the universal sandbox runtime for agents and humans.
pocketenv.io
sandbox
openclaw
agent
claude-code
vercel-sandbox
deno-sandbox
cloudflare-sandbox
atproto
sprites
daytona
Add service lexicon, API handlers, and schema
- Add io.pocketenv.service lexicon, generated types, and xrpc handlers
for add/delete/get/restart/update service endpoints
- Add service_id column to services and sandbox_ports with migration
- Add Cloudflare provider start/stopService stubs and wire handlers
- Update Dockerfile to provide node/npm in pkgx image and other
generated formatting changes
+5259
-2731
+5
README.md
+5
README.md
+24
apps/api/lexicons/service/addService.json
+24
apps/api/lexicons/service/addService.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.service.addService",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"input": {
8
+
"encoding": "application/json",
9
+
"schema": {
10
+
"type": "object",
11
+
"required": [
12
+
"service"
13
+
],
14
+
"properties": {
15
+
"service": {
16
+
"type": "ref",
17
+
"ref": "io.pocketenv.service.defs#service"
18
+
}
19
+
}
20
+
}
21
+
}
22
+
}
23
+
}
24
+
}
+68
apps/api/lexicons/service/defs.json
+68
apps/api/lexicons/service/defs.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.service.defs",
4
+
"defs": {
5
+
"serviceView": {
6
+
"type": "object",
7
+
"properties": {
8
+
"id": {
9
+
"type": "string",
10
+
"description": "Unique identifier of the service."
11
+
},
12
+
"name": {
13
+
"type": "string",
14
+
"description": "Name of the service."
15
+
},
16
+
"command": {
17
+
"type": "string",
18
+
"description": "Command to run the service."
19
+
},
20
+
"description": {
21
+
"type": "string",
22
+
"description": "Description of the service."
23
+
},
24
+
"ports": {
25
+
"type": "array",
26
+
"items": {
27
+
"type": "integer"
28
+
}
29
+
},
30
+
"createdAt": {
31
+
"type": "string",
32
+
"format": "datetime"
33
+
},
34
+
"updatedAt": {
35
+
"type": "string",
36
+
"format": "datetime"
37
+
}
38
+
}
39
+
},
40
+
"service": {
41
+
"type": "object",
42
+
"required": [
43
+
"name",
44
+
"command"
45
+
],
46
+
"properties": {
47
+
"name": {
48
+
"type": "string",
49
+
"description": "Name of the service."
50
+
},
51
+
"command": {
52
+
"type": "string",
53
+
"description": "Command to run the service."
54
+
},
55
+
"description": {
56
+
"type": "string",
57
+
"description": "Description of the service."
58
+
},
59
+
"ports": {
60
+
"type": "array",
61
+
"items": {
62
+
"type": "integer"
63
+
}
64
+
}
65
+
}
66
+
}
67
+
}
68
+
}
+21
apps/api/lexicons/service/deleteService.json
+21
apps/api/lexicons/service/deleteService.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.service.deleteService",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"serviceId"
11
+
],
12
+
"properties": {
13
+
"serviceId": {
14
+
"type": "string",
15
+
"description": "The ID of the service to delete."
16
+
}
17
+
}
18
+
}
19
+
}
20
+
}
21
+
}
+36
apps/api/lexicons/service/getServices.json
+36
apps/api/lexicons/service/getServices.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.service.getServices",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"sandboxId"
11
+
],
12
+
"properties": {
13
+
"sandboxId": {
14
+
"type": "string",
15
+
"description": "The ID of the sandbox for which to retrieve services."
16
+
}
17
+
}
18
+
},
19
+
"output": {
20
+
"encoding": "application/json",
21
+
"schema": {
22
+
"type": "object",
23
+
"properties": {
24
+
"services": {
25
+
"type": "array",
26
+
"items": {
27
+
"type": "ref",
28
+
"ref": "io.pocketenv.service.defs#serviceView"
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
34
+
}
35
+
}
36
+
}
+21
apps/api/lexicons/service/restartService.json
+21
apps/api/lexicons/service/restartService.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.service.restartService",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"serviceId"
11
+
],
12
+
"properties": {
13
+
"serviceId": {
14
+
"type": "string",
15
+
"description": "The ID of the service to restart."
16
+
}
17
+
}
18
+
}
19
+
}
20
+
}
21
+
}
+36
apps/api/lexicons/service/updateService.json
+36
apps/api/lexicons/service/updateService.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.service.updateService",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"serviceId"
11
+
],
12
+
"properties": {
13
+
"serviceId": {
14
+
"type": "string",
15
+
"description": "The ID of the service to delete."
16
+
}
17
+
}
18
+
},
19
+
"input": {
20
+
"encoding": "application/json",
21
+
"schema": {
22
+
"type": "object",
23
+
"required": [
24
+
"service"
25
+
],
26
+
"properties": {
27
+
"service": {
28
+
"type": "ref",
29
+
"ref": "io.pocketenv.service.defs#service"
30
+
}
31
+
}
32
+
}
33
+
}
34
+
}
35
+
}
36
+
}
+22
apps/api/pkl/defs/service/addService.pkl
+22
apps/api/pkl/defs/service/addService.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.service.addService"
5
+
defs = new Mapping<String, Procedure> {
6
+
["main"] {
7
+
type = "procedure"
8
+
input {
9
+
encoding = "application/json"
10
+
schema {
11
+
type = "object"
12
+
required = List("service")
13
+
properties {
14
+
["service"] = new Ref {
15
+
type = "ref"
16
+
ref = "io.pocketenv.service.defs#service"
17
+
}
18
+
}
19
+
}
20
+
}
21
+
}
22
+
}
+65
apps/api/pkl/defs/service/defs.pkl
+65
apps/api/pkl/defs/service/defs.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.service.defs"
5
+
defs = new Mapping<String, ObjectType> {
6
+
["serviceView"] = new ObjectType {
7
+
type = "object"
8
+
properties {
9
+
["id"] = new StringType {
10
+
type = "string"
11
+
description = "Unique identifier of the service."
12
+
}
13
+
["name"] = new StringType {
14
+
type = "string"
15
+
description = "Name of the service."
16
+
}
17
+
["command"] = new StringType {
18
+
type = "string"
19
+
description = "Command to run the service."
20
+
}
21
+
["description"] = new StringType {
22
+
type = "string"
23
+
description = "Description of the service."
24
+
}
25
+
["ports"] = new Array {
26
+
type = "array"
27
+
items = new IntegerType {
28
+
type = "integer"
29
+
}
30
+
}
31
+
["createdAt"] = new StringType {
32
+
type = "string"
33
+
format = "datetime"
34
+
}
35
+
["updatedAt"] = new StringType {
36
+
type = "string"
37
+
format = "datetime"
38
+
}
39
+
}
40
+
}
41
+
["service"] = new ObjectType {
42
+
type = "object"
43
+
required = List("name", "command")
44
+
properties {
45
+
["name"] = new StringType {
46
+
type = "string"
47
+
description = "Name of the service."
48
+
}
49
+
["command"] = new StringType {
50
+
type = "string"
51
+
description = "Command to run the service."
52
+
}
53
+
["description"] = new StringType {
54
+
type = "string"
55
+
description = "Description of the service."
56
+
}
57
+
["ports"] = new Array {
58
+
type = "array"
59
+
items = new IntegerType {
60
+
type = "integer"
61
+
}
62
+
}
63
+
}
64
+
}
65
+
}
+19
apps/api/pkl/defs/service/deleteService.pkl
+19
apps/api/pkl/defs/service/deleteService.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.service.deleteService"
5
+
defs = new Mapping<String, Procedure> {
6
+
["main"] {
7
+
type = "procedure"
8
+
parameters {
9
+
type = "params"
10
+
required = List("serviceId")
11
+
properties {
12
+
["serviceId"] = new StringType {
13
+
type = "string"
14
+
description = "The ID of the service to delete."
15
+
}
16
+
}
17
+
}
18
+
}
19
+
}
+33
apps/api/pkl/defs/service/getServices.pkl
+33
apps/api/pkl/defs/service/getServices.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.service.getServices"
5
+
defs = new Mapping<String, Query> {
6
+
["main"] {
7
+
type = "query"
8
+
parameters {
9
+
type = "params"
10
+
required = List("sandboxId")
11
+
properties {
12
+
["sandboxId"] = new StringType {
13
+
type = "string"
14
+
description = "The ID of the sandbox for which to retrieve services."
15
+
}
16
+
}
17
+
}
18
+
output {
19
+
encoding = "application/json"
20
+
schema = new ObjectType {
21
+
type = "object"
22
+
properties {
23
+
["services"] = new Array {
24
+
type = "array"
25
+
items = new Ref {
26
+
ref = "io.pocketenv.service.defs#serviceView"
27
+
}
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
+19
apps/api/pkl/defs/service/restartService.pkl
+19
apps/api/pkl/defs/service/restartService.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.service.restartService"
5
+
defs = new Mapping<String, Procedure> {
6
+
["main"] {
7
+
type = "procedure"
8
+
parameters {
9
+
type = "params"
10
+
required = List("serviceId")
11
+
properties {
12
+
["serviceId"] = new StringType {
13
+
type = "string"
14
+
description = "The ID of the service to restart."
15
+
}
16
+
}
17
+
}
18
+
}
19
+
}
+32
apps/api/pkl/defs/service/updateService.pkl
+32
apps/api/pkl/defs/service/updateService.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.service.updateService"
5
+
defs = new Mapping<String, Procedure> {
6
+
["main"] {
7
+
type = "procedure"
8
+
parameters {
9
+
type = "params"
10
+
required = List("serviceId")
11
+
properties {
12
+
["serviceId"] = new StringType {
13
+
type = "string"
14
+
description = "The ID of the service to delete."
15
+
}
16
+
}
17
+
}
18
+
input {
19
+
encoding = "application/json"
20
+
schema {
21
+
type = "object"
22
+
required = List("service")
23
+
properties {
24
+
["service"] = new Ref {
25
+
type = "ref"
26
+
ref = "io.pocketenv.service.defs#service"
27
+
}
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
+286
-216
apps/api/src/lexicon/index.ts
+286
-216
apps/api/src/lexicon/index.ts
···
7
7
type Options as XrpcOptions,
8
8
type AuthVerifier,
9
9
type StreamAuthVerifier,
10
-
} from '@atproto/xrpc-server'
11
-
import { schemas } from './lexicons'
12
-
import type * as IoPocketenvActorGetActorSandboxes from './types/io/pocketenv/actor/getActorSandboxes'
13
-
import type * as IoPocketenvActorGetProfile from './types/io/pocketenv/actor/getProfile'
14
-
import type * as IoPocketenvActorGetTerminalToken from './types/io/pocketenv/actor/getTerminalToken'
15
-
import type * as IoPocketenvFileAddFile from './types/io/pocketenv/file/addFile'
16
-
import type * as IoPocketenvFileDeleteFile from './types/io/pocketenv/file/deleteFile'
17
-
import type * as IoPocketenvFileGetFile from './types/io/pocketenv/file/getFile'
18
-
import type * as IoPocketenvFileGetFiles from './types/io/pocketenv/file/getFiles'
19
-
import type * as IoPocketenvFileUpdateFile from './types/io/pocketenv/file/updateFile'
20
-
import type * as IoPocketenvSandboxClaimSandbox from './types/io/pocketenv/sandbox/claimSandbox'
21
-
import type * as IoPocketenvSandboxCreateIntegration from './types/io/pocketenv/sandbox/createIntegration'
22
-
import type * as IoPocketenvSandboxCreateSandbox from './types/io/pocketenv/sandbox/createSandbox'
23
-
import type * as IoPocketenvSandboxDeleteSandbox from './types/io/pocketenv/sandbox/deleteSandbox'
24
-
import type * as IoPocketenvSandboxExec from './types/io/pocketenv/sandbox/exec'
25
-
import type * as IoPocketenvSandboxExposePort from './types/io/pocketenv/sandbox/exposePort'
26
-
import type * as IoPocketenvSandboxExposeVscode from './types/io/pocketenv/sandbox/exposeVscode'
27
-
import type * as IoPocketenvSandboxGetExposedPorts from './types/io/pocketenv/sandbox/getExposedPorts'
28
-
import type * as IoPocketenvSandboxGetIntegrations from './types/io/pocketenv/sandbox/getIntegrations'
29
-
import type * as IoPocketenvSandboxGetPreferences from './types/io/pocketenv/sandbox/getPreferences'
30
-
import type * as IoPocketenvSandboxGetSandbox from './types/io/pocketenv/sandbox/getSandbox'
31
-
import type * as IoPocketenvSandboxGetSandboxes from './types/io/pocketenv/sandbox/getSandboxes'
32
-
import type * as IoPocketenvSandboxGetSshKeys from './types/io/pocketenv/sandbox/getSshKeys'
33
-
import type * as IoPocketenvSandboxGetTailscaleAuthKey from './types/io/pocketenv/sandbox/getTailscaleAuthKey'
34
-
import type * as IoPocketenvSandboxGetTailscaleToken from './types/io/pocketenv/sandbox/getTailscaleToken'
35
-
import type * as IoPocketenvSandboxPutPreferences from './types/io/pocketenv/sandbox/putPreferences'
36
-
import type * as IoPocketenvSandboxPutSshKeys from './types/io/pocketenv/sandbox/putSshKeys'
37
-
import type * as IoPocketenvSandboxPutTailscaleAuthKey from './types/io/pocketenv/sandbox/putTailscaleAuthKey'
38
-
import type * as IoPocketenvSandboxPutTailscaleToken from './types/io/pocketenv/sandbox/putTailscaleToken'
39
-
import type * as IoPocketenvSandboxStartSandbox from './types/io/pocketenv/sandbox/startSandbox'
40
-
import type * as IoPocketenvSandboxStopSandbox from './types/io/pocketenv/sandbox/stopSandbox'
41
-
import type * as IoPocketenvSandboxUnexposePort from './types/io/pocketenv/sandbox/unexposePort'
42
-
import type * as IoPocketenvSandboxUpdateSandboxSettings from './types/io/pocketenv/sandbox/updateSandboxSettings'
43
-
import type * as IoPocketenvSecretAddSecret from './types/io/pocketenv/secret/addSecret'
44
-
import type * as IoPocketenvSecretDeleteSecret from './types/io/pocketenv/secret/deleteSecret'
45
-
import type * as IoPocketenvSecretGetSecret from './types/io/pocketenv/secret/getSecret'
46
-
import type * as IoPocketenvSecretGetSecrets from './types/io/pocketenv/secret/getSecrets'
47
-
import type * as IoPocketenvSecretUpdateSecret from './types/io/pocketenv/secret/updateSecret'
48
-
import type * as IoPocketenvVariableAddVariable from './types/io/pocketenv/variable/addVariable'
49
-
import type * as IoPocketenvVariableDeleteVariable from './types/io/pocketenv/variable/deleteVariable'
50
-
import type * as IoPocketenvVariableGetVariable from './types/io/pocketenv/variable/getVariable'
51
-
import type * as IoPocketenvVariableGetVariables from './types/io/pocketenv/variable/getVariables'
52
-
import type * as IoPocketenvVariableUpdateVariable from './types/io/pocketenv/variable/updateVariable'
53
-
import type * as IoPocketenvVolumeAddVolume from './types/io/pocketenv/volume/addVolume'
54
-
import type * as IoPocketenvVolumeDeleteVolume from './types/io/pocketenv/volume/deleteVolume'
55
-
import type * as IoPocketenvVolumeGetVolume from './types/io/pocketenv/volume/getVolume'
56
-
import type * as IoPocketenvVolumeGetVolumes from './types/io/pocketenv/volume/getVolumes'
57
-
import type * as IoPocketenvVolumeUpdateVolume from './types/io/pocketenv/volume/updateVolume'
10
+
} from "@atproto/xrpc-server";
11
+
import { schemas } from "./lexicons";
12
+
import type * as IoPocketenvActorGetActorSandboxes from "./types/io/pocketenv/actor/getActorSandboxes";
13
+
import type * as IoPocketenvActorGetProfile from "./types/io/pocketenv/actor/getProfile";
14
+
import type * as IoPocketenvActorGetTerminalToken from "./types/io/pocketenv/actor/getTerminalToken";
15
+
import type * as IoPocketenvFileAddFile from "./types/io/pocketenv/file/addFile";
16
+
import type * as IoPocketenvFileDeleteFile from "./types/io/pocketenv/file/deleteFile";
17
+
import type * as IoPocketenvFileGetFile from "./types/io/pocketenv/file/getFile";
18
+
import type * as IoPocketenvFileGetFiles from "./types/io/pocketenv/file/getFiles";
19
+
import type * as IoPocketenvFileUpdateFile from "./types/io/pocketenv/file/updateFile";
20
+
import type * as IoPocketenvSandboxClaimSandbox from "./types/io/pocketenv/sandbox/claimSandbox";
21
+
import type * as IoPocketenvSandboxCreateIntegration from "./types/io/pocketenv/sandbox/createIntegration";
22
+
import type * as IoPocketenvSandboxCreateSandbox from "./types/io/pocketenv/sandbox/createSandbox";
23
+
import type * as IoPocketenvSandboxDeleteSandbox from "./types/io/pocketenv/sandbox/deleteSandbox";
24
+
import type * as IoPocketenvSandboxExec from "./types/io/pocketenv/sandbox/exec";
25
+
import type * as IoPocketenvSandboxExposePort from "./types/io/pocketenv/sandbox/exposePort";
26
+
import type * as IoPocketenvSandboxExposeVscode from "./types/io/pocketenv/sandbox/exposeVscode";
27
+
import type * as IoPocketenvSandboxGetExposedPorts from "./types/io/pocketenv/sandbox/getExposedPorts";
28
+
import type * as IoPocketenvSandboxGetIntegrations from "./types/io/pocketenv/sandbox/getIntegrations";
29
+
import type * as IoPocketenvSandboxGetPreferences from "./types/io/pocketenv/sandbox/getPreferences";
30
+
import type * as IoPocketenvSandboxGetSandbox from "./types/io/pocketenv/sandbox/getSandbox";
31
+
import type * as IoPocketenvSandboxGetSandboxes from "./types/io/pocketenv/sandbox/getSandboxes";
32
+
import type * as IoPocketenvSandboxGetSshKeys from "./types/io/pocketenv/sandbox/getSshKeys";
33
+
import type * as IoPocketenvSandboxGetTailscaleAuthKey from "./types/io/pocketenv/sandbox/getTailscaleAuthKey";
34
+
import type * as IoPocketenvSandboxGetTailscaleToken from "./types/io/pocketenv/sandbox/getTailscaleToken";
35
+
import type * as IoPocketenvSandboxPutPreferences from "./types/io/pocketenv/sandbox/putPreferences";
36
+
import type * as IoPocketenvSandboxPutSshKeys from "./types/io/pocketenv/sandbox/putSshKeys";
37
+
import type * as IoPocketenvSandboxPutTailscaleAuthKey from "./types/io/pocketenv/sandbox/putTailscaleAuthKey";
38
+
import type * as IoPocketenvSandboxPutTailscaleToken from "./types/io/pocketenv/sandbox/putTailscaleToken";
39
+
import type * as IoPocketenvSandboxStartSandbox from "./types/io/pocketenv/sandbox/startSandbox";
40
+
import type * as IoPocketenvSandboxStopSandbox from "./types/io/pocketenv/sandbox/stopSandbox";
41
+
import type * as IoPocketenvSandboxUnexposePort from "./types/io/pocketenv/sandbox/unexposePort";
42
+
import type * as IoPocketenvSandboxUpdateSandboxSettings from "./types/io/pocketenv/sandbox/updateSandboxSettings";
43
+
import type * as IoPocketenvSecretAddSecret from "./types/io/pocketenv/secret/addSecret";
44
+
import type * as IoPocketenvSecretDeleteSecret from "./types/io/pocketenv/secret/deleteSecret";
45
+
import type * as IoPocketenvSecretGetSecret from "./types/io/pocketenv/secret/getSecret";
46
+
import type * as IoPocketenvSecretGetSecrets from "./types/io/pocketenv/secret/getSecrets";
47
+
import type * as IoPocketenvSecretUpdateSecret from "./types/io/pocketenv/secret/updateSecret";
48
+
import type * as IoPocketenvServiceAddService from "./types/io/pocketenv/service/addService";
49
+
import type * as IoPocketenvServiceDeleteService from "./types/io/pocketenv/service/deleteService";
50
+
import type * as IoPocketenvServiceGetServices from "./types/io/pocketenv/service/getServices";
51
+
import type * as IoPocketenvServiceRestartService from "./types/io/pocketenv/service/restartService";
52
+
import type * as IoPocketenvServiceUpdateService from "./types/io/pocketenv/service/updateService";
53
+
import type * as IoPocketenvVariableAddVariable from "./types/io/pocketenv/variable/addVariable";
54
+
import type * as IoPocketenvVariableDeleteVariable from "./types/io/pocketenv/variable/deleteVariable";
55
+
import type * as IoPocketenvVariableGetVariable from "./types/io/pocketenv/variable/getVariable";
56
+
import type * as IoPocketenvVariableGetVariables from "./types/io/pocketenv/variable/getVariables";
57
+
import type * as IoPocketenvVariableUpdateVariable from "./types/io/pocketenv/variable/updateVariable";
58
+
import type * as IoPocketenvVolumeAddVolume from "./types/io/pocketenv/volume/addVolume";
59
+
import type * as IoPocketenvVolumeDeleteVolume from "./types/io/pocketenv/volume/deleteVolume";
60
+
import type * as IoPocketenvVolumeGetVolume from "./types/io/pocketenv/volume/getVolume";
61
+
import type * as IoPocketenvVolumeGetVolumes from "./types/io/pocketenv/volume/getVolumes";
62
+
import type * as IoPocketenvVolumeUpdateVolume from "./types/io/pocketenv/volume/updateVolume";
58
63
59
64
export function createServer(options?: XrpcOptions): Server {
60
-
return new Server(options)
65
+
return new Server(options);
61
66
}
62
67
63
68
export class Server {
64
-
xrpc: XrpcServer
65
-
io: IoNS
66
-
app: AppNS
67
-
com: ComNS
69
+
xrpc: XrpcServer;
70
+
io: IoNS;
71
+
app: AppNS;
72
+
com: ComNS;
68
73
69
74
constructor(options?: XrpcOptions) {
70
-
this.xrpc = createXrpcServer(schemas, options)
71
-
this.io = new IoNS(this)
72
-
this.app = new AppNS(this)
73
-
this.com = new ComNS(this)
75
+
this.xrpc = createXrpcServer(schemas, options);
76
+
this.io = new IoNS(this);
77
+
this.app = new AppNS(this);
78
+
this.com = new ComNS(this);
74
79
}
75
80
}
76
81
77
82
export class IoNS {
78
-
_server: Server
79
-
pocketenv: IoPocketenvNS
83
+
_server: Server;
84
+
pocketenv: IoPocketenvNS;
80
85
81
86
constructor(server: Server) {
82
-
this._server = server
83
-
this.pocketenv = new IoPocketenvNS(server)
87
+
this._server = server;
88
+
this.pocketenv = new IoPocketenvNS(server);
84
89
}
85
90
}
86
91
87
92
export class IoPocketenvNS {
88
-
_server: Server
89
-
actor: IoPocketenvActorNS
90
-
file: IoPocketenvFileNS
91
-
sandbox: IoPocketenvSandboxNS
92
-
secret: IoPocketenvSecretNS
93
-
variable: IoPocketenvVariableNS
94
-
volume: IoPocketenvVolumeNS
93
+
_server: Server;
94
+
actor: IoPocketenvActorNS;
95
+
file: IoPocketenvFileNS;
96
+
sandbox: IoPocketenvSandboxNS;
97
+
secret: IoPocketenvSecretNS;
98
+
service: IoPocketenvServiceNS;
99
+
variable: IoPocketenvVariableNS;
100
+
volume: IoPocketenvVolumeNS;
95
101
96
102
constructor(server: Server) {
97
-
this._server = server
98
-
this.actor = new IoPocketenvActorNS(server)
99
-
this.file = new IoPocketenvFileNS(server)
100
-
this.sandbox = new IoPocketenvSandboxNS(server)
101
-
this.secret = new IoPocketenvSecretNS(server)
102
-
this.variable = new IoPocketenvVariableNS(server)
103
-
this.volume = new IoPocketenvVolumeNS(server)
103
+
this._server = server;
104
+
this.actor = new IoPocketenvActorNS(server);
105
+
this.file = new IoPocketenvFileNS(server);
106
+
this.sandbox = new IoPocketenvSandboxNS(server);
107
+
this.secret = new IoPocketenvSecretNS(server);
108
+
this.service = new IoPocketenvServiceNS(server);
109
+
this.variable = new IoPocketenvVariableNS(server);
110
+
this.volume = new IoPocketenvVolumeNS(server);
104
111
}
105
112
}
106
113
107
114
export class IoPocketenvActorNS {
108
-
_server: Server
115
+
_server: Server;
109
116
110
117
constructor(server: Server) {
111
-
this._server = server
118
+
this._server = server;
112
119
}
113
120
114
121
getActorSandboxes<AV extends AuthVerifier>(
···
118
125
IoPocketenvActorGetActorSandboxes.HandlerReqCtx<ExtractAuth<AV>>
119
126
>,
120
127
) {
121
-
const nsid = 'io.pocketenv.actor.getActorSandboxes' // @ts-ignore
122
-
return this._server.xrpc.method(nsid, cfg)
128
+
const nsid = "io.pocketenv.actor.getActorSandboxes"; // @ts-ignore
129
+
return this._server.xrpc.method(nsid, cfg);
123
130
}
124
131
125
132
getProfile<AV extends AuthVerifier>(
···
129
136
IoPocketenvActorGetProfile.HandlerReqCtx<ExtractAuth<AV>>
130
137
>,
131
138
) {
132
-
const nsid = 'io.pocketenv.actor.getProfile' // @ts-ignore
133
-
return this._server.xrpc.method(nsid, cfg)
139
+
const nsid = "io.pocketenv.actor.getProfile"; // @ts-ignore
140
+
return this._server.xrpc.method(nsid, cfg);
134
141
}
135
142
136
143
getTerminalToken<AV extends AuthVerifier>(
···
140
147
IoPocketenvActorGetTerminalToken.HandlerReqCtx<ExtractAuth<AV>>
141
148
>,
142
149
) {
143
-
const nsid = 'io.pocketenv.actor.getTerminalToken' // @ts-ignore
144
-
return this._server.xrpc.method(nsid, cfg)
150
+
const nsid = "io.pocketenv.actor.getTerminalToken"; // @ts-ignore
151
+
return this._server.xrpc.method(nsid, cfg);
145
152
}
146
153
}
147
154
148
155
export class IoPocketenvFileNS {
149
-
_server: Server
156
+
_server: Server;
150
157
151
158
constructor(server: Server) {
152
-
this._server = server
159
+
this._server = server;
153
160
}
154
161
155
162
addFile<AV extends AuthVerifier>(
···
159
166
IoPocketenvFileAddFile.HandlerReqCtx<ExtractAuth<AV>>
160
167
>,
161
168
) {
162
-
const nsid = 'io.pocketenv.file.addFile' // @ts-ignore
163
-
return this._server.xrpc.method(nsid, cfg)
169
+
const nsid = "io.pocketenv.file.addFile"; // @ts-ignore
170
+
return this._server.xrpc.method(nsid, cfg);
164
171
}
165
172
166
173
deleteFile<AV extends AuthVerifier>(
···
170
177
IoPocketenvFileDeleteFile.HandlerReqCtx<ExtractAuth<AV>>
171
178
>,
172
179
) {
173
-
const nsid = 'io.pocketenv.file.deleteFile' // @ts-ignore
174
-
return this._server.xrpc.method(nsid, cfg)
180
+
const nsid = "io.pocketenv.file.deleteFile"; // @ts-ignore
181
+
return this._server.xrpc.method(nsid, cfg);
175
182
}
176
183
177
184
getFile<AV extends AuthVerifier>(
···
181
188
IoPocketenvFileGetFile.HandlerReqCtx<ExtractAuth<AV>>
182
189
>,
183
190
) {
184
-
const nsid = 'io.pocketenv.file.getFile' // @ts-ignore
185
-
return this._server.xrpc.method(nsid, cfg)
191
+
const nsid = "io.pocketenv.file.getFile"; // @ts-ignore
192
+
return this._server.xrpc.method(nsid, cfg);
186
193
}
187
194
188
195
getFiles<AV extends AuthVerifier>(
···
192
199
IoPocketenvFileGetFiles.HandlerReqCtx<ExtractAuth<AV>>
193
200
>,
194
201
) {
195
-
const nsid = 'io.pocketenv.file.getFiles' // @ts-ignore
196
-
return this._server.xrpc.method(nsid, cfg)
202
+
const nsid = "io.pocketenv.file.getFiles"; // @ts-ignore
203
+
return this._server.xrpc.method(nsid, cfg);
197
204
}
198
205
199
206
updateFile<AV extends AuthVerifier>(
···
203
210
IoPocketenvFileUpdateFile.HandlerReqCtx<ExtractAuth<AV>>
204
211
>,
205
212
) {
206
-
const nsid = 'io.pocketenv.file.updateFile' // @ts-ignore
207
-
return this._server.xrpc.method(nsid, cfg)
213
+
const nsid = "io.pocketenv.file.updateFile"; // @ts-ignore
214
+
return this._server.xrpc.method(nsid, cfg);
208
215
}
209
216
}
210
217
211
218
export class IoPocketenvSandboxNS {
212
-
_server: Server
219
+
_server: Server;
213
220
214
221
constructor(server: Server) {
215
-
this._server = server
222
+
this._server = server;
216
223
}
217
224
218
225
claimSandbox<AV extends AuthVerifier>(
···
222
229
IoPocketenvSandboxClaimSandbox.HandlerReqCtx<ExtractAuth<AV>>
223
230
>,
224
231
) {
225
-
const nsid = 'io.pocketenv.sandbox.claimSandbox' // @ts-ignore
226
-
return this._server.xrpc.method(nsid, cfg)
232
+
const nsid = "io.pocketenv.sandbox.claimSandbox"; // @ts-ignore
233
+
return this._server.xrpc.method(nsid, cfg);
227
234
}
228
235
229
236
createIntegration<AV extends AuthVerifier>(
···
233
240
IoPocketenvSandboxCreateIntegration.HandlerReqCtx<ExtractAuth<AV>>
234
241
>,
235
242
) {
236
-
const nsid = 'io.pocketenv.sandbox.createIntegration' // @ts-ignore
237
-
return this._server.xrpc.method(nsid, cfg)
243
+
const nsid = "io.pocketenv.sandbox.createIntegration"; // @ts-ignore
244
+
return this._server.xrpc.method(nsid, cfg);
238
245
}
239
246
240
247
createSandbox<AV extends AuthVerifier>(
···
244
251
IoPocketenvSandboxCreateSandbox.HandlerReqCtx<ExtractAuth<AV>>
245
252
>,
246
253
) {
247
-
const nsid = 'io.pocketenv.sandbox.createSandbox' // @ts-ignore
248
-
return this._server.xrpc.method(nsid, cfg)
254
+
const nsid = "io.pocketenv.sandbox.createSandbox"; // @ts-ignore
255
+
return this._server.xrpc.method(nsid, cfg);
249
256
}
250
257
251
258
deleteSandbox<AV extends AuthVerifier>(
···
255
262
IoPocketenvSandboxDeleteSandbox.HandlerReqCtx<ExtractAuth<AV>>
256
263
>,
257
264
) {
258
-
const nsid = 'io.pocketenv.sandbox.deleteSandbox' // @ts-ignore
259
-
return this._server.xrpc.method(nsid, cfg)
265
+
const nsid = "io.pocketenv.sandbox.deleteSandbox"; // @ts-ignore
266
+
return this._server.xrpc.method(nsid, cfg);
260
267
}
261
268
262
269
exec<AV extends AuthVerifier>(
···
266
273
IoPocketenvSandboxExec.HandlerReqCtx<ExtractAuth<AV>>
267
274
>,
268
275
) {
269
-
const nsid = 'io.pocketenv.sandbox.exec' // @ts-ignore
270
-
return this._server.xrpc.method(nsid, cfg)
276
+
const nsid = "io.pocketenv.sandbox.exec"; // @ts-ignore
277
+
return this._server.xrpc.method(nsid, cfg);
271
278
}
272
279
273
280
exposePort<AV extends AuthVerifier>(
···
277
284
IoPocketenvSandboxExposePort.HandlerReqCtx<ExtractAuth<AV>>
278
285
>,
279
286
) {
280
-
const nsid = 'io.pocketenv.sandbox.exposePort' // @ts-ignore
281
-
return this._server.xrpc.method(nsid, cfg)
287
+
const nsid = "io.pocketenv.sandbox.exposePort"; // @ts-ignore
288
+
return this._server.xrpc.method(nsid, cfg);
282
289
}
283
290
284
291
exposeVscode<AV extends AuthVerifier>(
···
288
295
IoPocketenvSandboxExposeVscode.HandlerReqCtx<ExtractAuth<AV>>
289
296
>,
290
297
) {
291
-
const nsid = 'io.pocketenv.sandbox.exposeVscode' // @ts-ignore
292
-
return this._server.xrpc.method(nsid, cfg)
298
+
const nsid = "io.pocketenv.sandbox.exposeVscode"; // @ts-ignore
299
+
return this._server.xrpc.method(nsid, cfg);
293
300
}
294
301
295
302
getExposedPorts<AV extends AuthVerifier>(
···
299
306
IoPocketenvSandboxGetExposedPorts.HandlerReqCtx<ExtractAuth<AV>>
300
307
>,
301
308
) {
302
-
const nsid = 'io.pocketenv.sandbox.getExposedPorts' // @ts-ignore
303
-
return this._server.xrpc.method(nsid, cfg)
309
+
const nsid = "io.pocketenv.sandbox.getExposedPorts"; // @ts-ignore
310
+
return this._server.xrpc.method(nsid, cfg);
304
311
}
305
312
306
313
getIntegrations<AV extends AuthVerifier>(
···
310
317
IoPocketenvSandboxGetIntegrations.HandlerReqCtx<ExtractAuth<AV>>
311
318
>,
312
319
) {
313
-
const nsid = 'io.pocketenv.sandbox.getIntegrations' // @ts-ignore
314
-
return this._server.xrpc.method(nsid, cfg)
320
+
const nsid = "io.pocketenv.sandbox.getIntegrations"; // @ts-ignore
321
+
return this._server.xrpc.method(nsid, cfg);
315
322
}
316
323
317
324
getPreferences<AV extends AuthVerifier>(
···
321
328
IoPocketenvSandboxGetPreferences.HandlerReqCtx<ExtractAuth<AV>>
322
329
>,
323
330
) {
324
-
const nsid = 'io.pocketenv.sandbox.getPreferences' // @ts-ignore
325
-
return this._server.xrpc.method(nsid, cfg)
331
+
const nsid = "io.pocketenv.sandbox.getPreferences"; // @ts-ignore
332
+
return this._server.xrpc.method(nsid, cfg);
326
333
}
327
334
328
335
getSandbox<AV extends AuthVerifier>(
···
332
339
IoPocketenvSandboxGetSandbox.HandlerReqCtx<ExtractAuth<AV>>
333
340
>,
334
341
) {
335
-
const nsid = 'io.pocketenv.sandbox.getSandbox' // @ts-ignore
336
-
return this._server.xrpc.method(nsid, cfg)
342
+
const nsid = "io.pocketenv.sandbox.getSandbox"; // @ts-ignore
343
+
return this._server.xrpc.method(nsid, cfg);
337
344
}
338
345
339
346
getSandboxes<AV extends AuthVerifier>(
···
343
350
IoPocketenvSandboxGetSandboxes.HandlerReqCtx<ExtractAuth<AV>>
344
351
>,
345
352
) {
346
-
const nsid = 'io.pocketenv.sandbox.getSandboxes' // @ts-ignore
347
-
return this._server.xrpc.method(nsid, cfg)
353
+
const nsid = "io.pocketenv.sandbox.getSandboxes"; // @ts-ignore
354
+
return this._server.xrpc.method(nsid, cfg);
348
355
}
349
356
350
357
getSshKeys<AV extends AuthVerifier>(
···
354
361
IoPocketenvSandboxGetSshKeys.HandlerReqCtx<ExtractAuth<AV>>
355
362
>,
356
363
) {
357
-
const nsid = 'io.pocketenv.sandbox.getSshKeys' // @ts-ignore
358
-
return this._server.xrpc.method(nsid, cfg)
364
+
const nsid = "io.pocketenv.sandbox.getSshKeys"; // @ts-ignore
365
+
return this._server.xrpc.method(nsid, cfg);
359
366
}
360
367
361
368
getTailscaleAuthKey<AV extends AuthVerifier>(
···
365
372
IoPocketenvSandboxGetTailscaleAuthKey.HandlerReqCtx<ExtractAuth<AV>>
366
373
>,
367
374
) {
368
-
const nsid = 'io.pocketenv.sandbox.getTailscaleAuthKey' // @ts-ignore
369
-
return this._server.xrpc.method(nsid, cfg)
375
+
const nsid = "io.pocketenv.sandbox.getTailscaleAuthKey"; // @ts-ignore
376
+
return this._server.xrpc.method(nsid, cfg);
370
377
}
371
378
372
379
getTailscaleToken<AV extends AuthVerifier>(
···
376
383
IoPocketenvSandboxGetTailscaleToken.HandlerReqCtx<ExtractAuth<AV>>
377
384
>,
378
385
) {
379
-
const nsid = 'io.pocketenv.sandbox.getTailscaleToken' // @ts-ignore
380
-
return this._server.xrpc.method(nsid, cfg)
386
+
const nsid = "io.pocketenv.sandbox.getTailscaleToken"; // @ts-ignore
387
+
return this._server.xrpc.method(nsid, cfg);
381
388
}
382
389
383
390
putPreferences<AV extends AuthVerifier>(
···
387
394
IoPocketenvSandboxPutPreferences.HandlerReqCtx<ExtractAuth<AV>>
388
395
>,
389
396
) {
390
-
const nsid = 'io.pocketenv.sandbox.putPreferences' // @ts-ignore
391
-
return this._server.xrpc.method(nsid, cfg)
397
+
const nsid = "io.pocketenv.sandbox.putPreferences"; // @ts-ignore
398
+
return this._server.xrpc.method(nsid, cfg);
392
399
}
393
400
394
401
putSshKeys<AV extends AuthVerifier>(
···
398
405
IoPocketenvSandboxPutSshKeys.HandlerReqCtx<ExtractAuth<AV>>
399
406
>,
400
407
) {
401
-
const nsid = 'io.pocketenv.sandbox.putSshKeys' // @ts-ignore
402
-
return this._server.xrpc.method(nsid, cfg)
408
+
const nsid = "io.pocketenv.sandbox.putSshKeys"; // @ts-ignore
409
+
return this._server.xrpc.method(nsid, cfg);
403
410
}
404
411
405
412
putTailscaleAuthKey<AV extends AuthVerifier>(
···
409
416
IoPocketenvSandboxPutTailscaleAuthKey.HandlerReqCtx<ExtractAuth<AV>>
410
417
>,
411
418
) {
412
-
const nsid = 'io.pocketenv.sandbox.putTailscaleAuthKey' // @ts-ignore
413
-
return this._server.xrpc.method(nsid, cfg)
419
+
const nsid = "io.pocketenv.sandbox.putTailscaleAuthKey"; // @ts-ignore
420
+
return this._server.xrpc.method(nsid, cfg);
414
421
}
415
422
416
423
putTailscaleToken<AV extends AuthVerifier>(
···
420
427
IoPocketenvSandboxPutTailscaleToken.HandlerReqCtx<ExtractAuth<AV>>
421
428
>,
422
429
) {
423
-
const nsid = 'io.pocketenv.sandbox.putTailscaleToken' // @ts-ignore
424
-
return this._server.xrpc.method(nsid, cfg)
430
+
const nsid = "io.pocketenv.sandbox.putTailscaleToken"; // @ts-ignore
431
+
return this._server.xrpc.method(nsid, cfg);
425
432
}
426
433
427
434
startSandbox<AV extends AuthVerifier>(
···
431
438
IoPocketenvSandboxStartSandbox.HandlerReqCtx<ExtractAuth<AV>>
432
439
>,
433
440
) {
434
-
const nsid = 'io.pocketenv.sandbox.startSandbox' // @ts-ignore
435
-
return this._server.xrpc.method(nsid, cfg)
441
+
const nsid = "io.pocketenv.sandbox.startSandbox"; // @ts-ignore
442
+
return this._server.xrpc.method(nsid, cfg);
436
443
}
437
444
438
445
stopSandbox<AV extends AuthVerifier>(
···
442
449
IoPocketenvSandboxStopSandbox.HandlerReqCtx<ExtractAuth<AV>>
443
450
>,
444
451
) {
445
-
const nsid = 'io.pocketenv.sandbox.stopSandbox' // @ts-ignore
446
-
return this._server.xrpc.method(nsid, cfg)
452
+
const nsid = "io.pocketenv.sandbox.stopSandbox"; // @ts-ignore
453
+
return this._server.xrpc.method(nsid, cfg);
447
454
}
448
455
449
456
unexposePort<AV extends AuthVerifier>(
···
453
460
IoPocketenvSandboxUnexposePort.HandlerReqCtx<ExtractAuth<AV>>
454
461
>,
455
462
) {
456
-
const nsid = 'io.pocketenv.sandbox.unexposePort' // @ts-ignore
457
-
return this._server.xrpc.method(nsid, cfg)
463
+
const nsid = "io.pocketenv.sandbox.unexposePort"; // @ts-ignore
464
+
return this._server.xrpc.method(nsid, cfg);
458
465
}
459
466
460
467
updateSandboxSettings<AV extends AuthVerifier>(
···
464
471
IoPocketenvSandboxUpdateSandboxSettings.HandlerReqCtx<ExtractAuth<AV>>
465
472
>,
466
473
) {
467
-
const nsid = 'io.pocketenv.sandbox.updateSandboxSettings' // @ts-ignore
468
-
return this._server.xrpc.method(nsid, cfg)
474
+
const nsid = "io.pocketenv.sandbox.updateSandboxSettings"; // @ts-ignore
475
+
return this._server.xrpc.method(nsid, cfg);
469
476
}
470
477
}
471
478
472
479
export class IoPocketenvSecretNS {
473
-
_server: Server
480
+
_server: Server;
474
481
475
482
constructor(server: Server) {
476
-
this._server = server
483
+
this._server = server;
477
484
}
478
485
479
486
addSecret<AV extends AuthVerifier>(
···
483
490
IoPocketenvSecretAddSecret.HandlerReqCtx<ExtractAuth<AV>>
484
491
>,
485
492
) {
486
-
const nsid = 'io.pocketenv.secret.addSecret' // @ts-ignore
487
-
return this._server.xrpc.method(nsid, cfg)
493
+
const nsid = "io.pocketenv.secret.addSecret"; // @ts-ignore
494
+
return this._server.xrpc.method(nsid, cfg);
488
495
}
489
496
490
497
deleteSecret<AV extends AuthVerifier>(
···
494
501
IoPocketenvSecretDeleteSecret.HandlerReqCtx<ExtractAuth<AV>>
495
502
>,
496
503
) {
497
-
const nsid = 'io.pocketenv.secret.deleteSecret' // @ts-ignore
498
-
return this._server.xrpc.method(nsid, cfg)
504
+
const nsid = "io.pocketenv.secret.deleteSecret"; // @ts-ignore
505
+
return this._server.xrpc.method(nsid, cfg);
499
506
}
500
507
501
508
getSecret<AV extends AuthVerifier>(
···
505
512
IoPocketenvSecretGetSecret.HandlerReqCtx<ExtractAuth<AV>>
506
513
>,
507
514
) {
508
-
const nsid = 'io.pocketenv.secret.getSecret' // @ts-ignore
509
-
return this._server.xrpc.method(nsid, cfg)
515
+
const nsid = "io.pocketenv.secret.getSecret"; // @ts-ignore
516
+
return this._server.xrpc.method(nsid, cfg);
510
517
}
511
518
512
519
getSecrets<AV extends AuthVerifier>(
···
516
523
IoPocketenvSecretGetSecrets.HandlerReqCtx<ExtractAuth<AV>>
517
524
>,
518
525
) {
519
-
const nsid = 'io.pocketenv.secret.getSecrets' // @ts-ignore
520
-
return this._server.xrpc.method(nsid, cfg)
526
+
const nsid = "io.pocketenv.secret.getSecrets"; // @ts-ignore
527
+
return this._server.xrpc.method(nsid, cfg);
521
528
}
522
529
523
530
updateSecret<AV extends AuthVerifier>(
···
527
534
IoPocketenvSecretUpdateSecret.HandlerReqCtx<ExtractAuth<AV>>
528
535
>,
529
536
) {
530
-
const nsid = 'io.pocketenv.secret.updateSecret' // @ts-ignore
531
-
return this._server.xrpc.method(nsid, cfg)
537
+
const nsid = "io.pocketenv.secret.updateSecret"; // @ts-ignore
538
+
return this._server.xrpc.method(nsid, cfg);
539
+
}
540
+
}
541
+
542
+
export class IoPocketenvServiceNS {
543
+
_server: Server;
544
+
545
+
constructor(server: Server) {
546
+
this._server = server;
547
+
}
548
+
549
+
addService<AV extends AuthVerifier>(
550
+
cfg: ConfigOf<
551
+
AV,
552
+
IoPocketenvServiceAddService.Handler<ExtractAuth<AV>>,
553
+
IoPocketenvServiceAddService.HandlerReqCtx<ExtractAuth<AV>>
554
+
>,
555
+
) {
556
+
const nsid = "io.pocketenv.service.addService"; // @ts-ignore
557
+
return this._server.xrpc.method(nsid, cfg);
558
+
}
559
+
560
+
deleteService<AV extends AuthVerifier>(
561
+
cfg: ConfigOf<
562
+
AV,
563
+
IoPocketenvServiceDeleteService.Handler<ExtractAuth<AV>>,
564
+
IoPocketenvServiceDeleteService.HandlerReqCtx<ExtractAuth<AV>>
565
+
>,
566
+
) {
567
+
const nsid = "io.pocketenv.service.deleteService"; // @ts-ignore
568
+
return this._server.xrpc.method(nsid, cfg);
569
+
}
570
+
571
+
getServices<AV extends AuthVerifier>(
572
+
cfg: ConfigOf<
573
+
AV,
574
+
IoPocketenvServiceGetServices.Handler<ExtractAuth<AV>>,
575
+
IoPocketenvServiceGetServices.HandlerReqCtx<ExtractAuth<AV>>
576
+
>,
577
+
) {
578
+
const nsid = "io.pocketenv.service.getServices"; // @ts-ignore
579
+
return this._server.xrpc.method(nsid, cfg);
580
+
}
581
+
582
+
restartService<AV extends AuthVerifier>(
583
+
cfg: ConfigOf<
584
+
AV,
585
+
IoPocketenvServiceRestartService.Handler<ExtractAuth<AV>>,
586
+
IoPocketenvServiceRestartService.HandlerReqCtx<ExtractAuth<AV>>
587
+
>,
588
+
) {
589
+
const nsid = "io.pocketenv.service.restartService"; // @ts-ignore
590
+
return this._server.xrpc.method(nsid, cfg);
591
+
}
592
+
593
+
updateService<AV extends AuthVerifier>(
594
+
cfg: ConfigOf<
595
+
AV,
596
+
IoPocketenvServiceUpdateService.Handler<ExtractAuth<AV>>,
597
+
IoPocketenvServiceUpdateService.HandlerReqCtx<ExtractAuth<AV>>
598
+
>,
599
+
) {
600
+
const nsid = "io.pocketenv.service.updateService"; // @ts-ignore
601
+
return this._server.xrpc.method(nsid, cfg);
532
602
}
533
603
}
534
604
535
605
export class IoPocketenvVariableNS {
536
-
_server: Server
606
+
_server: Server;
537
607
538
608
constructor(server: Server) {
539
-
this._server = server
609
+
this._server = server;
540
610
}
541
611
542
612
addVariable<AV extends AuthVerifier>(
···
546
616
IoPocketenvVariableAddVariable.HandlerReqCtx<ExtractAuth<AV>>
547
617
>,
548
618
) {
549
-
const nsid = 'io.pocketenv.variable.addVariable' // @ts-ignore
550
-
return this._server.xrpc.method(nsid, cfg)
619
+
const nsid = "io.pocketenv.variable.addVariable"; // @ts-ignore
620
+
return this._server.xrpc.method(nsid, cfg);
551
621
}
552
622
553
623
deleteVariable<AV extends AuthVerifier>(
···
557
627
IoPocketenvVariableDeleteVariable.HandlerReqCtx<ExtractAuth<AV>>
558
628
>,
559
629
) {
560
-
const nsid = 'io.pocketenv.variable.deleteVariable' // @ts-ignore
561
-
return this._server.xrpc.method(nsid, cfg)
630
+
const nsid = "io.pocketenv.variable.deleteVariable"; // @ts-ignore
631
+
return this._server.xrpc.method(nsid, cfg);
562
632
}
563
633
564
634
getVariable<AV extends AuthVerifier>(
···
568
638
IoPocketenvVariableGetVariable.HandlerReqCtx<ExtractAuth<AV>>
569
639
>,
570
640
) {
571
-
const nsid = 'io.pocketenv.variable.getVariable' // @ts-ignore
572
-
return this._server.xrpc.method(nsid, cfg)
641
+
const nsid = "io.pocketenv.variable.getVariable"; // @ts-ignore
642
+
return this._server.xrpc.method(nsid, cfg);
573
643
}
574
644
575
645
getVariables<AV extends AuthVerifier>(
···
579
649
IoPocketenvVariableGetVariables.HandlerReqCtx<ExtractAuth<AV>>
580
650
>,
581
651
) {
582
-
const nsid = 'io.pocketenv.variable.getVariables' // @ts-ignore
583
-
return this._server.xrpc.method(nsid, cfg)
652
+
const nsid = "io.pocketenv.variable.getVariables"; // @ts-ignore
653
+
return this._server.xrpc.method(nsid, cfg);
584
654
}
585
655
586
656
updateVariable<AV extends AuthVerifier>(
···
590
660
IoPocketenvVariableUpdateVariable.HandlerReqCtx<ExtractAuth<AV>>
591
661
>,
592
662
) {
593
-
const nsid = 'io.pocketenv.variable.updateVariable' // @ts-ignore
594
-
return this._server.xrpc.method(nsid, cfg)
663
+
const nsid = "io.pocketenv.variable.updateVariable"; // @ts-ignore
664
+
return this._server.xrpc.method(nsid, cfg);
595
665
}
596
666
}
597
667
598
668
export class IoPocketenvVolumeNS {
599
-
_server: Server
669
+
_server: Server;
600
670
601
671
constructor(server: Server) {
602
-
this._server = server
672
+
this._server = server;
603
673
}
604
674
605
675
addVolume<AV extends AuthVerifier>(
···
609
679
IoPocketenvVolumeAddVolume.HandlerReqCtx<ExtractAuth<AV>>
610
680
>,
611
681
) {
612
-
const nsid = 'io.pocketenv.volume.addVolume' // @ts-ignore
613
-
return this._server.xrpc.method(nsid, cfg)
682
+
const nsid = "io.pocketenv.volume.addVolume"; // @ts-ignore
683
+
return this._server.xrpc.method(nsid, cfg);
614
684
}
615
685
616
686
deleteVolume<AV extends AuthVerifier>(
···
620
690
IoPocketenvVolumeDeleteVolume.HandlerReqCtx<ExtractAuth<AV>>
621
691
>,
622
692
) {
623
-
const nsid = 'io.pocketenv.volume.deleteVolume' // @ts-ignore
624
-
return this._server.xrpc.method(nsid, cfg)
693
+
const nsid = "io.pocketenv.volume.deleteVolume"; // @ts-ignore
694
+
return this._server.xrpc.method(nsid, cfg);
625
695
}
626
696
627
697
getVolume<AV extends AuthVerifier>(
···
631
701
IoPocketenvVolumeGetVolume.HandlerReqCtx<ExtractAuth<AV>>
632
702
>,
633
703
) {
634
-
const nsid = 'io.pocketenv.volume.getVolume' // @ts-ignore
635
-
return this._server.xrpc.method(nsid, cfg)
704
+
const nsid = "io.pocketenv.volume.getVolume"; // @ts-ignore
705
+
return this._server.xrpc.method(nsid, cfg);
636
706
}
637
707
638
708
getVolumes<AV extends AuthVerifier>(
···
642
712
IoPocketenvVolumeGetVolumes.HandlerReqCtx<ExtractAuth<AV>>
643
713
>,
644
714
) {
645
-
const nsid = 'io.pocketenv.volume.getVolumes' // @ts-ignore
646
-
return this._server.xrpc.method(nsid, cfg)
715
+
const nsid = "io.pocketenv.volume.getVolumes"; // @ts-ignore
716
+
return this._server.xrpc.method(nsid, cfg);
647
717
}
648
718
649
719
updateVolume<AV extends AuthVerifier>(
···
653
723
IoPocketenvVolumeUpdateVolume.HandlerReqCtx<ExtractAuth<AV>>
654
724
>,
655
725
) {
656
-
const nsid = 'io.pocketenv.volume.updateVolume' // @ts-ignore
657
-
return this._server.xrpc.method(nsid, cfg)
726
+
const nsid = "io.pocketenv.volume.updateVolume"; // @ts-ignore
727
+
return this._server.xrpc.method(nsid, cfg);
658
728
}
659
729
}
660
730
661
731
export class AppNS {
662
-
_server: Server
663
-
bsky: AppBskyNS
732
+
_server: Server;
733
+
bsky: AppBskyNS;
664
734
665
735
constructor(server: Server) {
666
-
this._server = server
667
-
this.bsky = new AppBskyNS(server)
736
+
this._server = server;
737
+
this.bsky = new AppBskyNS(server);
668
738
}
669
739
}
670
740
671
741
export class AppBskyNS {
672
-
_server: Server
673
-
actor: AppBskyActorNS
742
+
_server: Server;
743
+
actor: AppBskyActorNS;
674
744
675
745
constructor(server: Server) {
676
-
this._server = server
677
-
this.actor = new AppBskyActorNS(server)
746
+
this._server = server;
747
+
this.actor = new AppBskyActorNS(server);
678
748
}
679
749
}
680
750
681
751
export class AppBskyActorNS {
682
-
_server: Server
752
+
_server: Server;
683
753
684
754
constructor(server: Server) {
685
-
this._server = server
755
+
this._server = server;
686
756
}
687
757
}
688
758
689
759
export class ComNS {
690
-
_server: Server
691
-
atproto: ComAtprotoNS
760
+
_server: Server;
761
+
atproto: ComAtprotoNS;
692
762
693
763
constructor(server: Server) {
694
-
this._server = server
695
-
this.atproto = new ComAtprotoNS(server)
764
+
this._server = server;
765
+
this.atproto = new ComAtprotoNS(server);
696
766
}
697
767
}
698
768
699
769
export class ComAtprotoNS {
700
-
_server: Server
701
-
repo: ComAtprotoRepoNS
770
+
_server: Server;
771
+
repo: ComAtprotoRepoNS;
702
772
703
773
constructor(server: Server) {
704
-
this._server = server
705
-
this.repo = new ComAtprotoRepoNS(server)
774
+
this._server = server;
775
+
this.repo = new ComAtprotoRepoNS(server);
706
776
}
707
777
}
708
778
709
779
export class ComAtprotoRepoNS {
710
-
_server: Server
780
+
_server: Server;
711
781
712
782
constructor(server: Server) {
713
-
this._server = server
783
+
this._server = server;
714
784
}
715
785
}
716
786
717
787
type SharedRateLimitOpts<T> = {
718
-
name: string
719
-
calcKey?: (ctx: T) => string | null
720
-
calcPoints?: (ctx: T) => number
721
-
}
788
+
name: string;
789
+
calcKey?: (ctx: T) => string | null;
790
+
calcPoints?: (ctx: T) => number;
791
+
};
722
792
type RouteRateLimitOpts<T> = {
723
-
durationMs: number
724
-
points: number
725
-
calcKey?: (ctx: T) => string | null
726
-
calcPoints?: (ctx: T) => number
727
-
}
728
-
type HandlerOpts = { blobLimit?: number }
729
-
type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>
793
+
durationMs: number;
794
+
points: number;
795
+
calcKey?: (ctx: T) => string | null;
796
+
calcPoints?: (ctx: T) => number;
797
+
};
798
+
type HandlerOpts = { blobLimit?: number };
799
+
type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>;
730
800
type ConfigOf<Auth, Handler, ReqCtx> =
731
801
| Handler
732
802
| {
733
-
auth?: Auth
734
-
opts?: HandlerOpts
735
-
rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]
736
-
handler: Handler
737
-
}
803
+
auth?: Auth;
804
+
opts?: HandlerOpts;
805
+
rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[];
806
+
handler: Handler;
807
+
};
738
808
type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract<
739
809
Awaited<ReturnType<AV>>,
740
810
{ credentials: unknown }
741
-
>
811
+
>;
+1192
-994
apps/api/src/lexicon/lexicons.ts
+1192
-994
apps/api/src/lexicon/lexicons.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type LexiconDoc, Lexicons } from '@atproto/lexicon'
4
+
import { type LexiconDoc, Lexicons } from "@atproto/lexicon";
5
5
6
6
export const schemaDict = {
7
7
IoPocketenvActorDefs: {
8
8
lexicon: 1,
9
-
id: 'io.pocketenv.actor.defs',
9
+
id: "io.pocketenv.actor.defs",
10
10
defs: {
11
11
profileViewDetailed: {
12
-
type: 'object',
12
+
type: "object",
13
13
properties: {
14
14
id: {
15
-
type: 'string',
16
-
description: 'The unique identifier of the actor.',
15
+
type: "string",
16
+
description: "The unique identifier of the actor.",
17
17
},
18
18
did: {
19
-
type: 'string',
20
-
description: 'The DID of the actor.',
19
+
type: "string",
20
+
description: "The DID of the actor.",
21
21
},
22
22
handle: {
23
-
type: 'string',
24
-
description: 'The handle of the actor.',
23
+
type: "string",
24
+
description: "The handle of the actor.",
25
25
},
26
26
displayName: {
27
-
type: 'string',
28
-
description: 'The display name of the actor.',
27
+
type: "string",
28
+
description: "The display name of the actor.",
29
29
},
30
30
avatar: {
31
-
type: 'string',
31
+
type: "string",
32
32
description: "The URL of the actor's avatar image.",
33
-
format: 'uri',
33
+
format: "uri",
34
34
},
35
35
createdAt: {
36
-
type: 'string',
37
-
description: 'The date and time when the actor was created.',
38
-
format: 'datetime',
36
+
type: "string",
37
+
description: "The date and time when the actor was created.",
38
+
format: "datetime",
39
39
},
40
40
updatedAt: {
41
-
type: 'string',
42
-
description: 'The date and time when the actor was last updated.',
43
-
format: 'datetime',
41
+
type: "string",
42
+
description: "The date and time when the actor was last updated.",
43
+
format: "datetime",
44
44
},
45
45
},
46
46
},
···
48
48
},
49
49
IoPocketenvActorGetActorSandboxes: {
50
50
lexicon: 1,
51
-
id: 'io.pocketenv.actor.getActorSandboxes',
51
+
id: "io.pocketenv.actor.getActorSandboxes",
52
52
defs: {
53
53
main: {
54
-
type: 'query',
55
-
description: 'Get all sandboxes for a given actor',
54
+
type: "query",
55
+
description: "Get all sandboxes for a given actor",
56
56
parameters: {
57
-
type: 'params',
58
-
required: ['did'],
57
+
type: "params",
58
+
required: ["did"],
59
59
properties: {
60
60
did: {
61
-
type: 'string',
62
-
description: 'The DID or handle of the actor',
63
-
format: 'at-identifier',
61
+
type: "string",
62
+
description: "The DID or handle of the actor",
63
+
format: "at-identifier",
64
64
},
65
65
limit: {
66
-
type: 'integer',
67
-
description: 'The maximum number of sandboxes to return.',
66
+
type: "integer",
67
+
description: "The maximum number of sandboxes to return.",
68
68
minimum: 1,
69
69
},
70
70
offset: {
71
-
type: 'integer',
71
+
type: "integer",
72
72
description:
73
-
'The number of sandboxes to skip before starting to collect the result set.',
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
-
encoding: 'application/json',
79
+
encoding: "application/json",
80
80
schema: {
81
-
type: 'object',
81
+
type: "object",
82
82
properties: {
83
83
sandboxes: {
84
-
type: 'array',
84
+
type: "array",
85
85
items: {
86
-
type: 'ref',
87
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewDetailed',
86
+
type: "ref",
87
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewDetailed",
88
88
},
89
89
},
90
90
total: {
91
-
type: 'integer',
92
-
description: 'The total number of sandboxes available.',
91
+
type: "integer",
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
-
id: 'io.pocketenv.actor.getProfile',
103
+
id: "io.pocketenv.actor.getProfile",
104
104
defs: {
105
105
main: {
106
-
type: 'query',
107
-
description: 'Get the profile of an actor',
106
+
type: "query",
107
+
description: "Get the profile of an actor",
108
108
parameters: {
109
-
type: 'params',
109
+
type: "params",
110
110
properties: {
111
111
did: {
112
-
type: 'string',
113
-
description: 'The DID or handle of the actor',
114
-
format: 'at-identifier',
112
+
type: "string",
113
+
description: "The DID or handle of the actor",
114
+
format: "at-identifier",
115
115
},
116
116
},
117
117
},
118
118
output: {
119
-
encoding: 'application/json',
119
+
encoding: "application/json",
120
120
schema: {
121
-
type: 'ref',
122
-
ref: 'lex:io.pocketenv.actor.defs#profileViewDetailed',
121
+
type: "ref",
122
+
ref: "lex:io.pocketenv.actor.defs#profileViewDetailed",
123
123
},
124
124
},
125
125
},
···
127
127
},
128
128
IoPocketenvActorGetTerminalToken: {
129
129
lexicon: 1,
130
-
id: 'io.pocketenv.actor.getTerminalToken',
130
+
id: "io.pocketenv.actor.getTerminalToken",
131
131
defs: {
132
132
main: {
133
-
type: 'query',
134
-
description: 'Get a terminal token',
133
+
type: "query",
134
+
description: "Get a terminal token",
135
135
parameters: {
136
-
type: 'params',
136
+
type: "params",
137
137
properties: {},
138
138
},
139
139
output: {
140
-
encoding: 'application/json',
140
+
encoding: "application/json",
141
141
schema: {
142
-
type: 'object',
142
+
type: "object",
143
143
properties: {
144
144
token: {
145
-
type: 'string',
145
+
type: "string",
146
146
description:
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
+
"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
-
id: 'app.bsky.actor.profile',
157
+
id: "app.bsky.actor.profile",
158
158
defs: {
159
159
main: {
160
-
type: 'record',
161
-
description: 'A declaration of a Bluesky account profile.',
162
-
key: 'literal:self',
160
+
type: "record",
161
+
description: "A declaration of a Bluesky account profile.",
162
+
key: "literal:self",
163
163
record: {
164
-
type: 'object',
164
+
type: "object",
165
165
properties: {
166
166
displayName: {
167
-
type: 'string',
167
+
type: "string",
168
168
maxGraphemes: 64,
169
169
maxLength: 640,
170
170
},
171
171
description: {
172
-
type: 'string',
173
-
description: 'Free-form profile description text.',
172
+
type: "string",
173
+
description: "Free-form profile description text.",
174
174
maxGraphemes: 256,
175
175
maxLength: 2560,
176
176
},
177
177
avatar: {
178
-
type: 'blob',
178
+
type: "blob",
179
179
description:
180
180
"Small image to be displayed next to posts from account. AKA, 'profile picture'",
181
-
accept: ['image/png', 'image/jpeg'],
181
+
accept: ["image/png", "image/jpeg"],
182
182
maxSize: 1000000,
183
183
},
184
184
banner: {
185
-
type: 'blob',
185
+
type: "blob",
186
186
description:
187
-
'Larger horizontal image to display behind profile view.',
188
-
accept: ['image/png', 'image/jpeg'],
187
+
"Larger horizontal image to display behind profile view.",
188
+
accept: ["image/png", "image/jpeg"],
189
189
maxSize: 10000000,
190
190
},
191
191
labels: {
192
-
type: 'union',
192
+
type: "union",
193
193
description:
194
-
'Self-label values, specific to the Bluesky application, on the overall account.',
195
-
refs: ['lex:com.atproto.label.defs#selfLabels'],
194
+
"Self-label values, specific to the Bluesky application, on the overall account.",
195
+
refs: ["lex:com.atproto.label.defs#selfLabels"],
196
196
},
197
197
joinedViaStarterPack: {
198
-
type: 'ref',
199
-
ref: 'lex:com.atproto.repo.strongRef',
198
+
type: "ref",
199
+
ref: "lex:com.atproto.repo.strongRef",
200
200
},
201
201
createdAt: {
202
-
type: 'string',
203
-
format: 'datetime',
202
+
type: "string",
203
+
format: "datetime",
204
204
},
205
205
},
206
206
},
···
209
209
},
210
210
IoPocketenvFileAddFile: {
211
211
lexicon: 1,
212
-
id: 'io.pocketenv.file.addFile',
212
+
id: "io.pocketenv.file.addFile",
213
213
defs: {
214
214
main: {
215
-
type: 'procedure',
215
+
type: "procedure",
216
216
input: {
217
-
encoding: 'application/json',
217
+
encoding: "application/json",
218
218
schema: {
219
-
type: 'object',
220
-
required: ['file'],
219
+
type: "object",
220
+
required: ["file"],
221
221
properties: {
222
222
file: {
223
-
type: 'ref',
224
-
ref: 'lex:io.pocketenv.file.defs#file',
223
+
type: "ref",
224
+
ref: "lex:io.pocketenv.file.defs#file",
225
225
},
226
226
},
227
227
},
···
231
231
},
232
232
IoPocketenvFileDefs: {
233
233
lexicon: 1,
234
-
id: 'io.pocketenv.file.defs',
234
+
id: "io.pocketenv.file.defs",
235
235
defs: {
236
236
file: {
237
-
type: 'object',
238
-
required: ['path', 'content'],
237
+
type: "object",
238
+
required: ["path", "content"],
239
239
properties: {
240
240
sandboxId: {
241
-
type: 'string',
241
+
type: "string",
242
242
description:
243
-
'The ID of the sandbox to which the file belongs. This is used to associate the file with a specific sandbox environment.',
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
-
type: 'string',
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
-
type: 'string',
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
-
type: 'object',
258
+
type: "object",
259
259
properties: {
260
260
id: {
261
-
type: 'string',
262
-
description: 'Unique identifier of the file.',
261
+
type: "string",
262
+
description: "Unique identifier of the file.",
263
263
},
264
264
path: {
265
-
type: 'string',
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
-
type: 'string',
271
-
description: 'The timestamp when the file was created.',
272
-
format: 'datetime',
270
+
type: "string",
271
+
description: "The timestamp when the file was created.",
272
+
format: "datetime",
273
273
},
274
274
updatedAt: {
275
-
type: 'string',
276
-
description: 'The timestamp when the file was last updated.',
277
-
format: 'datetime',
275
+
type: "string",
276
+
description: "The timestamp when the file was last updated.",
277
+
format: "datetime",
278
278
},
279
279
},
280
280
},
281
281
files: {
282
-
type: 'array',
282
+
type: "array",
283
283
items: {
284
-
type: 'ref',
285
-
description: 'A file to add to the sandbox',
286
-
ref: 'lex:io.pocketenv.file.defs#file',
284
+
type: "ref",
285
+
description: "A file to add to the sandbox",
286
+
ref: "lex:io.pocketenv.file.defs#file",
287
287
},
288
288
},
289
289
},
290
290
},
291
291
IoPocketenvFileDeleteFile: {
292
292
lexicon: 1,
293
-
id: 'io.pocketenv.file.deleteFile',
293
+
id: "io.pocketenv.file.deleteFile",
294
294
defs: {
295
295
main: {
296
-
type: 'procedure',
296
+
type: "procedure",
297
297
parameters: {
298
-
type: 'params',
299
-
required: ['id'],
298
+
type: "params",
299
+
required: ["id"],
300
300
properties: {
301
301
id: {
302
-
type: 'string',
303
-
description: 'The ID of the file to delete',
302
+
type: "string",
303
+
description: "The ID of the file to delete",
304
304
},
305
305
},
306
306
},
···
309
309
},
310
310
IoPocketenvFileGetFile: {
311
311
lexicon: 1,
312
-
id: 'io.pocketenv.file.getFile',
312
+
id: "io.pocketenv.file.getFile",
313
313
defs: {
314
314
main: {
315
-
type: 'query',
315
+
type: "query",
316
316
parameters: {
317
-
type: 'params',
318
-
required: ['id'],
317
+
type: "params",
318
+
required: ["id"],
319
319
properties: {
320
320
id: {
321
-
type: 'string',
322
-
description: 'The ID of the file to retrieve.',
321
+
type: "string",
322
+
description: "The ID of the file to retrieve.",
323
323
},
324
324
},
325
325
},
326
326
output: {
327
-
encoding: 'application/json',
327
+
encoding: "application/json",
328
328
schema: {
329
-
type: 'object',
329
+
type: "object",
330
330
properties: {
331
331
file: {
332
-
type: 'ref',
333
-
ref: 'lex:io.pocketenv.file.defs#fileView',
332
+
type: "ref",
333
+
ref: "lex:io.pocketenv.file.defs#fileView",
334
334
},
335
335
},
336
336
},
···
340
340
},
341
341
IoPocketenvFileGetFiles: {
342
342
lexicon: 1,
343
-
id: 'io.pocketenv.file.getFiles',
343
+
id: "io.pocketenv.file.getFiles",
344
344
defs: {
345
345
main: {
346
-
type: 'query',
346
+
type: "query",
347
347
parameters: {
348
-
type: 'params',
348
+
type: "params",
349
349
properties: {
350
350
sandboxId: {
351
-
type: 'string',
352
-
description: 'The ID of the sandbox for which to retrieve files.',
351
+
type: "string",
352
+
description: "The ID of the sandbox for which to retrieve files.",
353
353
},
354
354
limit: {
355
-
type: 'integer',
356
-
description: 'The maximum number of files to return.',
355
+
type: "integer",
356
+
description: "The maximum number of files to return.",
357
357
minimum: 1,
358
358
},
359
359
offset: {
360
-
type: 'integer',
360
+
type: "integer",
361
361
description:
362
-
'The number of files to skip before starting to collect the result set.',
362
+
"The number of files to skip before starting to collect the result set.",
363
363
minimum: 0,
364
364
},
365
365
},
366
366
},
367
367
output: {
368
-
encoding: 'application/json',
368
+
encoding: "application/json",
369
369
schema: {
370
-
type: 'object',
370
+
type: "object",
371
371
properties: {
372
372
files: {
373
-
type: 'array',
373
+
type: "array",
374
374
items: {
375
-
type: 'ref',
376
-
ref: 'lex:io.pocketenv.file.defs#fileView',
375
+
type: "ref",
376
+
ref: "lex:io.pocketenv.file.defs#fileView",
377
377
},
378
378
},
379
379
total: {
380
-
type: 'integer',
381
-
description: 'The total number of files available.',
380
+
type: "integer",
381
+
description: "The total number of files available.",
382
382
minimum: 0,
383
383
},
384
384
},
···
389
389
},
390
390
IoPocketenvFileUpdateFile: {
391
391
lexicon: 1,
392
-
id: 'io.pocketenv.file.updateFile',
392
+
id: "io.pocketenv.file.updateFile",
393
393
defs: {
394
394
main: {
395
-
type: 'procedure',
395
+
type: "procedure",
396
396
input: {
397
-
encoding: 'application/json',
397
+
encoding: "application/json",
398
398
schema: {
399
-
type: 'object',
400
-
required: ['id', 'file'],
399
+
type: "object",
400
+
required: ["id", "file"],
401
401
properties: {
402
402
id: {
403
-
type: 'string',
404
-
description: 'The ID of the file to delete',
403
+
type: "string",
404
+
description: "The ID of the file to delete",
405
405
},
406
406
file: {
407
-
type: 'ref',
408
-
ref: 'lex:io.pocketenv.file.defs#file',
407
+
type: "ref",
408
+
ref: "lex:io.pocketenv.file.defs#file",
409
409
},
410
410
},
411
411
},
···
415
415
},
416
416
IoPocketenvPortDefs: {
417
417
lexicon: 1,
418
-
id: 'io.pocketenv.port.defs',
418
+
id: "io.pocketenv.port.defs",
419
419
defs: {
420
420
portView: {
421
-
type: 'object',
422
-
description: 'A view of a port exposed by a sandbox.',
421
+
type: "object",
422
+
description: "A view of a port exposed by a sandbox.",
423
423
properties: {
424
424
port: {
425
-
type: 'integer',
426
-
description: 'The port number.',
425
+
type: "integer",
426
+
description: "The port number.",
427
427
maximum: 65535,
428
428
minimum: 1025,
429
429
},
430
430
description: {
431
-
type: 'string',
432
-
description: 'A description of the port.',
431
+
type: "string",
432
+
description: "A description of the port.",
433
433
},
434
434
previewUrl: {
435
-
type: 'string',
436
-
description: 'A URL for previewing the service running on the port',
435
+
type: "string",
436
+
description: "A URL for previewing the service running on the port",
437
437
},
438
438
},
439
439
},
···
441
441
},
442
442
IoPocketenvSandboxClaimSandbox: {
443
443
lexicon: 1,
444
-
id: 'io.pocketenv.sandbox.claimSandbox',
444
+
id: "io.pocketenv.sandbox.claimSandbox",
445
445
defs: {
446
446
main: {
447
-
type: 'procedure',
448
-
description: 'Claim a sandbox by id',
447
+
type: "procedure",
448
+
description: "Claim a sandbox by id",
449
449
parameters: {
450
-
type: 'params',
451
-
required: ['id'],
450
+
type: "params",
451
+
required: ["id"],
452
452
properties: {
453
453
id: {
454
-
type: 'string',
455
-
description: 'The sandbox ID.',
454
+
type: "string",
455
+
description: "The sandbox ID.",
456
456
},
457
457
},
458
458
},
459
459
output: {
460
-
encoding: 'application/json',
460
+
encoding: "application/json",
461
461
schema: {
462
-
type: 'ref',
463
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
462
+
type: "ref",
463
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
464
464
},
465
465
},
466
466
},
···
468
468
},
469
469
IoPocketenvSandboxCreateIntegration: {
470
470
lexicon: 1,
471
-
id: 'io.pocketenv.sandbox.createIntegration',
471
+
id: "io.pocketenv.sandbox.createIntegration",
472
472
defs: {
473
473
main: {
474
-
type: 'procedure',
475
-
description: 'Create a new integration for the sandbox.',
474
+
type: "procedure",
475
+
description: "Create a new integration for the sandbox.",
476
476
input: {
477
-
encoding: 'application/json',
477
+
encoding: "application/json",
478
478
schema: {
479
-
type: 'object',
480
-
required: ['id', 'name'],
479
+
type: "object",
480
+
required: ["id", "name"],
481
481
properties: {
482
482
id: {
483
-
type: 'string',
484
-
description: 'The sandbox ID.',
483
+
type: "string",
484
+
description: "The sandbox ID.",
485
485
},
486
486
name: {
487
-
type: 'string',
488
-
description: 'The name of the integration.',
487
+
type: "string",
488
+
description: "The name of the integration.",
489
489
},
490
490
},
491
491
},
492
492
},
493
493
output: {
494
-
encoding: 'application/json',
494
+
encoding: "application/json",
495
495
schema: {
496
-
type: 'ref',
497
-
ref: 'lex:io.pocketenv.sandbox.defs#integrationView',
496
+
type: "ref",
497
+
ref: "lex:io.pocketenv.sandbox.defs#integrationView",
498
498
},
499
499
},
500
500
},
···
502
502
},
503
503
IoPocketenvSandboxCreateSandbox: {
504
504
lexicon: 1,
505
-
id: 'io.pocketenv.sandbox.createSandbox',
505
+
id: "io.pocketenv.sandbox.createSandbox",
506
506
defs: {
507
507
main: {
508
-
type: 'procedure',
509
-
description: 'Create a sandbox',
508
+
type: "procedure",
509
+
description: "Create a sandbox",
510
510
input: {
511
-
encoding: 'application/json',
511
+
encoding: "application/json",
512
512
schema: {
513
-
type: 'object',
514
-
required: ['base'],
513
+
type: "object",
514
+
required: ["base"],
515
515
properties: {
516
516
base: {
517
-
type: 'string',
517
+
type: "string",
518
518
description:
519
-
'The base sandbox URI to clone from, e.g. a template or an existing sandbox.',
519
+
"The base sandbox URI to clone from, e.g. a template or an existing sandbox.",
520
520
},
521
521
name: {
522
-
type: 'string',
523
-
description: 'The name of the sandbox',
522
+
type: "string",
523
+
description: "The name of the sandbox",
524
524
minLength: 1,
525
525
},
526
526
description: {
527
-
type: 'string',
528
-
description: 'A description for the sandbox',
527
+
type: "string",
528
+
description: "A description for the sandbox",
529
529
},
530
530
provider: {
531
-
type: 'string',
531
+
type: "string",
532
532
description:
533
533
"The provider to create the sandbox on, e.g. 'daytona', 'vercel', 'cloudflare', etc.",
534
-
enum: ['daytona', 'vercel', 'cloudflare', 'deno', 'sprites'],
534
+
enum: ["daytona", "vercel", "cloudflare", "deno", "sprites"],
535
535
},
536
536
topics: {
537
-
type: 'array',
537
+
type: "array",
538
538
description:
539
-
'A list of topics/tags to associate with the sandbox',
539
+
"A list of topics/tags to associate with the sandbox",
540
540
items: {
541
-
type: 'string',
541
+
type: "string",
542
542
maxLength: 50,
543
543
},
544
544
},
545
545
repo: {
546
-
type: 'string',
546
+
type: "string",
547
547
description:
548
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
548
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
549
549
},
550
550
vcpus: {
551
-
type: 'integer',
551
+
type: "integer",
552
552
description:
553
-
'The number of virtual CPUs to allocate for the sandbox',
553
+
"The number of virtual CPUs to allocate for the sandbox",
554
554
minimum: 1,
555
555
},
556
556
memory: {
557
-
type: 'integer',
557
+
type: "integer",
558
558
description:
559
-
'The amount of memory (in GB) to allocate for the sandbox',
559
+
"The amount of memory (in GB) to allocate for the sandbox",
560
560
minimum: 1,
561
561
},
562
562
disk: {
563
-
type: 'integer',
563
+
type: "integer",
564
564
description:
565
-
'The amount of disk space (in GB) to allocate for the sandbox',
565
+
"The amount of disk space (in GB) to allocate for the sandbox",
566
566
minimum: 3,
567
567
},
568
568
readme: {
569
-
type: 'string',
570
-
description: 'A URI to a README for the sandbox.',
571
-
format: 'uri',
569
+
type: "string",
570
+
description: "A URI to a README for the sandbox.",
571
+
format: "uri",
572
572
},
573
573
secrets: {
574
-
type: 'ref',
575
-
description: 'A list of secrets to add to the sandbox',
576
-
ref: 'lex:io.pocketenv.sandbox.defs#secrets',
574
+
type: "ref",
575
+
description: "A list of secrets to add to the sandbox",
576
+
ref: "lex:io.pocketenv.sandbox.defs#secrets",
577
577
},
578
578
envs: {
579
-
type: 'ref',
579
+
type: "ref",
580
580
description:
581
-
'A list of environment variables to add to the sandbox',
582
-
ref: 'lex:io.pocketenv.sandbox.defs#envs',
581
+
"A list of environment variables to add to the sandbox",
582
+
ref: "lex:io.pocketenv.sandbox.defs#envs",
583
583
},
584
584
keepAlive: {
585
-
type: 'boolean',
585
+
type: "boolean",
586
586
description:
587
-
'Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs.',
587
+
"Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs.",
588
588
},
589
589
},
590
590
},
591
591
},
592
592
output: {
593
-
encoding: 'application/json',
593
+
encoding: "application/json",
594
594
schema: {
595
-
type: 'ref',
596
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
595
+
type: "ref",
596
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
597
597
},
598
598
},
599
599
},
···
601
601
},
602
602
IoPocketenvSandboxDefs: {
603
603
lexicon: 1,
604
-
id: 'io.pocketenv.sandbox.defs',
604
+
id: "io.pocketenv.sandbox.defs",
605
605
defs: {
606
606
sandboxViewBasic: {
607
-
type: 'object',
607
+
type: "object",
608
608
properties: {
609
609
name: {
610
-
type: 'string',
611
-
description: 'Name of the sandbox',
610
+
type: "string",
611
+
description: "Name of the sandbox",
612
612
maxLength: 50,
613
613
},
614
614
provider: {
615
-
type: 'string',
615
+
type: "string",
616
616
description:
617
617
"The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.",
618
618
maxLength: 50,
619
619
},
620
620
description: {
621
-
type: 'string',
621
+
type: "string",
622
622
maxGraphemes: 300,
623
623
maxLength: 3000,
624
624
},
625
625
website: {
626
-
type: 'string',
627
-
description: 'Any URI related to the sandbox',
628
-
format: 'uri',
626
+
type: "string",
627
+
description: "Any URI related to the sandbox",
628
+
format: "uri",
629
629
},
630
630
logo: {
631
-
type: 'string',
632
-
description: 'URI to an image logo for the sandbox',
633
-
format: 'uri',
631
+
type: "string",
632
+
description: "URI to an image logo for the sandbox",
633
+
format: "uri",
634
634
},
635
635
topics: {
636
-
type: 'array',
636
+
type: "array",
637
637
items: {
638
-
type: 'string',
638
+
type: "string",
639
639
minLength: 1,
640
640
maxLength: 50,
641
641
},
642
642
maxLength: 50,
643
643
},
644
644
repo: {
645
-
type: 'string',
645
+
type: "string",
646
646
description:
647
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
647
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
648
648
},
649
649
readme: {
650
-
type: 'string',
651
-
description: 'A URI to a README for the sandbox.',
652
-
format: 'uri',
650
+
type: "string",
651
+
description: "A URI to a README for the sandbox.",
652
+
format: "uri",
653
653
},
654
654
vcpus: {
655
-
type: 'integer',
656
-
description: 'Number of virtual CPUs allocated to the sandbox',
655
+
type: "integer",
656
+
description: "Number of virtual CPUs allocated to the sandbox",
657
657
},
658
658
memory: {
659
-
type: 'integer',
660
-
description: 'Amount of memory in GB allocated to the sandbox',
659
+
type: "integer",
660
+
description: "Amount of memory in GB allocated to the sandbox",
661
661
},
662
662
disk: {
663
-
type: 'integer',
664
-
description: 'Amount of disk space in GB allocated to the sandbox',
663
+
type: "integer",
664
+
description: "Amount of disk space in GB allocated to the sandbox",
665
665
},
666
666
ports: {
667
-
type: 'array',
667
+
type: "array",
668
668
items: {
669
-
type: 'integer',
669
+
type: "integer",
670
670
maximum: 65535,
671
671
minimum: 1025,
672
672
},
673
673
maxLength: 100,
674
674
},
675
675
installs: {
676
-
type: 'integer',
676
+
type: "integer",
677
677
description:
678
-
'Number of times the sandbox has been installed by users.',
678
+
"Number of times the sandbox has been installed by users.",
679
679
},
680
680
createdAt: {
681
-
type: 'string',
682
-
format: 'datetime',
681
+
type: "string",
682
+
format: "datetime",
683
683
},
684
684
},
685
685
},
686
686
sandboxViewDetailed: {
687
-
type: 'object',
687
+
type: "object",
688
688
properties: {
689
689
name: {
690
-
type: 'string',
691
-
description: 'Name of the sandbox',
690
+
type: "string",
691
+
description: "Name of the sandbox",
692
692
maxLength: 50,
693
693
},
694
694
provider: {
695
-
type: 'string',
695
+
type: "string",
696
696
description:
697
697
"The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.",
698
698
maxLength: 50,
699
699
},
700
700
description: {
701
-
type: 'string',
701
+
type: "string",
702
702
maxGraphemes: 300,
703
703
maxLength: 3000,
704
704
},
705
705
status: {
706
-
type: 'string',
706
+
type: "string",
707
707
description:
708
708
"The current status of the sandbox, e.g. 'RUNNING', 'STOPPED', etc.",
709
709
},
710
710
startedAt: {
711
-
type: 'string',
712
-
format: 'datetime',
711
+
type: "string",
712
+
format: "datetime",
713
713
},
714
714
timeout: {
715
-
type: 'integer',
716
-
description: 'The sandbox timeout in seconds',
715
+
type: "integer",
716
+
description: "The sandbox timeout in seconds",
717
717
},
718
718
baseSandbox: {
719
-
type: 'string',
719
+
type: "string",
720
720
description:
721
-
'The base sandbox that this sandbox was created from, if any. This can be used to determine the template or configuration used to create the sandbox.',
721
+
"The base sandbox that this sandbox was created from, if any. This can be used to determine the template or configuration used to create the sandbox.",
722
722
},
723
723
website: {
724
-
type: 'string',
725
-
description: 'Any URI related to the sandbox',
726
-
format: 'uri',
724
+
type: "string",
725
+
description: "Any URI related to the sandbox",
726
+
format: "uri",
727
727
},
728
728
logo: {
729
-
type: 'string',
730
-
description: 'URI to an image logo for the sandbox',
731
-
format: 'uri',
729
+
type: "string",
730
+
description: "URI to an image logo for the sandbox",
731
+
format: "uri",
732
732
},
733
733
topics: {
734
-
type: 'array',
734
+
type: "array",
735
735
items: {
736
-
type: 'string',
736
+
type: "string",
737
737
minLength: 1,
738
738
maxLength: 50,
739
739
},
740
740
maxLength: 50,
741
741
},
742
742
repo: {
743
-
type: 'string',
743
+
type: "string",
744
744
description:
745
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
745
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
746
746
},
747
747
readme: {
748
-
type: 'string',
749
-
description: 'A URI to a README for the sandbox.',
750
-
format: 'uri',
748
+
type: "string",
749
+
description: "A URI to a README for the sandbox.",
750
+
format: "uri",
751
751
},
752
752
vcpus: {
753
-
type: 'integer',
754
-
description: 'Number of virtual CPUs allocated to the sandbox',
753
+
type: "integer",
754
+
description: "Number of virtual CPUs allocated to the sandbox",
755
755
},
756
756
memory: {
757
-
type: 'integer',
758
-
description: 'Amount of memory in GB allocated to the sandbox',
757
+
type: "integer",
758
+
description: "Amount of memory in GB allocated to the sandbox",
759
759
},
760
760
disk: {
761
-
type: 'integer',
762
-
description: 'Amount of disk space in GB allocated to the sandbox',
761
+
type: "integer",
762
+
description: "Amount of disk space in GB allocated to the sandbox",
763
763
},
764
764
ports: {
765
-
type: 'array',
765
+
type: "array",
766
766
items: {
767
-
type: 'integer',
767
+
type: "integer",
768
768
maximum: 65535,
769
769
minimum: 1025,
770
770
},
771
771
maxLength: 100,
772
772
},
773
773
installs: {
774
-
type: 'integer',
774
+
type: "integer",
775
775
description:
776
-
'Number of times the sandbox has been installed by users.',
776
+
"Number of times the sandbox has been installed by users.",
777
777
},
778
778
createdAt: {
779
-
type: 'string',
780
-
format: 'datetime',
779
+
type: "string",
780
+
format: "datetime",
781
781
},
782
782
owner: {
783
-
type: 'ref',
784
-
description: 'The user who created the sandbox',
785
-
ref: 'lex:io.pocketenv.user.defs#userViewBasic',
783
+
type: "ref",
784
+
description: "The user who created the sandbox",
785
+
ref: "lex:io.pocketenv.user.defs#userViewBasic",
786
786
},
787
787
},
788
788
},
789
789
sandboxDetailsPref: {
790
-
type: 'object',
791
-
nullable: ['repo', 'description', 'topics'],
790
+
type: "object",
791
+
nullable: ["repo", "description", "topics"],
792
792
properties: {
793
793
name: {
794
-
type: 'string',
795
-
description: 'The name of the sandbox',
794
+
type: "string",
795
+
description: "The name of the sandbox",
796
796
minLength: 1,
797
797
},
798
798
description: {
799
-
type: 'string',
800
-
description: 'A description for the sandbox',
799
+
type: "string",
800
+
description: "A description for the sandbox",
801
801
},
802
802
topics: {
803
-
type: 'array',
804
-
description: 'A list of topics/tags to associate with the sandbox',
803
+
type: "array",
804
+
description: "A list of topics/tags to associate with the sandbox",
805
805
items: {
806
-
type: 'string',
806
+
type: "string",
807
807
maxLength: 50,
808
808
},
809
809
},
810
810
repo: {
811
-
type: 'string',
811
+
type: "string",
812
812
description:
813
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
813
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
814
814
},
815
815
vcpus: {
816
-
type: 'integer',
816
+
type: "integer",
817
817
description:
818
-
'The number of virtual CPUs to allocate for the sandbox',
818
+
"The number of virtual CPUs to allocate for the sandbox",
819
819
minimum: 1,
820
820
},
821
821
memory: {
822
-
type: 'integer',
822
+
type: "integer",
823
823
description:
824
-
'The amount of memory (in GB) to allocate for the sandbox',
824
+
"The amount of memory (in GB) to allocate for the sandbox",
825
825
minimum: 1,
826
826
},
827
827
disk: {
828
-
type: 'integer',
828
+
type: "integer",
829
829
description:
830
-
'The amount of disk space (in GB) to allocate for the sandbox',
830
+
"The amount of disk space (in GB) to allocate for the sandbox",
831
831
minimum: 3,
832
832
},
833
833
readme: {
834
-
type: 'string',
835
-
description: 'A URI to a README for the sandbox.',
836
-
format: 'uri',
834
+
type: "string",
835
+
description: "A URI to a README for the sandbox.",
836
+
format: "uri",
837
837
},
838
838
},
839
839
},
840
840
secretPref: {
841
-
type: 'object',
841
+
type: "object",
842
842
properties: {
843
843
name: {
844
-
type: 'string',
845
-
description: 'The name of the secret',
844
+
type: "string",
845
+
description: "The name of the secret",
846
846
minLength: 1,
847
847
},
848
848
value: {
849
-
type: 'string',
849
+
type: "string",
850
850
description:
851
-
'The value of the secret. This will be encrypted at rest and redacted in any API responses.',
851
+
"The value of the secret. This will be encrypted at rest and redacted in any API responses.",
852
852
},
853
853
},
854
854
},
855
855
variablePref: {
856
-
type: 'object',
857
-
description: 'A variable to add to the sandbox',
856
+
type: "object",
857
+
description: "A variable to add to the sandbox",
858
858
properties: {
859
859
name: {
860
-
type: 'string',
861
-
description: 'The name of the variable',
860
+
type: "string",
861
+
description: "The name of the variable",
862
862
minLength: 1,
863
863
},
864
864
value: {
865
-
type: 'string',
865
+
type: "string",
866
866
description:
867
-
'The value of the variable. This will be visible in API responses and should not contain sensitive information.',
867
+
"The value of the variable. This will be visible in API responses and should not contain sensitive information.",
868
868
},
869
869
},
870
870
},
871
871
filePref: {
872
-
type: 'object',
873
-
description: 'A file to add to the sandbox',
872
+
type: "object",
873
+
description: "A file to add to the sandbox",
874
874
properties: {
875
875
name: {
876
-
type: 'string',
877
-
description: 'The name of the file',
876
+
type: "string",
877
+
description: "The name of the file",
878
878
minLength: 1,
879
879
},
880
880
content: {
881
-
type: 'string',
882
-
description: 'The content of the file.',
881
+
type: "string",
882
+
description: "The content of the file.",
883
883
},
884
884
encrypt: {
885
-
type: 'boolean',
885
+
type: "boolean",
886
886
description:
887
-
'Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information.',
887
+
"Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information.",
888
888
},
889
889
path: {
890
-
type: 'string',
890
+
type: "string",
891
891
description:
892
892
"The path within the sandbox where the file will be created, e.g. '/app/config.json'. If not provided, the file will be created in the root directory of the sandbox.",
893
893
},
894
894
},
895
895
},
896
896
volumePref: {
897
-
type: 'object',
898
-
description: 'A volume to add to the sandbox',
897
+
type: "object",
898
+
description: "A volume to add to the sandbox",
899
899
properties: {
900
900
name: {
901
-
type: 'string',
902
-
description: 'The name of the volume',
901
+
type: "string",
902
+
description: "The name of the volume",
903
903
minLength: 1,
904
904
},
905
905
path: {
906
-
type: 'string',
906
+
type: "string",
907
907
description:
908
908
"The mount path within the sandbox where the volume will be attached, e.g. '/data', '/logs', etc.",
909
909
},
910
910
readOnly: {
911
-
type: 'boolean',
912
-
description: 'Whether the volume should be mounted as read-only',
911
+
type: "boolean",
912
+
description: "Whether the volume should be mounted as read-only",
913
913
},
914
914
},
915
915
},
916
916
preferences: {
917
-
type: 'array',
917
+
type: "array",
918
918
items: {
919
-
type: 'union',
919
+
type: "union",
920
920
refs: [
921
-
'lex:io.pocketenv.sandbox.defs#sandboxDetailsPref',
922
-
'lex:io.pocketenv.sandbox.defs#secretPref',
923
-
'lex:io.pocketenv.sandbox.defs#variablePref',
924
-
'lex:io.pocketenv.sandbox.defs#filePref',
925
-
'lex:io.pocketenv.sandbox.defs#volumePref',
921
+
"lex:io.pocketenv.sandbox.defs#sandboxDetailsPref",
922
+
"lex:io.pocketenv.sandbox.defs#secretPref",
923
+
"lex:io.pocketenv.sandbox.defs#variablePref",
924
+
"lex:io.pocketenv.sandbox.defs#filePref",
925
+
"lex:io.pocketenv.sandbox.defs#volumePref",
926
926
],
927
927
},
928
928
},
929
929
sshKeysView: {
930
-
type: 'object',
930
+
type: "object",
931
931
properties: {
932
932
id: {
933
-
type: 'string',
934
-
description: 'Unique identifier of the SSH key.',
933
+
type: "string",
934
+
description: "Unique identifier of the SSH key.",
935
935
},
936
936
publicKey: {
937
-
type: 'string',
938
-
description: 'The public SSH key.',
937
+
type: "string",
938
+
description: "The public SSH key.",
939
939
},
940
940
privateKey: {
941
-
type: 'string',
942
-
description: 'The private SSH key (redacted in API responses)',
941
+
type: "string",
942
+
description: "The private SSH key (redacted in API responses)",
943
943
},
944
944
createdAt: {
945
-
type: 'string',
946
-
description: 'The timestamp when the SSH key was created.',
947
-
format: 'datetime',
945
+
type: "string",
946
+
description: "The timestamp when the SSH key was created.",
947
+
format: "datetime",
948
948
},
949
949
updatedAt: {
950
-
type: 'string',
951
-
description: 'The timestamp when the SSH key was last updated.',
952
-
format: 'datetime',
950
+
type: "string",
951
+
description: "The timestamp when the SSH key was last updated.",
952
+
format: "datetime",
953
953
},
954
954
},
955
955
},
956
956
tailscaleAuthKeyView: {
957
-
type: 'object',
957
+
type: "object",
958
958
properties: {
959
959
id: {
960
-
type: 'string',
961
-
description: 'Unique identifier of the Tailscale Auth Key.',
960
+
type: "string",
961
+
description: "Unique identifier of the Tailscale Auth Key.",
962
962
},
963
963
authKey: {
964
-
type: 'string',
965
-
description: 'The Tailscale auth key (redacted in API responses)',
964
+
type: "string",
965
+
description: "The Tailscale auth key (redacted in API responses)",
966
966
},
967
967
redacted: {
968
-
type: 'string',
969
-
description: 'The redacted Auth Key.',
968
+
type: "string",
969
+
description: "The redacted Auth Key.",
970
970
},
971
971
createdAt: {
972
-
type: 'string',
972
+
type: "string",
973
973
description:
974
-
'The timestamp when the Tailscale Auth Key was created.',
975
-
format: 'datetime',
974
+
"The timestamp when the Tailscale Auth Key was created.",
975
+
format: "datetime",
976
976
},
977
977
updatedAt: {
978
-
type: 'string',
978
+
type: "string",
979
979
description:
980
-
'The timestamp when the Tailscale Auth Key was last updated.',
981
-
format: 'datetime',
980
+
"The timestamp when the Tailscale Auth Key was last updated.",
981
+
format: "datetime",
982
982
},
983
983
},
984
984
},
985
985
integrationView: {
986
-
type: 'object',
986
+
type: "object",
987
987
properties: {
988
988
id: {
989
-
type: 'string',
990
-
description: 'Unique identifier of the integration.',
989
+
type: "string",
990
+
description: "Unique identifier of the integration.",
991
991
},
992
992
name: {
993
-
type: 'string',
993
+
type: "string",
994
994
description:
995
995
"The name of the integration, e.g. 'GitHub', 'Slack', 'Trello', etc.",
996
996
},
997
997
webhookUrl: {
998
-
type: 'string',
999
-
description: 'The webhook URL of the integration.',
1000
-
format: 'uri',
998
+
type: "string",
999
+
description: "The webhook URL of the integration.",
1000
+
format: "uri",
1001
1001
},
1002
1002
createdAt: {
1003
-
type: 'string',
1004
-
description: 'The timestamp when the integration was created.',
1005
-
format: 'datetime',
1003
+
type: "string",
1004
+
description: "The timestamp when the integration was created.",
1005
+
format: "datetime",
1006
1006
},
1007
1007
updatedAt: {
1008
-
type: 'string',
1009
-
description: 'The timestamp when the integration was last updated.',
1010
-
format: 'datetime',
1008
+
type: "string",
1009
+
description: "The timestamp when the integration was last updated.",
1010
+
format: "datetime",
1011
1011
},
1012
1012
},
1013
1013
},
1014
1014
integrationsView: {
1015
-
type: 'array',
1015
+
type: "array",
1016
1016
items: {
1017
-
type: 'ref',
1018
-
description: 'An integration connected to the sandbox',
1019
-
ref: 'lex:io.pocketenv.sandbox.defs#integrationView',
1017
+
type: "ref",
1018
+
description: "An integration connected to the sandbox",
1019
+
ref: "lex:io.pocketenv.sandbox.defs#integrationView",
1020
1020
},
1021
1021
},
1022
1022
},
1023
1023
},
1024
1024
IoPocketenvSandboxDeleteSandbox: {
1025
1025
lexicon: 1,
1026
-
id: 'io.pocketenv.sandbox.deleteSandbox',
1026
+
id: "io.pocketenv.sandbox.deleteSandbox",
1027
1027
defs: {
1028
1028
main: {
1029
-
type: 'procedure',
1030
-
description: 'Delete a sandbox by uri',
1029
+
type: "procedure",
1030
+
description: "Delete a sandbox by uri",
1031
1031
parameters: {
1032
-
type: 'params',
1033
-
required: ['id'],
1032
+
type: "params",
1033
+
required: ["id"],
1034
1034
properties: {
1035
1035
id: {
1036
-
type: 'string',
1037
-
description: 'The sandbox ID.',
1036
+
type: "string",
1037
+
description: "The sandbox ID.",
1038
1038
},
1039
1039
},
1040
1040
},
1041
1041
output: {
1042
-
encoding: 'application/json',
1042
+
encoding: "application/json",
1043
1043
schema: {
1044
-
type: 'ref',
1045
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1044
+
type: "ref",
1045
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1046
1046
},
1047
1047
},
1048
1048
},
···
1050
1050
},
1051
1051
IoPocketenvSandboxExec: {
1052
1052
lexicon: 1,
1053
-
id: 'io.pocketenv.sandbox.exec',
1053
+
id: "io.pocketenv.sandbox.exec",
1054
1054
defs: {
1055
1055
main: {
1056
-
type: 'procedure',
1057
-
description: 'Execute a command in a sandbox.',
1056
+
type: "procedure",
1057
+
description: "Execute a command in a sandbox.",
1058
1058
parameters: {
1059
-
type: 'params',
1060
-
required: ['id'],
1059
+
type: "params",
1060
+
required: ["id"],
1061
1061
properties: {
1062
1062
id: {
1063
-
type: 'string',
1064
-
description: 'The sandbox ID.',
1063
+
type: "string",
1064
+
description: "The sandbox ID.",
1065
1065
},
1066
1066
},
1067
1067
},
1068
1068
input: {
1069
-
encoding: 'application/json',
1069
+
encoding: "application/json",
1070
1070
schema: {
1071
-
type: 'object',
1072
-
required: ['command'],
1071
+
type: "object",
1072
+
required: ["command"],
1073
1073
properties: {
1074
1074
command: {
1075
-
type: 'string',
1076
-
description: 'The command to execute in the sandbox.',
1075
+
type: "string",
1076
+
description: "The command to execute in the sandbox.",
1077
1077
},
1078
1078
},
1079
1079
},
1080
1080
},
1081
1081
output: {
1082
-
encoding: 'application/json',
1082
+
encoding: "application/json",
1083
1083
schema: {
1084
-
type: 'object',
1084
+
type: "object",
1085
1085
properties: {
1086
1086
stdout: {
1087
-
type: 'string',
1088
-
description: 'The output of the executed command.',
1087
+
type: "string",
1088
+
description: "The output of the executed command.",
1089
1089
},
1090
1090
stderr: {
1091
-
type: 'string',
1091
+
type: "string",
1092
1092
description:
1093
-
'The error output of the executed command, if any.',
1093
+
"The error output of the executed command, if any.",
1094
1094
},
1095
1095
exitCode: {
1096
-
type: 'integer',
1097
-
description: 'The exit code of the executed command.',
1096
+
type: "integer",
1097
+
description: "The exit code of the executed command.",
1098
1098
},
1099
1099
},
1100
1100
},
···
1104
1104
},
1105
1105
IoPocketenvSandboxExposePort: {
1106
1106
lexicon: 1,
1107
-
id: 'io.pocketenv.sandbox.exposePort',
1107
+
id: "io.pocketenv.sandbox.exposePort",
1108
1108
defs: {
1109
1109
main: {
1110
-
type: 'procedure',
1111
-
description: 'Expose a port for a sandbox.',
1110
+
type: "procedure",
1111
+
description: "Expose a port for a sandbox.",
1112
1112
parameters: {
1113
-
type: 'params',
1114
-
required: ['id'],
1113
+
type: "params",
1114
+
required: ["id"],
1115
1115
properties: {
1116
1116
id: {
1117
-
type: 'string',
1118
-
description: 'The sandbox ID.',
1117
+
type: "string",
1118
+
description: "The sandbox ID.",
1119
1119
},
1120
1120
},
1121
1121
},
1122
1122
input: {
1123
-
encoding: 'application/json',
1123
+
encoding: "application/json",
1124
1124
schema: {
1125
-
type: 'object',
1126
-
required: ['port'],
1125
+
type: "object",
1126
+
required: ["port"],
1127
1127
properties: {
1128
1128
port: {
1129
-
type: 'integer',
1130
-
description: 'The port number to expose.',
1129
+
type: "integer",
1130
+
description: "The port number to expose.",
1131
1131
maximum: 65535,
1132
1132
minimum: 1025,
1133
1133
},
1134
1134
description: {
1135
-
type: 'string',
1136
-
description: 'A description of the port.',
1135
+
type: "string",
1136
+
description: "A description of the port.",
1137
1137
},
1138
1138
},
1139
1139
},
1140
1140
},
1141
1141
output: {
1142
-
encoding: 'application/json',
1142
+
encoding: "application/json",
1143
1143
schema: {
1144
-
type: 'object',
1145
-
nullable: ['previewUrl'],
1144
+
type: "object",
1145
+
nullable: ["previewUrl"],
1146
1146
properties: {
1147
1147
previewUrl: {
1148
-
type: 'string',
1149
-
description: 'The preview URL for the exposed port.',
1148
+
type: "string",
1149
+
description: "The preview URL for the exposed port.",
1150
1150
},
1151
1151
},
1152
1152
},
···
1156
1156
},
1157
1157
IoPocketenvSandboxExposeVscode: {
1158
1158
lexicon: 1,
1159
-
id: 'io.pocketenv.sandbox.exposeVscode',
1159
+
id: "io.pocketenv.sandbox.exposeVscode",
1160
1160
defs: {
1161
1161
main: {
1162
-
type: 'procedure',
1162
+
type: "procedure",
1163
1163
description:
1164
-
'Expose an instance of VS Code for a sandbox. This allows users to access a web-based version of VS Code that is connected to their sandbox environment, enabling them to edit code, manage files, and perform other development tasks directly from their browser.',
1164
+
"Expose an instance of VS Code for a sandbox. This allows users to access a web-based version of VS Code that is connected to their sandbox environment, enabling them to edit code, manage files, and perform other development tasks directly from their browser.",
1165
1165
parameters: {
1166
-
type: 'params',
1167
-
required: ['id'],
1166
+
type: "params",
1167
+
required: ["id"],
1168
1168
properties: {
1169
1169
id: {
1170
-
type: 'string',
1171
-
description: 'The sandbox ID.',
1170
+
type: "string",
1171
+
description: "The sandbox ID.",
1172
1172
},
1173
1173
},
1174
1174
},
1175
1175
output: {
1176
-
encoding: 'application/json',
1176
+
encoding: "application/json",
1177
1177
schema: {
1178
-
type: 'object',
1179
-
nullable: ['previewUrl'],
1178
+
type: "object",
1179
+
nullable: ["previewUrl"],
1180
1180
properties: {
1181
1181
previewUrl: {
1182
-
type: 'string',
1183
-
description: 'The preview URL for the exposed port.',
1182
+
type: "string",
1183
+
description: "The preview URL for the exposed port.",
1184
1184
},
1185
1185
},
1186
1186
},
···
1190
1190
},
1191
1191
IoPocketenvSandboxGetExposedPorts: {
1192
1192
lexicon: 1,
1193
-
id: 'io.pocketenv.sandbox.getExposedPorts',
1193
+
id: "io.pocketenv.sandbox.getExposedPorts",
1194
1194
defs: {
1195
1195
main: {
1196
-
type: 'query',
1197
-
description: 'Get the list of exposed ports for a sandbox.',
1196
+
type: "query",
1197
+
description: "Get the list of exposed ports for a sandbox.",
1198
1198
parameters: {
1199
-
type: 'params',
1200
-
required: ['id'],
1199
+
type: "params",
1200
+
required: ["id"],
1201
1201
properties: {
1202
1202
id: {
1203
-
type: 'string',
1204
-
description: 'The sandbox ID.',
1203
+
type: "string",
1204
+
description: "The sandbox ID.",
1205
1205
},
1206
1206
},
1207
1207
},
1208
1208
output: {
1209
-
encoding: 'application/json',
1209
+
encoding: "application/json",
1210
1210
schema: {
1211
-
type: 'object',
1211
+
type: "object",
1212
1212
properties: {
1213
1213
ports: {
1214
-
type: 'array',
1214
+
type: "array",
1215
1215
items: {
1216
-
type: 'ref',
1217
-
ref: 'lex:io.pocketenv.port.defs#portView',
1216
+
type: "ref",
1217
+
ref: "lex:io.pocketenv.port.defs#portView",
1218
1218
},
1219
1219
},
1220
1220
},
···
1225
1225
},
1226
1226
IoPocketenvSandboxGetIntegrations: {
1227
1227
lexicon: 1,
1228
-
id: 'io.pocketenv.sandbox.getIntegrations',
1228
+
id: "io.pocketenv.sandbox.getIntegrations",
1229
1229
defs: {
1230
1230
main: {
1231
-
type: 'query',
1232
-
description: 'Get the integrations for a sandbox.',
1231
+
type: "query",
1232
+
description: "Get the integrations for a sandbox.",
1233
1233
parameters: {
1234
-
type: 'params',
1235
-
required: ['id'],
1234
+
type: "params",
1235
+
required: ["id"],
1236
1236
properties: {
1237
1237
id: {
1238
-
type: 'string',
1239
-
description: 'The sandbox ID.',
1238
+
type: "string",
1239
+
description: "The sandbox ID.",
1240
1240
},
1241
1241
},
1242
1242
},
1243
1243
output: {
1244
-
encoding: 'application/json',
1244
+
encoding: "application/json",
1245
1245
schema: {
1246
-
type: 'ref',
1247
-
ref: 'lex:io.pocketenv.sandbox.defs#integrationsView',
1246
+
type: "ref",
1247
+
ref: "lex:io.pocketenv.sandbox.defs#integrationsView",
1248
1248
},
1249
1249
},
1250
1250
},
···
1252
1252
},
1253
1253
IoPocketenvSandboxGetPreferences: {
1254
1254
lexicon: 1,
1255
-
id: 'io.pocketenv.sandbox.getPreferences',
1255
+
id: "io.pocketenv.sandbox.getPreferences",
1256
1256
defs: {
1257
1257
main: {
1258
-
type: 'query',
1259
-
description: 'Get sandbox preferences',
1258
+
type: "query",
1259
+
description: "Get sandbox preferences",
1260
1260
parameters: {
1261
-
type: 'params',
1262
-
required: ['id'],
1261
+
type: "params",
1262
+
required: ["id"],
1263
1263
properties: {
1264
1264
id: {
1265
-
type: 'string',
1266
-
description: 'The sandbox ID or URI to retrieve',
1265
+
type: "string",
1266
+
description: "The sandbox ID or URI to retrieve",
1267
1267
},
1268
1268
},
1269
1269
},
1270
1270
output: {
1271
-
encoding: 'application/json',
1271
+
encoding: "application/json",
1272
1272
schema: {
1273
-
type: 'ref',
1274
-
ref: 'lex:io.pocketenv.sandbox.defs#preferences',
1273
+
type: "ref",
1274
+
ref: "lex:io.pocketenv.sandbox.defs#preferences",
1275
1275
},
1276
1276
},
1277
1277
},
···
1279
1279
},
1280
1280
IoPocketenvSandboxGetSandbox: {
1281
1281
lexicon: 1,
1282
-
id: 'io.pocketenv.sandbox.getSandbox',
1282
+
id: "io.pocketenv.sandbox.getSandbox",
1283
1283
defs: {
1284
1284
main: {
1285
-
type: 'query',
1286
-
description: 'Get a sandbox by ID or URI',
1285
+
type: "query",
1286
+
description: "Get a sandbox by ID or URI",
1287
1287
parameters: {
1288
-
type: 'params',
1289
-
required: ['id'],
1288
+
type: "params",
1289
+
required: ["id"],
1290
1290
properties: {
1291
1291
id: {
1292
-
type: 'string',
1293
-
description: 'The sandbox ID or URI to retrieve',
1292
+
type: "string",
1293
+
description: "The sandbox ID or URI to retrieve",
1294
1294
},
1295
1295
},
1296
1296
},
1297
1297
output: {
1298
-
encoding: 'application/json',
1298
+
encoding: "application/json",
1299
1299
schema: {
1300
-
type: 'ref',
1301
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1300
+
type: "ref",
1301
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1302
1302
},
1303
1303
},
1304
1304
},
···
1306
1306
},
1307
1307
IoPocketenvSandboxGetSandboxes: {
1308
1308
lexicon: 1,
1309
-
id: 'io.pocketenv.sandbox.getSandboxes',
1309
+
id: "io.pocketenv.sandbox.getSandboxes",
1310
1310
defs: {
1311
1311
main: {
1312
-
type: 'query',
1313
-
description: 'Get all sandboxes',
1312
+
type: "query",
1313
+
description: "Get all sandboxes",
1314
1314
parameters: {
1315
-
type: 'params',
1315
+
type: "params",
1316
1316
properties: {
1317
1317
limit: {
1318
-
type: 'integer',
1319
-
description: 'The maximum number of sandboxes to return.',
1318
+
type: "integer",
1319
+
description: "The maximum number of sandboxes to return.",
1320
1320
minimum: 1,
1321
1321
},
1322
1322
offset: {
1323
-
type: 'integer',
1323
+
type: "integer",
1324
1324
description:
1325
-
'The number of sandboxes to skip before starting to collect the result set.',
1325
+
"The number of sandboxes to skip before starting to collect the result set.",
1326
1326
minimum: 0,
1327
1327
},
1328
1328
},
1329
1329
},
1330
1330
output: {
1331
-
encoding: 'application/json',
1331
+
encoding: "application/json",
1332
1332
schema: {
1333
-
type: 'object',
1333
+
type: "object",
1334
1334
properties: {
1335
1335
sandboxes: {
1336
-
type: 'array',
1336
+
type: "array",
1337
1337
items: {
1338
-
type: 'ref',
1339
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1338
+
type: "ref",
1339
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1340
1340
},
1341
1341
},
1342
1342
total: {
1343
-
type: 'integer',
1344
-
description: 'The total number of sandboxes available.',
1343
+
type: "integer",
1344
+
description: "The total number of sandboxes available.",
1345
1345
minimum: 0,
1346
1346
},
1347
1347
},
···
1352
1352
},
1353
1353
IoPocketenvSandboxGetSshKeys: {
1354
1354
lexicon: 1,
1355
-
id: 'io.pocketenv.sandbox.getSshKeys',
1355
+
id: "io.pocketenv.sandbox.getSshKeys",
1356
1356
defs: {
1357
1357
main: {
1358
-
type: 'query',
1359
-
description: 'Get the SSH keys for a sandbox.',
1358
+
type: "query",
1359
+
description: "Get the SSH keys for a sandbox.",
1360
1360
parameters: {
1361
-
type: 'params',
1362
-
required: ['id'],
1361
+
type: "params",
1362
+
required: ["id"],
1363
1363
properties: {
1364
1364
id: {
1365
-
type: 'string',
1366
-
description: 'The sandbox ID.',
1365
+
type: "string",
1366
+
description: "The sandbox ID.",
1367
1367
},
1368
1368
},
1369
1369
},
1370
1370
output: {
1371
-
encoding: 'application/json',
1371
+
encoding: "application/json",
1372
1372
schema: {
1373
-
type: 'ref',
1374
-
ref: 'lex:io.pocketenv.sandbox.defs#sshKeysView',
1373
+
type: "ref",
1374
+
ref: "lex:io.pocketenv.sandbox.defs#sshKeysView",
1375
1375
},
1376
1376
},
1377
1377
},
···
1379
1379
},
1380
1380
IoPocketenvSandboxGetTailscaleAuthKey: {
1381
1381
lexicon: 1,
1382
-
id: 'io.pocketenv.sandbox.getTailscaleAuthKey',
1382
+
id: "io.pocketenv.sandbox.getTailscaleAuthKey",
1383
1383
defs: {
1384
1384
main: {
1385
-
type: 'query',
1386
-
description: 'Get the Tailscale token for a sandbox.',
1385
+
type: "query",
1386
+
description: "Get the Tailscale token for a sandbox.",
1387
1387
parameters: {
1388
-
type: 'params',
1389
-
required: ['id'],
1388
+
type: "params",
1389
+
required: ["id"],
1390
1390
properties: {
1391
1391
id: {
1392
-
type: 'string',
1393
-
description: 'The sandbox ID.',
1392
+
type: "string",
1393
+
description: "The sandbox ID.",
1394
1394
},
1395
1395
},
1396
1396
},
1397
1397
output: {
1398
-
encoding: 'application/json',
1398
+
encoding: "application/json",
1399
1399
schema: {
1400
-
type: 'ref',
1401
-
ref: 'lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView',
1400
+
type: "ref",
1401
+
ref: "lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView",
1402
1402
},
1403
1403
},
1404
1404
},
···
1406
1406
},
1407
1407
IoPocketenvSandboxGetTailscaleToken: {
1408
1408
lexicon: 1,
1409
-
id: 'io.pocketenv.sandbox.getTailscaleToken',
1409
+
id: "io.pocketenv.sandbox.getTailscaleToken",
1410
1410
defs: {
1411
1411
main: {
1412
-
type: 'query',
1413
-
description: 'Get the Tailscale token for a sandbox.',
1412
+
type: "query",
1413
+
description: "Get the Tailscale token for a sandbox.",
1414
1414
parameters: {
1415
-
type: 'params',
1416
-
required: ['id'],
1415
+
type: "params",
1416
+
required: ["id"],
1417
1417
properties: {
1418
1418
id: {
1419
-
type: 'string',
1420
-
description: 'The sandbox ID.',
1419
+
type: "string",
1420
+
description: "The sandbox ID.",
1421
1421
},
1422
1422
},
1423
1423
},
1424
1424
output: {
1425
-
encoding: 'application/json',
1425
+
encoding: "application/json",
1426
1426
schema: {
1427
-
type: 'ref',
1428
-
ref: 'lex:io.pocketenv.sandbox.defs#tailscaleTokenView',
1427
+
type: "ref",
1428
+
ref: "lex:io.pocketenv.sandbox.defs#tailscaleTokenView",
1429
1429
},
1430
1430
},
1431
1431
},
···
1433
1433
},
1434
1434
IoPocketenvSandboxPutPreferences: {
1435
1435
lexicon: 1,
1436
-
id: 'io.pocketenv.sandbox.putPreferences',
1436
+
id: "io.pocketenv.sandbox.putPreferences",
1437
1437
defs: {
1438
1438
main: {
1439
-
type: 'procedure',
1440
-
description: 'Update sandbox preferences.',
1439
+
type: "procedure",
1440
+
description: "Update sandbox preferences.",
1441
1441
input: {
1442
-
encoding: 'application/json',
1442
+
encoding: "application/json",
1443
1443
schema: {
1444
-
type: 'object',
1445
-
required: ['sandboxId', 'preferences'],
1444
+
type: "object",
1445
+
required: ["sandboxId", "preferences"],
1446
1446
properties: {
1447
1447
sandboxId: {
1448
-
type: 'string',
1449
-
description: 'The sandbox ID or URI',
1448
+
type: "string",
1449
+
description: "The sandbox ID or URI",
1450
1450
},
1451
1451
preferences: {
1452
-
type: 'ref',
1453
-
ref: 'lex:io.pocketenv.sandbox.defs#preferences',
1452
+
type: "ref",
1453
+
ref: "lex:io.pocketenv.sandbox.defs#preferences",
1454
1454
},
1455
1455
},
1456
1456
},
···
1460
1460
},
1461
1461
IoPocketenvSandboxPutSshKeys: {
1462
1462
lexicon: 1,
1463
-
id: 'io.pocketenv.sandbox.putSshKeys',
1463
+
id: "io.pocketenv.sandbox.putSshKeys",
1464
1464
defs: {
1465
1465
main: {
1466
-
type: 'procedure',
1467
-
description: 'Add or update SSH keys for a sandbox.',
1466
+
type: "procedure",
1467
+
description: "Add or update SSH keys for a sandbox.",
1468
1468
input: {
1469
-
encoding: 'application/json',
1469
+
encoding: "application/json",
1470
1470
schema: {
1471
-
type: 'object',
1472
-
required: ['id', 'privateKey', 'publicKey'],
1471
+
type: "object",
1472
+
required: ["id", "privateKey", "publicKey"],
1473
1473
properties: {
1474
1474
id: {
1475
-
type: 'string',
1476
-
description: 'The sandbox ID.',
1475
+
type: "string",
1476
+
description: "The sandbox ID.",
1477
1477
},
1478
1478
privateKey: {
1479
-
type: 'string',
1480
-
description: 'The private SSH key (encrypted)',
1479
+
type: "string",
1480
+
description: "The private SSH key (encrypted)",
1481
1481
},
1482
1482
publicKey: {
1483
-
type: 'string',
1484
-
description: 'The public SSH key.',
1483
+
type: "string",
1484
+
description: "The public SSH key.",
1485
1485
},
1486
1486
redacted: {
1487
-
type: 'string',
1488
-
description: 'The redacted SSH key.',
1487
+
type: "string",
1488
+
description: "The redacted SSH key.",
1489
1489
},
1490
1490
},
1491
1491
},
1492
1492
},
1493
1493
output: {
1494
-
encoding: 'application/json',
1494
+
encoding: "application/json",
1495
1495
schema: {
1496
-
type: 'ref',
1497
-
ref: 'lex:io.pocketenv.sandbox.defs#sshKeysView',
1496
+
type: "ref",
1497
+
ref: "lex:io.pocketenv.sandbox.defs#sshKeysView",
1498
1498
},
1499
1499
},
1500
1500
},
···
1502
1502
},
1503
1503
IoPocketenvSandboxPutTailscaleAuthKey: {
1504
1504
lexicon: 1,
1505
-
id: 'io.pocketenv.sandbox.putTailscaleAuthKey',
1505
+
id: "io.pocketenv.sandbox.putTailscaleAuthKey",
1506
1506
defs: {
1507
1507
main: {
1508
-
type: 'procedure',
1508
+
type: "procedure",
1509
1509
description:
1510
1510
"Store a Tailscale Auth Key for the sandbox. This Auth Key will be used to authenticate with the Tailscale API and manage the sandbox's Tailscale node.",
1511
1511
input: {
1512
-
encoding: 'application/json',
1512
+
encoding: "application/json",
1513
1513
schema: {
1514
-
type: 'object',
1515
-
required: ['id', 'authKey'],
1514
+
type: "object",
1515
+
required: ["id", "authKey"],
1516
1516
properties: {
1517
1517
id: {
1518
-
type: 'string',
1519
-
description: 'The sandbox ID.',
1518
+
type: "string",
1519
+
description: "The sandbox ID.",
1520
1520
},
1521
1521
authKey: {
1522
-
type: 'string',
1522
+
type: "string",
1523
1523
description:
1524
-
'The Tailscale Auth Key (encrypted) to store for the sandbox.',
1524
+
"The Tailscale Auth Key (encrypted) to store for the sandbox.",
1525
1525
},
1526
1526
redacted: {
1527
-
type: 'string',
1528
-
description: 'The redacted SSH key.',
1527
+
type: "string",
1528
+
description: "The redacted SSH key.",
1529
1529
},
1530
1530
},
1531
1531
},
1532
1532
},
1533
1533
output: {
1534
-
encoding: 'application/json',
1534
+
encoding: "application/json",
1535
1535
schema: {
1536
-
type: 'ref',
1537
-
ref: 'lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView',
1536
+
type: "ref",
1537
+
ref: "lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView",
1538
1538
},
1539
1539
},
1540
1540
},
···
1542
1542
},
1543
1543
IoPocketenvSandboxPutTailscaleToken: {
1544
1544
lexicon: 1,
1545
-
id: 'io.pocketenv.sandbox.putTailscaleToken',
1545
+
id: "io.pocketenv.sandbox.putTailscaleToken",
1546
1546
defs: {
1547
1547
main: {
1548
-
type: 'procedure',
1548
+
type: "procedure",
1549
1549
description:
1550
1550
"Store a Tailscale token for the sandbox. This token will be used to authenticate with the Tailscale API and manage the sandbox's Tailscale node.",
1551
1551
input: {
1552
-
encoding: 'application/json',
1552
+
encoding: "application/json",
1553
1553
schema: {
1554
-
type: 'object',
1555
-
required: ['id', 'token'],
1554
+
type: "object",
1555
+
required: ["id", "token"],
1556
1556
properties: {
1557
1557
id: {
1558
-
type: 'string',
1559
-
description: 'The sandbox ID.',
1558
+
type: "string",
1559
+
description: "The sandbox ID.",
1560
1560
},
1561
1561
token: {
1562
-
type: 'string',
1562
+
type: "string",
1563
1563
description:
1564
-
'The Tailscale token (encrypted) to store for the sandbox.',
1564
+
"The Tailscale token (encrypted) to store for the sandbox.",
1565
1565
},
1566
1566
},
1567
1567
},
1568
1568
},
1569
1569
output: {
1570
-
encoding: 'application/json',
1570
+
encoding: "application/json",
1571
1571
schema: {
1572
-
type: 'ref',
1573
-
ref: 'lex:io.pocketenv.sandbox.defs#tailscaleTokenView',
1572
+
type: "ref",
1573
+
ref: "lex:io.pocketenv.sandbox.defs#tailscaleTokenView",
1574
1574
},
1575
1575
},
1576
1576
},
···
1578
1578
},
1579
1579
IoPocketenvSandbox: {
1580
1580
lexicon: 1,
1581
-
id: 'io.pocketenv.sandbox',
1581
+
id: "io.pocketenv.sandbox",
1582
1582
defs: {
1583
1583
main: {
1584
-
type: 'record',
1585
-
key: 'tid',
1584
+
type: "record",
1585
+
key: "tid",
1586
1586
record: {
1587
-
type: 'object',
1588
-
required: ['name', 'createdAt'],
1587
+
type: "object",
1588
+
required: ["name", "createdAt"],
1589
1589
properties: {
1590
1590
name: {
1591
-
type: 'string',
1592
-
description: 'Name of the sandbox',
1591
+
type: "string",
1592
+
description: "Name of the sandbox",
1593
1593
maxLength: 255,
1594
1594
},
1595
1595
base: {
1596
-
type: 'ref',
1596
+
type: "ref",
1597
1597
description:
1598
-
'A strong reference to the base template for the sandbox environment.',
1599
-
ref: 'lex:com.atproto.repo.strongRef',
1598
+
"A strong reference to the base template for the sandbox environment.",
1599
+
ref: "lex:com.atproto.repo.strongRef",
1600
1600
},
1601
1601
provider: {
1602
-
type: 'string',
1602
+
type: "string",
1603
1603
description:
1604
1604
"The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.",
1605
1605
maxLength: 50,
1606
1606
},
1607
1607
description: {
1608
-
type: 'string',
1608
+
type: "string",
1609
1609
maxGraphemes: 300,
1610
1610
maxLength: 3000,
1611
1611
},
1612
1612
website: {
1613
-
type: 'string',
1614
-
description: 'Any URI related to the sandbox',
1615
-
format: 'uri',
1613
+
type: "string",
1614
+
description: "Any URI related to the sandbox",
1615
+
format: "uri",
1616
1616
},
1617
1617
logo: {
1618
-
type: 'string',
1619
-
description: 'URI to an image logo for the sandbox',
1620
-
format: 'uri',
1618
+
type: "string",
1619
+
description: "URI to an image logo for the sandbox",
1620
+
format: "uri",
1621
1621
},
1622
1622
topics: {
1623
-
type: 'array',
1623
+
type: "array",
1624
1624
items: {
1625
-
type: 'string',
1625
+
type: "string",
1626
1626
minLength: 1,
1627
1627
maxLength: 50,
1628
1628
},
1629
1629
maxLength: 50,
1630
1630
},
1631
1631
repo: {
1632
-
type: 'string',
1632
+
type: "string",
1633
1633
description:
1634
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
1634
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
1635
1635
},
1636
1636
readme: {
1637
-
type: 'string',
1638
-
description: 'A URI to a README for the sandbox.',
1639
-
format: 'uri',
1637
+
type: "string",
1638
+
description: "A URI to a README for the sandbox.",
1639
+
format: "uri",
1640
1640
},
1641
1641
vcpus: {
1642
-
type: 'integer',
1643
-
description: 'Number of virtual CPUs allocated to the sandbox',
1642
+
type: "integer",
1643
+
description: "Number of virtual CPUs allocated to the sandbox",
1644
1644
},
1645
1645
memory: {
1646
-
type: 'integer',
1647
-
description: 'Amount of memory in GB allocated to the sandbox',
1646
+
type: "integer",
1647
+
description: "Amount of memory in GB allocated to the sandbox",
1648
1648
},
1649
1649
disk: {
1650
-
type: 'integer',
1650
+
type: "integer",
1651
1651
description:
1652
-
'Amount of disk space in GB allocated to the sandbox',
1652
+
"Amount of disk space in GB allocated to the sandbox",
1653
1653
},
1654
1654
volumes: {
1655
-
type: 'array',
1655
+
type: "array",
1656
1656
items: {
1657
-
type: 'string',
1657
+
type: "string",
1658
1658
description:
1659
1659
"A path to be mounted as a volume in the sandbox, e.g. '/data', '/logs', etc.",
1660
1660
},
1661
1661
},
1662
1662
ports: {
1663
-
type: 'array',
1663
+
type: "array",
1664
1664
items: {
1665
-
type: 'integer',
1665
+
type: "integer",
1666
1666
description:
1667
-
'A port number that is exposed by the sandbox environment.',
1667
+
"A port number that is exposed by the sandbox environment.",
1668
1668
},
1669
1669
},
1670
1670
secrets: {
1671
-
type: 'array',
1671
+
type: "array",
1672
1672
items: {
1673
-
type: 'string',
1673
+
type: "string",
1674
1674
description:
1675
-
'Name of a secret to be added to the sandbox environment. Secrets are typically encrypted and stored securely, and can be used to store sensitive information such as API keys, database credentials, etc.',
1675
+
"Name of a secret to be added to the sandbox environment. Secrets are typically encrypted and stored securely, and can be used to store sensitive information such as API keys, database credentials, etc.",
1676
1676
},
1677
1677
},
1678
1678
envs: {
1679
-
type: 'array',
1679
+
type: "array",
1680
1680
items: {
1681
-
type: 'string',
1681
+
type: "string",
1682
1682
description:
1683
-
'Name of an environment variable to be added to the sandbox environment.',
1683
+
"Name of an environment variable to be added to the sandbox environment.",
1684
1684
},
1685
1685
},
1686
1686
createdAt: {
1687
-
type: 'string',
1688
-
format: 'datetime',
1687
+
type: "string",
1688
+
format: "datetime",
1689
1689
},
1690
1690
},
1691
1691
},
···
1694
1694
},
1695
1695
IoPocketenvSandboxStartSandbox: {
1696
1696
lexicon: 1,
1697
-
id: 'io.pocketenv.sandbox.startSandbox',
1697
+
id: "io.pocketenv.sandbox.startSandbox",
1698
1698
defs: {
1699
1699
main: {
1700
-
type: 'procedure',
1701
-
description: 'Start a sandbox',
1700
+
type: "procedure",
1701
+
description: "Start a sandbox",
1702
1702
parameters: {
1703
-
type: 'params',
1704
-
required: ['id'],
1703
+
type: "params",
1704
+
required: ["id"],
1705
1705
properties: {
1706
1706
id: {
1707
-
type: 'string',
1708
-
description: 'The sandbox ID.',
1707
+
type: "string",
1708
+
description: "The sandbox ID.",
1709
1709
},
1710
1710
},
1711
1711
},
1712
1712
input: {
1713
-
encoding: 'application/json',
1713
+
encoding: "application/json",
1714
1714
schema: {
1715
-
type: 'object',
1715
+
type: "object",
1716
1716
properties: {
1717
1717
repo: {
1718
-
type: 'string',
1718
+
type: "string",
1719
1719
description:
1720
-
'The git repository URL to clone into the sandbox before starting it. Optional.',
1720
+
"The git repository URL to clone into the sandbox before starting it. Optional.",
1721
1721
},
1722
1722
keepAlive: {
1723
-
type: 'boolean',
1723
+
type: "boolean",
1724
1724
description:
1725
-
'Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs.',
1725
+
"Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs.",
1726
1726
},
1727
1727
},
1728
1728
},
1729
1729
},
1730
1730
output: {
1731
-
encoding: 'application/json',
1731
+
encoding: "application/json",
1732
1732
schema: {
1733
-
type: 'ref',
1734
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1733
+
type: "ref",
1734
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1735
1735
},
1736
1736
},
1737
1737
},
···
1739
1739
},
1740
1740
IoPocketenvSandboxStopSandbox: {
1741
1741
lexicon: 1,
1742
-
id: 'io.pocketenv.sandbox.stopSandbox',
1742
+
id: "io.pocketenv.sandbox.stopSandbox",
1743
1743
defs: {
1744
1744
main: {
1745
-
type: 'procedure',
1746
-
description: 'Stop a sandbox',
1745
+
type: "procedure",
1746
+
description: "Stop a sandbox",
1747
1747
parameters: {
1748
-
type: 'params',
1749
-
required: ['id'],
1748
+
type: "params",
1749
+
required: ["id"],
1750
1750
properties: {
1751
1751
id: {
1752
-
type: 'string',
1753
-
description: 'The sandbox ID.',
1752
+
type: "string",
1753
+
description: "The sandbox ID.",
1754
1754
},
1755
1755
},
1756
1756
},
1757
1757
output: {
1758
-
encoding: 'application/json',
1758
+
encoding: "application/json",
1759
1759
schema: {
1760
-
type: 'ref',
1761
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1760
+
type: "ref",
1761
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1762
1762
},
1763
1763
},
1764
1764
},
···
1766
1766
},
1767
1767
IoPocketenvSandboxUnexposePort: {
1768
1768
lexicon: 1,
1769
-
id: 'io.pocketenv.sandbox.unexposePort',
1769
+
id: "io.pocketenv.sandbox.unexposePort",
1770
1770
defs: {
1771
1771
main: {
1772
-
type: 'procedure',
1773
-
description: 'Unexpose a port for a sandbox.',
1772
+
type: "procedure",
1773
+
description: "Unexpose a port for a sandbox.",
1774
1774
parameters: {
1775
-
type: 'params',
1776
-
required: ['id'],
1775
+
type: "params",
1776
+
required: ["id"],
1777
1777
properties: {
1778
1778
id: {
1779
-
type: 'string',
1780
-
description: 'The sandbox ID.',
1779
+
type: "string",
1780
+
description: "The sandbox ID.",
1781
1781
},
1782
1782
},
1783
1783
},
1784
1784
input: {
1785
-
encoding: 'application/json',
1785
+
encoding: "application/json",
1786
1786
schema: {
1787
-
type: 'object',
1788
-
required: ['port'],
1787
+
type: "object",
1788
+
required: ["port"],
1789
1789
properties: {
1790
1790
port: {
1791
-
type: 'integer',
1792
-
description: 'The port number to unexpose.',
1791
+
type: "integer",
1792
+
description: "The port number to unexpose.",
1793
1793
maximum: 65535,
1794
1794
minimum: 1024,
1795
1795
},
···
1801
1801
},
1802
1802
IoPocketenvSandboxUpdateSandboxSettings: {
1803
1803
lexicon: 1,
1804
-
id: 'io.pocketenv.sandbox.updateSandboxSettings',
1804
+
id: "io.pocketenv.sandbox.updateSandboxSettings",
1805
1805
defs: {
1806
1806
main: {
1807
-
type: 'procedure',
1808
-
description: 'Update sandbox settings',
1807
+
type: "procedure",
1808
+
description: "Update sandbox settings",
1809
1809
input: {
1810
-
encoding: 'application/json',
1810
+
encoding: "application/json",
1811
1811
schema: {
1812
-
type: 'object',
1812
+
type: "object",
1813
1813
properties: {
1814
1814
name: {
1815
-
type: 'string',
1816
-
description: 'The name of the sandbox',
1815
+
type: "string",
1816
+
description: "The name of the sandbox",
1817
1817
minLength: 1,
1818
1818
},
1819
1819
description: {
1820
-
type: 'string',
1821
-
description: 'A description for the sandbox',
1820
+
type: "string",
1821
+
description: "A description for the sandbox",
1822
1822
},
1823
1823
topics: {
1824
-
type: 'array',
1824
+
type: "array",
1825
1825
description:
1826
-
'A list of topics/tags to associate with the sandbox',
1826
+
"A list of topics/tags to associate with the sandbox",
1827
1827
items: {
1828
-
type: 'string',
1828
+
type: "string",
1829
1829
maxLength: 50,
1830
1830
},
1831
1831
},
1832
1832
repo: {
1833
-
type: 'string',
1833
+
type: "string",
1834
1834
description:
1835
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
1836
-
format: 'uri',
1835
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
1836
+
format: "uri",
1837
1837
},
1838
1838
vcpus: {
1839
-
type: 'integer',
1839
+
type: "integer",
1840
1840
description:
1841
-
'The number of virtual CPUs to allocate for the sandbox',
1841
+
"The number of virtual CPUs to allocate for the sandbox",
1842
1842
minimum: 1,
1843
1843
},
1844
1844
memory: {
1845
-
type: 'integer',
1845
+
type: "integer",
1846
1846
description:
1847
-
'The amount of memory (in GB) to allocate for the sandbox',
1847
+
"The amount of memory (in GB) to allocate for the sandbox",
1848
1848
minimum: 1,
1849
1849
},
1850
1850
disk: {
1851
-
type: 'integer',
1851
+
type: "integer",
1852
1852
description:
1853
-
'The amount of disk space (in GB) to allocate for the sandbox',
1853
+
"The amount of disk space (in GB) to allocate for the sandbox",
1854
1854
minimum: 3,
1855
1855
},
1856
1856
readme: {
1857
-
type: 'string',
1858
-
description: 'A URI to a README for the sandbox.',
1859
-
format: 'uri',
1857
+
type: "string",
1858
+
description: "A URI to a README for the sandbox.",
1859
+
format: "uri",
1860
1860
},
1861
1861
secrets: {
1862
-
type: 'ref',
1863
-
description: 'A list of secrets to add to the sandbox',
1864
-
ref: 'lex:io.pocketenv.secret.defs#secrets',
1862
+
type: "ref",
1863
+
description: "A list of secrets to add to the sandbox",
1864
+
ref: "lex:io.pocketenv.secret.defs#secrets",
1865
1865
},
1866
1866
variables: {
1867
-
type: 'ref',
1867
+
type: "ref",
1868
1868
description:
1869
-
'A list of environment variables to add to the sandbox',
1870
-
ref: 'lex:io.pocketenv.variable.defs#variables',
1869
+
"A list of environment variables to add to the sandbox",
1870
+
ref: "lex:io.pocketenv.variable.defs#variables",
1871
1871
},
1872
1872
files: {
1873
-
type: 'ref',
1874
-
description: 'A list of files to add to the sandbox',
1875
-
ref: 'lex:io.pocketenv.file.defs#file',
1873
+
type: "ref",
1874
+
description: "A list of files to add to the sandbox",
1875
+
ref: "lex:io.pocketenv.file.defs#file",
1876
1876
},
1877
1877
volumes: {
1878
-
type: 'ref',
1879
-
description: 'A list of volumes to add to the sandbox',
1880
-
ref: 'lex:io.pocketenv.volume.defs#volumes',
1878
+
type: "ref",
1879
+
description: "A list of volumes to add to the sandbox",
1880
+
ref: "lex:io.pocketenv.volume.defs#volumes",
1881
1881
},
1882
1882
},
1883
1883
},
1884
1884
},
1885
1885
output: {
1886
-
encoding: 'application/json',
1886
+
encoding: "application/json",
1887
1887
schema: {
1888
-
type: 'ref',
1889
-
ref: 'lex:io.pocketenv.sandbox.defs#profileViewDetailed',
1888
+
type: "ref",
1889
+
ref: "lex:io.pocketenv.sandbox.defs#profileViewDetailed",
1890
1890
},
1891
1891
},
1892
1892
},
···
1894
1894
},
1895
1895
IoPocketenvSecretAddSecret: {
1896
1896
lexicon: 1,
1897
-
id: 'io.pocketenv.secret.addSecret',
1897
+
id: "io.pocketenv.secret.addSecret",
1898
1898
defs: {
1899
1899
main: {
1900
-
type: 'procedure',
1900
+
type: "procedure",
1901
1901
input: {
1902
-
encoding: 'application/json',
1902
+
encoding: "application/json",
1903
1903
schema: {
1904
-
type: 'object',
1905
-
required: ['secret'],
1904
+
type: "object",
1905
+
required: ["secret"],
1906
1906
properties: {
1907
1907
secret: {
1908
-
type: 'ref',
1909
-
ref: 'lex:io.pocketenv.secret.defs#secret',
1908
+
type: "ref",
1909
+
ref: "lex:io.pocketenv.secret.defs#secret",
1910
1910
},
1911
1911
redacted: {
1912
-
type: 'string',
1913
-
description: 'The redacted secret value.',
1912
+
type: "string",
1913
+
description: "The redacted secret value.",
1914
1914
},
1915
1915
},
1916
1916
},
···
1920
1920
},
1921
1921
IoPocketenvSecretDefs: {
1922
1922
lexicon: 1,
1923
-
id: 'io.pocketenv.secret.defs',
1923
+
id: "io.pocketenv.secret.defs",
1924
1924
defs: {
1925
1925
secretView: {
1926
-
type: 'object',
1926
+
type: "object",
1927
1927
properties: {
1928
1928
id: {
1929
-
type: 'string',
1930
-
description: 'Unique identifier of the secret.',
1929
+
type: "string",
1930
+
description: "Unique identifier of the secret.",
1931
1931
},
1932
1932
name: {
1933
-
type: 'string',
1933
+
type: "string",
1934
1934
description:
1935
1935
"Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc.",
1936
1936
},
1937
1937
},
1938
1938
},
1939
1939
secret: {
1940
-
type: 'object',
1941
-
required: ['name', 'value'],
1940
+
type: "object",
1941
+
required: ["name", "value"],
1942
1942
properties: {
1943
1943
sandboxId: {
1944
-
type: 'string',
1944
+
type: "string",
1945
1945
description:
1946
-
'The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment.',
1946
+
"The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment.",
1947
1947
},
1948
1948
name: {
1949
-
type: 'string',
1949
+
type: "string",
1950
1950
description:
1951
1951
"Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc.",
1952
1952
},
1953
1953
value: {
1954
-
type: 'string',
1954
+
type: "string",
1955
1955
description:
1956
-
'Value of the secret. This will be encrypted at rest and redacted in any API responses.',
1956
+
"Value of the secret. This will be encrypted at rest and redacted in any API responses.",
1957
1957
},
1958
1958
},
1959
1959
},
1960
1960
secrets: {
1961
-
type: 'array',
1961
+
type: "array",
1962
1962
items: {
1963
-
type: 'ref',
1964
-
description: 'A secret to add to the sandbox',
1965
-
ref: 'lex:io.pocketenv.secret.defs#secret',
1963
+
type: "ref",
1964
+
description: "A secret to add to the sandbox",
1965
+
ref: "lex:io.pocketenv.secret.defs#secret",
1966
1966
},
1967
1967
},
1968
1968
},
1969
1969
},
1970
1970
IoPocketenvSecretDeleteSecret: {
1971
1971
lexicon: 1,
1972
-
id: 'io.pocketenv.secret.deleteSecret',
1972
+
id: "io.pocketenv.secret.deleteSecret",
1973
1973
defs: {
1974
1974
main: {
1975
-
type: 'procedure',
1975
+
type: "procedure",
1976
1976
parameters: {
1977
-
type: 'params',
1978
-
required: ['id'],
1977
+
type: "params",
1978
+
required: ["id"],
1979
1979
properties: {
1980
1980
id: {
1981
-
type: 'string',
1982
-
description: 'The ID of the secret to delete',
1981
+
type: "string",
1982
+
description: "The ID of the secret to delete",
1983
1983
},
1984
1984
},
1985
1985
},
···
1988
1988
},
1989
1989
IoPocketenvSecretGetSecret: {
1990
1990
lexicon: 1,
1991
-
id: 'io.pocketenv.secret.getSecret',
1991
+
id: "io.pocketenv.secret.getSecret",
1992
1992
defs: {
1993
1993
main: {
1994
-
type: 'query',
1994
+
type: "query",
1995
1995
parameters: {
1996
-
type: 'params',
1997
-
required: ['id'],
1996
+
type: "params",
1997
+
required: ["id"],
1998
1998
properties: {
1999
1999
id: {
2000
-
type: 'string',
2000
+
type: "string",
2001
2001
description:
2002
-
'The ID of the secret for which to retrieve secrets.',
2002
+
"The ID of the secret for which to retrieve secrets.",
2003
2003
},
2004
2004
},
2005
2005
},
2006
2006
output: {
2007
-
encoding: 'application/json',
2007
+
encoding: "application/json",
2008
2008
schema: {
2009
-
type: 'object',
2009
+
type: "object",
2010
2010
properties: {
2011
2011
secret: {
2012
-
type: 'ref',
2013
-
ref: 'lex:io.pocketenv.secret.defs#secretView',
2012
+
type: "ref",
2013
+
ref: "lex:io.pocketenv.secret.defs#secretView",
2014
2014
},
2015
2015
},
2016
2016
},
···
2020
2020
},
2021
2021
IoPocketenvSecretGetSecrets: {
2022
2022
lexicon: 1,
2023
-
id: 'io.pocketenv.secret.getSecrets',
2023
+
id: "io.pocketenv.secret.getSecrets",
2024
2024
defs: {
2025
2025
main: {
2026
-
type: 'query',
2026
+
type: "query",
2027
2027
parameters: {
2028
-
type: 'params',
2028
+
type: "params",
2029
2029
properties: {
2030
2030
sandboxId: {
2031
-
type: 'string',
2031
+
type: "string",
2032
2032
description:
2033
-
'The ID of the sandbox for which to retrieve secrets.',
2033
+
"The ID of the sandbox for which to retrieve secrets.",
2034
2034
},
2035
2035
limit: {
2036
-
type: 'integer',
2037
-
description: 'The maximum number of secrets to return.',
2036
+
type: "integer",
2037
+
description: "The maximum number of secrets to return.",
2038
2038
minimum: 1,
2039
2039
},
2040
2040
offset: {
2041
-
type: 'integer',
2041
+
type: "integer",
2042
2042
description:
2043
-
'The number of secrets to skip before starting to collect the result set.',
2043
+
"The number of secrets to skip before starting to collect the result set.",
2044
2044
minimum: 0,
2045
2045
},
2046
2046
},
2047
2047
},
2048
2048
output: {
2049
-
encoding: 'application/json',
2049
+
encoding: "application/json",
2050
2050
schema: {
2051
-
type: 'object',
2051
+
type: "object",
2052
2052
properties: {
2053
2053
secrets: {
2054
-
type: 'array',
2054
+
type: "array",
2055
2055
items: {
2056
-
type: 'ref',
2057
-
ref: 'lex:io.pocketenv.secret.defs#secretView',
2056
+
type: "ref",
2057
+
ref: "lex:io.pocketenv.secret.defs#secretView",
2058
2058
},
2059
2059
},
2060
2060
total: {
2061
-
type: 'integer',
2062
-
description: 'The total number of secrets available.',
2061
+
type: "integer",
2062
+
description: "The total number of secrets available.",
2063
2063
minimum: 0,
2064
2064
},
2065
2065
},
···
2070
2070
},
2071
2071
IoPocketenvSecretUpdateSecret: {
2072
2072
lexicon: 1,
2073
-
id: 'io.pocketenv.secret.updateSecret',
2073
+
id: "io.pocketenv.secret.updateSecret",
2074
2074
defs: {
2075
2075
main: {
2076
-
type: 'procedure',
2076
+
type: "procedure",
2077
2077
input: {
2078
-
encoding: 'application/json',
2078
+
encoding: "application/json",
2079
2079
schema: {
2080
-
type: 'object',
2081
-
required: ['id', 'secret'],
2080
+
type: "object",
2081
+
required: ["id", "secret"],
2082
2082
properties: {
2083
2083
id: {
2084
-
type: 'string',
2085
-
description: 'The ID of the secret to update.',
2084
+
type: "string",
2085
+
description: "The ID of the secret to update.",
2086
2086
},
2087
2087
secret: {
2088
-
type: 'ref',
2089
-
ref: 'lex:io.pocketenv.secret.defs#secret',
2088
+
type: "ref",
2089
+
ref: "lex:io.pocketenv.secret.defs#secret",
2090
2090
},
2091
2091
redacted: {
2092
-
type: 'string',
2093
-
description: 'The redacted secret value.',
2092
+
type: "string",
2093
+
description: "The redacted secret value.",
2094
+
},
2095
+
},
2096
+
},
2097
+
},
2098
+
},
2099
+
},
2100
+
},
2101
+
IoPocketenvServiceAddService: {
2102
+
lexicon: 1,
2103
+
id: "io.pocketenv.service.addService",
2104
+
defs: {
2105
+
main: {
2106
+
type: "procedure",
2107
+
input: {
2108
+
encoding: "application/json",
2109
+
schema: {
2110
+
type: "object",
2111
+
required: ["service"],
2112
+
properties: {
2113
+
service: {
2114
+
type: "ref",
2115
+
ref: "lex:io.pocketenv.service.defs#service",
2116
+
},
2117
+
},
2118
+
},
2119
+
},
2120
+
},
2121
+
},
2122
+
},
2123
+
IoPocketenvServiceDefs: {
2124
+
lexicon: 1,
2125
+
id: "io.pocketenv.service.defs",
2126
+
defs: {
2127
+
serviceView: {
2128
+
type: "object",
2129
+
properties: {
2130
+
id: {
2131
+
type: "string",
2132
+
description: "Unique identifier of the service.",
2133
+
},
2134
+
name: {
2135
+
type: "string",
2136
+
description: "Name of the service.",
2137
+
},
2138
+
command: {
2139
+
type: "string",
2140
+
description: "Command to run the service.",
2141
+
},
2142
+
description: {
2143
+
type: "string",
2144
+
description: "Description of the service.",
2145
+
},
2146
+
ports: {
2147
+
type: "array",
2148
+
items: {
2149
+
type: "integer",
2150
+
},
2151
+
},
2152
+
createdAt: {
2153
+
type: "string",
2154
+
format: "datetime",
2155
+
},
2156
+
updatedAt: {
2157
+
type: "string",
2158
+
format: "datetime",
2159
+
},
2160
+
},
2161
+
},
2162
+
service: {
2163
+
type: "object",
2164
+
required: ["name", "command"],
2165
+
properties: {
2166
+
name: {
2167
+
type: "string",
2168
+
description: "Name of the service.",
2169
+
},
2170
+
command: {
2171
+
type: "string",
2172
+
description: "Command to run the service.",
2173
+
},
2174
+
description: {
2175
+
type: "string",
2176
+
description: "Description of the service.",
2177
+
},
2178
+
ports: {
2179
+
type: "array",
2180
+
items: {
2181
+
type: "integer",
2182
+
},
2183
+
},
2184
+
},
2185
+
},
2186
+
},
2187
+
},
2188
+
IoPocketenvServiceDeleteService: {
2189
+
lexicon: 1,
2190
+
id: "io.pocketenv.service.deleteService",
2191
+
defs: {
2192
+
main: {
2193
+
type: "procedure",
2194
+
parameters: {
2195
+
type: "params",
2196
+
required: ["serviceId"],
2197
+
properties: {
2198
+
serviceId: {
2199
+
type: "string",
2200
+
description: "The ID of the service to delete.",
2201
+
},
2202
+
},
2203
+
},
2204
+
},
2205
+
},
2206
+
},
2207
+
IoPocketenvServiceGetServices: {
2208
+
lexicon: 1,
2209
+
id: "io.pocketenv.service.getServices",
2210
+
defs: {
2211
+
main: {
2212
+
type: "query",
2213
+
parameters: {
2214
+
type: "params",
2215
+
required: ["sandboxId"],
2216
+
properties: {
2217
+
sandboxId: {
2218
+
type: "string",
2219
+
description:
2220
+
"The ID of the sandbox for which to retrieve services.",
2221
+
},
2222
+
},
2223
+
},
2224
+
output: {
2225
+
encoding: "application/json",
2226
+
schema: {
2227
+
type: "object",
2228
+
properties: {
2229
+
services: {
2230
+
type: "array",
2231
+
items: {
2232
+
type: "ref",
2233
+
ref: "lex:io.pocketenv.service.defs#serviceView",
2234
+
},
2235
+
},
2236
+
},
2237
+
},
2238
+
},
2239
+
},
2240
+
},
2241
+
},
2242
+
IoPocketenvServiceRestartService: {
2243
+
lexicon: 1,
2244
+
id: "io.pocketenv.service.restartService",
2245
+
defs: {
2246
+
main: {
2247
+
type: "procedure",
2248
+
parameters: {
2249
+
type: "params",
2250
+
required: ["serviceId"],
2251
+
properties: {
2252
+
serviceId: {
2253
+
type: "string",
2254
+
description: "The ID of the service to restart.",
2255
+
},
2256
+
},
2257
+
},
2258
+
},
2259
+
},
2260
+
},
2261
+
IoPocketenvServiceUpdateService: {
2262
+
lexicon: 1,
2263
+
id: "io.pocketenv.service.updateService",
2264
+
defs: {
2265
+
main: {
2266
+
type: "procedure",
2267
+
parameters: {
2268
+
type: "params",
2269
+
required: ["serviceId"],
2270
+
properties: {
2271
+
serviceId: {
2272
+
type: "string",
2273
+
description: "The ID of the service to delete.",
2274
+
},
2275
+
},
2276
+
},
2277
+
input: {
2278
+
encoding: "application/json",
2279
+
schema: {
2280
+
type: "object",
2281
+
required: ["service"],
2282
+
properties: {
2283
+
service: {
2284
+
type: "ref",
2285
+
ref: "lex:io.pocketenv.service.defs#service",
2094
2286
},
2095
2287
},
2096
2288
},
···
2100
2292
},
2101
2293
IoPocketenvVariableAddVariable: {
2102
2294
lexicon: 1,
2103
-
id: 'io.pocketenv.variable.addVariable',
2295
+
id: "io.pocketenv.variable.addVariable",
2104
2296
defs: {
2105
2297
main: {
2106
-
type: 'procedure',
2298
+
type: "procedure",
2107
2299
input: {
2108
-
encoding: 'application/json',
2300
+
encoding: "application/json",
2109
2301
schema: {
2110
-
type: 'object',
2111
-
required: ['variable'],
2302
+
type: "object",
2303
+
required: ["variable"],
2112
2304
properties: {
2113
2305
variable: {
2114
-
type: 'ref',
2115
-
ref: 'lex:io.pocketenv.variable.defs#variable',
2306
+
type: "ref",
2307
+
ref: "lex:io.pocketenv.variable.defs#variable",
2116
2308
},
2117
2309
},
2118
2310
},
···
2122
2314
},
2123
2315
IoPocketenvVariableDefs: {
2124
2316
lexicon: 1,
2125
-
id: 'io.pocketenv.variable.defs',
2317
+
id: "io.pocketenv.variable.defs",
2126
2318
defs: {
2127
2319
variableView: {
2128
-
type: 'object',
2320
+
type: "object",
2129
2321
properties: {
2130
2322
id: {
2131
-
type: 'string',
2132
-
description: 'Unique identifier of the environment variable.',
2323
+
type: "string",
2324
+
description: "Unique identifier of the environment variable.",
2133
2325
},
2134
2326
name: {
2135
-
type: 'string',
2327
+
type: "string",
2136
2328
description:
2137
2329
"Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc.",
2138
2330
},
2139
2331
value: {
2140
-
type: 'string',
2332
+
type: "string",
2141
2333
description:
2142
-
'Value of the environment variable. This will be visible in API responses and should not contain sensitive information.',
2334
+
"Value of the environment variable. This will be visible in API responses and should not contain sensitive information.",
2143
2335
},
2144
2336
},
2145
2337
},
2146
2338
variable: {
2147
-
type: 'object',
2148
-
required: ['name', 'value'],
2339
+
type: "object",
2340
+
required: ["name", "value"],
2149
2341
properties: {
2150
2342
sandboxId: {
2151
-
type: 'string',
2343
+
type: "string",
2152
2344
description:
2153
-
'The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment.',
2345
+
"The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment.",
2154
2346
},
2155
2347
name: {
2156
-
type: 'string',
2348
+
type: "string",
2157
2349
description:
2158
2350
"Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc.",
2159
2351
},
2160
2352
value: {
2161
-
type: 'string',
2353
+
type: "string",
2162
2354
description:
2163
-
'Value of the environment variable. This will be visible in API responses and should not contain sensitive information.',
2355
+
"Value of the environment variable. This will be visible in API responses and should not contain sensitive information.",
2164
2356
},
2165
2357
},
2166
2358
},
2167
2359
variables: {
2168
-
type: 'array',
2360
+
type: "array",
2169
2361
items: {
2170
-
type: 'ref',
2171
-
description: 'An environment variable to add to the sandbox',
2172
-
ref: 'lex:io.pocketenv.variable.defs#envVar',
2362
+
type: "ref",
2363
+
description: "An environment variable to add to the sandbox",
2364
+
ref: "lex:io.pocketenv.variable.defs#envVar",
2173
2365
},
2174
2366
},
2175
2367
},
2176
2368
},
2177
2369
IoPocketenvVariableDeleteVariable: {
2178
2370
lexicon: 1,
2179
-
id: 'io.pocketenv.variable.deleteVariable',
2371
+
id: "io.pocketenv.variable.deleteVariable",
2180
2372
defs: {
2181
2373
main: {
2182
-
type: 'procedure',
2374
+
type: "procedure",
2183
2375
parameters: {
2184
-
type: 'params',
2185
-
required: ['id'],
2376
+
type: "params",
2377
+
required: ["id"],
2186
2378
properties: {
2187
2379
id: {
2188
-
type: 'string',
2189
-
description: 'The ID of the environment variable to delete',
2380
+
type: "string",
2381
+
description: "The ID of the environment variable to delete",
2190
2382
},
2191
2383
},
2192
2384
},
···
2195
2387
},
2196
2388
IoPocketenvVariableGetVariable: {
2197
2389
lexicon: 1,
2198
-
id: 'io.pocketenv.variable.getVariable',
2390
+
id: "io.pocketenv.variable.getVariable",
2199
2391
defs: {
2200
2392
main: {
2201
-
type: 'query',
2393
+
type: "query",
2202
2394
parameters: {
2203
-
type: 'params',
2204
-
required: ['id'],
2395
+
type: "params",
2396
+
required: ["id"],
2205
2397
properties: {
2206
2398
id: {
2207
-
type: 'string',
2399
+
type: "string",
2208
2400
description:
2209
-
'The ID of the variable for which to retrieve variables.',
2401
+
"The ID of the variable for which to retrieve variables.",
2210
2402
},
2211
2403
},
2212
2404
},
2213
2405
output: {
2214
-
encoding: 'application/json',
2406
+
encoding: "application/json",
2215
2407
schema: {
2216
-
type: 'object',
2408
+
type: "object",
2217
2409
properties: {
2218
2410
variable: {
2219
-
type: 'ref',
2220
-
ref: 'lex:io.pocketenv.variable.defs#variableView',
2411
+
type: "ref",
2412
+
ref: "lex:io.pocketenv.variable.defs#variableView",
2221
2413
},
2222
2414
},
2223
2415
},
···
2227
2419
},
2228
2420
IoPocketenvVariableGetVariables: {
2229
2421
lexicon: 1,
2230
-
id: 'io.pocketenv.variable.getVariables',
2422
+
id: "io.pocketenv.variable.getVariables",
2231
2423
defs: {
2232
2424
main: {
2233
-
type: 'query',
2425
+
type: "query",
2234
2426
parameters: {
2235
-
type: 'params',
2427
+
type: "params",
2236
2428
properties: {
2237
2429
sandboxId: {
2238
-
type: 'string',
2430
+
type: "string",
2239
2431
description:
2240
-
'The ID of the sandbox for which to retrieve variables.',
2432
+
"The ID of the sandbox for which to retrieve variables.",
2241
2433
},
2242
2434
limit: {
2243
-
type: 'integer',
2244
-
description: 'The maximum number of variables to return.',
2435
+
type: "integer",
2436
+
description: "The maximum number of variables to return.",
2245
2437
minimum: 1,
2246
2438
},
2247
2439
offset: {
2248
-
type: 'integer',
2440
+
type: "integer",
2249
2441
description:
2250
-
'The number of variables to skip before starting to collect the result set.',
2442
+
"The number of variables to skip before starting to collect the result set.",
2251
2443
minimum: 0,
2252
2444
},
2253
2445
},
2254
2446
},
2255
2447
output: {
2256
-
encoding: 'application/json',
2448
+
encoding: "application/json",
2257
2449
schema: {
2258
-
type: 'object',
2450
+
type: "object",
2259
2451
properties: {
2260
2452
variables: {
2261
-
type: 'array',
2453
+
type: "array",
2262
2454
items: {
2263
-
type: 'ref',
2264
-
ref: 'lex:io.pocketenv.variable.defs#variableView',
2455
+
type: "ref",
2456
+
ref: "lex:io.pocketenv.variable.defs#variableView",
2265
2457
},
2266
2458
},
2267
2459
total: {
2268
-
type: 'integer',
2269
-
description: 'The total number of variables available.',
2460
+
type: "integer",
2461
+
description: "The total number of variables available.",
2270
2462
minimum: 0,
2271
2463
},
2272
2464
},
···
2277
2469
},
2278
2470
IoPocketenvVariableUpdateVariable: {
2279
2471
lexicon: 1,
2280
-
id: 'io.pocketenv.variable.updateVariable',
2472
+
id: "io.pocketenv.variable.updateVariable",
2281
2473
defs: {
2282
2474
main: {
2283
-
type: 'procedure',
2475
+
type: "procedure",
2284
2476
input: {
2285
-
encoding: 'application/json',
2477
+
encoding: "application/json",
2286
2478
schema: {
2287
-
type: 'object',
2288
-
required: ['id', 'variable'],
2479
+
type: "object",
2480
+
required: ["id", "variable"],
2289
2481
properties: {
2290
2482
id: {
2291
-
type: 'string',
2292
-
description: 'The ID of the variable to update.',
2483
+
type: "string",
2484
+
description: "The ID of the variable to update.",
2293
2485
},
2294
2486
variable: {
2295
-
type: 'ref',
2296
-
ref: 'lex:io.pocketenv.variable.defs#variable',
2487
+
type: "ref",
2488
+
ref: "lex:io.pocketenv.variable.defs#variable",
2297
2489
},
2298
2490
},
2299
2491
},
···
2303
2495
},
2304
2496
IoPocketenvVolumeAddVolume: {
2305
2497
lexicon: 1,
2306
-
id: 'io.pocketenv.volume.addVolume',
2498
+
id: "io.pocketenv.volume.addVolume",
2307
2499
defs: {
2308
2500
main: {
2309
-
type: 'procedure',
2501
+
type: "procedure",
2310
2502
input: {
2311
-
encoding: 'application/json',
2503
+
encoding: "application/json",
2312
2504
schema: {
2313
-
type: 'object',
2314
-
required: ['volume'],
2505
+
type: "object",
2506
+
required: ["volume"],
2315
2507
properties: {
2316
2508
volume: {
2317
-
type: 'ref',
2318
-
ref: 'lex:io.pocketenv.volume.defs#volume',
2509
+
type: "ref",
2510
+
ref: "lex:io.pocketenv.volume.defs#volume",
2319
2511
},
2320
2512
},
2321
2513
},
···
2325
2517
},
2326
2518
IoPocketenvVolumeDefs: {
2327
2519
lexicon: 1,
2328
-
id: 'io.pocketenv.volume.defs',
2520
+
id: "io.pocketenv.volume.defs",
2329
2521
defs: {
2330
2522
volumeView: {
2331
-
type: 'object',
2523
+
type: "object",
2332
2524
properties: {
2333
2525
id: {
2334
-
type: 'string',
2335
-
description: 'Unique identifier of the volume.',
2526
+
type: "string",
2527
+
description: "Unique identifier of the volume.",
2336
2528
},
2337
2529
name: {
2338
-
type: 'string',
2530
+
type: "string",
2339
2531
description: "Name of the volume, e.g. 'data-volume', 'logs', etc.",
2340
2532
},
2341
2533
path: {
2342
-
type: 'string',
2534
+
type: "string",
2343
2535
description:
2344
2536
"The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc.",
2345
2537
},
2346
2538
readOnly: {
2347
-
type: 'boolean',
2539
+
type: "boolean",
2348
2540
description:
2349
-
'Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).',
2541
+
"Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).",
2350
2542
},
2351
2543
createdAt: {
2352
-
type: 'string',
2353
-
description: 'The timestamp when the volume was created.',
2354
-
format: 'datetime',
2544
+
type: "string",
2545
+
description: "The timestamp when the volume was created.",
2546
+
format: "datetime",
2355
2547
},
2356
2548
updatedAt: {
2357
-
type: 'string',
2358
-
description: 'The timestamp when the volume was last updated.',
2359
-
format: 'datetime',
2549
+
type: "string",
2550
+
description: "The timestamp when the volume was last updated.",
2551
+
format: "datetime",
2360
2552
},
2361
2553
},
2362
2554
},
2363
2555
volumes: {
2364
-
type: 'array',
2556
+
type: "array",
2365
2557
items: {
2366
-
type: 'ref',
2367
-
description: 'A volume to add to the sandbox',
2368
-
ref: 'lex:io.pocketenv.volume.defs#volume',
2558
+
type: "ref",
2559
+
description: "A volume to add to the sandbox",
2560
+
ref: "lex:io.pocketenv.volume.defs#volume",
2369
2561
},
2370
2562
},
2371
2563
volume: {
2372
-
type: 'object',
2373
-
required: ['name'],
2564
+
type: "object",
2565
+
required: ["name"],
2374
2566
properties: {
2375
2567
sandboxId: {
2376
-
type: 'string',
2568
+
type: "string",
2377
2569
description:
2378
-
'The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment.',
2570
+
"The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment.",
2379
2571
},
2380
2572
name: {
2381
-
type: 'string',
2573
+
type: "string",
2382
2574
description: "Name of the volume, e.g. 'data-volume', 'logs', etc.",
2383
2575
},
2384
2576
path: {
2385
-
type: 'string',
2577
+
type: "string",
2386
2578
description:
2387
2579
"The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc.",
2388
2580
},
2389
2581
readOnly: {
2390
-
type: 'boolean',
2582
+
type: "boolean",
2391
2583
description:
2392
-
'Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).',
2584
+
"Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).",
2393
2585
},
2394
2586
},
2395
2587
},
···
2397
2589
},
2398
2590
IoPocketenvVolumeDeleteVolume: {
2399
2591
lexicon: 1,
2400
-
id: 'io.pocketenv.volume.deleteVolume',
2592
+
id: "io.pocketenv.volume.deleteVolume",
2401
2593
defs: {
2402
2594
main: {
2403
-
type: 'procedure',
2595
+
type: "procedure",
2404
2596
parameters: {
2405
-
type: 'params',
2406
-
required: ['id'],
2597
+
type: "params",
2598
+
required: ["id"],
2407
2599
properties: {
2408
2600
id: {
2409
-
type: 'string',
2410
-
description: 'The ID of the volume to delete.',
2601
+
type: "string",
2602
+
description: "The ID of the volume to delete.",
2411
2603
},
2412
2604
},
2413
2605
},
···
2416
2608
},
2417
2609
IoPocketenvVolumeGetVolume: {
2418
2610
lexicon: 1,
2419
-
id: 'io.pocketenv.volume.getVolume',
2611
+
id: "io.pocketenv.volume.getVolume",
2420
2612
defs: {
2421
2613
main: {
2422
-
type: 'query',
2614
+
type: "query",
2423
2615
parameters: {
2424
-
type: 'params',
2425
-
required: ['id'],
2616
+
type: "params",
2617
+
required: ["id"],
2426
2618
properties: {
2427
2619
id: {
2428
-
type: 'string',
2620
+
type: "string",
2429
2621
description:
2430
-
'The ID of the volume for which to retrieve volumes.',
2622
+
"The ID of the volume for which to retrieve volumes.",
2431
2623
},
2432
2624
},
2433
2625
},
2434
2626
output: {
2435
-
encoding: 'application/json',
2627
+
encoding: "application/json",
2436
2628
schema: {
2437
-
type: 'object',
2629
+
type: "object",
2438
2630
properties: {
2439
2631
volume: {
2440
-
type: 'ref',
2441
-
ref: 'lex:io.pocketenv.volume.defs#volumeView',
2632
+
type: "ref",
2633
+
ref: "lex:io.pocketenv.volume.defs#volumeView",
2442
2634
},
2443
2635
},
2444
2636
},
···
2448
2640
},
2449
2641
IoPocketenvVolumeGetVolumes: {
2450
2642
lexicon: 1,
2451
-
id: 'io.pocketenv.volume.getVolumes',
2643
+
id: "io.pocketenv.volume.getVolumes",
2452
2644
defs: {
2453
2645
main: {
2454
-
type: 'query',
2646
+
type: "query",
2455
2647
parameters: {
2456
-
type: 'params',
2648
+
type: "params",
2457
2649
properties: {
2458
2650
sandboxId: {
2459
-
type: 'string',
2651
+
type: "string",
2460
2652
description:
2461
-
'The ID of the sandbox for which to retrieve volumes.',
2653
+
"The ID of the sandbox for which to retrieve volumes.",
2462
2654
},
2463
2655
limit: {
2464
-
type: 'integer',
2465
-
description: 'The maximum number of volumes to return.',
2656
+
type: "integer",
2657
+
description: "The maximum number of volumes to return.",
2466
2658
minimum: 1,
2467
2659
},
2468
2660
offset: {
2469
-
type: 'integer',
2661
+
type: "integer",
2470
2662
description:
2471
-
'The number of volumes to skip before starting to collect the result set.',
2663
+
"The number of volumes to skip before starting to collect the result set.",
2472
2664
minimum: 0,
2473
2665
},
2474
2666
},
2475
2667
},
2476
2668
output: {
2477
-
encoding: 'application/json',
2669
+
encoding: "application/json",
2478
2670
schema: {
2479
-
type: 'object',
2671
+
type: "object",
2480
2672
properties: {
2481
2673
volumes: {
2482
-
type: 'array',
2674
+
type: "array",
2483
2675
items: {
2484
-
type: 'ref',
2485
-
ref: 'lex:io.pocketenv.volume.defs#volumeView',
2676
+
type: "ref",
2677
+
ref: "lex:io.pocketenv.volume.defs#volumeView",
2486
2678
},
2487
2679
},
2488
2680
total: {
2489
-
type: 'integer',
2490
-
description: 'The total number of volumes available.',
2681
+
type: "integer",
2682
+
description: "The total number of volumes available.",
2491
2683
minimum: 0,
2492
2684
},
2493
2685
},
···
2498
2690
},
2499
2691
IoPocketenvVolumeUpdateVolume: {
2500
2692
lexicon: 1,
2501
-
id: 'io.pocketenv.volume.updateVolume',
2693
+
id: "io.pocketenv.volume.updateVolume",
2502
2694
defs: {
2503
2695
main: {
2504
-
type: 'procedure',
2696
+
type: "procedure",
2505
2697
input: {
2506
-
encoding: 'application/json',
2698
+
encoding: "application/json",
2507
2699
schema: {
2508
-
type: 'object',
2509
-
required: ['id', 'volume'],
2700
+
type: "object",
2701
+
required: ["id", "volume"],
2510
2702
properties: {
2511
2703
id: {
2512
-
type: 'string',
2513
-
description: 'The ID of the volume to update.',
2704
+
type: "string",
2705
+
description: "The ID of the volume to update.",
2514
2706
},
2515
2707
volume: {
2516
-
type: 'ref',
2517
-
ref: 'lex:io.pocketenv.volume.defs#volume',
2708
+
type: "ref",
2709
+
ref: "lex:io.pocketenv.volume.defs#volume",
2518
2710
},
2519
2711
},
2520
2712
},
···
2524
2716
},
2525
2717
IoPocketenvPublicKey: {
2526
2718
lexicon: 1,
2527
-
id: 'io.pocketenv.publicKey',
2719
+
id: "io.pocketenv.publicKey",
2528
2720
defs: {
2529
2721
main: {
2530
-
type: 'record',
2531
-
key: 'tid',
2722
+
type: "record",
2723
+
key: "tid",
2532
2724
record: {
2533
-
type: 'object',
2534
-
required: ['name', 'key', 'createdAt'],
2725
+
type: "object",
2726
+
required: ["name", "key", "createdAt"],
2535
2727
properties: {
2536
2728
name: {
2537
-
type: 'string',
2538
-
description: 'Name of the public key',
2729
+
type: "string",
2730
+
description: "Name of the public key",
2539
2731
maxLength: 255,
2540
2732
},
2541
2733
key: {
2542
-
type: 'string',
2734
+
type: "string",
2543
2735
description:
2544
-
'The public key value, e.g. an SSH public key string.',
2736
+
"The public key value, e.g. an SSH public key string.",
2545
2737
},
2546
2738
createdAt: {
2547
-
type: 'string',
2548
-
format: 'datetime',
2739
+
type: "string",
2740
+
format: "datetime",
2549
2741
},
2550
2742
},
2551
2743
},
···
2554
2746
},
2555
2747
ComAtprotoRepoStrongRef: {
2556
2748
lexicon: 1,
2557
-
id: 'com.atproto.repo.strongRef',
2558
-
description: 'A URI with a content-hash fingerprint.',
2749
+
id: "com.atproto.repo.strongRef",
2750
+
description: "A URI with a content-hash fingerprint.",
2559
2751
defs: {
2560
2752
main: {
2561
-
type: 'object',
2562
-
required: ['uri', 'cid'],
2753
+
type: "object",
2754
+
required: ["uri", "cid"],
2563
2755
properties: {
2564
2756
uri: {
2565
-
type: 'string',
2566
-
format: 'at-uri',
2757
+
type: "string",
2758
+
format: "at-uri",
2567
2759
},
2568
2760
cid: {
2569
-
type: 'string',
2570
-
format: 'cid',
2761
+
type: "string",
2762
+
format: "cid",
2571
2763
},
2572
2764
},
2573
2765
},
2574
2766
},
2575
2767
},
2576
-
} as const satisfies Record<string, LexiconDoc>
2768
+
} as const satisfies Record<string, LexiconDoc>;
2577
2769
2578
-
export const schemas = Object.values(schemaDict)
2579
-
export const lexicons: Lexicons = new Lexicons(schemas)
2770
+
export const schemas = Object.values(schemaDict);
2771
+
export const lexicons: Lexicons = new Lexicons(schemas);
2580
2772
export const ids = {
2581
-
IoPocketenvActorDefs: 'io.pocketenv.actor.defs',
2582
-
IoPocketenvActorGetActorSandboxes: 'io.pocketenv.actor.getActorSandboxes',
2583
-
IoPocketenvActorGetProfile: 'io.pocketenv.actor.getProfile',
2584
-
IoPocketenvActorGetTerminalToken: 'io.pocketenv.actor.getTerminalToken',
2585
-
AppBskyActorProfile: 'app.bsky.actor.profile',
2586
-
IoPocketenvFileAddFile: 'io.pocketenv.file.addFile',
2587
-
IoPocketenvFileDefs: 'io.pocketenv.file.defs',
2588
-
IoPocketenvFileDeleteFile: 'io.pocketenv.file.deleteFile',
2589
-
IoPocketenvFileGetFile: 'io.pocketenv.file.getFile',
2590
-
IoPocketenvFileGetFiles: 'io.pocketenv.file.getFiles',
2591
-
IoPocketenvFileUpdateFile: 'io.pocketenv.file.updateFile',
2592
-
IoPocketenvPortDefs: 'io.pocketenv.port.defs',
2593
-
IoPocketenvSandboxClaimSandbox: 'io.pocketenv.sandbox.claimSandbox',
2594
-
IoPocketenvSandboxCreateIntegration: 'io.pocketenv.sandbox.createIntegration',
2595
-
IoPocketenvSandboxCreateSandbox: 'io.pocketenv.sandbox.createSandbox',
2596
-
IoPocketenvSandboxDefs: 'io.pocketenv.sandbox.defs',
2597
-
IoPocketenvSandboxDeleteSandbox: 'io.pocketenv.sandbox.deleteSandbox',
2598
-
IoPocketenvSandboxExec: 'io.pocketenv.sandbox.exec',
2599
-
IoPocketenvSandboxExposePort: 'io.pocketenv.sandbox.exposePort',
2600
-
IoPocketenvSandboxExposeVscode: 'io.pocketenv.sandbox.exposeVscode',
2601
-
IoPocketenvSandboxGetExposedPorts: 'io.pocketenv.sandbox.getExposedPorts',
2602
-
IoPocketenvSandboxGetIntegrations: 'io.pocketenv.sandbox.getIntegrations',
2603
-
IoPocketenvSandboxGetPreferences: 'io.pocketenv.sandbox.getPreferences',
2604
-
IoPocketenvSandboxGetSandbox: 'io.pocketenv.sandbox.getSandbox',
2605
-
IoPocketenvSandboxGetSandboxes: 'io.pocketenv.sandbox.getSandboxes',
2606
-
IoPocketenvSandboxGetSshKeys: 'io.pocketenv.sandbox.getSshKeys',
2773
+
IoPocketenvActorDefs: "io.pocketenv.actor.defs",
2774
+
IoPocketenvActorGetActorSandboxes: "io.pocketenv.actor.getActorSandboxes",
2775
+
IoPocketenvActorGetProfile: "io.pocketenv.actor.getProfile",
2776
+
IoPocketenvActorGetTerminalToken: "io.pocketenv.actor.getTerminalToken",
2777
+
AppBskyActorProfile: "app.bsky.actor.profile",
2778
+
IoPocketenvFileAddFile: "io.pocketenv.file.addFile",
2779
+
IoPocketenvFileDefs: "io.pocketenv.file.defs",
2780
+
IoPocketenvFileDeleteFile: "io.pocketenv.file.deleteFile",
2781
+
IoPocketenvFileGetFile: "io.pocketenv.file.getFile",
2782
+
IoPocketenvFileGetFiles: "io.pocketenv.file.getFiles",
2783
+
IoPocketenvFileUpdateFile: "io.pocketenv.file.updateFile",
2784
+
IoPocketenvPortDefs: "io.pocketenv.port.defs",
2785
+
IoPocketenvSandboxClaimSandbox: "io.pocketenv.sandbox.claimSandbox",
2786
+
IoPocketenvSandboxCreateIntegration: "io.pocketenv.sandbox.createIntegration",
2787
+
IoPocketenvSandboxCreateSandbox: "io.pocketenv.sandbox.createSandbox",
2788
+
IoPocketenvSandboxDefs: "io.pocketenv.sandbox.defs",
2789
+
IoPocketenvSandboxDeleteSandbox: "io.pocketenv.sandbox.deleteSandbox",
2790
+
IoPocketenvSandboxExec: "io.pocketenv.sandbox.exec",
2791
+
IoPocketenvSandboxExposePort: "io.pocketenv.sandbox.exposePort",
2792
+
IoPocketenvSandboxExposeVscode: "io.pocketenv.sandbox.exposeVscode",
2793
+
IoPocketenvSandboxGetExposedPorts: "io.pocketenv.sandbox.getExposedPorts",
2794
+
IoPocketenvSandboxGetIntegrations: "io.pocketenv.sandbox.getIntegrations",
2795
+
IoPocketenvSandboxGetPreferences: "io.pocketenv.sandbox.getPreferences",
2796
+
IoPocketenvSandboxGetSandbox: "io.pocketenv.sandbox.getSandbox",
2797
+
IoPocketenvSandboxGetSandboxes: "io.pocketenv.sandbox.getSandboxes",
2798
+
IoPocketenvSandboxGetSshKeys: "io.pocketenv.sandbox.getSshKeys",
2607
2799
IoPocketenvSandboxGetTailscaleAuthKey:
2608
-
'io.pocketenv.sandbox.getTailscaleAuthKey',
2609
-
IoPocketenvSandboxGetTailscaleToken: 'io.pocketenv.sandbox.getTailscaleToken',
2610
-
IoPocketenvSandboxPutPreferences: 'io.pocketenv.sandbox.putPreferences',
2611
-
IoPocketenvSandboxPutSshKeys: 'io.pocketenv.sandbox.putSshKeys',
2800
+
"io.pocketenv.sandbox.getTailscaleAuthKey",
2801
+
IoPocketenvSandboxGetTailscaleToken: "io.pocketenv.sandbox.getTailscaleToken",
2802
+
IoPocketenvSandboxPutPreferences: "io.pocketenv.sandbox.putPreferences",
2803
+
IoPocketenvSandboxPutSshKeys: "io.pocketenv.sandbox.putSshKeys",
2612
2804
IoPocketenvSandboxPutTailscaleAuthKey:
2613
-
'io.pocketenv.sandbox.putTailscaleAuthKey',
2614
-
IoPocketenvSandboxPutTailscaleToken: 'io.pocketenv.sandbox.putTailscaleToken',
2615
-
IoPocketenvSandbox: 'io.pocketenv.sandbox',
2616
-
IoPocketenvSandboxStartSandbox: 'io.pocketenv.sandbox.startSandbox',
2617
-
IoPocketenvSandboxStopSandbox: 'io.pocketenv.sandbox.stopSandbox',
2618
-
IoPocketenvSandboxUnexposePort: 'io.pocketenv.sandbox.unexposePort',
2805
+
"io.pocketenv.sandbox.putTailscaleAuthKey",
2806
+
IoPocketenvSandboxPutTailscaleToken: "io.pocketenv.sandbox.putTailscaleToken",
2807
+
IoPocketenvSandbox: "io.pocketenv.sandbox",
2808
+
IoPocketenvSandboxStartSandbox: "io.pocketenv.sandbox.startSandbox",
2809
+
IoPocketenvSandboxStopSandbox: "io.pocketenv.sandbox.stopSandbox",
2810
+
IoPocketenvSandboxUnexposePort: "io.pocketenv.sandbox.unexposePort",
2619
2811
IoPocketenvSandboxUpdateSandboxSettings:
2620
-
'io.pocketenv.sandbox.updateSandboxSettings',
2621
-
IoPocketenvSecretAddSecret: 'io.pocketenv.secret.addSecret',
2622
-
IoPocketenvSecretDefs: 'io.pocketenv.secret.defs',
2623
-
IoPocketenvSecretDeleteSecret: 'io.pocketenv.secret.deleteSecret',
2624
-
IoPocketenvSecretGetSecret: 'io.pocketenv.secret.getSecret',
2625
-
IoPocketenvSecretGetSecrets: 'io.pocketenv.secret.getSecrets',
2626
-
IoPocketenvSecretUpdateSecret: 'io.pocketenv.secret.updateSecret',
2627
-
IoPocketenvVariableAddVariable: 'io.pocketenv.variable.addVariable',
2628
-
IoPocketenvVariableDefs: 'io.pocketenv.variable.defs',
2629
-
IoPocketenvVariableDeleteVariable: 'io.pocketenv.variable.deleteVariable',
2630
-
IoPocketenvVariableGetVariable: 'io.pocketenv.variable.getVariable',
2631
-
IoPocketenvVariableGetVariables: 'io.pocketenv.variable.getVariables',
2632
-
IoPocketenvVariableUpdateVariable: 'io.pocketenv.variable.updateVariable',
2633
-
IoPocketenvVolumeAddVolume: 'io.pocketenv.volume.addVolume',
2634
-
IoPocketenvVolumeDefs: 'io.pocketenv.volume.defs',
2635
-
IoPocketenvVolumeDeleteVolume: 'io.pocketenv.volume.deleteVolume',
2636
-
IoPocketenvVolumeGetVolume: 'io.pocketenv.volume.getVolume',
2637
-
IoPocketenvVolumeGetVolumes: 'io.pocketenv.volume.getVolumes',
2638
-
IoPocketenvVolumeUpdateVolume: 'io.pocketenv.volume.updateVolume',
2639
-
IoPocketenvPublicKey: 'io.pocketenv.publicKey',
2640
-
ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
2641
-
}
2812
+
"io.pocketenv.sandbox.updateSandboxSettings",
2813
+
IoPocketenvSecretAddSecret: "io.pocketenv.secret.addSecret",
2814
+
IoPocketenvSecretDefs: "io.pocketenv.secret.defs",
2815
+
IoPocketenvSecretDeleteSecret: "io.pocketenv.secret.deleteSecret",
2816
+
IoPocketenvSecretGetSecret: "io.pocketenv.secret.getSecret",
2817
+
IoPocketenvSecretGetSecrets: "io.pocketenv.secret.getSecrets",
2818
+
IoPocketenvSecretUpdateSecret: "io.pocketenv.secret.updateSecret",
2819
+
IoPocketenvServiceAddService: "io.pocketenv.service.addService",
2820
+
IoPocketenvServiceDefs: "io.pocketenv.service.defs",
2821
+
IoPocketenvServiceDeleteService: "io.pocketenv.service.deleteService",
2822
+
IoPocketenvServiceGetServices: "io.pocketenv.service.getServices",
2823
+
IoPocketenvServiceRestartService: "io.pocketenv.service.restartService",
2824
+
IoPocketenvServiceUpdateService: "io.pocketenv.service.updateService",
2825
+
IoPocketenvVariableAddVariable: "io.pocketenv.variable.addVariable",
2826
+
IoPocketenvVariableDefs: "io.pocketenv.variable.defs",
2827
+
IoPocketenvVariableDeleteVariable: "io.pocketenv.variable.deleteVariable",
2828
+
IoPocketenvVariableGetVariable: "io.pocketenv.variable.getVariable",
2829
+
IoPocketenvVariableGetVariables: "io.pocketenv.variable.getVariables",
2830
+
IoPocketenvVariableUpdateVariable: "io.pocketenv.variable.updateVariable",
2831
+
IoPocketenvVolumeAddVolume: "io.pocketenv.volume.addVolume",
2832
+
IoPocketenvVolumeDefs: "io.pocketenv.volume.defs",
2833
+
IoPocketenvVolumeDeleteVolume: "io.pocketenv.volume.deleteVolume",
2834
+
IoPocketenvVolumeGetVolume: "io.pocketenv.volume.getVolume",
2835
+
IoPocketenvVolumeGetVolumes: "io.pocketenv.volume.getVolumes",
2836
+
IoPocketenvVolumeUpdateVolume: "io.pocketenv.volume.updateVolume",
2837
+
IoPocketenvPublicKey: "io.pocketenv.publicKey",
2838
+
ComAtprotoRepoStrongRef: "com.atproto.repo.strongRef",
2839
+
};
+19
-19
apps/api/src/lexicon/types/app/bsky/actor/profile.ts
+19
-19
apps/api/src/lexicon/types/app/bsky/actor/profile.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type { ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
8
-
import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
9
-
import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
4
+
import type { ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
+
import type * as ComAtprotoLabelDefs from "../../../com/atproto/label/defs";
9
+
import type * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef";
10
10
11
11
export interface Record {
12
-
displayName?: string
12
+
displayName?: string;
13
13
/** Free-form profile description text. */
14
-
description?: string
14
+
description?: string;
15
15
/** Small image to be displayed next to posts from account. AKA, 'profile picture' */
16
-
avatar?: BlobRef
16
+
avatar?: BlobRef;
17
17
/** Larger horizontal image to display behind profile view. */
18
-
banner?: BlobRef
18
+
banner?: BlobRef;
19
19
labels?:
20
20
| ComAtprotoLabelDefs.SelfLabels
21
-
| { $type: string; [k: string]: unknown }
22
-
joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main
23
-
createdAt?: string
24
-
[k: string]: unknown
21
+
| { $type: string; [k: string]: unknown };
22
+
joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main;
23
+
createdAt?: string;
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
-
hasProp(v, '$type') &&
31
-
(v.$type === 'app.bsky.actor.profile#main' ||
32
-
v.$type === 'app.bsky.actor.profile')
33
-
)
30
+
hasProp(v, "$type") &&
31
+
(v.$type === "app.bsky.actor.profile#main" ||
32
+
v.$type === "app.bsky.actor.profile")
33
+
);
34
34
}
35
35
36
36
export function validateRecord(v: unknown): ValidationResult {
37
-
return lexicons.validate('app.bsky.actor.profile#main', v)
37
+
return lexicons.validate("app.bsky.actor.profile#main", v);
38
38
}
+12
-12
apps/api/src/lexicon/types/com/atproto/repo/strongRef.ts
+12
-12
apps/api/src/lexicon/types/com/atproto/repo/strongRef.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
8
9
9
export interface Main {
10
-
uri: string
11
-
cid: string
12
-
[k: string]: unknown
10
+
uri: string;
11
+
cid: string;
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
-
hasProp(v, '$type') &&
19
-
(v.$type === 'com.atproto.repo.strongRef#main' ||
20
-
v.$type === 'com.atproto.repo.strongRef')
21
-
)
18
+
hasProp(v, "$type") &&
19
+
(v.$type === "com.atproto.repo.strongRef#main" ||
20
+
v.$type === "com.atproto.repo.strongRef")
21
+
);
22
22
}
23
23
24
24
export function validateMain(v: unknown): ValidationResult {
25
-
return lexicons.validate('com.atproto.repo.strongRef#main', v)
25
+
return lexicons.validate("com.atproto.repo.strongRef#main", v);
26
26
}
+16
-16
apps/api/src/lexicon/types/io/pocketenv/actor/defs.ts
+16
-16
apps/api/src/lexicon/types/io/pocketenv/actor/defs.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
8
9
9
export interface ProfileViewDetailed {
10
10
/** The unique identifier of the actor. */
11
-
id?: string
11
+
id?: string;
12
12
/** The DID of the actor. */
13
-
did?: string
13
+
did?: string;
14
14
/** The handle of the actor. */
15
-
handle?: string
15
+
handle?: string;
16
16
/** The display name of the actor. */
17
-
displayName?: string
17
+
displayName?: string;
18
18
/** The URL of the actor's avatar image. */
19
-
avatar?: string
19
+
avatar?: string;
20
20
/** The date and time when the actor was created. */
21
-
createdAt?: string
21
+
createdAt?: string;
22
22
/** The date and time when the actor was last updated. */
23
-
updatedAt?: string
24
-
[k: string]: unknown
23
+
updatedAt?: string;
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
-
hasProp(v, '$type') &&
31
-
v.$type === 'io.pocketenv.actor.defs#profileViewDetailed'
32
-
)
30
+
hasProp(v, "$type") &&
31
+
v.$type === "io.pocketenv.actor.defs#profileViewDetailed"
32
+
);
33
33
}
34
34
35
35
export function validateProfileViewDetailed(v: unknown): ValidationResult {
36
-
return lexicons.validate('io.pocketenv.actor.defs#profileViewDetailed', v)
36
+
return lexicons.validate("io.pocketenv.actor.defs#profileViewDetailed", v);
37
37
}
+29
-29
apps/api/src/lexicon/types/io/pocketenv/actor/getActorSandboxes.ts
+29
-29
apps/api/src/lexicon/types/io/pocketenv/actor/getActorSandboxes.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from '../sandbox/defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
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
-
did: string
14
+
did: string;
15
15
/** The maximum number of sandboxes to return. */
16
-
limit?: number
16
+
limit?: number;
17
17
/** The number of sandboxes to skip before starting to collect the result set. */
18
-
offset?: number
18
+
offset?: number;
19
19
}
20
20
21
-
export type InputSchema = undefined
21
+
export type InputSchema = undefined;
22
22
23
23
export interface OutputSchema {
24
-
sandboxes?: IoPocketenvSandboxDefs.SandboxViewDetailed[]
24
+
sandboxes?: IoPocketenvSandboxDefs.SandboxViewDetailed[];
25
25
/** The total number of sandboxes available. */
26
-
total?: number
27
-
[k: string]: unknown
26
+
total?: number;
27
+
[k: string]: unknown;
28
28
}
29
29
30
-
export type HandlerInput = undefined
30
+
export type HandlerInput = undefined;
31
31
32
32
export interface HandlerSuccess {
33
-
encoding: 'application/json'
34
-
body: OutputSchema
35
-
headers?: { [key: string]: string }
33
+
encoding: "application/json";
34
+
body: OutputSchema;
35
+
headers?: { [key: string]: string };
36
36
}
37
37
38
38
export interface HandlerError {
39
-
status: number
40
-
message?: string
39
+
status: number;
40
+
message?: string;
41
41
}
42
42
43
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
43
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
44
44
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
45
-
auth: HA
46
-
params: QueryParams
47
-
input: HandlerInput
48
-
req: express.Request
49
-
res: express.Response
50
-
resetRouteRateLimits: () => Promise<void>
51
-
}
45
+
auth: HA;
46
+
params: QueryParams;
47
+
input: HandlerInput;
48
+
req: express.Request;
49
+
res: express.Response;
50
+
resetRouteRateLimits: () => Promise<void>;
51
+
};
52
52
export type Handler<HA extends HandlerAuth = never> = (
53
53
ctx: HandlerReqCtx<HA>,
54
-
) => Promise<HandlerOutput> | HandlerOutput
54
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/actor/getProfile.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/actor/getProfile.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvActorDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvActorDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The DID or handle of the actor */
14
-
did?: string
14
+
did?: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvActorDefs.ProfileViewDetailed
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvActorDefs.ProfileViewDetailed;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/actor/getTerminalToken.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/actor/getTerminalToken.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
10
11
-
export type QueryParams = {}
11
+
export type QueryParams = {};
12
12
13
-
export type InputSchema = undefined
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
-
token?: string
18
-
[k: string]: unknown
17
+
token?: string;
18
+
[k: string]: unknown;
19
19
}
20
20
21
-
export type HandlerInput = undefined
21
+
export type HandlerInput = undefined;
22
22
23
23
export interface HandlerSuccess {
24
-
encoding: 'application/json'
25
-
body: OutputSchema
26
-
headers?: { [key: string]: string }
24
+
encoding: "application/json";
25
+
body: OutputSchema;
26
+
headers?: { [key: string]: string };
27
27
}
28
28
29
29
export interface HandlerError {
30
-
status: number
31
-
message?: string
30
+
status: number;
31
+
message?: string;
32
32
}
33
33
34
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
34
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
35
35
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
36
-
auth: HA
37
-
params: QueryParams
38
-
input: HandlerInput
39
-
req: express.Request
40
-
res: express.Response
41
-
resetRouteRateLimits: () => Promise<void>
42
-
}
36
+
auth: HA;
37
+
params: QueryParams;
38
+
input: HandlerInput;
39
+
req: express.Request;
40
+
res: express.Response;
41
+
resetRouteRateLimits: () => Promise<void>;
42
+
};
43
43
export type Handler<HA extends HandlerAuth = never> = (
44
44
ctx: HandlerReqCtx<HA>,
45
-
) => Promise<HandlerOutput> | HandlerOutput
45
+
) => Promise<HandlerOutput> | HandlerOutput;
+23
-23
apps/api/src/lexicon/types/io/pocketenv/file/addFile.ts
+23
-23
apps/api/src/lexicon/types/io/pocketenv/file/addFile.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvFileDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvFileDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
-
file: IoPocketenvFileDefs.File
16
-
[k: string]: unknown
15
+
file: IoPocketenvFileDefs.File;
16
+
[k: string]: unknown;
17
17
}
18
18
19
19
export interface HandlerInput {
20
-
encoding: 'application/json'
21
-
body: InputSchema
20
+
encoding: "application/json";
21
+
body: InputSchema;
22
22
}
23
23
24
24
export interface HandlerError {
25
-
status: number
26
-
message?: string
25
+
status: number;
26
+
message?: string;
27
27
}
28
28
29
-
export type HandlerOutput = HandlerError | void
29
+
export type HandlerOutput = HandlerError | void;
30
30
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
31
-
auth: HA
32
-
params: QueryParams
33
-
input: HandlerInput
34
-
req: express.Request
35
-
res: express.Response
36
-
resetRouteRateLimits: () => Promise<void>
37
-
}
31
+
auth: HA;
32
+
params: QueryParams;
33
+
input: HandlerInput;
34
+
req: express.Request;
35
+
res: express.Response;
36
+
resetRouteRateLimits: () => Promise<void>;
37
+
};
38
38
export type Handler<HA extends HandlerAuth = never> = (
39
39
ctx: HandlerReqCtx<HA>,
40
-
) => Promise<HandlerOutput> | HandlerOutput
40
+
) => Promise<HandlerOutput> | HandlerOutput;
+21
-21
apps/api/src/lexicon/types/io/pocketenv/file/defs.ts
+21
-21
apps/api/src/lexicon/types/io/pocketenv/file/defs.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
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
-
sandboxId?: string
11
+
sandboxId?: string;
12
12
/** The file path within the sandbox, e.g. '/app/config.json', '/home/user/.ssh/id_rsa', etc. */
13
-
path: string
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
-
content: string
16
-
[k: string]: unknown
15
+
content: string;
16
+
[k: string]: unknown;
17
17
}
18
18
19
19
export function isFile(v: unknown): v is File {
20
20
return (
21
-
isObj(v) && hasProp(v, '$type') && v.$type === 'io.pocketenv.file.defs#file'
22
-
)
21
+
isObj(v) && hasProp(v, "$type") && v.$type === "io.pocketenv.file.defs#file"
22
+
);
23
23
}
24
24
25
25
export function validateFile(v: unknown): ValidationResult {
26
-
return lexicons.validate('io.pocketenv.file.defs#file', v)
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
-
id?: string
31
+
id?: string;
32
32
/** The file path within the sandbox, e.g. '/app/config.json', '/home/user/.ssh/id_rsa', etc. */
33
-
path?: string
33
+
path?: string;
34
34
/** The timestamp when the file was created. */
35
-
createdAt?: string
35
+
createdAt?: string;
36
36
/** The timestamp when the file was last updated. */
37
-
updatedAt?: string
38
-
[k: string]: unknown
37
+
updatedAt?: string;
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
-
hasProp(v, '$type') &&
45
-
v.$type === 'io.pocketenv.file.defs#fileView'
46
-
)
44
+
hasProp(v, "$type") &&
45
+
v.$type === "io.pocketenv.file.defs#fileView"
46
+
);
47
47
}
48
48
49
49
export function validateFileView(v: unknown): ValidationResult {
50
-
return lexicons.validate('io.pocketenv.file.defs#fileView', v)
50
+
return lexicons.validate("io.pocketenv.file.defs#fileView", v);
51
51
}
52
52
53
-
export type Files = File[]
53
+
export type Files = File[];
+20
-20
apps/api/src/lexicon/types/io/pocketenv/file/deleteFile.ts
+20
-20
apps/api/src/lexicon/types/io/pocketenv/file/deleteFile.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
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
-
id: string
13
+
id: string;
14
14
}
15
15
16
-
export type InputSchema = undefined
17
-
export type HandlerInput = undefined
16
+
export type InputSchema = undefined;
17
+
export type HandlerInput = undefined;
18
18
19
19
export interface HandlerError {
20
-
status: number
21
-
message?: string
20
+
status: number;
21
+
message?: string;
22
22
}
23
23
24
-
export type HandlerOutput = HandlerError | void
24
+
export type HandlerOutput = HandlerError | void;
25
25
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
-
auth: HA
27
-
params: QueryParams
28
-
input: HandlerInput
29
-
req: express.Request
30
-
res: express.Response
31
-
resetRouteRateLimits: () => Promise<void>
32
-
}
26
+
auth: HA;
27
+
params: QueryParams;
28
+
input: HandlerInput;
29
+
req: express.Request;
30
+
res: express.Response;
31
+
resetRouteRateLimits: () => Promise<void>;
32
+
};
33
33
export type Handler<HA extends HandlerAuth = never> = (
34
34
ctx: HandlerReqCtx<HA>,
35
-
) => Promise<HandlerOutput> | HandlerOutput
35
+
) => Promise<HandlerOutput> | HandlerOutput;
+26
-26
apps/api/src/lexicon/types/io/pocketenv/file/getFile.ts
+26
-26
apps/api/src/lexicon/types/io/pocketenv/file/getFile.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvFileDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvFileDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The ID of the file to retrieve. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
17
+
export type InputSchema = undefined;
18
18
19
19
export interface OutputSchema {
20
-
file?: IoPocketenvFileDefs.FileView
21
-
[k: string]: unknown
20
+
file?: IoPocketenvFileDefs.FileView;
21
+
[k: string]: unknown;
22
22
}
23
23
24
-
export type HandlerInput = undefined
24
+
export type HandlerInput = undefined;
25
25
26
26
export interface HandlerSuccess {
27
-
encoding: 'application/json'
28
-
body: OutputSchema
29
-
headers?: { [key: string]: string }
27
+
encoding: "application/json";
28
+
body: OutputSchema;
29
+
headers?: { [key: string]: string };
30
30
}
31
31
32
32
export interface HandlerError {
33
-
status: number
34
-
message?: string
33
+
status: number;
34
+
message?: string;
35
35
}
36
36
37
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
38
38
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
-
auth: HA
40
-
params: QueryParams
41
-
input: HandlerInput
42
-
req: express.Request
43
-
res: express.Response
44
-
resetRouteRateLimits: () => Promise<void>
45
-
}
39
+
auth: HA;
40
+
params: QueryParams;
41
+
input: HandlerInput;
42
+
req: express.Request;
43
+
res: express.Response;
44
+
resetRouteRateLimits: () => Promise<void>;
45
+
};
46
46
export type Handler<HA extends HandlerAuth = never> = (
47
47
ctx: HandlerReqCtx<HA>,
48
-
) => Promise<HandlerOutput> | HandlerOutput
48
+
) => Promise<HandlerOutput> | HandlerOutput;
+29
-29
apps/api/src/lexicon/types/io/pocketenv/file/getFiles.ts
+29
-29
apps/api/src/lexicon/types/io/pocketenv/file/getFiles.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvFileDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
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
-
sandboxId?: string
14
+
sandboxId?: string;
15
15
/** The maximum number of files to return. */
16
-
limit?: number
16
+
limit?: number;
17
17
/** The number of files to skip before starting to collect the result set. */
18
-
offset?: number
18
+
offset?: number;
19
19
}
20
20
21
-
export type InputSchema = undefined
21
+
export type InputSchema = undefined;
22
22
23
23
export interface OutputSchema {
24
-
files?: IoPocketenvFileDefs.FileView[]
24
+
files?: IoPocketenvFileDefs.FileView[];
25
25
/** The total number of files available. */
26
-
total?: number
27
-
[k: string]: unknown
26
+
total?: number;
27
+
[k: string]: unknown;
28
28
}
29
29
30
-
export type HandlerInput = undefined
30
+
export type HandlerInput = undefined;
31
31
32
32
export interface HandlerSuccess {
33
-
encoding: 'application/json'
34
-
body: OutputSchema
35
-
headers?: { [key: string]: string }
33
+
encoding: "application/json";
34
+
body: OutputSchema;
35
+
headers?: { [key: string]: string };
36
36
}
37
37
38
38
export interface HandlerError {
39
-
status: number
40
-
message?: string
39
+
status: number;
40
+
message?: string;
41
41
}
42
42
43
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
43
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
44
44
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
45
-
auth: HA
46
-
params: QueryParams
47
-
input: HandlerInput
48
-
req: express.Request
49
-
res: express.Response
50
-
resetRouteRateLimits: () => Promise<void>
51
-
}
45
+
auth: HA;
46
+
params: QueryParams;
47
+
input: HandlerInput;
48
+
req: express.Request;
49
+
res: express.Response;
50
+
resetRouteRateLimits: () => Promise<void>;
51
+
};
52
52
export type Handler<HA extends HandlerAuth = never> = (
53
53
ctx: HandlerReqCtx<HA>,
54
-
) => Promise<HandlerOutput> | HandlerOutput
54
+
) => Promise<HandlerOutput> | HandlerOutput;
+24
-24
apps/api/src/lexicon/types/io/pocketenv/file/updateFile.ts
+24
-24
apps/api/src/lexicon/types/io/pocketenv/file/updateFile.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvFileDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvFileDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The ID of the file to delete */
16
-
id: string
17
-
file: IoPocketenvFileDefs.File
18
-
[k: string]: unknown
16
+
id: string;
17
+
file: IoPocketenvFileDefs.File;
18
+
[k: string]: unknown;
19
19
}
20
20
21
21
export interface HandlerInput {
22
-
encoding: 'application/json'
23
-
body: InputSchema
22
+
encoding: "application/json";
23
+
body: InputSchema;
24
24
}
25
25
26
26
export interface HandlerError {
27
-
status: number
28
-
message?: string
27
+
status: number;
28
+
message?: string;
29
29
}
30
30
31
-
export type HandlerOutput = HandlerError | void
31
+
export type HandlerOutput = HandlerError | void;
32
32
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
33
-
auth: HA
34
-
params: QueryParams
35
-
input: HandlerInput
36
-
req: express.Request
37
-
res: express.Response
38
-
resetRouteRateLimits: () => Promise<void>
39
-
}
33
+
auth: HA;
34
+
params: QueryParams;
35
+
input: HandlerInput;
36
+
req: express.Request;
37
+
res: express.Response;
38
+
resetRouteRateLimits: () => Promise<void>;
39
+
};
40
40
export type Handler<HA extends HandlerAuth = never> = (
41
41
ctx: HandlerReqCtx<HA>,
42
-
) => Promise<HandlerOutput> | HandlerOutput
42
+
) => Promise<HandlerOutput> | HandlerOutput;
+12
-12
apps/api/src/lexicon/types/io/pocketenv/port/defs.ts
+12
-12
apps/api/src/lexicon/types/io/pocketenv/port/defs.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
8
9
9
/** A view of a port exposed by a sandbox. */
10
10
export interface PortView {
11
11
/** The port number. */
12
-
port?: number
12
+
port?: number;
13
13
/** A description of the port. */
14
-
description?: string
14
+
description?: string;
15
15
/** A URL for previewing the service running on the port */
16
-
previewUrl?: string
17
-
[k: string]: unknown
16
+
previewUrl?: string;
17
+
[k: string]: unknown;
18
18
}
19
19
20
20
export function isPortView(v: unknown): v is PortView {
21
21
return (
22
22
isObj(v) &&
23
-
hasProp(v, '$type') &&
24
-
v.$type === 'io.pocketenv.port.defs#portView'
25
-
)
23
+
hasProp(v, "$type") &&
24
+
v.$type === "io.pocketenv.port.defs#portView"
25
+
);
26
26
}
27
27
28
28
export function validatePortView(v: unknown): ValidationResult {
29
-
return lexicons.validate('io.pocketenv.port.defs#portView', v)
29
+
return lexicons.validate("io.pocketenv.port.defs#portView", v);
30
30
}
+13
-13
apps/api/src/lexicon/types/io/pocketenv/publicKey.ts
+13
-13
apps/api/src/lexicon/types/io/pocketenv/publicKey.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../lexicons'
6
-
import { isObj, hasProp } from '../../../util'
7
-
import { CID } from 'multiformats/cid'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../lexicons";
6
+
import { isObj, hasProp } from "../../../util";
7
+
import { CID } from "multiformats/cid";
8
8
9
9
export interface Record {
10
10
/** Name of the public key */
11
-
name: string
11
+
name: string;
12
12
/** The public key value, e.g. an SSH public key string. */
13
-
key: string
14
-
createdAt: string
15
-
[k: string]: unknown
13
+
key: string;
14
+
createdAt: string;
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
-
hasProp(v, '$type') &&
22
-
(v.$type === 'io.pocketenv.publicKey#main' ||
23
-
v.$type === 'io.pocketenv.publicKey')
24
-
)
21
+
hasProp(v, "$type") &&
22
+
(v.$type === "io.pocketenv.publicKey#main" ||
23
+
v.$type === "io.pocketenv.publicKey")
24
+
);
25
25
}
26
26
27
27
export function validateRecord(v: unknown): ValidationResult {
28
-
return lexicons.validate('io.pocketenv.publicKey#main', v)
28
+
return lexicons.validate("io.pocketenv.publicKey#main", v);
29
29
}
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox.ts
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../lexicons'
6
-
import { isObj, hasProp } from '../../../util'
7
-
import { CID } from 'multiformats/cid'
8
-
import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../lexicons";
6
+
import { isObj, hasProp } from "../../../util";
7
+
import { CID } from "multiformats/cid";
8
+
import type * as ComAtprotoRepoStrongRef from "../../com/atproto/repo/strongRef";
9
9
10
10
export interface Record {
11
11
/** Name of the sandbox */
12
-
name: string
13
-
base?: ComAtprotoRepoStrongRef.Main
12
+
name: string;
13
+
base?: ComAtprotoRepoStrongRef.Main;
14
14
/** The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc. */
15
-
provider?: string
16
-
description?: string
15
+
provider?: string;
16
+
description?: string;
17
17
/** Any URI related to the sandbox */
18
-
website?: string
18
+
website?: string;
19
19
/** URI to an image logo for the sandbox */
20
-
logo?: string
21
-
topics?: string[]
20
+
logo?: string;
21
+
topics?: string[];
22
22
/** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */
23
-
repo?: string
23
+
repo?: string;
24
24
/** A URI to a README for the sandbox. */
25
-
readme?: string
25
+
readme?: string;
26
26
/** Number of virtual CPUs allocated to the sandbox */
27
-
vcpus?: number
27
+
vcpus?: number;
28
28
/** Amount of memory in GB allocated to the sandbox */
29
-
memory?: number
29
+
memory?: number;
30
30
/** Amount of disk space in GB allocated to the sandbox */
31
-
disk?: number
32
-
volumes?: string[]
33
-
ports?: number[]
34
-
secrets?: string[]
35
-
envs?: string[]
36
-
createdAt: string
37
-
[k: string]: unknown
31
+
disk?: number;
32
+
volumes?: string[];
33
+
ports?: number[];
34
+
secrets?: string[];
35
+
envs?: string[];
36
+
createdAt: string;
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
-
hasProp(v, '$type') &&
44
-
(v.$type === 'io.pocketenv.sandbox#main' ||
45
-
v.$type === 'io.pocketenv.sandbox')
46
-
)
43
+
hasProp(v, "$type") &&
44
+
(v.$type === "io.pocketenv.sandbox#main" ||
45
+
v.$type === "io.pocketenv.sandbox")
46
+
);
47
47
}
48
48
49
49
export function validateRecord(v: unknown): ValidationResult {
50
-
return lexicons.validate('io.pocketenv.sandbox#main', v)
50
+
return lexicons.validate("io.pocketenv.sandbox#main", v);
51
51
}
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/claimSandbox.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/claimSandbox.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/createIntegration.ts
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/createIntegration.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The sandbox ID. */
16
-
id: string
16
+
id: string;
17
17
/** The name of the integration. */
18
-
name: string
19
-
[k: string]: unknown
18
+
name: string;
19
+
[k: string]: unknown;
20
20
}
21
21
22
-
export type OutputSchema = IoPocketenvSandboxDefs.IntegrationView
22
+
export type OutputSchema = IoPocketenvSandboxDefs.IntegrationView;
23
23
24
24
export interface HandlerInput {
25
-
encoding: 'application/json'
26
-
body: InputSchema
25
+
encoding: "application/json";
26
+
body: InputSchema;
27
27
}
28
28
29
29
export interface HandlerSuccess {
30
-
encoding: 'application/json'
31
-
body: OutputSchema
32
-
headers?: { [key: string]: string }
30
+
encoding: "application/json";
31
+
body: OutputSchema;
32
+
headers?: { [key: string]: string };
33
33
}
34
34
35
35
export interface HandlerError {
36
-
status: number
37
-
message?: string
36
+
status: number;
37
+
message?: string;
38
38
}
39
39
40
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
40
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
41
41
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
42
-
auth: HA
43
-
params: QueryParams
44
-
input: HandlerInput
45
-
req: express.Request
46
-
res: express.Response
47
-
resetRouteRateLimits: () => Promise<void>
48
-
}
42
+
auth: HA;
43
+
params: QueryParams;
44
+
input: HandlerInput;
45
+
req: express.Request;
46
+
res: express.Response;
47
+
resetRouteRateLimits: () => Promise<void>;
48
+
};
49
49
export type Handler<HA extends HandlerAuth = never> = (
50
50
ctx: HandlerReqCtx<HA>,
51
-
) => Promise<HandlerOutput> | HandlerOutput
51
+
) => Promise<HandlerOutput> | HandlerOutput;
+39
-39
apps/api/src/lexicon/types/io/pocketenv/sandbox/createSandbox.ts
+39
-39
apps/api/src/lexicon/types/io/pocketenv/sandbox/createSandbox.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
-
export type QueryParams = {}
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
-
base: string
16
+
base: string;
17
17
/** The name of the sandbox */
18
-
name?: string
18
+
name?: string;
19
19
/** A description for the sandbox */
20
-
description?: string
20
+
description?: string;
21
21
/** The provider to create the sandbox on, e.g. 'daytona', 'vercel', 'cloudflare', etc. */
22
-
provider?: 'daytona' | 'vercel' | 'cloudflare' | 'deno' | 'sprites'
22
+
provider?: "daytona" | "vercel" | "cloudflare" | "deno" | "sprites";
23
23
/** A list of topics/tags to associate with the sandbox */
24
-
topics?: string[]
24
+
topics?: string[];
25
25
/** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */
26
-
repo?: string
26
+
repo?: string;
27
27
/** The number of virtual CPUs to allocate for the sandbox */
28
-
vcpus?: number
28
+
vcpus?: number;
29
29
/** The amount of memory (in GB) to allocate for the sandbox */
30
-
memory?: number
30
+
memory?: number;
31
31
/** The amount of disk space (in GB) to allocate for the sandbox */
32
-
disk?: number
32
+
disk?: number;
33
33
/** A URI to a README for the sandbox. */
34
-
readme?: string
35
-
secrets?: IoPocketenvSandboxDefs.Secrets
36
-
envs?: IoPocketenvSandboxDefs.Envs
34
+
readme?: string;
35
+
secrets?: IoPocketenvSandboxDefs.Secrets;
36
+
envs?: IoPocketenvSandboxDefs.Envs;
37
37
/** Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs. */
38
-
keepAlive?: boolean
39
-
[k: string]: unknown
38
+
keepAlive?: boolean;
39
+
[k: string]: unknown;
40
40
}
41
41
42
-
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic
42
+
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic;
43
43
44
44
export interface HandlerInput {
45
-
encoding: 'application/json'
46
-
body: InputSchema
45
+
encoding: "application/json";
46
+
body: InputSchema;
47
47
}
48
48
49
49
export interface HandlerSuccess {
50
-
encoding: 'application/json'
51
-
body: OutputSchema
52
-
headers?: { [key: string]: string }
50
+
encoding: "application/json";
51
+
body: OutputSchema;
52
+
headers?: { [key: string]: string };
53
53
}
54
54
55
55
export interface HandlerError {
56
-
status: number
57
-
message?: string
56
+
status: number;
57
+
message?: string;
58
58
}
59
59
60
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
60
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
61
61
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
62
-
auth: HA
63
-
params: QueryParams
64
-
input: HandlerInput
65
-
req: express.Request
66
-
res: express.Response
67
-
resetRouteRateLimits: () => Promise<void>
68
-
}
62
+
auth: HA;
63
+
params: QueryParams;
64
+
input: HandlerInput;
65
+
req: express.Request;
66
+
res: express.Response;
67
+
resetRouteRateLimits: () => Promise<void>;
68
+
};
69
69
export type Handler<HA extends HandlerAuth = never> = (
70
70
ctx: HandlerReqCtx<HA>,
71
-
) => Promise<HandlerOutput> | HandlerOutput
71
+
) => Promise<HandlerOutput> | HandlerOutput;
+124
-124
apps/api/src/lexicon/types/io/pocketenv/sandbox/defs.ts
+124
-124
apps/api/src/lexicon/types/io/pocketenv/sandbox/defs.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
8
-
import type * as IoPocketenvUserDefs from '../user/defs'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
+
import type * as IoPocketenvUserDefs from "../user/defs";
9
9
10
10
export interface SandboxViewBasic {
11
11
/** Name of the sandbox */
12
-
name?: string
12
+
name?: string;
13
13
/** The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc. */
14
-
provider?: string
15
-
description?: string
14
+
provider?: string;
15
+
description?: string;
16
16
/** Any URI related to the sandbox */
17
-
website?: string
17
+
website?: string;
18
18
/** URI to an image logo for the sandbox */
19
-
logo?: string
20
-
topics?: string[]
19
+
logo?: string;
20
+
topics?: string[];
21
21
/** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */
22
-
repo?: string
22
+
repo?: string;
23
23
/** A URI to a README for the sandbox. */
24
-
readme?: string
24
+
readme?: string;
25
25
/** Number of virtual CPUs allocated to the sandbox */
26
-
vcpus?: number
26
+
vcpus?: number;
27
27
/** Amount of memory in GB allocated to the sandbox */
28
-
memory?: number
28
+
memory?: number;
29
29
/** Amount of disk space in GB allocated to the sandbox */
30
-
disk?: number
31
-
ports?: number[]
30
+
disk?: number;
31
+
ports?: number[];
32
32
/** Number of times the sandbox has been installed by users. */
33
-
installs?: number
34
-
createdAt?: string
35
-
[k: string]: unknown
33
+
installs?: number;
34
+
createdAt?: string;
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
-
hasProp(v, '$type') &&
42
-
v.$type === 'io.pocketenv.sandbox.defs#sandboxViewBasic'
43
-
)
41
+
hasProp(v, "$type") &&
42
+
v.$type === "io.pocketenv.sandbox.defs#sandboxViewBasic"
43
+
);
44
44
}
45
45
46
46
export function validateSandboxViewBasic(v: unknown): ValidationResult {
47
-
return lexicons.validate('io.pocketenv.sandbox.defs#sandboxViewBasic', v)
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
-
name?: string
52
+
name?: string;
53
53
/** The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc. */
54
-
provider?: string
55
-
description?: string
54
+
provider?: string;
55
+
description?: string;
56
56
/** The current status of the sandbox, e.g. 'RUNNING', 'STOPPED', etc. */
57
-
status?: string
58
-
startedAt?: string
57
+
status?: string;
58
+
startedAt?: string;
59
59
/** The sandbox timeout in seconds */
60
-
timeout?: number
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
-
baseSandbox?: string
62
+
baseSandbox?: string;
63
63
/** Any URI related to the sandbox */
64
-
website?: string
64
+
website?: string;
65
65
/** URI to an image logo for the sandbox */
66
-
logo?: string
67
-
topics?: string[]
66
+
logo?: string;
67
+
topics?: string[];
68
68
/** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */
69
-
repo?: string
69
+
repo?: string;
70
70
/** A URI to a README for the sandbox. */
71
-
readme?: string
71
+
readme?: string;
72
72
/** Number of virtual CPUs allocated to the sandbox */
73
-
vcpus?: number
73
+
vcpus?: number;
74
74
/** Amount of memory in GB allocated to the sandbox */
75
-
memory?: number
75
+
memory?: number;
76
76
/** Amount of disk space in GB allocated to the sandbox */
77
-
disk?: number
78
-
ports?: number[]
77
+
disk?: number;
78
+
ports?: number[];
79
79
/** Number of times the sandbox has been installed by users. */
80
-
installs?: number
81
-
createdAt?: string
82
-
owner?: IoPocketenvUserDefs.UserViewBasic
83
-
[k: string]: unknown
80
+
installs?: number;
81
+
createdAt?: string;
82
+
owner?: IoPocketenvUserDefs.UserViewBasic;
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
-
hasProp(v, '$type') &&
90
-
v.$type === 'io.pocketenv.sandbox.defs#sandboxViewDetailed'
91
-
)
89
+
hasProp(v, "$type") &&
90
+
v.$type === "io.pocketenv.sandbox.defs#sandboxViewDetailed"
91
+
);
92
92
}
93
93
94
94
export function validateSandboxViewDetailed(v: unknown): ValidationResult {
95
-
return lexicons.validate('io.pocketenv.sandbox.defs#sandboxViewDetailed', v)
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
-
name?: string
100
+
name?: string;
101
101
/** A description for the sandbox */
102
-
description?: string | null
102
+
description?: string | null;
103
103
/** A list of topics/tags to associate with the sandbox */
104
-
topics?: (string | null)[]
104
+
topics?: (string | null)[];
105
105
/** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */
106
-
repo?: string | null
106
+
repo?: string | null;
107
107
/** The number of virtual CPUs to allocate for the sandbox */
108
-
vcpus?: number
108
+
vcpus?: number;
109
109
/** The amount of memory (in GB) to allocate for the sandbox */
110
-
memory?: number
110
+
memory?: number;
111
111
/** The amount of disk space (in GB) to allocate for the sandbox */
112
-
disk?: number
112
+
disk?: number;
113
113
/** A URI to a README for the sandbox. */
114
-
readme?: string
115
-
[k: string]: unknown
114
+
readme?: string;
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
-
hasProp(v, '$type') &&
122
-
v.$type === 'io.pocketenv.sandbox.defs#sandboxDetailsPref'
123
-
)
121
+
hasProp(v, "$type") &&
122
+
v.$type === "io.pocketenv.sandbox.defs#sandboxDetailsPref"
123
+
);
124
124
}
125
125
126
126
export function validateSandboxDetailsPref(v: unknown): ValidationResult {
127
-
return lexicons.validate('io.pocketenv.sandbox.defs#sandboxDetailsPref', v)
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
-
name?: string
132
+
name?: string;
133
133
/** The value of the secret. This will be encrypted at rest and redacted in any API responses. */
134
-
value?: string
135
-
[k: string]: unknown
134
+
value?: string;
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
-
hasProp(v, '$type') &&
142
-
v.$type === 'io.pocketenv.sandbox.defs#secretPref'
143
-
)
141
+
hasProp(v, "$type") &&
142
+
v.$type === "io.pocketenv.sandbox.defs#secretPref"
143
+
);
144
144
}
145
145
146
146
export function validateSecretPref(v: unknown): ValidationResult {
147
-
return lexicons.validate('io.pocketenv.sandbox.defs#secretPref', v)
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
-
name?: string
153
+
name?: string;
154
154
/** The value of the variable. This will be visible in API responses and should not contain sensitive information. */
155
-
value?: string
156
-
[k: string]: unknown
155
+
value?: string;
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
-
hasProp(v, '$type') &&
163
-
v.$type === 'io.pocketenv.sandbox.defs#variablePref'
164
-
)
162
+
hasProp(v, "$type") &&
163
+
v.$type === "io.pocketenv.sandbox.defs#variablePref"
164
+
);
165
165
}
166
166
167
167
export function validateVariablePref(v: unknown): ValidationResult {
168
-
return lexicons.validate('io.pocketenv.sandbox.defs#variablePref', v)
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
-
name?: string
174
+
name?: string;
175
175
/** The content of the file. */
176
-
content?: string
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
-
encrypt?: boolean
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
-
path?: string
181
-
[k: string]: unknown
180
+
path?: string;
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
-
hasProp(v, '$type') &&
188
-
v.$type === 'io.pocketenv.sandbox.defs#filePref'
189
-
)
187
+
hasProp(v, "$type") &&
188
+
v.$type === "io.pocketenv.sandbox.defs#filePref"
189
+
);
190
190
}
191
191
192
192
export function validateFilePref(v: unknown): ValidationResult {
193
-
return lexicons.validate('io.pocketenv.sandbox.defs#filePref', v)
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
-
name?: string
199
+
name?: string;
200
200
/** The mount path within the sandbox where the volume will be attached, e.g. '/data', '/logs', etc. */
201
-
path?: string
201
+
path?: string;
202
202
/** Whether the volume should be mounted as read-only */
203
-
readOnly?: boolean
204
-
[k: string]: unknown
203
+
readOnly?: boolean;
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
-
hasProp(v, '$type') &&
211
-
v.$type === 'io.pocketenv.sandbox.defs#volumePref'
212
-
)
210
+
hasProp(v, "$type") &&
211
+
v.$type === "io.pocketenv.sandbox.defs#volumePref"
212
+
);
213
213
}
214
214
215
215
export function validateVolumePref(v: unknown): ValidationResult {
216
-
return lexicons.validate('io.pocketenv.sandbox.defs#volumePref', v)
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
+
)[];
227
227
228
228
export interface SshKeysView {
229
229
/** Unique identifier of the SSH key. */
230
-
id?: string
230
+
id?: string;
231
231
/** The public SSH key. */
232
-
publicKey?: string
232
+
publicKey?: string;
233
233
/** The private SSH key (redacted in API responses) */
234
-
privateKey?: string
234
+
privateKey?: string;
235
235
/** The timestamp when the SSH key was created. */
236
-
createdAt?: string
236
+
createdAt?: string;
237
237
/** The timestamp when the SSH key was last updated. */
238
-
updatedAt?: string
239
-
[k: string]: unknown
238
+
updatedAt?: string;
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
-
hasProp(v, '$type') &&
246
-
v.$type === 'io.pocketenv.sandbox.defs#sshKeysView'
247
-
)
245
+
hasProp(v, "$type") &&
246
+
v.$type === "io.pocketenv.sandbox.defs#sshKeysView"
247
+
);
248
248
}
249
249
250
250
export function validateSshKeysView(v: unknown): ValidationResult {
251
-
return lexicons.validate('io.pocketenv.sandbox.defs#sshKeysView', v)
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
-
id?: string
256
+
id?: string;
257
257
/** The Tailscale auth key (redacted in API responses) */
258
-
authKey?: string
258
+
authKey?: string;
259
259
/** The redacted Auth Key. */
260
-
redacted?: string
260
+
redacted?: string;
261
261
/** The timestamp when the Tailscale Auth Key was created. */
262
-
createdAt?: string
262
+
createdAt?: string;
263
263
/** The timestamp when the Tailscale Auth Key was last updated. */
264
-
updatedAt?: string
265
-
[k: string]: unknown
264
+
updatedAt?: string;
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
-
hasProp(v, '$type') &&
272
-
v.$type === 'io.pocketenv.sandbox.defs#tailscaleAuthKeyView'
273
-
)
271
+
hasProp(v, "$type") &&
272
+
v.$type === "io.pocketenv.sandbox.defs#tailscaleAuthKeyView"
273
+
);
274
274
}
275
275
276
276
export function validateTailscaleAuthKeyView(v: unknown): ValidationResult {
277
-
return lexicons.validate('io.pocketenv.sandbox.defs#tailscaleAuthKeyView', v)
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
-
id?: string
282
+
id?: string;
283
283
/** The name of the integration, e.g. 'GitHub', 'Slack', 'Trello', etc. */
284
-
name?: string
284
+
name?: string;
285
285
/** The webhook URL of the integration. */
286
-
webhookUrl?: string
286
+
webhookUrl?: string;
287
287
/** The timestamp when the integration was created. */
288
-
createdAt?: string
288
+
createdAt?: string;
289
289
/** The timestamp when the integration was last updated. */
290
-
updatedAt?: string
291
-
[k: string]: unknown
290
+
updatedAt?: string;
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
-
hasProp(v, '$type') &&
298
-
v.$type === 'io.pocketenv.sandbox.defs#integrationView'
299
-
)
297
+
hasProp(v, "$type") &&
298
+
v.$type === "io.pocketenv.sandbox.defs#integrationView"
299
+
);
300
300
}
301
301
302
302
export function validateIntegrationView(v: unknown): ValidationResult {
303
-
return lexicons.validate('io.pocketenv.sandbox.defs#integrationView', v)
303
+
return lexicons.validate("io.pocketenv.sandbox.defs#integrationView", v);
304
304
}
305
305
306
-
export type IntegrationsView = IntegrationView[]
306
+
export type IntegrationsView = IntegrationView[];
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/deleteSandbox.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/deleteSandbox.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+29
-29
apps/api/src/lexicon/types/io/pocketenv/sandbox/exec.ts
+29
-29
apps/api/src/lexicon/types/io/pocketenv/sandbox/exec.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
10
11
11
export interface QueryParams {
12
12
/** The sandbox ID. */
13
-
id: string
13
+
id: string;
14
14
}
15
15
16
16
export interface InputSchema {
17
17
/** The command to execute in the sandbox. */
18
-
command: string
19
-
[k: string]: unknown
18
+
command: string;
19
+
[k: string]: unknown;
20
20
}
21
21
22
22
export interface OutputSchema {
23
23
/** The output of the executed command. */
24
-
stdout?: string
24
+
stdout?: string;
25
25
/** The error output of the executed command, if any. */
26
-
stderr?: string
26
+
stderr?: string;
27
27
/** The exit code of the executed command. */
28
-
exitCode?: number
29
-
[k: string]: unknown
28
+
exitCode?: number;
29
+
[k: string]: unknown;
30
30
}
31
31
32
32
export interface HandlerInput {
33
-
encoding: 'application/json'
34
-
body: InputSchema
33
+
encoding: "application/json";
34
+
body: InputSchema;
35
35
}
36
36
37
37
export interface HandlerSuccess {
38
-
encoding: 'application/json'
39
-
body: OutputSchema
40
-
headers?: { [key: string]: string }
38
+
encoding: "application/json";
39
+
body: OutputSchema;
40
+
headers?: { [key: string]: string };
41
41
}
42
42
43
43
export interface HandlerError {
44
-
status: number
45
-
message?: string
44
+
status: number;
45
+
message?: string;
46
46
}
47
47
48
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
48
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
49
49
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
50
-
auth: HA
51
-
params: QueryParams
52
-
input: HandlerInput
53
-
req: express.Request
54
-
res: express.Response
55
-
resetRouteRateLimits: () => Promise<void>
56
-
}
50
+
auth: HA;
51
+
params: QueryParams;
52
+
input: HandlerInput;
53
+
req: express.Request;
54
+
res: express.Response;
55
+
resetRouteRateLimits: () => Promise<void>;
56
+
};
57
57
export type Handler<HA extends HandlerAuth = never> = (
58
58
ctx: HandlerReqCtx<HA>,
59
-
) => Promise<HandlerOutput> | HandlerOutput
59
+
) => Promise<HandlerOutput> | HandlerOutput;
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/exposePort.ts
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/exposePort.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
10
11
11
export interface QueryParams {
12
12
/** The sandbox ID. */
13
-
id: string
13
+
id: string;
14
14
}
15
15
16
16
export interface InputSchema {
17
17
/** The port number to expose. */
18
-
port: number
18
+
port: number;
19
19
/** A description of the port. */
20
-
description?: string
21
-
[k: string]: unknown
20
+
description?: string;
21
+
[k: string]: unknown;
22
22
}
23
23
24
24
export interface OutputSchema {
25
25
/** The preview URL for the exposed port. */
26
-
previewUrl?: string | null
27
-
[k: string]: unknown
26
+
previewUrl?: string | null;
27
+
[k: string]: unknown;
28
28
}
29
29
30
30
export interface HandlerInput {
31
-
encoding: 'application/json'
32
-
body: InputSchema
31
+
encoding: "application/json";
32
+
body: InputSchema;
33
33
}
34
34
35
35
export interface HandlerSuccess {
36
-
encoding: 'application/json'
37
-
body: OutputSchema
38
-
headers?: { [key: string]: string }
36
+
encoding: "application/json";
37
+
body: OutputSchema;
38
+
headers?: { [key: string]: string };
39
39
}
40
40
41
41
export interface HandlerError {
42
-
status: number
43
-
message?: string
42
+
status: number;
43
+
message?: string;
44
44
}
45
45
46
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
46
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
47
47
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
48
-
auth: HA
49
-
params: QueryParams
50
-
input: HandlerInput
51
-
req: express.Request
52
-
res: express.Response
53
-
resetRouteRateLimits: () => Promise<void>
54
-
}
48
+
auth: HA;
49
+
params: QueryParams;
50
+
input: HandlerInput;
51
+
req: express.Request;
52
+
res: express.Response;
53
+
resetRouteRateLimits: () => Promise<void>;
54
+
};
55
55
export type Handler<HA extends HandlerAuth = never> = (
56
56
ctx: HandlerReqCtx<HA>,
57
-
) => Promise<HandlerOutput> | HandlerOutput
57
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/exposeVscode.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/exposeVscode.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
10
11
11
export interface QueryParams {
12
12
/** The sandbox ID. */
13
-
id: string
13
+
id: string;
14
14
}
15
15
16
-
export type InputSchema = undefined
16
+
export type InputSchema = undefined;
17
17
18
18
export interface OutputSchema {
19
19
/** The preview URL for the exposed port. */
20
-
previewUrl?: string | null
21
-
[k: string]: unknown
20
+
previewUrl?: string | null;
21
+
[k: string]: unknown;
22
22
}
23
23
24
-
export type HandlerInput = undefined
24
+
export type HandlerInput = undefined;
25
25
26
26
export interface HandlerSuccess {
27
-
encoding: 'application/json'
28
-
body: OutputSchema
29
-
headers?: { [key: string]: string }
27
+
encoding: "application/json";
28
+
body: OutputSchema;
29
+
headers?: { [key: string]: string };
30
30
}
31
31
32
32
export interface HandlerError {
33
-
status: number
34
-
message?: string
33
+
status: number;
34
+
message?: string;
35
35
}
36
36
37
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
38
38
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
-
auth: HA
40
-
params: QueryParams
41
-
input: HandlerInput
42
-
req: express.Request
43
-
res: express.Response
44
-
resetRouteRateLimits: () => Promise<void>
45
-
}
39
+
auth: HA;
40
+
params: QueryParams;
41
+
input: HandlerInput;
42
+
req: express.Request;
43
+
res: express.Response;
44
+
resetRouteRateLimits: () => Promise<void>;
45
+
};
46
46
export type Handler<HA extends HandlerAuth = never> = (
47
47
ctx: HandlerReqCtx<HA>,
48
-
) => Promise<HandlerOutput> | HandlerOutput
48
+
) => Promise<HandlerOutput> | HandlerOutput;
+26
-26
apps/api/src/lexicon/types/io/pocketenv/sandbox/getExposedPorts.ts
+26
-26
apps/api/src/lexicon/types/io/pocketenv/sandbox/getExposedPorts.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvPortDefs from '../port/defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvPortDefs from "../port/defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
17
+
export type InputSchema = undefined;
18
18
19
19
export interface OutputSchema {
20
-
ports?: IoPocketenvPortDefs.PortView[]
21
-
[k: string]: unknown
20
+
ports?: IoPocketenvPortDefs.PortView[];
21
+
[k: string]: unknown;
22
22
}
23
23
24
-
export type HandlerInput = undefined
24
+
export type HandlerInput = undefined;
25
25
26
26
export interface HandlerSuccess {
27
-
encoding: 'application/json'
28
-
body: OutputSchema
29
-
headers?: { [key: string]: string }
27
+
encoding: "application/json";
28
+
body: OutputSchema;
29
+
headers?: { [key: string]: string };
30
30
}
31
31
32
32
export interface HandlerError {
33
-
status: number
34
-
message?: string
33
+
status: number;
34
+
message?: string;
35
35
}
36
36
37
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
38
38
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
-
auth: HA
40
-
params: QueryParams
41
-
input: HandlerInput
42
-
req: express.Request
43
-
res: express.Response
44
-
resetRouteRateLimits: () => Promise<void>
45
-
}
39
+
auth: HA;
40
+
params: QueryParams;
41
+
input: HandlerInput;
42
+
req: express.Request;
43
+
res: express.Response;
44
+
resetRouteRateLimits: () => Promise<void>;
45
+
};
46
46
export type Handler<HA extends HandlerAuth = never> = (
47
47
ctx: HandlerReqCtx<HA>,
48
-
) => Promise<HandlerOutput> | HandlerOutput
48
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getIntegrations.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getIntegrations.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.IntegrationsView
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.IntegrationsView;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getPreferences.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getPreferences.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID or URI to retrieve */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.Preferences
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.Preferences;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getSandbox.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getSandbox.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID or URI to retrieve */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/getSandboxes.ts
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/getSandboxes.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The maximum number of sandboxes to return. */
14
-
limit?: number
14
+
limit?: number;
15
15
/** The number of sandboxes to skip before starting to collect the result set. */
16
-
offset?: number
16
+
offset?: number;
17
17
}
18
18
19
-
export type InputSchema = undefined
19
+
export type InputSchema = undefined;
20
20
21
21
export interface OutputSchema {
22
-
sandboxes?: IoPocketenvSandboxDefs.SandboxViewBasic[]
22
+
sandboxes?: IoPocketenvSandboxDefs.SandboxViewBasic[];
23
23
/** The total number of sandboxes available. */
24
-
total?: number
25
-
[k: string]: unknown
24
+
total?: number;
25
+
[k: string]: unknown;
26
26
}
27
27
28
-
export type HandlerInput = undefined
28
+
export type HandlerInput = undefined;
29
29
30
30
export interface HandlerSuccess {
31
-
encoding: 'application/json'
32
-
body: OutputSchema
33
-
headers?: { [key: string]: string }
31
+
encoding: "application/json";
32
+
body: OutputSchema;
33
+
headers?: { [key: string]: string };
34
34
}
35
35
36
36
export interface HandlerError {
37
-
status: number
38
-
message?: string
37
+
status: number;
38
+
message?: string;
39
39
}
40
40
41
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
42
42
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
-
auth: HA
44
-
params: QueryParams
45
-
input: HandlerInput
46
-
req: express.Request
47
-
res: express.Response
48
-
resetRouteRateLimits: () => Promise<void>
49
-
}
43
+
auth: HA;
44
+
params: QueryParams;
45
+
input: HandlerInput;
46
+
req: express.Request;
47
+
res: express.Response;
48
+
resetRouteRateLimits: () => Promise<void>;
49
+
};
50
50
export type Handler<HA extends HandlerAuth = never> = (
51
51
ctx: HandlerReqCtx<HA>,
52
-
) => Promise<HandlerOutput> | HandlerOutput
52
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getSshKeys.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getSshKeys.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.SshKeysView
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.SshKeysView;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getTailscaleAuthKey.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getTailscaleAuthKey.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.TailscaleAuthKeyView
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.TailscaleAuthKeyView;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getTailscaleToken.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/getTailscaleToken.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.TailscaleTokenView
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.TailscaleTokenView;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+24
-24
apps/api/src/lexicon/types/io/pocketenv/sandbox/putPreferences.ts
+24
-24
apps/api/src/lexicon/types/io/pocketenv/sandbox/putPreferences.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The sandbox ID or URI */
16
-
sandboxId: string
17
-
preferences: IoPocketenvSandboxDefs.Preferences
18
-
[k: string]: unknown
16
+
sandboxId: string;
17
+
preferences: IoPocketenvSandboxDefs.Preferences;
18
+
[k: string]: unknown;
19
19
}
20
20
21
21
export interface HandlerInput {
22
-
encoding: 'application/json'
23
-
body: InputSchema
22
+
encoding: "application/json";
23
+
body: InputSchema;
24
24
}
25
25
26
26
export interface HandlerError {
27
-
status: number
28
-
message?: string
27
+
status: number;
28
+
message?: string;
29
29
}
30
30
31
-
export type HandlerOutput = HandlerError | void
31
+
export type HandlerOutput = HandlerError | void;
32
32
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
33
-
auth: HA
34
-
params: QueryParams
35
-
input: HandlerInput
36
-
req: express.Request
37
-
res: express.Response
38
-
resetRouteRateLimits: () => Promise<void>
39
-
}
33
+
auth: HA;
34
+
params: QueryParams;
35
+
input: HandlerInput;
36
+
req: express.Request;
37
+
res: express.Response;
38
+
resetRouteRateLimits: () => Promise<void>;
39
+
};
40
40
export type Handler<HA extends HandlerAuth = never> = (
41
41
ctx: HandlerReqCtx<HA>,
42
-
) => Promise<HandlerOutput> | HandlerOutput
42
+
) => Promise<HandlerOutput> | HandlerOutput;
+30
-30
apps/api/src/lexicon/types/io/pocketenv/sandbox/putSshKeys.ts
+30
-30
apps/api/src/lexicon/types/io/pocketenv/sandbox/putSshKeys.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The sandbox ID. */
16
-
id: string
16
+
id: string;
17
17
/** The private SSH key (encrypted) */
18
-
privateKey: string
18
+
privateKey: string;
19
19
/** The public SSH key. */
20
-
publicKey: string
20
+
publicKey: string;
21
21
/** The redacted SSH key. */
22
-
redacted?: string
23
-
[k: string]: unknown
22
+
redacted?: string;
23
+
[k: string]: unknown;
24
24
}
25
25
26
-
export type OutputSchema = IoPocketenvSandboxDefs.SshKeysView
26
+
export type OutputSchema = IoPocketenvSandboxDefs.SshKeysView;
27
27
28
28
export interface HandlerInput {
29
-
encoding: 'application/json'
30
-
body: InputSchema
29
+
encoding: "application/json";
30
+
body: InputSchema;
31
31
}
32
32
33
33
export interface HandlerSuccess {
34
-
encoding: 'application/json'
35
-
body: OutputSchema
36
-
headers?: { [key: string]: string }
34
+
encoding: "application/json";
35
+
body: OutputSchema;
36
+
headers?: { [key: string]: string };
37
37
}
38
38
39
39
export interface HandlerError {
40
-
status: number
41
-
message?: string
40
+
status: number;
41
+
message?: string;
42
42
}
43
43
44
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
44
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
45
45
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
46
-
auth: HA
47
-
params: QueryParams
48
-
input: HandlerInput
49
-
req: express.Request
50
-
res: express.Response
51
-
resetRouteRateLimits: () => Promise<void>
52
-
}
46
+
auth: HA;
47
+
params: QueryParams;
48
+
input: HandlerInput;
49
+
req: express.Request;
50
+
res: express.Response;
51
+
resetRouteRateLimits: () => Promise<void>;
52
+
};
53
53
export type Handler<HA extends HandlerAuth = never> = (
54
54
ctx: HandlerReqCtx<HA>,
55
-
) => Promise<HandlerOutput> | HandlerOutput
55
+
) => Promise<HandlerOutput> | HandlerOutput;
+29
-29
apps/api/src/lexicon/types/io/pocketenv/sandbox/putTailscaleAuthKey.ts
+29
-29
apps/api/src/lexicon/types/io/pocketenv/sandbox/putTailscaleAuthKey.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The sandbox ID. */
16
-
id: string
16
+
id: string;
17
17
/** The Tailscale Auth Key (encrypted) to store for the sandbox. */
18
-
authKey: string
18
+
authKey: string;
19
19
/** The redacted SSH key. */
20
-
redacted?: string
21
-
[k: string]: unknown
20
+
redacted?: string;
21
+
[k: string]: unknown;
22
22
}
23
23
24
-
export type OutputSchema = IoPocketenvSandboxDefs.TailscaleAuthKeyView
24
+
export type OutputSchema = IoPocketenvSandboxDefs.TailscaleAuthKeyView;
25
25
26
26
export interface HandlerInput {
27
-
encoding: 'application/json'
28
-
body: InputSchema
27
+
encoding: "application/json";
28
+
body: InputSchema;
29
29
}
30
30
31
31
export interface HandlerSuccess {
32
-
encoding: 'application/json'
33
-
body: OutputSchema
34
-
headers?: { [key: string]: string }
32
+
encoding: "application/json";
33
+
body: OutputSchema;
34
+
headers?: { [key: string]: string };
35
35
}
36
36
37
37
export interface HandlerError {
38
-
status: number
39
-
message?: string
38
+
status: number;
39
+
message?: string;
40
40
}
41
41
42
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
43
43
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
44
-
auth: HA
45
-
params: QueryParams
46
-
input: HandlerInput
47
-
req: express.Request
48
-
res: express.Response
49
-
resetRouteRateLimits: () => Promise<void>
50
-
}
44
+
auth: HA;
45
+
params: QueryParams;
46
+
input: HandlerInput;
47
+
req: express.Request;
48
+
res: express.Response;
49
+
resetRouteRateLimits: () => Promise<void>;
50
+
};
51
51
export type Handler<HA extends HandlerAuth = never> = (
52
52
ctx: HandlerReqCtx<HA>,
53
-
) => Promise<HandlerOutput> | HandlerOutput
53
+
) => Promise<HandlerOutput> | HandlerOutput;
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/putTailscaleToken.ts
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/putTailscaleToken.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The sandbox ID. */
16
-
id: string
16
+
id: string;
17
17
/** The Tailscale token (encrypted) to store for the sandbox. */
18
-
token: string
19
-
[k: string]: unknown
18
+
token: string;
19
+
[k: string]: unknown;
20
20
}
21
21
22
-
export type OutputSchema = IoPocketenvSandboxDefs.TailscaleTokenView
22
+
export type OutputSchema = IoPocketenvSandboxDefs.TailscaleTokenView;
23
23
24
24
export interface HandlerInput {
25
-
encoding: 'application/json'
26
-
body: InputSchema
25
+
encoding: "application/json";
26
+
body: InputSchema;
27
27
}
28
28
29
29
export interface HandlerSuccess {
30
-
encoding: 'application/json'
31
-
body: OutputSchema
32
-
headers?: { [key: string]: string }
30
+
encoding: "application/json";
31
+
body: OutputSchema;
32
+
headers?: { [key: string]: string };
33
33
}
34
34
35
35
export interface HandlerError {
36
-
status: number
37
-
message?: string
36
+
status: number;
37
+
message?: string;
38
38
}
39
39
40
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
40
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
41
41
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
42
-
auth: HA
43
-
params: QueryParams
44
-
input: HandlerInput
45
-
req: express.Request
46
-
res: express.Response
47
-
resetRouteRateLimits: () => Promise<void>
48
-
}
42
+
auth: HA;
43
+
params: QueryParams;
44
+
input: HandlerInput;
45
+
req: express.Request;
46
+
res: express.Response;
47
+
resetRouteRateLimits: () => Promise<void>;
48
+
};
49
49
export type Handler<HA extends HandlerAuth = never> = (
50
50
ctx: HandlerReqCtx<HA>,
51
-
) => Promise<HandlerOutput> | HandlerOutput
51
+
) => Promise<HandlerOutput> | HandlerOutput;
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/startSandbox.ts
+28
-28
apps/api/src/lexicon/types/io/pocketenv/sandbox/startSandbox.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
17
export interface InputSchema {
18
18
/** The git repository URL to clone into the sandbox before starting it. Optional. */
19
-
repo?: string
19
+
repo?: string;
20
20
/** Prevent the sandbox from being automatically stop after a period of inactivity. Use with caution, as this may lead to increased costs. */
21
-
keepAlive?: boolean
22
-
[k: string]: unknown
21
+
keepAlive?: boolean;
22
+
[k: string]: unknown;
23
23
}
24
24
25
-
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic
25
+
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic;
26
26
27
27
export interface HandlerInput {
28
-
encoding: 'application/json'
29
-
body: InputSchema
28
+
encoding: "application/json";
29
+
body: InputSchema;
30
30
}
31
31
32
32
export interface HandlerSuccess {
33
-
encoding: 'application/json'
34
-
body: OutputSchema
35
-
headers?: { [key: string]: string }
33
+
encoding: "application/json";
34
+
body: OutputSchema;
35
+
headers?: { [key: string]: string };
36
36
}
37
37
38
38
export interface HandlerError {
39
-
status: number
40
-
message?: string
39
+
status: number;
40
+
message?: string;
41
41
}
42
42
43
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
43
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
44
44
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
45
-
auth: HA
46
-
params: QueryParams
47
-
input: HandlerInput
48
-
req: express.Request
49
-
res: express.Response
50
-
resetRouteRateLimits: () => Promise<void>
51
-
}
45
+
auth: HA;
46
+
params: QueryParams;
47
+
input: HandlerInput;
48
+
req: express.Request;
49
+
res: express.Response;
50
+
resetRouteRateLimits: () => Promise<void>;
51
+
};
52
52
export type Handler<HA extends HandlerAuth = never> = (
53
53
ctx: HandlerReqCtx<HA>,
54
-
) => Promise<HandlerOutput> | HandlerOutput
54
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/stopSandbox.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/stopSandbox.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSandboxDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The sandbox ID. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
18
-
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic
19
-
export type HandlerInput = undefined
17
+
export type InputSchema = undefined;
18
+
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic;
19
+
export type HandlerInput = undefined;
20
20
21
21
export interface HandlerSuccess {
22
-
encoding: 'application/json'
23
-
body: OutputSchema
24
-
headers?: { [key: string]: string }
22
+
encoding: "application/json";
23
+
body: OutputSchema;
24
+
headers?: { [key: string]: string };
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+22
-22
apps/api/src/lexicon/types/io/pocketenv/sandbox/unexposePort.ts
+22
-22
apps/api/src/lexicon/types/io/pocketenv/sandbox/unexposePort.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
10
11
11
export interface QueryParams {
12
12
/** The sandbox ID. */
13
-
id: string
13
+
id: string;
14
14
}
15
15
16
16
export interface InputSchema {
17
17
/** The port number to unexpose. */
18
-
port: number
19
-
[k: string]: unknown
18
+
port: number;
19
+
[k: string]: unknown;
20
20
}
21
21
22
22
export interface HandlerInput {
23
-
encoding: 'application/json'
24
-
body: InputSchema
23
+
encoding: "application/json";
24
+
body: InputSchema;
25
25
}
26
26
27
27
export interface HandlerError {
28
-
status: number
29
-
message?: string
28
+
status: number;
29
+
message?: string;
30
30
}
31
31
32
-
export type HandlerOutput = HandlerError | void
32
+
export type HandlerOutput = HandlerError | void;
33
33
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
-
auth: HA
35
-
params: QueryParams
36
-
input: HandlerInput
37
-
req: express.Request
38
-
res: express.Response
39
-
resetRouteRateLimits: () => Promise<void>
40
-
}
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
41
export type Handler<HA extends HandlerAuth = never> = (
42
42
ctx: HandlerReqCtx<HA>,
43
-
) => Promise<HandlerOutput> | HandlerOutput
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+42
-42
apps/api/src/lexicon/types/io/pocketenv/sandbox/updateSandboxSettings.ts
+42
-42
apps/api/src/lexicon/types/io/pocketenv/sandbox/updateSandboxSettings.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSecretDefs from '../secret/defs'
11
-
import type * as IoPocketenvVariableDefs from '../variable/defs'
12
-
import type * as IoPocketenvFileDefs from '../file/defs'
13
-
import type * as IoPocketenvVolumeDefs from '../volume/defs'
14
-
import type * as IoPocketenvSandboxDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSecretDefs from "../secret/defs";
11
+
import type * as IoPocketenvVariableDefs from "../variable/defs";
12
+
import type * as IoPocketenvFileDefs from "../file/defs";
13
+
import type * as IoPocketenvVolumeDefs from "../volume/defs";
14
+
import type * as IoPocketenvSandboxDefs from "./defs";
15
15
16
-
export type QueryParams = {}
16
+
export type QueryParams = {};
17
17
18
18
export interface InputSchema {
19
19
/** The name of the sandbox */
20
-
name?: string
20
+
name?: string;
21
21
/** A description for the sandbox */
22
-
description?: string
22
+
description?: string;
23
23
/** A list of topics/tags to associate with the sandbox */
24
-
topics?: string[]
24
+
topics?: string[];
25
25
/** A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo. */
26
-
repo?: string
26
+
repo?: string;
27
27
/** The number of virtual CPUs to allocate for the sandbox */
28
-
vcpus?: number
28
+
vcpus?: number;
29
29
/** The amount of memory (in GB) to allocate for the sandbox */
30
-
memory?: number
30
+
memory?: number;
31
31
/** The amount of disk space (in GB) to allocate for the sandbox */
32
-
disk?: number
32
+
disk?: number;
33
33
/** A URI to a README for the sandbox. */
34
-
readme?: string
35
-
secrets?: IoPocketenvSecretDefs.Secrets
36
-
variables?: IoPocketenvVariableDefs.Variables
37
-
files?: IoPocketenvFileDefs.File
38
-
volumes?: IoPocketenvVolumeDefs.Volumes
39
-
[k: string]: unknown
34
+
readme?: string;
35
+
secrets?: IoPocketenvSecretDefs.Secrets;
36
+
variables?: IoPocketenvVariableDefs.Variables;
37
+
files?: IoPocketenvFileDefs.File;
38
+
volumes?: IoPocketenvVolumeDefs.Volumes;
39
+
[k: string]: unknown;
40
40
}
41
41
42
-
export type OutputSchema = IoPocketenvSandboxDefs.ProfileViewDetailed
42
+
export type OutputSchema = IoPocketenvSandboxDefs.ProfileViewDetailed;
43
43
44
44
export interface HandlerInput {
45
-
encoding: 'application/json'
46
-
body: InputSchema
45
+
encoding: "application/json";
46
+
body: InputSchema;
47
47
}
48
48
49
49
export interface HandlerSuccess {
50
-
encoding: 'application/json'
51
-
body: OutputSchema
52
-
headers?: { [key: string]: string }
50
+
encoding: "application/json";
51
+
body: OutputSchema;
52
+
headers?: { [key: string]: string };
53
53
}
54
54
55
55
export interface HandlerError {
56
-
status: number
57
-
message?: string
56
+
status: number;
57
+
message?: string;
58
58
}
59
59
60
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
60
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
61
61
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
62
-
auth: HA
63
-
params: QueryParams
64
-
input: HandlerInput
65
-
req: express.Request
66
-
res: express.Response
67
-
resetRouteRateLimits: () => Promise<void>
68
-
}
62
+
auth: HA;
63
+
params: QueryParams;
64
+
input: HandlerInput;
65
+
req: express.Request;
66
+
res: express.Response;
67
+
resetRouteRateLimits: () => Promise<void>;
68
+
};
69
69
export type Handler<HA extends HandlerAuth = never> = (
70
70
ctx: HandlerReqCtx<HA>,
71
-
) => Promise<HandlerOutput> | HandlerOutput
71
+
) => Promise<HandlerOutput> | HandlerOutput;
+24
-24
apps/api/src/lexicon/types/io/pocketenv/secret/addSecret.ts
+24
-24
apps/api/src/lexicon/types/io/pocketenv/secret/addSecret.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSecretDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSecretDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
-
secret: IoPocketenvSecretDefs.Secret
15
+
secret: IoPocketenvSecretDefs.Secret;
16
16
/** The redacted secret value. */
17
-
redacted?: string
18
-
[k: string]: unknown
17
+
redacted?: string;
18
+
[k: string]: unknown;
19
19
}
20
20
21
21
export interface HandlerInput {
22
-
encoding: 'application/json'
23
-
body: InputSchema
22
+
encoding: "application/json";
23
+
body: InputSchema;
24
24
}
25
25
26
26
export interface HandlerError {
27
-
status: number
28
-
message?: string
27
+
status: number;
28
+
message?: string;
29
29
}
30
30
31
-
export type HandlerOutput = HandlerError | void
31
+
export type HandlerOutput = HandlerError | void;
32
32
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
33
-
auth: HA
34
-
params: QueryParams
35
-
input: HandlerInput
36
-
req: express.Request
37
-
res: express.Response
38
-
resetRouteRateLimits: () => Promise<void>
39
-
}
33
+
auth: HA;
34
+
params: QueryParams;
35
+
input: HandlerInput;
36
+
req: express.Request;
37
+
res: express.Response;
38
+
resetRouteRateLimits: () => Promise<void>;
39
+
};
40
40
export type Handler<HA extends HandlerAuth = never> = (
41
41
ctx: HandlerReqCtx<HA>,
42
-
) => Promise<HandlerOutput> | HandlerOutput
42
+
) => Promise<HandlerOutput> | HandlerOutput;
+20
-20
apps/api/src/lexicon/types/io/pocketenv/secret/defs.ts
+20
-20
apps/api/src/lexicon/types/io/pocketenv/secret/defs.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
8
9
9
export interface SecretView {
10
10
/** Unique identifier of the secret. */
11
-
id?: string
11
+
id?: string;
12
12
/** Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc. */
13
-
name?: string
14
-
[k: string]: unknown
13
+
name?: string;
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
-
hasProp(v, '$type') &&
21
-
v.$type === 'io.pocketenv.secret.defs#secretView'
22
-
)
20
+
hasProp(v, "$type") &&
21
+
v.$type === "io.pocketenv.secret.defs#secretView"
22
+
);
23
23
}
24
24
25
25
export function validateSecretView(v: unknown): ValidationResult {
26
-
return lexicons.validate('io.pocketenv.secret.defs#secretView', v)
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
-
sandboxId?: string
31
+
sandboxId?: string;
32
32
/** Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc. */
33
-
name: string
33
+
name: string;
34
34
/** Value of the secret. This will be encrypted at rest and redacted in any API responses. */
35
-
value: string
36
-
[k: string]: unknown
35
+
value: string;
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
-
hasProp(v, '$type') &&
43
-
v.$type === 'io.pocketenv.secret.defs#secret'
44
-
)
42
+
hasProp(v, "$type") &&
43
+
v.$type === "io.pocketenv.secret.defs#secret"
44
+
);
45
45
}
46
46
47
47
export function validateSecret(v: unknown): ValidationResult {
48
-
return lexicons.validate('io.pocketenv.secret.defs#secret', v)
48
+
return lexicons.validate("io.pocketenv.secret.defs#secret", v);
49
49
}
50
50
51
-
export type Secrets = Secret[]
51
+
export type Secrets = Secret[];
+20
-20
apps/api/src/lexicon/types/io/pocketenv/secret/deleteSecret.ts
+20
-20
apps/api/src/lexicon/types/io/pocketenv/secret/deleteSecret.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
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
-
id: string
13
+
id: string;
14
14
}
15
15
16
-
export type InputSchema = undefined
17
-
export type HandlerInput = undefined
16
+
export type InputSchema = undefined;
17
+
export type HandlerInput = undefined;
18
18
19
19
export interface HandlerError {
20
-
status: number
21
-
message?: string
20
+
status: number;
21
+
message?: string;
22
22
}
23
23
24
-
export type HandlerOutput = HandlerError | void
24
+
export type HandlerOutput = HandlerError | void;
25
25
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
-
auth: HA
27
-
params: QueryParams
28
-
input: HandlerInput
29
-
req: express.Request
30
-
res: express.Response
31
-
resetRouteRateLimits: () => Promise<void>
32
-
}
26
+
auth: HA;
27
+
params: QueryParams;
28
+
input: HandlerInput;
29
+
req: express.Request;
30
+
res: express.Response;
31
+
resetRouteRateLimits: () => Promise<void>;
32
+
};
33
33
export type Handler<HA extends HandlerAuth = never> = (
34
34
ctx: HandlerReqCtx<HA>,
35
-
) => Promise<HandlerOutput> | HandlerOutput
35
+
) => Promise<HandlerOutput> | HandlerOutput;
+26
-26
apps/api/src/lexicon/types/io/pocketenv/secret/getSecret.ts
+26
-26
apps/api/src/lexicon/types/io/pocketenv/secret/getSecret.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSecretDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSecretDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The ID of the secret for which to retrieve secrets. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
17
+
export type InputSchema = undefined;
18
18
19
19
export interface OutputSchema {
20
-
secret?: IoPocketenvSecretDefs.SecretView
21
-
[k: string]: unknown
20
+
secret?: IoPocketenvSecretDefs.SecretView;
21
+
[k: string]: unknown;
22
22
}
23
23
24
-
export type HandlerInput = undefined
24
+
export type HandlerInput = undefined;
25
25
26
26
export interface HandlerSuccess {
27
-
encoding: 'application/json'
28
-
body: OutputSchema
29
-
headers?: { [key: string]: string }
27
+
encoding: "application/json";
28
+
body: OutputSchema;
29
+
headers?: { [key: string]: string };
30
30
}
31
31
32
32
export interface HandlerError {
33
-
status: number
34
-
message?: string
33
+
status: number;
34
+
message?: string;
35
35
}
36
36
37
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
38
38
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
-
auth: HA
40
-
params: QueryParams
41
-
input: HandlerInput
42
-
req: express.Request
43
-
res: express.Response
44
-
resetRouteRateLimits: () => Promise<void>
45
-
}
39
+
auth: HA;
40
+
params: QueryParams;
41
+
input: HandlerInput;
42
+
req: express.Request;
43
+
res: express.Response;
44
+
resetRouteRateLimits: () => Promise<void>;
45
+
};
46
46
export type Handler<HA extends HandlerAuth = never> = (
47
47
ctx: HandlerReqCtx<HA>,
48
-
) => Promise<HandlerOutput> | HandlerOutput
48
+
) => Promise<HandlerOutput> | HandlerOutput;
+29
-29
apps/api/src/lexicon/types/io/pocketenv/secret/getSecrets.ts
+29
-29
apps/api/src/lexicon/types/io/pocketenv/secret/getSecrets.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSecretDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
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
-
sandboxId?: string
14
+
sandboxId?: string;
15
15
/** The maximum number of secrets to return. */
16
-
limit?: number
16
+
limit?: number;
17
17
/** The number of secrets to skip before starting to collect the result set. */
18
-
offset?: number
18
+
offset?: number;
19
19
}
20
20
21
-
export type InputSchema = undefined
21
+
export type InputSchema = undefined;
22
22
23
23
export interface OutputSchema {
24
-
secrets?: IoPocketenvSecretDefs.SecretView[]
24
+
secrets?: IoPocketenvSecretDefs.SecretView[];
25
25
/** The total number of secrets available. */
26
-
total?: number
27
-
[k: string]: unknown
26
+
total?: number;
27
+
[k: string]: unknown;
28
28
}
29
29
30
-
export type HandlerInput = undefined
30
+
export type HandlerInput = undefined;
31
31
32
32
export interface HandlerSuccess {
33
-
encoding: 'application/json'
34
-
body: OutputSchema
35
-
headers?: { [key: string]: string }
33
+
encoding: "application/json";
34
+
body: OutputSchema;
35
+
headers?: { [key: string]: string };
36
36
}
37
37
38
38
export interface HandlerError {
39
-
status: number
40
-
message?: string
39
+
status: number;
40
+
message?: string;
41
41
}
42
42
43
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
43
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
44
44
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
45
-
auth: HA
46
-
params: QueryParams
47
-
input: HandlerInput
48
-
req: express.Request
49
-
res: express.Response
50
-
resetRouteRateLimits: () => Promise<void>
51
-
}
45
+
auth: HA;
46
+
params: QueryParams;
47
+
input: HandlerInput;
48
+
req: express.Request;
49
+
res: express.Response;
50
+
resetRouteRateLimits: () => Promise<void>;
51
+
};
52
52
export type Handler<HA extends HandlerAuth = never> = (
53
53
ctx: HandlerReqCtx<HA>,
54
-
) => Promise<HandlerOutput> | HandlerOutput
54
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/secret/updateSecret.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/secret/updateSecret.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvSecretDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvSecretDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The ID of the secret to update. */
16
-
id: string
17
-
secret: IoPocketenvSecretDefs.Secret
16
+
id: string;
17
+
secret: IoPocketenvSecretDefs.Secret;
18
18
/** The redacted secret value. */
19
-
redacted?: string
20
-
[k: string]: unknown
19
+
redacted?: string;
20
+
[k: string]: unknown;
21
21
}
22
22
23
23
export interface HandlerInput {
24
-
encoding: 'application/json'
25
-
body: InputSchema
24
+
encoding: "application/json";
25
+
body: InputSchema;
26
26
}
27
27
28
28
export interface HandlerError {
29
-
status: number
30
-
message?: string
29
+
status: number;
30
+
message?: string;
31
31
}
32
32
33
-
export type HandlerOutput = HandlerError | void
33
+
export type HandlerOutput = HandlerError | void;
34
34
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
35
-
auth: HA
36
-
params: QueryParams
37
-
input: HandlerInput
38
-
req: express.Request
39
-
res: express.Response
40
-
resetRouteRateLimits: () => Promise<void>
41
-
}
35
+
auth: HA;
36
+
params: QueryParams;
37
+
input: HandlerInput;
38
+
req: express.Request;
39
+
res: express.Response;
40
+
resetRouteRateLimits: () => Promise<void>;
41
+
};
42
42
export type Handler<HA extends HandlerAuth = never> = (
43
43
ctx: HandlerReqCtx<HA>,
44
-
) => Promise<HandlerOutput> | HandlerOutput
44
+
) => Promise<HandlerOutput> | HandlerOutput;
+40
apps/api/src/lexicon/types/io/pocketenv/service/addService.ts
+40
apps/api/src/lexicon/types/io/pocketenv/service/addService.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvServiceDefs from "./defs";
11
+
12
+
export type QueryParams = {};
13
+
14
+
export interface InputSchema {
15
+
service: IoPocketenvServiceDefs.Service;
16
+
[k: string]: unknown;
17
+
}
18
+
19
+
export interface HandlerInput {
20
+
encoding: "application/json";
21
+
body: InputSchema;
22
+
}
23
+
24
+
export interface HandlerError {
25
+
status: number;
26
+
message?: string;
27
+
}
28
+
29
+
export type HandlerOutput = HandlerError | void;
30
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
31
+
auth: HA;
32
+
params: QueryParams;
33
+
input: HandlerInput;
34
+
req: express.Request;
35
+
res: express.Response;
36
+
resetRouteRateLimits: () => Promise<void>;
37
+
};
38
+
export type Handler<HA extends HandlerAuth = never> = (
39
+
ctx: HandlerReqCtx<HA>,
40
+
) => Promise<HandlerOutput> | HandlerOutput;
+57
apps/api/src/lexicon/types/io/pocketenv/service/defs.ts
+57
apps/api/src/lexicon/types/io/pocketenv/service/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
+
9
+
export interface ServiceView {
10
+
/** Unique identifier of the service. */
11
+
id?: string;
12
+
/** Name of the service. */
13
+
name?: string;
14
+
/** Command to run the service. */
15
+
command?: string;
16
+
/** Description of the service. */
17
+
description?: string;
18
+
ports?: number[];
19
+
createdAt?: string;
20
+
updatedAt?: string;
21
+
[k: string]: unknown;
22
+
}
23
+
24
+
export function isServiceView(v: unknown): v is ServiceView {
25
+
return (
26
+
isObj(v) &&
27
+
hasProp(v, "$type") &&
28
+
v.$type === "io.pocketenv.service.defs#serviceView"
29
+
);
30
+
}
31
+
32
+
export function validateServiceView(v: unknown): ValidationResult {
33
+
return lexicons.validate("io.pocketenv.service.defs#serviceView", v);
34
+
}
35
+
36
+
export interface Service {
37
+
/** Name of the service. */
38
+
name: string;
39
+
/** Command to run the service. */
40
+
command: string;
41
+
/** Description of the service. */
42
+
description?: string;
43
+
ports?: number[];
44
+
[k: string]: unknown;
45
+
}
46
+
47
+
export function isService(v: unknown): v is Service {
48
+
return (
49
+
isObj(v) &&
50
+
hasProp(v, "$type") &&
51
+
v.$type === "io.pocketenv.service.defs#service"
52
+
);
53
+
}
54
+
55
+
export function validateService(v: unknown): ValidationResult {
56
+
return lexicons.validate("io.pocketenv.service.defs#service", v);
57
+
}
+35
apps/api/src/lexicon/types/io/pocketenv/service/deleteService.ts
+35
apps/api/src/lexicon/types/io/pocketenv/service/deleteService.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
11
+
export interface QueryParams {
12
+
/** The ID of the service to delete. */
13
+
serviceId: string;
14
+
}
15
+
16
+
export type InputSchema = undefined;
17
+
export type HandlerInput = undefined;
18
+
19
+
export interface HandlerError {
20
+
status: number;
21
+
message?: string;
22
+
}
23
+
24
+
export type HandlerOutput = HandlerError | void;
25
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
+
auth: HA;
27
+
params: QueryParams;
28
+
input: HandlerInput;
29
+
req: express.Request;
30
+
res: express.Response;
31
+
resetRouteRateLimits: () => Promise<void>;
32
+
};
33
+
export type Handler<HA extends HandlerAuth = never> = (
34
+
ctx: HandlerReqCtx<HA>,
35
+
) => Promise<HandlerOutput> | HandlerOutput;
+48
apps/api/src/lexicon/types/io/pocketenv/service/getServices.ts
+48
apps/api/src/lexicon/types/io/pocketenv/service/getServices.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvServiceDefs from "./defs";
11
+
12
+
export interface QueryParams {
13
+
/** The ID of the sandbox for which to retrieve services. */
14
+
sandboxId: string;
15
+
}
16
+
17
+
export type InputSchema = undefined;
18
+
19
+
export interface OutputSchema {
20
+
services?: IoPocketenvServiceDefs.ServiceView[];
21
+
[k: string]: unknown;
22
+
}
23
+
24
+
export type HandlerInput = undefined;
25
+
26
+
export interface HandlerSuccess {
27
+
encoding: "application/json";
28
+
body: OutputSchema;
29
+
headers?: { [key: string]: string };
30
+
}
31
+
32
+
export interface HandlerError {
33
+
status: number;
34
+
message?: string;
35
+
}
36
+
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
38
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
+
auth: HA;
40
+
params: QueryParams;
41
+
input: HandlerInput;
42
+
req: express.Request;
43
+
res: express.Response;
44
+
resetRouteRateLimits: () => Promise<void>;
45
+
};
46
+
export type Handler<HA extends HandlerAuth = never> = (
47
+
ctx: HandlerReqCtx<HA>,
48
+
) => Promise<HandlerOutput> | HandlerOutput;
+35
apps/api/src/lexicon/types/io/pocketenv/service/restartService.ts
+35
apps/api/src/lexicon/types/io/pocketenv/service/restartService.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
11
+
export interface QueryParams {
12
+
/** The ID of the service to restart. */
13
+
serviceId: string;
14
+
}
15
+
16
+
export type InputSchema = undefined;
17
+
export type HandlerInput = undefined;
18
+
19
+
export interface HandlerError {
20
+
status: number;
21
+
message?: string;
22
+
}
23
+
24
+
export type HandlerOutput = HandlerError | void;
25
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
+
auth: HA;
27
+
params: QueryParams;
28
+
input: HandlerInput;
29
+
req: express.Request;
30
+
res: express.Response;
31
+
resetRouteRateLimits: () => Promise<void>;
32
+
};
33
+
export type Handler<HA extends HandlerAuth = never> = (
34
+
ctx: HandlerReqCtx<HA>,
35
+
) => Promise<HandlerOutput> | HandlerOutput;
+43
apps/api/src/lexicon/types/io/pocketenv/service/updateService.ts
+43
apps/api/src/lexicon/types/io/pocketenv/service/updateService.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvServiceDefs from "./defs";
11
+
12
+
export interface QueryParams {
13
+
/** The ID of the service to delete. */
14
+
serviceId: string;
15
+
}
16
+
17
+
export interface InputSchema {
18
+
service: IoPocketenvServiceDefs.Service;
19
+
[k: string]: unknown;
20
+
}
21
+
22
+
export interface HandlerInput {
23
+
encoding: "application/json";
24
+
body: InputSchema;
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number;
29
+
message?: string;
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | void;
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA;
35
+
params: QueryParams;
36
+
input: HandlerInput;
37
+
req: express.Request;
38
+
res: express.Response;
39
+
resetRouteRateLimits: () => Promise<void>;
40
+
};
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput;
+23
-23
apps/api/src/lexicon/types/io/pocketenv/variable/addVariable.ts
+23
-23
apps/api/src/lexicon/types/io/pocketenv/variable/addVariable.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvVariableDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvVariableDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
-
variable: IoPocketenvVariableDefs.Variable
16
-
[k: string]: unknown
15
+
variable: IoPocketenvVariableDefs.Variable;
16
+
[k: string]: unknown;
17
17
}
18
18
19
19
export interface HandlerInput {
20
-
encoding: 'application/json'
21
-
body: InputSchema
20
+
encoding: "application/json";
21
+
body: InputSchema;
22
22
}
23
23
24
24
export interface HandlerError {
25
-
status: number
26
-
message?: string
25
+
status: number;
26
+
message?: string;
27
27
}
28
28
29
-
export type HandlerOutput = HandlerError | void
29
+
export type HandlerOutput = HandlerError | void;
30
30
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
31
-
auth: HA
32
-
params: QueryParams
33
-
input: HandlerInput
34
-
req: express.Request
35
-
res: express.Response
36
-
resetRouteRateLimits: () => Promise<void>
37
-
}
31
+
auth: HA;
32
+
params: QueryParams;
33
+
input: HandlerInput;
34
+
req: express.Request;
35
+
res: express.Response;
36
+
resetRouteRateLimits: () => Promise<void>;
37
+
};
38
38
export type Handler<HA extends HandlerAuth = never> = (
39
39
ctx: HandlerReqCtx<HA>,
40
-
) => Promise<HandlerOutput> | HandlerOutput
40
+
) => Promise<HandlerOutput> | HandlerOutput;
+21
-21
apps/api/src/lexicon/types/io/pocketenv/variable/defs.ts
+21
-21
apps/api/src/lexicon/types/io/pocketenv/variable/defs.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
8
9
9
export interface VariableView {
10
10
/** Unique identifier of the environment variable. */
11
-
id?: string
11
+
id?: string;
12
12
/** Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc. */
13
-
name?: string
13
+
name?: string;
14
14
/** Value of the environment variable. This will be visible in API responses and should not contain sensitive information. */
15
-
value?: string
16
-
[k: string]: unknown
15
+
value?: string;
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
-
hasProp(v, '$type') &&
23
-
v.$type === 'io.pocketenv.variable.defs#variableView'
24
-
)
22
+
hasProp(v, "$type") &&
23
+
v.$type === "io.pocketenv.variable.defs#variableView"
24
+
);
25
25
}
26
26
27
27
export function validateVariableView(v: unknown): ValidationResult {
28
-
return lexicons.validate('io.pocketenv.variable.defs#variableView', v)
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
-
sandboxId?: string
33
+
sandboxId?: string;
34
34
/** Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc. */
35
-
name: string
35
+
name: string;
36
36
/** Value of the environment variable. This will be visible in API responses and should not contain sensitive information. */
37
-
value: string
38
-
[k: string]: unknown
37
+
value: string;
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
-
hasProp(v, '$type') &&
45
-
v.$type === 'io.pocketenv.variable.defs#variable'
46
-
)
44
+
hasProp(v, "$type") &&
45
+
v.$type === "io.pocketenv.variable.defs#variable"
46
+
);
47
47
}
48
48
49
49
export function validateVariable(v: unknown): ValidationResult {
50
-
return lexicons.validate('io.pocketenv.variable.defs#variable', v)
50
+
return lexicons.validate("io.pocketenv.variable.defs#variable", v);
51
51
}
52
52
53
-
export type Variables = EnvVar[]
53
+
export type Variables = EnvVar[];
+20
-20
apps/api/src/lexicon/types/io/pocketenv/variable/deleteVariable.ts
+20
-20
apps/api/src/lexicon/types/io/pocketenv/variable/deleteVariable.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
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
-
id: string
13
+
id: string;
14
14
}
15
15
16
-
export type InputSchema = undefined
17
-
export type HandlerInput = undefined
16
+
export type InputSchema = undefined;
17
+
export type HandlerInput = undefined;
18
18
19
19
export interface HandlerError {
20
-
status: number
21
-
message?: string
20
+
status: number;
21
+
message?: string;
22
22
}
23
23
24
-
export type HandlerOutput = HandlerError | void
24
+
export type HandlerOutput = HandlerError | void;
25
25
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
-
auth: HA
27
-
params: QueryParams
28
-
input: HandlerInput
29
-
req: express.Request
30
-
res: express.Response
31
-
resetRouteRateLimits: () => Promise<void>
32
-
}
26
+
auth: HA;
27
+
params: QueryParams;
28
+
input: HandlerInput;
29
+
req: express.Request;
30
+
res: express.Response;
31
+
resetRouteRateLimits: () => Promise<void>;
32
+
};
33
33
export type Handler<HA extends HandlerAuth = never> = (
34
34
ctx: HandlerReqCtx<HA>,
35
-
) => Promise<HandlerOutput> | HandlerOutput
35
+
) => Promise<HandlerOutput> | HandlerOutput;
+26
-26
apps/api/src/lexicon/types/io/pocketenv/variable/getVariable.ts
+26
-26
apps/api/src/lexicon/types/io/pocketenv/variable/getVariable.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvVariableDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvVariableDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The ID of the variable for which to retrieve variables. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
17
+
export type InputSchema = undefined;
18
18
19
19
export interface OutputSchema {
20
-
variable?: IoPocketenvVariableDefs.VariableView
21
-
[k: string]: unknown
20
+
variable?: IoPocketenvVariableDefs.VariableView;
21
+
[k: string]: unknown;
22
22
}
23
23
24
-
export type HandlerInput = undefined
24
+
export type HandlerInput = undefined;
25
25
26
26
export interface HandlerSuccess {
27
-
encoding: 'application/json'
28
-
body: OutputSchema
29
-
headers?: { [key: string]: string }
27
+
encoding: "application/json";
28
+
body: OutputSchema;
29
+
headers?: { [key: string]: string };
30
30
}
31
31
32
32
export interface HandlerError {
33
-
status: number
34
-
message?: string
33
+
status: number;
34
+
message?: string;
35
35
}
36
36
37
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
38
38
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
-
auth: HA
40
-
params: QueryParams
41
-
input: HandlerInput
42
-
req: express.Request
43
-
res: express.Response
44
-
resetRouteRateLimits: () => Promise<void>
45
-
}
39
+
auth: HA;
40
+
params: QueryParams;
41
+
input: HandlerInput;
42
+
req: express.Request;
43
+
res: express.Response;
44
+
resetRouteRateLimits: () => Promise<void>;
45
+
};
46
46
export type Handler<HA extends HandlerAuth = never> = (
47
47
ctx: HandlerReqCtx<HA>,
48
-
) => Promise<HandlerOutput> | HandlerOutput
48
+
) => Promise<HandlerOutput> | HandlerOutput;
+29
-29
apps/api/src/lexicon/types/io/pocketenv/variable/getVariables.ts
+29
-29
apps/api/src/lexicon/types/io/pocketenv/variable/getVariables.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvVariableDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
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
-
sandboxId?: string
14
+
sandboxId?: string;
15
15
/** The maximum number of variables to return. */
16
-
limit?: number
16
+
limit?: number;
17
17
/** The number of variables to skip before starting to collect the result set. */
18
-
offset?: number
18
+
offset?: number;
19
19
}
20
20
21
-
export type InputSchema = undefined
21
+
export type InputSchema = undefined;
22
22
23
23
export interface OutputSchema {
24
-
variables?: IoPocketenvVariableDefs.VariableView[]
24
+
variables?: IoPocketenvVariableDefs.VariableView[];
25
25
/** The total number of variables available. */
26
-
total?: number
27
-
[k: string]: unknown
26
+
total?: number;
27
+
[k: string]: unknown;
28
28
}
29
29
30
-
export type HandlerInput = undefined
30
+
export type HandlerInput = undefined;
31
31
32
32
export interface HandlerSuccess {
33
-
encoding: 'application/json'
34
-
body: OutputSchema
35
-
headers?: { [key: string]: string }
33
+
encoding: "application/json";
34
+
body: OutputSchema;
35
+
headers?: { [key: string]: string };
36
36
}
37
37
38
38
export interface HandlerError {
39
-
status: number
40
-
message?: string
39
+
status: number;
40
+
message?: string;
41
41
}
42
42
43
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
43
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
44
44
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
45
-
auth: HA
46
-
params: QueryParams
47
-
input: HandlerInput
48
-
req: express.Request
49
-
res: express.Response
50
-
resetRouteRateLimits: () => Promise<void>
51
-
}
45
+
auth: HA;
46
+
params: QueryParams;
47
+
input: HandlerInput;
48
+
req: express.Request;
49
+
res: express.Response;
50
+
resetRouteRateLimits: () => Promise<void>;
51
+
};
52
52
export type Handler<HA extends HandlerAuth = never> = (
53
53
ctx: HandlerReqCtx<HA>,
54
-
) => Promise<HandlerOutput> | HandlerOutput
54
+
) => Promise<HandlerOutput> | HandlerOutput;
+24
-24
apps/api/src/lexicon/types/io/pocketenv/variable/updateVariable.ts
+24
-24
apps/api/src/lexicon/types/io/pocketenv/variable/updateVariable.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvVariableDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvVariableDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The ID of the variable to update. */
16
-
id: string
17
-
variable: IoPocketenvVariableDefs.Variable
18
-
[k: string]: unknown
16
+
id: string;
17
+
variable: IoPocketenvVariableDefs.Variable;
18
+
[k: string]: unknown;
19
19
}
20
20
21
21
export interface HandlerInput {
22
-
encoding: 'application/json'
23
-
body: InputSchema
22
+
encoding: "application/json";
23
+
body: InputSchema;
24
24
}
25
25
26
26
export interface HandlerError {
27
-
status: number
28
-
message?: string
27
+
status: number;
28
+
message?: string;
29
29
}
30
30
31
-
export type HandlerOutput = HandlerError | void
31
+
export type HandlerOutput = HandlerError | void;
32
32
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
33
-
auth: HA
34
-
params: QueryParams
35
-
input: HandlerInput
36
-
req: express.Request
37
-
res: express.Response
38
-
resetRouteRateLimits: () => Promise<void>
39
-
}
33
+
auth: HA;
34
+
params: QueryParams;
35
+
input: HandlerInput;
36
+
req: express.Request;
37
+
res: express.Response;
38
+
resetRouteRateLimits: () => Promise<void>;
39
+
};
40
40
export type Handler<HA extends HandlerAuth = never> = (
41
41
ctx: HandlerReqCtx<HA>,
42
-
) => Promise<HandlerOutput> | HandlerOutput
42
+
) => Promise<HandlerOutput> | HandlerOutput;
+23
-23
apps/api/src/lexicon/types/io/pocketenv/volume/addVolume.ts
+23
-23
apps/api/src/lexicon/types/io/pocketenv/volume/addVolume.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvVolumeDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvVolumeDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
-
volume: IoPocketenvVolumeDefs.Volume
16
-
[k: string]: unknown
15
+
volume: IoPocketenvVolumeDefs.Volume;
16
+
[k: string]: unknown;
17
17
}
18
18
19
19
export interface HandlerInput {
20
-
encoding: 'application/json'
21
-
body: InputSchema
20
+
encoding: "application/json";
21
+
body: InputSchema;
22
22
}
23
23
24
24
export interface HandlerError {
25
-
status: number
26
-
message?: string
25
+
status: number;
26
+
message?: string;
27
27
}
28
28
29
-
export type HandlerOutput = HandlerError | void
29
+
export type HandlerOutput = HandlerError | void;
30
30
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
31
-
auth: HA
32
-
params: QueryParams
33
-
input: HandlerInput
34
-
req: express.Request
35
-
res: express.Response
36
-
resetRouteRateLimits: () => Promise<void>
37
-
}
31
+
auth: HA;
32
+
params: QueryParams;
33
+
input: HandlerInput;
34
+
req: express.Request;
35
+
res: express.Response;
36
+
resetRouteRateLimits: () => Promise<void>;
37
+
};
38
38
export type Handler<HA extends HandlerAuth = never> = (
39
39
ctx: HandlerReqCtx<HA>,
40
-
) => Promise<HandlerOutput> | HandlerOutput
40
+
) => Promise<HandlerOutput> | HandlerOutput;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/volume/defs.ts
+25
-25
apps/api/src/lexicon/types/io/pocketenv/volume/defs.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import { type ValidationResult, BlobRef } from '@atproto/lexicon'
5
-
import { lexicons } from '../../../../lexicons'
6
-
import { isObj, hasProp } from '../../../../util'
7
-
import { CID } from 'multiformats/cid'
4
+
import { type ValidationResult, BlobRef } from "@atproto/lexicon";
5
+
import { lexicons } from "../../../../lexicons";
6
+
import { isObj, hasProp } from "../../../../util";
7
+
import { CID } from "multiformats/cid";
8
8
9
9
export interface VolumeView {
10
10
/** Unique identifier of the volume. */
11
-
id?: string
11
+
id?: string;
12
12
/** Name of the volume, e.g. 'data-volume', 'logs', etc. */
13
-
name?: string
13
+
name?: string;
14
14
/** The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc. */
15
-
path?: string
15
+
path?: string;
16
16
/** Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write). */
17
-
readOnly?: boolean
17
+
readOnly?: boolean;
18
18
/** The timestamp when the volume was created. */
19
-
createdAt?: string
19
+
createdAt?: string;
20
20
/** The timestamp when the volume was last updated. */
21
-
updatedAt?: string
22
-
[k: string]: unknown
21
+
updatedAt?: string;
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
-
hasProp(v, '$type') &&
29
-
v.$type === 'io.pocketenv.volume.defs#volumeView'
30
-
)
28
+
hasProp(v, "$type") &&
29
+
v.$type === "io.pocketenv.volume.defs#volumeView"
30
+
);
31
31
}
32
32
33
33
export function validateVolumeView(v: unknown): ValidationResult {
34
-
return lexicons.validate('io.pocketenv.volume.defs#volumeView', v)
34
+
return lexicons.validate("io.pocketenv.volume.defs#volumeView", v);
35
35
}
36
36
37
-
export type Volumes = Volume[]
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
-
sandboxId?: string
41
+
sandboxId?: string;
42
42
/** Name of the volume, e.g. 'data-volume', 'logs', etc. */
43
-
name: string
43
+
name: string;
44
44
/** The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc. */
45
-
path?: string
45
+
path?: string;
46
46
/** Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write). */
47
-
readOnly?: boolean
48
-
[k: string]: unknown
47
+
readOnly?: boolean;
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
-
hasProp(v, '$type') &&
55
-
v.$type === 'io.pocketenv.volume.defs#volume'
56
-
)
54
+
hasProp(v, "$type") &&
55
+
v.$type === "io.pocketenv.volume.defs#volume"
56
+
);
57
57
}
58
58
59
59
export function validateVolume(v: unknown): ValidationResult {
60
-
return lexicons.validate('io.pocketenv.volume.defs#volume', v)
60
+
return lexicons.validate("io.pocketenv.volume.defs#volume", v);
61
61
}
+20
-20
apps/api/src/lexicon/types/io/pocketenv/volume/deleteVolume.ts
+20
-20
apps/api/src/lexicon/types/io/pocketenv/volume/deleteVolume.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
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
-
id: string
13
+
id: string;
14
14
}
15
15
16
-
export type InputSchema = undefined
17
-
export type HandlerInput = undefined
16
+
export type InputSchema = undefined;
17
+
export type HandlerInput = undefined;
18
18
19
19
export interface HandlerError {
20
-
status: number
21
-
message?: string
20
+
status: number;
21
+
message?: string;
22
22
}
23
23
24
-
export type HandlerOutput = HandlerError | void
24
+
export type HandlerOutput = HandlerError | void;
25
25
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
-
auth: HA
27
-
params: QueryParams
28
-
input: HandlerInput
29
-
req: express.Request
30
-
res: express.Response
31
-
resetRouteRateLimits: () => Promise<void>
32
-
}
26
+
auth: HA;
27
+
params: QueryParams;
28
+
input: HandlerInput;
29
+
req: express.Request;
30
+
res: express.Response;
31
+
resetRouteRateLimits: () => Promise<void>;
32
+
};
33
33
export type Handler<HA extends HandlerAuth = never> = (
34
34
ctx: HandlerReqCtx<HA>,
35
-
) => Promise<HandlerOutput> | HandlerOutput
35
+
) => Promise<HandlerOutput> | HandlerOutput;
+26
-26
apps/api/src/lexicon/types/io/pocketenv/volume/getVolume.ts
+26
-26
apps/api/src/lexicon/types/io/pocketenv/volume/getVolume.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvVolumeDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvVolumeDefs from "./defs";
11
11
12
12
export interface QueryParams {
13
13
/** The ID of the volume for which to retrieve volumes. */
14
-
id: string
14
+
id: string;
15
15
}
16
16
17
-
export type InputSchema = undefined
17
+
export type InputSchema = undefined;
18
18
19
19
export interface OutputSchema {
20
-
volume?: IoPocketenvVolumeDefs.VolumeView
21
-
[k: string]: unknown
20
+
volume?: IoPocketenvVolumeDefs.VolumeView;
21
+
[k: string]: unknown;
22
22
}
23
23
24
-
export type HandlerInput = undefined
24
+
export type HandlerInput = undefined;
25
25
26
26
export interface HandlerSuccess {
27
-
encoding: 'application/json'
28
-
body: OutputSchema
29
-
headers?: { [key: string]: string }
27
+
encoding: "application/json";
28
+
body: OutputSchema;
29
+
headers?: { [key: string]: string };
30
30
}
31
31
32
32
export interface HandlerError {
33
-
status: number
34
-
message?: string
33
+
status: number;
34
+
message?: string;
35
35
}
36
36
37
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
38
38
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
-
auth: HA
40
-
params: QueryParams
41
-
input: HandlerInput
42
-
req: express.Request
43
-
res: express.Response
44
-
resetRouteRateLimits: () => Promise<void>
45
-
}
39
+
auth: HA;
40
+
params: QueryParams;
41
+
input: HandlerInput;
42
+
req: express.Request;
43
+
res: express.Response;
44
+
resetRouteRateLimits: () => Promise<void>;
45
+
};
46
46
export type Handler<HA extends HandlerAuth = never> = (
47
47
ctx: HandlerReqCtx<HA>,
48
-
) => Promise<HandlerOutput> | HandlerOutput
48
+
) => Promise<HandlerOutput> | HandlerOutput;
+29
-29
apps/api/src/lexicon/types/io/pocketenv/volume/getVolumes.ts
+29
-29
apps/api/src/lexicon/types/io/pocketenv/volume/getVolumes.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvVolumeDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
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
-
sandboxId?: string
14
+
sandboxId?: string;
15
15
/** The maximum number of volumes to return. */
16
-
limit?: number
16
+
limit?: number;
17
17
/** The number of volumes to skip before starting to collect the result set. */
18
-
offset?: number
18
+
offset?: number;
19
19
}
20
20
21
-
export type InputSchema = undefined
21
+
export type InputSchema = undefined;
22
22
23
23
export interface OutputSchema {
24
-
volumes?: IoPocketenvVolumeDefs.VolumeView[]
24
+
volumes?: IoPocketenvVolumeDefs.VolumeView[];
25
25
/** The total number of volumes available. */
26
-
total?: number
27
-
[k: string]: unknown
26
+
total?: number;
27
+
[k: string]: unknown;
28
28
}
29
29
30
-
export type HandlerInput = undefined
30
+
export type HandlerInput = undefined;
31
31
32
32
export interface HandlerSuccess {
33
-
encoding: 'application/json'
34
-
body: OutputSchema
35
-
headers?: { [key: string]: string }
33
+
encoding: "application/json";
34
+
body: OutputSchema;
35
+
headers?: { [key: string]: string };
36
36
}
37
37
38
38
export interface HandlerError {
39
-
status: number
40
-
message?: string
39
+
status: number;
40
+
message?: string;
41
41
}
42
42
43
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
43
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
44
44
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
45
-
auth: HA
46
-
params: QueryParams
47
-
input: HandlerInput
48
-
req: express.Request
49
-
res: express.Response
50
-
resetRouteRateLimits: () => Promise<void>
51
-
}
45
+
auth: HA;
46
+
params: QueryParams;
47
+
input: HandlerInput;
48
+
req: express.Request;
49
+
res: express.Response;
50
+
resetRouteRateLimits: () => Promise<void>;
51
+
};
52
52
export type Handler<HA extends HandlerAuth = never> = (
53
53
ctx: HandlerReqCtx<HA>,
54
-
) => Promise<HandlerOutput> | HandlerOutput
54
+
) => Promise<HandlerOutput> | HandlerOutput;
+24
-24
apps/api/src/lexicon/types/io/pocketenv/volume/updateVolume.ts
+24
-24
apps/api/src/lexicon/types/io/pocketenv/volume/updateVolume.ts
···
1
1
/**
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
-
import type express from 'express'
5
-
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
-
import { lexicons } from '../../../../lexicons'
7
-
import { isObj, hasProp } from '../../../../util'
8
-
import { CID } from 'multiformats/cid'
9
-
import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
-
import type * as IoPocketenvVolumeDefs from './defs'
4
+
import type express from "express";
5
+
import { ValidationResult, BlobRef } from "@atproto/lexicon";
6
+
import { lexicons } from "../../../../lexicons";
7
+
import { isObj, hasProp } from "../../../../util";
8
+
import { CID } from "multiformats/cid";
9
+
import { type HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
10
+
import type * as IoPocketenvVolumeDefs from "./defs";
11
11
12
-
export type QueryParams = {}
12
+
export type QueryParams = {};
13
13
14
14
export interface InputSchema {
15
15
/** The ID of the volume to update. */
16
-
id: string
17
-
volume: IoPocketenvVolumeDefs.Volume
18
-
[k: string]: unknown
16
+
id: string;
17
+
volume: IoPocketenvVolumeDefs.Volume;
18
+
[k: string]: unknown;
19
19
}
20
20
21
21
export interface HandlerInput {
22
-
encoding: 'application/json'
23
-
body: InputSchema
22
+
encoding: "application/json";
23
+
body: InputSchema;
24
24
}
25
25
26
26
export interface HandlerError {
27
-
status: number
28
-
message?: string
27
+
status: number;
28
+
message?: string;
29
29
}
30
30
31
-
export type HandlerOutput = HandlerError | void
31
+
export type HandlerOutput = HandlerError | void;
32
32
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
33
-
auth: HA
34
-
params: QueryParams
35
-
input: HandlerInput
36
-
req: express.Request
37
-
res: express.Response
38
-
resetRouteRateLimits: () => Promise<void>
39
-
}
33
+
auth: HA;
34
+
params: QueryParams;
35
+
input: HandlerInput;
36
+
req: express.Request;
37
+
res: express.Response;
38
+
resetRouteRateLimits: () => Promise<void>;
39
+
};
40
40
export type Handler<HA extends HandlerAuth = never> = (
41
41
ctx: HandlerReqCtx<HA>,
42
-
) => Promise<HandlerOutput> | HandlerOutput
42
+
) => Promise<HandlerOutput> | HandlerOutput;
+2
-2
apps/api/src/lexicon/util.ts
+2
-2
apps/api/src/lexicon/util.ts
···
2
2
* GENERATED CODE - DO NOT MODIFY
3
3
*/
4
4
export function isObj(v: unknown): v is Record<string, unknown> {
5
-
return typeof v === 'object' && v !== null
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
-
return prop in data
12
+
return prop in data;
13
13
}
+1
-3
apps/api/src/schema/sandbox-ports.ts
+1
-3
apps/api/src/schema/sandbox-ports.ts
+2
-3
apps/api/src/schema/services.ts
+2
-3
apps/api/src/schema/services.ts
···
5
5
const services = pgTable(
6
6
"services",
7
7
{
8
-
id: text("id")
9
-
.primaryKey()
10
-
.default(sql`xata_id()`),
8
+
id: text("id").primaryKey().default(sql`xata_id()`),
11
9
sandboxId: text("sandbox_id")
12
10
.notNull()
13
11
.references(() => sandboxes.id),
14
12
name: text("name").notNull(),
15
13
command: text("command").notNull(),
16
14
description: text("description"),
15
+
serviceId: text("service_id"),
17
16
createdAt: timestamp("created_at").defaultNow().notNull(),
18
17
updatedAt: timestamp("updated_at").defaultNow().notNull(),
19
18
},
+10
apps/api/src/xrpc/index.ts
+10
apps/api/src/xrpc/index.ts
···
43
43
import unexposePort from "./io/pocketenv/sandbox/unexposePort";
44
44
import exposeVscode from "./io/pocketenv/sandbox/exposeVscode";
45
45
import exec from "./io/pocketenv/sandbox/exec";
46
+
import addService from "./io/pocketenv/service/addService";
47
+
import deleteService from "./io/pocketenv/service/deleteService";
48
+
import getServices from "./io/pocketenv/service/getServices";
49
+
import restartService from "./io/pocketenv/service/restartService";
50
+
import updateService from "./io/pocketenv/service/updateService";
46
51
47
52
export default function (server: Server, ctx: Context) {
48
53
// io.pocketenv
···
92
97
unexposePort(server, ctx);
93
98
exposeVscode(server, ctx);
94
99
exec(server, ctx);
100
+
addService(server, ctx);
101
+
deleteService(server, ctx);
102
+
getServices(server, ctx);
103
+
restartService(server, ctx);
104
+
updateService(server, ctx);
95
105
96
106
return server;
97
107
}
+4
apps/api/src/xrpc/io/pocketenv/service/addService.ts
+4
apps/api/src/xrpc/io/pocketenv/service/addService.ts
+4
apps/api/src/xrpc/io/pocketenv/service/deleteService.ts
+4
apps/api/src/xrpc/io/pocketenv/service/deleteService.ts
+4
apps/api/src/xrpc/io/pocketenv/service/getServices.ts
+4
apps/api/src/xrpc/io/pocketenv/service/getServices.ts
+4
apps/api/src/xrpc/io/pocketenv/service/restartService.ts
+4
apps/api/src/xrpc/io/pocketenv/service/restartService.ts
+4
apps/api/src/xrpc/io/pocketenv/service/updateService.ts
+4
apps/api/src/xrpc/io/pocketenv/service/updateService.ts
+15
-2
apps/cf-sandbox/deploy/pkgx/Dockerfile
+15
-2
apps/cf-sandbox/deploy/pkgx/Dockerfile
···
2
2
3
3
ARG TARGETARCH
4
4
5
+
COPY --from=docker.io/library/node:24 /usr/local/bin/node /usr/local/bin/node
6
+
7
+
COPY --from=docker.io/library/node:24 /usr/local/include /usr/local/include
8
+
9
+
COPY --from=docker.io/library/node:24 /usr/local/lib/node_modules /usr/local/lib/node_modules
10
+
11
+
RUN printf '#!/bin/sh\nexec node /usr/local/lib/node_modules/npm/bin/npm-cli.js "$@"\n' > /usr/local/bin/npm && \
12
+
printf '#!/bin/sh\nexec node /usr/local/lib/node_modules/npm/bin/npx-cli.js "$@"\n' > /usr/local/bin/npx && \
13
+
chmod +x /usr/local/bin/npm /usr/local/bin/npx
14
+
15
+
RUN mkdir -p ~/.npm-global && npm config set prefix ~/.npm-global
16
+
17
+
ENV PATH "/root/.npm-global/bin:${PATH}"
18
+
5
19
RUN apt-get update -y && apt-get install -y \
6
20
curl \
7
21
git \
···
61
75
62
76
RUN chmod a+x /root/.local/bin/banner.sh
63
77
64
-
RUN pkgm install node && \
65
-
npm install -g pm2
78
+
RUN npm install -g pm2
66
79
67
80
RUN curl -fsSL https://code-server.dev/install.sh | sh && \
68
81
code-server --install-extension bastndev.lynx-theme --force && \
+1
apps/cf-sandbox/drizzle/0033_ambiguous_masked_marvel.sql
+1
apps/cf-sandbox/drizzle/0033_ambiguous_masked_marvel.sql
···
1
+
ALTER TABLE "services" ADD COLUMN "service_id" text;
+1444
apps/cf-sandbox/drizzle/meta/0033_snapshot.json
+1444
apps/cf-sandbox/drizzle/meta/0033_snapshot.json
···
1
+
{
2
+
"id": "318e2171-8ade-4527-8007-b38c2ab497a3",
3
+
"prevId": "0af35a3f-be0b-4475-8df8-700ef5b39052",
4
+
"version": "7",
5
+
"dialect": "postgresql",
6
+
"tables": {
7
+
"public.authorized_keys": {
8
+
"name": "authorized_keys",
9
+
"schema": "",
10
+
"columns": {
11
+
"id": {
12
+
"name": "id",
13
+
"type": "text",
14
+
"primaryKey": true,
15
+
"notNull": true,
16
+
"default": "xata_id()"
17
+
},
18
+
"sandbox_id": {
19
+
"name": "sandbox_id",
20
+
"type": "text",
21
+
"primaryKey": false,
22
+
"notNull": false
23
+
},
24
+
"public_key": {
25
+
"name": "public_key",
26
+
"type": "text",
27
+
"primaryKey": false,
28
+
"notNull": true
29
+
},
30
+
"created_at": {
31
+
"name": "created_at",
32
+
"type": "timestamp",
33
+
"primaryKey": false,
34
+
"notNull": true,
35
+
"default": "now()"
36
+
}
37
+
},
38
+
"indexes": {},
39
+
"foreignKeys": {
40
+
"authorized_keys_sandbox_id_sandboxes_id_fk": {
41
+
"name": "authorized_keys_sandbox_id_sandboxes_id_fk",
42
+
"tableFrom": "authorized_keys",
43
+
"tableTo": "sandboxes",
44
+
"columnsFrom": [
45
+
"sandbox_id"
46
+
],
47
+
"columnsTo": [
48
+
"id"
49
+
],
50
+
"onDelete": "no action",
51
+
"onUpdate": "no action"
52
+
}
53
+
},
54
+
"compositePrimaryKeys": {},
55
+
"uniqueConstraints": {},
56
+
"policies": {},
57
+
"checkConstraints": {},
58
+
"isRLSEnabled": false
59
+
},
60
+
"public.files": {
61
+
"name": "files",
62
+
"schema": "",
63
+
"columns": {
64
+
"id": {
65
+
"name": "id",
66
+
"type": "text",
67
+
"primaryKey": true,
68
+
"notNull": true,
69
+
"default": "xata_id()"
70
+
},
71
+
"content": {
72
+
"name": "content",
73
+
"type": "text",
74
+
"primaryKey": false,
75
+
"notNull": true
76
+
},
77
+
"created_at": {
78
+
"name": "created_at",
79
+
"type": "timestamp",
80
+
"primaryKey": false,
81
+
"notNull": true,
82
+
"default": "now()"
83
+
},
84
+
"updated_at": {
85
+
"name": "updated_at",
86
+
"type": "timestamp",
87
+
"primaryKey": false,
88
+
"notNull": true,
89
+
"default": "now()"
90
+
}
91
+
},
92
+
"indexes": {},
93
+
"foreignKeys": {},
94
+
"compositePrimaryKeys": {},
95
+
"uniqueConstraints": {},
96
+
"policies": {},
97
+
"checkConstraints": {},
98
+
"isRLSEnabled": false
99
+
},
100
+
"public.sandbox_files": {
101
+
"name": "sandbox_files",
102
+
"schema": "",
103
+
"columns": {
104
+
"id": {
105
+
"name": "id",
106
+
"type": "text",
107
+
"primaryKey": true,
108
+
"notNull": true,
109
+
"default": "file_id()"
110
+
},
111
+
"sandbox_id": {
112
+
"name": "sandbox_id",
113
+
"type": "text",
114
+
"primaryKey": false,
115
+
"notNull": true
116
+
},
117
+
"file_id": {
118
+
"name": "file_id",
119
+
"type": "text",
120
+
"primaryKey": false,
121
+
"notNull": true
122
+
},
123
+
"path": {
124
+
"name": "path",
125
+
"type": "text",
126
+
"primaryKey": false,
127
+
"notNull": true
128
+
},
129
+
"created_at": {
130
+
"name": "created_at",
131
+
"type": "timestamp",
132
+
"primaryKey": false,
133
+
"notNull": true,
134
+
"default": "now()"
135
+
},
136
+
"updated_at": {
137
+
"name": "updated_at",
138
+
"type": "timestamp",
139
+
"primaryKey": false,
140
+
"notNull": true,
141
+
"default": "now()"
142
+
}
143
+
},
144
+
"indexes": {
145
+
"unique_sandbox_file_path": {
146
+
"name": "unique_sandbox_file_path",
147
+
"columns": [
148
+
{
149
+
"expression": "sandbox_id",
150
+
"isExpression": false,
151
+
"asc": true,
152
+
"nulls": "last"
153
+
},
154
+
{
155
+
"expression": "path",
156
+
"isExpression": false,
157
+
"asc": true,
158
+
"nulls": "last"
159
+
}
160
+
],
161
+
"isUnique": true,
162
+
"concurrently": false,
163
+
"method": "btree",
164
+
"with": {}
165
+
}
166
+
},
167
+
"foreignKeys": {
168
+
"sandbox_files_sandbox_id_sandboxes_id_fk": {
169
+
"name": "sandbox_files_sandbox_id_sandboxes_id_fk",
170
+
"tableFrom": "sandbox_files",
171
+
"tableTo": "sandboxes",
172
+
"columnsFrom": [
173
+
"sandbox_id"
174
+
],
175
+
"columnsTo": [
176
+
"id"
177
+
],
178
+
"onDelete": "no action",
179
+
"onUpdate": "no action"
180
+
},
181
+
"sandbox_files_file_id_files_id_fk": {
182
+
"name": "sandbox_files_file_id_files_id_fk",
183
+
"tableFrom": "sandbox_files",
184
+
"tableTo": "files",
185
+
"columnsFrom": [
186
+
"file_id"
187
+
],
188
+
"columnsTo": [
189
+
"id"
190
+
],
191
+
"onDelete": "no action",
192
+
"onUpdate": "no action"
193
+
}
194
+
},
195
+
"compositePrimaryKeys": {},
196
+
"uniqueConstraints": {},
197
+
"policies": {},
198
+
"checkConstraints": {},
199
+
"isRLSEnabled": false
200
+
},
201
+
"public.sandbox_ports": {
202
+
"name": "sandbox_ports",
203
+
"schema": "",
204
+
"columns": {
205
+
"id": {
206
+
"name": "id",
207
+
"type": "text",
208
+
"primaryKey": true,
209
+
"notNull": true,
210
+
"default": "xata_id()"
211
+
},
212
+
"sandbox_id": {
213
+
"name": "sandbox_id",
214
+
"type": "text",
215
+
"primaryKey": false,
216
+
"notNull": true
217
+
},
218
+
"exposed_port": {
219
+
"name": "exposed_port",
220
+
"type": "integer",
221
+
"primaryKey": false,
222
+
"notNull": true
223
+
},
224
+
"preview_url": {
225
+
"name": "preview_url",
226
+
"type": "text",
227
+
"primaryKey": false,
228
+
"notNull": false
229
+
},
230
+
"description": {
231
+
"name": "description",
232
+
"type": "text",
233
+
"primaryKey": false,
234
+
"notNull": false
235
+
},
236
+
"service_id": {
237
+
"name": "service_id",
238
+
"type": "text",
239
+
"primaryKey": false,
240
+
"notNull": false
241
+
},
242
+
"created_at": {
243
+
"name": "created_at",
244
+
"type": "timestamp",
245
+
"primaryKey": false,
246
+
"notNull": true,
247
+
"default": "now()"
248
+
},
249
+
"updated_at": {
250
+
"name": "updated_at",
251
+
"type": "timestamp",
252
+
"primaryKey": false,
253
+
"notNull": true,
254
+
"default": "now()"
255
+
}
256
+
},
257
+
"indexes": {
258
+
"unique_sandbox_port": {
259
+
"name": "unique_sandbox_port",
260
+
"columns": [
261
+
{
262
+
"expression": "sandbox_id",
263
+
"isExpression": false,
264
+
"asc": true,
265
+
"nulls": "last"
266
+
},
267
+
{
268
+
"expression": "exposed_port",
269
+
"isExpression": false,
270
+
"asc": true,
271
+
"nulls": "last"
272
+
}
273
+
],
274
+
"isUnique": true,
275
+
"concurrently": false,
276
+
"method": "btree",
277
+
"with": {}
278
+
}
279
+
},
280
+
"foreignKeys": {
281
+
"sandbox_ports_sandbox_id_sandboxes_id_fk": {
282
+
"name": "sandbox_ports_sandbox_id_sandboxes_id_fk",
283
+
"tableFrom": "sandbox_ports",
284
+
"tableTo": "sandboxes",
285
+
"columnsFrom": [
286
+
"sandbox_id"
287
+
],
288
+
"columnsTo": [
289
+
"id"
290
+
],
291
+
"onDelete": "no action",
292
+
"onUpdate": "no action"
293
+
},
294
+
"sandbox_ports_service_id_services_id_fk": {
295
+
"name": "sandbox_ports_service_id_services_id_fk",
296
+
"tableFrom": "sandbox_ports",
297
+
"tableTo": "services",
298
+
"columnsFrom": [
299
+
"service_id"
300
+
],
301
+
"columnsTo": [
302
+
"id"
303
+
],
304
+
"onDelete": "no action",
305
+
"onUpdate": "no action"
306
+
}
307
+
},
308
+
"compositePrimaryKeys": {},
309
+
"uniqueConstraints": {},
310
+
"policies": {},
311
+
"checkConstraints": {},
312
+
"isRLSEnabled": false
313
+
},
314
+
"public.sandbox_secrets": {
315
+
"name": "sandbox_secrets",
316
+
"schema": "",
317
+
"columns": {
318
+
"id": {
319
+
"name": "id",
320
+
"type": "text",
321
+
"primaryKey": true,
322
+
"notNull": true,
323
+
"default": "xata_id()"
324
+
},
325
+
"sandbox_id": {
326
+
"name": "sandbox_id",
327
+
"type": "text",
328
+
"primaryKey": false,
329
+
"notNull": true
330
+
},
331
+
"secret_id": {
332
+
"name": "secret_id",
333
+
"type": "text",
334
+
"primaryKey": false,
335
+
"notNull": true
336
+
},
337
+
"name": {
338
+
"name": "name",
339
+
"type": "text",
340
+
"primaryKey": false,
341
+
"notNull": false
342
+
},
343
+
"created_at": {
344
+
"name": "created_at",
345
+
"type": "timestamp",
346
+
"primaryKey": false,
347
+
"notNull": true,
348
+
"default": "now()"
349
+
},
350
+
"updated_at": {
351
+
"name": "updated_at",
352
+
"type": "timestamp",
353
+
"primaryKey": false,
354
+
"notNull": true,
355
+
"default": "now()"
356
+
}
357
+
},
358
+
"indexes": {
359
+
"unique_sandbox_secret_by_name": {
360
+
"name": "unique_sandbox_secret_by_name",
361
+
"columns": [
362
+
{
363
+
"expression": "sandbox_id",
364
+
"isExpression": false,
365
+
"asc": true,
366
+
"nulls": "last"
367
+
},
368
+
{
369
+
"expression": "name",
370
+
"isExpression": false,
371
+
"asc": true,
372
+
"nulls": "last"
373
+
}
374
+
],
375
+
"isUnique": true,
376
+
"concurrently": false,
377
+
"method": "btree",
378
+
"with": {}
379
+
}
380
+
},
381
+
"foreignKeys": {
382
+
"sandbox_secrets_sandbox_id_sandboxes_id_fk": {
383
+
"name": "sandbox_secrets_sandbox_id_sandboxes_id_fk",
384
+
"tableFrom": "sandbox_secrets",
385
+
"tableTo": "sandboxes",
386
+
"columnsFrom": [
387
+
"sandbox_id"
388
+
],
389
+
"columnsTo": [
390
+
"id"
391
+
],
392
+
"onDelete": "no action",
393
+
"onUpdate": "no action"
394
+
},
395
+
"sandbox_secrets_secret_id_secrets_id_fk": {
396
+
"name": "sandbox_secrets_secret_id_secrets_id_fk",
397
+
"tableFrom": "sandbox_secrets",
398
+
"tableTo": "secrets",
399
+
"columnsFrom": [
400
+
"secret_id"
401
+
],
402
+
"columnsTo": [
403
+
"id"
404
+
],
405
+
"onDelete": "no action",
406
+
"onUpdate": "no action"
407
+
}
408
+
},
409
+
"compositePrimaryKeys": {},
410
+
"uniqueConstraints": {},
411
+
"policies": {},
412
+
"checkConstraints": {},
413
+
"isRLSEnabled": false
414
+
},
415
+
"public.sandbox_variables": {
416
+
"name": "sandbox_variables",
417
+
"schema": "",
418
+
"columns": {
419
+
"id": {
420
+
"name": "id",
421
+
"type": "text",
422
+
"primaryKey": true,
423
+
"notNull": true,
424
+
"default": "xata_id()"
425
+
},
426
+
"sandbox_id": {
427
+
"name": "sandbox_id",
428
+
"type": "text",
429
+
"primaryKey": false,
430
+
"notNull": true
431
+
},
432
+
"variable_id": {
433
+
"name": "variable_id",
434
+
"type": "text",
435
+
"primaryKey": false,
436
+
"notNull": true
437
+
},
438
+
"name": {
439
+
"name": "name",
440
+
"type": "text",
441
+
"primaryKey": false,
442
+
"notNull": true
443
+
},
444
+
"created_at": {
445
+
"name": "created_at",
446
+
"type": "timestamp",
447
+
"primaryKey": false,
448
+
"notNull": true,
449
+
"default": "now()"
450
+
},
451
+
"updated_at": {
452
+
"name": "updated_at",
453
+
"type": "timestamp",
454
+
"primaryKey": false,
455
+
"notNull": true,
456
+
"default": "now()"
457
+
}
458
+
},
459
+
"indexes": {
460
+
"unique_sandbox_variables_by_name": {
461
+
"name": "unique_sandbox_variables_by_name",
462
+
"columns": [
463
+
{
464
+
"expression": "sandbox_id",
465
+
"isExpression": false,
466
+
"asc": true,
467
+
"nulls": "last"
468
+
},
469
+
{
470
+
"expression": "name",
471
+
"isExpression": false,
472
+
"asc": true,
473
+
"nulls": "last"
474
+
}
475
+
],
476
+
"isUnique": true,
477
+
"concurrently": false,
478
+
"method": "btree",
479
+
"with": {}
480
+
}
481
+
},
482
+
"foreignKeys": {
483
+
"sandbox_variables_sandbox_id_sandboxes_id_fk": {
484
+
"name": "sandbox_variables_sandbox_id_sandboxes_id_fk",
485
+
"tableFrom": "sandbox_variables",
486
+
"tableTo": "sandboxes",
487
+
"columnsFrom": [
488
+
"sandbox_id"
489
+
],
490
+
"columnsTo": [
491
+
"id"
492
+
],
493
+
"onDelete": "no action",
494
+
"onUpdate": "no action"
495
+
},
496
+
"sandbox_variables_variable_id_variables_id_fk": {
497
+
"name": "sandbox_variables_variable_id_variables_id_fk",
498
+
"tableFrom": "sandbox_variables",
499
+
"tableTo": "variables",
500
+
"columnsFrom": [
501
+
"variable_id"
502
+
],
503
+
"columnsTo": [
504
+
"id"
505
+
],
506
+
"onDelete": "no action",
507
+
"onUpdate": "no action"
508
+
}
509
+
},
510
+
"compositePrimaryKeys": {},
511
+
"uniqueConstraints": {},
512
+
"policies": {},
513
+
"checkConstraints": {},
514
+
"isRLSEnabled": false
515
+
},
516
+
"public.sandbox_volumes": {
517
+
"name": "sandbox_volumes",
518
+
"schema": "",
519
+
"columns": {
520
+
"id": {
521
+
"name": "id",
522
+
"type": "text",
523
+
"primaryKey": true,
524
+
"notNull": true,
525
+
"default": "volume_id()"
526
+
},
527
+
"sandbox_id": {
528
+
"name": "sandbox_id",
529
+
"type": "text",
530
+
"primaryKey": false,
531
+
"notNull": true
532
+
},
533
+
"volume_id": {
534
+
"name": "volume_id",
535
+
"type": "text",
536
+
"primaryKey": false,
537
+
"notNull": true
538
+
},
539
+
"name": {
540
+
"name": "name",
541
+
"type": "text",
542
+
"primaryKey": false,
543
+
"notNull": false
544
+
},
545
+
"path": {
546
+
"name": "path",
547
+
"type": "text",
548
+
"primaryKey": false,
549
+
"notNull": true
550
+
},
551
+
"created_at": {
552
+
"name": "created_at",
553
+
"type": "timestamp",
554
+
"primaryKey": false,
555
+
"notNull": true,
556
+
"default": "now()"
557
+
},
558
+
"updated_at": {
559
+
"name": "updated_at",
560
+
"type": "timestamp",
561
+
"primaryKey": false,
562
+
"notNull": true,
563
+
"default": "now()"
564
+
}
565
+
},
566
+
"indexes": {
567
+
"unique_sandbox_volume_path": {
568
+
"name": "unique_sandbox_volume_path",
569
+
"columns": [
570
+
{
571
+
"expression": "sandbox_id",
572
+
"isExpression": false,
573
+
"asc": true,
574
+
"nulls": "last"
575
+
},
576
+
{
577
+
"expression": "path",
578
+
"isExpression": false,
579
+
"asc": true,
580
+
"nulls": "last"
581
+
}
582
+
],
583
+
"isUnique": true,
584
+
"concurrently": false,
585
+
"method": "btree",
586
+
"with": {}
587
+
}
588
+
},
589
+
"foreignKeys": {
590
+
"sandbox_volumes_sandbox_id_sandboxes_id_fk": {
591
+
"name": "sandbox_volumes_sandbox_id_sandboxes_id_fk",
592
+
"tableFrom": "sandbox_volumes",
593
+
"tableTo": "sandboxes",
594
+
"columnsFrom": [
595
+
"sandbox_id"
596
+
],
597
+
"columnsTo": [
598
+
"id"
599
+
],
600
+
"onDelete": "no action",
601
+
"onUpdate": "no action"
602
+
},
603
+
"sandbox_volumes_volume_id_volumes_id_fk": {
604
+
"name": "sandbox_volumes_volume_id_volumes_id_fk",
605
+
"tableFrom": "sandbox_volumes",
606
+
"tableTo": "volumes",
607
+
"columnsFrom": [
608
+
"volume_id"
609
+
],
610
+
"columnsTo": [
611
+
"id"
612
+
],
613
+
"onDelete": "no action",
614
+
"onUpdate": "no action"
615
+
}
616
+
},
617
+
"compositePrimaryKeys": {},
618
+
"uniqueConstraints": {},
619
+
"policies": {},
620
+
"checkConstraints": {},
621
+
"isRLSEnabled": false
622
+
},
623
+
"public.sandboxes": {
624
+
"name": "sandboxes",
625
+
"schema": "",
626
+
"columns": {
627
+
"id": {
628
+
"name": "id",
629
+
"type": "text",
630
+
"primaryKey": true,
631
+
"notNull": true,
632
+
"default": "sandbox_id()"
633
+
},
634
+
"base": {
635
+
"name": "base",
636
+
"type": "text",
637
+
"primaryKey": false,
638
+
"notNull": false
639
+
},
640
+
"name": {
641
+
"name": "name",
642
+
"type": "text",
643
+
"primaryKey": false,
644
+
"notNull": true
645
+
},
646
+
"display_name": {
647
+
"name": "display_name",
648
+
"type": "text",
649
+
"primaryKey": false,
650
+
"notNull": false
651
+
},
652
+
"uri": {
653
+
"name": "uri",
654
+
"type": "text",
655
+
"primaryKey": false,
656
+
"notNull": false
657
+
},
658
+
"cid": {
659
+
"name": "cid",
660
+
"type": "text",
661
+
"primaryKey": false,
662
+
"notNull": false
663
+
},
664
+
"repo": {
665
+
"name": "repo",
666
+
"type": "text",
667
+
"primaryKey": false,
668
+
"notNull": false
669
+
},
670
+
"provider": {
671
+
"name": "provider",
672
+
"type": "text",
673
+
"primaryKey": false,
674
+
"notNull": true,
675
+
"default": "'cloudflare'"
676
+
},
677
+
"description": {
678
+
"name": "description",
679
+
"type": "text",
680
+
"primaryKey": false,
681
+
"notNull": false
682
+
},
683
+
"topics": {
684
+
"name": "topics",
685
+
"type": "text[]",
686
+
"primaryKey": false,
687
+
"notNull": false
688
+
},
689
+
"logo": {
690
+
"name": "logo",
691
+
"type": "text",
692
+
"primaryKey": false,
693
+
"notNull": false
694
+
},
695
+
"readme": {
696
+
"name": "readme",
697
+
"type": "text",
698
+
"primaryKey": false,
699
+
"notNull": false
700
+
},
701
+
"public_key": {
702
+
"name": "public_key",
703
+
"type": "text",
704
+
"primaryKey": false,
705
+
"notNull": true
706
+
},
707
+
"user_id": {
708
+
"name": "user_id",
709
+
"type": "text",
710
+
"primaryKey": false,
711
+
"notNull": false
712
+
},
713
+
"instance_type": {
714
+
"name": "instance_type",
715
+
"type": "text",
716
+
"primaryKey": false,
717
+
"notNull": false
718
+
},
719
+
"vcpus": {
720
+
"name": "vcpus",
721
+
"type": "integer",
722
+
"primaryKey": false,
723
+
"notNull": false
724
+
},
725
+
"memory": {
726
+
"name": "memory",
727
+
"type": "integer",
728
+
"primaryKey": false,
729
+
"notNull": false
730
+
},
731
+
"disk": {
732
+
"name": "disk",
733
+
"type": "integer",
734
+
"primaryKey": false,
735
+
"notNull": false
736
+
},
737
+
"status": {
738
+
"name": "status",
739
+
"type": "text",
740
+
"primaryKey": false,
741
+
"notNull": true
742
+
},
743
+
"keep_alive": {
744
+
"name": "keep_alive",
745
+
"type": "boolean",
746
+
"primaryKey": false,
747
+
"notNull": true,
748
+
"default": false
749
+
},
750
+
"sleep_after": {
751
+
"name": "sleep_after",
752
+
"type": "text",
753
+
"primaryKey": false,
754
+
"notNull": false
755
+
},
756
+
"sandbox_id": {
757
+
"name": "sandbox_id",
758
+
"type": "text",
759
+
"primaryKey": false,
760
+
"notNull": false
761
+
},
762
+
"installs": {
763
+
"name": "installs",
764
+
"type": "integer",
765
+
"primaryKey": false,
766
+
"notNull": true,
767
+
"default": 0
768
+
},
769
+
"started_at": {
770
+
"name": "started_at",
771
+
"type": "timestamp",
772
+
"primaryKey": false,
773
+
"notNull": false
774
+
},
775
+
"created_at": {
776
+
"name": "created_at",
777
+
"type": "timestamp",
778
+
"primaryKey": false,
779
+
"notNull": true,
780
+
"default": "now()"
781
+
},
782
+
"updated_at": {
783
+
"name": "updated_at",
784
+
"type": "timestamp",
785
+
"primaryKey": false,
786
+
"notNull": true,
787
+
"default": "now()"
788
+
}
789
+
},
790
+
"indexes": {},
791
+
"foreignKeys": {
792
+
"sandboxes_user_id_users_id_fk": {
793
+
"name": "sandboxes_user_id_users_id_fk",
794
+
"tableFrom": "sandboxes",
795
+
"tableTo": "users",
796
+
"columnsFrom": [
797
+
"user_id"
798
+
],
799
+
"columnsTo": [
800
+
"id"
801
+
],
802
+
"onDelete": "no action",
803
+
"onUpdate": "no action"
804
+
}
805
+
},
806
+
"compositePrimaryKeys": {},
807
+
"uniqueConstraints": {
808
+
"sandboxes_name_unique": {
809
+
"name": "sandboxes_name_unique",
810
+
"nullsNotDistinct": false,
811
+
"columns": [
812
+
"name"
813
+
]
814
+
},
815
+
"sandboxes_uri_unique": {
816
+
"name": "sandboxes_uri_unique",
817
+
"nullsNotDistinct": false,
818
+
"columns": [
819
+
"uri"
820
+
]
821
+
},
822
+
"sandboxes_cid_unique": {
823
+
"name": "sandboxes_cid_unique",
824
+
"nullsNotDistinct": false,
825
+
"columns": [
826
+
"cid"
827
+
]
828
+
}
829
+
},
830
+
"policies": {},
831
+
"checkConstraints": {},
832
+
"isRLSEnabled": false
833
+
},
834
+
"public.secrets": {
835
+
"name": "secrets",
836
+
"schema": "",
837
+
"columns": {
838
+
"id": {
839
+
"name": "id",
840
+
"type": "text",
841
+
"primaryKey": true,
842
+
"notNull": true,
843
+
"default": "secret_id()"
844
+
},
845
+
"name": {
846
+
"name": "name",
847
+
"type": "text",
848
+
"primaryKey": false,
849
+
"notNull": true
850
+
},
851
+
"value": {
852
+
"name": "value",
853
+
"type": "text",
854
+
"primaryKey": false,
855
+
"notNull": true
856
+
},
857
+
"redacted": {
858
+
"name": "redacted",
859
+
"type": "text",
860
+
"primaryKey": false,
861
+
"notNull": false
862
+
},
863
+
"created_at": {
864
+
"name": "created_at",
865
+
"type": "timestamp",
866
+
"primaryKey": false,
867
+
"notNull": true,
868
+
"default": "now()"
869
+
}
870
+
},
871
+
"indexes": {},
872
+
"foreignKeys": {},
873
+
"compositePrimaryKeys": {},
874
+
"uniqueConstraints": {},
875
+
"policies": {},
876
+
"checkConstraints": {},
877
+
"isRLSEnabled": false
878
+
},
879
+
"public.snapshots": {
880
+
"name": "snapshots",
881
+
"schema": "",
882
+
"columns": {
883
+
"id": {
884
+
"name": "id",
885
+
"type": "text",
886
+
"primaryKey": true,
887
+
"notNull": true,
888
+
"default": "snapshot_id()"
889
+
},
890
+
"slug": {
891
+
"name": "slug",
892
+
"type": "text",
893
+
"primaryKey": false,
894
+
"notNull": true
895
+
},
896
+
"created_at": {
897
+
"name": "created_at",
898
+
"type": "timestamp",
899
+
"primaryKey": false,
900
+
"notNull": true,
901
+
"default": "now()"
902
+
}
903
+
},
904
+
"indexes": {},
905
+
"foreignKeys": {},
906
+
"compositePrimaryKeys": {},
907
+
"uniqueConstraints": {
908
+
"snapshots_slug_unique": {
909
+
"name": "snapshots_slug_unique",
910
+
"nullsNotDistinct": false,
911
+
"columns": [
912
+
"slug"
913
+
]
914
+
}
915
+
},
916
+
"policies": {},
917
+
"checkConstraints": {},
918
+
"isRLSEnabled": false
919
+
},
920
+
"public.ssh_keys": {
921
+
"name": "ssh_keys",
922
+
"schema": "",
923
+
"columns": {
924
+
"id": {
925
+
"name": "id",
926
+
"type": "text",
927
+
"primaryKey": true,
928
+
"notNull": true,
929
+
"default": "xata_id()"
930
+
},
931
+
"sandbox_id": {
932
+
"name": "sandbox_id",
933
+
"type": "text",
934
+
"primaryKey": false,
935
+
"notNull": true
936
+
},
937
+
"public_key": {
938
+
"name": "public_key",
939
+
"type": "text",
940
+
"primaryKey": false,
941
+
"notNull": true
942
+
},
943
+
"private_key": {
944
+
"name": "private_key",
945
+
"type": "text",
946
+
"primaryKey": false,
947
+
"notNull": true
948
+
},
949
+
"redacted": {
950
+
"name": "redacted",
951
+
"type": "text",
952
+
"primaryKey": false,
953
+
"notNull": false
954
+
},
955
+
"created_at": {
956
+
"name": "created_at",
957
+
"type": "timestamp",
958
+
"primaryKey": false,
959
+
"notNull": true,
960
+
"default": "now()"
961
+
}
962
+
},
963
+
"indexes": {
964
+
"unique_sandbox_ssh_key": {
965
+
"name": "unique_sandbox_ssh_key",
966
+
"columns": [
967
+
{
968
+
"expression": "public_key",
969
+
"isExpression": false,
970
+
"asc": true,
971
+
"nulls": "last"
972
+
},
973
+
{
974
+
"expression": "sandbox_id",
975
+
"isExpression": false,
976
+
"asc": true,
977
+
"nulls": "last"
978
+
}
979
+
],
980
+
"isUnique": true,
981
+
"concurrently": false,
982
+
"method": "btree",
983
+
"with": {}
984
+
}
985
+
},
986
+
"foreignKeys": {
987
+
"ssh_keys_sandbox_id_sandboxes_id_fk": {
988
+
"name": "ssh_keys_sandbox_id_sandboxes_id_fk",
989
+
"tableFrom": "ssh_keys",
990
+
"tableTo": "sandboxes",
991
+
"columnsFrom": [
992
+
"sandbox_id"
993
+
],
994
+
"columnsTo": [
995
+
"id"
996
+
],
997
+
"onDelete": "no action",
998
+
"onUpdate": "no action"
999
+
}
1000
+
},
1001
+
"compositePrimaryKeys": {},
1002
+
"uniqueConstraints": {},
1003
+
"policies": {},
1004
+
"checkConstraints": {},
1005
+
"isRLSEnabled": false
1006
+
},
1007
+
"public.tailscale_auth_keys": {
1008
+
"name": "tailscale_auth_keys",
1009
+
"schema": "",
1010
+
"columns": {
1011
+
"id": {
1012
+
"name": "id",
1013
+
"type": "text",
1014
+
"primaryKey": true,
1015
+
"notNull": true,
1016
+
"default": "xata_id()"
1017
+
},
1018
+
"sandbox_id": {
1019
+
"name": "sandbox_id",
1020
+
"type": "text",
1021
+
"primaryKey": false,
1022
+
"notNull": true
1023
+
},
1024
+
"auth_key": {
1025
+
"name": "auth_key",
1026
+
"type": "text",
1027
+
"primaryKey": false,
1028
+
"notNull": true
1029
+
},
1030
+
"redacted": {
1031
+
"name": "redacted",
1032
+
"type": "text",
1033
+
"primaryKey": false,
1034
+
"notNull": true
1035
+
},
1036
+
"created_at": {
1037
+
"name": "created_at",
1038
+
"type": "timestamp",
1039
+
"primaryKey": false,
1040
+
"notNull": true,
1041
+
"default": "now()"
1042
+
}
1043
+
},
1044
+
"indexes": {},
1045
+
"foreignKeys": {
1046
+
"tailscale_auth_keys_sandbox_id_sandboxes_id_fk": {
1047
+
"name": "tailscale_auth_keys_sandbox_id_sandboxes_id_fk",
1048
+
"tableFrom": "tailscale_auth_keys",
1049
+
"tableTo": "sandboxes",
1050
+
"columnsFrom": [
1051
+
"sandbox_id"
1052
+
],
1053
+
"columnsTo": [
1054
+
"id"
1055
+
],
1056
+
"onDelete": "no action",
1057
+
"onUpdate": "no action"
1058
+
}
1059
+
},
1060
+
"compositePrimaryKeys": {},
1061
+
"uniqueConstraints": {},
1062
+
"policies": {},
1063
+
"checkConstraints": {},
1064
+
"isRLSEnabled": false
1065
+
},
1066
+
"public.users": {
1067
+
"name": "users",
1068
+
"schema": "",
1069
+
"columns": {
1070
+
"id": {
1071
+
"name": "id",
1072
+
"type": "text",
1073
+
"primaryKey": true,
1074
+
"notNull": true,
1075
+
"default": "xata_id()"
1076
+
},
1077
+
"did": {
1078
+
"name": "did",
1079
+
"type": "text",
1080
+
"primaryKey": false,
1081
+
"notNull": true
1082
+
},
1083
+
"display_name": {
1084
+
"name": "display_name",
1085
+
"type": "text",
1086
+
"primaryKey": false,
1087
+
"notNull": false
1088
+
},
1089
+
"handle": {
1090
+
"name": "handle",
1091
+
"type": "text",
1092
+
"primaryKey": false,
1093
+
"notNull": true
1094
+
},
1095
+
"avatar": {
1096
+
"name": "avatar",
1097
+
"type": "text",
1098
+
"primaryKey": false,
1099
+
"notNull": false
1100
+
},
1101
+
"created_at": {
1102
+
"name": "created_at",
1103
+
"type": "timestamp",
1104
+
"primaryKey": false,
1105
+
"notNull": true,
1106
+
"default": "now()"
1107
+
},
1108
+
"updated_at": {
1109
+
"name": "updated_at",
1110
+
"type": "timestamp",
1111
+
"primaryKey": false,
1112
+
"notNull": true,
1113
+
"default": "now()"
1114
+
}
1115
+
},
1116
+
"indexes": {},
1117
+
"foreignKeys": {},
1118
+
"compositePrimaryKeys": {},
1119
+
"uniqueConstraints": {
1120
+
"users_did_unique": {
1121
+
"name": "users_did_unique",
1122
+
"nullsNotDistinct": false,
1123
+
"columns": [
1124
+
"did"
1125
+
]
1126
+
},
1127
+
"users_handle_unique": {
1128
+
"name": "users_handle_unique",
1129
+
"nullsNotDistinct": false,
1130
+
"columns": [
1131
+
"handle"
1132
+
]
1133
+
}
1134
+
},
1135
+
"policies": {},
1136
+
"checkConstraints": {},
1137
+
"isRLSEnabled": false
1138
+
},
1139
+
"public.variables": {
1140
+
"name": "variables",
1141
+
"schema": "",
1142
+
"columns": {
1143
+
"id": {
1144
+
"name": "id",
1145
+
"type": "text",
1146
+
"primaryKey": true,
1147
+
"notNull": true,
1148
+
"default": "variable_id()"
1149
+
},
1150
+
"name": {
1151
+
"name": "name",
1152
+
"type": "text",
1153
+
"primaryKey": false,
1154
+
"notNull": true
1155
+
},
1156
+
"value": {
1157
+
"name": "value",
1158
+
"type": "text",
1159
+
"primaryKey": false,
1160
+
"notNull": true
1161
+
},
1162
+
"created_at": {
1163
+
"name": "created_at",
1164
+
"type": "timestamp",
1165
+
"primaryKey": false,
1166
+
"notNull": true,
1167
+
"default": "now()"
1168
+
},
1169
+
"updated_at": {
1170
+
"name": "updated_at",
1171
+
"type": "timestamp",
1172
+
"primaryKey": false,
1173
+
"notNull": true,
1174
+
"default": "now()"
1175
+
}
1176
+
},
1177
+
"indexes": {},
1178
+
"foreignKeys": {},
1179
+
"compositePrimaryKeys": {},
1180
+
"uniqueConstraints": {},
1181
+
"policies": {},
1182
+
"checkConstraints": {},
1183
+
"isRLSEnabled": false
1184
+
},
1185
+
"public.volumes": {
1186
+
"name": "volumes",
1187
+
"schema": "",
1188
+
"columns": {
1189
+
"id": {
1190
+
"name": "id",
1191
+
"type": "text",
1192
+
"primaryKey": true,
1193
+
"notNull": true,
1194
+
"default": "volume_id()"
1195
+
},
1196
+
"slug": {
1197
+
"name": "slug",
1198
+
"type": "text",
1199
+
"primaryKey": false,
1200
+
"notNull": true
1201
+
},
1202
+
"size": {
1203
+
"name": "size",
1204
+
"type": "integer",
1205
+
"primaryKey": false,
1206
+
"notNull": true
1207
+
},
1208
+
"size_unit": {
1209
+
"name": "size_unit",
1210
+
"type": "text",
1211
+
"primaryKey": false,
1212
+
"notNull": true
1213
+
},
1214
+
"created_at": {
1215
+
"name": "created_at",
1216
+
"type": "timestamp",
1217
+
"primaryKey": false,
1218
+
"notNull": true,
1219
+
"default": "now()"
1220
+
},
1221
+
"updated_at": {
1222
+
"name": "updated_at",
1223
+
"type": "timestamp",
1224
+
"primaryKey": false,
1225
+
"notNull": true,
1226
+
"default": "now()"
1227
+
}
1228
+
},
1229
+
"indexes": {},
1230
+
"foreignKeys": {},
1231
+
"compositePrimaryKeys": {},
1232
+
"uniqueConstraints": {
1233
+
"volumes_slug_unique": {
1234
+
"name": "volumes_slug_unique",
1235
+
"nullsNotDistinct": false,
1236
+
"columns": [
1237
+
"slug"
1238
+
]
1239
+
}
1240
+
},
1241
+
"policies": {},
1242
+
"checkConstraints": {},
1243
+
"isRLSEnabled": false
1244
+
},
1245
+
"public.integrations": {
1246
+
"name": "integrations",
1247
+
"schema": "",
1248
+
"columns": {
1249
+
"id": {
1250
+
"name": "id",
1251
+
"type": "text",
1252
+
"primaryKey": true,
1253
+
"notNull": true,
1254
+
"default": "xata_id()"
1255
+
},
1256
+
"sandbox_id": {
1257
+
"name": "sandbox_id",
1258
+
"type": "text",
1259
+
"primaryKey": false,
1260
+
"notNull": true
1261
+
},
1262
+
"name": {
1263
+
"name": "name",
1264
+
"type": "text",
1265
+
"primaryKey": false,
1266
+
"notNull": true
1267
+
},
1268
+
"description": {
1269
+
"name": "description",
1270
+
"type": "text",
1271
+
"primaryKey": false,
1272
+
"notNull": false
1273
+
},
1274
+
"webhook_url": {
1275
+
"name": "webhook_url",
1276
+
"type": "text",
1277
+
"primaryKey": false,
1278
+
"notNull": true
1279
+
},
1280
+
"created_at": {
1281
+
"name": "created_at",
1282
+
"type": "timestamp",
1283
+
"primaryKey": false,
1284
+
"notNull": true,
1285
+
"default": "now()"
1286
+
}
1287
+
},
1288
+
"indexes": {
1289
+
"unique_sandbox_integration": {
1290
+
"name": "unique_sandbox_integration",
1291
+
"columns": [
1292
+
{
1293
+
"expression": "sandbox_id",
1294
+
"isExpression": false,
1295
+
"asc": true,
1296
+
"nulls": "last"
1297
+
},
1298
+
{
1299
+
"expression": "name",
1300
+
"isExpression": false,
1301
+
"asc": true,
1302
+
"nulls": "last"
1303
+
}
1304
+
],
1305
+
"isUnique": true,
1306
+
"concurrently": false,
1307
+
"method": "btree",
1308
+
"with": {}
1309
+
}
1310
+
},
1311
+
"foreignKeys": {
1312
+
"integrations_sandbox_id_sandboxes_id_fk": {
1313
+
"name": "integrations_sandbox_id_sandboxes_id_fk",
1314
+
"tableFrom": "integrations",
1315
+
"tableTo": "sandboxes",
1316
+
"columnsFrom": [
1317
+
"sandbox_id"
1318
+
],
1319
+
"columnsTo": [
1320
+
"id"
1321
+
],
1322
+
"onDelete": "no action",
1323
+
"onUpdate": "no action"
1324
+
}
1325
+
},
1326
+
"compositePrimaryKeys": {},
1327
+
"uniqueConstraints": {},
1328
+
"policies": {},
1329
+
"checkConstraints": {},
1330
+
"isRLSEnabled": false
1331
+
},
1332
+
"public.services": {
1333
+
"name": "services",
1334
+
"schema": "",
1335
+
"columns": {
1336
+
"id": {
1337
+
"name": "id",
1338
+
"type": "text",
1339
+
"primaryKey": true,
1340
+
"notNull": true,
1341
+
"default": "xata_id()"
1342
+
},
1343
+
"sandbox_id": {
1344
+
"name": "sandbox_id",
1345
+
"type": "text",
1346
+
"primaryKey": false,
1347
+
"notNull": true
1348
+
},
1349
+
"name": {
1350
+
"name": "name",
1351
+
"type": "text",
1352
+
"primaryKey": false,
1353
+
"notNull": true
1354
+
},
1355
+
"command": {
1356
+
"name": "command",
1357
+
"type": "text",
1358
+
"primaryKey": false,
1359
+
"notNull": true
1360
+
},
1361
+
"description": {
1362
+
"name": "description",
1363
+
"type": "text",
1364
+
"primaryKey": false,
1365
+
"notNull": false
1366
+
},
1367
+
"service_id": {
1368
+
"name": "service_id",
1369
+
"type": "text",
1370
+
"primaryKey": false,
1371
+
"notNull": false
1372
+
},
1373
+
"created_at": {
1374
+
"name": "created_at",
1375
+
"type": "timestamp",
1376
+
"primaryKey": false,
1377
+
"notNull": true,
1378
+
"default": "now()"
1379
+
},
1380
+
"updated_at": {
1381
+
"name": "updated_at",
1382
+
"type": "timestamp",
1383
+
"primaryKey": false,
1384
+
"notNull": true,
1385
+
"default": "now()"
1386
+
}
1387
+
},
1388
+
"indexes": {
1389
+
"unique_sandbox_service": {
1390
+
"name": "unique_sandbox_service",
1391
+
"columns": [
1392
+
{
1393
+
"expression": "name",
1394
+
"isExpression": false,
1395
+
"asc": true,
1396
+
"nulls": "last"
1397
+
},
1398
+
{
1399
+
"expression": "sandbox_id",
1400
+
"isExpression": false,
1401
+
"asc": true,
1402
+
"nulls": "last"
1403
+
}
1404
+
],
1405
+
"isUnique": true,
1406
+
"concurrently": false,
1407
+
"method": "btree",
1408
+
"with": {}
1409
+
}
1410
+
},
1411
+
"foreignKeys": {
1412
+
"services_sandbox_id_sandboxes_id_fk": {
1413
+
"name": "services_sandbox_id_sandboxes_id_fk",
1414
+
"tableFrom": "services",
1415
+
"tableTo": "sandboxes",
1416
+
"columnsFrom": [
1417
+
"sandbox_id"
1418
+
],
1419
+
"columnsTo": [
1420
+
"id"
1421
+
],
1422
+
"onDelete": "no action",
1423
+
"onUpdate": "no action"
1424
+
}
1425
+
},
1426
+
"compositePrimaryKeys": {},
1427
+
"uniqueConstraints": {},
1428
+
"policies": {},
1429
+
"checkConstraints": {},
1430
+
"isRLSEnabled": false
1431
+
}
1432
+
},
1433
+
"enums": {},
1434
+
"schemas": {},
1435
+
"sequences": {},
1436
+
"roles": {},
1437
+
"policies": {},
1438
+
"views": {},
1439
+
"_meta": {
1440
+
"columns": {},
1441
+
"schemas": {},
1442
+
"tables": {}
1443
+
}
1444
+
}
+7
apps/cf-sandbox/drizzle/meta/_journal.json
+7
apps/cf-sandbox/drizzle/meta/_journal.json
+95
apps/cf-sandbox/src/index.ts
+95
apps/cf-sandbox/src/index.ts
···
38
38
import { consola } from "consola";
39
39
import decrypt from "./lib/decrypt";
40
40
import crypto from "node:crypto";
41
+
import services from "./schema/services";
41
42
42
43
type Bindings = {
43
44
Sandbox: DurableObjectNamespace<Sandbox<Env>>;
···
798
799
errorMessage,
799
800
);
800
801
return c.json({ error: `Failed to unexpose vscode: ${errorMessage}` }, 500);
802
+
}
803
+
});
804
+
805
+
app.post("/v1/sandboxes/:sandboxId/services/:serviceId", async (c) => {
806
+
const { sandboxes: record } = await getSandboxById(
807
+
c.var.db,
808
+
c.req.param("sandboxId"),
809
+
);
810
+
811
+
if (!record) {
812
+
return c.json({ error: "Sandbox not found" }, 404);
813
+
}
814
+
815
+
if (record.provider !== "cloudflare") {
816
+
return c.json({ error: "Sandbox provider not supported" }, 400);
817
+
}
818
+
819
+
try {
820
+
let sandbox: BaseSandbox | null = null;
821
+
822
+
sandbox = await createSandbox("cloudflare", {
823
+
id: record.sandboxId!,
824
+
});
825
+
826
+
const [service] = await c.var.db
827
+
.select()
828
+
.from(services)
829
+
.where(
830
+
and(
831
+
eq(services.id, c.req.param("serviceId")),
832
+
eq(services.sandboxId, record.id),
833
+
),
834
+
)
835
+
.execute();
836
+
837
+
if (!service) {
838
+
return c.json({ error: "Service not found" }, 404);
839
+
}
840
+
841
+
const serviceId = await sandbox.startService(service.command);
842
+
843
+
await c.var.db
844
+
.update(services)
845
+
.set({ serviceId })
846
+
.where(eq(services.id, service.id))
847
+
.execute();
848
+
849
+
return c.json({ serviceId });
850
+
} catch (err) {
851
+
console.log(`Failed to start service:`, err);
852
+
}
853
+
});
854
+
855
+
app.delete("/v1/sandboxes/:sandboxId/services/:serviceId", async (c) => {
856
+
const { sandboxes: record } = await getSandboxById(
857
+
c.var.db,
858
+
c.req.param("sandboxId"),
859
+
);
860
+
861
+
if (!record) {
862
+
return c.json({ error: "Sandbox not found" }, 404);
863
+
}
864
+
865
+
if (record.provider !== "cloudflare") {
866
+
return c.json({ error: "Sandbox provider not supported" }, 400);
867
+
}
868
+
869
+
try {
870
+
let sandbox: BaseSandbox | null = null;
871
+
872
+
sandbox = await createSandbox("cloudflare", {
873
+
id: record.sandboxId!,
874
+
});
875
+
876
+
const [service] = await c.var.db
877
+
.select()
878
+
.from(services)
879
+
.where(
880
+
and(
881
+
eq(services.id, c.req.param("serviceId")),
882
+
eq(services.sandboxId, record.id),
883
+
),
884
+
)
885
+
.execute();
886
+
887
+
if (!service) {
888
+
return c.json({ error: "Service not found" }, 404);
889
+
}
890
+
891
+
await sandbox.stopService(service.serviceId!);
892
+
893
+
return c.json({});
894
+
} catch (err) {
895
+
console.log(`Failed to stop service:`, err);
801
896
}
802
897
});
803
898
+9
apps/cf-sandbox/src/providers/cloudflare/index.ts
+9
apps/cf-sandbox/src/providers/cloudflare/index.ts
···
187
187
console.log("Failed to unexpose vscode port", e);
188
188
}
189
189
}
190
+
191
+
async startService(command: string): Promise<string> {
192
+
const { id } = await this.sandbox.startProcess(command);
193
+
return id;
194
+
}
195
+
196
+
async stopService(id: string): Promise<void> {
197
+
await this.sandbox.killProcess(id);
198
+
}
190
199
}
191
200
192
201
class CloudflareProvider implements BaseProvider {
+2
apps/cf-sandbox/src/providers/index.ts
+2
apps/cf-sandbox/src/providers/index.ts
···
25
25
abstract unexpose(port: number): Promise<void>;
26
26
abstract exposeVscode(hostname: string): Promise<string | null>;
27
27
abstract unexposeVscode(): Promise<void>;
28
+
abstract startService(command: string): Promise<string>;
29
+
abstract stopService(id: string): Promise<void>;
28
30
}
29
31
30
32
abstract class BaseProvider {
+1
apps/cf-sandbox/src/schema/services.ts
+1
apps/cf-sandbox/src/schema/services.ts
+1
apps/cli/README.md
+1
apps/cli/README.md
···
1
1
# Pocketenv CLI
2
2
3
3
[](https://www.npmjs.com/package/@pocketenv/cli)
4
+
4
5
[](https://discord.gg/9ada4pFUFS)
5
6
[](https://opensource.org/licenses/MPL-2.0)
6
7
+1
apps/sandbox/src/schema/services.ts
+1
apps/sandbox/src/schema/services.ts