experimental-agent 0.1.2 → 0.1.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.
Files changed (43) hide show
  1. package/README.md +9 -0
  2. package/dist/agent-workflow.d.mts +1 -1
  3. package/dist/agent-workflow.d.ts +1 -1
  4. package/dist/agent-workflow.js +352 -104
  5. package/dist/agent-workflow.mjs +1 -1
  6. package/dist/{chunk-W4SSZPDX.mjs → chunk-24UDM5XV.mjs} +4 -4
  7. package/dist/chunk-2ZXHR6T6.mjs +401 -0
  8. package/dist/chunk-4WDKWMVB.mjs +389 -0
  9. package/dist/chunk-IACG26TC.mjs +2212 -0
  10. package/dist/chunk-NGLND33F.mjs +1247 -0
  11. package/dist/{chunk-E7TOPGHY.mjs → chunk-RXPVLORL.mjs} +3 -3
  12. package/dist/{chunk-HJGPUEFC.mjs → chunk-YRYXN7W4.mjs} +7 -1
  13. package/dist/client-Bkuq-Dfa.d.mts +2340 -0
  14. package/dist/client-Bkuq-Dfa.d.ts +2340 -0
  15. package/dist/{client-YUU54ZZH.mjs → client-SNN3XDKO.mjs} +2 -2
  16. package/dist/client.d.mts +1 -1
  17. package/dist/client.d.ts +1 -1
  18. package/dist/client.js +1 -1
  19. package/dist/client.mjs +1 -1
  20. package/dist/{handler-LDFBSCRA.mjs → handler-WFNQWR6V.mjs} +2 -1
  21. package/dist/index.d.mts +2 -2
  22. package/dist/index.d.ts +2 -2
  23. package/dist/index.js +623 -220
  24. package/dist/index.mjs +78 -40
  25. package/dist/lifecycle-workflow.d.mts +1 -1
  26. package/dist/lifecycle-workflow.d.ts +1 -1
  27. package/dist/lifecycle-workflow.js +88 -6
  28. package/dist/lifecycle-workflow.mjs +1 -1
  29. package/dist/local-fs-handlers-ESZBRAWK.mjs +439 -0
  30. package/dist/next/loader.js +3 -3
  31. package/dist/next/loader.mjs +1 -1
  32. package/dist/next.js +10 -4
  33. package/dist/next.mjs +9 -3
  34. package/dist/{sandbox-GPCA35PJ.mjs → sandbox-IFK5MVRM.mjs} +3 -3
  35. package/dist/{storage-LL6IA24R.mjs → storage-FCSHTDLC.mjs} +3 -3
  36. package/package.json +2 -2
  37. package/dist/chunk-2SPAJ777.mjs +0 -365
  38. package/dist/chunk-6J462JGP.mjs +0 -1267
  39. package/dist/chunk-ILPVXRI5.mjs +0 -2026
  40. package/dist/chunk-ORE6LK2L.mjs +0 -344
  41. package/dist/client-CKLwB-ES.d.mts +0 -2115
  42. package/dist/client-CKLwB-ES.d.ts +0 -2115
  43. package/dist/local-fs-handlers-SY2RDXZE.mjs +0 -314
@@ -1,1267 +0,0 @@
1
- import {
2
- sandboxLifecycleWorkflow
3
- } from "./chunk-W4SSZPDX.mjs";
4
- import {
5
- SandboxError,
6
- SandboxNotFoundError
7
- } from "./chunk-HJGPUEFC.mjs";
8
-
9
- // src/utils/debug.ts
10
- var enabled = process.env.AGENT_DEBUG === "1" || process.env.AGENT_DEBUG === "true";
11
- function debug(...args) {
12
- if (enabled) {
13
- console.log(...args);
14
- }
15
- }
16
-
17
- // src/sandbox/bindings/local.ts
18
- import { spawn } from "child_process";
19
- import * as fs from "fs/promises";
20
- import * as path2 from "path";
21
- import * as errore from "errore";
22
- import { ulid } from "ulid";
23
-
24
- // src/sandbox/write-files.ts
25
- import * as path from "path";
26
- var MAX_RETRIES = 2;
27
- var RETRY_BASE_MS = 500;
28
- async function execChecked(sandbox, opts, errorLabel) {
29
- for (let attempt = 0; ; attempt++) {
30
- const execResult = await sandbox.exec(opts);
31
- if (execResult instanceof Error) {
32
- throw execResult;
33
- }
34
- const result = await execResult.result;
35
- if (result.exitCode === 0) {
36
- return result;
37
- }
38
- const isTransient = result.exitCode === 255 && !result.stderr.trim();
39
- if (isTransient && attempt < MAX_RETRIES) {
40
- await new Promise((r) => setTimeout(r, RETRY_BASE_MS * (attempt + 1)));
41
- continue;
42
- }
43
- throw new Error(
44
- `${errorLabel} with exit code ${result.exitCode}: ${result.stderr}`
45
- );
46
- }
47
- }
48
- async function writeFiles(opts) {
49
- const { sandbox, files, destPath } = opts;
50
- if (files.length === 0) {
51
- return;
52
- }
53
- const filePaths = files.map((file) => path.posix.join(destPath, file.path));
54
- const parentDirs = Array.from(
55
- new Set(filePaths.map((p) => path.posix.dirname(p)))
56
- );
57
- const shellScripts = filePaths.filter((p) => p.endsWith(".sh"));
58
- const mkdirResult = await sandbox.exec({
59
- command: "mkdir",
60
- args: ["-p", ...parentDirs]
61
- });
62
- if (mkdirResult instanceof Error) {
63
- throw mkdirResult;
64
- }
65
- await mkdirResult.result;
66
- const CHUNK_SIZE = 5e4;
67
- for (let i = 0; i < files.length; i++) {
68
- const file = files[i];
69
- const fullPath = filePaths[i];
70
- const base64Content = toBase64(file.content);
71
- if (base64Content.length < CHUNK_SIZE) {
72
- const marker = `EOF_${i}`;
73
- await execChecked(
74
- sandbox,
75
- {
76
- command: "bash",
77
- args: [
78
- "-c",
79
- `base64 -d > ${quote(fullPath)} << '${marker}'
80
- ${base64Content}
81
- ${marker}`
82
- ]
83
- },
84
- "writeFiles failed"
85
- );
86
- } else {
87
- const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;
88
- const clearResult = await sandbox.exec({
89
- command: "bash",
90
- args: ["-c", `> ${quote(tempB64)}`]
91
- });
92
- if (clearResult instanceof Error) {
93
- throw clearResult;
94
- }
95
- await clearResult.result;
96
- for (let offset = 0; offset < base64Content.length; offset += CHUNK_SIZE) {
97
- const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);
98
- const marker = `CHUNK_${offset}`;
99
- await execChecked(
100
- sandbox,
101
- {
102
- command: "bash",
103
- args: [
104
- "-c",
105
- `cat >> ${quote(tempB64)} << '${marker}'
106
- ${chunk}
107
- ${marker}`
108
- ]
109
- },
110
- "writeFiles chunk failed"
111
- );
112
- }
113
- await execChecked(
114
- sandbox,
115
- {
116
- command: "bash",
117
- args: [
118
- "-c",
119
- `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`
120
- ]
121
- },
122
- "writeFiles decode failed"
123
- );
124
- }
125
- }
126
- if (shellScripts.length > 0) {
127
- const chmodResult = await sandbox.exec({
128
- command: "chmod",
129
- args: ["+x", ...shellScripts]
130
- });
131
- if (chmodResult instanceof Error) {
132
- throw chmodResult;
133
- }
134
- await chmodResult.result;
135
- }
136
- }
137
- function toBase64(content) {
138
- if (typeof content === "string") {
139
- return Buffer.from(content).toString("base64");
140
- }
141
- return content.toString("base64");
142
- }
143
- function quote(s) {
144
- return `'${s.replace(/'/g, "'\\''")}'`;
145
- }
146
-
147
- // src/sandbox/bindings/local.ts
148
- var localSandbox = ({
149
- sandboxRecord,
150
- storage,
151
- setup,
152
- onRestart
153
- }) => {
154
- const config = sandboxRecord.config;
155
- const basePath = config.path ?? process.cwd();
156
- const processes = /* @__PURE__ */ new Map();
157
- const sandbox = {
158
- id: sandboxRecord.id,
159
- config: sandboxRecord.config,
160
- exec: ({ command, args, signal }) => {
161
- return errore.tryAsync({
162
- try: () => {
163
- const commandId = `command_${ulid()}`;
164
- const child = spawn(command, args, {
165
- cwd: basePath,
166
- signal
167
- });
168
- processes.set(commandId, child);
169
- let stdout = "";
170
- let stderr = "";
171
- const logQueue = [];
172
- let logResolve = null;
173
- let closed = false;
174
- child.stdout.on("data", (data) => {
175
- const str = String(data);
176
- stdout += str;
177
- logQueue.push({ stream: "stdout", data: str });
178
- logResolve?.();
179
- });
180
- child.stderr.on("data", (data) => {
181
- const str = String(data);
182
- stderr += str;
183
- logQueue.push({ stream: "stderr", data: str });
184
- logResolve?.();
185
- });
186
- const result2 = new Promise((resolve, reject) => {
187
- child.on("error", (err) => {
188
- processes.delete(commandId);
189
- closed = true;
190
- logResolve?.();
191
- reject(err);
192
- });
193
- child.on("close", (code) => {
194
- processes.delete(commandId);
195
- closed = true;
196
- logResolve?.();
197
- resolve({ stdout, stderr, exitCode: code ?? 0 });
198
- });
199
- });
200
- async function* logs() {
201
- while (!closed || logQueue.length > 0) {
202
- const entry = logQueue.shift();
203
- if (entry) {
204
- yield entry;
205
- } else if (!closed) {
206
- await new Promise((resolve) => {
207
- logResolve = resolve;
208
- });
209
- logResolve = null;
210
- }
211
- }
212
- }
213
- return Promise.resolve({ commandId, logs, result: result2 });
214
- },
215
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
216
- });
217
- },
218
- getDomain: (port) => {
219
- return Promise.resolve(`http://localhost:${port}`);
220
- },
221
- kill: async ({ commandId, storage: storage2 }) => {
222
- const child = processes.get(commandId);
223
- if (!child) {
224
- return new SandboxError({
225
- reason: `Command ${commandId} not found or already finished`
226
- });
227
- }
228
- child.kill("SIGTERM");
229
- const cmd = await storage2.command.get(commandId);
230
- if (cmd instanceof Error) {
231
- return new SandboxError({ reason: cmd.message, cause: cmd });
232
- }
233
- if (cmd && cmd.status === "running") {
234
- const result2 = await storage2.command.set({
235
- ...cmd,
236
- status: "killed"
237
- });
238
- if (result2 instanceof Error) {
239
- return new SandboxError({ reason: result2.message, cause: result2 });
240
- }
241
- }
242
- },
243
- readFile: async ({ path: filePath }) => {
244
- const fullPath = path2.join(basePath, filePath);
245
- try {
246
- return await fs.readFile(fullPath);
247
- } catch (e) {
248
- if (e instanceof Error && "code" in e && e.code === "ENOENT") {
249
- return null;
250
- }
251
- return new SandboxError({ reason: String(e), cause: e });
252
- }
253
- },
254
- writeFiles: (opts) => writeFiles({ sandbox, ...opts }),
255
- updateNetworkPolicy: () => Promise.resolve(
256
- new SandboxError({
257
- reason: "updateNetworkPolicy is only available for Vercel sandboxes"
258
- })
259
- ),
260
- tag: {
261
- list: async () => {
262
- const sandboxRecord2 = await storage.sandbox.get(sandbox.id);
263
- if (sandboxRecord2 instanceof Error) {
264
- return sandboxRecord2;
265
- }
266
- return sandboxRecord2.tags ?? {};
267
- },
268
- get: async (key) => {
269
- const sandboxRecord2 = await storage.sandbox.get(sandbox.id);
270
- if (sandboxRecord2 instanceof Error) {
271
- return sandboxRecord2;
272
- }
273
- return sandboxRecord2.tags?.[key];
274
- },
275
- set: async (key, value) => {
276
- const result2 = await storage.sandbox.tag.set({
277
- sandboxId: sandbox.id,
278
- tags: { [key]: value }
279
- });
280
- if (result2 instanceof Error) {
281
- return result2;
282
- }
283
- return void 0;
284
- },
285
- setMany: async (tags) => {
286
- const result2 = await storage.sandbox.tag.set({
287
- sandboxId: sandbox.id,
288
- tags
289
- });
290
- if (result2 instanceof Error) {
291
- return result2;
292
- }
293
- return void 0;
294
- }
295
- }
296
- };
297
- const result = sandbox;
298
- if (setup || onRestart) {
299
- let resolveSetupMeta;
300
- result._setupMeta = new Promise((r) => {
301
- resolveSetupMeta = r;
302
- });
303
- result._onReady = (async () => {
304
- let needsSetupRun = !!setup;
305
- if (setup) {
306
- const existing = await storage.setup.get(setup.key);
307
- if (!(existing instanceof Error) && existing) {
308
- debug(
309
- `[sandbox:setup] setup already complete for key "${setup.key}", skipping`
310
- );
311
- needsSetupRun = false;
312
- }
313
- }
314
- resolveSetupMeta({
315
- needsSetupRun,
316
- createdFromSnapshot: false
317
- });
318
- if (needsSetupRun && setup) {
319
- debug(`[sandbox:setup] running setup.run (local, key="${setup.key}")`);
320
- await setup.run(sandbox);
321
- await storage.setup.set({
322
- key: setup.key,
323
- snapshotId: null,
324
- createdAt: Date.now(),
325
- lastUsedAt: null,
326
- acquiringLockId: null,
327
- acquiringLockAt: null
328
- });
329
- debug(
330
- `[sandbox:setup] setup complete, stored record (key="${setup.key}")`
331
- );
332
- }
333
- if (onRestart) {
334
- debug("[sandbox:setup] running onRestart (local)");
335
- await onRestart(sandbox);
336
- }
337
- })();
338
- }
339
- return result;
340
- };
341
-
342
- // src/sandbox/bindings/vercel.ts
343
- import * as path3 from "path";
344
- import { Sandbox as VercelSandboxSDK } from "@vercel/sandbox";
345
- import * as errore2 from "errore";
346
- import { start } from "workflow/api";
347
- var VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1e3;
348
- var LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
349
- var LOCK_POLL_INTERVAL_MS = 200;
350
- var getTestCredentials = () => process.env.NODE_ENV === "test" ? {
351
- token: process.env.TEST_VERCEL_TOKEN,
352
- teamId: process.env.TEST_VERCEL_TEAM_ID,
353
- projectId: process.env.TEST_VERCEL_PROJECT_ID
354
- } : {};
355
- var createPromises = /* @__PURE__ */ new Map();
356
- var ACTIVITY_THROTTLE_MS = 1e4;
357
- var lastActivitySent = /* @__PURE__ */ new Map();
358
- var DEFAULT_VCPUS = 2;
359
- function isSandboxGoneError(e) {
360
- if (!(e instanceof Error)) {
361
- return false;
362
- }
363
- const errorWithResponse = e;
364
- const errorWithCause = e;
365
- const status = errorWithResponse.response?.status ?? errorWithCause.cause?.response?.status;
366
- if (status === 410 || status === 422) {
367
- return true;
368
- }
369
- const message = e.message || String(e);
370
- if (message.includes("Expected a stream of command data") || message.includes("Expected a stream of logs")) {
371
- return true;
372
- }
373
- return false;
374
- }
375
- var vercelSandbox = ({
376
- sandboxRecord,
377
- storageConfig,
378
- enableLifecycleWorkflow,
379
- storage,
380
- rpc,
381
- setup,
382
- onRestart
383
- }) => {
384
- const { id, config } = sandboxRecord;
385
- const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;
386
- const ports = config.ports;
387
- const networkPolicy = config.networkPolicy;
388
- const initialVercel = sandboxRecord.providerMetadata?.provider === "vercel" ? sandboxRecord.providerMetadata : null;
389
- let sandboxPromise = null;
390
- let recoveredFromStale = false;
391
- let createdFromSnapshot = false;
392
- let needsSetupRun = false;
393
- const HOME_DIR = "/home/vercel-sandbox";
394
- async function pollForSandboxId() {
395
- const deadline = Date.now() + LOCK_TIMEOUT_MS;
396
- while (Date.now() < deadline) {
397
- await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));
398
- const record = await storage.sandbox.get(id);
399
- if (record instanceof Error) {
400
- return new SandboxError({ reason: record.message, cause: record });
401
- }
402
- const vercelSandboxId = record?.providerMetadata?.provider === "vercel" ? record.providerMetadata.sandboxId : null;
403
- if (vercelSandboxId) {
404
- return vercelSandboxId;
405
- }
406
- if (!record?.acquiringLockAt) {
407
- const finalCheck = await storage.sandbox.get(id);
408
- if (finalCheck instanceof Error) {
409
- return new SandboxError({
410
- reason: finalCheck.message,
411
- cause: finalCheck
412
- });
413
- }
414
- const finalVercelSandboxId = finalCheck?.providerMetadata?.provider === "vercel" ? finalCheck.providerMetadata.sandboxId : null;
415
- if (finalVercelSandboxId) {
416
- return finalVercelSandboxId;
417
- }
418
- return doGetOrCreateSandboxId();
419
- }
420
- }
421
- return new SandboxError({
422
- reason: "Timed out waiting for sandbox creation by another process"
423
- });
424
- }
425
- async function startLifecycleWorkflow(vercelSandboxId) {
426
- if (!enableLifecycleWorkflow) {
427
- return;
428
- }
429
- const lifecycleInput = {
430
- id,
431
- vercelSandboxId,
432
- storageConfig,
433
- rpc
434
- };
435
- await start(sandboxLifecycleWorkflow, [{ input: lifecycleInput }]).catch(
436
- // biome-ignore lint/suspicious/noEmptyBlockStatements: intentionally ignored - workflow start is fire-and-forget
437
- () => {
438
- }
439
- );
440
- }
441
- async function createSandboxFromSnapshot(snapshotId) {
442
- return await errore2.tryAsync({
443
- try: async () => {
444
- const sandbox2 = await VercelSandboxSDK.create({
445
- source: { type: "snapshot", snapshotId },
446
- resources: { vcpus },
447
- timeout: VERCEL_MAX_TIMEOUT_MS,
448
- ports,
449
- networkPolicy,
450
- ...getTestCredentials()
451
- });
452
- const now = Date.now();
453
- await storage.sandbox.set({
454
- id,
455
- config,
456
- tags: sandboxRecord.tags,
457
- createdAt: now,
458
- lastActivityAt: now,
459
- acquiringLockId: null,
460
- acquiringLockAt: null,
461
- providerMetadata: {
462
- provider: "vercel",
463
- sandboxId: sandbox2.sandboxId,
464
- snapshotId
465
- }
466
- });
467
- await startLifecycleWorkflow(sandbox2.sandboxId);
468
- return sandbox2.sandboxId;
469
- },
470
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
471
- });
472
- }
473
- async function createFreshSandbox() {
474
- return await errore2.tryAsync({
475
- try: async () => {
476
- const sandbox2 = await VercelSandboxSDK.create({
477
- resources: { vcpus },
478
- timeout: VERCEL_MAX_TIMEOUT_MS,
479
- ports,
480
- networkPolicy,
481
- ...getTestCredentials()
482
- });
483
- const now = Date.now();
484
- await storage.sandbox.set({
485
- id,
486
- config,
487
- tags: sandboxRecord.tags,
488
- createdAt: now,
489
- lastActivityAt: now,
490
- acquiringLockId: null,
491
- acquiringLockAt: null,
492
- providerMetadata: {
493
- provider: "vercel",
494
- sandboxId: sandbox2.sandboxId,
495
- snapshotId: null
496
- }
497
- });
498
- await startLifecycleWorkflow(sandbox2.sandboxId);
499
- return sandbox2.sandboxId;
500
- },
501
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
502
- });
503
- }
504
- function execOnInstance(instance, {
505
- command,
506
- args,
507
- signal
508
- }) {
509
- return errore2.tryAsync({
510
- try: async () => {
511
- const output = await instance.runCommand({
512
- cwd: HOME_DIR,
513
- args,
514
- cmd: command,
515
- signal,
516
- detached: true
517
- });
518
- let stdout = "";
519
- let stderr = "";
520
- const logBuffer = [];
521
- const state = {
522
- resolve: null,
523
- consumed: false
524
- };
525
- const consumeLogs = (async () => {
526
- try {
527
- for await (const log of output.logs()) {
528
- const entry = log.stream === "stdout" ? { stream: "stdout", data: log.data } : { stream: "stderr", data: log.data };
529
- if (log.stream === "stdout") {
530
- stdout += log.data;
531
- } else {
532
- stderr += log.data;
533
- }
534
- logBuffer.push(entry);
535
- state.resolve?.();
536
- }
537
- } catch {
538
- }
539
- state.consumed = true;
540
- state.resolve?.();
541
- })();
542
- async function* logs() {
543
- let index = 0;
544
- while (!state.consumed || index < logBuffer.length) {
545
- if (index < logBuffer.length) {
546
- yield logBuffer[index++];
547
- } else {
548
- await new Promise((resolve) => {
549
- state.resolve = resolve;
550
- });
551
- state.resolve = null;
552
- }
553
- }
554
- }
555
- const result = consumeLogs.then(async () => {
556
- try {
557
- const finished = await output.wait();
558
- return {
559
- stdout,
560
- stderr,
561
- exitCode: finished.exitCode
562
- };
563
- } catch (e) {
564
- if (isSandboxGoneError(e)) {
565
- return { stdout, stderr, exitCode: 1 };
566
- }
567
- throw e;
568
- }
569
- });
570
- return { commandId: output.cmdId, logs, result };
571
- },
572
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
573
- });
574
- }
575
- function readFileOnInstance(instance, { path: path4 }) {
576
- return errore2.tryAsync({
577
- try: () => instance.readFileToBuffer({ path: path4, cwd: HOME_DIR }),
578
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
579
- });
580
- }
581
- async function writeFilesOnInstance(instance, opts) {
582
- const { files, destPath } = opts;
583
- if (files.length === 0) {
584
- return;
585
- }
586
- const nativeFiles = files.map((file) => {
587
- const filePath = path3.posix.join(destPath, file.path);
588
- const absolutePath = path3.posix.isAbsolute(filePath) ? filePath : path3.posix.join(HOME_DIR, filePath);
589
- return {
590
- path: absolutePath,
591
- content: typeof file.content === "string" ? Buffer.from(file.content) : file.content
592
- };
593
- });
594
- await instance.writeFiles(nativeFiles);
595
- const shellScripts = nativeFiles.filter((f) => f.path.endsWith(".sh"));
596
- if (shellScripts.length > 0) {
597
- const chmodResult = await execOnInstance(instance, {
598
- command: "chmod",
599
- args: ["+x", ...shellScripts.map((f) => f.path)]
600
- });
601
- if (chmodResult instanceof Error) {
602
- throw chmodResult;
603
- }
604
- await chmodResult.result;
605
- }
606
- }
607
- function createTempSandbox(instance) {
608
- const tempSandbox = {
609
- id: `__setup_temp_${Date.now()}`,
610
- config,
611
- exec: (opts) => execOnInstance(instance, opts),
612
- readFile: (opts) => readFileOnInstance(instance, opts),
613
- getDomain: () => Promise.resolve(
614
- new SandboxError({ reason: "not available during setup" })
615
- ),
616
- kill: () => Promise.resolve(
617
- new SandboxError({ reason: "not available during setup" })
618
- ),
619
- writeFiles: (opts) => writeFilesOnInstance(instance, opts),
620
- updateNetworkPolicy: (policy) => errore2.tryAsync({
621
- try: () => instance.updateNetworkPolicy(policy),
622
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
623
- }),
624
- tag: {
625
- list: async () => ({}),
626
- get: async () => void 0,
627
- set: async () => void 0,
628
- setMany: async () => void 0
629
- }
630
- };
631
- return tempSandbox;
632
- }
633
- async function pollForSetupSnapshot(key) {
634
- const deadline = Date.now() + LOCK_TIMEOUT_MS;
635
- while (Date.now() < deadline) {
636
- await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));
637
- const record = await storage.setup.get(key);
638
- if (record instanceof Error) {
639
- return null;
640
- }
641
- if (record?.snapshotId) {
642
- return record.snapshotId;
643
- }
644
- if (!record?.acquiringLockId) {
645
- return null;
646
- }
647
- }
648
- return null;
649
- }
650
- async function createSetupSnapshot(opts) {
651
- if (!setup) {
652
- return;
653
- }
654
- const setupKey = setup.key;
655
- if (!opts?.force) {
656
- const existing = await storage.setup.get(setupKey);
657
- if (!(existing instanceof Error) && existing?.snapshotId) {
658
- return;
659
- }
660
- }
661
- debug(`[sandbox:setup] acquiring lock for setup key "${setupKey}"`);
662
- const lockId = crypto.randomUUID();
663
- const locked = await storage.setup.acquireLock(
664
- setupKey,
665
- lockId,
666
- LOCK_TIMEOUT_MS
667
- );
668
- if (locked instanceof Error || !locked) {
669
- debug(
670
- `[sandbox:setup] lock not acquired for key "${setupKey}" (another process holds it)`
671
- );
672
- return;
673
- }
674
- if (!opts?.force && locked.snapshotId) {
675
- debug(
676
- `[sandbox:setup] snapshot already exists after lock for key "${setupKey}", skipping`
677
- );
678
- return;
679
- }
680
- let tempInstance = null;
681
- try {
682
- debug(
683
- `[sandbox:setup] creating temp sandbox for snapshot (key="${setupKey}")`
684
- );
685
- tempInstance = await VercelSandboxSDK.create({
686
- resources: { vcpus },
687
- timeout: VERCEL_MAX_TIMEOUT_MS,
688
- ports,
689
- networkPolicy,
690
- ...getTestCredentials()
691
- });
692
- const tempSandbox = createTempSandbox(
693
- tempInstance
694
- );
695
- await setup.run(tempSandbox);
696
- debug(
697
- `[sandbox:setup] setup.run complete, snapshotting (key="${setupKey}")`
698
- );
699
- const snapshot = await tempInstance.snapshot();
700
- await storage.setup.set({
701
- key: setupKey,
702
- snapshotId: snapshot.snapshotId,
703
- createdAt: locked.createdAt,
704
- lastUsedAt: null,
705
- acquiringLockId: null,
706
- acquiringLockAt: null
707
- });
708
- debug(
709
- `[sandbox:setup] snapshot stored: ${snapshot.snapshotId} (key="${setupKey}")`
710
- );
711
- await tempInstance.stop().catch(() => void 0);
712
- } catch (e) {
713
- console.error(
714
- `[sandbox:setup] failed to create setup snapshot (key="${setupKey}"):`,
715
- e
716
- );
717
- if (tempInstance) {
718
- await tempInstance.stop().catch(() => void 0);
719
- }
720
- await storage.setup.set({
721
- key: setupKey,
722
- snapshotId: null,
723
- createdAt: locked.createdAt,
724
- lastUsedAt: null,
725
- acquiringLockId: null,
726
- acquiringLockAt: null
727
- }).catch(() => void 0);
728
- }
729
- }
730
- async function doGetOrCreateSandboxId() {
731
- if (initialVercel?.sandboxId && !recoveredFromStale) {
732
- return initialVercel.sandboxId;
733
- }
734
- const existing = await storage.sandbox.get(id);
735
- if (existing instanceof Error) {
736
- if (existing instanceof SandboxNotFoundError) {
737
- } else {
738
- return new SandboxError({ reason: existing.message, cause: existing });
739
- }
740
- }
741
- const existingRecord = existing instanceof SandboxNotFoundError ? null : existing;
742
- const existingVercel = existingRecord?.providerMetadata?.provider === "vercel" ? existingRecord.providerMetadata : null;
743
- if (existingVercel?.sandboxId) {
744
- return existingVercel.sandboxId;
745
- }
746
- const hasActiveLock = existingRecord?.acquiringLockId && existingRecord.acquiringLockAt && Date.now() - existingRecord.acquiringLockAt < LOCK_TIMEOUT_MS;
747
- if (hasActiveLock) {
748
- return pollForSandboxId();
749
- }
750
- const lockId = crypto.randomUUID();
751
- const now = Date.now();
752
- const locked = await storage.sandbox.acquireLock(
753
- {
754
- id,
755
- config,
756
- tags: existingRecord?.tags ?? sandboxRecord.tags,
757
- createdAt: existingRecord?.createdAt ?? sandboxRecord.createdAt,
758
- lastActivityAt: existingRecord?.lastActivityAt ?? sandboxRecord.lastActivityAt,
759
- acquiringLockId: lockId,
760
- acquiringLockAt: now,
761
- providerMetadata: {
762
- provider: "vercel",
763
- sandboxId: null,
764
- snapshotId: existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? null
765
- }
766
- },
767
- LOCK_TIMEOUT_MS
768
- );
769
- if (locked instanceof Error) {
770
- return new SandboxError({ reason: locked.message, cause: locked });
771
- }
772
- if (!locked) {
773
- return pollForSandboxId();
774
- }
775
- const lockedRecord = locked;
776
- async function releaseSandboxLock() {
777
- await storage.sandbox.set({
778
- ...lockedRecord,
779
- acquiringLockId: null,
780
- acquiringLockAt: null
781
- }).catch(() => void 0);
782
- }
783
- const lockedVercel = lockedRecord.providerMetadata?.provider === "vercel" ? lockedRecord.providerMetadata : null;
784
- if (lockedVercel?.sandboxId) {
785
- await releaseSandboxLock();
786
- return lockedVercel.sandboxId;
787
- }
788
- const snapshotId = lockedVercel?.snapshotId ?? initialVercel?.snapshotId ?? config.lifecycle?.snapshotId;
789
- if (snapshotId) {
790
- const result = await createSandboxFromSnapshot(snapshotId);
791
- if (!(result instanceof Error)) {
792
- createdFromSnapshot = true;
793
- return result;
794
- }
795
- }
796
- if (setup) {
797
- let forceRecreateSnapshot = false;
798
- const setupRecord = await storage.setup.get(setup.key);
799
- if (!(setupRecord instanceof Error) && setupRecord) {
800
- if (setupRecord.snapshotId) {
801
- debug(
802
- `[sandbox:setup] found setup snapshot ${setupRecord.snapshotId} for key "${setup.key}"`
803
- );
804
- const result = await createSandboxFromSnapshot(
805
- setupRecord.snapshotId
806
- );
807
- if (!(result instanceof Error)) {
808
- createdFromSnapshot = true;
809
- storage.setup.set({
810
- ...setupRecord,
811
- lastUsedAt: Date.now()
812
- }).catch(() => void 0);
813
- return result;
814
- }
815
- debug(
816
- `[sandbox:setup] snapshot ${setupRecord.snapshotId} failed (expired?), will recreate`
817
- );
818
- forceRecreateSnapshot = true;
819
- } else if (setupRecord.acquiringLockId && setupRecord.acquiringLockAt && Date.now() - setupRecord.acquiringLockAt < LOCK_TIMEOUT_MS) {
820
- debug(
821
- `[sandbox:setup] snapshot in progress for key "${setup.key}", waiting...`
822
- );
823
- const snapshotId2 = await pollForSetupSnapshot(setup.key);
824
- if (snapshotId2) {
825
- debug(
826
- `[sandbox:setup] snapshot ready: ${snapshotId2} for key "${setup.key}"`
827
- );
828
- const result = await createSandboxFromSnapshot(snapshotId2);
829
- if (!(result instanceof Error)) {
830
- createdFromSnapshot = true;
831
- return result;
832
- }
833
- }
834
- }
835
- }
836
- debug(
837
- `[sandbox:setup] no snapshot for key "${setup.key}", will run setup on this sandbox`
838
- );
839
- needsSetupRun = true;
840
- createSetupSnapshot({ force: forceRecreateSnapshot }).catch((e) => {
841
- console.error(
842
- "[sandbox:setup] failed to create background snapshot:",
843
- e
844
- );
845
- });
846
- }
847
- const freshResult = await createFreshSandbox();
848
- if (freshResult instanceof Error) {
849
- await releaseSandboxLock();
850
- }
851
- return freshResult;
852
- }
853
- function getOrCreateSandboxId() {
854
- const cached = createPromises.get(id);
855
- if (cached) {
856
- return cached;
857
- }
858
- const promise = doGetOrCreateSandboxId().finally(() => {
859
- createPromises.delete(id);
860
- });
861
- createPromises.set(id, promise);
862
- return promise;
863
- }
864
- async function doGetSandbox() {
865
- const vercelSandboxId = await getOrCreateSandboxId();
866
- if (vercelSandboxId instanceof Error) {
867
- return vercelSandboxId;
868
- }
869
- return errore2.tryAsync({
870
- try: () => VercelSandboxSDK.get({
871
- sandboxId: vercelSandboxId,
872
- ...getTestCredentials()
873
- }),
874
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
875
- });
876
- }
877
- function getSandbox2() {
878
- if (!sandboxPromise) {
879
- sandboxPromise = doGetSandbox();
880
- }
881
- return sandboxPromise;
882
- }
883
- async function recoverFromStaleSandbox() {
884
- sandboxPromise = null;
885
- recoveredFromStale = true;
886
- const existing = await storage.sandbox.get(id);
887
- if (existing instanceof Error || !existing) {
888
- return;
889
- }
890
- const existingVercel = existing.providerMetadata?.provider === "vercel" ? existing.providerMetadata : null;
891
- if (existingVercel?.sandboxId) {
892
- await storage.sandbox.set({
893
- id: existing.id,
894
- config: existing.config,
895
- tags: existing.tags,
896
- createdAt: existing.createdAt,
897
- lastActivityAt: existing.lastActivityAt,
898
- acquiringLockId: null,
899
- acquiringLockAt: null,
900
- providerMetadata: {
901
- provider: "vercel",
902
- sandboxId: null,
903
- snapshotId: existingVercel.snapshotId
904
- }
905
- });
906
- }
907
- }
908
- async function updateLastActivity() {
909
- const now = Date.now();
910
- const lastSent = lastActivitySent.get(id);
911
- if (lastSent && now - lastSent < ACTIVITY_THROTTLE_MS) {
912
- return;
913
- }
914
- lastActivitySent.set(id, now);
915
- const existing = await storage.sandbox.get(id);
916
- if (existing instanceof Error || !existing) {
917
- return;
918
- }
919
- const existingVercel = existing.providerMetadata?.provider === "vercel" ? existing.providerMetadata : null;
920
- await storage.sandbox.set({
921
- id: existing.id,
922
- config: existing.config,
923
- tags: existing.tags,
924
- createdAt: existing.createdAt,
925
- lastActivityAt: now,
926
- acquiringLockId: null,
927
- acquiringLockAt: null,
928
- providerMetadata: existingVercel ?? {
929
- provider: "vercel",
930
- sandboxId: null,
931
- snapshotId: null
932
- }
933
- });
934
- }
935
- const lifecycle = {
936
- start: async () => {
937
- const sandbox2 = await getSandbox2();
938
- if (sandbox2 instanceof Error) {
939
- return sandbox2;
940
- }
941
- await updateLastActivity();
942
- return sandbox2.status;
943
- },
944
- snapshot: async () => {
945
- const sandbox2 = await getSandbox2();
946
- if (sandbox2 instanceof Error) {
947
- return sandbox2;
948
- }
949
- return errore2.tryAsync({
950
- try: async () => {
951
- const existing = await storage.sandbox.get(id);
952
- const snapshot = await sandbox2.snapshot();
953
- await storage.sandbox.set({
954
- id,
955
- config,
956
- tags: existing instanceof Error ? null : existing?.tags ?? null,
957
- createdAt: existing instanceof Error ? null : existing?.createdAt ?? null,
958
- lastActivityAt: existing instanceof Error ? null : existing?.lastActivityAt ?? null,
959
- acquiringLockId: null,
960
- acquiringLockAt: null,
961
- providerMetadata: {
962
- provider: "vercel",
963
- sandboxId: null,
964
- snapshotId: snapshot.snapshotId
965
- }
966
- });
967
- return { snapshotId: snapshot.snapshotId };
968
- },
969
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
970
- });
971
- },
972
- stop: async () => {
973
- const sandbox2 = await getSandbox2();
974
- if (sandbox2 instanceof Error) {
975
- return sandbox2;
976
- }
977
- return errore2.tryAsync({
978
- try: async () => {
979
- await sandbox2.stop();
980
- const existing = await storage.sandbox.get(id);
981
- if (existing instanceof Error || !existing) {
982
- return void 0;
983
- }
984
- await storage.sandbox.set({
985
- id: existing.id,
986
- config: existing.config,
987
- tags: existing.tags,
988
- createdAt: existing.createdAt,
989
- lastActivityAt: existing.lastActivityAt,
990
- acquiringLockId: null,
991
- acquiringLockAt: null,
992
- providerMetadata: {
993
- provider: "vercel",
994
- sandboxId: null,
995
- snapshotId: null
996
- }
997
- });
998
- return void 0;
999
- },
1000
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
1001
- });
1002
- },
1003
- getStatus: async () => {
1004
- const sandbox2 = await getSandbox2();
1005
- if (sandbox2 instanceof Error) {
1006
- return sandbox2;
1007
- }
1008
- return sandbox2.status;
1009
- },
1010
- getCreatedAt: async () => {
1011
- const sandbox2 = await getSandbox2();
1012
- if (sandbox2 instanceof Error) {
1013
- return sandbox2;
1014
- }
1015
- return sandbox2.createdAt;
1016
- },
1017
- getRemainingTimeout: async () => {
1018
- const sandbox2 = await getSandbox2();
1019
- if (sandbox2 instanceof Error) {
1020
- return sandbox2;
1021
- }
1022
- return sandbox2.timeout;
1023
- }
1024
- };
1025
- async function doExec(opts) {
1026
- const instance = await getSandbox2();
1027
- if (instance instanceof Error) {
1028
- return instance;
1029
- }
1030
- const updatePromise = updateLastActivity();
1031
- const execResult = await execOnInstance(instance, opts);
1032
- await updatePromise;
1033
- return execResult;
1034
- }
1035
- const sandbox = {
1036
- id,
1037
- config,
1038
- exec: async (opts) => {
1039
- const result = await doExec(opts);
1040
- if (result instanceof SandboxError && isSandboxGoneError(result.cause)) {
1041
- await recoverFromStaleSandbox();
1042
- return await doExec(opts);
1043
- }
1044
- return result;
1045
- },
1046
- getDomain: async (port) => {
1047
- const sandbox2 = await getSandbox2();
1048
- if (sandbox2 instanceof Error) {
1049
- return sandbox2;
1050
- }
1051
- try {
1052
- return sandbox2.domain(port);
1053
- } catch (e) {
1054
- return new SandboxError({ reason: String(e), cause: e });
1055
- }
1056
- },
1057
- kill: async ({ commandId, storage: cmdStorage }) => {
1058
- const instance = await getSandbox2();
1059
- if (instance instanceof Error) {
1060
- return instance;
1061
- }
1062
- const cmd = await cmdStorage.command.get(commandId);
1063
- if (cmd instanceof Error) {
1064
- return new SandboxError({ reason: cmd.message, cause: cmd });
1065
- }
1066
- if (cmd && cmd.status === "running") {
1067
- const result = await cmdStorage.command.set({
1068
- ...cmd,
1069
- status: "killed"
1070
- });
1071
- if (result instanceof Error) {
1072
- return new SandboxError({ reason: result.message, cause: result });
1073
- }
1074
- }
1075
- return void 0;
1076
- },
1077
- readFile: async (opts) => {
1078
- const instance = await getSandbox2();
1079
- if (instance instanceof Error) {
1080
- return instance;
1081
- }
1082
- return readFileOnInstance(instance, opts);
1083
- },
1084
- writeFiles: async (opts) => {
1085
- const instance = await getSandbox2();
1086
- if (instance instanceof Error) {
1087
- throw instance;
1088
- }
1089
- return writeFilesOnInstance(instance, opts);
1090
- },
1091
- lifecycle,
1092
- updateNetworkPolicy: async (policy) => {
1093
- const instance = await getSandbox2();
1094
- if (instance instanceof Error) {
1095
- return instance;
1096
- }
1097
- return errore2.tryAsync({
1098
- try: () => instance.updateNetworkPolicy(policy),
1099
- catch: (e) => new SandboxError({ reason: String(e), cause: e })
1100
- });
1101
- },
1102
- tag: {
1103
- list: async () => {
1104
- const sandboxRecord2 = await storage.sandbox.get(id);
1105
- if (sandboxRecord2 instanceof Error) {
1106
- return sandboxRecord2;
1107
- }
1108
- return sandboxRecord2.tags ?? {};
1109
- },
1110
- get: async (key) => {
1111
- const sandboxRecord2 = await storage.sandbox.get(id);
1112
- if (sandboxRecord2 instanceof Error) {
1113
- return sandboxRecord2;
1114
- }
1115
- return sandboxRecord2.tags?.[key];
1116
- },
1117
- set: async (key, value) => {
1118
- const result = await storage.sandbox.tag.set({
1119
- sandboxId: id,
1120
- tags: { [key]: value }
1121
- });
1122
- if (result instanceof Error) {
1123
- return result;
1124
- }
1125
- return void 0;
1126
- },
1127
- setMany: async (tags) => {
1128
- const result = await storage.sandbox.tag.set({
1129
- sandboxId: id,
1130
- tags
1131
- });
1132
- if (result instanceof Error) {
1133
- return result;
1134
- }
1135
- return void 0;
1136
- }
1137
- }
1138
- };
1139
- let onReadyPromise = Promise.resolve();
1140
- let setupMetaPromise = Promise.resolve({
1141
- needsSetupRun: false,
1142
- createdFromSnapshot: false
1143
- });
1144
- if (config.lifecycle?.autoStart !== false) {
1145
- sandboxPromise = doGetSandbox();
1146
- setupMetaPromise = sandboxPromise.then(() => ({
1147
- needsSetupRun,
1148
- createdFromSnapshot
1149
- }));
1150
- onReadyPromise = sandboxPromise.then(async (instance) => {
1151
- if (instance instanceof Error) {
1152
- return;
1153
- }
1154
- if (needsSetupRun && setup) {
1155
- debug(
1156
- `[sandbox:setup] running setup.run on session sandbox (key="${setup.key}")`
1157
- );
1158
- await setup.run(sandbox);
1159
- debug("[sandbox:setup] setup.run complete on session sandbox");
1160
- }
1161
- if (createdFromSnapshot && onRestart) {
1162
- debug("[sandbox:setup] running onRestart (created from snapshot)");
1163
- await onRestart(sandbox);
1164
- }
1165
- });
1166
- }
1167
- sandbox._onReady = onReadyPromise;
1168
- sandbox._setupMeta = setupMetaPromise;
1169
- return sandbox;
1170
- };
1171
-
1172
- // src/sandbox/client.ts
1173
- var sandboxCache = /* @__PURE__ */ new Map();
1174
- function getSandbox({
1175
- sandboxRecord,
1176
- storageConfig,
1177
- storage,
1178
- rpc,
1179
- enableLifecycleWorkflow = true,
1180
- setup,
1181
- onRestart
1182
- }) {
1183
- const cached = sandboxCache.get(sandboxRecord.id);
1184
- if (cached) {
1185
- debug("[getSandbox] cache hit for", sandboxRecord.id);
1186
- return cached;
1187
- }
1188
- const sbx = createSandbox({
1189
- sandboxRecord,
1190
- storageConfig,
1191
- storage,
1192
- rpc,
1193
- enableLifecycleWorkflow,
1194
- setup,
1195
- onRestart
1196
- });
1197
- sandboxCache.set(sandboxRecord.id, sbx);
1198
- return sbx;
1199
- }
1200
- function createSandbox({
1201
- sandboxRecord,
1202
- storageConfig,
1203
- storage,
1204
- rpc,
1205
- enableLifecycleWorkflow = true,
1206
- setup,
1207
- onRestart
1208
- }) {
1209
- let sbx;
1210
- switch (sandboxRecord.config.type) {
1211
- case "local":
1212
- sbx = localSandbox({
1213
- sandboxRecord,
1214
- storage,
1215
- setup,
1216
- onRestart
1217
- });
1218
- break;
1219
- case "vercel":
1220
- sbx = vercelSandbox({
1221
- sandboxRecord,
1222
- storageConfig,
1223
- storage,
1224
- rpc,
1225
- enableLifecycleWorkflow,
1226
- setup,
1227
- onRestart
1228
- });
1229
- break;
1230
- case "custom":
1231
- throw new Error("Custom sandboxes are not supported");
1232
- default:
1233
- sandboxRecord.config;
1234
- throw new Error(
1235
- `Unknown sandbox type: ${// biome-ignore lint/suspicious/noExplicitAny: .
1236
- sandboxRecord.config.type}`
1237
- );
1238
- }
1239
- if (!sbx._onReady) {
1240
- return sbx;
1241
- }
1242
- const onReady = sbx._onReady;
1243
- return {
1244
- ...sbx,
1245
- exec: async (opts) => {
1246
- await onReady;
1247
- return sbx.exec(opts);
1248
- },
1249
- getDomain: async (port) => {
1250
- await onReady;
1251
- return sbx.getDomain(port);
1252
- },
1253
- readFile: async (opts) => {
1254
- await onReady;
1255
- return sbx.readFile(opts);
1256
- },
1257
- writeFiles: async (opts) => {
1258
- await onReady;
1259
- return sbx.writeFiles(opts);
1260
- }
1261
- };
1262
- }
1263
-
1264
- export {
1265
- getSandbox
1266
- };
1267
- //# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/utils/debug.ts", "../src/sandbox/bindings/local.ts", "../src/sandbox/write-files.ts", "../src/sandbox/bindings/vercel.ts", "../src/sandbox/client.ts"],
  "sourcesContent": ["const enabled =\n  process.env.AGENT_DEBUG === \"1\" || process.env.AGENT_DEBUG === \"true\";\n\nexport function debug(...args: unknown[]) {\n  if (enabled) {\n    console.log(...args);\n  }\n}\n", "import type { ChildProcess } from \"node:child_process\";\nimport { spawn } from \"node:child_process\";\nimport * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport * as errore from \"errore\";\nimport { ulid } from \"ulid\";\nimport { SandboxError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport type { SandboxRecord, Storage } from \"../../storage\";\nimport { debug } from \"../../utils/debug\";\nimport type { SandboxSetupMeta } from \"../client\";\nimport type { LogEntry, OnRestart, Sandbox, SandboxSetup } from \"../types\";\nimport { writeFiles } from \"../write-files\";\n\nexport const localSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storage,\n  setup,\n  onRestart,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"local\" } };\n  storage: Storage;\n  setup?: SandboxSetup;\n  onRestart?: OnRestart;\n}): Sandbox<TTags> & {\n  _onReady?: Promise<void>;\n  _setupMeta?: Promise<SandboxSetupMeta>;\n} => {\n  const config = sandboxRecord.config;\n  const basePath = config.path ?? process.cwd();\n  const processes = new Map<string, ChildProcess>();\n\n  const sandbox: Sandbox<TTags> = {\n    id: sandboxRecord.id,\n    config: sandboxRecord.config,\n    exec: ({ command, args, signal }) => {\n      return errore.tryAsync({\n        try: () => {\n          const commandId = `command_${ulid()}`;\n\n          const child = spawn(command, args, {\n            cwd: basePath,\n            signal,\n          });\n\n          processes.set(commandId, child);\n\n          let stdout = \"\";\n          let stderr = \"\";\n          const logQueue: LogEntry[] = [];\n          let logResolve: (() => void) | null = null;\n          let closed = false;\n\n          child.stdout.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stdout += str;\n            logQueue.push({ stream: \"stdout\", data: str });\n            logResolve?.();\n          });\n\n          child.stderr.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stderr += str;\n            logQueue.push({ stream: \"stderr\", data: str });\n            logResolve?.();\n          });\n\n          const result = new Promise<{\n            stdout: string;\n            stderr: string;\n            exitCode: number;\n          }>((resolve, reject) => {\n            child.on(\"error\", (err) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              reject(err);\n            });\n\n            child.on(\"close\", (code: number | null) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              resolve({ stdout, stderr, exitCode: code ?? 0 });\n            });\n          });\n\n          async function* logs(): AsyncIterable<LogEntry> {\n            while (!closed || logQueue.length > 0) {\n              const entry = logQueue.shift();\n              if (entry) {\n                yield entry;\n              } else if (!closed) {\n                await new Promise<void>((resolve) => {\n                  logResolve = resolve;\n                });\n                logResolve = null;\n              }\n            }\n          }\n\n          return Promise.resolve({ commandId, logs, result });\n        },\n        catch: (e: unknown) =>\n          new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getDomain: (port) => {\n      return Promise.resolve(`http://localhost:${port}`);\n    },\n\n    kill: async ({ commandId, storage }) => {\n      const child = processes.get(commandId);\n      if (!child) {\n        return new SandboxError({\n          reason: `Command ${commandId} not found or already finished`,\n        });\n      }\n\n      child.kill(\"SIGTERM\");\n\n      const cmd = await storage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await storage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n    },\n\n    readFile: async ({ path: filePath }) => {\n      const fullPath = path.join(basePath, filePath);\n      try {\n        return await fs.readFile(fullPath);\n      } catch (e: unknown) {\n        if (\n          e instanceof Error &&\n          \"code\" in e &&\n          (e as NodeJS.ErrnoException).code === \"ENOENT\"\n        ) {\n          return null;\n        }\n        return new SandboxError({ reason: String(e), cause: e });\n      }\n    },\n\n    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\n\n    updateNetworkPolicy: () =>\n      Promise.resolve(\n        new SandboxError({\n          reason: \"updateNetworkPolicy is only available for Vercel sandboxes\",\n        })\n      ),\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  const result: Sandbox<TTags> & {\n    _onReady?: Promise<void>;\n    _setupMeta?: Promise<SandboxSetupMeta>;\n  } = sandbox;\n\n  if (setup || onRestart) {\n    let resolveSetupMeta!: (meta: SandboxSetupMeta) => void;\n    result._setupMeta = new Promise<SandboxSetupMeta>((r) => {\n      resolveSetupMeta = r;\n    });\n\n    result._onReady = (async () => {\n      let needsSetupRun = !!setup;\n      if (setup) {\n        const existing = await storage.setup.get(setup.key);\n        if (!(existing instanceof Error) && existing) {\n          debug(\n            `[sandbox:setup] setup already complete for key \"${setup.key}\", skipping`\n          );\n          needsSetupRun = false;\n        }\n      }\n\n      // Resolve setup metadata before running setup so the workflow\n      // can emit the correct status indicator while setup runs.\n      resolveSetupMeta({\n        needsSetupRun,\n        createdFromSnapshot: false,\n      });\n\n      if (needsSetupRun && setup) {\n        debug(`[sandbox:setup] running setup.run (local, key=\"${setup.key}\")`);\n        await setup.run(sandbox);\n        await storage.setup.set({\n          key: setup.key,\n          snapshotId: null,\n          createdAt: Date.now(),\n          lastUsedAt: null,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n        });\n        debug(\n          `[sandbox:setup] setup complete, stored record (key=\"${setup.key}\")`\n        );\n      }\n      if (onRestart) {\n        debug(\"[sandbox:setup] running onRestart (local)\");\n        await onRestart(sandbox);\n      }\n    })();\n  }\n\n  return result;\n};\n", "import * as path from \"node:path\";\nimport type { UploadableFile } from \"../skills/types\";\nimport type { Sandbox } from \"./types\";\n\nconst MAX_RETRIES = 2;\nconst RETRY_BASE_MS = 500;\n\n/**\n * Exec a command and assert exit code 0. Retries on transient failures\n * (exit code 255 with empty stderr \u2014 typically a sandbox process killed\n * before it could produce output).\n */\nasync function execChecked(\n  sandbox: Pick<Sandbox, \"exec\">,\n  opts: { command: string; args?: string[] },\n  errorLabel: string\n): Promise<{ stdout: string; stderr: string; exitCode: number }> {\n  for (let attempt = 0; ; attempt++) {\n    const execResult = await sandbox.exec(opts);\n    if (execResult instanceof Error) {\n      throw execResult;\n    }\n    const result = await execResult.result;\n    if (result.exitCode === 0) {\n      return result;\n    }\n\n    const isTransient = result.exitCode === 255 && !result.stderr.trim();\n    if (isTransient && attempt < MAX_RETRIES) {\n      await new Promise((r) => setTimeout(r, RETRY_BASE_MS * (attempt + 1)));\n      continue;\n    }\n\n    throw new Error(\n      `${errorLabel} with exit code ${result.exitCode}: ${result.stderr}`\n    );\n  }\n}\n\n/**\n * Writes files to a sandbox at the specified destination path.\n * Shell scripts (.sh files) are automatically made executable.\n *\n * For small files (<100KB total), uses single exec with heredoc.\n * For large files, writes base64 chunks then decodes to avoid ARG_MAX limits.\n */\nexport async function writeFiles(opts: {\n  sandbox: Pick<Sandbox, \"exec\">;\n  files: UploadableFile[];\n  destPath: string;\n}): Promise<void> {\n  const { sandbox, files, destPath } = opts;\n\n  if (files.length === 0) {\n    return;\n  }\n\n  const filePaths = files.map((file) => path.posix.join(destPath, file.path));\n  const parentDirs = Array.from(\n    new Set(filePaths.map((p) => path.posix.dirname(p)))\n  );\n  const shellScripts = filePaths.filter((p) => p.endsWith(\".sh\"));\n\n  const mkdirResult = await sandbox.exec({\n    command: \"mkdir\",\n    args: [\"-p\", ...parentDirs],\n  });\n  if (mkdirResult instanceof Error) {\n    throw mkdirResult;\n  }\n  await mkdirResult.result;\n\n  const CHUNK_SIZE = 50_000;\n\n  for (let i = 0; i < files.length; i++) {\n    const file = files[i];\n    const fullPath = filePaths[i];\n    const base64Content = toBase64(file.content);\n\n    if (base64Content.length < CHUNK_SIZE) {\n      const marker = `EOF_${i}`;\n      await execChecked(\n        sandbox,\n        {\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `base64 -d > ${quote(fullPath)} << '${marker}'\n${base64Content}\n${marker}`,\n          ],\n        },\n        \"writeFiles failed\"\n      );\n    } else {\n      const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;\n\n      const clearResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\"-c\", `> ${quote(tempB64)}`],\n      });\n      if (clearResult instanceof Error) {\n        throw clearResult;\n      }\n      await clearResult.result;\n\n      for (\n        let offset = 0;\n        offset < base64Content.length;\n        offset += CHUNK_SIZE\n      ) {\n        const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);\n        const marker = `CHUNK_${offset}`;\n        await execChecked(\n          sandbox,\n          {\n            command: \"bash\",\n            args: [\n              \"-c\",\n              `cat >> ${quote(tempB64)} << '${marker}'\n${chunk}\n${marker}`,\n            ],\n          },\n          \"writeFiles chunk failed\"\n        );\n      }\n\n      await execChecked(\n        sandbox,\n        {\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`,\n          ],\n        },\n        \"writeFiles decode failed\"\n      );\n    }\n  }\n\n  if (shellScripts.length > 0) {\n    const chmodResult = await sandbox.exec({\n      command: \"chmod\",\n      args: [\"+x\", ...shellScripts],\n    });\n    if (chmodResult instanceof Error) {\n      throw chmodResult;\n    }\n    await chmodResult.result;\n  }\n}\n\nfunction toBase64(content: string | Buffer): string {\n  if (typeof content === \"string\") {\n    return Buffer.from(content).toString(\"base64\");\n  }\n  return content.toString(\"base64\");\n}\n\nfunction quote(s: string): string {\n  return `'${s.replace(/'/g, \"'\\\\''\")}'`;\n}\n", "import * as path from \"node:path\";\nimport { Sandbox as VercelSandboxSDK } from \"@vercel/sandbox\";\nimport * as errore from \"errore\";\nimport { start } from \"workflow/api\";\nimport { SandboxError, SandboxNotFoundError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport type { RpcFn, SandboxRecord, Storage, StorageConfig } from \"../../storage\";\nimport { debug } from \"../../utils/debug\";\nimport type { SandboxSetupMeta } from \"../client\";\nimport type {\n  LogEntry,\n  OnRestart,\n  Sandbox,\n  SandboxLifecycle,\n  SandboxLifecycleInput,\n  SandboxSetup,\n  SandboxStatus,\n} from \"../types\";\nimport { sandboxLifecycleWorkflow } from \"./lifecycle-workflow\";\n\nexport type VercelSandboxCreateOptions = Extract<\n  Parameters<typeof VercelSandboxSDK.create>[0],\n  // biome-ignore lint/complexity/noBannedTypes: .\n  {}\n>;\n\nexport const VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1000; // 5 hours\nconst LOCK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes - if lock older than this, consider it stale\nconst LOCK_POLL_INTERVAL_MS = 200;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\n/**\n * Module-level cache for in-flight sandbox creation promises.\n * Prevents parallel requests within the same process from creating duplicate sandboxes.\n */\nconst createPromises = new Map<string, Promise<SandboxError | string>>();\n\nconst ACTIVITY_THROTTLE_MS = 10_000;\nconst lastActivitySent = new Map<string, number>();\n\nconst DEFAULT_VCPUS = 2;\n\nfunction isSandboxGoneError(e: unknown): boolean {\n  if (!(e instanceof Error)) {\n    return false;\n  }\n\n  const errorWithResponse = e as { response?: { status?: number } };\n  const errorWithCause = e as { cause?: { response?: { status?: number } } };\n\n  const status =\n    errorWithResponse.response?.status ??\n    errorWithCause.cause?.response?.status;\n\n  if (status === 410 || status === 422) {\n    return true;\n  }\n\n  const message = e.message || String(e);\n  if (\n    message.includes(\"Expected a stream of command data\") ||\n    message.includes(\"Expected a stream of logs\")\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\nexport const vercelSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n  enableLifecycleWorkflow,\n  storage,\n  rpc,\n  setup,\n  onRestart,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"vercel\" } };\n  storageConfig: StorageConfig;\n  enableLifecycleWorkflow: boolean;\n  storage: Storage;\n  rpc?: RpcFn;\n  setup?: SandboxSetup;\n  onRestart?: OnRestart;\n}): Sandbox<TTags> & {\n  _onReady?: Promise<void>;\n  _setupMeta?: Promise<SandboxSetupMeta>;\n} => {\n  const { id, config } = sandboxRecord;\n  const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;\n  const ports = config.ports;\n  const networkPolicy = config.networkPolicy;\n  const initialVercel =\n    sandboxRecord.providerMetadata?.provider === \"vercel\"\n      ? sandboxRecord.providerMetadata\n      : null;\n\n  type SandboxInstance = Awaited<ReturnType<typeof VercelSandboxSDK.get>>;\n  let sandboxPromise: Promise<SandboxError | SandboxInstance> | null = null;\n  let recoveredFromStale = false;\n  let createdFromSnapshot = false;\n  let needsSetupRun = false;\n  const HOME_DIR = \"/home/vercel-sandbox\";\n\n  async function pollForSandboxId(): Promise<SandboxError | string> {\n    const deadline = Date.now() + LOCK_TIMEOUT_MS;\n    while (Date.now() < deadline) {\n      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));\n      const record = await storage.sandbox.get(id);\n      if (record instanceof Error) {\n        return new SandboxError({ reason: record.message, cause: record });\n      }\n      const vercelSandboxId =\n        record?.providerMetadata?.provider === \"vercel\"\n          ? record.providerMetadata.sandboxId\n          : null;\n      if (vercelSandboxId) {\n        return vercelSandboxId;\n      }\n      if (!record?.acquiringLockAt) {\n        const finalCheck = await storage.sandbox.get(id);\n        if (finalCheck instanceof Error) {\n          return new SandboxError({\n            reason: finalCheck.message,\n            cause: finalCheck,\n          });\n        }\n        const finalVercelSandboxId =\n          finalCheck?.providerMetadata?.provider === \"vercel\"\n            ? finalCheck.providerMetadata.sandboxId\n            : null;\n        if (finalVercelSandboxId) {\n          return finalVercelSandboxId;\n        }\n        return doGetOrCreateSandboxId();\n      }\n    }\n    return new SandboxError({\n      reason: \"Timed out waiting for sandbox creation by another process\",\n    });\n  }\n\n  async function startLifecycleWorkflow(\n    vercelSandboxId: string\n  ): Promise<void> {\n    if (!enableLifecycleWorkflow) {\n      return;\n    }\n    const lifecycleInput: SandboxLifecycleInput = {\n      id,\n      vercelSandboxId,\n      storageConfig,\n      rpc,\n    };\n    await start(sandboxLifecycleWorkflow, [{ input: lifecycleInput }]).catch(\n      // biome-ignore lint/suspicious/noEmptyBlockStatements: intentionally ignored - workflow start is fire-and-forget\n      () => {}\n    );\n  }\n\n  async function createSandboxFromSnapshot(\n    snapshotId: string\n  ): Promise<SandboxError | string> {\n    return await errore.tryAsync({\n      try: async () => {\n        const sandbox = await VercelSandboxSDK.create({\n          source: { type: \"snapshot\", snapshotId },\n          resources: { vcpus },\n          timeout: VERCEL_MAX_TIMEOUT_MS,\n          ports,\n          networkPolicy,\n          ...getTestCredentials(),\n        });\n        const now = Date.now();\n        await storage.sandbox.set({\n          id,\n          config,\n          tags: sandboxRecord.tags,\n          createdAt: now,\n          lastActivityAt: now,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n          providerMetadata: {\n            provider: \"vercel\",\n            sandboxId: sandbox.sandboxId,\n            snapshotId,\n          },\n        });\n        await startLifecycleWorkflow(sandbox.sandboxId);\n        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function createFreshSandbox(): Promise<SandboxError | string> {\n    return await errore.tryAsync({\n      try: async () => {\n        const sandbox = await VercelSandboxSDK.create({\n          resources: { vcpus },\n          timeout: VERCEL_MAX_TIMEOUT_MS,\n          ports,\n          networkPolicy,\n          ...getTestCredentials(),\n        });\n        const now = Date.now();\n        await storage.sandbox.set({\n          id,\n          config,\n          tags: sandboxRecord.tags,\n          createdAt: now,\n          lastActivityAt: now,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n          providerMetadata: {\n            provider: \"vercel\",\n            sandboxId: sandbox.sandboxId,\n            snapshotId: null,\n          },\n        });\n        await startLifecycleWorkflow(sandbox.sandboxId);\n        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  /**\n   * Core exec logic against a raw Vercel SDK instance.\n   * Shared between the main sandbox wrapper and temporary setup sandboxes.\n   */\n  function execOnInstance(\n    instance: SandboxInstance,\n    {\n      command,\n      args,\n      signal,\n    }: { command: string; args?: string[]; signal?: AbortSignal }\n  ): Promise<\n    | SandboxError\n    | {\n        commandId: string;\n        logs: () => AsyncIterable<LogEntry>;\n        result: Promise<{ stdout: string; stderr: string; exitCode: number }>;\n      }\n  > {\n    return errore.tryAsync({\n      try: async () => {\n        const output = await instance.runCommand({\n          cwd: HOME_DIR,\n          args,\n          cmd: command,\n          signal,\n          detached: true,\n        });\n\n        let stdout = \"\";\n        let stderr = \"\";\n        const logBuffer: LogEntry[] = [];\n        const state = {\n          resolve: null as (() => void) | null,\n          consumed: false,\n        };\n\n        const consumeLogs = (async () => {\n          try {\n            for await (const log of output.logs()) {\n              const entry: LogEntry =\n                log.stream === \"stdout\"\n                  ? { stream: \"stdout\", data: log.data }\n                  : { stream: \"stderr\", data: log.data };\n\n              if (log.stream === \"stdout\") {\n                stdout += log.data;\n              } else {\n                stderr += log.data;\n              }\n\n              logBuffer.push(entry);\n              state.resolve?.();\n            }\n          } catch {\n            // Sandbox may have been stopped - logs endpoint returns 422\n          }\n          state.consumed = true;\n          state.resolve?.();\n        })();\n\n        async function* logs(): AsyncIterable<LogEntry> {\n          let index = 0;\n          while (!state.consumed || index < logBuffer.length) {\n            if (index < logBuffer.length) {\n              yield logBuffer[index++];\n            } else {\n              await new Promise<void>((resolve) => {\n                state.resolve = resolve;\n              });\n              state.resolve = null;\n            }\n          }\n        }\n\n        const result = consumeLogs.then(async () => {\n          try {\n            const finished = await output.wait();\n            return {\n              stdout,\n              stderr,\n              exitCode: finished.exitCode,\n            };\n          } catch (e) {\n            if (isSandboxGoneError(e)) {\n              return { stdout, stderr, exitCode: 1 };\n            }\n            throw e;\n          }\n        });\n\n        return { commandId: output.cmdId, logs, result };\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  function readFileOnInstance(\n    instance: SandboxInstance,\n    { path }: { path: string }\n  ): Promise<SandboxError | Buffer | null> {\n    return errore.tryAsync({\n      try: () => instance.readFileToBuffer({ path, cwd: HOME_DIR }),\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function writeFilesOnInstance(\n    instance: SandboxInstance,\n    opts: {\n      files: { path: string; content: string | Buffer }[];\n      destPath: string;\n    }\n  ): Promise<void> {\n    const { files, destPath } = opts;\n    if (files.length === 0) {\n      return;\n    }\n\n    const nativeFiles = files.map((file) => {\n      const filePath = path.posix.join(destPath, file.path);\n      const absolutePath = path.posix.isAbsolute(filePath)\n        ? filePath\n        : path.posix.join(HOME_DIR, filePath);\n      return {\n        path: absolutePath,\n        content:\n          typeof file.content === \"string\"\n            ? Buffer.from(file.content)\n            : file.content,\n      };\n    });\n\n    await instance.writeFiles(nativeFiles);\n\n    const shellScripts = nativeFiles.filter((f) => f.path.endsWith(\".sh\"));\n    if (shellScripts.length > 0) {\n      const chmodResult = await execOnInstance(instance, {\n        command: \"chmod\",\n        args: [\"+x\", ...shellScripts.map((f) => f.path)],\n      });\n      if (chmodResult instanceof Error) {\n        throw chmodResult;\n      }\n      await chmodResult.result;\n    }\n  }\n\n  /**\n   * Creates a minimal Sandbox wrapper around a raw Vercel SDK instance.\n   * Used for running setup.run() on a temporary sandbox for snapshot creation.\n   */\n  function createTempSandbox(instance: SandboxInstance): Sandbox {\n    const tempSandbox: Sandbox = {\n      id: `__setup_temp_${Date.now()}`,\n      config,\n      exec: (opts) => execOnInstance(instance, opts),\n      readFile: (opts) => readFileOnInstance(instance, opts),\n      getDomain: () =>\n        Promise.resolve(\n          new SandboxError({ reason: \"not available during setup\" })\n        ),\n      kill: () =>\n        Promise.resolve(\n          new SandboxError({ reason: \"not available during setup\" })\n        ),\n      writeFiles: (opts) => writeFilesOnInstance(instance, opts),\n      updateNetworkPolicy: (policy) =>\n        errore.tryAsync({\n          try: () => instance.updateNetworkPolicy(policy),\n          catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n        }),\n      tag: {\n        list: async () => ({}) as TTags,\n        get: async () => undefined,\n        set: async () => undefined,\n        setMany: async () => undefined,\n      },\n    };\n    return tempSandbox;\n  }\n\n  /**\n   * Polls for a setup snapshot to become available. Returns the snapshotId\n   * if one appears before the lock times out, or null if it doesn't.\n   */\n  async function pollForSetupSnapshot(key: string): Promise<string | null> {\n    const deadline = Date.now() + LOCK_TIMEOUT_MS;\n    while (Date.now() < deadline) {\n      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));\n      const record = await storage.setup.get(key);\n      if (record instanceof Error) {\n        return null;\n      }\n      if (record?.snapshotId) {\n        return record.snapshotId;\n      }\n      // Lock released but no snapshot \u2014 creation failed\n      if (!record?.acquiringLockId) {\n        return null;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Creates a background sandbox, runs setup, snapshots it, and stores the\n   * snapshot ID. Uses atomic locking to ensure only one process creates it.\n   *\n   * @param force - Skip the \"snapshot already exists\" early exit. Used when\n   *   the caller knows the existing snapshot is stale/expired.\n   */\n  async function createSetupSnapshot(opts?: {\n    force?: boolean;\n  }): Promise<void> {\n    if (!setup) {\n      return;\n    }\n    const setupKey = setup.key;\n\n    // Check if snapshot already exists (fast path \u2014 avoids lock attempt)\n    if (!opts?.force) {\n      const existing = await storage.setup.get(setupKey);\n      if (!(existing instanceof Error) && existing?.snapshotId) {\n        return;\n      }\n    }\n\n    // Atomically acquire lock (handles active-lock detection internally)\n    debug(`[sandbox:setup] acquiring lock for setup key \"${setupKey}\"`);\n    const lockId = crypto.randomUUID();\n    const locked = await storage.setup.acquireLock(\n      setupKey,\n      lockId,\n      LOCK_TIMEOUT_MS\n    );\n    if (locked instanceof Error || !locked) {\n      debug(\n        `[sandbox:setup] lock not acquired for key \"${setupKey}\" (another process holds it)`\n      );\n      return;\n    }\n\n    // Re-check: another worker may have created the snapshot between our\n    // pre-check and lock acquisition. If so, skip unless force (stale snapshot).\n    if (!opts?.force && locked.snapshotId) {\n      debug(\n        `[sandbox:setup] snapshot already exists after lock for key \"${setupKey}\", skipping`\n      );\n      return;\n    }\n\n    let tempInstance: Awaited<\n      ReturnType<typeof VercelSandboxSDK.create>\n    > | null = null;\n    try {\n      // Create a temporary sandbox for snapshotting.\n      debug(\n        `[sandbox:setup] creating temp sandbox for snapshot (key=\"${setupKey}\")`\n      );\n      tempInstance = await VercelSandboxSDK.create({\n        resources: { vcpus },\n        timeout: VERCEL_MAX_TIMEOUT_MS,\n        ports,\n        networkPolicy,\n        ...getTestCredentials(),\n      });\n\n      const tempSandbox = createTempSandbox(\n        tempInstance as unknown as SandboxInstance\n      );\n      await setup.run(tempSandbox);\n      debug(\n        `[sandbox:setup] setup.run complete, snapshotting (key=\"${setupKey}\")`\n      );\n      const snapshot = await tempInstance.snapshot();\n\n      await storage.setup.set({\n        key: setupKey,\n        snapshotId: snapshot.snapshotId,\n        createdAt: locked.createdAt,\n        lastUsedAt: null,\n        acquiringLockId: null,\n        acquiringLockAt: null,\n      });\n      debug(\n        `[sandbox:setup] snapshot stored: ${snapshot.snapshotId} (key=\"${setupKey}\")`\n      );\n\n      // Stop the temp sandbox \u2014 no longer needed after snapshotting\n      await tempInstance.stop().catch(() => undefined);\n    } catch (e) {\n      console.error(\n        `[sandbox:setup] failed to create setup snapshot (key=\"${setupKey}\"):`,\n        e\n      );\n      // Stop the temp sandbox on failure\n      if (tempInstance) {\n        await tempInstance.stop().catch(() => undefined);\n      }\n      // Clean up lock on failure\n      await storage.setup\n        .set({\n          key: setupKey,\n          snapshotId: null,\n          createdAt: locked.createdAt,\n          lastUsedAt: null,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n        })\n        .catch(() => undefined);\n    }\n  }\n\n  async function doGetOrCreateSandboxId(): Promise<SandboxError | string> {\n    if (initialVercel?.sandboxId && !recoveredFromStale) {\n      return initialVercel.sandboxId;\n    }\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error) {\n      if (existing instanceof SandboxNotFoundError) {\n        // Sandbox doesn't exist yet, continue with creation\n      } else {\n        return new SandboxError({ reason: existing.message, cause: existing });\n      }\n    }\n\n    const existingRecord =\n      existing instanceof SandboxNotFoundError ? null : existing;\n    const existingVercel =\n      existingRecord?.providerMetadata?.provider === \"vercel\"\n        ? existingRecord.providerMetadata\n        : null;\n\n    if (existingVercel?.sandboxId) {\n      return existingVercel.sandboxId;\n    }\n\n    const hasActiveLock =\n      existingRecord?.acquiringLockId &&\n      existingRecord.acquiringLockAt &&\n      Date.now() - existingRecord.acquiringLockAt < LOCK_TIMEOUT_MS;\n\n    if (hasActiveLock) {\n      return pollForSandboxId();\n    }\n\n    const lockId = crypto.randomUUID();\n    const now = Date.now();\n    const locked = await storage.sandbox.acquireLock(\n      {\n        id,\n        config,\n        tags: existingRecord?.tags ?? sandboxRecord.tags,\n        createdAt: existingRecord?.createdAt ?? sandboxRecord.createdAt,\n        lastActivityAt:\n          existingRecord?.lastActivityAt ?? sandboxRecord.lastActivityAt,\n        acquiringLockId: lockId,\n        acquiringLockAt: now,\n        providerMetadata: {\n          provider: \"vercel\",\n          sandboxId: null,\n          snapshotId:\n            existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? null,\n        },\n      },\n      LOCK_TIMEOUT_MS\n    );\n\n    if (locked instanceof Error) {\n      return new SandboxError({ reason: locked.message, cause: locked });\n    }\n    if (!locked) {\n      return pollForSandboxId();\n    }\n\n    // Capture the locked record for use in the release helper.\n    // TS can't narrow `locked` inside nested functions, so we bind it here.\n    const lockedRecord = locked;\n\n    // Release the sandbox lock so other workers can retry quickly\n    // instead of waiting for lock timeout.\n    async function releaseSandboxLock(): Promise<void> {\n      await storage.sandbox\n        .set({\n          ...lockedRecord,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n        })\n        .catch(() => undefined);\n    }\n\n    // Re-check after lock: another worker may have created the sandbox\n    // between our initial check and lock acquisition.\n    const lockedVercel =\n      lockedRecord.providerMetadata?.provider === \"vercel\"\n        ? lockedRecord.providerMetadata\n        : null;\n    if (lockedVercel?.sandboxId) {\n      await releaseSandboxLock();\n      return lockedVercel.sandboxId;\n    }\n\n    const snapshotId =\n      lockedVercel?.snapshotId ??\n      initialVercel?.snapshotId ??\n      config.lifecycle?.snapshotId;\n    if (snapshotId) {\n      const result = await createSandboxFromSnapshot(snapshotId);\n      if (!(result instanceof Error)) {\n        createdFromSnapshot = true;\n        return result;\n      }\n    }\n\n    // Check for setup snapshot\n    if (setup) {\n      let forceRecreateSnapshot = false;\n      const setupRecord = await storage.setup.get(setup.key);\n      if (!(setupRecord instanceof Error) && setupRecord) {\n        if (setupRecord.snapshotId) {\n          debug(\n            `[sandbox:setup] found setup snapshot ${setupRecord.snapshotId} for key \"${setup.key}\"`\n          );\n          const result = await createSandboxFromSnapshot(\n            setupRecord.snapshotId\n          );\n          if (!(result instanceof Error)) {\n            createdFromSnapshot = true;\n            // Update lastUsedAt (fire-and-forget)\n            storage.setup\n              .set({\n                ...setupRecord,\n                lastUsedAt: Date.now(),\n              })\n              .catch(() => undefined);\n            return result;\n          }\n          // Snapshot is stale/expired \u2014 force background to overwrite it\n          debug(\n            `[sandbox:setup] snapshot ${setupRecord.snapshotId} failed (expired?), will recreate`\n          );\n          forceRecreateSnapshot = true;\n        } else if (\n          setupRecord.acquiringLockId &&\n          setupRecord.acquiringLockAt &&\n          Date.now() - setupRecord.acquiringLockAt < LOCK_TIMEOUT_MS\n        ) {\n          // Another process is creating the setup snapshot \u2014 wait for it\n          debug(\n            `[sandbox:setup] snapshot in progress for key \"${setup.key}\", waiting...`\n          );\n          const snapshotId = await pollForSetupSnapshot(setup.key);\n          if (snapshotId) {\n            debug(\n              `[sandbox:setup] snapshot ready: ${snapshotId} for key \"${setup.key}\"`\n            );\n            const result = await createSandboxFromSnapshot(snapshotId);\n            if (!(result instanceof Error)) {\n              createdFromSnapshot = true;\n              return result;\n            }\n          }\n          // Poll failed or snapshot creation failed \u2014 fall through to cold path\n        }\n      }\n      // No setup snapshot available \u2014 create fresh and run setup later.\n      // Kick off background snapshot immediately so it runs in parallel\n      // with setup.run on the session sandbox.\n      debug(\n        `[sandbox:setup] no snapshot for key \"${setup.key}\", will run setup on this sandbox`\n      );\n      needsSetupRun = true;\n      createSetupSnapshot({ force: forceRecreateSnapshot }).catch((e) => {\n        console.error(\n          \"[sandbox:setup] failed to create background snapshot:\",\n          e\n        );\n      });\n    }\n\n    const freshResult = await createFreshSandbox();\n    if (freshResult instanceof Error) {\n      await releaseSandboxLock();\n    }\n    return freshResult;\n  }\n\n  function getOrCreateSandboxId(): Promise<SandboxError | string> {\n    const cached = createPromises.get(id);\n    if (cached) {\n      return cached;\n    }\n\n    const promise = doGetOrCreateSandboxId().finally(() => {\n      createPromises.delete(id);\n    });\n    createPromises.set(id, promise);\n    return promise;\n  }\n\n  async function doGetSandbox(): Promise<SandboxError | SandboxInstance> {\n    const vercelSandboxId = await getOrCreateSandboxId();\n    if (vercelSandboxId instanceof Error) {\n      return vercelSandboxId;\n    }\n\n    return errore.tryAsync({\n      try: () =>\n        VercelSandboxSDK.get({\n          sandboxId: vercelSandboxId,\n          ...getTestCredentials(),\n        }),\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  function getSandbox(): Promise<SandboxError | SandboxInstance> {\n    if (!sandboxPromise) {\n      sandboxPromise = doGetSandbox();\n    }\n    return sandboxPromise;\n  }\n\n  async function recoverFromStaleSandbox(): Promise<void> {\n    sandboxPromise = null;\n    recoveredFromStale = true;\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error || !existing) {\n      return;\n    }\n\n    const existingVercel =\n      existing.providerMetadata?.provider === \"vercel\"\n        ? existing.providerMetadata\n        : null;\n\n    if (existingVercel?.sandboxId) {\n      await storage.sandbox.set({\n        id: existing.id,\n        config: existing.config,\n        tags: existing.tags,\n        createdAt: existing.createdAt,\n        lastActivityAt: existing.lastActivityAt,\n        acquiringLockId: null,\n        acquiringLockAt: null,\n        providerMetadata: {\n          provider: \"vercel\",\n          sandboxId: null,\n          snapshotId: existingVercel.snapshotId,\n        },\n      });\n    }\n  }\n\n  async function updateLastActivity(): Promise<void> {\n    const now = Date.now();\n    const lastSent = lastActivitySent.get(id);\n    if (lastSent && now - lastSent < ACTIVITY_THROTTLE_MS) {\n      return;\n    }\n    lastActivitySent.set(id, now);\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error || !existing) {\n      return;\n    }\n    const existingVercel =\n      existing.providerMetadata?.provider === \"vercel\"\n        ? existing.providerMetadata\n        : null;\n    await storage.sandbox.set({\n      id: existing.id,\n      config: existing.config,\n      tags: existing.tags,\n      createdAt: existing.createdAt,\n      lastActivityAt: now,\n      acquiringLockId: null,\n      acquiringLockAt: null,\n      providerMetadata: existingVercel ?? {\n        provider: \"vercel\",\n        sandboxId: null,\n        snapshotId: null,\n      },\n    });\n  }\n\n  const lifecycle: SandboxLifecycle = {\n    start: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      await updateLastActivity();\n      return sandbox.status as SandboxStatus;\n    },\n\n    snapshot: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      return errore.tryAsync({\n        try: async () => {\n          const existing = await storage.sandbox.get(id);\n          const snapshot = await sandbox.snapshot();\n          await storage.sandbox.set({\n            id,\n            config,\n            tags: existing instanceof Error ? null : (existing?.tags ?? null),\n            createdAt:\n              existing instanceof Error ? null : (existing?.createdAt ?? null),\n            lastActivityAt:\n              existing instanceof Error\n                ? null\n                : (existing?.lastActivityAt ?? null),\n            acquiringLockId: null,\n            acquiringLockAt: null,\n            providerMetadata: {\n              provider: \"vercel\",\n              sandboxId: null,\n              snapshotId: snapshot.snapshotId,\n            },\n          });\n          return { snapshotId: snapshot.snapshotId };\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    stop: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      return errore.tryAsync({\n        try: async () => {\n          await sandbox.stop();\n          const existing = await storage.sandbox.get(id);\n          if (existing instanceof Error || !existing) {\n            return undefined;\n          }\n          await storage.sandbox.set({\n            id: existing.id,\n            config: existing.config,\n            tags: existing.tags,\n            createdAt: existing.createdAt,\n            lastActivityAt: existing.lastActivityAt,\n            acquiringLockId: null,\n            acquiringLockAt: null,\n            providerMetadata: {\n              provider: \"vercel\",\n              sandboxId: null,\n              snapshotId: null,\n            },\n          });\n          return undefined;\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getStatus: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.status as SandboxStatus;\n    },\n\n    getCreatedAt: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.createdAt;\n    },\n\n    getRemainingTimeout: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.timeout;\n    },\n  };\n\n  async function doExec(opts: {\n    command: string;\n    args?: string[];\n    signal?: AbortSignal;\n  }) {\n    const instance = await getSandbox();\n    if (instance instanceof Error) {\n      return instance;\n    }\n\n    const updatePromise = updateLastActivity();\n    const execResult = await execOnInstance(instance, opts);\n    await updatePromise;\n    return execResult;\n  }\n\n  const sandbox: Sandbox<TTags> & {\n    _onReady?: Promise<void>;\n    _setupMeta?: Promise<SandboxSetupMeta>;\n  } = {\n    id,\n    config,\n    exec: async (opts) => {\n      const result = await doExec(opts);\n\n      if (result instanceof SandboxError && isSandboxGoneError(result.cause)) {\n        await recoverFromStaleSandbox();\n        return await doExec(opts);\n      }\n\n      return result;\n    },\n\n    getDomain: async (port) => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      try {\n        return sandbox.domain(port);\n      } catch (e) {\n        return new SandboxError({ reason: String(e), cause: e });\n      }\n    },\n\n    kill: async ({ commandId, storage: cmdStorage }) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n\n      const cmd = await cmdStorage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await cmdStorage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n      return undefined;\n    },\n\n    readFile: async (opts) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n      return readFileOnInstance(instance, opts);\n    },\n\n    writeFiles: async (opts) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        throw instance;\n      }\n      return writeFilesOnInstance(instance, opts);\n    },\n\n    lifecycle,\n\n    updateNetworkPolicy: async (policy) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n      return errore.tryAsync({\n        try: () => instance.updateNetworkPolicy(policy),\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  let onReadyPromise: Promise<void> = Promise.resolve();\n  let setupMetaPromise: Promise<SandboxSetupMeta> = Promise.resolve({\n    needsSetupRun: false,\n    createdFromSnapshot: false,\n  });\n\n  if (config.lifecycle?.autoStart !== false) {\n    sandboxPromise = doGetSandbox();\n\n    // Resolve setup metadata as soon as the sandbox instance is ready\n    // (before _onReady runs setup). The workflow reads this to choose the status indicator.\n    setupMetaPromise = sandboxPromise.then(() => ({\n      needsSetupRun,\n      createdFromSnapshot,\n    }));\n\n    // After sandbox instance is ready, run setup and/or onRestart.\n    // sandboxPromise is already resolved by the time .then() runs,\n    // so setup.run / onRestart calling sandbox.exec() won't deadlock.\n    onReadyPromise = sandboxPromise.then(async (instance) => {\n      if (instance instanceof Error) {\n        return;\n      }\n\n      if (needsSetupRun && setup) {\n        debug(\n          `[sandbox:setup] running setup.run on session sandbox (key=\"${setup.key}\")`\n        );\n        await setup.run(sandbox);\n        debug(\"[sandbox:setup] setup.run complete on session sandbox\");\n      }\n\n      if (createdFromSnapshot && onRestart) {\n        debug(\"[sandbox:setup] running onRestart (created from snapshot)\");\n        await onRestart(sandbox);\n      }\n    });\n  }\n\n  sandbox._onReady = onReadyPromise;\n  sandbox._setupMeta = setupMetaPromise;\n  return sandbox;\n};\n", "import type { TagsSchema } from \"../index\";\nimport type { RpcFn, SandboxRecord, Storage, StorageConfig } from \"../storage\";\nimport { debug } from \"../utils/debug\";\nimport { localSandbox } from \"./bindings/local\";\nimport { vercelSandbox } from \"./bindings/vercel\";\nimport type { OnRestart, Sandbox, SandboxSetup } from \"./types\";\n\n/**\n * Metadata about how the sandbox was set up.\n * Used by the workflow to emit the correct status indicator.\n * Returned as a promise because the metadata is determined asynchronously\n * during sandbox creation, before _onReady runs setup.\n */\nexport type SandboxSetupMeta = {\n  /** Whether setup.run() needs to execute (cold start, no snapshot). */\n  needsSetupRun: boolean;\n  /** Whether the sandbox was created from a snapshot. */\n  createdFromSnapshot: boolean;\n};\n\ntype SandboxWithMeta<TTags extends TagsSchema = TagsSchema> = Sandbox<TTags> & {\n  _onReady?: Promise<void>;\n  _setupMeta?: Promise<SandboxSetupMeta>;\n};\n\n/**\n * Module-level cache for sandbox instances keyed by sandbox record ID.\n *\n * Caches all sandbox instances so that the workflow (which calls getSandbox\n * without setup/onRestart) reuses the same instance created during session(),\n * including its _onReady promise and setup metadata.\n */\nconst sandboxCache = new Map<string, SandboxWithMeta>();\n\nexport function getSandbox<TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n  storage,\n  rpc,\n  enableLifecycleWorkflow = true,\n  setup,\n  onRestart,\n}: {\n  storageConfig: StorageConfig;\n  sandboxRecord: SandboxRecord;\n  storage: Storage;\n  rpc?: RpcFn;\n  enableLifecycleWorkflow?: boolean;\n  setup?: SandboxSetup;\n  onRestart?: OnRestart;\n}): SandboxWithMeta<TTags> {\n  const cached = sandboxCache.get(sandboxRecord.id);\n  if (cached) {\n    debug(\"[getSandbox] cache hit for\", sandboxRecord.id);\n    return cached as SandboxWithMeta<TTags>;\n  }\n\n  const sbx = createSandbox<TTags>({\n    sandboxRecord,\n    storageConfig,\n    storage,\n    rpc,\n    enableLifecycleWorkflow,\n    setup,\n    onRestart,\n  });\n\n  sandboxCache.set(sandboxRecord.id, sbx as SandboxWithMeta);\n\n  return sbx;\n}\n\nfunction createSandbox<TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n  storage,\n  rpc,\n  enableLifecycleWorkflow = true,\n  setup,\n  onRestart,\n}: {\n  storageConfig: StorageConfig;\n  sandboxRecord: SandboxRecord;\n  storage: Storage;\n  rpc?: RpcFn;\n  enableLifecycleWorkflow?: boolean;\n  setup?: SandboxSetup;\n  onRestart?: OnRestart;\n}): SandboxWithMeta<TTags> {\n  let sbx: SandboxWithMeta<TTags>;\n\n  switch (sandboxRecord.config.type) {\n    case \"local\":\n      sbx = localSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"local\" };\n        },\n        storage,\n        setup,\n        onRestart,\n      });\n      break;\n    case \"vercel\":\n      sbx = vercelSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"vercel\" };\n        },\n        storageConfig,\n        storage,\n        rpc: rpc!,\n        enableLifecycleWorkflow,\n        setup,\n        onRestart,\n      });\n      break;\n    case \"custom\":\n      throw new Error(\"Custom sandboxes are not supported\");\n    default:\n      sandboxRecord.config satisfies never;\n      throw new Error(\n        `Unknown sandbox type: ${\n          // biome-ignore lint/suspicious/noExplicitAny: .\n          (sandboxRecord.config as any).type\n        }`\n      );\n  }\n\n  // Don't await _onReady here \u2014 let the workflow await it so it can emit\n  // status indicators over the stream while setup runs.\n  // Instead, wrap sandbox methods so any operation on the sandbox implicitly\n  // waits for setup to complete. We return a NEW object so that setup.run(),\n  // which holds the original `sbx` via closure, calls unwrapped methods and\n  // avoids a deadlock.\n  if (!sbx._onReady) {\n    return sbx;\n  }\n\n  const onReady = sbx._onReady;\n  return {\n    ...sbx,\n    exec: async (opts) => {\n      await onReady;\n      return sbx.exec(opts);\n    },\n    getDomain: async (port) => {\n      await onReady;\n      return sbx.getDomain(port);\n    },\n    readFile: async (opts) => {\n      await onReady;\n      return sbx.readFile(opts);\n    },\n    writeFiles: async (opts) => {\n      await onReady;\n      return sbx.writeFiles(opts);\n    },\n  };\n}\n"],
  "mappings": "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",
  "names": ["path", "result", "storage", "sandboxRecord", "path", "errore", "sandbox", "path", "snapshotId", "getSandbox", "sandboxRecord"]
}
