+5

apps/api/lexicons/sandbox/defs.json

reviewed

··· 181 181 }, 182 182 "sandboxDetailsPref": { 183 183 "type": "object", 184 184 + "nullable": [ 185 185 + "repo", 186 186 + "description", 187 187 + "topics" 188 188 + ], 184 189 "properties": { 185 190 "name": { 186 191 "type": "string",

+5

apps/api/lexicons/sandbox/putPreferences.json

reviewed

··· 10 10 "schema": { 11 11 "type": "object", 12 12 "required": [ 13 13 + "sandboxId", 13 14 "preferences" 14 15 ], 15 16 "properties": { 17 17 + "sandboxId": { 18 18 + "type": "string", 19 19 + "description": "The sandbox ID or URI" 20 20 + }, 16 21 "preferences": { 17 22 "type": "ref", 18 23 "ref": "io.pocketenv.sandbox.defs#preferences"

+1

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

reviewed

··· 183 183 } 184 184 ["sandboxDetailsPref"] = new ObjectType { 185 185 type = "object" 186 186 + nullable = List("repo", "description", "topics") 186 187 properties { 187 188 ["name"] = new StringType { 188 189 type = "string"

+5 -1

apps/api/pkl/defs/sandbox/putPreferences.pkl

reviewed

··· 10 10 encoding = "application/json" 11 11 schema = new ObjectType { 12 12 type = "object" 13 13 - required = List("preferences") 13 13 + required = List("sandboxId", "preferences") 14 14 properties { 15 15 + ["sandboxId"] = new StringType { 16 16 + type = "string" 17 17 + description = "The sandbox ID or URI" 18 18 + } 15 19 ["preferences"] = new Ref { 16 20 type = "ref" 17 21 ref = "io.pocketenv.sandbox.defs#preferences"

+1

apps/api/pkl/schema/lexicon.pkl

reviewed

··· 44 44 class ObjectType extends BaseType { 45 45 type: "object" 46 46 required: List<String>? 47 47 + nullable: List<String>? 47 48 properties: Mapping<String, StringType | IntegerType | BooleanType | Blob | Ref | Union | Array> 48 49 } 49 50

+177 -177

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 IoPocketenvFileGetFiles from "./types/io/pocketenv/file/getFiles"; 18 18 - import type * as IoPocketenvSandboxClaimSandbox from "./types/io/pocketenv/sandbox/claimSandbox"; 19 19 - import type * as IoPocketenvSandboxCreateIntegration from "./types/io/pocketenv/sandbox/createIntegration"; 20 20 - import type * as IoPocketenvSandboxCreateSandbox from "./types/io/pocketenv/sandbox/createSandbox"; 21 21 - import type * as IoPocketenvSandboxDeleteSandbox from "./types/io/pocketenv/sandbox/deleteSandbox"; 22 22 - import type * as IoPocketenvSandboxGetIntegrations from "./types/io/pocketenv/sandbox/getIntegrations"; 23 23 - import type * as IoPocketenvSandboxGetPreferences from "./types/io/pocketenv/sandbox/getPreferences"; 24 24 - import type * as IoPocketenvSandboxGetSandbox from "./types/io/pocketenv/sandbox/getSandbox"; 25 25 - import type * as IoPocketenvSandboxGetSandboxes from "./types/io/pocketenv/sandbox/getSandboxes"; 26 26 - import type * as IoPocketenvSandboxGetSshKeys from "./types/io/pocketenv/sandbox/getSshKeys"; 27 27 - import type * as IoPocketenvSandboxGetTailscaleAuthKey from "./types/io/pocketenv/sandbox/getTailscaleAuthKey"; 28 28 - import type * as IoPocketenvSandboxGetTailscaleToken from "./types/io/pocketenv/sandbox/getTailscaleToken"; 29 29 - import type * as IoPocketenvSandboxPutPreferences from "./types/io/pocketenv/sandbox/putPreferences"; 30 30 - import type * as IoPocketenvSandboxPutSshKeys from "./types/io/pocketenv/sandbox/putSshKeys"; 31 31 - import type * as IoPocketenvSandboxPutTailscaleAuthKey from "./types/io/pocketenv/sandbox/putTailscaleAuthKey"; 32 32 - import type * as IoPocketenvSandboxPutTailscaleToken from "./types/io/pocketenv/sandbox/putTailscaleToken"; 33 33 - import type * as IoPocketenvSandboxStartSandbox from "./types/io/pocketenv/sandbox/startSandbox"; 34 34 - import type * as IoPocketenvSandboxStopSandbox from "./types/io/pocketenv/sandbox/stopSandbox"; 35 35 - import type * as IoPocketenvSandboxUpdateSandboxSettings from "./types/io/pocketenv/sandbox/updateSandboxSettings"; 36 36 - import type * as IoPocketenvSecretAddSecret from "./types/io/pocketenv/secret/addSecret"; 37 37 - import type * as IoPocketenvSecretDeleteSecret from "./types/io/pocketenv/secret/deleteSecret"; 38 38 - import type * as IoPocketenvSecretGetSecrets from "./types/io/pocketenv/secret/getSecrets"; 39 39 - import type * as IoPocketenvVariableAddVariable from "./types/io/pocketenv/variable/addVariable"; 40 40 - import type * as IoPocketenvVariableDeleteVariable from "./types/io/pocketenv/variable/deleteVariable"; 41 41 - import type * as IoPocketenvVariableGetVariables from "./types/io/pocketenv/variable/getVariables"; 42 42 - import type * as IoPocketenvVolumeAddVolume from "./types/io/pocketenv/volume/addVolume"; 43 43 - import type * as IoPocketenvVolumeDeleteVolume from "./types/io/pocketenv/volume/deleteVolume"; 44 44 - import type * as IoPocketenvVolumeGetVolumes from "./types/io/pocketenv/volume/getVolumes"; 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 IoPocketenvFileGetFiles from './types/io/pocketenv/file/getFiles' 18 18 + import type * as IoPocketenvSandboxClaimSandbox from './types/io/pocketenv/sandbox/claimSandbox' 19 19 + import type * as IoPocketenvSandboxCreateIntegration from './types/io/pocketenv/sandbox/createIntegration' 20 20 + import type * as IoPocketenvSandboxCreateSandbox from './types/io/pocketenv/sandbox/createSandbox' 21 21 + import type * as IoPocketenvSandboxDeleteSandbox from './types/io/pocketenv/sandbox/deleteSandbox' 22 22 + import type * as IoPocketenvSandboxGetIntegrations from './types/io/pocketenv/sandbox/getIntegrations' 23 23 + import type * as IoPocketenvSandboxGetPreferences from './types/io/pocketenv/sandbox/getPreferences' 24 24 + import type * as IoPocketenvSandboxGetSandbox from './types/io/pocketenv/sandbox/getSandbox' 25 25 + import type * as IoPocketenvSandboxGetSandboxes from './types/io/pocketenv/sandbox/getSandboxes' 26 26 + import type * as IoPocketenvSandboxGetSshKeys from './types/io/pocketenv/sandbox/getSshKeys' 27 27 + import type * as IoPocketenvSandboxGetTailscaleAuthKey from './types/io/pocketenv/sandbox/getTailscaleAuthKey' 28 28 + import type * as IoPocketenvSandboxGetTailscaleToken from './types/io/pocketenv/sandbox/getTailscaleToken' 29 29 + import type * as IoPocketenvSandboxPutPreferences from './types/io/pocketenv/sandbox/putPreferences' 30 30 + import type * as IoPocketenvSandboxPutSshKeys from './types/io/pocketenv/sandbox/putSshKeys' 31 31 + import type * as IoPocketenvSandboxPutTailscaleAuthKey from './types/io/pocketenv/sandbox/putTailscaleAuthKey' 32 32 + import type * as IoPocketenvSandboxPutTailscaleToken from './types/io/pocketenv/sandbox/putTailscaleToken' 33 33 + import type * as IoPocketenvSandboxStartSandbox from './types/io/pocketenv/sandbox/startSandbox' 34 34 + import type * as IoPocketenvSandboxStopSandbox from './types/io/pocketenv/sandbox/stopSandbox' 35 35 + import type * as IoPocketenvSandboxUpdateSandboxSettings from './types/io/pocketenv/sandbox/updateSandboxSettings' 36 36 + import type * as IoPocketenvSecretAddSecret from './types/io/pocketenv/secret/addSecret' 37 37 + import type * as IoPocketenvSecretDeleteSecret from './types/io/pocketenv/secret/deleteSecret' 38 38 + import type * as IoPocketenvSecretGetSecrets from './types/io/pocketenv/secret/getSecrets' 39 39 + import type * as IoPocketenvVariableAddVariable from './types/io/pocketenv/variable/addVariable' 40 40 + import type * as IoPocketenvVariableDeleteVariable from './types/io/pocketenv/variable/deleteVariable' 41 41 + import type * as IoPocketenvVariableGetVariables from './types/io/pocketenv/variable/getVariables' 42 42 + import type * as IoPocketenvVolumeAddVolume from './types/io/pocketenv/volume/addVolume' 43 43 + import type * as IoPocketenvVolumeDeleteVolume from './types/io/pocketenv/volume/deleteVolume' 44 44 + import type * as IoPocketenvVolumeGetVolumes from './types/io/pocketenv/volume/getVolumes' 45 45 46 46 export function createServer(options?: XrpcOptions): Server { 47 47 - return new Server(options); 47 47 + return new Server(options) 48 48 } 49 49 50 50 export class Server { 51 51 - xrpc: XrpcServer; 52 52 - io: IoNS; 53 53 - app: AppNS; 54 54 - com: ComNS; 51 51 + xrpc: XrpcServer 52 52 + io: IoNS 53 53 + app: AppNS 54 54 + com: ComNS 55 55 56 56 constructor(options?: XrpcOptions) { 57 57 - this.xrpc = createXrpcServer(schemas, options); 58 58 - this.io = new IoNS(this); 59 59 - this.app = new AppNS(this); 60 60 - this.com = new ComNS(this); 57 57 + this.xrpc = createXrpcServer(schemas, options) 58 58 + this.io = new IoNS(this) 59 59 + this.app = new AppNS(this) 60 60 + this.com = new ComNS(this) 61 61 } 62 62 } 63 63 64 64 export class IoNS { 65 65 - _server: Server; 66 66 - pocketenv: IoPocketenvNS; 65 65 + _server: Server 66 66 + pocketenv: IoPocketenvNS 67 67 68 68 constructor(server: Server) { 69 69 - this._server = server; 70 70 - this.pocketenv = new IoPocketenvNS(server); 69 69 + this._server = server 70 70 + this.pocketenv = new IoPocketenvNS(server) 71 71 } 72 72 } 73 73 74 74 export class IoPocketenvNS { 75 75 - _server: Server; 76 76 - actor: IoPocketenvActorNS; 77 77 - file: IoPocketenvFileNS; 78 78 - sandbox: IoPocketenvSandboxNS; 79 79 - secret: IoPocketenvSecretNS; 80 80 - variable: IoPocketenvVariableNS; 81 81 - volume: IoPocketenvVolumeNS; 75 75 + _server: Server 76 76 + actor: IoPocketenvActorNS 77 77 + file: IoPocketenvFileNS 78 78 + sandbox: IoPocketenvSandboxNS 79 79 + secret: IoPocketenvSecretNS 80 80 + variable: IoPocketenvVariableNS 81 81 + volume: IoPocketenvVolumeNS 82 82 83 83 constructor(server: Server) { 84 84 - this._server = server; 85 85 - this.actor = new IoPocketenvActorNS(server); 86 86 - this.file = new IoPocketenvFileNS(server); 87 87 - this.sandbox = new IoPocketenvSandboxNS(server); 88 88 - this.secret = new IoPocketenvSecretNS(server); 89 89 - this.variable = new IoPocketenvVariableNS(server); 90 90 - this.volume = new IoPocketenvVolumeNS(server); 84 84 + this._server = server 85 85 + this.actor = new IoPocketenvActorNS(server) 86 86 + this.file = new IoPocketenvFileNS(server) 87 87 + this.sandbox = new IoPocketenvSandboxNS(server) 88 88 + this.secret = new IoPocketenvSecretNS(server) 89 89 + this.variable = new IoPocketenvVariableNS(server) 90 90 + this.volume = new IoPocketenvVolumeNS(server) 91 91 } 92 92 } 93 93 94 94 export class IoPocketenvActorNS { 95 95 - _server: Server; 95 95 + _server: Server 96 96 97 97 constructor(server: Server) { 98 98 - this._server = server; 98 98 + this._server = server 99 99 } 100 100 101 101 getActorSandboxes<AV extends AuthVerifier>( ··· 105 105 IoPocketenvActorGetActorSandboxes.HandlerReqCtx<ExtractAuth<AV>> 106 106 >, 107 107 ) { 108 108 - const nsid = "io.pocketenv.actor.getActorSandboxes"; // @ts-ignore 109 109 - return this._server.xrpc.method(nsid, cfg); 108 108 + const nsid = 'io.pocketenv.actor.getActorSandboxes' // @ts-ignore 109 109 + return this._server.xrpc.method(nsid, cfg) 110 110 } 111 111 112 112 getProfile<AV extends AuthVerifier>( ··· 116 116 IoPocketenvActorGetProfile.HandlerReqCtx<ExtractAuth<AV>> 117 117 >, 118 118 ) { 119 119 - const nsid = "io.pocketenv.actor.getProfile"; // @ts-ignore 120 120 - return this._server.xrpc.method(nsid, cfg); 119 119 + const nsid = 'io.pocketenv.actor.getProfile' // @ts-ignore 120 120 + return this._server.xrpc.method(nsid, cfg) 121 121 } 122 122 123 123 getTerminalToken<AV extends AuthVerifier>( ··· 127 127 IoPocketenvActorGetTerminalToken.HandlerReqCtx<ExtractAuth<AV>> 128 128 >, 129 129 ) { 130 130 - const nsid = "io.pocketenv.actor.getTerminalToken"; // @ts-ignore 131 131 - return this._server.xrpc.method(nsid, cfg); 130 130 + const nsid = 'io.pocketenv.actor.getTerminalToken' // @ts-ignore 131 131 + return this._server.xrpc.method(nsid, cfg) 132 132 } 133 133 } 134 134 135 135 export class IoPocketenvFileNS { 136 136 - _server: Server; 136 136 + _server: Server 137 137 138 138 constructor(server: Server) { 139 139 - this._server = server; 139 139 + this._server = server 140 140 } 141 141 142 142 addFile<AV extends AuthVerifier>( ··· 146 146 IoPocketenvFileAddFile.HandlerReqCtx<ExtractAuth<AV>> 147 147 >, 148 148 ) { 149 149 - const nsid = "io.pocketenv.file.addFile"; // @ts-ignore 150 150 - return this._server.xrpc.method(nsid, cfg); 149 149 + const nsid = 'io.pocketenv.file.addFile' // @ts-ignore 150 150 + return this._server.xrpc.method(nsid, cfg) 151 151 } 152 152 153 153 deleteFile<AV extends AuthVerifier>( ··· 157 157 IoPocketenvFileDeleteFile.HandlerReqCtx<ExtractAuth<AV>> 158 158 >, 159 159 ) { 160 160 - const nsid = "io.pocketenv.file.deleteFile"; // @ts-ignore 161 161 - return this._server.xrpc.method(nsid, cfg); 160 160 + const nsid = 'io.pocketenv.file.deleteFile' // @ts-ignore 161 161 + return this._server.xrpc.method(nsid, cfg) 162 162 } 163 163 164 164 getFiles<AV extends AuthVerifier>( ··· 168 168 IoPocketenvFileGetFiles.HandlerReqCtx<ExtractAuth<AV>> 169 169 >, 170 170 ) { 171 171 - const nsid = "io.pocketenv.file.getFiles"; // @ts-ignore 172 172 - return this._server.xrpc.method(nsid, cfg); 171 171 + const nsid = 'io.pocketenv.file.getFiles' // @ts-ignore 172 172 + return this._server.xrpc.method(nsid, cfg) 173 173 } 174 174 } 175 175 176 176 export class IoPocketenvSandboxNS { 177 177 - _server: Server; 177 177 + _server: Server 178 178 179 179 constructor(server: Server) { 180 180 - this._server = server; 180 180 + this._server = server 181 181 } 182 182 183 183 claimSandbox<AV extends AuthVerifier>( ··· 187 187 IoPocketenvSandboxClaimSandbox.HandlerReqCtx<ExtractAuth<AV>> 188 188 >, 189 189 ) { 190 190 - const nsid = "io.pocketenv.sandbox.claimSandbox"; // @ts-ignore 191 191 - return this._server.xrpc.method(nsid, cfg); 190 190 + const nsid = 'io.pocketenv.sandbox.claimSandbox' // @ts-ignore 191 191 + return this._server.xrpc.method(nsid, cfg) 192 192 } 193 193 194 194 createIntegration<AV extends AuthVerifier>( ··· 198 198 IoPocketenvSandboxCreateIntegration.HandlerReqCtx<ExtractAuth<AV>> 199 199 >, 200 200 ) { 201 201 - const nsid = "io.pocketenv.sandbox.createIntegration"; // @ts-ignore 202 202 - return this._server.xrpc.method(nsid, cfg); 201 201 + const nsid = 'io.pocketenv.sandbox.createIntegration' // @ts-ignore 202 202 + return this._server.xrpc.method(nsid, cfg) 203 203 } 204 204 205 205 createSandbox<AV extends AuthVerifier>( ··· 209 209 IoPocketenvSandboxCreateSandbox.HandlerReqCtx<ExtractAuth<AV>> 210 210 >, 211 211 ) { 212 212 - const nsid = "io.pocketenv.sandbox.createSandbox"; // @ts-ignore 213 213 - return this._server.xrpc.method(nsid, cfg); 212 212 + const nsid = 'io.pocketenv.sandbox.createSandbox' // @ts-ignore 213 213 + return this._server.xrpc.method(nsid, cfg) 214 214 } 215 215 216 216 deleteSandbox<AV extends AuthVerifier>( ··· 220 220 IoPocketenvSandboxDeleteSandbox.HandlerReqCtx<ExtractAuth<AV>> 221 221 >, 222 222 ) { 223 223 - const nsid = "io.pocketenv.sandbox.deleteSandbox"; // @ts-ignore 224 224 - return this._server.xrpc.method(nsid, cfg); 223 223 + const nsid = 'io.pocketenv.sandbox.deleteSandbox' // @ts-ignore 224 224 + return this._server.xrpc.method(nsid, cfg) 225 225 } 226 226 227 227 getIntegrations<AV extends AuthVerifier>( ··· 231 231 IoPocketenvSandboxGetIntegrations.HandlerReqCtx<ExtractAuth<AV>> 232 232 >, 233 233 ) { 234 234 - const nsid = "io.pocketenv.sandbox.getIntegrations"; // @ts-ignore 235 235 - return this._server.xrpc.method(nsid, cfg); 234 234 + const nsid = 'io.pocketenv.sandbox.getIntegrations' // @ts-ignore 235 235 + return this._server.xrpc.method(nsid, cfg) 236 236 } 237 237 238 238 getPreferences<AV extends AuthVerifier>( ··· 242 242 IoPocketenvSandboxGetPreferences.HandlerReqCtx<ExtractAuth<AV>> 243 243 >, 244 244 ) { 245 245 - const nsid = "io.pocketenv.sandbox.getPreferences"; // @ts-ignore 246 246 - return this._server.xrpc.method(nsid, cfg); 245 245 + const nsid = 'io.pocketenv.sandbox.getPreferences' // @ts-ignore 246 246 + return this._server.xrpc.method(nsid, cfg) 247 247 } 248 248 249 249 getSandbox<AV extends AuthVerifier>( ··· 253 253 IoPocketenvSandboxGetSandbox.HandlerReqCtx<ExtractAuth<AV>> 254 254 >, 255 255 ) { 256 256 - const nsid = "io.pocketenv.sandbox.getSandbox"; // @ts-ignore 257 257 - return this._server.xrpc.method(nsid, cfg); 256 256 + const nsid = 'io.pocketenv.sandbox.getSandbox' // @ts-ignore 257 257 + return this._server.xrpc.method(nsid, cfg) 258 258 } 259 259 260 260 getSandboxes<AV extends AuthVerifier>( ··· 264 264 IoPocketenvSandboxGetSandboxes.HandlerReqCtx<ExtractAuth<AV>> 265 265 >, 266 266 ) { 267 267 - const nsid = "io.pocketenv.sandbox.getSandboxes"; // @ts-ignore 268 268 - return this._server.xrpc.method(nsid, cfg); 267 267 + const nsid = 'io.pocketenv.sandbox.getSandboxes' // @ts-ignore 268 268 + return this._server.xrpc.method(nsid, cfg) 269 269 } 270 270 271 271 getSshKeys<AV extends AuthVerifier>( ··· 275 275 IoPocketenvSandboxGetSshKeys.HandlerReqCtx<ExtractAuth<AV>> 276 276 >, 277 277 ) { 278 278 - const nsid = "io.pocketenv.sandbox.getSshKeys"; // @ts-ignore 279 279 - return this._server.xrpc.method(nsid, cfg); 278 278 + const nsid = 'io.pocketenv.sandbox.getSshKeys' // @ts-ignore 279 279 + return this._server.xrpc.method(nsid, cfg) 280 280 } 281 281 282 282 getTailscaleAuthKey<AV extends AuthVerifier>( ··· 286 286 IoPocketenvSandboxGetTailscaleAuthKey.HandlerReqCtx<ExtractAuth<AV>> 287 287 >, 288 288 ) { 289 289 - const nsid = "io.pocketenv.sandbox.getTailscaleAuthKey"; // @ts-ignore 290 290 - return this._server.xrpc.method(nsid, cfg); 289 289 + const nsid = 'io.pocketenv.sandbox.getTailscaleAuthKey' // @ts-ignore 290 290 + return this._server.xrpc.method(nsid, cfg) 291 291 } 292 292 293 293 getTailscaleToken<AV extends AuthVerifier>( ··· 297 297 IoPocketenvSandboxGetTailscaleToken.HandlerReqCtx<ExtractAuth<AV>> 298 298 >, 299 299 ) { 300 300 - const nsid = "io.pocketenv.sandbox.getTailscaleToken"; // @ts-ignore 301 301 - return this._server.xrpc.method(nsid, cfg); 300 300 + const nsid = 'io.pocketenv.sandbox.getTailscaleToken' // @ts-ignore 301 301 + return this._server.xrpc.method(nsid, cfg) 302 302 } 303 303 304 304 putPreferences<AV extends AuthVerifier>( ··· 308 308 IoPocketenvSandboxPutPreferences.HandlerReqCtx<ExtractAuth<AV>> 309 309 >, 310 310 ) { 311 311 - const nsid = "io.pocketenv.sandbox.putPreferences"; // @ts-ignore 312 312 - return this._server.xrpc.method(nsid, cfg); 311 311 + const nsid = 'io.pocketenv.sandbox.putPreferences' // @ts-ignore 312 312 + return this._server.xrpc.method(nsid, cfg) 313 313 } 314 314 315 315 putSshKeys<AV extends AuthVerifier>( ··· 319 319 IoPocketenvSandboxPutSshKeys.HandlerReqCtx<ExtractAuth<AV>> 320 320 >, 321 321 ) { 322 322 - const nsid = "io.pocketenv.sandbox.putSshKeys"; // @ts-ignore 323 323 - return this._server.xrpc.method(nsid, cfg); 322 322 + const nsid = 'io.pocketenv.sandbox.putSshKeys' // @ts-ignore 323 323 + return this._server.xrpc.method(nsid, cfg) 324 324 } 325 325 326 326 putTailscaleAuthKey<AV extends AuthVerifier>( ··· 330 330 IoPocketenvSandboxPutTailscaleAuthKey.HandlerReqCtx<ExtractAuth<AV>> 331 331 >, 332 332 ) { 333 333 - const nsid = "io.pocketenv.sandbox.putTailscaleAuthKey"; // @ts-ignore 334 334 - return this._server.xrpc.method(nsid, cfg); 333 333 + const nsid = 'io.pocketenv.sandbox.putTailscaleAuthKey' // @ts-ignore 334 334 + return this._server.xrpc.method(nsid, cfg) 335 335 } 336 336 337 337 putTailscaleToken<AV extends AuthVerifier>( ··· 341 341 IoPocketenvSandboxPutTailscaleToken.HandlerReqCtx<ExtractAuth<AV>> 342 342 >, 343 343 ) { 344 344 - const nsid = "io.pocketenv.sandbox.putTailscaleToken"; // @ts-ignore 345 345 - return this._server.xrpc.method(nsid, cfg); 344 344 + const nsid = 'io.pocketenv.sandbox.putTailscaleToken' // @ts-ignore 345 345 + return this._server.xrpc.method(nsid, cfg) 346 346 } 347 347 348 348 startSandbox<AV extends AuthVerifier>( ··· 352 352 IoPocketenvSandboxStartSandbox.HandlerReqCtx<ExtractAuth<AV>> 353 353 >, 354 354 ) { 355 355 - const nsid = "io.pocketenv.sandbox.startSandbox"; // @ts-ignore 356 356 - return this._server.xrpc.method(nsid, cfg); 355 355 + const nsid = 'io.pocketenv.sandbox.startSandbox' // @ts-ignore 356 356 + return this._server.xrpc.method(nsid, cfg) 357 357 } 358 358 359 359 stopSandbox<AV extends AuthVerifier>( ··· 363 363 IoPocketenvSandboxStopSandbox.HandlerReqCtx<ExtractAuth<AV>> 364 364 >, 365 365 ) { 366 366 - const nsid = "io.pocketenv.sandbox.stopSandbox"; // @ts-ignore 367 367 - return this._server.xrpc.method(nsid, cfg); 366 366 + const nsid = 'io.pocketenv.sandbox.stopSandbox' // @ts-ignore 367 367 + return this._server.xrpc.method(nsid, cfg) 368 368 } 369 369 370 370 updateSandboxSettings<AV extends AuthVerifier>( ··· 374 374 IoPocketenvSandboxUpdateSandboxSettings.HandlerReqCtx<ExtractAuth<AV>> 375 375 >, 376 376 ) { 377 377 - const nsid = "io.pocketenv.sandbox.updateSandboxSettings"; // @ts-ignore 378 378 - return this._server.xrpc.method(nsid, cfg); 377 377 + const nsid = 'io.pocketenv.sandbox.updateSandboxSettings' // @ts-ignore 378 378 + return this._server.xrpc.method(nsid, cfg) 379 379 } 380 380 } 381 381 382 382 export class IoPocketenvSecretNS { 383 383 - _server: Server; 383 383 + _server: Server 384 384 385 385 constructor(server: Server) { 386 386 - this._server = server; 386 386 + this._server = server 387 387 } 388 388 389 389 addSecret<AV extends AuthVerifier>( ··· 393 393 IoPocketenvSecretAddSecret.HandlerReqCtx<ExtractAuth<AV>> 394 394 >, 395 395 ) { 396 396 - const nsid = "io.pocketenv.secret.addSecret"; // @ts-ignore 397 397 - return this._server.xrpc.method(nsid, cfg); 396 396 + const nsid = 'io.pocketenv.secret.addSecret' // @ts-ignore 397 397 + return this._server.xrpc.method(nsid, cfg) 398 398 } 399 399 400 400 deleteSecret<AV extends AuthVerifier>( ··· 404 404 IoPocketenvSecretDeleteSecret.HandlerReqCtx<ExtractAuth<AV>> 405 405 >, 406 406 ) { 407 407 - const nsid = "io.pocketenv.secret.deleteSecret"; // @ts-ignore 408 408 - return this._server.xrpc.method(nsid, cfg); 407 407 + const nsid = 'io.pocketenv.secret.deleteSecret' // @ts-ignore 408 408 + return this._server.xrpc.method(nsid, cfg) 409 409 } 410 410 411 411 getSecrets<AV extends AuthVerifier>( ··· 415 415 IoPocketenvSecretGetSecrets.HandlerReqCtx<ExtractAuth<AV>> 416 416 >, 417 417 ) { 418 418 - const nsid = "io.pocketenv.secret.getSecrets"; // @ts-ignore 419 419 - return this._server.xrpc.method(nsid, cfg); 418 418 + const nsid = 'io.pocketenv.secret.getSecrets' // @ts-ignore 419 419 + return this._server.xrpc.method(nsid, cfg) 420 420 } 421 421 } 422 422 423 423 export class IoPocketenvVariableNS { 424 424 - _server: Server; 424 424 + _server: Server 425 425 426 426 constructor(server: Server) { 427 427 - this._server = server; 427 427 + this._server = server 428 428 } 429 429 430 430 addVariable<AV extends AuthVerifier>( ··· 434 434 IoPocketenvVariableAddVariable.HandlerReqCtx<ExtractAuth<AV>> 435 435 >, 436 436 ) { 437 437 - const nsid = "io.pocketenv.variable.addVariable"; // @ts-ignore 438 438 - return this._server.xrpc.method(nsid, cfg); 437 437 + const nsid = 'io.pocketenv.variable.addVariable' // @ts-ignore 438 438 + return this._server.xrpc.method(nsid, cfg) 439 439 } 440 440 441 441 deleteVariable<AV extends AuthVerifier>( ··· 445 445 IoPocketenvVariableDeleteVariable.HandlerReqCtx<ExtractAuth<AV>> 446 446 >, 447 447 ) { 448 448 - const nsid = "io.pocketenv.variable.deleteVariable"; // @ts-ignore 449 449 - return this._server.xrpc.method(nsid, cfg); 448 448 + const nsid = 'io.pocketenv.variable.deleteVariable' // @ts-ignore 449 449 + return this._server.xrpc.method(nsid, cfg) 450 450 } 451 451 452 452 getVariables<AV extends AuthVerifier>( ··· 456 456 IoPocketenvVariableGetVariables.HandlerReqCtx<ExtractAuth<AV>> 457 457 >, 458 458 ) { 459 459 - const nsid = "io.pocketenv.variable.getVariables"; // @ts-ignore 460 460 - return this._server.xrpc.method(nsid, cfg); 459 459 + const nsid = 'io.pocketenv.variable.getVariables' // @ts-ignore 460 460 + return this._server.xrpc.method(nsid, cfg) 461 461 } 462 462 } 463 463 464 464 export class IoPocketenvVolumeNS { 465 465 - _server: Server; 465 465 + _server: Server 466 466 467 467 constructor(server: Server) { 468 468 - this._server = server; 468 468 + this._server = server 469 469 } 470 470 471 471 addVolume<AV extends AuthVerifier>( ··· 475 475 IoPocketenvVolumeAddVolume.HandlerReqCtx<ExtractAuth<AV>> 476 476 >, 477 477 ) { 478 478 - const nsid = "io.pocketenv.volume.addVolume"; // @ts-ignore 479 479 - return this._server.xrpc.method(nsid, cfg); 478 478 + const nsid = 'io.pocketenv.volume.addVolume' // @ts-ignore 479 479 + return this._server.xrpc.method(nsid, cfg) 480 480 } 481 481 482 482 deleteVolume<AV extends AuthVerifier>( ··· 486 486 IoPocketenvVolumeDeleteVolume.HandlerReqCtx<ExtractAuth<AV>> 487 487 >, 488 488 ) { 489 489 - const nsid = "io.pocketenv.volume.deleteVolume"; // @ts-ignore 490 490 - return this._server.xrpc.method(nsid, cfg); 489 489 + const nsid = 'io.pocketenv.volume.deleteVolume' // @ts-ignore 490 490 + return this._server.xrpc.method(nsid, cfg) 491 491 } 492 492 493 493 getVolumes<AV extends AuthVerifier>( ··· 497 497 IoPocketenvVolumeGetVolumes.HandlerReqCtx<ExtractAuth<AV>> 498 498 >, 499 499 ) { 500 500 - const nsid = "io.pocketenv.volume.getVolumes"; // @ts-ignore 501 501 - return this._server.xrpc.method(nsid, cfg); 500 500 + const nsid = 'io.pocketenv.volume.getVolumes' // @ts-ignore 501 501 + return this._server.xrpc.method(nsid, cfg) 502 502 } 503 503 } 504 504 505 505 export class AppNS { 506 506 - _server: Server; 507 507 - bsky: AppBskyNS; 506 506 + _server: Server 507 507 + bsky: AppBskyNS 508 508 509 509 constructor(server: Server) { 510 510 - this._server = server; 511 511 - this.bsky = new AppBskyNS(server); 510 510 + this._server = server 511 511 + this.bsky = new AppBskyNS(server) 512 512 } 513 513 } 514 514 515 515 export class AppBskyNS { 516 516 - _server: Server; 517 517 - actor: AppBskyActorNS; 516 516 + _server: Server 517 517 + actor: AppBskyActorNS 518 518 519 519 constructor(server: Server) { 520 520 - this._server = server; 521 521 - this.actor = new AppBskyActorNS(server); 520 520 + this._server = server 521 521 + this.actor = new AppBskyActorNS(server) 522 522 } 523 523 } 524 524 525 525 export class AppBskyActorNS { 526 526 - _server: Server; 526 526 + _server: Server 527 527 528 528 constructor(server: Server) { 529 529 - this._server = server; 529 529 + this._server = server 530 530 } 531 531 } 532 532 533 533 export class ComNS { 534 534 - _server: Server; 535 535 - atproto: ComAtprotoNS; 534 534 + _server: Server 535 535 + atproto: ComAtprotoNS 536 536 537 537 constructor(server: Server) { 538 538 - this._server = server; 539 539 - this.atproto = new ComAtprotoNS(server); 538 538 + this._server = server 539 539 + this.atproto = new ComAtprotoNS(server) 540 540 } 541 541 } 542 542 543 543 export class ComAtprotoNS { 544 544 - _server: Server; 545 545 - repo: ComAtprotoRepoNS; 544 544 + _server: Server 545 545 + repo: ComAtprotoRepoNS 546 546 547 547 constructor(server: Server) { 548 548 - this._server = server; 549 549 - this.repo = new ComAtprotoRepoNS(server); 548 548 + this._server = server 549 549 + this.repo = new ComAtprotoRepoNS(server) 550 550 } 551 551 } 552 552 553 553 export class ComAtprotoRepoNS { 554 554 - _server: Server; 554 554 + _server: Server 555 555 556 556 constructor(server: Server) { 557 557 - this._server = server; 557 557 + this._server = server 558 558 } 559 559 } 560 560 561 561 type SharedRateLimitOpts<T> = { 562 562 - name: string; 563 563 - calcKey?: (ctx: T) => string | null; 564 564 - calcPoints?: (ctx: T) => number; 565 565 - }; 562 562 + name: string 563 563 + calcKey?: (ctx: T) => string | null 564 564 + calcPoints?: (ctx: T) => number 565 565 + } 566 566 type RouteRateLimitOpts<T> = { 567 567 - durationMs: number; 568 568 - points: number; 569 569 - calcKey?: (ctx: T) => string | null; 570 570 - calcPoints?: (ctx: T) => number; 571 571 - }; 572 572 - type HandlerOpts = { blobLimit?: number }; 573 573 - type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>; 567 567 + durationMs: number 568 568 + points: number 569 569 + calcKey?: (ctx: T) => string | null 570 570 + calcPoints?: (ctx: T) => number 571 571 + } 572 572 + type HandlerOpts = { blobLimit?: number } 573 573 + type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T> 574 574 type ConfigOf<Auth, Handler, ReqCtx> = 575 575 | Handler 576 576 | { 577 577 - auth?: Auth; 578 578 - opts?: HandlerOpts; 579 579 - rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]; 580 580 - handler: Handler; 581 581 - }; 577 577 + auth?: Auth 578 578 + opts?: HandlerOpts 579 579 + rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[] 580 580 + handler: Handler 581 581 + } 582 582 type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract< 583 583 Awaited<ReturnType<AV>>, 584 584 { credentials: unknown } 585 585 - >; 585 585 + >

+817 -812

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 IoPocketenvFileGetFiles: { 311 311 lexicon: 1, 312 312 - id: "io.pocketenv.file.getFiles", 312 312 + id: 'io.pocketenv.file.getFiles', 313 313 defs: { 314 314 main: { 315 315 - type: "query", 315 315 + type: 'query', 316 316 parameters: { 317 317 - type: "params", 317 317 + type: 'params', 318 318 properties: { 319 319 sandboxId: { 320 320 - type: "string", 321 321 - description: "The ID of the sandbox for which to retrieve files.", 320 320 + type: 'string', 321 321 + description: 'The ID of the sandbox for which to retrieve files.', 322 322 }, 323 323 limit: { 324 324 - type: "integer", 325 325 - description: "The maximum number of files to return.", 324 324 + type: 'integer', 325 325 + description: 'The maximum number of files to return.', 326 326 minimum: 1, 327 327 }, 328 328 offset: { 329 329 - type: "integer", 329 329 + type: 'integer', 330 330 description: 331 331 - "The number of files to skip before starting to collect the result set.", 331 331 + 'The number of files to skip before starting to collect the result set.', 332 332 minimum: 0, 333 333 }, 334 334 }, 335 335 }, 336 336 output: { 337 337 - encoding: "application/json", 337 337 + encoding: 'application/json', 338 338 schema: { 339 339 - type: "object", 339 339 + type: 'object', 340 340 properties: { 341 341 files: { 342 342 - type: "array", 342 342 + type: 'array', 343 343 items: { 344 344 - type: "ref", 345 345 - ref: "lex:io.pocketenv.file.defs#fileView", 344 344 + type: 'ref', 345 345 + ref: 'lex:io.pocketenv.file.defs#fileView', 346 346 }, 347 347 }, 348 348 total: { 349 349 - type: "integer", 350 350 - description: "The total number of files available.", 349 349 + type: 'integer', 350 350 + description: 'The total number of files available.', 351 351 minimum: 0, 352 352 }, 353 353 }, ··· 358 358 }, 359 359 IoPocketenvSandboxClaimSandbox: { 360 360 lexicon: 1, 361 361 - id: "io.pocketenv.sandbox.claimSandbox", 361 361 + id: 'io.pocketenv.sandbox.claimSandbox', 362 362 defs: { 363 363 main: { 364 364 - type: "procedure", 365 365 - description: "Claim a sandbox by id", 364 364 + type: 'procedure', 365 365 + description: 'Claim a sandbox by id', 366 366 parameters: { 367 367 - type: "params", 368 368 - required: ["id"], 367 367 + type: 'params', 368 368 + required: ['id'], 369 369 properties: { 370 370 id: { 371 371 - type: "string", 372 372 - description: "The sandbox ID.", 371 371 + type: 'string', 372 372 + description: 'The sandbox ID.', 373 373 }, 374 374 }, 375 375 }, 376 376 output: { 377 377 - encoding: "application/json", 377 377 + encoding: 'application/json', 378 378 schema: { 379 379 - type: "ref", 380 380 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 379 379 + type: 'ref', 380 380 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 381 381 }, 382 382 }, 383 383 }, ··· 385 385 }, 386 386 IoPocketenvSandboxCreateIntegration: { 387 387 lexicon: 1, 388 388 - id: "io.pocketenv.sandbox.createIntegration", 388 388 + id: 'io.pocketenv.sandbox.createIntegration', 389 389 defs: { 390 390 main: { 391 391 - type: "procedure", 392 392 - description: "Create a new integration for the sandbox.", 391 391 + type: 'procedure', 392 392 + description: 'Create a new integration for the sandbox.', 393 393 input: { 394 394 - encoding: "application/json", 394 394 + encoding: 'application/json', 395 395 schema: { 396 396 - type: "object", 397 397 - required: ["id", "name"], 396 396 + type: 'object', 397 397 + required: ['id', 'name'], 398 398 properties: { 399 399 id: { 400 400 - type: "string", 401 401 - description: "The sandbox ID.", 400 400 + type: 'string', 401 401 + description: 'The sandbox ID.', 402 402 }, 403 403 name: { 404 404 - type: "string", 405 405 - description: "The name of the integration.", 404 404 + type: 'string', 405 405 + description: 'The name of the integration.', 406 406 }, 407 407 }, 408 408 }, 409 409 }, 410 410 output: { 411 411 - encoding: "application/json", 411 411 + encoding: 'application/json', 412 412 schema: { 413 413 - type: "ref", 414 414 - ref: "lex:io.pocketenv.sandbox.defs#integrationView", 413 413 + type: 'ref', 414 414 + ref: 'lex:io.pocketenv.sandbox.defs#integrationView', 415 415 }, 416 416 }, 417 417 }, ··· 419 419 }, 420 420 IoPocketenvSandboxCreateSandbox: { 421 421 lexicon: 1, 422 422 - id: "io.pocketenv.sandbox.createSandbox", 422 422 + id: 'io.pocketenv.sandbox.createSandbox', 423 423 defs: { 424 424 main: { 425 425 - type: "procedure", 426 426 - description: "Create a sandbox", 425 425 + type: 'procedure', 426 426 + description: 'Create a sandbox', 427 427 input: { 428 428 - encoding: "application/json", 428 428 + encoding: 'application/json', 429 429 schema: { 430 430 - type: "object", 431 431 - required: ["base"], 430 430 + type: 'object', 431 431 + required: ['base'], 432 432 properties: { 433 433 base: { 434 434 - type: "string", 434 434 + type: 'string', 435 435 description: 436 436 - "The base sandbox URI to clone from, e.g. a template or an existing sandbox.", 436 436 + 'The base sandbox URI to clone from, e.g. a template or an existing sandbox.', 437 437 }, 438 438 name: { 439 439 - type: "string", 440 440 - description: "The name of the sandbox", 439 439 + type: 'string', 440 440 + description: 'The name of the sandbox', 441 441 minLength: 1, 442 442 }, 443 443 description: { 444 444 - type: "string", 445 445 - description: "A description for the sandbox", 444 444 + type: 'string', 445 445 + description: 'A description for the sandbox', 446 446 }, 447 447 provider: { 448 448 - type: "string", 448 448 + type: 'string', 449 449 description: 450 450 "The provider to create the sandbox on, e.g. 'daytona', 'vercel', 'cloudflare', etc.", 451 451 - enum: ["daytona", "vercel", "cloudflare", "deno"], 451 451 + enum: ['daytona', 'vercel', 'cloudflare', 'deno'], 452 452 }, 453 453 topics: { 454 454 - type: "array", 454 454 + type: 'array', 455 455 description: 456 456 - "A list of topics/tags to associate with the sandbox", 456 456 + 'A list of topics/tags to associate with the sandbox', 457 457 items: { 458 458 - type: "string", 458 458 + type: 'string', 459 459 maxLength: 50, 460 460 }, 461 461 }, 462 462 repo: { 463 463 - type: "string", 463 463 + type: 'string', 464 464 description: 465 465 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 466 466 - format: "uri", 465 465 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 466 466 + format: 'uri', 467 467 }, 468 468 vcpus: { 469 469 - type: "integer", 469 469 + type: 'integer', 470 470 description: 471 471 - "The number of virtual CPUs to allocate for the sandbox", 471 471 + 'The number of virtual CPUs to allocate for the sandbox', 472 472 minimum: 1, 473 473 }, 474 474 memory: { 475 475 - type: "integer", 475 475 + type: 'integer', 476 476 description: 477 477 - "The amount of memory (in GB) to allocate for the sandbox", 477 477 + 'The amount of memory (in GB) to allocate for the sandbox', 478 478 minimum: 1, 479 479 }, 480 480 disk: { 481 481 - type: "integer", 481 481 + type: 'integer', 482 482 description: 483 483 - "The amount of disk space (in GB) to allocate for the sandbox", 483 483 + 'The amount of disk space (in GB) to allocate for the sandbox', 484 484 minimum: 3, 485 485 }, 486 486 readme: { 487 487 - type: "string", 488 488 - description: "A URI to a README for the sandbox.", 489 489 - format: "uri", 487 487 + type: 'string', 488 488 + description: 'A URI to a README for the sandbox.', 489 489 + format: 'uri', 490 490 }, 491 491 secrets: { 492 492 - type: "ref", 493 493 - description: "A list of secrets to add to the sandbox", 494 494 - ref: "lex:io.pocketenv.sandbox.defs#secrets", 492 492 + type: 'ref', 493 493 + description: 'A list of secrets to add to the sandbox', 494 494 + ref: 'lex:io.pocketenv.sandbox.defs#secrets', 495 495 }, 496 496 envs: { 497 497 - type: "ref", 497 497 + type: 'ref', 498 498 description: 499 499 - "A list of environment variables to add to the sandbox", 500 500 - ref: "lex:io.pocketenv.sandbox.defs#envs", 499 499 + 'A list of environment variables to add to the sandbox', 500 500 + ref: 'lex:io.pocketenv.sandbox.defs#envs', 501 501 }, 502 502 }, 503 503 }, 504 504 }, 505 505 output: { 506 506 - encoding: "application/json", 506 506 + encoding: 'application/json', 507 507 schema: { 508 508 - type: "ref", 509 509 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 508 508 + type: 'ref', 509 509 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 510 510 }, 511 511 }, 512 512 }, ··· 514 514 }, 515 515 IoPocketenvSandboxDefs: { 516 516 lexicon: 1, 517 517 - id: "io.pocketenv.sandbox.defs", 517 517 + id: 'io.pocketenv.sandbox.defs', 518 518 defs: { 519 519 sandboxViewBasic: { 520 520 - type: "object", 520 520 + type: 'object', 521 521 properties: { 522 522 name: { 523 523 - type: "string", 524 524 - description: "Name of the sandbox", 523 523 + type: 'string', 524 524 + description: 'Name of the sandbox', 525 525 maxLength: 50, 526 526 }, 527 527 provider: { 528 528 - type: "string", 528 528 + type: 'string', 529 529 description: 530 530 "The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.", 531 531 maxLength: 50, 532 532 }, 533 533 description: { 534 534 - type: "string", 534 534 + type: 'string', 535 535 maxGraphemes: 300, 536 536 maxLength: 3000, 537 537 }, 538 538 website: { 539 539 - type: "string", 540 540 - description: "Any URI related to the sandbox", 541 541 - format: "uri", 539 539 + type: 'string', 540 540 + description: 'Any URI related to the sandbox', 541 541 + format: 'uri', 542 542 }, 543 543 logo: { 544 544 - type: "string", 545 545 - description: "URI to an image logo for the sandbox", 546 546 - format: "uri", 544 544 + type: 'string', 545 545 + description: 'URI to an image logo for the sandbox', 546 546 + format: 'uri', 547 547 }, 548 548 topics: { 549 549 - type: "array", 549 549 + type: 'array', 550 550 items: { 551 551 - type: "string", 551 551 + type: 'string', 552 552 minLength: 1, 553 553 maxLength: 50, 554 554 }, 555 555 maxLength: 50, 556 556 }, 557 557 repo: { 558 558 - type: "string", 558 558 + type: 'string', 559 559 description: 560 560 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 561 561 - format: "uri", 560 560 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 561 561 + format: 'uri', 562 562 }, 563 563 readme: { 564 564 - type: "string", 565 565 - description: "A URI to a README for the sandbox.", 566 566 - format: "uri", 564 564 + type: 'string', 565 565 + description: 'A URI to a README for the sandbox.', 566 566 + format: 'uri', 567 567 }, 568 568 vcpus: { 569 569 - type: "integer", 570 570 - description: "Number of virtual CPUs allocated to the sandbox", 569 569 + type: 'integer', 570 570 + description: 'Number of virtual CPUs allocated to the sandbox', 571 571 }, 572 572 memory: { 573 573 - type: "integer", 574 574 - description: "Amount of memory in GB allocated to the sandbox", 573 573 + type: 'integer', 574 574 + description: 'Amount of memory in GB allocated to the sandbox', 575 575 }, 576 576 disk: { 577 577 - type: "integer", 578 578 - description: "Amount of disk space in GB allocated to the sandbox", 577 577 + type: 'integer', 578 578 + description: 'Amount of disk space in GB allocated to the sandbox', 579 579 }, 580 580 ports: { 581 581 - type: "array", 581 581 + type: 'array', 582 582 items: { 583 583 - type: "integer", 583 583 + type: 'integer', 584 584 maximum: 65535, 585 585 minimum: 1, 586 586 }, 587 587 maxLength: 100, 588 588 }, 589 589 installs: { 590 590 - type: "integer", 590 590 + type: 'integer', 591 591 description: 592 592 - "Number of times the sandbox has been installed by users.", 592 592 + 'Number of times the sandbox has been installed by users.', 593 593 }, 594 594 createdAt: { 595 595 - type: "string", 596 596 - format: "datetime", 595 595 + type: 'string', 596 596 + format: 'datetime', 597 597 }, 598 598 }, 599 599 }, 600 600 sandboxViewDetailed: { 601 601 - type: "object", 601 601 + type: 'object', 602 602 properties: { 603 603 name: { 604 604 - type: "string", 605 605 - description: "Name of the sandbox", 604 604 + type: 'string', 605 605 + description: 'Name of the sandbox', 606 606 maxLength: 50, 607 607 }, 608 608 provider: { 609 609 - type: "string", 609 609 + type: 'string', 610 610 description: 611 611 "The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.", 612 612 maxLength: 50, 613 613 }, 614 614 description: { 615 615 - type: "string", 615 615 + type: 'string', 616 616 maxGraphemes: 300, 617 617 maxLength: 3000, 618 618 }, 619 619 status: { 620 620 - type: "string", 620 620 + type: 'string', 621 621 description: 622 622 "The current status of the sandbox, e.g. 'RUNNING', 'STOPPED', etc.", 623 623 }, 624 624 startedAt: { 625 625 - type: "string", 626 626 - format: "datetime", 625 625 + type: 'string', 626 626 + format: 'datetime', 627 627 }, 628 628 timeout: { 629 629 - type: "integer", 630 630 - description: "The sandbox timeout in seconds", 629 629 + type: 'integer', 630 630 + description: 'The sandbox timeout in seconds', 631 631 }, 632 632 baseSandbox: { 633 633 - type: "string", 633 633 + type: 'string', 634 634 description: 635 635 - "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.", 635 635 + '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.', 636 636 }, 637 637 website: { 638 638 - type: "string", 639 639 - description: "Any URI related to the sandbox", 640 640 - format: "uri", 638 638 + type: 'string', 639 639 + description: 'Any URI related to the sandbox', 640 640 + format: 'uri', 641 641 }, 642 642 logo: { 643 643 - type: "string", 644 644 - description: "URI to an image logo for the sandbox", 645 645 - format: "uri", 643 643 + type: 'string', 644 644 + description: 'URI to an image logo for the sandbox', 645 645 + format: 'uri', 646 646 }, 647 647 topics: { 648 648 - type: "array", 648 648 + type: 'array', 649 649 items: { 650 650 - type: "string", 650 650 + type: 'string', 651 651 minLength: 1, 652 652 maxLength: 50, 653 653 }, 654 654 maxLength: 50, 655 655 }, 656 656 repo: { 657 657 - type: "string", 657 657 + type: 'string', 658 658 description: 659 659 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 660 660 - format: "uri", 659 659 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 660 660 + format: 'uri', 661 661 }, 662 662 readme: { 663 663 - type: "string", 664 664 - description: "A URI to a README for the sandbox.", 665 665 - format: "uri", 663 663 + type: 'string', 664 664 + description: 'A URI to a README for the sandbox.', 665 665 + format: 'uri', 666 666 }, 667 667 vcpus: { 668 668 - type: "integer", 669 669 - description: "Number of virtual CPUs allocated to the sandbox", 668 668 + type: 'integer', 669 669 + description: 'Number of virtual CPUs allocated to the sandbox', 670 670 }, 671 671 memory: { 672 672 - type: "integer", 673 673 - description: "Amount of memory in GB allocated to the sandbox", 672 672 + type: 'integer', 673 673 + description: 'Amount of memory in GB allocated to the sandbox', 674 674 }, 675 675 disk: { 676 676 - type: "integer", 677 677 - description: "Amount of disk space in GB allocated to the sandbox", 676 676 + type: 'integer', 677 677 + description: 'Amount of disk space in GB allocated to the sandbox', 678 678 }, 679 679 ports: { 680 680 - type: "array", 680 680 + type: 'array', 681 681 items: { 682 682 - type: "integer", 682 682 + type: 'integer', 683 683 maximum: 65535, 684 684 minimum: 1, 685 685 }, 686 686 maxLength: 100, 687 687 }, 688 688 installs: { 689 689 - type: "integer", 689 689 + type: 'integer', 690 690 description: 691 691 - "Number of times the sandbox has been installed by users.", 691 691 + 'Number of times the sandbox has been installed by users.', 692 692 }, 693 693 createdAt: { 694 694 - type: "string", 695 695 - format: "datetime", 694 694 + type: 'string', 695 695 + format: 'datetime', 696 696 }, 697 697 owner: { 698 698 - type: "ref", 699 699 - description: "The user who created the sandbox", 700 700 - ref: "lex:io.pocketenv.user.defs#userViewBasic", 698 698 + type: 'ref', 699 699 + description: 'The user who created the sandbox', 700 700 + ref: 'lex:io.pocketenv.user.defs#userViewBasic', 701 701 }, 702 702 }, 703 703 }, 704 704 sandboxDetailsPref: { 705 705 - type: "object", 705 705 + type: 'object', 706 706 + nullable: ['repo', 'description', 'topics'], 706 707 properties: { 707 708 name: { 708 708 - type: "string", 709 709 - description: "The name of the sandbox", 709 709 + type: 'string', 710 710 + description: 'The name of the sandbox', 710 711 minLength: 1, 711 712 }, 712 713 description: { 713 713 - type: "string", 714 714 - description: "A description for the sandbox", 714 714 + type: 'string', 715 715 + description: 'A description for the sandbox', 715 716 }, 716 717 topics: { 717 717 - type: "array", 718 718 - description: "A list of topics/tags to associate with the sandbox", 718 718 + type: 'array', 719 719 + description: 'A list of topics/tags to associate with the sandbox', 719 720 items: { 720 720 - type: "string", 721 721 + type: 'string', 721 722 maxLength: 50, 722 723 }, 723 724 }, 724 725 repo: { 725 725 - type: "string", 726 726 + type: 'string', 726 727 description: 727 727 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 728 728 - format: "uri", 728 728 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 729 729 + format: 'uri', 729 730 }, 730 731 vcpus: { 731 731 - type: "integer", 732 732 + type: 'integer', 732 733 description: 733 733 - "The number of virtual CPUs to allocate for the sandbox", 734 734 + 'The number of virtual CPUs to allocate for the sandbox', 734 735 minimum: 1, 735 736 }, 736 737 memory: { 737 737 - type: "integer", 738 738 + type: 'integer', 738 739 description: 739 739 - "The amount of memory (in GB) to allocate for the sandbox", 740 740 + 'The amount of memory (in GB) to allocate for the sandbox', 740 741 minimum: 1, 741 742 }, 742 743 disk: { 743 743 - type: "integer", 744 744 + type: 'integer', 744 745 description: 745 745 - "The amount of disk space (in GB) to allocate for the sandbox", 746 746 + 'The amount of disk space (in GB) to allocate for the sandbox', 746 747 minimum: 3, 747 748 }, 748 749 readme: { 749 749 - type: "string", 750 750 - description: "A URI to a README for the sandbox.", 751 751 - format: "uri", 750 750 + type: 'string', 751 751 + description: 'A URI to a README for the sandbox.', 752 752 + format: 'uri', 752 753 }, 753 754 }, 754 755 }, 755 756 secretPref: { 756 756 - type: "object", 757 757 + type: 'object', 757 758 properties: { 758 759 name: { 759 759 - type: "string", 760 760 - description: "The name of the secret", 760 760 + type: 'string', 761 761 + description: 'The name of the secret', 761 762 minLength: 1, 762 763 }, 763 764 value: { 764 764 - type: "string", 765 765 + type: 'string', 765 766 description: 766 766 - "The value of the secret. This will be encrypted at rest and redacted in any API responses.", 767 767 + 'The value of the secret. This will be encrypted at rest and redacted in any API responses.', 767 768 }, 768 769 }, 769 770 }, 770 771 variablePref: { 771 771 - type: "object", 772 772 - description: "A variable to add to the sandbox", 772 772 + type: 'object', 773 773 + description: 'A variable to add to the sandbox', 773 774 properties: { 774 775 name: { 775 775 - type: "string", 776 776 - description: "The name of the variable", 776 776 + type: 'string', 777 777 + description: 'The name of the variable', 777 778 minLength: 1, 778 779 }, 779 780 value: { 780 780 - type: "string", 781 781 + type: 'string', 781 782 description: 782 782 - "The value of the variable. This will be visible in API responses and should not contain sensitive information.", 783 783 + 'The value of the variable. This will be visible in API responses and should not contain sensitive information.', 783 784 }, 784 785 }, 785 786 }, 786 787 filePref: { 787 787 - type: "object", 788 788 - description: "A file to add to the sandbox", 788 788 + type: 'object', 789 789 + description: 'A file to add to the sandbox', 789 790 properties: { 790 791 name: { 791 791 - type: "string", 792 792 - description: "The name of the file", 792 792 + type: 'string', 793 793 + description: 'The name of the file', 793 794 minLength: 1, 794 795 }, 795 796 content: { 796 796 - type: "string", 797 797 - description: "The content of the file.", 797 797 + type: 'string', 798 798 + description: 'The content of the file.', 798 799 }, 799 800 encrypt: { 800 800 - type: "boolean", 801 801 + type: 'boolean', 801 802 description: 802 802 - "Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information.", 803 803 + 'Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information.', 803 804 }, 804 805 path: { 805 805 - type: "string", 806 806 + type: 'string', 806 807 description: 807 808 "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.", 808 809 }, 809 810 }, 810 811 }, 811 812 volumePref: { 812 812 - type: "object", 813 813 - description: "A volume to add to the sandbox", 813 813 + type: 'object', 814 814 + description: 'A volume to add to the sandbox', 814 815 properties: { 815 816 name: { 816 816 - type: "string", 817 817 - description: "The name of the volume", 817 817 + type: 'string', 818 818 + description: 'The name of the volume', 818 819 minLength: 1, 819 820 }, 820 821 path: { 821 821 - type: "string", 822 822 + type: 'string', 822 823 description: 823 824 "The mount path within the sandbox where the volume will be attached, e.g. '/data', '/logs', etc.", 824 825 }, 825 826 readOnly: { 826 826 - type: "boolean", 827 827 - description: "Whether the volume should be mounted as read-only", 827 827 + type: 'boolean', 828 828 + description: 'Whether the volume should be mounted as read-only', 828 829 }, 829 830 }, 830 831 }, 831 832 preferences: { 832 832 - type: "array", 833 833 + type: 'array', 833 834 items: { 834 834 - type: "union", 835 835 + type: 'union', 835 836 refs: [ 836 836 - "lex:io.pocketenv.sandbox.defs#sandboxDetailsPref", 837 837 - "lex:io.pocketenv.sandbox.defs#secretPref", 838 838 - "lex:io.pocketenv.sandbox.defs#variablePref", 839 839 - "lex:io.pocketenv.sandbox.defs#filePref", 840 840 - "lex:io.pocketenv.sandbox.defs#volumePref", 837 837 + 'lex:io.pocketenv.sandbox.defs#sandboxDetailsPref', 838 838 + 'lex:io.pocketenv.sandbox.defs#secretPref', 839 839 + 'lex:io.pocketenv.sandbox.defs#variablePref', 840 840 + 'lex:io.pocketenv.sandbox.defs#filePref', 841 841 + 'lex:io.pocketenv.sandbox.defs#volumePref', 841 842 ], 842 843 }, 843 844 }, 844 845 sshKeysView: { 845 845 - type: "object", 846 846 + type: 'object', 846 847 properties: { 847 848 id: { 848 848 - type: "string", 849 849 - description: "Unique identifier of the SSH key.", 849 849 + type: 'string', 850 850 + description: 'Unique identifier of the SSH key.', 850 851 }, 851 852 publicKey: { 852 852 - type: "string", 853 853 - description: "The public SSH key.", 853 853 + type: 'string', 854 854 + description: 'The public SSH key.', 854 855 }, 855 856 privateKey: { 856 856 - type: "string", 857 857 - description: "The private SSH key (redacted in API responses)", 857 857 + type: 'string', 858 858 + description: 'The private SSH key (redacted in API responses)', 858 859 }, 859 860 createdAt: { 860 860 - type: "string", 861 861 - description: "The timestamp when the SSH key was created.", 862 862 - format: "datetime", 861 861 + type: 'string', 862 862 + description: 'The timestamp when the SSH key was created.', 863 863 + format: 'datetime', 863 864 }, 864 865 updatedAt: { 865 865 - type: "string", 866 866 - description: "The timestamp when the SSH key was last updated.", 867 867 - format: "datetime", 866 866 + type: 'string', 867 867 + description: 'The timestamp when the SSH key was last updated.', 868 868 + format: 'datetime', 868 869 }, 869 870 }, 870 871 }, 871 872 tailscaleAuthKeyView: { 872 872 - type: "object", 873 873 + type: 'object', 873 874 properties: { 874 875 id: { 875 875 - type: "string", 876 876 - description: "Unique identifier of the Tailscale Auth Key.", 876 876 + type: 'string', 877 877 + description: 'Unique identifier of the Tailscale Auth Key.', 877 878 }, 878 879 authKey: { 879 879 - type: "string", 880 880 - description: "The Tailscale auth key (redacted in API responses)", 880 880 + type: 'string', 881 881 + description: 'The Tailscale auth key (redacted in API responses)', 881 882 }, 882 883 redacted: { 883 883 - type: "string", 884 884 - description: "The redacted Auth Key.", 884 884 + type: 'string', 885 885 + description: 'The redacted Auth Key.', 885 886 }, 886 887 createdAt: { 887 887 - type: "string", 888 888 + type: 'string', 888 889 description: 889 889 - "The timestamp when the Tailscale Auth Key was created.", 890 890 - format: "datetime", 890 890 + 'The timestamp when the Tailscale Auth Key was created.', 891 891 + format: 'datetime', 891 892 }, 892 893 updatedAt: { 893 893 - type: "string", 894 894 + type: 'string', 894 895 description: 895 895 - "The timestamp when the Tailscale Auth Key was last updated.", 896 896 - format: "datetime", 896 896 + 'The timestamp when the Tailscale Auth Key was last updated.', 897 897 + format: 'datetime', 897 898 }, 898 899 }, 899 900 }, 900 901 integrationView: { 901 901 - type: "object", 902 902 + type: 'object', 902 903 properties: { 903 904 id: { 904 904 - type: "string", 905 905 - description: "Unique identifier of the integration.", 905 905 + type: 'string', 906 906 + description: 'Unique identifier of the integration.', 906 907 }, 907 908 name: { 908 908 - type: "string", 909 909 + type: 'string', 909 910 description: 910 911 "The name of the integration, e.g. 'GitHub', 'Slack', 'Trello', etc.", 911 912 }, 912 913 webhookUrl: { 913 913 - type: "string", 914 914 - description: "The webhook URL of the integration.", 915 915 - format: "uri", 914 914 + type: 'string', 915 915 + description: 'The webhook URL of the integration.', 916 916 + format: 'uri', 916 917 }, 917 918 createdAt: { 918 918 - type: "string", 919 919 - description: "The timestamp when the integration was created.", 920 920 - format: "datetime", 919 919 + type: 'string', 920 920 + description: 'The timestamp when the integration was created.', 921 921 + format: 'datetime', 921 922 }, 922 923 updatedAt: { 923 923 - type: "string", 924 924 - description: "The timestamp when the integration was last updated.", 925 925 - format: "datetime", 924 924 + type: 'string', 925 925 + description: 'The timestamp when the integration was last updated.', 926 926 + format: 'datetime', 926 927 }, 927 928 }, 928 929 }, 929 930 integrationsView: { 930 930 - type: "array", 931 931 + type: 'array', 931 932 items: { 932 932 - type: "ref", 933 933 - description: "An integration connected to the sandbox", 934 934 - ref: "lex:io.pocketenv.sandbox.defs#integrationView", 933 933 + type: 'ref', 934 934 + description: 'An integration connected to the sandbox', 935 935 + ref: 'lex:io.pocketenv.sandbox.defs#integrationView', 935 936 }, 936 937 }, 937 938 }, 938 939 }, 939 940 IoPocketenvSandboxDeleteSandbox: { 940 941 lexicon: 1, 941 941 - id: "io.pocketenv.sandbox.deleteSandbox", 942 942 + id: 'io.pocketenv.sandbox.deleteSandbox', 942 943 defs: { 943 944 main: { 944 944 - type: "procedure", 945 945 - description: "Delete a sandbox by uri", 945 945 + type: 'procedure', 946 946 + description: 'Delete a sandbox by uri', 946 947 parameters: { 947 947 - type: "params", 948 948 - required: ["id"], 948 948 + type: 'params', 949 949 + required: ['id'], 949 950 properties: { 950 951 id: { 951 951 - type: "string", 952 952 - description: "The sandbox ID.", 952 952 + type: 'string', 953 953 + description: 'The sandbox ID.', 953 954 }, 954 955 }, 955 956 }, 956 957 output: { 957 957 - encoding: "application/json", 958 958 + encoding: 'application/json', 958 959 schema: { 959 959 - type: "ref", 960 960 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 960 960 + type: 'ref', 961 961 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 961 962 }, 962 963 }, 963 964 }, ··· 965 966 }, 966 967 IoPocketenvSandboxGetIntegrations: { 967 968 lexicon: 1, 968 968 - id: "io.pocketenv.sandbox.getIntegrations", 969 969 + id: 'io.pocketenv.sandbox.getIntegrations', 969 970 defs: { 970 971 main: { 971 971 - type: "query", 972 972 - description: "Get the integrations for a sandbox.", 972 972 + type: 'query', 973 973 + description: 'Get the integrations for a sandbox.', 973 974 parameters: { 974 974 - type: "params", 975 975 - required: ["id"], 975 975 + type: 'params', 976 976 + required: ['id'], 976 977 properties: { 977 978 id: { 978 978 - type: "string", 979 979 - description: "The sandbox ID.", 979 979 + type: 'string', 980 980 + description: 'The sandbox ID.', 980 981 }, 981 982 }, 982 983 }, 983 984 output: { 984 984 - encoding: "application/json", 985 985 + encoding: 'application/json', 985 986 schema: { 986 986 - type: "ref", 987 987 - ref: "lex:io.pocketenv.sandbox.defs#integrationsView", 987 987 + type: 'ref', 988 988 + ref: 'lex:io.pocketenv.sandbox.defs#integrationsView', 988 989 }, 989 990 }, 990 991 }, ··· 992 993 }, 993 994 IoPocketenvSandboxGetPreferences: { 994 995 lexicon: 1, 995 995 - id: "io.pocketenv.sandbox.getPreferences", 996 996 + id: 'io.pocketenv.sandbox.getPreferences', 996 997 defs: { 997 998 main: { 998 998 - type: "query", 999 999 - description: "Get sandbox preferences", 999 999 + type: 'query', 1000 1000 + description: 'Get sandbox preferences', 1000 1001 parameters: { 1001 1001 - type: "params", 1002 1002 - required: ["id"], 1002 1002 + type: 'params', 1003 1003 + required: ['id'], 1003 1004 properties: { 1004 1005 id: { 1005 1005 - type: "string", 1006 1006 - description: "The sandbox ID or URI to retrieve", 1006 1006 + type: 'string', 1007 1007 + description: 'The sandbox ID or URI to retrieve', 1007 1008 }, 1008 1009 }, 1009 1010 }, 1010 1011 output: { 1011 1011 - encoding: "application/json", 1012 1012 + encoding: 'application/json', 1012 1013 schema: { 1013 1013 - type: "ref", 1014 1014 - ref: "lex:io.pocketenv.sandbox.defs#preferences", 1014 1014 + type: 'ref', 1015 1015 + ref: 'lex:io.pocketenv.sandbox.defs#preferences', 1015 1016 }, 1016 1017 }, 1017 1018 }, ··· 1019 1020 }, 1020 1021 IoPocketenvSandboxGetSandbox: { 1021 1022 lexicon: 1, 1022 1022 - id: "io.pocketenv.sandbox.getSandbox", 1023 1023 + id: 'io.pocketenv.sandbox.getSandbox', 1023 1024 defs: { 1024 1025 main: { 1025 1025 - type: "query", 1026 1026 - description: "Get a sandbox by ID or URI", 1026 1026 + type: 'query', 1027 1027 + description: 'Get a sandbox by ID or URI', 1027 1028 parameters: { 1028 1028 - type: "params", 1029 1029 - required: ["id"], 1029 1029 + type: 'params', 1030 1030 + required: ['id'], 1030 1031 properties: { 1031 1032 id: { 1032 1032 - type: "string", 1033 1033 - description: "The sandbox ID or URI to retrieve", 1033 1033 + type: 'string', 1034 1034 + description: 'The sandbox ID or URI to retrieve', 1034 1035 }, 1035 1036 }, 1036 1037 }, 1037 1038 output: { 1038 1038 - encoding: "application/json", 1039 1039 + encoding: 'application/json', 1039 1040 schema: { 1040 1040 - type: "ref", 1041 1041 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1041 1041 + type: 'ref', 1042 1042 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1042 1043 }, 1043 1044 }, 1044 1045 }, ··· 1046 1047 }, 1047 1048 IoPocketenvSandboxGetSandboxes: { 1048 1049 lexicon: 1, 1049 1049 - id: "io.pocketenv.sandbox.getSandboxes", 1050 1050 + id: 'io.pocketenv.sandbox.getSandboxes', 1050 1051 defs: { 1051 1052 main: { 1052 1052 - type: "query", 1053 1053 - description: "Get all sandboxes", 1053 1053 + type: 'query', 1054 1054 + description: 'Get all sandboxes', 1054 1055 parameters: { 1055 1055 - type: "params", 1056 1056 + type: 'params', 1056 1057 properties: { 1057 1058 limit: { 1058 1058 - type: "integer", 1059 1059 - description: "The maximum number of sandboxes to return.", 1059 1059 + type: 'integer', 1060 1060 + description: 'The maximum number of sandboxes to return.', 1060 1061 minimum: 1, 1061 1062 }, 1062 1063 offset: { 1063 1063 - type: "integer", 1064 1064 + type: 'integer', 1064 1065 description: 1065 1065 - "The number of sandboxes to skip before starting to collect the result set.", 1066 1066 + 'The number of sandboxes to skip before starting to collect the result set.', 1066 1067 minimum: 0, 1067 1068 }, 1068 1069 }, 1069 1070 }, 1070 1071 output: { 1071 1071 - encoding: "application/json", 1072 1072 + encoding: 'application/json', 1072 1073 schema: { 1073 1073 - type: "object", 1074 1074 + type: 'object', 1074 1075 properties: { 1075 1076 sandboxes: { 1076 1076 - type: "array", 1077 1077 + type: 'array', 1077 1078 items: { 1078 1078 - type: "ref", 1079 1079 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1079 1079 + type: 'ref', 1080 1080 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1080 1081 }, 1081 1082 }, 1082 1083 total: { 1083 1083 - type: "integer", 1084 1084 - description: "The total number of sandboxes available.", 1084 1084 + type: 'integer', 1085 1085 + description: 'The total number of sandboxes available.', 1085 1086 minimum: 0, 1086 1087 }, 1087 1088 }, ··· 1092 1093 }, 1093 1094 IoPocketenvSandboxGetSshKeys: { 1094 1095 lexicon: 1, 1095 1095 - id: "io.pocketenv.sandbox.getSshKeys", 1096 1096 + id: 'io.pocketenv.sandbox.getSshKeys', 1096 1097 defs: { 1097 1098 main: { 1098 1098 - type: "query", 1099 1099 - description: "Get the SSH keys for a sandbox.", 1099 1099 + type: 'query', 1100 1100 + description: 'Get the SSH keys for a sandbox.', 1100 1101 parameters: { 1101 1101 - type: "params", 1102 1102 - required: ["id"], 1102 1102 + type: 'params', 1103 1103 + required: ['id'], 1103 1104 properties: { 1104 1105 id: { 1105 1105 - type: "string", 1106 1106 - description: "The sandbox ID.", 1106 1106 + type: 'string', 1107 1107 + description: 'The sandbox ID.', 1107 1108 }, 1108 1109 }, 1109 1110 }, 1110 1111 output: { 1111 1111 - encoding: "application/json", 1112 1112 + encoding: 'application/json', 1112 1113 schema: { 1113 1113 - type: "ref", 1114 1114 - ref: "lex:io.pocketenv.sandbox.defs#sshKeysView", 1114 1114 + type: 'ref', 1115 1115 + ref: 'lex:io.pocketenv.sandbox.defs#sshKeysView', 1115 1116 }, 1116 1117 }, 1117 1118 }, ··· 1119 1120 }, 1120 1121 IoPocketenvSandboxGetTailscaleAuthKey: { 1121 1122 lexicon: 1, 1122 1122 - id: "io.pocketenv.sandbox.getTailscaleAuthKey", 1123 1123 + id: 'io.pocketenv.sandbox.getTailscaleAuthKey', 1123 1124 defs: { 1124 1125 main: { 1125 1125 - type: "query", 1126 1126 - description: "Get the Tailscale token for a sandbox.", 1126 1126 + type: 'query', 1127 1127 + description: 'Get the Tailscale token for a sandbox.', 1127 1128 parameters: { 1128 1128 - type: "params", 1129 1129 - required: ["id"], 1129 1129 + type: 'params', 1130 1130 + required: ['id'], 1130 1131 properties: { 1131 1132 id: { 1132 1132 - type: "string", 1133 1133 - description: "The sandbox ID.", 1133 1133 + type: 'string', 1134 1134 + description: 'The sandbox ID.', 1134 1135 }, 1135 1136 }, 1136 1137 }, 1137 1138 output: { 1138 1138 - encoding: "application/json", 1139 1139 + encoding: 'application/json', 1139 1140 schema: { 1140 1140 - type: "ref", 1141 1141 - ref: "lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView", 1141 1141 + type: 'ref', 1142 1142 + ref: 'lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView', 1142 1143 }, 1143 1144 }, 1144 1145 }, ··· 1146 1147 }, 1147 1148 IoPocketenvSandboxGetTailscaleToken: { 1148 1149 lexicon: 1, 1149 1149 - id: "io.pocketenv.sandbox.getTailscaleToken", 1150 1150 + id: 'io.pocketenv.sandbox.getTailscaleToken', 1150 1151 defs: { 1151 1152 main: { 1152 1152 - type: "query", 1153 1153 - description: "Get the Tailscale token for a sandbox.", 1153 1153 + type: 'query', 1154 1154 + description: 'Get the Tailscale token for a sandbox.', 1154 1155 parameters: { 1155 1155 - type: "params", 1156 1156 - required: ["id"], 1156 1156 + type: 'params', 1157 1157 + required: ['id'], 1157 1158 properties: { 1158 1159 id: { 1159 1159 - type: "string", 1160 1160 - description: "The sandbox ID.", 1160 1160 + type: 'string', 1161 1161 + description: 'The sandbox ID.', 1161 1162 }, 1162 1163 }, 1163 1164 }, 1164 1165 output: { 1165 1165 - encoding: "application/json", 1166 1166 + encoding: 'application/json', 1166 1167 schema: { 1167 1167 - type: "ref", 1168 1168 - ref: "lex:io.pocketenv.sandbox.defs#tailscaleTokenView", 1168 1168 + type: 'ref', 1169 1169 + ref: 'lex:io.pocketenv.sandbox.defs#tailscaleTokenView', 1169 1170 }, 1170 1171 }, 1171 1172 }, ··· 1173 1174 }, 1174 1175 IoPocketenvSandboxPutPreferences: { 1175 1176 lexicon: 1, 1176 1176 - id: "io.pocketenv.sandbox.putPreferences", 1177 1177 + id: 'io.pocketenv.sandbox.putPreferences', 1177 1178 defs: { 1178 1179 main: { 1179 1179 - type: "procedure", 1180 1180 - description: "Update sandbox preferences.", 1180 1180 + type: 'procedure', 1181 1181 + description: 'Update sandbox preferences.', 1181 1182 input: { 1182 1182 - encoding: "application/json", 1183 1183 + encoding: 'application/json', 1183 1184 schema: { 1184 1184 - type: "object", 1185 1185 - required: ["preferences"], 1185 1185 + type: 'object', 1186 1186 + required: ['sandboxId', 'preferences'], 1186 1187 properties: { 1188 1188 + sandboxId: { 1189 1189 + type: 'string', 1190 1190 + description: 'The sandbox ID or URI', 1191 1191 + }, 1187 1192 preferences: { 1188 1188 - type: "ref", 1189 1189 - ref: "lex:io.pocketenv.sandbox.defs#preferences", 1193 1193 + type: 'ref', 1194 1194 + ref: 'lex:io.pocketenv.sandbox.defs#preferences', 1190 1195 }, 1191 1196 }, 1192 1197 }, ··· 1196 1201 }, 1197 1202 IoPocketenvSandboxPutSshKeys: { 1198 1203 lexicon: 1, 1199 1199 - id: "io.pocketenv.sandbox.putSshKeys", 1204 1204 + id: 'io.pocketenv.sandbox.putSshKeys', 1200 1205 defs: { 1201 1206 main: { 1202 1202 - type: "procedure", 1203 1203 - description: "Add or update SSH keys for a sandbox.", 1207 1207 + type: 'procedure', 1208 1208 + description: 'Add or update SSH keys for a sandbox.', 1204 1209 input: { 1205 1205 - encoding: "application/json", 1210 1210 + encoding: 'application/json', 1206 1211 schema: { 1207 1207 - type: "object", 1208 1208 - required: ["id", "privateKey", "publicKey"], 1212 1212 + type: 'object', 1213 1213 + required: ['id', 'privateKey', 'publicKey'], 1209 1214 properties: { 1210 1215 id: { 1211 1211 - type: "string", 1212 1212 - description: "The sandbox ID.", 1216 1216 + type: 'string', 1217 1217 + description: 'The sandbox ID.', 1213 1218 }, 1214 1219 privateKey: { 1215 1215 - type: "string", 1216 1216 - description: "The private SSH key (encrypted)", 1220 1220 + type: 'string', 1221 1221 + description: 'The private SSH key (encrypted)', 1217 1222 }, 1218 1223 publicKey: { 1219 1219 - type: "string", 1220 1220 - description: "The public SSH key.", 1224 1224 + type: 'string', 1225 1225 + description: 'The public SSH key.', 1221 1226 }, 1222 1227 redacted: { 1223 1223 - type: "string", 1224 1224 - description: "The redacted SSH key.", 1228 1228 + type: 'string', 1229 1229 + description: 'The redacted SSH key.', 1225 1230 }, 1226 1231 }, 1227 1232 }, 1228 1233 }, 1229 1234 output: { 1230 1230 - encoding: "application/json", 1235 1235 + encoding: 'application/json', 1231 1236 schema: { 1232 1232 - type: "ref", 1233 1233 - ref: "lex:io.pocketenv.sandbox.defs#sshKeysView", 1237 1237 + type: 'ref', 1238 1238 + ref: 'lex:io.pocketenv.sandbox.defs#sshKeysView', 1234 1239 }, 1235 1240 }, 1236 1241 }, ··· 1238 1243 }, 1239 1244 IoPocketenvSandboxPutTailscaleAuthKey: { 1240 1245 lexicon: 1, 1241 1241 - id: "io.pocketenv.sandbox.putTailscaleAuthKey", 1246 1246 + id: 'io.pocketenv.sandbox.putTailscaleAuthKey', 1242 1247 defs: { 1243 1248 main: { 1244 1244 - type: "procedure", 1249 1249 + type: 'procedure', 1245 1250 description: 1246 1251 "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.", 1247 1252 input: { 1248 1248 - encoding: "application/json", 1253 1253 + encoding: 'application/json', 1249 1254 schema: { 1250 1250 - type: "object", 1251 1251 - required: ["id", "authKey"], 1255 1255 + type: 'object', 1256 1256 + required: ['id', 'authKey'], 1252 1257 properties: { 1253 1258 id: { 1254 1254 - type: "string", 1255 1255 - description: "The sandbox ID.", 1259 1259 + type: 'string', 1260 1260 + description: 'The sandbox ID.', 1256 1261 }, 1257 1262 authKey: { 1258 1258 - type: "string", 1263 1263 + type: 'string', 1259 1264 description: 1260 1260 - "The Tailscale Auth Key (encrypted) to store for the sandbox.", 1265 1265 + 'The Tailscale Auth Key (encrypted) to store for the sandbox.', 1261 1266 }, 1262 1267 redacted: { 1263 1263 - type: "string", 1264 1264 - description: "The redacted SSH key.", 1268 1268 + type: 'string', 1269 1269 + description: 'The redacted SSH key.', 1265 1270 }, 1266 1271 }, 1267 1272 }, 1268 1273 }, 1269 1274 output: { 1270 1270 - encoding: "application/json", 1275 1275 + encoding: 'application/json', 1271 1276 schema: { 1272 1272 - type: "ref", 1273 1273 - ref: "lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView", 1277 1277 + type: 'ref', 1278 1278 + ref: 'lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView', 1274 1279 }, 1275 1280 }, 1276 1281 }, ··· 1278 1283 }, 1279 1284 IoPocketenvSandboxPutTailscaleToken: { 1280 1285 lexicon: 1, 1281 1281 - id: "io.pocketenv.sandbox.putTailscaleToken", 1286 1286 + id: 'io.pocketenv.sandbox.putTailscaleToken', 1282 1287 defs: { 1283 1288 main: { 1284 1284 - type: "procedure", 1289 1289 + type: 'procedure', 1285 1290 description: 1286 1291 "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.", 1287 1292 input: { 1288 1288 - encoding: "application/json", 1293 1293 + encoding: 'application/json', 1289 1294 schema: { 1290 1290 - type: "object", 1291 1291 - required: ["id", "token"], 1295 1295 + type: 'object', 1296 1296 + required: ['id', 'token'], 1292 1297 properties: { 1293 1298 id: { 1294 1294 - type: "string", 1295 1295 - description: "The sandbox ID.", 1299 1299 + type: 'string', 1300 1300 + description: 'The sandbox ID.', 1296 1301 }, 1297 1302 token: { 1298 1298 - type: "string", 1303 1303 + type: 'string', 1299 1304 description: 1300 1300 - "The Tailscale token (encrypted) to store for the sandbox.", 1305 1305 + 'The Tailscale token (encrypted) to store for the sandbox.', 1301 1306 }, 1302 1307 }, 1303 1308 }, 1304 1309 }, 1305 1310 output: { 1306 1306 - encoding: "application/json", 1311 1311 + encoding: 'application/json', 1307 1312 schema: { 1308 1308 - type: "ref", 1309 1309 - ref: "lex:io.pocketenv.sandbox.defs#tailscaleTokenView", 1313 1313 + type: 'ref', 1314 1314 + ref: 'lex:io.pocketenv.sandbox.defs#tailscaleTokenView', 1310 1315 }, 1311 1316 }, 1312 1317 }, ··· 1314 1319 }, 1315 1320 IoPocketenvSandbox: { 1316 1321 lexicon: 1, 1317 1317 - id: "io.pocketenv.sandbox", 1322 1322 + id: 'io.pocketenv.sandbox', 1318 1323 defs: { 1319 1324 main: { 1320 1320 - type: "record", 1321 1321 - key: "tid", 1325 1325 + type: 'record', 1326 1326 + key: 'tid', 1322 1327 record: { 1323 1323 - type: "object", 1324 1324 - required: ["name", "createdAt"], 1328 1328 + type: 'object', 1329 1329 + required: ['name', 'createdAt'], 1325 1330 properties: { 1326 1331 name: { 1327 1327 - type: "string", 1328 1328 - description: "Name of the sandbox", 1332 1332 + type: 'string', 1333 1333 + description: 'Name of the sandbox', 1329 1334 maxLength: 255, 1330 1335 }, 1331 1336 base: { 1332 1332 - type: "ref", 1337 1337 + type: 'ref', 1333 1338 description: 1334 1334 - "A strong reference to the base template for the sandbox environment.", 1335 1335 - ref: "lex:com.atproto.repo.strongRef", 1339 1339 + 'A strong reference to the base template for the sandbox environment.', 1340 1340 + ref: 'lex:com.atproto.repo.strongRef', 1336 1341 }, 1337 1342 provider: { 1338 1338 - type: "string", 1343 1343 + type: 'string', 1339 1344 description: 1340 1345 "The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.", 1341 1346 maxLength: 50, 1342 1347 }, 1343 1348 description: { 1344 1344 - type: "string", 1349 1349 + type: 'string', 1345 1350 maxGraphemes: 300, 1346 1351 maxLength: 3000, 1347 1352 }, 1348 1353 website: { 1349 1349 - type: "string", 1350 1350 - description: "Any URI related to the sandbox", 1351 1351 - format: "uri", 1354 1354 + type: 'string', 1355 1355 + description: 'Any URI related to the sandbox', 1356 1356 + format: 'uri', 1352 1357 }, 1353 1358 logo: { 1354 1354 - type: "string", 1355 1355 - description: "URI to an image logo for the sandbox", 1356 1356 - format: "uri", 1359 1359 + type: 'string', 1360 1360 + description: 'URI to an image logo for the sandbox', 1361 1361 + format: 'uri', 1357 1362 }, 1358 1363 topics: { 1359 1359 - type: "array", 1364 1364 + type: 'array', 1360 1365 items: { 1361 1361 - type: "string", 1366 1366 + type: 'string', 1362 1367 minLength: 1, 1363 1368 maxLength: 50, 1364 1369 }, 1365 1370 maxLength: 50, 1366 1371 }, 1367 1372 repo: { 1368 1368 - type: "string", 1373 1373 + type: 'string', 1369 1374 description: 1370 1370 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 1371 1371 - format: "uri", 1375 1375 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 1376 1376 + format: 'uri', 1372 1377 }, 1373 1378 readme: { 1374 1374 - type: "string", 1375 1375 - description: "A URI to a README for the sandbox.", 1376 1376 - format: "uri", 1379 1379 + type: 'string', 1380 1380 + description: 'A URI to a README for the sandbox.', 1381 1381 + format: 'uri', 1377 1382 }, 1378 1383 vcpus: { 1379 1379 - type: "integer", 1380 1380 - description: "Number of virtual CPUs allocated to the sandbox", 1384 1384 + type: 'integer', 1385 1385 + description: 'Number of virtual CPUs allocated to the sandbox', 1381 1386 }, 1382 1387 memory: { 1383 1383 - type: "integer", 1384 1384 - description: "Amount of memory in GB allocated to the sandbox", 1388 1388 + type: 'integer', 1389 1389 + description: 'Amount of memory in GB allocated to the sandbox', 1385 1390 }, 1386 1391 disk: { 1387 1387 - type: "integer", 1392 1392 + type: 'integer', 1388 1393 description: 1389 1389 - "Amount of disk space in GB allocated to the sandbox", 1394 1394 + 'Amount of disk space in GB allocated to the sandbox', 1390 1395 }, 1391 1396 volumes: { 1392 1392 - type: "array", 1397 1397 + type: 'array', 1393 1398 items: { 1394 1394 - type: "string", 1399 1399 + type: 'string', 1395 1400 description: 1396 1401 "A path to be mounted as a volume in the sandbox, e.g. '/data', '/logs', etc.", 1397 1402 }, 1398 1403 }, 1399 1404 ports: { 1400 1400 - type: "array", 1405 1405 + type: 'array', 1401 1406 items: { 1402 1402 - type: "integer", 1407 1407 + type: 'integer', 1403 1408 description: 1404 1404 - "A port number that is exposed by the sandbox environment.", 1409 1409 + 'A port number that is exposed by the sandbox environment.', 1405 1410 }, 1406 1411 }, 1407 1412 secrets: { 1408 1408 - type: "array", 1413 1413 + type: 'array', 1409 1414 items: { 1410 1410 - type: "string", 1415 1415 + type: 'string', 1411 1416 description: 1412 1412 - "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.", 1417 1417 + '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.', 1413 1418 }, 1414 1419 }, 1415 1420 envs: { 1416 1416 - type: "array", 1421 1421 + type: 'array', 1417 1422 items: { 1418 1418 - type: "string", 1423 1423 + type: 'string', 1419 1424 description: 1420 1420 - "Name of an environment variable to be added to the sandbox environment.", 1425 1425 + 'Name of an environment variable to be added to the sandbox environment.', 1421 1426 }, 1422 1427 }, 1423 1428 createdAt: { 1424 1424 - type: "string", 1425 1425 - format: "datetime", 1429 1429 + type: 'string', 1430 1430 + format: 'datetime', 1426 1431 }, 1427 1432 }, 1428 1433 }, ··· 1431 1436 }, 1432 1437 IoPocketenvSandboxStartSandbox: { 1433 1438 lexicon: 1, 1434 1434 - id: "io.pocketenv.sandbox.startSandbox", 1439 1439 + id: 'io.pocketenv.sandbox.startSandbox', 1435 1440 defs: { 1436 1441 main: { 1437 1437 - type: "procedure", 1438 1438 - description: "Start a sandbox", 1442 1442 + type: 'procedure', 1443 1443 + description: 'Start a sandbox', 1439 1444 parameters: { 1440 1440 - type: "params", 1441 1441 - required: ["id"], 1445 1445 + type: 'params', 1446 1446 + required: ['id'], 1442 1447 properties: { 1443 1448 id: { 1444 1444 - type: "string", 1445 1445 - description: "The sandbox ID.", 1449 1449 + type: 'string', 1450 1450 + description: 'The sandbox ID.', 1446 1451 }, 1447 1452 }, 1448 1453 }, 1449 1454 output: { 1450 1450 - encoding: "application/json", 1455 1455 + encoding: 'application/json', 1451 1456 schema: { 1452 1452 - type: "ref", 1453 1453 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1457 1457 + type: 'ref', 1458 1458 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1454 1459 }, 1455 1460 }, 1456 1461 }, ··· 1458 1463 }, 1459 1464 IoPocketenvSandboxStopSandbox: { 1460 1465 lexicon: 1, 1461 1461 - id: "io.pocketenv.sandbox.stopSandbox", 1466 1466 + id: 'io.pocketenv.sandbox.stopSandbox', 1462 1467 defs: { 1463 1468 main: { 1464 1464 - type: "procedure", 1465 1465 - description: "Stop a sandbox", 1469 1469 + type: 'procedure', 1470 1470 + description: 'Stop a sandbox', 1466 1471 parameters: { 1467 1467 - type: "params", 1468 1468 - required: ["id"], 1472 1472 + type: 'params', 1473 1473 + required: ['id'], 1469 1474 properties: { 1470 1475 id: { 1471 1471 - type: "string", 1472 1472 - description: "The sandbox ID.", 1476 1476 + type: 'string', 1477 1477 + description: 'The sandbox ID.', 1473 1478 }, 1474 1479 }, 1475 1480 }, 1476 1481 output: { 1477 1477 - encoding: "application/json", 1482 1482 + encoding: 'application/json', 1478 1483 schema: { 1479 1479 - type: "ref", 1480 1480 - ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic", 1484 1484 + type: 'ref', 1485 1485 + ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic', 1481 1486 }, 1482 1487 }, 1483 1488 }, ··· 1485 1490 }, 1486 1491 IoPocketenvSandboxUpdateSandboxSettings: { 1487 1492 lexicon: 1, 1488 1488 - id: "io.pocketenv.sandbox.updateSandboxSettings", 1493 1493 + id: 'io.pocketenv.sandbox.updateSandboxSettings', 1489 1494 defs: { 1490 1495 main: { 1491 1491 - type: "procedure", 1492 1492 - description: "Update sandbox settings", 1496 1496 + type: 'procedure', 1497 1497 + description: 'Update sandbox settings', 1493 1498 input: { 1494 1494 - encoding: "application/json", 1499 1499 + encoding: 'application/json', 1495 1500 schema: { 1496 1496 - type: "object", 1501 1501 + type: 'object', 1497 1502 properties: { 1498 1503 name: { 1499 1499 - type: "string", 1500 1500 - description: "The name of the sandbox", 1504 1504 + type: 'string', 1505 1505 + description: 'The name of the sandbox', 1501 1506 minLength: 1, 1502 1507 }, 1503 1508 description: { 1504 1504 - type: "string", 1505 1505 - description: "A description for the sandbox", 1509 1509 + type: 'string', 1510 1510 + description: 'A description for the sandbox', 1506 1511 }, 1507 1512 topics: { 1508 1508 - type: "array", 1513 1513 + type: 'array', 1509 1514 description: 1510 1510 - "A list of topics/tags to associate with the sandbox", 1515 1515 + 'A list of topics/tags to associate with the sandbox', 1511 1516 items: { 1512 1512 - type: "string", 1517 1517 + type: 'string', 1513 1518 maxLength: 50, 1514 1519 }, 1515 1520 }, 1516 1521 repo: { 1517 1517 - type: "string", 1522 1522 + type: 'string', 1518 1523 description: 1519 1519 - "A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.", 1520 1520 - format: "uri", 1524 1524 + 'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.', 1525 1525 + format: 'uri', 1521 1526 }, 1522 1527 vcpus: { 1523 1523 - type: "integer", 1528 1528 + type: 'integer', 1524 1529 description: 1525 1525 - "The number of virtual CPUs to allocate for the sandbox", 1530 1530 + 'The number of virtual CPUs to allocate for the sandbox', 1526 1531 minimum: 1, 1527 1532 }, 1528 1533 memory: { 1529 1529 - type: "integer", 1534 1534 + type: 'integer', 1530 1535 description: 1531 1531 - "The amount of memory (in GB) to allocate for the sandbox", 1536 1536 + 'The amount of memory (in GB) to allocate for the sandbox', 1532 1537 minimum: 1, 1533 1538 }, 1534 1539 disk: { 1535 1535 - type: "integer", 1540 1540 + type: 'integer', 1536 1541 description: 1537 1537 - "The amount of disk space (in GB) to allocate for the sandbox", 1542 1542 + 'The amount of disk space (in GB) to allocate for the sandbox', 1538 1543 minimum: 3, 1539 1544 }, 1540 1545 readme: { 1541 1541 - type: "string", 1542 1542 - description: "A URI to a README for the sandbox.", 1543 1543 - format: "uri", 1546 1546 + type: 'string', 1547 1547 + description: 'A URI to a README for the sandbox.', 1548 1548 + format: 'uri', 1544 1549 }, 1545 1550 secrets: { 1546 1546 - type: "ref", 1547 1547 - description: "A list of secrets to add to the sandbox", 1548 1548 - ref: "lex:io.pocketenv.secret.defs#secrets", 1551 1551 + type: 'ref', 1552 1552 + description: 'A list of secrets to add to the sandbox', 1553 1553 + ref: 'lex:io.pocketenv.secret.defs#secrets', 1549 1554 }, 1550 1555 variables: { 1551 1551 - type: "ref", 1556 1556 + type: 'ref', 1552 1557 description: 1553 1553 - "A list of environment variables to add to the sandbox", 1554 1554 - ref: "lex:io.pocketenv.variable.defs#variables", 1558 1558 + 'A list of environment variables to add to the sandbox', 1559 1559 + ref: 'lex:io.pocketenv.variable.defs#variables', 1555 1560 }, 1556 1561 files: { 1557 1557 - type: "ref", 1558 1558 - description: "A list of files to add to the sandbox", 1559 1559 - ref: "lex:io.pocketenv.file.defs#file", 1562 1562 + type: 'ref', 1563 1563 + description: 'A list of files to add to the sandbox', 1564 1564 + ref: 'lex:io.pocketenv.file.defs#file', 1560 1565 }, 1561 1566 volumes: { 1562 1562 - type: "ref", 1563 1563 - description: "A list of volumes to add to the sandbox", 1564 1564 - ref: "lex:io.pocketenv.volume.defs#volumes", 1567 1567 + type: 'ref', 1568 1568 + description: 'A list of volumes to add to the sandbox', 1569 1569 + ref: 'lex:io.pocketenv.volume.defs#volumes', 1565 1570 }, 1566 1571 }, 1567 1572 }, 1568 1573 }, 1569 1574 output: { 1570 1570 - encoding: "application/json", 1575 1575 + encoding: 'application/json', 1571 1576 schema: { 1572 1572 - type: "ref", 1573 1573 - ref: "lex:io.pocketenv.sandbox.defs#profileViewDetailed", 1577 1577 + type: 'ref', 1578 1578 + ref: 'lex:io.pocketenv.sandbox.defs#profileViewDetailed', 1574 1579 }, 1575 1580 }, 1576 1581 }, ··· 1578 1583 }, 1579 1584 IoPocketenvSecretAddSecret: { 1580 1585 lexicon: 1, 1581 1581 - id: "io.pocketenv.secret.addSecret", 1586 1586 + id: 'io.pocketenv.secret.addSecret', 1582 1587 defs: { 1583 1588 main: { 1584 1584 - type: "procedure", 1589 1589 + type: 'procedure', 1585 1590 input: { 1586 1586 - encoding: "application/json", 1591 1591 + encoding: 'application/json', 1587 1592 schema: { 1588 1588 - type: "object", 1589 1589 - required: ["secret"], 1593 1593 + type: 'object', 1594 1594 + required: ['secret'], 1590 1595 properties: { 1591 1596 secret: { 1592 1592 - type: "ref", 1593 1593 - ref: "lex:io.pocketenv.secret.defs#secret", 1597 1597 + type: 'ref', 1598 1598 + ref: 'lex:io.pocketenv.secret.defs#secret', 1594 1599 }, 1595 1600 redacted: { 1596 1596 - type: "string", 1597 1597 - description: "The redacted secret value.", 1601 1601 + type: 'string', 1602 1602 + description: 'The redacted secret value.', 1598 1603 }, 1599 1604 }, 1600 1605 }, ··· 1604 1609 }, 1605 1610 IoPocketenvSecretDefs: { 1606 1611 lexicon: 1, 1607 1607 - id: "io.pocketenv.secret.defs", 1612 1612 + id: 'io.pocketenv.secret.defs', 1608 1613 defs: { 1609 1614 secretView: { 1610 1610 - type: "object", 1615 1615 + type: 'object', 1611 1616 properties: { 1612 1617 id: { 1613 1613 - type: "string", 1614 1614 - description: "Unique identifier of the secret.", 1618 1618 + type: 'string', 1619 1619 + description: 'Unique identifier of the secret.', 1615 1620 }, 1616 1621 name: { 1617 1617 - type: "string", 1622 1622 + type: 'string', 1618 1623 description: 1619 1624 "Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc.", 1620 1625 }, 1621 1626 }, 1622 1627 }, 1623 1628 secret: { 1624 1624 - type: "object", 1625 1625 - required: ["name", "value"], 1629 1629 + type: 'object', 1630 1630 + required: ['name', 'value'], 1626 1631 properties: { 1627 1632 sandboxId: { 1628 1628 - type: "string", 1633 1633 + type: 'string', 1629 1634 description: 1630 1630 - "The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment.", 1635 1635 + 'The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment.', 1631 1636 }, 1632 1637 name: { 1633 1633 - type: "string", 1638 1638 + type: 'string', 1634 1639 description: 1635 1640 "Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc.", 1636 1641 }, 1637 1642 value: { 1638 1638 - type: "string", 1643 1643 + type: 'string', 1639 1644 description: 1640 1640 - "Value of the secret. This will be encrypted at rest and redacted in any API responses.", 1645 1645 + 'Value of the secret. This will be encrypted at rest and redacted in any API responses.', 1641 1646 }, 1642 1647 }, 1643 1648 }, 1644 1649 secrets: { 1645 1645 - type: "array", 1650 1650 + type: 'array', 1646 1651 items: { 1647 1647 - type: "ref", 1648 1648 - description: "A secret to add to the sandbox", 1649 1649 - ref: "lex:io.pocketenv.secret.defs#secret", 1652 1652 + type: 'ref', 1653 1653 + description: 'A secret to add to the sandbox', 1654 1654 + ref: 'lex:io.pocketenv.secret.defs#secret', 1650 1655 }, 1651 1656 }, 1652 1657 }, 1653 1658 }, 1654 1659 IoPocketenvSecretDeleteSecret: { 1655 1660 lexicon: 1, 1656 1656 - id: "io.pocketenv.secret.deleteSecret", 1661 1661 + id: 'io.pocketenv.secret.deleteSecret', 1657 1662 defs: { 1658 1663 main: { 1659 1659 - type: "procedure", 1664 1664 + type: 'procedure', 1660 1665 parameters: { 1661 1661 - type: "params", 1662 1662 - required: ["id"], 1666 1666 + type: 'params', 1667 1667 + required: ['id'], 1663 1668 properties: { 1664 1669 id: { 1665 1665 - type: "string", 1666 1666 - description: "The ID of the secret to delete", 1670 1670 + type: 'string', 1671 1671 + description: 'The ID of the secret to delete', 1667 1672 }, 1668 1673 }, 1669 1674 }, ··· 1672 1677 }, 1673 1678 IoPocketenvSecretGetSecrets: { 1674 1679 lexicon: 1, 1675 1675 - id: "io.pocketenv.secret.getSecrets", 1680 1680 + id: 'io.pocketenv.secret.getSecrets', 1676 1681 defs: { 1677 1682 main: { 1678 1678 - type: "query", 1683 1683 + type: 'query', 1679 1684 parameters: { 1680 1680 - type: "params", 1685 1685 + type: 'params', 1681 1686 properties: { 1682 1687 sandboxId: { 1683 1683 - type: "string", 1688 1688 + type: 'string', 1684 1689 description: 1685 1685 - "The ID of the sandbox for which to retrieve secrets.", 1690 1690 + 'The ID of the sandbox for which to retrieve secrets.', 1686 1691 }, 1687 1692 limit: { 1688 1688 - type: "integer", 1689 1689 - description: "The maximum number of secrets to return.", 1693 1693 + type: 'integer', 1694 1694 + description: 'The maximum number of secrets to return.', 1690 1695 minimum: 1, 1691 1696 }, 1692 1697 offset: { 1693 1693 - type: "integer", 1698 1698 + type: 'integer', 1694 1699 description: 1695 1695 - "The number of secrets to skip before starting to collect the result set.", 1700 1700 + 'The number of secrets to skip before starting to collect the result set.', 1696 1701 minimum: 0, 1697 1702 }, 1698 1703 }, 1699 1704 }, 1700 1705 output: { 1701 1701 - encoding: "application/json", 1706 1706 + encoding: 'application/json', 1702 1707 schema: { 1703 1703 - type: "object", 1708 1708 + type: 'object', 1704 1709 properties: { 1705 1710 secrets: { 1706 1706 - type: "array", 1711 1711 + type: 'array', 1707 1712 items: { 1708 1708 - type: "ref", 1709 1709 - ref: "lex:io.pocketenv.secret.defs#secretView", 1713 1713 + type: 'ref', 1714 1714 + ref: 'lex:io.pocketenv.secret.defs#secretView', 1710 1715 }, 1711 1716 }, 1712 1717 total: { 1713 1713 - type: "integer", 1714 1714 - description: "The total number of secrets available.", 1718 1718 + type: 'integer', 1719 1719 + description: 'The total number of secrets available.', 1715 1720 minimum: 0, 1716 1721 }, 1717 1722 }, ··· 1722 1727 }, 1723 1728 IoPocketenvVariableAddVariable: { 1724 1729 lexicon: 1, 1725 1725 - id: "io.pocketenv.variable.addVariable", 1730 1730 + id: 'io.pocketenv.variable.addVariable', 1726 1731 defs: { 1727 1732 main: { 1728 1728 - type: "procedure", 1733 1733 + type: 'procedure', 1729 1734 input: { 1730 1730 - encoding: "application/json", 1735 1735 + encoding: 'application/json', 1731 1736 schema: { 1732 1732 - type: "object", 1733 1733 - required: ["variable"], 1737 1737 + type: 'object', 1738 1738 + required: ['variable'], 1734 1739 properties: { 1735 1740 variable: { 1736 1736 - type: "ref", 1737 1737 - ref: "lex:io.pocketenv.variable.defs#variable", 1741 1741 + type: 'ref', 1742 1742 + ref: 'lex:io.pocketenv.variable.defs#variable', 1738 1743 }, 1739 1744 }, 1740 1745 }, ··· 1744 1749 }, 1745 1750 IoPocketenvVariableDefs: { 1746 1751 lexicon: 1, 1747 1747 - id: "io.pocketenv.variable.defs", 1752 1752 + id: 'io.pocketenv.variable.defs', 1748 1753 defs: { 1749 1754 variableView: { 1750 1750 - type: "object", 1755 1755 + type: 'object', 1751 1756 properties: { 1752 1757 id: { 1753 1753 - type: "string", 1754 1754 - description: "Unique identifier of the environment variable.", 1758 1758 + type: 'string', 1759 1759 + description: 'Unique identifier of the environment variable.', 1755 1760 }, 1756 1761 name: { 1757 1757 - type: "string", 1762 1762 + type: 'string', 1758 1763 description: 1759 1764 "Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc.", 1760 1765 }, 1761 1766 value: { 1762 1762 - type: "string", 1767 1767 + type: 'string', 1763 1768 description: 1764 1764 - "Value of the environment variable. This will be visible in API responses and should not contain sensitive information.", 1769 1769 + 'Value of the environment variable. This will be visible in API responses and should not contain sensitive information.', 1765 1770 }, 1766 1771 }, 1767 1772 }, 1768 1773 variable: { 1769 1769 - type: "object", 1770 1770 - required: ["name", "value"], 1774 1774 + type: 'object', 1775 1775 + required: ['name', 'value'], 1771 1776 properties: { 1772 1777 sandboxId: { 1773 1773 - type: "string", 1778 1778 + type: 'string', 1774 1779 description: 1775 1775 - "The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment.", 1780 1780 + 'The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment.', 1776 1781 }, 1777 1782 name: { 1778 1778 - type: "string", 1783 1783 + type: 'string', 1779 1784 description: 1780 1785 "Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc.", 1781 1786 }, 1782 1787 value: { 1783 1783 - type: "string", 1788 1788 + type: 'string', 1784 1789 description: 1785 1785 - "Value of the environment variable. This will be visible in API responses and should not contain sensitive information.", 1790 1790 + 'Value of the environment variable. This will be visible in API responses and should not contain sensitive information.', 1786 1791 }, 1787 1792 }, 1788 1793 }, 1789 1794 variables: { 1790 1790 - type: "array", 1795 1795 + type: 'array', 1791 1796 items: { 1792 1792 - type: "ref", 1793 1793 - description: "An environment variable to add to the sandbox", 1794 1794 - ref: "lex:io.pocketenv.variable.defs#envVar", 1797 1797 + type: 'ref', 1798 1798 + description: 'An environment variable to add to the sandbox', 1799 1799 + ref: 'lex:io.pocketenv.variable.defs#envVar', 1795 1800 }, 1796 1801 }, 1797 1802 }, 1798 1803 }, 1799 1804 IoPocketenvVariableDeleteVariable: { 1800 1805 lexicon: 1, 1801 1801 - id: "io.pocketenv.variable.deleteVariable", 1806 1806 + id: 'io.pocketenv.variable.deleteVariable', 1802 1807 defs: { 1803 1808 main: { 1804 1804 - type: "procedure", 1809 1809 + type: 'procedure', 1805 1810 parameters: { 1806 1806 - type: "params", 1807 1807 - required: ["id"], 1811 1811 + type: 'params', 1812 1812 + required: ['id'], 1808 1813 properties: { 1809 1814 id: { 1810 1810 - type: "string", 1811 1811 - description: "The ID of the environment variable to delete", 1815 1815 + type: 'string', 1816 1816 + description: 'The ID of the environment variable to delete', 1812 1817 }, 1813 1818 }, 1814 1819 }, ··· 1817 1822 }, 1818 1823 IoPocketenvVariableGetVariables: { 1819 1824 lexicon: 1, 1820 1820 - id: "io.pocketenv.variable.getVariables", 1825 1825 + id: 'io.pocketenv.variable.getVariables', 1821 1826 defs: { 1822 1827 main: { 1823 1823 - type: "query", 1828 1828 + type: 'query', 1824 1829 parameters: { 1825 1825 - type: "params", 1830 1830 + type: 'params', 1826 1831 properties: { 1827 1832 sandboxId: { 1828 1828 - type: "string", 1833 1833 + type: 'string', 1829 1834 description: 1830 1830 - "The ID of the sandbox for which to retrieve variables.", 1835 1835 + 'The ID of the sandbox for which to retrieve variables.', 1831 1836 }, 1832 1837 limit: { 1833 1833 - type: "integer", 1834 1834 - description: "The maximum number of variables to return.", 1838 1838 + type: 'integer', 1839 1839 + description: 'The maximum number of variables to return.', 1835 1840 minimum: 1, 1836 1841 }, 1837 1842 offset: { 1838 1838 - type: "integer", 1843 1843 + type: 'integer', 1839 1844 description: 1840 1840 - "The number of variables to skip before starting to collect the result set.", 1845 1845 + 'The number of variables to skip before starting to collect the result set.', 1841 1846 minimum: 0, 1842 1847 }, 1843 1848 }, 1844 1849 }, 1845 1850 output: { 1846 1846 - encoding: "application/json", 1851 1851 + encoding: 'application/json', 1847 1852 schema: { 1848 1848 - type: "object", 1853 1853 + type: 'object', 1849 1854 properties: { 1850 1855 variables: { 1851 1851 - type: "array", 1856 1856 + type: 'array', 1852 1857 items: { 1853 1853 - type: "ref", 1854 1854 - ref: "lex:io.pocketenv.variable.defs#variableView", 1858 1858 + type: 'ref', 1859 1859 + ref: 'lex:io.pocketenv.variable.defs#variableView', 1855 1860 }, 1856 1861 }, 1857 1862 total: { 1858 1858 - type: "integer", 1859 1859 - description: "The total number of variables available.", 1863 1863 + type: 'integer', 1864 1864 + description: 'The total number of variables available.', 1860 1865 minimum: 0, 1861 1866 }, 1862 1867 }, ··· 1867 1872 }, 1868 1873 IoPocketenvVolumeAddVolume: { 1869 1874 lexicon: 1, 1870 1870 - id: "io.pocketenv.volume.addVolume", 1875 1875 + id: 'io.pocketenv.volume.addVolume', 1871 1876 defs: { 1872 1877 main: { 1873 1873 - type: "procedure", 1878 1878 + type: 'procedure', 1874 1879 input: { 1875 1875 - encoding: "application/json", 1880 1880 + encoding: 'application/json', 1876 1881 schema: { 1877 1877 - type: "object", 1878 1878 - required: ["volume"], 1882 1882 + type: 'object', 1883 1883 + required: ['volume'], 1879 1884 properties: { 1880 1885 volume: { 1881 1881 - type: "ref", 1882 1882 - ref: "lex:io.pocketenv.volume.defs#volume", 1886 1886 + type: 'ref', 1887 1887 + ref: 'lex:io.pocketenv.volume.defs#volume', 1883 1888 }, 1884 1889 }, 1885 1890 }, ··· 1889 1894 }, 1890 1895 IoPocketenvVolumeDefs: { 1891 1896 lexicon: 1, 1892 1892 - id: "io.pocketenv.volume.defs", 1897 1897 + id: 'io.pocketenv.volume.defs', 1893 1898 defs: { 1894 1899 volumeView: { 1895 1895 - type: "object", 1900 1900 + type: 'object', 1896 1901 properties: { 1897 1902 id: { 1898 1898 - type: "string", 1899 1899 - description: "Unique identifier of the volume.", 1903 1903 + type: 'string', 1904 1904 + description: 'Unique identifier of the volume.', 1900 1905 }, 1901 1906 name: { 1902 1902 - type: "string", 1907 1907 + type: 'string', 1903 1908 description: "Name of the volume, e.g. 'data-volume', 'logs', etc.", 1904 1909 }, 1905 1910 path: { 1906 1906 - type: "string", 1911 1911 + type: 'string', 1907 1912 description: 1908 1913 "The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc.", 1909 1914 }, 1910 1915 readOnly: { 1911 1911 - type: "boolean", 1916 1916 + type: 'boolean', 1912 1917 description: 1913 1913 - "Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).", 1918 1918 + 'Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).', 1914 1919 }, 1915 1920 createdAt: { 1916 1916 - type: "string", 1917 1917 - description: "The timestamp when the volume was created.", 1918 1918 - format: "datetime", 1921 1921 + type: 'string', 1922 1922 + description: 'The timestamp when the volume was created.', 1923 1923 + format: 'datetime', 1919 1924 }, 1920 1925 updatedAt: { 1921 1921 - type: "string", 1922 1922 - description: "The timestamp when the volume was last updated.", 1923 1923 - format: "datetime", 1926 1926 + type: 'string', 1927 1927 + description: 'The timestamp when the volume was last updated.', 1928 1928 + format: 'datetime', 1924 1929 }, 1925 1930 }, 1926 1931 }, 1927 1932 volumes: { 1928 1928 - type: "array", 1933 1933 + type: 'array', 1929 1934 items: { 1930 1930 - type: "ref", 1931 1931 - description: "A volume to add to the sandbox", 1932 1932 - ref: "lex:io.pocketenv.volume.defs#volume", 1935 1935 + type: 'ref', 1936 1936 + description: 'A volume to add to the sandbox', 1937 1937 + ref: 'lex:io.pocketenv.volume.defs#volume', 1933 1938 }, 1934 1939 }, 1935 1940 volume: { 1936 1936 - type: "object", 1937 1937 - required: ["name"], 1941 1941 + type: 'object', 1942 1942 + required: ['name'], 1938 1943 properties: { 1939 1944 sandboxId: { 1940 1940 - type: "string", 1945 1945 + type: 'string', 1941 1946 description: 1942 1942 - "The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment.", 1947 1947 + 'The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment.', 1943 1948 }, 1944 1949 name: { 1945 1945 - type: "string", 1950 1950 + type: 'string', 1946 1951 description: "Name of the volume, e.g. 'data-volume', 'logs', etc.", 1947 1952 }, 1948 1953 path: { 1949 1949 - type: "string", 1954 1954 + type: 'string', 1950 1955 description: 1951 1956 "The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc.", 1952 1957 }, 1953 1958 readOnly: { 1954 1954 - type: "boolean", 1959 1959 + type: 'boolean', 1955 1960 description: 1956 1956 - "Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).", 1961 1961 + 'Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).', 1957 1962 }, 1958 1963 }, 1959 1964 }, ··· 1961 1966 }, 1962 1967 IoPocketenvVolumeDeleteVolume: { 1963 1968 lexicon: 1, 1964 1964 - id: "io.pocketenv.volume.deleteVolume", 1969 1969 + id: 'io.pocketenv.volume.deleteVolume', 1965 1970 defs: { 1966 1971 main: { 1967 1967 - type: "procedure", 1972 1972 + type: 'procedure', 1968 1973 parameters: { 1969 1969 - type: "params", 1970 1970 - required: ["id"], 1974 1974 + type: 'params', 1975 1975 + required: ['id'], 1971 1976 properties: { 1972 1977 id: { 1973 1973 - type: "string", 1974 1974 - description: "The ID of the volume to delete.", 1978 1978 + type: 'string', 1979 1979 + description: 'The ID of the volume to delete.', 1975 1980 }, 1976 1981 }, 1977 1982 }, ··· 1980 1985 }, 1981 1986 IoPocketenvVolumeGetVolumes: { 1982 1987 lexicon: 1, 1983 1983 - id: "io.pocketenv.volume.getVolumes", 1988 1988 + id: 'io.pocketenv.volume.getVolumes', 1984 1989 defs: { 1985 1990 main: { 1986 1986 - type: "query", 1991 1991 + type: 'query', 1987 1992 parameters: { 1988 1988 - type: "params", 1993 1993 + type: 'params', 1989 1994 properties: { 1990 1995 sandboxId: { 1991 1991 - type: "string", 1996 1996 + type: 'string', 1992 1997 description: 1993 1993 - "The ID of the sandbox for which to retrieve volumes.", 1998 1998 + 'The ID of the sandbox for which to retrieve volumes.', 1994 1999 }, 1995 2000 limit: { 1996 1996 - type: "integer", 1997 1997 - description: "The maximum number of volumes to return.", 2001 2001 + type: 'integer', 2002 2002 + description: 'The maximum number of volumes to return.', 1998 2003 minimum: 1, 1999 2004 }, 2000 2005 offset: { 2001 2001 - type: "integer", 2006 2006 + type: 'integer', 2002 2007 description: 2003 2003 - "The number of volumes to skip before starting to collect the result set.", 2008 2008 + 'The number of volumes to skip before starting to collect the result set.', 2004 2009 minimum: 0, 2005 2010 }, 2006 2011 }, 2007 2012 }, 2008 2013 output: { 2009 2009 - encoding: "application/json", 2014 2014 + encoding: 'application/json', 2010 2015 schema: { 2011 2011 - type: "object", 2016 2016 + type: 'object', 2012 2017 properties: { 2013 2018 volumes: { 2014 2014 - type: "array", 2019 2019 + type: 'array', 2015 2020 items: { 2016 2016 - type: "ref", 2017 2017 - ref: "lex:io.pocketenv.volume.defs#volumeView", 2021 2021 + type: 'ref', 2022 2022 + ref: 'lex:io.pocketenv.volume.defs#volumeView', 2018 2023 }, 2019 2024 }, 2020 2025 total: { 2021 2021 - type: "integer", 2022 2022 - description: "The total number of volumes available.", 2026 2026 + type: 'integer', 2027 2027 + description: 'The total number of volumes available.', 2023 2028 minimum: 0, 2024 2029 }, 2025 2030 }, ··· 2030 2035 }, 2031 2036 IoPocketenvPublicKey: { 2032 2037 lexicon: 1, 2033 2033 - id: "io.pocketenv.publicKey", 2038 2038 + id: 'io.pocketenv.publicKey', 2034 2039 defs: { 2035 2040 main: { 2036 2036 - type: "record", 2037 2037 - key: "tid", 2041 2041 + type: 'record', 2042 2042 + key: 'tid', 2038 2043 record: { 2039 2039 - type: "object", 2040 2040 - required: ["name", "key", "createdAt"], 2044 2044 + type: 'object', 2045 2045 + required: ['name', 'key', 'createdAt'], 2041 2046 properties: { 2042 2047 name: { 2043 2043 - type: "string", 2044 2044 - description: "Name of the public key", 2048 2048 + type: 'string', 2049 2049 + description: 'Name of the public key', 2045 2050 maxLength: 255, 2046 2051 }, 2047 2052 key: { 2048 2048 - type: "string", 2053 2053 + type: 'string', 2049 2054 description: 2050 2050 - "The public key value, e.g. an SSH public key string.", 2055 2055 + 'The public key value, e.g. an SSH public key string.', 2051 2056 }, 2052 2057 createdAt: { 2053 2053 - type: "string", 2054 2054 - format: "datetime", 2058 2058 + type: 'string', 2059 2059 + format: 'datetime', 2055 2060 }, 2056 2061 }, 2057 2062 }, ··· 2060 2065 }, 2061 2066 ComAtprotoRepoStrongRef: { 2062 2067 lexicon: 1, 2063 2063 - id: "com.atproto.repo.strongRef", 2064 2064 - description: "A URI with a content-hash fingerprint.", 2068 2068 + id: 'com.atproto.repo.strongRef', 2069 2069 + description: 'A URI with a content-hash fingerprint.', 2065 2070 defs: { 2066 2071 main: { 2067 2067 - type: "object", 2068 2068 - required: ["uri", "cid"], 2072 2072 + type: 'object', 2073 2073 + required: ['uri', 'cid'], 2069 2074 properties: { 2070 2075 uri: { 2071 2071 - type: "string", 2072 2072 - format: "at-uri", 2076 2076 + type: 'string', 2077 2077 + format: 'at-uri', 2073 2078 }, 2074 2079 cid: { 2075 2075 - type: "string", 2076 2076 - format: "cid", 2080 2080 + type: 'string', 2081 2081 + format: 'cid', 2077 2082 }, 2078 2083 }, 2079 2084 }, 2080 2085 }, 2081 2086 }, 2082 2082 - } as const satisfies Record<string, LexiconDoc>; 2087 2087 + } as const satisfies Record<string, LexiconDoc> 2083 2088 2084 2084 - export const schemas = Object.values(schemaDict); 2085 2085 - export const lexicons: Lexicons = new Lexicons(schemas); 2089 2089 + export const schemas = Object.values(schemaDict) 2090 2090 + export const lexicons: Lexicons = new Lexicons(schemas) 2086 2091 export const ids = { 2087 2087 - IoPocketenvActorDefs: "io.pocketenv.actor.defs", 2088 2088 - IoPocketenvActorGetActorSandboxes: "io.pocketenv.actor.getActorSandboxes", 2089 2089 - IoPocketenvActorGetProfile: "io.pocketenv.actor.getProfile", 2090 2090 - IoPocketenvActorGetTerminalToken: "io.pocketenv.actor.getTerminalToken", 2091 2091 - AppBskyActorProfile: "app.bsky.actor.profile", 2092 2092 - IoPocketenvFileAddFile: "io.pocketenv.file.addFile", 2093 2093 - IoPocketenvFileDefs: "io.pocketenv.file.defs", 2094 2094 - IoPocketenvFileDeleteFile: "io.pocketenv.file.deleteFile", 2095 2095 - IoPocketenvFileGetFiles: "io.pocketenv.file.getFiles", 2096 2096 - IoPocketenvSandboxClaimSandbox: "io.pocketenv.sandbox.claimSandbox", 2097 2097 - IoPocketenvSandboxCreateIntegration: "io.pocketenv.sandbox.createIntegration", 2098 2098 - IoPocketenvSandboxCreateSandbox: "io.pocketenv.sandbox.createSandbox", 2099 2099 - IoPocketenvSandboxDefs: "io.pocketenv.sandbox.defs", 2100 2100 - IoPocketenvSandboxDeleteSandbox: "io.pocketenv.sandbox.deleteSandbox", 2101 2101 - IoPocketenvSandboxGetIntegrations: "io.pocketenv.sandbox.getIntegrations", 2102 2102 - IoPocketenvSandboxGetPreferences: "io.pocketenv.sandbox.getPreferences", 2103 2103 - IoPocketenvSandboxGetSandbox: "io.pocketenv.sandbox.getSandbox", 2104 2104 - IoPocketenvSandboxGetSandboxes: "io.pocketenv.sandbox.getSandboxes", 2105 2105 - IoPocketenvSandboxGetSshKeys: "io.pocketenv.sandbox.getSshKeys", 2092 2092 + IoPocketenvActorDefs: 'io.pocketenv.actor.defs', 2093 2093 + IoPocketenvActorGetActorSandboxes: 'io.pocketenv.actor.getActorSandboxes', 2094 2094 + IoPocketenvActorGetProfile: 'io.pocketenv.actor.getProfile', 2095 2095 + IoPocketenvActorGetTerminalToken: 'io.pocketenv.actor.getTerminalToken', 2096 2096 + AppBskyActorProfile: 'app.bsky.actor.profile', 2097 2097 + IoPocketenvFileAddFile: 'io.pocketenv.file.addFile', 2098 2098 + IoPocketenvFileDefs: 'io.pocketenv.file.defs', 2099 2099 + IoPocketenvFileDeleteFile: 'io.pocketenv.file.deleteFile', 2100 2100 + IoPocketenvFileGetFiles: 'io.pocketenv.file.getFiles', 2101 2101 + IoPocketenvSandboxClaimSandbox: 'io.pocketenv.sandbox.claimSandbox', 2102 2102 + IoPocketenvSandboxCreateIntegration: 'io.pocketenv.sandbox.createIntegration', 2103 2103 + IoPocketenvSandboxCreateSandbox: 'io.pocketenv.sandbox.createSandbox', 2104 2104 + IoPocketenvSandboxDefs: 'io.pocketenv.sandbox.defs', 2105 2105 + IoPocketenvSandboxDeleteSandbox: 'io.pocketenv.sandbox.deleteSandbox', 2106 2106 + IoPocketenvSandboxGetIntegrations: 'io.pocketenv.sandbox.getIntegrations', 2107 2107 + IoPocketenvSandboxGetPreferences: 'io.pocketenv.sandbox.getPreferences', 2108 2108 + IoPocketenvSandboxGetSandbox: 'io.pocketenv.sandbox.getSandbox', 2109 2109 + IoPocketenvSandboxGetSandboxes: 'io.pocketenv.sandbox.getSandboxes', 2110 2110 + IoPocketenvSandboxGetSshKeys: 'io.pocketenv.sandbox.getSshKeys', 2106 2111 IoPocketenvSandboxGetTailscaleAuthKey: 2107 2107 - "io.pocketenv.sandbox.getTailscaleAuthKey", 2108 2108 - IoPocketenvSandboxGetTailscaleToken: "io.pocketenv.sandbox.getTailscaleToken", 2109 2109 - IoPocketenvSandboxPutPreferences: "io.pocketenv.sandbox.putPreferences", 2110 2110 - IoPocketenvSandboxPutSshKeys: "io.pocketenv.sandbox.putSshKeys", 2112 2112 + 'io.pocketenv.sandbox.getTailscaleAuthKey', 2113 2113 + IoPocketenvSandboxGetTailscaleToken: 'io.pocketenv.sandbox.getTailscaleToken', 2114 2114 + IoPocketenvSandboxPutPreferences: 'io.pocketenv.sandbox.putPreferences', 2115 2115 + IoPocketenvSandboxPutSshKeys: 'io.pocketenv.sandbox.putSshKeys', 2111 2116 IoPocketenvSandboxPutTailscaleAuthKey: 2112 2112 - "io.pocketenv.sandbox.putTailscaleAuthKey", 2113 2113 - IoPocketenvSandboxPutTailscaleToken: "io.pocketenv.sandbox.putTailscaleToken", 2114 2114 - IoPocketenvSandbox: "io.pocketenv.sandbox", 2115 2115 - IoPocketenvSandboxStartSandbox: "io.pocketenv.sandbox.startSandbox", 2116 2116 - IoPocketenvSandboxStopSandbox: "io.pocketenv.sandbox.stopSandbox", 2117 2117 + 'io.pocketenv.sandbox.putTailscaleAuthKey', 2118 2118 + IoPocketenvSandboxPutTailscaleToken: 'io.pocketenv.sandbox.putTailscaleToken', 2119 2119 + IoPocketenvSandbox: 'io.pocketenv.sandbox', 2120 2120 + IoPocketenvSandboxStartSandbox: 'io.pocketenv.sandbox.startSandbox', 2121 2121 + IoPocketenvSandboxStopSandbox: 'io.pocketenv.sandbox.stopSandbox', 2117 2122 IoPocketenvSandboxUpdateSandboxSettings: 2118 2118 - "io.pocketenv.sandbox.updateSandboxSettings", 2119 2119 - IoPocketenvSecretAddSecret: "io.pocketenv.secret.addSecret", 2120 2120 - IoPocketenvSecretDefs: "io.pocketenv.secret.defs", 2121 2121 - IoPocketenvSecretDeleteSecret: "io.pocketenv.secret.deleteSecret", 2122 2122 - IoPocketenvSecretGetSecrets: "io.pocketenv.secret.getSecrets", 2123 2123 - IoPocketenvVariableAddVariable: "io.pocketenv.variable.addVariable", 2124 2124 - IoPocketenvVariableDefs: "io.pocketenv.variable.defs", 2125 2125 - IoPocketenvVariableDeleteVariable: "io.pocketenv.variable.deleteVariable", 2126 2126 - IoPocketenvVariableGetVariables: "io.pocketenv.variable.getVariables", 2127 2127 - IoPocketenvVolumeAddVolume: "io.pocketenv.volume.addVolume", 2128 2128 - IoPocketenvVolumeDefs: "io.pocketenv.volume.defs", 2129 2129 - IoPocketenvVolumeDeleteVolume: "io.pocketenv.volume.deleteVolume", 2130 2130 - IoPocketenvVolumeGetVolumes: "io.pocketenv.volume.getVolumes", 2131 2131 - IoPocketenvPublicKey: "io.pocketenv.publicKey", 2132 2132 - ComAtprotoRepoStrongRef: "com.atproto.repo.strongRef", 2133 2133 - }; 2123 2123 + 'io.pocketenv.sandbox.updateSandboxSettings', 2124 2124 + IoPocketenvSecretAddSecret: 'io.pocketenv.secret.addSecret', 2125 2125 + IoPocketenvSecretDefs: 'io.pocketenv.secret.defs', 2126 2126 + IoPocketenvSecretDeleteSecret: 'io.pocketenv.secret.deleteSecret', 2127 2127 + IoPocketenvSecretGetSecrets: 'io.pocketenv.secret.getSecrets', 2128 2128 + IoPocketenvVariableAddVariable: 'io.pocketenv.variable.addVariable', 2129 2129 + IoPocketenvVariableDefs: 'io.pocketenv.variable.defs', 2130 2130 + IoPocketenvVariableDeleteVariable: 'io.pocketenv.variable.deleteVariable', 2131 2131 + IoPocketenvVariableGetVariables: 'io.pocketenv.variable.getVariables', 2132 2132 + IoPocketenvVolumeAddVolume: 'io.pocketenv.volume.addVolume', 2133 2133 + IoPocketenvVolumeDefs: 'io.pocketenv.volume.defs', 2134 2134 + IoPocketenvVolumeDeleteVolume: 'io.pocketenv.volume.deleteVolume', 2135 2135 + IoPocketenvVolumeGetVolumes: 'io.pocketenv.volume.getVolumes', 2136 2136 + IoPocketenvPublicKey: 'io.pocketenv.publicKey', 2137 2137 + ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef', 2138 2138 + }

+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

+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

+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

+38 -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"; 22 22 + provider?: 'daytona' | 'vercel' | 'cloudflare' | 'deno' 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 + [k: string]: unknown 38 38 } 39 39 40 40 - export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic; 40 40 + export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic 41 41 42 42 export interface HandlerInput { 43 43 - encoding: "application/json"; 44 44 - body: InputSchema; 43 43 + encoding: 'application/json' 44 44 + body: InputSchema 45 45 } 46 46 47 47 export interface HandlerSuccess { 48 48 - encoding: "application/json"; 49 49 - body: OutputSchema; 50 50 - headers?: { [key: string]: string }; 48 48 + encoding: 'application/json' 49 49 + body: OutputSchema 50 50 + headers?: { [key: string]: string } 51 51 } 52 52 53 53 export interface HandlerError { 54 54 - status: number; 55 55 - message?: string; 54 54 + status: number 55 55 + message?: string 56 56 } 57 57 58 58 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 58 58 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 59 59 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 - }; 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 + } 67 67 export type Handler<HA extends HandlerAuth = never> = ( 68 68 ctx: HandlerReqCtx<HA>, 69 69 - ) => Promise<HandlerOutput> | HandlerOutput; 69 69 + ) => 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; 102 102 + description?: string | null 103 103 /** A list of topics/tags to associate with the sandbox */ 104 104 - topics?: string[]; 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; 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

+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

+25 -23

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 - preferences: IoPocketenvSandboxDefs.Preferences; 16 16 - [k: string]: unknown; 15 15 + /** The sandbox ID or URI */ 16 16 + sandboxId: string 17 17 + preferences: IoPocketenvSandboxDefs.Preferences 18 18 + [k: string]: unknown 17 19 } 18 20 19 21 export interface HandlerInput { 20 20 - encoding: "application/json"; 21 21 - body: InputSchema; 22 22 + encoding: 'application/json' 23 23 + body: InputSchema 22 24 } 23 25 24 26 export interface HandlerError { 25 25 - status: number; 26 26 - message?: string; 27 27 + status: number 28 28 + message?: string 27 29 } 28 30 29 29 - export type HandlerOutput = HandlerError | void; 31 31 + export type HandlerOutput = HandlerError | void 30 32 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 - }; 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 + } 38 40 export type Handler<HA extends HandlerAuth = never> = ( 39 41 ctx: HandlerReqCtx<HA>, 40 40 - ) => 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

+25 -25

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 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

+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

+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

+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

+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

+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

+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

+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

+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 }

+33

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

reviewed

··· 1 1 import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server"; 2 2 import type { Context } from "context"; 3 3 + import { and, eq } from "drizzle-orm"; 3 4 import type { Server } from "lexicon"; 5 5 + import { isSandboxDetailsPref } from "lexicon/types/io/pocketenv/sandbox/defs"; 4 6 import type { HandlerInput } from "lexicon/types/io/pocketenv/sandbox/putPreferences"; 7 7 + import sandboxes from "schema/sandboxes"; 8 8 + import users from "schema/users"; 5 9 6 10 export default function (server: Server, ctx: Context) { 7 11 const putPreferences = async (input: HandlerInput, auth: HandlerAuth) => { ··· 9 13 throw new XRPCError(401, "Unauthorized"); 10 14 } 11 15 16 16 + const [user] = await ctx.db 17 17 + .select() 18 18 + .from(users) 19 19 + .where(eq(users.did, auth.credentials.did)) 20 20 + .execute(); 21 21 + 22 22 + if (!user) { 23 23 + throw new XRPCError(404, "User not found"); 24 24 + } 25 25 + 26 26 + for (const pref of input.body.preferences) { 27 27 + if (isSandboxDetailsPref(pref)) { 28 28 + await ctx.db 29 29 + .update(sandboxes) 30 30 + .set({ 31 31 + name: pref.name, 32 32 + description: pref.description, 33 33 + topics: pref.topics, 34 34 + repo: pref.repo, 35 35 + }) 36 36 + .where( 37 37 + and( 38 38 + eq(sandboxes.id, input.body.sandboxId), 39 39 + eq(sandboxes.userId, user.id), 40 40 + ), 41 41 + ) 42 42 + .execute(); 43 43 + } 44 44 + } 12 45 return {}; 13 46 }; 14 47 server.io.pocketenv.sandbox.putPreferences({

+13

apps/web/src/api/preferences.ts

reviewed

··· 1 1 + import { client } from "."; 2 2 + import type { Preference } from "../types/preferences"; 3 3 + 4 4 + export const putPreferences = (sandboxId: string, preferences: Preference[]) => 5 5 + client.post( 6 6 + "/xrpc/io.pocketenv.sandbox.putPreferences", 7 7 + { sandboxId, preferences }, 8 8 + { 9 9 + headers: { 10 10 + Authorization: `Bearer ${localStorage.getItem("token")}`, 11 11 + }, 12 12 + }, 13 13 + );

+12

apps/web/src/hooks/usePreferences.ts

reviewed

··· 1 1 + import { useMutation } from "@tanstack/react-query"; 2 2 + import { putPreferences } from "../api/preferences"; 3 3 + import type { Preference } from "../types/preferences"; 4 4 + 5 5 + export const useUpdatePreferencesMutation = () => 6 6 + useMutation({ 7 7 + mutationKey: ["updatePreferences"], 8 8 + mutationFn: async (params: { 9 9 + sandboxId: string; 10 10 + preferences: Preference[]; 11 11 + }) => putPreferences(params.sandboxId, params.preferences), 12 12 + });

+26 -4

apps/web/src/pages/settings/Settings.tsx

reviewed

··· 7 7 import Main from "../../layouts/Main"; 8 8 import Sidebar from "./sidebar/Sidebar"; 9 9 import { useNotyf } from "../../hooks/useNotyf"; 10 10 + import { useUpdatePreferencesMutation } from "../../hooks/usePreferences"; 11 11 + import consola from "consola"; 12 12 + import { useQueryClient } from "@tanstack/react-query"; 10 13 11 14 const settingsSchema = z.object({ 12 15 name: z ··· 25 28 26 29 function Settings() { 27 30 const notyf = useNotyf(); 28 28 - 31 31 + const { mutateAsync: updatePreferences } = useUpdatePreferencesMutation(); 32 32 + const queryClient = useQueryClient(); 29 33 const routerState = useRouterState(); 30 34 const pathname = routerState.location.pathname; 31 35 const { data } = useSandboxQuery( ··· 55 59 } 56 60 }, [data, reset]); 57 61 58 58 - const onSubmit = (values: SettingsFormValues) => { 59 59 - console.log(values); 60 60 - notyf.open("primary", "Settings saved successfully!"); 62 62 + const onSubmit = async (values: SettingsFormValues) => { 63 63 + try { 64 64 + await updatePreferences({ 65 65 + sandboxId: data!.sandbox!.id, 66 66 + preferences: [ 67 67 + { 68 68 + name: values.name, 69 69 + description: values.description, 70 70 + topics: values.topics?.split(" "), 71 71 + $type: "io.pocketenv.sandbox.defs#sandboxDetailsPref", 72 72 + }, 73 73 + ], 74 74 + }); 75 75 + queryClient.invalidateQueries({ 76 76 + queryKey: ["sandbox", data!.sandbox!.id], 77 77 + }); 78 78 + notyf.open("primary", "Settings saved successfully!"); 79 79 + } catch (error) { 80 80 + consola.error(error); 81 81 + notyf.open("error", "Failed to save settings!"); 82 82 + } 61 83 }; 62 84 63 85 return (

+39 -6

apps/web/src/pages/settings/repository/Repository.tsx

reviewed

··· 6 6 import Main from "../../../layouts/Main"; 7 7 import Sidebar from "../sidebar/Sidebar"; 8 8 import { useNotyf } from "../../../hooks/useNotyf"; 9 9 + import { useUpdatePreferencesMutation } from "../../../hooks/usePreferences"; 10 10 + import consola from "consola"; 11 11 + import { useQueryClient } from "@tanstack/react-query"; 12 12 + import { useEffect, useRef } from "react"; 9 13 10 14 const gitUrlSchema = z.object({ 11 15 repositoryUrl: z 12 16 .string() 13 17 .trim() 14 14 - .min(1, "Repository URL is required") 15 15 - .regex( 16 16 - /^(https?:\/\/.+\/.+\/.+|git@.+:.+\/.+)$/, 18 18 + .refine( 19 19 + (val) => 20 20 + val === "" || /^(https?:\/\/.+\/.+\/.+|git@.+:.+\/.+)$/.test(val), 17 21 "Must be a valid Git URL (e.g. https://tangled.org/user/repo or git@tangled.org:user/repo)", 18 22 ), 19 23 }); ··· 22 26 23 27 function Repository() { 24 28 const notyf = useNotyf(); 29 29 + const queryClient = useQueryClient(); 25 30 const routerState = useRouterState(); 26 31 const pathname = routerState.location.pathname; 32 32 + const { mutateAsync: updatePreferences } = useUpdatePreferencesMutation(); 27 33 const { data } = useSandboxQuery( 28 34 `at:/${pathname.replace("/repository", "").replace("sandbox", "io.pocketenv.sandbox")}`, 29 35 ); 30 36 const index = Math.floor(Math.random() * 7); 37 37 + const hasReset = useRef(false); 31 38 32 39 const { 33 40 register, 34 41 handleSubmit, 42 42 + reset, 35 43 formState: { errors }, 36 44 } = useForm<GitUrlFormValues>({ 37 45 resolver: zodResolver(gitUrlSchema), 38 46 }); 39 47 40 40 - const onSubmit = (values: GitUrlFormValues) => { 41 41 - console.log(values); 42 42 - notyf.open("primary", "Repository added successfully!"); 48 48 + const onSubmit = async (values: GitUrlFormValues) => { 49 49 + try { 50 50 + await updatePreferences({ 51 51 + sandboxId: data!.sandbox!.id, 52 52 + preferences: [ 53 53 + { 54 54 + repo: values.repositoryUrl === "" ? null : values.repositoryUrl, 55 55 + $type: "io.pocketenv.sandbox.defs#sandboxDetailsPref", 56 56 + }, 57 57 + ], 58 58 + }); 59 59 + notyf.open("primary", "Repository added successfully!"); 60 60 + queryClient.invalidateQueries({ 61 61 + queryKey: ["sandbox", data!.sandbox!.id], 62 62 + }); 63 63 + } catch (error) { 64 64 + consola.error(error); 65 65 + notyf.open("error", "Failed to add repository!"); 66 66 + } 43 67 }; 68 68 + 69 69 + useEffect(() => { 70 70 + if (data?.sandbox && !hasReset.current) { 71 71 + hasReset.current = true; 72 72 + reset({ 73 73 + repositoryUrl: data.sandbox.repo, 74 74 + }); 75 75 + } 76 76 + }, [data, reset]); 44 77 45 78 return ( 46 79 <Main

+9

apps/web/src/types/preferences.ts

reviewed

··· 1 1 + export type SandboxDetails = { 2 2 + name?: string; 3 3 + description?: string; 4 4 + topics?: string[]; 5 5 + repo?: string; 6 6 + $type: "io.pocketenv.sandbox.defs#sandboxDetailsPref"; 7 7 + }; 8 8 + 9 9 + export type Preference = SandboxDetails;

+1

apps/web/src/types/sandbox.ts

reviewed

··· 12 12 topics?: string[]; 13 13 logo?: string; 14 14 readme?: string; 15 15 + repo?: string; 15 16 vcpus?: number; 16 17 memory?: number; 17 18 installs: number;