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 GET endpoints for file/secret/variable/volume
Introduce lexicon/docs and xrpc handlers/types for single-resource GET
operations and wire them into the client hooks and UI. Update delete
handlers to accept params and enforce auth. Change files.id default to
xata_id() and add corresponding drizzle migrations and snapshots.
+6151
-2211
+33
apps/api/lexicons/file/getFile.json
+33
apps/api/lexicons/file/getFile.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.file.getFile",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"id"
11
+
],
12
+
"properties": {
13
+
"id": {
14
+
"type": "string",
15
+
"description": "The ID of the file to retrieve."
16
+
}
17
+
}
18
+
},
19
+
"output": {
20
+
"encoding": "application/json",
21
+
"schema": {
22
+
"type": "object",
23
+
"properties": {
24
+
"file": {
25
+
"type": "ref",
26
+
"ref": "io.pocketenv.file.defs#fileView"
27
+
}
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
+33
apps/api/lexicons/secret/getSecret.json
+33
apps/api/lexicons/secret/getSecret.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.secret.getSecret",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"id"
11
+
],
12
+
"properties": {
13
+
"id": {
14
+
"type": "string",
15
+
"description": "The ID of the secret for which to retrieve secrets."
16
+
}
17
+
}
18
+
},
19
+
"output": {
20
+
"encoding": "application/json",
21
+
"schema": {
22
+
"type": "object",
23
+
"properties": {
24
+
"secret": {
25
+
"type": "ref",
26
+
"ref": "io.pocketenv.secret.defs#secretView"
27
+
}
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
+33
apps/api/lexicons/variable/getVariable.json
+33
apps/api/lexicons/variable/getVariable.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.variable.getVariable",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"id"
11
+
],
12
+
"properties": {
13
+
"id": {
14
+
"type": "string",
15
+
"description": "The ID of the variable for which to retrieve variables."
16
+
}
17
+
}
18
+
},
19
+
"output": {
20
+
"encoding": "application/json",
21
+
"schema": {
22
+
"type": "object",
23
+
"properties": {
24
+
"variable": {
25
+
"type": "ref",
26
+
"ref": "io.pocketenv.variable.defs#variableView"
27
+
}
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
+33
apps/api/lexicons/volume/getVolume.json
+33
apps/api/lexicons/volume/getVolume.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "io.pocketenv.volume.getVolume",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"id"
11
+
],
12
+
"properties": {
13
+
"id": {
14
+
"type": "string",
15
+
"description": "The ID of the volume for which to retrieve volumes."
16
+
}
17
+
}
18
+
},
19
+
"output": {
20
+
"encoding": "application/json",
21
+
"schema": {
22
+
"type": "object",
23
+
"properties": {
24
+
"volume": {
25
+
"type": "ref",
26
+
"ref": "io.pocketenv.volume.defs#volumeView"
27
+
}
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
+30
apps/api/pkl/defs/file/getFile.pkl
+30
apps/api/pkl/defs/file/getFile.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.file.getFile"
5
+
defs = new Mapping<String, Query> {
6
+
["main"] {
7
+
type = "query"
8
+
parameters {
9
+
type = "params"
10
+
required = List("id")
11
+
properties {
12
+
["id"] = new StringType {
13
+
type = "string"
14
+
description = "The ID of the file to retrieve."
15
+
}
16
+
}
17
+
}
18
+
output {
19
+
encoding = "application/json"
20
+
schema = new ObjectType {
21
+
type = "object"
22
+
properties {
23
+
["file"] = new Ref {
24
+
ref = "io.pocketenv.file.defs#fileView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+30
apps/api/pkl/defs/secret/getSecret.pkl
+30
apps/api/pkl/defs/secret/getSecret.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.secret.getSecret"
5
+
defs = new Mapping<String, Query> {
6
+
["main"] {
7
+
type = "query"
8
+
parameters {
9
+
type = "params"
10
+
required = List("id")
11
+
properties {
12
+
["id"] = new StringType {
13
+
type = "string"
14
+
description = "The ID of the secret for which to retrieve secrets."
15
+
}
16
+
}
17
+
}
18
+
output {
19
+
encoding = "application/json"
20
+
schema = new ObjectType {
21
+
type = "object"
22
+
properties {
23
+
["secret"] = new Ref {
24
+
ref = "io.pocketenv.secret.defs#secretView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+30
apps/api/pkl/defs/variable/getVariable.pkl
+30
apps/api/pkl/defs/variable/getVariable.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.variable.getVariable"
5
+
defs = new Mapping<String, Query> {
6
+
["main"] {
7
+
type = "query"
8
+
parameters {
9
+
type = "params"
10
+
required = List("id")
11
+
properties {
12
+
["id"] = new StringType {
13
+
type = "string"
14
+
description = "The ID of the variable for which to retrieve variables."
15
+
}
16
+
}
17
+
}
18
+
output {
19
+
encoding = "application/json"
20
+
schema = new ObjectType {
21
+
type = "object"
22
+
properties {
23
+
["variable"] = new Ref {
24
+
ref = "io.pocketenv.variable.defs#variableView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+30
apps/api/pkl/defs/volume/getVolume.pkl
+30
apps/api/pkl/defs/volume/getVolume.pkl
···
1
+
amends "../../schema/lexicon.pkl"
2
+
3
+
lexicon = 1
4
+
id = "io.pocketenv.volume.getVolume"
5
+
defs = new Mapping<String, Query> {
6
+
["main"] {
7
+
type = "query"
8
+
parameters {
9
+
type = "params"
10
+
required = List("id")
11
+
properties {
12
+
["id"] = new StringType {
13
+
type = "string"
14
+
description = "The ID of the volume for which to retrieve volumes."
15
+
}
16
+
}
17
+
}
18
+
output {
19
+
encoding = "application/json"
20
+
schema = new ObjectType {
21
+
type = "object"
22
+
properties {
23
+
["volume"] = new Ref {
24
+
ref = "io.pocketenv.volume.defs#volumeView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+225
-177
apps/api/src/lexicon/index.ts
+225
-177
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 IoPocketenvFileGetFiles from './types/io/pocketenv/file/getFiles'
18
-
import type * as IoPocketenvSandboxClaimSandbox from './types/io/pocketenv/sandbox/claimSandbox'
19
-
import type * as IoPocketenvSandboxCreateIntegration from './types/io/pocketenv/sandbox/createIntegration'
20
-
import type * as IoPocketenvSandboxCreateSandbox from './types/io/pocketenv/sandbox/createSandbox'
21
-
import type * as IoPocketenvSandboxDeleteSandbox from './types/io/pocketenv/sandbox/deleteSandbox'
22
-
import type * as IoPocketenvSandboxGetIntegrations from './types/io/pocketenv/sandbox/getIntegrations'
23
-
import type * as IoPocketenvSandboxGetPreferences from './types/io/pocketenv/sandbox/getPreferences'
24
-
import type * as IoPocketenvSandboxGetSandbox from './types/io/pocketenv/sandbox/getSandbox'
25
-
import type * as IoPocketenvSandboxGetSandboxes from './types/io/pocketenv/sandbox/getSandboxes'
26
-
import type * as IoPocketenvSandboxGetSshKeys from './types/io/pocketenv/sandbox/getSshKeys'
27
-
import type * as IoPocketenvSandboxGetTailscaleAuthKey from './types/io/pocketenv/sandbox/getTailscaleAuthKey'
28
-
import type * as IoPocketenvSandboxGetTailscaleToken from './types/io/pocketenv/sandbox/getTailscaleToken'
29
-
import type * as IoPocketenvSandboxPutPreferences from './types/io/pocketenv/sandbox/putPreferences'
30
-
import type * as IoPocketenvSandboxPutSshKeys from './types/io/pocketenv/sandbox/putSshKeys'
31
-
import type * as IoPocketenvSandboxPutTailscaleAuthKey from './types/io/pocketenv/sandbox/putTailscaleAuthKey'
32
-
import type * as IoPocketenvSandboxPutTailscaleToken from './types/io/pocketenv/sandbox/putTailscaleToken'
33
-
import type * as IoPocketenvSandboxStartSandbox from './types/io/pocketenv/sandbox/startSandbox'
34
-
import type * as IoPocketenvSandboxStopSandbox from './types/io/pocketenv/sandbox/stopSandbox'
35
-
import type * as IoPocketenvSandboxUpdateSandboxSettings from './types/io/pocketenv/sandbox/updateSandboxSettings'
36
-
import type * as IoPocketenvSecretAddSecret from './types/io/pocketenv/secret/addSecret'
37
-
import type * as IoPocketenvSecretDeleteSecret from './types/io/pocketenv/secret/deleteSecret'
38
-
import type * as IoPocketenvSecretGetSecrets from './types/io/pocketenv/secret/getSecrets'
39
-
import type * as IoPocketenvVariableAddVariable from './types/io/pocketenv/variable/addVariable'
40
-
import type * as IoPocketenvVariableDeleteVariable from './types/io/pocketenv/variable/deleteVariable'
41
-
import type * as IoPocketenvVariableGetVariables from './types/io/pocketenv/variable/getVariables'
42
-
import type * as IoPocketenvVolumeAddVolume from './types/io/pocketenv/volume/addVolume'
43
-
import type * as IoPocketenvVolumeDeleteVolume from './types/io/pocketenv/volume/deleteVolume'
44
-
import type * as IoPocketenvVolumeGetVolumes from './types/io/pocketenv/volume/getVolumes'
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 IoPocketenvSandboxClaimSandbox from "./types/io/pocketenv/sandbox/claimSandbox";
20
+
import type * as IoPocketenvSandboxCreateIntegration from "./types/io/pocketenv/sandbox/createIntegration";
21
+
import type * as IoPocketenvSandboxCreateSandbox from "./types/io/pocketenv/sandbox/createSandbox";
22
+
import type * as IoPocketenvSandboxDeleteSandbox from "./types/io/pocketenv/sandbox/deleteSandbox";
23
+
import type * as IoPocketenvSandboxGetIntegrations from "./types/io/pocketenv/sandbox/getIntegrations";
24
+
import type * as IoPocketenvSandboxGetPreferences from "./types/io/pocketenv/sandbox/getPreferences";
25
+
import type * as IoPocketenvSandboxGetSandbox from "./types/io/pocketenv/sandbox/getSandbox";
26
+
import type * as IoPocketenvSandboxGetSandboxes from "./types/io/pocketenv/sandbox/getSandboxes";
27
+
import type * as IoPocketenvSandboxGetSshKeys from "./types/io/pocketenv/sandbox/getSshKeys";
28
+
import type * as IoPocketenvSandboxGetTailscaleAuthKey from "./types/io/pocketenv/sandbox/getTailscaleAuthKey";
29
+
import type * as IoPocketenvSandboxGetTailscaleToken from "./types/io/pocketenv/sandbox/getTailscaleToken";
30
+
import type * as IoPocketenvSandboxPutPreferences from "./types/io/pocketenv/sandbox/putPreferences";
31
+
import type * as IoPocketenvSandboxPutSshKeys from "./types/io/pocketenv/sandbox/putSshKeys";
32
+
import type * as IoPocketenvSandboxPutTailscaleAuthKey from "./types/io/pocketenv/sandbox/putTailscaleAuthKey";
33
+
import type * as IoPocketenvSandboxPutTailscaleToken from "./types/io/pocketenv/sandbox/putTailscaleToken";
34
+
import type * as IoPocketenvSandboxStartSandbox from "./types/io/pocketenv/sandbox/startSandbox";
35
+
import type * as IoPocketenvSandboxStopSandbox from "./types/io/pocketenv/sandbox/stopSandbox";
36
+
import type * as IoPocketenvSandboxUpdateSandboxSettings from "./types/io/pocketenv/sandbox/updateSandboxSettings";
37
+
import type * as IoPocketenvSecretAddSecret from "./types/io/pocketenv/secret/addSecret";
38
+
import type * as IoPocketenvSecretDeleteSecret from "./types/io/pocketenv/secret/deleteSecret";
39
+
import type * as IoPocketenvSecretGetSecret from "./types/io/pocketenv/secret/getSecret";
40
+
import type * as IoPocketenvSecretGetSecrets from "./types/io/pocketenv/secret/getSecrets";
41
+
import type * as IoPocketenvVariableAddVariable from "./types/io/pocketenv/variable/addVariable";
42
+
import type * as IoPocketenvVariableDeleteVariable from "./types/io/pocketenv/variable/deleteVariable";
43
+
import type * as IoPocketenvVariableGetVariable from "./types/io/pocketenv/variable/getVariable";
44
+
import type * as IoPocketenvVariableGetVariables from "./types/io/pocketenv/variable/getVariables";
45
+
import type * as IoPocketenvVolumeAddVolume from "./types/io/pocketenv/volume/addVolume";
46
+
import type * as IoPocketenvVolumeDeleteVolume from "./types/io/pocketenv/volume/deleteVolume";
47
+
import type * as IoPocketenvVolumeGetVolume from "./types/io/pocketenv/volume/getVolume";
48
+
import type * as IoPocketenvVolumeGetVolumes from "./types/io/pocketenv/volume/getVolumes";
45
49
46
50
export function createServer(options?: XrpcOptions): Server {
47
-
return new Server(options)
51
+
return new Server(options);
48
52
}
49
53
50
54
export class Server {
51
-
xrpc: XrpcServer
52
-
io: IoNS
53
-
app: AppNS
54
-
com: ComNS
55
+
xrpc: XrpcServer;
56
+
io: IoNS;
57
+
app: AppNS;
58
+
com: ComNS;
55
59
56
60
constructor(options?: XrpcOptions) {
57
-
this.xrpc = createXrpcServer(schemas, options)
58
-
this.io = new IoNS(this)
59
-
this.app = new AppNS(this)
60
-
this.com = new ComNS(this)
61
+
this.xrpc = createXrpcServer(schemas, options);
62
+
this.io = new IoNS(this);
63
+
this.app = new AppNS(this);
64
+
this.com = new ComNS(this);
61
65
}
62
66
}
63
67
64
68
export class IoNS {
65
-
_server: Server
66
-
pocketenv: IoPocketenvNS
69
+
_server: Server;
70
+
pocketenv: IoPocketenvNS;
67
71
68
72
constructor(server: Server) {
69
-
this._server = server
70
-
this.pocketenv = new IoPocketenvNS(server)
73
+
this._server = server;
74
+
this.pocketenv = new IoPocketenvNS(server);
71
75
}
72
76
}
73
77
74
78
export class IoPocketenvNS {
75
-
_server: Server
76
-
actor: IoPocketenvActorNS
77
-
file: IoPocketenvFileNS
78
-
sandbox: IoPocketenvSandboxNS
79
-
secret: IoPocketenvSecretNS
80
-
variable: IoPocketenvVariableNS
81
-
volume: IoPocketenvVolumeNS
79
+
_server: Server;
80
+
actor: IoPocketenvActorNS;
81
+
file: IoPocketenvFileNS;
82
+
sandbox: IoPocketenvSandboxNS;
83
+
secret: IoPocketenvSecretNS;
84
+
variable: IoPocketenvVariableNS;
85
+
volume: IoPocketenvVolumeNS;
82
86
83
87
constructor(server: Server) {
84
-
this._server = server
85
-
this.actor = new IoPocketenvActorNS(server)
86
-
this.file = new IoPocketenvFileNS(server)
87
-
this.sandbox = new IoPocketenvSandboxNS(server)
88
-
this.secret = new IoPocketenvSecretNS(server)
89
-
this.variable = new IoPocketenvVariableNS(server)
90
-
this.volume = new IoPocketenvVolumeNS(server)
88
+
this._server = server;
89
+
this.actor = new IoPocketenvActorNS(server);
90
+
this.file = new IoPocketenvFileNS(server);
91
+
this.sandbox = new IoPocketenvSandboxNS(server);
92
+
this.secret = new IoPocketenvSecretNS(server);
93
+
this.variable = new IoPocketenvVariableNS(server);
94
+
this.volume = new IoPocketenvVolumeNS(server);
91
95
}
92
96
}
93
97
94
98
export class IoPocketenvActorNS {
95
-
_server: Server
99
+
_server: Server;
96
100
97
101
constructor(server: Server) {
98
-
this._server = server
102
+
this._server = server;
99
103
}
100
104
101
105
getActorSandboxes<AV extends AuthVerifier>(
···
105
109
IoPocketenvActorGetActorSandboxes.HandlerReqCtx<ExtractAuth<AV>>
106
110
>,
107
111
) {
108
-
const nsid = 'io.pocketenv.actor.getActorSandboxes' // @ts-ignore
109
-
return this._server.xrpc.method(nsid, cfg)
112
+
const nsid = "io.pocketenv.actor.getActorSandboxes"; // @ts-ignore
113
+
return this._server.xrpc.method(nsid, cfg);
110
114
}
111
115
112
116
getProfile<AV extends AuthVerifier>(
···
116
120
IoPocketenvActorGetProfile.HandlerReqCtx<ExtractAuth<AV>>
117
121
>,
118
122
) {
119
-
const nsid = 'io.pocketenv.actor.getProfile' // @ts-ignore
120
-
return this._server.xrpc.method(nsid, cfg)
123
+
const nsid = "io.pocketenv.actor.getProfile"; // @ts-ignore
124
+
return this._server.xrpc.method(nsid, cfg);
121
125
}
122
126
123
127
getTerminalToken<AV extends AuthVerifier>(
···
127
131
IoPocketenvActorGetTerminalToken.HandlerReqCtx<ExtractAuth<AV>>
128
132
>,
129
133
) {
130
-
const nsid = 'io.pocketenv.actor.getTerminalToken' // @ts-ignore
131
-
return this._server.xrpc.method(nsid, cfg)
134
+
const nsid = "io.pocketenv.actor.getTerminalToken"; // @ts-ignore
135
+
return this._server.xrpc.method(nsid, cfg);
132
136
}
133
137
}
134
138
135
139
export class IoPocketenvFileNS {
136
-
_server: Server
140
+
_server: Server;
137
141
138
142
constructor(server: Server) {
139
-
this._server = server
143
+
this._server = server;
140
144
}
141
145
142
146
addFile<AV extends AuthVerifier>(
···
146
150
IoPocketenvFileAddFile.HandlerReqCtx<ExtractAuth<AV>>
147
151
>,
148
152
) {
149
-
const nsid = 'io.pocketenv.file.addFile' // @ts-ignore
150
-
return this._server.xrpc.method(nsid, cfg)
153
+
const nsid = "io.pocketenv.file.addFile"; // @ts-ignore
154
+
return this._server.xrpc.method(nsid, cfg);
151
155
}
152
156
153
157
deleteFile<AV extends AuthVerifier>(
···
157
161
IoPocketenvFileDeleteFile.HandlerReqCtx<ExtractAuth<AV>>
158
162
>,
159
163
) {
160
-
const nsid = 'io.pocketenv.file.deleteFile' // @ts-ignore
161
-
return this._server.xrpc.method(nsid, cfg)
164
+
const nsid = "io.pocketenv.file.deleteFile"; // @ts-ignore
165
+
return this._server.xrpc.method(nsid, cfg);
166
+
}
167
+
168
+
getFile<AV extends AuthVerifier>(
169
+
cfg: ConfigOf<
170
+
AV,
171
+
IoPocketenvFileGetFile.Handler<ExtractAuth<AV>>,
172
+
IoPocketenvFileGetFile.HandlerReqCtx<ExtractAuth<AV>>
173
+
>,
174
+
) {
175
+
const nsid = "io.pocketenv.file.getFile"; // @ts-ignore
176
+
return this._server.xrpc.method(nsid, cfg);
162
177
}
163
178
164
179
getFiles<AV extends AuthVerifier>(
···
168
183
IoPocketenvFileGetFiles.HandlerReqCtx<ExtractAuth<AV>>
169
184
>,
170
185
) {
171
-
const nsid = 'io.pocketenv.file.getFiles' // @ts-ignore
172
-
return this._server.xrpc.method(nsid, cfg)
186
+
const nsid = "io.pocketenv.file.getFiles"; // @ts-ignore
187
+
return this._server.xrpc.method(nsid, cfg);
173
188
}
174
189
}
175
190
176
191
export class IoPocketenvSandboxNS {
177
-
_server: Server
192
+
_server: Server;
178
193
179
194
constructor(server: Server) {
180
-
this._server = server
195
+
this._server = server;
181
196
}
182
197
183
198
claimSandbox<AV extends AuthVerifier>(
···
187
202
IoPocketenvSandboxClaimSandbox.HandlerReqCtx<ExtractAuth<AV>>
188
203
>,
189
204
) {
190
-
const nsid = 'io.pocketenv.sandbox.claimSandbox' // @ts-ignore
191
-
return this._server.xrpc.method(nsid, cfg)
205
+
const nsid = "io.pocketenv.sandbox.claimSandbox"; // @ts-ignore
206
+
return this._server.xrpc.method(nsid, cfg);
192
207
}
193
208
194
209
createIntegration<AV extends AuthVerifier>(
···
198
213
IoPocketenvSandboxCreateIntegration.HandlerReqCtx<ExtractAuth<AV>>
199
214
>,
200
215
) {
201
-
const nsid = 'io.pocketenv.sandbox.createIntegration' // @ts-ignore
202
-
return this._server.xrpc.method(nsid, cfg)
216
+
const nsid = "io.pocketenv.sandbox.createIntegration"; // @ts-ignore
217
+
return this._server.xrpc.method(nsid, cfg);
203
218
}
204
219
205
220
createSandbox<AV extends AuthVerifier>(
···
209
224
IoPocketenvSandboxCreateSandbox.HandlerReqCtx<ExtractAuth<AV>>
210
225
>,
211
226
) {
212
-
const nsid = 'io.pocketenv.sandbox.createSandbox' // @ts-ignore
213
-
return this._server.xrpc.method(nsid, cfg)
227
+
const nsid = "io.pocketenv.sandbox.createSandbox"; // @ts-ignore
228
+
return this._server.xrpc.method(nsid, cfg);
214
229
}
215
230
216
231
deleteSandbox<AV extends AuthVerifier>(
···
220
235
IoPocketenvSandboxDeleteSandbox.HandlerReqCtx<ExtractAuth<AV>>
221
236
>,
222
237
) {
223
-
const nsid = 'io.pocketenv.sandbox.deleteSandbox' // @ts-ignore
224
-
return this._server.xrpc.method(nsid, cfg)
238
+
const nsid = "io.pocketenv.sandbox.deleteSandbox"; // @ts-ignore
239
+
return this._server.xrpc.method(nsid, cfg);
225
240
}
226
241
227
242
getIntegrations<AV extends AuthVerifier>(
···
231
246
IoPocketenvSandboxGetIntegrations.HandlerReqCtx<ExtractAuth<AV>>
232
247
>,
233
248
) {
234
-
const nsid = 'io.pocketenv.sandbox.getIntegrations' // @ts-ignore
235
-
return this._server.xrpc.method(nsid, cfg)
249
+
const nsid = "io.pocketenv.sandbox.getIntegrations"; // @ts-ignore
250
+
return this._server.xrpc.method(nsid, cfg);
236
251
}
237
252
238
253
getPreferences<AV extends AuthVerifier>(
···
242
257
IoPocketenvSandboxGetPreferences.HandlerReqCtx<ExtractAuth<AV>>
243
258
>,
244
259
) {
245
-
const nsid = 'io.pocketenv.sandbox.getPreferences' // @ts-ignore
246
-
return this._server.xrpc.method(nsid, cfg)
260
+
const nsid = "io.pocketenv.sandbox.getPreferences"; // @ts-ignore
261
+
return this._server.xrpc.method(nsid, cfg);
247
262
}
248
263
249
264
getSandbox<AV extends AuthVerifier>(
···
253
268
IoPocketenvSandboxGetSandbox.HandlerReqCtx<ExtractAuth<AV>>
254
269
>,
255
270
) {
256
-
const nsid = 'io.pocketenv.sandbox.getSandbox' // @ts-ignore
257
-
return this._server.xrpc.method(nsid, cfg)
271
+
const nsid = "io.pocketenv.sandbox.getSandbox"; // @ts-ignore
272
+
return this._server.xrpc.method(nsid, cfg);
258
273
}
259
274
260
275
getSandboxes<AV extends AuthVerifier>(
···
264
279
IoPocketenvSandboxGetSandboxes.HandlerReqCtx<ExtractAuth<AV>>
265
280
>,
266
281
) {
267
-
const nsid = 'io.pocketenv.sandbox.getSandboxes' // @ts-ignore
268
-
return this._server.xrpc.method(nsid, cfg)
282
+
const nsid = "io.pocketenv.sandbox.getSandboxes"; // @ts-ignore
283
+
return this._server.xrpc.method(nsid, cfg);
269
284
}
270
285
271
286
getSshKeys<AV extends AuthVerifier>(
···
275
290
IoPocketenvSandboxGetSshKeys.HandlerReqCtx<ExtractAuth<AV>>
276
291
>,
277
292
) {
278
-
const nsid = 'io.pocketenv.sandbox.getSshKeys' // @ts-ignore
279
-
return this._server.xrpc.method(nsid, cfg)
293
+
const nsid = "io.pocketenv.sandbox.getSshKeys"; // @ts-ignore
294
+
return this._server.xrpc.method(nsid, cfg);
280
295
}
281
296
282
297
getTailscaleAuthKey<AV extends AuthVerifier>(
···
286
301
IoPocketenvSandboxGetTailscaleAuthKey.HandlerReqCtx<ExtractAuth<AV>>
287
302
>,
288
303
) {
289
-
const nsid = 'io.pocketenv.sandbox.getTailscaleAuthKey' // @ts-ignore
290
-
return this._server.xrpc.method(nsid, cfg)
304
+
const nsid = "io.pocketenv.sandbox.getTailscaleAuthKey"; // @ts-ignore
305
+
return this._server.xrpc.method(nsid, cfg);
291
306
}
292
307
293
308
getTailscaleToken<AV extends AuthVerifier>(
···
297
312
IoPocketenvSandboxGetTailscaleToken.HandlerReqCtx<ExtractAuth<AV>>
298
313
>,
299
314
) {
300
-
const nsid = 'io.pocketenv.sandbox.getTailscaleToken' // @ts-ignore
301
-
return this._server.xrpc.method(nsid, cfg)
315
+
const nsid = "io.pocketenv.sandbox.getTailscaleToken"; // @ts-ignore
316
+
return this._server.xrpc.method(nsid, cfg);
302
317
}
303
318
304
319
putPreferences<AV extends AuthVerifier>(
···
308
323
IoPocketenvSandboxPutPreferences.HandlerReqCtx<ExtractAuth<AV>>
309
324
>,
310
325
) {
311
-
const nsid = 'io.pocketenv.sandbox.putPreferences' // @ts-ignore
312
-
return this._server.xrpc.method(nsid, cfg)
326
+
const nsid = "io.pocketenv.sandbox.putPreferences"; // @ts-ignore
327
+
return this._server.xrpc.method(nsid, cfg);
313
328
}
314
329
315
330
putSshKeys<AV extends AuthVerifier>(
···
319
334
IoPocketenvSandboxPutSshKeys.HandlerReqCtx<ExtractAuth<AV>>
320
335
>,
321
336
) {
322
-
const nsid = 'io.pocketenv.sandbox.putSshKeys' // @ts-ignore
323
-
return this._server.xrpc.method(nsid, cfg)
337
+
const nsid = "io.pocketenv.sandbox.putSshKeys"; // @ts-ignore
338
+
return this._server.xrpc.method(nsid, cfg);
324
339
}
325
340
326
341
putTailscaleAuthKey<AV extends AuthVerifier>(
···
330
345
IoPocketenvSandboxPutTailscaleAuthKey.HandlerReqCtx<ExtractAuth<AV>>
331
346
>,
332
347
) {
333
-
const nsid = 'io.pocketenv.sandbox.putTailscaleAuthKey' // @ts-ignore
334
-
return this._server.xrpc.method(nsid, cfg)
348
+
const nsid = "io.pocketenv.sandbox.putTailscaleAuthKey"; // @ts-ignore
349
+
return this._server.xrpc.method(nsid, cfg);
335
350
}
336
351
337
352
putTailscaleToken<AV extends AuthVerifier>(
···
341
356
IoPocketenvSandboxPutTailscaleToken.HandlerReqCtx<ExtractAuth<AV>>
342
357
>,
343
358
) {
344
-
const nsid = 'io.pocketenv.sandbox.putTailscaleToken' // @ts-ignore
345
-
return this._server.xrpc.method(nsid, cfg)
359
+
const nsid = "io.pocketenv.sandbox.putTailscaleToken"; // @ts-ignore
360
+
return this._server.xrpc.method(nsid, cfg);
346
361
}
347
362
348
363
startSandbox<AV extends AuthVerifier>(
···
352
367
IoPocketenvSandboxStartSandbox.HandlerReqCtx<ExtractAuth<AV>>
353
368
>,
354
369
) {
355
-
const nsid = 'io.pocketenv.sandbox.startSandbox' // @ts-ignore
356
-
return this._server.xrpc.method(nsid, cfg)
370
+
const nsid = "io.pocketenv.sandbox.startSandbox"; // @ts-ignore
371
+
return this._server.xrpc.method(nsid, cfg);
357
372
}
358
373
359
374
stopSandbox<AV extends AuthVerifier>(
···
363
378
IoPocketenvSandboxStopSandbox.HandlerReqCtx<ExtractAuth<AV>>
364
379
>,
365
380
) {
366
-
const nsid = 'io.pocketenv.sandbox.stopSandbox' // @ts-ignore
367
-
return this._server.xrpc.method(nsid, cfg)
381
+
const nsid = "io.pocketenv.sandbox.stopSandbox"; // @ts-ignore
382
+
return this._server.xrpc.method(nsid, cfg);
368
383
}
369
384
370
385
updateSandboxSettings<AV extends AuthVerifier>(
···
374
389
IoPocketenvSandboxUpdateSandboxSettings.HandlerReqCtx<ExtractAuth<AV>>
375
390
>,
376
391
) {
377
-
const nsid = 'io.pocketenv.sandbox.updateSandboxSettings' // @ts-ignore
378
-
return this._server.xrpc.method(nsid, cfg)
392
+
const nsid = "io.pocketenv.sandbox.updateSandboxSettings"; // @ts-ignore
393
+
return this._server.xrpc.method(nsid, cfg);
379
394
}
380
395
}
381
396
382
397
export class IoPocketenvSecretNS {
383
-
_server: Server
398
+
_server: Server;
384
399
385
400
constructor(server: Server) {
386
-
this._server = server
401
+
this._server = server;
387
402
}
388
403
389
404
addSecret<AV extends AuthVerifier>(
···
393
408
IoPocketenvSecretAddSecret.HandlerReqCtx<ExtractAuth<AV>>
394
409
>,
395
410
) {
396
-
const nsid = 'io.pocketenv.secret.addSecret' // @ts-ignore
397
-
return this._server.xrpc.method(nsid, cfg)
411
+
const nsid = "io.pocketenv.secret.addSecret"; // @ts-ignore
412
+
return this._server.xrpc.method(nsid, cfg);
398
413
}
399
414
400
415
deleteSecret<AV extends AuthVerifier>(
···
404
419
IoPocketenvSecretDeleteSecret.HandlerReqCtx<ExtractAuth<AV>>
405
420
>,
406
421
) {
407
-
const nsid = 'io.pocketenv.secret.deleteSecret' // @ts-ignore
408
-
return this._server.xrpc.method(nsid, cfg)
422
+
const nsid = "io.pocketenv.secret.deleteSecret"; // @ts-ignore
423
+
return this._server.xrpc.method(nsid, cfg);
424
+
}
425
+
426
+
getSecret<AV extends AuthVerifier>(
427
+
cfg: ConfigOf<
428
+
AV,
429
+
IoPocketenvSecretGetSecret.Handler<ExtractAuth<AV>>,
430
+
IoPocketenvSecretGetSecret.HandlerReqCtx<ExtractAuth<AV>>
431
+
>,
432
+
) {
433
+
const nsid = "io.pocketenv.secret.getSecret"; // @ts-ignore
434
+
return this._server.xrpc.method(nsid, cfg);
409
435
}
410
436
411
437
getSecrets<AV extends AuthVerifier>(
···
415
441
IoPocketenvSecretGetSecrets.HandlerReqCtx<ExtractAuth<AV>>
416
442
>,
417
443
) {
418
-
const nsid = 'io.pocketenv.secret.getSecrets' // @ts-ignore
419
-
return this._server.xrpc.method(nsid, cfg)
444
+
const nsid = "io.pocketenv.secret.getSecrets"; // @ts-ignore
445
+
return this._server.xrpc.method(nsid, cfg);
420
446
}
421
447
}
422
448
423
449
export class IoPocketenvVariableNS {
424
-
_server: Server
450
+
_server: Server;
425
451
426
452
constructor(server: Server) {
427
-
this._server = server
453
+
this._server = server;
428
454
}
429
455
430
456
addVariable<AV extends AuthVerifier>(
···
434
460
IoPocketenvVariableAddVariable.HandlerReqCtx<ExtractAuth<AV>>
435
461
>,
436
462
) {
437
-
const nsid = 'io.pocketenv.variable.addVariable' // @ts-ignore
438
-
return this._server.xrpc.method(nsid, cfg)
463
+
const nsid = "io.pocketenv.variable.addVariable"; // @ts-ignore
464
+
return this._server.xrpc.method(nsid, cfg);
439
465
}
440
466
441
467
deleteVariable<AV extends AuthVerifier>(
···
445
471
IoPocketenvVariableDeleteVariable.HandlerReqCtx<ExtractAuth<AV>>
446
472
>,
447
473
) {
448
-
const nsid = 'io.pocketenv.variable.deleteVariable' // @ts-ignore
449
-
return this._server.xrpc.method(nsid, cfg)
474
+
const nsid = "io.pocketenv.variable.deleteVariable"; // @ts-ignore
475
+
return this._server.xrpc.method(nsid, cfg);
476
+
}
477
+
478
+
getVariable<AV extends AuthVerifier>(
479
+
cfg: ConfigOf<
480
+
AV,
481
+
IoPocketenvVariableGetVariable.Handler<ExtractAuth<AV>>,
482
+
IoPocketenvVariableGetVariable.HandlerReqCtx<ExtractAuth<AV>>
483
+
>,
484
+
) {
485
+
const nsid = "io.pocketenv.variable.getVariable"; // @ts-ignore
486
+
return this._server.xrpc.method(nsid, cfg);
450
487
}
451
488
452
489
getVariables<AV extends AuthVerifier>(
···
456
493
IoPocketenvVariableGetVariables.HandlerReqCtx<ExtractAuth<AV>>
457
494
>,
458
495
) {
459
-
const nsid = 'io.pocketenv.variable.getVariables' // @ts-ignore
460
-
return this._server.xrpc.method(nsid, cfg)
496
+
const nsid = "io.pocketenv.variable.getVariables"; // @ts-ignore
497
+
return this._server.xrpc.method(nsid, cfg);
461
498
}
462
499
}
463
500
464
501
export class IoPocketenvVolumeNS {
465
-
_server: Server
502
+
_server: Server;
466
503
467
504
constructor(server: Server) {
468
-
this._server = server
505
+
this._server = server;
469
506
}
470
507
471
508
addVolume<AV extends AuthVerifier>(
···
475
512
IoPocketenvVolumeAddVolume.HandlerReqCtx<ExtractAuth<AV>>
476
513
>,
477
514
) {
478
-
const nsid = 'io.pocketenv.volume.addVolume' // @ts-ignore
479
-
return this._server.xrpc.method(nsid, cfg)
515
+
const nsid = "io.pocketenv.volume.addVolume"; // @ts-ignore
516
+
return this._server.xrpc.method(nsid, cfg);
480
517
}
481
518
482
519
deleteVolume<AV extends AuthVerifier>(
···
486
523
IoPocketenvVolumeDeleteVolume.HandlerReqCtx<ExtractAuth<AV>>
487
524
>,
488
525
) {
489
-
const nsid = 'io.pocketenv.volume.deleteVolume' // @ts-ignore
490
-
return this._server.xrpc.method(nsid, cfg)
526
+
const nsid = "io.pocketenv.volume.deleteVolume"; // @ts-ignore
527
+
return this._server.xrpc.method(nsid, cfg);
528
+
}
529
+
530
+
getVolume<AV extends AuthVerifier>(
531
+
cfg: ConfigOf<
532
+
AV,
533
+
IoPocketenvVolumeGetVolume.Handler<ExtractAuth<AV>>,
534
+
IoPocketenvVolumeGetVolume.HandlerReqCtx<ExtractAuth<AV>>
535
+
>,
536
+
) {
537
+
const nsid = "io.pocketenv.volume.getVolume"; // @ts-ignore
538
+
return this._server.xrpc.method(nsid, cfg);
491
539
}
492
540
493
541
getVolumes<AV extends AuthVerifier>(
···
497
545
IoPocketenvVolumeGetVolumes.HandlerReqCtx<ExtractAuth<AV>>
498
546
>,
499
547
) {
500
-
const nsid = 'io.pocketenv.volume.getVolumes' // @ts-ignore
501
-
return this._server.xrpc.method(nsid, cfg)
548
+
const nsid = "io.pocketenv.volume.getVolumes"; // @ts-ignore
549
+
return this._server.xrpc.method(nsid, cfg);
502
550
}
503
551
}
504
552
505
553
export class AppNS {
506
-
_server: Server
507
-
bsky: AppBskyNS
554
+
_server: Server;
555
+
bsky: AppBskyNS;
508
556
509
557
constructor(server: Server) {
510
-
this._server = server
511
-
this.bsky = new AppBskyNS(server)
558
+
this._server = server;
559
+
this.bsky = new AppBskyNS(server);
512
560
}
513
561
}
514
562
515
563
export class AppBskyNS {
516
-
_server: Server
517
-
actor: AppBskyActorNS
564
+
_server: Server;
565
+
actor: AppBskyActorNS;
518
566
519
567
constructor(server: Server) {
520
-
this._server = server
521
-
this.actor = new AppBskyActorNS(server)
568
+
this._server = server;
569
+
this.actor = new AppBskyActorNS(server);
522
570
}
523
571
}
524
572
525
573
export class AppBskyActorNS {
526
-
_server: Server
574
+
_server: Server;
527
575
528
576
constructor(server: Server) {
529
-
this._server = server
577
+
this._server = server;
530
578
}
531
579
}
532
580
533
581
export class ComNS {
534
-
_server: Server
535
-
atproto: ComAtprotoNS
582
+
_server: Server;
583
+
atproto: ComAtprotoNS;
536
584
537
585
constructor(server: Server) {
538
-
this._server = server
539
-
this.atproto = new ComAtprotoNS(server)
586
+
this._server = server;
587
+
this.atproto = new ComAtprotoNS(server);
540
588
}
541
589
}
542
590
543
591
export class ComAtprotoNS {
544
-
_server: Server
545
-
repo: ComAtprotoRepoNS
592
+
_server: Server;
593
+
repo: ComAtprotoRepoNS;
546
594
547
595
constructor(server: Server) {
548
-
this._server = server
549
-
this.repo = new ComAtprotoRepoNS(server)
596
+
this._server = server;
597
+
this.repo = new ComAtprotoRepoNS(server);
550
598
}
551
599
}
552
600
553
601
export class ComAtprotoRepoNS {
554
-
_server: Server
602
+
_server: Server;
555
603
556
604
constructor(server: Server) {
557
-
this._server = server
605
+
this._server = server;
558
606
}
559
607
}
560
608
561
609
type SharedRateLimitOpts<T> = {
562
-
name: string
563
-
calcKey?: (ctx: T) => string | null
564
-
calcPoints?: (ctx: T) => number
565
-
}
610
+
name: string;
611
+
calcKey?: (ctx: T) => string | null;
612
+
calcPoints?: (ctx: T) => number;
613
+
};
566
614
type RouteRateLimitOpts<T> = {
567
-
durationMs: number
568
-
points: number
569
-
calcKey?: (ctx: T) => string | null
570
-
calcPoints?: (ctx: T) => number
571
-
}
572
-
type HandlerOpts = { blobLimit?: number }
573
-
type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>
615
+
durationMs: number;
616
+
points: number;
617
+
calcKey?: (ctx: T) => string | null;
618
+
calcPoints?: (ctx: T) => number;
619
+
};
620
+
type HandlerOpts = { blobLimit?: number };
621
+
type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>;
574
622
type ConfigOf<Auth, Handler, ReqCtx> =
575
623
| Handler
576
624
| {
577
-
auth?: Auth
578
-
opts?: HandlerOpts
579
-
rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]
580
-
handler: Handler
581
-
}
625
+
auth?: Auth;
626
+
opts?: HandlerOpts;
627
+
rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[];
628
+
handler: Handler;
629
+
};
582
630
type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract<
583
631
Awaited<ReturnType<AV>>,
584
632
{ credentials: unknown }
585
-
>
633
+
>;
+946
-815
apps/api/src/lexicon/lexicons.ts
+946
-815
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
+
defs: {
295
+
main: {
296
+
type: "procedure",
297
+
parameters: {
298
+
type: "params",
299
+
required: ["id"],
300
+
properties: {
301
+
id: {
302
+
type: "string",
303
+
description: "The ID of the file to delete",
304
+
},
305
+
},
306
+
},
307
+
},
308
+
},
309
+
},
310
+
IoPocketenvFileGetFile: {
311
+
lexicon: 1,
312
+
id: "io.pocketenv.file.getFile",
294
313
defs: {
295
314
main: {
296
-
type: 'procedure',
315
+
type: "query",
297
316
parameters: {
298
-
type: 'params',
299
-
required: ['id'],
317
+
type: "params",
318
+
required: ["id"],
300
319
properties: {
301
320
id: {
302
-
type: 'string',
303
-
description: 'The ID of the file to delete',
321
+
type: "string",
322
+
description: "The ID of the file to retrieve.",
323
+
},
324
+
},
325
+
},
326
+
output: {
327
+
encoding: "application/json",
328
+
schema: {
329
+
type: "object",
330
+
properties: {
331
+
file: {
332
+
type: "ref",
333
+
ref: "lex:io.pocketenv.file.defs#fileView",
334
+
},
304
335
},
305
336
},
306
337
},
···
309
340
},
310
341
IoPocketenvFileGetFiles: {
311
342
lexicon: 1,
312
-
id: 'io.pocketenv.file.getFiles',
343
+
id: "io.pocketenv.file.getFiles",
313
344
defs: {
314
345
main: {
315
-
type: 'query',
346
+
type: "query",
316
347
parameters: {
317
-
type: 'params',
348
+
type: "params",
318
349
properties: {
319
350
sandboxId: {
320
-
type: 'string',
321
-
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.",
322
353
},
323
354
limit: {
324
-
type: 'integer',
325
-
description: 'The maximum number of files to return.',
355
+
type: "integer",
356
+
description: "The maximum number of files to return.",
326
357
minimum: 1,
327
358
},
328
359
offset: {
329
-
type: 'integer',
360
+
type: "integer",
330
361
description:
331
-
'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.",
332
363
minimum: 0,
333
364
},
334
365
},
335
366
},
336
367
output: {
337
-
encoding: 'application/json',
368
+
encoding: "application/json",
338
369
schema: {
339
-
type: 'object',
370
+
type: "object",
340
371
properties: {
341
372
files: {
342
-
type: 'array',
373
+
type: "array",
343
374
items: {
344
-
type: 'ref',
345
-
ref: 'lex:io.pocketenv.file.defs#fileView',
375
+
type: "ref",
376
+
ref: "lex:io.pocketenv.file.defs#fileView",
346
377
},
347
378
},
348
379
total: {
349
-
type: 'integer',
350
-
description: 'The total number of files available.',
380
+
type: "integer",
381
+
description: "The total number of files available.",
351
382
minimum: 0,
352
383
},
353
384
},
···
358
389
},
359
390
IoPocketenvSandboxClaimSandbox: {
360
391
lexicon: 1,
361
-
id: 'io.pocketenv.sandbox.claimSandbox',
392
+
id: "io.pocketenv.sandbox.claimSandbox",
362
393
defs: {
363
394
main: {
364
-
type: 'procedure',
365
-
description: 'Claim a sandbox by id',
395
+
type: "procedure",
396
+
description: "Claim a sandbox by id",
366
397
parameters: {
367
-
type: 'params',
368
-
required: ['id'],
398
+
type: "params",
399
+
required: ["id"],
369
400
properties: {
370
401
id: {
371
-
type: 'string',
372
-
description: 'The sandbox ID.',
402
+
type: "string",
403
+
description: "The sandbox ID.",
373
404
},
374
405
},
375
406
},
376
407
output: {
377
-
encoding: 'application/json',
408
+
encoding: "application/json",
378
409
schema: {
379
-
type: 'ref',
380
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
410
+
type: "ref",
411
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
381
412
},
382
413
},
383
414
},
···
385
416
},
386
417
IoPocketenvSandboxCreateIntegration: {
387
418
lexicon: 1,
388
-
id: 'io.pocketenv.sandbox.createIntegration',
419
+
id: "io.pocketenv.sandbox.createIntegration",
389
420
defs: {
390
421
main: {
391
-
type: 'procedure',
392
-
description: 'Create a new integration for the sandbox.',
422
+
type: "procedure",
423
+
description: "Create a new integration for the sandbox.",
393
424
input: {
394
-
encoding: 'application/json',
425
+
encoding: "application/json",
395
426
schema: {
396
-
type: 'object',
397
-
required: ['id', 'name'],
427
+
type: "object",
428
+
required: ["id", "name"],
398
429
properties: {
399
430
id: {
400
-
type: 'string',
401
-
description: 'The sandbox ID.',
431
+
type: "string",
432
+
description: "The sandbox ID.",
402
433
},
403
434
name: {
404
-
type: 'string',
405
-
description: 'The name of the integration.',
435
+
type: "string",
436
+
description: "The name of the integration.",
406
437
},
407
438
},
408
439
},
409
440
},
410
441
output: {
411
-
encoding: 'application/json',
442
+
encoding: "application/json",
412
443
schema: {
413
-
type: 'ref',
414
-
ref: 'lex:io.pocketenv.sandbox.defs#integrationView',
444
+
type: "ref",
445
+
ref: "lex:io.pocketenv.sandbox.defs#integrationView",
415
446
},
416
447
},
417
448
},
···
419
450
},
420
451
IoPocketenvSandboxCreateSandbox: {
421
452
lexicon: 1,
422
-
id: 'io.pocketenv.sandbox.createSandbox',
453
+
id: "io.pocketenv.sandbox.createSandbox",
423
454
defs: {
424
455
main: {
425
-
type: 'procedure',
426
-
description: 'Create a sandbox',
456
+
type: "procedure",
457
+
description: "Create a sandbox",
427
458
input: {
428
-
encoding: 'application/json',
459
+
encoding: "application/json",
429
460
schema: {
430
-
type: 'object',
431
-
required: ['base'],
461
+
type: "object",
462
+
required: ["base"],
432
463
properties: {
433
464
base: {
434
-
type: 'string',
465
+
type: "string",
435
466
description:
436
-
'The base sandbox URI to clone from, e.g. a template or an existing sandbox.',
467
+
"The base sandbox URI to clone from, e.g. a template or an existing sandbox.",
437
468
},
438
469
name: {
439
-
type: 'string',
440
-
description: 'The name of the sandbox',
470
+
type: "string",
471
+
description: "The name of the sandbox",
441
472
minLength: 1,
442
473
},
443
474
description: {
444
-
type: 'string',
445
-
description: 'A description for the sandbox',
475
+
type: "string",
476
+
description: "A description for the sandbox",
446
477
},
447
478
provider: {
448
-
type: 'string',
479
+
type: "string",
449
480
description:
450
481
"The provider to create the sandbox on, e.g. 'daytona', 'vercel', 'cloudflare', etc.",
451
-
enum: ['daytona', 'vercel', 'cloudflare', 'deno'],
482
+
enum: ["daytona", "vercel", "cloudflare", "deno"],
452
483
},
453
484
topics: {
454
-
type: 'array',
485
+
type: "array",
455
486
description:
456
-
'A list of topics/tags to associate with the sandbox',
487
+
"A list of topics/tags to associate with the sandbox",
457
488
items: {
458
-
type: 'string',
489
+
type: "string",
459
490
maxLength: 50,
460
491
},
461
492
},
462
493
repo: {
463
-
type: 'string',
494
+
type: "string",
464
495
description:
465
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
466
-
format: 'uri',
496
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
497
+
format: "uri",
467
498
},
468
499
vcpus: {
469
-
type: 'integer',
500
+
type: "integer",
470
501
description:
471
-
'The number of virtual CPUs to allocate for the sandbox',
502
+
"The number of virtual CPUs to allocate for the sandbox",
472
503
minimum: 1,
473
504
},
474
505
memory: {
475
-
type: 'integer',
506
+
type: "integer",
476
507
description:
477
-
'The amount of memory (in GB) to allocate for the sandbox',
508
+
"The amount of memory (in GB) to allocate for the sandbox",
478
509
minimum: 1,
479
510
},
480
511
disk: {
481
-
type: 'integer',
512
+
type: "integer",
482
513
description:
483
-
'The amount of disk space (in GB) to allocate for the sandbox',
514
+
"The amount of disk space (in GB) to allocate for the sandbox",
484
515
minimum: 3,
485
516
},
486
517
readme: {
487
-
type: 'string',
488
-
description: 'A URI to a README for the sandbox.',
489
-
format: 'uri',
518
+
type: "string",
519
+
description: "A URI to a README for the sandbox.",
520
+
format: "uri",
490
521
},
491
522
secrets: {
492
-
type: 'ref',
493
-
description: 'A list of secrets to add to the sandbox',
494
-
ref: 'lex:io.pocketenv.sandbox.defs#secrets',
523
+
type: "ref",
524
+
description: "A list of secrets to add to the sandbox",
525
+
ref: "lex:io.pocketenv.sandbox.defs#secrets",
495
526
},
496
527
envs: {
497
-
type: 'ref',
528
+
type: "ref",
498
529
description:
499
-
'A list of environment variables to add to the sandbox',
500
-
ref: 'lex:io.pocketenv.sandbox.defs#envs',
530
+
"A list of environment variables to add to the sandbox",
531
+
ref: "lex:io.pocketenv.sandbox.defs#envs",
501
532
},
502
533
},
503
534
},
504
535
},
505
536
output: {
506
-
encoding: 'application/json',
537
+
encoding: "application/json",
507
538
schema: {
508
-
type: 'ref',
509
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
539
+
type: "ref",
540
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
510
541
},
511
542
},
512
543
},
···
514
545
},
515
546
IoPocketenvSandboxDefs: {
516
547
lexicon: 1,
517
-
id: 'io.pocketenv.sandbox.defs',
548
+
id: "io.pocketenv.sandbox.defs",
518
549
defs: {
519
550
sandboxViewBasic: {
520
-
type: 'object',
551
+
type: "object",
521
552
properties: {
522
553
name: {
523
-
type: 'string',
524
-
description: 'Name of the sandbox',
554
+
type: "string",
555
+
description: "Name of the sandbox",
525
556
maxLength: 50,
526
557
},
527
558
provider: {
528
-
type: 'string',
559
+
type: "string",
529
560
description:
530
561
"The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.",
531
562
maxLength: 50,
532
563
},
533
564
description: {
534
-
type: 'string',
565
+
type: "string",
535
566
maxGraphemes: 300,
536
567
maxLength: 3000,
537
568
},
538
569
website: {
539
-
type: 'string',
540
-
description: 'Any URI related to the sandbox',
541
-
format: 'uri',
570
+
type: "string",
571
+
description: "Any URI related to the sandbox",
572
+
format: "uri",
542
573
},
543
574
logo: {
544
-
type: 'string',
545
-
description: 'URI to an image logo for the sandbox',
546
-
format: 'uri',
575
+
type: "string",
576
+
description: "URI to an image logo for the sandbox",
577
+
format: "uri",
547
578
},
548
579
topics: {
549
-
type: 'array',
580
+
type: "array",
550
581
items: {
551
-
type: 'string',
582
+
type: "string",
552
583
minLength: 1,
553
584
maxLength: 50,
554
585
},
555
586
maxLength: 50,
556
587
},
557
588
repo: {
558
-
type: 'string',
589
+
type: "string",
559
590
description:
560
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
561
-
format: 'uri',
591
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
592
+
format: "uri",
562
593
},
563
594
readme: {
564
-
type: 'string',
565
-
description: 'A URI to a README for the sandbox.',
566
-
format: 'uri',
595
+
type: "string",
596
+
description: "A URI to a README for the sandbox.",
597
+
format: "uri",
567
598
},
568
599
vcpus: {
569
-
type: 'integer',
570
-
description: 'Number of virtual CPUs allocated to the sandbox',
600
+
type: "integer",
601
+
description: "Number of virtual CPUs allocated to the sandbox",
571
602
},
572
603
memory: {
573
-
type: 'integer',
574
-
description: 'Amount of memory in GB allocated to the sandbox',
604
+
type: "integer",
605
+
description: "Amount of memory in GB allocated to the sandbox",
575
606
},
576
607
disk: {
577
-
type: 'integer',
578
-
description: 'Amount of disk space in GB allocated to the sandbox',
608
+
type: "integer",
609
+
description: "Amount of disk space in GB allocated to the sandbox",
579
610
},
580
611
ports: {
581
-
type: 'array',
612
+
type: "array",
582
613
items: {
583
-
type: 'integer',
614
+
type: "integer",
584
615
maximum: 65535,
585
616
minimum: 1,
586
617
},
587
618
maxLength: 100,
588
619
},
589
620
installs: {
590
-
type: 'integer',
621
+
type: "integer",
591
622
description:
592
-
'Number of times the sandbox has been installed by users.',
623
+
"Number of times the sandbox has been installed by users.",
593
624
},
594
625
createdAt: {
595
-
type: 'string',
596
-
format: 'datetime',
626
+
type: "string",
627
+
format: "datetime",
597
628
},
598
629
},
599
630
},
600
631
sandboxViewDetailed: {
601
-
type: 'object',
632
+
type: "object",
602
633
properties: {
603
634
name: {
604
-
type: 'string',
605
-
description: 'Name of the sandbox',
635
+
type: "string",
636
+
description: "Name of the sandbox",
606
637
maxLength: 50,
607
638
},
608
639
provider: {
609
-
type: 'string',
640
+
type: "string",
610
641
description:
611
642
"The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.",
612
643
maxLength: 50,
613
644
},
614
645
description: {
615
-
type: 'string',
646
+
type: "string",
616
647
maxGraphemes: 300,
617
648
maxLength: 3000,
618
649
},
619
650
status: {
620
-
type: 'string',
651
+
type: "string",
621
652
description:
622
653
"The current status of the sandbox, e.g. 'RUNNING', 'STOPPED', etc.",
623
654
},
624
655
startedAt: {
625
-
type: 'string',
626
-
format: 'datetime',
656
+
type: "string",
657
+
format: "datetime",
627
658
},
628
659
timeout: {
629
-
type: 'integer',
630
-
description: 'The sandbox timeout in seconds',
660
+
type: "integer",
661
+
description: "The sandbox timeout in seconds",
631
662
},
632
663
baseSandbox: {
633
-
type: 'string',
664
+
type: "string",
634
665
description:
635
-
'The base sandbox that this sandbox was created from, if any. This can be used to determine the template or configuration used to create the sandbox.',
666
+
"The base sandbox that this sandbox was created from, if any. This can be used to determine the template or configuration used to create the sandbox.",
636
667
},
637
668
website: {
638
-
type: 'string',
639
-
description: 'Any URI related to the sandbox',
640
-
format: 'uri',
669
+
type: "string",
670
+
description: "Any URI related to the sandbox",
671
+
format: "uri",
641
672
},
642
673
logo: {
643
-
type: 'string',
644
-
description: 'URI to an image logo for the sandbox',
645
-
format: 'uri',
674
+
type: "string",
675
+
description: "URI to an image logo for the sandbox",
676
+
format: "uri",
646
677
},
647
678
topics: {
648
-
type: 'array',
679
+
type: "array",
649
680
items: {
650
-
type: 'string',
681
+
type: "string",
651
682
minLength: 1,
652
683
maxLength: 50,
653
684
},
654
685
maxLength: 50,
655
686
},
656
687
repo: {
657
-
type: 'string',
688
+
type: "string",
658
689
description:
659
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
660
-
format: 'uri',
690
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
691
+
format: "uri",
661
692
},
662
693
readme: {
663
-
type: 'string',
664
-
description: 'A URI to a README for the sandbox.',
665
-
format: 'uri',
694
+
type: "string",
695
+
description: "A URI to a README for the sandbox.",
696
+
format: "uri",
666
697
},
667
698
vcpus: {
668
-
type: 'integer',
669
-
description: 'Number of virtual CPUs allocated to the sandbox',
699
+
type: "integer",
700
+
description: "Number of virtual CPUs allocated to the sandbox",
670
701
},
671
702
memory: {
672
-
type: 'integer',
673
-
description: 'Amount of memory in GB allocated to the sandbox',
703
+
type: "integer",
704
+
description: "Amount of memory in GB allocated to the sandbox",
674
705
},
675
706
disk: {
676
-
type: 'integer',
677
-
description: 'Amount of disk space in GB allocated to the sandbox',
707
+
type: "integer",
708
+
description: "Amount of disk space in GB allocated to the sandbox",
678
709
},
679
710
ports: {
680
-
type: 'array',
711
+
type: "array",
681
712
items: {
682
-
type: 'integer',
713
+
type: "integer",
683
714
maximum: 65535,
684
715
minimum: 1,
685
716
},
686
717
maxLength: 100,
687
718
},
688
719
installs: {
689
-
type: 'integer',
720
+
type: "integer",
690
721
description:
691
-
'Number of times the sandbox has been installed by users.',
722
+
"Number of times the sandbox has been installed by users.",
692
723
},
693
724
createdAt: {
694
-
type: 'string',
695
-
format: 'datetime',
725
+
type: "string",
726
+
format: "datetime",
696
727
},
697
728
owner: {
698
-
type: 'ref',
699
-
description: 'The user who created the sandbox',
700
-
ref: 'lex:io.pocketenv.user.defs#userViewBasic',
729
+
type: "ref",
730
+
description: "The user who created the sandbox",
731
+
ref: "lex:io.pocketenv.user.defs#userViewBasic",
701
732
},
702
733
},
703
734
},
704
735
sandboxDetailsPref: {
705
-
type: 'object',
706
-
nullable: ['repo', 'description', 'topics'],
736
+
type: "object",
737
+
nullable: ["repo", "description", "topics"],
707
738
properties: {
708
739
name: {
709
-
type: 'string',
710
-
description: 'The name of the sandbox',
740
+
type: "string",
741
+
description: "The name of the sandbox",
711
742
minLength: 1,
712
743
},
713
744
description: {
714
-
type: 'string',
715
-
description: 'A description for the sandbox',
745
+
type: "string",
746
+
description: "A description for the sandbox",
716
747
},
717
748
topics: {
718
-
type: 'array',
719
-
description: 'A list of topics/tags to associate with the sandbox',
749
+
type: "array",
750
+
description: "A list of topics/tags to associate with the sandbox",
720
751
items: {
721
-
type: 'string',
752
+
type: "string",
722
753
maxLength: 50,
723
754
},
724
755
},
725
756
repo: {
726
-
type: 'string',
757
+
type: "string",
727
758
description:
728
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
729
-
format: 'uri',
759
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
760
+
format: "uri",
730
761
},
731
762
vcpus: {
732
-
type: 'integer',
763
+
type: "integer",
733
764
description:
734
-
'The number of virtual CPUs to allocate for the sandbox',
765
+
"The number of virtual CPUs to allocate for the sandbox",
735
766
minimum: 1,
736
767
},
737
768
memory: {
738
-
type: 'integer',
769
+
type: "integer",
739
770
description:
740
-
'The amount of memory (in GB) to allocate for the sandbox',
771
+
"The amount of memory (in GB) to allocate for the sandbox",
741
772
minimum: 1,
742
773
},
743
774
disk: {
744
-
type: 'integer',
775
+
type: "integer",
745
776
description:
746
-
'The amount of disk space (in GB) to allocate for the sandbox',
777
+
"The amount of disk space (in GB) to allocate for the sandbox",
747
778
minimum: 3,
748
779
},
749
780
readme: {
750
-
type: 'string',
751
-
description: 'A URI to a README for the sandbox.',
752
-
format: 'uri',
781
+
type: "string",
782
+
description: "A URI to a README for the sandbox.",
783
+
format: "uri",
753
784
},
754
785
},
755
786
},
756
787
secretPref: {
757
-
type: 'object',
788
+
type: "object",
758
789
properties: {
759
790
name: {
760
-
type: 'string',
761
-
description: 'The name of the secret',
791
+
type: "string",
792
+
description: "The name of the secret",
762
793
minLength: 1,
763
794
},
764
795
value: {
765
-
type: 'string',
796
+
type: "string",
766
797
description:
767
-
'The value of the secret. This will be encrypted at rest and redacted in any API responses.',
798
+
"The value of the secret. This will be encrypted at rest and redacted in any API responses.",
768
799
},
769
800
},
770
801
},
771
802
variablePref: {
772
-
type: 'object',
773
-
description: 'A variable to add to the sandbox',
803
+
type: "object",
804
+
description: "A variable to add to the sandbox",
774
805
properties: {
775
806
name: {
776
-
type: 'string',
777
-
description: 'The name of the variable',
807
+
type: "string",
808
+
description: "The name of the variable",
778
809
minLength: 1,
779
810
},
780
811
value: {
781
-
type: 'string',
812
+
type: "string",
782
813
description:
783
-
'The value of the variable. This will be visible in API responses and should not contain sensitive information.',
814
+
"The value of the variable. This will be visible in API responses and should not contain sensitive information.",
784
815
},
785
816
},
786
817
},
787
818
filePref: {
788
-
type: 'object',
789
-
description: 'A file to add to the sandbox',
819
+
type: "object",
820
+
description: "A file to add to the sandbox",
790
821
properties: {
791
822
name: {
792
-
type: 'string',
793
-
description: 'The name of the file',
823
+
type: "string",
824
+
description: "The name of the file",
794
825
minLength: 1,
795
826
},
796
827
content: {
797
-
type: 'string',
798
-
description: 'The content of the file.',
828
+
type: "string",
829
+
description: "The content of the file.",
799
830
},
800
831
encrypt: {
801
-
type: 'boolean',
832
+
type: "boolean",
802
833
description:
803
-
'Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information.',
834
+
"Whether the file content should be encrypted at rest and redacted in API responses. This is useful for files that may contain sensitive information.",
804
835
},
805
836
path: {
806
-
type: 'string',
837
+
type: "string",
807
838
description:
808
839
"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.",
809
840
},
810
841
},
811
842
},
812
843
volumePref: {
813
-
type: 'object',
814
-
description: 'A volume to add to the sandbox',
844
+
type: "object",
845
+
description: "A volume to add to the sandbox",
815
846
properties: {
816
847
name: {
817
-
type: 'string',
818
-
description: 'The name of the volume',
848
+
type: "string",
849
+
description: "The name of the volume",
819
850
minLength: 1,
820
851
},
821
852
path: {
822
-
type: 'string',
853
+
type: "string",
823
854
description:
824
855
"The mount path within the sandbox where the volume will be attached, e.g. '/data', '/logs', etc.",
825
856
},
826
857
readOnly: {
827
-
type: 'boolean',
828
-
description: 'Whether the volume should be mounted as read-only',
858
+
type: "boolean",
859
+
description: "Whether the volume should be mounted as read-only",
829
860
},
830
861
},
831
862
},
832
863
preferences: {
833
-
type: 'array',
864
+
type: "array",
834
865
items: {
835
-
type: 'union',
866
+
type: "union",
836
867
refs: [
837
-
'lex:io.pocketenv.sandbox.defs#sandboxDetailsPref',
838
-
'lex:io.pocketenv.sandbox.defs#secretPref',
839
-
'lex:io.pocketenv.sandbox.defs#variablePref',
840
-
'lex:io.pocketenv.sandbox.defs#filePref',
841
-
'lex:io.pocketenv.sandbox.defs#volumePref',
868
+
"lex:io.pocketenv.sandbox.defs#sandboxDetailsPref",
869
+
"lex:io.pocketenv.sandbox.defs#secretPref",
870
+
"lex:io.pocketenv.sandbox.defs#variablePref",
871
+
"lex:io.pocketenv.sandbox.defs#filePref",
872
+
"lex:io.pocketenv.sandbox.defs#volumePref",
842
873
],
843
874
},
844
875
},
845
876
sshKeysView: {
846
-
type: 'object',
877
+
type: "object",
847
878
properties: {
848
879
id: {
849
-
type: 'string',
850
-
description: 'Unique identifier of the SSH key.',
880
+
type: "string",
881
+
description: "Unique identifier of the SSH key.",
851
882
},
852
883
publicKey: {
853
-
type: 'string',
854
-
description: 'The public SSH key.',
884
+
type: "string",
885
+
description: "The public SSH key.",
855
886
},
856
887
privateKey: {
857
-
type: 'string',
858
-
description: 'The private SSH key (redacted in API responses)',
888
+
type: "string",
889
+
description: "The private SSH key (redacted in API responses)",
859
890
},
860
891
createdAt: {
861
-
type: 'string',
862
-
description: 'The timestamp when the SSH key was created.',
863
-
format: 'datetime',
892
+
type: "string",
893
+
description: "The timestamp when the SSH key was created.",
894
+
format: "datetime",
864
895
},
865
896
updatedAt: {
866
-
type: 'string',
867
-
description: 'The timestamp when the SSH key was last updated.',
868
-
format: 'datetime',
897
+
type: "string",
898
+
description: "The timestamp when the SSH key was last updated.",
899
+
format: "datetime",
869
900
},
870
901
},
871
902
},
872
903
tailscaleAuthKeyView: {
873
-
type: 'object',
904
+
type: "object",
874
905
properties: {
875
906
id: {
876
-
type: 'string',
877
-
description: 'Unique identifier of the Tailscale Auth Key.',
907
+
type: "string",
908
+
description: "Unique identifier of the Tailscale Auth Key.",
878
909
},
879
910
authKey: {
880
-
type: 'string',
881
-
description: 'The Tailscale auth key (redacted in API responses)',
911
+
type: "string",
912
+
description: "The Tailscale auth key (redacted in API responses)",
882
913
},
883
914
redacted: {
884
-
type: 'string',
885
-
description: 'The redacted Auth Key.',
915
+
type: "string",
916
+
description: "The redacted Auth Key.",
886
917
},
887
918
createdAt: {
888
-
type: 'string',
919
+
type: "string",
889
920
description:
890
-
'The timestamp when the Tailscale Auth Key was created.',
891
-
format: 'datetime',
921
+
"The timestamp when the Tailscale Auth Key was created.",
922
+
format: "datetime",
892
923
},
893
924
updatedAt: {
894
-
type: 'string',
925
+
type: "string",
895
926
description:
896
-
'The timestamp when the Tailscale Auth Key was last updated.',
897
-
format: 'datetime',
927
+
"The timestamp when the Tailscale Auth Key was last updated.",
928
+
format: "datetime",
898
929
},
899
930
},
900
931
},
901
932
integrationView: {
902
-
type: 'object',
933
+
type: "object",
903
934
properties: {
904
935
id: {
905
-
type: 'string',
906
-
description: 'Unique identifier of the integration.',
936
+
type: "string",
937
+
description: "Unique identifier of the integration.",
907
938
},
908
939
name: {
909
-
type: 'string',
940
+
type: "string",
910
941
description:
911
942
"The name of the integration, e.g. 'GitHub', 'Slack', 'Trello', etc.",
912
943
},
913
944
webhookUrl: {
914
-
type: 'string',
915
-
description: 'The webhook URL of the integration.',
916
-
format: 'uri',
945
+
type: "string",
946
+
description: "The webhook URL of the integration.",
947
+
format: "uri",
917
948
},
918
949
createdAt: {
919
-
type: 'string',
920
-
description: 'The timestamp when the integration was created.',
921
-
format: 'datetime',
950
+
type: "string",
951
+
description: "The timestamp when the integration was created.",
952
+
format: "datetime",
922
953
},
923
954
updatedAt: {
924
-
type: 'string',
925
-
description: 'The timestamp when the integration was last updated.',
926
-
format: 'datetime',
955
+
type: "string",
956
+
description: "The timestamp when the integration was last updated.",
957
+
format: "datetime",
927
958
},
928
959
},
929
960
},
930
961
integrationsView: {
931
-
type: 'array',
962
+
type: "array",
932
963
items: {
933
-
type: 'ref',
934
-
description: 'An integration connected to the sandbox',
935
-
ref: 'lex:io.pocketenv.sandbox.defs#integrationView',
964
+
type: "ref",
965
+
description: "An integration connected to the sandbox",
966
+
ref: "lex:io.pocketenv.sandbox.defs#integrationView",
936
967
},
937
968
},
938
969
},
939
970
},
940
971
IoPocketenvSandboxDeleteSandbox: {
941
972
lexicon: 1,
942
-
id: 'io.pocketenv.sandbox.deleteSandbox',
973
+
id: "io.pocketenv.sandbox.deleteSandbox",
943
974
defs: {
944
975
main: {
945
-
type: 'procedure',
946
-
description: 'Delete a sandbox by uri',
976
+
type: "procedure",
977
+
description: "Delete a sandbox by uri",
947
978
parameters: {
948
-
type: 'params',
949
-
required: ['id'],
979
+
type: "params",
980
+
required: ["id"],
950
981
properties: {
951
982
id: {
952
-
type: 'string',
953
-
description: 'The sandbox ID.',
983
+
type: "string",
984
+
description: "The sandbox ID.",
954
985
},
955
986
},
956
987
},
957
988
output: {
958
-
encoding: 'application/json',
989
+
encoding: "application/json",
959
990
schema: {
960
-
type: 'ref',
961
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
991
+
type: "ref",
992
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
962
993
},
963
994
},
964
995
},
···
966
997
},
967
998
IoPocketenvSandboxGetIntegrations: {
968
999
lexicon: 1,
969
-
id: 'io.pocketenv.sandbox.getIntegrations',
1000
+
id: "io.pocketenv.sandbox.getIntegrations",
970
1001
defs: {
971
1002
main: {
972
-
type: 'query',
973
-
description: 'Get the integrations for a sandbox.',
1003
+
type: "query",
1004
+
description: "Get the integrations for a sandbox.",
974
1005
parameters: {
975
-
type: 'params',
976
-
required: ['id'],
1006
+
type: "params",
1007
+
required: ["id"],
977
1008
properties: {
978
1009
id: {
979
-
type: 'string',
980
-
description: 'The sandbox ID.',
1010
+
type: "string",
1011
+
description: "The sandbox ID.",
981
1012
},
982
1013
},
983
1014
},
984
1015
output: {
985
-
encoding: 'application/json',
1016
+
encoding: "application/json",
986
1017
schema: {
987
-
type: 'ref',
988
-
ref: 'lex:io.pocketenv.sandbox.defs#integrationsView',
1018
+
type: "ref",
1019
+
ref: "lex:io.pocketenv.sandbox.defs#integrationsView",
989
1020
},
990
1021
},
991
1022
},
···
993
1024
},
994
1025
IoPocketenvSandboxGetPreferences: {
995
1026
lexicon: 1,
996
-
id: 'io.pocketenv.sandbox.getPreferences',
1027
+
id: "io.pocketenv.sandbox.getPreferences",
997
1028
defs: {
998
1029
main: {
999
-
type: 'query',
1000
-
description: 'Get sandbox preferences',
1030
+
type: "query",
1031
+
description: "Get sandbox preferences",
1001
1032
parameters: {
1002
-
type: 'params',
1003
-
required: ['id'],
1033
+
type: "params",
1034
+
required: ["id"],
1004
1035
properties: {
1005
1036
id: {
1006
-
type: 'string',
1007
-
description: 'The sandbox ID or URI to retrieve',
1037
+
type: "string",
1038
+
description: "The sandbox ID or URI to retrieve",
1008
1039
},
1009
1040
},
1010
1041
},
1011
1042
output: {
1012
-
encoding: 'application/json',
1043
+
encoding: "application/json",
1013
1044
schema: {
1014
-
type: 'ref',
1015
-
ref: 'lex:io.pocketenv.sandbox.defs#preferences',
1045
+
type: "ref",
1046
+
ref: "lex:io.pocketenv.sandbox.defs#preferences",
1016
1047
},
1017
1048
},
1018
1049
},
···
1020
1051
},
1021
1052
IoPocketenvSandboxGetSandbox: {
1022
1053
lexicon: 1,
1023
-
id: 'io.pocketenv.sandbox.getSandbox',
1054
+
id: "io.pocketenv.sandbox.getSandbox",
1024
1055
defs: {
1025
1056
main: {
1026
-
type: 'query',
1027
-
description: 'Get a sandbox by ID or URI',
1057
+
type: "query",
1058
+
description: "Get a sandbox by ID or URI",
1028
1059
parameters: {
1029
-
type: 'params',
1030
-
required: ['id'],
1060
+
type: "params",
1061
+
required: ["id"],
1031
1062
properties: {
1032
1063
id: {
1033
-
type: 'string',
1034
-
description: 'The sandbox ID or URI to retrieve',
1064
+
type: "string",
1065
+
description: "The sandbox ID or URI to retrieve",
1035
1066
},
1036
1067
},
1037
1068
},
1038
1069
output: {
1039
-
encoding: 'application/json',
1070
+
encoding: "application/json",
1040
1071
schema: {
1041
-
type: 'ref',
1042
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1072
+
type: "ref",
1073
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1043
1074
},
1044
1075
},
1045
1076
},
···
1047
1078
},
1048
1079
IoPocketenvSandboxGetSandboxes: {
1049
1080
lexicon: 1,
1050
-
id: 'io.pocketenv.sandbox.getSandboxes',
1081
+
id: "io.pocketenv.sandbox.getSandboxes",
1051
1082
defs: {
1052
1083
main: {
1053
-
type: 'query',
1054
-
description: 'Get all sandboxes',
1084
+
type: "query",
1085
+
description: "Get all sandboxes",
1055
1086
parameters: {
1056
-
type: 'params',
1087
+
type: "params",
1057
1088
properties: {
1058
1089
limit: {
1059
-
type: 'integer',
1060
-
description: 'The maximum number of sandboxes to return.',
1090
+
type: "integer",
1091
+
description: "The maximum number of sandboxes to return.",
1061
1092
minimum: 1,
1062
1093
},
1063
1094
offset: {
1064
-
type: 'integer',
1095
+
type: "integer",
1065
1096
description:
1066
-
'The number of sandboxes to skip before starting to collect the result set.',
1097
+
"The number of sandboxes to skip before starting to collect the result set.",
1067
1098
minimum: 0,
1068
1099
},
1069
1100
},
1070
1101
},
1071
1102
output: {
1072
-
encoding: 'application/json',
1103
+
encoding: "application/json",
1073
1104
schema: {
1074
-
type: 'object',
1105
+
type: "object",
1075
1106
properties: {
1076
1107
sandboxes: {
1077
-
type: 'array',
1108
+
type: "array",
1078
1109
items: {
1079
-
type: 'ref',
1080
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1110
+
type: "ref",
1111
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1081
1112
},
1082
1113
},
1083
1114
total: {
1084
-
type: 'integer',
1085
-
description: 'The total number of sandboxes available.',
1115
+
type: "integer",
1116
+
description: "The total number of sandboxes available.",
1086
1117
minimum: 0,
1087
1118
},
1088
1119
},
···
1093
1124
},
1094
1125
IoPocketenvSandboxGetSshKeys: {
1095
1126
lexicon: 1,
1096
-
id: 'io.pocketenv.sandbox.getSshKeys',
1127
+
id: "io.pocketenv.sandbox.getSshKeys",
1097
1128
defs: {
1098
1129
main: {
1099
-
type: 'query',
1100
-
description: 'Get the SSH keys for a sandbox.',
1130
+
type: "query",
1131
+
description: "Get the SSH keys for a sandbox.",
1101
1132
parameters: {
1102
-
type: 'params',
1103
-
required: ['id'],
1133
+
type: "params",
1134
+
required: ["id"],
1104
1135
properties: {
1105
1136
id: {
1106
-
type: 'string',
1107
-
description: 'The sandbox ID.',
1137
+
type: "string",
1138
+
description: "The sandbox ID.",
1108
1139
},
1109
1140
},
1110
1141
},
1111
1142
output: {
1112
-
encoding: 'application/json',
1143
+
encoding: "application/json",
1113
1144
schema: {
1114
-
type: 'ref',
1115
-
ref: 'lex:io.pocketenv.sandbox.defs#sshKeysView',
1145
+
type: "ref",
1146
+
ref: "lex:io.pocketenv.sandbox.defs#sshKeysView",
1116
1147
},
1117
1148
},
1118
1149
},
···
1120
1151
},
1121
1152
IoPocketenvSandboxGetTailscaleAuthKey: {
1122
1153
lexicon: 1,
1123
-
id: 'io.pocketenv.sandbox.getTailscaleAuthKey',
1154
+
id: "io.pocketenv.sandbox.getTailscaleAuthKey",
1124
1155
defs: {
1125
1156
main: {
1126
-
type: 'query',
1127
-
description: 'Get the Tailscale token for a sandbox.',
1157
+
type: "query",
1158
+
description: "Get the Tailscale token for a sandbox.",
1128
1159
parameters: {
1129
-
type: 'params',
1130
-
required: ['id'],
1160
+
type: "params",
1161
+
required: ["id"],
1131
1162
properties: {
1132
1163
id: {
1133
-
type: 'string',
1134
-
description: 'The sandbox ID.',
1164
+
type: "string",
1165
+
description: "The sandbox ID.",
1135
1166
},
1136
1167
},
1137
1168
},
1138
1169
output: {
1139
-
encoding: 'application/json',
1170
+
encoding: "application/json",
1140
1171
schema: {
1141
-
type: 'ref',
1142
-
ref: 'lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView',
1172
+
type: "ref",
1173
+
ref: "lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView",
1143
1174
},
1144
1175
},
1145
1176
},
···
1147
1178
},
1148
1179
IoPocketenvSandboxGetTailscaleToken: {
1149
1180
lexicon: 1,
1150
-
id: 'io.pocketenv.sandbox.getTailscaleToken',
1181
+
id: "io.pocketenv.sandbox.getTailscaleToken",
1151
1182
defs: {
1152
1183
main: {
1153
-
type: 'query',
1154
-
description: 'Get the Tailscale token for a sandbox.',
1184
+
type: "query",
1185
+
description: "Get the Tailscale token for a sandbox.",
1155
1186
parameters: {
1156
-
type: 'params',
1157
-
required: ['id'],
1187
+
type: "params",
1188
+
required: ["id"],
1158
1189
properties: {
1159
1190
id: {
1160
-
type: 'string',
1161
-
description: 'The sandbox ID.',
1191
+
type: "string",
1192
+
description: "The sandbox ID.",
1162
1193
},
1163
1194
},
1164
1195
},
1165
1196
output: {
1166
-
encoding: 'application/json',
1197
+
encoding: "application/json",
1167
1198
schema: {
1168
-
type: 'ref',
1169
-
ref: 'lex:io.pocketenv.sandbox.defs#tailscaleTokenView',
1199
+
type: "ref",
1200
+
ref: "lex:io.pocketenv.sandbox.defs#tailscaleTokenView",
1170
1201
},
1171
1202
},
1172
1203
},
···
1174
1205
},
1175
1206
IoPocketenvSandboxPutPreferences: {
1176
1207
lexicon: 1,
1177
-
id: 'io.pocketenv.sandbox.putPreferences',
1208
+
id: "io.pocketenv.sandbox.putPreferences",
1178
1209
defs: {
1179
1210
main: {
1180
-
type: 'procedure',
1181
-
description: 'Update sandbox preferences.',
1211
+
type: "procedure",
1212
+
description: "Update sandbox preferences.",
1182
1213
input: {
1183
-
encoding: 'application/json',
1214
+
encoding: "application/json",
1184
1215
schema: {
1185
-
type: 'object',
1186
-
required: ['sandboxId', 'preferences'],
1216
+
type: "object",
1217
+
required: ["sandboxId", "preferences"],
1187
1218
properties: {
1188
1219
sandboxId: {
1189
-
type: 'string',
1190
-
description: 'The sandbox ID or URI',
1220
+
type: "string",
1221
+
description: "The sandbox ID or URI",
1191
1222
},
1192
1223
preferences: {
1193
-
type: 'ref',
1194
-
ref: 'lex:io.pocketenv.sandbox.defs#preferences',
1224
+
type: "ref",
1225
+
ref: "lex:io.pocketenv.sandbox.defs#preferences",
1195
1226
},
1196
1227
},
1197
1228
},
···
1201
1232
},
1202
1233
IoPocketenvSandboxPutSshKeys: {
1203
1234
lexicon: 1,
1204
-
id: 'io.pocketenv.sandbox.putSshKeys',
1235
+
id: "io.pocketenv.sandbox.putSshKeys",
1205
1236
defs: {
1206
1237
main: {
1207
-
type: 'procedure',
1208
-
description: 'Add or update SSH keys for a sandbox.',
1238
+
type: "procedure",
1239
+
description: "Add or update SSH keys for a sandbox.",
1209
1240
input: {
1210
-
encoding: 'application/json',
1241
+
encoding: "application/json",
1211
1242
schema: {
1212
-
type: 'object',
1213
-
required: ['id', 'privateKey', 'publicKey'],
1243
+
type: "object",
1244
+
required: ["id", "privateKey", "publicKey"],
1214
1245
properties: {
1215
1246
id: {
1216
-
type: 'string',
1217
-
description: 'The sandbox ID.',
1247
+
type: "string",
1248
+
description: "The sandbox ID.",
1218
1249
},
1219
1250
privateKey: {
1220
-
type: 'string',
1221
-
description: 'The private SSH key (encrypted)',
1251
+
type: "string",
1252
+
description: "The private SSH key (encrypted)",
1222
1253
},
1223
1254
publicKey: {
1224
-
type: 'string',
1225
-
description: 'The public SSH key.',
1255
+
type: "string",
1256
+
description: "The public SSH key.",
1226
1257
},
1227
1258
redacted: {
1228
-
type: 'string',
1229
-
description: 'The redacted SSH key.',
1259
+
type: "string",
1260
+
description: "The redacted SSH key.",
1230
1261
},
1231
1262
},
1232
1263
},
1233
1264
},
1234
1265
output: {
1235
-
encoding: 'application/json',
1266
+
encoding: "application/json",
1236
1267
schema: {
1237
-
type: 'ref',
1238
-
ref: 'lex:io.pocketenv.sandbox.defs#sshKeysView',
1268
+
type: "ref",
1269
+
ref: "lex:io.pocketenv.sandbox.defs#sshKeysView",
1239
1270
},
1240
1271
},
1241
1272
},
···
1243
1274
},
1244
1275
IoPocketenvSandboxPutTailscaleAuthKey: {
1245
1276
lexicon: 1,
1246
-
id: 'io.pocketenv.sandbox.putTailscaleAuthKey',
1277
+
id: "io.pocketenv.sandbox.putTailscaleAuthKey",
1247
1278
defs: {
1248
1279
main: {
1249
-
type: 'procedure',
1280
+
type: "procedure",
1250
1281
description:
1251
1282
"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.",
1252
1283
input: {
1253
-
encoding: 'application/json',
1284
+
encoding: "application/json",
1254
1285
schema: {
1255
-
type: 'object',
1256
-
required: ['id', 'authKey'],
1286
+
type: "object",
1287
+
required: ["id", "authKey"],
1257
1288
properties: {
1258
1289
id: {
1259
-
type: 'string',
1260
-
description: 'The sandbox ID.',
1290
+
type: "string",
1291
+
description: "The sandbox ID.",
1261
1292
},
1262
1293
authKey: {
1263
-
type: 'string',
1294
+
type: "string",
1264
1295
description:
1265
-
'The Tailscale Auth Key (encrypted) to store for the sandbox.',
1296
+
"The Tailscale Auth Key (encrypted) to store for the sandbox.",
1266
1297
},
1267
1298
redacted: {
1268
-
type: 'string',
1269
-
description: 'The redacted SSH key.',
1299
+
type: "string",
1300
+
description: "The redacted SSH key.",
1270
1301
},
1271
1302
},
1272
1303
},
1273
1304
},
1274
1305
output: {
1275
-
encoding: 'application/json',
1306
+
encoding: "application/json",
1276
1307
schema: {
1277
-
type: 'ref',
1278
-
ref: 'lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView',
1308
+
type: "ref",
1309
+
ref: "lex:io.pocketenv.sandbox.defs#tailscaleAuthKeyView",
1279
1310
},
1280
1311
},
1281
1312
},
···
1283
1314
},
1284
1315
IoPocketenvSandboxPutTailscaleToken: {
1285
1316
lexicon: 1,
1286
-
id: 'io.pocketenv.sandbox.putTailscaleToken',
1317
+
id: "io.pocketenv.sandbox.putTailscaleToken",
1287
1318
defs: {
1288
1319
main: {
1289
-
type: 'procedure',
1320
+
type: "procedure",
1290
1321
description:
1291
1322
"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.",
1292
1323
input: {
1293
-
encoding: 'application/json',
1324
+
encoding: "application/json",
1294
1325
schema: {
1295
-
type: 'object',
1296
-
required: ['id', 'token'],
1326
+
type: "object",
1327
+
required: ["id", "token"],
1297
1328
properties: {
1298
1329
id: {
1299
-
type: 'string',
1300
-
description: 'The sandbox ID.',
1330
+
type: "string",
1331
+
description: "The sandbox ID.",
1301
1332
},
1302
1333
token: {
1303
-
type: 'string',
1334
+
type: "string",
1304
1335
description:
1305
-
'The Tailscale token (encrypted) to store for the sandbox.',
1336
+
"The Tailscale token (encrypted) to store for the sandbox.",
1306
1337
},
1307
1338
},
1308
1339
},
1309
1340
},
1310
1341
output: {
1311
-
encoding: 'application/json',
1342
+
encoding: "application/json",
1312
1343
schema: {
1313
-
type: 'ref',
1314
-
ref: 'lex:io.pocketenv.sandbox.defs#tailscaleTokenView',
1344
+
type: "ref",
1345
+
ref: "lex:io.pocketenv.sandbox.defs#tailscaleTokenView",
1315
1346
},
1316
1347
},
1317
1348
},
···
1319
1350
},
1320
1351
IoPocketenvSandbox: {
1321
1352
lexicon: 1,
1322
-
id: 'io.pocketenv.sandbox',
1353
+
id: "io.pocketenv.sandbox",
1323
1354
defs: {
1324
1355
main: {
1325
-
type: 'record',
1326
-
key: 'tid',
1356
+
type: "record",
1357
+
key: "tid",
1327
1358
record: {
1328
-
type: 'object',
1329
-
required: ['name', 'createdAt'],
1359
+
type: "object",
1360
+
required: ["name", "createdAt"],
1330
1361
properties: {
1331
1362
name: {
1332
-
type: 'string',
1333
-
description: 'Name of the sandbox',
1363
+
type: "string",
1364
+
description: "Name of the sandbox",
1334
1365
maxLength: 255,
1335
1366
},
1336
1367
base: {
1337
-
type: 'ref',
1368
+
type: "ref",
1338
1369
description:
1339
-
'A strong reference to the base template for the sandbox environment.',
1340
-
ref: 'lex:com.atproto.repo.strongRef',
1370
+
"A strong reference to the base template for the sandbox environment.",
1371
+
ref: "lex:com.atproto.repo.strongRef",
1341
1372
},
1342
1373
provider: {
1343
-
type: 'string',
1374
+
type: "string",
1344
1375
description:
1345
1376
"The provider of the sandbox, e.g. 'daytona', 'vercel', 'cloudflare', etc.",
1346
1377
maxLength: 50,
1347
1378
},
1348
1379
description: {
1349
-
type: 'string',
1380
+
type: "string",
1350
1381
maxGraphemes: 300,
1351
1382
maxLength: 3000,
1352
1383
},
1353
1384
website: {
1354
-
type: 'string',
1355
-
description: 'Any URI related to the sandbox',
1356
-
format: 'uri',
1385
+
type: "string",
1386
+
description: "Any URI related to the sandbox",
1387
+
format: "uri",
1357
1388
},
1358
1389
logo: {
1359
-
type: 'string',
1360
-
description: 'URI to an image logo for the sandbox',
1361
-
format: 'uri',
1390
+
type: "string",
1391
+
description: "URI to an image logo for the sandbox",
1392
+
format: "uri",
1362
1393
},
1363
1394
topics: {
1364
-
type: 'array',
1395
+
type: "array",
1365
1396
items: {
1366
-
type: 'string',
1397
+
type: "string",
1367
1398
minLength: 1,
1368
1399
maxLength: 50,
1369
1400
},
1370
1401
maxLength: 50,
1371
1402
},
1372
1403
repo: {
1373
-
type: 'string',
1404
+
type: "string",
1374
1405
description:
1375
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
1376
-
format: 'uri',
1406
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
1407
+
format: "uri",
1377
1408
},
1378
1409
readme: {
1379
-
type: 'string',
1380
-
description: 'A URI to a README for the sandbox.',
1381
-
format: 'uri',
1410
+
type: "string",
1411
+
description: "A URI to a README for the sandbox.",
1412
+
format: "uri",
1382
1413
},
1383
1414
vcpus: {
1384
-
type: 'integer',
1385
-
description: 'Number of virtual CPUs allocated to the sandbox',
1415
+
type: "integer",
1416
+
description: "Number of virtual CPUs allocated to the sandbox",
1386
1417
},
1387
1418
memory: {
1388
-
type: 'integer',
1389
-
description: 'Amount of memory in GB allocated to the sandbox',
1419
+
type: "integer",
1420
+
description: "Amount of memory in GB allocated to the sandbox",
1390
1421
},
1391
1422
disk: {
1392
-
type: 'integer',
1423
+
type: "integer",
1393
1424
description:
1394
-
'Amount of disk space in GB allocated to the sandbox',
1425
+
"Amount of disk space in GB allocated to the sandbox",
1395
1426
},
1396
1427
volumes: {
1397
-
type: 'array',
1428
+
type: "array",
1398
1429
items: {
1399
-
type: 'string',
1430
+
type: "string",
1400
1431
description:
1401
1432
"A path to be mounted as a volume in the sandbox, e.g. '/data', '/logs', etc.",
1402
1433
},
1403
1434
},
1404
1435
ports: {
1405
-
type: 'array',
1436
+
type: "array",
1406
1437
items: {
1407
-
type: 'integer',
1438
+
type: "integer",
1408
1439
description:
1409
-
'A port number that is exposed by the sandbox environment.',
1440
+
"A port number that is exposed by the sandbox environment.",
1410
1441
},
1411
1442
},
1412
1443
secrets: {
1413
-
type: 'array',
1444
+
type: "array",
1414
1445
items: {
1415
-
type: 'string',
1446
+
type: "string",
1416
1447
description:
1417
-
'Name of a secret to be added to the sandbox environment. Secrets are typically encrypted and stored securely, and can be used to store sensitive information such as API keys, database credentials, etc.',
1448
+
"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.",
1418
1449
},
1419
1450
},
1420
1451
envs: {
1421
-
type: 'array',
1452
+
type: "array",
1422
1453
items: {
1423
-
type: 'string',
1454
+
type: "string",
1424
1455
description:
1425
-
'Name of an environment variable to be added to the sandbox environment.',
1456
+
"Name of an environment variable to be added to the sandbox environment.",
1426
1457
},
1427
1458
},
1428
1459
createdAt: {
1429
-
type: 'string',
1430
-
format: 'datetime',
1460
+
type: "string",
1461
+
format: "datetime",
1431
1462
},
1432
1463
},
1433
1464
},
···
1436
1467
},
1437
1468
IoPocketenvSandboxStartSandbox: {
1438
1469
lexicon: 1,
1439
-
id: 'io.pocketenv.sandbox.startSandbox',
1470
+
id: "io.pocketenv.sandbox.startSandbox",
1440
1471
defs: {
1441
1472
main: {
1442
-
type: 'procedure',
1443
-
description: 'Start a sandbox',
1473
+
type: "procedure",
1474
+
description: "Start a sandbox",
1444
1475
parameters: {
1445
-
type: 'params',
1446
-
required: ['id'],
1476
+
type: "params",
1477
+
required: ["id"],
1447
1478
properties: {
1448
1479
id: {
1449
-
type: 'string',
1450
-
description: 'The sandbox ID.',
1480
+
type: "string",
1481
+
description: "The sandbox ID.",
1451
1482
},
1452
1483
},
1453
1484
},
1454
1485
output: {
1455
-
encoding: 'application/json',
1486
+
encoding: "application/json",
1456
1487
schema: {
1457
-
type: 'ref',
1458
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1488
+
type: "ref",
1489
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1459
1490
},
1460
1491
},
1461
1492
},
···
1463
1494
},
1464
1495
IoPocketenvSandboxStopSandbox: {
1465
1496
lexicon: 1,
1466
-
id: 'io.pocketenv.sandbox.stopSandbox',
1497
+
id: "io.pocketenv.sandbox.stopSandbox",
1467
1498
defs: {
1468
1499
main: {
1469
-
type: 'procedure',
1470
-
description: 'Stop a sandbox',
1500
+
type: "procedure",
1501
+
description: "Stop a sandbox",
1471
1502
parameters: {
1472
-
type: 'params',
1473
-
required: ['id'],
1503
+
type: "params",
1504
+
required: ["id"],
1474
1505
properties: {
1475
1506
id: {
1476
-
type: 'string',
1477
-
description: 'The sandbox ID.',
1507
+
type: "string",
1508
+
description: "The sandbox ID.",
1478
1509
},
1479
1510
},
1480
1511
},
1481
1512
output: {
1482
-
encoding: 'application/json',
1513
+
encoding: "application/json",
1483
1514
schema: {
1484
-
type: 'ref',
1485
-
ref: 'lex:io.pocketenv.sandbox.defs#sandboxViewBasic',
1515
+
type: "ref",
1516
+
ref: "lex:io.pocketenv.sandbox.defs#sandboxViewBasic",
1486
1517
},
1487
1518
},
1488
1519
},
···
1490
1521
},
1491
1522
IoPocketenvSandboxUpdateSandboxSettings: {
1492
1523
lexicon: 1,
1493
-
id: 'io.pocketenv.sandbox.updateSandboxSettings',
1524
+
id: "io.pocketenv.sandbox.updateSandboxSettings",
1494
1525
defs: {
1495
1526
main: {
1496
-
type: 'procedure',
1497
-
description: 'Update sandbox settings',
1527
+
type: "procedure",
1528
+
description: "Update sandbox settings",
1498
1529
input: {
1499
-
encoding: 'application/json',
1530
+
encoding: "application/json",
1500
1531
schema: {
1501
-
type: 'object',
1532
+
type: "object",
1502
1533
properties: {
1503
1534
name: {
1504
-
type: 'string',
1505
-
description: 'The name of the sandbox',
1535
+
type: "string",
1536
+
description: "The name of the sandbox",
1506
1537
minLength: 1,
1507
1538
},
1508
1539
description: {
1509
-
type: 'string',
1510
-
description: 'A description for the sandbox',
1540
+
type: "string",
1541
+
description: "A description for the sandbox",
1511
1542
},
1512
1543
topics: {
1513
-
type: 'array',
1544
+
type: "array",
1514
1545
description:
1515
-
'A list of topics/tags to associate with the sandbox',
1546
+
"A list of topics/tags to associate with the sandbox",
1516
1547
items: {
1517
-
type: 'string',
1548
+
type: "string",
1518
1549
maxLength: 50,
1519
1550
},
1520
1551
},
1521
1552
repo: {
1522
-
type: 'string',
1553
+
type: "string",
1523
1554
description:
1524
-
'A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.',
1525
-
format: 'uri',
1555
+
"A git repository URL to clone into the sandbox, e.g. a GitHub/Tangled repo.",
1556
+
format: "uri",
1526
1557
},
1527
1558
vcpus: {
1528
-
type: 'integer',
1559
+
type: "integer",
1529
1560
description:
1530
-
'The number of virtual CPUs to allocate for the sandbox',
1561
+
"The number of virtual CPUs to allocate for the sandbox",
1531
1562
minimum: 1,
1532
1563
},
1533
1564
memory: {
1534
-
type: 'integer',
1565
+
type: "integer",
1535
1566
description:
1536
-
'The amount of memory (in GB) to allocate for the sandbox',
1567
+
"The amount of memory (in GB) to allocate for the sandbox",
1537
1568
minimum: 1,
1538
1569
},
1539
1570
disk: {
1540
-
type: 'integer',
1571
+
type: "integer",
1541
1572
description:
1542
-
'The amount of disk space (in GB) to allocate for the sandbox',
1573
+
"The amount of disk space (in GB) to allocate for the sandbox",
1543
1574
minimum: 3,
1544
1575
},
1545
1576
readme: {
1546
-
type: 'string',
1547
-
description: 'A URI to a README for the sandbox.',
1548
-
format: 'uri',
1577
+
type: "string",
1578
+
description: "A URI to a README for the sandbox.",
1579
+
format: "uri",
1549
1580
},
1550
1581
secrets: {
1551
-
type: 'ref',
1552
-
description: 'A list of secrets to add to the sandbox',
1553
-
ref: 'lex:io.pocketenv.secret.defs#secrets',
1582
+
type: "ref",
1583
+
description: "A list of secrets to add to the sandbox",
1584
+
ref: "lex:io.pocketenv.secret.defs#secrets",
1554
1585
},
1555
1586
variables: {
1556
-
type: 'ref',
1587
+
type: "ref",
1557
1588
description:
1558
-
'A list of environment variables to add to the sandbox',
1559
-
ref: 'lex:io.pocketenv.variable.defs#variables',
1589
+
"A list of environment variables to add to the sandbox",
1590
+
ref: "lex:io.pocketenv.variable.defs#variables",
1560
1591
},
1561
1592
files: {
1562
-
type: 'ref',
1563
-
description: 'A list of files to add to the sandbox',
1564
-
ref: 'lex:io.pocketenv.file.defs#file',
1593
+
type: "ref",
1594
+
description: "A list of files to add to the sandbox",
1595
+
ref: "lex:io.pocketenv.file.defs#file",
1565
1596
},
1566
1597
volumes: {
1567
-
type: 'ref',
1568
-
description: 'A list of volumes to add to the sandbox',
1569
-
ref: 'lex:io.pocketenv.volume.defs#volumes',
1598
+
type: "ref",
1599
+
description: "A list of volumes to add to the sandbox",
1600
+
ref: "lex:io.pocketenv.volume.defs#volumes",
1570
1601
},
1571
1602
},
1572
1603
},
1573
1604
},
1574
1605
output: {
1575
-
encoding: 'application/json',
1606
+
encoding: "application/json",
1576
1607
schema: {
1577
-
type: 'ref',
1578
-
ref: 'lex:io.pocketenv.sandbox.defs#profileViewDetailed',
1608
+
type: "ref",
1609
+
ref: "lex:io.pocketenv.sandbox.defs#profileViewDetailed",
1579
1610
},
1580
1611
},
1581
1612
},
···
1583
1614
},
1584
1615
IoPocketenvSecretAddSecret: {
1585
1616
lexicon: 1,
1586
-
id: 'io.pocketenv.secret.addSecret',
1617
+
id: "io.pocketenv.secret.addSecret",
1587
1618
defs: {
1588
1619
main: {
1589
-
type: 'procedure',
1620
+
type: "procedure",
1590
1621
input: {
1591
-
encoding: 'application/json',
1622
+
encoding: "application/json",
1592
1623
schema: {
1593
-
type: 'object',
1594
-
required: ['secret'],
1624
+
type: "object",
1625
+
required: ["secret"],
1595
1626
properties: {
1596
1627
secret: {
1597
-
type: 'ref',
1598
-
ref: 'lex:io.pocketenv.secret.defs#secret',
1628
+
type: "ref",
1629
+
ref: "lex:io.pocketenv.secret.defs#secret",
1599
1630
},
1600
1631
redacted: {
1601
-
type: 'string',
1602
-
description: 'The redacted secret value.',
1632
+
type: "string",
1633
+
description: "The redacted secret value.",
1603
1634
},
1604
1635
},
1605
1636
},
···
1609
1640
},
1610
1641
IoPocketenvSecretDefs: {
1611
1642
lexicon: 1,
1612
-
id: 'io.pocketenv.secret.defs',
1643
+
id: "io.pocketenv.secret.defs",
1613
1644
defs: {
1614
1645
secretView: {
1615
-
type: 'object',
1646
+
type: "object",
1616
1647
properties: {
1617
1648
id: {
1618
-
type: 'string',
1619
-
description: 'Unique identifier of the secret.',
1649
+
type: "string",
1650
+
description: "Unique identifier of the secret.",
1620
1651
},
1621
1652
name: {
1622
-
type: 'string',
1653
+
type: "string",
1623
1654
description:
1624
1655
"Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc.",
1625
1656
},
1626
1657
},
1627
1658
},
1628
1659
secret: {
1629
-
type: 'object',
1630
-
required: ['name', 'value'],
1660
+
type: "object",
1661
+
required: ["name", "value"],
1631
1662
properties: {
1632
1663
sandboxId: {
1633
-
type: 'string',
1664
+
type: "string",
1634
1665
description:
1635
-
'The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment.',
1666
+
"The ID of the sandbox to which the secret belongs. This is used to associate the secret with a specific sandbox environment.",
1636
1667
},
1637
1668
name: {
1638
-
type: 'string',
1669
+
type: "string",
1639
1670
description:
1640
1671
"Name of the secret, e.g. 'DATABASE_URL', 'SSH_KEY', etc.",
1641
1672
},
1642
1673
value: {
1643
-
type: 'string',
1674
+
type: "string",
1644
1675
description:
1645
-
'Value of the secret. This will be encrypted at rest and redacted in any API responses.',
1676
+
"Value of the secret. This will be encrypted at rest and redacted in any API responses.",
1646
1677
},
1647
1678
},
1648
1679
},
1649
1680
secrets: {
1650
-
type: 'array',
1681
+
type: "array",
1651
1682
items: {
1652
-
type: 'ref',
1653
-
description: 'A secret to add to the sandbox',
1654
-
ref: 'lex:io.pocketenv.secret.defs#secret',
1683
+
type: "ref",
1684
+
description: "A secret to add to the sandbox",
1685
+
ref: "lex:io.pocketenv.secret.defs#secret",
1655
1686
},
1656
1687
},
1657
1688
},
1658
1689
},
1659
1690
IoPocketenvSecretDeleteSecret: {
1660
1691
lexicon: 1,
1661
-
id: 'io.pocketenv.secret.deleteSecret',
1692
+
id: "io.pocketenv.secret.deleteSecret",
1662
1693
defs: {
1663
1694
main: {
1664
-
type: 'procedure',
1695
+
type: "procedure",
1665
1696
parameters: {
1666
-
type: 'params',
1667
-
required: ['id'],
1697
+
type: "params",
1698
+
required: ["id"],
1668
1699
properties: {
1669
1700
id: {
1670
-
type: 'string',
1671
-
description: 'The ID of the secret to delete',
1701
+
type: "string",
1702
+
description: "The ID of the secret to delete",
1703
+
},
1704
+
},
1705
+
},
1706
+
},
1707
+
},
1708
+
},
1709
+
IoPocketenvSecretGetSecret: {
1710
+
lexicon: 1,
1711
+
id: "io.pocketenv.secret.getSecret",
1712
+
defs: {
1713
+
main: {
1714
+
type: "query",
1715
+
parameters: {
1716
+
type: "params",
1717
+
required: ["id"],
1718
+
properties: {
1719
+
id: {
1720
+
type: "string",
1721
+
description:
1722
+
"The ID of the secret for which to retrieve secrets.",
1723
+
},
1724
+
},
1725
+
},
1726
+
output: {
1727
+
encoding: "application/json",
1728
+
schema: {
1729
+
type: "object",
1730
+
properties: {
1731
+
secret: {
1732
+
type: "ref",
1733
+
ref: "lex:io.pocketenv.secret.defs#secretView",
1734
+
},
1672
1735
},
1673
1736
},
1674
1737
},
···
1677
1740
},
1678
1741
IoPocketenvSecretGetSecrets: {
1679
1742
lexicon: 1,
1680
-
id: 'io.pocketenv.secret.getSecrets',
1743
+
id: "io.pocketenv.secret.getSecrets",
1681
1744
defs: {
1682
1745
main: {
1683
-
type: 'query',
1746
+
type: "query",
1684
1747
parameters: {
1685
-
type: 'params',
1748
+
type: "params",
1686
1749
properties: {
1687
1750
sandboxId: {
1688
-
type: 'string',
1751
+
type: "string",
1689
1752
description:
1690
-
'The ID of the sandbox for which to retrieve secrets.',
1753
+
"The ID of the sandbox for which to retrieve secrets.",
1691
1754
},
1692
1755
limit: {
1693
-
type: 'integer',
1694
-
description: 'The maximum number of secrets to return.',
1756
+
type: "integer",
1757
+
description: "The maximum number of secrets to return.",
1695
1758
minimum: 1,
1696
1759
},
1697
1760
offset: {
1698
-
type: 'integer',
1761
+
type: "integer",
1699
1762
description:
1700
-
'The number of secrets to skip before starting to collect the result set.',
1763
+
"The number of secrets to skip before starting to collect the result set.",
1701
1764
minimum: 0,
1702
1765
},
1703
1766
},
1704
1767
},
1705
1768
output: {
1706
-
encoding: 'application/json',
1769
+
encoding: "application/json",
1707
1770
schema: {
1708
-
type: 'object',
1771
+
type: "object",
1709
1772
properties: {
1710
1773
secrets: {
1711
-
type: 'array',
1774
+
type: "array",
1712
1775
items: {
1713
-
type: 'ref',
1714
-
ref: 'lex:io.pocketenv.secret.defs#secretView',
1776
+
type: "ref",
1777
+
ref: "lex:io.pocketenv.secret.defs#secretView",
1715
1778
},
1716
1779
},
1717
1780
total: {
1718
-
type: 'integer',
1719
-
description: 'The total number of secrets available.',
1781
+
type: "integer",
1782
+
description: "The total number of secrets available.",
1720
1783
minimum: 0,
1721
1784
},
1722
1785
},
···
1727
1790
},
1728
1791
IoPocketenvVariableAddVariable: {
1729
1792
lexicon: 1,
1730
-
id: 'io.pocketenv.variable.addVariable',
1793
+
id: "io.pocketenv.variable.addVariable",
1731
1794
defs: {
1732
1795
main: {
1733
-
type: 'procedure',
1796
+
type: "procedure",
1734
1797
input: {
1735
-
encoding: 'application/json',
1798
+
encoding: "application/json",
1736
1799
schema: {
1737
-
type: 'object',
1738
-
required: ['variable'],
1800
+
type: "object",
1801
+
required: ["variable"],
1739
1802
properties: {
1740
1803
variable: {
1741
-
type: 'ref',
1742
-
ref: 'lex:io.pocketenv.variable.defs#variable',
1804
+
type: "ref",
1805
+
ref: "lex:io.pocketenv.variable.defs#variable",
1743
1806
},
1744
1807
},
1745
1808
},
···
1749
1812
},
1750
1813
IoPocketenvVariableDefs: {
1751
1814
lexicon: 1,
1752
-
id: 'io.pocketenv.variable.defs',
1815
+
id: "io.pocketenv.variable.defs",
1753
1816
defs: {
1754
1817
variableView: {
1755
-
type: 'object',
1818
+
type: "object",
1756
1819
properties: {
1757
1820
id: {
1758
-
type: 'string',
1759
-
description: 'Unique identifier of the environment variable.',
1821
+
type: "string",
1822
+
description: "Unique identifier of the environment variable.",
1760
1823
},
1761
1824
name: {
1762
-
type: 'string',
1825
+
type: "string",
1763
1826
description:
1764
1827
"Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc.",
1765
1828
},
1766
1829
value: {
1767
-
type: 'string',
1830
+
type: "string",
1768
1831
description:
1769
-
'Value of the environment variable. This will be visible in API responses and should not contain sensitive information.',
1832
+
"Value of the environment variable. This will be visible in API responses and should not contain sensitive information.",
1770
1833
},
1771
1834
},
1772
1835
},
1773
1836
variable: {
1774
-
type: 'object',
1775
-
required: ['name', 'value'],
1837
+
type: "object",
1838
+
required: ["name", "value"],
1776
1839
properties: {
1777
1840
sandboxId: {
1778
-
type: 'string',
1841
+
type: "string",
1779
1842
description:
1780
-
'The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment.',
1843
+
"The ID of the sandbox to which the environment variable belongs. This is used to associate the variable with a specific sandbox environment.",
1781
1844
},
1782
1845
name: {
1783
-
type: 'string',
1846
+
type: "string",
1784
1847
description:
1785
1848
"Name of the environment variable, e.g. 'NODE_ENV', 'PORT', etc.",
1786
1849
},
1787
1850
value: {
1788
-
type: 'string',
1851
+
type: "string",
1789
1852
description:
1790
-
'Value of the environment variable. This will be visible in API responses and should not contain sensitive information.',
1853
+
"Value of the environment variable. This will be visible in API responses and should not contain sensitive information.",
1791
1854
},
1792
1855
},
1793
1856
},
1794
1857
variables: {
1795
-
type: 'array',
1858
+
type: "array",
1796
1859
items: {
1797
-
type: 'ref',
1798
-
description: 'An environment variable to add to the sandbox',
1799
-
ref: 'lex:io.pocketenv.variable.defs#envVar',
1860
+
type: "ref",
1861
+
description: "An environment variable to add to the sandbox",
1862
+
ref: "lex:io.pocketenv.variable.defs#envVar",
1800
1863
},
1801
1864
},
1802
1865
},
1803
1866
},
1804
1867
IoPocketenvVariableDeleteVariable: {
1805
1868
lexicon: 1,
1806
-
id: 'io.pocketenv.variable.deleteVariable',
1869
+
id: "io.pocketenv.variable.deleteVariable",
1807
1870
defs: {
1808
1871
main: {
1809
-
type: 'procedure',
1872
+
type: "procedure",
1810
1873
parameters: {
1811
-
type: 'params',
1812
-
required: ['id'],
1874
+
type: "params",
1875
+
required: ["id"],
1813
1876
properties: {
1814
1877
id: {
1815
-
type: 'string',
1816
-
description: 'The ID of the environment variable to delete',
1878
+
type: "string",
1879
+
description: "The ID of the environment variable to delete",
1880
+
},
1881
+
},
1882
+
},
1883
+
},
1884
+
},
1885
+
},
1886
+
IoPocketenvVariableGetVariable: {
1887
+
lexicon: 1,
1888
+
id: "io.pocketenv.variable.getVariable",
1889
+
defs: {
1890
+
main: {
1891
+
type: "query",
1892
+
parameters: {
1893
+
type: "params",
1894
+
required: ["id"],
1895
+
properties: {
1896
+
id: {
1897
+
type: "string",
1898
+
description:
1899
+
"The ID of the variable for which to retrieve variables.",
1900
+
},
1901
+
},
1902
+
},
1903
+
output: {
1904
+
encoding: "application/json",
1905
+
schema: {
1906
+
type: "object",
1907
+
properties: {
1908
+
variable: {
1909
+
type: "ref",
1910
+
ref: "lex:io.pocketenv.variable.defs#variableView",
1911
+
},
1817
1912
},
1818
1913
},
1819
1914
},
···
1822
1917
},
1823
1918
IoPocketenvVariableGetVariables: {
1824
1919
lexicon: 1,
1825
-
id: 'io.pocketenv.variable.getVariables',
1920
+
id: "io.pocketenv.variable.getVariables",
1826
1921
defs: {
1827
1922
main: {
1828
-
type: 'query',
1923
+
type: "query",
1829
1924
parameters: {
1830
-
type: 'params',
1925
+
type: "params",
1831
1926
properties: {
1832
1927
sandboxId: {
1833
-
type: 'string',
1928
+
type: "string",
1834
1929
description:
1835
-
'The ID of the sandbox for which to retrieve variables.',
1930
+
"The ID of the sandbox for which to retrieve variables.",
1836
1931
},
1837
1932
limit: {
1838
-
type: 'integer',
1839
-
description: 'The maximum number of variables to return.',
1933
+
type: "integer",
1934
+
description: "The maximum number of variables to return.",
1840
1935
minimum: 1,
1841
1936
},
1842
1937
offset: {
1843
-
type: 'integer',
1938
+
type: "integer",
1844
1939
description:
1845
-
'The number of variables to skip before starting to collect the result set.',
1940
+
"The number of variables to skip before starting to collect the result set.",
1846
1941
minimum: 0,
1847
1942
},
1848
1943
},
1849
1944
},
1850
1945
output: {
1851
-
encoding: 'application/json',
1946
+
encoding: "application/json",
1852
1947
schema: {
1853
-
type: 'object',
1948
+
type: "object",
1854
1949
properties: {
1855
1950
variables: {
1856
-
type: 'array',
1951
+
type: "array",
1857
1952
items: {
1858
-
type: 'ref',
1859
-
ref: 'lex:io.pocketenv.variable.defs#variableView',
1953
+
type: "ref",
1954
+
ref: "lex:io.pocketenv.variable.defs#variableView",
1860
1955
},
1861
1956
},
1862
1957
total: {
1863
-
type: 'integer',
1864
-
description: 'The total number of variables available.',
1958
+
type: "integer",
1959
+
description: "The total number of variables available.",
1865
1960
minimum: 0,
1866
1961
},
1867
1962
},
···
1872
1967
},
1873
1968
IoPocketenvVolumeAddVolume: {
1874
1969
lexicon: 1,
1875
-
id: 'io.pocketenv.volume.addVolume',
1970
+
id: "io.pocketenv.volume.addVolume",
1876
1971
defs: {
1877
1972
main: {
1878
-
type: 'procedure',
1973
+
type: "procedure",
1879
1974
input: {
1880
-
encoding: 'application/json',
1975
+
encoding: "application/json",
1881
1976
schema: {
1882
-
type: 'object',
1883
-
required: ['volume'],
1977
+
type: "object",
1978
+
required: ["volume"],
1884
1979
properties: {
1885
1980
volume: {
1886
-
type: 'ref',
1887
-
ref: 'lex:io.pocketenv.volume.defs#volume',
1981
+
type: "ref",
1982
+
ref: "lex:io.pocketenv.volume.defs#volume",
1888
1983
},
1889
1984
},
1890
1985
},
···
1894
1989
},
1895
1990
IoPocketenvVolumeDefs: {
1896
1991
lexicon: 1,
1897
-
id: 'io.pocketenv.volume.defs',
1992
+
id: "io.pocketenv.volume.defs",
1898
1993
defs: {
1899
1994
volumeView: {
1900
-
type: 'object',
1995
+
type: "object",
1901
1996
properties: {
1902
1997
id: {
1903
-
type: 'string',
1904
-
description: 'Unique identifier of the volume.',
1998
+
type: "string",
1999
+
description: "Unique identifier of the volume.",
1905
2000
},
1906
2001
name: {
1907
-
type: 'string',
2002
+
type: "string",
1908
2003
description: "Name of the volume, e.g. 'data-volume', 'logs', etc.",
1909
2004
},
1910
2005
path: {
1911
-
type: 'string',
2006
+
type: "string",
1912
2007
description:
1913
2008
"The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc.",
1914
2009
},
1915
2010
readOnly: {
1916
-
type: 'boolean',
2011
+
type: "boolean",
1917
2012
description:
1918
-
'Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).',
2013
+
"Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).",
1919
2014
},
1920
2015
createdAt: {
1921
-
type: 'string',
1922
-
description: 'The timestamp when the volume was created.',
1923
-
format: 'datetime',
2016
+
type: "string",
2017
+
description: "The timestamp when the volume was created.",
2018
+
format: "datetime",
1924
2019
},
1925
2020
updatedAt: {
1926
-
type: 'string',
1927
-
description: 'The timestamp when the volume was last updated.',
1928
-
format: 'datetime',
2021
+
type: "string",
2022
+
description: "The timestamp when the volume was last updated.",
2023
+
format: "datetime",
1929
2024
},
1930
2025
},
1931
2026
},
1932
2027
volumes: {
1933
-
type: 'array',
2028
+
type: "array",
1934
2029
items: {
1935
-
type: 'ref',
1936
-
description: 'A volume to add to the sandbox',
1937
-
ref: 'lex:io.pocketenv.volume.defs#volume',
2030
+
type: "ref",
2031
+
description: "A volume to add to the sandbox",
2032
+
ref: "lex:io.pocketenv.volume.defs#volume",
1938
2033
},
1939
2034
},
1940
2035
volume: {
1941
-
type: 'object',
1942
-
required: ['name'],
2036
+
type: "object",
2037
+
required: ["name"],
1943
2038
properties: {
1944
2039
sandboxId: {
1945
-
type: 'string',
2040
+
type: "string",
1946
2041
description:
1947
-
'The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment.',
2042
+
"The ID of the sandbox to which the volume belongs. This is used to associate the volume with a specific sandbox environment.",
1948
2043
},
1949
2044
name: {
1950
-
type: 'string',
2045
+
type: "string",
1951
2046
description: "Name of the volume, e.g. 'data-volume', 'logs', etc.",
1952
2047
},
1953
2048
path: {
1954
-
type: 'string',
2049
+
type: "string",
1955
2050
description:
1956
2051
"The path within the sandbox where the volume will be mounted, e.g. '/data', '/logs', etc.",
1957
2052
},
1958
2053
readOnly: {
1959
-
type: 'boolean',
2054
+
type: "boolean",
1960
2055
description:
1961
-
'Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).',
2056
+
"Whether the volume should be mounted as read-only within the sandbox. Defaults to false (read-write).",
1962
2057
},
1963
2058
},
1964
2059
},
···
1966
2061
},
1967
2062
IoPocketenvVolumeDeleteVolume: {
1968
2063
lexicon: 1,
1969
-
id: 'io.pocketenv.volume.deleteVolume',
2064
+
id: "io.pocketenv.volume.deleteVolume",
2065
+
defs: {
2066
+
main: {
2067
+
type: "procedure",
2068
+
parameters: {
2069
+
type: "params",
2070
+
required: ["id"],
2071
+
properties: {
2072
+
id: {
2073
+
type: "string",
2074
+
description: "The ID of the volume to delete.",
2075
+
},
2076
+
},
2077
+
},
2078
+
},
2079
+
},
2080
+
},
2081
+
IoPocketenvVolumeGetVolume: {
2082
+
lexicon: 1,
2083
+
id: "io.pocketenv.volume.getVolume",
1970
2084
defs: {
1971
2085
main: {
1972
-
type: 'procedure',
2086
+
type: "query",
1973
2087
parameters: {
1974
-
type: 'params',
1975
-
required: ['id'],
2088
+
type: "params",
2089
+
required: ["id"],
1976
2090
properties: {
1977
2091
id: {
1978
-
type: 'string',
1979
-
description: 'The ID of the volume to delete.',
2092
+
type: "string",
2093
+
description:
2094
+
"The ID of the volume for which to retrieve volumes.",
2095
+
},
2096
+
},
2097
+
},
2098
+
output: {
2099
+
encoding: "application/json",
2100
+
schema: {
2101
+
type: "object",
2102
+
properties: {
2103
+
volume: {
2104
+
type: "ref",
2105
+
ref: "lex:io.pocketenv.volume.defs#volumeView",
2106
+
},
1980
2107
},
1981
2108
},
1982
2109
},
···
1985
2112
},
1986
2113
IoPocketenvVolumeGetVolumes: {
1987
2114
lexicon: 1,
1988
-
id: 'io.pocketenv.volume.getVolumes',
2115
+
id: "io.pocketenv.volume.getVolumes",
1989
2116
defs: {
1990
2117
main: {
1991
-
type: 'query',
2118
+
type: "query",
1992
2119
parameters: {
1993
-
type: 'params',
2120
+
type: "params",
1994
2121
properties: {
1995
2122
sandboxId: {
1996
-
type: 'string',
2123
+
type: "string",
1997
2124
description:
1998
-
'The ID of the sandbox for which to retrieve volumes.',
2125
+
"The ID of the sandbox for which to retrieve volumes.",
1999
2126
},
2000
2127
limit: {
2001
-
type: 'integer',
2002
-
description: 'The maximum number of volumes to return.',
2128
+
type: "integer",
2129
+
description: "The maximum number of volumes to return.",
2003
2130
minimum: 1,
2004
2131
},
2005
2132
offset: {
2006
-
type: 'integer',
2133
+
type: "integer",
2007
2134
description:
2008
-
'The number of volumes to skip before starting to collect the result set.',
2135
+
"The number of volumes to skip before starting to collect the result set.",
2009
2136
minimum: 0,
2010
2137
},
2011
2138
},
2012
2139
},
2013
2140
output: {
2014
-
encoding: 'application/json',
2141
+
encoding: "application/json",
2015
2142
schema: {
2016
-
type: 'object',
2143
+
type: "object",
2017
2144
properties: {
2018
2145
volumes: {
2019
-
type: 'array',
2146
+
type: "array",
2020
2147
items: {
2021
-
type: 'ref',
2022
-
ref: 'lex:io.pocketenv.volume.defs#volumeView',
2148
+
type: "ref",
2149
+
ref: "lex:io.pocketenv.volume.defs#volumeView",
2023
2150
},
2024
2151
},
2025
2152
total: {
2026
-
type: 'integer',
2027
-
description: 'The total number of volumes available.',
2153
+
type: "integer",
2154
+
description: "The total number of volumes available.",
2028
2155
minimum: 0,
2029
2156
},
2030
2157
},
···
2035
2162
},
2036
2163
IoPocketenvPublicKey: {
2037
2164
lexicon: 1,
2038
-
id: 'io.pocketenv.publicKey',
2165
+
id: "io.pocketenv.publicKey",
2039
2166
defs: {
2040
2167
main: {
2041
-
type: 'record',
2042
-
key: 'tid',
2168
+
type: "record",
2169
+
key: "tid",
2043
2170
record: {
2044
-
type: 'object',
2045
-
required: ['name', 'key', 'createdAt'],
2171
+
type: "object",
2172
+
required: ["name", "key", "createdAt"],
2046
2173
properties: {
2047
2174
name: {
2048
-
type: 'string',
2049
-
description: 'Name of the public key',
2175
+
type: "string",
2176
+
description: "Name of the public key",
2050
2177
maxLength: 255,
2051
2178
},
2052
2179
key: {
2053
-
type: 'string',
2180
+
type: "string",
2054
2181
description:
2055
-
'The public key value, e.g. an SSH public key string.',
2182
+
"The public key value, e.g. an SSH public key string.",
2056
2183
},
2057
2184
createdAt: {
2058
-
type: 'string',
2059
-
format: 'datetime',
2185
+
type: "string",
2186
+
format: "datetime",
2060
2187
},
2061
2188
},
2062
2189
},
···
2065
2192
},
2066
2193
ComAtprotoRepoStrongRef: {
2067
2194
lexicon: 1,
2068
-
id: 'com.atproto.repo.strongRef',
2069
-
description: 'A URI with a content-hash fingerprint.',
2195
+
id: "com.atproto.repo.strongRef",
2196
+
description: "A URI with a content-hash fingerprint.",
2070
2197
defs: {
2071
2198
main: {
2072
-
type: 'object',
2073
-
required: ['uri', 'cid'],
2199
+
type: "object",
2200
+
required: ["uri", "cid"],
2074
2201
properties: {
2075
2202
uri: {
2076
-
type: 'string',
2077
-
format: 'at-uri',
2203
+
type: "string",
2204
+
format: "at-uri",
2078
2205
},
2079
2206
cid: {
2080
-
type: 'string',
2081
-
format: 'cid',
2207
+
type: "string",
2208
+
format: "cid",
2082
2209
},
2083
2210
},
2084
2211
},
2085
2212
},
2086
2213
},
2087
-
} as const satisfies Record<string, LexiconDoc>
2214
+
} as const satisfies Record<string, LexiconDoc>;
2088
2215
2089
-
export const schemas = Object.values(schemaDict)
2090
-
export const lexicons: Lexicons = new Lexicons(schemas)
2216
+
export const schemas = Object.values(schemaDict);
2217
+
export const lexicons: Lexicons = new Lexicons(schemas);
2091
2218
export const ids = {
2092
-
IoPocketenvActorDefs: 'io.pocketenv.actor.defs',
2093
-
IoPocketenvActorGetActorSandboxes: 'io.pocketenv.actor.getActorSandboxes',
2094
-
IoPocketenvActorGetProfile: 'io.pocketenv.actor.getProfile',
2095
-
IoPocketenvActorGetTerminalToken: 'io.pocketenv.actor.getTerminalToken',
2096
-
AppBskyActorProfile: 'app.bsky.actor.profile',
2097
-
IoPocketenvFileAddFile: 'io.pocketenv.file.addFile',
2098
-
IoPocketenvFileDefs: 'io.pocketenv.file.defs',
2099
-
IoPocketenvFileDeleteFile: 'io.pocketenv.file.deleteFile',
2100
-
IoPocketenvFileGetFiles: 'io.pocketenv.file.getFiles',
2101
-
IoPocketenvSandboxClaimSandbox: 'io.pocketenv.sandbox.claimSandbox',
2102
-
IoPocketenvSandboxCreateIntegration: 'io.pocketenv.sandbox.createIntegration',
2103
-
IoPocketenvSandboxCreateSandbox: 'io.pocketenv.sandbox.createSandbox',
2104
-
IoPocketenvSandboxDefs: 'io.pocketenv.sandbox.defs',
2105
-
IoPocketenvSandboxDeleteSandbox: 'io.pocketenv.sandbox.deleteSandbox',
2106
-
IoPocketenvSandboxGetIntegrations: 'io.pocketenv.sandbox.getIntegrations',
2107
-
IoPocketenvSandboxGetPreferences: 'io.pocketenv.sandbox.getPreferences',
2108
-
IoPocketenvSandboxGetSandbox: 'io.pocketenv.sandbox.getSandbox',
2109
-
IoPocketenvSandboxGetSandboxes: 'io.pocketenv.sandbox.getSandboxes',
2110
-
IoPocketenvSandboxGetSshKeys: 'io.pocketenv.sandbox.getSshKeys',
2219
+
IoPocketenvActorDefs: "io.pocketenv.actor.defs",
2220
+
IoPocketenvActorGetActorSandboxes: "io.pocketenv.actor.getActorSandboxes",
2221
+
IoPocketenvActorGetProfile: "io.pocketenv.actor.getProfile",
2222
+
IoPocketenvActorGetTerminalToken: "io.pocketenv.actor.getTerminalToken",
2223
+
AppBskyActorProfile: "app.bsky.actor.profile",
2224
+
IoPocketenvFileAddFile: "io.pocketenv.file.addFile",
2225
+
IoPocketenvFileDefs: "io.pocketenv.file.defs",
2226
+
IoPocketenvFileDeleteFile: "io.pocketenv.file.deleteFile",
2227
+
IoPocketenvFileGetFile: "io.pocketenv.file.getFile",
2228
+
IoPocketenvFileGetFiles: "io.pocketenv.file.getFiles",
2229
+
IoPocketenvSandboxClaimSandbox: "io.pocketenv.sandbox.claimSandbox",
2230
+
IoPocketenvSandboxCreateIntegration: "io.pocketenv.sandbox.createIntegration",
2231
+
IoPocketenvSandboxCreateSandbox: "io.pocketenv.sandbox.createSandbox",
2232
+
IoPocketenvSandboxDefs: "io.pocketenv.sandbox.defs",
2233
+
IoPocketenvSandboxDeleteSandbox: "io.pocketenv.sandbox.deleteSandbox",
2234
+
IoPocketenvSandboxGetIntegrations: "io.pocketenv.sandbox.getIntegrations",
2235
+
IoPocketenvSandboxGetPreferences: "io.pocketenv.sandbox.getPreferences",
2236
+
IoPocketenvSandboxGetSandbox: "io.pocketenv.sandbox.getSandbox",
2237
+
IoPocketenvSandboxGetSandboxes: "io.pocketenv.sandbox.getSandboxes",
2238
+
IoPocketenvSandboxGetSshKeys: "io.pocketenv.sandbox.getSshKeys",
2111
2239
IoPocketenvSandboxGetTailscaleAuthKey:
2112
-
'io.pocketenv.sandbox.getTailscaleAuthKey',
2113
-
IoPocketenvSandboxGetTailscaleToken: 'io.pocketenv.sandbox.getTailscaleToken',
2114
-
IoPocketenvSandboxPutPreferences: 'io.pocketenv.sandbox.putPreferences',
2115
-
IoPocketenvSandboxPutSshKeys: 'io.pocketenv.sandbox.putSshKeys',
2240
+
"io.pocketenv.sandbox.getTailscaleAuthKey",
2241
+
IoPocketenvSandboxGetTailscaleToken: "io.pocketenv.sandbox.getTailscaleToken",
2242
+
IoPocketenvSandboxPutPreferences: "io.pocketenv.sandbox.putPreferences",
2243
+
IoPocketenvSandboxPutSshKeys: "io.pocketenv.sandbox.putSshKeys",
2116
2244
IoPocketenvSandboxPutTailscaleAuthKey:
2117
-
'io.pocketenv.sandbox.putTailscaleAuthKey',
2118
-
IoPocketenvSandboxPutTailscaleToken: 'io.pocketenv.sandbox.putTailscaleToken',
2119
-
IoPocketenvSandbox: 'io.pocketenv.sandbox',
2120
-
IoPocketenvSandboxStartSandbox: 'io.pocketenv.sandbox.startSandbox',
2121
-
IoPocketenvSandboxStopSandbox: 'io.pocketenv.sandbox.stopSandbox',
2245
+
"io.pocketenv.sandbox.putTailscaleAuthKey",
2246
+
IoPocketenvSandboxPutTailscaleToken: "io.pocketenv.sandbox.putTailscaleToken",
2247
+
IoPocketenvSandbox: "io.pocketenv.sandbox",
2248
+
IoPocketenvSandboxStartSandbox: "io.pocketenv.sandbox.startSandbox",
2249
+
IoPocketenvSandboxStopSandbox: "io.pocketenv.sandbox.stopSandbox",
2122
2250
IoPocketenvSandboxUpdateSandboxSettings:
2123
-
'io.pocketenv.sandbox.updateSandboxSettings',
2124
-
IoPocketenvSecretAddSecret: 'io.pocketenv.secret.addSecret',
2125
-
IoPocketenvSecretDefs: 'io.pocketenv.secret.defs',
2126
-
IoPocketenvSecretDeleteSecret: 'io.pocketenv.secret.deleteSecret',
2127
-
IoPocketenvSecretGetSecrets: 'io.pocketenv.secret.getSecrets',
2128
-
IoPocketenvVariableAddVariable: 'io.pocketenv.variable.addVariable',
2129
-
IoPocketenvVariableDefs: 'io.pocketenv.variable.defs',
2130
-
IoPocketenvVariableDeleteVariable: 'io.pocketenv.variable.deleteVariable',
2131
-
IoPocketenvVariableGetVariables: 'io.pocketenv.variable.getVariables',
2132
-
IoPocketenvVolumeAddVolume: 'io.pocketenv.volume.addVolume',
2133
-
IoPocketenvVolumeDefs: 'io.pocketenv.volume.defs',
2134
-
IoPocketenvVolumeDeleteVolume: 'io.pocketenv.volume.deleteVolume',
2135
-
IoPocketenvVolumeGetVolumes: 'io.pocketenv.volume.getVolumes',
2136
-
IoPocketenvPublicKey: 'io.pocketenv.publicKey',
2137
-
ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
2138
-
}
2251
+
"io.pocketenv.sandbox.updateSandboxSettings",
2252
+
IoPocketenvSecretAddSecret: "io.pocketenv.secret.addSecret",
2253
+
IoPocketenvSecretDefs: "io.pocketenv.secret.defs",
2254
+
IoPocketenvSecretDeleteSecret: "io.pocketenv.secret.deleteSecret",
2255
+
IoPocketenvSecretGetSecret: "io.pocketenv.secret.getSecret",
2256
+
IoPocketenvSecretGetSecrets: "io.pocketenv.secret.getSecrets",
2257
+
IoPocketenvVariableAddVariable: "io.pocketenv.variable.addVariable",
2258
+
IoPocketenvVariableDefs: "io.pocketenv.variable.defs",
2259
+
IoPocketenvVariableDeleteVariable: "io.pocketenv.variable.deleteVariable",
2260
+
IoPocketenvVariableGetVariable: "io.pocketenv.variable.getVariable",
2261
+
IoPocketenvVariableGetVariables: "io.pocketenv.variable.getVariables",
2262
+
IoPocketenvVolumeAddVolume: "io.pocketenv.volume.addVolume",
2263
+
IoPocketenvVolumeDefs: "io.pocketenv.volume.defs",
2264
+
IoPocketenvVolumeDeleteVolume: "io.pocketenv.volume.deleteVolume",
2265
+
IoPocketenvVolumeGetVolume: "io.pocketenv.volume.getVolume",
2266
+
IoPocketenvVolumeGetVolumes: "io.pocketenv.volume.getVolumes",
2267
+
IoPocketenvPublicKey: "io.pocketenv.publicKey",
2268
+
ComAtprotoRepoStrongRef: "com.atproto.repo.strongRef",
2269
+
};
+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;
+48
apps/api/src/lexicon/types/io/pocketenv/file/getFile.ts
+48
apps/api/src/lexicon/types/io/pocketenv/file/getFile.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 IoPocketenvFileDefs from "./defs";
11
+
12
+
export interface QueryParams {
13
+
/** The ID of the file to retrieve. */
14
+
id: string;
15
+
}
16
+
17
+
export type InputSchema = undefined;
18
+
19
+
export interface OutputSchema {
20
+
file?: IoPocketenvFileDefs.FileView;
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;
+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;
+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;
+38
-38
apps/api/src/lexicon/types/io/pocketenv/sandbox/createSandbox.ts
+38
-38
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'
22
+
provider?: "daytona" | "vercel" | "cloudflare" | "deno";
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
37
-
[k: string]: unknown
34
+
readme?: string;
35
+
secrets?: IoPocketenvSandboxDefs.Secrets;
36
+
envs?: IoPocketenvSandboxDefs.Envs;
37
+
[k: string]: unknown;
38
38
}
39
39
40
-
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic
40
+
export type OutputSchema = IoPocketenvSandboxDefs.SandboxViewBasic;
41
41
42
42
export interface HandlerInput {
43
-
encoding: 'application/json'
44
-
body: InputSchema
43
+
encoding: "application/json";
44
+
body: InputSchema;
45
45
}
46
46
47
47
export interface HandlerSuccess {
48
-
encoding: 'application/json'
49
-
body: OutputSchema
50
-
headers?: { [key: string]: string }
48
+
encoding: "application/json";
49
+
body: OutputSchema;
50
+
headers?: { [key: string]: string };
51
51
}
52
52
53
53
export interface HandlerError {
54
-
status: number
55
-
message?: string
54
+
status: number;
55
+
message?: string;
56
56
}
57
57
58
-
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
58
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
59
59
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
60
-
auth: HA
61
-
params: QueryParams
62
-
input: HandlerInput
63
-
req: express.Request
64
-
res: express.Response
65
-
resetRouteRateLimits: () => Promise<void>
66
-
}
60
+
auth: HA;
61
+
params: QueryParams;
62
+
input: HandlerInput;
63
+
req: express.Request;
64
+
res: express.Response;
65
+
resetRouteRateLimits: () => Promise<void>;
66
+
};
67
67
export type Handler<HA extends HandlerAuth = never> = (
68
68
ctx: HandlerReqCtx<HA>,
69
-
) => Promise<HandlerOutput> | HandlerOutput
69
+
) => 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;
+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;
+25
-25
apps/api/src/lexicon/types/io/pocketenv/sandbox/startSandbox.ts
+25
-25
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
-
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;
+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;
+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;
+48
apps/api/src/lexicon/types/io/pocketenv/secret/getSecret.ts
+48
apps/api/src/lexicon/types/io/pocketenv/secret/getSecret.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 IoPocketenvSecretDefs from "./defs";
11
+
12
+
export interface QueryParams {
13
+
/** The ID of the secret for which to retrieve secrets. */
14
+
id: string;
15
+
}
16
+
17
+
export type InputSchema = undefined;
18
+
19
+
export interface OutputSchema {
20
+
secret?: IoPocketenvSecretDefs.SecretView;
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;
+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;
+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;
+48
apps/api/src/lexicon/types/io/pocketenv/variable/getVariable.ts
+48
apps/api/src/lexicon/types/io/pocketenv/variable/getVariable.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 IoPocketenvVariableDefs from "./defs";
11
+
12
+
export interface QueryParams {
13
+
/** The ID of the variable for which to retrieve variables. */
14
+
id: string;
15
+
}
16
+
17
+
export type InputSchema = undefined;
18
+
19
+
export interface OutputSchema {
20
+
variable?: IoPocketenvVariableDefs.VariableView;
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;
+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;
+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;
+48
apps/api/src/lexicon/types/io/pocketenv/volume/getVolume.ts
+48
apps/api/src/lexicon/types/io/pocketenv/volume/getVolume.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 IoPocketenvVolumeDefs from "./defs";
11
+
12
+
export interface QueryParams {
13
+
/** The ID of the volume for which to retrieve volumes. */
14
+
id: string;
15
+
}
16
+
17
+
export type InputSchema = undefined;
18
+
19
+
export interface OutputSchema {
20
+
volume?: IoPocketenvVolumeDefs.VolumeView;
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;
+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;
+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
}
+3
-1
apps/api/src/schema/files.ts
+3
-1
apps/api/src/schema/files.ts
···
2
2
import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
3
3
4
4
const files = pgTable("files", {
5
-
id: text("id").primaryKey().default(sql`variable_id()`),
5
+
id: text("id")
6
+
.primaryKey()
7
+
.default(sql`xata_id()`),
6
8
content: text("content").notNull(),
7
9
createdAt: timestamp("created_at").defaultNow().notNull(),
8
10
updatedAt: timestamp("updated_at").defaultNow().notNull(),
+13
apps/api/src/xrpc/index.ts
+13
apps/api/src/xrpc/index.ts
···
29
29
import getTailscaleAuthKey from "./io/pocketenv/sandbox/getTailscaleAuthKey";
30
30
import putSshKeys from "./io/pocketenv/sandbox/putSshKeys";
31
31
import putTailscaleAuthKey from "./io/pocketenv/sandbox/putTailscaleAuthKey";
32
+
import getFile from "./io/pocketenv/file/getFile";
33
+
import getSecret from "./io/pocketenv/secret/getSecret";
34
+
import getVariable from "./io/pocketenv/variable/getVariable";
35
+
import getVolume from "./io/pocketenv/volume/getVolume";
36
+
import deleteVariable from "./io/pocketenv/variable/deleteVariable";
32
37
33
38
export default function (server: Server, ctx: Context) {
34
39
// io.pocketenv
···
61
66
getTailscaleAuthKey(server, ctx);
62
67
putSshKeys(server, ctx);
63
68
putTailscaleAuthKey(server, ctx);
69
+
getFile(server, ctx);
70
+
getSecret(server, ctx);
71
+
getVariable(server, ctx);
72
+
getVolume(server, ctx);
73
+
deleteFile(server, ctx);
74
+
deleteSecret(server, ctx);
75
+
deleteVolume(server, ctx);
76
+
deleteVariable(server, ctx);
64
77
65
78
return server;
66
79
}
+12
-4
apps/api/src/xrpc/io/pocketenv/file/deleteFile.ts
+12
-4
apps/api/src/xrpc/io/pocketenv/file/deleteFile.ts
···
1
1
import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server";
2
2
import type { Context } from "context";
3
+
import { eq } from "drizzle-orm";
3
4
import type { Server } from "lexicon";
4
-
import type { HandlerInput } from "lexicon/types/io/pocketenv/file/deleteFile";
5
+
import type { QueryParams } from "lexicon/types/io/pocketenv/file/deleteFile";
6
+
import sandboxFiles from "schema/sandbox-files";
5
7
6
8
export default function (server: Server, ctx: Context) {
7
-
const deleteFile = async (input: HandlerInput, auth: HandlerAuth) => {
9
+
const deleteFile = async (params: QueryParams, auth: HandlerAuth) => {
10
+
if (!auth.credentials) {
11
+
throw new XRPCError(401, "Unauthorized");
12
+
}
13
+
14
+
await ctx.db.delete(sandboxFiles).where(eq(sandboxFiles.id, params.id));
15
+
8
16
return {};
9
17
};
10
18
server.io.pocketenv.file.deleteFile({
11
19
auth: ctx.authVerifier,
12
-
handler: async ({ input, auth }) => {
13
-
await deleteFile(input, auth);
20
+
handler: async ({ params, auth }) => {
21
+
await deleteFile(params, auth);
14
22
},
15
23
});
16
24
}
+95
apps/api/src/xrpc/io/pocketenv/file/getFile.ts
+95
apps/api/src/xrpc/io/pocketenv/file/getFile.ts
···
1
+
import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server";
2
+
import type { Context } from "context";
3
+
import { eq, and } from "drizzle-orm";
4
+
import type { Server } from "lexicon";
5
+
import type {
6
+
QueryParams,
7
+
OutputSchema,
8
+
} from "lexicon/types/io/pocketenv/file/getFile";
9
+
import files from "schema/files";
10
+
import sandboxFiles, { type SelectSandboxFile } from "schema/sandbox-files";
11
+
import sandboxes from "schema/sandboxes";
12
+
import users from "schema/users";
13
+
import { pipe, Effect } from "effect";
14
+
import { consola } from "consola";
15
+
16
+
export default function (server: Server, ctx: Context) {
17
+
const getFile = (params: QueryParams, auth: HandlerAuth) => {
18
+
if (!auth?.credentials?.did) {
19
+
throw new XRPCError(401, "Unauthorized");
20
+
}
21
+
22
+
return pipe(
23
+
{ params, ctx, auth },
24
+
retrieve,
25
+
Effect.flatMap(presentation),
26
+
Effect.retry({ times: 3 }),
27
+
Effect.timeout("10 seconds"),
28
+
Effect.catchAll((err) => {
29
+
consola.error("Error retrieving files:", err);
30
+
return Effect.succeed({ sandboxes: [] });
31
+
}),
32
+
);
33
+
};
34
+
35
+
server.io.pocketenv.file.getFile({
36
+
auth: ctx.authVerifier,
37
+
handler: async ({ params, auth }) => {
38
+
const result = await Effect.runPromise(getFile(params, auth));
39
+
return {
40
+
encoding: "application/json",
41
+
body: result,
42
+
};
43
+
},
44
+
});
45
+
}
46
+
47
+
const retrieve = ({
48
+
params,
49
+
ctx,
50
+
auth,
51
+
}: {
52
+
params: QueryParams;
53
+
ctx: Context;
54
+
auth: HandlerAuth;
55
+
}): Effect.Effect<SelectSandboxFile[], Error> => {
56
+
return Effect.tryPromise({
57
+
try: async () =>
58
+
ctx.db
59
+
.select()
60
+
.from(sandboxFiles)
61
+
.leftJoin(sandboxes, eq(sandboxes.id, sandboxFiles.sandboxId))
62
+
.leftJoin(files, eq(files.id, sandboxFiles.fileId))
63
+
.leftJoin(users, eq(users.id, sandboxes.userId))
64
+
.where(
65
+
and(
66
+
eq(users.did, auth.credentials.did),
67
+
eq(sandboxFiles.id, params.id),
68
+
),
69
+
)
70
+
.execute()
71
+
.then((rows) =>
72
+
rows.map((row) => row.sandbox_files).filter((file) => file !== null),
73
+
),
74
+
catch: (error) => {
75
+
consola.error("Error retrieving file:", error);
76
+
throw new XRPCError(
77
+
500,
78
+
`Failed to retrieve file: ${error instanceof Error ? error.message : String(error)}`,
79
+
);
80
+
},
81
+
});
82
+
};
83
+
84
+
const presentation = (
85
+
files: SelectSandboxFile[],
86
+
): Effect.Effect<OutputSchema, never> => {
87
+
return Effect.sync(() => ({
88
+
file: files.map((file) => ({
89
+
id: file.id,
90
+
path: file.path,
91
+
createdAt: file.createdAt.toISOString(),
92
+
updatedAt: file.updatedAt.toISOString(),
93
+
}))[0],
94
+
}));
95
+
};
+1
-1
apps/api/src/xrpc/io/pocketenv/file/getFiles.ts
+1
-1
apps/api/src/xrpc/io/pocketenv/file/getFiles.ts
+15
apps/api/src/xrpc/io/pocketenv/secret/deleteSecret.ts
+15
apps/api/src/xrpc/io/pocketenv/secret/deleteSecret.ts
···
1
1
import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server";
2
2
import type { Context } from "context";
3
+
import { eq, or } from "drizzle-orm";
3
4
import type { Server } from "lexicon";
4
5
import type { QueryParams } from "lexicon/types/io/pocketenv/secret/deleteSecret";
6
+
import sandboxSecrets from "schema/sandbox-secrets";
5
7
6
8
export default function (server: Server, ctx: Context) {
7
9
const deleteSecret = async (params: QueryParams, auth: HandlerAuth) => {
10
+
if (!auth.credentials) {
11
+
throw new XRPCError(401, "Unauthorized");
12
+
}
13
+
14
+
await ctx.db
15
+
.delete(sandboxSecrets)
16
+
.where(
17
+
or(
18
+
eq(sandboxSecrets.id, params.id),
19
+
eq(sandboxSecrets.secretId, params.id),
20
+
),
21
+
);
22
+
8
23
return {};
9
24
};
10
25
server.io.pocketenv.secret.deleteSecret({
+96
apps/api/src/xrpc/io/pocketenv/secret/getSecret.ts
+96
apps/api/src/xrpc/io/pocketenv/secret/getSecret.ts
···
1
+
import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server";
2
+
import type { Context } from "context";
3
+
import { eq, and, count } from "drizzle-orm";
4
+
import type { Server } from "lexicon";
5
+
import type {
6
+
QueryParams,
7
+
OutputSchema,
8
+
} from "lexicon/types/io/pocketenv/secret/getSecret";
9
+
import sandboxes from "schema/sandboxes";
10
+
import users from "schema/users";
11
+
import { pipe, Effect } from "effect";
12
+
import { consola } from "consola";
13
+
import secrets, { type SelectSecret } from "schema/secrets";
14
+
import sandboxSecrets from "schema/sandbox-secrets";
15
+
16
+
export default function (server: Server, ctx: Context) {
17
+
const getSecret = (params: QueryParams, auth: HandlerAuth) => {
18
+
if (!auth?.credentials?.did) {
19
+
throw new XRPCError(401, "Unauthorized");
20
+
}
21
+
22
+
return pipe(
23
+
{ params, ctx, auth },
24
+
retrieve,
25
+
Effect.flatMap(presentation),
26
+
Effect.retry({ times: 3 }),
27
+
Effect.timeout("10 seconds"),
28
+
Effect.catchAll((err) => {
29
+
consola.error("Error retrieving secret:", err);
30
+
return Effect.succeed({ secrets: [] });
31
+
}),
32
+
);
33
+
};
34
+
35
+
server.io.pocketenv.secret.getSecret({
36
+
auth: ctx.authVerifier,
37
+
handler: async ({ params, auth }) => {
38
+
const result = await Effect.runPromise(getSecret(params, auth));
39
+
return {
40
+
encoding: "application/json",
41
+
body: result,
42
+
};
43
+
},
44
+
});
45
+
}
46
+
47
+
const retrieve = ({
48
+
params,
49
+
ctx,
50
+
auth,
51
+
}: {
52
+
params: QueryParams;
53
+
ctx: Context;
54
+
auth: HandlerAuth;
55
+
}): Effect.Effect<SelectSecret[], Error> => {
56
+
return Effect.tryPromise({
57
+
try: async () =>
58
+
ctx.db
59
+
.select()
60
+
.from(sandboxSecrets)
61
+
.leftJoin(sandboxes, eq(sandboxes.id, sandboxSecrets.sandboxId))
62
+
.leftJoin(secrets, eq(secrets.id, sandboxSecrets.secretId))
63
+
.leftJoin(users, eq(users.id, sandboxes.userId))
64
+
.where(
65
+
and(
66
+
eq(users.did, auth.credentials.did),
67
+
eq(sandboxSecrets.secretId, params.id),
68
+
),
69
+
)
70
+
.execute()
71
+
.then((rows) =>
72
+
rows
73
+
.map((row) => row.secrets)
74
+
.filter((variable) => variable !== null),
75
+
),
76
+
catch: (error) => {
77
+
consola.error("Error retrieving secret:", error);
78
+
throw new XRPCError(
79
+
500,
80
+
`Failed to retrieve secret: ${error instanceof Error ? error.message : String(error)}`,
81
+
);
82
+
},
83
+
});
84
+
};
85
+
86
+
const presentation = (
87
+
secrets: SelectSecret[],
88
+
): Effect.Effect<OutputSchema, never> => {
89
+
return Effect.sync(() => ({
90
+
secret: secrets.map((secret) => ({
91
+
id: secret.id,
92
+
name: secret.name,
93
+
createdAt: secret.createdAt.toISOString(),
94
+
}))[0],
95
+
}));
96
+
};
+15
apps/api/src/xrpc/io/pocketenv/variable/deleteVariable.ts
+15
apps/api/src/xrpc/io/pocketenv/variable/deleteVariable.ts
···
1
1
import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server";
2
2
import type { Context } from "context";
3
+
import { eq, or } from "drizzle-orm";
3
4
import type { Server } from "lexicon";
4
5
import type { QueryParams } from "lexicon/types/io/pocketenv/variable/deleteVariable";
6
+
import sandboxVariables from "schema/sandbox-variables";
5
7
6
8
export default function (server: Server, ctx: Context) {
7
9
const deleteVariable = async (params: QueryParams, auth: HandlerAuth) => {
10
+
if (!auth.credentials) {
11
+
throw new XRPCError(401, "Unauthorized");
12
+
}
13
+
14
+
await ctx.db
15
+
.delete(sandboxVariables)
16
+
.where(
17
+
or(
18
+
eq(sandboxVariables.id, params.id),
19
+
eq(sandboxVariables.variableId, params.id),
20
+
),
21
+
);
22
+
8
23
return {};
9
24
};
10
25
server.io.pocketenv.variable.deleteVariable({
+98
apps/api/src/xrpc/io/pocketenv/variable/getVariable.ts
+98
apps/api/src/xrpc/io/pocketenv/variable/getVariable.ts
···
1
+
import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server";
2
+
import type { Context } from "context";
3
+
import { eq, and, count } from "drizzle-orm";
4
+
import type { Server } from "lexicon";
5
+
import type {
6
+
QueryParams,
7
+
OutputSchema,
8
+
} from "lexicon/types/io/pocketenv/variable/getVariable";
9
+
import sandboxes from "schema/sandboxes";
10
+
import users from "schema/users";
11
+
import { pipe, Effect } from "effect";
12
+
import { consola } from "consola";
13
+
import variables, { type SelectVariable } from "schema/variables";
14
+
import sandboxVariables from "schema/sandbox-variables";
15
+
16
+
export default function (server: Server, ctx: Context) {
17
+
const getVariable = (params: QueryParams, auth: HandlerAuth) => {
18
+
if (!auth?.credentials?.did) {
19
+
throw new XRPCError(401, "Unauthorized");
20
+
}
21
+
22
+
return pipe(
23
+
{ params, ctx, auth },
24
+
retrieve,
25
+
Effect.flatMap(presentation),
26
+
Effect.retry({ times: 3 }),
27
+
Effect.timeout("10 seconds"),
28
+
Effect.catchAll((err) => {
29
+
consola.error("Error retrieving variable:", err);
30
+
return Effect.succeed({ variables: [] });
31
+
}),
32
+
);
33
+
};
34
+
35
+
server.io.pocketenv.variable.getVariable({
36
+
auth: ctx.authVerifier,
37
+
handler: async ({ params, auth }) => {
38
+
const result = await Effect.runPromise(getVariable(params, auth));
39
+
return {
40
+
encoding: "application/json",
41
+
body: result,
42
+
};
43
+
},
44
+
});
45
+
}
46
+
47
+
const retrieve = ({
48
+
params,
49
+
ctx,
50
+
auth,
51
+
}: {
52
+
params: QueryParams;
53
+
ctx: Context;
54
+
auth: HandlerAuth;
55
+
}): Effect.Effect<SelectVariable[], Error> => {
56
+
return Effect.tryPromise({
57
+
try: async () =>
58
+
ctx.db
59
+
.select()
60
+
.from(sandboxVariables)
61
+
.leftJoin(sandboxes, eq(sandboxes.id, sandboxVariables.sandboxId))
62
+
.leftJoin(variables, eq(variables.id, sandboxVariables.variableId))
63
+
.leftJoin(users, eq(users.id, sandboxes.userId))
64
+
.where(
65
+
and(
66
+
eq(users.did, auth.credentials.did),
67
+
eq(sandboxVariables.variableId, params.id),
68
+
),
69
+
)
70
+
.execute()
71
+
.then((rows) =>
72
+
rows
73
+
.map((row) => row.variables)
74
+
.filter((variable) => variable !== null),
75
+
),
76
+
catch: (error) => {
77
+
consola.error("Error retrieving variable:", error);
78
+
throw new XRPCError(
79
+
500,
80
+
`Failed to retrieve variable: ${error instanceof Error ? error.message : String(error)}`,
81
+
);
82
+
},
83
+
});
84
+
};
85
+
86
+
const presentation = (
87
+
variables: SelectVariable[],
88
+
): Effect.Effect<OutputSchema, never> => {
89
+
return Effect.sync(() => ({
90
+
variable: variables.map((variable) => ({
91
+
id: variable.id,
92
+
name: variable.name,
93
+
value: variable.value,
94
+
createdAt: variable.createdAt.toISOString(),
95
+
updatedAt: variable.updatedAt.toISOString(),
96
+
}))[0],
97
+
}));
98
+
};
+1
-1
apps/api/src/xrpc/io/pocketenv/variable/getVariables.ts
+1
-1
apps/api/src/xrpc/io/pocketenv/variable/getVariables.ts
+1
apps/api/src/xrpc/io/pocketenv/volume/addVolume.ts
+1
apps/api/src/xrpc/io/pocketenv/volume/addVolume.ts
+15
apps/api/src/xrpc/io/pocketenv/volume/deleteVolume.ts
+15
apps/api/src/xrpc/io/pocketenv/volume/deleteVolume.ts
···
1
1
import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server";
2
2
import type { Context } from "context";
3
+
import { eq, or } from "drizzle-orm";
3
4
import type { Server } from "lexicon";
4
5
import type { QueryParams } from "lexicon/types/io/pocketenv/volume/deleteVolume";
6
+
import sandboxVolumes from "schema/sandbox-volumes";
5
7
6
8
export default function (server: Server, ctx: Context) {
7
9
const deleteVolume = async (params: QueryParams, auth: HandlerAuth) => {
10
+
if (!auth.credentials) {
11
+
throw new XRPCError(401, "Unauthorized");
12
+
}
13
+
14
+
await ctx.db
15
+
.delete(sandboxVolumes)
16
+
.where(
17
+
or(
18
+
eq(sandboxVolumes.id, params.id),
19
+
eq(sandboxVolumes.volumeId, params.id),
20
+
),
21
+
);
22
+
8
23
return {};
9
24
};
10
25
server.io.pocketenv.volume.deleteVolume({
+100
apps/api/src/xrpc/io/pocketenv/volume/getVolume.ts
+100
apps/api/src/xrpc/io/pocketenv/volume/getVolume.ts
···
1
+
import { XRPCError, type HandlerAuth } from "@atproto/xrpc-server";
2
+
import type { Context } from "context";
3
+
import { eq, and, count } from "drizzle-orm";
4
+
import type { Server } from "lexicon";
5
+
import type {
6
+
QueryParams,
7
+
OutputSchema,
8
+
} from "lexicon/types/io/pocketenv/volume/getVolume";
9
+
import volumes, { type SelectVolume } from "schema/volumes";
10
+
import sandboxVolumes, {
11
+
type SelectSandboxVolume,
12
+
} from "schema/sandbox-volumes";
13
+
import sandboxes from "schema/sandboxes";
14
+
import users from "schema/users";
15
+
import { pipe, Effect } from "effect";
16
+
import { consola } from "consola";
17
+
18
+
export default function (server: Server, ctx: Context) {
19
+
const getVolume = (params: QueryParams, auth: HandlerAuth) => {
20
+
if (!auth?.credentials?.did) {
21
+
throw new XRPCError(401, "Unauthorized");
22
+
}
23
+
24
+
return pipe(
25
+
{ params, ctx, auth },
26
+
retrieve,
27
+
Effect.flatMap(presentation),
28
+
Effect.retry({ times: 3 }),
29
+
Effect.timeout("10 seconds"),
30
+
Effect.catchAll((err) => {
31
+
consola.error("Error retrieving volume:", err);
32
+
return Effect.succeed({ volumes: [] });
33
+
}),
34
+
);
35
+
};
36
+
37
+
server.io.pocketenv.volume.getVolume({
38
+
auth: ctx.authVerifier,
39
+
handler: async ({ params, auth }) => {
40
+
const result = await Effect.runPromise(getVolume(params, auth));
41
+
return {
42
+
encoding: "application/json",
43
+
body: result,
44
+
};
45
+
},
46
+
});
47
+
}
48
+
49
+
const retrieve = ({
50
+
params,
51
+
ctx,
52
+
auth,
53
+
}: {
54
+
params: QueryParams;
55
+
ctx: Context;
56
+
auth: HandlerAuth;
57
+
}): Effect.Effect<SelectSandboxVolume[], Error> => {
58
+
return Effect.tryPromise({
59
+
try: async () =>
60
+
ctx.db
61
+
.select()
62
+
.from(sandboxVolumes)
63
+
.leftJoin(sandboxes, eq(sandboxes.id, sandboxVolumes.sandboxId))
64
+
.leftJoin(volumes, eq(volumes.id, sandboxVolumes.volumeId))
65
+
.leftJoin(users, eq(users.id, sandboxes.userId))
66
+
.where(
67
+
and(
68
+
eq(users.did, auth.credentials.did),
69
+
eq(sandboxVolumes.id, params.id),
70
+
),
71
+
)
72
+
.execute()
73
+
.then((rows) =>
74
+
rows
75
+
.map((row) => row.sandbox_volumes)
76
+
.filter((volume) => volume !== null),
77
+
),
78
+
catch: (error) => {
79
+
consola.error("Error retrieving volume:", error);
80
+
throw new XRPCError(
81
+
500,
82
+
`Failed to retrieve volume: ${error instanceof Error ? error.message : String(error)}`,
83
+
);
84
+
},
85
+
});
86
+
};
87
+
88
+
const presentation = (
89
+
volumes: SelectSandboxVolume[],
90
+
): Effect.Effect<OutputSchema, never> => {
91
+
return Effect.sync(() => ({
92
+
volume: volumes.map((volume, index) => ({
93
+
id: volume.id,
94
+
name: volume.name || "",
95
+
path: volume.path,
96
+
createdAt: volume.createdAt.toISOString(),
97
+
updatedAt: volume.updatedAt.toISOString(),
98
+
}))[0],
99
+
}));
100
+
};
+7
-7
apps/api/src/xrpc/io/pocketenv/volume/getVolumes.ts
+7
-7
apps/api/src/xrpc/io/pocketenv/volume/getVolumes.ts
···
28
28
Effect.retry({ times: 3 }),
29
29
Effect.timeout("10 seconds"),
30
30
Effect.catchAll((err) => {
31
-
consola.error("Error retrieving files:", err);
32
-
return Effect.succeed({ sandboxes: [] });
31
+
consola.error("Error retrieving volumes:", err);
32
+
return Effect.succeed({ volumes: [] });
33
33
}),
34
34
);
35
35
};
···
123
123
.then((result) => result[0]?.count ?? 0),
124
124
]),
125
125
catch: (error) => {
126
-
consola.error("Error retrieving files:", error);
126
+
consola.error("Error retrieving volumes:", error);
127
127
throw new XRPCError(
128
128
500,
129
-
`Failed to retrieve files: ${error instanceof Error ? error.message : String(error)}`,
129
+
`Failed to retrieve volumes: ${error instanceof Error ? error.message : String(error)}`,
130
130
);
131
131
},
132
132
});
133
133
};
134
134
135
-
const presentation = ([volumes, metadata, total]: [
135
+
const presentation = ([volumes, , total]: [
136
136
SelectSandboxVolume[],
137
137
(SelectVolume | null)[],
138
138
number,
139
139
]): Effect.Effect<OutputSchema, never> => {
140
140
return Effect.sync(() => ({
141
-
volumes: volumes.map((volume, index) => ({
141
+
volumes: volumes.map((volume) => ({
142
142
id: volume.id,
143
-
name: metadata[index]?.slug,
143
+
name: volume.name!,
144
144
path: volume.path,
145
145
createdAt: volume.createdAt.toISOString(),
146
146
updatedAt: volume.updatedAt.toISOString(),
+1
apps/cf-sandbox/drizzle/0026_known_blue_blade.sql
+1
apps/cf-sandbox/drizzle/0026_known_blue_blade.sql
···
1
+
ALTER TABLE "files" ALTER COLUMN "id" SET DEFAULT xata_id();
+1
apps/cf-sandbox/drizzle/0027_cooing_rattler.sql
+1
apps/cf-sandbox/drizzle/0027_cooing_rattler.sql
···
1
+
ALTER TABLE "files" ALTER COLUMN "id" SET DEFAULT xata_id();
+1315
apps/cf-sandbox/drizzle/meta/0026_snapshot.json
+1315
apps/cf-sandbox/drizzle/meta/0026_snapshot.json
···
1
+
{
2
+
"id": "6d5c52ad-5c37-408b-a30d-5c4c232c3e90",
3
+
"prevId": "7c2213ab-de38-4110-a874-cf45e0108dcf",
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": "file_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": "xata_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": {
146
+
"name": "unique_sandbox_file",
147
+
"columns": [
148
+
{
149
+
"expression": "sandbox_id",
150
+
"isExpression": false,
151
+
"asc": true,
152
+
"nulls": "last"
153
+
},
154
+
{
155
+
"expression": "file_id",
156
+
"isExpression": false,
157
+
"asc": true,
158
+
"nulls": "last"
159
+
}
160
+
],
161
+
"isUnique": true,
162
+
"concurrently": false,
163
+
"method": "btree",
164
+
"with": {}
165
+
},
166
+
"unique_sandbox_file_path": {
167
+
"name": "unique_sandbox_file_path",
168
+
"columns": [
169
+
{
170
+
"expression": "sandbox_id",
171
+
"isExpression": false,
172
+
"asc": true,
173
+
"nulls": "last"
174
+
},
175
+
{
176
+
"expression": "path",
177
+
"isExpression": false,
178
+
"asc": true,
179
+
"nulls": "last"
180
+
}
181
+
],
182
+
"isUnique": true,
183
+
"concurrently": false,
184
+
"method": "btree",
185
+
"with": {}
186
+
}
187
+
},
188
+
"foreignKeys": {
189
+
"sandbox_files_sandbox_id_sandboxes_id_fk": {
190
+
"name": "sandbox_files_sandbox_id_sandboxes_id_fk",
191
+
"tableFrom": "sandbox_files",
192
+
"tableTo": "sandboxes",
193
+
"columnsFrom": [
194
+
"sandbox_id"
195
+
],
196
+
"columnsTo": [
197
+
"id"
198
+
],
199
+
"onDelete": "no action",
200
+
"onUpdate": "no action"
201
+
},
202
+
"sandbox_files_file_id_files_id_fk": {
203
+
"name": "sandbox_files_file_id_files_id_fk",
204
+
"tableFrom": "sandbox_files",
205
+
"tableTo": "files",
206
+
"columnsFrom": [
207
+
"file_id"
208
+
],
209
+
"columnsTo": [
210
+
"id"
211
+
],
212
+
"onDelete": "no action",
213
+
"onUpdate": "no action"
214
+
}
215
+
},
216
+
"compositePrimaryKeys": {},
217
+
"uniqueConstraints": {},
218
+
"policies": {},
219
+
"checkConstraints": {},
220
+
"isRLSEnabled": false
221
+
},
222
+
"public.sandbox_secrets": {
223
+
"name": "sandbox_secrets",
224
+
"schema": "",
225
+
"columns": {
226
+
"id": {
227
+
"name": "id",
228
+
"type": "text",
229
+
"primaryKey": true,
230
+
"notNull": true,
231
+
"default": "xata_id()"
232
+
},
233
+
"sandbox_id": {
234
+
"name": "sandbox_id",
235
+
"type": "text",
236
+
"primaryKey": false,
237
+
"notNull": true
238
+
},
239
+
"secret_id": {
240
+
"name": "secret_id",
241
+
"type": "text",
242
+
"primaryKey": false,
243
+
"notNull": true
244
+
},
245
+
"name": {
246
+
"name": "name",
247
+
"type": "text",
248
+
"primaryKey": false,
249
+
"notNull": false
250
+
},
251
+
"created_at": {
252
+
"name": "created_at",
253
+
"type": "timestamp",
254
+
"primaryKey": false,
255
+
"notNull": true,
256
+
"default": "now()"
257
+
},
258
+
"updated_at": {
259
+
"name": "updated_at",
260
+
"type": "timestamp",
261
+
"primaryKey": false,
262
+
"notNull": true,
263
+
"default": "now()"
264
+
}
265
+
},
266
+
"indexes": {
267
+
"unique_sandbox_secret": {
268
+
"name": "unique_sandbox_secret",
269
+
"columns": [
270
+
{
271
+
"expression": "sandbox_id",
272
+
"isExpression": false,
273
+
"asc": true,
274
+
"nulls": "last"
275
+
},
276
+
{
277
+
"expression": "secret_id",
278
+
"isExpression": false,
279
+
"asc": true,
280
+
"nulls": "last"
281
+
}
282
+
],
283
+
"isUnique": true,
284
+
"concurrently": false,
285
+
"method": "btree",
286
+
"with": {}
287
+
},
288
+
"unique_sandbox_secret_by_name": {
289
+
"name": "unique_sandbox_secret_by_name",
290
+
"columns": [
291
+
{
292
+
"expression": "sandbox_id",
293
+
"isExpression": false,
294
+
"asc": true,
295
+
"nulls": "last"
296
+
},
297
+
{
298
+
"expression": "name",
299
+
"isExpression": false,
300
+
"asc": true,
301
+
"nulls": "last"
302
+
}
303
+
],
304
+
"isUnique": true,
305
+
"concurrently": false,
306
+
"method": "btree",
307
+
"with": {}
308
+
}
309
+
},
310
+
"foreignKeys": {
311
+
"sandbox_secrets_sandbox_id_sandboxes_id_fk": {
312
+
"name": "sandbox_secrets_sandbox_id_sandboxes_id_fk",
313
+
"tableFrom": "sandbox_secrets",
314
+
"tableTo": "sandboxes",
315
+
"columnsFrom": [
316
+
"sandbox_id"
317
+
],
318
+
"columnsTo": [
319
+
"id"
320
+
],
321
+
"onDelete": "no action",
322
+
"onUpdate": "no action"
323
+
},
324
+
"sandbox_secrets_secret_id_secrets_id_fk": {
325
+
"name": "sandbox_secrets_secret_id_secrets_id_fk",
326
+
"tableFrom": "sandbox_secrets",
327
+
"tableTo": "secrets",
328
+
"columnsFrom": [
329
+
"secret_id"
330
+
],
331
+
"columnsTo": [
332
+
"id"
333
+
],
334
+
"onDelete": "no action",
335
+
"onUpdate": "no action"
336
+
}
337
+
},
338
+
"compositePrimaryKeys": {},
339
+
"uniqueConstraints": {},
340
+
"policies": {},
341
+
"checkConstraints": {},
342
+
"isRLSEnabled": false
343
+
},
344
+
"public.sandbox_variables": {
345
+
"name": "sandbox_variables",
346
+
"schema": "",
347
+
"columns": {
348
+
"id": {
349
+
"name": "id",
350
+
"type": "text",
351
+
"primaryKey": true,
352
+
"notNull": true,
353
+
"default": "xata_id()"
354
+
},
355
+
"sandbox_id": {
356
+
"name": "sandbox_id",
357
+
"type": "text",
358
+
"primaryKey": false,
359
+
"notNull": true
360
+
},
361
+
"variable_id": {
362
+
"name": "variable_id",
363
+
"type": "text",
364
+
"primaryKey": false,
365
+
"notNull": true
366
+
},
367
+
"name": {
368
+
"name": "name",
369
+
"type": "text",
370
+
"primaryKey": false,
371
+
"notNull": true
372
+
},
373
+
"created_at": {
374
+
"name": "created_at",
375
+
"type": "timestamp",
376
+
"primaryKey": false,
377
+
"notNull": true,
378
+
"default": "now()"
379
+
},
380
+
"updated_at": {
381
+
"name": "updated_at",
382
+
"type": "timestamp",
383
+
"primaryKey": false,
384
+
"notNull": true,
385
+
"default": "now()"
386
+
}
387
+
},
388
+
"indexes": {
389
+
"unique_sandbox_variables": {
390
+
"name": "unique_sandbox_variables",
391
+
"columns": [
392
+
{
393
+
"expression": "sandbox_id",
394
+
"isExpression": false,
395
+
"asc": true,
396
+
"nulls": "last"
397
+
},
398
+
{
399
+
"expression": "variable_id",
400
+
"isExpression": false,
401
+
"asc": true,
402
+
"nulls": "last"
403
+
}
404
+
],
405
+
"isUnique": true,
406
+
"concurrently": false,
407
+
"method": "btree",
408
+
"with": {}
409
+
},
410
+
"unique_sandbox_variables_by_name": {
411
+
"name": "unique_sandbox_variables_by_name",
412
+
"columns": [
413
+
{
414
+
"expression": "sandbox_id",
415
+
"isExpression": false,
416
+
"asc": true,
417
+
"nulls": "last"
418
+
},
419
+
{
420
+
"expression": "name",
421
+
"isExpression": false,
422
+
"asc": true,
423
+
"nulls": "last"
424
+
}
425
+
],
426
+
"isUnique": true,
427
+
"concurrently": false,
428
+
"method": "btree",
429
+
"with": {}
430
+
}
431
+
},
432
+
"foreignKeys": {
433
+
"sandbox_variables_sandbox_id_sandboxes_id_fk": {
434
+
"name": "sandbox_variables_sandbox_id_sandboxes_id_fk",
435
+
"tableFrom": "sandbox_variables",
436
+
"tableTo": "sandboxes",
437
+
"columnsFrom": [
438
+
"sandbox_id"
439
+
],
440
+
"columnsTo": [
441
+
"id"
442
+
],
443
+
"onDelete": "no action",
444
+
"onUpdate": "no action"
445
+
},
446
+
"sandbox_variables_variable_id_variables_id_fk": {
447
+
"name": "sandbox_variables_variable_id_variables_id_fk",
448
+
"tableFrom": "sandbox_variables",
449
+
"tableTo": "variables",
450
+
"columnsFrom": [
451
+
"variable_id"
452
+
],
453
+
"columnsTo": [
454
+
"id"
455
+
],
456
+
"onDelete": "no action",
457
+
"onUpdate": "no action"
458
+
}
459
+
},
460
+
"compositePrimaryKeys": {},
461
+
"uniqueConstraints": {},
462
+
"policies": {},
463
+
"checkConstraints": {},
464
+
"isRLSEnabled": false
465
+
},
466
+
"public.sandbox_volumes": {
467
+
"name": "sandbox_volumes",
468
+
"schema": "",
469
+
"columns": {
470
+
"id": {
471
+
"name": "id",
472
+
"type": "text",
473
+
"primaryKey": true,
474
+
"notNull": true,
475
+
"default": "xata_id()"
476
+
},
477
+
"sandbox_id": {
478
+
"name": "sandbox_id",
479
+
"type": "text",
480
+
"primaryKey": false,
481
+
"notNull": true
482
+
},
483
+
"volume_id": {
484
+
"name": "volume_id",
485
+
"type": "text",
486
+
"primaryKey": false,
487
+
"notNull": true
488
+
},
489
+
"name": {
490
+
"name": "name",
491
+
"type": "text",
492
+
"primaryKey": false,
493
+
"notNull": false
494
+
},
495
+
"path": {
496
+
"name": "path",
497
+
"type": "text",
498
+
"primaryKey": false,
499
+
"notNull": true
500
+
},
501
+
"created_at": {
502
+
"name": "created_at",
503
+
"type": "timestamp",
504
+
"primaryKey": false,
505
+
"notNull": true,
506
+
"default": "now()"
507
+
},
508
+
"updated_at": {
509
+
"name": "updated_at",
510
+
"type": "timestamp",
511
+
"primaryKey": false,
512
+
"notNull": true,
513
+
"default": "now()"
514
+
}
515
+
},
516
+
"indexes": {
517
+
"unique_sandbox_volume": {
518
+
"name": "unique_sandbox_volume",
519
+
"columns": [
520
+
{
521
+
"expression": "sandbox_id",
522
+
"isExpression": false,
523
+
"asc": true,
524
+
"nulls": "last"
525
+
},
526
+
{
527
+
"expression": "volume_id",
528
+
"isExpression": false,
529
+
"asc": true,
530
+
"nulls": "last"
531
+
}
532
+
],
533
+
"isUnique": true,
534
+
"concurrently": false,
535
+
"method": "btree",
536
+
"with": {}
537
+
},
538
+
"unique_sandbox_volume_path": {
539
+
"name": "unique_sandbox_volume_path",
540
+
"columns": [
541
+
{
542
+
"expression": "sandbox_id",
543
+
"isExpression": false,
544
+
"asc": true,
545
+
"nulls": "last"
546
+
},
547
+
{
548
+
"expression": "path",
549
+
"isExpression": false,
550
+
"asc": true,
551
+
"nulls": "last"
552
+
}
553
+
],
554
+
"isUnique": true,
555
+
"concurrently": false,
556
+
"method": "btree",
557
+
"with": {}
558
+
}
559
+
},
560
+
"foreignKeys": {
561
+
"sandbox_volumes_sandbox_id_sandboxes_id_fk": {
562
+
"name": "sandbox_volumes_sandbox_id_sandboxes_id_fk",
563
+
"tableFrom": "sandbox_volumes",
564
+
"tableTo": "sandboxes",
565
+
"columnsFrom": [
566
+
"sandbox_id"
567
+
],
568
+
"columnsTo": [
569
+
"id"
570
+
],
571
+
"onDelete": "no action",
572
+
"onUpdate": "no action"
573
+
},
574
+
"sandbox_volumes_volume_id_volumes_id_fk": {
575
+
"name": "sandbox_volumes_volume_id_volumes_id_fk",
576
+
"tableFrom": "sandbox_volumes",
577
+
"tableTo": "volumes",
578
+
"columnsFrom": [
579
+
"volume_id"
580
+
],
581
+
"columnsTo": [
582
+
"id"
583
+
],
584
+
"onDelete": "no action",
585
+
"onUpdate": "no action"
586
+
}
587
+
},
588
+
"compositePrimaryKeys": {},
589
+
"uniqueConstraints": {},
590
+
"policies": {},
591
+
"checkConstraints": {},
592
+
"isRLSEnabled": false
593
+
},
594
+
"public.sandboxes": {
595
+
"name": "sandboxes",
596
+
"schema": "",
597
+
"columns": {
598
+
"id": {
599
+
"name": "id",
600
+
"type": "text",
601
+
"primaryKey": true,
602
+
"notNull": true,
603
+
"default": "sandbox_id()"
604
+
},
605
+
"base": {
606
+
"name": "base",
607
+
"type": "text",
608
+
"primaryKey": false,
609
+
"notNull": false
610
+
},
611
+
"name": {
612
+
"name": "name",
613
+
"type": "text",
614
+
"primaryKey": false,
615
+
"notNull": true
616
+
},
617
+
"display_name": {
618
+
"name": "display_name",
619
+
"type": "text",
620
+
"primaryKey": false,
621
+
"notNull": false
622
+
},
623
+
"uri": {
624
+
"name": "uri",
625
+
"type": "text",
626
+
"primaryKey": false,
627
+
"notNull": false
628
+
},
629
+
"cid": {
630
+
"name": "cid",
631
+
"type": "text",
632
+
"primaryKey": false,
633
+
"notNull": false
634
+
},
635
+
"repo": {
636
+
"name": "repo",
637
+
"type": "text",
638
+
"primaryKey": false,
639
+
"notNull": false
640
+
},
641
+
"provider": {
642
+
"name": "provider",
643
+
"type": "text",
644
+
"primaryKey": false,
645
+
"notNull": true,
646
+
"default": "'cloudflare'"
647
+
},
648
+
"description": {
649
+
"name": "description",
650
+
"type": "text",
651
+
"primaryKey": false,
652
+
"notNull": false
653
+
},
654
+
"topics": {
655
+
"name": "topics",
656
+
"type": "text[]",
657
+
"primaryKey": false,
658
+
"notNull": false
659
+
},
660
+
"logo": {
661
+
"name": "logo",
662
+
"type": "text",
663
+
"primaryKey": false,
664
+
"notNull": false
665
+
},
666
+
"readme": {
667
+
"name": "readme",
668
+
"type": "text",
669
+
"primaryKey": false,
670
+
"notNull": false
671
+
},
672
+
"public_key": {
673
+
"name": "public_key",
674
+
"type": "text",
675
+
"primaryKey": false,
676
+
"notNull": true
677
+
},
678
+
"user_id": {
679
+
"name": "user_id",
680
+
"type": "text",
681
+
"primaryKey": false,
682
+
"notNull": false
683
+
},
684
+
"instance_type": {
685
+
"name": "instance_type",
686
+
"type": "text",
687
+
"primaryKey": false,
688
+
"notNull": false
689
+
},
690
+
"vcpus": {
691
+
"name": "vcpus",
692
+
"type": "integer",
693
+
"primaryKey": false,
694
+
"notNull": false
695
+
},
696
+
"memory": {
697
+
"name": "memory",
698
+
"type": "integer",
699
+
"primaryKey": false,
700
+
"notNull": false
701
+
},
702
+
"disk": {
703
+
"name": "disk",
704
+
"type": "integer",
705
+
"primaryKey": false,
706
+
"notNull": false
707
+
},
708
+
"status": {
709
+
"name": "status",
710
+
"type": "text",
711
+
"primaryKey": false,
712
+
"notNull": true
713
+
},
714
+
"keep_alive": {
715
+
"name": "keep_alive",
716
+
"type": "boolean",
717
+
"primaryKey": false,
718
+
"notNull": true,
719
+
"default": false
720
+
},
721
+
"sleep_after": {
722
+
"name": "sleep_after",
723
+
"type": "text",
724
+
"primaryKey": false,
725
+
"notNull": false
726
+
},
727
+
"sandbox_id": {
728
+
"name": "sandbox_id",
729
+
"type": "text",
730
+
"primaryKey": false,
731
+
"notNull": false
732
+
},
733
+
"installs": {
734
+
"name": "installs",
735
+
"type": "integer",
736
+
"primaryKey": false,
737
+
"notNull": true,
738
+
"default": 0
739
+
},
740
+
"started_at": {
741
+
"name": "started_at",
742
+
"type": "timestamp",
743
+
"primaryKey": false,
744
+
"notNull": false
745
+
},
746
+
"created_at": {
747
+
"name": "created_at",
748
+
"type": "timestamp",
749
+
"primaryKey": false,
750
+
"notNull": true,
751
+
"default": "now()"
752
+
},
753
+
"updated_at": {
754
+
"name": "updated_at",
755
+
"type": "timestamp",
756
+
"primaryKey": false,
757
+
"notNull": true,
758
+
"default": "now()"
759
+
}
760
+
},
761
+
"indexes": {},
762
+
"foreignKeys": {
763
+
"sandboxes_user_id_users_id_fk": {
764
+
"name": "sandboxes_user_id_users_id_fk",
765
+
"tableFrom": "sandboxes",
766
+
"tableTo": "users",
767
+
"columnsFrom": [
768
+
"user_id"
769
+
],
770
+
"columnsTo": [
771
+
"id"
772
+
],
773
+
"onDelete": "no action",
774
+
"onUpdate": "no action"
775
+
}
776
+
},
777
+
"compositePrimaryKeys": {},
778
+
"uniqueConstraints": {
779
+
"sandboxes_name_unique": {
780
+
"name": "sandboxes_name_unique",
781
+
"nullsNotDistinct": false,
782
+
"columns": [
783
+
"name"
784
+
]
785
+
},
786
+
"sandboxes_uri_unique": {
787
+
"name": "sandboxes_uri_unique",
788
+
"nullsNotDistinct": false,
789
+
"columns": [
790
+
"uri"
791
+
]
792
+
},
793
+
"sandboxes_cid_unique": {
794
+
"name": "sandboxes_cid_unique",
795
+
"nullsNotDistinct": false,
796
+
"columns": [
797
+
"cid"
798
+
]
799
+
}
800
+
},
801
+
"policies": {},
802
+
"checkConstraints": {},
803
+
"isRLSEnabled": false
804
+
},
805
+
"public.secrets": {
806
+
"name": "secrets",
807
+
"schema": "",
808
+
"columns": {
809
+
"id": {
810
+
"name": "id",
811
+
"type": "text",
812
+
"primaryKey": true,
813
+
"notNull": true,
814
+
"default": "secret_id()"
815
+
},
816
+
"name": {
817
+
"name": "name",
818
+
"type": "text",
819
+
"primaryKey": false,
820
+
"notNull": true
821
+
},
822
+
"value": {
823
+
"name": "value",
824
+
"type": "text",
825
+
"primaryKey": false,
826
+
"notNull": true
827
+
},
828
+
"redacted": {
829
+
"name": "redacted",
830
+
"type": "text",
831
+
"primaryKey": false,
832
+
"notNull": false
833
+
},
834
+
"created_at": {
835
+
"name": "created_at",
836
+
"type": "timestamp",
837
+
"primaryKey": false,
838
+
"notNull": true,
839
+
"default": "now()"
840
+
}
841
+
},
842
+
"indexes": {},
843
+
"foreignKeys": {},
844
+
"compositePrimaryKeys": {},
845
+
"uniqueConstraints": {},
846
+
"policies": {},
847
+
"checkConstraints": {},
848
+
"isRLSEnabled": false
849
+
},
850
+
"public.snapshots": {
851
+
"name": "snapshots",
852
+
"schema": "",
853
+
"columns": {
854
+
"id": {
855
+
"name": "id",
856
+
"type": "text",
857
+
"primaryKey": true,
858
+
"notNull": true,
859
+
"default": "snapshot_id()"
860
+
},
861
+
"slug": {
862
+
"name": "slug",
863
+
"type": "text",
864
+
"primaryKey": false,
865
+
"notNull": true
866
+
},
867
+
"created_at": {
868
+
"name": "created_at",
869
+
"type": "timestamp",
870
+
"primaryKey": false,
871
+
"notNull": true,
872
+
"default": "now()"
873
+
}
874
+
},
875
+
"indexes": {},
876
+
"foreignKeys": {},
877
+
"compositePrimaryKeys": {},
878
+
"uniqueConstraints": {
879
+
"snapshots_slug_unique": {
880
+
"name": "snapshots_slug_unique",
881
+
"nullsNotDistinct": false,
882
+
"columns": [
883
+
"slug"
884
+
]
885
+
}
886
+
},
887
+
"policies": {},
888
+
"checkConstraints": {},
889
+
"isRLSEnabled": false
890
+
},
891
+
"public.ssh_keys": {
892
+
"name": "ssh_keys",
893
+
"schema": "",
894
+
"columns": {
895
+
"id": {
896
+
"name": "id",
897
+
"type": "text",
898
+
"primaryKey": true,
899
+
"notNull": true,
900
+
"default": "xata_id()"
901
+
},
902
+
"sandbox_id": {
903
+
"name": "sandbox_id",
904
+
"type": "text",
905
+
"primaryKey": false,
906
+
"notNull": true
907
+
},
908
+
"public_key": {
909
+
"name": "public_key",
910
+
"type": "text",
911
+
"primaryKey": false,
912
+
"notNull": true
913
+
},
914
+
"private_key": {
915
+
"name": "private_key",
916
+
"type": "text",
917
+
"primaryKey": false,
918
+
"notNull": true
919
+
},
920
+
"redacted": {
921
+
"name": "redacted",
922
+
"type": "text",
923
+
"primaryKey": false,
924
+
"notNull": false
925
+
},
926
+
"created_at": {
927
+
"name": "created_at",
928
+
"type": "timestamp",
929
+
"primaryKey": false,
930
+
"notNull": true,
931
+
"default": "now()"
932
+
}
933
+
},
934
+
"indexes": {
935
+
"unique_sandbox_ssh_key": {
936
+
"name": "unique_sandbox_ssh_key",
937
+
"columns": [
938
+
{
939
+
"expression": "public_key",
940
+
"isExpression": false,
941
+
"asc": true,
942
+
"nulls": "last"
943
+
},
944
+
{
945
+
"expression": "sandbox_id",
946
+
"isExpression": false,
947
+
"asc": true,
948
+
"nulls": "last"
949
+
}
950
+
],
951
+
"isUnique": true,
952
+
"concurrently": false,
953
+
"method": "btree",
954
+
"with": {}
955
+
}
956
+
},
957
+
"foreignKeys": {
958
+
"ssh_keys_sandbox_id_sandboxes_id_fk": {
959
+
"name": "ssh_keys_sandbox_id_sandboxes_id_fk",
960
+
"tableFrom": "ssh_keys",
961
+
"tableTo": "sandboxes",
962
+
"columnsFrom": [
963
+
"sandbox_id"
964
+
],
965
+
"columnsTo": [
966
+
"id"
967
+
],
968
+
"onDelete": "no action",
969
+
"onUpdate": "no action"
970
+
}
971
+
},
972
+
"compositePrimaryKeys": {},
973
+
"uniqueConstraints": {},
974
+
"policies": {},
975
+
"checkConstraints": {},
976
+
"isRLSEnabled": false
977
+
},
978
+
"public.tailscale_auth_keys": {
979
+
"name": "tailscale_auth_keys",
980
+
"schema": "",
981
+
"columns": {
982
+
"id": {
983
+
"name": "id",
984
+
"type": "text",
985
+
"primaryKey": true,
986
+
"notNull": true,
987
+
"default": "xata_id()"
988
+
},
989
+
"sandbox_id": {
990
+
"name": "sandbox_id",
991
+
"type": "text",
992
+
"primaryKey": false,
993
+
"notNull": true
994
+
},
995
+
"auth_key": {
996
+
"name": "auth_key",
997
+
"type": "text",
998
+
"primaryKey": false,
999
+
"notNull": true
1000
+
},
1001
+
"redacted": {
1002
+
"name": "redacted",
1003
+
"type": "text",
1004
+
"primaryKey": false,
1005
+
"notNull": true
1006
+
},
1007
+
"created_at": {
1008
+
"name": "created_at",
1009
+
"type": "timestamp",
1010
+
"primaryKey": false,
1011
+
"notNull": true,
1012
+
"default": "now()"
1013
+
}
1014
+
},
1015
+
"indexes": {},
1016
+
"foreignKeys": {
1017
+
"tailscale_auth_keys_sandbox_id_sandboxes_id_fk": {
1018
+
"name": "tailscale_auth_keys_sandbox_id_sandboxes_id_fk",
1019
+
"tableFrom": "tailscale_auth_keys",
1020
+
"tableTo": "sandboxes",
1021
+
"columnsFrom": [
1022
+
"sandbox_id"
1023
+
],
1024
+
"columnsTo": [
1025
+
"id"
1026
+
],
1027
+
"onDelete": "no action",
1028
+
"onUpdate": "no action"
1029
+
}
1030
+
},
1031
+
"compositePrimaryKeys": {},
1032
+
"uniqueConstraints": {},
1033
+
"policies": {},
1034
+
"checkConstraints": {},
1035
+
"isRLSEnabled": false
1036
+
},
1037
+
"public.users": {
1038
+
"name": "users",
1039
+
"schema": "",
1040
+
"columns": {
1041
+
"id": {
1042
+
"name": "id",
1043
+
"type": "text",
1044
+
"primaryKey": true,
1045
+
"notNull": true,
1046
+
"default": "xata_id()"
1047
+
},
1048
+
"did": {
1049
+
"name": "did",
1050
+
"type": "text",
1051
+
"primaryKey": false,
1052
+
"notNull": true
1053
+
},
1054
+
"display_name": {
1055
+
"name": "display_name",
1056
+
"type": "text",
1057
+
"primaryKey": false,
1058
+
"notNull": false
1059
+
},
1060
+
"handle": {
1061
+
"name": "handle",
1062
+
"type": "text",
1063
+
"primaryKey": false,
1064
+
"notNull": true
1065
+
},
1066
+
"avatar": {
1067
+
"name": "avatar",
1068
+
"type": "text",
1069
+
"primaryKey": false,
1070
+
"notNull": false
1071
+
},
1072
+
"created_at": {
1073
+
"name": "created_at",
1074
+
"type": "timestamp",
1075
+
"primaryKey": false,
1076
+
"notNull": true,
1077
+
"default": "now()"
1078
+
},
1079
+
"updated_at": {
1080
+
"name": "updated_at",
1081
+
"type": "timestamp",
1082
+
"primaryKey": false,
1083
+
"notNull": true,
1084
+
"default": "now()"
1085
+
}
1086
+
},
1087
+
"indexes": {},
1088
+
"foreignKeys": {},
1089
+
"compositePrimaryKeys": {},
1090
+
"uniqueConstraints": {
1091
+
"users_did_unique": {
1092
+
"name": "users_did_unique",
1093
+
"nullsNotDistinct": false,
1094
+
"columns": [
1095
+
"did"
1096
+
]
1097
+
},
1098
+
"users_handle_unique": {
1099
+
"name": "users_handle_unique",
1100
+
"nullsNotDistinct": false,
1101
+
"columns": [
1102
+
"handle"
1103
+
]
1104
+
}
1105
+
},
1106
+
"policies": {},
1107
+
"checkConstraints": {},
1108
+
"isRLSEnabled": false
1109
+
},
1110
+
"public.variables": {
1111
+
"name": "variables",
1112
+
"schema": "",
1113
+
"columns": {
1114
+
"id": {
1115
+
"name": "id",
1116
+
"type": "text",
1117
+
"primaryKey": true,
1118
+
"notNull": true,
1119
+
"default": "variable_id()"
1120
+
},
1121
+
"name": {
1122
+
"name": "name",
1123
+
"type": "text",
1124
+
"primaryKey": false,
1125
+
"notNull": true
1126
+
},
1127
+
"value": {
1128
+
"name": "value",
1129
+
"type": "text",
1130
+
"primaryKey": false,
1131
+
"notNull": true
1132
+
},
1133
+
"created_at": {
1134
+
"name": "created_at",
1135
+
"type": "timestamp",
1136
+
"primaryKey": false,
1137
+
"notNull": true,
1138
+
"default": "now()"
1139
+
},
1140
+
"updated_at": {
1141
+
"name": "updated_at",
1142
+
"type": "timestamp",
1143
+
"primaryKey": false,
1144
+
"notNull": true,
1145
+
"default": "now()"
1146
+
}
1147
+
},
1148
+
"indexes": {},
1149
+
"foreignKeys": {},
1150
+
"compositePrimaryKeys": {},
1151
+
"uniqueConstraints": {},
1152
+
"policies": {},
1153
+
"checkConstraints": {},
1154
+
"isRLSEnabled": false
1155
+
},
1156
+
"public.volumes": {
1157
+
"name": "volumes",
1158
+
"schema": "",
1159
+
"columns": {
1160
+
"id": {
1161
+
"name": "id",
1162
+
"type": "text",
1163
+
"primaryKey": true,
1164
+
"notNull": true,
1165
+
"default": "volume_id()"
1166
+
},
1167
+
"slug": {
1168
+
"name": "slug",
1169
+
"type": "text",
1170
+
"primaryKey": false,
1171
+
"notNull": true
1172
+
},
1173
+
"size": {
1174
+
"name": "size",
1175
+
"type": "integer",
1176
+
"primaryKey": false,
1177
+
"notNull": true
1178
+
},
1179
+
"size_unit": {
1180
+
"name": "size_unit",
1181
+
"type": "text",
1182
+
"primaryKey": false,
1183
+
"notNull": true
1184
+
},
1185
+
"created_at": {
1186
+
"name": "created_at",
1187
+
"type": "timestamp",
1188
+
"primaryKey": false,
1189
+
"notNull": true,
1190
+
"default": "now()"
1191
+
},
1192
+
"updated_at": {
1193
+
"name": "updated_at",
1194
+
"type": "timestamp",
1195
+
"primaryKey": false,
1196
+
"notNull": true,
1197
+
"default": "now()"
1198
+
}
1199
+
},
1200
+
"indexes": {},
1201
+
"foreignKeys": {},
1202
+
"compositePrimaryKeys": {},
1203
+
"uniqueConstraints": {
1204
+
"volumes_slug_unique": {
1205
+
"name": "volumes_slug_unique",
1206
+
"nullsNotDistinct": false,
1207
+
"columns": [
1208
+
"slug"
1209
+
]
1210
+
}
1211
+
},
1212
+
"policies": {},
1213
+
"checkConstraints": {},
1214
+
"isRLSEnabled": false
1215
+
},
1216
+
"public.integrations": {
1217
+
"name": "integrations",
1218
+
"schema": "",
1219
+
"columns": {
1220
+
"id": {
1221
+
"name": "id",
1222
+
"type": "text",
1223
+
"primaryKey": true,
1224
+
"notNull": true,
1225
+
"default": "xata_id()"
1226
+
},
1227
+
"sandbox_id": {
1228
+
"name": "sandbox_id",
1229
+
"type": "text",
1230
+
"primaryKey": false,
1231
+
"notNull": true
1232
+
},
1233
+
"name": {
1234
+
"name": "name",
1235
+
"type": "text",
1236
+
"primaryKey": false,
1237
+
"notNull": true
1238
+
},
1239
+
"description": {
1240
+
"name": "description",
1241
+
"type": "text",
1242
+
"primaryKey": false,
1243
+
"notNull": false
1244
+
},
1245
+
"webhook_url": {
1246
+
"name": "webhook_url",
1247
+
"type": "text",
1248
+
"primaryKey": false,
1249
+
"notNull": true
1250
+
},
1251
+
"created_at": {
1252
+
"name": "created_at",
1253
+
"type": "timestamp",
1254
+
"primaryKey": false,
1255
+
"notNull": true,
1256
+
"default": "now()"
1257
+
}
1258
+
},
1259
+
"indexes": {
1260
+
"unique_sandbox_integration": {
1261
+
"name": "unique_sandbox_integration",
1262
+
"columns": [
1263
+
{
1264
+
"expression": "sandbox_id",
1265
+
"isExpression": false,
1266
+
"asc": true,
1267
+
"nulls": "last"
1268
+
},
1269
+
{
1270
+
"expression": "name",
1271
+
"isExpression": false,
1272
+
"asc": true,
1273
+
"nulls": "last"
1274
+
}
1275
+
],
1276
+
"isUnique": true,
1277
+
"concurrently": false,
1278
+
"method": "btree",
1279
+
"with": {}
1280
+
}
1281
+
},
1282
+
"foreignKeys": {
1283
+
"integrations_sandbox_id_sandboxes_id_fk": {
1284
+
"name": "integrations_sandbox_id_sandboxes_id_fk",
1285
+
"tableFrom": "integrations",
1286
+
"tableTo": "sandboxes",
1287
+
"columnsFrom": [
1288
+
"sandbox_id"
1289
+
],
1290
+
"columnsTo": [
1291
+
"id"
1292
+
],
1293
+
"onDelete": "no action",
1294
+
"onUpdate": "no action"
1295
+
}
1296
+
},
1297
+
"compositePrimaryKeys": {},
1298
+
"uniqueConstraints": {},
1299
+
"policies": {},
1300
+
"checkConstraints": {},
1301
+
"isRLSEnabled": false
1302
+
}
1303
+
},
1304
+
"enums": {},
1305
+
"schemas": {},
1306
+
"sequences": {},
1307
+
"roles": {},
1308
+
"policies": {},
1309
+
"views": {},
1310
+
"_meta": {
1311
+
"columns": {},
1312
+
"schemas": {},
1313
+
"tables": {}
1314
+
}
1315
+
}
+1315
apps/cf-sandbox/drizzle/meta/0027_snapshot.json
+1315
apps/cf-sandbox/drizzle/meta/0027_snapshot.json
···
1
+
{
2
+
"id": "024d2a4f-c8a8-4c1d-acaf-5cc7ea758c7a",
3
+
"prevId": "6d5c52ad-5c37-408b-a30d-5c4c232c3e90",
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": "xata_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": {
146
+
"name": "unique_sandbox_file",
147
+
"columns": [
148
+
{
149
+
"expression": "sandbox_id",
150
+
"isExpression": false,
151
+
"asc": true,
152
+
"nulls": "last"
153
+
},
154
+
{
155
+
"expression": "file_id",
156
+
"isExpression": false,
157
+
"asc": true,
158
+
"nulls": "last"
159
+
}
160
+
],
161
+
"isUnique": true,
162
+
"concurrently": false,
163
+
"method": "btree",
164
+
"with": {}
165
+
},
166
+
"unique_sandbox_file_path": {
167
+
"name": "unique_sandbox_file_path",
168
+
"columns": [
169
+
{
170
+
"expression": "sandbox_id",
171
+
"isExpression": false,
172
+
"asc": true,
173
+
"nulls": "last"
174
+
},
175
+
{
176
+
"expression": "path",
177
+
"isExpression": false,
178
+
"asc": true,
179
+
"nulls": "last"
180
+
}
181
+
],
182
+
"isUnique": true,
183
+
"concurrently": false,
184
+
"method": "btree",
185
+
"with": {}
186
+
}
187
+
},
188
+
"foreignKeys": {
189
+
"sandbox_files_sandbox_id_sandboxes_id_fk": {
190
+
"name": "sandbox_files_sandbox_id_sandboxes_id_fk",
191
+
"tableFrom": "sandbox_files",
192
+
"tableTo": "sandboxes",
193
+
"columnsFrom": [
194
+
"sandbox_id"
195
+
],
196
+
"columnsTo": [
197
+
"id"
198
+
],
199
+
"onDelete": "no action",
200
+
"onUpdate": "no action"
201
+
},
202
+
"sandbox_files_file_id_files_id_fk": {
203
+
"name": "sandbox_files_file_id_files_id_fk",
204
+
"tableFrom": "sandbox_files",
205
+
"tableTo": "files",
206
+
"columnsFrom": [
207
+
"file_id"
208
+
],
209
+
"columnsTo": [
210
+
"id"
211
+
],
212
+
"onDelete": "no action",
213
+
"onUpdate": "no action"
214
+
}
215
+
},
216
+
"compositePrimaryKeys": {},
217
+
"uniqueConstraints": {},
218
+
"policies": {},
219
+
"checkConstraints": {},
220
+
"isRLSEnabled": false
221
+
},
222
+
"public.sandbox_secrets": {
223
+
"name": "sandbox_secrets",
224
+
"schema": "",
225
+
"columns": {
226
+
"id": {
227
+
"name": "id",
228
+
"type": "text",
229
+
"primaryKey": true,
230
+
"notNull": true,
231
+
"default": "xata_id()"
232
+
},
233
+
"sandbox_id": {
234
+
"name": "sandbox_id",
235
+
"type": "text",
236
+
"primaryKey": false,
237
+
"notNull": true
238
+
},
239
+
"secret_id": {
240
+
"name": "secret_id",
241
+
"type": "text",
242
+
"primaryKey": false,
243
+
"notNull": true
244
+
},
245
+
"name": {
246
+
"name": "name",
247
+
"type": "text",
248
+
"primaryKey": false,
249
+
"notNull": false
250
+
},
251
+
"created_at": {
252
+
"name": "created_at",
253
+
"type": "timestamp",
254
+
"primaryKey": false,
255
+
"notNull": true,
256
+
"default": "now()"
257
+
},
258
+
"updated_at": {
259
+
"name": "updated_at",
260
+
"type": "timestamp",
261
+
"primaryKey": false,
262
+
"notNull": true,
263
+
"default": "now()"
264
+
}
265
+
},
266
+
"indexes": {
267
+
"unique_sandbox_secret": {
268
+
"name": "unique_sandbox_secret",
269
+
"columns": [
270
+
{
271
+
"expression": "sandbox_id",
272
+
"isExpression": false,
273
+
"asc": true,
274
+
"nulls": "last"
275
+
},
276
+
{
277
+
"expression": "secret_id",
278
+
"isExpression": false,
279
+
"asc": true,
280
+
"nulls": "last"
281
+
}
282
+
],
283
+
"isUnique": true,
284
+
"concurrently": false,
285
+
"method": "btree",
286
+
"with": {}
287
+
},
288
+
"unique_sandbox_secret_by_name": {
289
+
"name": "unique_sandbox_secret_by_name",
290
+
"columns": [
291
+
{
292
+
"expression": "sandbox_id",
293
+
"isExpression": false,
294
+
"asc": true,
295
+
"nulls": "last"
296
+
},
297
+
{
298
+
"expression": "name",
299
+
"isExpression": false,
300
+
"asc": true,
301
+
"nulls": "last"
302
+
}
303
+
],
304
+
"isUnique": true,
305
+
"concurrently": false,
306
+
"method": "btree",
307
+
"with": {}
308
+
}
309
+
},
310
+
"foreignKeys": {
311
+
"sandbox_secrets_sandbox_id_sandboxes_id_fk": {
312
+
"name": "sandbox_secrets_sandbox_id_sandboxes_id_fk",
313
+
"tableFrom": "sandbox_secrets",
314
+
"tableTo": "sandboxes",
315
+
"columnsFrom": [
316
+
"sandbox_id"
317
+
],
318
+
"columnsTo": [
319
+
"id"
320
+
],
321
+
"onDelete": "no action",
322
+
"onUpdate": "no action"
323
+
},
324
+
"sandbox_secrets_secret_id_secrets_id_fk": {
325
+
"name": "sandbox_secrets_secret_id_secrets_id_fk",
326
+
"tableFrom": "sandbox_secrets",
327
+
"tableTo": "secrets",
328
+
"columnsFrom": [
329
+
"secret_id"
330
+
],
331
+
"columnsTo": [
332
+
"id"
333
+
],
334
+
"onDelete": "no action",
335
+
"onUpdate": "no action"
336
+
}
337
+
},
338
+
"compositePrimaryKeys": {},
339
+
"uniqueConstraints": {},
340
+
"policies": {},
341
+
"checkConstraints": {},
342
+
"isRLSEnabled": false
343
+
},
344
+
"public.sandbox_variables": {
345
+
"name": "sandbox_variables",
346
+
"schema": "",
347
+
"columns": {
348
+
"id": {
349
+
"name": "id",
350
+
"type": "text",
351
+
"primaryKey": true,
352
+
"notNull": true,
353
+
"default": "xata_id()"
354
+
},
355
+
"sandbox_id": {
356
+
"name": "sandbox_id",
357
+
"type": "text",
358
+
"primaryKey": false,
359
+
"notNull": true
360
+
},
361
+
"variable_id": {
362
+
"name": "variable_id",
363
+
"type": "text",
364
+
"primaryKey": false,
365
+
"notNull": true
366
+
},
367
+
"name": {
368
+
"name": "name",
369
+
"type": "text",
370
+
"primaryKey": false,
371
+
"notNull": true
372
+
},
373
+
"created_at": {
374
+
"name": "created_at",
375
+
"type": "timestamp",
376
+
"primaryKey": false,
377
+
"notNull": true,
378
+
"default": "now()"
379
+
},
380
+
"updated_at": {
381
+
"name": "updated_at",
382
+
"type": "timestamp",
383
+
"primaryKey": false,
384
+
"notNull": true,
385
+
"default": "now()"
386
+
}
387
+
},
388
+
"indexes": {
389
+
"unique_sandbox_variables": {
390
+
"name": "unique_sandbox_variables",
391
+
"columns": [
392
+
{
393
+
"expression": "sandbox_id",
394
+
"isExpression": false,
395
+
"asc": true,
396
+
"nulls": "last"
397
+
},
398
+
{
399
+
"expression": "variable_id",
400
+
"isExpression": false,
401
+
"asc": true,
402
+
"nulls": "last"
403
+
}
404
+
],
405
+
"isUnique": true,
406
+
"concurrently": false,
407
+
"method": "btree",
408
+
"with": {}
409
+
},
410
+
"unique_sandbox_variables_by_name": {
411
+
"name": "unique_sandbox_variables_by_name",
412
+
"columns": [
413
+
{
414
+
"expression": "sandbox_id",
415
+
"isExpression": false,
416
+
"asc": true,
417
+
"nulls": "last"
418
+
},
419
+
{
420
+
"expression": "name",
421
+
"isExpression": false,
422
+
"asc": true,
423
+
"nulls": "last"
424
+
}
425
+
],
426
+
"isUnique": true,
427
+
"concurrently": false,
428
+
"method": "btree",
429
+
"with": {}
430
+
}
431
+
},
432
+
"foreignKeys": {
433
+
"sandbox_variables_sandbox_id_sandboxes_id_fk": {
434
+
"name": "sandbox_variables_sandbox_id_sandboxes_id_fk",
435
+
"tableFrom": "sandbox_variables",
436
+
"tableTo": "sandboxes",
437
+
"columnsFrom": [
438
+
"sandbox_id"
439
+
],
440
+
"columnsTo": [
441
+
"id"
442
+
],
443
+
"onDelete": "no action",
444
+
"onUpdate": "no action"
445
+
},
446
+
"sandbox_variables_variable_id_variables_id_fk": {
447
+
"name": "sandbox_variables_variable_id_variables_id_fk",
448
+
"tableFrom": "sandbox_variables",
449
+
"tableTo": "variables",
450
+
"columnsFrom": [
451
+
"variable_id"
452
+
],
453
+
"columnsTo": [
454
+
"id"
455
+
],
456
+
"onDelete": "no action",
457
+
"onUpdate": "no action"
458
+
}
459
+
},
460
+
"compositePrimaryKeys": {},
461
+
"uniqueConstraints": {},
462
+
"policies": {},
463
+
"checkConstraints": {},
464
+
"isRLSEnabled": false
465
+
},
466
+
"public.sandbox_volumes": {
467
+
"name": "sandbox_volumes",
468
+
"schema": "",
469
+
"columns": {
470
+
"id": {
471
+
"name": "id",
472
+
"type": "text",
473
+
"primaryKey": true,
474
+
"notNull": true,
475
+
"default": "xata_id()"
476
+
},
477
+
"sandbox_id": {
478
+
"name": "sandbox_id",
479
+
"type": "text",
480
+
"primaryKey": false,
481
+
"notNull": true
482
+
},
483
+
"volume_id": {
484
+
"name": "volume_id",
485
+
"type": "text",
486
+
"primaryKey": false,
487
+
"notNull": true
488
+
},
489
+
"name": {
490
+
"name": "name",
491
+
"type": "text",
492
+
"primaryKey": false,
493
+
"notNull": false
494
+
},
495
+
"path": {
496
+
"name": "path",
497
+
"type": "text",
498
+
"primaryKey": false,
499
+
"notNull": true
500
+
},
501
+
"created_at": {
502
+
"name": "created_at",
503
+
"type": "timestamp",
504
+
"primaryKey": false,
505
+
"notNull": true,
506
+
"default": "now()"
507
+
},
508
+
"updated_at": {
509
+
"name": "updated_at",
510
+
"type": "timestamp",
511
+
"primaryKey": false,
512
+
"notNull": true,
513
+
"default": "now()"
514
+
}
515
+
},
516
+
"indexes": {
517
+
"unique_sandbox_volume": {
518
+
"name": "unique_sandbox_volume",
519
+
"columns": [
520
+
{
521
+
"expression": "sandbox_id",
522
+
"isExpression": false,
523
+
"asc": true,
524
+
"nulls": "last"
525
+
},
526
+
{
527
+
"expression": "volume_id",
528
+
"isExpression": false,
529
+
"asc": true,
530
+
"nulls": "last"
531
+
}
532
+
],
533
+
"isUnique": true,
534
+
"concurrently": false,
535
+
"method": "btree",
536
+
"with": {}
537
+
},
538
+
"unique_sandbox_volume_path": {
539
+
"name": "unique_sandbox_volume_path",
540
+
"columns": [
541
+
{
542
+
"expression": "sandbox_id",
543
+
"isExpression": false,
544
+
"asc": true,
545
+
"nulls": "last"
546
+
},
547
+
{
548
+
"expression": "path",
549
+
"isExpression": false,
550
+
"asc": true,
551
+
"nulls": "last"
552
+
}
553
+
],
554
+
"isUnique": true,
555
+
"concurrently": false,
556
+
"method": "btree",
557
+
"with": {}
558
+
}
559
+
},
560
+
"foreignKeys": {
561
+
"sandbox_volumes_sandbox_id_sandboxes_id_fk": {
562
+
"name": "sandbox_volumes_sandbox_id_sandboxes_id_fk",
563
+
"tableFrom": "sandbox_volumes",
564
+
"tableTo": "sandboxes",
565
+
"columnsFrom": [
566
+
"sandbox_id"
567
+
],
568
+
"columnsTo": [
569
+
"id"
570
+
],
571
+
"onDelete": "no action",
572
+
"onUpdate": "no action"
573
+
},
574
+
"sandbox_volumes_volume_id_volumes_id_fk": {
575
+
"name": "sandbox_volumes_volume_id_volumes_id_fk",
576
+
"tableFrom": "sandbox_volumes",
577
+
"tableTo": "volumes",
578
+
"columnsFrom": [
579
+
"volume_id"
580
+
],
581
+
"columnsTo": [
582
+
"id"
583
+
],
584
+
"onDelete": "no action",
585
+
"onUpdate": "no action"
586
+
}
587
+
},
588
+
"compositePrimaryKeys": {},
589
+
"uniqueConstraints": {},
590
+
"policies": {},
591
+
"checkConstraints": {},
592
+
"isRLSEnabled": false
593
+
},
594
+
"public.sandboxes": {
595
+
"name": "sandboxes",
596
+
"schema": "",
597
+
"columns": {
598
+
"id": {
599
+
"name": "id",
600
+
"type": "text",
601
+
"primaryKey": true,
602
+
"notNull": true,
603
+
"default": "sandbox_id()"
604
+
},
605
+
"base": {
606
+
"name": "base",
607
+
"type": "text",
608
+
"primaryKey": false,
609
+
"notNull": false
610
+
},
611
+
"name": {
612
+
"name": "name",
613
+
"type": "text",
614
+
"primaryKey": false,
615
+
"notNull": true
616
+
},
617
+
"display_name": {
618
+
"name": "display_name",
619
+
"type": "text",
620
+
"primaryKey": false,
621
+
"notNull": false
622
+
},
623
+
"uri": {
624
+
"name": "uri",
625
+
"type": "text",
626
+
"primaryKey": false,
627
+
"notNull": false
628
+
},
629
+
"cid": {
630
+
"name": "cid",
631
+
"type": "text",
632
+
"primaryKey": false,
633
+
"notNull": false
634
+
},
635
+
"repo": {
636
+
"name": "repo",
637
+
"type": "text",
638
+
"primaryKey": false,
639
+
"notNull": false
640
+
},
641
+
"provider": {
642
+
"name": "provider",
643
+
"type": "text",
644
+
"primaryKey": false,
645
+
"notNull": true,
646
+
"default": "'cloudflare'"
647
+
},
648
+
"description": {
649
+
"name": "description",
650
+
"type": "text",
651
+
"primaryKey": false,
652
+
"notNull": false
653
+
},
654
+
"topics": {
655
+
"name": "topics",
656
+
"type": "text[]",
657
+
"primaryKey": false,
658
+
"notNull": false
659
+
},
660
+
"logo": {
661
+
"name": "logo",
662
+
"type": "text",
663
+
"primaryKey": false,
664
+
"notNull": false
665
+
},
666
+
"readme": {
667
+
"name": "readme",
668
+
"type": "text",
669
+
"primaryKey": false,
670
+
"notNull": false
671
+
},
672
+
"public_key": {
673
+
"name": "public_key",
674
+
"type": "text",
675
+
"primaryKey": false,
676
+
"notNull": true
677
+
},
678
+
"user_id": {
679
+
"name": "user_id",
680
+
"type": "text",
681
+
"primaryKey": false,
682
+
"notNull": false
683
+
},
684
+
"instance_type": {
685
+
"name": "instance_type",
686
+
"type": "text",
687
+
"primaryKey": false,
688
+
"notNull": false
689
+
},
690
+
"vcpus": {
691
+
"name": "vcpus",
692
+
"type": "integer",
693
+
"primaryKey": false,
694
+
"notNull": false
695
+
},
696
+
"memory": {
697
+
"name": "memory",
698
+
"type": "integer",
699
+
"primaryKey": false,
700
+
"notNull": false
701
+
},
702
+
"disk": {
703
+
"name": "disk",
704
+
"type": "integer",
705
+
"primaryKey": false,
706
+
"notNull": false
707
+
},
708
+
"status": {
709
+
"name": "status",
710
+
"type": "text",
711
+
"primaryKey": false,
712
+
"notNull": true
713
+
},
714
+
"keep_alive": {
715
+
"name": "keep_alive",
716
+
"type": "boolean",
717
+
"primaryKey": false,
718
+
"notNull": true,
719
+
"default": false
720
+
},
721
+
"sleep_after": {
722
+
"name": "sleep_after",
723
+
"type": "text",
724
+
"primaryKey": false,
725
+
"notNull": false
726
+
},
727
+
"sandbox_id": {
728
+
"name": "sandbox_id",
729
+
"type": "text",
730
+
"primaryKey": false,
731
+
"notNull": false
732
+
},
733
+
"installs": {
734
+
"name": "installs",
735
+
"type": "integer",
736
+
"primaryKey": false,
737
+
"notNull": true,
738
+
"default": 0
739
+
},
740
+
"started_at": {
741
+
"name": "started_at",
742
+
"type": "timestamp",
743
+
"primaryKey": false,
744
+
"notNull": false
745
+
},
746
+
"created_at": {
747
+
"name": "created_at",
748
+
"type": "timestamp",
749
+
"primaryKey": false,
750
+
"notNull": true,
751
+
"default": "now()"
752
+
},
753
+
"updated_at": {
754
+
"name": "updated_at",
755
+
"type": "timestamp",
756
+
"primaryKey": false,
757
+
"notNull": true,
758
+
"default": "now()"
759
+
}
760
+
},
761
+
"indexes": {},
762
+
"foreignKeys": {
763
+
"sandboxes_user_id_users_id_fk": {
764
+
"name": "sandboxes_user_id_users_id_fk",
765
+
"tableFrom": "sandboxes",
766
+
"tableTo": "users",
767
+
"columnsFrom": [
768
+
"user_id"
769
+
],
770
+
"columnsTo": [
771
+
"id"
772
+
],
773
+
"onDelete": "no action",
774
+
"onUpdate": "no action"
775
+
}
776
+
},
777
+
"compositePrimaryKeys": {},
778
+
"uniqueConstraints": {
779
+
"sandboxes_name_unique": {
780
+
"name": "sandboxes_name_unique",
781
+
"nullsNotDistinct": false,
782
+
"columns": [
783
+
"name"
784
+
]
785
+
},
786
+
"sandboxes_uri_unique": {
787
+
"name": "sandboxes_uri_unique",
788
+
"nullsNotDistinct": false,
789
+
"columns": [
790
+
"uri"
791
+
]
792
+
},
793
+
"sandboxes_cid_unique": {
794
+
"name": "sandboxes_cid_unique",
795
+
"nullsNotDistinct": false,
796
+
"columns": [
797
+
"cid"
798
+
]
799
+
}
800
+
},
801
+
"policies": {},
802
+
"checkConstraints": {},
803
+
"isRLSEnabled": false
804
+
},
805
+
"public.secrets": {
806
+
"name": "secrets",
807
+
"schema": "",
808
+
"columns": {
809
+
"id": {
810
+
"name": "id",
811
+
"type": "text",
812
+
"primaryKey": true,
813
+
"notNull": true,
814
+
"default": "secret_id()"
815
+
},
816
+
"name": {
817
+
"name": "name",
818
+
"type": "text",
819
+
"primaryKey": false,
820
+
"notNull": true
821
+
},
822
+
"value": {
823
+
"name": "value",
824
+
"type": "text",
825
+
"primaryKey": false,
826
+
"notNull": true
827
+
},
828
+
"redacted": {
829
+
"name": "redacted",
830
+
"type": "text",
831
+
"primaryKey": false,
832
+
"notNull": false
833
+
},
834
+
"created_at": {
835
+
"name": "created_at",
836
+
"type": "timestamp",
837
+
"primaryKey": false,
838
+
"notNull": true,
839
+
"default": "now()"
840
+
}
841
+
},
842
+
"indexes": {},
843
+
"foreignKeys": {},
844
+
"compositePrimaryKeys": {},
845
+
"uniqueConstraints": {},
846
+
"policies": {},
847
+
"checkConstraints": {},
848
+
"isRLSEnabled": false
849
+
},
850
+
"public.snapshots": {
851
+
"name": "snapshots",
852
+
"schema": "",
853
+
"columns": {
854
+
"id": {
855
+
"name": "id",
856
+
"type": "text",
857
+
"primaryKey": true,
858
+
"notNull": true,
859
+
"default": "snapshot_id()"
860
+
},
861
+
"slug": {
862
+
"name": "slug",
863
+
"type": "text",
864
+
"primaryKey": false,
865
+
"notNull": true
866
+
},
867
+
"created_at": {
868
+
"name": "created_at",
869
+
"type": "timestamp",
870
+
"primaryKey": false,
871
+
"notNull": true,
872
+
"default": "now()"
873
+
}
874
+
},
875
+
"indexes": {},
876
+
"foreignKeys": {},
877
+
"compositePrimaryKeys": {},
878
+
"uniqueConstraints": {
879
+
"snapshots_slug_unique": {
880
+
"name": "snapshots_slug_unique",
881
+
"nullsNotDistinct": false,
882
+
"columns": [
883
+
"slug"
884
+
]
885
+
}
886
+
},
887
+
"policies": {},
888
+
"checkConstraints": {},
889
+
"isRLSEnabled": false
890
+
},
891
+
"public.ssh_keys": {
892
+
"name": "ssh_keys",
893
+
"schema": "",
894
+
"columns": {
895
+
"id": {
896
+
"name": "id",
897
+
"type": "text",
898
+
"primaryKey": true,
899
+
"notNull": true,
900
+
"default": "xata_id()"
901
+
},
902
+
"sandbox_id": {
903
+
"name": "sandbox_id",
904
+
"type": "text",
905
+
"primaryKey": false,
906
+
"notNull": true
907
+
},
908
+
"public_key": {
909
+
"name": "public_key",
910
+
"type": "text",
911
+
"primaryKey": false,
912
+
"notNull": true
913
+
},
914
+
"private_key": {
915
+
"name": "private_key",
916
+
"type": "text",
917
+
"primaryKey": false,
918
+
"notNull": true
919
+
},
920
+
"redacted": {
921
+
"name": "redacted",
922
+
"type": "text",
923
+
"primaryKey": false,
924
+
"notNull": false
925
+
},
926
+
"created_at": {
927
+
"name": "created_at",
928
+
"type": "timestamp",
929
+
"primaryKey": false,
930
+
"notNull": true,
931
+
"default": "now()"
932
+
}
933
+
},
934
+
"indexes": {
935
+
"unique_sandbox_ssh_key": {
936
+
"name": "unique_sandbox_ssh_key",
937
+
"columns": [
938
+
{
939
+
"expression": "public_key",
940
+
"isExpression": false,
941
+
"asc": true,
942
+
"nulls": "last"
943
+
},
944
+
{
945
+
"expression": "sandbox_id",
946
+
"isExpression": false,
947
+
"asc": true,
948
+
"nulls": "last"
949
+
}
950
+
],
951
+
"isUnique": true,
952
+
"concurrently": false,
953
+
"method": "btree",
954
+
"with": {}
955
+
}
956
+
},
957
+
"foreignKeys": {
958
+
"ssh_keys_sandbox_id_sandboxes_id_fk": {
959
+
"name": "ssh_keys_sandbox_id_sandboxes_id_fk",
960
+
"tableFrom": "ssh_keys",
961
+
"tableTo": "sandboxes",
962
+
"columnsFrom": [
963
+
"sandbox_id"
964
+
],
965
+
"columnsTo": [
966
+
"id"
967
+
],
968
+
"onDelete": "no action",
969
+
"onUpdate": "no action"
970
+
}
971
+
},
972
+
"compositePrimaryKeys": {},
973
+
"uniqueConstraints": {},
974
+
"policies": {},
975
+
"checkConstraints": {},
976
+
"isRLSEnabled": false
977
+
},
978
+
"public.tailscale_auth_keys": {
979
+
"name": "tailscale_auth_keys",
980
+
"schema": "",
981
+
"columns": {
982
+
"id": {
983
+
"name": "id",
984
+
"type": "text",
985
+
"primaryKey": true,
986
+
"notNull": true,
987
+
"default": "xata_id()"
988
+
},
989
+
"sandbox_id": {
990
+
"name": "sandbox_id",
991
+
"type": "text",
992
+
"primaryKey": false,
993
+
"notNull": true
994
+
},
995
+
"auth_key": {
996
+
"name": "auth_key",
997
+
"type": "text",
998
+
"primaryKey": false,
999
+
"notNull": true
1000
+
},
1001
+
"redacted": {
1002
+
"name": "redacted",
1003
+
"type": "text",
1004
+
"primaryKey": false,
1005
+
"notNull": true
1006
+
},
1007
+
"created_at": {
1008
+
"name": "created_at",
1009
+
"type": "timestamp",
1010
+
"primaryKey": false,
1011
+
"notNull": true,
1012
+
"default": "now()"
1013
+
}
1014
+
},
1015
+
"indexes": {},
1016
+
"foreignKeys": {
1017
+
"tailscale_auth_keys_sandbox_id_sandboxes_id_fk": {
1018
+
"name": "tailscale_auth_keys_sandbox_id_sandboxes_id_fk",
1019
+
"tableFrom": "tailscale_auth_keys",
1020
+
"tableTo": "sandboxes",
1021
+
"columnsFrom": [
1022
+
"sandbox_id"
1023
+
],
1024
+
"columnsTo": [
1025
+
"id"
1026
+
],
1027
+
"onDelete": "no action",
1028
+
"onUpdate": "no action"
1029
+
}
1030
+
},
1031
+
"compositePrimaryKeys": {},
1032
+
"uniqueConstraints": {},
1033
+
"policies": {},
1034
+
"checkConstraints": {},
1035
+
"isRLSEnabled": false
1036
+
},
1037
+
"public.users": {
1038
+
"name": "users",
1039
+
"schema": "",
1040
+
"columns": {
1041
+
"id": {
1042
+
"name": "id",
1043
+
"type": "text",
1044
+
"primaryKey": true,
1045
+
"notNull": true,
1046
+
"default": "xata_id()"
1047
+
},
1048
+
"did": {
1049
+
"name": "did",
1050
+
"type": "text",
1051
+
"primaryKey": false,
1052
+
"notNull": true
1053
+
},
1054
+
"display_name": {
1055
+
"name": "display_name",
1056
+
"type": "text",
1057
+
"primaryKey": false,
1058
+
"notNull": false
1059
+
},
1060
+
"handle": {
1061
+
"name": "handle",
1062
+
"type": "text",
1063
+
"primaryKey": false,
1064
+
"notNull": true
1065
+
},
1066
+
"avatar": {
1067
+
"name": "avatar",
1068
+
"type": "text",
1069
+
"primaryKey": false,
1070
+
"notNull": false
1071
+
},
1072
+
"created_at": {
1073
+
"name": "created_at",
1074
+
"type": "timestamp",
1075
+
"primaryKey": false,
1076
+
"notNull": true,
1077
+
"default": "now()"
1078
+
},
1079
+
"updated_at": {
1080
+
"name": "updated_at",
1081
+
"type": "timestamp",
1082
+
"primaryKey": false,
1083
+
"notNull": true,
1084
+
"default": "now()"
1085
+
}
1086
+
},
1087
+
"indexes": {},
1088
+
"foreignKeys": {},
1089
+
"compositePrimaryKeys": {},
1090
+
"uniqueConstraints": {
1091
+
"users_did_unique": {
1092
+
"name": "users_did_unique",
1093
+
"nullsNotDistinct": false,
1094
+
"columns": [
1095
+
"did"
1096
+
]
1097
+
},
1098
+
"users_handle_unique": {
1099
+
"name": "users_handle_unique",
1100
+
"nullsNotDistinct": false,
1101
+
"columns": [
1102
+
"handle"
1103
+
]
1104
+
}
1105
+
},
1106
+
"policies": {},
1107
+
"checkConstraints": {},
1108
+
"isRLSEnabled": false
1109
+
},
1110
+
"public.variables": {
1111
+
"name": "variables",
1112
+
"schema": "",
1113
+
"columns": {
1114
+
"id": {
1115
+
"name": "id",
1116
+
"type": "text",
1117
+
"primaryKey": true,
1118
+
"notNull": true,
1119
+
"default": "variable_id()"
1120
+
},
1121
+
"name": {
1122
+
"name": "name",
1123
+
"type": "text",
1124
+
"primaryKey": false,
1125
+
"notNull": true
1126
+
},
1127
+
"value": {
1128
+
"name": "value",
1129
+
"type": "text",
1130
+
"primaryKey": false,
1131
+
"notNull": true
1132
+
},
1133
+
"created_at": {
1134
+
"name": "created_at",
1135
+
"type": "timestamp",
1136
+
"primaryKey": false,
1137
+
"notNull": true,
1138
+
"default": "now()"
1139
+
},
1140
+
"updated_at": {
1141
+
"name": "updated_at",
1142
+
"type": "timestamp",
1143
+
"primaryKey": false,
1144
+
"notNull": true,
1145
+
"default": "now()"
1146
+
}
1147
+
},
1148
+
"indexes": {},
1149
+
"foreignKeys": {},
1150
+
"compositePrimaryKeys": {},
1151
+
"uniqueConstraints": {},
1152
+
"policies": {},
1153
+
"checkConstraints": {},
1154
+
"isRLSEnabled": false
1155
+
},
1156
+
"public.volumes": {
1157
+
"name": "volumes",
1158
+
"schema": "",
1159
+
"columns": {
1160
+
"id": {
1161
+
"name": "id",
1162
+
"type": "text",
1163
+
"primaryKey": true,
1164
+
"notNull": true,
1165
+
"default": "volume_id()"
1166
+
},
1167
+
"slug": {
1168
+
"name": "slug",
1169
+
"type": "text",
1170
+
"primaryKey": false,
1171
+
"notNull": true
1172
+
},
1173
+
"size": {
1174
+
"name": "size",
1175
+
"type": "integer",
1176
+
"primaryKey": false,
1177
+
"notNull": true
1178
+
},
1179
+
"size_unit": {
1180
+
"name": "size_unit",
1181
+
"type": "text",
1182
+
"primaryKey": false,
1183
+
"notNull": true
1184
+
},
1185
+
"created_at": {
1186
+
"name": "created_at",
1187
+
"type": "timestamp",
1188
+
"primaryKey": false,
1189
+
"notNull": true,
1190
+
"default": "now()"
1191
+
},
1192
+
"updated_at": {
1193
+
"name": "updated_at",
1194
+
"type": "timestamp",
1195
+
"primaryKey": false,
1196
+
"notNull": true,
1197
+
"default": "now()"
1198
+
}
1199
+
},
1200
+
"indexes": {},
1201
+
"foreignKeys": {},
1202
+
"compositePrimaryKeys": {},
1203
+
"uniqueConstraints": {
1204
+
"volumes_slug_unique": {
1205
+
"name": "volumes_slug_unique",
1206
+
"nullsNotDistinct": false,
1207
+
"columns": [
1208
+
"slug"
1209
+
]
1210
+
}
1211
+
},
1212
+
"policies": {},
1213
+
"checkConstraints": {},
1214
+
"isRLSEnabled": false
1215
+
},
1216
+
"public.integrations": {
1217
+
"name": "integrations",
1218
+
"schema": "",
1219
+
"columns": {
1220
+
"id": {
1221
+
"name": "id",
1222
+
"type": "text",
1223
+
"primaryKey": true,
1224
+
"notNull": true,
1225
+
"default": "xata_id()"
1226
+
},
1227
+
"sandbox_id": {
1228
+
"name": "sandbox_id",
1229
+
"type": "text",
1230
+
"primaryKey": false,
1231
+
"notNull": true
1232
+
},
1233
+
"name": {
1234
+
"name": "name",
1235
+
"type": "text",
1236
+
"primaryKey": false,
1237
+
"notNull": true
1238
+
},
1239
+
"description": {
1240
+
"name": "description",
1241
+
"type": "text",
1242
+
"primaryKey": false,
1243
+
"notNull": false
1244
+
},
1245
+
"webhook_url": {
1246
+
"name": "webhook_url",
1247
+
"type": "text",
1248
+
"primaryKey": false,
1249
+
"notNull": true
1250
+
},
1251
+
"created_at": {
1252
+
"name": "created_at",
1253
+
"type": "timestamp",
1254
+
"primaryKey": false,
1255
+
"notNull": true,
1256
+
"default": "now()"
1257
+
}
1258
+
},
1259
+
"indexes": {
1260
+
"unique_sandbox_integration": {
1261
+
"name": "unique_sandbox_integration",
1262
+
"columns": [
1263
+
{
1264
+
"expression": "sandbox_id",
1265
+
"isExpression": false,
1266
+
"asc": true,
1267
+
"nulls": "last"
1268
+
},
1269
+
{
1270
+
"expression": "name",
1271
+
"isExpression": false,
1272
+
"asc": true,
1273
+
"nulls": "last"
1274
+
}
1275
+
],
1276
+
"isUnique": true,
1277
+
"concurrently": false,
1278
+
"method": "btree",
1279
+
"with": {}
1280
+
}
1281
+
},
1282
+
"foreignKeys": {
1283
+
"integrations_sandbox_id_sandboxes_id_fk": {
1284
+
"name": "integrations_sandbox_id_sandboxes_id_fk",
1285
+
"tableFrom": "integrations",
1286
+
"tableTo": "sandboxes",
1287
+
"columnsFrom": [
1288
+
"sandbox_id"
1289
+
],
1290
+
"columnsTo": [
1291
+
"id"
1292
+
],
1293
+
"onDelete": "no action",
1294
+
"onUpdate": "no action"
1295
+
}
1296
+
},
1297
+
"compositePrimaryKeys": {},
1298
+
"uniqueConstraints": {},
1299
+
"policies": {},
1300
+
"checkConstraints": {},
1301
+
"isRLSEnabled": false
1302
+
}
1303
+
},
1304
+
"enums": {},
1305
+
"schemas": {},
1306
+
"sequences": {},
1307
+
"roles": {},
1308
+
"policies": {},
1309
+
"views": {},
1310
+
"_meta": {
1311
+
"columns": {},
1312
+
"schemas": {},
1313
+
"tables": {}
1314
+
}
1315
+
}
+14
apps/cf-sandbox/drizzle/meta/_journal.json
+14
apps/cf-sandbox/drizzle/meta/_journal.json
···
183
183
"when": 1773219945973,
184
184
"tag": "0025_worthless_old_lace",
185
185
"breakpoints": true
186
+
},
187
+
{
188
+
"idx": 26,
189
+
"version": "7",
190
+
"when": 1773258025287,
191
+
"tag": "0026_known_blue_blade",
192
+
"breakpoints": true
193
+
},
194
+
{
195
+
"idx": 27,
196
+
"version": "7",
197
+
"when": 1773258112498,
198
+
"tag": "0027_cooing_rattler",
199
+
"breakpoints": true
186
200
}
187
201
]
188
202
}
+1
-1
apps/cf-sandbox/src/schema/files.ts
+1
-1
apps/cf-sandbox/src/schema/files.ts
···
4
4
const files = pgTable("files", {
5
5
id: text("id")
6
6
.primaryKey()
7
-
.default(sql`variable_id()`),
7
+
.default(sql`xata_id()`),
8
8
content: text("content").notNull(),
9
9
createdAt: timestamp("created_at").defaultNow().notNull(),
10
10
updatedAt: timestamp("updated_at").defaultNow().notNull(),
+1
-1
apps/sandbox/src/schema/files.ts
+1
-1
apps/sandbox/src/schema/files.ts
···
4
4
const files = pgTable("files", {
5
5
id: text("id")
6
6
.primaryKey()
7
-
.default(sql`variable_id()`),
7
+
.default(sql`xata_id()`),
8
8
content: text("content").notNull(),
9
9
createdAt: timestamp("created_at").defaultNow().notNull(),
10
10
updatedAt: timestamp("updated_at").defaultNow().notNull(),
+17
-2
apps/web/src/api/file.ts
+17
-2
apps/web/src/api/file.ts
···
19
19
);
20
20
21
21
export const deleteFile = (id: string) =>
22
-
client.post(`/xrpc/io.pocketenv.file.deleteFile?id=${id}`, undefined, {
22
+
client.post(`/xrpc/io.pocketenv.file.deleteFile`, undefined, {
23
+
params: {
24
+
id,
25
+
},
23
26
headers: {
24
27
Authorization: `Bearer ${localStorage.getItem("token")}`,
25
28
},
···
27
30
28
31
export const getFiles = (sandboxId?: string, offset?: number, limit?: number) =>
29
32
client.get<{ files: File[]; total: number }>(
30
-
`/xrpc/io.pocketenv.file.getFiles${sandboxId ? `?sandboxId=${sandboxId}` : ""}&offset=${offset ?? 0}&limit=${limit ?? 30}`,
33
+
`/xrpc/io.pocketenv.file.getFiles`,
31
34
{
35
+
params: {
36
+
sandboxId,
37
+
offset: offset ?? 0,
38
+
limit: limit ?? 30,
39
+
},
32
40
headers: {
33
41
Authorization: `Bearer ${localStorage.getItem("token")}`,
34
42
},
35
43
},
36
44
);
45
+
46
+
export const getFile = (id: string) =>
47
+
client.get<{ file: File }>(`/xrpc/io.pocketenv.file.getFile?id=${id}`, {
48
+
headers: {
49
+
Authorization: `Bearer ${localStorage.getItem("token")}`,
50
+
},
51
+
});
+14
-1
apps/web/src/api/secret.ts
+14
-1
apps/web/src/api/secret.ts
···
19
19
);
20
20
21
21
export const deleteSecret = (id: string) =>
22
-
client.post(`/xrpc/io.pocketenv.secret.deleteSecret?id=${id}`, undefined, {
22
+
client.post(`/xrpc/io.pocketenv.secret.deleteSecret`, undefined, {
23
+
params: {
24
+
id,
25
+
},
23
26
headers: {
24
27
Authorization: `Bearer ${localStorage.getItem("token")}`,
25
28
},
···
38
41
},
39
42
},
40
43
);
44
+
45
+
export const getSecret = (id: string) =>
46
+
client.get<{ secret: Secret }>(`/xrpc/io.pocketenv.secret.getSecret`, {
47
+
params: {
48
+
id,
49
+
},
50
+
headers: {
51
+
Authorization: `Bearer ${localStorage.getItem("token")}`,
52
+
},
53
+
});
+26
-9
apps/web/src/api/variable.ts
+26
-9
apps/web/src/api/variable.ts
···
19
19
);
20
20
21
21
export const deleteVariable = (id: string) =>
22
-
client.post(
23
-
`/xrpc/io.pocketenv.variable.deleteVariable?id=${id}`,
24
-
undefined,
25
-
{
26
-
headers: {
27
-
Authorization: `Bearer ${localStorage.getItem("token")}`,
28
-
},
22
+
client.post(`/xrpc/io.pocketenv.variable.deleteVariable`, undefined, {
23
+
params: {
24
+
id,
29
25
},
30
-
);
26
+
headers: {
27
+
Authorization: `Bearer ${localStorage.getItem("token")}`,
28
+
},
29
+
});
31
30
32
31
export const getVariables = (
33
32
sandboxId?: string,
···
35
34
limit?: number,
36
35
) =>
37
36
client.get<{ variables: Variable[]; total: number }>(
38
-
`/xrpc/io.pocketenv.variable.getVariables${sandboxId ? `?sandboxId=${sandboxId}` : ""}&offset=${offset ?? 0}&limit=${limit ?? 30}`,
37
+
`/xrpc/io.pocketenv.variable.getVariables`,
38
+
{
39
+
params: {
40
+
sandboxId,
41
+
offset: offset ?? 0,
42
+
limit: limit ?? 30,
43
+
},
44
+
headers: {
45
+
Authorization: `Bearer ${localStorage.getItem("token")}`,
46
+
},
47
+
},
48
+
);
49
+
50
+
export const getVariable = (id: string) =>
51
+
client.get<{ variable: Variable }>(
52
+
`/xrpc/io.pocketenv.variable.getVariable`,
39
53
{
54
+
params: {
55
+
id,
56
+
},
40
57
headers: {
41
58
Authorization: `Bearer ${localStorage.getItem("token")}`,
42
59
},
+20
-2
apps/web/src/api/volume.ts
+20
-2
apps/web/src/api/volume.ts
···
19
19
);
20
20
21
21
export const deleteVolume = (id: string) =>
22
-
client.post(`/xrpc/io.pocketenv.volume.deleteVolume?id=${id}`, undefined, {
22
+
client.post(`/xrpc/io.pocketenv.volume.deleteVolume`, undefined, {
23
+
params: {
24
+
id,
25
+
},
23
26
headers: {
24
27
Authorization: `Bearer ${localStorage.getItem("token")}`,
25
28
},
···
31
34
limit?: number,
32
35
) =>
33
36
client.get<{ volumes: Volume[]; total: number }>(
34
-
`/xrpc/io.pocketenv.volume.getVolumes${sandboxId ? `?sandboxId=${sandboxId}` : ""}&offset=${offset ?? 0}&limit=${limit ?? 30}`,
37
+
`/xrpc/io.pocketenv.volume.getVolumes`,
35
38
{
39
+
params: {
40
+
sandboxId,
41
+
offset: offset ?? 0,
42
+
limit: limit ?? 30,
43
+
},
36
44
headers: {
37
45
Authorization: `Bearer ${localStorage.getItem("token")}`,
38
46
},
39
47
},
40
48
);
49
+
50
+
export const getVolume = (id: string) =>
51
+
client.get<{ volume: Volume }>(`/xrpc/io.pocketenv.volume.getVolume`, {
52
+
params: {
53
+
id,
54
+
},
55
+
headers: {
56
+
Authorization: `Bearer ${localStorage.getItem("token")}`,
57
+
},
58
+
});
+6
-1
apps/web/src/components/confirmdelete/ConfirmDelete.tsx
+6
-1
apps/web/src/components/confirmdelete/ConfirmDelete.tsx
···
7
7
onConfirm: () => Promise<void>;
8
8
subject: string;
9
9
title?: string;
10
+
subjectId?: string;
10
11
};
11
12
12
13
function ConfirmDeleteModal({
···
15
16
onConfirm,
16
17
subject,
17
18
title,
19
+
subjectId,
18
20
}: ConfirmDeleteModalProps) {
19
21
const [isLoading, setIsLoading] = useState(false);
20
22
useEffect(() => {
···
87
89
<p className="font-semibold text-center">
88
90
Are you sure you want to delete this {subject}?
89
91
</p>
90
-
<p className="text-center ">This action cannot be undone.</p>
92
+
<p className="text-center">This action cannot be undone.</p>
93
+
{subjectId && (
94
+
<p className="font-semibold text-center">'{subjectId}'</p>
95
+
)}
91
96
</div>
92
97
<div className="modal-footer">
93
98
<button
+9
-1
apps/web/src/hooks/useFile.ts
+9
-1
apps/web/src/hooks/useFile.ts
···
1
1
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
2
-
import { addFile, deleteFile, getFiles } from "../api/file";
2
+
import { addFile, deleteFile, getFile, getFiles } from "../api/file";
3
3
4
4
export const useAddFileMutation = () => {
5
5
const queryClient = useQueryClient();
···
41
41
queryFn: () => getFiles(sandboxId, offset, limit),
42
42
select: (response) => response.data,
43
43
});
44
+
45
+
export const useFileQuery = (id: string) =>
46
+
useQuery({
47
+
queryKey: ["file", id],
48
+
queryFn: () => getFile(id),
49
+
select: (response) => response.data,
50
+
enabled: !!id,
51
+
});
+9
-1
apps/web/src/hooks/useSecret.ts
+9
-1
apps/web/src/hooks/useSecret.ts
···
1
1
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
2
-
import { addSecret, deleteSecret, getSecrets } from "../api/secret";
2
+
import { addSecret, deleteSecret, getSecret, getSecrets } from "../api/secret";
3
3
4
4
export const useAddSecretMutation = () => {
5
5
const queryClient = useQueryClient();
···
41
41
queryFn: () => getSecrets(sandboxId, offset, limit),
42
42
select: (response) => response.data,
43
43
});
44
+
45
+
export const useSecretQuery = (id: string) =>
46
+
useQuery({
47
+
queryKey: ["secret", id],
48
+
queryFn: () => getSecret(id),
49
+
select: (response) => response.data,
50
+
enabled: !!id,
51
+
});
+16
-3
apps/web/src/hooks/useVariable.ts
+16
-3
apps/web/src/hooks/useVariable.ts
···
1
1
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
2
-
import { addVariable, deleteVariable, getVariables } from "../api/variable";
2
+
import {
3
+
addVariable,
4
+
deleteVariable,
5
+
getVariable,
6
+
getVariables,
7
+
} from "../api/variable";
3
8
4
9
export const useAddVariableMutation = () => {
5
10
const queryClient = useQueryClient();
···
20
25
});
21
26
};
22
27
23
-
export const useDeleteVariableMutation = (id: string) => {
28
+
export const useDeleteVariableMutation = () => {
24
29
const queryClient = useQueryClient();
25
30
return useMutation({
26
31
mutationKey: ["deleteVariable"],
27
-
mutationFn: async () => deleteVariable(id),
32
+
mutationFn: async (id: string) => deleteVariable(id),
28
33
onSuccess: () => {
29
34
queryClient.invalidateQueries({ queryKey: ["variables"] });
30
35
},
···
41
46
queryFn: async () => getVariables(sandboxId, offset, limit),
42
47
select: (response) => response.data,
43
48
});
49
+
50
+
export const useVariableQuery = (id: string) =>
51
+
useQuery({
52
+
queryKey: ["variable", id],
53
+
queryFn: () => getVariable(id),
54
+
select: (response) => response.data,
55
+
enabled: !!id,
56
+
});
+9
-1
apps/web/src/hooks/useVolume.ts
+9
-1
apps/web/src/hooks/useVolume.ts
···
1
1
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
2
-
import { addVolume, deleteVolume, getVolumes } from "../api/volume";
2
+
import { addVolume, deleteVolume, getVolume, getVolumes } from "../api/volume";
3
3
4
4
export const useAddVolumeMutation = () => {
5
5
const queryClient = useQueryClient();
···
39
39
queryFn: async () => getVolumes(sandboxId, offset, limit),
40
40
select: (response) => response.data,
41
41
});
42
+
43
+
export const useVolumeQuery = (id: string) =>
44
+
useQuery({
45
+
queryKey: ["volume", id],
46
+
queryFn: () => getVolume(id),
47
+
select: (response) => response.data,
48
+
enabled: !!id,
49
+
});
+17
-3
apps/web/src/pages/settings/files/Files.tsx
+17
-3
apps/web/src/pages/settings/files/Files.tsx
···
5
5
import Sidebar from "../sidebar/Sidebar";
6
6
import AddFileModal from "../../../components/contextmenu/AddFileModal";
7
7
import { useState } from "react";
8
-
import { useFilesQuery } from "../../../hooks/useFile";
8
+
import { useDeleteFileMutation, useFilesQuery } from "../../../hooks/useFile";
9
9
import dayjs from "dayjs";
10
10
import Pagination from "../../../components/pagination";
11
11
import ConfirmDelete from "../../../components/confirmdelete";
12
+
import { useQueryClient } from "@tanstack/react-query";
12
13
13
14
const PAGE_SIZE = 12;
14
15
const SKELETON_ROWS = 8;
···
33
34
);
34
35
35
36
function Files() {
37
+
const queryClient = useQueryClient();
36
38
const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
39
+
const [selectedFile, setSelectedFile] = useState<string | undefined>(
40
+
undefined,
41
+
);
42
+
const { mutateAsync: deleteFile } = useDeleteFileMutation();
37
43
const [selectedFileId, setSelectedFileId] = useState<string | undefined>(
38
44
undefined,
39
45
);
···
58
64
setCurrentPage(page);
59
65
};
60
66
61
-
const handleConfirmDelete = async () => {};
67
+
const handleConfirmDelete = async () => {
68
+
await deleteFile(selectedFileId!);
69
+
queryClient.invalidateQueries({ queryKey: ["files"] });
70
+
};
62
71
63
72
return (
64
73
<Main
···
122
131
</button>
123
132
<button
124
133
className="btn btn-outline join-item"
125
-
onClick={() => setConfirmDeleteOpen(true)}
134
+
onClick={() => {
135
+
setSelectedFileId(file.id);
136
+
setSelectedFile(file.path);
137
+
setConfirmDeleteOpen(true);
138
+
}}
126
139
>
127
140
Delete
128
141
</button>
···
158
171
onConfirm={handleConfirmDelete}
159
172
subject={"file"}
160
173
title={"file?"}
174
+
subjectId={selectedFile}
161
175
/>
162
176
</>
163
177
</Main>
+21
-3
apps/web/src/pages/settings/secrets/Secrets.tsx
+21
-3
apps/web/src/pages/settings/secrets/Secrets.tsx
···
5
5
import Sidebar from "../sidebar/Sidebar";
6
6
import AddSecretModal from "../../../components/contextmenu/AddSecretModal";
7
7
import { useState } from "react";
8
-
import { useSecretsQuery } from "../../../hooks/useSecret";
8
+
import {
9
+
useDeleteSecretMutation,
10
+
useSecretsQuery,
11
+
} from "../../../hooks/useSecret";
9
12
import dayjs from "dayjs";
10
13
import Pagination from "../../../components/pagination";
11
14
import ConfirmDelete from "../../../components/confirmdelete/ConfirmDelete";
15
+
import { set } from "react-hook-form";
12
16
13
17
const PAGE_SIZE = 12;
14
18
const SKELETON_ROWS = 8;
···
34
38
35
39
function Secrets() {
36
40
const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
41
+
const [selectedSecret, setSelectedSecret] = useState<string | undefined>(
42
+
undefined,
43
+
);
37
44
const [selectedSecretId, setSelectedSecretId] = useState<string | undefined>(
38
45
undefined,
39
46
);
···
43
50
44
51
const routerState = useRouterState();
45
52
const pathname = routerState.location.pathname;
53
+
const { mutateAsync: deleteSecret } = useDeleteSecretMutation();
46
54
const { data } = useSandboxQuery(
47
55
`at:/${pathname.replace("/secrets", "").replace("sandbox", "io.pocketenv.sandbox")}`,
48
56
);
···
58
66
setCurrentPage(page);
59
67
};
60
68
61
-
const handleConfirmDelete = async () => {};
69
+
const handleConfirmDelete = async () => {
70
+
await deleteSecret(selectedSecretId!);
71
+
setSelectedSecret(undefined);
72
+
setSelectedSecretId(undefined);
73
+
setConfirmDeleteOpen(false);
74
+
};
62
75
63
76
return (
64
77
<Main
···
127
140
</button>
128
141
<button
129
142
className="btn btn-outline join-item"
130
-
onClick={() => setConfirmDeleteOpen(true)}
143
+
onClick={() => {
144
+
setSelectedSecret(secret.name);
145
+
setSelectedSecretId(secret.id);
146
+
setConfirmDeleteOpen(true);
147
+
}}
131
148
>
132
149
Delete
133
150
</button>
···
163
180
onConfirm={handleConfirmDelete}
164
181
subject={"secret"}
165
182
title={"secret?"}
183
+
subjectId={selectedSecret}
166
184
/>
167
185
</>
168
186
</Main>
+25
-3
apps/web/src/pages/settings/variables/Variables.tsx
+25
-3
apps/web/src/pages/settings/variables/Variables.tsx
···
5
5
import Sidebar from "../sidebar/Sidebar";
6
6
import AddVariableModal from "../../../components/contextmenu/AddVariableModal";
7
7
import { useState } from "react";
8
-
import { useVariablesQuery } from "../../../hooks/useVariable";
8
+
import {
9
+
useDeleteVariableMutation,
10
+
useVariablesQuery,
11
+
} from "../../../hooks/useVariable";
9
12
import dayjs from "dayjs";
10
13
import Pagination from "../../../components/pagination";
11
14
import ConfirmDelete from "../../../components/confirmdelete";
15
+
import { useQueryClient } from "@tanstack/react-query";
12
16
13
17
const PAGE_SIZE = 10;
14
18
const SKELETON_ROWS = 8;
···
35
39
);
36
40
37
41
function Variables() {
42
+
const queryClient = useQueryClient();
38
43
const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
44
+
const { mutateAsync: deleteVariable } = useDeleteVariableMutation();
45
+
const [selectedVariable, setSelectedVariable] = useState<string | undefined>(
46
+
undefined,
47
+
);
39
48
const [selectedVariableId, setSelectedVariableId] = useState<
40
49
string | undefined
41
50
>(undefined);
···
62
71
setCurrentPage(page);
63
72
};
64
73
65
-
const handleConfirmDelete = async () => {};
74
+
const handleConfirmDelete = async () => {
75
+
await deleteVariable(selectedVariableId!);
76
+
queryClient.invalidateQueries({
77
+
queryKey: ["variables"],
78
+
});
79
+
setConfirmDeleteOpen(false);
80
+
setSelectedVariableId(undefined);
81
+
setSelectedVariable(undefined);
82
+
};
66
83
67
84
return (
68
85
<Main
···
134
151
</button>
135
152
<button
136
153
className="btn btn-outline join-item"
137
-
onClick={() => setConfirmDeleteOpen(true)}
154
+
onClick={() => {
155
+
setSelectedVariableId(variable.id);
156
+
setSelectedVariable(variable.name);
157
+
setConfirmDeleteOpen(true);
158
+
}}
138
159
>
139
160
Delete
140
161
</button>
···
170
191
onConfirm={handleConfirmDelete}
171
192
subject={"variable"}
172
193
title={"variable?"}
194
+
subjectId={selectedVariable}
173
195
/>
174
196
</>
175
197
</Main>
+22
-3
apps/web/src/pages/settings/volumes/Volumes.tsx
+22
-3
apps/web/src/pages/settings/volumes/Volumes.tsx
···
5
5
import Sidebar from "../sidebar/Sidebar";
6
6
import AddVolumeModal from "../../../components/contextmenu/AddVolumeModal";
7
7
import { useState } from "react";
8
-
import { useVolumesQuery } from "../../../hooks/useVolume";
8
+
import {
9
+
useDeleteVolumeMutation,
10
+
useVolumesQuery,
11
+
} from "../../../hooks/useVolume";
9
12
import dayjs from "dayjs";
10
13
import Pagination from "../../../components/pagination";
11
14
import ConfirmDelete from "../../../components/confirmdelete/ConfirmDelete";
15
+
import { useQueryClient } from "@tanstack/react-query";
12
16
13
17
const PAGE_SIZE = 12;
14
18
const SKELETON_ROWS = 8;
···
35
39
);
36
40
37
41
function Volumes() {
42
+
const queryClient = useQueryClient();
38
43
const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
44
+
const { mutateAsync: deleteVolume } = useDeleteVolumeMutation();
45
+
const [selectedVolume, setSelectedVolume] = useState<string | undefined>(
46
+
undefined,
47
+
);
39
48
const [selectedVolumeId, setSelectedVolumeId] = useState<string | undefined>(
40
49
undefined,
41
50
);
···
60
69
setCurrentPage(page);
61
70
};
62
71
63
-
const handleConfirmDelete = async () => {};
72
+
const handleConfirmDelete = async () => {
73
+
await deleteVolume(selectedVolumeId!);
74
+
queryClient.invalidateQueries(["volumes", data?.sandbox?.id]);
75
+
setSelectedVolumeId(undefined);
76
+
setSelectedVolume(undefined);
77
+
};
64
78
65
79
return (
66
80
<Main
···
129
143
</button>
130
144
<button
131
145
className="btn btn-outline join-item"
132
-
onClick={() => setConfirmDeleteOpen(true)}
146
+
onClick={() => {
147
+
setSelectedVolumeId(volume.id);
148
+
setSelectedVolume(volume.name);
149
+
setConfirmDeleteOpen(true);
150
+
}}
133
151
>
134
152
Delete
135
153
</button>
···
165
183
onConfirm={handleConfirmDelete}
166
184
subject={"volume"}
167
185
title={"volume?"}
186
+
subjectId={selectedVolume}
168
187
/>
169
188
</>
170
189
</Main>