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