@rivet-dev/agentos 0.2.22 → 0.4.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +18 -0
- package/assets/inspector-tabs-app/assets/{agentos-hero-logo-E3fapwXM.svg → agentos-hero-logo-BL8gBiZH.svg} +1 -1
- package/assets/inspector-tabs-app/assets/{sed-BwsOyU9v.svg → coreutils-CQXb6ysD.svg} +1 -1
- package/assets/inspector-tabs-app/assets/filesystem-Dt4eKrkX.js +1 -0
- package/assets/inspector-tabs-app/assets/{hooks-DU8a-cwM.js → hooks-B_kCGlJx.js} +1 -1
- package/assets/inspector-tabs-app/assets/index-BQ48yGn7.css +1 -0
- package/assets/inspector-tabs-app/assets/index-CMgGagyE.js +126 -0
- package/assets/inspector-tabs-app/assets/processes-C3xk9hpI.js +4 -0
- package/assets/inspector-tabs-app/assets/scroll-area-DKdlhVEr.js +1 -0
- package/assets/inspector-tabs-app/assets/system-DOSmuuav.js +1 -0
- package/assets/inspector-tabs-app/assets/terminal-DbNlwtw-.js +13 -0
- package/assets/inspector-tabs-app/assets/useMutation-B4fxUbt-.js +1 -0
- package/assets/inspector-tabs-app/assets/vm-status-badges-QaK7sEZ4.js +1 -0
- package/assets/inspector-tabs-app/index.html +2 -2
- package/dist/index.d.ts +2925 -448
- package/dist/index.js +35 -1924
- package/dist/index.js.map +1 -1
- package/package.json +62 -114
- package/assets/inspector-tabs-app/assets/filesystem-C-x0K5sy.js +0 -1
- package/assets/inspector-tabs-app/assets/index-7G_DbdZ6.js +0 -110
- package/assets/inspector-tabs-app/assets/index-DG_s1YoH.css +0 -1
- package/assets/inspector-tabs-app/assets/scroll-area-kPbv4IGy.js +0 -1
- package/assets/inspector-tabs-app/assets/system-D98yBhMj.js +0 -2
- package/assets/inspector-tabs-app/assets/terminal-Bv9GKv4q.js +0 -13
- package/assets/inspector-tabs-app/assets/transcript-kMbm_tF8.js +0 -1
- package/assets/inspector-tabs-app/assets/useSuspenseQuery-ChN8rnBd.js +0 -1
- package/assets/inspector-tabs-app/assets/vm-boot-gate-rpuO0b5W.js +0 -1
- package/assets/inspector-tabs-app/assets/vm-status-badges-09qyfN_A.js +0 -5
- package/dist/chunk-V6TY7KAL.js +0 -8
- package/dist/chunk-V6TY7KAL.js.map +0 -1
- package/dist/client.d.ts +0 -2
- package/dist/client.js +0 -3
- package/dist/client.js.map +0 -1
- package/dist/node.d.ts +0 -67
- package/dist/node.js +0 -275
- package/dist/node.js.map +0 -1
- package/dist/react.d.ts +0 -1
- package/dist/react.js +0 -3
- package/dist/react.js.map +0 -1
package/dist/index.d.ts
CHANGED
|
@@ -1,465 +1,2942 @@
|
|
|
1
|
-
import {
|
|
2
|
-
|
|
3
|
-
import * as _rivet_dev_agentos_core from '@rivet-dev/agentos-core';
|
|
4
|
-
import { LanguageSpawnOptions, SpawnOptions, LanguageExecutionOptions, JavaScriptExecutionOptions, NpmProjectInstallOptions, NpmPackageInstallOptions, TypeScriptExecutionOptions, TypeScriptFileExecutionOptions, TypeScriptCheckOptions, InlineExecutionOptions, PythonInstallOptions, SessionStreamEntry, AgentExitEvent, ProcessOutput, ProcessExit, ShellData, ShellExit, CronEvent, CronJobInfo, HostFunctionSchemas, AgentOsOptions, AgentOs, DynamicMountDescriptor, ProcessDescriptor, OpenSessionInput, PromptInput, PackageDescriptor, CodeExecutionResult } from '@rivet-dev/agentos-core';
|
|
5
|
-
export * from '@rivet-dev/agentos-core';
|
|
6
|
-
import * as _agentclientprotocol_sdk from '@agentclientprotocol/sdk';
|
|
7
|
-
import * as _rivet_dev_agentos_core_internal_runtime_compat from '@rivet-dev/agentos-core/internal/runtime-compat';
|
|
8
|
-
import { DatabaseProvider, RawAccess } from 'rivetkit/db';
|
|
1
|
+
import { BaseActorDefinition, Type, Client, Registry } from 'rivetkit';
|
|
2
|
+
import { ActorAccessor, GetOptions, ActorHandle, ActorConnectOptions, ActorConn, CreateOptions, GetWithIdOptions, ClientConfigInput } from 'rivetkit/client';
|
|
9
3
|
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
type
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
4
|
+
declare const AGENTOS_API_VERSION: "agentos-sdk.dev/v1alpha1";
|
|
5
|
+
declare const AGENTOS_CONTRACT_MAJOR: 1;
|
|
6
|
+
declare const AGENTOS_CONTRACT_HASH: "sha256:06086c42788602d49d762f2b3003a8fe89a3d136219611cdbbc84d0fc4c267ca";
|
|
7
|
+
declare const AGENTOS_CAPABILITIES: readonly ["config.merge-patch", "network.pull-streaming", "output.replay", "inspector.filesystem", "inspector.processes", "inspector.software", "inspector.terminals", "inspector.vm", "language.javascript", "language.python", "language.typescript", "software.registry"];
|
|
8
|
+
declare const AGENTOS_CONTRACT: {
|
|
9
|
+
readonly apiVersion: "agentos-sdk.dev/v1alpha1";
|
|
10
|
+
readonly contractMajor: 1;
|
|
11
|
+
readonly contractHash: "sha256:06086c42788602d49d762f2b3003a8fe89a3d136219611cdbbc84d0fc4c267ca";
|
|
12
|
+
readonly capabilities: readonly ["config.merge-patch", "network.pull-streaming", "output.replay", "inspector.filesystem", "inspector.processes", "inspector.software", "inspector.terminals", "inspector.vm", "language.javascript", "language.python", "language.typescript", "software.registry"];
|
|
13
|
+
};
|
|
14
|
+
declare namespace Input {
|
|
15
|
+
type ActorCodeEvaluationResult = {
|
|
16
|
+
result: ActorCodeExecutionResult;
|
|
17
|
+
value?: JsonValue | null;
|
|
18
|
+
};
|
|
19
|
+
type ActorCodeExecutionResult = {
|
|
20
|
+
execution?: ActorExecutionDescriptor | null;
|
|
21
|
+
outcome: ActorExecutionOutcome;
|
|
22
|
+
exitCode?: number | null;
|
|
23
|
+
error?: ActorExecutionError | null;
|
|
24
|
+
stdout?: FileBytes | null;
|
|
25
|
+
stderr?: FileBytes | null;
|
|
26
|
+
stdoutTruncated?: boolean | null;
|
|
27
|
+
stderrTruncated?: boolean | null;
|
|
28
|
+
};
|
|
29
|
+
type ActorContextDescriptor = {
|
|
30
|
+
context: ActorContextId;
|
|
31
|
+
state: string;
|
|
32
|
+
language?: string | null;
|
|
33
|
+
createdAtMs: number | bigint;
|
|
34
|
+
lastStartedAtMs?: number | bigint | null;
|
|
35
|
+
lastCompletedAtMs?: number | bigint | null;
|
|
36
|
+
};
|
|
37
|
+
type ActorContextId = {
|
|
38
|
+
generation: number | bigint;
|
|
39
|
+
contextId: string;
|
|
40
|
+
};
|
|
41
|
+
type ActorCronJob = {
|
|
42
|
+
name: string;
|
|
43
|
+
expression: string;
|
|
44
|
+
timezone?: string | null;
|
|
45
|
+
command: string;
|
|
46
|
+
args: Array<string>;
|
|
47
|
+
options: ActorSpawnOptions;
|
|
48
|
+
configRevision: number | bigint;
|
|
49
|
+
nextRunAtMs: number | bigint;
|
|
50
|
+
lastRunAtMs?: number | bigint | null;
|
|
51
|
+
maxHistory: number | bigint;
|
|
52
|
+
};
|
|
53
|
+
type ActorExecOptions = {
|
|
54
|
+
env?: {
|
|
55
|
+
[key in string]?: string;
|
|
56
|
+
};
|
|
57
|
+
cwd?: string | null;
|
|
58
|
+
stdin?: FileContentInput | null;
|
|
59
|
+
timeoutMs?: number | bigint | null;
|
|
60
|
+
captureStdio?: boolean | null;
|
|
61
|
+
};
|
|
62
|
+
type ActorExecResult = {
|
|
63
|
+
status: ActorExitStatus;
|
|
64
|
+
stdout: string;
|
|
65
|
+
stderr: string;
|
|
66
|
+
};
|
|
67
|
+
type ActorExecutionDescriptor = {
|
|
68
|
+
executionId: string;
|
|
69
|
+
generation: number | bigint;
|
|
70
|
+
state: string;
|
|
71
|
+
language?: string | null;
|
|
72
|
+
processId?: string | null;
|
|
73
|
+
pid?: number | null;
|
|
74
|
+
createdAtMs: number | bigint;
|
|
75
|
+
lastStartedAtMs?: number | bigint | null;
|
|
76
|
+
lastCompletedAtMs?: number | bigint | null;
|
|
77
|
+
lastOutcome?: ActorExecutionOutcome | null;
|
|
78
|
+
lastExitCode?: number | null;
|
|
79
|
+
};
|
|
80
|
+
type ActorExecutionError = {
|
|
81
|
+
code: string;
|
|
82
|
+
name: string;
|
|
83
|
+
message: string;
|
|
84
|
+
stack?: string | null;
|
|
85
|
+
details?: JsonValue | null;
|
|
86
|
+
};
|
|
87
|
+
type ActorExecutionOutcome = "succeeded" | "failed" | "cancelled" | "timedOut";
|
|
88
|
+
type ActorExecutionOutputOptions = {
|
|
89
|
+
capture?: ActorOutputCapture | null;
|
|
90
|
+
retainEvents?: boolean | null;
|
|
91
|
+
};
|
|
92
|
+
type ActorExecutionPtyOptions = {
|
|
93
|
+
cols?: number | null;
|
|
94
|
+
rows?: number | null;
|
|
95
|
+
};
|
|
96
|
+
type ActorExitStatus = {
|
|
97
|
+
exitCode: number;
|
|
98
|
+
signal?: ActorSignal | null;
|
|
99
|
+
};
|
|
100
|
+
type ActorFetchStreamChunk = {
|
|
101
|
+
body: FileBytes;
|
|
102
|
+
done: boolean;
|
|
103
|
+
};
|
|
104
|
+
type ActorFetchStreamHead = {
|
|
105
|
+
stream: ActorFetchStreamId;
|
|
106
|
+
status: number;
|
|
107
|
+
statusText: string;
|
|
108
|
+
headers: Array<[string, string]>;
|
|
109
|
+
};
|
|
110
|
+
type ActorFetchStreamId = {
|
|
111
|
+
generation: number | bigint;
|
|
112
|
+
streamId: string;
|
|
113
|
+
expiresAtMs: number | bigint;
|
|
114
|
+
};
|
|
115
|
+
type ActorFileStat = {
|
|
116
|
+
mode: number;
|
|
117
|
+
sizeBytes: number | bigint;
|
|
118
|
+
blocks: number | bigint;
|
|
119
|
+
dev: number | bigint;
|
|
120
|
+
rdev: number | bigint;
|
|
121
|
+
isDirectory: boolean;
|
|
122
|
+
isSymbolicLink: boolean;
|
|
123
|
+
atimeMs: number;
|
|
124
|
+
mtimeMs: number;
|
|
125
|
+
ctimeMs: number;
|
|
126
|
+
birthtimeMs: number;
|
|
127
|
+
ino: number | bigint;
|
|
128
|
+
nlink: number | bigint;
|
|
129
|
+
uid: number;
|
|
130
|
+
gid: number;
|
|
131
|
+
};
|
|
132
|
+
type ActorHttpRequest = {
|
|
133
|
+
port: number;
|
|
134
|
+
path: string;
|
|
135
|
+
method?: string;
|
|
136
|
+
headers?: {
|
|
137
|
+
[key in string]?: string;
|
|
138
|
+
};
|
|
139
|
+
body?: FileContentInput | null;
|
|
140
|
+
};
|
|
141
|
+
type ActorHttpResponse = {
|
|
142
|
+
status: number;
|
|
143
|
+
statusText: string;
|
|
144
|
+
headers: Array<[string, string]>;
|
|
145
|
+
body: FileBytes;
|
|
146
|
+
};
|
|
147
|
+
type ActorInlineExecutionOptions = {
|
|
148
|
+
process?: ActorLanguageExecutionOptions;
|
|
149
|
+
inputs?: {
|
|
150
|
+
[key in string]?: JsonValue;
|
|
151
|
+
} | null;
|
|
152
|
+
};
|
|
153
|
+
type ActorInstalledSoftware = {
|
|
154
|
+
packageId: string;
|
|
155
|
+
digest: string;
|
|
156
|
+
sizeBytes: number | bigint;
|
|
157
|
+
packageName: string;
|
|
158
|
+
version: string;
|
|
159
|
+
commands: Array<string>;
|
|
160
|
+
};
|
|
161
|
+
type ActorJavaScriptExecutionOptions = {
|
|
162
|
+
inline?: ActorInlineExecutionOptions;
|
|
163
|
+
format?: ActorJavaScriptModuleFormat | null;
|
|
164
|
+
filePath?: string | null;
|
|
165
|
+
};
|
|
166
|
+
type ActorJavaScriptModuleFormat = "module" | "commonJs";
|
|
167
|
+
type ActorLanguageExecutionOptions = {
|
|
168
|
+
context?: ActorContextId | null;
|
|
169
|
+
cwd?: string | null;
|
|
170
|
+
env?: {
|
|
171
|
+
[key in string]?: string;
|
|
172
|
+
};
|
|
173
|
+
args?: Array<string>;
|
|
174
|
+
stdin?: FileContentInput | null;
|
|
175
|
+
timeoutMs?: number | bigint | null;
|
|
176
|
+
pty?: ActorExecutionPtyOptions | null;
|
|
177
|
+
output?: ActorExecutionOutputOptions;
|
|
178
|
+
};
|
|
179
|
+
type ActorLanguageSpawnOptions = {
|
|
180
|
+
cwd?: string | null;
|
|
181
|
+
env?: {
|
|
182
|
+
[key in string]?: string;
|
|
183
|
+
};
|
|
184
|
+
args?: Array<string>;
|
|
185
|
+
stdin?: FileContentInput | null;
|
|
186
|
+
timeoutMs?: number | bigint | null;
|
|
187
|
+
pty?: ActorExecutionPtyOptions | null;
|
|
188
|
+
};
|
|
189
|
+
type ActorNpmInstallOptions = {
|
|
190
|
+
context?: ActorContextId | null;
|
|
191
|
+
cwd?: string | null;
|
|
192
|
+
env?: {
|
|
193
|
+
[key in string]?: string;
|
|
194
|
+
};
|
|
195
|
+
timeoutMs?: number | bigint | null;
|
|
196
|
+
frozen?: boolean | null;
|
|
197
|
+
dev?: boolean | null;
|
|
198
|
+
global?: boolean | null;
|
|
199
|
+
output?: ActorExecutionOutputOptions;
|
|
200
|
+
};
|
|
201
|
+
type ActorOutputCapture = "none" | "stderr" | "all";
|
|
202
|
+
type ActorOutputEvent = {
|
|
203
|
+
sequence: number | bigint;
|
|
204
|
+
stream: ProcessStream;
|
|
205
|
+
data: FileBytes;
|
|
206
|
+
timestampMs: number | bigint;
|
|
207
|
+
};
|
|
208
|
+
type ActorOutputReplay = {
|
|
209
|
+
generation: number | bigint;
|
|
210
|
+
events: Array<ActorOutputEvent>;
|
|
211
|
+
nextCursor?: number | bigint | null;
|
|
212
|
+
hasMore: boolean;
|
|
213
|
+
truncated: boolean;
|
|
214
|
+
end?: ActorExitStatus | null;
|
|
215
|
+
};
|
|
216
|
+
type ActorPreview = {
|
|
217
|
+
token: string;
|
|
218
|
+
path: string;
|
|
219
|
+
port: number;
|
|
220
|
+
expiresAtMs: number | bigint;
|
|
221
|
+
};
|
|
222
|
+
type ActorProcessExit = {
|
|
223
|
+
process: ActorProcessId;
|
|
224
|
+
status: ActorExitStatus;
|
|
225
|
+
};
|
|
226
|
+
type ActorProcessId = {
|
|
227
|
+
generation: number | bigint;
|
|
228
|
+
pid: number;
|
|
229
|
+
};
|
|
230
|
+
type ActorProcessInfo = {
|
|
231
|
+
process: ActorProcessId;
|
|
232
|
+
command: string;
|
|
233
|
+
args: Array<string>;
|
|
234
|
+
running: boolean;
|
|
235
|
+
exit?: ActorExitStatus | null;
|
|
236
|
+
startedAtMs: number | bigint;
|
|
237
|
+
};
|
|
238
|
+
type ActorProcessTree = {
|
|
239
|
+
generation: number | bigint;
|
|
240
|
+
roots: Array<ActorProcessTreeNode>;
|
|
241
|
+
};
|
|
242
|
+
type ActorProcessTreeNode = {
|
|
243
|
+
process?: ActorProcessId | null;
|
|
244
|
+
pid: number;
|
|
245
|
+
ppid: number;
|
|
246
|
+
pgid: number;
|
|
247
|
+
sid: number;
|
|
248
|
+
driver: string;
|
|
249
|
+
command: string;
|
|
250
|
+
args: Array<string>;
|
|
251
|
+
cwd: string;
|
|
252
|
+
status: ProcessStatus;
|
|
253
|
+
exit?: ActorExitStatus | null;
|
|
254
|
+
startTimeMs: number;
|
|
255
|
+
exitTimeMs?: number | null;
|
|
256
|
+
children: Array<ActorProcessTreeNode>;
|
|
257
|
+
};
|
|
258
|
+
type ActorPythonInstallOptions = {
|
|
259
|
+
context?: ActorContextId | null;
|
|
260
|
+
cwd?: string | null;
|
|
261
|
+
env?: {
|
|
262
|
+
[key in string]?: string;
|
|
263
|
+
};
|
|
264
|
+
timeoutMs?: number | bigint | null;
|
|
265
|
+
upgrade?: boolean | null;
|
|
266
|
+
requirementsFile?: string | null;
|
|
267
|
+
indexUrl?: string | null;
|
|
268
|
+
extraIndexUrls?: Array<string>;
|
|
269
|
+
output?: ActorExecutionOutputOptions;
|
|
270
|
+
};
|
|
271
|
+
type ActorSignal = "SIGTERM" | "SIGINT" | "SIGKILL";
|
|
272
|
+
type ActorSpawnOptions = {
|
|
273
|
+
env?: {
|
|
274
|
+
[key in string]?: string;
|
|
275
|
+
};
|
|
276
|
+
cwd?: string | null;
|
|
277
|
+
stdio?: SpawnStdio | null;
|
|
278
|
+
/**
|
|
279
|
+
* Keep stdin open for `v1.process.stdin.write`. Without it the process reads EOF, as under
|
|
280
|
+
* `docker exec` without `-i`, so a command that reads stdin cannot wait forever, and
|
|
281
|
+
* `v1.process.stdin.write` fails with `invalid_input`.
|
|
282
|
+
*/
|
|
283
|
+
openStdin?: boolean | null;
|
|
284
|
+
stdinFd?: number | null;
|
|
285
|
+
stdoutFd?: number | null;
|
|
286
|
+
stderrFd?: number | null;
|
|
287
|
+
};
|
|
288
|
+
type ActorTerminalExit = {
|
|
289
|
+
terminal: ActorTerminalId;
|
|
290
|
+
status: ActorExitStatus;
|
|
291
|
+
};
|
|
292
|
+
type ActorTerminalId = {
|
|
293
|
+
generation: number | bigint;
|
|
294
|
+
shellId: string;
|
|
295
|
+
};
|
|
296
|
+
type ActorTerminalOptions = {
|
|
297
|
+
command?: string | null;
|
|
298
|
+
args?: Array<string>;
|
|
299
|
+
env?: {
|
|
300
|
+
[key in string]?: string;
|
|
301
|
+
};
|
|
302
|
+
cwd?: string | null;
|
|
303
|
+
cols?: number | null;
|
|
304
|
+
rows?: number | null;
|
|
305
|
+
};
|
|
306
|
+
type ActorTypeScriptCheckOptions = {
|
|
307
|
+
context?: ActorContextId | null;
|
|
308
|
+
cwd?: string | null;
|
|
309
|
+
filePath?: string | null;
|
|
310
|
+
tsconfigPath?: string | null;
|
|
311
|
+
compilerOptions?: {
|
|
312
|
+
[key in string]?: JsonValue;
|
|
313
|
+
} | null;
|
|
314
|
+
timeoutMs?: number | bigint | null;
|
|
315
|
+
output?: ActorExecutionOutputOptions;
|
|
316
|
+
};
|
|
317
|
+
type ActorTypeScriptCheckResult = {
|
|
318
|
+
result: ActorCodeExecutionResult;
|
|
319
|
+
hasErrors?: boolean | null;
|
|
320
|
+
diagnostics: Array<ActorTypeScriptDiagnostic>;
|
|
321
|
+
};
|
|
322
|
+
type ActorTypeScriptDiagnostic = {
|
|
323
|
+
code: number;
|
|
324
|
+
category: string;
|
|
325
|
+
message: string;
|
|
326
|
+
filePath?: string | null;
|
|
327
|
+
line?: number | null;
|
|
328
|
+
column?: number | null;
|
|
329
|
+
};
|
|
330
|
+
type ActorTypeScriptExecutionOptions = {
|
|
331
|
+
inline?: ActorInlineExecutionOptions;
|
|
332
|
+
filePath?: string | null;
|
|
333
|
+
tsconfigPath?: string | null;
|
|
334
|
+
compilerOptions?: {
|
|
335
|
+
[key in string]?: JsonValue;
|
|
336
|
+
} | null;
|
|
337
|
+
};
|
|
338
|
+
type AgentOsActorConfig = {
|
|
339
|
+
user?: VmUserConfig | null;
|
|
340
|
+
environment?: {
|
|
341
|
+
[key in string]?: string;
|
|
342
|
+
} | null;
|
|
343
|
+
allowedNodeBuiltins?: Array<string> | null;
|
|
344
|
+
highResolutionTime?: boolean | null;
|
|
345
|
+
loopbackExemptPorts: Array<number>;
|
|
346
|
+
limits?: AgentOsLimits | null;
|
|
347
|
+
permissions?: Permissions | null;
|
|
348
|
+
filesystem: HostedFilesystemConfig;
|
|
349
|
+
defaultSoftware?: boolean | null;
|
|
350
|
+
software: Array<RemotePackageSource>;
|
|
351
|
+
preview: PreviewPolicy;
|
|
352
|
+
};
|
|
353
|
+
type AgentOsActorConfigInput = {
|
|
354
|
+
user?: VmUserConfig | null;
|
|
355
|
+
environment?: {
|
|
356
|
+
[key in string]?: string;
|
|
357
|
+
} | null;
|
|
358
|
+
allowedNodeBuiltins?: Array<string> | null;
|
|
359
|
+
highResolutionTime?: boolean | null;
|
|
360
|
+
loopbackExemptPorts?: Array<number> | null;
|
|
361
|
+
limits?: AgentOsLimits | null;
|
|
362
|
+
permissions?: Permissions | null;
|
|
363
|
+
filesystem?: HostedFilesystemConfigInput | null;
|
|
364
|
+
/**
|
|
365
|
+
* Install agentOS default software (coreutils, sed, grep, gawk, findutils,
|
|
366
|
+
* diffutils, tar, gzip) before `software`. Defaults to true.
|
|
367
|
+
*/
|
|
368
|
+
defaultSoftware?: boolean | null;
|
|
369
|
+
/**
|
|
370
|
+
* Software installed after the default software, in order. Registry
|
|
371
|
+
* entries are resolved to an exact URL and digest when the config is
|
|
372
|
+
* accepted, so the durable config never follows a moving manifest.
|
|
373
|
+
*/
|
|
374
|
+
software?: Array<SoftwareSourceInput> | null;
|
|
375
|
+
preview?: PreviewPolicyInput | null;
|
|
376
|
+
};
|
|
377
|
+
type AgentOsActorCreateInput = {
|
|
378
|
+
config?: AgentOsActorConfigInput | null;
|
|
379
|
+
};
|
|
380
|
+
type AgentOsLimits = {
|
|
381
|
+
agentosPackages?: AgentOsPackageLimits;
|
|
382
|
+
resources?: ResourceLimits | null;
|
|
383
|
+
http?: HttpLimits | null;
|
|
384
|
+
tls?: TlsLimits;
|
|
385
|
+
hostFunctions?: HostFunctionLimits | null;
|
|
386
|
+
plugins?: PluginLimits | null;
|
|
387
|
+
sqlite?: SqliteLimits | null;
|
|
388
|
+
jsRuntime?: JsRuntimeLimits | null;
|
|
389
|
+
python?: PythonLimits | null;
|
|
390
|
+
wasm?: WasmLimits | null;
|
|
391
|
+
execution?: ExecutionLimits;
|
|
392
|
+
process?: ProcessLimits | null;
|
|
393
|
+
};
|
|
394
|
+
type AgentOsPackageLimits = {
|
|
395
|
+
maxMounts?: number | bigint;
|
|
396
|
+
};
|
|
397
|
+
type ConfigApplyState = "applying" | "ready" | "restart_required" | "failed";
|
|
398
|
+
type ConfigGet = Record<string, never>;
|
|
399
|
+
type ConfigPatch = {
|
|
400
|
+
patch: JsonValue;
|
|
401
|
+
expectedRevision?: number | bigint | null;
|
|
402
|
+
};
|
|
403
|
+
type ConfigSet = {
|
|
404
|
+
config: AgentOsActorConfigInput;
|
|
405
|
+
expectedRevision?: number | bigint | null;
|
|
406
|
+
};
|
|
407
|
+
type ConfigSnapshot = {
|
|
408
|
+
revision: number | bigint;
|
|
409
|
+
desired: AgentOsActorConfig;
|
|
410
|
+
appliedRevision?: number | bigint | null;
|
|
411
|
+
state: ConfigApplyState;
|
|
412
|
+
issues: Array<VmIssue>;
|
|
413
|
+
createdAtMs: number | bigint;
|
|
414
|
+
updatedAtMs: number | bigint;
|
|
415
|
+
};
|
|
416
|
+
type ContextsCreate = {
|
|
417
|
+
contextId: string;
|
|
418
|
+
};
|
|
419
|
+
type ContextsDelete = {
|
|
420
|
+
context: ActorContextId;
|
|
421
|
+
};
|
|
422
|
+
type ContextsGet = {
|
|
423
|
+
context: ActorContextId;
|
|
424
|
+
};
|
|
425
|
+
type ContextsList = Record<string, never>;
|
|
426
|
+
type ContextsReset = {
|
|
427
|
+
context: ActorContextId;
|
|
428
|
+
};
|
|
429
|
+
type CoreSidecarStatus = {
|
|
430
|
+
state: string;
|
|
431
|
+
activeVmCount: number;
|
|
432
|
+
};
|
|
433
|
+
type CronCancel = {
|
|
434
|
+
name: string;
|
|
435
|
+
};
|
|
436
|
+
type CronFiredEvent = {
|
|
437
|
+
scheduleName: string;
|
|
438
|
+
process?: ActorProcessId | null;
|
|
439
|
+
error?: CronLaunchError | null;
|
|
440
|
+
firedAtMs: number | bigint;
|
|
441
|
+
};
|
|
442
|
+
type CronLaunchError = {
|
|
443
|
+
code: string;
|
|
444
|
+
message: string;
|
|
445
|
+
};
|
|
446
|
+
type CronList = Record<string, never>;
|
|
447
|
+
type CronSchedule = {
|
|
448
|
+
name?: string | null;
|
|
449
|
+
expression: string;
|
|
450
|
+
timezone?: string | null;
|
|
451
|
+
command: string;
|
|
452
|
+
args?: Array<string>;
|
|
453
|
+
options?: ActorSpawnOptions;
|
|
454
|
+
maxHistory?: number | bigint | null;
|
|
455
|
+
};
|
|
456
|
+
type DirEntryType = "file" | "directory" | "symlink";
|
|
457
|
+
type ExecutionLimits = {
|
|
458
|
+
completedTtlMs?: number | bigint;
|
|
459
|
+
maxCompletedExecutions?: number | bigint;
|
|
460
|
+
liveExecutionWarningThreshold?: number | bigint;
|
|
461
|
+
};
|
|
462
|
+
type FileBytes = Uint8Array;
|
|
463
|
+
type FileContentInput = string | Uint8Array;
|
|
464
|
+
type FilesystemEntry = {
|
|
465
|
+
path: string;
|
|
466
|
+
type: DirEntryType;
|
|
467
|
+
mode: string;
|
|
468
|
+
uid: number;
|
|
469
|
+
gid: number;
|
|
470
|
+
content?: string | null;
|
|
471
|
+
encoding?: FilesystemEntryEncoding | null;
|
|
472
|
+
target?: string | null;
|
|
473
|
+
};
|
|
474
|
+
type FilesystemEntryEncoding = "utf8" | "base64";
|
|
475
|
+
type FilesystemExists = {
|
|
476
|
+
path: string;
|
|
477
|
+
};
|
|
478
|
+
type FilesystemExport = {
|
|
479
|
+
maxBytes?: number | null;
|
|
480
|
+
};
|
|
481
|
+
type FilesystemListMounts = Record<string, never>;
|
|
482
|
+
type FilesystemMkdir = {
|
|
483
|
+
path: string;
|
|
484
|
+
recursive?: boolean;
|
|
485
|
+
};
|
|
486
|
+
type FilesystemMove = {
|
|
487
|
+
from: string;
|
|
488
|
+
to: string;
|
|
489
|
+
};
|
|
490
|
+
type FilesystemReadFile = {
|
|
491
|
+
path: string;
|
|
492
|
+
maxBytes?: number | null;
|
|
493
|
+
};
|
|
494
|
+
type FilesystemReadFiles = {
|
|
495
|
+
paths: Array<string>;
|
|
496
|
+
maxBytes?: number | null;
|
|
497
|
+
};
|
|
498
|
+
type FilesystemReaddir = {
|
|
499
|
+
path: string;
|
|
500
|
+
};
|
|
501
|
+
type FilesystemReaddirEntries = {
|
|
502
|
+
path: string;
|
|
503
|
+
};
|
|
504
|
+
type FilesystemReaddirRecursive = {
|
|
505
|
+
path: string;
|
|
506
|
+
maxDepth?: number | null;
|
|
507
|
+
exclude?: Array<string>;
|
|
508
|
+
};
|
|
509
|
+
type FilesystemRemove = {
|
|
510
|
+
path: string;
|
|
511
|
+
recursive?: boolean;
|
|
512
|
+
};
|
|
513
|
+
type FilesystemSnapshotEntries = {
|
|
514
|
+
entries: Array<FilesystemEntry>;
|
|
515
|
+
};
|
|
516
|
+
type FilesystemSnapshotExport = {
|
|
517
|
+
format: string;
|
|
518
|
+
filesystem: FilesystemSnapshotEntries;
|
|
519
|
+
};
|
|
520
|
+
type FilesystemStat = {
|
|
521
|
+
path: string;
|
|
522
|
+
};
|
|
523
|
+
type FilesystemWriteEntry = {
|
|
524
|
+
path: string;
|
|
525
|
+
content: FileContentInput;
|
|
526
|
+
};
|
|
527
|
+
type FilesystemWriteFile = {
|
|
528
|
+
path: string;
|
|
529
|
+
content: FileContentInput;
|
|
530
|
+
};
|
|
531
|
+
type FilesystemWriteFiles = {
|
|
532
|
+
entries: Array<FilesystemWriteEntry>;
|
|
533
|
+
};
|
|
534
|
+
type FsPermissionRule = {
|
|
535
|
+
mode: PermissionMode;
|
|
536
|
+
operations?: Array<string> | null;
|
|
537
|
+
paths?: Array<string> | null;
|
|
538
|
+
};
|
|
539
|
+
type FsPermissions = PermissionMode | RulePermissions<FsPermissionRule>;
|
|
540
|
+
type HostFunctionLimits = {
|
|
541
|
+
defaultTimeoutMs?: number | bigint | null;
|
|
542
|
+
maxTimeoutMs?: number | bigint | null;
|
|
543
|
+
maxRegisteredCollections?: number | bigint | null;
|
|
544
|
+
maxRegisteredFunctionsPerVm?: number | bigint | null;
|
|
545
|
+
maxFunctionsPerCollection?: number | bigint | null;
|
|
546
|
+
maxSchemaBytes?: number | bigint | null;
|
|
547
|
+
maxExamplesPerFunction?: number | bigint | null;
|
|
548
|
+
maxExampleInputBytes?: number | bigint | null;
|
|
549
|
+
};
|
|
550
|
+
type HostedFilesystemBackend = {
|
|
551
|
+
type: "durable";
|
|
552
|
+
namespace: string;
|
|
553
|
+
};
|
|
554
|
+
type HostedFilesystemBackendInput = {
|
|
555
|
+
type: "durable";
|
|
556
|
+
namespace?: string | null;
|
|
557
|
+
};
|
|
558
|
+
type HostedFilesystemConfig = {
|
|
559
|
+
root: HostedRootFilesystem;
|
|
560
|
+
mounts: Array<HostedFilesystemMount>;
|
|
561
|
+
};
|
|
562
|
+
type HostedFilesystemConfigInput = {
|
|
563
|
+
root?: HostedRootFilesystemInput | null;
|
|
564
|
+
mounts?: Array<HostedFilesystemMountInput>;
|
|
565
|
+
};
|
|
566
|
+
type HostedFilesystemMount = {
|
|
567
|
+
path: string;
|
|
568
|
+
backend: HostedFilesystemBackend;
|
|
569
|
+
readOnly: boolean;
|
|
570
|
+
};
|
|
571
|
+
type HostedFilesystemMountInput = {
|
|
572
|
+
path: string;
|
|
573
|
+
backend: HostedFilesystemBackendInput;
|
|
574
|
+
readOnly?: boolean;
|
|
575
|
+
};
|
|
576
|
+
type HostedRootFilesystem = {
|
|
577
|
+
type: "default";
|
|
578
|
+
} | {
|
|
579
|
+
type: "durable";
|
|
580
|
+
namespace: string;
|
|
581
|
+
readOnly: boolean;
|
|
582
|
+
};
|
|
583
|
+
type HostedRootFilesystemInput = {
|
|
584
|
+
type: "default";
|
|
585
|
+
} | {
|
|
586
|
+
type: "durable";
|
|
587
|
+
namespace?: string | null;
|
|
588
|
+
readOnly?: boolean;
|
|
589
|
+
};
|
|
590
|
+
type HttpLimits = {
|
|
591
|
+
maxFetchResponseBytes?: number | bigint | null;
|
|
592
|
+
};
|
|
593
|
+
type JavaScriptEvaluate = {
|
|
594
|
+
expression: string;
|
|
595
|
+
options?: ActorJavaScriptExecutionOptions;
|
|
596
|
+
};
|
|
597
|
+
type JavaScriptExecute = {
|
|
598
|
+
source: string;
|
|
599
|
+
options?: ActorJavaScriptExecutionOptions;
|
|
600
|
+
};
|
|
601
|
+
type JavaScriptExecuteFile = {
|
|
602
|
+
path: string;
|
|
603
|
+
options?: ActorLanguageExecutionOptions;
|
|
604
|
+
};
|
|
605
|
+
type JavaScriptNpmInstall = {
|
|
606
|
+
packages?: Array<string>;
|
|
607
|
+
options?: ActorNpmInstallOptions;
|
|
608
|
+
};
|
|
609
|
+
type JavaScriptNpmRunPackage = {
|
|
610
|
+
packageSpec: string;
|
|
611
|
+
binary?: string | null;
|
|
612
|
+
options?: ActorLanguageExecutionOptions;
|
|
613
|
+
};
|
|
614
|
+
type JavaScriptNpmRunScript = {
|
|
615
|
+
script: string;
|
|
616
|
+
options?: ActorLanguageExecutionOptions;
|
|
617
|
+
};
|
|
618
|
+
type JavaScriptSpawn = {
|
|
619
|
+
source: string;
|
|
620
|
+
options?: ActorLanguageSpawnOptions;
|
|
621
|
+
};
|
|
622
|
+
type JavaScriptSpawnFile = {
|
|
623
|
+
path: string;
|
|
624
|
+
options?: ActorLanguageSpawnOptions;
|
|
625
|
+
};
|
|
626
|
+
type JsRuntimeLimits = {
|
|
627
|
+
v8HeapLimitMb?: number | bigint | null;
|
|
628
|
+
syncRpcWaitTimeoutMs?: number | bigint | null;
|
|
629
|
+
cpuTimeLimitMs?: number | bigint | null;
|
|
630
|
+
wallClockLimitMs?: number | bigint | null;
|
|
631
|
+
importCacheMaterializeTimeoutMs?: number | bigint | null;
|
|
632
|
+
capturedOutputLimitBytes?: number | bigint | null;
|
|
633
|
+
stdinBufferLimitBytes?: number | bigint | null;
|
|
634
|
+
eventPayloadLimitBytes?: number | bigint | null;
|
|
635
|
+
v8IpcMaxFrameBytes?: number | bigint | null;
|
|
636
|
+
};
|
|
637
|
+
type JsonValue = number | string | boolean | Array<JsonValue> | {
|
|
638
|
+
[key in string]?: JsonValue;
|
|
639
|
+
} | null;
|
|
640
|
+
type NetworkFetch = {
|
|
641
|
+
request: ActorHttpRequest;
|
|
642
|
+
};
|
|
643
|
+
type NetworkFetchStreamCancel = {
|
|
644
|
+
stream: ActorFetchStreamId;
|
|
645
|
+
};
|
|
646
|
+
type NetworkFetchStreamRead = {
|
|
647
|
+
stream: ActorFetchStreamId;
|
|
648
|
+
maxBytes?: number | null;
|
|
649
|
+
};
|
|
650
|
+
type NetworkFetchStreamStart = {
|
|
651
|
+
request: ActorHttpRequest;
|
|
652
|
+
};
|
|
653
|
+
type NetworkPreviewCreate = {
|
|
654
|
+
port: number;
|
|
655
|
+
ttlMs?: number | bigint | null;
|
|
656
|
+
};
|
|
657
|
+
type NetworkPreviewExpire = {
|
|
658
|
+
token: string;
|
|
659
|
+
};
|
|
660
|
+
type PackageStartupStatus = {
|
|
661
|
+
requiredTotal: number;
|
|
662
|
+
requiredReady: number;
|
|
663
|
+
optionalPreloadTotal: number;
|
|
664
|
+
optionalPreloadReady: number;
|
|
665
|
+
optionalPreloadFailed: number;
|
|
666
|
+
optionalPreloadSkipped: number;
|
|
667
|
+
optionalPreloadWarmedBytes: number | bigint;
|
|
668
|
+
optionalPreloadDeadlineHit: boolean;
|
|
669
|
+
optionalPreloadCoordinatorAvailable: boolean;
|
|
670
|
+
};
|
|
671
|
+
type PatternPermissionRule = {
|
|
672
|
+
mode: PermissionMode;
|
|
673
|
+
operations?: Array<string> | null;
|
|
674
|
+
patterns?: Array<string> | null;
|
|
675
|
+
};
|
|
676
|
+
type PatternPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
|
|
677
|
+
type PermissionMode = "allow" | "deny";
|
|
678
|
+
type Permissions = {
|
|
679
|
+
fs?: FsPermissions | null;
|
|
680
|
+
network?: PatternPermissions | null;
|
|
681
|
+
childProcess?: PatternPermissions | null;
|
|
682
|
+
process?: PatternPermissions | null;
|
|
683
|
+
env?: PatternPermissions | null;
|
|
684
|
+
hostFunction?: PatternPermissions | null;
|
|
685
|
+
};
|
|
686
|
+
type PluginLimits = {
|
|
687
|
+
maxPersistedManifestBytes?: number | bigint | null;
|
|
688
|
+
maxPersistedManifestFileBytes?: number | bigint | null;
|
|
689
|
+
};
|
|
690
|
+
type PreviewPolicy = {
|
|
691
|
+
defaultTtlMs: number | bigint;
|
|
692
|
+
maxTtlMs: number | bigint;
|
|
693
|
+
maxActive: number;
|
|
694
|
+
};
|
|
695
|
+
type PreviewPolicyInput = {
|
|
696
|
+
defaultTtlMs?: number | bigint | null;
|
|
697
|
+
maxTtlMs?: number | bigint | null;
|
|
698
|
+
maxActive?: number | null;
|
|
699
|
+
};
|
|
700
|
+
type ProcessExitEvent = {
|
|
701
|
+
process: ActorProcessId;
|
|
702
|
+
status: ActorExitStatus;
|
|
703
|
+
};
|
|
704
|
+
type ProcessGet = {
|
|
705
|
+
process: ActorProcessId;
|
|
706
|
+
};
|
|
707
|
+
type ProcessLimits = {
|
|
708
|
+
maxSpawnFileActions?: number | bigint | null;
|
|
709
|
+
maxSpawnFileActionBytes?: number | bigint | null;
|
|
710
|
+
pendingStdinBytes?: number | bigint | null;
|
|
711
|
+
pendingEventCount?: number | bigint | null;
|
|
712
|
+
pendingEventBytes?: number | bigint | null;
|
|
713
|
+
};
|
|
714
|
+
type ProcessList = Record<string, never>;
|
|
715
|
+
type ProcessOutputEvent = {
|
|
716
|
+
process: ActorProcessId;
|
|
717
|
+
sequence: number | bigint;
|
|
718
|
+
stream: ProcessStream;
|
|
719
|
+
data: FileBytes;
|
|
720
|
+
timestampMs: number | bigint;
|
|
721
|
+
};
|
|
722
|
+
type ProcessOutputRead = {
|
|
723
|
+
process: ActorProcessId;
|
|
724
|
+
after?: number | bigint | null;
|
|
725
|
+
maxEvents?: number | null;
|
|
726
|
+
maxBytes?: number | null;
|
|
727
|
+
};
|
|
728
|
+
type ProcessPtyResize = {
|
|
729
|
+
process: ActorProcessId;
|
|
730
|
+
cols: number;
|
|
731
|
+
rows: number;
|
|
732
|
+
};
|
|
733
|
+
type ProcessRun = {
|
|
734
|
+
command: string;
|
|
735
|
+
args?: Array<string>;
|
|
736
|
+
options?: ActorExecOptions;
|
|
737
|
+
};
|
|
738
|
+
type ProcessSignal = {
|
|
739
|
+
process: ActorProcessId;
|
|
740
|
+
signal: ActorSignal;
|
|
741
|
+
};
|
|
742
|
+
type ProcessSpawn = {
|
|
743
|
+
command: string;
|
|
744
|
+
args?: Array<string>;
|
|
745
|
+
options?: ActorSpawnOptions;
|
|
746
|
+
};
|
|
747
|
+
type ProcessStatus = "running" | "exited";
|
|
748
|
+
type ProcessStdinClose = {
|
|
749
|
+
process: ActorProcessId;
|
|
750
|
+
};
|
|
751
|
+
type ProcessStdinWrite = {
|
|
752
|
+
process: ActorProcessId;
|
|
753
|
+
data: FileContentInput;
|
|
754
|
+
};
|
|
755
|
+
type ProcessStream = "stdout" | "stderr";
|
|
756
|
+
type ProcessTree = Record<string, never>;
|
|
757
|
+
type ProcessWait = {
|
|
758
|
+
process: ActorProcessId;
|
|
759
|
+
};
|
|
760
|
+
type PythonEvaluate = {
|
|
761
|
+
expression: string;
|
|
762
|
+
options?: ActorInlineExecutionOptions;
|
|
763
|
+
};
|
|
764
|
+
type PythonExecute = {
|
|
765
|
+
source: string;
|
|
766
|
+
options?: ActorInlineExecutionOptions;
|
|
767
|
+
};
|
|
768
|
+
type PythonExecuteFile = {
|
|
769
|
+
path: string;
|
|
770
|
+
options?: ActorLanguageExecutionOptions;
|
|
771
|
+
};
|
|
772
|
+
type PythonExecuteModule = {
|
|
773
|
+
module: string;
|
|
774
|
+
options?: ActorLanguageExecutionOptions;
|
|
775
|
+
};
|
|
776
|
+
type PythonInstall = {
|
|
777
|
+
packages?: Array<string>;
|
|
778
|
+
options?: ActorPythonInstallOptions;
|
|
779
|
+
};
|
|
780
|
+
type PythonLimits = {
|
|
781
|
+
outputBufferMaxBytes?: number | bigint | null;
|
|
782
|
+
executionTimeoutMs?: number | bigint | null;
|
|
783
|
+
maxOldSpaceMb?: number | bigint | null;
|
|
784
|
+
vfsRpcTimeoutMs?: number | bigint | null;
|
|
785
|
+
};
|
|
786
|
+
type PythonSpawn = {
|
|
787
|
+
source: string;
|
|
788
|
+
options?: ActorLanguageSpawnOptions;
|
|
789
|
+
};
|
|
790
|
+
type PythonSpawnFile = {
|
|
791
|
+
path: string;
|
|
792
|
+
options?: ActorLanguageSpawnOptions;
|
|
793
|
+
};
|
|
794
|
+
type PythonSpawnModule = {
|
|
795
|
+
module: string;
|
|
796
|
+
options?: ActorLanguageSpawnOptions;
|
|
797
|
+
};
|
|
798
|
+
type RegistrySoftwareSourceInput = {
|
|
799
|
+
/**
|
|
800
|
+
* Registry package name, such as `git` or `ripgrep`.
|
|
801
|
+
*/
|
|
802
|
+
registry: string;
|
|
803
|
+
/**
|
|
804
|
+
* agentOS release whose manifest lists the package, such as `0.4.3` or
|
|
805
|
+
* `latest`. Defaults to the agentOS release the actor is built with.
|
|
806
|
+
*/
|
|
807
|
+
version?: string | null;
|
|
808
|
+
};
|
|
809
|
+
type RemotePackageSource = {
|
|
810
|
+
url: string;
|
|
811
|
+
digest?: string | null;
|
|
812
|
+
sizeBytes?: number | bigint | null;
|
|
813
|
+
packageId?: string | null;
|
|
814
|
+
};
|
|
815
|
+
type RemotePackageSourceInput = {
|
|
816
|
+
url: string;
|
|
817
|
+
digest?: string | null;
|
|
818
|
+
/**
|
|
819
|
+
* Resolution metadata is accepted so a `v1.config.get` snapshot can be sent
|
|
820
|
+
* back to `v1.config.set`. Core re-resolves the source and never trusts it.
|
|
821
|
+
*/
|
|
822
|
+
sizeBytes?: number | bigint | null;
|
|
823
|
+
packageId?: string | null;
|
|
824
|
+
};
|
|
825
|
+
type ResourceLimits = {
|
|
826
|
+
cpuCount?: number | bigint | null;
|
|
827
|
+
maxProcesses?: number | bigint | null;
|
|
828
|
+
maxOpenFds?: number | bigint | null;
|
|
829
|
+
maxPipes?: number | bigint | null;
|
|
830
|
+
maxPtys?: number | bigint | null;
|
|
831
|
+
maxSockets?: number | bigint | null;
|
|
832
|
+
maxConnections?: number | bigint | null;
|
|
833
|
+
maxSocketBufferedBytes?: number | bigint | null;
|
|
834
|
+
maxSocketDatagramQueueLen?: number | bigint | null;
|
|
835
|
+
maxFilesystemBytes?: number | bigint | null;
|
|
836
|
+
maxInodeCount?: number | bigint | null;
|
|
837
|
+
maxBlockingReadMs?: number | bigint | null;
|
|
838
|
+
maxPreadBytes?: number | bigint | null;
|
|
839
|
+
maxFdWriteBytes?: number | bigint | null;
|
|
840
|
+
maxProcessArgvBytes?: number | bigint | null;
|
|
841
|
+
maxProcessEnvBytes?: number | bigint | null;
|
|
842
|
+
maxReaddirEntries?: number | bigint | null;
|
|
843
|
+
maxWasmFuel?: number | bigint | null;
|
|
844
|
+
maxWasmMemoryBytes?: number | bigint | null;
|
|
845
|
+
maxWasmStackBytes?: number | bigint | null;
|
|
846
|
+
};
|
|
847
|
+
type RootSnapshotExport = {
|
|
848
|
+
kind: SnapshotExportKind;
|
|
849
|
+
source: FilesystemSnapshotExport;
|
|
850
|
+
};
|
|
851
|
+
type RulePermissions<T> = {
|
|
852
|
+
default?: PermissionMode | null;
|
|
853
|
+
rules: Array<T>;
|
|
854
|
+
};
|
|
855
|
+
type SnapshotExportKind = "snapshot-export";
|
|
856
|
+
type SoftwareInstall = {
|
|
857
|
+
/**
|
|
858
|
+
* A `{ url, digest? }` artifact or a `{ registry, version? }` package. The
|
|
859
|
+
* result's `source` is the resolved, digest-pinned URL that is persisted.
|
|
860
|
+
*/
|
|
861
|
+
source: SoftwareSourceInput;
|
|
862
|
+
expectedRevision?: number | bigint | null;
|
|
863
|
+
};
|
|
864
|
+
type SoftwareList = Record<string, never>;
|
|
865
|
+
type SoftwareMutationResult = {
|
|
866
|
+
software?: ActorInstalledSoftware | null;
|
|
867
|
+
source: RemotePackageSource;
|
|
868
|
+
config: ConfigSnapshot;
|
|
869
|
+
};
|
|
870
|
+
type SoftwareSourceInput = RegistrySoftwareSourceInput | RemotePackageSourceInput;
|
|
871
|
+
type SoftwareUninstall = {
|
|
872
|
+
packageId: string;
|
|
873
|
+
expectedRevision?: number | bigint | null;
|
|
874
|
+
};
|
|
875
|
+
type SpawnStdio = "pipe" | "inherit";
|
|
876
|
+
type SqliteLimits = {
|
|
877
|
+
maxResultBytes?: number | bigint | null;
|
|
878
|
+
};
|
|
879
|
+
type TerminalClose = {
|
|
880
|
+
terminal: ActorTerminalId;
|
|
881
|
+
};
|
|
882
|
+
type TerminalExitEvent = {
|
|
883
|
+
terminal: ActorTerminalId;
|
|
884
|
+
status: ActorExitStatus;
|
|
885
|
+
};
|
|
886
|
+
type TerminalList = Record<string, never>;
|
|
887
|
+
type TerminalOpen = {
|
|
888
|
+
options?: ActorTerminalOptions;
|
|
889
|
+
};
|
|
890
|
+
type TerminalOutputEvent = {
|
|
891
|
+
terminal: ActorTerminalId;
|
|
892
|
+
sequence: number | bigint;
|
|
893
|
+
stream: ProcessStream;
|
|
894
|
+
data: FileBytes;
|
|
895
|
+
timestampMs: number | bigint;
|
|
896
|
+
};
|
|
897
|
+
type TerminalOutputRead = {
|
|
898
|
+
terminal: ActorTerminalId;
|
|
899
|
+
after?: number | bigint | null;
|
|
900
|
+
maxBytes?: number | null;
|
|
901
|
+
maxEvents?: number | null;
|
|
902
|
+
};
|
|
903
|
+
type TerminalPtyResize = {
|
|
904
|
+
terminal: ActorTerminalId;
|
|
905
|
+
cols: number;
|
|
906
|
+
rows: number;
|
|
907
|
+
};
|
|
908
|
+
type TerminalStdinWrite = {
|
|
909
|
+
terminal: ActorTerminalId;
|
|
910
|
+
data: FileContentInput;
|
|
911
|
+
};
|
|
912
|
+
type TerminalWait = {
|
|
913
|
+
terminal: ActorTerminalId;
|
|
914
|
+
};
|
|
915
|
+
type TlsLimits = {
|
|
916
|
+
maxBufferedBytes?: number | bigint;
|
|
917
|
+
};
|
|
918
|
+
type TypeScriptCheck = {
|
|
919
|
+
source: string;
|
|
920
|
+
options?: ActorTypeScriptCheckOptions;
|
|
921
|
+
};
|
|
922
|
+
type TypeScriptCheckProject = {
|
|
923
|
+
options?: ActorTypeScriptCheckOptions;
|
|
924
|
+
};
|
|
925
|
+
type TypeScriptEvaluate = {
|
|
926
|
+
expression: string;
|
|
927
|
+
options?: ActorTypeScriptExecutionOptions;
|
|
928
|
+
};
|
|
929
|
+
type TypeScriptExecute = {
|
|
930
|
+
source: string;
|
|
931
|
+
options?: ActorTypeScriptExecutionOptions;
|
|
932
|
+
};
|
|
933
|
+
type TypeScriptExecuteFile = {
|
|
934
|
+
path: string;
|
|
935
|
+
options?: ActorTypeScriptExecutionOptions;
|
|
936
|
+
};
|
|
937
|
+
type TypeScriptSpawn = {
|
|
938
|
+
source: string;
|
|
939
|
+
options?: ActorLanguageSpawnOptions;
|
|
940
|
+
};
|
|
941
|
+
type TypeScriptSpawnFile = {
|
|
942
|
+
path: string;
|
|
943
|
+
options?: ActorLanguageSpawnOptions;
|
|
944
|
+
};
|
|
945
|
+
type VmBooted = {
|
|
946
|
+
generation: number | bigint;
|
|
947
|
+
configRevision: number | bigint;
|
|
948
|
+
bootedAtMs: number | bigint;
|
|
949
|
+
};
|
|
950
|
+
type VmGroupConfig = {
|
|
951
|
+
gid: number;
|
|
952
|
+
name: string;
|
|
953
|
+
members: Array<string>;
|
|
954
|
+
};
|
|
955
|
+
type VmIssue = {
|
|
956
|
+
code: string;
|
|
957
|
+
message: string;
|
|
958
|
+
atMs: number | bigint;
|
|
959
|
+
};
|
|
960
|
+
type VmLifecycleState = "initializing" | "preloading" | "booting" | "ready" | "degraded" | "stopping" | "failed";
|
|
961
|
+
type VmLimitWarning = {
|
|
962
|
+
limit: string;
|
|
963
|
+
observed: number | bigint;
|
|
964
|
+
capacity: number | bigint;
|
|
965
|
+
message: string;
|
|
966
|
+
};
|
|
967
|
+
type VmRestart = Record<string, never>;
|
|
968
|
+
type VmShutdown = {
|
|
969
|
+
generation: number | bigint;
|
|
970
|
+
reason: string;
|
|
971
|
+
shutdownAtMs: number | bigint;
|
|
972
|
+
};
|
|
973
|
+
type VmStatus = Record<string, never>;
|
|
974
|
+
type VmStatusSnapshot = {
|
|
975
|
+
lifecycle: VmLifecycleState;
|
|
976
|
+
configState: ConfigApplyState;
|
|
977
|
+
desiredConfigRevision: number | bigint;
|
|
978
|
+
appliedConfigRevision?: number | bigint | null;
|
|
979
|
+
generation: number | bigint;
|
|
980
|
+
lastBootAtMs?: number | bigint | null;
|
|
981
|
+
lastShutdownAtMs?: number | bigint | null;
|
|
982
|
+
packages: PackageStartupStatus;
|
|
983
|
+
issues: Array<VmIssue>;
|
|
984
|
+
core?: CoreSidecarStatus | null;
|
|
985
|
+
};
|
|
986
|
+
type VmUserAccountConfig = {
|
|
987
|
+
uid: number;
|
|
988
|
+
gid: number;
|
|
989
|
+
username: string;
|
|
990
|
+
homedir: string;
|
|
991
|
+
shell: string;
|
|
992
|
+
gecos?: string;
|
|
993
|
+
supplementaryGids: Array<number>;
|
|
994
|
+
};
|
|
995
|
+
type VmUserConfig = {
|
|
996
|
+
uid?: number;
|
|
997
|
+
gid?: number;
|
|
998
|
+
euid?: number;
|
|
999
|
+
egid?: number;
|
|
1000
|
+
username?: string;
|
|
1001
|
+
homedir?: string;
|
|
1002
|
+
shell?: string;
|
|
1003
|
+
gecos?: string;
|
|
1004
|
+
groupName?: string;
|
|
1005
|
+
supplementaryGids?: Array<number>;
|
|
1006
|
+
accounts?: Array<VmUserAccountConfig>;
|
|
1007
|
+
groups?: Array<VmGroupConfig>;
|
|
1008
|
+
};
|
|
1009
|
+
type WasmLimits = {
|
|
1010
|
+
maxModuleFileBytes?: number | bigint | null;
|
|
1011
|
+
capturedOutputLimitBytes?: number | bigint | null;
|
|
1012
|
+
syncReadLimitBytes?: number | bigint | null;
|
|
1013
|
+
prewarmTimeoutMs?: number | bigint | null;
|
|
1014
|
+
runnerHeapLimitMb?: number | bigint | null;
|
|
1015
|
+
runnerCpuTimeLimitMs?: number | bigint | null;
|
|
1016
|
+
};
|
|
89
1017
|
}
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
1018
|
+
declare namespace Output {
|
|
1019
|
+
type ActorCodeEvaluationResult = {
|
|
1020
|
+
result: ActorCodeExecutionResult;
|
|
1021
|
+
value?: JsonValue | null;
|
|
1022
|
+
};
|
|
1023
|
+
type ActorCodeExecutionResult = {
|
|
1024
|
+
execution?: ActorExecutionDescriptor | null;
|
|
1025
|
+
outcome: ActorExecutionOutcome;
|
|
1026
|
+
exitCode?: number | null;
|
|
1027
|
+
error?: ActorExecutionError | null;
|
|
1028
|
+
stdout?: FileBytes | null;
|
|
1029
|
+
stderr?: FileBytes | null;
|
|
1030
|
+
stdoutTruncated?: boolean | null;
|
|
1031
|
+
stderrTruncated?: boolean | null;
|
|
1032
|
+
};
|
|
1033
|
+
type ActorContextDescriptor = {
|
|
1034
|
+
context: ActorContextId;
|
|
1035
|
+
state: string;
|
|
1036
|
+
language?: string | null;
|
|
1037
|
+
createdAtMs: number | bigint;
|
|
1038
|
+
lastStartedAtMs?: number | bigint | null;
|
|
1039
|
+
lastCompletedAtMs?: number | bigint | null;
|
|
1040
|
+
};
|
|
1041
|
+
type ActorContextId = {
|
|
1042
|
+
generation: number | bigint;
|
|
1043
|
+
contextId: string;
|
|
1044
|
+
};
|
|
1045
|
+
type ActorCronJob = {
|
|
1046
|
+
name: string;
|
|
1047
|
+
expression: string;
|
|
1048
|
+
timezone?: string | null;
|
|
1049
|
+
command: string;
|
|
1050
|
+
args: Array<string>;
|
|
1051
|
+
options: ActorSpawnOptions;
|
|
1052
|
+
configRevision: number | bigint;
|
|
1053
|
+
nextRunAtMs: number | bigint;
|
|
1054
|
+
lastRunAtMs?: number | bigint | null;
|
|
1055
|
+
maxHistory: number | bigint;
|
|
1056
|
+
};
|
|
1057
|
+
type ActorExecOptions = {
|
|
1058
|
+
env?: {
|
|
1059
|
+
[key in string]?: string;
|
|
1060
|
+
};
|
|
1061
|
+
cwd?: string | null;
|
|
1062
|
+
stdin?: FileContentInput | null;
|
|
1063
|
+
timeoutMs?: number | bigint | null;
|
|
1064
|
+
captureStdio?: boolean | null;
|
|
1065
|
+
};
|
|
1066
|
+
type ActorExecResult = {
|
|
1067
|
+
status: ActorExitStatus;
|
|
1068
|
+
stdout: string;
|
|
1069
|
+
stderr: string;
|
|
1070
|
+
};
|
|
1071
|
+
type ActorExecutionDescriptor = {
|
|
1072
|
+
executionId: string;
|
|
1073
|
+
generation: number | bigint;
|
|
1074
|
+
state: string;
|
|
1075
|
+
language?: string | null;
|
|
1076
|
+
processId?: string | null;
|
|
1077
|
+
pid?: number | null;
|
|
1078
|
+
createdAtMs: number | bigint;
|
|
1079
|
+
lastStartedAtMs?: number | bigint | null;
|
|
1080
|
+
lastCompletedAtMs?: number | bigint | null;
|
|
1081
|
+
lastOutcome?: ActorExecutionOutcome | null;
|
|
1082
|
+
lastExitCode?: number | null;
|
|
1083
|
+
};
|
|
1084
|
+
type ActorExecutionError = {
|
|
1085
|
+
code: string;
|
|
1086
|
+
name: string;
|
|
1087
|
+
message: string;
|
|
1088
|
+
stack?: string | null;
|
|
1089
|
+
details?: JsonValue | null;
|
|
1090
|
+
};
|
|
1091
|
+
type ActorExecutionOutcome = "succeeded" | "failed" | "cancelled" | "timedOut";
|
|
1092
|
+
type ActorExecutionOutputOptions = {
|
|
1093
|
+
capture?: ActorOutputCapture | null;
|
|
1094
|
+
retainEvents?: boolean | null;
|
|
1095
|
+
};
|
|
1096
|
+
type ActorExecutionPtyOptions = {
|
|
1097
|
+
cols?: number | null;
|
|
1098
|
+
rows?: number | null;
|
|
1099
|
+
};
|
|
1100
|
+
type ActorExitStatus = {
|
|
1101
|
+
exitCode: number;
|
|
1102
|
+
signal?: ActorSignal | null;
|
|
1103
|
+
};
|
|
1104
|
+
type ActorFetchStreamChunk = {
|
|
1105
|
+
body: FileBytes;
|
|
1106
|
+
done: boolean;
|
|
1107
|
+
};
|
|
1108
|
+
type ActorFetchStreamHead = {
|
|
1109
|
+
stream: ActorFetchStreamId;
|
|
1110
|
+
status: number;
|
|
1111
|
+
statusText: string;
|
|
1112
|
+
headers: Array<[string, string]>;
|
|
1113
|
+
};
|
|
1114
|
+
type ActorFetchStreamId = {
|
|
1115
|
+
generation: number | bigint;
|
|
1116
|
+
streamId: string;
|
|
1117
|
+
expiresAtMs: number | bigint;
|
|
1118
|
+
};
|
|
1119
|
+
type ActorFileStat = {
|
|
1120
|
+
mode: number;
|
|
1121
|
+
sizeBytes: number | bigint;
|
|
1122
|
+
blocks: number | bigint;
|
|
1123
|
+
dev: number | bigint;
|
|
1124
|
+
rdev: number | bigint;
|
|
1125
|
+
isDirectory: boolean;
|
|
1126
|
+
isSymbolicLink: boolean;
|
|
1127
|
+
atimeMs: number;
|
|
1128
|
+
mtimeMs: number;
|
|
1129
|
+
ctimeMs: number;
|
|
1130
|
+
birthtimeMs: number;
|
|
1131
|
+
ino: number | bigint;
|
|
1132
|
+
nlink: number | bigint;
|
|
1133
|
+
uid: number;
|
|
1134
|
+
gid: number;
|
|
1135
|
+
};
|
|
1136
|
+
type ActorHttpRequest = {
|
|
1137
|
+
port: number;
|
|
1138
|
+
path: string;
|
|
1139
|
+
method?: string;
|
|
1140
|
+
headers?: {
|
|
1141
|
+
[key in string]?: string;
|
|
1142
|
+
};
|
|
1143
|
+
body?: FileContentInput | null;
|
|
1144
|
+
};
|
|
1145
|
+
type ActorHttpResponse = {
|
|
1146
|
+
status: number;
|
|
1147
|
+
statusText: string;
|
|
1148
|
+
headers: Array<[string, string]>;
|
|
1149
|
+
body: FileBytes;
|
|
1150
|
+
};
|
|
1151
|
+
type ActorInlineExecutionOptions = {
|
|
1152
|
+
process?: ActorLanguageExecutionOptions;
|
|
1153
|
+
inputs?: {
|
|
1154
|
+
[key in string]?: JsonValue;
|
|
1155
|
+
} | null;
|
|
1156
|
+
};
|
|
1157
|
+
type ActorInstalledSoftware = {
|
|
1158
|
+
packageId: string;
|
|
1159
|
+
digest: string;
|
|
1160
|
+
sizeBytes: number | bigint;
|
|
1161
|
+
packageName: string;
|
|
1162
|
+
version: string;
|
|
1163
|
+
commands: Array<string>;
|
|
1164
|
+
};
|
|
1165
|
+
type ActorJavaScriptExecutionOptions = {
|
|
1166
|
+
inline?: ActorInlineExecutionOptions;
|
|
1167
|
+
format?: ActorJavaScriptModuleFormat | null;
|
|
1168
|
+
filePath?: string | null;
|
|
1169
|
+
};
|
|
1170
|
+
type ActorJavaScriptModuleFormat = "module" | "commonJs";
|
|
1171
|
+
type ActorLanguageExecutionOptions = {
|
|
1172
|
+
context?: ActorContextId | null;
|
|
1173
|
+
cwd?: string | null;
|
|
1174
|
+
env?: {
|
|
1175
|
+
[key in string]?: string;
|
|
1176
|
+
};
|
|
1177
|
+
args?: Array<string>;
|
|
1178
|
+
stdin?: FileContentInput | null;
|
|
1179
|
+
timeoutMs?: number | bigint | null;
|
|
1180
|
+
pty?: ActorExecutionPtyOptions | null;
|
|
1181
|
+
output?: ActorExecutionOutputOptions;
|
|
1182
|
+
};
|
|
1183
|
+
type ActorLanguageSpawnOptions = {
|
|
1184
|
+
cwd?: string | null;
|
|
1185
|
+
env?: {
|
|
1186
|
+
[key in string]?: string;
|
|
1187
|
+
};
|
|
1188
|
+
args?: Array<string>;
|
|
1189
|
+
stdin?: FileContentInput | null;
|
|
1190
|
+
timeoutMs?: number | bigint | null;
|
|
1191
|
+
pty?: ActorExecutionPtyOptions | null;
|
|
1192
|
+
};
|
|
1193
|
+
type ActorNpmInstallOptions = {
|
|
1194
|
+
context?: ActorContextId | null;
|
|
1195
|
+
cwd?: string | null;
|
|
1196
|
+
env?: {
|
|
1197
|
+
[key in string]?: string;
|
|
1198
|
+
};
|
|
1199
|
+
timeoutMs?: number | bigint | null;
|
|
1200
|
+
frozen?: boolean | null;
|
|
1201
|
+
dev?: boolean | null;
|
|
1202
|
+
global?: boolean | null;
|
|
1203
|
+
output?: ActorExecutionOutputOptions;
|
|
1204
|
+
};
|
|
1205
|
+
type ActorOutputCapture = "none" | "stderr" | "all";
|
|
1206
|
+
type ActorOutputEvent = {
|
|
1207
|
+
sequence: number | bigint;
|
|
1208
|
+
stream: ProcessStream;
|
|
1209
|
+
data: FileBytes;
|
|
1210
|
+
timestampMs: number | bigint;
|
|
1211
|
+
};
|
|
1212
|
+
type ActorOutputReplay = {
|
|
1213
|
+
generation: number | bigint;
|
|
1214
|
+
events: Array<ActorOutputEvent>;
|
|
1215
|
+
nextCursor?: number | bigint | null;
|
|
1216
|
+
hasMore: boolean;
|
|
1217
|
+
truncated: boolean;
|
|
1218
|
+
end?: ActorExitStatus | null;
|
|
1219
|
+
};
|
|
1220
|
+
type ActorPreview = {
|
|
1221
|
+
token: string;
|
|
1222
|
+
path: string;
|
|
1223
|
+
port: number;
|
|
1224
|
+
expiresAtMs: number | bigint;
|
|
1225
|
+
};
|
|
1226
|
+
type ActorProcessExit = {
|
|
1227
|
+
process: ActorProcessId;
|
|
1228
|
+
status: ActorExitStatus;
|
|
1229
|
+
};
|
|
1230
|
+
type ActorProcessId = {
|
|
1231
|
+
generation: number | bigint;
|
|
1232
|
+
pid: number;
|
|
1233
|
+
};
|
|
1234
|
+
type ActorProcessInfo = {
|
|
1235
|
+
process: ActorProcessId;
|
|
1236
|
+
command: string;
|
|
1237
|
+
args: Array<string>;
|
|
1238
|
+
running: boolean;
|
|
1239
|
+
exit?: ActorExitStatus | null;
|
|
1240
|
+
startedAtMs: number | bigint;
|
|
1241
|
+
};
|
|
1242
|
+
type ActorProcessTree = {
|
|
1243
|
+
generation: number | bigint;
|
|
1244
|
+
roots: Array<ActorProcessTreeNode>;
|
|
1245
|
+
};
|
|
1246
|
+
type ActorProcessTreeNode = {
|
|
1247
|
+
process?: ActorProcessId | null;
|
|
1248
|
+
pid: number;
|
|
1249
|
+
ppid: number;
|
|
1250
|
+
pgid: number;
|
|
1251
|
+
sid: number;
|
|
1252
|
+
driver: string;
|
|
1253
|
+
command: string;
|
|
1254
|
+
args: Array<string>;
|
|
1255
|
+
cwd: string;
|
|
1256
|
+
status: ProcessStatus;
|
|
1257
|
+
exit?: ActorExitStatus | null;
|
|
1258
|
+
startTimeMs: number;
|
|
1259
|
+
exitTimeMs?: number | null;
|
|
1260
|
+
children: Array<ActorProcessTreeNode>;
|
|
1261
|
+
};
|
|
1262
|
+
type ActorPythonInstallOptions = {
|
|
1263
|
+
context?: ActorContextId | null;
|
|
1264
|
+
cwd?: string | null;
|
|
1265
|
+
env?: {
|
|
1266
|
+
[key in string]?: string;
|
|
1267
|
+
};
|
|
1268
|
+
timeoutMs?: number | bigint | null;
|
|
1269
|
+
upgrade?: boolean | null;
|
|
1270
|
+
requirementsFile?: string | null;
|
|
1271
|
+
indexUrl?: string | null;
|
|
1272
|
+
extraIndexUrls?: Array<string>;
|
|
1273
|
+
output?: ActorExecutionOutputOptions;
|
|
1274
|
+
};
|
|
1275
|
+
type ActorSignal = "SIGTERM" | "SIGINT" | "SIGKILL";
|
|
1276
|
+
type ActorSpawnOptions = {
|
|
1277
|
+
env?: {
|
|
1278
|
+
[key in string]?: string;
|
|
1279
|
+
};
|
|
1280
|
+
cwd?: string | null;
|
|
1281
|
+
stdio?: SpawnStdio | null;
|
|
1282
|
+
/**
|
|
1283
|
+
* Keep stdin open for `v1.process.stdin.write`. Without it the process reads EOF, as under
|
|
1284
|
+
* `docker exec` without `-i`, so a command that reads stdin cannot wait forever, and
|
|
1285
|
+
* `v1.process.stdin.write` fails with `invalid_input`.
|
|
1286
|
+
*/
|
|
1287
|
+
openStdin?: boolean | null;
|
|
1288
|
+
stdinFd?: number | null;
|
|
1289
|
+
stdoutFd?: number | null;
|
|
1290
|
+
stderrFd?: number | null;
|
|
1291
|
+
};
|
|
1292
|
+
type ActorTerminalExit = {
|
|
1293
|
+
terminal: ActorTerminalId;
|
|
1294
|
+
status: ActorExitStatus;
|
|
1295
|
+
};
|
|
1296
|
+
type ActorTerminalId = {
|
|
1297
|
+
generation: number | bigint;
|
|
1298
|
+
shellId: string;
|
|
1299
|
+
};
|
|
1300
|
+
type ActorTerminalOptions = {
|
|
1301
|
+
command?: string | null;
|
|
1302
|
+
args?: Array<string>;
|
|
1303
|
+
env?: {
|
|
1304
|
+
[key in string]?: string;
|
|
1305
|
+
};
|
|
1306
|
+
cwd?: string | null;
|
|
1307
|
+
cols?: number | null;
|
|
1308
|
+
rows?: number | null;
|
|
1309
|
+
};
|
|
1310
|
+
type ActorTypeScriptCheckOptions = {
|
|
1311
|
+
context?: ActorContextId | null;
|
|
1312
|
+
cwd?: string | null;
|
|
1313
|
+
filePath?: string | null;
|
|
1314
|
+
tsconfigPath?: string | null;
|
|
1315
|
+
compilerOptions?: {
|
|
1316
|
+
[key in string]?: JsonValue;
|
|
1317
|
+
} | null;
|
|
1318
|
+
timeoutMs?: number | bigint | null;
|
|
1319
|
+
output?: ActorExecutionOutputOptions;
|
|
1320
|
+
};
|
|
1321
|
+
type ActorTypeScriptCheckResult = {
|
|
1322
|
+
result: ActorCodeExecutionResult;
|
|
1323
|
+
hasErrors?: boolean | null;
|
|
1324
|
+
diagnostics: Array<ActorTypeScriptDiagnostic>;
|
|
1325
|
+
};
|
|
1326
|
+
type ActorTypeScriptDiagnostic = {
|
|
1327
|
+
code: number;
|
|
1328
|
+
category: string;
|
|
1329
|
+
message: string;
|
|
1330
|
+
filePath?: string | null;
|
|
1331
|
+
line?: number | null;
|
|
1332
|
+
column?: number | null;
|
|
1333
|
+
};
|
|
1334
|
+
type ActorTypeScriptExecutionOptions = {
|
|
1335
|
+
inline?: ActorInlineExecutionOptions;
|
|
1336
|
+
filePath?: string | null;
|
|
1337
|
+
tsconfigPath?: string | null;
|
|
1338
|
+
compilerOptions?: {
|
|
1339
|
+
[key in string]?: JsonValue;
|
|
1340
|
+
} | null;
|
|
1341
|
+
};
|
|
1342
|
+
type AgentOsActorConfig = {
|
|
1343
|
+
user?: VmUserConfig | null;
|
|
1344
|
+
environment?: {
|
|
1345
|
+
[key in string]?: string;
|
|
1346
|
+
} | null;
|
|
1347
|
+
allowedNodeBuiltins?: Array<string> | null;
|
|
1348
|
+
highResolutionTime?: boolean | null;
|
|
1349
|
+
loopbackExemptPorts: Array<number>;
|
|
1350
|
+
limits?: AgentOsLimits | null;
|
|
1351
|
+
permissions?: Permissions | null;
|
|
1352
|
+
filesystem: HostedFilesystemConfig;
|
|
1353
|
+
defaultSoftware?: boolean | null;
|
|
1354
|
+
software: Array<RemotePackageSource>;
|
|
1355
|
+
preview: PreviewPolicy;
|
|
1356
|
+
};
|
|
1357
|
+
type AgentOsActorConfigInput = {
|
|
1358
|
+
user?: VmUserConfig | null;
|
|
1359
|
+
environment?: {
|
|
1360
|
+
[key in string]?: string;
|
|
1361
|
+
} | null;
|
|
1362
|
+
allowedNodeBuiltins?: Array<string> | null;
|
|
1363
|
+
highResolutionTime?: boolean | null;
|
|
1364
|
+
loopbackExemptPorts?: Array<number> | null;
|
|
1365
|
+
limits?: AgentOsLimits | null;
|
|
1366
|
+
permissions?: Permissions | null;
|
|
1367
|
+
filesystem?: HostedFilesystemConfigInput | null;
|
|
1368
|
+
/**
|
|
1369
|
+
* Install agentOS default software (coreutils, sed, grep, gawk, findutils,
|
|
1370
|
+
* diffutils, tar, gzip) before `software`. Defaults to true.
|
|
1371
|
+
*/
|
|
1372
|
+
defaultSoftware?: boolean | null;
|
|
1373
|
+
/**
|
|
1374
|
+
* Software installed after the default software, in order. Registry
|
|
1375
|
+
* entries are resolved to an exact URL and digest when the config is
|
|
1376
|
+
* accepted, so the durable config never follows a moving manifest.
|
|
1377
|
+
*/
|
|
1378
|
+
software?: Array<SoftwareSourceInput> | null;
|
|
1379
|
+
preview?: PreviewPolicyInput | null;
|
|
1380
|
+
};
|
|
1381
|
+
type AgentOsActorCreateInput = {
|
|
1382
|
+
config?: AgentOsActorConfigInput | null;
|
|
1383
|
+
};
|
|
1384
|
+
type AgentOsLimits = {
|
|
1385
|
+
agentosPackages?: AgentOsPackageLimits;
|
|
1386
|
+
resources?: ResourceLimits | null;
|
|
1387
|
+
http?: HttpLimits | null;
|
|
1388
|
+
tls?: TlsLimits;
|
|
1389
|
+
hostFunctions?: HostFunctionLimits | null;
|
|
1390
|
+
plugins?: PluginLimits | null;
|
|
1391
|
+
sqlite?: SqliteLimits | null;
|
|
1392
|
+
jsRuntime?: JsRuntimeLimits | null;
|
|
1393
|
+
python?: PythonLimits | null;
|
|
1394
|
+
wasm?: WasmLimits | null;
|
|
1395
|
+
execution?: ExecutionLimits;
|
|
1396
|
+
process?: ProcessLimits | null;
|
|
1397
|
+
};
|
|
1398
|
+
type AgentOsPackageLimits = {
|
|
1399
|
+
maxMounts?: number | bigint;
|
|
1400
|
+
};
|
|
1401
|
+
type ConfigApplyState = "applying" | "ready" | "restart_required" | "failed";
|
|
1402
|
+
type ConfigGet = Record<string, never>;
|
|
1403
|
+
type ConfigPatch = {
|
|
1404
|
+
patch: JsonValue;
|
|
1405
|
+
expectedRevision?: number | bigint | null;
|
|
1406
|
+
};
|
|
1407
|
+
type ConfigSet = {
|
|
1408
|
+
config: AgentOsActorConfigInput;
|
|
1409
|
+
expectedRevision?: number | bigint | null;
|
|
1410
|
+
};
|
|
1411
|
+
type ConfigSnapshot = {
|
|
1412
|
+
revision: number | bigint;
|
|
1413
|
+
desired: AgentOsActorConfig;
|
|
1414
|
+
appliedRevision?: number | bigint | null;
|
|
1415
|
+
state: ConfigApplyState;
|
|
1416
|
+
issues: Array<VmIssue>;
|
|
1417
|
+
createdAtMs: number | bigint;
|
|
1418
|
+
updatedAtMs: number | bigint;
|
|
1419
|
+
};
|
|
1420
|
+
type ContextsCreate = {
|
|
1421
|
+
contextId: string;
|
|
1422
|
+
};
|
|
1423
|
+
type ContextsDelete = {
|
|
1424
|
+
context: ActorContextId;
|
|
1425
|
+
};
|
|
1426
|
+
type ContextsGet = {
|
|
1427
|
+
context: ActorContextId;
|
|
1428
|
+
};
|
|
1429
|
+
type ContextsList = Record<string, never>;
|
|
1430
|
+
type ContextsReset = {
|
|
1431
|
+
context: ActorContextId;
|
|
1432
|
+
};
|
|
1433
|
+
type CoreSidecarStatus = {
|
|
1434
|
+
state: string;
|
|
1435
|
+
activeVmCount: number;
|
|
1436
|
+
};
|
|
1437
|
+
type CronCancel = {
|
|
1438
|
+
name: string;
|
|
1439
|
+
};
|
|
1440
|
+
type CronFiredEvent = {
|
|
1441
|
+
scheduleName: string;
|
|
1442
|
+
process?: ActorProcessId | null;
|
|
1443
|
+
error?: CronLaunchError | null;
|
|
1444
|
+
firedAtMs: number | bigint;
|
|
1445
|
+
};
|
|
1446
|
+
type CronLaunchError = {
|
|
1447
|
+
code: string;
|
|
1448
|
+
message: string;
|
|
1449
|
+
};
|
|
1450
|
+
type CronList = Record<string, never>;
|
|
1451
|
+
type CronSchedule = {
|
|
1452
|
+
name?: string | null;
|
|
1453
|
+
expression: string;
|
|
1454
|
+
timezone?: string | null;
|
|
1455
|
+
command: string;
|
|
1456
|
+
args?: Array<string>;
|
|
1457
|
+
options?: ActorSpawnOptions;
|
|
1458
|
+
maxHistory?: number | bigint | null;
|
|
1459
|
+
};
|
|
1460
|
+
type DirEntryType = "file" | "directory" | "symlink";
|
|
1461
|
+
type ExecutionLimits = {
|
|
1462
|
+
completedTtlMs?: number | bigint;
|
|
1463
|
+
maxCompletedExecutions?: number | bigint;
|
|
1464
|
+
liveExecutionWarningThreshold?: number | bigint;
|
|
1465
|
+
};
|
|
1466
|
+
type FileBytes = Uint8Array;
|
|
1467
|
+
type FileContentInput = string | Uint8Array;
|
|
1468
|
+
type FilesystemEntry = {
|
|
1469
|
+
path: string;
|
|
1470
|
+
type: DirEntryType;
|
|
1471
|
+
mode: string;
|
|
1472
|
+
uid: number;
|
|
1473
|
+
gid: number;
|
|
1474
|
+
content?: string | null;
|
|
1475
|
+
encoding?: FilesystemEntryEncoding | null;
|
|
1476
|
+
target?: string | null;
|
|
1477
|
+
};
|
|
1478
|
+
type FilesystemEntryEncoding = "utf8" | "base64";
|
|
1479
|
+
type FilesystemExists = {
|
|
1480
|
+
path: string;
|
|
1481
|
+
};
|
|
1482
|
+
type FilesystemExport = {
|
|
1483
|
+
maxBytes?: number | null;
|
|
1484
|
+
};
|
|
1485
|
+
type FilesystemListMounts = Record<string, never>;
|
|
1486
|
+
type FilesystemMkdir = {
|
|
1487
|
+
path: string;
|
|
1488
|
+
recursive?: boolean;
|
|
1489
|
+
};
|
|
1490
|
+
type FilesystemMove = {
|
|
1491
|
+
from: string;
|
|
1492
|
+
to: string;
|
|
1493
|
+
};
|
|
1494
|
+
type FilesystemReadFile = {
|
|
1495
|
+
path: string;
|
|
1496
|
+
maxBytes?: number | null;
|
|
1497
|
+
};
|
|
1498
|
+
type FilesystemReadFiles = {
|
|
1499
|
+
paths: Array<string>;
|
|
1500
|
+
maxBytes?: number | null;
|
|
1501
|
+
};
|
|
1502
|
+
type FilesystemReaddir = {
|
|
1503
|
+
path: string;
|
|
1504
|
+
};
|
|
1505
|
+
type FilesystemReaddirEntries = {
|
|
1506
|
+
path: string;
|
|
1507
|
+
};
|
|
1508
|
+
type FilesystemReaddirRecursive = {
|
|
1509
|
+
path: string;
|
|
1510
|
+
maxDepth?: number | null;
|
|
1511
|
+
exclude?: Array<string>;
|
|
1512
|
+
};
|
|
1513
|
+
type FilesystemRemove = {
|
|
1514
|
+
path: string;
|
|
1515
|
+
recursive?: boolean;
|
|
1516
|
+
};
|
|
1517
|
+
type FilesystemSnapshotEntries = {
|
|
1518
|
+
entries: Array<FilesystemEntry>;
|
|
1519
|
+
};
|
|
1520
|
+
type FilesystemSnapshotExport = {
|
|
1521
|
+
format: string;
|
|
1522
|
+
filesystem: FilesystemSnapshotEntries;
|
|
1523
|
+
};
|
|
1524
|
+
type FilesystemStat = {
|
|
1525
|
+
path: string;
|
|
1526
|
+
};
|
|
1527
|
+
type FilesystemWriteEntry = {
|
|
1528
|
+
path: string;
|
|
1529
|
+
content: FileContentInput;
|
|
1530
|
+
};
|
|
1531
|
+
type FilesystemWriteFile = {
|
|
1532
|
+
path: string;
|
|
1533
|
+
content: FileContentInput;
|
|
1534
|
+
};
|
|
1535
|
+
type FilesystemWriteFiles = {
|
|
1536
|
+
entries: Array<FilesystemWriteEntry>;
|
|
1537
|
+
};
|
|
1538
|
+
type FsPermissionRule = {
|
|
1539
|
+
mode: PermissionMode;
|
|
1540
|
+
operations?: Array<string> | null;
|
|
1541
|
+
paths?: Array<string> | null;
|
|
1542
|
+
};
|
|
1543
|
+
type FsPermissions = PermissionMode | RulePermissions<FsPermissionRule>;
|
|
1544
|
+
type HostFunctionLimits = {
|
|
1545
|
+
defaultTimeoutMs?: number | bigint | null;
|
|
1546
|
+
maxTimeoutMs?: number | bigint | null;
|
|
1547
|
+
maxRegisteredCollections?: number | bigint | null;
|
|
1548
|
+
maxRegisteredFunctionsPerVm?: number | bigint | null;
|
|
1549
|
+
maxFunctionsPerCollection?: number | bigint | null;
|
|
1550
|
+
maxSchemaBytes?: number | bigint | null;
|
|
1551
|
+
maxExamplesPerFunction?: number | bigint | null;
|
|
1552
|
+
maxExampleInputBytes?: number | bigint | null;
|
|
1553
|
+
};
|
|
1554
|
+
type HostedFilesystemBackend = {
|
|
1555
|
+
type: "durable";
|
|
1556
|
+
namespace: string;
|
|
1557
|
+
};
|
|
1558
|
+
type HostedFilesystemBackendInput = {
|
|
1559
|
+
type: "durable";
|
|
1560
|
+
namespace?: string | null;
|
|
1561
|
+
};
|
|
1562
|
+
type HostedFilesystemConfig = {
|
|
1563
|
+
root: HostedRootFilesystem;
|
|
1564
|
+
mounts: Array<HostedFilesystemMount>;
|
|
1565
|
+
};
|
|
1566
|
+
type HostedFilesystemConfigInput = {
|
|
1567
|
+
root?: HostedRootFilesystemInput | null;
|
|
1568
|
+
mounts?: Array<HostedFilesystemMountInput>;
|
|
1569
|
+
};
|
|
1570
|
+
type HostedFilesystemMount = {
|
|
1571
|
+
path: string;
|
|
1572
|
+
backend: HostedFilesystemBackend;
|
|
1573
|
+
readOnly: boolean;
|
|
1574
|
+
};
|
|
1575
|
+
type HostedFilesystemMountInput = {
|
|
1576
|
+
path: string;
|
|
1577
|
+
backend: HostedFilesystemBackendInput;
|
|
1578
|
+
readOnly?: boolean;
|
|
1579
|
+
};
|
|
1580
|
+
type HostedRootFilesystem = {
|
|
1581
|
+
type: "default";
|
|
1582
|
+
} | {
|
|
1583
|
+
type: "durable";
|
|
1584
|
+
namespace: string;
|
|
1585
|
+
readOnly: boolean;
|
|
1586
|
+
};
|
|
1587
|
+
type HostedRootFilesystemInput = {
|
|
1588
|
+
type: "default";
|
|
1589
|
+
} | {
|
|
1590
|
+
type: "durable";
|
|
1591
|
+
namespace?: string | null;
|
|
1592
|
+
readOnly?: boolean;
|
|
1593
|
+
};
|
|
1594
|
+
type HttpLimits = {
|
|
1595
|
+
maxFetchResponseBytes?: number | bigint | null;
|
|
1596
|
+
};
|
|
1597
|
+
type JavaScriptEvaluate = {
|
|
1598
|
+
expression: string;
|
|
1599
|
+
options?: ActorJavaScriptExecutionOptions;
|
|
1600
|
+
};
|
|
1601
|
+
type JavaScriptExecute = {
|
|
1602
|
+
source: string;
|
|
1603
|
+
options?: ActorJavaScriptExecutionOptions;
|
|
1604
|
+
};
|
|
1605
|
+
type JavaScriptExecuteFile = {
|
|
1606
|
+
path: string;
|
|
1607
|
+
options?: ActorLanguageExecutionOptions;
|
|
1608
|
+
};
|
|
1609
|
+
type JavaScriptNpmInstall = {
|
|
1610
|
+
packages?: Array<string>;
|
|
1611
|
+
options?: ActorNpmInstallOptions;
|
|
1612
|
+
};
|
|
1613
|
+
type JavaScriptNpmRunPackage = {
|
|
1614
|
+
packageSpec: string;
|
|
1615
|
+
binary?: string | null;
|
|
1616
|
+
options?: ActorLanguageExecutionOptions;
|
|
1617
|
+
};
|
|
1618
|
+
type JavaScriptNpmRunScript = {
|
|
1619
|
+
script: string;
|
|
1620
|
+
options?: ActorLanguageExecutionOptions;
|
|
1621
|
+
};
|
|
1622
|
+
type JavaScriptSpawn = {
|
|
1623
|
+
source: string;
|
|
1624
|
+
options?: ActorLanguageSpawnOptions;
|
|
1625
|
+
};
|
|
1626
|
+
type JavaScriptSpawnFile = {
|
|
1627
|
+
path: string;
|
|
1628
|
+
options?: ActorLanguageSpawnOptions;
|
|
1629
|
+
};
|
|
1630
|
+
type JsRuntimeLimits = {
|
|
1631
|
+
v8HeapLimitMb?: number | bigint | null;
|
|
1632
|
+
syncRpcWaitTimeoutMs?: number | bigint | null;
|
|
1633
|
+
cpuTimeLimitMs?: number | bigint | null;
|
|
1634
|
+
wallClockLimitMs?: number | bigint | null;
|
|
1635
|
+
importCacheMaterializeTimeoutMs?: number | bigint | null;
|
|
1636
|
+
capturedOutputLimitBytes?: number | bigint | null;
|
|
1637
|
+
stdinBufferLimitBytes?: number | bigint | null;
|
|
1638
|
+
eventPayloadLimitBytes?: number | bigint | null;
|
|
1639
|
+
v8IpcMaxFrameBytes?: number | bigint | null;
|
|
1640
|
+
};
|
|
1641
|
+
type JsonValue = number | string | boolean | Array<JsonValue> | {
|
|
1642
|
+
[key in string]?: JsonValue;
|
|
1643
|
+
} | null;
|
|
1644
|
+
type NetworkFetch = {
|
|
1645
|
+
request: ActorHttpRequest;
|
|
1646
|
+
};
|
|
1647
|
+
type NetworkFetchStreamCancel = {
|
|
1648
|
+
stream: ActorFetchStreamId;
|
|
1649
|
+
};
|
|
1650
|
+
type NetworkFetchStreamRead = {
|
|
1651
|
+
stream: ActorFetchStreamId;
|
|
1652
|
+
maxBytes?: number | null;
|
|
1653
|
+
};
|
|
1654
|
+
type NetworkFetchStreamStart = {
|
|
1655
|
+
request: ActorHttpRequest;
|
|
1656
|
+
};
|
|
1657
|
+
type NetworkPreviewCreate = {
|
|
1658
|
+
port: number;
|
|
1659
|
+
ttlMs?: number | bigint | null;
|
|
1660
|
+
};
|
|
1661
|
+
type NetworkPreviewExpire = {
|
|
1662
|
+
token: string;
|
|
1663
|
+
};
|
|
1664
|
+
type PackageStartupStatus = {
|
|
1665
|
+
requiredTotal: number;
|
|
1666
|
+
requiredReady: number;
|
|
1667
|
+
optionalPreloadTotal: number;
|
|
1668
|
+
optionalPreloadReady: number;
|
|
1669
|
+
optionalPreloadFailed: number;
|
|
1670
|
+
optionalPreloadSkipped: number;
|
|
1671
|
+
optionalPreloadWarmedBytes: number | bigint;
|
|
1672
|
+
optionalPreloadDeadlineHit: boolean;
|
|
1673
|
+
optionalPreloadCoordinatorAvailable: boolean;
|
|
1674
|
+
};
|
|
1675
|
+
type PatternPermissionRule = {
|
|
1676
|
+
mode: PermissionMode;
|
|
1677
|
+
operations?: Array<string> | null;
|
|
1678
|
+
patterns?: Array<string> | null;
|
|
1679
|
+
};
|
|
1680
|
+
type PatternPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
|
|
1681
|
+
type PermissionMode = "allow" | "deny";
|
|
1682
|
+
type Permissions = {
|
|
1683
|
+
fs?: FsPermissions | null;
|
|
1684
|
+
network?: PatternPermissions | null;
|
|
1685
|
+
childProcess?: PatternPermissions | null;
|
|
1686
|
+
process?: PatternPermissions | null;
|
|
1687
|
+
env?: PatternPermissions | null;
|
|
1688
|
+
hostFunction?: PatternPermissions | null;
|
|
1689
|
+
};
|
|
1690
|
+
type PluginLimits = {
|
|
1691
|
+
maxPersistedManifestBytes?: number | bigint | null;
|
|
1692
|
+
maxPersistedManifestFileBytes?: number | bigint | null;
|
|
1693
|
+
};
|
|
1694
|
+
type PreviewPolicy = {
|
|
1695
|
+
defaultTtlMs: number | bigint;
|
|
1696
|
+
maxTtlMs: number | bigint;
|
|
1697
|
+
maxActive: number;
|
|
1698
|
+
};
|
|
1699
|
+
type PreviewPolicyInput = {
|
|
1700
|
+
defaultTtlMs?: number | bigint | null;
|
|
1701
|
+
maxTtlMs?: number | bigint | null;
|
|
1702
|
+
maxActive?: number | null;
|
|
1703
|
+
};
|
|
1704
|
+
type ProcessExitEvent = {
|
|
1705
|
+
process: ActorProcessId;
|
|
1706
|
+
status: ActorExitStatus;
|
|
1707
|
+
};
|
|
1708
|
+
type ProcessGet = {
|
|
1709
|
+
process: ActorProcessId;
|
|
1710
|
+
};
|
|
1711
|
+
type ProcessLimits = {
|
|
1712
|
+
maxSpawnFileActions?: number | bigint | null;
|
|
1713
|
+
maxSpawnFileActionBytes?: number | bigint | null;
|
|
1714
|
+
pendingStdinBytes?: number | bigint | null;
|
|
1715
|
+
pendingEventCount?: number | bigint | null;
|
|
1716
|
+
pendingEventBytes?: number | bigint | null;
|
|
1717
|
+
};
|
|
1718
|
+
type ProcessList = Record<string, never>;
|
|
1719
|
+
type ProcessOutputEvent = {
|
|
1720
|
+
process: ActorProcessId;
|
|
1721
|
+
sequence: number | bigint;
|
|
1722
|
+
stream: ProcessStream;
|
|
1723
|
+
data: FileBytes;
|
|
1724
|
+
timestampMs: number | bigint;
|
|
1725
|
+
};
|
|
1726
|
+
type ProcessOutputRead = {
|
|
1727
|
+
process: ActorProcessId;
|
|
1728
|
+
after?: number | bigint | null;
|
|
1729
|
+
maxEvents?: number | null;
|
|
1730
|
+
maxBytes?: number | null;
|
|
1731
|
+
};
|
|
1732
|
+
type ProcessPtyResize = {
|
|
1733
|
+
process: ActorProcessId;
|
|
1734
|
+
cols: number;
|
|
1735
|
+
rows: number;
|
|
1736
|
+
};
|
|
1737
|
+
type ProcessRun = {
|
|
1738
|
+
command: string;
|
|
1739
|
+
args?: Array<string>;
|
|
1740
|
+
options?: ActorExecOptions;
|
|
1741
|
+
};
|
|
1742
|
+
type ProcessSignal = {
|
|
1743
|
+
process: ActorProcessId;
|
|
1744
|
+
signal: ActorSignal;
|
|
1745
|
+
};
|
|
1746
|
+
type ProcessSpawn = {
|
|
1747
|
+
command: string;
|
|
1748
|
+
args?: Array<string>;
|
|
1749
|
+
options?: ActorSpawnOptions;
|
|
1750
|
+
};
|
|
1751
|
+
type ProcessStatus = "running" | "exited";
|
|
1752
|
+
type ProcessStdinClose = {
|
|
1753
|
+
process: ActorProcessId;
|
|
1754
|
+
};
|
|
1755
|
+
type ProcessStdinWrite = {
|
|
1756
|
+
process: ActorProcessId;
|
|
1757
|
+
data: FileContentInput;
|
|
1758
|
+
};
|
|
1759
|
+
type ProcessStream = "stdout" | "stderr";
|
|
1760
|
+
type ProcessTree = Record<string, never>;
|
|
1761
|
+
type ProcessWait = {
|
|
1762
|
+
process: ActorProcessId;
|
|
1763
|
+
};
|
|
1764
|
+
type PythonEvaluate = {
|
|
1765
|
+
expression: string;
|
|
1766
|
+
options?: ActorInlineExecutionOptions;
|
|
1767
|
+
};
|
|
1768
|
+
type PythonExecute = {
|
|
1769
|
+
source: string;
|
|
1770
|
+
options?: ActorInlineExecutionOptions;
|
|
1771
|
+
};
|
|
1772
|
+
type PythonExecuteFile = {
|
|
1773
|
+
path: string;
|
|
1774
|
+
options?: ActorLanguageExecutionOptions;
|
|
1775
|
+
};
|
|
1776
|
+
type PythonExecuteModule = {
|
|
1777
|
+
module: string;
|
|
1778
|
+
options?: ActorLanguageExecutionOptions;
|
|
1779
|
+
};
|
|
1780
|
+
type PythonInstall = {
|
|
1781
|
+
packages?: Array<string>;
|
|
1782
|
+
options?: ActorPythonInstallOptions;
|
|
1783
|
+
};
|
|
1784
|
+
type PythonLimits = {
|
|
1785
|
+
outputBufferMaxBytes?: number | bigint | null;
|
|
1786
|
+
executionTimeoutMs?: number | bigint | null;
|
|
1787
|
+
maxOldSpaceMb?: number | bigint | null;
|
|
1788
|
+
vfsRpcTimeoutMs?: number | bigint | null;
|
|
1789
|
+
};
|
|
1790
|
+
type PythonSpawn = {
|
|
1791
|
+
source: string;
|
|
1792
|
+
options?: ActorLanguageSpawnOptions;
|
|
1793
|
+
};
|
|
1794
|
+
type PythonSpawnFile = {
|
|
1795
|
+
path: string;
|
|
1796
|
+
options?: ActorLanguageSpawnOptions;
|
|
1797
|
+
};
|
|
1798
|
+
type PythonSpawnModule = {
|
|
1799
|
+
module: string;
|
|
1800
|
+
options?: ActorLanguageSpawnOptions;
|
|
1801
|
+
};
|
|
1802
|
+
type RegistrySoftwareSourceInput = {
|
|
1803
|
+
/**
|
|
1804
|
+
* Registry package name, such as `git` or `ripgrep`.
|
|
1805
|
+
*/
|
|
1806
|
+
registry: string;
|
|
1807
|
+
/**
|
|
1808
|
+
* agentOS release whose manifest lists the package, such as `0.4.3` or
|
|
1809
|
+
* `latest`. Defaults to the agentOS release the actor is built with.
|
|
1810
|
+
*/
|
|
1811
|
+
version?: string | null;
|
|
1812
|
+
};
|
|
1813
|
+
type RemotePackageSource = {
|
|
1814
|
+
url: string;
|
|
1815
|
+
digest?: string | null;
|
|
1816
|
+
sizeBytes?: number | bigint | null;
|
|
1817
|
+
packageId?: string | null;
|
|
1818
|
+
};
|
|
1819
|
+
type RemotePackageSourceInput = {
|
|
1820
|
+
url: string;
|
|
1821
|
+
digest?: string | null;
|
|
1822
|
+
/**
|
|
1823
|
+
* Resolution metadata is accepted so a `v1.config.get` snapshot can be sent
|
|
1824
|
+
* back to `v1.config.set`. Core re-resolves the source and never trusts it.
|
|
1825
|
+
*/
|
|
1826
|
+
sizeBytes?: number | bigint | null;
|
|
1827
|
+
packageId?: string | null;
|
|
1828
|
+
};
|
|
1829
|
+
type ResourceLimits = {
|
|
1830
|
+
cpuCount?: number | bigint | null;
|
|
1831
|
+
maxProcesses?: number | bigint | null;
|
|
1832
|
+
maxOpenFds?: number | bigint | null;
|
|
1833
|
+
maxPipes?: number | bigint | null;
|
|
1834
|
+
maxPtys?: number | bigint | null;
|
|
1835
|
+
maxSockets?: number | bigint | null;
|
|
1836
|
+
maxConnections?: number | bigint | null;
|
|
1837
|
+
maxSocketBufferedBytes?: number | bigint | null;
|
|
1838
|
+
maxSocketDatagramQueueLen?: number | bigint | null;
|
|
1839
|
+
maxFilesystemBytes?: number | bigint | null;
|
|
1840
|
+
maxInodeCount?: number | bigint | null;
|
|
1841
|
+
maxBlockingReadMs?: number | bigint | null;
|
|
1842
|
+
maxPreadBytes?: number | bigint | null;
|
|
1843
|
+
maxFdWriteBytes?: number | bigint | null;
|
|
1844
|
+
maxProcessArgvBytes?: number | bigint | null;
|
|
1845
|
+
maxProcessEnvBytes?: number | bigint | null;
|
|
1846
|
+
maxReaddirEntries?: number | bigint | null;
|
|
1847
|
+
maxWasmFuel?: number | bigint | null;
|
|
1848
|
+
maxWasmMemoryBytes?: number | bigint | null;
|
|
1849
|
+
maxWasmStackBytes?: number | bigint | null;
|
|
1850
|
+
};
|
|
1851
|
+
type RootSnapshotExport = {
|
|
1852
|
+
kind: SnapshotExportKind;
|
|
1853
|
+
source: FilesystemSnapshotExport;
|
|
1854
|
+
};
|
|
1855
|
+
type RulePermissions<T> = {
|
|
1856
|
+
default?: PermissionMode | null;
|
|
1857
|
+
rules: Array<T>;
|
|
1858
|
+
};
|
|
1859
|
+
type SnapshotExportKind = "snapshot-export";
|
|
1860
|
+
type SoftwareInstall = {
|
|
1861
|
+
/**
|
|
1862
|
+
* A `{ url, digest? }` artifact or a `{ registry, version? }` package. The
|
|
1863
|
+
* result's `source` is the resolved, digest-pinned URL that is persisted.
|
|
1864
|
+
*/
|
|
1865
|
+
source: SoftwareSourceInput;
|
|
1866
|
+
expectedRevision?: number | bigint | null;
|
|
1867
|
+
};
|
|
1868
|
+
type SoftwareList = Record<string, never>;
|
|
1869
|
+
type SoftwareMutationResult = {
|
|
1870
|
+
software?: ActorInstalledSoftware | null;
|
|
1871
|
+
source: RemotePackageSource;
|
|
1872
|
+
config: ConfigSnapshot;
|
|
1873
|
+
};
|
|
1874
|
+
type SoftwareSourceInput = RegistrySoftwareSourceInput | RemotePackageSourceInput;
|
|
1875
|
+
type SoftwareUninstall = {
|
|
1876
|
+
packageId: string;
|
|
1877
|
+
expectedRevision?: number | bigint | null;
|
|
1878
|
+
};
|
|
1879
|
+
type SpawnStdio = "pipe" | "inherit";
|
|
1880
|
+
type SqliteLimits = {
|
|
1881
|
+
maxResultBytes?: number | bigint | null;
|
|
1882
|
+
};
|
|
1883
|
+
type TerminalClose = {
|
|
1884
|
+
terminal: ActorTerminalId;
|
|
1885
|
+
};
|
|
1886
|
+
type TerminalExitEvent = {
|
|
1887
|
+
terminal: ActorTerminalId;
|
|
1888
|
+
status: ActorExitStatus;
|
|
1889
|
+
};
|
|
1890
|
+
type TerminalList = Record<string, never>;
|
|
1891
|
+
type TerminalOpen = {
|
|
1892
|
+
options?: ActorTerminalOptions;
|
|
1893
|
+
};
|
|
1894
|
+
type TerminalOutputEvent = {
|
|
1895
|
+
terminal: ActorTerminalId;
|
|
1896
|
+
sequence: number | bigint;
|
|
1897
|
+
stream: ProcessStream;
|
|
1898
|
+
data: FileBytes;
|
|
1899
|
+
timestampMs: number | bigint;
|
|
1900
|
+
};
|
|
1901
|
+
type TerminalOutputRead = {
|
|
1902
|
+
terminal: ActorTerminalId;
|
|
1903
|
+
after?: number | bigint | null;
|
|
1904
|
+
maxBytes?: number | null;
|
|
1905
|
+
maxEvents?: number | null;
|
|
1906
|
+
};
|
|
1907
|
+
type TerminalPtyResize = {
|
|
1908
|
+
terminal: ActorTerminalId;
|
|
1909
|
+
cols: number;
|
|
1910
|
+
rows: number;
|
|
1911
|
+
};
|
|
1912
|
+
type TerminalStdinWrite = {
|
|
1913
|
+
terminal: ActorTerminalId;
|
|
1914
|
+
data: FileContentInput;
|
|
1915
|
+
};
|
|
1916
|
+
type TerminalWait = {
|
|
1917
|
+
terminal: ActorTerminalId;
|
|
1918
|
+
};
|
|
1919
|
+
type TlsLimits = {
|
|
1920
|
+
maxBufferedBytes?: number | bigint;
|
|
1921
|
+
};
|
|
1922
|
+
type TypeScriptCheck = {
|
|
1923
|
+
source: string;
|
|
1924
|
+
options?: ActorTypeScriptCheckOptions;
|
|
1925
|
+
};
|
|
1926
|
+
type TypeScriptCheckProject = {
|
|
1927
|
+
options?: ActorTypeScriptCheckOptions;
|
|
1928
|
+
};
|
|
1929
|
+
type TypeScriptEvaluate = {
|
|
1930
|
+
expression: string;
|
|
1931
|
+
options?: ActorTypeScriptExecutionOptions;
|
|
1932
|
+
};
|
|
1933
|
+
type TypeScriptExecute = {
|
|
1934
|
+
source: string;
|
|
1935
|
+
options?: ActorTypeScriptExecutionOptions;
|
|
1936
|
+
};
|
|
1937
|
+
type TypeScriptExecuteFile = {
|
|
1938
|
+
path: string;
|
|
1939
|
+
options?: ActorTypeScriptExecutionOptions;
|
|
1940
|
+
};
|
|
1941
|
+
type TypeScriptSpawn = {
|
|
1942
|
+
source: string;
|
|
1943
|
+
options?: ActorLanguageSpawnOptions;
|
|
1944
|
+
};
|
|
1945
|
+
type TypeScriptSpawnFile = {
|
|
1946
|
+
path: string;
|
|
1947
|
+
options?: ActorLanguageSpawnOptions;
|
|
1948
|
+
};
|
|
1949
|
+
type VmBooted = {
|
|
1950
|
+
generation: number | bigint;
|
|
1951
|
+
configRevision: number | bigint;
|
|
1952
|
+
bootedAtMs: number | bigint;
|
|
1953
|
+
};
|
|
1954
|
+
type VmGroupConfig = {
|
|
1955
|
+
gid: number;
|
|
1956
|
+
name: string;
|
|
1957
|
+
members: Array<string>;
|
|
1958
|
+
};
|
|
1959
|
+
type VmIssue = {
|
|
1960
|
+
code: string;
|
|
1961
|
+
message: string;
|
|
1962
|
+
atMs: number | bigint;
|
|
1963
|
+
};
|
|
1964
|
+
type VmLifecycleState = "initializing" | "preloading" | "booting" | "ready" | "degraded" | "stopping" | "failed";
|
|
1965
|
+
type VmLimitWarning = {
|
|
1966
|
+
limit: string;
|
|
1967
|
+
observed: number | bigint;
|
|
1968
|
+
capacity: number | bigint;
|
|
1969
|
+
message: string;
|
|
1970
|
+
};
|
|
1971
|
+
type VmRestart = Record<string, never>;
|
|
1972
|
+
type VmShutdown = {
|
|
1973
|
+
generation: number | bigint;
|
|
1974
|
+
reason: string;
|
|
1975
|
+
shutdownAtMs: number | bigint;
|
|
1976
|
+
};
|
|
1977
|
+
type VmStatus = Record<string, never>;
|
|
1978
|
+
type VmStatusSnapshot = {
|
|
1979
|
+
lifecycle: VmLifecycleState;
|
|
1980
|
+
configState: ConfigApplyState;
|
|
1981
|
+
desiredConfigRevision: number | bigint;
|
|
1982
|
+
appliedConfigRevision?: number | bigint | null;
|
|
1983
|
+
generation: number | bigint;
|
|
1984
|
+
lastBootAtMs?: number | bigint | null;
|
|
1985
|
+
lastShutdownAtMs?: number | bigint | null;
|
|
1986
|
+
packages: PackageStartupStatus;
|
|
1987
|
+
issues: Array<VmIssue>;
|
|
1988
|
+
core?: CoreSidecarStatus | null;
|
|
1989
|
+
};
|
|
1990
|
+
type VmUserAccountConfig = {
|
|
1991
|
+
uid: number;
|
|
1992
|
+
gid: number;
|
|
1993
|
+
username: string;
|
|
1994
|
+
homedir: string;
|
|
1995
|
+
shell: string;
|
|
1996
|
+
gecos?: string;
|
|
1997
|
+
supplementaryGids: Array<number>;
|
|
1998
|
+
};
|
|
1999
|
+
type VmUserConfig = {
|
|
2000
|
+
uid?: number;
|
|
2001
|
+
gid?: number;
|
|
2002
|
+
euid?: number;
|
|
2003
|
+
egid?: number;
|
|
2004
|
+
username?: string;
|
|
2005
|
+
homedir?: string;
|
|
2006
|
+
shell?: string;
|
|
2007
|
+
gecos?: string;
|
|
2008
|
+
groupName?: string;
|
|
2009
|
+
supplementaryGids?: Array<number>;
|
|
2010
|
+
accounts?: Array<VmUserAccountConfig>;
|
|
2011
|
+
groups?: Array<VmGroupConfig>;
|
|
2012
|
+
};
|
|
2013
|
+
type WasmLimits = {
|
|
2014
|
+
maxModuleFileBytes?: number | bigint | null;
|
|
2015
|
+
capturedOutputLimitBytes?: number | bigint | null;
|
|
2016
|
+
syncReadLimitBytes?: number | bigint | null;
|
|
2017
|
+
prewarmTimeoutMs?: number | bigint | null;
|
|
2018
|
+
runnerHeapLimitMb?: number | bigint | null;
|
|
2019
|
+
runnerCpuTimeLimitMs?: number | bigint | null;
|
|
2020
|
+
};
|
|
98
2021
|
}
|
|
99
|
-
|
|
100
|
-
|
|
2022
|
+
type AgentOsActorCreateInput = Input.AgentOsActorCreateInput;
|
|
2023
|
+
type AgentOsRivetError = {
|
|
2024
|
+
group: string;
|
|
2025
|
+
code: string;
|
|
2026
|
+
message: string;
|
|
2027
|
+
metadata: Output.JsonValue | null;
|
|
2028
|
+
};
|
|
2029
|
+
type V1ConfigGetInput = Record<string, never>;
|
|
2030
|
+
type V1ConfigGetOutput = {
|
|
2031
|
+
revision: number | bigint;
|
|
2032
|
+
desired: Output.AgentOsActorConfig;
|
|
2033
|
+
appliedRevision?: number | bigint | null;
|
|
2034
|
+
state: Output.ConfigApplyState;
|
|
2035
|
+
issues: Array<Output.VmIssue>;
|
|
2036
|
+
createdAtMs: number | bigint;
|
|
2037
|
+
updatedAtMs: number | bigint;
|
|
2038
|
+
};
|
|
2039
|
+
type V1ConfigPatchInput = {
|
|
2040
|
+
patch: Input.JsonValue;
|
|
2041
|
+
expectedRevision?: number | bigint | null;
|
|
2042
|
+
};
|
|
2043
|
+
type V1ConfigPatchOutput = {
|
|
2044
|
+
revision: number | bigint;
|
|
2045
|
+
desired: Output.AgentOsActorConfig;
|
|
2046
|
+
appliedRevision?: number | bigint | null;
|
|
2047
|
+
state: Output.ConfigApplyState;
|
|
2048
|
+
issues: Array<Output.VmIssue>;
|
|
2049
|
+
createdAtMs: number | bigint;
|
|
2050
|
+
updatedAtMs: number | bigint;
|
|
2051
|
+
};
|
|
2052
|
+
type V1ConfigSetInput = {
|
|
2053
|
+
config: Input.AgentOsActorConfigInput;
|
|
2054
|
+
expectedRevision?: number | bigint | null;
|
|
2055
|
+
};
|
|
2056
|
+
type V1ConfigSetOutput = {
|
|
2057
|
+
revision: number | bigint;
|
|
2058
|
+
desired: Output.AgentOsActorConfig;
|
|
2059
|
+
appliedRevision?: number | bigint | null;
|
|
2060
|
+
state: Output.ConfigApplyState;
|
|
2061
|
+
issues: Array<Output.VmIssue>;
|
|
2062
|
+
createdAtMs: number | bigint;
|
|
2063
|
+
updatedAtMs: number | bigint;
|
|
2064
|
+
};
|
|
2065
|
+
type V1ContextsCreateInput = {
|
|
2066
|
+
contextId: string;
|
|
2067
|
+
};
|
|
2068
|
+
type V1ContextsCreateOutput = {
|
|
2069
|
+
context: Output.ActorContextId;
|
|
101
2070
|
state: string;
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
}
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
*/
|
|
152
|
-
seq: number;
|
|
153
|
-
cols: number;
|
|
154
|
-
rows: number;
|
|
155
|
-
data: string;
|
|
156
|
-
}
|
|
157
|
-
type SerializableCronAction = {
|
|
158
|
-
type: "session";
|
|
159
|
-
agentType: string;
|
|
160
|
-
prompt: string;
|
|
161
|
-
cwd?: string;
|
|
162
|
-
} | {
|
|
163
|
-
type: "exec";
|
|
2071
|
+
language?: string | null;
|
|
2072
|
+
createdAtMs: number | bigint;
|
|
2073
|
+
lastStartedAtMs?: number | bigint | null;
|
|
2074
|
+
lastCompletedAtMs?: number | bigint | null;
|
|
2075
|
+
};
|
|
2076
|
+
type V1ContextsDeleteInput = {
|
|
2077
|
+
context: Input.ActorContextId;
|
|
2078
|
+
};
|
|
2079
|
+
type V1ContextsDeleteOutput = void;
|
|
2080
|
+
type V1ContextsGetInput = {
|
|
2081
|
+
context: Input.ActorContextId;
|
|
2082
|
+
};
|
|
2083
|
+
type V1ContextsGetOutput = {
|
|
2084
|
+
context: Output.ActorContextId;
|
|
2085
|
+
state: string;
|
|
2086
|
+
language?: string | null;
|
|
2087
|
+
createdAtMs: number | bigint;
|
|
2088
|
+
lastStartedAtMs?: number | bigint | null;
|
|
2089
|
+
lastCompletedAtMs?: number | bigint | null;
|
|
2090
|
+
};
|
|
2091
|
+
type V1ContextsListInput = Record<string, never>;
|
|
2092
|
+
type V1ContextsListOutput = Array<{
|
|
2093
|
+
context: Output.ActorContextId;
|
|
2094
|
+
state: string;
|
|
2095
|
+
language?: string | null;
|
|
2096
|
+
createdAtMs: number | bigint;
|
|
2097
|
+
lastStartedAtMs?: number | bigint | null;
|
|
2098
|
+
lastCompletedAtMs?: number | bigint | null;
|
|
2099
|
+
}>;
|
|
2100
|
+
type V1ContextsResetInput = {
|
|
2101
|
+
context: Input.ActorContextId;
|
|
2102
|
+
};
|
|
2103
|
+
type V1ContextsResetOutput = {
|
|
2104
|
+
context: Output.ActorContextId;
|
|
2105
|
+
state: string;
|
|
2106
|
+
language?: string | null;
|
|
2107
|
+
createdAtMs: number | bigint;
|
|
2108
|
+
lastStartedAtMs?: number | bigint | null;
|
|
2109
|
+
lastCompletedAtMs?: number | bigint | null;
|
|
2110
|
+
};
|
|
2111
|
+
type V1CronCancelInput = {
|
|
2112
|
+
name: string;
|
|
2113
|
+
};
|
|
2114
|
+
type V1CronCancelOutput = boolean;
|
|
2115
|
+
type V1CronListInput = Record<string, never>;
|
|
2116
|
+
type V1CronListOutput = Array<{
|
|
2117
|
+
name: string;
|
|
2118
|
+
expression: string;
|
|
2119
|
+
timezone?: string | null;
|
|
164
2120
|
command: string;
|
|
165
|
-
args
|
|
2121
|
+
args: Array<string>;
|
|
2122
|
+
options: Output.ActorSpawnOptions;
|
|
2123
|
+
configRevision: number | bigint;
|
|
2124
|
+
nextRunAtMs: number | bigint;
|
|
2125
|
+
lastRunAtMs?: number | bigint | null;
|
|
2126
|
+
maxHistory: number | bigint;
|
|
2127
|
+
}>;
|
|
2128
|
+
type V1CronScheduleInput = {
|
|
2129
|
+
name?: string | null;
|
|
2130
|
+
expression: string;
|
|
2131
|
+
timezone?: string | null;
|
|
2132
|
+
command: string;
|
|
2133
|
+
args?: Array<string>;
|
|
2134
|
+
options?: Input.ActorSpawnOptions;
|
|
2135
|
+
maxHistory?: number | bigint | null;
|
|
166
2136
|
};
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
type
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
2137
|
+
type V1CronScheduleOutput = {
|
|
2138
|
+
name: string;
|
|
2139
|
+
expression: string;
|
|
2140
|
+
timezone?: string | null;
|
|
2141
|
+
command: string;
|
|
2142
|
+
args: Array<string>;
|
|
2143
|
+
options: Output.ActorSpawnOptions;
|
|
2144
|
+
configRevision: number | bigint;
|
|
2145
|
+
nextRunAtMs: number | bigint;
|
|
2146
|
+
lastRunAtMs?: number | bigint | null;
|
|
2147
|
+
maxHistory: number | bigint;
|
|
2148
|
+
};
|
|
2149
|
+
type V1FilesystemExistsInput = {
|
|
2150
|
+
path: string;
|
|
2151
|
+
};
|
|
2152
|
+
type V1FilesystemExistsOutput = boolean;
|
|
2153
|
+
type V1FilesystemExportInput = {
|
|
2154
|
+
maxBytes?: number | null;
|
|
2155
|
+
};
|
|
2156
|
+
type V1FilesystemExportOutput = {
|
|
2157
|
+
kind: Output.SnapshotExportKind;
|
|
2158
|
+
source: Output.FilesystemSnapshotExport;
|
|
2159
|
+
};
|
|
2160
|
+
type V1FilesystemListMountsInput = Record<string, never>;
|
|
2161
|
+
type V1FilesystemListMountsOutput = Array<{
|
|
2162
|
+
path: string;
|
|
2163
|
+
kind: string;
|
|
2164
|
+
readOnly: boolean;
|
|
2165
|
+
}>;
|
|
2166
|
+
type V1FilesystemMkdirInput = {
|
|
2167
|
+
path: string;
|
|
2168
|
+
recursive?: boolean;
|
|
2169
|
+
};
|
|
2170
|
+
type V1FilesystemMkdirOutput = void;
|
|
2171
|
+
type V1FilesystemMoveInput = {
|
|
2172
|
+
from: string;
|
|
2173
|
+
to: string;
|
|
2174
|
+
};
|
|
2175
|
+
type V1FilesystemMoveOutput = void;
|
|
2176
|
+
type V1FilesystemReadFileInput = {
|
|
2177
|
+
path: string;
|
|
2178
|
+
maxBytes?: number | null;
|
|
2179
|
+
};
|
|
2180
|
+
type V1FilesystemReadFileOutput = Uint8Array;
|
|
2181
|
+
type V1FilesystemReadFilesInput = {
|
|
2182
|
+
paths: Array<string>;
|
|
2183
|
+
maxBytes?: number | null;
|
|
2184
|
+
};
|
|
2185
|
+
type V1FilesystemReadFilesOutput = Array<{
|
|
2186
|
+
path: string;
|
|
2187
|
+
content?: Output.FileBytes | null;
|
|
2188
|
+
error?: string | null;
|
|
2189
|
+
}>;
|
|
2190
|
+
type V1FilesystemReaddirInput = {
|
|
2191
|
+
path: string;
|
|
2192
|
+
};
|
|
2193
|
+
type V1FilesystemReaddirOutput = Array<string>;
|
|
2194
|
+
type V1FilesystemReaddirEntriesInput = {
|
|
2195
|
+
path: string;
|
|
2196
|
+
};
|
|
2197
|
+
type V1FilesystemReaddirEntriesOutput = Array<{
|
|
2198
|
+
name: string;
|
|
2199
|
+
isDirectory: boolean;
|
|
2200
|
+
isSymbolicLink: boolean;
|
|
2201
|
+
}>;
|
|
2202
|
+
type V1FilesystemReaddirRecursiveInput = {
|
|
2203
|
+
path: string;
|
|
2204
|
+
maxDepth?: number | null;
|
|
2205
|
+
exclude?: Array<string>;
|
|
2206
|
+
};
|
|
2207
|
+
type V1FilesystemReaddirRecursiveOutput = Array<{
|
|
2208
|
+
path: string;
|
|
2209
|
+
type: Output.DirEntryType;
|
|
2210
|
+
sizeBytes: number | bigint;
|
|
2211
|
+
}>;
|
|
2212
|
+
type V1FilesystemRemoveInput = {
|
|
2213
|
+
path: string;
|
|
2214
|
+
recursive?: boolean;
|
|
2215
|
+
};
|
|
2216
|
+
type V1FilesystemRemoveOutput = void;
|
|
2217
|
+
type V1FilesystemStatInput = {
|
|
2218
|
+
path: string;
|
|
2219
|
+
};
|
|
2220
|
+
type V1FilesystemStatOutput = {
|
|
2221
|
+
mode: number;
|
|
2222
|
+
sizeBytes: number | bigint;
|
|
2223
|
+
blocks: number | bigint;
|
|
2224
|
+
dev: number | bigint;
|
|
2225
|
+
rdev: number | bigint;
|
|
2226
|
+
isDirectory: boolean;
|
|
2227
|
+
isSymbolicLink: boolean;
|
|
2228
|
+
atimeMs: number;
|
|
2229
|
+
mtimeMs: number;
|
|
2230
|
+
ctimeMs: number;
|
|
2231
|
+
birthtimeMs: number;
|
|
2232
|
+
ino: number | bigint;
|
|
2233
|
+
nlink: number | bigint;
|
|
2234
|
+
uid: number;
|
|
2235
|
+
gid: number;
|
|
2236
|
+
};
|
|
2237
|
+
type V1FilesystemWriteFileInput = {
|
|
2238
|
+
path: string;
|
|
2239
|
+
content: Input.FileContentInput;
|
|
2240
|
+
};
|
|
2241
|
+
type V1FilesystemWriteFileOutput = void;
|
|
2242
|
+
type V1FilesystemWriteFilesInput = {
|
|
2243
|
+
entries: Array<Input.FilesystemWriteEntry>;
|
|
2244
|
+
};
|
|
2245
|
+
type V1FilesystemWriteFilesOutput = Array<{
|
|
2246
|
+
path: string;
|
|
2247
|
+
success: boolean;
|
|
2248
|
+
error?: string | null;
|
|
2249
|
+
}>;
|
|
2250
|
+
type V1JavaScriptEvaluateInput = {
|
|
2251
|
+
expression: string;
|
|
2252
|
+
options?: Input.ActorJavaScriptExecutionOptions;
|
|
2253
|
+
};
|
|
2254
|
+
type V1JavaScriptEvaluateOutput = {
|
|
2255
|
+
result: Output.ActorCodeExecutionResult;
|
|
2256
|
+
value?: Output.JsonValue | null;
|
|
2257
|
+
};
|
|
2258
|
+
type V1JavaScriptExecuteInput = {
|
|
2259
|
+
source: string;
|
|
2260
|
+
options?: Input.ActorJavaScriptExecutionOptions;
|
|
2261
|
+
};
|
|
2262
|
+
type V1JavaScriptExecuteOutput = {
|
|
2263
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2264
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2265
|
+
exitCode?: number | null;
|
|
2266
|
+
error?: Output.ActorExecutionError | null;
|
|
2267
|
+
stdout?: Output.FileBytes | null;
|
|
2268
|
+
stderr?: Output.FileBytes | null;
|
|
2269
|
+
stdoutTruncated?: boolean | null;
|
|
2270
|
+
stderrTruncated?: boolean | null;
|
|
2271
|
+
};
|
|
2272
|
+
type V1JavaScriptExecuteFileInput = {
|
|
2273
|
+
path: string;
|
|
2274
|
+
options?: Input.ActorLanguageExecutionOptions;
|
|
2275
|
+
};
|
|
2276
|
+
type V1JavaScriptExecuteFileOutput = {
|
|
2277
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2278
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2279
|
+
exitCode?: number | null;
|
|
2280
|
+
error?: Output.ActorExecutionError | null;
|
|
2281
|
+
stdout?: Output.FileBytes | null;
|
|
2282
|
+
stderr?: Output.FileBytes | null;
|
|
2283
|
+
stdoutTruncated?: boolean | null;
|
|
2284
|
+
stderrTruncated?: boolean | null;
|
|
2285
|
+
};
|
|
2286
|
+
type V1JavaScriptNpmInstallInput = {
|
|
2287
|
+
packages?: Array<string>;
|
|
2288
|
+
options?: Input.ActorNpmInstallOptions;
|
|
2289
|
+
};
|
|
2290
|
+
type V1JavaScriptNpmInstallOutput = {
|
|
2291
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2292
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2293
|
+
exitCode?: number | null;
|
|
2294
|
+
error?: Output.ActorExecutionError | null;
|
|
2295
|
+
stdout?: Output.FileBytes | null;
|
|
2296
|
+
stderr?: Output.FileBytes | null;
|
|
2297
|
+
stdoutTruncated?: boolean | null;
|
|
2298
|
+
stderrTruncated?: boolean | null;
|
|
2299
|
+
};
|
|
2300
|
+
type V1JavaScriptNpmRunPackageInput = {
|
|
2301
|
+
packageSpec: string;
|
|
2302
|
+
binary?: string | null;
|
|
2303
|
+
options?: Input.ActorLanguageExecutionOptions;
|
|
2304
|
+
};
|
|
2305
|
+
type V1JavaScriptNpmRunPackageOutput = {
|
|
2306
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2307
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2308
|
+
exitCode?: number | null;
|
|
2309
|
+
error?: Output.ActorExecutionError | null;
|
|
2310
|
+
stdout?: Output.FileBytes | null;
|
|
2311
|
+
stderr?: Output.FileBytes | null;
|
|
2312
|
+
stdoutTruncated?: boolean | null;
|
|
2313
|
+
stderrTruncated?: boolean | null;
|
|
2314
|
+
};
|
|
2315
|
+
type V1JavaScriptNpmRunScriptInput = {
|
|
2316
|
+
script: string;
|
|
2317
|
+
options?: Input.ActorLanguageExecutionOptions;
|
|
2318
|
+
};
|
|
2319
|
+
type V1JavaScriptNpmRunScriptOutput = {
|
|
2320
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2321
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2322
|
+
exitCode?: number | null;
|
|
2323
|
+
error?: Output.ActorExecutionError | null;
|
|
2324
|
+
stdout?: Output.FileBytes | null;
|
|
2325
|
+
stderr?: Output.FileBytes | null;
|
|
2326
|
+
stdoutTruncated?: boolean | null;
|
|
2327
|
+
stderrTruncated?: boolean | null;
|
|
2328
|
+
};
|
|
2329
|
+
type V1JavaScriptSpawnInput = {
|
|
2330
|
+
source: string;
|
|
2331
|
+
options?: Input.ActorLanguageSpawnOptions;
|
|
2332
|
+
};
|
|
2333
|
+
type V1JavaScriptSpawnOutput = {
|
|
2334
|
+
generation: number | bigint;
|
|
2335
|
+
pid: number;
|
|
2336
|
+
};
|
|
2337
|
+
type V1JavaScriptSpawnFileInput = {
|
|
2338
|
+
path: string;
|
|
2339
|
+
options?: Input.ActorLanguageSpawnOptions;
|
|
2340
|
+
};
|
|
2341
|
+
type V1JavaScriptSpawnFileOutput = {
|
|
2342
|
+
generation: number | bigint;
|
|
2343
|
+
pid: number;
|
|
2344
|
+
};
|
|
2345
|
+
type V1NetworkFetchInput = {
|
|
2346
|
+
request: Input.ActorHttpRequest;
|
|
2347
|
+
};
|
|
2348
|
+
type V1NetworkFetchOutput = {
|
|
188
2349
|
status: number;
|
|
189
2350
|
statusText: string;
|
|
190
|
-
headers:
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
2351
|
+
headers: Array<[string, string]>;
|
|
2352
|
+
body: Output.FileBytes;
|
|
2353
|
+
};
|
|
2354
|
+
type V1NetworkFetchStreamCancelInput = {
|
|
2355
|
+
stream: Input.ActorFetchStreamId;
|
|
2356
|
+
};
|
|
2357
|
+
type V1NetworkFetchStreamCancelOutput = void;
|
|
2358
|
+
type V1NetworkFetchStreamReadInput = {
|
|
2359
|
+
stream: Input.ActorFetchStreamId;
|
|
2360
|
+
maxBytes?: number | null;
|
|
2361
|
+
};
|
|
2362
|
+
type V1NetworkFetchStreamReadOutput = {
|
|
2363
|
+
body: Output.FileBytes;
|
|
2364
|
+
done: boolean;
|
|
2365
|
+
};
|
|
2366
|
+
type V1NetworkFetchStreamStartInput = {
|
|
2367
|
+
request: Input.ActorHttpRequest;
|
|
2368
|
+
};
|
|
2369
|
+
type V1NetworkFetchStreamStartOutput = {
|
|
2370
|
+
stream: Output.ActorFetchStreamId;
|
|
196
2371
|
status: number;
|
|
197
2372
|
statusText: string;
|
|
198
|
-
headers:
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
export: (c: AnyContext, options: _rivet_dev_agentos_core.ExportRootFilesystemOptions) => Promise<_rivet_dev_agentos_core.RootSnapshotExport>;
|
|
389
|
-
mount: (c: AnyContext, descriptor: DynamicMountDescriptor) => Promise<void>;
|
|
390
|
-
unmount: (c: AnyContext, path: string) => Promise<void>;
|
|
391
|
-
listMounts: (c: AnyContext) => Promise<_rivet_dev_agentos_core.MountInfo[]>;
|
|
392
|
-
};
|
|
393
|
-
network: {
|
|
394
|
-
httpRequest: (c: AnyContext, request: _rivet_dev_agentos_core.HttpRequest) => Promise<_rivet_dev_agentos_core.HttpResponse>;
|
|
395
|
-
};
|
|
396
|
-
software: {
|
|
397
|
-
list: (c: AnyContext) => Promise<{
|
|
398
|
-
packageName: string;
|
|
399
|
-
commands: string[];
|
|
400
|
-
}[]>;
|
|
401
|
-
link: (c: AnyContext, descriptor: PackageDescriptor) => Promise<void>;
|
|
402
|
-
};
|
|
403
|
-
agents: {
|
|
404
|
-
list: (c: AnyContext) => Promise<_rivet_dev_agentos_core.AgentRegistryEntry[]>;
|
|
405
|
-
};
|
|
406
|
-
sessions: {
|
|
407
|
-
open: (c: AnyContext, input: OpenSessionInput) => Promise<void>;
|
|
408
|
-
get: (c: AnyContext, input?: _rivet_dev_agentos_core.SessionTarget | undefined) => Promise<_rivet_dev_agentos_core.SessionInfo>;
|
|
409
|
-
list: (c: AnyContext, input?: _rivet_dev_agentos_core.ListSessionsInput | undefined) => Promise<_rivet_dev_agentos_core.SessionPage>;
|
|
410
|
-
delete: (c: AnyContext, input?: _rivet_dev_agentos_core.SessionTarget | undefined) => Promise<void>;
|
|
411
|
-
unload: (c: AnyContext, input?: _rivet_dev_agentos_core.SessionTarget | undefined) => Promise<void>;
|
|
412
|
-
prompt: (c: AnyContext, input: PromptInput) => Promise<_rivet_dev_agentos_core.PromptResult>;
|
|
413
|
-
cancelPrompt: (c: AnyContext, input?: _rivet_dev_agentos_core.SessionTarget | undefined) => Promise<_rivet_dev_agentos_core.CancelPromptResult>;
|
|
414
|
-
respondPermission: (c: AnyContext, input: _rivet_dev_agentos_core.PermissionResponse) => Promise<_rivet_dev_agentos_core.PermissionResponseResult>;
|
|
415
|
-
readHistory: (c: AnyContext, input?: _rivet_dev_agentos_core.ReadHistoryInput | undefined) => Promise<_rivet_dev_agentos_core.HistoryPage>;
|
|
416
|
-
getConfig: (c: AnyContext, input?: _rivet_dev_agentos_core.SessionTarget | undefined) => Promise<_rivet_dev_agentos_core.SessionConfig>;
|
|
417
|
-
setConfigOption: (c: AnyContext, input: _rivet_dev_agentos_core.SetSessionConfigOptionInput) => Promise<_rivet_dev_agentos_core.SessionConfig>;
|
|
418
|
-
getCapabilities: (c: AnyContext, input?: _rivet_dev_agentos_core.SessionTarget | undefined) => Promise<_rivet_dev_agentos_core.SessionCapabilities | null>;
|
|
419
|
-
getAgentInfo: (c: AnyContext, input?: _rivet_dev_agentos_core.SessionTarget | undefined) => Promise<_agentclientprotocol_sdk.Implementation | null>;
|
|
420
|
-
};
|
|
421
|
-
cron: {
|
|
422
|
-
schedule: (c: AnyContext, cronOptions: SerializableCronJobOptions) => Promise<{
|
|
423
|
-
id: string;
|
|
424
|
-
}>;
|
|
425
|
-
list: (c: AnyContext) => Promise<_rivet_dev_agentos_core.CronJobInfo[]>;
|
|
426
|
-
cancel: (c: AnyContext, id: string) => Promise<void>;
|
|
427
|
-
};
|
|
428
|
-
};
|
|
429
|
-
type AgentOsActions = ReturnType<typeof createAgentOsActions>;
|
|
430
|
-
interface AgentOsActorExtras<THostFunctions extends HostFunctionSchemas = HostFunctionSchemas> extends AgentOsOptions<THostFunctions> {
|
|
2373
|
+
headers: Array<[string, string]>;
|
|
2374
|
+
};
|
|
2375
|
+
type V1NetworkPreviewCreateInput = {
|
|
2376
|
+
port: number;
|
|
2377
|
+
ttlMs?: number | bigint | null;
|
|
2378
|
+
};
|
|
2379
|
+
type V1NetworkPreviewCreateOutput = {
|
|
2380
|
+
token: string;
|
|
2381
|
+
path: string;
|
|
2382
|
+
port: number;
|
|
2383
|
+
expiresAtMs: number | bigint;
|
|
2384
|
+
};
|
|
2385
|
+
type V1NetworkPreviewExpireInput = {
|
|
2386
|
+
token: string;
|
|
2387
|
+
};
|
|
2388
|
+
type V1NetworkPreviewExpireOutput = boolean;
|
|
2389
|
+
type V1ProcessGetInput = {
|
|
2390
|
+
process: Input.ActorProcessId;
|
|
2391
|
+
};
|
|
2392
|
+
type V1ProcessGetOutput = {
|
|
2393
|
+
process: Output.ActorProcessId;
|
|
2394
|
+
command: string;
|
|
2395
|
+
args: Array<string>;
|
|
2396
|
+
running: boolean;
|
|
2397
|
+
exit?: Output.ActorExitStatus | null;
|
|
2398
|
+
startedAtMs: number | bigint;
|
|
2399
|
+
};
|
|
2400
|
+
type V1ProcessListInput = Record<string, never>;
|
|
2401
|
+
type V1ProcessListOutput = Array<{
|
|
2402
|
+
process: Output.ActorProcessId;
|
|
2403
|
+
command: string;
|
|
2404
|
+
args: Array<string>;
|
|
2405
|
+
running: boolean;
|
|
2406
|
+
exit?: Output.ActorExitStatus | null;
|
|
2407
|
+
startedAtMs: number | bigint;
|
|
2408
|
+
}>;
|
|
2409
|
+
type V1ProcessOutputReadInput = {
|
|
2410
|
+
process: Input.ActorProcessId;
|
|
2411
|
+
after?: number | bigint | null;
|
|
2412
|
+
maxEvents?: number | null;
|
|
2413
|
+
maxBytes?: number | null;
|
|
2414
|
+
};
|
|
2415
|
+
type V1ProcessOutputReadOutput = {
|
|
2416
|
+
generation: number | bigint;
|
|
2417
|
+
events: Array<Output.ActorOutputEvent>;
|
|
2418
|
+
nextCursor?: number | bigint | null;
|
|
2419
|
+
hasMore: boolean;
|
|
2420
|
+
truncated: boolean;
|
|
2421
|
+
end?: Output.ActorExitStatus | null;
|
|
2422
|
+
};
|
|
2423
|
+
type V1ProcessPtyResizeInput = {
|
|
2424
|
+
process: Input.ActorProcessId;
|
|
2425
|
+
cols: number;
|
|
2426
|
+
rows: number;
|
|
2427
|
+
};
|
|
2428
|
+
type V1ProcessPtyResizeOutput = void;
|
|
2429
|
+
type V1ProcessRunInput = {
|
|
2430
|
+
command: string;
|
|
2431
|
+
args?: Array<string>;
|
|
2432
|
+
options?: Input.ActorExecOptions;
|
|
2433
|
+
};
|
|
2434
|
+
type V1ProcessRunOutput = {
|
|
2435
|
+
status: Output.ActorExitStatus;
|
|
2436
|
+
stdout: string;
|
|
2437
|
+
stderr: string;
|
|
2438
|
+
};
|
|
2439
|
+
type V1ProcessSignalInput = {
|
|
2440
|
+
process: Input.ActorProcessId;
|
|
2441
|
+
signal: Input.ActorSignal;
|
|
2442
|
+
};
|
|
2443
|
+
type V1ProcessSignalOutput = void;
|
|
2444
|
+
type V1ProcessSpawnInput = {
|
|
2445
|
+
command: string;
|
|
2446
|
+
args?: Array<string>;
|
|
2447
|
+
options?: Input.ActorSpawnOptions;
|
|
2448
|
+
};
|
|
2449
|
+
type V1ProcessSpawnOutput = {
|
|
2450
|
+
generation: number | bigint;
|
|
2451
|
+
pid: number;
|
|
2452
|
+
};
|
|
2453
|
+
type V1ProcessStdinCloseInput = {
|
|
2454
|
+
process: Input.ActorProcessId;
|
|
2455
|
+
};
|
|
2456
|
+
type V1ProcessStdinCloseOutput = void;
|
|
2457
|
+
type V1ProcessStdinWriteInput = {
|
|
2458
|
+
process: Input.ActorProcessId;
|
|
2459
|
+
data: Input.FileContentInput;
|
|
2460
|
+
};
|
|
2461
|
+
type V1ProcessStdinWriteOutput = void;
|
|
2462
|
+
type V1ProcessTreeInput = Record<string, never>;
|
|
2463
|
+
type V1ProcessTreeOutput = {
|
|
2464
|
+
generation: number | bigint;
|
|
2465
|
+
roots: Array<Output.ActorProcessTreeNode>;
|
|
2466
|
+
};
|
|
2467
|
+
type V1ProcessWaitInput = {
|
|
2468
|
+
process: Input.ActorProcessId;
|
|
2469
|
+
};
|
|
2470
|
+
type V1ProcessWaitOutput = {
|
|
2471
|
+
process: Output.ActorProcessId;
|
|
2472
|
+
status: Output.ActorExitStatus;
|
|
2473
|
+
};
|
|
2474
|
+
type V1PythonEvaluateInput = {
|
|
2475
|
+
expression: string;
|
|
2476
|
+
options?: Input.ActorInlineExecutionOptions;
|
|
2477
|
+
};
|
|
2478
|
+
type V1PythonEvaluateOutput = {
|
|
2479
|
+
result: Output.ActorCodeExecutionResult;
|
|
2480
|
+
value?: Output.JsonValue | null;
|
|
2481
|
+
};
|
|
2482
|
+
type V1PythonExecuteInput = {
|
|
2483
|
+
source: string;
|
|
2484
|
+
options?: Input.ActorInlineExecutionOptions;
|
|
2485
|
+
};
|
|
2486
|
+
type V1PythonExecuteOutput = {
|
|
2487
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2488
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2489
|
+
exitCode?: number | null;
|
|
2490
|
+
error?: Output.ActorExecutionError | null;
|
|
2491
|
+
stdout?: Output.FileBytes | null;
|
|
2492
|
+
stderr?: Output.FileBytes | null;
|
|
2493
|
+
stdoutTruncated?: boolean | null;
|
|
2494
|
+
stderrTruncated?: boolean | null;
|
|
2495
|
+
};
|
|
2496
|
+
type V1PythonExecuteFileInput = {
|
|
2497
|
+
path: string;
|
|
2498
|
+
options?: Input.ActorLanguageExecutionOptions;
|
|
2499
|
+
};
|
|
2500
|
+
type V1PythonExecuteFileOutput = {
|
|
2501
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2502
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2503
|
+
exitCode?: number | null;
|
|
2504
|
+
error?: Output.ActorExecutionError | null;
|
|
2505
|
+
stdout?: Output.FileBytes | null;
|
|
2506
|
+
stderr?: Output.FileBytes | null;
|
|
2507
|
+
stdoutTruncated?: boolean | null;
|
|
2508
|
+
stderrTruncated?: boolean | null;
|
|
2509
|
+
};
|
|
2510
|
+
type V1PythonExecuteModuleInput = {
|
|
2511
|
+
module: string;
|
|
2512
|
+
options?: Input.ActorLanguageExecutionOptions;
|
|
2513
|
+
};
|
|
2514
|
+
type V1PythonExecuteModuleOutput = {
|
|
2515
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2516
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2517
|
+
exitCode?: number | null;
|
|
2518
|
+
error?: Output.ActorExecutionError | null;
|
|
2519
|
+
stdout?: Output.FileBytes | null;
|
|
2520
|
+
stderr?: Output.FileBytes | null;
|
|
2521
|
+
stdoutTruncated?: boolean | null;
|
|
2522
|
+
stderrTruncated?: boolean | null;
|
|
2523
|
+
};
|
|
2524
|
+
type V1PythonInstallInput = {
|
|
2525
|
+
packages?: Array<string>;
|
|
2526
|
+
options?: Input.ActorPythonInstallOptions;
|
|
2527
|
+
};
|
|
2528
|
+
type V1PythonInstallOutput = {
|
|
2529
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2530
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2531
|
+
exitCode?: number | null;
|
|
2532
|
+
error?: Output.ActorExecutionError | null;
|
|
2533
|
+
stdout?: Output.FileBytes | null;
|
|
2534
|
+
stderr?: Output.FileBytes | null;
|
|
2535
|
+
stdoutTruncated?: boolean | null;
|
|
2536
|
+
stderrTruncated?: boolean | null;
|
|
2537
|
+
};
|
|
2538
|
+
type V1PythonSpawnInput = {
|
|
2539
|
+
source: string;
|
|
2540
|
+
options?: Input.ActorLanguageSpawnOptions;
|
|
2541
|
+
};
|
|
2542
|
+
type V1PythonSpawnOutput = {
|
|
2543
|
+
generation: number | bigint;
|
|
2544
|
+
pid: number;
|
|
2545
|
+
};
|
|
2546
|
+
type V1PythonSpawnFileInput = {
|
|
2547
|
+
path: string;
|
|
2548
|
+
options?: Input.ActorLanguageSpawnOptions;
|
|
2549
|
+
};
|
|
2550
|
+
type V1PythonSpawnFileOutput = {
|
|
2551
|
+
generation: number | bigint;
|
|
2552
|
+
pid: number;
|
|
2553
|
+
};
|
|
2554
|
+
type V1PythonSpawnModuleInput = {
|
|
2555
|
+
module: string;
|
|
2556
|
+
options?: Input.ActorLanguageSpawnOptions;
|
|
2557
|
+
};
|
|
2558
|
+
type V1PythonSpawnModuleOutput = {
|
|
2559
|
+
generation: number | bigint;
|
|
2560
|
+
pid: number;
|
|
2561
|
+
};
|
|
2562
|
+
type V1SoftwareInstallInput = {
|
|
431
2563
|
/**
|
|
432
|
-
*
|
|
433
|
-
*
|
|
434
|
-
* database cannot be replaced.
|
|
2564
|
+
* A `{ url, digest? }` artifact or a `{ registry, version? }` package. The
|
|
2565
|
+
* result's `source` is the resolved, digest-pinned URL that is persisted.
|
|
435
2566
|
*/
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
2567
|
+
source: Input.SoftwareSourceInput;
|
|
2568
|
+
expectedRevision?: number | bigint | null;
|
|
2569
|
+
};
|
|
2570
|
+
type V1SoftwareInstallOutput = {
|
|
2571
|
+
software?: Output.ActorInstalledSoftware | null;
|
|
2572
|
+
source: Output.RemotePackageSource;
|
|
2573
|
+
config: Output.ConfigSnapshot;
|
|
2574
|
+
};
|
|
2575
|
+
type V1SoftwareListInput = Record<string, never>;
|
|
2576
|
+
type V1SoftwareListOutput = Array<{
|
|
2577
|
+
packageId: string;
|
|
2578
|
+
digest: string;
|
|
2579
|
+
sizeBytes: number | bigint;
|
|
2580
|
+
packageName: string;
|
|
2581
|
+
version: string;
|
|
2582
|
+
commands: Array<string>;
|
|
2583
|
+
}>;
|
|
2584
|
+
type V1SoftwareUninstallInput = {
|
|
2585
|
+
packageId: string;
|
|
2586
|
+
expectedRevision?: number | bigint | null;
|
|
2587
|
+
};
|
|
2588
|
+
type V1SoftwareUninstallOutput = {
|
|
2589
|
+
software?: Output.ActorInstalledSoftware | null;
|
|
2590
|
+
source: Output.RemotePackageSource;
|
|
2591
|
+
config: Output.ConfigSnapshot;
|
|
2592
|
+
};
|
|
2593
|
+
type V1TerminalCloseInput = {
|
|
2594
|
+
terminal: Input.ActorTerminalId;
|
|
2595
|
+
};
|
|
2596
|
+
type V1TerminalCloseOutput = void;
|
|
2597
|
+
type V1TerminalListInput = Record<string, never>;
|
|
2598
|
+
type V1TerminalListOutput = Array<{
|
|
2599
|
+
terminal: Output.ActorTerminalId;
|
|
2600
|
+
pid: number;
|
|
2601
|
+
running: boolean;
|
|
2602
|
+
exit?: Output.ActorExitStatus | null;
|
|
2603
|
+
}>;
|
|
2604
|
+
type V1TerminalOpenInput = {
|
|
2605
|
+
options?: Input.ActorTerminalOptions;
|
|
2606
|
+
};
|
|
2607
|
+
type V1TerminalOpenOutput = {
|
|
2608
|
+
generation: number | bigint;
|
|
2609
|
+
shellId: string;
|
|
2610
|
+
};
|
|
2611
|
+
type V1TerminalOutputReadInput = {
|
|
2612
|
+
terminal: Input.ActorTerminalId;
|
|
2613
|
+
after?: number | bigint | null;
|
|
2614
|
+
maxBytes?: number | null;
|
|
2615
|
+
maxEvents?: number | null;
|
|
2616
|
+
};
|
|
2617
|
+
type V1TerminalOutputReadOutput = {
|
|
2618
|
+
generation: number | bigint;
|
|
2619
|
+
events: Array<Output.ActorOutputEvent>;
|
|
2620
|
+
nextCursor?: number | bigint | null;
|
|
2621
|
+
hasMore: boolean;
|
|
2622
|
+
truncated: boolean;
|
|
2623
|
+
end?: Output.ActorExitStatus | null;
|
|
2624
|
+
};
|
|
2625
|
+
type V1TerminalPtyResizeInput = {
|
|
2626
|
+
terminal: Input.ActorTerminalId;
|
|
2627
|
+
cols: number;
|
|
2628
|
+
rows: number;
|
|
2629
|
+
};
|
|
2630
|
+
type V1TerminalPtyResizeOutput = void;
|
|
2631
|
+
type V1TerminalStdinWriteInput = {
|
|
2632
|
+
terminal: Input.ActorTerminalId;
|
|
2633
|
+
data: Input.FileContentInput;
|
|
2634
|
+
};
|
|
2635
|
+
type V1TerminalStdinWriteOutput = void;
|
|
2636
|
+
type V1TerminalWaitInput = {
|
|
2637
|
+
terminal: Input.ActorTerminalId;
|
|
2638
|
+
};
|
|
2639
|
+
type V1TerminalWaitOutput = {
|
|
2640
|
+
terminal: Output.ActorTerminalId;
|
|
2641
|
+
status: Output.ActorExitStatus;
|
|
2642
|
+
};
|
|
2643
|
+
type V1TypeScriptCheckInput = {
|
|
2644
|
+
source: string;
|
|
2645
|
+
options?: Input.ActorTypeScriptCheckOptions;
|
|
2646
|
+
};
|
|
2647
|
+
type V1TypeScriptCheckOutput = {
|
|
2648
|
+
result: Output.ActorCodeExecutionResult;
|
|
2649
|
+
hasErrors?: boolean | null;
|
|
2650
|
+
diagnostics: Array<Output.ActorTypeScriptDiagnostic>;
|
|
2651
|
+
};
|
|
2652
|
+
type V1TypeScriptCheckProjectInput = {
|
|
2653
|
+
options?: Input.ActorTypeScriptCheckOptions;
|
|
2654
|
+
};
|
|
2655
|
+
type V1TypeScriptCheckProjectOutput = {
|
|
2656
|
+
result: Output.ActorCodeExecutionResult;
|
|
2657
|
+
hasErrors?: boolean | null;
|
|
2658
|
+
diagnostics: Array<Output.ActorTypeScriptDiagnostic>;
|
|
2659
|
+
};
|
|
2660
|
+
type V1TypeScriptEvaluateInput = {
|
|
2661
|
+
expression: string;
|
|
2662
|
+
options?: Input.ActorTypeScriptExecutionOptions;
|
|
2663
|
+
};
|
|
2664
|
+
type V1TypeScriptEvaluateOutput = {
|
|
2665
|
+
result: Output.ActorCodeExecutionResult;
|
|
2666
|
+
value?: Output.JsonValue | null;
|
|
2667
|
+
};
|
|
2668
|
+
type V1TypeScriptExecuteInput = {
|
|
2669
|
+
source: string;
|
|
2670
|
+
options?: Input.ActorTypeScriptExecutionOptions;
|
|
2671
|
+
};
|
|
2672
|
+
type V1TypeScriptExecuteOutput = {
|
|
2673
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2674
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2675
|
+
exitCode?: number | null;
|
|
2676
|
+
error?: Output.ActorExecutionError | null;
|
|
2677
|
+
stdout?: Output.FileBytes | null;
|
|
2678
|
+
stderr?: Output.FileBytes | null;
|
|
2679
|
+
stdoutTruncated?: boolean | null;
|
|
2680
|
+
stderrTruncated?: boolean | null;
|
|
2681
|
+
};
|
|
2682
|
+
type V1TypeScriptExecuteFileInput = {
|
|
2683
|
+
path: string;
|
|
2684
|
+
options?: Input.ActorTypeScriptExecutionOptions;
|
|
2685
|
+
};
|
|
2686
|
+
type V1TypeScriptExecuteFileOutput = {
|
|
2687
|
+
execution?: Output.ActorExecutionDescriptor | null;
|
|
2688
|
+
outcome: Output.ActorExecutionOutcome;
|
|
2689
|
+
exitCode?: number | null;
|
|
2690
|
+
error?: Output.ActorExecutionError | null;
|
|
2691
|
+
stdout?: Output.FileBytes | null;
|
|
2692
|
+
stderr?: Output.FileBytes | null;
|
|
2693
|
+
stdoutTruncated?: boolean | null;
|
|
2694
|
+
stderrTruncated?: boolean | null;
|
|
2695
|
+
};
|
|
2696
|
+
type V1TypeScriptSpawnInput = {
|
|
2697
|
+
source: string;
|
|
2698
|
+
options?: Input.ActorLanguageSpawnOptions;
|
|
2699
|
+
};
|
|
2700
|
+
type V1TypeScriptSpawnOutput = {
|
|
2701
|
+
generation: number | bigint;
|
|
2702
|
+
pid: number;
|
|
2703
|
+
};
|
|
2704
|
+
type V1TypeScriptSpawnFileInput = {
|
|
2705
|
+
path: string;
|
|
2706
|
+
options?: Input.ActorLanguageSpawnOptions;
|
|
2707
|
+
};
|
|
2708
|
+
type V1TypeScriptSpawnFileOutput = {
|
|
2709
|
+
generation: number | bigint;
|
|
2710
|
+
pid: number;
|
|
2711
|
+
};
|
|
2712
|
+
type V1VmRestartInput = Record<string, never>;
|
|
2713
|
+
type V1VmRestartOutput = {
|
|
2714
|
+
lifecycle: Output.VmLifecycleState;
|
|
2715
|
+
configState: Output.ConfigApplyState;
|
|
2716
|
+
desiredConfigRevision: number | bigint;
|
|
2717
|
+
appliedConfigRevision?: number | bigint | null;
|
|
2718
|
+
generation: number | bigint;
|
|
2719
|
+
lastBootAtMs?: number | bigint | null;
|
|
2720
|
+
lastShutdownAtMs?: number | bigint | null;
|
|
2721
|
+
packages: Output.PackageStartupStatus;
|
|
2722
|
+
issues: Array<Output.VmIssue>;
|
|
2723
|
+
core?: Output.CoreSidecarStatus | null;
|
|
2724
|
+
};
|
|
2725
|
+
type V1VmStatusInput = Record<string, never>;
|
|
2726
|
+
type V1VmStatusOutput = {
|
|
2727
|
+
lifecycle: Output.VmLifecycleState;
|
|
2728
|
+
configState: Output.ConfigApplyState;
|
|
2729
|
+
desiredConfigRevision: number | bigint;
|
|
2730
|
+
appliedConfigRevision?: number | bigint | null;
|
|
2731
|
+
generation: number | bigint;
|
|
2732
|
+
lastBootAtMs?: number | bigint | null;
|
|
2733
|
+
lastShutdownAtMs?: number | bigint | null;
|
|
2734
|
+
packages: Output.PackageStartupStatus;
|
|
2735
|
+
issues: Array<Output.VmIssue>;
|
|
2736
|
+
core?: Output.CoreSidecarStatus | null;
|
|
2737
|
+
};
|
|
2738
|
+
interface AgentOsActions {
|
|
2739
|
+
readonly v1: {
|
|
2740
|
+
readonly config: {
|
|
2741
|
+
readonly get: (input: V1ConfigGetInput) => Promise<V1ConfigGetOutput>;
|
|
2742
|
+
readonly patch: (input: V1ConfigPatchInput) => Promise<V1ConfigPatchOutput>;
|
|
2743
|
+
readonly set: (input: V1ConfigSetInput) => Promise<V1ConfigSetOutput>;
|
|
2744
|
+
};
|
|
2745
|
+
readonly contexts: {
|
|
2746
|
+
readonly create: (input: V1ContextsCreateInput) => Promise<V1ContextsCreateOutput>;
|
|
2747
|
+
readonly delete: (input: V1ContextsDeleteInput) => Promise<V1ContextsDeleteOutput>;
|
|
2748
|
+
readonly get: (input: V1ContextsGetInput) => Promise<V1ContextsGetOutput>;
|
|
2749
|
+
readonly list: (input: V1ContextsListInput) => Promise<V1ContextsListOutput>;
|
|
2750
|
+
readonly reset: (input: V1ContextsResetInput) => Promise<V1ContextsResetOutput>;
|
|
2751
|
+
};
|
|
2752
|
+
readonly cron: {
|
|
2753
|
+
readonly cancel: (input: V1CronCancelInput) => Promise<V1CronCancelOutput>;
|
|
2754
|
+
readonly list: (input: V1CronListInput) => Promise<V1CronListOutput>;
|
|
2755
|
+
readonly schedule: (input: V1CronScheduleInput) => Promise<V1CronScheduleOutput>;
|
|
2756
|
+
};
|
|
2757
|
+
readonly filesystem: {
|
|
2758
|
+
readonly exists: (input: V1FilesystemExistsInput) => Promise<V1FilesystemExistsOutput>;
|
|
2759
|
+
readonly export: (input: V1FilesystemExportInput) => Promise<V1FilesystemExportOutput>;
|
|
2760
|
+
readonly listMounts: (input: V1FilesystemListMountsInput) => Promise<V1FilesystemListMountsOutput>;
|
|
2761
|
+
readonly mkdir: (input: V1FilesystemMkdirInput) => Promise<V1FilesystemMkdirOutput>;
|
|
2762
|
+
readonly move: (input: V1FilesystemMoveInput) => Promise<V1FilesystemMoveOutput>;
|
|
2763
|
+
readonly readFile: (input: V1FilesystemReadFileInput) => Promise<V1FilesystemReadFileOutput>;
|
|
2764
|
+
readonly readFiles: (input: V1FilesystemReadFilesInput) => Promise<V1FilesystemReadFilesOutput>;
|
|
2765
|
+
readonly readdir: (input: V1FilesystemReaddirInput) => Promise<V1FilesystemReaddirOutput>;
|
|
2766
|
+
readonly readdirEntries: (input: V1FilesystemReaddirEntriesInput) => Promise<V1FilesystemReaddirEntriesOutput>;
|
|
2767
|
+
readonly readdirRecursive: (input: V1FilesystemReaddirRecursiveInput) => Promise<V1FilesystemReaddirRecursiveOutput>;
|
|
2768
|
+
readonly remove: (input: V1FilesystemRemoveInput) => Promise<V1FilesystemRemoveOutput>;
|
|
2769
|
+
readonly stat: (input: V1FilesystemStatInput) => Promise<V1FilesystemStatOutput>;
|
|
2770
|
+
readonly writeFile: (input: V1FilesystemWriteFileInput) => Promise<V1FilesystemWriteFileOutput>;
|
|
2771
|
+
readonly writeFiles: (input: V1FilesystemWriteFilesInput) => Promise<V1FilesystemWriteFilesOutput>;
|
|
2772
|
+
};
|
|
2773
|
+
readonly javascript: {
|
|
2774
|
+
readonly evaluate: (input: V1JavaScriptEvaluateInput) => Promise<V1JavaScriptEvaluateOutput>;
|
|
2775
|
+
readonly execute: (input: V1JavaScriptExecuteInput) => Promise<V1JavaScriptExecuteOutput>;
|
|
2776
|
+
readonly executeFile: (input: V1JavaScriptExecuteFileInput) => Promise<V1JavaScriptExecuteFileOutput>;
|
|
2777
|
+
readonly npm: {
|
|
2778
|
+
readonly install: (input: V1JavaScriptNpmInstallInput) => Promise<V1JavaScriptNpmInstallOutput>;
|
|
2779
|
+
readonly runPackage: (input: V1JavaScriptNpmRunPackageInput) => Promise<V1JavaScriptNpmRunPackageOutput>;
|
|
2780
|
+
readonly runScript: (input: V1JavaScriptNpmRunScriptInput) => Promise<V1JavaScriptNpmRunScriptOutput>;
|
|
2781
|
+
};
|
|
2782
|
+
readonly spawn: (input: V1JavaScriptSpawnInput) => Promise<V1JavaScriptSpawnOutput>;
|
|
2783
|
+
readonly spawnFile: (input: V1JavaScriptSpawnFileInput) => Promise<V1JavaScriptSpawnFileOutput>;
|
|
2784
|
+
};
|
|
2785
|
+
readonly network: {
|
|
2786
|
+
readonly fetch: (input: V1NetworkFetchInput) => Promise<V1NetworkFetchOutput>;
|
|
2787
|
+
readonly fetchStream: {
|
|
2788
|
+
readonly cancel: (input: V1NetworkFetchStreamCancelInput) => Promise<V1NetworkFetchStreamCancelOutput>;
|
|
2789
|
+
readonly read: (input: V1NetworkFetchStreamReadInput) => Promise<V1NetworkFetchStreamReadOutput>;
|
|
2790
|
+
readonly start: (input: V1NetworkFetchStreamStartInput) => Promise<V1NetworkFetchStreamStartOutput>;
|
|
2791
|
+
};
|
|
2792
|
+
readonly preview: {
|
|
2793
|
+
readonly create: (input: V1NetworkPreviewCreateInput) => Promise<V1NetworkPreviewCreateOutput>;
|
|
2794
|
+
readonly expire: (input: V1NetworkPreviewExpireInput) => Promise<V1NetworkPreviewExpireOutput>;
|
|
2795
|
+
};
|
|
2796
|
+
};
|
|
2797
|
+
readonly process: {
|
|
2798
|
+
readonly get: (input: V1ProcessGetInput) => Promise<V1ProcessGetOutput>;
|
|
2799
|
+
readonly list: (input: V1ProcessListInput) => Promise<V1ProcessListOutput>;
|
|
2800
|
+
readonly output: {
|
|
2801
|
+
readonly read: (input: V1ProcessOutputReadInput) => Promise<V1ProcessOutputReadOutput>;
|
|
2802
|
+
};
|
|
2803
|
+
readonly pty: {
|
|
2804
|
+
readonly resize: (input: V1ProcessPtyResizeInput) => Promise<V1ProcessPtyResizeOutput>;
|
|
2805
|
+
};
|
|
2806
|
+
readonly run: (input: V1ProcessRunInput) => Promise<V1ProcessRunOutput>;
|
|
2807
|
+
readonly signal: (input: V1ProcessSignalInput) => Promise<V1ProcessSignalOutput>;
|
|
2808
|
+
readonly spawn: (input: V1ProcessSpawnInput) => Promise<V1ProcessSpawnOutput>;
|
|
2809
|
+
readonly stdin: {
|
|
2810
|
+
readonly close: (input: V1ProcessStdinCloseInput) => Promise<V1ProcessStdinCloseOutput>;
|
|
2811
|
+
readonly write: (input: V1ProcessStdinWriteInput) => Promise<V1ProcessStdinWriteOutput>;
|
|
2812
|
+
};
|
|
2813
|
+
readonly tree: (input: V1ProcessTreeInput) => Promise<V1ProcessTreeOutput>;
|
|
2814
|
+
readonly wait: (input: V1ProcessWaitInput) => Promise<V1ProcessWaitOutput>;
|
|
2815
|
+
};
|
|
2816
|
+
readonly python: {
|
|
2817
|
+
readonly evaluate: (input: V1PythonEvaluateInput) => Promise<V1PythonEvaluateOutput>;
|
|
2818
|
+
readonly execute: (input: V1PythonExecuteInput) => Promise<V1PythonExecuteOutput>;
|
|
2819
|
+
readonly executeFile: (input: V1PythonExecuteFileInput) => Promise<V1PythonExecuteFileOutput>;
|
|
2820
|
+
readonly executeModule: (input: V1PythonExecuteModuleInput) => Promise<V1PythonExecuteModuleOutput>;
|
|
2821
|
+
readonly install: (input: V1PythonInstallInput) => Promise<V1PythonInstallOutput>;
|
|
2822
|
+
readonly spawn: (input: V1PythonSpawnInput) => Promise<V1PythonSpawnOutput>;
|
|
2823
|
+
readonly spawnFile: (input: V1PythonSpawnFileInput) => Promise<V1PythonSpawnFileOutput>;
|
|
2824
|
+
readonly spawnModule: (input: V1PythonSpawnModuleInput) => Promise<V1PythonSpawnModuleOutput>;
|
|
2825
|
+
};
|
|
2826
|
+
readonly software: {
|
|
2827
|
+
readonly install: (input: V1SoftwareInstallInput) => Promise<V1SoftwareInstallOutput>;
|
|
2828
|
+
readonly list: (input: V1SoftwareListInput) => Promise<V1SoftwareListOutput>;
|
|
2829
|
+
readonly uninstall: (input: V1SoftwareUninstallInput) => Promise<V1SoftwareUninstallOutput>;
|
|
2830
|
+
};
|
|
2831
|
+
readonly terminal: {
|
|
2832
|
+
readonly close: (input: V1TerminalCloseInput) => Promise<V1TerminalCloseOutput>;
|
|
2833
|
+
readonly list: (input: V1TerminalListInput) => Promise<V1TerminalListOutput>;
|
|
2834
|
+
readonly open: (input: V1TerminalOpenInput) => Promise<V1TerminalOpenOutput>;
|
|
2835
|
+
readonly output: {
|
|
2836
|
+
readonly read: (input: V1TerminalOutputReadInput) => Promise<V1TerminalOutputReadOutput>;
|
|
2837
|
+
};
|
|
2838
|
+
readonly pty: {
|
|
2839
|
+
readonly resize: (input: V1TerminalPtyResizeInput) => Promise<V1TerminalPtyResizeOutput>;
|
|
2840
|
+
};
|
|
2841
|
+
readonly stdin: {
|
|
2842
|
+
readonly write: (input: V1TerminalStdinWriteInput) => Promise<V1TerminalStdinWriteOutput>;
|
|
2843
|
+
};
|
|
2844
|
+
readonly wait: (input: V1TerminalWaitInput) => Promise<V1TerminalWaitOutput>;
|
|
2845
|
+
};
|
|
2846
|
+
readonly typescript: {
|
|
2847
|
+
readonly check: (input: V1TypeScriptCheckInput) => Promise<V1TypeScriptCheckOutput>;
|
|
2848
|
+
readonly checkProject: (input: V1TypeScriptCheckProjectInput) => Promise<V1TypeScriptCheckProjectOutput>;
|
|
2849
|
+
readonly evaluate: (input: V1TypeScriptEvaluateInput) => Promise<V1TypeScriptEvaluateOutput>;
|
|
2850
|
+
readonly execute: (input: V1TypeScriptExecuteInput) => Promise<V1TypeScriptExecuteOutput>;
|
|
2851
|
+
readonly executeFile: (input: V1TypeScriptExecuteFileInput) => Promise<V1TypeScriptExecuteFileOutput>;
|
|
2852
|
+
readonly spawn: (input: V1TypeScriptSpawnInput) => Promise<V1TypeScriptSpawnOutput>;
|
|
2853
|
+
readonly spawnFile: (input: V1TypeScriptSpawnFileInput) => Promise<V1TypeScriptSpawnFileOutput>;
|
|
2854
|
+
};
|
|
2855
|
+
readonly vm: {
|
|
2856
|
+
readonly restart: (input: V1VmRestartInput) => Promise<V1VmRestartOutput>;
|
|
2857
|
+
readonly status: (input: V1VmStatusInput) => Promise<V1VmStatusOutput>;
|
|
2858
|
+
};
|
|
453
2859
|
};
|
|
454
2860
|
}
|
|
455
|
-
type
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
2861
|
+
type AgentOsEvents = {
|
|
2862
|
+
readonly "vm.booted": Type<{
|
|
2863
|
+
generation: number | bigint;
|
|
2864
|
+
configRevision: number | bigint;
|
|
2865
|
+
bootedAtMs: number | bigint;
|
|
2866
|
+
}>;
|
|
2867
|
+
readonly "vm.shutdown": Type<{
|
|
2868
|
+
generation: number | bigint;
|
|
2869
|
+
reason: string;
|
|
2870
|
+
shutdownAtMs: number | bigint;
|
|
2871
|
+
}>;
|
|
2872
|
+
readonly "vm.limitWarning": Type<{
|
|
2873
|
+
limit: string;
|
|
2874
|
+
observed: number | bigint;
|
|
2875
|
+
capacity: number | bigint;
|
|
2876
|
+
message: string;
|
|
2877
|
+
}>;
|
|
2878
|
+
readonly "process.output": Type<{
|
|
2879
|
+
process: Output.ActorProcessId;
|
|
2880
|
+
sequence: number | bigint;
|
|
2881
|
+
stream: Output.ProcessStream;
|
|
2882
|
+
data: Output.FileBytes;
|
|
2883
|
+
timestampMs: number | bigint;
|
|
2884
|
+
}>;
|
|
2885
|
+
readonly "process.exit": Type<{
|
|
2886
|
+
process: Output.ActorProcessId;
|
|
2887
|
+
status: Output.ActorExitStatus;
|
|
2888
|
+
}>;
|
|
2889
|
+
readonly "terminal.output": Type<{
|
|
2890
|
+
terminal: Output.ActorTerminalId;
|
|
2891
|
+
sequence: number | bigint;
|
|
2892
|
+
stream: Output.ProcessStream;
|
|
2893
|
+
data: Output.FileBytes;
|
|
2894
|
+
timestampMs: number | bigint;
|
|
2895
|
+
}>;
|
|
2896
|
+
readonly "terminal.exit": Type<{
|
|
2897
|
+
terminal: Output.ActorTerminalId;
|
|
2898
|
+
status: Output.ActorExitStatus;
|
|
2899
|
+
}>;
|
|
2900
|
+
readonly "cron.fired": Type<{
|
|
2901
|
+
scheduleName: string;
|
|
2902
|
+
process?: Output.ActorProcessId | null;
|
|
2903
|
+
error?: Output.CronLaunchError | null;
|
|
2904
|
+
firedAtMs: number | bigint;
|
|
2905
|
+
}>;
|
|
2906
|
+
};
|
|
2907
|
+
type AgentOsActorDefinition = BaseActorDefinition<undefined, undefined, undefined, undefined, AgentOsActorCreateInput, undefined, AgentOsEvents, Record<never, never>, Record<never, never>>;
|
|
2908
|
+
type AgentOsActorConnection = ActorConn<AgentOsActorDefinition> & AgentOsActions;
|
|
2909
|
+
type AgentOsActorHandle = Omit<ActorHandle<AgentOsActorDefinition>, "connect"> & AgentOsActions & {
|
|
2910
|
+
connect(params?: unknown, options?: ActorConnectOptions): AgentOsActorConnection;
|
|
2911
|
+
};
|
|
2912
|
+
type AgentOsRegistry = Registry<{
|
|
2913
|
+
agentOS: AgentOsActorDefinition;
|
|
2914
|
+
}>;
|
|
2915
|
+
type AgentOsCreateOptions = Omit<CreateOptions, "input"> & {
|
|
2916
|
+
input?: AgentOsActorCreateInput;
|
|
2917
|
+
};
|
|
2918
|
+
type AgentOsGetOrCreateOptions = Omit<GetOptions, "createWithInput"> & {
|
|
2919
|
+
createWithInput?: AgentOsActorCreateInput;
|
|
2920
|
+
};
|
|
2921
|
+
type AgentOsActorAccessor = Omit<ActorAccessor<AgentOsActorDefinition>, "create" | "getOrCreate"> & {
|
|
2922
|
+
getOrCreate(key?: string | string[], options?: AgentOsGetOrCreateOptions): AgentOsActorHandle;
|
|
2923
|
+
create(key?: string | string[], options?: AgentOsCreateOptions): Promise<AgentOsActorHandle>;
|
|
2924
|
+
};
|
|
2925
|
+
type AgentOsClient = Omit<Client<AgentOsRegistry>, "agentOS" | "getForId"> & {
|
|
2926
|
+
readonly agentOS: AgentOsActorAccessor;
|
|
2927
|
+
getForId(name: "agentOS", actorId: string, options?: GetWithIdOptions): AgentOsActorHandle;
|
|
2928
|
+
};
|
|
459
2929
|
/**
|
|
460
|
-
* RivetKit
|
|
461
|
-
*
|
|
2930
|
+
* Creates a vanilla RivetKit client with the generated agentOS contract.
|
|
2931
|
+
* Services runs the agentOS actor in the `services` pool, so the client
|
|
2932
|
+
* uses that pool unless the config sets `poolName`.
|
|
2933
|
+
*
|
|
2934
|
+
* The client talks to the engine, whose `/metadata` has no client endpoint to
|
|
2935
|
+
* redirect to, so it skips that lookup unless the config sets
|
|
2936
|
+
* `disableMetadataLookup: false`. RivetKit retries the lookup forever, which
|
|
2937
|
+
* makes every call hang when the endpoint is unreachable. A RivetKit app URL
|
|
2938
|
+
* that redirects through `/metadata` needs `disableMetadataLookup: false`.
|
|
462
2939
|
*/
|
|
463
|
-
declare
|
|
2940
|
+
declare function createAgentOsClient(endpointOrConfig?: string | ClientConfigInput): AgentOsClient;
|
|
464
2941
|
|
|
465
|
-
export { type
|
|
2942
|
+
export { AGENTOS_API_VERSION, AGENTOS_CAPABILITIES, AGENTOS_CONTRACT, AGENTOS_CONTRACT_HASH, AGENTOS_CONTRACT_MAJOR, type AgentOsActions, type AgentOsActorAccessor, type AgentOsActorConnection, type AgentOsActorCreateInput, type AgentOsActorDefinition, type AgentOsActorHandle, type AgentOsClient, type AgentOsCreateOptions, type AgentOsEvents, type AgentOsGetOrCreateOptions, type AgentOsRegistry, type AgentOsRivetError, Input, Output, type V1ConfigGetInput, type V1ConfigGetOutput, type V1ConfigPatchInput, type V1ConfigPatchOutput, type V1ConfigSetInput, type V1ConfigSetOutput, type V1ContextsCreateInput, type V1ContextsCreateOutput, type V1ContextsDeleteInput, type V1ContextsDeleteOutput, type V1ContextsGetInput, type V1ContextsGetOutput, type V1ContextsListInput, type V1ContextsListOutput, type V1ContextsResetInput, type V1ContextsResetOutput, type V1CronCancelInput, type V1CronCancelOutput, type V1CronListInput, type V1CronListOutput, type V1CronScheduleInput, type V1CronScheduleOutput, type V1FilesystemExistsInput, type V1FilesystemExistsOutput, type V1FilesystemExportInput, type V1FilesystemExportOutput, type V1FilesystemListMountsInput, type V1FilesystemListMountsOutput, type V1FilesystemMkdirInput, type V1FilesystemMkdirOutput, type V1FilesystemMoveInput, type V1FilesystemMoveOutput, type V1FilesystemReadFileInput, type V1FilesystemReadFileOutput, type V1FilesystemReadFilesInput, type V1FilesystemReadFilesOutput, type V1FilesystemReaddirEntriesInput, type V1FilesystemReaddirEntriesOutput, type V1FilesystemReaddirInput, type V1FilesystemReaddirOutput, type V1FilesystemReaddirRecursiveInput, type V1FilesystemReaddirRecursiveOutput, type V1FilesystemRemoveInput, type V1FilesystemRemoveOutput, type V1FilesystemStatInput, type V1FilesystemStatOutput, type V1FilesystemWriteFileInput, type V1FilesystemWriteFileOutput, type V1FilesystemWriteFilesInput, type V1FilesystemWriteFilesOutput, type V1JavaScriptEvaluateInput, type V1JavaScriptEvaluateOutput, type V1JavaScriptExecuteFileInput, type V1JavaScriptExecuteFileOutput, type V1JavaScriptExecuteInput, type V1JavaScriptExecuteOutput, type V1JavaScriptNpmInstallInput, type V1JavaScriptNpmInstallOutput, type V1JavaScriptNpmRunPackageInput, type V1JavaScriptNpmRunPackageOutput, type V1JavaScriptNpmRunScriptInput, type V1JavaScriptNpmRunScriptOutput, type V1JavaScriptSpawnFileInput, type V1JavaScriptSpawnFileOutput, type V1JavaScriptSpawnInput, type V1JavaScriptSpawnOutput, type V1NetworkFetchInput, type V1NetworkFetchOutput, type V1NetworkFetchStreamCancelInput, type V1NetworkFetchStreamCancelOutput, type V1NetworkFetchStreamReadInput, type V1NetworkFetchStreamReadOutput, type V1NetworkFetchStreamStartInput, type V1NetworkFetchStreamStartOutput, type V1NetworkPreviewCreateInput, type V1NetworkPreviewCreateOutput, type V1NetworkPreviewExpireInput, type V1NetworkPreviewExpireOutput, type V1ProcessGetInput, type V1ProcessGetOutput, type V1ProcessListInput, type V1ProcessListOutput, type V1ProcessOutputReadInput, type V1ProcessOutputReadOutput, type V1ProcessPtyResizeInput, type V1ProcessPtyResizeOutput, type V1ProcessRunInput, type V1ProcessRunOutput, type V1ProcessSignalInput, type V1ProcessSignalOutput, type V1ProcessSpawnInput, type V1ProcessSpawnOutput, type V1ProcessStdinCloseInput, type V1ProcessStdinCloseOutput, type V1ProcessStdinWriteInput, type V1ProcessStdinWriteOutput, type V1ProcessTreeInput, type V1ProcessTreeOutput, type V1ProcessWaitInput, type V1ProcessWaitOutput, type V1PythonEvaluateInput, type V1PythonEvaluateOutput, type V1PythonExecuteFileInput, type V1PythonExecuteFileOutput, type V1PythonExecuteInput, type V1PythonExecuteModuleInput, type V1PythonExecuteModuleOutput, type V1PythonExecuteOutput, type V1PythonInstallInput, type V1PythonInstallOutput, type V1PythonSpawnFileInput, type V1PythonSpawnFileOutput, type V1PythonSpawnInput, type V1PythonSpawnModuleInput, type V1PythonSpawnModuleOutput, type V1PythonSpawnOutput, type V1SoftwareInstallInput, type V1SoftwareInstallOutput, type V1SoftwareListInput, type V1SoftwareListOutput, type V1SoftwareUninstallInput, type V1SoftwareUninstallOutput, type V1TerminalCloseInput, type V1TerminalCloseOutput, type V1TerminalListInput, type V1TerminalListOutput, type V1TerminalOpenInput, type V1TerminalOpenOutput, type V1TerminalOutputReadInput, type V1TerminalOutputReadOutput, type V1TerminalPtyResizeInput, type V1TerminalPtyResizeOutput, type V1TerminalStdinWriteInput, type V1TerminalStdinWriteOutput, type V1TerminalWaitInput, type V1TerminalWaitOutput, type V1TypeScriptCheckInput, type V1TypeScriptCheckOutput, type V1TypeScriptCheckProjectInput, type V1TypeScriptCheckProjectOutput, type V1TypeScriptEvaluateInput, type V1TypeScriptEvaluateOutput, type V1TypeScriptExecuteFileInput, type V1TypeScriptExecuteFileOutput, type V1TypeScriptExecuteInput, type V1TypeScriptExecuteOutput, type V1TypeScriptSpawnFileInput, type V1TypeScriptSpawnFileOutput, type V1TypeScriptSpawnInput, type V1TypeScriptSpawnOutput, type V1VmRestartInput, type V1VmRestartOutput, type V1VmStatusInput, type V1VmStatusOutput, createAgentOsClient };
|