@groundbox/mastra 0.0.0-stage → 0.1.0
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 +9 -0
- package/README.md +132 -2
- package/dist/index.cjs +1258 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +375 -0
- package/dist/index.d.ts +375 -0
- package/dist/index.js +1237 -0
- package/dist/index.js.map +1 -0
- package/package.json +70 -4
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,375 @@
|
|
|
1
|
+
import { Groundbox, CommandStream, Sandbox } from '@groundbox/sdk';
|
|
2
|
+
import { RequestContext } from '@mastra/core/di';
|
|
3
|
+
import { MastraFilesystem, ProviderStatus, ReadOptions, FileContent, WriteOptions, RemoveOptions, CopyOptions, ListOptions, FileEntry, FileStat, ProcessHandle, SpawnProcessOptions, CommandResult, SandboxProcessManager, ProcessInfo, MastraSandbox, SandboxComputer, SandboxNetworking, MastraSandboxOptions, SandboxCloneOptions, SandboxInfo, ExecuteCommandOptions, SandboxFileInput, WriteFilesOptions } from '@mastra/core/workspace';
|
|
4
|
+
import { SandboxProvider } from '@mastra/core/editor';
|
|
5
|
+
|
|
6
|
+
declare class GroundboxSandboxFilesystem extends MastraFilesystem {
|
|
7
|
+
private readonly sandbox;
|
|
8
|
+
readonly id: string;
|
|
9
|
+
readonly name = "GroundboxSandboxFilesystem";
|
|
10
|
+
readonly provider = "groundbox";
|
|
11
|
+
status: ProviderStatus;
|
|
12
|
+
constructor(sandbox: GroundboxSandbox);
|
|
13
|
+
get basePath(): string | undefined;
|
|
14
|
+
getInstructions(): string;
|
|
15
|
+
getCommandCwd(): Promise<string | undefined>;
|
|
16
|
+
resolveAbsolutePath(path: string): string;
|
|
17
|
+
private abs;
|
|
18
|
+
/** Run `fn` with the sandbox started, retrying once when it died under us. */
|
|
19
|
+
private run;
|
|
20
|
+
private script;
|
|
21
|
+
/** The entry itself (a symlink is described, not followed), or undefined when nothing is there. */
|
|
22
|
+
private lstat;
|
|
23
|
+
readFile(path: string, options?: ReadOptions): Promise<string | Buffer>;
|
|
24
|
+
writeFile(path: string, content: FileContent, options?: WriteOptions): Promise<void>;
|
|
25
|
+
appendFile(path: string, content: FileContent): Promise<void>;
|
|
26
|
+
deleteFile(path: string, options?: RemoveOptions): Promise<void>;
|
|
27
|
+
copyFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
|
|
28
|
+
moveFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
|
|
29
|
+
mkdir(path: string, options?: {
|
|
30
|
+
recursive?: boolean;
|
|
31
|
+
}): Promise<void>;
|
|
32
|
+
rmdir(path: string, options?: RemoveOptions): Promise<void>;
|
|
33
|
+
readdir(path: string, options?: ListOptions): Promise<FileEntry[]>;
|
|
34
|
+
private listOne;
|
|
35
|
+
private resolveLinks;
|
|
36
|
+
exists(path: string): Promise<boolean>;
|
|
37
|
+
stat(path: string): Promise<FileStat>;
|
|
38
|
+
private assertParentDirectory;
|
|
39
|
+
/** A files API error about one path, as the Mastra error it means. */
|
|
40
|
+
private fileError;
|
|
41
|
+
private check;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
/**
|
|
45
|
+
* Groundbox process manager.
|
|
46
|
+
*
|
|
47
|
+
* Every spawn is a Groundbox background command (`POST /sandboxes/{id}/commands`), so it runs on
|
|
48
|
+
* in the sandbox with nobody connected and has an id (`ex_...`) at once. Its output is followed
|
|
49
|
+
* over the exec stream (`attach_command`), which reconnects by itself and reads on from where it
|
|
50
|
+
* was, so a dropped connection loses no output. Kill, stdin and close-stdin go through the same
|
|
51
|
+
* command id. A command started in another process can be picked up again with `get(id)`.
|
|
52
|
+
*/
|
|
53
|
+
|
|
54
|
+
interface GroundboxProcessManagerOptions {
|
|
55
|
+
/** Default timeout in milliseconds for commands that don't specify one. Unset: no timeout (the sandbox's lifetime). */
|
|
56
|
+
defaultTimeout?: number;
|
|
57
|
+
}
|
|
58
|
+
type Ended = {
|
|
59
|
+
exit_code: number;
|
|
60
|
+
duration_ms: number;
|
|
61
|
+
timed_out: boolean;
|
|
62
|
+
};
|
|
63
|
+
/** A Groundbox command, as Mastra's ProcessHandle. */
|
|
64
|
+
declare class GroundboxProcessHandle extends ProcessHandle {
|
|
65
|
+
private readonly client;
|
|
66
|
+
private readonly sandboxId;
|
|
67
|
+
private readonly stream;
|
|
68
|
+
private readonly startTime;
|
|
69
|
+
private readonly stdinOpen;
|
|
70
|
+
readonly pid: string;
|
|
71
|
+
private _exitCode;
|
|
72
|
+
private _timedOut;
|
|
73
|
+
private _killed;
|
|
74
|
+
private _detached;
|
|
75
|
+
private _waitPromise;
|
|
76
|
+
private readonly _ended;
|
|
77
|
+
constructor(pid: string, client: Groundbox, sandboxId: string, stream: CommandStream | undefined, startTime: number, stdinOpen: boolean, options?: SpawnProcessOptions, ended?: Ended);
|
|
78
|
+
get exitCode(): number | undefined;
|
|
79
|
+
private settle;
|
|
80
|
+
/** The output stream failed for good: read the command's state until it ends. */
|
|
81
|
+
private pollUntilEnded;
|
|
82
|
+
wait(): Promise<CommandResult>;
|
|
83
|
+
private doWait;
|
|
84
|
+
kill(): Promise<boolean>;
|
|
85
|
+
sendStdin(data: string): Promise<void>;
|
|
86
|
+
closeStdin(): Promise<void>;
|
|
87
|
+
/** Stop following the output; the command runs on in the sandbox. */
|
|
88
|
+
detach(): void;
|
|
89
|
+
}
|
|
90
|
+
/**
|
|
91
|
+
* Mastra process manager over Groundbox background commands.
|
|
92
|
+
*/
|
|
93
|
+
declare class GroundboxProcessManager extends SandboxProcessManager<GroundboxSandbox> {
|
|
94
|
+
private readonly defaultTimeout;
|
|
95
|
+
constructor(options?: GroundboxProcessManagerOptions);
|
|
96
|
+
spawn(command: string, options?: SpawnProcessOptions): Promise<ProcessHandle>;
|
|
97
|
+
list(): Promise<ProcessInfo[]>;
|
|
98
|
+
/**
|
|
99
|
+
* A tracked process, or a Groundbox command this manager did not start (by its `ex_...` id),
|
|
100
|
+
* attached from the start of its kept output.
|
|
101
|
+
*/
|
|
102
|
+
get(pid: string, options?: {
|
|
103
|
+
release?: boolean;
|
|
104
|
+
}): Promise<ProcessHandle | undefined>;
|
|
105
|
+
/** Stop following every tracked process's output and forget them (the sandbox is going away). */
|
|
106
|
+
detachAll(): void;
|
|
107
|
+
/** Release a process and stop following its output. */
|
|
108
|
+
release(pid: string): void;
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
/** Metadata key that ties a Groundbox sandbox to this sandbox's logical id. */
|
|
112
|
+
declare const MASTRA_ID_METADATA_KEY = "mastra-sandbox-id";
|
|
113
|
+
type InstructionsOption = string | ((opts: {
|
|
114
|
+
defaultInstructions: string;
|
|
115
|
+
requestContext?: RequestContext;
|
|
116
|
+
}) => string);
|
|
117
|
+
/** A Groundbox volume to attach at creation. */
|
|
118
|
+
interface GroundboxVolumeMount {
|
|
119
|
+
/** Volume id (`vol_...`) or name. */
|
|
120
|
+
volume: string;
|
|
121
|
+
/** Absolute path in the sandbox. */
|
|
122
|
+
path: string;
|
|
123
|
+
/** Read-only, so other sandboxes can attach it too. */
|
|
124
|
+
readOnly?: boolean;
|
|
125
|
+
}
|
|
126
|
+
/** A Linux desktop with Chrome, for computer use. */
|
|
127
|
+
interface GroundboxDesktopOptions {
|
|
128
|
+
width?: number;
|
|
129
|
+
height?: number;
|
|
130
|
+
/** Page Chrome opens at start. */
|
|
131
|
+
startUrl?: string;
|
|
132
|
+
/** Record the session. */
|
|
133
|
+
recording?: boolean;
|
|
134
|
+
}
|
|
135
|
+
interface GroundboxSandboxOptions extends Omit<MastraSandboxOptions, 'processes'> {
|
|
136
|
+
/**
|
|
137
|
+
* Logical id of this sandbox. A Groundbox sandbox started for it carries the id in its
|
|
138
|
+
* metadata (`mastra-sandbox-id`), so a later `start()` with the same id, in this process or
|
|
139
|
+
* another, reconnects to it (resuming it when paused) instead of creating a new one.
|
|
140
|
+
*/
|
|
141
|
+
id?: string;
|
|
142
|
+
/** Reattach to this Groundbox sandbox (`sbx_...`) first, when it is still there. */
|
|
143
|
+
sandboxId?: string;
|
|
144
|
+
/** API key. Defaults to the GROUNDBOX_API_KEY environment variable. */
|
|
145
|
+
apiKey?: string;
|
|
146
|
+
/** API base URL, ending in /v1. Defaults to GROUNDBOX_API_URL, then https://api.groundbox.dev/v1. */
|
|
147
|
+
baseUrl?: string;
|
|
148
|
+
/** A Groundbox client to use instead of making one (tests, a custom fetch or WebSocket). */
|
|
149
|
+
client?: Groundbox;
|
|
150
|
+
/**
|
|
151
|
+
* Default timeout for a command, in milliseconds.
|
|
152
|
+
* @default 300_000 (5 minutes)
|
|
153
|
+
*/
|
|
154
|
+
timeout?: number;
|
|
155
|
+
/** vCPUs, 1 to 16. @default 2 */
|
|
156
|
+
cpus?: number;
|
|
157
|
+
/** Memory in GB, up to 4 per vCPU. @default 2 per vCPU */
|
|
158
|
+
memoryGb?: number;
|
|
159
|
+
/** Disk in GB (a minimum: never smaller than the image's disk). @default 20 */
|
|
160
|
+
diskGb?: number;
|
|
161
|
+
/** Start from a public Docker image (`python:3.12-slim`) or one in your Groundbox registry. Commands then run as root. */
|
|
162
|
+
image?: string;
|
|
163
|
+
/** Start from a Groundbox template (id or name), built ahead with `create_template`. */
|
|
164
|
+
template?: string;
|
|
165
|
+
/** Start from a kept Groundbox snapshot (`snap_...`): its memory, disk and processes. */
|
|
166
|
+
snapshotId?: string;
|
|
167
|
+
/**
|
|
168
|
+
* Environment for every command: set on the Groundbox sandbox at creation, and kept as
|
|
169
|
+
* Mastra's runtime overlay (change it later with `setEnv`).
|
|
170
|
+
*/
|
|
171
|
+
env?: Record<string, string>;
|
|
172
|
+
/** Metadata pairs on the Groundbox sandbox (list and filter sandboxes by them). */
|
|
173
|
+
metadata?: Record<string, string>;
|
|
174
|
+
/** Names of team secrets to expose as environment variables of the same names. */
|
|
175
|
+
secrets?: string[];
|
|
176
|
+
/** Environment variable name to team secret name. */
|
|
177
|
+
envFromSecrets?: Record<string, string>;
|
|
178
|
+
/** Hosts the sandbox may reach; everything else is blocked. Names, `*.wildcards`, IPv4 addresses and networks. */
|
|
179
|
+
allowHosts?: string[];
|
|
180
|
+
/** Hosts the sandbox may not reach. */
|
|
181
|
+
denyHosts?: string[];
|
|
182
|
+
/** Volumes to attach at creation. A sandbox with volumes cannot be paused, so `stop()` shuts it down instead. */
|
|
183
|
+
volumes?: GroundboxVolumeMount[];
|
|
184
|
+
/**
|
|
185
|
+
* How long the Groundbox sandbox may live, in minutes, from its last start or wake (up to
|
|
186
|
+
* 43,200). What happens then is `onTimeout`.
|
|
187
|
+
* @default 60
|
|
188
|
+
*/
|
|
189
|
+
timeoutMinutes?: number;
|
|
190
|
+
/**
|
|
191
|
+
* What the sandbox's timeout does: delete it, shut it down keeping its disk, or pause it.
|
|
192
|
+
* `stop` and `pause` need the paid plan.
|
|
193
|
+
* @default 'delete'
|
|
194
|
+
*/
|
|
195
|
+
onTimeout?: 'delete' | 'stop' | 'pause';
|
|
196
|
+
/** Pause the sandbox after this many seconds with nothing using it (at least 30); the next request wakes it. */
|
|
197
|
+
idleTimeoutSeconds?: number;
|
|
198
|
+
/** Half price for work that can wait: it starts when a machine has spare room. */
|
|
199
|
+
flex?: boolean;
|
|
200
|
+
/** Start a Linux desktop with Chrome and expose Mastra's computer-use tools. */
|
|
201
|
+
desktop?: boolean | GroundboxDesktopOptions;
|
|
202
|
+
/**
|
|
203
|
+
* Make port previews (`networking.getPortUrl`) public. Private previews open only for
|
|
204
|
+
* members of your Groundbox team who are signed in.
|
|
205
|
+
* @default false
|
|
206
|
+
*/
|
|
207
|
+
publicPreviews?: boolean;
|
|
208
|
+
/** Kept-snapshot name `snapshot()` writes to and the next start boots from. Defaults to the sandbox's id. */
|
|
209
|
+
checkpointName?: string;
|
|
210
|
+
/** Kept-snapshot name to boot from when `checkpointName` has none yet. */
|
|
211
|
+
seedCheckpointName?: string;
|
|
212
|
+
/** Replace or extend the instructions the agent gets about this sandbox. */
|
|
213
|
+
instructions?: InstructionsOption;
|
|
214
|
+
}
|
|
215
|
+
/**
|
|
216
|
+
* Groundbox sandbox provider for Mastra workspaces.
|
|
217
|
+
*
|
|
218
|
+
* @example
|
|
219
|
+
* ```typescript
|
|
220
|
+
* import { Workspace } from '@mastra/core/workspace';
|
|
221
|
+
* import { GroundboxSandbox } from '@groundbox/mastra';
|
|
222
|
+
*
|
|
223
|
+
* const workspace = new Workspace({ sandbox: new GroundboxSandbox({ cpus: 2 }) });
|
|
224
|
+
* ```
|
|
225
|
+
*/
|
|
226
|
+
declare class GroundboxSandbox extends MastraSandbox<Sandbox> {
|
|
227
|
+
readonly id: string;
|
|
228
|
+
readonly name = "GroundboxSandbox";
|
|
229
|
+
readonly provider = "groundbox";
|
|
230
|
+
status: ProviderStatus;
|
|
231
|
+
readonly processes: GroundboxProcessManager;
|
|
232
|
+
readonly computer?: SandboxComputer;
|
|
233
|
+
readonly supportsCheckpoints = true;
|
|
234
|
+
/**
|
|
235
|
+
* Public HTTPS URLs for ports in the sandbox, through Groundbox previews
|
|
236
|
+
* (`https://<slug>-<port>.groundbox.page`). The app must listen on 0.0.0.0. Private unless
|
|
237
|
+
* `publicPreviews` is set. Previews are on the paid plan.
|
|
238
|
+
*/
|
|
239
|
+
readonly networking: SandboxNetworking;
|
|
240
|
+
private readonly client;
|
|
241
|
+
private readonly commandTimeout;
|
|
242
|
+
private readonly options;
|
|
243
|
+
private readonly publicPreviews;
|
|
244
|
+
private readonly checkpointName;
|
|
245
|
+
private _sandbox;
|
|
246
|
+
private _sandboxId;
|
|
247
|
+
private _preferredSandboxId;
|
|
248
|
+
private _createdAt;
|
|
249
|
+
private _isRetrying;
|
|
250
|
+
private _filesystem;
|
|
251
|
+
/** The `workingDirectory` option as given, apart from the detected home folder. */
|
|
252
|
+
private readonly explicitWorkingDirectory;
|
|
253
|
+
constructor(options?: GroundboxSandboxOptions);
|
|
254
|
+
/** The Groundbox client this sandbox uses, for any API call this class does not wrap. */
|
|
255
|
+
get groundbox(): Groundbox;
|
|
256
|
+
/** The Groundbox sandbox id (`sbx_...`), once started. Persist it to reattach with `sandboxId`. */
|
|
257
|
+
get sandboxId(): string | undefined;
|
|
258
|
+
/** The Groundbox sandbox as last read. */
|
|
259
|
+
get instance(): Sandbox;
|
|
260
|
+
/** The sandbox's disk through Groundbox's files API. Pass it as the workspace `filesystem` to give the agent file tools on it. */
|
|
261
|
+
get filesystem(): GroundboxSandboxFilesystem;
|
|
262
|
+
/** @internal The Groundbox sandbox id; throws when the sandbox has not been started. */
|
|
263
|
+
requireSandboxId(): string;
|
|
264
|
+
/**
|
|
265
|
+
* A sibling sandbox with this one's settings and per-instance overrides. No I/O: it creates
|
|
266
|
+
* (or reconnects to the sandbox for its `id`, or reattaches to `sandboxId`) on its own start.
|
|
267
|
+
* `idleTimeoutMinutes` becomes Groundbox's idle pause.
|
|
268
|
+
*/
|
|
269
|
+
clone(options?: SandboxCloneOptions): GroundboxSandbox;
|
|
270
|
+
/**
|
|
271
|
+
* The Groundbox sandbox for this logical id: the one named by `sandboxId` (or the last one
|
|
272
|
+
* this instance had) when it is still there, else the newest live sandbox whose metadata
|
|
273
|
+
* carries this id. Errors other than not-found propagate: making a duplicate on an auth or
|
|
274
|
+
* network error would be worse than failing.
|
|
275
|
+
*/
|
|
276
|
+
protected find(): Promise<Sandbox | undefined>;
|
|
277
|
+
/** The newest live sandbox for this logical id, without starting or resuming it. */
|
|
278
|
+
private lookup;
|
|
279
|
+
/** Bring an existing sandbox to `running`: wait out a transition, resume a paused one, start a shut-down one. */
|
|
280
|
+
protected connect(existing: Sandbox): Promise<void>;
|
|
281
|
+
protected create(): Promise<void>;
|
|
282
|
+
/** The create request: this sandbox's settings, booted from a checkpoint when one is kept. */
|
|
283
|
+
private createSpec;
|
|
284
|
+
/** Wait while the sandbox is between states (queued, pausing, shutting down, ...). */
|
|
285
|
+
private settle;
|
|
286
|
+
private adopt;
|
|
287
|
+
/**
|
|
288
|
+
* Groundbox's own image starts commands in /home/runner. On a Docker image, a template or a
|
|
289
|
+
* snapshot the home folder can differ, so it is read from the sandbox once.
|
|
290
|
+
*/
|
|
291
|
+
private detectWorkingDirectory;
|
|
292
|
+
/** Read the Groundbox sandbox again and keep it. */
|
|
293
|
+
refresh(): Promise<Sandbox | undefined>;
|
|
294
|
+
/**
|
|
295
|
+
* Pause the Groundbox sandbox: memory, processes and disk are kept and only storage is
|
|
296
|
+
* billed. The next start resumes it. A sandbox with volumes cannot be paused, so it is shut
|
|
297
|
+
* down instead (disk kept, a cold boot on the next start).
|
|
298
|
+
*/
|
|
299
|
+
stop(): Promise<void>;
|
|
300
|
+
/** Delete the Groundbox sandbox for good. Billing stops. */
|
|
301
|
+
destroy(): Promise<void>;
|
|
302
|
+
isReady(): Promise<boolean>;
|
|
303
|
+
getInfo(): Promise<SandboxInfo>;
|
|
304
|
+
getInstructions(opts?: {
|
|
305
|
+
requestContext?: RequestContext;
|
|
306
|
+
}): string;
|
|
307
|
+
private defaultInstructions;
|
|
308
|
+
/**
|
|
309
|
+
* Run a command and wait for it. Without streaming callbacks or an abort signal this is one
|
|
310
|
+
* `POST /exec` call; otherwise it is a background command followed over the exec stream.
|
|
311
|
+
*/
|
|
312
|
+
executeCommand(command: string, args?: string[], options?: ExecuteCommandOptions): Promise<CommandResult>;
|
|
313
|
+
/**
|
|
314
|
+
* Write many files at once: they go up as one tar.gz and are unpacked in the sandbox. Modes are
|
|
315
|
+
* kept. A relative path is resolved against the working directory. Files are written as the
|
|
316
|
+
* sandbox user (`runner` on Groundbox's image), so a path it cannot write to fails.
|
|
317
|
+
*/
|
|
318
|
+
writeFiles(files: SandboxFileInput[], options?: WriteFilesOptions): Promise<void>;
|
|
319
|
+
/**
|
|
320
|
+
* Keep the sandbox as it is now (memory, disk and processes) as a Groundbox snapshot named
|
|
321
|
+
* `checkpointName`, replacing the previous one of that name. The next sandbox started for this
|
|
322
|
+
* checkpoint boots from it. Kept snapshots are on the paid plan.
|
|
323
|
+
*/
|
|
324
|
+
snapshot(): Promise<void>;
|
|
325
|
+
private listCheckpoints;
|
|
326
|
+
private findCheckpoint;
|
|
327
|
+
/** Whether `error` came from the sandbox not running, as opposed to the call itself. */
|
|
328
|
+
private isSandboxGone;
|
|
329
|
+
/**
|
|
330
|
+
* Run `fn`; when it fails because the sandbox stopped, was paused or timed out, start it again
|
|
331
|
+
* (resuming it, or making a new one when it ended) and run `fn` once more.
|
|
332
|
+
*/
|
|
333
|
+
retryOnDead<T>(fn: () => Promise<T>): Promise<T>;
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
/** One key name as the desktop takes it: `Enter` is `Return`, `ArrowUp` is `Up`, F-keys and letters pass through. */
|
|
337
|
+
declare function toKeysym(key: string): string;
|
|
338
|
+
/** A key or a chord (`['ctrl', 's']`) as one `key` action: `ctrl+s`. */
|
|
339
|
+
declare function toKeyCombo(key: string | string[]): string;
|
|
340
|
+
declare function createGroundboxComputer(sandbox: GroundboxSandbox): SandboxComputer;
|
|
341
|
+
|
|
342
|
+
/**
|
|
343
|
+
* Groundbox sandbox provider descriptor for the Mastra editor.
|
|
344
|
+
*
|
|
345
|
+
* @example
|
|
346
|
+
* ```typescript
|
|
347
|
+
* import { MastraEditor } from '@mastra/editor';
|
|
348
|
+
* import { groundboxSandboxProvider } from '@groundbox/mastra';
|
|
349
|
+
*
|
|
350
|
+
* const editor = new MastraEditor({ sandboxes: [groundboxSandboxProvider] });
|
|
351
|
+
* ```
|
|
352
|
+
*/
|
|
353
|
+
|
|
354
|
+
/** The serializable subset of GroundboxSandboxOptions the editor stores. */
|
|
355
|
+
interface GroundboxProviderConfig {
|
|
356
|
+
cpus?: number;
|
|
357
|
+
memoryGb?: number;
|
|
358
|
+
diskGb?: number;
|
|
359
|
+
image?: string;
|
|
360
|
+
template?: string;
|
|
361
|
+
timeout?: number;
|
|
362
|
+
timeoutMinutes?: number;
|
|
363
|
+
idleTimeoutSeconds?: number;
|
|
364
|
+
env?: Record<string, string>;
|
|
365
|
+
metadata?: Record<string, string>;
|
|
366
|
+
allowHosts?: string[];
|
|
367
|
+
denyHosts?: string[];
|
|
368
|
+
desktop?: boolean;
|
|
369
|
+
publicPreviews?: boolean;
|
|
370
|
+
apiKey?: string;
|
|
371
|
+
baseUrl?: string;
|
|
372
|
+
}
|
|
373
|
+
declare const groundboxSandboxProvider: SandboxProvider<GroundboxProviderConfig>;
|
|
374
|
+
|
|
375
|
+
export { type GroundboxDesktopOptions, GroundboxProcessHandle, GroundboxProcessManager, type GroundboxProcessManagerOptions, type GroundboxProviderConfig, GroundboxSandbox, GroundboxSandboxFilesystem, type GroundboxSandboxOptions, type GroundboxVolumeMount, MASTRA_ID_METADATA_KEY, createGroundboxComputer, groundboxSandboxProvider, toKeyCombo, toKeysym };
|