+4

apps/api/lexicons/sandbox/createSandbox.json

reviewed

··· 78 78 "type": "ref", 79 79 "description": "A list of environment variables to add to the sandbox", 80 80 "ref": "io.pocketenv.sandbox.defs#envs" 81 81 + }, 82 82 + "keepAlive": { 83 83 + "type": "boolean", 84 84 + "description": "Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs." 81 85 } 82 86 } 83 87 }

+4

apps/api/lexicons/sandbox/startSandbox.json

reviewed

··· 25 25 "repo": { 26 26 "type": "string", 27 27 "description": "The git repository URL to clone into the sandbox before starting it. Optional." 28 28 + }, 29 29 + "keepAlive": { 30 30 + "type": "boolean", 31 31 + "description": "Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs." 28 32 } 29 33 } 30 34 }

+5

apps/api/pkl/defs/sandbox/createSandbox.pkl

reviewed

··· 75 75 ref = "io.pocketenv.sandbox.defs#envs" 76 76 description = "A list of environment variables to add to the sandbox" 77 77 } 78 78 + ["keepAlive"] = new BooleanType { 79 79 + type = "boolean" 80 80 + description = 81 81 + "Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs." 82 82 + } 78 83 } 79 84 } 80 85 }

+5

apps/api/pkl/defs/sandbox/startSandbox.pkl

reviewed

··· 26 26 description = 27 27 "The git repository URL to clone into the sandbox before starting it. Optional." 28 28 } 29 29 + ["keepAlive"] = new BooleanType { 30 30 + type = "boolean" 31 31 + description = 32 32 + "Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs." 33 33 + } 29 34 } 30 35 } 31 36 }

+216 -216

apps/api/src/lexicon/index.ts

reviewed

··· 7 7 type Options as XrpcOptions, 8 8 type AuthVerifier, 9 9 type StreamAuthVerifier, 10 10 - } from "@atproto/xrpc-server"; 11 11 - import { schemas } from "./lexicons"; 12 12 - import type * as IoPocketenvActorGetActorSandboxes from "./types/io/pocketenv/actor/getActorSandboxes"; 13 13 - import type * as IoPocketenvActorGetProfile from "./types/io/pocketenv/actor/getProfile"; 14 14 - import type * as IoPocketenvActorGetTerminalToken from "./types/io/pocketenv/actor/getTerminalToken"; 15 15 - import type * as IoPocketenvFileAddFile from "./types/io/pocketenv/file/addFile"; 16 16 - import type * as IoPocketenvFileDeleteFile from "./types/io/pocketenv/file/deleteFile"; 17 17 - import type * as IoPocketenvFileGetFile from "./types/io/pocketenv/file/getFile"; 18 18 - import type * as IoPocketenvFileGetFiles from "./types/io/pocketenv/file/getFiles"; 19 19 - import type * as IoPocketenvFileUpdateFile from "./types/io/pocketenv/file/updateFile"; 20 20 - import type * as IoPocketenvSandboxClaimSandbox from "./types/io/pocketenv/sandbox/claimSandbox"; 21 21 - import type * as IoPocketenvSandboxCreateIntegration from "./types/io/pocketenv/sandbox/createIntegration"; 22 22 - import type * as IoPocketenvSandboxCreateSandbox from "./types/io/pocketenv/sandbox/createSandbox"; 23 23 - import type * as IoPocketenvSandboxDeleteSandbox from "./types/io/pocketenv/sandbox/deleteSandbox"; 24 24 - import type * as IoPocketenvSandboxExec from "./types/io/pocketenv/sandbox/exec"; 25 25 - import type * as IoPocketenvSandboxExposePort from "./types/io/pocketenv/sandbox/exposePort"; 26 26 - import type * as IoPocketenvSandboxExposeVscode from "./types/io/pocketenv/sandbox/exposeVscode"; 27 27 - import type * as IoPocketenvSandboxGetExposedPorts from "./types/io/pocketenv/sandbox/getExposedPorts"; 28 28 - import type * as IoPocketenvSandboxGetIntegrations from "./types/io/pocketenv/sandbox/getIntegrations"; 29 29 - import type * as IoPocketenvSandboxGetPreferences from "./types/io/pocketenv/sandbox/getPreferences"; 30 30 - import type * as IoPocketenvSandboxGetSandbox from "./types/io/pocketenv/sandbox/getSandbox"; 31 31 - import type * as IoPocketenvSandboxGetSandboxes from "./types/io/pocketenv/sandbox/getSandboxes"; 32 32 - import type * as IoPocketenvSandboxGetSshKeys from "./types/io/pocketenv/sandbox/getSshKeys"; 33 33 - import type * as IoPocketenvSandboxGetTailscaleAuthKey from "./types/io/pocketenv/sandbox/getTailscaleAuthKey"; 34 34 - import type * as IoPocketenvSandboxGetTailscaleToken from "./types/io/pocketenv/sandbox/getTailscaleToken"; 35 35 - import type * as IoPocketenvSandboxPutPreferences from "./types/io/pocketenv/sandbox/putPreferences"; 36 36 - import type * as IoPocketenvSandboxPutSshKeys from "./types/io/pocketenv/sandbox/putSshKeys"; 37 37 - import type * as IoPocketenvSandboxPutTailscaleAuthKey from "./types/io/pocketenv/sandbox/putTailscaleAuthKey"; 38 38 - import type * as IoPocketenvSandboxPutTailscaleToken from "./types/io/pocketenv/sandbox/putTailscaleToken"; 39 39 - import type * as IoPocketenvSandboxStartSandbox from "./types/io/pocketenv/sandbox/startSandbox"; 40 40 - import type * as IoPocketenvSandboxStopSandbox from "./types/io/pocketenv/sandbox/stopSandbox"; 41 41 - import type * as IoPocketenvSandboxUnexposePort from "./types/io/pocketenv/sandbox/unexposePort"; 42 42 - import type * as IoPocketenvSandboxUpdateSandboxSettings from "./types/io/pocketenv/sandbox/updateSandboxSettings"; 43 43 - import type * as IoPocketenvSecretAddSecret from "./types/io/pocketenv/secret/addSecret"; 44 44 - import type * as IoPocketenvSecretDeleteSecret from "./types/io/pocketenv/secret/deleteSecret"; 45 45 - import type * as IoPocketenvSecretGetSecret from "./types/io/pocketenv/secret/getSecret"; 46 46 - import type * as IoPocketenvSecretGetSecrets from "./types/io/pocketenv/secret/getSecrets"; 47 47 - import type * as IoPocketenvSecretUpdateSecret from "./types/io/pocketenv/secret/updateSecret"; 48 48 - import type * as IoPocketenvVariableAddVariable from "./types/io/pocketenv/variable/addVariable"; 49 49 - import type * as IoPocketenvVariableDeleteVariable from "./types/io/pocketenv/variable/deleteVariable"; 50 50 - import type * as IoPocketenvVariableGetVariable from "./types/io/pocketenv/variable/getVariable"; 51 51 - import type * as IoPocketenvVariableGetVariables from "./types/io/pocketenv/variable/getVariables"; 52 52 - import type * as IoPocketenvVariableUpdateVariable from "./types/io/pocketenv/variable/updateVariable"; 53 53 - import type * as IoPocketenvVolumeAddVolume from "./types/io/pocketenv/volume/addVolume"; 54 54 - import type * as IoPocketenvVolumeDeleteVolume from "./types/io/pocketenv/volume/deleteVolume"; 55 55 - import type * as IoPocketenvVolumeGetVolume from "./types/io/pocketenv/volume/getVolume"; 56 56 - import type * as IoPocketenvVolumeGetVolumes from "./types/io/pocketenv/volume/getVolumes"; 57 57 - import type * as IoPocketenvVolumeUpdateVolume from "./types/io/pocketenv/volume/updateVolume"; 10 10 + } from '@atproto/xrpc-server' 11 11 + import { schemas } from './lexicons' 12 12 + import type * as IoPocketenvActorGetActorSandboxes from './types/io/pocketenv/actor/getActorSandboxes' 13 13 + import type * as IoPocketenvActorGetProfile from './types/io/pocketenv/actor/getProfile' 14 14 + import type * as IoPocketenvActorGetTerminalToken from './types/io/pocketenv/actor/getTerminalToken' 15 15 + import type * as IoPocketenvFileAddFile from './types/io/pocketenv/file/addFile' 16 16 + import type * as IoPocketenvFileDeleteFile from './types/io/pocketenv/file/deleteFile' 17 17 + import type * as IoPocketenvFileGetFile from './types/io/pocketenv/file/getFile' 18 18 + import type * as IoPocketenvFileGetFiles from './types/io/pocketenv/file/getFiles' 19 19 + import type * as IoPocketenvFileUpdateFile from './types/io/pocketenv/file/updateFile' 20 20 + import type * as IoPocketenvSandboxClaimSandbox from './types/io/pocketenv/sandbox/claimSandbox' 21 21 + import type * as IoPocketenvSandboxCreateIntegration from './types/io/pocketenv/sandbox/createIntegration' 22 22 + import type * as IoPocketenvSandboxCreateSandbox from './types/io/pocketenv/sandbox/createSandbox' 23 23 + import type * as IoPocketenvSandboxDeleteSandbox from './types/io/pocketenv/sandbox/deleteSandbox' 24 24 + import type * as IoPocketenvSandboxExec from './types/io/pocketenv/sandbox/exec' 25 25 + import type * as IoPocketenvSandboxExposePort from './types/io/pocketenv/sandbox/exposePort' 26 26 + import type * as IoPocketenvSandboxExposeVscode from './types/io/pocketenv/sandbox/exposeVscode' 27 27 + import type * as IoPocketenvSandboxGetExposedPorts from './types/io/pocketenv/sandbox/getExposedPorts' 28 28 + import type * as IoPocketenvSandboxGetIntegrations from './types/io/pocketenv/sandbox/getIntegrations' 29 29 + import type * as IoPocketenvSandboxGetPreferences from './types/io/pocketenv/sandbox/getPreferences' 30 30 + import type * as IoPocketenvSandboxGetSandbox from './types/io/pocketenv/sandbox/getSandbox' 31 31 + import type * as IoPocketenvSandboxGetSandboxes from './types/io/pocketenv/sandbox/getSandboxes' 32 32 + import type * as IoPocketenvSandboxGetSshKeys from './types/io/pocketenv/sandbox/getSshKeys' 33 33 + import type * as IoPocketenvSandboxGetTailscaleAuthKey from './types/io/pocketenv/sandbox/getTailscaleAuthKey' 34 34 + import type * as IoPocketenvSandboxGetTailscaleToken from './types/io/pocketenv/sandbox/getTailscaleToken' 35 35 + import type * as IoPocketenvSandboxPutPreferences from './types/io/pocketenv/sandbox/putPreferences' 36 36 + import type * as IoPocketenvSandboxPutSshKeys from './types/io/pocketenv/sandbox/putSshKeys' 37 37 + import type * as IoPocketenvSandboxPutTailscaleAuthKey from './types/io/pocketenv/sandbox/putTailscaleAuthKey' 38 38 + import type * as IoPocketenvSandboxPutTailscaleToken from './types/io/pocketenv/sandbox/putTailscaleToken' 39 39 + import type * as IoPocketenvSandboxStartSandbox from './types/io/pocketenv/sandbox/startSandbox' 40 40 + import type * as IoPocketenvSandboxStopSandbox from './types/io/pocketenv/sandbox/stopSandbox' 41 41 + import type * as IoPocketenvSandboxUnexposePort from './types/io/pocketenv/sandbox/unexposePort' 42 42 + import type * as IoPocketenvSandboxUpdateSandboxSettings from './types/io/pocketenv/sandbox/updateSandboxSettings' 43 43 + import type * as IoPocketenvSecretAddSecret from './types/io/pocketenv/secret/addSecret' 44 44 + import type * as IoPocketenvSecretDeleteSecret from './types/io/pocketenv/secret/deleteSecret' 45 45 + import type * as IoPocketenvSecretGetSecret from './types/io/pocketenv/secret/getSecret' 46 46 + import type * as IoPocketenvSecretGetSecrets from './types/io/pocketenv/secret/getSecrets' 47 47 + import type * as IoPocketenvSecretUpdateSecret from './types/io/pocketenv/secret/updateSecret' 48 48 + import type * as IoPocketenvVariableAddVariable from './types/io/pocketenv/variable/addVariable' 49 49 + import type * as IoPocketenvVariableDeleteVariable from './types/io/pocketenv/variable/deleteVariable' 50 50 + import type * as IoPocketenvVariableGetVariable from './types/io/pocketenv/variable/getVariable' 51 51 + import type * as IoPocketenvVariableGetVariables from './types/io/pocketenv/variable/getVariables' 52 52 + import type * as IoPocketenvVariableUpdateVariable from './types/io/pocketenv/variable/updateVariable' 53 53 + import type * as IoPocketenvVolumeAddVolume from './types/io/pocketenv/volume/addVolume' 54 54 + import type * as IoPocketenvVolumeDeleteVolume from './types/io/pocketenv/volume/deleteVolume' 55 55 + import type * as IoPocketenvVolumeGetVolume from './types/io/pocketenv/volume/getVolume' 56 56 + import type * as IoPocketenvVolumeGetVolumes from './types/io/pocketenv/volume/getVolumes' 57 57 + import type * as IoPocketenvVolumeUpdateVolume from './types/io/pocketenv/volume/updateVolume' 58 58 59 59 export function createServer(options?: XrpcOptions): Server { 60 60 - return new Server(options); 60 60 + return new Server(options) 61 61 } 62 62 63 63 export class Server { 64 64 - xrpc: XrpcServer; 65 65 - io: IoNS; 66 66 - app: AppNS; 67 67 - com: ComNS; 64 64 + xrpc: XrpcServer 65 65 + io: IoNS 66 66 + app: AppNS 67 67 + com: ComNS 68 68 69 69 constructor(options?: XrpcOptions) { 70 70 - this.xrpc = createXrpcServer(schemas, options); 71 71 - this.io = new IoNS(this); 72 72 - this.app = new AppNS(this); 73 73 - this.com = new ComNS(this); 70 70 + this.xrpc = createXrpcServer(schemas, options) 71 71 + this.io = new IoNS(this) 72 72 + this.app = new AppNS(this) 73 73 + this.com = new ComNS(this) 74 74 } 75 75 } 76 76 77 77 export class IoNS { 78 78 - _server: Server; 79 79 - pocketenv: IoPocketenvNS; 78 78 + _server: Server 79 79 + pocketenv: IoPocketenvNS 80 80 81 81 constructor(server: Server) { 82 82 - this._server = server; 83 83 - this.pocketenv = new IoPocketenvNS(server); 82 82 + this._server = server 83 83 + this.pocketenv = new IoPocketenvNS(server) 84 84 } 85 85 } 86 86 87 87 export class IoPocketenvNS { 88 88 - _server: Server; 89 89 - actor: IoPocketenvActorNS; 90 90 - file: IoPocketenvFileNS; 91 91 - sandbox: IoPocketenvSandboxNS; 92 92 - secret: IoPocketenvSecretNS; 93 93 - variable: IoPocketenvVariableNS; 94 94 - volume: IoPocketenvVolumeNS; 88 88 + _server: Server 89 89 + actor: IoPocketenvActorNS 90 90 + file: IoPocketenvFileNS 91 91 + sandbox: IoPocketenvSandboxNS 92 92 + secret: IoPocketenvSecretNS 93 93 + variable: IoPocketenvVariableNS 94 94 + volume: IoPocketenvVolumeNS 95 95 96 96 constructor(server: Server) { 97 97 - this._server = server; 98 98 - this.actor = new IoPocketenvActorNS(server); 99 99 - this.file = new IoPocketenvFileNS(server); 100 100 - this.sandbox = new IoPocketenvSandboxNS(server); 101 101 - this.secret = new IoPocketenvSecretNS(server); 102 102 - this.variable = new IoPocketenvVariableNS(server); 103 103 - this.volume = new IoPocketenvVolumeNS(server); 97 97 + this._server = server 98 98 + this.actor = new IoPocketenvActorNS(server) 99 99 + this.file = new IoPocketenvFileNS(server) 100 100 + this.sandbox = new IoPocketenvSandboxNS(server) 101 101 + this.secret = new IoPocketenvSecretNS(server) 102 102 + this.variable = new IoPocketenvVariableNS(server) 103 103 + this.volume = new IoPocketenvVolumeNS(server) 104 104 } 105 105 } 106 106 107 107 export class IoPocketenvActorNS { 108 108 - _server: Server; 108 108 + _server: Server 109 109 110 110 constructor(server: Server) { 111 111 - this._server = server; 111 111 + this._server = server 112 112 } 113 113 114 114 getActorSandboxes<AV extends AuthVerifier>( ··· 118 118 IoPocketenvActorGetActorSandboxes.HandlerReqCtx<ExtractAuth<AV>> 119 119 >, 120 120 ) { 121 121 - const nsid = "io.pocketenv.actor.getActorSandboxes"; // @ts-ignore 122 122 - return this._server.xrpc.method(nsid, cfg); 121 121 + const nsid = 'io.pocketenv.actor.getActorSandboxes' // @ts-ignore 122 122 + return this._server.xrpc.method(nsid, cfg) 123 123 } 124 124 125 125 getProfile<AV extends AuthVerifier>( ··· 129 129 IoPocketenvActorGetProfile.HandlerReqCtx<ExtractAuth<AV>> 130 130 >, 131 131 ) { 132 132 - const nsid = "io.pocketenv.actor.getProfile"; // @ts-ignore 133 133 - return this._server.xrpc.method(nsid, cfg); 132 132 + const nsid = 'io.pocketenv.actor.getProfile' // @ts-ignore 133 133 + return this._server.xrpc.method(nsid, cfg) 134 134 } 135 135 136 136 getTerminalToken<AV extends AuthVerifier>( ··· 140 140 IoPocketenvActorGetTerminalToken.HandlerReqCtx<ExtractAuth<AV>> 141 141 >, 142 142 ) { 143 143 - const nsid = "io.pocketenv.actor.getTerminalToken"; // @ts-ignore 144 144 - return this._server.xrpc.method(nsid, cfg); 143 143 + const nsid = 'io.pocketenv.actor.getTerminalToken' // @ts-ignore 144 144 + return this._server.xrpc.method(nsid, cfg) 145 145 } 146 146 } 147 147 148 148 export class IoPocketenvFileNS { 149 149 - _server: Server; 149 149 + _server: Server 150 150 151 151 constructor(server: Server) { 152 152 - this._server = server; 152 152 + this._server = server 153 153 } 154 154 155 155 addFile<AV extends AuthVerifier>( ··· 159 159 IoPocketenvFileAddFile.HandlerReqCtx<ExtractAuth<AV>> 160 160 >, 161 161 ) { 162 162 - const nsid = "io.pocketenv.file.addFile"; // @ts-ignore 163 163 - return this._server.xrpc.method(nsid, cfg); 162 162 + const nsid = 'io.pocketenv.file.addFile' // @ts-ignore 163 163 + return this._server.xrpc.method(nsid, cfg) 164 164 } 165 165 166 166 deleteFile<AV extends AuthVerifier>( ··· 170 170 IoPocketenvFileDeleteFile.HandlerReqCtx<ExtractAuth<AV>> 171 171 >, 172 172 ) { 173 173 - const nsid = "io.pocketenv.file.deleteFile"; // @ts-ignore 174 174 - return this._server.xrpc.method(nsid, cfg); 173 173 + const nsid = 'io.pocketenv.file.deleteFile' // @ts-ignore 174 174 + return this._server.xrpc.method(nsid, cfg) 175 175 } 176 176 177 177 getFile<AV extends AuthVerifier>( ··· 181 181 IoPocketenvFileGetFile.HandlerReqCtx<ExtractAuth<AV>> 182 182 >, 183 183 ) { 184 184 - const nsid = "io.pocketenv.file.getFile"; // @ts-ignore 185 185 - return this._server.xrpc.method(nsid, cfg); 184 184 + const nsid = 'io.pocketenv.file.getFile' // @ts-ignore 185 185 + return this._server.xrpc.method(nsid, cfg) 186 186 } 187 187 188 188 getFiles<AV extends AuthVerifier>( ··· 192 192 IoPocketenvFileGetFiles.HandlerReqCtx<ExtractAuth<AV>> 193 193 >, 194 194 ) { 195 195 - const nsid = "io.pocketenv.file.getFiles"; // @ts-ignore 196 196 - return this._server.xrpc.method(nsid, cfg); 195 195 + const nsid = 'io.pocketenv.file.getFiles' // @ts-ignore 196 196 + return this._server.xrpc.method(nsid, cfg) 197 197 } 198 198 199 199 updateFile<AV extends AuthVerifier>( ··· 203 203 IoPocketenvFileUpdateFile.HandlerReqCtx<ExtractAuth<AV>> 204 204 >, 205 205 ) { 206 206 - const nsid = "io.pocketenv.file.updateFile"; // @ts-ignore 207 207 - return this._server.xrpc.method(nsid, cfg); 206 206 + const nsid = 'io.pocketenv.file.updateFile' // @ts-ignore 207 207 + return this._server.xrpc.method(nsid, cfg) 208 208 } 209 209 } 210 210 211 211 export class IoPocketenvSandboxNS { 212 212 - _server: Server; 212 212 + _server: Server 213 213 214 214 constructor(server: Server) { 215 215 - this._server = server; 215 215 + this._server = server 216 216 } 217 217 218 218 claimSandbox<AV extends AuthVerifier>( ··· 222 222 IoPocketenvSandboxClaimSandbox.HandlerReqCtx<ExtractAuth<AV>> 223 223 >, 224 224 ) { 225 225 - const nsid = "io.pocketenv.sandbox.claimSandbox"; // @ts-ignore 226 226 - return this._server.xrpc.method(nsid, cfg); 225 225 + const nsid = 'io.pocketenv.sandbox.claimSandbox' // @ts-ignore 226 226 + return this._server.xrpc.method(nsid, cfg) 227 227 } 228 228 229 229 createIntegration<AV extends AuthVerifier>( ··· 233 233 IoPocketenvSandboxCreateIntegration.HandlerReqCtx<ExtractAuth<AV>> 234 234 >, 235 235 ) { 236 236 - const nsid = "io.pocketenv.sandbox.createIntegration"; // @ts-ignore 237 237 - return this._server.xrpc.method(nsid, cfg); 236 236 + const nsid = 'io.pocketenv.sandbox.createIntegration' // @ts-ignore 237 237 + return this._server.xrpc.method(nsid, cfg) 238 238 } 239 239 240 240 createSandbox<AV extends AuthVerifier>( ··· 244 244 IoPocketenvSandboxCreateSandbox.HandlerReqCtx<ExtractAuth<AV>> 245 245 >, 246 246 ) { 247 247 - const nsid = "io.pocketenv.sandbox.createSandbox"; // @ts-ignore 248 248 - return this._server.xrpc.method(nsid, cfg); 247 247 + const nsid = 'io.pocketenv.sandbox.createSandbox' // @ts-ignore 248 248 + return this._server.xrpc.method(nsid, cfg) 249 249 } 250 250 251 251 deleteSandbox<AV extends AuthVerifier>( ··· 255 255 IoPocketenvSandboxDeleteSandbox.HandlerReqCtx<ExtractAuth<AV>> 256 256 >, 257 257 ) { 258 258 - const nsid = "io.pocketenv.sandbox.deleteSandbox"; // @ts-ignore 259 259 - return this._server.xrpc.method(nsid, cfg); 258 258 + const nsid = 'io.pocketenv.sandbox.deleteSandbox' // @ts-ignore 259 259 + return this._server.xrpc.method(nsid, cfg) 260 260 } 261 261 262 262 exec<AV extends AuthVerifier>( ··· 266 266 IoPocketenvSandboxExec.HandlerReqCtx<ExtractAuth<AV>> 267 267 >, 268 268 ) { 269 269 - const nsid = "io.pocketenv.sandbox.exec"; // @ts-ignore 270 270 - return this._server.xrpc.method(nsid, cfg); 269 269 + const nsid = 'io.pocketenv.sandbox.exec' // @ts-ignore 270 270 + return this._server.xrpc.method(nsid, cfg) 271 271 } 272 272 273 273 exposePort<AV extends AuthVerifier>( ··· 277 277 IoPocketenvSandboxExposePort.HandlerReqCtx<ExtractAuth<AV>> 278 278 >, 279 279 ) { 280 280 - const nsid = "io.pocketenv.sandbox.exposePort"; // @ts-ignore 281 281 - return this._server.xrpc.method(nsid, cfg); 280 280 + const nsid = 'io.pocketenv.sandbox.exposePort' // @ts-ignore 281 281 + return this._server.xrpc.method(nsid, cfg) 282 282 } 283 283 284 284 exposeVscode<AV extends AuthVerifier>( ··· 288 288 IoPocketenvSandboxExposeVscode.HandlerReqCtx<ExtractAuth<AV>> 289 289 >, 290 290 ) { 291 291 - const nsid = "io.pocketenv.sandbox.exposeVscode"; // @ts-ignore 292 292 - return this._server.xrpc.method(nsid, cfg); 291 291 + const nsid = 'io.pocketenv.sandbox.exposeVscode' // @ts-ignore 292 292 + return this._server.xrpc.method(nsid, cfg) 293 293 } 294 294 295 295 getExposedPorts<AV extends AuthVerifier>( ··· 299 299 IoPocketenvSandboxGetExposedPorts.HandlerReqCtx<ExtractAuth<AV>> 300 300 >, 301 301 ) { 302 302 - const nsid = "io.pocketenv.sandbox.getExposedPorts"; // @ts-ignore 303 303 - return this._server.xrpc.method(nsid, cfg); 302 302 + const nsid = 'io.pocketenv.sandbox.getExposedPorts' // @ts-ignore 303 303 + return this._server.xrpc.method(nsid, cfg) 304 304 } 305 305 306 306 getIntegrations<AV extends AuthVerifier>( ··· 310 310 IoPocketenvSandboxGetIntegrations.HandlerReqCtx<ExtractAuth<AV>> 311 311 >, 312 312 ) { 313 313 - const nsid = "io.pocketenv.sandbox.getIntegrations"; // @ts-ignore 314 314 - return this._server.xrpc.method(nsid, cfg); 313 313 + const nsid = 'io.pocketenv.sandbox.getIntegrations' // @ts-ignore 314 314 + return this._server.xrpc.method(nsid, cfg) 315 315 } 316 316 317 317 getPreferences<AV extends AuthVerifier>( ··· 321 321 IoPocketenvSandboxGetPreferences.HandlerReqCtx<ExtractAuth<AV>> 322 322 >, 323 323 ) { 324 324 - const nsid = "io.pocketenv.sandbox.getPreferences"; // @ts-ignore 325 325 - return this._server.xrpc.method(nsid, cfg); 324 324 + const nsid = 'io.pocketenv.sandbox.getPreferences' // @ts-ignore 325 325 + return this._server.xrpc.method(nsid, cfg) 326 326 } 327 327 328 328 getSandbox<AV extends AuthVerifier>( ··· 332 332 IoPocketenvSandboxGetSandbox.HandlerReqCtx<ExtractAuth<AV>> 333 333 >, 334 334 ) { 335 335 - const nsid = "io.pocketenv.sandbox.getSandbox"; // @ts-ignore 336 336 - return this._server.xrpc.method(nsid, cfg); 335 335 + const nsid = 'io.pocketenv.sandbox.getSandbox' // @ts-ignore 336 336 + return this._server.xrpc.method(nsid, cfg) 337 337 } 338 338 339 339 getSandboxes<AV extends AuthVerifier>( ··· 343 343 IoPocketenvSandboxGetSandboxes.HandlerReqCtx<ExtractAuth<AV>> 344 344 >, 345 345 ) { 346 346 - const nsid = "io.pocketenv.sandbox.getSandboxes"; // @ts-ignore 347 347 - return this._server.xrpc.method(nsid, cfg); 346 346 + const nsid = 'io.pocketenv.sandbox.getSandboxes' // @ts-ignore 347 347 + return this._server.xrpc.method(nsid, cfg) 348 348 } 349 349 350 350 getSshKeys<AV extends AuthVerifier>( ··· 354 354 IoPocketenvSandboxGetSshKeys.HandlerReqCtx<ExtractAuth<AV>> 355 355 >, 356 356 ) { 357 357 - const nsid = "io.pocketenv.sandbox.getSshKeys"; // @ts-ignore 358 358 - return this._server.xrpc.method(nsid, cfg); 357 357 + const nsid = 'io.pocketenv.sandbox.getSshKeys' // @ts-ignore 358 358 + return this._server.xrpc.method(nsid, cfg) 359 359 } 360 360 361 361 getTailscaleAuthKey<AV extends AuthVerifier>( ··· 365 365 IoPocketenvSandboxGetTailscaleAuthKey.HandlerReqCtx<ExtractAuth<AV>> 366 366 >, 367 367 ) { 368 368 - const nsid = "io.pocketenv.sandbox.getTailscaleAuthKey"; // @ts-ignore 369 369 - return this._server.xrpc.method(nsid, cfg); 368 368 + const nsid = 'io.pocketenv.sandbox.getTailscaleAuthKey' // @ts-ignore 369 369 + return this._server.xrpc.method(nsid, cfg) 370 370 } 371 371 372 372 getTailscaleToken<AV extends AuthVerifier>( ··· 376 376 IoPocketenvSandboxGetTailscaleToken.HandlerReqCtx<ExtractAuth<AV>> 377 377 >, 378 378 ) { 379 379 - const nsid = "io.pocketenv.sandbox.getTailscaleToken"; // @ts-ignore 380 380 - return this._server.xrpc.method(nsid, cfg); 379 379 + const nsid = 'io.pocketenv.sandbox.getTailscaleToken' // @ts-ignore 380 380 + return this._server.xrpc.method(nsid, cfg) 381 381 } 382 382 383 383 putPreferences<AV extends AuthVerifier>( ··· 387 387 IoPocketenvSandboxPutPreferences.HandlerReqCtx<ExtractAuth<AV>> 388 388 >, 389 389 ) { 390 390 - const nsid = "io.pocketenv.sandbox.putPreferences"; // @ts-ignore 391 391 - return this._server.xrpc.method(nsid, cfg); 390 390 + const nsid = 'io.pocketenv.sandbox.putPreferences' // @ts-ignore 391 391 + return this._server.xrpc.method(nsid, cfg) 392 392 } 393 393 394 394 putSshKeys<AV extends AuthVerifier>( ··· 398 398 IoPocketenvSandboxPutSshKeys.HandlerReqCtx<ExtractAuth<AV>> 399 399 >, 400 400 ) { 401 401 - const nsid = "io.pocketenv.sandbox.putSshKeys"; // @ts-ignore 402 402 - return this._server.xrpc.method(nsid, cfg); 401 401 + const nsid = 'io.pocketenv.sandbox.putSshKeys' // @ts-ignore 402 402 + return this._server.xrpc.method(nsid, cfg) 403 403 } 404 404 405 405 putTailscaleAuthKey<AV extends AuthVerifier>( ··· 409 409 IoPocketenvSandboxPutTailscaleAuthKey.HandlerReqCtx<ExtractAuth<AV>> 410 410 >, 411 411 ) { 412 412 - const nsid = "io.pocketenv.sandbox.putTailscaleAuthKey"; // @ts-ignore 413 413 - return this._server.xrpc.method(nsid, cfg); 412 412 + const nsid = 'io.pocketenv.sandbox.putTailscaleAuthKey' // @ts-ignore 413 413 + return this._server.xrpc.method(nsid, cfg) 414 414 } 415 415 416 416 putTailscaleToken<AV extends AuthVerifier>( ··· 420 420 IoPocketenvSandboxPutTailscaleToken.HandlerReqCtx<ExtractAuth<AV>> 421 421 >, 422 422 ) { 423 423 - const nsid = "io.pocketenv.sandbox.putTailscaleToken"; // @ts-ignore 424 424 - return this._server.xrpc.method(nsid, cfg); 423 423 + const nsid = 'io.pocketenv.sandbox.putTailscaleToken' // @ts-ignore 424 424 + return this._server.xrpc.method(nsid, cfg) 425 425 } 426 426 427 427 startSandbox<AV extends AuthVerifier>( ··· 431 431 IoPocketenvSandboxStartSandbox.HandlerReqCtx<ExtractAuth<AV>> 432 432 >, 433 433 ) { 434 434 - const nsid = "io.pocketenv.sandbox.startSandbox"; // @ts-ignore 435 435 - return this._server.xrpc.method(nsid, cfg); 434 434 + const nsid = 'io.pocketenv.sandbox.startSandbox' // @ts-ignore 435 435 + return this._server.xrpc.method(nsid, cfg) 436 436 } 437 437 438 438 stopSandbox<AV extends AuthVerifier>( ··· 442 442 IoPocketenvSandboxStopSandbox.HandlerReqCtx<ExtractAuth<AV>> 443 443 >, 444 444 ) { 445 445 - const nsid = "io.pocketenv.sandbox.stopSandbox"; // @ts-ignore 446 446 - return this._server.xrpc.method(nsid, cfg); 445 445 + const nsid = 'io.pocketenv.sandbox.stopSandbox' // @ts-ignore 446 446 + return this._server.xrpc.method(nsid, cfg) 447 447 } 448 448 449 449 unexposePort<AV extends AuthVerifier>( ··· 453 453 IoPocketenvSandboxUnexposePort.HandlerReqCtx<ExtractAuth<AV>> 454 454 >, 455 455 ) { 456 456 - const nsid = "io.pocketenv.sandbox.unexposePort"; // @ts-ignore 457 457 - return this._server.xrpc.method(nsid, cfg); 456 456 + const nsid = 'io.pocketenv.sandbox.unexposePort' // @ts-ignore 457 457 + return this._server.xrpc.method(nsid, cfg) 458 458 } 459 459 460 460 updateSandboxSettings<AV extends AuthVerifier>( ··· 464 464 IoPocketenvSandboxUpdateSandboxSettings.HandlerReqCtx<ExtractAuth<AV>> 465 465 >, 466 466 ) { 467 467 - const nsid = "io.pocketenv.sandbox.updateSandboxSettings"; // @ts-ignore 468 468 - return this._server.xrpc.method(nsid, cfg); 467 467 + const nsid = 'io.pocketenv.sandbox.updateSandboxSettings' // @ts-ignore 468 468 + return this._server.xrpc.method(nsid, cfg) 469 469 } 470 470 } 471 471 472 472 export class IoPocketenvSecretNS { 473 473 - _server: Server; 473 473 + _server: Server 474 474 475 475 constructor(server: Server) { 476 476 - this._server = server; 476 476 + this._server = server 477 477 } 478 478 479 479 addSecret<AV extends AuthVerifier>( ··· 483 483 IoPocketenvSecretAddSecret.HandlerReqCtx<ExtractAuth<AV>> 484 484 >, 485 485 ) { 486 486 - const nsid = "io.pocketenv.secret.addSecret"; // @ts-ignore 487 487 - return this._server.xrpc.method(nsid, cfg); 486 486 + const nsid = 'io.pocketenv.secret.addSecret' // @ts-ignore 487 487 + return this._server.xrpc.method(nsid, cfg) 488 488 } 489 489 490 490 deleteSecret<AV extends AuthVerifier>( ··· 494 494 IoPocketenvSecretDeleteSecret.HandlerReqCtx<ExtractAuth<AV>> 495 495 >, 496 496 ) { 497 497 - const nsid = "io.pocketenv.secret.deleteSecret"; // @ts-ignore 498 498 - return this._server.xrpc.method(nsid, cfg); 497 497 + const nsid = 'io.pocketenv.secret.deleteSecret' // @ts-ignore 498 498 + return this._server.xrpc.method(nsid, cfg) 499 499 } 500 500 501 501 getSecret<AV extends AuthVerifier>( ··· 505 505 IoPocketenvSecretGetSecret.HandlerReqCtx<ExtractAuth<AV>> 506 506 >, 507 507 ) { 508 508 - const nsid = "io.pocketenv.secret.getSecret"; // @ts-ignore 509 509 - return this._server.xrpc.method(nsid, cfg); 508 508 + const nsid = 'io.pocketenv.secret.getSecret' // @ts-ignore 509 509 + return this._server.xrpc.method(nsid, cfg) 510 510 } 511 511 512 512 getSecrets<AV extends AuthVerifier>( ··· 516 516 IoPocketenvSecretGetSecrets.HandlerReqCtx<ExtractAuth<AV>> 517 517 >, 518 518 ) { 519 519 - const nsid = "io.pocketenv.secret.getSecrets"; // @ts-ignore 520 520 - return this._server.xrpc.method(nsid, cfg); 519 519 + const nsid = 'io.pocketenv.secret.getSecrets' // @ts-ignore 520 520 + return this._server.xrpc.method(nsid, cfg) 521 521 } 522 522 523 523 updateSecret<AV extends AuthVerifier>( ··· 527 527 IoPocketenvSecretUpdateSecret.HandlerReqCtx<ExtractAuth<AV>> 528 528 >, 529 529 ) { 530 530 - const nsid = "io.pocketenv.secret.updateSecret"; // @ts-ignore 531 531 - return this._server.xrpc.method(nsid, cfg); 530 530 + const nsid = 'io.pocketenv.secret.updateSecret' // @ts-ignore 531 531 + return this._server.xrpc.method(nsid, cfg) 532 532 } 533 533 } 534 534 535 535 export class IoPocketenvVariableNS { 536 536 - _server: Server; 536 536 + _server: Server 537 537 538 538 constructor(server: Server) { 539 539 - this._server = server; 539 539 + this._server = server 540 540 } 541 541 542 542 addVariable<AV extends AuthVerifier>( ··· 546 546 IoPocketenvVariableAddVariable.HandlerReqCtx<ExtractAuth<AV>> 547 547 >, 548 548 ) { 549 549 - const nsid = "io.pocketenv.variable.addVariable"; // @ts-ignore 550 550 - return this._server.xrpc.method(nsid, cfg); 549 549 + const nsid = 'io.pocketenv.variable.addVariable' // @ts-ignore 550 550 + return this._server.xrpc.method(nsid, cfg) 551 551 } 552 552 553 553 deleteVariable<AV extends AuthVerifier>( ··· 557 557 IoPocketenvVariableDeleteVariable.HandlerReqCtx<ExtractAuth<AV>> 558 558 >, 559 559 ) { 560 560 - const nsid = "io.pocketenv.variable.deleteVariable"; // @ts-ignore 561 561 - return this._server.xrpc.method(nsid, cfg); 560 560 + const nsid = 'io.pocketenv.variable.deleteVariable' // @ts-ignore 561 561 + return this._server.xrpc.method(nsid, cfg) 562 562 } 563 563 564 564 getVariable<AV extends AuthVerifier>( ··· 568 568 IoPocketenvVariableGetVariable.HandlerReqCtx<ExtractAuth<AV>> 569 569 >, 570 570 ) { 571 571 - const nsid = "io.pocketenv.variable.getVariable"; // @ts-ignore 572 572 - return this._server.xrpc.method(nsid, cfg); 571 571 + const nsid = 'io.pocketenv.variable.getVariable' // @ts-ignore 572 572 + return this._server.xrpc.method(nsid, cfg) 573 573 } 574 574 575 575 getVariables<AV extends AuthVerifier>( ··· 579 579 IoPocketenvVariableGetVariables.HandlerReqCtx<ExtractAuth<AV>> 580 580 >, 581 581 ) { 582 582 - const nsid = "io.pocketenv.variable.getVariables"; // @ts-ignore 583 583 - return this._server.xrpc.method(nsid, cfg); 582 582 + const nsid = 'io.pocketenv.variable.getVariables' // @ts-ignore 583 583 + return this._server.xrpc.method(nsid, cfg) 584 584 } 585 585 586 586 updateVariable<AV extends AuthVerifier>( ··· 590 590 IoPocketenvVariableUpdateVariable.HandlerReqCtx<ExtractAuth<AV>> 591 591 >, 592 592 ) { 593 593 - const nsid = "io.pocketenv.variable.updateVariable"; // @ts-ignore 594 594 - return this._server.xrpc.method(nsid, cfg); 593 593 + const nsid = 'io.pocketenv.variable.updateVariable' // @ts-ignore 594 594 + return this._server.xrpc.method(nsid, cfg) 595 595 } 596 596 } 597 597 598 598 export class IoPocketenvVolumeNS { 599 599 - _server: Server; 599 599 + _server: Server 600 600 601 601 constructor(server: Server) { 602 602 - this._server = server; 602 602 + this._server = server 603 603 } 604 604 605 605 addVolume<AV extends AuthVerifier>( ··· 609 609 IoPocketenvVolumeAddVolume.HandlerReqCtx<ExtractAuth<AV>> 610 610 >, 611 611 ) { 612 612 - const nsid = "io.pocketenv.volume.addVolume"; // @ts-ignore 613 613 - return this._server.xrpc.method(nsid, cfg); 612 612 + const nsid = 'io.pocketenv.volume.addVolume' // @ts-ignore 613 613 + return this._server.xrpc.method(nsid, cfg) 614 614 } 615 615 616 616 deleteVolume<AV extends AuthVerifier>( ··· 620 620 IoPocketenvVolumeDeleteVolume.HandlerReqCtx<ExtractAuth<AV>> 621 621 >, 622 622 ) { 623 623 - const nsid = "io.pocketenv.volume.deleteVolume"; // @ts-ignore 624 624 - return this._server.xrpc.method(nsid, cfg); 623 623 + const nsid = 'io.pocketenv.volume.deleteVolume' // @ts-ignore 624 624 + return this._server.xrpc.method(nsid, cfg) 625 625 } 626 626 627 627 getVolume<AV extends AuthVerifier>( ··· 631 631 IoPocketenvVolumeGetVolume.HandlerReqCtx<ExtractAuth<AV>> 632 632 >, 633 633 ) { 634 634 - const nsid = "io.pocketenv.volume.getVolume"; // @ts-ignore 635 635 - return this._server.xrpc.method(nsid, cfg); 634 634 + const nsid = 'io.pocketenv.volume.getVolume' // @ts-ignore 635 635 + return this._server.xrpc.method(nsid, cfg) 636 636 } 637 637 638 638 getVolumes<AV extends AuthVerifier>( ··· 642 642 IoPocketenvVolumeGetVolumes.HandlerReqCtx<ExtractAuth<AV>> 643 643 >, 644 644 ) { 645 645 - const nsid = "io.pocketenv.volume.getVolumes"; // @ts-ignore 646 646 - return this._server.xrpc.method(nsid, cfg); 645 645 + const nsid = 'io.pocketenv.volume.getVolumes' // @ts-ignore 646 646 + return this._server.xrpc.method(nsid, cfg) 647 647 } 648 648 649 649 updateVolume<AV extends AuthVerifier>( ··· 653 653 IoPocketenvVolumeUpdateVolume.HandlerReqCtx<ExtractAuth<AV>> 654 654 >, 655 655 ) { 656 656 - const nsid = "io.pocketenv.volume.updateVolume"; // @ts-ignore 657 657 - return this._server.xrpc.method(nsid, cfg); 656 656 + const nsid = 'io.pocketenv.volume.updateVolume' // @ts-ignore 657 657 + return this._server.xrpc.method(nsid, cfg) 658 658 } 659 659 } 660 660 661 661 export class AppNS { 662 662 - _server: Server; 663 663 - bsky: AppBskyNS; 662 662 + _server: Server 663 663 + bsky: AppBskyNS 664 664 665 665 constructor(server: Server) { 666 666 - this._server = server; 667 667 - this.bsky = new AppBskyNS(server); 666 666 + this._server = server 667 667 + this.bsky = new AppBskyNS(server) 668 668 } 669 669 } 670 670 671 671 export class AppBskyNS { 672 672 - _server: Server; 673 673 - actor: AppBskyActorNS; 672 672 + _server: Server 673 673 + actor: AppBskyActorNS 674 674 675 675 constructor(server: Server) { 676 676 - this._server = server; 677 677 - this.actor = new AppBskyActorNS(server); 676 676 + this._server = server 677 677 + this.actor = new AppBskyActorNS(server) 678 678 } 679 679 } 680 680 681 681 export class AppBskyActorNS { 682 682 - _server: Server; 682 682 + _server: Server 683 683 684 684 constructor(server: Server) { 685 685 - this._server = server; 685 685 + this._server = server 686 686 } 687 687 } 688 688 689 689 export class ComNS { 690 690 - _server: Server; 691 691 - atproto: ComAtprotoNS; 690 690 + _server: Server 691 691 + atproto: ComAtprotoNS 692 692 693 693 constructor(server: Server) { 694 694 - this._server = server; 695 695 - this.atproto = new ComAtprotoNS(server); 694 694 + this._server = server 695 695 + this.atproto = new ComAtprotoNS(server) 696 696 } 697 697 } 698 698 699 699 export class ComAtprotoNS { 700 700 - _server: Server; 701 701 - repo: ComAtprotoRepoNS; 700 700 + _server: Server 701 701 + repo: ComAtprotoRepoNS 702 702 703 703 constructor(server: Server) { 704 704 - this._server = server; 705 705 - this.repo = new ComAtprotoRepoNS(server); 704 704 + this._server = server 705 705 + this.repo = new ComAtprotoRepoNS(server) 706 706 } 707 707 } 708 708 709 709 export class ComAtprotoRepoNS { 710 710 - _server: Server; 710 710 + _server: Server 711 711 712 712 constructor(server: Server) { 713 713 - this._server = server; 713 713 + this._server = server 714 714 } 715 715 } 716 716 717 717 type SharedRateLimitOpts<T> = { 718 718 - name: string; 719 719 - calcKey?: (ctx: T) => string | null; 720 720 - calcPoints?: (ctx: T) => number; 721 721 - }; 718 718 + name: string 719 719 + calcKey?: (ctx: T) => string | null 720 720 + calcPoints?: (ctx: T) => number 721 721 + } 722 722 type RouteRateLimitOpts<T> = { 723 723 - durationMs: number; 724 724 - points: number; 725 725 - calcKey?: (ctx: T) => string | null; 726 726 - calcPoints?: (ctx: T) => number; 727 727 - }; 728 728 - type HandlerOpts = { blobLimit?: number }; 729 729 - type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>; 723 723 + durationMs: number 724 724 + points: number 725 725 + calcKey?: (ctx: T) => string | null 726 726 + calcPoints?: (ctx: T) => number 727 727 + } 728 728 + type HandlerOpts = { blobLimit?: number } 729 729 + type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T> 730 730 type ConfigOf<Auth, Handler, ReqCtx> = 731 731 | Handler 732 732 | { 733 733 - auth?: Auth; 734 734 - opts?: HandlerOpts; 735 735 - rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]; 736 736 - handler: Handler; 737 737 - }; 733 733 + auth?: Auth 734 734 + opts?: HandlerOpts 735 735 + rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[] 736 736 + handler: Handler 737 737 + } 738 738 type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract< 739 739 Awaited<ReturnType<AV>>, 740 740 { credentials: unknown } 741 741 - >; 741 741 + >

+1000 -990

apps/api/src/lexicon/lexicons.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type LexiconDoc, Lexicons } from "@atproto/lexicon"; 4 4 + import { type LexiconDoc, Lexicons } from '@atproto/lexicon' 5 5 6 6 export const schemaDict = { 7 7 IoPocketenvActorDefs: { 8 8 lexicon: 1, 9 9 - id: "io.pocketenv.actor.defs", 9 9 + id: 'io.pocketenv.actor.defs', 10 10 defs: { 11 11 profileViewDetailed: { 12 12 - type: "object", 12 12 + type: 'object', 13 13 properties: { 14 14 id: { 15 15 - type: "string", 16 16 - description: "The unique identifier of the actor.", 15 15 + type: 'string', 16 16 + description: 'The unique identifier of the actor.', 17 17 }, 18 18 did: { 19 19 - type: "string", 20 20 - description: "The DID of the actor.", 19 19 + type: 'string', 20 20 + description: 'The DID of the actor.', 21 21 }, 22 22 handle: { 23 23 - type: "string", 24 24 - description: "The handle of the actor.", 23 23 + type: 'string', 24 24 + description: 'The handle of the actor.', 25 25 }, 26 26 displayName: { 27 27 - type: "string", 28 28 - description: "The display name of the actor.", 27 27 + type: 'string', 28 28 + description: 'The display name of the actor.', 29 29 }, 30 30 avatar: { 31 31 - type: "string", 31 31 + type: 'string', 32 32 description: "The URL of the actor's avatar image.", 33 33 - format: "uri", 33 33 + format: 'uri', 34 34 }, 35 35 createdAt: { 36 36 - type: "string", 37 37 - description: "The date and time when the actor was created.", 38 38 - format: "datetime", 36 36 + type: 'string', 37 37 + description: 'The date and time when the actor was created.', 38 38 + format: 'datetime', 39 39 }, 40 40 updatedAt: { 41 41 - type: "string", 42 42 - description: "The date and time when the actor was last updated.", 43 43 - format: "datetime", 41 41 + type: 'string', 42 42 + description: 'The date and time when the actor was last updated.', 43 43 + format: 'datetime', 44 44 }, 45 45 }, 46 46 }, ··· 48 48 }, 49 49 IoPocketenvActorGetActorSandboxes: { 50 50 lexicon: 1, 51 51 - id: "io.pocketenv.actor.getActorSandboxes", 51 51 + id: 'io.pocketenv.actor.getActorSandboxes', 52 52 defs: { 53 53 main: { 54 54 - type: "query", 55 55 - description: "Get all sandboxes for a given actor", 54 54 + type: 'query', 55 55 + description: 'Get all sandboxes for a given actor', 56 56 parameters: { 57 57 - type: "params", 58 58 - required: ["did"], 57 57 + type: 'params', 58 58 + required: ['did'], 59 59 properties: { 60 60 did: { 61 61 - type: "string", 62 62 - description: "The DID or handle of the actor", 63 63 - format: "at-identifier", 61 61 + type: 'string', 62 62 + description: 'The DID or handle of the actor', 63 63 + format: 'at-identifier', 64 64 }, 65 65 limit: { 66 66 - type: "integer", 67 67 - description: "The maximum number of sandboxes to return.", 66 66 + type: 'integer', 67 67 + description: 'The maximum number of sandboxes to return.', 68 68 minimum: 1, 69 69 }, 70 70 offset: { 71 71 - type: "integer", 71 71 + type: 'integer', 72 72 description: 73 73 - "The number of sandboxes to skip before starting to collect the result set.", 73 73 + 'The number of sandboxes to skip before starting to collect the result set.', 74 74 minimum: 0, 75 75 }, 76 76 }, 77 77 }, 78 78 output: { 79 79 - encoding: "application/json", 79 79 + encoding: 'application/json', 80 80 schema: { 81 81 - type: "object", 81 81 + type: 'object', 82 82 properties: { 83 83 sandboxes: { 84 84 - type: "array", 84 84 + type: 'array', 85 85 items: { 86 86 - type: "ref", 87 87 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewDetailed", 86 86 + type: 'ref', 87 87 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewDetailed', 88 88 }, 89 89 }, 90 90 total: { 91 91 - type: "integer", 92 92 - description: "The total number of sandboxes available.", 91 91 + type: 'integer', 92 92 + description: 'The total number of sandboxes available.', 93 93 minimum: 0, 94 94 }, 95 95 }, ··· 100 100 }, 101 101 IoPocketenvActorGetProfile: { 102 102 lexicon: 1, 103 103 - id: "io.pocketenv.actor.getProfile", 103 103 + id: 'io.pocketenv.actor.getProfile', 104 104 defs: { 105 105 main: { 106 106 - type: "query", 107 107 - description: "Get the profile of an actor", 106 106 + type: 'query', 107 107 + description: 'Get the profile of an actor', 108 108 parameters: { 109 109 - type: "params", 109 109 + type: 'params', 110 110 properties: { 111 111 did: { 112 112 - type: "string", 113 113 - description: "The DID or handle of the actor", 114 114 - format: "at-identifier", 112 112 + type: 'string', 113 113 + description: 'The DID or handle of the actor', 114 114 + format: 'at-identifier', 115 115 }, 116 116 }, 117 117 }, 118 118 output: { 119 119 - encoding: "application/json", 119 119 + encoding: 'application/json', 120 120 schema: { 121 121 - type: "ref", 122 122 - ref: "lex:io.pocketenv.actor.defs#profileViewDetailed", 121 121 + type: 'ref', 122 122 + ref: 'lex:io.pocketenv.actor.defs#profileViewDetailed', 123 123 }, 124 124 }, 125 125 }, ··· 127 127 }, 128 128 IoPocketenvActorGetTerminalToken: { 129 129 lexicon: 1, 130 130 - id: "io.pocketenv.actor.getTerminalToken", 130 130 + id: 'io.pocketenv.actor.getTerminalToken', 131 131 defs: { 132 132 main: { 133 133 - type: "query", 134 134 - description: "Get a terminal token", 133 133 + type: 'query', 134 134 + description: 'Get a terminal token', 135 135 parameters: { 136 136 - type: "params", 136 136 + type: 'params', 137 137 properties: {}, 138 138 }, 139 139 output: { 140 140 - encoding: "application/json", 140 140 + encoding: 'application/json', 141 141 schema: { 142 142 - type: "object", 142 142 + type: 'object', 143 143 properties: { 144 144 token: { 145 145 - type: "string", 145 145 + type: 'string', 146 146 description: 147 147 - "An access token that can be used to authenticate with the terminal service. This token is typically short-lived and should be used immediately to establish a connection with the terminal.", 147 147 + 'An access token that can be used to authenticate with the terminal service. This token is typically short-lived and should be used immediately to establish a connection with the terminal.', 148 148 }, 149 149 }, 150 150 }, ··· 154 154 }, 155 155 AppBskyActorProfile: { 156 156 lexicon: 1, 157 157 - id: "app.bsky.actor.profile", 157 157 + id: 'app.bsky.actor.profile', 158 158 defs: { 159 159 main: { 160 160 - type: "record", 161 161 - description: "A declaration of a Bluesky account profile.", 162 162 - key: "literal:self", 160 160 + type: 'record', 161 161 + description: 'A declaration of a Bluesky account profile.', 162 162 + key: 'literal:self', 163 163 record: { 164 164 - type: "object", 164 164 + type: 'object', 165 165 properties: { 166 166 displayName: { 167 167 - type: "string", 167 167 + type: 'string', 168 168 maxGraphemes: 64, 169 169 maxLength: 640, 170 170 }, 171 171 description: { 172 172 - type: "string", 173 173 - description: "Free-form profile description text.", 172 172 + type: 'string', 173 173 + description: 'Free-form profile description text.', 174 174 maxGraphemes: 256, 175 175 maxLength: 2560, 176 176 }, 177 177 avatar: { 178 178 - type: "blob", 178 178 + type: 'blob', 179 179 description: 180 180 "Small image to be displayed next to posts from account. AKA, 'profile picture'", 181 181 - accept: ["image/png", "image/jpeg"], 181 181 + accept: ['image/png', 'image/jpeg'], 182 182 maxSize: 1000000, 183 183 }, 184 184 banner: { 185 185 - type: "blob", 185 185 + type: 'blob', 186 186 description: 187 187 - "Larger horizontal image to display behind profile view.", 188 188 - accept: ["image/png", "image/jpeg"], 187 187 + 'Larger horizontal image to display behind profile view.', 188 188 + accept: ['image/png', 'image/jpeg'], 189 189 maxSize: 10000000, 190 190 }, 191 191 labels: { 192 192 - type: "union", 192 192 + type: 'union', 193 193 description: 194 194 - "Self-label values, specific to the Bluesky application, on the overall account.", 195 195 - refs: ["lex:com.atproto.label.defs#selfLabels"], 194 194 + 'Self-label values, specific to the Bluesky application, on the overall account.', 195 195 + refs: ['lex:com.atproto.label.defs#selfLabels'], 196 196 }, 197 197 joinedViaStarterPack: { 198 198 - type: "ref", 199 199 - ref: "lex:com.atproto.repo.strongRef", 198 198 + type: 'ref', 199 199 + ref: 'lex:com.atproto.repo.strongRef', 200 200 }, 201 201 createdAt: { 202 202 - type: "string", 203 203 - format: "datetime", 202 202 + type: 'string', 203 203 + format: 'datetime', 204 204 }, 205 205 }, 206 206 }, ··· 209 209 }, 210 210 IoPocketenvFileAddFile: { 211 211 lexicon: 1, 212 212 - id: "io.pocketenv.file.addFile", 212 212 + id: 'io.pocketenv.file.addFile', 213 213 defs: { 214 214 main: { 215 215 - type: "procedure", 215 215 + type: 'procedure', 216 216 input: { 217 217 - encoding: "application/json", 217 217 + encoding: 'application/json', 218 218 schema: { 219 219 - type: "object", 220 220 - required: ["file"], 219 219 + type: 'object', 220 220 + required: ['file'], 221 221 properties: { 222 222 file: { 223 223 - type: "ref", 224 224 - ref: "lex:io.pocketenv.file.defs#file", 223 223 + type: 'ref', 224 224 + ref: 'lex:io.pocketenv.file.defs#file', 225 225 }, 226 226 }, 227 227 }, ··· 231 231 }, 232 232 IoPocketenvFileDefs: { 233 233 lexicon: 1, 234 234 - id: "io.pocketenv.file.defs", 234 234 + id: 'io.pocketenv.file.defs', 235 235 defs: { 236 236 file: { 237 237 - type: "object", 238 238 - required: ["path", "content"], 237 237 + type: 'object', 238 238 + required: ['path', 'content'], 239 239 properties: { 240 240 sandboxId: { 241 241 - type: "string", 241 241 + type: 'string', 242 242 description: 243 243 - "The ID of the sandbox to which the file belongs. This is used to associate the file with a specific sandbox environment.", 243 243 + 'The ID of the sandbox to which the file belongs. This is used to associate the file with a specific sandbox environment.', 244 244 }, 245 245 path: { 246 246 - type: "string", 246 246 + type: 'string', 247 247 description: 248 248 "The file path within the sandbox, e.g. '/app/config.json', '/home/user/.ssh/id_rsa', etc.", 249 249 }, 250 250 content: { 251 251 - type: "string", 251 251 + type: 'string', 252 252 description: 253 253 "The content of the file. This will be written to the specified path within the sandbox. The content should be base64 encoded if it's binary data.", 254 254 }, 255 255 }, 256 256 }, 257 257 fileView: { 258 258 - type: "object", 258 258 + type: 'object', 259 259 properties: { 260 260 id: { 261 261 - type: "string", 262 262 - description: "Unique identifier of the file.", 261 261 + type: 'string', 262 262 + description: 'Unique identifier of the file.', 263 263 }, 264 264 path: { 265 265 - type: "string", 265 265 + type: 'string', 266 266 description: 267 267 "The file path within the sandbox, e.g. '/app/config.json', '/home/user/.ssh/id_rsa', etc.", 268 268 }, 269 269 createdAt: { 270 270 - type: "string", 271 271 - description: "The timestamp when the file was created.", 272 272 - format: "datetime", 270 270 + type: 'string', 271 271 + description: 'The timestamp when the file was created.', 272 272 + format: 'datetime', 273 273 }, 274 274 updatedAt: { 275 275 - type: "string", 276 276 - description: "The timestamp when the file was last updated.", 277 277 - format: "datetime", 275 275 + type: 'string', 276 276 + description: 'The timestamp when the file was last updated.', 277 277 + format: 'datetime', 278 278 }, 279 279 }, 280 280 }, 281 281 files: { 282 282 - type: "array", 282 282 + type: 'array', 283 283 items: { 284 284 - type: "ref", 285 285 - description: "A file to add to the sandbox", 286 286 - ref: "lex:io.pocketenv.file.defs#file", 284 284 + type: 'ref', 285 285 + description: 'A file to add to the sandbox', 286 286 + ref: 'lex:io.pocketenv.file.defs#file', 287 287 }, 288 288 }, 289 289 }, 290 290 }, 291 291 IoPocketenvFileDeleteFile: { 292 292 lexicon: 1, 293 293 - id: "io.pocketenv.file.deleteFile", 293 293 + id: 'io.pocketenv.file.deleteFile', 294 294 defs: { 295 295 main: { 296 296 - type: "procedure", 296 296 + type: 'procedure', 297 297 parameters: { 298 298 - type: "params", 299 299 - required: ["id"], 298 298 + type: 'params', 299 299 + required: ['id'], 300 300 properties: { 301 301 id: { 302 302 - type: "string", 303 303 - description: "The ID of the file to delete", 302 302 + type: 'string', 303 303 + description: 'The ID of the file to delete', 304 304 }, 305 305 }, 306 306 }, ··· 309 309 }, 310 310 IoPocketenvFileGetFile: { 311 311 lexicon: 1, 312 312 - id: "io.pocketenv.file.getFile", 312 312 + id: 'io.pocketenv.file.getFile', 313 313 defs: { 314 314 main: { 315 315 - type: "query", 315 315 + type: 'query', 316 316 parameters: { 317 317 - type: "params", 318 318 - required: ["id"], 317 317 + type: 'params', 318 318 + required: ['id'], 319 319 properties: { 320 320 id: { 321 321 - type: "string", 322 322 - description: "The ID of the file to retrieve.", 321 321 + type: 'string', 322 322 + description: 'The ID of the file to retrieve.', 323 323 }, 324 324 }, 325 325 }, 326 326 output: { 327 327 - encoding: "application/json", 327 327 + encoding: 'application/json', 328 328 schema: { 329 329 - type: "object", 329 329 + type: 'object', 330 330 properties: { 331 331 file: { 332 332 - type: "ref", 333 333 - ref: "lex:io.pocketenv.file.defs#fileView", 332 332 + type: 'ref', 333 333 + ref: 'lex:io.pocketenv.file.defs#fileView', 334 334 }, 335 335 }, 336 336 }, ··· 340 340 }, 341 341 IoPocketenvFileGetFiles: { 342 342 lexicon: 1, 343 343 - id: "io.pocketenv.file.getFiles", 343 343 + id: 'io.pocketenv.file.getFiles', 344 344 defs: { 345 345 main: { 346 346 - type: "query", 346 346 + type: 'query', 347 347 parameters: { 348 348 - type: "params", 348 348 + type: 'params', 349 349 properties: { 350 350 sandboxId: { 351 351 - type: "string", 352 352 - description: "The ID of the sandbox for which to retrieve files.", 351 351 + type: 'string', 352 352 + description: 'The ID of the sandbox for which to retrieve files.', 353 353 }, 354 354 limit: { 355 355 - type: "integer", 356 356 - description: "The maximum number of files to return.", 355 355 + type: 'integer', 356 356 + description: 'The maximum number of files to return.', 357 357 minimum: 1, 358 358 }, 359 359 offset: { 360 360 - type: "integer", 360 360 + type: 'integer', 361 361 description: 362 362 - "The number of files to skip before starting to collect the result set.", 362 362 + 'The number of files to skip before starting to collect the result set.', 363 363 minimum: 0, 364 364 }, 365 365 }, 366 366 }, 367 367 output: { 368 368 - encoding: "application/json", 368 368 + encoding: 'application/json', 369 369 schema: { 370 370 - type: "object", 370 370 + type: 'object', 371 371 properties: { 372 372 files: { 373 373 - type: "array", 373 373 + type: 'array', 374 374 items: { 375 375 - type: "ref", 376 376 - ref: "lex:io.pocketenv.file.defs#fileView", 375 375 + type: 'ref', 376 376 + ref: 'lex:io.pocketenv.file.defs#fileView', 377 377 }, 378 378 }, 379 379 total: { 380 380 - type: "integer", 381 381 - description: "The total number of files available.", 380 380 + type: 'integer', 381 381 + description: 'The total number of files available.', 382 382 minimum: 0, 383 383 }, 384 384 }, ··· 389 389 }, 390 390 IoPocketenvFileUpdateFile: { 391 391 lexicon: 1, 392 392 - id: "io.pocketenv.file.updateFile", 392 392 + id: 'io.pocketenv.file.updateFile', 393 393 defs: { 394 394 main: { 395 395 - type: "procedure", 395 395 + type: 'procedure', 396 396 input: { 397 397 - encoding: "application/json", 397 397 + encoding: 'application/json', 398 398 schema: { 399 399 - type: "object", 400 400 - required: ["id", "file"], 399 399 + type: 'object', 400 400 + required: ['id', 'file'], 401 401 properties: { 402 402 id: { 403 403 - type: "string", 404 404 - description: "The ID of the file to delete", 403 403 + type: 'string', 404 404 + description: 'The ID of the file to delete', 405 405 }, 406 406 file: { 407 407 - type: "ref", 408 408 - ref: "lex:io.pocketenv.file.defs#file", 407 407 + type: 'ref', 408 408 + ref: 'lex:io.pocketenv.file.defs#file', 409 409 }, 410 410 }, 411 411 }, ··· 415 415 }, 416 416 IoPocketenvPortDefs: { 417 417 lexicon: 1, 418 418 - id: "io.pocketenv.port.defs", 418 418 + id: 'io.pocketenv.port.defs', 419 419 defs: { 420 420 portView: { 421 421 - type: "object", 422 422 - description: "A view of a port exposed by a sandbox.", 421 421 + type: 'object', 422 422 + description: 'A view of a port exposed by a sandbox.', 423 423 properties: { 424 424 port: { 425 425 - type: "integer", 426 426 - description: "The port number.", 425 425 + type: 'integer', 426 426 + description: 'The port number.', 427 427 maximum: 65535, 428 428 minimum: 1025, 429 429 }, 430 430 description: { 431 431 - type: "string", 432 432 - description: "A description of the port.", 431 431 + type: 'string', 432 432 + description: 'A description of the port.', 433 433 }, 434 434 previewUrl: { 435 435 - type: "string", 436 436 - description: "A URL for previewing the service running on the port", 435 435 + type: 'string', 436 436 + description: 'A URL for previewing the service running on the port', 437 437 }, 438 438 }, 439 439 }, ··· 441 441 }, 442 442 IoPocketenvSandboxClaimSandbox: { 443 443 lexicon: 1, 444 444 - id: "io.pocketenv.sandbox.claimSandbox", 444 444 + id: 'io.pocketenv.sandbox.claimSandbox', 445 445 defs: { 446 446 main: { 447 447 - type: "procedure", 448 448 - description: "Claim a sandbox by id", 447 447 + type: 'procedure', 448 448 + description: 'Claim a sandbox by id', 449 449 parameters: { 450 450 - type: "params", 451 451 - required: ["id"], 450 450 + type: 'params', 451 451 + required: ['id'], 452 452 properties: { 453 453 id: { 454 454 - type: "string", 455 455 - description: "The sandbox ID.", 454 454 + type: 'string', 455 455 + description: 'The sandbox ID.', 456 456 }, 457 457 }, 458 458 }, 459 459 output: { 460 460 - encoding: "application/json", 460 460 + encoding: 'application/json', 461 461 schema: { 462 462 - type: "ref", 463 463 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 462 462 + type: 'ref', 463 463 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 464 464 }, 465 465 }, 466 466 }, ··· 468 468 }, 469 469 IoPocketenvSandboxCreateIntegration: { 470 470 lexicon: 1, 471 471 - id: "io.pocketenv.sandbox.createIntegration", 471 471 + id: 'io.pocketenv.sandbox.createIntegration', 472 472 defs: { 473 473 main: { 474 474 - type: "procedure", 475 475 - description: "Create a new integration for the sandbox.", 474 474 + type: 'procedure', 475 475 + description: 'Create a new integration for the sandbox.', 476 476 input: { 477 477 - encoding: "application/json", 477 477 + encoding: 'application/json', 478 478 schema: { 479 479 - type: "object", 480 480 - required: ["id", "name"], 479 479 + type: 'object', 480 480 + required: ['id', 'name'], 481 481 properties: { 482 482 id: { 483 483 - type: "string", 484 484 - description: "The sandbox ID.", 483 483 + type: 'string', 484 484 + description: 'The sandbox ID.', 485 485 }, 486 486 name: { 487 487 - type: "string", 488 488 - description: "The name of the integration.", 487 487 + type: 'string', 488 488 + description: 'The name of the integration.', 489 489 }, 490 490 }, 491 491 }, 492 492 }, 493 493 output: { 494 494 - encoding: "application/json", 494 494 + encoding: 'application/json', 495 495 schema: { 496 496 - type: "ref", 497 497 - ref: "lex:io.pocketenv.sandbox.defs#integrationView", 496 496 + type: 'ref', 497 497 + ref: 'lex:io.pocketenv.sandbox.defs#integrationView', 498 498 }, 499 499 }, 500 500 }, ··· 502 502 }, 503 503 IoPocketenvSandboxCreateSandbox: { 504 504 lexicon: 1, 505 505 - id: "io.pocketenv.sandbox.createSandbox", 505 505 + id: 'io.pocketenv.sandbox.createSandbox', 506 506 defs: { 507 507 main: { 508 508 - type: "procedure", 509 509 - description: "Create a sandbox", 508 508 + type: 'procedure', 509 509 + description: 'Create a sandbox', 510 510 input: { 511 511 - encoding: "application/json", 511 511 + encoding: 'application/json', 512 512 schema: { 513 513 - type: "object", 514 514 - required: ["base"], 513 513 + type: 'object', 514 514 + required: ['base'], 515 515 properties: { 516 516 base: { 517 517 - type: "string", 517 517 + type: 'string', 518 518 description: 519 519 - "The base sandbox URI to clone from, e.g. a template or an existing sandbox.", 519 519 + 'The base sandbox URI to clone from, e.g. a template or an existing sandbox.', 520 520 }, 521 521 name: { 522 522 - type: "string", 523 523 - description: "The name of the sandbox", 522 522 + type: 'string', 523 523 + description: 'The name of the sandbox', 524 524 minLength: 1, 525 525 }, 526 526 description: { 527 527 - type: "string", 528 528 - description: "A description for the sandbox", 527 527 + type: 'string', 528 528 + description: 'A description for the sandbox', 529 529 }, 530 530 provider: { 531 531 - type: "string", 531 531 + type: 'string', 532 532 description: 533 533 "The provider to create the sandbox on, e.g. 'daytona', 'vercel', 'cloudflare', etc.", 534 534 - enum: ["daytona", "vercel", "cloudflare", "deno", "sprites"], 534 534 + enum: ['daytona', 'vercel', 'cloudflare', 'deno', 'sprites'], 535 535 }, 536 536 topics: { 537 537 - type: "array", 537 537 + type: 'array', 538 538 description: 539 539 - "A list of topics/tags to associate with the sandbox", 539 539 + 'A list of topics/tags to associate with the sandbox', 540 540 items: { 541 541 - type: "string", 541 541 + type: 'string', 542 542 maxLength: 50, 543 543 }, 544 544 }, 545 545 repo: { 546 546 - type: "string", 546 546 + type: 'string', 547 547 description: 548 548 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 548 548 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 549 549 }, 550 550 vcpus: { 551 551 - type: "integer", 551 551 + type: 'integer', 552 552 description: 553 553 - "The number of virtual CPUs to allocate for the sandbox", 553 553 + 'The number of virtual CPUs to allocate for the sandbox', 554 554 minimum: 1, 555 555 }, 556 556 memory: { 557 557 - type: "integer", 557 557 + type: 'integer', 558 558 description: 559 559 - "The amount of memory (in GB) to allocate for the sandbox", 559 559 + 'The amount of memory (in GB) to allocate for the sandbox', 560 560 minimum: 1, 561 561 }, 562 562 disk: { 563 563 - type: "integer", 563 563 + type: 'integer', 564 564 description: 565 565 - "The amount of disk space (in GB) to allocate for the sandbox", 565 565 + 'The amount of disk space (in GB) to allocate for the sandbox', 566 566 minimum: 3, 567 567 }, 568 568 readme: { 569 569 - type: "string", 570 570 - description: "A URI to a README for the sandbox.", 571 571 - format: "uri", 569 569 + type: 'string', 570 570 + description: 'A URI to a README for the sandbox.', 571 571 + format: 'uri', 572 572 }, 573 573 secrets: { 574 574 - type: "ref", 575 575 - description: "A list of secrets to add to the sandbox", 576 576 - ref: "lex:io.pocketenv.sandbox.defs#secrets", 574 574 + type: 'ref', 575 575 + description: 'A list of secrets to add to the sandbox', 576 576 + ref: 'lex:io.pocketenv.sandbox.defs#secrets', 577 577 }, 578 578 envs: { 579 579 - type: "ref", 579 579 + type: 'ref', 580 580 + description: 581 581 + 'A list of environment variables to add to the sandbox', 582 582 + ref: 'lex:io.pocketenv.sandbox.defs#envs', 583 583 + }, 584 584 + keepAlive: { 585 585 + type: 'boolean', 580 586 description: 581 581 - "A list of environment variables to add to the sandbox", 582 582 - ref: "lex:io.pocketenv.sandbox.defs#envs", 587 587 + 'Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs.', 583 588 }, 584 589 }, 585 590 }, 586 591 }, 587 592 output: { 588 588 - encoding: "application/json", 593 593 + encoding: 'application/json', 589 594 schema: { 590 590 - type: "ref", 591 591 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 595 595 + type: 'ref', 596 596 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 592 597 }, 593 598 }, 594 599 }, ··· 596 601 }, 597 602 IoPocketenvSandboxDefs: { 598 603 lexicon: 1, 599 599 - id: "io.pocketenv.sandbox.defs", 604 604 + id: 'io.pocketenv.sandbox.defs', 600 605 defs: { 601 606 sandboxViewBasic: { 602 602 - type: "object", 607 607 + type: 'object', 603 608 properties: { 604 609 name: { 605 605 - type: "string", 606 606 - description: "Name of the sandbox", 610 610 + type: 'string', 611 611 + description: 'Name of the sandbox', 607 612 maxLength: 50, 608 613 }, 609 614 provider: { 610 610 - type: "string", 615 615 + type: 'string', 611 616 description: 612 617 "The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.", 613 618 maxLength: 50, 614 619 }, 615 620 description: { 616 616 - type: "string", 621 621 + type: 'string', 617 622 maxGraphemes: 300, 618 623 maxLength: 3000, 619 624 }, 620 625 website: { 621 621 - type: "string", 622 622 - description: "Any URI related to the sandbox", 623 623 - format: "uri", 626 626 + type: 'string', 627 627 + description: 'Any URI related to the sandbox', 628 628 + format: 'uri', 624 629 }, 625 630 logo: { 626 626 - type: "string", 627 627 - description: "URI to an image logo for the sandbox", 628 628 - format: "uri", 631 631 + type: 'string', 632 632 + description: 'URI to an image logo for the sandbox', 633 633 + format: 'uri', 629 634 }, 630 635 topics: { 631 631 - type: "array", 636 636 + type: 'array', 632 637 items: { 633 633 - type: "string", 638 638 + type: 'string', 634 639 minLength: 1, 635 640 maxLength: 50, 636 641 }, 637 642 maxLength: 50, 638 643 }, 639 644 repo: { 640 640 - type: "string", 645 645 + type: 'string', 641 646 description: 642 642 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 647 647 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 643 648 }, 644 649 readme: { 645 645 - type: "string", 646 646 - description: "A URI to a README for the sandbox.", 647 647 - format: "uri", 650 650 + type: 'string', 651 651 + description: 'A URI to a README for the sandbox.', 652 652 + format: 'uri', 648 653 }, 649 654 vcpus: { 650 650 - type: "integer", 651 651 - description: "Number of virtual CPUs allocated to the sandbox", 655 655 + type: 'integer', 656 656 + description: 'Number of virtual CPUs allocated to the sandbox', 652 657 }, 653 658 memory: { 654 654 - type: "integer", 655 655 - description: "Amount of memory in GB allocated to the sandbox", 659 659 + type: 'integer', 660 660 + description: 'Amount of memory in GB allocated to the sandbox', 656 661 }, 657 662 disk: { 658 658 - type: "integer", 659 659 - description: "Amount of disk space in GB allocated to the sandbox", 663 663 + type: 'integer', 664 664 + description: 'Amount of disk space in GB allocated to the sandbox', 660 665 }, 661 666 ports: { 662 662 - type: "array", 667 667 + type: 'array', 663 668 items: { 664 664 - type: "integer", 669 669 + type: 'integer', 665 670 maximum: 65535, 666 671 minimum: 1025, 667 672 }, 668 673 maxLength: 100, 669 674 }, 670 675 installs: { 671 671 - type: "integer", 676 676 + type: 'integer', 672 677 description: 673 673 - "Number of times the sandbox has been installed by users.", 678 678 + 'Number of times the sandbox has been installed by users.', 674 679 }, 675 680 createdAt: { 676 676 - type: "string", 677 677 - format: "datetime", 681 681 + type: 'string', 682 682 + format: 'datetime', 678 683 }, 679 684 }, 680 685 }, 681 686 sandboxViewDetailed: { 682 682 - type: "object", 687 687 + type: 'object', 683 688 properties: { 684 689 name: { 685 685 - type: "string", 686 686 - description: "Name of the sandbox", 690 690 + type: 'string', 691 691 + description: 'Name of the sandbox', 687 692 maxLength: 50, 688 693 }, 689 694 provider: { 690 690 - type: "string", 695 695 + type: 'string', 691 696 description: 692 697 "The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.", 693 698 maxLength: 50, 694 699 }, 695 700 description: { 696 696 - type: "string", 701 701 + type: 'string', 697 702 maxGraphemes: 300, 698 703 maxLength: 3000, 699 704 }, 700 705 status: { 701 701 - type: "string", 706 706 + type: 'string', 702 707 description: 703 708 "The current status of the sandbox, e.g. 'RUNNING', 'STOPPED', etc.", 704 709 }, 705 710 startedAt: { 706 706 - type: "string", 707 707 - format: "datetime", 711 711 + type: 'string', 712 712 + format: 'datetime', 708 713 }, 709 714 timeout: { 710 710 - type: "integer", 711 711 - description: "The sandbox timeout in seconds", 715 715 + type: 'integer', 716 716 + description: 'The sandbox timeout in seconds', 712 717 }, 713 718 baseSandbox: { 714 714 - type: "string", 719 719 + type: 'string', 715 720 description: 716 716 - "The base sandbox that this sandbox was created from, if any. This can be used to determine the template or configuration used to create the sandbox.", 721 721 + 'The base sandbox that this sandbox was created from, if any. This can be used to determine the template or configuration used to create the sandbox.', 717 722 }, 718 723 website: { 719 719 - type: "string", 720 720 - description: "Any URI related to the sandbox", 721 721 - format: "uri", 724 724 + type: 'string', 725 725 + description: 'Any URI related to the sandbox', 726 726 + format: 'uri', 722 727 }, 723 728 logo: { 724 724 - type: "string", 725 725 - description: "URI to an image logo for the sandbox", 726 726 - format: "uri", 729 729 + type: 'string', 730 730 + description: 'URI to an image logo for the sandbox', 731 731 + format: 'uri', 727 732 }, 728 733 topics: { 729 729 - type: "array", 734 734 + type: 'array', 730 735 items: { 731 731 - type: "string", 736 736 + type: 'string', 732 737 minLength: 1, 733 738 maxLength: 50, 734 739 }, 735 740 maxLength: 50, 736 741 }, 737 742 repo: { 738 738 - type: "string", 743 743 + type: 'string', 739 744 description: 740 740 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 745 745 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 741 746 }, 742 747 readme: { 743 743 - type: "string", 744 744 - description: "A URI to a README for the sandbox.", 745 745 - format: "uri", 748 748 + type: 'string', 749 749 + description: 'A URI to a README for the sandbox.', 750 750 + format: 'uri', 746 751 }, 747 752 vcpus: { 748 748 - type: "integer", 749 749 - description: "Number of virtual CPUs allocated to the sandbox", 753 753 + type: 'integer', 754 754 + description: 'Number of virtual CPUs allocated to the sandbox', 750 755 }, 751 756 memory: { 752 752 - type: "integer", 753 753 - description: "Amount of memory in GB allocated to the sandbox", 757 757 + type: 'integer', 758 758 + description: 'Amount of memory in GB allocated to the sandbox', 754 759 }, 755 760 disk: { 756 756 - type: "integer", 757 757 - description: "Amount of disk space in GB allocated to the sandbox", 761 761 + type: 'integer', 762 762 + description: 'Amount of disk space in GB allocated to the sandbox', 758 763 }, 759 764 ports: { 760 760 - type: "array", 765 765 + type: 'array', 761 766 items: { 762 762 - type: "integer", 767 767 + type: 'integer', 763 768 maximum: 65535, 764 769 minimum: 1025, 765 770 }, 766 771 maxLength: 100, 767 772 }, 768 773 installs: { 769 769 - type: "integer", 774 774 + type: 'integer', 770 775 description: 771 771 - "Number of times the sandbox has been installed by users.", 776 776 + 'Number of times the sandbox has been installed by users.', 772 777 }, 773 778 createdAt: { 774 774 - type: "string", 775 775 - format: "datetime", 779 779 + type: 'string', 780 780 + format: 'datetime', 776 781 }, 777 782 owner: { 778 778 - type: "ref", 779 779 - description: "The user who created the sandbox", 780 780 - ref: "lex:io.pocketenv.user.defs#userViewBasic", 783 783 + type: 'ref', 784 784 + description: 'The user who created the sandbox', 785 785 + ref: 'lex:io.pocketenv.user.defs#userViewBasic', 781 786 }, 782 787 }, 783 788 }, 784 789 sandboxDetailsPref: { 785 785 - type: "object", 786 786 - nullable: ["repo", "description", "topics"], 790 790 + type: 'object', 791 791 + nullable: ['repo', 'description', 'topics'], 787 792 properties: { 788 793 name: { 789 789 - type: "string", 790 790 - description: "The name of the sandbox", 794 794 + type: 'string', 795 795 + description: 'The name of the sandbox', 791 796 minLength: 1, 792 797 }, 793 798 description: { 794 794 - type: "string", 795 795 - description: "A description for the sandbox", 799 799 + type: 'string', 800 800 + description: 'A description for the sandbox', 796 801 }, 797 802 topics: { 798 798 - type: "array", 799 799 - description: "A list of topics/tags to associate with the sandbox", 803 803 + type: 'array', 804 804 + description: 'A list of topics/tags to associate with the sandbox', 800 805 items: { 801 801 - type: "string", 806 806 + type: 'string', 802 807 maxLength: 50, 803 808 }, 804 809 }, 805 810 repo: { 806 806 - type: "string", 811 811 + type: 'string', 807 812 description: 808 808 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 813 813 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 809 814 }, 810 815 vcpus: { 811 811 - type: "integer", 816 816 + type: 'integer', 812 817 description: 813 813 - "The number of virtual CPUs to allocate for the sandbox", 818 818 + 'The number of virtual CPUs to allocate for the sandbox', 814 819 minimum: 1, 815 820 }, 816 821 memory: { 817 817 - type: "integer", 822 822 + type: 'integer', 818 823 description: 819 819 - "The amount of memory (in GB) to allocate for the sandbox", 824 824 + 'The amount of memory (in GB) to allocate for the sandbox', 820 825 minimum: 1, 821 826 }, 822 827 disk: { 823 823 - type: "integer", 828 828 + type: 'integer', 824 829 description: 825 825 - "The amount of disk space (in GB) to allocate for the sandbox", 830 830 + 'The amount of disk space (in GB) to allocate for the sandbox', 826 831 minimum: 3, 827 832 }, 828 833 readme: { 829 829 - type: "string", 830 830 - description: "A URI to a README for the sandbox.", 831 831 - format: "uri", 834 834 + type: 'string', 835 835 + description: 'A URI to a README for the sandbox.', 836 836 + format: 'uri', 832 837 }, 833 838 }, 834 839 }, 835 840 secretPref: { 836 836 - type: "object", 841 841 + type: 'object', 837 842 properties: { 838 843 name: { 839 839 - type: "string", 840 840 - description: "The name of the secret", 844 844 + type: 'string', 845 845 + description: 'The name of the secret', 841 846 minLength: 1, 842 847 }, 843 848 value: { 844 844 - type: "string", 849 849 + type: 'string', 845 850 description: 846 846 - "The value of the secret. This will be encrypted at rest and redacted in any API responses.", 851 851 + 'The value of the secret. This will be encrypted at rest and redacted in any API responses.', 847 852 }, 848 853 }, 849 854 }, 850 855 variablePref: { 851 851 - type: "object", 852 852 - description: "A variable to add to the sandbox", 856 856 + type: 'object', 857 857 + description: 'A variable to add to the sandbox', 853 858 properties: { 854 859 name: { 855 855 - type: "string", 856 856 - description: "The name of the variable", 860 860 + type: 'string', 861 861 + description: 'The name of the variable', 857 862 minLength: 1, 858 863 }, 859 864 value: { 860 860 - type: "string", 865 865 + type: 'string', 861 866 description: 862 862 - "The value of the variable. This will be visible in API responses and should not contain sensitive information.", 867 867 + 'The value of the variable. This will be visible in API responses and should not contain sensitive information.', 863 868 }, 864 869 }, 865 870 }, 866 871 filePref: { 867 867 - type: "object", 868 868 - description: "A file to add to the sandbox", 872 872 + type: 'object', 873 873 + description: 'A file to add to the sandbox', 869 874 properties: { 870 875 name: { 871 871 - type: "string", 872 872 - description: "The name of the file", 876 876 + type: 'string', 877 877 + description: 'The name of the file', 873 878 minLength: 1, 874 879 }, 875 880 content: { 876 876 - type: "string", 877 877 - description: "The content of the file.", 881 881 + type: 'string', 882 882 + description: 'The content of the file.', 878 883 }, 879 884 encrypt: { 880 880 - type: "boolean", 885 885 + type: 'boolean', 881 886 description: 882 882 - "Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information.", 887 887 + 'Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information.', 883 888 }, 884 889 path: { 885 885 - type: "string", 890 890 + type: 'string', 886 891 description: 887 892 "The path within the sandbox where the file will be created, e.g. '/app/config.json'. If not provided, the file will be created in the root directory of the sandbox.", 888 893 }, 889 894 }, 890 895 }, 891 896 volumePref: { 892 892 - type: "object", 893 893 - description: "A volume to add to the sandbox", 897 897 + type: 'object', 898 898 + description: 'A volume to add to the sandbox', 894 899 properties: { 895 900 name: { 896 896 - type: "string", 897 897 - description: "The name of the volume", 901 901 + type: 'string', 902 902 + description: 'The name of the volume', 898 903 minLength: 1, 899 904 }, 900 905 path: { 901 901 - type: "string", 906 906 + type: 'string', 902 907 description: 903 908 "The mount path within the sandbox where the volume will be attached, e.g. '/data', '/logs', etc.", 904 909 }, 905 910 readOnly: { 906 906 - type: "boolean", 907 907 - description: "Whether the volume should be mounted as read-only", 911 911 + type: 'boolean', 912 912 + description: 'Whether the volume should be mounted as read-only', 908 913 }, 909 914 }, 910 915 }, 911 916 preferences: { 912 912 - type: "array", 917 917 + type: 'array', 913 918 items: { 914 914 - type: "union", 919 919 + type: 'union', 915 920 refs: [ 916 916 - "lex:io.pocketenv.sandbox.defs#sandboxDetailsPref", 917 917 - "lex:io.pocketenv.sandbox.defs#secretPref", 918 918 - "lex:io.pocketenv.sandbox.defs#variablePref", 919 919 - "lex:io.pocketenv.sandbox.defs#filePref", 920 920 - "lex:io.pocketenv.sandbox.defs#volumePref", 921 921 + 'lex:io.pocketenv.sandbox.defs#sandboxDetailsPref', 922 922 + 'lex:io.pocketenv.sandbox.defs#secretPref', 923 923 + 'lex:io.pocketenv.sandbox.defs#variablePref', 924 924 + 'lex:io.pocketenv.sandbox.defs#filePref', 925 925 + 'lex:io.pocketenv.sandbox.defs#volumePref', 921 926 ], 922 927 }, 923 928 }, 924 929 sshKeysView: { 925 925 - type: "object", 930 930 + type: 'object', 926 931 properties: { 927 932 id: { 928 928 - type: "string", 929 929 - description: "Unique identifier of the SSH key.", 933 933 + type: 'string', 934 934 + description: 'Unique identifier of the SSH key.', 930 935 }, 931 936 publicKey: { 932 932 - type: "string", 933 933 - description: "The public SSH key.", 937 937 + type: 'string', 938 938 + description: 'The public SSH key.', 934 939 }, 935 940 privateKey: { 936 936 - type: "string", 937 937 - description: "The private SSH key (redacted in API responses)", 941 941 + type: 'string', 942 942 + description: 'The private SSH key (redacted in API responses)', 938 943 }, 939 944 createdAt: { 940 940 - type: "string", 941 941 - description: "The timestamp when the SSH key was created.", 942 942 - format: "datetime", 945 945 + type: 'string', 946 946 + description: 'The timestamp when the SSH key was created.', 947 947 + format: 'datetime', 943 948 }, 944 949 updatedAt: { 945 945 - type: "string", 946 946 - description: "The timestamp when the SSH key was last updated.", 947 947 - format: "datetime", 950 950 + type: 'string', 951 951 + description: 'The timestamp when the SSH key was last updated.', 952 952 + format: 'datetime', 948 953 }, 949 954 }, 950 955 }, 951 956 tailscaleAuthKeyView: { 952 952 - type: "object", 957 957 + type: 'object', 953 958 properties: { 954 959 id: { 955 955 - type: "string", 956 956 - description: "Unique identifier of the Tailscale Auth Key.", 960 960 + type: 'string', 961 961 + description: 'Unique identifier of the Tailscale Auth Key.', 957 962 }, 958 963 authKey: { 959 959 - type: "string", 960 960 - description: "The Tailscale auth key (redacted in API responses)", 964 964 + type: 'string', 965 965 + description: 'The Tailscale auth key (redacted in API responses)', 961 966 }, 962 967 redacted: { 963 963 - type: "string", 964 964 - description: "The redacted Auth Key.", 968 968 + type: 'string', 969 969 + description: 'The redacted Auth Key.', 965 970 }, 966 971 createdAt: { 967 967 - type: "string", 972 972 + type: 'string', 968 973 description: 969 969 - "The timestamp when the Tailscale Auth Key was created.", 970 970 - format: "datetime", 974 974 + 'The timestamp when the Tailscale Auth Key was created.', 975 975 + format: 'datetime', 971 976 }, 972 977 updatedAt: { 973 973 - type: "string", 978 978 + type: 'string', 974 979 description: 975 975 - "The timestamp when the Tailscale Auth Key was last updated.", 976 976 - format: "datetime", 980 980 + 'The timestamp when the Tailscale Auth Key was last updated.', 981 981 + format: 'datetime', 977 982 }, 978 983 }, 979 984 }, 980 985 integrationView: { 981 981 - type: "object", 986 986 + type: 'object', 982 987 properties: { 983 988 id: { 984 984 - type: "string", 985 985 - description: "Unique identifier of the integration.", 989 989 + type: 'string', 990 990 + description: 'Unique identifier of the integration.', 986 991 }, 987 992 name: { 988 988 - type: "string", 993 993 + type: 'string', 989 994 description: 990 995 "The name of the integration, e.g. 'GitHub', 'Slack', 'Trello', etc.", 991 996 }, 992 997 webhookUrl: { 993 993 - type: "string", 994 994 - description: "The webhook URL of the integration.", 995 995 - format: "uri", 998 998 + type: 'string', 999 999 + description: 'The webhook URL of the integration.', 1000 1000 + format: 'uri', 996 1001 }, 997 1002 createdAt: { 998 998 - type: "string", 999 999 - description: "The timestamp when the integration was created.", 1000 1000 - format: "datetime", 1003 1003 + type: 'string', 1004 1004 + description: 'The timestamp when the integration was created.', 1005 1005 + format: 'datetime', 1001 1006 }, 1002 1007 updatedAt: { 1003 1003 - type: "string", 1004 1004 - description: "The timestamp when the integration was last updated.", 1005 1005 - format: "datetime", 1008 1008 + type: 'string', 1009 1009 + description: 'The timestamp when the integration was last updated.', 1010 1010 + format: 'datetime', 1006 1011 }, 1007 1012 }, 1008 1013 }, 1009 1014 integrationsView: { 1010 1010 - type: "array", 1015 1015 + type: 'array', 1011 1016 items: { 1012 1012 - type: "ref", 1013 1013 - description: "An integration connected to the sandbox", 1014 1014 - ref: "lex:io.pocketenv.sandbox.defs#integrationView", 1017 1017 + type: 'ref', 1018 1018 + description: 'An integration connected to the sandbox', 1019 1019 + ref: 'lex:io.pocketenv.sandbox.defs#integrationView', 1015 1020 }, 1016 1021 }, 1017 1022 }, 1018 1023 }, 1019 1024 IoPocketenvSandboxDeleteSandbox: { 1020 1025 lexicon: 1, 1021 1021 - id: "io.pocketenv.sandbox.deleteSandbox", 1026 1026 + id: 'io.pocketenv.sandbox.deleteSandbox', 1022 1027 defs: { 1023 1028 main: { 1024 1024 - type: "procedure", 1025 1025 - description: "Delete a sandbox by uri", 1029 1029 + type: 'procedure', 1030 1030 + description: 'Delete a sandbox by uri', 1026 1031 parameters: { 1027 1027 - type: "params", 1028 1028 - required: ["id"], 1032 1032 + type: 'params', 1033 1033 + required: ['id'], 1029 1034 properties: { 1030 1035 id: { 1031 1031 - type: "string", 1032 1032 - description: "The sandbox ID.", 1036 1036 + type: 'string', 1037 1037 + description: 'The sandbox ID.', 1033 1038 }, 1034 1039 }, 1035 1040 }, 1036 1041 output: { 1037 1037 - encoding: "application/json", 1042 1042 + encoding: 'application/json', 1038 1043 schema: { 1039 1039 - type: "ref", 1040 1040 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1044 1044 + type: 'ref', 1045 1045 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1041 1046 }, 1042 1047 }, 1043 1048 }, ··· 1045 1050 }, 1046 1051 IoPocketenvSandboxExec: { 1047 1052 lexicon: 1, 1048 1048 - id: "io.pocketenv.sandbox.exec", 1053 1053 + id: 'io.pocketenv.sandbox.exec', 1049 1054 defs: { 1050 1055 main: { 1051 1051 - type: "procedure", 1052 1052 - description: "Execute a command in a sandbox.", 1056 1056 + type: 'procedure', 1057 1057 + description: 'Execute a command in a sandbox.', 1053 1058 parameters: { 1054 1054 - type: "params", 1055 1055 - required: ["id"], 1059 1059 + type: 'params', 1060 1060 + required: ['id'], 1056 1061 properties: { 1057 1062 id: { 1058 1058 - type: "string", 1059 1059 - description: "The sandbox ID.", 1063 1063 + type: 'string', 1064 1064 + description: 'The sandbox ID.', 1060 1065 }, 1061 1066 }, 1062 1067 }, 1063 1068 input: { 1064 1064 - encoding: "application/json", 1069 1069 + encoding: 'application/json', 1065 1070 schema: { 1066 1066 - type: "object", 1067 1067 - required: ["command"], 1071 1071 + type: 'object', 1072 1072 + required: ['command'], 1068 1073 properties: { 1069 1074 command: { 1070 1070 - type: "string", 1071 1071 - description: "The command to execute in the sandbox.", 1075 1075 + type: 'string', 1076 1076 + description: 'The command to execute in the sandbox.', 1072 1077 }, 1073 1078 }, 1074 1079 }, 1075 1080 }, 1076 1081 output: { 1077 1077 - encoding: "application/json", 1082 1082 + encoding: 'application/json', 1078 1083 schema: { 1079 1079 - type: "object", 1084 1084 + type: 'object', 1080 1085 properties: { 1081 1086 stdout: { 1082 1082 - type: "string", 1083 1083 - description: "The output of the executed command.", 1087 1087 + type: 'string', 1088 1088 + description: 'The output of the executed command.', 1084 1089 }, 1085 1090 stderr: { 1086 1086 - type: "string", 1091 1091 + type: 'string', 1087 1092 description: 1088 1088 - "The error output of the executed command, if any.", 1093 1093 + 'The error output of the executed command, if any.', 1089 1094 }, 1090 1095 exitCode: { 1091 1091 - type: "integer", 1092 1092 - description: "The exit code of the executed command.", 1096 1096 + type: 'integer', 1097 1097 + description: 'The exit code of the executed command.', 1093 1098 }, 1094 1099 }, 1095 1100 }, ··· 1099 1104 }, 1100 1105 IoPocketenvSandboxExposePort: { 1101 1106 lexicon: 1, 1102 1102 - id: "io.pocketenv.sandbox.exposePort", 1107 1107 + id: 'io.pocketenv.sandbox.exposePort', 1103 1108 defs: { 1104 1109 main: { 1105 1105 - type: "procedure", 1106 1106 - description: "Expose a port for a sandbox.", 1110 1110 + type: 'procedure', 1111 1111 + description: 'Expose a port for a sandbox.', 1107 1112 parameters: { 1108 1108 - type: "params", 1109 1109 - required: ["id"], 1113 1113 + type: 'params', 1114 1114 + required: ['id'], 1110 1115 properties: { 1111 1116 id: { 1112 1112 - type: "string", 1113 1113 - description: "The sandbox ID.", 1117 1117 + type: 'string', 1118 1118 + description: 'The sandbox ID.', 1114 1119 }, 1115 1120 }, 1116 1121 }, 1117 1122 input: { 1118 1118 - encoding: "application/json", 1123 1123 + encoding: 'application/json', 1119 1124 schema: { 1120 1120 - type: "object", 1121 1121 - required: ["port"], 1125 1125 + type: 'object', 1126 1126 + required: ['port'], 1122 1127 properties: { 1123 1128 port: { 1124 1124 - type: "integer", 1125 1125 - description: "The port number to expose.", 1129 1129 + type: 'integer', 1130 1130 + description: 'The port number to expose.', 1126 1131 maximum: 65535, 1127 1132 minimum: 1025, 1128 1133 }, 1129 1134 description: { 1130 1130 - type: "string", 1131 1131 - description: "A description of the port.", 1135 1135 + type: 'string', 1136 1136 + description: 'A description of the port.', 1132 1137 }, 1133 1138 }, 1134 1139 }, 1135 1140 }, 1136 1141 output: { 1137 1137 - encoding: "application/json", 1142 1142 + encoding: 'application/json', 1138 1143 schema: { 1139 1139 - type: "object", 1140 1140 - nullable: ["previewUrl"], 1144 1144 + type: 'object', 1145 1145 + nullable: ['previewUrl'], 1141 1146 properties: { 1142 1147 previewUrl: { 1143 1143 - type: "string", 1144 1144 - description: "The preview URL for the exposed port.", 1148 1148 + type: 'string', 1149 1149 + description: 'The preview URL for the exposed port.', 1145 1150 }, 1146 1151 }, 1147 1152 }, ··· 1151 1156 }, 1152 1157 IoPocketenvSandboxExposeVscode: { 1153 1158 lexicon: 1, 1154 1154 - id: "io.pocketenv.sandbox.exposeVscode", 1159 1159 + id: 'io.pocketenv.sandbox.exposeVscode', 1155 1160 defs: { 1156 1161 main: { 1157 1157 - type: "procedure", 1162 1162 + type: 'procedure', 1158 1163 description: 1159 1159 - "Expose an instance of VS Code for a sandbox. This allows users to access a web-based version of VS Code that is connected to their sandbox environment, enabling them to edit code, manage files, and perform other development tasks directly from their browser.", 1164 1164 + 'Expose an instance of VS Code for a sandbox. This allows users to access a web-based version of VS Code that is connected to their sandbox environment, enabling them to edit code, manage files, and perform other development tasks directly from their browser.', 1160 1165 parameters: { 1161 1161 - type: "params", 1162 1162 - required: ["id"], 1166 1166 + type: 'params', 1167 1167 + required: ['id'], 1163 1168 properties: { 1164 1169 id: { 1165 1165 - type: "string", 1166 1166 - description: "The sandbox ID.", 1170 1170 + type: 'string', 1171 1171 + description: 'The sandbox ID.', 1167 1172 }, 1168 1173 }, 1169 1174 }, 1170 1175 output: { 1171 1171 - encoding: "application/json", 1176 1176 + encoding: 'application/json', 1172 1177 schema: { 1173 1173 - type: "object", 1174 1174 - nullable: ["previewUrl"], 1178 1178 + type: 'object', 1179 1179 + nullable: ['previewUrl'], 1175 1180 properties: { 1176 1181 previewUrl: { 1177 1177 - type: "string", 1178 1178 - description: "The preview URL for the exposed port.", 1182 1182 + type: 'string', 1183 1183 + description: 'The preview URL for the exposed port.', 1179 1184 }, 1180 1185 }, 1181 1186 }, ··· 1185 1190 }, 1186 1191 IoPocketenvSandboxGetExposedPorts: { 1187 1192 lexicon: 1, 1188 1188 - id: "io.pocketenv.sandbox.getExposedPorts", 1193 1193 + id: 'io.pocketenv.sandbox.getExposedPorts', 1189 1194 defs: { 1190 1195 main: { 1191 1191 - type: "query", 1192 1192 - description: "Get the list of exposed ports for a sandbox.", 1196 1196 + type: 'query', 1197 1197 + description: 'Get the list of exposed ports for a sandbox.', 1193 1198 parameters: { 1194 1194 - type: "params", 1195 1195 - required: ["id"], 1199 1199 + type: 'params', 1200 1200 + required: ['id'], 1196 1201 properties: { 1197 1202 id: { 1198 1198 - type: "string", 1199 1199 - description: "The sandbox ID.", 1203 1203 + type: 'string', 1204 1204 + description: 'The sandbox ID.', 1200 1205 }, 1201 1206 }, 1202 1207 }, 1203 1208 output: { 1204 1204 - encoding: "application/json", 1209 1209 + encoding: 'application/json', 1205 1210 schema: { 1206 1206 - type: "object", 1211 1211 + type: 'object', 1207 1212 properties: { 1208 1213 ports: { 1209 1209 - type: "array", 1214 1214 + type: 'array', 1210 1215 items: { 1211 1211 - type: "ref", 1212 1212 - ref: "lex:io.pocketenv.port.defs#portView", 1216 1216 + type: 'ref', 1217 1217 + ref: 'lex:io.pocketenv.port.defs#portView', 1213 1218 }, 1214 1219 }, 1215 1220 }, ··· 1220 1225 }, 1221 1226 IoPocketenvSandboxGetIntegrations: { 1222 1227 lexicon: 1, 1223 1223 - id: "io.pocketenv.sandbox.getIntegrations", 1228 1228 + id: 'io.pocketenv.sandbox.getIntegrations', 1224 1229 defs: { 1225 1230 main: { 1226 1226 - type: "query", 1227 1227 - description: "Get the integrations for a sandbox.", 1231 1231 + type: 'query', 1232 1232 + description: 'Get the integrations for a sandbox.', 1228 1233 parameters: { 1229 1229 - type: "params", 1230 1230 - required: ["id"], 1234 1234 + type: 'params', 1235 1235 + required: ['id'], 1231 1236 properties: { 1232 1237 id: { 1233 1233 - type: "string", 1234 1234 - description: "The sandbox ID.", 1238 1238 + type: 'string', 1239 1239 + description: 'The sandbox ID.', 1235 1240 }, 1236 1241 }, 1237 1242 }, 1238 1243 output: { 1239 1239 - encoding: "application/json", 1244 1244 + encoding: 'application/json', 1240 1245 schema: { 1241 1241 - type: "ref", 1242 1242 - ref: "lex:io.pocketenv.sandbox.defs#integrationsView", 1246 1246 + type: 'ref', 1247 1247 + ref: 'lex:io.pocketenv.sandbox.defs#integrationsView', 1243 1248 }, 1244 1249 }, 1245 1250 }, ··· 1247 1252 }, 1248 1253 IoPocketenvSandboxGetPreferences: { 1249 1254 lexicon: 1, 1250 1250 - id: "io.pocketenv.sandbox.getPreferences", 1255 1255 + id: 'io.pocketenv.sandbox.getPreferences', 1251 1256 defs: { 1252 1257 main: { 1253 1253 - type: "query", 1254 1254 - description: "Get sandbox preferences", 1258 1258 + type: 'query', 1259 1259 + description: 'Get sandbox preferences', 1255 1260 parameters: { 1256 1256 - type: "params", 1257 1257 - required: ["id"], 1261 1261 + type: 'params', 1262 1262 + required: ['id'], 1258 1263 properties: { 1259 1264 id: { 1260 1260 - type: "string", 1261 1261 - description: "The sandbox ID or URI to retrieve", 1265 1265 + type: 'string', 1266 1266 + description: 'The sandbox ID or URI to retrieve', 1262 1267 }, 1263 1268 }, 1264 1269 }, 1265 1270 output: { 1266 1266 - encoding: "application/json", 1271 1271 + encoding: 'application/json', 1267 1272 schema: { 1268 1268 - type: "ref", 1269 1269 - ref: "lex:io.pocketenv.sandbox.defs#preferences", 1273 1273 + type: 'ref', 1274 1274 + ref: 'lex:io.pocketenv.sandbox.defs#preferences', 1270 1275 }, 1271 1276 }, 1272 1277 }, ··· 1274 1279 }, 1275 1280 IoPocketenvSandboxGetSandbox: { 1276 1281 lexicon: 1, 1277 1277 - id: "io.pocketenv.sandbox.getSandbox", 1282 1282 + id: 'io.pocketenv.sandbox.getSandbox', 1278 1283 defs: { 1279 1284 main: { 1280 1280 - type: "query", 1281 1281 - description: "Get a sandbox by ID or URI", 1285 1285 + type: 'query', 1286 1286 + description: 'Get a sandbox by ID or URI', 1282 1287 parameters: { 1283 1283 - type: "params", 1284 1284 - required: ["id"], 1288 1288 + type: 'params', 1289 1289 + required: ['id'], 1285 1290 properties: { 1286 1291 id: { 1287 1287 - type: "string", 1288 1288 - description: "The sandbox ID or URI to retrieve", 1292 1292 + type: 'string', 1293 1293 + description: 'The sandbox ID or URI to retrieve', 1289 1294 }, 1290 1295 }, 1291 1296 }, 1292 1297 output: { 1293 1293 - encoding: "application/json", 1298 1298 + encoding: 'application/json', 1294 1299 schema: { 1295 1295 - type: "ref", 1296 1296 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1300 1300 + type: 'ref', 1301 1301 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1297 1302 }, 1298 1303 }, 1299 1304 }, ··· 1301 1306 }, 1302 1307 IoPocketenvSandboxGetSandboxes: { 1303 1308 lexicon: 1, 1304 1304 - id: "io.pocketenv.sandbox.getSandboxes", 1309 1309 + id: 'io.pocketenv.sandbox.getSandboxes', 1305 1310 defs: { 1306 1311 main: { 1307 1307 - type: "query", 1308 1308 - description: "Get all sandboxes", 1312 1312 + type: 'query', 1313 1313 + description: 'Get all sandboxes', 1309 1314 parameters: { 1310 1310 - type: "params", 1315 1315 + type: 'params', 1311 1316 properties: { 1312 1317 limit: { 1313 1313 - type: "integer", 1314 1314 - description: "The maximum number of sandboxes to return.", 1318 1318 + type: 'integer', 1319 1319 + description: 'The maximum number of sandboxes to return.', 1315 1320 minimum: 1, 1316 1321 }, 1317 1322 offset: { 1318 1318 - type: "integer", 1323 1323 + type: 'integer', 1319 1324 description: 1320 1320 - "The number of sandboxes to skip before starting to collect the result set.", 1325 1325 + 'The number of sandboxes to skip before starting to collect the result set.', 1321 1326 minimum: 0, 1322 1327 }, 1323 1328 }, 1324 1329 }, 1325 1330 output: { 1326 1326 - encoding: "application/json", 1331 1331 + encoding: 'application/json', 1327 1332 schema: { 1328 1328 - type: "object", 1333 1333 + type: 'object', 1329 1334 properties: { 1330 1335 sandboxes: { 1331 1331 - type: "array", 1336 1336 + type: 'array', 1332 1337 items: { 1333 1333 - type: "ref", 1334 1334 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1338 1338 + type: 'ref', 1339 1339 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1335 1340 }, 1336 1341 }, 1337 1342 total: { 1338 1338 - type: "integer", 1339 1339 - description: "The total number of sandboxes available.", 1343 1343 + type: 'integer', 1344 1344 + description: 'The total number of sandboxes available.', 1340 1345 minimum: 0, 1341 1346 }, 1342 1347 }, ··· 1347 1352 }, 1348 1353 IoPocketenvSandboxGetSshKeys: { 1349 1354 lexicon: 1, 1350 1350 - id: "io.pocketenv.sandbox.getSshKeys", 1355 1355 + id: 'io.pocketenv.sandbox.getSshKeys', 1351 1356 defs: { 1352 1357 main: { 1353 1353 - type: "query", 1354 1354 - description: "Get the SSH keys for a sandbox.", 1358 1358 + type: 'query', 1359 1359 + description: 'Get the SSH keys for a sandbox.', 1355 1360 parameters: { 1356 1356 - type: "params", 1357 1357 - required: ["id"], 1361 1361 + type: 'params', 1362 1362 + required: ['id'], 1358 1363 properties: { 1359 1364 id: { 1360 1360 - type: "string", 1361 1361 - description: "The sandbox ID.", 1365 1365 + type: 'string', 1366 1366 + description: 'The sandbox ID.', 1362 1367 }, 1363 1368 }, 1364 1369 }, 1365 1370 output: { 1366 1366 - encoding: "application/json", 1371 1371 + encoding: 'application/json', 1367 1372 schema: { 1368 1368 - type: "ref", 1369 1369 - ref: "lex:io.pocketenv.sandbox.defs#sshKeysView", 1373 1373 + type: 'ref', 1374 1374 + ref: 'lex:io.pocketenv.sandbox.defs#sshKeysView', 1370 1375 }, 1371 1376 }, 1372 1377 }, ··· 1374 1379 }, 1375 1380 IoPocketenvSandboxGetTailscaleAuthKey: { 1376 1381 lexicon: 1, 1377 1377 - id: "io.pocketenv.sandbox.getTailscaleAuthKey", 1382 1382 + id: 'io.pocketenv.sandbox.getTailscaleAuthKey', 1378 1383 defs: { 1379 1384 main: { 1380 1380 - type: "query", 1381 1381 - description: "Get the Tailscale token for a sandbox.", 1385 1385 + type: 'query', 1386 1386 + description: 'Get the Tailscale token for a sandbox.', 1382 1387 parameters: { 1383 1383 - type: "params", 1384 1384 - required: ["id"], 1388 1388 + type: 'params', 1389 1389 + required: ['id'], 1385 1390 properties: { 1386 1391 id: { 1387 1387 - type: "string", 1388 1388 - description: "The sandbox ID.", 1392 1392 + type: 'string', 1393 1393 + description: 'The sandbox ID.', 1389 1394 }, 1390 1395 }, 1391 1396 }, 1392 1397 output: { 1393 1393 - encoding: "application/json", 1398 1398 + encoding: 'application/json', 1394 1399 schema: { 1395 1395 - type: "ref", 1396 1396 - ref: "lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView", 1400 1400 + type: 'ref', 1401 1401 + ref: 'lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView', 1397 1402 }, 1398 1403 }, 1399 1404 }, ··· 1401 1406 }, 1402 1407 IoPocketenvSandboxGetTailscaleToken: { 1403 1408 lexicon: 1, 1404 1404 - id: "io.pocketenv.sandbox.getTailscaleToken", 1409 1409 + id: 'io.pocketenv.sandbox.getTailscaleToken', 1405 1410 defs: { 1406 1411 main: { 1407 1407 - type: "query", 1408 1408 - description: "Get the Tailscale token for a sandbox.", 1412 1412 + type: 'query', 1413 1413 + description: 'Get the Tailscale token for a sandbox.', 1409 1414 parameters: { 1410 1410 - type: "params", 1411 1411 - required: ["id"], 1415 1415 + type: 'params', 1416 1416 + required: ['id'], 1412 1417 properties: { 1413 1418 id: { 1414 1414 - type: "string", 1415 1415 - description: "The sandbox ID.", 1419 1419 + type: 'string', 1420 1420 + description: 'The sandbox ID.', 1416 1421 }, 1417 1422 }, 1418 1423 }, 1419 1424 output: { 1420 1420 - encoding: "application/json", 1425 1425 + encoding: 'application/json', 1421 1426 schema: { 1422 1422 - type: "ref", 1423 1423 - ref: "lex:io.pocketenv.sandbox.defs#tailscaleTokenView", 1427 1427 + type: 'ref', 1428 1428 + ref: 'lex:io.pocketenv.sandbox.defs#tailscaleTokenView', 1424 1429 }, 1425 1430 }, 1426 1431 }, ··· 1428 1433 }, 1429 1434 IoPocketenvSandboxPutPreferences: { 1430 1435 lexicon: 1, 1431 1431 - id: "io.pocketenv.sandbox.putPreferences", 1436 1436 + id: 'io.pocketenv.sandbox.putPreferences', 1432 1437 defs: { 1433 1438 main: { 1434 1434 - type: "procedure", 1435 1435 - description: "Update sandbox preferences.", 1439 1439 + type: 'procedure', 1440 1440 + description: 'Update sandbox preferences.', 1436 1441 input: { 1437 1437 - encoding: "application/json", 1442 1442 + encoding: 'application/json', 1438 1443 schema: { 1439 1439 - type: "object", 1440 1440 - required: ["sandboxId", "preferences"], 1444 1444 + type: 'object', 1445 1445 + required: ['sandboxId', 'preferences'], 1441 1446 properties: { 1442 1447 sandboxId: { 1443 1443 - type: "string", 1444 1444 - description: "The sandbox ID or URI", 1448 1448 + type: 'string', 1449 1449 + description: 'The sandbox ID or URI', 1445 1450 }, 1446 1451 preferences: { 1447 1447 - type: "ref", 1448 1448 - ref: "lex:io.pocketenv.sandbox.defs#preferences", 1452 1452 + type: 'ref', 1453 1453 + ref: 'lex:io.pocketenv.sandbox.defs#preferences', 1449 1454 }, 1450 1455 }, 1451 1456 }, ··· 1455 1460 }, 1456 1461 IoPocketenvSandboxPutSshKeys: { 1457 1462 lexicon: 1, 1458 1458 - id: "io.pocketenv.sandbox.putSshKeys", 1463 1463 + id: 'io.pocketenv.sandbox.putSshKeys', 1459 1464 defs: { 1460 1465 main: { 1461 1461 - type: "procedure", 1462 1462 - description: "Add or update SSH keys for a sandbox.", 1466 1466 + type: 'procedure', 1467 1467 + description: 'Add or update SSH keys for a sandbox.', 1463 1468 input: { 1464 1464 - encoding: "application/json", 1469 1469 + encoding: 'application/json', 1465 1470 schema: { 1466 1466 - type: "object", 1467 1467 - required: ["id", "privateKey", "publicKey"], 1471 1471 + type: 'object', 1472 1472 + required: ['id', 'privateKey', 'publicKey'], 1468 1473 properties: { 1469 1474 id: { 1470 1470 - type: "string", 1471 1471 - description: "The sandbox ID.", 1475 1475 + type: 'string', 1476 1476 + description: 'The sandbox ID.', 1472 1477 }, 1473 1478 privateKey: { 1474 1474 - type: "string", 1475 1475 - description: "The private SSH key (encrypted)", 1479 1479 + type: 'string', 1480 1480 + description: 'The private SSH key (encrypted)', 1476 1481 }, 1477 1482 publicKey: { 1478 1478 - type: "string", 1479 1479 - description: "The public SSH key.", 1483 1483 + type: 'string', 1484 1484 + description: 'The public SSH key.', 1480 1485 }, 1481 1486 redacted: { 1482 1482 - type: "string", 1483 1483 - description: "The redacted SSH key.", 1487 1487 + type: 'string', 1488 1488 + description: 'The redacted SSH key.', 1484 1489 }, 1485 1490 }, 1486 1491 }, 1487 1492 }, 1488 1493 output: { 1489 1489 - encoding: "application/json", 1494 1494 + encoding: 'application/json', 1490 1495 schema: { 1491 1491 - type: "ref", 1492 1492 - ref: "lex:io.pocketenv.sandbox.defs#sshKeysView", 1496 1496 + type: 'ref', 1497 1497 + ref: 'lex:io.pocketenv.sandbox.defs#sshKeysView', 1493 1498 }, 1494 1499 }, 1495 1500 }, ··· 1497 1502 }, 1498 1503 IoPocketenvSandboxPutTailscaleAuthKey: { 1499 1504 lexicon: 1, 1500 1500 - id: "io.pocketenv.sandbox.putTailscaleAuthKey", 1505 1505 + id: 'io.pocketenv.sandbox.putTailscaleAuthKey', 1501 1506 defs: { 1502 1507 main: { 1503 1503 - type: "procedure", 1508 1508 + type: 'procedure', 1504 1509 description: 1505 1510 "Store a Tailscale Auth Key for the sandbox. This Auth Key will be used to authenticate with the Tailscale API and manage the sandbox's Tailscale node.", 1506 1511 input: { 1507 1507 - encoding: "application/json", 1512 1512 + encoding: 'application/json', 1508 1513 schema: { 1509 1509 - type: "object", 1510 1510 - required: ["id", "authKey"], 1514 1514 + type: 'object', 1515 1515 + required: ['id', 'authKey'], 1511 1516 properties: { 1512 1517 id: { 1513 1513 - type: "string", 1514 1514 - description: "The sandbox ID.", 1518 1518 + type: 'string', 1519 1519 + description: 'The sandbox ID.', 1515 1520 }, 1516 1521 authKey: { 1517 1517 - type: "string", 1522 1522 + type: 'string', 1518 1523 description: 1519 1519 - "The Tailscale Auth Key (encrypted) to store for the sandbox.", 1524 1524 + 'The Tailscale Auth Key (encrypted) to store for the sandbox.', 1520 1525 }, 1521 1526 redacted: { 1522 1522 - type: "string", 1523 1523 - description: "The redacted SSH key.", 1527 1527 + type: 'string', 1528 1528 + description: 'The redacted SSH key.', 1524 1529 }, 1525 1530 }, 1526 1531 }, 1527 1532 }, 1528 1533 output: { 1529 1529 - encoding: "application/json", 1534 1534 + encoding: 'application/json', 1530 1535 schema: { 1531 1531 - type: "ref", 1532 1532 - ref: "lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView", 1536 1536 + type: 'ref', 1537 1537 + ref: 'lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView', 1533 1538 }, 1534 1539 }, 1535 1540 }, ··· 1537 1542 }, 1538 1543 IoPocketenvSandboxPutTailscaleToken: { 1539 1544 lexicon: 1, 1540 1540 - id: "io.pocketenv.sandbox.putTailscaleToken", 1545 1545 + id: 'io.pocketenv.sandbox.putTailscaleToken', 1541 1546 defs: { 1542 1547 main: { 1543 1543 - type: "procedure", 1548 1548 + type: 'procedure', 1544 1549 description: 1545 1550 "Store a Tailscale token for the sandbox. This token will be used to authenticate with the Tailscale API and manage the sandbox's Tailscale node.", 1546 1551 input: { 1547 1547 - encoding: "application/json", 1552 1552 + encoding: 'application/json', 1548 1553 schema: { 1549 1549 - type: "object", 1550 1550 - required: ["id", "token"], 1554 1554 + type: 'object', 1555 1555 + required: ['id', 'token'], 1551 1556 properties: { 1552 1557 id: { 1553 1553 - type: "string", 1554 1554 - description: "The sandbox ID.", 1558 1558 + type: 'string', 1559 1559 + description: 'The sandbox ID.', 1555 1560 }, 1556 1561 token: { 1557 1557 - type: "string", 1562 1562 + type: 'string', 1558 1563 description: 1559 1559 - "The Tailscale token (encrypted) to store for the sandbox.", 1564 1564 + 'The Tailscale token (encrypted) to store for the sandbox.', 1560 1565 }, 1561 1566 }, 1562 1567 }, 1563 1568 }, 1564 1569 output: { 1565 1565 - encoding: "application/json", 1570 1570 + encoding: 'application/json', 1566 1571 schema: { 1567 1567 - type: "ref", 1568 1568 - ref: "lex:io.pocketenv.sandbox.defs#tailscaleTokenView", 1572 1572 + type: 'ref', 1573 1573 + ref: 'lex:io.pocketenv.sandbox.defs#tailscaleTokenView', 1569 1574 }, 1570 1575 }, 1571 1576 }, ··· 1573 1578 }, 1574 1579 IoPocketenvSandbox: { 1575 1580 lexicon: 1, 1576 1576 - id: "io.pocketenv.sandbox", 1581 1581 + id: 'io.pocketenv.sandbox', 1577 1582 defs: { 1578 1583 main: { 1579 1579 - type: "record", 1580 1580 - key: "tid", 1584 1584 + type: 'record', 1585 1585 + key: 'tid', 1581 1586 record: { 1582 1582 - type: "object", 1583 1583 - required: ["name", "createdAt"], 1587 1587 + type: 'object', 1588 1588 + required: ['name', 'createdAt'], 1584 1589 properties: { 1585 1590 name: { 1586 1586 - type: "string", 1587 1587 - description: "Name of the sandbox", 1591 1591 + type: 'string', 1592 1592 + description: 'Name of the sandbox', 1588 1593 maxLength: 255, 1589 1594 }, 1590 1595 base: { 1591 1591 - type: "ref", 1596 1596 + type: 'ref', 1592 1597 description: 1593 1593 - "A strong reference to the base template for the sandbox environment.", 1594 1594 - ref: "lex:com.atproto.repo.strongRef", 1598 1598 + 'A strong reference to the base template for the sandbox environment.', 1599 1599 + ref: 'lex:com.atproto.repo.strongRef', 1595 1600 }, 1596 1601 provider: { 1597 1597 - type: "string", 1602 1602 + type: 'string', 1598 1603 description: 1599 1604 "The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.", 1600 1605 maxLength: 50, 1601 1606 }, 1602 1607 description: { 1603 1603 - type: "string", 1608 1608 + type: 'string', 1604 1609 maxGraphemes: 300, 1605 1610 maxLength: 3000, 1606 1611 }, 1607 1612 website: { 1608 1608 - type: "string", 1609 1609 - description: "Any URI related to the sandbox", 1610 1610 - format: "uri", 1613 1613 + type: 'string', 1614 1614 + description: 'Any URI related to the sandbox', 1615 1615 + format: 'uri', 1611 1616 }, 1612 1617 logo: { 1613 1613 - type: "string", 1614 1614 - description: "URI to an image logo for the sandbox", 1615 1615 - format: "uri", 1618 1618 + type: 'string', 1619 1619 + description: 'URI to an image logo for the sandbox', 1620 1620 + format: 'uri', 1616 1621 }, 1617 1622 topics: { 1618 1618 - type: "array", 1623 1623 + type: 'array', 1619 1624 items: { 1620 1620 - type: "string", 1625 1625 + type: 'string', 1621 1626 minLength: 1, 1622 1627 maxLength: 50, 1623 1628 }, 1624 1629 maxLength: 50, 1625 1630 }, 1626 1631 repo: { 1627 1627 - type: "string", 1632 1632 + type: 'string', 1628 1633 description: 1629 1629 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 1634 1634 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 1630 1635 }, 1631 1636 readme: { 1632 1632 - type: "string", 1633 1633 - description: "A URI to a README for the sandbox.", 1634 1634 - format: "uri", 1637 1637 + type: 'string', 1638 1638 + description: 'A URI to a README for the sandbox.', 1639 1639 + format: 'uri', 1635 1640 }, 1636 1641 vcpus: { 1637 1637 - type: "integer", 1638 1638 - description: "Number of virtual CPUs allocated to the sandbox", 1642 1642 + type: 'integer', 1643 1643 + description: 'Number of virtual CPUs allocated to the sandbox', 1639 1644 }, 1640 1645 memory: { 1641 1641 - type: "integer", 1642 1642 - description: "Amount of memory in GB allocated to the sandbox", 1646 1646 + type: 'integer', 1647 1647 + description: 'Amount of memory in GB allocated to the sandbox', 1643 1648 }, 1644 1649 disk: { 1645 1645 - type: "integer", 1650 1650 + type: 'integer', 1646 1651 description: 1647 1647 - "Amount of disk space in GB allocated to the sandbox", 1652 1652 + 'Amount of disk space in GB allocated to the sandbox', 1648 1653 }, 1649 1654 volumes: { 1650 1650 - type: "array", 1655 1655 + type: 'array', 1651 1656 items: { 1652 1652 - type: "string", 1657 1657 + type: 'string', 1653 1658 description: 1654 1659 "A path to be mounted as a volume in the sandbox, e.g. '/data', '/logs', etc.", 1655 1660 }, 1656 1661 }, 1657 1662 ports: { 1658 1658 - type: "array", 1663 1663 + type: 'array', 1659 1664 items: { 1660 1660 - type: "integer", 1665 1665 + type: 'integer', 1661 1666 description: 1662 1662 - "A port number that is exposed by the sandbox environment.", 1667 1667 + 'A port number that is exposed by the sandbox environment.', 1663 1668 }, 1664 1669 }, 1665 1670 secrets: { 1666 1666 - type: "array", 1671 1671 + type: 'array', 1667 1672 items: { 1668 1668 - type: "string", 1673 1673 + type: 'string', 1669 1674 description: 1670 1670 - "Name of a secret to be added to the sandbox environment. Secrets are typically encrypted and stored securely, and can be used to store sensitive information such as API keys, database credentials, etc.", 1675 1675 + 'Name of a secret to be added to the sandbox environment. Secrets are typically encrypted and stored securely, and can be used to store sensitive information such as API keys, database credentials, etc.', 1671 1676 }, 1672 1677 }, 1673 1678 envs: { 1674 1674 - type: "array", 1679 1679 + type: 'array', 1675 1680 items: { 1676 1676 - type: "string", 1681 1681 + type: 'string', 1677 1682 description: 1678 1678 - "Name of an environment variable to be added to the sandbox environment.", 1683 1683 + 'Name of an environment variable to be added to the sandbox environment.', 1679 1684 }, 1680 1685 }, 1681 1686 createdAt: { 1682 1682 - type: "string", 1683 1683 - format: "datetime", 1687 1687 + type: 'string', 1688 1688 + format: 'datetime', 1684 1689 }, 1685 1690 }, 1686 1691 }, ··· 1689 1694 }, 1690 1695 IoPocketenvSandboxStartSandbox: { 1691 1696 lexicon: 1, 1692 1692 - id: "io.pocketenv.sandbox.startSandbox", 1697 1697 + id: 'io.pocketenv.sandbox.startSandbox', 1693 1698 defs: { 1694 1699 main: { 1695 1695 - type: "procedure", 1696 1696 - description: "Start a sandbox", 1700 1700 + type: 'procedure', 1701 1701 + description: 'Start a sandbox', 1697 1702 parameters: { 1698 1698 - type: "params", 1699 1699 - required: ["id"], 1703 1703 + type: 'params', 1704 1704 + required: ['id'], 1700 1705 properties: { 1701 1706 id: { 1702 1702 - type: "string", 1703 1703 - description: "The sandbox ID.", 1707 1707 + type: 'string', 1708 1708 + description: 'The sandbox ID.', 1704 1709 }, 1705 1710 }, 1706 1711 }, 1707 1712 input: { 1708 1708 - encoding: "application/json", 1713 1713 + encoding: 'application/json', 1709 1714 schema: { 1710 1710 - type: "object", 1715 1715 + type: 'object', 1711 1716 properties: { 1712 1717 repo: { 1713 1713 - type: "string", 1718 1718 + type: 'string', 1714 1719 description: 1715 1715 - "The git repository URL to clone into the sandbox before starting it. Optional.", 1720 1720 + 'The git repository URL to clone into the sandbox before starting it. Optional.', 1721 1721 + }, 1722 1722 + keepAlive: { 1723 1723 + type: 'boolean', 1724 1724 + description: 1725 1725 + 'Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs.', 1716 1726 }, 1717 1727 }, 1718 1728 }, 1719 1729 }, 1720 1730 output: { 1721 1721 - encoding: "application/json", 1731 1731 + encoding: 'application/json', 1722 1732 schema: { 1723 1723 - type: "ref", 1724 1724 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1733 1733 + type: 'ref', 1734 1734 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1725 1735 }, 1726 1736 }, 1727 1737 }, ··· 1729 1739 }, 1730 1740 IoPocketenvSandboxStopSandbox: { 1731 1741 lexicon: 1, 1732 1732 - id: "io.pocketenv.sandbox.stopSandbox", 1742 1742 + id: 'io.pocketenv.sandbox.stopSandbox', 1733 1743 defs: { 1734 1744 main: { 1735 1735 - type: "procedure", 1736 1736 - description: "Stop a sandbox", 1745 1745 + type: 'procedure', 1746 1746 + description: 'Stop a sandbox', 1737 1747 parameters: { 1738 1738 - type: "params", 1739 1739 - required: ["id"], 1748 1748 + type: 'params', 1749 1749 + required: ['id'], 1740 1750 properties: { 1741 1751 id: { 1742 1742 - type: "string", 1743 1743 - description: "The sandbox ID.", 1752 1752 + type: 'string', 1753 1753 + description: 'The sandbox ID.', 1744 1754 }, 1745 1755 }, 1746 1756 }, 1747 1757 output: { 1748 1748 - encoding: "application/json", 1758 1758 + encoding: 'application/json', 1749 1759 schema: { 1750 1750 - type: "ref", 1751 1751 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1760 1760 + type: 'ref', 1761 1761 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1752 1762 }, 1753 1763 }, 1754 1764 }, ··· 1756 1766 }, 1757 1767 IoPocketenvSandboxUnexposePort: { 1758 1768 lexicon: 1, 1759 1759 - id: "io.pocketenv.sandbox.unexposePort", 1769 1769 + id: 'io.pocketenv.sandbox.unexposePort', 1760 1770 defs: { 1761 1771 main: { 1762 1762 - type: "procedure", 1763 1763 - description: "Unexpose a port for a sandbox.", 1772 1772 + type: 'procedure', 1773 1773 + description: 'Unexpose a port for a sandbox.', 1764 1774 parameters: { 1765 1765 - type: "params", 1766 1766 - required: ["id"], 1775 1775 + type: 'params', 1776 1776 + required: ['id'], 1767 1777 properties: { 1768 1778 id: { 1769 1769 - type: "string", 1770 1770 - description: "The sandbox ID.", 1779 1779 + type: 'string', 1780 1780 + description: 'The sandbox ID.', 1771 1781 }, 1772 1782 }, 1773 1783 }, 1774 1784 input: { 1775 1775 - encoding: "application/json", 1785 1785 + encoding: 'application/json', 1776 1786 schema: { 1777 1777 - type: "object", 1778 1778 - required: ["port"], 1787 1787 + type: 'object', 1788 1788 + required: ['port'], 1779 1789 properties: { 1780 1790 port: { 1781 1781 - type: "integer", 1782 1782 - description: "The port number to unexpose.", 1791 1791 + type: 'integer', 1792 1792 + description: 'The port number to unexpose.', 1783 1793 maximum: 65535, 1784 1794 minimum: 1024, 1785 1795 }, ··· 1791 1801 }, 1792 1802 IoPocketenvSandboxUpdateSandboxSettings: { 1793 1803 lexicon: 1, 1794 1794 - id: "io.pocketenv.sandbox.updateSandboxSettings", 1804 1804 + id: 'io.pocketenv.sandbox.updateSandboxSettings', 1795 1805 defs: { 1796 1806 main: { 1797 1797 - type: "procedure", 1798 1798 - description: "Update sandbox settings", 1807 1807 + type: 'procedure', 1808 1808 + description: 'Update sandbox settings', 1799 1809 input: { 1800 1800 - encoding: "application/json", 1810 1810 + encoding: 'application/json', 1801 1811 schema: { 1802 1802 - type: "object", 1812 1812 + type: 'object', 1803 1813 properties: { 1804 1814 name: { 1805 1805 - type: "string", 1806 1806 - description: "The name of the sandbox", 1815 1815 + type: 'string', 1816 1816 + description: 'The name of the sandbox', 1807 1817 minLength: 1, 1808 1818 }, 1809 1819 description: { 1810 1810 - type: "string", 1811 1811 - description: "A description for the sandbox", 1820 1820 + type: 'string', 1821 1821 + description: 'A description for the sandbox', 1812 1822 }, 1813 1823 topics: { 1814 1814 - type: "array", 1824 1824 + type: 'array', 1815 1825 description: 1816 1816 - "A list of topics/tags to associate with the sandbox", 1826 1826 + 'A list of topics/tags to associate with the sandbox', 1817 1827 items: { 1818 1818 - type: "string", 1828 1828 + type: 'string', 1819 1829 maxLength: 50, 1820 1830 }, 1821 1831 }, 1822 1832 repo: { 1823 1823 - type: "string", 1833 1833 + type: 'string', 1824 1834 description: 1825 1825 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 1826 1826 - format: "uri", 1835 1835 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 1836 1836 + format: 'uri', 1827 1837 }, 1828 1838 vcpus: { 1829 1829 - type: "integer", 1839 1839 + type: 'integer', 1830 1840 description: 1831 1831 - "The number of virtual CPUs to allocate for the sandbox", 1841 1841 + 'The number of virtual CPUs to allocate for the sandbox', 1832 1842 minimum: 1, 1833 1843 }, 1834 1844 memory: { 1835 1835 - type: "integer", 1845 1845 + type: 'integer', 1836 1846 description: 1837 1837 - "The amount of memory (in GB) to allocate for the sandbox", 1847 1847 + 'The amount of memory (in GB) to allocate for the sandbox', 1838 1848 minimum: 1, 1839 1849 }, 1840 1850 disk: { 1841 1841 - type: "integer", 1851 1851 + type: 'integer', 1842 1852 description: 1843 1843 - "The amount of disk space (in GB) to allocate for the sandbox", 1853 1853 + 'The amount of disk space (in GB) to allocate for the sandbox', 1844 1854 minimum: 3, 1845 1855 }, 1846 1856 readme: { 1847 1847 - type: "string", 1848 1848 - description: "A URI to a README for the sandbox.", 1849 1849 - format: "uri", 1857 1857 + type: 'string', 1858 1858 + description: 'A URI to a README for the sandbox.', 1859 1859 + format: 'uri', 1850 1860 }, 1851 1861 secrets: { 1852 1852 - type: "ref", 1853 1853 - description: "A list of secrets to add to the sandbox", 1854 1854 - ref: "lex:io.pocketenv.secret.defs#secrets", 1862 1862 + type: 'ref', 1863 1863 + description: 'A list of secrets to add to the sandbox', 1864 1864 + ref: 'lex:io.pocketenv.secret.defs#secrets', 1855 1865 }, 1856 1866 variables: { 1857 1857 - type: "ref", 1867 1867 + type: 'ref', 1858 1868 description: 1859 1859 - "A list of environment variables to add to the sandbox", 1860 1860 - ref: "lex:io.pocketenv.variable.defs#variables", 1869 1869 + 'A list of environment variables to add to the sandbox', 1870 1870 + ref: 'lex:io.pocketenv.variable.defs#variables', 1861 1871 }, 1862 1872 files: { 1863 1863 - type: "ref", 1864 1864 - description: "A list of files to add to the sandbox", 1865 1865 - ref: "lex:io.pocketenv.file.defs#file", 1873 1873 + type: 'ref', 1874 1874 + description: 'A list of files to add to the sandbox', 1875 1875 + ref: 'lex:io.pocketenv.file.defs#file', 1866 1876 }, 1867 1877 volumes: { 1868 1868 - type: "ref", 1869 1869 - description: "A list of volumes to add to the sandbox", 1870 1870 - ref: "lex:io.pocketenv.volume.defs#volumes", 1878 1878 + type: 'ref', 1879 1879 + description: 'A list of volumes to add to the sandbox', 1880 1880 + ref: 'lex:io.pocketenv.volume.defs#volumes', 1871 1881 }, 1872 1882 }, 1873 1883 }, 1874 1884 }, 1875 1885 output: { 1876 1876 - encoding: "application/json", 1886 1886 + encoding: 'application/json', 1877 1887 schema: { 1878 1878 - type: "ref", 1879 1879 - ref: "lex:io.pocketenv.sandbox.defs#profileViewDetailed", 1888 1888 + type: 'ref', 1889 1889 + ref: 'lex:io.pocketenv.sandbox.defs#profileViewDetailed', 1880 1890 }, 1881 1891 }, 1882 1892 }, ··· 1884 1894 }, 1885 1895 IoPocketenvSecretAddSecret: { 1886 1896 lexicon: 1, 1887 1887 - id: "io.pocketenv.secret.addSecret", 1897 1897 + id: 'io.pocketenv.secret.addSecret', 1888 1898 defs: { 1889 1899 main: { 1890 1890 - type: "procedure", 1900 1900 + type: 'procedure', 1891 1901 input: { 1892 1892 - encoding: "application/json", 1902 1902 + encoding: 'application/json', 1893 1903 schema: { 1894 1894 - type: "object", 1895 1895 - required: ["secret"], 1904 1904 + type: 'object', 1905 1905 + required: ['secret'], 1896 1906 properties: { 1897 1907 secret: { 1898 1898 - type: "ref", 1899 1899 - ref: "lex:io.pocketenv.secret.defs#secret", 1908 1908 + type: 'ref', 1909 1909 + ref: 'lex:io.pocketenv.secret.defs#secret', 1900 1910 }, 1901 1911 redacted: { 1902 1902 - type: "string", 1903 1903 - description: "The redacted secret value.", 1912 1912 + type: 'string', 1913 1913 + description: 'The redacted secret value.', 1904 1914 }, 1905 1915 }, 1906 1916 }, ··· 1910 1920 }, 1911 1921 IoPocketenvSecretDefs: { 1912 1922 lexicon: 1, 1913 1913 - id: "io.pocketenv.secret.defs", 1923 1923 + id: 'io.pocketenv.secret.defs', 1914 1924 defs: { 1915 1925 secretView: { 1916 1916 - type: "object", 1926 1926 + type: 'object', 1917 1927 properties: { 1918 1928 id: { 1919 1919 - type: "string", 1920 1920 - description: "Unique identifier of the secret.", 1929 1929 + type: 'string', 1930 1930 + description: 'Unique identifier of the secret.', 1921 1931 }, 1922 1932 name: { 1923 1923 - type: "string", 1933 1933 + type: 'string', 1924 1934 description: 1925 1935 "Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc.", 1926 1936 }, 1927 1937 }, 1928 1938 }, 1929 1939 secret: { 1930 1930 - type: "object", 1931 1931 - required: ["name", "value"], 1940 1940 + type: 'object', 1941 1941 + required: ['name', 'value'], 1932 1942 properties: { 1933 1943 sandboxId: { 1934 1934 - type: "string", 1944 1944 + type: 'string', 1935 1945 description: 1936 1936 - "The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment.", 1946 1946 + 'The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment.', 1937 1947 }, 1938 1948 name: { 1939 1939 - type: "string", 1949 1949 + type: 'string', 1940 1950 description: 1941 1951 "Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc.", 1942 1952 }, 1943 1953 value: { 1944 1944 - type: "string", 1954 1954 + type: 'string', 1945 1955 description: 1946 1946 - "Value of the secret. This will be encrypted at rest and redacted in any API responses.", 1956 1956 + 'Value of the secret. This will be encrypted at rest and redacted in any API responses.', 1947 1957 }, 1948 1958 }, 1949 1959 }, 1950 1960 secrets: { 1951 1951 - type: "array", 1961 1961 + type: 'array', 1952 1962 items: { 1953 1953 - type: "ref", 1954 1954 - description: "A secret to add to the sandbox", 1955 1955 - ref: "lex:io.pocketenv.secret.defs#secret", 1963 1963 + type: 'ref', 1964 1964 + description: 'A secret to add to the sandbox', 1965 1965 + ref: 'lex:io.pocketenv.secret.defs#secret', 1956 1966 }, 1957 1967 }, 1958 1968 }, 1959 1969 }, 1960 1970 IoPocketenvSecretDeleteSecret: { 1961 1971 lexicon: 1, 1962 1962 - id: "io.pocketenv.secret.deleteSecret", 1972 1972 + id: 'io.pocketenv.secret.deleteSecret', 1963 1973 defs: { 1964 1974 main: { 1965 1965 - type: "procedure", 1975 1975 + type: 'procedure', 1966 1976 parameters: { 1967 1967 - type: "params", 1968 1968 - required: ["id"], 1977 1977 + type: 'params', 1978 1978 + required: ['id'], 1969 1979 properties: { 1970 1980 id: { 1971 1971 - type: "string", 1972 1972 - description: "The ID of the secret to delete", 1981 1981 + type: 'string', 1982 1982 + description: 'The ID of the secret to delete', 1973 1983 }, 1974 1984 }, 1975 1985 }, ··· 1978 1988 }, 1979 1989 IoPocketenvSecretGetSecret: { 1980 1990 lexicon: 1, 1981 1981 - id: "io.pocketenv.secret.getSecret", 1991 1991 + id: 'io.pocketenv.secret.getSecret', 1982 1992 defs: { 1983 1993 main: { 1984 1984 - type: "query", 1994 1994 + type: 'query', 1985 1995 parameters: { 1986 1986 - type: "params", 1987 1987 - required: ["id"], 1996 1996 + type: 'params', 1997 1997 + required: ['id'], 1988 1998 properties: { 1989 1999 id: { 1990 1990 - type: "string", 2000 2000 + type: 'string', 1991 2001 description: 1992 1992 - "The ID of the secret for which to retrieve secrets.", 2002 2002 + 'The ID of the secret for which to retrieve secrets.', 1993 2003 }, 1994 2004 }, 1995 2005 }, 1996 2006 output: { 1997 1997 - encoding: "application/json", 2007 2007 + encoding: 'application/json', 1998 2008 schema: { 1999 1999 - type: "object", 2009 2009 + type: 'object', 2000 2010 properties: { 2001 2011 secret: { 2002 2002 - type: "ref", 2003 2003 - ref: "lex:io.pocketenv.secret.defs#secretView", 2012 2012 + type: 'ref', 2013 2013 + ref: 'lex:io.pocketenv.secret.defs#secretView', 2004 2014 }, 2005 2015 }, 2006 2016 }, ··· 2010 2020 }, 2011 2021 IoPocketenvSecretGetSecrets: { 2012 2022 lexicon: 1, 2013 2013 - id: "io.pocketenv.secret.getSecrets", 2023 2023 + id: 'io.pocketenv.secret.getSecrets', 2014 2024 defs: { 2015 2025 main: { 2016 2016 - type: "query", 2026 2026 + type: 'query', 2017 2027 parameters: { 2018 2018 - type: "params", 2028 2028 + type: 'params', 2019 2029 properties: { 2020 2030 sandboxId: { 2021 2021 - type: "string", 2031 2031 + type: 'string', 2022 2032 description: 2023 2023 - "The ID of the sandbox for which to retrieve secrets.", 2033 2033 + 'The ID of the sandbox for which to retrieve secrets.', 2024 2034 }, 2025 2035 limit: { 2026 2026 - type: "integer", 2027 2027 - description: "The maximum number of secrets to return.", 2036 2036 + type: 'integer', 2037 2037 + description: 'The maximum number of secrets to return.', 2028 2038 minimum: 1, 2029 2039 }, 2030 2040 offset: { 2031 2031 - type: "integer", 2041 2041 + type: 'integer', 2032 2042 description: 2033 2033 - "The number of secrets to skip before starting to collect the result set.", 2043 2043 + 'The number of secrets to skip before starting to collect the result set.', 2034 2044 minimum: 0, 2035 2045 }, 2036 2046 }, 2037 2047 }, 2038 2048 output: { 2039 2039 - encoding: "application/json", 2049 2049 + encoding: 'application/json', 2040 2050 schema: { 2041 2041 - type: "object", 2051 2051 + type: 'object', 2042 2052 properties: { 2043 2053 secrets: { 2044 2044 - type: "array", 2054 2054 + type: 'array', 2045 2055 items: { 2046 2046 - type: "ref", 2047 2047 - ref: "lex:io.pocketenv.secret.defs#secretView", 2056 2056 + type: 'ref', 2057 2057 + ref: 'lex:io.pocketenv.secret.defs#secretView', 2048 2058 }, 2049 2059 }, 2050 2060 total: { 2051 2051 - type: "integer", 2052 2052 - description: "The total number of secrets available.", 2061 2061 + type: 'integer', 2062 2062 + description: 'The total number of secrets available.', 2053 2063 minimum: 0, 2054 2064 }, 2055 2065 }, ··· 2060 2070 }, 2061 2071 IoPocketenvSecretUpdateSecret: { 2062 2072 lexicon: 1, 2063 2063 - id: "io.pocketenv.secret.updateSecret", 2073 2073 + id: 'io.pocketenv.secret.updateSecret', 2064 2074 defs: { 2065 2075 main: { 2066 2066 - type: "procedure", 2076 2076 + type: 'procedure', 2067 2077 input: { 2068 2068 - encoding: "application/json", 2078 2078 + encoding: 'application/json', 2069 2079 schema: { 2070 2070 - type: "object", 2071 2071 - required: ["id", "secret"], 2080 2080 + type: 'object', 2081 2081 + required: ['id', 'secret'], 2072 2082 properties: { 2073 2083 id: { 2074 2074 - type: "string", 2075 2075 - description: "The ID of the secret to update.", 2084 2084 + type: 'string', 2085 2085 + description: 'The ID of the secret to update.', 2076 2086 }, 2077 2087 secret: { 2078 2078 - type: "ref", 2079 2079 - ref: "lex:io.pocketenv.secret.defs#secret", 2088 2088 + type: 'ref', 2089 2089 + ref: 'lex:io.pocketenv.secret.defs#secret', 2080 2090 }, 2081 2091 redacted: { 2082 2082 - type: "string", 2083 2083 - description: "The redacted secret value.", 2092 2092 + type: 'string', 2093 2093 + description: 'The redacted secret value.', 2084 2094 }, 2085 2095 }, 2086 2096 }, ··· 2090 2100 }, 2091 2101 IoPocketenvVariableAddVariable: { 2092 2102 lexicon: 1, 2093 2093 - id: "io.pocketenv.variable.addVariable", 2103 2103 + id: 'io.pocketenv.variable.addVariable', 2094 2104 defs: { 2095 2105 main: { 2096 2096 - type: "procedure", 2106 2106 + type: 'procedure', 2097 2107 input: { 2098 2098 - encoding: "application/json", 2108 2108 + encoding: 'application/json', 2099 2109 schema: { 2100 2100 - type: "object", 2101 2101 - required: ["variable"], 2110 2110 + type: 'object', 2111 2111 + required: ['variable'], 2102 2112 properties: { 2103 2113 variable: { 2104 2104 - type: "ref", 2105 2105 - ref: "lex:io.pocketenv.variable.defs#variable", 2114 2114 + type: 'ref', 2115 2115 + ref: 'lex:io.pocketenv.variable.defs#variable', 2106 2116 }, 2107 2117 }, 2108 2118 }, ··· 2112 2122 }, 2113 2123 IoPocketenvVariableDefs: { 2114 2124 lexicon: 1, 2115 2115 - id: "io.pocketenv.variable.defs", 2125 2125 + id: 'io.pocketenv.variable.defs', 2116 2126 defs: { 2117 2127 variableView: { 2118 2118 - type: "object", 2128 2128 + type: 'object', 2119 2129 properties: { 2120 2130 id: { 2121 2121 - type: "string", 2122 2122 - description: "Unique identifier of the environment variable.", 2131 2131 + type: 'string', 2132 2132 + description: 'Unique identifier of the environment variable.', 2123 2133 }, 2124 2134 name: { 2125 2125 - type: "string", 2135 2135 + type: 'string', 2126 2136 description: 2127 2137 "Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc.", 2128 2138 }, 2129 2139 value: { 2130 2130 - type: "string", 2140 2140 + type: 'string', 2131 2141 description: 2132 2132 - "Value of the environment variable. This will be visible in API responses and should not contain sensitive information.", 2142 2142 + 'Value of the environment variable. This will be visible in API responses and should not contain sensitive information.', 2133 2143 }, 2134 2144 }, 2135 2145 }, 2136 2146 variable: { 2137 2137 - type: "object", 2138 2138 - required: ["name", "value"], 2147 2147 + type: 'object', 2148 2148 + required: ['name', 'value'], 2139 2149 properties: { 2140 2150 sandboxId: { 2141 2141 - type: "string", 2151 2151 + type: 'string', 2142 2152 description: 2143 2143 - "The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment.", 2153 2153 + 'The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment.', 2144 2154 }, 2145 2155 name: { 2146 2146 - type: "string", 2156 2156 + type: 'string', 2147 2157 description: 2148 2158 "Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc.", 2149 2159 }, 2150 2160 value: { 2151 2151 - type: "string", 2161 2161 + type: 'string', 2152 2162 description: 2153 2153 - "Value of the environment variable. This will be visible in API responses and should not contain sensitive information.", 2163 2163 + 'Value of the environment variable. This will be visible in API responses and should not contain sensitive information.', 2154 2164 }, 2155 2165 }, 2156 2166 }, 2157 2167 variables: { 2158 2158 - type: "array", 2168 2168 + type: 'array', 2159 2169 items: { 2160 2160 - type: "ref", 2161 2161 - description: "An environment variable to add to the sandbox", 2162 2162 - ref: "lex:io.pocketenv.variable.defs#envVar", 2170 2170 + type: 'ref', 2171 2171 + description: 'An environment variable to add to the sandbox', 2172 2172 + ref: 'lex:io.pocketenv.variable.defs#envVar', 2163 2173 }, 2164 2174 }, 2165 2175 }, 2166 2176 }, 2167 2177 IoPocketenvVariableDeleteVariable: { 2168 2178 lexicon: 1, 2169 2169 - id: "io.pocketenv.variable.deleteVariable", 2179 2179 + id: 'io.pocketenv.variable.deleteVariable', 2170 2180 defs: { 2171 2181 main: { 2172 2172 - type: "procedure", 2182 2182 + type: 'procedure', 2173 2183 parameters: { 2174 2174 - type: "params", 2175 2175 - required: ["id"], 2184 2184 + type: 'params', 2185 2185 + required: ['id'], 2176 2186 properties: { 2177 2187 id: { 2178 2178 - type: "string", 2179 2179 - description: "The ID of the environment variable to delete", 2188 2188 + type: 'string', 2189 2189 + description: 'The ID of the environment variable to delete', 2180 2190 }, 2181 2191 }, 2182 2192 }, ··· 2185 2195 }, 2186 2196 IoPocketenvVariableGetVariable: { 2187 2197 lexicon: 1, 2188 2188 - id: "io.pocketenv.variable.getVariable", 2198 2198 + id: 'io.pocketenv.variable.getVariable', 2189 2199 defs: { 2190 2200 main: { 2191 2191 - type: "query", 2201 2201 + type: 'query', 2192 2202 parameters: { 2193 2193 - type: "params", 2194 2194 - required: ["id"], 2203 2203 + type: 'params', 2204 2204 + required: ['id'], 2195 2205 properties: { 2196 2206 id: { 2197 2197 - type: "string", 2207 2207 + type: 'string', 2198 2208 description: 2199 2199 - "The ID of the variable for which to retrieve variables.", 2209 2209 + 'The ID of the variable for which to retrieve variables.', 2200 2210 }, 2201 2211 }, 2202 2212 }, 2203 2213 output: { 2204 2204 - encoding: "application/json", 2214 2214 + encoding: 'application/json', 2205 2215 schema: { 2206 2206 - type: "object", 2216 2216 + type: 'object', 2207 2217 properties: { 2208 2218 variable: { 2209 2209 - type: "ref", 2210 2210 - ref: "lex:io.pocketenv.variable.defs#variableView", 2219 2219 + type: 'ref', 2220 2220 + ref: 'lex:io.pocketenv.variable.defs#variableView', 2211 2221 }, 2212 2222 }, 2213 2223 }, ··· 2217 2227 }, 2218 2228 IoPocketenvVariableGetVariables: { 2219 2229 lexicon: 1, 2220 2220 - id: "io.pocketenv.variable.getVariables", 2230 2230 + id: 'io.pocketenv.variable.getVariables', 2221 2231 defs: { 2222 2232 main: { 2223 2223 - type: "query", 2233 2233 + type: 'query', 2224 2234 parameters: { 2225 2225 - type: "params", 2235 2235 + type: 'params', 2226 2236 properties: { 2227 2237 sandboxId: { 2228 2228 - type: "string", 2238 2238 + type: 'string', 2229 2239 description: 2230 2230 - "The ID of the sandbox for which to retrieve variables.", 2240 2240 + 'The ID of the sandbox for which to retrieve variables.', 2231 2241 }, 2232 2242 limit: { 2233 2233 - type: "integer", 2234 2234 - description: "The maximum number of variables to return.", 2243 2243 + type: 'integer', 2244 2244 + description: 'The maximum number of variables to return.', 2235 2245 minimum: 1, 2236 2246 }, 2237 2247 offset: { 2238 2238 - type: "integer", 2248 2248 + type: 'integer', 2239 2249 description: 2240 2240 - "The number of variables to skip before starting to collect the result set.", 2250 2250 + 'The number of variables to skip before starting to collect the result set.', 2241 2251 minimum: 0, 2242 2252 }, 2243 2253 }, 2244 2254 }, 2245 2255 output: { 2246 2246 - encoding: "application/json", 2256 2256 + encoding: 'application/json', 2247 2257 schema: { 2248 2248 - type: "object", 2258 2258 + type: 'object', 2249 2259 properties: { 2250 2260 variables: { 2251 2251 - type: "array", 2261 2261 + type: 'array', 2252 2262 items: { 2253 2253 - type: "ref", 2254 2254 - ref: "lex:io.pocketenv.variable.defs#variableView", 2263 2263 + type: 'ref', 2264 2264 + ref: 'lex:io.pocketenv.variable.defs#variableView', 2255 2265 }, 2256 2266 }, 2257 2267 total: { 2258 2258 - type: "integer", 2259 2259 - description: "The total number of variables available.", 2268 2268 + type: 'integer', 2269 2269 + description: 'The total number of variables available.', 2260 2270 minimum: 0, 2261 2271 }, 2262 2272 }, ··· 2267 2277 }, 2268 2278 IoPocketenvVariableUpdateVariable: { 2269 2279 lexicon: 1, 2270 2270 - id: "io.pocketenv.variable.updateVariable", 2280 2280 + id: 'io.pocketenv.variable.updateVariable', 2271 2281 defs: { 2272 2282 main: { 2273 2273 - type: "procedure", 2283 2283 + type: 'procedure', 2274 2284 input: { 2275 2275 - encoding: "application/json", 2285 2285 + encoding: 'application/json', 2276 2286 schema: { 2277 2277 - type: "object", 2278 2278 - required: ["id", "variable"], 2287 2287 + type: 'object', 2288 2288 + required: ['id', 'variable'], 2279 2289 properties: { 2280 2290 id: { 2281 2281 - type: "string", 2282 2282 - description: "The ID of the variable to update.", 2291 2291 + type: 'string', 2292 2292 + description: 'The ID of the variable to update.', 2283 2293 }, 2284 2294 variable: { 2285 2285 - type: "ref", 2286 2286 - ref: "lex:io.pocketenv.variable.defs#variable", 2295 2295 + type: 'ref', 2296 2296 + ref: 'lex:io.pocketenv.variable.defs#variable', 2287 2297 }, 2288 2298 }, 2289 2299 }, ··· 2293 2303 }, 2294 2304 IoPocketenvVolumeAddVolume: { 2295 2305 lexicon: 1, 2296 2296 - id: "io.pocketenv.volume.addVolume", 2306 2306 + id: 'io.pocketenv.volume.addVolume', 2297 2307 defs: { 2298 2308 main: { 2299 2299 - type: "procedure", 2309 2309 + type: 'procedure', 2300 2310 input: { 2301 2301 - encoding: "application/json", 2311 2311 + encoding: 'application/json', 2302 2312 schema: { 2303 2303 - type: "object", 2304 2304 - required: ["volume"], 2313 2313 + type: 'object', 2314 2314 + required: ['volume'], 2305 2315 properties: { 2306 2316 volume: { 2307 2307 - type: "ref", 2308 2308 - ref: "lex:io.pocketenv.volume.defs#volume", 2317 2317 + type: 'ref', 2318 2318 + ref: 'lex:io.pocketenv.volume.defs#volume', 2309 2319 }, 2310 2320 }, 2311 2321 }, ··· 2315 2325 }, 2316 2326 IoPocketenvVolumeDefs: { 2317 2327 lexicon: 1, 2318 2318 - id: "io.pocketenv.volume.defs", 2328 2328 + id: 'io.pocketenv.volume.defs', 2319 2329 defs: { 2320 2330 volumeView: { 2321 2321 - type: "object", 2331 2331 + type: 'object', 2322 2332 properties: { 2323 2333 id: { 2324 2324 - type: "string", 2325 2325 - description: "Unique identifier of the volume.", 2334 2334 + type: 'string', 2335 2335 + description: 'Unique identifier of the volume.', 2326 2336 }, 2327 2337 name: { 2328 2328 - type: "string", 2338 2338 + type: 'string', 2329 2339 description: "Name of the volume, e.g. 'data-volume', 'logs', etc.", 2330 2340 }, 2331 2341 path: { 2332 2332 - type: "string", 2342 2342 + type: 'string', 2333 2343 description: 2334 2344 "The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc.", 2335 2345 }, 2336 2346 readOnly: { 2337 2337 - type: "boolean", 2347 2347 + type: 'boolean', 2338 2348 description: 2339 2339 - "Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).", 2349 2349 + 'Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).', 2340 2350 }, 2341 2351 createdAt: { 2342 2342 - type: "string", 2343 2343 - description: "The timestamp when the volume was created.", 2344 2344 - format: "datetime", 2352 2352 + type: 'string', 2353 2353 + description: 'The timestamp when the volume was created.', 2354 2354 + format: 'datetime', 2345 2355 }, 2346 2356 updatedAt: { 2347 2347 - type: "string", 2348 2348 - description: "The timestamp when the volume was last updated.", 2349 2349 - format: "datetime", 2357 2357 + type: 'string', 2358 2358 + description: 'The timestamp when the volume was last updated.', 2359 2359 + format: 'datetime', 2350 2360 }, 2351 2361 }, 2352 2362 }, 2353 2363 volumes: { 2354 2354 - type: "array", 2364 2364 + type: 'array', 2355 2365 items: { 2356 2356 - type: "ref", 2357 2357 - description: "A volume to add to the sandbox", 2358 2358 - ref: "lex:io.pocketenv.volume.defs#volume", 2366 2366 + type: 'ref', 2367 2367 + description: 'A volume to add to the sandbox', 2368 2368 + ref: 'lex:io.pocketenv.volume.defs#volume', 2359 2369 }, 2360 2370 }, 2361 2371 volume: { 2362 2362 - type: "object", 2363 2363 - required: ["name"], 2372 2372 + type: 'object', 2373 2373 + required: ['name'], 2364 2374 properties: { 2365 2375 sandboxId: { 2366 2366 - type: "string", 2376 2376 + type: 'string', 2367 2377 description: 2368 2368 - "The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment.", 2378 2378 + 'The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment.', 2369 2379 }, 2370 2380 name: { 2371 2371 - type: "string", 2381 2381 + type: 'string', 2372 2382 description: "Name of the volume, e.g. 'data-volume', 'logs', etc.", 2373 2383 }, 2374 2384 path: { 2375 2375 - type: "string", 2385 2385 + type: 'string', 2376 2386 description: 2377 2387 "The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc.", 2378 2388 }, 2379 2389 readOnly: { 2380 2380 - type: "boolean", 2390 2390 + type: 'boolean', 2381 2391 description: 2382 2382 - "Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).", 2392 2392 + 'Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).', 2383 2393 }, 2384 2394 }, 2385 2395 }, ··· 2387 2397 }, 2388 2398 IoPocketenvVolumeDeleteVolume: { 2389 2399 lexicon: 1, 2390 2390 - id: "io.pocketenv.volume.deleteVolume", 2400 2400 + id: 'io.pocketenv.volume.deleteVolume', 2391 2401 defs: { 2392 2402 main: { 2393 2393 - type: "procedure", 2403 2403 + type: 'procedure', 2394 2404 parameters: { 2395 2395 - type: "params", 2396 2396 - required: ["id"], 2405 2405 + type: 'params', 2406 2406 + required: ['id'], 2397 2407 properties: { 2398 2408 id: { 2399 2399 - type: "string", 2400 2400 - description: "The ID of the volume to delete.", 2409 2409 + type: 'string', 2410 2410 + description: 'The ID of the volume to delete.', 2401 2411 }, 2402 2412 }, 2403 2413 }, ··· 2406 2416 }, 2407 2417 IoPocketenvVolumeGetVolume: { 2408 2418 lexicon: 1, 2409 2409 - id: "io.pocketenv.volume.getVolume", 2419 2419 + id: 'io.pocketenv.volume.getVolume', 2410 2420 defs: { 2411 2421 main: { 2412 2412 - type: "query", 2422 2422 + type: 'query', 2413 2423 parameters: { 2414 2414 - type: "params", 2415 2415 - required: ["id"], 2424 2424 + type: 'params', 2425 2425 + required: ['id'], 2416 2426 properties: { 2417 2427 id: { 2418 2418 - type: "string", 2428 2428 + type: 'string', 2419 2429 description: 2420 2420 - "The ID of the volume for which to retrieve volumes.", 2430 2430 + 'The ID of the volume for which to retrieve volumes.', 2421 2431 }, 2422 2432 }, 2423 2433 }, 2424 2434 output: { 2425 2425 - encoding: "application/json", 2435 2435 + encoding: 'application/json', 2426 2436 schema: { 2427 2427 - type: "object", 2437 2437 + type: 'object', 2428 2438 properties: { 2429 2439 volume: { 2430 2430 - type: "ref", 2431 2431 - ref: "lex:io.pocketenv.volume.defs#volumeView", 2440 2440 + type: 'ref', 2441 2441 + ref: 'lex:io.pocketenv.volume.defs#volumeView', 2432 2442 }, 2433 2443 }, 2434 2444 }, ··· 2438 2448 }, 2439 2449 IoPocketenvVolumeGetVolumes: { 2440 2450 lexicon: 1, 2441 2441 - id: "io.pocketenv.volume.getVolumes", 2451 2451 + id: 'io.pocketenv.volume.getVolumes', 2442 2452 defs: { 2443 2453 main: { 2444 2444 - type: "query", 2454 2454 + type: 'query', 2445 2455 parameters: { 2446 2446 - type: "params", 2456 2456 + type: 'params', 2447 2457 properties: { 2448 2458 sandboxId: { 2449 2449 - type: "string", 2459 2459 + type: 'string', 2450 2460 description: 2451 2451 - "The ID of the sandbox for which to retrieve volumes.", 2461 2461 + 'The ID of the sandbox for which to retrieve volumes.', 2452 2462 }, 2453 2463 limit: { 2454 2454 - type: "integer", 2455 2455 - description: "The maximum number of volumes to return.", 2464 2464 + type: 'integer', 2465 2465 + description: 'The maximum number of volumes to return.', 2456 2466 minimum: 1, 2457 2467 }, 2458 2468 offset: { 2459 2459 - type: "integer", 2469 2469 + type: 'integer', 2460 2470 description: 2461 2461 - "The number of volumes to skip before starting to collect the result set.", 2471 2471 + 'The number of volumes to skip before starting to collect the result set.', 2462 2472 minimum: 0, 2463 2473 }, 2464 2474 }, 2465 2475 }, 2466 2476 output: { 2467 2467 - encoding: "application/json", 2477 2477 + encoding: 'application/json', 2468 2478 schema: { 2469 2469 - type: "object", 2479 2479 + type: 'object', 2470 2480 properties: { 2471 2481 volumes: { 2472 2472 - type: "array", 2482 2482 + type: 'array', 2473 2483 items: { 2474 2474 - type: "ref", 2475 2475 - ref: "lex:io.pocketenv.volume.defs#volumeView", 2484 2484 + type: 'ref', 2485 2485 + ref: 'lex:io.pocketenv.volume.defs#volumeView', 2476 2486 }, 2477 2487 }, 2478 2488 total: { 2479 2479 - type: "integer", 2480 2480 - description: "The total number of volumes available.", 2489 2489 + type: 'integer', 2490 2490 + description: 'The total number of volumes available.', 2481 2491 minimum: 0, 2482 2492 }, 2483 2493 }, ··· 2488 2498 }, 2489 2499 IoPocketenvVolumeUpdateVolume: { 2490 2500 lexicon: 1, 2491 2491 - id: "io.pocketenv.volume.updateVolume", 2501 2501 + id: 'io.pocketenv.volume.updateVolume', 2492 2502 defs: { 2493 2503 main: { 2494 2494 - type: "procedure", 2504 2504 + type: 'procedure', 2495 2505 input: { 2496 2496 - encoding: "application/json", 2506 2506 + encoding: 'application/json', 2497 2507 schema: { 2498 2498 - type: "object", 2499 2499 - required: ["id", "volume"], 2508 2508 + type: 'object', 2509 2509 + required: ['id', 'volume'], 2500 2510 properties: { 2501 2511 id: { 2502 2502 - type: "string", 2503 2503 - description: "The ID of the volume to update.", 2512 2512 + type: 'string', 2513 2513 + description: 'The ID of the volume to update.', 2504 2514 }, 2505 2515 volume: { 2506 2506 - type: "ref", 2507 2507 - ref: "lex:io.pocketenv.volume.defs#volume", 2516 2516 + type: 'ref', 2517 2517 + ref: 'lex:io.pocketenv.volume.defs#volume', 2508 2518 }, 2509 2519 }, 2510 2520 }, ··· 2514 2524 }, 2515 2525 IoPocketenvPublicKey: { 2516 2526 lexicon: 1, 2517 2517 - id: "io.pocketenv.publicKey", 2527 2527 + id: 'io.pocketenv.publicKey', 2518 2528 defs: { 2519 2529 main: { 2520 2520 - type: "record", 2521 2521 - key: "tid", 2530 2530 + type: 'record', 2531 2531 + key: 'tid', 2522 2532 record: { 2523 2523 - type: "object", 2524 2524 - required: ["name", "key", "createdAt"], 2533 2533 + type: 'object', 2534 2534 + required: ['name', 'key', 'createdAt'], 2525 2535 properties: { 2526 2536 name: { 2527 2527 - type: "string", 2528 2528 - description: "Name of the public key", 2537 2537 + type: 'string', 2538 2538 + description: 'Name of the public key', 2529 2539 maxLength: 255, 2530 2540 }, 2531 2541 key: { 2532 2532 - type: "string", 2542 2542 + type: 'string', 2533 2543 description: 2534 2534 - "The public key value, e.g. an SSH public key string.", 2544 2544 + 'The public key value, e.g. an SSH public key string.', 2535 2545 }, 2536 2546 createdAt: { 2537 2537 - type: "string", 2538 2538 - format: "datetime", 2547 2547 + type: 'string', 2548 2548 + format: 'datetime', 2539 2549 }, 2540 2550 }, 2541 2551 }, ··· 2544 2554 }, 2545 2555 ComAtprotoRepoStrongRef: { 2546 2556 lexicon: 1, 2547 2547 - id: "com.atproto.repo.strongRef", 2548 2548 - description: "A URI with a content-hash fingerprint.", 2557 2557 + id: 'com.atproto.repo.strongRef', 2558 2558 + description: 'A URI with a content-hash fingerprint.', 2549 2559 defs: { 2550 2560 main: { 2551 2551 - type: "object", 2552 2552 - required: ["uri", "cid"], 2561 2561 + type: 'object', 2562 2562 + required: ['uri', 'cid'], 2553 2563 properties: { 2554 2564 uri: { 2555 2555 - type: "string", 2556 2556 - format: "at-uri", 2565 2565 + type: 'string', 2566 2566 + format: 'at-uri', 2557 2567 }, 2558 2568 cid: { 2559 2559 - type: "string", 2560 2560 - format: "cid", 2569 2569 + type: 'string', 2570 2570 + format: 'cid', 2561 2571 }, 2562 2572 }, 2563 2573 }, 2564 2574 }, 2565 2575 }, 2566 2566 - } as const satisfies Record<string, LexiconDoc>; 2576 2576 + } as const satisfies Record<string, LexiconDoc> 2567 2577 2568 2568 - export const schemas = Object.values(schemaDict); 2569 2569 - export const lexicons: Lexicons = new Lexicons(schemas); 2578 2578 + export const schemas = Object.values(schemaDict) 2579 2579 + export const lexicons: Lexicons = new Lexicons(schemas) 2570 2580 export const ids = { 2571 2571 - IoPocketenvActorDefs: "io.pocketenv.actor.defs", 2572 2572 - IoPocketenvActorGetActorSandboxes: "io.pocketenv.actor.getActorSandboxes", 2573 2573 - IoPocketenvActorGetProfile: "io.pocketenv.actor.getProfile", 2574 2574 - IoPocketenvActorGetTerminalToken: "io.pocketenv.actor.getTerminalToken", 2575 2575 - AppBskyActorProfile: "app.bsky.actor.profile", 2576 2576 - IoPocketenvFileAddFile: "io.pocketenv.file.addFile", 2577 2577 - IoPocketenvFileDefs: "io.pocketenv.file.defs", 2578 2578 - IoPocketenvFileDeleteFile: "io.pocketenv.file.deleteFile", 2579 2579 - IoPocketenvFileGetFile: "io.pocketenv.file.getFile", 2580 2580 - IoPocketenvFileGetFiles: "io.pocketenv.file.getFiles", 2581 2581 - IoPocketenvFileUpdateFile: "io.pocketenv.file.updateFile", 2582 2582 - IoPocketenvPortDefs: "io.pocketenv.port.defs", 2583 2583 - IoPocketenvSandboxClaimSandbox: "io.pocketenv.sandbox.claimSandbox", 2584 2584 - IoPocketenvSandboxCreateIntegration: "io.pocketenv.sandbox.createIntegration", 2585 2585 - IoPocketenvSandboxCreateSandbox: "io.pocketenv.sandbox.createSandbox", 2586 2586 - IoPocketenvSandboxDefs: "io.pocketenv.sandbox.defs", 2587 2587 - IoPocketenvSandboxDeleteSandbox: "io.pocketenv.sandbox.deleteSandbox", 2588 2588 - IoPocketenvSandboxExec: "io.pocketenv.sandbox.exec", 2589 2589 - IoPocketenvSandboxExposePort: "io.pocketenv.sandbox.exposePort", 2590 2590 - IoPocketenvSandboxExposeVscode: "io.pocketenv.sandbox.exposeVscode", 2591 2591 - IoPocketenvSandboxGetExposedPorts: "io.pocketenv.sandbox.getExposedPorts", 2592 2592 - IoPocketenvSandboxGetIntegrations: "io.pocketenv.sandbox.getIntegrations", 2593 2593 - IoPocketenvSandboxGetPreferences: "io.pocketenv.sandbox.getPreferences", 2594 2594 - IoPocketenvSandboxGetSandbox: "io.pocketenv.sandbox.getSandbox", 2595 2595 - IoPocketenvSandboxGetSandboxes: "io.pocketenv.sandbox.getSandboxes", 2596 2596 - IoPocketenvSandboxGetSshKeys: "io.pocketenv.sandbox.getSshKeys", 2581 2581 + IoPocketenvActorDefs: 'io.pocketenv.actor.defs', 2582 2582 + IoPocketenvActorGetActorSandboxes: 'io.pocketenv.actor.getActorSandboxes', 2583 2583 + IoPocketenvActorGetProfile: 'io.pocketenv.actor.getProfile', 2584 2584 + IoPocketenvActorGetTerminalToken: 'io.pocketenv.actor.getTerminalToken', 2585 2585 + AppBskyActorProfile: 'app.bsky.actor.profile', 2586 2586 + IoPocketenvFileAddFile: 'io.pocketenv.file.addFile', 2587 2587 + IoPocketenvFileDefs: 'io.pocketenv.file.defs', 2588 2588 + IoPocketenvFileDeleteFile: 'io.pocketenv.file.deleteFile', 2589 2589 + IoPocketenvFileGetFile: 'io.pocketenv.file.getFile', 2590 2590 + IoPocketenvFileGetFiles: 'io.pocketenv.file.getFiles', 2591 2591 + IoPocketenvFileUpdateFile: 'io.pocketenv.file.updateFile', 2592 2592 + IoPocketenvPortDefs: 'io.pocketenv.port.defs', 2593 2593 + IoPocketenvSandboxClaimSandbox: 'io.pocketenv.sandbox.claimSandbox', 2594 2594 + IoPocketenvSandboxCreateIntegration: 'io.pocketenv.sandbox.createIntegration', 2595 2595 + IoPocketenvSandboxCreateSandbox: 'io.pocketenv.sandbox.createSandbox', 2596 2596 + IoPocketenvSandboxDefs: 'io.pocketenv.sandbox.defs', 2597 2597 + IoPocketenvSandboxDeleteSandbox: 'io.pocketenv.sandbox.deleteSandbox', 2598 2598 + IoPocketenvSandboxExec: 'io.pocketenv.sandbox.exec', 2599 2599 + IoPocketenvSandboxExposePort: 'io.pocketenv.sandbox.exposePort', 2600 2600 + IoPocketenvSandboxExposeVscode: 'io.pocketenv.sandbox.exposeVscode', 2601 2601 + IoPocketenvSandboxGetExposedPorts: 'io.pocketenv.sandbox.getExposedPorts', 2602 2602 + IoPocketenvSandboxGetIntegrations: 'io.pocketenv.sandbox.getIntegrations', 2603 2603 + IoPocketenvSandboxGetPreferences: 'io.pocketenv.sandbox.getPreferences', 2604 2604 + IoPocketenvSandboxGetSandbox: 'io.pocketenv.sandbox.getSandbox', 2605 2605 + IoPocketenvSandboxGetSandboxes: 'io.pocketenv.sandbox.getSandboxes', 2606 2606 + IoPocketenvSandboxGetSshKeys: 'io.pocketenv.sandbox.getSshKeys', 2597 2607 IoPocketenvSandboxGetTailscaleAuthKey: 2598 2598 - "io.pocketenv.sandbox.getTailscaleAuthKey", 2599 2599 - IoPocketenvSandboxGetTailscaleToken: "io.pocketenv.sandbox.getTailscaleToken", 2600 2600 - IoPocketenvSandboxPutPreferences: "io.pocketenv.sandbox.putPreferences", 2601 2601 - IoPocketenvSandboxPutSshKeys: "io.pocketenv.sandbox.putSshKeys", 2608 2608 + 'io.pocketenv.sandbox.getTailscaleAuthKey', 2609 2609 + IoPocketenvSandboxGetTailscaleToken: 'io.pocketenv.sandbox.getTailscaleToken', 2610 2610 + IoPocketenvSandboxPutPreferences: 'io.pocketenv.sandbox.putPreferences', 2611 2611 + IoPocketenvSandboxPutSshKeys: 'io.pocketenv.sandbox.putSshKeys', 2602 2612 IoPocketenvSandboxPutTailscaleAuthKey: 2603 2603 - "io.pocketenv.sandbox.putTailscaleAuthKey", 2604 2604 - IoPocketenvSandboxPutTailscaleToken: "io.pocketenv.sandbox.putTailscaleToken", 2605 2605 - IoPocketenvSandbox: "io.pocketenv.sandbox", 2606 2606 - IoPocketenvSandboxStartSandbox: "io.pocketenv.sandbox.startSandbox", 2607 2607 - IoPocketenvSandboxStopSandbox: "io.pocketenv.sandbox.stopSandbox", 2608 2608 - IoPocketenvSandboxUnexposePort: "io.pocketenv.sandbox.unexposePort", 2613 2613 + 'io.pocketenv.sandbox.putTailscaleAuthKey', 2614 2614 + IoPocketenvSandboxPutTailscaleToken: 'io.pocketenv.sandbox.putTailscaleToken', 2615 2615 + IoPocketenvSandbox: 'io.pocketenv.sandbox', 2616 2616 + IoPocketenvSandboxStartSandbox: 'io.pocketenv.sandbox.startSandbox', 2617 2617 + IoPocketenvSandboxStopSandbox: 'io.pocketenv.sandbox.stopSandbox', 2618 2618 + IoPocketenvSandboxUnexposePort: 'io.pocketenv.sandbox.unexposePort', 2609 2619 IoPocketenvSandboxUpdateSandboxSettings: 2610 2610 - "io.pocketenv.sandbox.updateSandboxSettings", 2611 2611 - IoPocketenvSecretAddSecret: "io.pocketenv.secret.addSecret", 2612 2612 - IoPocketenvSecretDefs: "io.pocketenv.secret.defs", 2613 2613 - IoPocketenvSecretDeleteSecret: "io.pocketenv.secret.deleteSecret", 2614 2614 - IoPocketenvSecretGetSecret: "io.pocketenv.secret.getSecret", 2615 2615 - IoPocketenvSecretGetSecrets: "io.pocketenv.secret.getSecrets", 2616 2616 - IoPocketenvSecretUpdateSecret: "io.pocketenv.secret.updateSecret", 2617 2617 - IoPocketenvVariableAddVariable: "io.pocketenv.variable.addVariable", 2618 2618 - IoPocketenvVariableDefs: "io.pocketenv.variable.defs", 2619 2619 - IoPocketenvVariableDeleteVariable: "io.pocketenv.variable.deleteVariable", 2620 2620 - IoPocketenvVariableGetVariable: "io.pocketenv.variable.getVariable", 2621 2621 - IoPocketenvVariableGetVariables: "io.pocketenv.variable.getVariables", 2622 2622 - IoPocketenvVariableUpdateVariable: "io.pocketenv.variable.updateVariable", 2623 2623 - IoPocketenvVolumeAddVolume: "io.pocketenv.volume.addVolume", 2624 2624 - IoPocketenvVolumeDefs: "io.pocketenv.volume.defs", 2625 2625 - IoPocketenvVolumeDeleteVolume: "io.pocketenv.volume.deleteVolume", 2626 2626 - IoPocketenvVolumeGetVolume: "io.pocketenv.volume.getVolume", 2627 2627 - IoPocketenvVolumeGetVolumes: "io.pocketenv.volume.getVolumes", 2628 2628 - IoPocketenvVolumeUpdateVolume: "io.pocketenv.volume.updateVolume", 2629 2629 - IoPocketenvPublicKey: "io.pocketenv.publicKey", 2630 2630 - ComAtprotoRepoStrongRef: "com.atproto.repo.strongRef", 2631 2631 - }; 2620 2620 + 'io.pocketenv.sandbox.updateSandboxSettings', 2621 2621 + IoPocketenvSecretAddSecret: 'io.pocketenv.secret.addSecret', 2622 2622 + IoPocketenvSecretDefs: 'io.pocketenv.secret.defs', 2623 2623 + IoPocketenvSecretDeleteSecret: 'io.pocketenv.secret.deleteSecret', 2624 2624 + IoPocketenvSecretGetSecret: 'io.pocketenv.secret.getSecret', 2625 2625 + IoPocketenvSecretGetSecrets: 'io.pocketenv.secret.getSecrets', 2626 2626 + IoPocketenvSecretUpdateSecret: 'io.pocketenv.secret.updateSecret', 2627 2627 + IoPocketenvVariableAddVariable: 'io.pocketenv.variable.addVariable', 2628 2628 + IoPocketenvVariableDefs: 'io.pocketenv.variable.defs', 2629 2629 + IoPocketenvVariableDeleteVariable: 'io.pocketenv.variable.deleteVariable', 2630 2630 + IoPocketenvVariableGetVariable: 'io.pocketenv.variable.getVariable', 2631 2631 + IoPocketenvVariableGetVariables: 'io.pocketenv.variable.getVariables', 2632 2632 + IoPocketenvVariableUpdateVariable: 'io.pocketenv.variable.updateVariable', 2633 2633 + IoPocketenvVolumeAddVolume: 'io.pocketenv.volume.addVolume', 2634 2634 + IoPocketenvVolumeDefs: 'io.pocketenv.volume.defs', 2635 2635 + IoPocketenvVolumeDeleteVolume: 'io.pocketenv.volume.deleteVolume', 2636 2636 + IoPocketenvVolumeGetVolume: 'io.pocketenv.volume.getVolume', 2637 2637 + IoPocketenvVolumeGetVolumes: 'io.pocketenv.volume.getVolumes', 2638 2638 + IoPocketenvVolumeUpdateVolume: 'io.pocketenv.volume.updateVolume', 2639 2639 + IoPocketenvPublicKey: 'io.pocketenv.publicKey', 2640 2640 + ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef', 2641 2641 + }

+19 -19

apps/api/src/lexicon/types/app/bsky/actor/profile.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 8 8 - import type * as ComAtprotoLabelDefs from "../../../com/atproto/label/defs"; 9 9 - import type * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef"; 4 4 + import type { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 + import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs' 9 9 + import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef' 10 10 11 11 export interface Record { 12 12 - displayName?: string; 12 12 + displayName?: string 13 13 /** Free-form profile description text. */ 14 14 - description?: string; 14 14 + description?: string 15 15 /** Small image to be displayed next to posts from account. AKA, 'profile picture' */ 16 16 - avatar?: BlobRef; 16 16 + avatar?: BlobRef 17 17 /** Larger horizontal image to display behind profile view. */ 18 18 - banner?: BlobRef; 18 18 + banner?: BlobRef 19 19 labels?: 20 20 | ComAtprotoLabelDefs.SelfLabels 21 21 - | { $type: string; [k: string]: unknown }; 22 22 - joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main; 23 23 - createdAt?: string; 24 24 - [k: string]: unknown; 21 21 + | { $type: string; [k: string]: unknown } 22 22 + joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main 23 23 + createdAt?: string 24 24 + [k: string]: unknown 25 25 } 26 26 27 27 export function isRecord(v: unknown): v is Record { 28 28 return ( 29 29 isObj(v) && 30 30 - hasProp(v, "$type") && 31 31 - (v.$type === "app.bsky.actor.profile#main" || 32 32 - v.$type === "app.bsky.actor.profile") 33 33 - ); 30 30 + hasProp(v, '$type') && 31 31 + (v.$type === 'app.bsky.actor.profile#main' || 32 32 + v.$type === 'app.bsky.actor.profile') 33 33 + ) 34 34 } 35 35 36 36 export function validateRecord(v: unknown): ValidationResult { 37 37 - return lexicons.validate("app.bsky.actor.profile#main", v); 37 37 + return lexicons.validate('app.bsky.actor.profile#main', v) 38 38 }

+12 -12

apps/api/src/lexicon/types/com/atproto/repo/strongRef.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 9 9 export interface Main { 10 10 - uri: string; 11 11 - cid: string; 12 12 - [k: string]: unknown; 10 10 + uri: string 11 11 + cid: string 12 12 + [k: string]: unknown 13 13 } 14 14 15 15 export function isMain(v: unknown): v is Main { 16 16 return ( 17 17 isObj(v) && 18 18 - hasProp(v, "$type") && 19 19 - (v.$type === "com.atproto.repo.strongRef#main" || 20 20 - v.$type === "com.atproto.repo.strongRef") 21 21 - ); 18 18 + hasProp(v, '$type') && 19 19 + (v.$type === 'com.atproto.repo.strongRef#main' || 20 20 + v.$type === 'com.atproto.repo.strongRef') 21 21 + ) 22 22 } 23 23 24 24 export function validateMain(v: unknown): ValidationResult { 25 25 - return lexicons.validate("com.atproto.repo.strongRef#main", v); 25 25 + return lexicons.validate('com.atproto.repo.strongRef#main', v) 26 26 }

+16 -16

apps/api/src/lexicon/types/io/pocketenv/actor/defs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 9 9 export interface ProfileViewDetailed { 10 10 /** The unique identifier of the actor. */ 11 11 - id?: string; 11 11 + id?: string 12 12 /** The DID of the actor. */ 13 13 - did?: string; 13 13 + did?: string 14 14 /** The handle of the actor. */ 15 15 - handle?: string; 15 15 + handle?: string 16 16 /** The display name of the actor. */ 17 17 - displayName?: string; 17 17 + displayName?: string 18 18 /** The URL of the actor's avatar image. */ 19 19 - avatar?: string; 19 19 + avatar?: string 20 20 /** The date and time when the actor was created. */ 21 21 - createdAt?: string; 21 21 + createdAt?: string 22 22 /** The date and time when the actor was last updated. */ 23 23 - updatedAt?: string; 24 24 - [k: string]: unknown; 23 23 + updatedAt?: string 24 24 + [k: string]: unknown 25 25 } 26 26 27 27 export function isProfileViewDetailed(v: unknown): v is ProfileViewDetailed { 28 28 return ( 29 29 isObj(v) && 30 30 - hasProp(v, "$type") && 31 31 - v.$type === "io.pocketenv.actor.defs#profileViewDetailed" 32 32 - ); 30 30 + hasProp(v, '$type') && 31 31 + v.$type === 'io.pocketenv.actor.defs#profileViewDetailed' 32 32 + ) 33 33 } 34 34 35 35 export function validateProfileViewDetailed(v: unknown): ValidationResult { 36 36 - return lexicons.validate("io.pocketenv.actor.defs#profileViewDetailed", v); 36 36 + return lexicons.validate('io.pocketenv.actor.defs#profileViewDetailed', v) 37 37 }

+29 -29

apps/api/src/lexicon/types/io/pocketenv/actor/getActorSandboxes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "../sandbox/defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from '../sandbox/defs' 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did: string; 14 14 + did: string 15 15 /** The maximum number of sandboxes to return. */ 16 16 - limit?: number; 16 16 + limit?: number 17 17 /** The number of sandboxes to skip before starting to collect the result set. */ 18 18 - offset?: number; 18 18 + offset?: number 19 19 } 20 20 21 21 - export type InputSchema = undefined; 21 21 + export type InputSchema = undefined 22 22 23 23 export interface OutputSchema { 24 24 - sandboxes?: IoPocketenvSandboxDefs.SandboxViewDetailed[]; 24 24 + sandboxes?: IoPocketenvSandboxDefs.SandboxViewDetailed[] 25 25 /** The total number of sandboxes available. */ 26 26 - total?: number; 27 27 - [k: string]: unknown; 26 26 + total?: number 27 27 + [k: string]: unknown 28 28 } 29 29 30 30 - export type HandlerInput = undefined; 30 30 + export type HandlerInput = undefined 31 31 32 32 export interface HandlerSuccess { 33 33 - encoding: "application/json"; 34 34 - body: OutputSchema; 35 35 - headers?: { [key: string]: string }; 33 33 + encoding: 'application/json' 34 34 + body: OutputSchema 35 35 + headers?: { [key: string]: string } 36 36 } 37 37 38 38 export interface HandlerError { 39 39 - status: number; 40 40 - message?: string; 39 39 + status: number 40 40 + message?: string 41 41 } 42 42 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 44 44 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: express.Request; 49 49 - res: express.Response; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 45 45 + auth: HA 46 46 + params: QueryParams 47 47 + input: HandlerInput 48 48 + req: express.Request 49 49 + res: express.Response 50 50 + resetRouteRateLimits: () => Promise<void> 51 51 + } 52 52 export type Handler<HA extends HandlerAuth = never> = ( 53 53 ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 54 54 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/actor/getProfile.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvActorDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvActorDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did?: string; 14 14 + did?: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvActorDefs.ProfileViewDetailed; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvActorDefs.ProfileViewDetailed 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/actor/getTerminalToken.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 - export type QueryParams = {}; 11 11 + export type QueryParams = {} 12 12 13 13 - export type InputSchema = undefined; 13 13 + export type InputSchema = undefined 14 14 15 15 export interface OutputSchema { 16 16 /** An access token that can be used to authenticate with the terminal service. This token is typically short-lived and should be used immediately to establish a connection with the terminal. */ 17 17 - token?: string; 18 18 - [k: string]: unknown; 17 17 + token?: string 18 18 + [k: string]: unknown 19 19 } 20 20 21 21 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = undefined 22 22 23 23 export interface HandlerSuccess { 24 24 - encoding: "application/json"; 25 25 - body: OutputSchema; 26 26 - headers?: { [key: string]: string }; 24 24 + encoding: 'application/json' 25 25 + body: OutputSchema 26 26 + headers?: { [key: string]: string } 27 27 } 28 28 29 29 export interface HandlerError { 30 30 - status: number; 31 31 - message?: string; 30 30 + status: number 31 31 + message?: string 32 32 } 33 33 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 35 35 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: express.Request; 40 40 - res: express.Response; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 36 36 + auth: HA 37 37 + params: QueryParams 38 38 + input: HandlerInput 39 39 + req: express.Request 40 40 + res: express.Response 41 41 + resetRouteRateLimits: () => Promise<void> 42 42 + } 43 43 export type Handler<HA extends HandlerAuth = never> = ( 44 44 ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 45 45 + ) => Promise<HandlerOutput> | HandlerOutput

+23 -23

apps/api/src/lexicon/types/io/pocketenv/file/addFile.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvFileDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvFileDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 - file: IoPocketenvFileDefs.File; 16 16 - [k: string]: unknown; 15 15 + file: IoPocketenvFileDefs.File 16 16 + [k: string]: unknown 17 17 } 18 18 19 19 export interface HandlerInput { 20 20 - encoding: "application/json"; 21 21 - body: InputSchema; 20 20 + encoding: 'application/json' 21 21 + body: InputSchema 22 22 } 23 23 24 24 export interface HandlerError { 25 25 - status: number; 26 26 - message?: string; 25 25 + status: number 26 26 + message?: string 27 27 } 28 28 29 29 - export type HandlerOutput = HandlerError | void; 29 29 + export type HandlerOutput = HandlerError | void 30 30 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA; 32 32 - params: QueryParams; 33 33 - input: HandlerInput; 34 34 - req: express.Request; 35 35 - res: express.Response; 36 36 - resetRouteRateLimits: () => Promise<void>; 37 37 - }; 31 31 + auth: HA 32 32 + params: QueryParams 33 33 + input: HandlerInput 34 34 + req: express.Request 35 35 + res: express.Response 36 36 + resetRouteRateLimits: () => Promise<void> 37 37 + } 38 38 export type Handler<HA extends HandlerAuth = never> = ( 39 39 ctx: HandlerReqCtx<HA>, 40 40 - ) => Promise<HandlerOutput> | HandlerOutput; 40 40 + ) => Promise<HandlerOutput> | HandlerOutput

+21 -21

apps/api/src/lexicon/types/io/pocketenv/file/defs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 9 9 export interface File { 10 10 /** The ID of the sandbox to which the file belongs. This is used to associate the file with a specific sandbox environment. */ 11 11 - sandboxId?: string; 11 11 + sandboxId?: string 12 12 /** The file path within the sandbox, e.g. '/app/config.json', '/home/user/.ssh/id_rsa', etc. */ 13 13 - path: string; 13 13 + path: string 14 14 /** The content of the file. This will be written to the specified path within the sandbox. The content should be base64 encoded if it's binary data. */ 15 15 - content: string; 16 16 - [k: string]: unknown; 15 15 + content: string 16 16 + [k: string]: unknown 17 17 } 18 18 19 19 export function isFile(v: unknown): v is File { 20 20 return ( 21 21 - isObj(v) && hasProp(v, "$type") && v.$type === "io.pocketenv.file.defs#file" 22 22 - ); 21 21 + isObj(v) && hasProp(v, '$type') && v.$type === 'io.pocketenv.file.defs#file' 22 22 + ) 23 23 } 24 24 25 25 export function validateFile(v: unknown): ValidationResult { 26 26 - return lexicons.validate("io.pocketenv.file.defs#file", v); 26 26 + return lexicons.validate('io.pocketenv.file.defs#file', v) 27 27 } 28 28 29 29 export interface FileView { 30 30 /** Unique identifier of the file. */ 31 31 - id?: string; 31 31 + id?: string 32 32 /** The file path within the sandbox, e.g. '/app/config.json', '/home/user/.ssh/id_rsa', etc. */ 33 33 - path?: string; 33 33 + path?: string 34 34 /** The timestamp when the file was created. */ 35 35 - createdAt?: string; 35 35 + createdAt?: string 36 36 /** The timestamp when the file was last updated. */ 37 37 - updatedAt?: string; 38 38 - [k: string]: unknown; 37 37 + updatedAt?: string 38 38 + [k: string]: unknown 39 39 } 40 40 41 41 export function isFileView(v: unknown): v is FileView { 42 42 return ( 43 43 isObj(v) && 44 44 - hasProp(v, "$type") && 45 45 - v.$type === "io.pocketenv.file.defs#fileView" 46 46 - ); 44 44 + hasProp(v, '$type') && 45 45 + v.$type === 'io.pocketenv.file.defs#fileView' 46 46 + ) 47 47 } 48 48 49 49 export function validateFileView(v: unknown): ValidationResult { 50 50 - return lexicons.validate("io.pocketenv.file.defs#fileView", v); 50 50 + return lexicons.validate('io.pocketenv.file.defs#fileView', v) 51 51 } 52 52 53 53 - export type Files = File[]; 53 53 + export type Files = File[]

+20 -20

apps/api/src/lexicon/types/io/pocketenv/file/deleteFile.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 export interface QueryParams { 12 12 /** The ID of the file to delete */ 13 13 - id: string; 13 13 + id: string 14 14 } 15 15 16 16 - export type InputSchema = undefined; 17 17 - export type HandlerInput = undefined; 16 16 + export type InputSchema = undefined 17 17 + export type HandlerInput = undefined 18 18 19 19 export interface HandlerError { 20 20 - status: number; 21 21 - message?: string; 20 20 + status: number 21 21 + message?: string 22 22 } 23 23 24 24 - export type HandlerOutput = HandlerError | void; 24 24 + export type HandlerOutput = HandlerError | void 25 25 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 26 26 - auth: HA; 27 27 - params: QueryParams; 28 28 - input: HandlerInput; 29 29 - req: express.Request; 30 30 - res: express.Response; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 26 26 + auth: HA 27 27 + params: QueryParams 28 28 + input: HandlerInput 29 29 + req: express.Request 30 30 + res: express.Response 31 31 + resetRouteRateLimits: () => Promise<void> 32 32 + } 33 33 export type Handler<HA extends HandlerAuth = never> = ( 34 34 ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput; 35 35 + ) => Promise<HandlerOutput> | HandlerOutput

+26 -26

apps/api/src/lexicon/types/io/pocketenv/file/getFile.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvFileDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvFileDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the file to retrieve. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 17 17 + export type InputSchema = undefined 18 18 19 19 export interface OutputSchema { 20 20 - file?: IoPocketenvFileDefs.FileView; 21 21 - [k: string]: unknown; 20 20 + file?: IoPocketenvFileDefs.FileView 21 21 + [k: string]: unknown 22 22 } 23 23 24 24 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = undefined 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: "application/json"; 28 28 - body: OutputSchema; 29 29 - headers?: { [key: string]: string }; 27 27 + encoding: 'application/json' 28 28 + body: OutputSchema 29 29 + headers?: { [key: string]: string } 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number; 34 34 - message?: string; 33 33 + status: number 34 34 + message?: string 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: express.Request; 43 43 - res: express.Response; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 39 39 + auth: HA 40 40 + params: QueryParams 41 41 + input: HandlerInput 42 42 + req: express.Request 43 43 + res: express.Response 44 44 + resetRouteRateLimits: () => Promise<void> 45 45 + } 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 48 48 + ) => Promise<HandlerOutput> | HandlerOutput

+29 -29

apps/api/src/lexicon/types/io/pocketenv/file/getFiles.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvFileDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvFileDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the sandbox for which to retrieve files. */ 14 14 - sandboxId?: string; 14 14 + sandboxId?: string 15 15 /** The maximum number of files to return. */ 16 16 - limit?: number; 16 16 + limit?: number 17 17 /** The number of files to skip before starting to collect the result set. */ 18 18 - offset?: number; 18 18 + offset?: number 19 19 } 20 20 21 21 - export type InputSchema = undefined; 21 21 + export type InputSchema = undefined 22 22 23 23 export interface OutputSchema { 24 24 - files?: IoPocketenvFileDefs.FileView[]; 24 24 + files?: IoPocketenvFileDefs.FileView[] 25 25 /** The total number of files available. */ 26 26 - total?: number; 27 27 - [k: string]: unknown; 26 26 + total?: number 27 27 + [k: string]: unknown 28 28 } 29 29 30 30 - export type HandlerInput = undefined; 30 30 + export type HandlerInput = undefined 31 31 32 32 export interface HandlerSuccess { 33 33 - encoding: "application/json"; 34 34 - body: OutputSchema; 35 35 - headers?: { [key: string]: string }; 33 33 + encoding: 'application/json' 34 34 + body: OutputSchema 35 35 + headers?: { [key: string]: string } 36 36 } 37 37 38 38 export interface HandlerError { 39 39 - status: number; 40 40 - message?: string; 39 39 + status: number 40 40 + message?: string 41 41 } 42 42 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 44 44 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: express.Request; 49 49 - res: express.Response; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 45 45 + auth: HA 46 46 + params: QueryParams 47 47 + input: HandlerInput 48 48 + req: express.Request 49 49 + res: express.Response 50 50 + resetRouteRateLimits: () => Promise<void> 51 51 + } 52 52 export type Handler<HA extends HandlerAuth = never> = ( 53 53 ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 54 54 + ) => Promise<HandlerOutput> | HandlerOutput

+24 -24

apps/api/src/lexicon/types/io/pocketenv/file/updateFile.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvFileDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvFileDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The ID of the file to delete */ 16 16 - id: string; 17 17 - file: IoPocketenvFileDefs.File; 18 18 - [k: string]: unknown; 16 16 + id: string 17 17 + file: IoPocketenvFileDefs.File 18 18 + [k: string]: unknown 19 19 } 20 20 21 21 export interface HandlerInput { 22 22 - encoding: "application/json"; 23 23 - body: InputSchema; 22 22 + encoding: 'application/json' 23 23 + body: InputSchema 24 24 } 25 25 26 26 export interface HandlerError { 27 27 - status: number; 28 28 - message?: string; 27 27 + status: number 28 28 + message?: string 29 29 } 30 30 31 31 - export type HandlerOutput = HandlerError | void; 31 31 + export type HandlerOutput = HandlerError | void 32 32 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: express.Request; 37 37 - res: express.Response; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 33 33 + auth: HA 34 34 + params: QueryParams 35 35 + input: HandlerInput 36 36 + req: express.Request 37 37 + res: express.Response 38 38 + resetRouteRateLimits: () => Promise<void> 39 39 + } 40 40 export type Handler<HA extends HandlerAuth = never> = ( 41 41 ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 42 42 + ) => Promise<HandlerOutput> | HandlerOutput

+12 -12

apps/api/src/lexicon/types/io/pocketenv/port/defs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 9 9 /** A view of a port exposed by a sandbox. */ 10 10 export interface PortView { 11 11 /** The port number. */ 12 12 - port?: number; 12 12 + port?: number 13 13 /** A description of the port. */ 14 14 - description?: string; 14 14 + description?: string 15 15 /** A URL for previewing the service running on the port */ 16 16 - previewUrl?: string; 17 17 - [k: string]: unknown; 16 16 + previewUrl?: string 17 17 + [k: string]: unknown 18 18 } 19 19 20 20 export function isPortView(v: unknown): v is PortView { 21 21 return ( 22 22 isObj(v) && 23 23 - hasProp(v, "$type") && 24 24 - v.$type === "io.pocketenv.port.defs#portView" 25 25 - ); 23 23 + hasProp(v, '$type') && 24 24 + v.$type === 'io.pocketenv.port.defs#portView' 25 25 + ) 26 26 } 27 27 28 28 export function validatePortView(v: unknown): ValidationResult { 29 29 - return lexicons.validate("io.pocketenv.port.defs#portView", v); 29 29 + return lexicons.validate('io.pocketenv.port.defs#portView', v) 30 30 }

+13 -13

apps/api/src/lexicon/types/io/pocketenv/publicKey.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../util"; 7 7 - import { CID } from "multiformats/cid"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 9 9 export interface Record { 10 10 /** Name of the public key */ 11 11 - name: string; 11 11 + name: string 12 12 /** The public key value, e.g. an SSH public key string. */ 13 13 - key: string; 14 14 - createdAt: string; 15 15 - [k: string]: unknown; 13 13 + key: string 14 14 + createdAt: string 15 15 + [k: string]: unknown 16 16 } 17 17 18 18 export function isRecord(v: unknown): v is Record { 19 19 return ( 20 20 isObj(v) && 21 21 - hasProp(v, "$type") && 22 22 - (v.$type === "io.pocketenv.publicKey#main" || 23 23 - v.$type === "io.pocketenv.publicKey") 24 24 - ); 21 21 + hasProp(v, '$type') && 22 22 + (v.$type === 'io.pocketenv.publicKey#main' || 23 23 + v.$type === 'io.pocketenv.publicKey') 24 24 + ) 25 25 } 26 26 27 27 export function validateRecord(v: unknown): ValidationResult { 28 28 - return lexicons.validate("io.pocketenv.publicKey#main", v); 28 28 + return lexicons.validate('io.pocketenv.publicKey#main', v) 29 29 }

+28 -28

apps/api/src/lexicon/types/io/pocketenv/sandbox.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../util"; 7 7 - import { CID } from "multiformats/cid"; 8 8 - import type * as ComAtprotoRepoStrongRef from "../../com/atproto/repo/strongRef"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 + import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef' 9 9 10 10 export interface Record { 11 11 /** Name of the sandbox */ 12 12 - name: string; 13 13 - base?: ComAtprotoRepoStrongRef.Main; 12 12 + name: string 13 13 + base?: ComAtprotoRepoStrongRef.Main 14 14 /** The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc. */ 15 15 - provider?: string; 16 16 - description?: string; 15 15 + provider?: string 16 16 + description?: string 17 17 /** Any URI related to the sandbox */ 18 18 - website?: string; 18 18 + website?: string 19 19 /** URI to an image logo for the sandbox */ 20 20 - logo?: string; 21 21 - topics?: string[]; 20 20 + logo?: string 21 21 + topics?: string[] 22 22 /** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */ 23 23 - repo?: string; 23 23 + repo?: string 24 24 /** A URI to a README for the sandbox. */ 25 25 - readme?: string; 25 25 + readme?: string 26 26 /** Number of virtual CPUs allocated to the sandbox */ 27 27 - vcpus?: number; 27 27 + vcpus?: number 28 28 /** Amount of memory in GB allocated to the sandbox */ 29 29 - memory?: number; 29 29 + memory?: number 30 30 /** Amount of disk space in GB allocated to the sandbox */ 31 31 - disk?: number; 32 32 - volumes?: string[]; 33 33 - ports?: number[]; 34 34 - secrets?: string[]; 35 35 - envs?: string[]; 36 36 - createdAt: string; 37 37 - [k: string]: unknown; 31 31 + disk?: number 32 32 + volumes?: string[] 33 33 + ports?: number[] 34 34 + secrets?: string[] 35 35 + envs?: string[] 36 36 + createdAt: string 37 37 + [k: string]: unknown 38 38 } 39 39 40 40 export function isRecord(v: unknown): v is Record { 41 41 return ( 42 42 isObj(v) && 43 43 - hasProp(v, "$type") && 44 44 - (v.$type === "io.pocketenv.sandbox#main" || 45 45 - v.$type === "io.pocketenv.sandbox") 46 46 - ); 43 43 + hasProp(v, '$type') && 44 44 + (v.$type === 'io.pocketenv.sandbox#main' || 45 45 + v.$type === 'io.pocketenv.sandbox') 46 46 + ) 47 47 } 48 48 49 49 export function validateRecord(v: unknown): ValidationResult { 50 50 - return lexicons.validate("io.pocketenv.sandbox#main", v); 50 50 + return lexicons.validate('io.pocketenv.sandbox#main', v) 51 51 }

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/claimSandbox.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+28 -28

apps/api/src/lexicon/types/io/pocketenv/sandbox/createIntegration.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The sandbox ID. */ 16 16 - id: string; 16 16 + id: string 17 17 /** The name of the integration. */ 18 18 - name: string; 19 19 - [k: string]: unknown; 18 18 + name: string 19 19 + [k: string]: unknown 20 20 } 21 21 22 22 - export type OutputSchema = IoPocketenvSandboxDefs.IntegrationView; 22 22 + export type OutputSchema = IoPocketenvSandboxDefs.IntegrationView 23 23 24 24 export interface HandlerInput { 25 25 - encoding: "application/json"; 26 26 - body: InputSchema; 25 25 + encoding: 'application/json' 26 26 + body: InputSchema 27 27 } 28 28 29 29 export interface HandlerSuccess { 30 30 - encoding: "application/json"; 31 31 - body: OutputSchema; 32 32 - headers?: { [key: string]: string }; 30 30 + encoding: 'application/json' 31 31 + body: OutputSchema 32 32 + headers?: { [key: string]: string } 33 33 } 34 34 35 35 export interface HandlerError { 36 36 - status: number; 37 37 - message?: string; 36 36 + status: number 37 37 + message?: string 38 38 } 39 39 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: express.Request; 46 46 - res: express.Response; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 42 42 + auth: HA 43 43 + params: QueryParams 44 44 + input: HandlerInput 45 45 + req: express.Request 46 46 + res: express.Response 47 47 + resetRouteRateLimits: () => Promise<void> 48 48 + } 49 49 export type Handler<HA extends HandlerAuth = never> = ( 50 50 ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 51 51 + ) => Promise<HandlerOutput> | HandlerOutput

+40 -38

apps/api/src/lexicon/types/io/pocketenv/sandbox/createSandbox.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The base sandbox URI to clone from, e.g. a template or an existing sandbox. */ 16 16 - base: string; 16 16 + base: string 17 17 /** The name of the sandbox */ 18 18 - name?: string; 18 18 + name?: string 19 19 /** A description for the sandbox */ 20 20 - description?: string; 20 20 + description?: string 21 21 /** The provider to create the sandbox on, e.g. 'daytona', 'vercel', 'cloudflare', etc. */ 22 22 - provider?: "daytona" | "vercel" | "cloudflare" | "deno" | "sprites"; 22 22 + provider?: 'daytona' | 'vercel' | 'cloudflare' | 'deno' | 'sprites' 23 23 /** A list of topics/tags to associate with the sandbox */ 24 24 - topics?: string[]; 24 24 + topics?: string[] 25 25 /** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */ 26 26 - repo?: string; 26 26 + repo?: string 27 27 /** The number of virtual CPUs to allocate for the sandbox */ 28 28 - vcpus?: number; 28 28 + vcpus?: number 29 29 /** The amount of memory (in GB) to allocate for the sandbox */ 30 30 - memory?: number; 30 30 + memory?: number 31 31 /** The amount of disk space (in GB) to allocate for the sandbox */ 32 32 - disk?: number; 32 32 + disk?: number 33 33 /** A URI to a README for the sandbox. */ 34 34 - readme?: string; 35 35 - secrets?: IoPocketenvSandboxDefs.Secrets; 36 36 - envs?: IoPocketenvSandboxDefs.Envs; 37 37 - [k: string]: unknown; 34 34 + readme?: string 35 35 + secrets?: IoPocketenvSandboxDefs.Secrets 36 36 + envs?: IoPocketenvSandboxDefs.Envs 37 37 + /** Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs. */ 38 38 + keepAlive?: boolean 39 39 + [k: string]: unknown 38 40 } 39 41 40 40 - export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic; 42 42 + export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic 41 43 42 44 export interface HandlerInput { 43 43 - encoding: "application/json"; 44 44 - body: InputSchema; 45 45 + encoding: 'application/json' 46 46 + body: InputSchema 45 47 } 46 48 47 49 export interface HandlerSuccess { 48 48 - encoding: "application/json"; 49 49 - body: OutputSchema; 50 50 - headers?: { [key: string]: string }; 50 50 + encoding: 'application/json' 51 51 + body: OutputSchema 52 52 + headers?: { [key: string]: string } 51 53 } 52 54 53 55 export interface HandlerError { 54 54 - status: number; 55 55 - message?: string; 56 56 + status: number 57 57 + message?: string 56 58 } 57 59 58 58 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 60 60 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 59 61 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 60 60 - auth: HA; 61 61 - params: QueryParams; 62 62 - input: HandlerInput; 63 63 - req: express.Request; 64 64 - res: express.Response; 65 65 - resetRouteRateLimits: () => Promise<void>; 66 66 - }; 62 62 + auth: HA 63 63 + params: QueryParams 64 64 + input: HandlerInput 65 65 + req: express.Request 66 66 + res: express.Response 67 67 + resetRouteRateLimits: () => Promise<void> 68 68 + } 67 69 export type Handler<HA extends HandlerAuth = never> = ( 68 70 ctx: HandlerReqCtx<HA>, 69 69 - ) => Promise<HandlerOutput> | HandlerOutput; 71 71 + ) => Promise<HandlerOutput> | HandlerOutput

+124 -124

apps/api/src/lexicon/types/io/pocketenv/sandbox/defs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 8 8 - import type * as IoPocketenvUserDefs from "../user/defs"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 + import type * as IoPocketenvUserDefs from '../user/defs' 9 9 10 10 export interface SandboxViewBasic { 11 11 /** Name of the sandbox */ 12 12 - name?: string; 12 12 + name?: string 13 13 /** The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc. */ 14 14 - provider?: string; 15 15 - description?: string; 14 14 + provider?: string 15 15 + description?: string 16 16 /** Any URI related to the sandbox */ 17 17 - website?: string; 17 17 + website?: string 18 18 /** URI to an image logo for the sandbox */ 19 19 - logo?: string; 20 20 - topics?: string[]; 19 19 + logo?: string 20 20 + topics?: string[] 21 21 /** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */ 22 22 - repo?: string; 22 22 + repo?: string 23 23 /** A URI to a README for the sandbox. */ 24 24 - readme?: string; 24 24 + readme?: string 25 25 /** Number of virtual CPUs allocated to the sandbox */ 26 26 - vcpus?: number; 26 26 + vcpus?: number 27 27 /** Amount of memory in GB allocated to the sandbox */ 28 28 - memory?: number; 28 28 + memory?: number 29 29 /** Amount of disk space in GB allocated to the sandbox */ 30 30 - disk?: number; 31 31 - ports?: number[]; 30 30 + disk?: number 31 31 + ports?: number[] 32 32 /** Number of times the sandbox has been installed by users. */ 33 33 - installs?: number; 34 34 - createdAt?: string; 35 35 - [k: string]: unknown; 33 33 + installs?: number 34 34 + createdAt?: string 35 35 + [k: string]: unknown 36 36 } 37 37 38 38 export function isSandboxViewBasic(v: unknown): v is SandboxViewBasic { 39 39 return ( 40 40 isObj(v) && 41 41 - hasProp(v, "$type") && 42 42 - v.$type === "io.pocketenv.sandbox.defs#sandboxViewBasic" 43 43 - ); 41 41 + hasProp(v, '$type') && 42 42 + v.$type === 'io.pocketenv.sandbox.defs#sandboxViewBasic' 43 43 + ) 44 44 } 45 45 46 46 export function validateSandboxViewBasic(v: unknown): ValidationResult { 47 47 - return lexicons.validate("io.pocketenv.sandbox.defs#sandboxViewBasic", v); 47 47 + return lexicons.validate('io.pocketenv.sandbox.defs#sandboxViewBasic', v) 48 48 } 49 49 50 50 export interface SandboxViewDetailed { 51 51 /** Name of the sandbox */ 52 52 - name?: string; 52 52 + name?: string 53 53 /** The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc. */ 54 54 - provider?: string; 55 55 - description?: string; 54 54 + provider?: string 55 55 + description?: string 56 56 /** The current status of the sandbox, e.g. 'RUNNING', 'STOPPED', etc. */ 57 57 - status?: string; 58 58 - startedAt?: string; 57 57 + status?: string 58 58 + startedAt?: string 59 59 /** The sandbox timeout in seconds */ 60 60 - timeout?: number; 60 60 + timeout?: number 61 61 /** The base sandbox that this sandbox was created from, if any. This can be used to determine the template or configuration used to create the sandbox. */ 62 62 - baseSandbox?: string; 62 62 + baseSandbox?: string 63 63 /** Any URI related to the sandbox */ 64 64 - website?: string; 64 64 + website?: string 65 65 /** URI to an image logo for the sandbox */ 66 66 - logo?: string; 67 67 - topics?: string[]; 66 66 + logo?: string 67 67 + topics?: string[] 68 68 /** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */ 69 69 - repo?: string; 69 69 + repo?: string 70 70 /** A URI to a README for the sandbox. */ 71 71 - readme?: string; 71 71 + readme?: string 72 72 /** Number of virtual CPUs allocated to the sandbox */ 73 73 - vcpus?: number; 73 73 + vcpus?: number 74 74 /** Amount of memory in GB allocated to the sandbox */ 75 75 - memory?: number; 75 75 + memory?: number 76 76 /** Amount of disk space in GB allocated to the sandbox */ 77 77 - disk?: number; 78 78 - ports?: number[]; 77 77 + disk?: number 78 78 + ports?: number[] 79 79 /** Number of times the sandbox has been installed by users. */ 80 80 - installs?: number; 81 81 - createdAt?: string; 82 82 - owner?: IoPocketenvUserDefs.UserViewBasic; 83 83 - [k: string]: unknown; 80 80 + installs?: number 81 81 + createdAt?: string 82 82 + owner?: IoPocketenvUserDefs.UserViewBasic 83 83 + [k: string]: unknown 84 84 } 85 85 86 86 export function isSandboxViewDetailed(v: unknown): v is SandboxViewDetailed { 87 87 return ( 88 88 isObj(v) && 89 89 - hasProp(v, "$type") && 90 90 - v.$type === "io.pocketenv.sandbox.defs#sandboxViewDetailed" 91 91 - ); 89 89 + hasProp(v, '$type') && 90 90 + v.$type === 'io.pocketenv.sandbox.defs#sandboxViewDetailed' 91 91 + ) 92 92 } 93 93 94 94 export function validateSandboxViewDetailed(v: unknown): ValidationResult { 95 95 - return lexicons.validate("io.pocketenv.sandbox.defs#sandboxViewDetailed", v); 95 95 + return lexicons.validate('io.pocketenv.sandbox.defs#sandboxViewDetailed', v) 96 96 } 97 97 98 98 export interface SandboxDetailsPref { 99 99 /** The name of the sandbox */ 100 100 - name?: string; 100 100 + name?: string 101 101 /** A description for the sandbox */ 102 102 - description?: string | null; 102 102 + description?: string | null 103 103 /** A list of topics/tags to associate with the sandbox */ 104 104 - topics?: (string | null)[]; 104 104 + topics?: (string | null)[] 105 105 /** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */ 106 106 - repo?: string | null; 106 106 + repo?: string | null 107 107 /** The number of virtual CPUs to allocate for the sandbox */ 108 108 - vcpus?: number; 108 108 + vcpus?: number 109 109 /** The amount of memory (in GB) to allocate for the sandbox */ 110 110 - memory?: number; 110 110 + memory?: number 111 111 /** The amount of disk space (in GB) to allocate for the sandbox */ 112 112 - disk?: number; 112 112 + disk?: number 113 113 /** A URI to a README for the sandbox. */ 114 114 - readme?: string; 115 115 - [k: string]: unknown; 114 114 + readme?: string 115 115 + [k: string]: unknown 116 116 } 117 117 118 118 export function isSandboxDetailsPref(v: unknown): v is SandboxDetailsPref { 119 119 return ( 120 120 isObj(v) && 121 121 - hasProp(v, "$type") && 122 122 - v.$type === "io.pocketenv.sandbox.defs#sandboxDetailsPref" 123 123 - ); 121 121 + hasProp(v, '$type') && 122 122 + v.$type === 'io.pocketenv.sandbox.defs#sandboxDetailsPref' 123 123 + ) 124 124 } 125 125 126 126 export function validateSandboxDetailsPref(v: unknown): ValidationResult { 127 127 - return lexicons.validate("io.pocketenv.sandbox.defs#sandboxDetailsPref", v); 127 127 + return lexicons.validate('io.pocketenv.sandbox.defs#sandboxDetailsPref', v) 128 128 } 129 129 130 130 export interface SecretPref { 131 131 /** The name of the secret */ 132 132 - name?: string; 132 132 + name?: string 133 133 /** The value of the secret. This will be encrypted at rest and redacted in any API responses. */ 134 134 - value?: string; 135 135 - [k: string]: unknown; 134 134 + value?: string 135 135 + [k: string]: unknown 136 136 } 137 137 138 138 export function isSecretPref(v: unknown): v is SecretPref { 139 139 return ( 140 140 isObj(v) && 141 141 - hasProp(v, "$type") && 142 142 - v.$type === "io.pocketenv.sandbox.defs#secretPref" 143 143 - ); 141 141 + hasProp(v, '$type') && 142 142 + v.$type === 'io.pocketenv.sandbox.defs#secretPref' 143 143 + ) 144 144 } 145 145 146 146 export function validateSecretPref(v: unknown): ValidationResult { 147 147 - return lexicons.validate("io.pocketenv.sandbox.defs#secretPref", v); 147 147 + return lexicons.validate('io.pocketenv.sandbox.defs#secretPref', v) 148 148 } 149 149 150 150 /** A variable to add to the sandbox */ 151 151 export interface VariablePref { 152 152 /** The name of the variable */ 153 153 - name?: string; 153 153 + name?: string 154 154 /** The value of the variable. This will be visible in API responses and should not contain sensitive information. */ 155 155 - value?: string; 156 156 - [k: string]: unknown; 155 155 + value?: string 156 156 + [k: string]: unknown 157 157 } 158 158 159 159 export function isVariablePref(v: unknown): v is VariablePref { 160 160 return ( 161 161 isObj(v) && 162 162 - hasProp(v, "$type") && 163 163 - v.$type === "io.pocketenv.sandbox.defs#variablePref" 164 164 - ); 162 162 + hasProp(v, '$type') && 163 163 + v.$type === 'io.pocketenv.sandbox.defs#variablePref' 164 164 + ) 165 165 } 166 166 167 167 export function validateVariablePref(v: unknown): ValidationResult { 168 168 - return lexicons.validate("io.pocketenv.sandbox.defs#variablePref", v); 168 168 + return lexicons.validate('io.pocketenv.sandbox.defs#variablePref', v) 169 169 } 170 170 171 171 /** A file to add to the sandbox */ 172 172 export interface FilePref { 173 173 /** The name of the file */ 174 174 - name?: string; 174 174 + name?: string 175 175 /** The content of the file. */ 176 176 - content?: string; 176 176 + content?: string 177 177 /** Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information. */ 178 178 - encrypt?: boolean; 178 178 + encrypt?: boolean 179 179 /** The path within the sandbox where the file will be created, e.g. '/app/config.json'. If not provided, the file will be created in the root directory of the sandbox. */ 180 180 - path?: string; 181 181 - [k: string]: unknown; 180 180 + path?: string 181 181 + [k: string]: unknown 182 182 } 183 183 184 184 export function isFilePref(v: unknown): v is FilePref { 185 185 return ( 186 186 isObj(v) && 187 187 - hasProp(v, "$type") && 188 188 - v.$type === "io.pocketenv.sandbox.defs#filePref" 189 189 - ); 187 187 + hasProp(v, '$type') && 188 188 + v.$type === 'io.pocketenv.sandbox.defs#filePref' 189 189 + ) 190 190 } 191 191 192 192 export function validateFilePref(v: unknown): ValidationResult { 193 193 - return lexicons.validate("io.pocketenv.sandbox.defs#filePref", v); 193 193 + return lexicons.validate('io.pocketenv.sandbox.defs#filePref', v) 194 194 } 195 195 196 196 /** A volume to add to the sandbox */ 197 197 export interface VolumePref { 198 198 /** The name of the volume */ 199 199 - name?: string; 199 199 + name?: string 200 200 /** The mount path within the sandbox where the volume will be attached, e.g. '/data', '/logs', etc. */ 201 201 - path?: string; 201 201 + path?: string 202 202 /** Whether the volume should be mounted as read-only */ 203 203 - readOnly?: boolean; 204 204 - [k: string]: unknown; 203 203 + readOnly?: boolean 204 204 + [k: string]: unknown 205 205 } 206 206 207 207 export function isVolumePref(v: unknown): v is VolumePref { 208 208 return ( 209 209 isObj(v) && 210 210 - hasProp(v, "$type") && 211 211 - v.$type === "io.pocketenv.sandbox.defs#volumePref" 212 212 - ); 210 210 + hasProp(v, '$type') && 211 211 + v.$type === 'io.pocketenv.sandbox.defs#volumePref' 212 212 + ) 213 213 } 214 214 215 215 export function validateVolumePref(v: unknown): ValidationResult { 216 216 - return lexicons.validate("io.pocketenv.sandbox.defs#volumePref", v); 216 216 + return lexicons.validate('io.pocketenv.sandbox.defs#volumePref', v) 217 217 } 218 218 219 219 export type Preferences = ( ··· 223 223 | FilePref 224 224 | VolumePref 225 225 | { $type: string; [k: string]: unknown } 226 226 - )[]; 226 226 + )[] 227 227 228 228 export interface SshKeysView { 229 229 /** Unique identifier of the SSH key. */ 230 230 - id?: string; 230 230 + id?: string 231 231 /** The public SSH key. */ 232 232 - publicKey?: string; 232 232 + publicKey?: string 233 233 /** The private SSH key (redacted in API responses) */ 234 234 - privateKey?: string; 234 234 + privateKey?: string 235 235 /** The timestamp when the SSH key was created. */ 236 236 - createdAt?: string; 236 236 + createdAt?: string 237 237 /** The timestamp when the SSH key was last updated. */ 238 238 - updatedAt?: string; 239 239 - [k: string]: unknown; 238 238 + updatedAt?: string 239 239 + [k: string]: unknown 240 240 } 241 241 242 242 export function isSshKeysView(v: unknown): v is SshKeysView { 243 243 return ( 244 244 isObj(v) && 245 245 - hasProp(v, "$type") && 246 246 - v.$type === "io.pocketenv.sandbox.defs#sshKeysView" 247 247 - ); 245 245 + hasProp(v, '$type') && 246 246 + v.$type === 'io.pocketenv.sandbox.defs#sshKeysView' 247 247 + ) 248 248 } 249 249 250 250 export function validateSshKeysView(v: unknown): ValidationResult { 251 251 - return lexicons.validate("io.pocketenv.sandbox.defs#sshKeysView", v); 251 251 + return lexicons.validate('io.pocketenv.sandbox.defs#sshKeysView', v) 252 252 } 253 253 254 254 export interface TailscaleAuthKeyView { 255 255 /** Unique identifier of the Tailscale Auth Key. */ 256 256 - id?: string; 256 256 + id?: string 257 257 /** The Tailscale auth key (redacted in API responses) */ 258 258 - authKey?: string; 258 258 + authKey?: string 259 259 /** The redacted Auth Key. */ 260 260 - redacted?: string; 260 260 + redacted?: string 261 261 /** The timestamp when the Tailscale Auth Key was created. */ 262 262 - createdAt?: string; 262 262 + createdAt?: string 263 263 /** The timestamp when the Tailscale Auth Key was last updated. */ 264 264 - updatedAt?: string; 265 265 - [k: string]: unknown; 264 264 + updatedAt?: string 265 265 + [k: string]: unknown 266 266 } 267 267 268 268 export function isTailscaleAuthKeyView(v: unknown): v is TailscaleAuthKeyView { 269 269 return ( 270 270 isObj(v) && 271 271 - hasProp(v, "$type") && 272 272 - v.$type === "io.pocketenv.sandbox.defs#tailscaleAuthKeyView" 273 273 - ); 271 271 + hasProp(v, '$type') && 272 272 + v.$type === 'io.pocketenv.sandbox.defs#tailscaleAuthKeyView' 273 273 + ) 274 274 } 275 275 276 276 export function validateTailscaleAuthKeyView(v: unknown): ValidationResult { 277 277 - return lexicons.validate("io.pocketenv.sandbox.defs#tailscaleAuthKeyView", v); 277 277 + return lexicons.validate('io.pocketenv.sandbox.defs#tailscaleAuthKeyView', v) 278 278 } 279 279 280 280 export interface IntegrationView { 281 281 /** Unique identifier of the integration. */ 282 282 - id?: string; 282 282 + id?: string 283 283 /** The name of the integration, e.g. 'GitHub', 'Slack', 'Trello', etc. */ 284 284 - name?: string; 284 284 + name?: string 285 285 /** The webhook URL of the integration. */ 286 286 - webhookUrl?: string; 286 286 + webhookUrl?: string 287 287 /** The timestamp when the integration was created. */ 288 288 - createdAt?: string; 288 288 + createdAt?: string 289 289 /** The timestamp when the integration was last updated. */ 290 290 - updatedAt?: string; 291 291 - [k: string]: unknown; 290 290 + updatedAt?: string 291 291 + [k: string]: unknown 292 292 } 293 293 294 294 export function isIntegrationView(v: unknown): v is IntegrationView { 295 295 return ( 296 296 isObj(v) && 297 297 - hasProp(v, "$type") && 298 298 - v.$type === "io.pocketenv.sandbox.defs#integrationView" 299 299 - ); 297 297 + hasProp(v, '$type') && 298 298 + v.$type === 'io.pocketenv.sandbox.defs#integrationView' 299 299 + ) 300 300 } 301 301 302 302 export function validateIntegrationView(v: unknown): ValidationResult { 303 303 - return lexicons.validate("io.pocketenv.sandbox.defs#integrationView", v); 303 303 + return lexicons.validate('io.pocketenv.sandbox.defs#integrationView', v) 304 304 } 305 305 306 306 - export type IntegrationsView = IntegrationView[]; 306 306 + export type IntegrationsView = IntegrationView[]

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/deleteSandbox.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+29 -29

apps/api/src/lexicon/types/io/pocketenv/sandbox/exec.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 export interface QueryParams { 12 12 /** The sandbox ID. */ 13 13 - id: string; 13 13 + id: string 14 14 } 15 15 16 16 export interface InputSchema { 17 17 /** The command to execute in the sandbox. */ 18 18 - command: string; 19 19 - [k: string]: unknown; 18 18 + command: string 19 19 + [k: string]: unknown 20 20 } 21 21 22 22 export interface OutputSchema { 23 23 /** The output of the executed command. */ 24 24 - stdout?: string; 24 24 + stdout?: string 25 25 /** The error output of the executed command, if any. */ 26 26 - stderr?: string; 26 26 + stderr?: string 27 27 /** The exit code of the executed command. */ 28 28 - exitCode?: number; 29 29 - [k: string]: unknown; 28 28 + exitCode?: number 29 29 + [k: string]: unknown 30 30 } 31 31 32 32 export interface HandlerInput { 33 33 - encoding: "application/json"; 34 34 - body: InputSchema; 33 33 + encoding: 'application/json' 34 34 + body: InputSchema 35 35 } 36 36 37 37 export interface HandlerSuccess { 38 38 - encoding: "application/json"; 39 39 - body: OutputSchema; 40 40 - headers?: { [key: string]: string }; 38 38 + encoding: 'application/json' 39 39 + body: OutputSchema 40 40 + headers?: { [key: string]: string } 41 41 } 42 42 43 43 export interface HandlerError { 44 44 - status: number; 45 45 - message?: string; 44 44 + status: number 45 45 + message?: string 46 46 } 47 47 48 48 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 48 48 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 49 49 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 50 50 - auth: HA; 51 51 - params: QueryParams; 52 52 - input: HandlerInput; 53 53 - req: express.Request; 54 54 - res: express.Response; 55 55 - resetRouteRateLimits: () => Promise<void>; 56 56 - }; 50 50 + auth: HA 51 51 + params: QueryParams 52 52 + input: HandlerInput 53 53 + req: express.Request 54 54 + res: express.Response 55 55 + resetRouteRateLimits: () => Promise<void> 56 56 + } 57 57 export type Handler<HA extends HandlerAuth = never> = ( 58 58 ctx: HandlerReqCtx<HA>, 59 59 - ) => Promise<HandlerOutput> | HandlerOutput; 59 59 + ) => Promise<HandlerOutput> | HandlerOutput

+28 -28

apps/api/src/lexicon/types/io/pocketenv/sandbox/exposePort.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 export interface QueryParams { 12 12 /** The sandbox ID. */ 13 13 - id: string; 13 13 + id: string 14 14 } 15 15 16 16 export interface InputSchema { 17 17 /** The port number to expose. */ 18 18 - port: number; 18 18 + port: number 19 19 /** A description of the port. */ 20 20 - description?: string; 21 21 - [k: string]: unknown; 20 20 + description?: string 21 21 + [k: string]: unknown 22 22 } 23 23 24 24 export interface OutputSchema { 25 25 /** The preview URL for the exposed port. */ 26 26 - previewUrl?: string | null; 27 27 - [k: string]: unknown; 26 26 + previewUrl?: string | null 27 27 + [k: string]: unknown 28 28 } 29 29 30 30 export interface HandlerInput { 31 31 - encoding: "application/json"; 32 32 - body: InputSchema; 31 31 + encoding: 'application/json' 32 32 + body: InputSchema 33 33 } 34 34 35 35 export interface HandlerSuccess { 36 36 - encoding: "application/json"; 37 37 - body: OutputSchema; 38 38 - headers?: { [key: string]: string }; 36 36 + encoding: 'application/json' 37 37 + body: OutputSchema 38 38 + headers?: { [key: string]: string } 39 39 } 40 40 41 41 export interface HandlerError { 42 42 - status: number; 43 43 - message?: string; 42 42 + status: number 43 43 + message?: string 44 44 } 45 45 46 46 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 46 46 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 47 47 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 48 48 - auth: HA; 49 49 - params: QueryParams; 50 50 - input: HandlerInput; 51 51 - req: express.Request; 52 52 - res: express.Response; 53 53 - resetRouteRateLimits: () => Promise<void>; 54 54 - }; 48 48 + auth: HA 49 49 + params: QueryParams 50 50 + input: HandlerInput 51 51 + req: express.Request 52 52 + res: express.Response 53 53 + resetRouteRateLimits: () => Promise<void> 54 54 + } 55 55 export type Handler<HA extends HandlerAuth = never> = ( 56 56 ctx: HandlerReqCtx<HA>, 57 57 - ) => Promise<HandlerOutput> | HandlerOutput; 57 57 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/exposeVscode.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 export interface QueryParams { 12 12 /** The sandbox ID. */ 13 13 - id: string; 13 13 + id: string 14 14 } 15 15 16 16 - export type InputSchema = undefined; 16 16 + export type InputSchema = undefined 17 17 18 18 export interface OutputSchema { 19 19 /** The preview URL for the exposed port. */ 20 20 - previewUrl?: string | null; 21 21 - [k: string]: unknown; 20 20 + previewUrl?: string | null 21 21 + [k: string]: unknown 22 22 } 23 23 24 24 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = undefined 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: "application/json"; 28 28 - body: OutputSchema; 29 29 - headers?: { [key: string]: string }; 27 27 + encoding: 'application/json' 28 28 + body: OutputSchema 29 29 + headers?: { [key: string]: string } 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number; 34 34 - message?: string; 33 33 + status: number 34 34 + message?: string 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: express.Request; 43 43 - res: express.Response; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 39 39 + auth: HA 40 40 + params: QueryParams 41 41 + input: HandlerInput 42 42 + req: express.Request 43 43 + res: express.Response 44 44 + resetRouteRateLimits: () => Promise<void> 45 45 + } 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 48 48 + ) => Promise<HandlerOutput> | HandlerOutput

+26 -26

apps/api/src/lexicon/types/io/pocketenv/sandbox/getExposedPorts.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvPortDefs from "../port/defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvPortDefs from '../port/defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 17 17 + export type InputSchema = undefined 18 18 19 19 export interface OutputSchema { 20 20 - ports?: IoPocketenvPortDefs.PortView[]; 21 21 - [k: string]: unknown; 20 20 + ports?: IoPocketenvPortDefs.PortView[] 21 21 + [k: string]: unknown 22 22 } 23 23 24 24 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = undefined 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: "application/json"; 28 28 - body: OutputSchema; 29 29 - headers?: { [key: string]: string }; 27 27 + encoding: 'application/json' 28 28 + body: OutputSchema 29 29 + headers?: { [key: string]: string } 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number; 34 34 - message?: string; 33 33 + status: number 34 34 + message?: string 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: express.Request; 43 43 - res: express.Response; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 39 39 + auth: HA 40 40 + params: QueryParams 41 41 + input: HandlerInput 42 42 + req: express.Request 43 43 + res: express.Response 44 44 + resetRouteRateLimits: () => Promise<void> 45 45 + } 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 48 48 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/getIntegrations.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.IntegrationsView; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.IntegrationsView 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/getPreferences.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID or URI to retrieve */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.Preferences; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.Preferences 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/getSandbox.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID or URI to retrieve */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+28 -28

apps/api/src/lexicon/types/io/pocketenv/sandbox/getSandboxes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The maximum number of sandboxes to return. */ 14 14 - limit?: number; 14 14 + limit?: number 15 15 /** The number of sandboxes to skip before starting to collect the result set. */ 16 16 - offset?: number; 16 16 + offset?: number 17 17 } 18 18 19 19 - export type InputSchema = undefined; 19 19 + export type InputSchema = undefined 20 20 21 21 export interface OutputSchema { 22 22 - sandboxes?: IoPocketenvSandboxDefs.SandboxViewBasic[]; 22 22 + sandboxes?: IoPocketenvSandboxDefs.SandboxViewBasic[] 23 23 /** The total number of sandboxes available. */ 24 24 - total?: number; 25 25 - [k: string]: unknown; 24 24 + total?: number 25 25 + [k: string]: unknown 26 26 } 27 27 28 28 - export type HandlerInput = undefined; 28 28 + export type HandlerInput = undefined 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: "application/json"; 32 32 - body: OutputSchema; 33 33 - headers?: { [key: string]: string }; 31 31 + encoding: 'application/json' 32 32 + body: OutputSchema 33 33 + headers?: { [key: string]: string } 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number; 38 38 - message?: string; 37 37 + status: number 38 38 + message?: string 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: express.Request; 47 47 - res: express.Response; 48 48 - resetRouteRateLimits: () => Promise<void>; 49 49 - }; 43 43 + auth: HA 44 44 + params: QueryParams 45 45 + input: HandlerInput 46 46 + req: express.Request 47 47 + res: express.Response 48 48 + resetRouteRateLimits: () => Promise<void> 49 49 + } 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput; 52 52 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/getSshKeys.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.SshKeysView; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.SshKeysView 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/getTailscaleAuthKey.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.TailscaleAuthKeyView; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.TailscaleAuthKeyView 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/getTailscaleToken.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.TailscaleTokenView; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.TailscaleTokenView 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+24 -24

apps/api/src/lexicon/types/io/pocketenv/sandbox/putPreferences.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The sandbox ID or URI */ 16 16 - sandboxId: string; 17 17 - preferences: IoPocketenvSandboxDefs.Preferences; 18 18 - [k: string]: unknown; 16 16 + sandboxId: string 17 17 + preferences: IoPocketenvSandboxDefs.Preferences 18 18 + [k: string]: unknown 19 19 } 20 20 21 21 export interface HandlerInput { 22 22 - encoding: "application/json"; 23 23 - body: InputSchema; 22 22 + encoding: 'application/json' 23 23 + body: InputSchema 24 24 } 25 25 26 26 export interface HandlerError { 27 27 - status: number; 28 28 - message?: string; 27 27 + status: number 28 28 + message?: string 29 29 } 30 30 31 31 - export type HandlerOutput = HandlerError | void; 31 31 + export type HandlerOutput = HandlerError | void 32 32 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: express.Request; 37 37 - res: express.Response; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 33 33 + auth: HA 34 34 + params: QueryParams 35 35 + input: HandlerInput 36 36 + req: express.Request 37 37 + res: express.Response 38 38 + resetRouteRateLimits: () => Promise<void> 39 39 + } 40 40 export type Handler<HA extends HandlerAuth = never> = ( 41 41 ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 42 42 + ) => Promise<HandlerOutput> | HandlerOutput

+30 -30

apps/api/src/lexicon/types/io/pocketenv/sandbox/putSshKeys.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The sandbox ID. */ 16 16 - id: string; 16 16 + id: string 17 17 /** The private SSH key (encrypted) */ 18 18 - privateKey: string; 18 18 + privateKey: string 19 19 /** The public SSH key. */ 20 20 - publicKey: string; 20 20 + publicKey: string 21 21 /** The redacted SSH key. */ 22 22 - redacted?: string; 23 23 - [k: string]: unknown; 22 22 + redacted?: string 23 23 + [k: string]: unknown 24 24 } 25 25 26 26 - export type OutputSchema = IoPocketenvSandboxDefs.SshKeysView; 26 26 + export type OutputSchema = IoPocketenvSandboxDefs.SshKeysView 27 27 28 28 export interface HandlerInput { 29 29 - encoding: "application/json"; 30 30 - body: InputSchema; 29 29 + encoding: 'application/json' 30 30 + body: InputSchema 31 31 } 32 32 33 33 export interface HandlerSuccess { 34 34 - encoding: "application/json"; 35 35 - body: OutputSchema; 36 36 - headers?: { [key: string]: string }; 34 34 + encoding: 'application/json' 35 35 + body: OutputSchema 36 36 + headers?: { [key: string]: string } 37 37 } 38 38 39 39 export interface HandlerError { 40 40 - status: number; 41 41 - message?: string; 40 40 + status: number 41 41 + message?: string 42 42 } 43 43 44 44 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 44 44 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 45 45 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 46 46 - auth: HA; 47 47 - params: QueryParams; 48 48 - input: HandlerInput; 49 49 - req: express.Request; 50 50 - res: express.Response; 51 51 - resetRouteRateLimits: () => Promise<void>; 52 52 - }; 46 46 + auth: HA 47 47 + params: QueryParams 48 48 + input: HandlerInput 49 49 + req: express.Request 50 50 + res: express.Response 51 51 + resetRouteRateLimits: () => Promise<void> 52 52 + } 53 53 export type Handler<HA extends HandlerAuth = never> = ( 54 54 ctx: HandlerReqCtx<HA>, 55 55 - ) => Promise<HandlerOutput> | HandlerOutput; 55 55 + ) => Promise<HandlerOutput> | HandlerOutput

+29 -29

apps/api/src/lexicon/types/io/pocketenv/sandbox/putTailscaleAuthKey.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The sandbox ID. */ 16 16 - id: string; 16 16 + id: string 17 17 /** The Tailscale Auth Key (encrypted) to store for the sandbox. */ 18 18 - authKey: string; 18 18 + authKey: string 19 19 /** The redacted SSH key. */ 20 20 - redacted?: string; 21 21 - [k: string]: unknown; 20 20 + redacted?: string 21 21 + [k: string]: unknown 22 22 } 23 23 24 24 - export type OutputSchema = IoPocketenvSandboxDefs.TailscaleAuthKeyView; 24 24 + export type OutputSchema = IoPocketenvSandboxDefs.TailscaleAuthKeyView 25 25 26 26 export interface HandlerInput { 27 27 - encoding: "application/json"; 28 28 - body: InputSchema; 27 27 + encoding: 'application/json' 28 28 + body: InputSchema 29 29 } 30 30 31 31 export interface HandlerSuccess { 32 32 - encoding: "application/json"; 33 33 - body: OutputSchema; 34 34 - headers?: { [key: string]: string }; 32 32 + encoding: 'application/json' 33 33 + body: OutputSchema 34 34 + headers?: { [key: string]: string } 35 35 } 36 36 37 37 export interface HandlerError { 38 38 - status: number; 39 39 - message?: string; 38 38 + status: number 39 39 + message?: string 40 40 } 41 41 42 42 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 43 43 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 44 44 - auth: HA; 45 45 - params: QueryParams; 46 46 - input: HandlerInput; 47 47 - req: express.Request; 48 48 - res: express.Response; 49 49 - resetRouteRateLimits: () => Promise<void>; 50 50 - }; 44 44 + auth: HA 45 45 + params: QueryParams 46 46 + input: HandlerInput 47 47 + req: express.Request 48 48 + res: express.Response 49 49 + resetRouteRateLimits: () => Promise<void> 50 50 + } 51 51 export type Handler<HA extends HandlerAuth = never> = ( 52 52 ctx: HandlerReqCtx<HA>, 53 53 - ) => Promise<HandlerOutput> | HandlerOutput; 53 53 + ) => Promise<HandlerOutput> | HandlerOutput

+28 -28

apps/api/src/lexicon/types/io/pocketenv/sandbox/putTailscaleToken.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The sandbox ID. */ 16 16 - id: string; 16 16 + id: string 17 17 /** The Tailscale token (encrypted) to store for the sandbox. */ 18 18 - token: string; 19 19 - [k: string]: unknown; 18 18 + token: string 19 19 + [k: string]: unknown 20 20 } 21 21 22 22 - export type OutputSchema = IoPocketenvSandboxDefs.TailscaleTokenView; 22 22 + export type OutputSchema = IoPocketenvSandboxDefs.TailscaleTokenView 23 23 24 24 export interface HandlerInput { 25 25 - encoding: "application/json"; 26 26 - body: InputSchema; 25 25 + encoding: 'application/json' 26 26 + body: InputSchema 27 27 } 28 28 29 29 export interface HandlerSuccess { 30 30 - encoding: "application/json"; 31 31 - body: OutputSchema; 32 32 - headers?: { [key: string]: string }; 30 30 + encoding: 'application/json' 31 31 + body: OutputSchema 32 32 + headers?: { [key: string]: string } 33 33 } 34 34 35 35 export interface HandlerError { 36 36 - status: number; 37 37 - message?: string; 36 36 + status: number 37 37 + message?: string 38 38 } 39 39 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: express.Request; 46 46 - res: express.Response; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 42 42 + auth: HA 43 43 + params: QueryParams 44 44 + input: HandlerInput 45 45 + req: express.Request 46 46 + res: express.Response 47 47 + resetRouteRateLimits: () => Promise<void> 48 48 + } 49 49 export type Handler<HA extends HandlerAuth = never> = ( 50 50 ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 51 51 + ) => Promise<HandlerOutput> | HandlerOutput

+29 -27

apps/api/src/lexicon/types/io/pocketenv/sandbox/startSandbox.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 export interface InputSchema { 18 18 /** The git repository URL to clone into the sandbox before starting it. Optional. */ 19 19 - repo?: string; 20 20 - [k: string]: unknown; 19 19 + repo?: string 20 20 + /** Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs. */ 21 21 + keepAlive?: boolean 22 22 + [k: string]: unknown 21 23 } 22 24 23 23 - export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic; 25 25 + export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic 24 26 25 27 export interface HandlerInput { 26 26 - encoding: "application/json"; 27 27 - body: InputSchema; 28 28 + encoding: 'application/json' 29 29 + body: InputSchema 28 30 } 29 31 30 32 export interface HandlerSuccess { 31 31 - encoding: "application/json"; 32 32 - body: OutputSchema; 33 33 - headers?: { [key: string]: string }; 33 33 + encoding: 'application/json' 34 34 + body: OutputSchema 35 35 + headers?: { [key: string]: string } 34 36 } 35 37 36 38 export interface HandlerError { 37 37 - status: number; 38 38 - message?: string; 39 39 + status: number 40 40 + message?: string 39 41 } 40 42 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 42 44 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: express.Request; 47 47 - res: express.Response; 48 48 - resetRouteRateLimits: () => Promise<void>; 49 49 - }; 45 45 + auth: HA 46 46 + params: QueryParams 47 47 + input: HandlerInput 48 48 + req: express.Request 49 49 + res: express.Response 50 50 + resetRouteRateLimits: () => Promise<void> 51 51 + } 50 52 export type Handler<HA extends HandlerAuth = never> = ( 51 53 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput; 54 54 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/sandbox/stopSandbox.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSandboxDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The sandbox ID. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic; 19 19 - export type HandlerInput = undefined; 17 17 + export type InputSchema = undefined 18 18 + export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic 19 19 + export type HandlerInput = undefined 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 22 22 + encoding: 'application/json' 23 23 + body: OutputSchema 24 24 + headers?: { [key: string]: string } 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+22 -22

apps/api/src/lexicon/types/io/pocketenv/sandbox/unexposePort.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 export interface QueryParams { 12 12 /** The sandbox ID. */ 13 13 - id: string; 13 13 + id: string 14 14 } 15 15 16 16 export interface InputSchema { 17 17 /** The port number to unexpose. */ 18 18 - port: number; 19 19 - [k: string]: unknown; 18 18 + port: number 19 19 + [k: string]: unknown 20 20 } 21 21 22 22 export interface HandlerInput { 23 23 - encoding: "application/json"; 24 24 - body: InputSchema; 23 23 + encoding: 'application/json' 24 24 + body: InputSchema 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 28 28 + status: number 29 29 + message?: string 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | void; 32 32 + export type HandlerOutput = HandlerError | void 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 34 34 + auth: HA 35 35 + params: QueryParams 36 36 + input: HandlerInput 37 37 + req: express.Request 38 38 + res: express.Response 39 39 + resetRouteRateLimits: () => Promise<void> 40 40 + } 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + ) => Promise<HandlerOutput> | HandlerOutput

+42 -42

apps/api/src/lexicon/types/io/pocketenv/sandbox/updateSandboxSettings.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSecretDefs from "../secret/defs"; 11 11 - import type * as IoPocketenvVariableDefs from "../variable/defs"; 12 12 - import type * as IoPocketenvFileDefs from "../file/defs"; 13 13 - import type * as IoPocketenvVolumeDefs from "../volume/defs"; 14 14 - import type * as IoPocketenvSandboxDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSecretDefs from '../secret/defs' 11 11 + import type * as IoPocketenvVariableDefs from '../variable/defs' 12 12 + import type * as IoPocketenvFileDefs from '../file/defs' 13 13 + import type * as IoPocketenvVolumeDefs from '../volume/defs' 14 14 + import type * as IoPocketenvSandboxDefs from './defs' 15 15 16 16 - export type QueryParams = {}; 16 16 + export type QueryParams = {} 17 17 18 18 export interface InputSchema { 19 19 /** The name of the sandbox */ 20 20 - name?: string; 20 20 + name?: string 21 21 /** A description for the sandbox */ 22 22 - description?: string; 22 22 + description?: string 23 23 /** A list of topics/tags to associate with the sandbox */ 24 24 - topics?: string[]; 24 24 + topics?: string[] 25 25 /** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */ 26 26 - repo?: string; 26 26 + repo?: string 27 27 /** The number of virtual CPUs to allocate for the sandbox */ 28 28 - vcpus?: number; 28 28 + vcpus?: number 29 29 /** The amount of memory (in GB) to allocate for the sandbox */ 30 30 - memory?: number; 30 30 + memory?: number 31 31 /** The amount of disk space (in GB) to allocate for the sandbox */ 32 32 - disk?: number; 32 32 + disk?: number 33 33 /** A URI to a README for the sandbox. */ 34 34 - readme?: string; 35 35 - secrets?: IoPocketenvSecretDefs.Secrets; 36 36 - variables?: IoPocketenvVariableDefs.Variables; 37 37 - files?: IoPocketenvFileDefs.File; 38 38 - volumes?: IoPocketenvVolumeDefs.Volumes; 39 39 - [k: string]: unknown; 34 34 + readme?: string 35 35 + secrets?: IoPocketenvSecretDefs.Secrets 36 36 + variables?: IoPocketenvVariableDefs.Variables 37 37 + files?: IoPocketenvFileDefs.File 38 38 + volumes?: IoPocketenvVolumeDefs.Volumes 39 39 + [k: string]: unknown 40 40 } 41 41 42 42 - export type OutputSchema = IoPocketenvSandboxDefs.ProfileViewDetailed; 42 42 + export type OutputSchema = IoPocketenvSandboxDefs.ProfileViewDetailed 43 43 44 44 export interface HandlerInput { 45 45 - encoding: "application/json"; 46 46 - body: InputSchema; 45 45 + encoding: 'application/json' 46 46 + body: InputSchema 47 47 } 48 48 49 49 export interface HandlerSuccess { 50 50 - encoding: "application/json"; 51 51 - body: OutputSchema; 52 52 - headers?: { [key: string]: string }; 50 50 + encoding: 'application/json' 51 51 + body: OutputSchema 52 52 + headers?: { [key: string]: string } 53 53 } 54 54 55 55 export interface HandlerError { 56 56 - status: number; 57 57 - message?: string; 56 56 + status: number 57 57 + message?: string 58 58 } 59 59 60 60 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 60 60 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 61 61 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 62 62 - auth: HA; 63 63 - params: QueryParams; 64 64 - input: HandlerInput; 65 65 - req: express.Request; 66 66 - res: express.Response; 67 67 - resetRouteRateLimits: () => Promise<void>; 68 68 - }; 62 62 + auth: HA 63 63 + params: QueryParams 64 64 + input: HandlerInput 65 65 + req: express.Request 66 66 + res: express.Response 67 67 + resetRouteRateLimits: () => Promise<void> 68 68 + } 69 69 export type Handler<HA extends HandlerAuth = never> = ( 70 70 ctx: HandlerReqCtx<HA>, 71 71 - ) => Promise<HandlerOutput> | HandlerOutput; 71 71 + ) => Promise<HandlerOutput> | HandlerOutput

+24 -24

apps/api/src/lexicon/types/io/pocketenv/secret/addSecret.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSecretDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSecretDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 - secret: IoPocketenvSecretDefs.Secret; 15 15 + secret: IoPocketenvSecretDefs.Secret 16 16 /** The redacted secret value. */ 17 17 - redacted?: string; 18 18 - [k: string]: unknown; 17 17 + redacted?: string 18 18 + [k: string]: unknown 19 19 } 20 20 21 21 export interface HandlerInput { 22 22 - encoding: "application/json"; 23 23 - body: InputSchema; 22 22 + encoding: 'application/json' 23 23 + body: InputSchema 24 24 } 25 25 26 26 export interface HandlerError { 27 27 - status: number; 28 28 - message?: string; 27 27 + status: number 28 28 + message?: string 29 29 } 30 30 31 31 - export type HandlerOutput = HandlerError | void; 31 31 + export type HandlerOutput = HandlerError | void 32 32 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: express.Request; 37 37 - res: express.Response; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 33 33 + auth: HA 34 34 + params: QueryParams 35 35 + input: HandlerInput 36 36 + req: express.Request 37 37 + res: express.Response 38 38 + resetRouteRateLimits: () => Promise<void> 39 39 + } 40 40 export type Handler<HA extends HandlerAuth = never> = ( 41 41 ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 42 42 + ) => Promise<HandlerOutput> | HandlerOutput

+20 -20

apps/api/src/lexicon/types/io/pocketenv/secret/defs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 9 9 export interface SecretView { 10 10 /** Unique identifier of the secret. */ 11 11 - id?: string; 11 11 + id?: string 12 12 /** Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc. */ 13 13 - name?: string; 14 14 - [k: string]: unknown; 13 13 + name?: string 14 14 + [k: string]: unknown 15 15 } 16 16 17 17 export function isSecretView(v: unknown): v is SecretView { 18 18 return ( 19 19 isObj(v) && 20 20 - hasProp(v, "$type") && 21 21 - v.$type === "io.pocketenv.secret.defs#secretView" 22 22 - ); 20 20 + hasProp(v, '$type') && 21 21 + v.$type === 'io.pocketenv.secret.defs#secretView' 22 22 + ) 23 23 } 24 24 25 25 export function validateSecretView(v: unknown): ValidationResult { 26 26 - return lexicons.validate("io.pocketenv.secret.defs#secretView", v); 26 26 + return lexicons.validate('io.pocketenv.secret.defs#secretView', v) 27 27 } 28 28 29 29 export interface Secret { 30 30 /** The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment. */ 31 31 - sandboxId?: string; 31 31 + sandboxId?: string 32 32 /** Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc. */ 33 33 - name: string; 33 33 + name: string 34 34 /** Value of the secret. This will be encrypted at rest and redacted in any API responses. */ 35 35 - value: string; 36 36 - [k: string]: unknown; 35 35 + value: string 36 36 + [k: string]: unknown 37 37 } 38 38 39 39 export function isSecret(v: unknown): v is Secret { 40 40 return ( 41 41 isObj(v) && 42 42 - hasProp(v, "$type") && 43 43 - v.$type === "io.pocketenv.secret.defs#secret" 44 44 - ); 42 42 + hasProp(v, '$type') && 43 43 + v.$type === 'io.pocketenv.secret.defs#secret' 44 44 + ) 45 45 } 46 46 47 47 export function validateSecret(v: unknown): ValidationResult { 48 48 - return lexicons.validate("io.pocketenv.secret.defs#secret", v); 48 48 + return lexicons.validate('io.pocketenv.secret.defs#secret', v) 49 49 } 50 50 51 51 - export type Secrets = Secret[]; 51 51 + export type Secrets = Secret[]

+20 -20

apps/api/src/lexicon/types/io/pocketenv/secret/deleteSecret.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 export interface QueryParams { 12 12 /** The ID of the secret to delete */ 13 13 - id: string; 13 13 + id: string 14 14 } 15 15 16 16 - export type InputSchema = undefined; 17 17 - export type HandlerInput = undefined; 16 16 + export type InputSchema = undefined 17 17 + export type HandlerInput = undefined 18 18 19 19 export interface HandlerError { 20 20 - status: number; 21 21 - message?: string; 20 20 + status: number 21 21 + message?: string 22 22 } 23 23 24 24 - export type HandlerOutput = HandlerError | void; 24 24 + export type HandlerOutput = HandlerError | void 25 25 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 26 26 - auth: HA; 27 27 - params: QueryParams; 28 28 - input: HandlerInput; 29 29 - req: express.Request; 30 30 - res: express.Response; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 26 26 + auth: HA 27 27 + params: QueryParams 28 28 + input: HandlerInput 29 29 + req: express.Request 30 30 + res: express.Response 31 31 + resetRouteRateLimits: () => Promise<void> 32 32 + } 33 33 export type Handler<HA extends HandlerAuth = never> = ( 34 34 ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput; 35 35 + ) => Promise<HandlerOutput> | HandlerOutput

+26 -26

apps/api/src/lexicon/types/io/pocketenv/secret/getSecret.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSecretDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSecretDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the secret for which to retrieve secrets. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 17 17 + export type InputSchema = undefined 18 18 19 19 export interface OutputSchema { 20 20 - secret?: IoPocketenvSecretDefs.SecretView; 21 21 - [k: string]: unknown; 20 20 + secret?: IoPocketenvSecretDefs.SecretView 21 21 + [k: string]: unknown 22 22 } 23 23 24 24 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = undefined 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: "application/json"; 28 28 - body: OutputSchema; 29 29 - headers?: { [key: string]: string }; 27 27 + encoding: 'application/json' 28 28 + body: OutputSchema 29 29 + headers?: { [key: string]: string } 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number; 34 34 - message?: string; 33 33 + status: number 34 34 + message?: string 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: express.Request; 43 43 - res: express.Response; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 39 39 + auth: HA 40 40 + params: QueryParams 41 41 + input: HandlerInput 42 42 + req: express.Request 43 43 + res: express.Response 44 44 + resetRouteRateLimits: () => Promise<void> 45 45 + } 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 48 48 + ) => Promise<HandlerOutput> | HandlerOutput

+29 -29

apps/api/src/lexicon/types/io/pocketenv/secret/getSecrets.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSecretDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSecretDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the sandbox for which to retrieve secrets. */ 14 14 - sandboxId?: string; 14 14 + sandboxId?: string 15 15 /** The maximum number of secrets to return. */ 16 16 - limit?: number; 16 16 + limit?: number 17 17 /** The number of secrets to skip before starting to collect the result set. */ 18 18 - offset?: number; 18 18 + offset?: number 19 19 } 20 20 21 21 - export type InputSchema = undefined; 21 21 + export type InputSchema = undefined 22 22 23 23 export interface OutputSchema { 24 24 - secrets?: IoPocketenvSecretDefs.SecretView[]; 24 24 + secrets?: IoPocketenvSecretDefs.SecretView[] 25 25 /** The total number of secrets available. */ 26 26 - total?: number; 27 27 - [k: string]: unknown; 26 26 + total?: number 27 27 + [k: string]: unknown 28 28 } 29 29 30 30 - export type HandlerInput = undefined; 30 30 + export type HandlerInput = undefined 31 31 32 32 export interface HandlerSuccess { 33 33 - encoding: "application/json"; 34 34 - body: OutputSchema; 35 35 - headers?: { [key: string]: string }; 33 33 + encoding: 'application/json' 34 34 + body: OutputSchema 35 35 + headers?: { [key: string]: string } 36 36 } 37 37 38 38 export interface HandlerError { 39 39 - status: number; 40 40 - message?: string; 39 39 + status: number 40 40 + message?: string 41 41 } 42 42 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 44 44 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: express.Request; 49 49 - res: express.Response; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 45 45 + auth: HA 46 46 + params: QueryParams 47 47 + input: HandlerInput 48 48 + req: express.Request 49 49 + res: express.Response 50 50 + resetRouteRateLimits: () => Promise<void> 51 51 + } 52 52 export type Handler<HA extends HandlerAuth = never> = ( 53 53 ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 54 54 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/secret/updateSecret.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvSecretDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvSecretDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The ID of the secret to update. */ 16 16 - id: string; 17 17 - secret: IoPocketenvSecretDefs.Secret; 16 16 + id: string 17 17 + secret: IoPocketenvSecretDefs.Secret 18 18 /** The redacted secret value. */ 19 19 - redacted?: string; 20 20 - [k: string]: unknown; 19 19 + redacted?: string 20 20 + [k: string]: unknown 21 21 } 22 22 23 23 export interface HandlerInput { 24 24 - encoding: "application/json"; 25 25 - body: InputSchema; 24 24 + encoding: 'application/json' 25 25 + body: InputSchema 26 26 } 27 27 28 28 export interface HandlerError { 29 29 - status: number; 30 30 - message?: string; 29 29 + status: number 30 30 + message?: string 31 31 } 32 32 33 33 - export type HandlerOutput = HandlerError | void; 33 33 + export type HandlerOutput = HandlerError | void 34 34 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: express.Request; 39 39 - res: express.Response; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 35 35 + auth: HA 36 36 + params: QueryParams 37 37 + input: HandlerInput 38 38 + req: express.Request 39 39 + res: express.Response 40 40 + resetRouteRateLimits: () => Promise<void> 41 41 + } 42 42 export type Handler<HA extends HandlerAuth = never> = ( 43 43 ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 44 44 + ) => Promise<HandlerOutput> | HandlerOutput

+23 -23

apps/api/src/lexicon/types/io/pocketenv/variable/addVariable.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvVariableDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvVariableDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 - variable: IoPocketenvVariableDefs.Variable; 16 16 - [k: string]: unknown; 15 15 + variable: IoPocketenvVariableDefs.Variable 16 16 + [k: string]: unknown 17 17 } 18 18 19 19 export interface HandlerInput { 20 20 - encoding: "application/json"; 21 21 - body: InputSchema; 20 20 + encoding: 'application/json' 21 21 + body: InputSchema 22 22 } 23 23 24 24 export interface HandlerError { 25 25 - status: number; 26 26 - message?: string; 25 25 + status: number 26 26 + message?: string 27 27 } 28 28 29 29 - export type HandlerOutput = HandlerError | void; 29 29 + export type HandlerOutput = HandlerError | void 30 30 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA; 32 32 - params: QueryParams; 33 33 - input: HandlerInput; 34 34 - req: express.Request; 35 35 - res: express.Response; 36 36 - resetRouteRateLimits: () => Promise<void>; 37 37 - }; 31 31 + auth: HA 32 32 + params: QueryParams 33 33 + input: HandlerInput 34 34 + req: express.Request 35 35 + res: express.Response 36 36 + resetRouteRateLimits: () => Promise<void> 37 37 + } 38 38 export type Handler<HA extends HandlerAuth = never> = ( 39 39 ctx: HandlerReqCtx<HA>, 40 40 - ) => Promise<HandlerOutput> | HandlerOutput; 40 40 + ) => Promise<HandlerOutput> | HandlerOutput

+21 -21

apps/api/src/lexicon/types/io/pocketenv/variable/defs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 9 9 export interface VariableView { 10 10 /** Unique identifier of the environment variable. */ 11 11 - id?: string; 11 11 + id?: string 12 12 /** Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc. */ 13 13 - name?: string; 13 13 + name?: string 14 14 /** Value of the environment variable. This will be visible in API responses and should not contain sensitive information. */ 15 15 - value?: string; 16 16 - [k: string]: unknown; 15 15 + value?: string 16 16 + [k: string]: unknown 17 17 } 18 18 19 19 export function isVariableView(v: unknown): v is VariableView { 20 20 return ( 21 21 isObj(v) && 22 22 - hasProp(v, "$type") && 23 23 - v.$type === "io.pocketenv.variable.defs#variableView" 24 24 - ); 22 22 + hasProp(v, '$type') && 23 23 + v.$type === 'io.pocketenv.variable.defs#variableView' 24 24 + ) 25 25 } 26 26 27 27 export function validateVariableView(v: unknown): ValidationResult { 28 28 - return lexicons.validate("io.pocketenv.variable.defs#variableView", v); 28 28 + return lexicons.validate('io.pocketenv.variable.defs#variableView', v) 29 29 } 30 30 31 31 export interface Variable { 32 32 /** The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment. */ 33 33 - sandboxId?: string; 33 33 + sandboxId?: string 34 34 /** Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc. */ 35 35 - name: string; 35 35 + name: string 36 36 /** Value of the environment variable. This will be visible in API responses and should not contain sensitive information. */ 37 37 - value: string; 38 38 - [k: string]: unknown; 37 37 + value: string 38 38 + [k: string]: unknown 39 39 } 40 40 41 41 export function isVariable(v: unknown): v is Variable { 42 42 return ( 43 43 isObj(v) && 44 44 - hasProp(v, "$type") && 45 45 - v.$type === "io.pocketenv.variable.defs#variable" 46 46 - ); 44 44 + hasProp(v, '$type') && 45 45 + v.$type === 'io.pocketenv.variable.defs#variable' 46 46 + ) 47 47 } 48 48 49 49 export function validateVariable(v: unknown): ValidationResult { 50 50 - return lexicons.validate("io.pocketenv.variable.defs#variable", v); 50 50 + return lexicons.validate('io.pocketenv.variable.defs#variable', v) 51 51 } 52 52 53 53 - export type Variables = EnvVar[]; 53 53 + export type Variables = EnvVar[]

+20 -20

apps/api/src/lexicon/types/io/pocketenv/variable/deleteVariable.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 export interface QueryParams { 12 12 /** The ID of the environment variable to delete */ 13 13 - id: string; 13 13 + id: string 14 14 } 15 15 16 16 - export type InputSchema = undefined; 17 17 - export type HandlerInput = undefined; 16 16 + export type InputSchema = undefined 17 17 + export type HandlerInput = undefined 18 18 19 19 export interface HandlerError { 20 20 - status: number; 21 21 - message?: string; 20 20 + status: number 21 21 + message?: string 22 22 } 23 23 24 24 - export type HandlerOutput = HandlerError | void; 24 24 + export type HandlerOutput = HandlerError | void 25 25 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 26 26 - auth: HA; 27 27 - params: QueryParams; 28 28 - input: HandlerInput; 29 29 - req: express.Request; 30 30 - res: express.Response; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 26 26 + auth: HA 27 27 + params: QueryParams 28 28 + input: HandlerInput 29 29 + req: express.Request 30 30 + res: express.Response 31 31 + resetRouteRateLimits: () => Promise<void> 32 32 + } 33 33 export type Handler<HA extends HandlerAuth = never> = ( 34 34 ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput; 35 35 + ) => Promise<HandlerOutput> | HandlerOutput

+26 -26

apps/api/src/lexicon/types/io/pocketenv/variable/getVariable.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvVariableDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvVariableDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the variable for which to retrieve variables. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 17 17 + export type InputSchema = undefined 18 18 19 19 export interface OutputSchema { 20 20 - variable?: IoPocketenvVariableDefs.VariableView; 21 21 - [k: string]: unknown; 20 20 + variable?: IoPocketenvVariableDefs.VariableView 21 21 + [k: string]: unknown 22 22 } 23 23 24 24 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = undefined 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: "application/json"; 28 28 - body: OutputSchema; 29 29 - headers?: { [key: string]: string }; 27 27 + encoding: 'application/json' 28 28 + body: OutputSchema 29 29 + headers?: { [key: string]: string } 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number; 34 34 - message?: string; 33 33 + status: number 34 34 + message?: string 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: express.Request; 43 43 - res: express.Response; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 39 39 + auth: HA 40 40 + params: QueryParams 41 41 + input: HandlerInput 42 42 + req: express.Request 43 43 + res: express.Response 44 44 + resetRouteRateLimits: () => Promise<void> 45 45 + } 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 48 48 + ) => Promise<HandlerOutput> | HandlerOutput

+29 -29

apps/api/src/lexicon/types/io/pocketenv/variable/getVariables.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvVariableDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvVariableDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the sandbox for which to retrieve variables. */ 14 14 - sandboxId?: string; 14 14 + sandboxId?: string 15 15 /** The maximum number of variables to return. */ 16 16 - limit?: number; 16 16 + limit?: number 17 17 /** The number of variables to skip before starting to collect the result set. */ 18 18 - offset?: number; 18 18 + offset?: number 19 19 } 20 20 21 21 - export type InputSchema = undefined; 21 21 + export type InputSchema = undefined 22 22 23 23 export interface OutputSchema { 24 24 - variables?: IoPocketenvVariableDefs.VariableView[]; 24 24 + variables?: IoPocketenvVariableDefs.VariableView[] 25 25 /** The total number of variables available. */ 26 26 - total?: number; 27 27 - [k: string]: unknown; 26 26 + total?: number 27 27 + [k: string]: unknown 28 28 } 29 29 30 30 - export type HandlerInput = undefined; 30 30 + export type HandlerInput = undefined 31 31 32 32 export interface HandlerSuccess { 33 33 - encoding: "application/json"; 34 34 - body: OutputSchema; 35 35 - headers?: { [key: string]: string }; 33 33 + encoding: 'application/json' 34 34 + body: OutputSchema 35 35 + headers?: { [key: string]: string } 36 36 } 37 37 38 38 export interface HandlerError { 39 39 - status: number; 40 40 - message?: string; 39 39 + status: number 40 40 + message?: string 41 41 } 42 42 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 44 44 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: express.Request; 49 49 - res: express.Response; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 45 45 + auth: HA 46 46 + params: QueryParams 47 47 + input: HandlerInput 48 48 + req: express.Request 49 49 + res: express.Response 50 50 + resetRouteRateLimits: () => Promise<void> 51 51 + } 52 52 export type Handler<HA extends HandlerAuth = never> = ( 53 53 ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 54 54 + ) => Promise<HandlerOutput> | HandlerOutput

+24 -24

apps/api/src/lexicon/types/io/pocketenv/variable/updateVariable.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvVariableDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvVariableDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The ID of the variable to update. */ 16 16 - id: string; 17 17 - variable: IoPocketenvVariableDefs.Variable; 18 18 - [k: string]: unknown; 16 16 + id: string 17 17 + variable: IoPocketenvVariableDefs.Variable 18 18 + [k: string]: unknown 19 19 } 20 20 21 21 export interface HandlerInput { 22 22 - encoding: "application/json"; 23 23 - body: InputSchema; 22 22 + encoding: 'application/json' 23 23 + body: InputSchema 24 24 } 25 25 26 26 export interface HandlerError { 27 27 - status: number; 28 28 - message?: string; 27 27 + status: number 28 28 + message?: string 29 29 } 30 30 31 31 - export type HandlerOutput = HandlerError | void; 31 31 + export type HandlerOutput = HandlerError | void 32 32 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: express.Request; 37 37 - res: express.Response; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 33 33 + auth: HA 34 34 + params: QueryParams 35 35 + input: HandlerInput 36 36 + req: express.Request 37 37 + res: express.Response 38 38 + resetRouteRateLimits: () => Promise<void> 39 39 + } 40 40 export type Handler<HA extends HandlerAuth = never> = ( 41 41 ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 42 42 + ) => Promise<HandlerOutput> | HandlerOutput

+23 -23

apps/api/src/lexicon/types/io/pocketenv/volume/addVolume.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvVolumeDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvVolumeDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 - volume: IoPocketenvVolumeDefs.Volume; 16 16 - [k: string]: unknown; 15 15 + volume: IoPocketenvVolumeDefs.Volume 16 16 + [k: string]: unknown 17 17 } 18 18 19 19 export interface HandlerInput { 20 20 - encoding: "application/json"; 21 21 - body: InputSchema; 20 20 + encoding: 'application/json' 21 21 + body: InputSchema 22 22 } 23 23 24 24 export interface HandlerError { 25 25 - status: number; 26 26 - message?: string; 25 25 + status: number 26 26 + message?: string 27 27 } 28 28 29 29 - export type HandlerOutput = HandlerError | void; 29 29 + export type HandlerOutput = HandlerError | void 30 30 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA; 32 32 - params: QueryParams; 33 33 - input: HandlerInput; 34 34 - req: express.Request; 35 35 - res: express.Response; 36 36 - resetRouteRateLimits: () => Promise<void>; 37 37 - }; 31 31 + auth: HA 32 32 + params: QueryParams 33 33 + input: HandlerInput 34 34 + req: express.Request 35 35 + res: express.Response 36 36 + resetRouteRateLimits: () => Promise<void> 37 37 + } 38 38 export type Handler<HA extends HandlerAuth = never> = ( 39 39 ctx: HandlerReqCtx<HA>, 40 40 - ) => Promise<HandlerOutput> | HandlerOutput; 40 40 + ) => Promise<HandlerOutput> | HandlerOutput

+25 -25

apps/api/src/lexicon/types/io/pocketenv/volume/defs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 - import { lexicons } from "../../../../lexicons"; 6 6 - import { isObj, hasProp } from "../../../../util"; 7 7 - import { CID } from "multiformats/cid"; 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { lexicons } from '../../../../lexicons' 6 6 + import { isObj, hasProp } from '../../../../util' 7 7 + import { CID } from 'multiformats/cid' 8 8 9 9 export interface VolumeView { 10 10 /** Unique identifier of the volume. */ 11 11 - id?: string; 11 11 + id?: string 12 12 /** Name of the volume, e.g. 'data-volume', 'logs', etc. */ 13 13 - name?: string; 13 13 + name?: string 14 14 /** The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc. */ 15 15 - path?: string; 15 15 + path?: string 16 16 /** Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write). */ 17 17 - readOnly?: boolean; 17 17 + readOnly?: boolean 18 18 /** The timestamp when the volume was created. */ 19 19 - createdAt?: string; 19 19 + createdAt?: string 20 20 /** The timestamp when the volume was last updated. */ 21 21 - updatedAt?: string; 22 22 - [k: string]: unknown; 21 21 + updatedAt?: string 22 22 + [k: string]: unknown 23 23 } 24 24 25 25 export function isVolumeView(v: unknown): v is VolumeView { 26 26 return ( 27 27 isObj(v) && 28 28 - hasProp(v, "$type") && 29 29 - v.$type === "io.pocketenv.volume.defs#volumeView" 30 30 - ); 28 28 + hasProp(v, '$type') && 29 29 + v.$type === 'io.pocketenv.volume.defs#volumeView' 30 30 + ) 31 31 } 32 32 33 33 export function validateVolumeView(v: unknown): ValidationResult { 34 34 - return lexicons.validate("io.pocketenv.volume.defs#volumeView", v); 34 34 + return lexicons.validate('io.pocketenv.volume.defs#volumeView', v) 35 35 } 36 36 37 37 - export type Volumes = Volume[]; 37 37 + export type Volumes = Volume[] 38 38 39 39 export interface Volume { 40 40 /** The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment. */ 41 41 - sandboxId?: string; 41 41 + sandboxId?: string 42 42 /** Name of the volume, e.g. 'data-volume', 'logs', etc. */ 43 43 - name: string; 43 43 + name: string 44 44 /** The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc. */ 45 45 - path?: string; 45 45 + path?: string 46 46 /** Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write). */ 47 47 - readOnly?: boolean; 48 48 - [k: string]: unknown; 47 47 + readOnly?: boolean 48 48 + [k: string]: unknown 49 49 } 50 50 51 51 export function isVolume(v: unknown): v is Volume { 52 52 return ( 53 53 isObj(v) && 54 54 - hasProp(v, "$type") && 55 55 - v.$type === "io.pocketenv.volume.defs#volume" 56 56 - ); 54 54 + hasProp(v, '$type') && 55 55 + v.$type === 'io.pocketenv.volume.defs#volume' 56 56 + ) 57 57 } 58 58 59 59 export function validateVolume(v: unknown): ValidationResult { 60 60 - return lexicons.validate("io.pocketenv.volume.defs#volume", v); 60 60 + return lexicons.validate('io.pocketenv.volume.defs#volume', v) 61 61 }

+20 -20

apps/api/src/lexicon/types/io/pocketenv/volume/deleteVolume.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 11 11 export interface QueryParams { 12 12 /** The ID of the volume to delete. */ 13 13 - id: string; 13 13 + id: string 14 14 } 15 15 16 16 - export type InputSchema = undefined; 17 17 - export type HandlerInput = undefined; 16 16 + export type InputSchema = undefined 17 17 + export type HandlerInput = undefined 18 18 19 19 export interface HandlerError { 20 20 - status: number; 21 21 - message?: string; 20 20 + status: number 21 21 + message?: string 22 22 } 23 23 24 24 - export type HandlerOutput = HandlerError | void; 24 24 + export type HandlerOutput = HandlerError | void 25 25 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 26 26 - auth: HA; 27 27 - params: QueryParams; 28 28 - input: HandlerInput; 29 29 - req: express.Request; 30 30 - res: express.Response; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 26 26 + auth: HA 27 27 + params: QueryParams 28 28 + input: HandlerInput 29 29 + req: express.Request 30 30 + res: express.Response 31 31 + resetRouteRateLimits: () => Promise<void> 32 32 + } 33 33 export type Handler<HA extends HandlerAuth = never> = ( 34 34 ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput; 35 35 + ) => Promise<HandlerOutput> | HandlerOutput

+26 -26

apps/api/src/lexicon/types/io/pocketenv/volume/getVolume.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvVolumeDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvVolumeDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the volume for which to retrieve volumes. */ 14 14 - id: string; 14 14 + id: string 15 15 } 16 16 17 17 - export type InputSchema = undefined; 17 17 + export type InputSchema = undefined 18 18 19 19 export interface OutputSchema { 20 20 - volume?: IoPocketenvVolumeDefs.VolumeView; 21 21 - [k: string]: unknown; 20 20 + volume?: IoPocketenvVolumeDefs.VolumeView 21 21 + [k: string]: unknown 22 22 } 23 23 24 24 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = undefined 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: "application/json"; 28 28 - body: OutputSchema; 29 29 - headers?: { [key: string]: string }; 27 27 + encoding: 'application/json' 28 28 + body: OutputSchema 29 29 + headers?: { [key: string]: string } 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number; 34 34 - message?: string; 33 33 + status: number 34 34 + message?: string 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: express.Request; 43 43 - res: express.Response; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 39 39 + auth: HA 40 40 + params: QueryParams 41 41 + input: HandlerInput 42 42 + req: express.Request 43 43 + res: express.Response 44 44 + resetRouteRateLimits: () => Promise<void> 45 45 + } 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 48 48 + ) => Promise<HandlerOutput> | HandlerOutput

+29 -29

apps/api/src/lexicon/types/io/pocketenv/volume/getVolumes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvVolumeDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvVolumeDefs from './defs' 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the sandbox for which to retrieve volumes. */ 14 14 - sandboxId?: string; 14 14 + sandboxId?: string 15 15 /** The maximum number of volumes to return. */ 16 16 - limit?: number; 16 16 + limit?: number 17 17 /** The number of volumes to skip before starting to collect the result set. */ 18 18 - offset?: number; 18 18 + offset?: number 19 19 } 20 20 21 21 - export type InputSchema = undefined; 21 21 + export type InputSchema = undefined 22 22 23 23 export interface OutputSchema { 24 24 - volumes?: IoPocketenvVolumeDefs.VolumeView[]; 24 24 + volumes?: IoPocketenvVolumeDefs.VolumeView[] 25 25 /** The total number of volumes available. */ 26 26 - total?: number; 27 27 - [k: string]: unknown; 26 26 + total?: number 27 27 + [k: string]: unknown 28 28 } 29 29 30 30 - export type HandlerInput = undefined; 30 30 + export type HandlerInput = undefined 31 31 32 32 export interface HandlerSuccess { 33 33 - encoding: "application/json"; 34 34 - body: OutputSchema; 35 35 - headers?: { [key: string]: string }; 33 33 + encoding: 'application/json' 34 34 + body: OutputSchema 35 35 + headers?: { [key: string]: string } 36 36 } 37 37 38 38 export interface HandlerError { 39 39 - status: number; 40 40 - message?: string; 39 39 + status: number 40 40 + message?: string 41 41 } 42 42 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 44 44 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: express.Request; 49 49 - res: express.Response; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 45 45 + auth: HA 46 46 + params: QueryParams 47 47 + input: HandlerInput 48 48 + req: express.Request 49 49 + res: express.Response 50 50 + resetRouteRateLimits: () => Promise<void> 51 51 + } 52 52 export type Handler<HA extends HandlerAuth = never> = ( 53 53 ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 54 54 + ) => Promise<HandlerOutput> | HandlerOutput

+24 -24

apps/api/src/lexicon/types/io/pocketenv/volume/updateVolume.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as IoPocketenvVolumeDefs from "./defs"; 4 4 + import type express from 'express' 5 5 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 + import { lexicons } from '../../../../lexicons' 7 7 + import { isObj, hasProp } from '../../../../util' 8 8 + import { CID } from 'multiformats/cid' 9 9 + import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 + import type * as IoPocketenvVolumeDefs from './defs' 11 11 12 12 - export type QueryParams = {}; 12 12 + export type QueryParams = {} 13 13 14 14 export interface InputSchema { 15 15 /** The ID of the volume to update. */ 16 16 - id: string; 17 17 - volume: IoPocketenvVolumeDefs.Volume; 18 18 - [k: string]: unknown; 16 16 + id: string 17 17 + volume: IoPocketenvVolumeDefs.Volume 18 18 + [k: string]: unknown 19 19 } 20 20 21 21 export interface HandlerInput { 22 22 - encoding: "application/json"; 23 23 - body: InputSchema; 22 22 + encoding: 'application/json' 23 23 + body: InputSchema 24 24 } 25 25 26 26 export interface HandlerError { 27 27 - status: number; 28 28 - message?: string; 27 27 + status: number 28 28 + message?: string 29 29 } 30 30 31 31 - export type HandlerOutput = HandlerError | void; 31 31 + export type HandlerOutput = HandlerError | void 32 32 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: express.Request; 37 37 - res: express.Response; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 33 33 + auth: HA 34 34 + params: QueryParams 35 35 + input: HandlerInput 36 36 + req: express.Request 37 37 + res: express.Response 38 38 + resetRouteRateLimits: () => Promise<void> 39 39 + } 40 40 export type Handler<HA extends HandlerAuth = never> = ( 41 41 ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 42 42 + ) => Promise<HandlerOutput> | HandlerOutput

+2 -2

apps/api/src/lexicon/util.ts

reviewed

··· 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 export function isObj(v: unknown): v is Record<string, unknown> { 5 5 - return typeof v === "object" && v !== null; 5 5 + return typeof v === 'object' && v !== null 6 6 } 7 7 8 8 export function hasProp<K extends PropertyKey>( 9 9 data: object, 10 10 prop: K, 11 11 ): data is Record<K, unknown> { 12 12 - return prop in data; 12 12 + return prop in data 13 13 }

+1

apps/api/src/xrpc/io/pocketenv/sandbox/createSandbox.ts

reviewed

··· 60 60 provider, 61 61 base: input.base.split("/").pop()!, 62 62 repo: input.repo, 63 63 + keepAlive: input.keepAlive, 63 64 }, 64 65 { 65 66 headers: {

+1

apps/api/src/xrpc/io/pocketenv/sandbox/startSandbox.ts

reviewed

··· 56 56 `/v1/sandboxes/${record.id}/start`, 57 57 { 58 58 repo: input.repo, 59 59 + keepAlive: input.keepAlive, 59 60 }, 60 61 { 61 62 headers: {

+2 -1

apps/cf-sandbox/src/index.ts

reviewed

··· 254 254 ); 255 255 256 256 const body = await c.req.json<StartSandboxConfig>(); 257 257 - const { repo } = StartSandboxConfigSchema.parse(body); 257 257 + const { repo, keepAlive } = StartSandboxConfigSchema.parse(body); 258 258 259 259 if (!record) { 260 260 return c.json({ error: "Sandbox not found" }, 404); ··· 297 297 sandbox = await createSandbox("cloudflare", { 298 298 id: record.sandboxId || sandboxId, 299 299 memory: "4GiB", 300 300 + keepAlive, 300 301 }); 301 302 302 303 if (!sandbox) {