experimental-agent 0.1.4 → 0.2.1

package/dist/chunk-AML2VCQS.mjs

@@ -0,0 +1,1287 @@
+import {
+  dockerSandbox,
+  markSetupComplete,
+  pollForSetupCompletion,
+  resetSetupState,
+  writeFiles
+} from "./chunk-ZIAHPXOJ.mjs";
+import {
+  createLogger
+} from "./chunk-OZZVS6L5.mjs";
+import {
+  sandboxLifecycleWorkflow
+} from "./chunk-NXDVNJRS.mjs";
+import {
+  getStorage
+} from "./chunk-TGNVXSMX.mjs";
+import {
+  SandboxError,
+  SandboxNotFoundError
+} from "./chunk-YRYXN7W4.mjs";
+
+// src/sandbox/bindings/local.ts
+import { spawn } from "child_process";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as errore from "errore";
+import { ulid } from "ulid";
+var localSandbox = ({
+  sandboxRecord,
+  storage,
+  setup,
+  onRestart
+}) => {
+  const config = sandboxRecord.config;
+  const basePath = config.cwd ?? process.cwd();
+  const processes = /* @__PURE__ */ new Map();
+  let startPromise = null;
+  const sandbox = {
+    id: sandboxRecord.id,
+    config: sandboxRecord.config,
+    cwd: basePath,
+    exec: ({ command, args, cwd, env, signal, sudo }) => {
+      return errore.tryAsync({
+        try: () => {
+          const commandId = `command_${ulid()}`;
+          const finalCmd = sudo ? "sudo" : command;
+          const finalArgs = sudo ? [command, ...args ?? []] : args ?? [];
+          const child = spawn(finalCmd, finalArgs, {
+            cwd: cwd ? path.resolve(basePath, cwd) : basePath,
+            env: env ? { ...process.env, ...env } : void 0,
+            signal
+          });
+          processes.set(commandId, child);
+          let stdout = "";
+          let stderr = "";
+          const logQueue = [];
+          let logResolve = null;
+          let closed = false;
+          child.stdout.on("data", (data) => {
+            const str = String(data);
+            stdout += str;
+            logQueue.push({ stream: "stdout", data: str });
+            logResolve?.();
+          });
+          child.stderr.on("data", (data) => {
+            const str = String(data);
+            stderr += str;
+            logQueue.push({ stream: "stderr", data: str });
+            logResolve?.();
+          });
+          const result = new Promise((resolve2, reject) => {
+            child.on("error", (err) => {
+              processes.delete(commandId);
+              closed = true;
+              logResolve?.();
+              reject(err);
+            });
+            child.on("close", (code) => {
+              processes.delete(commandId);
+              closed = true;
+              logResolve?.();
+              resolve2({ stdout, stderr, exitCode: code ?? 0 });
+            });
+          });
+          async function* logs() {
+            while (!closed || logQueue.length > 0) {
+              const entry = logQueue.shift();
+              if (entry) {
+                yield entry;
+              } else if (!closed) {
+                await new Promise((resolve2) => {
+                  logResolve = resolve2;
+                });
+                logResolve = null;
+              }
+            }
+          }
+          return Promise.resolve({ commandId, logs, result });
+        },
+        catch: (e) => new SandboxError({ reason: String(e), cause: e })
+      });
+    },
+    getDomain: (port) => {
+      return Promise.resolve(`http://localhost:${port}`);
+    },
+    kill: async ({ commandId, storage: storage2 }) => {
+      const child = processes.get(commandId);
+      if (!child) {
+        return new SandboxError({
+          reason: `Command ${commandId} not found or already finished`
+        });
+      }
+      child.kill("SIGTERM");
+      const cmd = await storage2.command.get(commandId);
+      if (cmd instanceof Error) {
+        return new SandboxError({ reason: cmd.message, cause: cmd });
+      }
+      if (cmd && cmd.status === "running") {
+        const result = await storage2.command.set({
+          ...cmd,
+          status: "killed"
+        });
+        if (result instanceof Error) {
+          return new SandboxError({ reason: result.message, cause: result });
+        }
+      }
+    },
+    readFile: async ({ path: filePath }) => {
+      const fullPath = path.join(basePath, filePath);
+      try {
+        return await fs.readFile(fullPath);
+      } catch (e) {
+        if (e instanceof Error && "code" in e && e.code === "ENOENT") {
+          return null;
+        }
+        return new SandboxError({ reason: String(e), cause: e });
+      }
+    },
+    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),
+    updateNetworkPolicy: () => Promise.resolve(
+      new SandboxError({
+        reason: "updateNetworkPolicy is only available for Vercel sandboxes"
+      })
+    ),
+    lifecycle: {
+      start: () => {
+        if (startPromise) {
+          return startPromise;
+        }
+        startPromise = (async () => {
+          if (!setup && sandboxRecord.setupKey) {
+            await pollForSetupCompletion({
+              storage,
+              sandboxId: sandboxRecord.id,
+              setupKey: sandboxRecord.setupKey
+            });
+          }
+          if (setup) {
+            const existing = await storage.setup.get(setup.key);
+            if (existing instanceof Error || !existing) {
+              try {
+                await setup.run(sandbox);
+                await storage.setup.set({
+                  key: setup.key,
+                  snapshotId: null,
+                  createdAt: Date.now(),
+                  lastUsedAt: null,
+                  acquiringLockId: null,
+                  acquiringLockAt: null
+                });
+                await markSetupComplete({
+                  storage,
+                  sandboxId: sandboxRecord.id,
+                  setupKey: setup.key
+                });
+              } catch (e) {
+                await resetSetupState({
+                  storage,
+                  sandboxId: sandboxRecord.id,
+                  setupKey: setup.key
+                });
+                throw e;
+              }
+            }
+          }
+          if (onRestart) {
+            await onRestart(sandbox);
+          }
+          return void 0;
+        })().catch((e) => {
+          startPromise = null;
+          throw e;
+        });
+        return startPromise;
+      },
+      snapshot: () => Promise.resolve(
+        new SandboxError({
+          reason: "snapshot is not supported for local sandboxes"
+        })
+      ),
+      stop: () => Promise.resolve(
+        new SandboxError({
+          reason: "stop is not supported for local sandboxes"
+        })
+      ),
+      getStatus: () => Promise.resolve(
+        new SandboxError({
+          reason: "getStatus is not supported for local sandboxes"
+        })
+      ),
+      getCreatedAt: () => Promise.resolve(
+        new SandboxError({
+          reason: "getCreatedAt is not supported for local sandboxes"
+        })
+      ),
+      getRemainingTimeout: () => Promise.resolve(
+        new SandboxError({
+          reason: "getRemainingTimeout is not supported for local sandboxes"
+        })
+      )
+    },
+    tag: {
+      list: async () => {
+        const sandboxRecord2 = await storage.sandbox.get(sandbox.id);
+        if (sandboxRecord2 instanceof Error) {
+          return sandboxRecord2;
+        }
+        return sandboxRecord2.tags ?? {};
+      },
+      get: async (key) => {
+        const sandboxRecord2 = await storage.sandbox.get(sandbox.id);
+        if (sandboxRecord2 instanceof Error) {
+          return sandboxRecord2;
+        }
+        return sandboxRecord2.tags?.[key];
+      },
+      set: async (key, value) => {
+        const result = await storage.sandbox.tag.set({
+          sandboxId: sandbox.id,
+          tags: { [key]: value }
+        });
+        if (result instanceof Error) {
+          return result;
+        }
+        return void 0;
+      },
+      setMany: async (tags) => {
+        const result = await storage.sandbox.tag.set({
+          sandboxId: sandbox.id,
+          tags
+        });
+        if (result instanceof Error) {
+          return result;
+        }
+        return void 0;
+      }
+    }
+  };
+  return sandbox;
+};
+
+// src/sandbox/bindings/vercel.ts
+import * as path2 from "path";
+import { Sandbox as VercelSandboxSDK } from "@vercel/sandbox";
+import * as errore2 from "errore";
+import { start } from "workflow/api";
+var setupLog = createLogger({ subsystem: "sandbox:setup" });
+var VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1e3;
+var LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
+var LOCK_POLL_INTERVAL_MS = 200;
+var getTestCredentials = () => process.env.NODE_ENV === "test" ? {
+  token: process.env.TEST_VERCEL_TOKEN,
+  teamId: process.env.TEST_VERCEL_TEAM_ID,
+  projectId: process.env.TEST_VERCEL_PROJECT_ID
+} : {};
+var createPromises = /* @__PURE__ */ new Map();
+var ACTIVITY_THROTTLE_MS = 1e4;
+var lastActivitySent = /* @__PURE__ */ new Map();
+var DEFAULT_VCPUS = 2;
+function isSandboxGoneError(e) {
+  if (!(e instanceof Error)) {
+    return false;
+  }
+  const errorWithResponse = e;
+  const errorWithCause = e;
+  const status = errorWithResponse.response?.status ?? errorWithCause.cause?.response?.status;
+  if (status === 410 || status === 422) {
+    return true;
+  }
+  const message = e.message || String(e);
+  if (message.includes("Expected a stream of command data") || message.includes("Expected a stream of logs")) {
+    return true;
+  }
+  return false;
+}
+var vercelSandbox = ({
+  sandboxRecord,
+  storageConfig,
+  enableLifecycleWorkflow,
+  storage,
+  rpc,
+  setup,
+  onRestart
+}) => {
+  const { id, config } = sandboxRecord;
+  const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;
+  const ports = config.ports;
+  const networkPolicy = config.networkPolicy;
+  const initialVercel = sandboxRecord.providerMetadata?.provider === "vercel" ? sandboxRecord.providerMetadata : null;
+  let recoveredFromStale = false;
+  const HOME_DIR = "/home/vercel-sandbox";
+  const cwd = config.cwd ?? HOME_DIR;
+  const pollStorage = getStorage({
+    config: storageConfig,
+    rpc: (p) => rpc({ ...p, _quiet: true })
+  });
+  async function pollForSandboxId() {
+    const done = setupLog.time(
+      "waiting for sandbox lock",
+      { sandboxId: id },
+      { logOnStart: true }
+    );
+    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));
+      const record = await pollStorage.sandbox.get(id);
+      if (record instanceof Error) {
+        return new SandboxError({ reason: record.message, cause: record });
+      }
+      const vercelSandboxId = record?.providerMetadata?.provider === "vercel" ? record.providerMetadata.sandboxId : null;
+      if (vercelSandboxId) {
+        done();
+        return {
+          sandboxId: vercelSandboxId,
+          needsSetupRun: false,
+          createdFromSnapshot: false
+        };
+      }
+      const lockStale = record?.acquiringLockAt && Date.now() - record.acquiringLockAt >= LOCK_TIMEOUT_MS;
+      if (!record?.acquiringLockAt || lockStale) {
+        if (lockStale) {
+          setupLog.warn("sandbox lock is stale, taking over", {
+            sandboxId: id,
+            lockAge: Date.now() - record.acquiringLockAt
+          });
+        }
+        done({ staleLock: !!lockStale });
+        return doGetOrCreateSandboxId();
+      }
+    }
+    return new SandboxError({
+      reason: "Timed out waiting for sandbox creation by another process"
+    });
+  }
+  async function startLifecycleWorkflow(vercelSandboxId) {
+    if (!enableLifecycleWorkflow) {
+      return;
+    }
+    const lifecycleInput = {
+      id,
+      vercelSandboxId,
+      storageConfig,
+      rpc
+    };
+    await start(sandboxLifecycleWorkflow, [{ input: lifecycleInput }]).catch(
+      // biome-ignore lint/suspicious/noEmptyBlockStatements: intentionally ignored - workflow start is fire-and-forget
+      () => {
+      }
+    );
+  }
+  async function createSandboxFromSnapshot(snapshotId) {
+    return await errore2.tryAsync({
+      try: async () => {
+        const sandbox2 = await VercelSandboxSDK.create({
+          source: { type: "snapshot", snapshotId },
+          resources: { vcpus },
+          timeout: VERCEL_MAX_TIMEOUT_MS,
+          ports,
+          networkPolicy,
+          ...getTestCredentials()
+        });
+        const now = Date.now();
+        await storage.sandbox.set({
+          id,
+          config,
+          tags: sandboxRecord.tags,
+          createdAt: now,
+          lastActivityAt: now,
+          acquiringLockId: null,
+          acquiringLockAt: null,
+          setupKey: sandboxRecord.setupKey,
+          providerMetadata: {
+            provider: "vercel",
+            sandboxId: sandbox2.sandboxId,
+            snapshotId
+          }
+        });
+        await startLifecycleWorkflow(sandbox2.sandboxId);
+        return sandbox2.sandboxId;
+      },
+      catch: (e) => new SandboxError({ reason: String(e), cause: e })
+    });
+  }
+  async function createFreshSandbox() {
+    return await errore2.tryAsync({
+      try: async () => {
+        const sandbox2 = await VercelSandboxSDK.create({
+          resources: { vcpus },
+          timeout: VERCEL_MAX_TIMEOUT_MS,
+          ports,
+          networkPolicy,
+          ...getTestCredentials()
+        });
+        const now = Date.now();
+        await storage.sandbox.set({
+          id,
+          config,
+          tags: sandboxRecord.tags,
+          createdAt: now,
+          lastActivityAt: now,
+          acquiringLockId: null,
+          acquiringLockAt: null,
+          setupKey: sandboxRecord.setupKey,
+          providerMetadata: {
+            provider: "vercel",
+            sandboxId: sandbox2.sandboxId,
+            snapshotId: null
+          }
+        });
+        await startLifecycleWorkflow(sandbox2.sandboxId);
+        return sandbox2.sandboxId;
+      },
+      catch: (e) => new SandboxError({ reason: String(e), cause: e })
+    });
+  }
+  function execOnInstance(instance, {
+    command,
+    args,
+    cwd: execCwd,
+    env,
+    signal,
+    sudo
+  }) {
+    return errore2.tryAsync({
+      try: async () => {
+        const finalCmd = sudo ? "sudo" : command;
+        const finalArgs = sudo ? [command, ...args ?? []] : args;
+        const output = await instance.runCommand({
+          cwd: execCwd ?? cwd,
+          args: finalArgs,
+          env,
+          cmd: finalCmd,
+          signal,
+          detached: true
+        });
+        let stdout = "";
+        let stderr = "";
+        const logBuffer = [];
+        const state = {
+          resolve: null,
+          consumed: false
+        };
+        const consumeLogs = (async () => {
+          try {
+            for await (const log2 of output.logs()) {
+              const entry = log2.stream === "stdout" ? { stream: "stdout", data: log2.data } : { stream: "stderr", data: log2.data };
+              if (log2.stream === "stdout") {
+                stdout += log2.data;
+              } else {
+                stderr += log2.data;
+              }
+              logBuffer.push(entry);
+              state.resolve?.();
+            }
+          } catch {
+          }
+          state.consumed = true;
+          state.resolve?.();
+        })();
+        async function* logs() {
+          let index = 0;
+          while (!state.consumed || index < logBuffer.length) {
+            if (index < logBuffer.length) {
+              yield logBuffer[index++];
+            } else {
+              await new Promise((resolve2) => {
+                state.resolve = resolve2;
+              });
+              state.resolve = null;
+            }
+          }
+        }
+        const result = consumeLogs.then(async () => {
+          try {
+            const finished = await output.wait();
+            return {
+              stdout,
+              stderr,
+              exitCode: finished.exitCode
+            };
+          } catch (e) {
+            if (isSandboxGoneError(e)) {
+              return { stdout, stderr, exitCode: 1 };
+            }
+            throw e;
+          }
+        });
+        return { commandId: output.cmdId, logs, result };
+      },
+      catch: (e) => new SandboxError({ reason: String(e), cause: e })
+    });
+  }
+  function readFileOnInstance(instance, { path: path3 }) {
+    return errore2.tryAsync({
+      try: () => instance.readFileToBuffer({ path: path3, cwd }),
+      catch: (e) => new SandboxError({ reason: String(e), cause: e })
+    });
+  }
+  async function writeFilesOnInstance(instance, opts) {
+    const { files, destPath } = opts;
+    if (files.length === 0) {
+      return;
+    }
+    const nativeFiles = files.map((file) => {
+      const filePath = path2.posix.join(destPath, file.path);
+      const absolutePath = path2.posix.isAbsolute(filePath) ? filePath : path2.posix.join(cwd, filePath);
+      return {
+        path: absolutePath,
+        content: typeof file.content === "string" ? Buffer.from(file.content) : file.content
+      };
+    });
+    await instance.writeFiles(nativeFiles);
+    const shellScripts = nativeFiles.filter((f) => f.path.endsWith(".sh"));
+    if (shellScripts.length > 0) {
+      const chmodResult = await execOnInstance(instance, {
+        command: "chmod",
+        args: ["+x", ...shellScripts.map((f) => f.path)]
+      });
+      if (chmodResult instanceof Error) {
+        throw chmodResult;
+      }
+      await chmodResult.result;
+    }
+  }
+  function createTempSandbox(instance) {
+    const notAvailable = () => Promise.resolve(
+      new SandboxError({ reason: "not available during setup" })
+    );
+    const tempSandbox = {
+      id: `__setup_temp_${Date.now()}`,
+      config,
+      cwd,
+      exec: (opts) => execOnInstance(instance, opts),
+      readFile: (opts) => readFileOnInstance(instance, opts),
+      getDomain: () => notAvailable(),
+      kill: () => notAvailable(),
+      writeFiles: (opts) => writeFilesOnInstance(instance, opts),
+      updateNetworkPolicy: (policy) => errore2.tryAsync({
+        try: () => instance.updateNetworkPolicy(policy),
+        catch: (e) => new SandboxError({ reason: String(e), cause: e })
+      }),
+      lifecycle: {
+        start: () => notAvailable(),
+        snapshot: () => notAvailable(),
+        stop: () => notAvailable(),
+        getStatus: () => notAvailable(),
+        getCreatedAt: () => notAvailable(),
+        getRemainingTimeout: () => notAvailable()
+      },
+      tag: {
+        list: async () => ({}),
+        get: async () => void 0,
+        set: async () => void 0,
+        setMany: async () => void 0
+      }
+    };
+    return tempSandbox;
+  }
+  async function pollForSetupSnapshot(key) {
+    const done = setupLog.time(
+      "waiting for setup snapshot",
+      { setupKey: key },
+      { logOnStart: true }
+    );
+    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));
+      const record = await pollStorage.setup.get(key);
+      if (record instanceof Error) {
+        return null;
+      }
+      if (record?.snapshotId) {
+        done();
+        return record.snapshotId;
+      }
+      const lockStale = record?.acquiringLockAt && Date.now() - record.acquiringLockAt >= LOCK_TIMEOUT_MS;
+      if (!record?.acquiringLockId || lockStale) {
+        if (lockStale) {
+          setupLog.warn("setup lock is stale, giving up poll", {
+            setupKey: key,
+            lockAge: Date.now() - record.acquiringLockAt
+          });
+        }
+        done({ staleLock: !!lockStale, found: false });
+        return null;
+      }
+    }
+    done({ timedOut: true });
+    return null;
+  }
+  async function createSetupSnapshot(opts) {
+    if (!setup) {
+      return;
+    }
+    const setupKey = setup.key;
+    if (!opts?.force) {
+      const existing = await storage.setup.get(setupKey);
+      if (!(existing instanceof Error) && existing?.snapshotId) {
+        return;
+      }
+    }
+    const lockId = crypto.randomUUID();
+    const locked = await storage.setup.acquireLock(
+      setupKey,
+      lockId,
+      LOCK_TIMEOUT_MS
+    );
+    if (locked instanceof Error || !locked) {
+      return;
+    }
+    if (!opts?.force && locked.snapshotId) {
+      return;
+    }
+    let tempInstance = null;
+    try {
+      tempInstance = await VercelSandboxSDK.create({
+        resources: { vcpus },
+        timeout: VERCEL_MAX_TIMEOUT_MS,
+        ports,
+        networkPolicy,
+        ...getTestCredentials()
+      });
+      const tempSandbox = createTempSandbox(
+        tempInstance
+      );
+      await setup.run(tempSandbox);
+      const snapshot = await tempInstance.snapshot();
+      await storage.setup.set({
+        key: setupKey,
+        snapshotId: snapshot.snapshotId,
+        createdAt: locked.createdAt,
+        lastUsedAt: null,
+        acquiringLockId: null,
+        acquiringLockAt: null
+      });
+      await tempInstance.stop().catch(() => void 0);
+    } catch (e) {
+      setupLog.error("failed to create setup snapshot", { setupKey, cause: e });
+      if (tempInstance) {
+        await tempInstance.stop().catch(() => void 0);
+      }
+      await storage.setup.set({
+        key: setupKey,
+        snapshotId: null,
+        createdAt: locked.createdAt,
+        lastUsedAt: null,
+        acquiringLockId: null,
+        acquiringLockAt: null
+      }).catch(() => void 0);
+    }
+  }
+  async function doGetOrCreateSandboxId() {
+    const done = setupLog.time("doGetOrCreateSandboxId", { sandboxId: id });
+    if (initialVercel?.sandboxId && !recoveredFromStale) {
+      done({ path: "cache-hit" });
+      return {
+        sandboxId: initialVercel.sandboxId,
+        needsSetupRun: false,
+        createdFromSnapshot: false
+      };
+    }
+    const existing = await storage.sandbox.get(id);
+    if (existing instanceof Error) {
+      if (existing instanceof SandboxNotFoundError) {
+      } else {
+        return new SandboxError({ reason: existing.message, cause: existing });
+      }
+    }
+    const existingRecord = existing instanceof SandboxNotFoundError ? null : existing;
+    const existingVercel = existingRecord?.providerMetadata?.provider === "vercel" ? existingRecord.providerMetadata : null;
+    if (existingVercel?.sandboxId) {
+      return {
+        sandboxId: existingVercel.sandboxId,
+        needsSetupRun: false,
+        createdFromSnapshot: false
+      };
+    }
+    const hasActiveLock = existingRecord?.acquiringLockId && existingRecord.acquiringLockAt && Date.now() - existingRecord.acquiringLockAt < LOCK_TIMEOUT_MS;
+    if (hasActiveLock) {
+      return pollForSandboxId();
+    }
+    const lockId = crypto.randomUUID();
+    const now = Date.now();
+    const locked = await storage.sandbox.acquireLock(
+      {
+        id,
+        config,
+        tags: existingRecord?.tags ?? sandboxRecord.tags,
+        createdAt: existingRecord?.createdAt ?? sandboxRecord.createdAt,
+        lastActivityAt: existingRecord?.lastActivityAt ?? sandboxRecord.lastActivityAt,
+        acquiringLockId: lockId,
+        acquiringLockAt: now,
+        setupKey: sandboxRecord.setupKey,
+        providerMetadata: {
+          provider: "vercel",
+          sandboxId: null,
+          snapshotId: existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? null
+        }
+      },
+      LOCK_TIMEOUT_MS
+    );
+    if (locked instanceof Error) {
+      return new SandboxError({ reason: locked.message, cause: locked });
+    }
+    if (!locked) {
+      return pollForSandboxId();
+    }
+    const lockedRecord = locked;
+    async function releaseSandboxLock() {
+      await storage.sandbox.update({
+        id: lockedRecord.id,
+        acquiringLockId: null,
+        acquiringLockAt: null
+      }).catch(() => void 0);
+    }
+    const lockedVercel = lockedRecord.providerMetadata?.provider === "vercel" ? lockedRecord.providerMetadata : null;
+    if (lockedVercel?.sandboxId) {
+      await releaseSandboxLock();
+      return {
+        sandboxId: lockedVercel.sandboxId,
+        needsSetupRun: false,
+        createdFromSnapshot: false
+      };
+    }
+    const snapshotId = lockedVercel?.snapshotId ?? initialVercel?.snapshotId ?? config.lifecycle?.snapshotId;
+    if (snapshotId) {
+      const result = await createSandboxFromSnapshot(snapshotId);
+      if (!(result instanceof Error)) {
+        done({ path: "config-snapshot" });
+        return {
+          sandboxId: result,
+          needsSetupRun: false,
+          createdFromSnapshot: true
+        };
+      }
+    }
+    if (setup) {
+      let forceRecreateSnapshot = false;
+      const setupRecord = await storage.setup.get(setup.key);
+      if (!(setupRecord instanceof Error) && setupRecord) {
+        if (setupRecord.snapshotId) {
+          const result = await createSandboxFromSnapshot(
+            setupRecord.snapshotId
+          );
+          if (!(result instanceof Error)) {
+            storage.setup.set({
+              ...setupRecord,
+              lastUsedAt: Date.now()
+            }).catch(() => void 0);
+            done({ path: "setup-snapshot" });
+            return {
+              sandboxId: result,
+              needsSetupRun: false,
+              createdFromSnapshot: true
+            };
+          }
+          forceRecreateSnapshot = true;
+        } else if (setupRecord.acquiringLockId && setupRecord.acquiringLockAt && Date.now() - setupRecord.acquiringLockAt < LOCK_TIMEOUT_MS) {
+          const polledSnapshotId = await pollForSetupSnapshot(setup.key);
+          if (polledSnapshotId) {
+            const result = await createSandboxFromSnapshot(polledSnapshotId);
+            if (!(result instanceof Error)) {
+              done({ path: "polled-snapshot" });
+              return {
+                sandboxId: result,
+                needsSetupRun: false,
+                createdFromSnapshot: true
+              };
+            }
+          }
+        }
+      }
+      createSetupSnapshot({ force: forceRecreateSnapshot }).catch((e) => {
+        setupLog.error("failed to create background snapshot", { cause: e });
+      });
+      const freshResult2 = await createFreshSandbox();
+      if (freshResult2 instanceof Error) {
+        await releaseSandboxLock();
+        return freshResult2;
+      }
+      done({ path: "fresh-with-setup" });
+      return {
+        sandboxId: freshResult2,
+        needsSetupRun: true,
+        createdFromSnapshot: false
+      };
+    }
+    const freshResult = await createFreshSandbox();
+    if (freshResult instanceof Error) {
+      await releaseSandboxLock();
+      return freshResult;
+    }
+    done({ path: "fresh" });
+    return {
+      sandboxId: freshResult,
+      needsSetupRun: false,
+      createdFromSnapshot: false
+    };
+  }
+  function getOrCreateSandboxId() {
+    const cached = createPromises.get(id);
+    if (cached) {
+      return cached;
+    }
+    const promise = doGetOrCreateSandboxId().finally(() => {
+      createPromises.delete(id);
+    });
+    createPromises.set(id, promise);
+    return promise;
+  }
+  async function doGetSandbox() {
+    const createResult = await getOrCreateSandboxId();
+    if (createResult instanceof Error) {
+      return createResult;
+    }
+    const instance = await errore2.tryAsync({
+      try: () => VercelSandboxSDK.get({
+        sandboxId: createResult.sandboxId,
+        ...getTestCredentials()
+      }),
+      catch: (e) => new SandboxError({ reason: String(e), cause: e })
+    });
+    if (instance instanceof Error) {
+      return instance;
+    }
+    return {
+      instance,
+      needsSetupRun: createResult.needsSetupRun,
+      createdFromSnapshot: createResult.createdFromSnapshot
+    };
+  }
+  let getSandboxPromise = null;
+  function getSandboxResult() {
+    if (!getSandboxPromise) {
+      getSandboxPromise = doGetSandbox();
+    }
+    return getSandboxPromise;
+  }
+  async function getSandboxInstance() {
+    const result = await getSandboxResult();
+    if (result instanceof Error) {
+      return result;
+    }
+    return result.instance;
+  }
+  async function recoverFromStaleSandbox() {
+    getSandboxPromise = null;
+    recoveredFromStale = true;
+    const existing = await storage.sandbox.get(id);
+    if (existing instanceof Error || !existing) {
+      return;
+    }
+    const existingVercel = existing.providerMetadata?.provider === "vercel" ? existing.providerMetadata : null;
+    if (existingVercel?.sandboxId) {
+      await storage.sandbox.update({
+        id: existing.id,
+        acquiringLockId: null,
+        acquiringLockAt: null,
+        providerMetadata: {
+          provider: "vercel",
+          sandboxId: null,
+          snapshotId: existingVercel.snapshotId
+        }
+      });
+    }
+  }
+  async function updateLastActivity() {
+    const now = Date.now();
+    const lastSent = lastActivitySent.get(id);
+    if (lastSent && now - lastSent < ACTIVITY_THROTTLE_MS) {
+      return;
+    }
+    lastActivitySent.set(id, now);
+    const existing = await storage.sandbox.get(id);
+    if (existing instanceof Error || !existing) {
+      return;
+    }
+    const existingVercel = existing.providerMetadata?.provider === "vercel" ? existing.providerMetadata : null;
+    await storage.sandbox.update({
+      id: existing.id,
+      lastActivityAt: now,
+      acquiringLockId: null,
+      acquiringLockAt: null,
+      providerMetadata: existingVercel ?? {
+        provider: "vercel",
+        sandboxId: null,
+        snapshotId: null
+      }
+    });
+  }
+  let startPromise = null;
+  const lifecycle = {
+    start: () => {
+      if (startPromise) {
+        return startPromise;
+      }
+      startPromise = (async () => {
+        if (!setup && sandboxRecord.setupKey) {
+          await pollForSetupCompletion({
+            storage: pollStorage,
+            sandboxId: sandboxRecord.id,
+            setupKey: sandboxRecord.setupKey
+          });
+        }
+        const result = await getSandboxResult();
+        if (result instanceof Error) {
+          startPromise = null;
+          return result;
+        }
+        await updateLastActivity();
+        if (result.needsSetupRun && setup) {
+          try {
+            await setup.run(sandbox);
+            await markSetupComplete({
+              storage,
+              sandboxId: sandboxRecord.id,
+              setupKey: setup.key
+            });
+          } catch (e) {
+            await resetSetupState({
+              storage,
+              sandboxId: sandboxRecord.id,
+              setupKey: setup.key
+            });
+            throw e;
+          }
+        }
+        if (result.createdFromSnapshot && onRestart) {
+          await onRestart(sandbox);
+        }
+        return void 0;
+      })().catch((e) => {
+        startPromise = null;
+        throw e;
+      });
+      return startPromise;
+    },
+    snapshot: async () => {
+      const sandbox2 = await getSandboxInstance();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return errore2.tryAsync({
+        try: async () => {
+          const snapshot = await sandbox2.snapshot();
+          await storage.sandbox.update({
+            id,
+            acquiringLockId: null,
+            acquiringLockAt: null,
+            providerMetadata: {
+              provider: "vercel",
+              sandboxId: null,
+              snapshotId: snapshot.snapshotId
+            }
+          });
+          return { snapshotId: snapshot.snapshotId };
+        },
+        catch: (e) => new SandboxError({ reason: String(e), cause: e })
+      });
+    },
+    stop: async () => {
+      const sandbox2 = await getSandboxInstance();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return errore2.tryAsync({
+        try: async () => {
+          await sandbox2.stop();
+          await storage.sandbox.update({
+            id,
+            acquiringLockId: null,
+            acquiringLockAt: null,
+            providerMetadata: {
+              provider: "vercel",
+              sandboxId: null,
+              snapshotId: null
+            }
+          });
+          return void 0;
+        },
+        catch: (e) => new SandboxError({ reason: String(e), cause: e })
+      });
+    },
+    getStatus: async () => {
+      const sandbox2 = await getSandboxInstance();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return sandbox2.status;
+    },
+    getCreatedAt: async () => {
+      const sandbox2 = await getSandboxInstance();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return sandbox2.createdAt;
+    },
+    getRemainingTimeout: async () => {
+      const sandbox2 = await getSandboxInstance();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return sandbox2.timeout;
+    }
+  };
+  async function doExec(opts) {
+    const instance = await getSandboxInstance();
+    if (instance instanceof Error) {
+      return instance;
+    }
+    const updatePromise = updateLastActivity();
+    const execResult = await execOnInstance(instance, opts);
+    await updatePromise;
+    return execResult;
+  }
+  const sandbox = {
+    id,
+    config,
+    cwd,
+    exec: async (opts) => {
+      const result = await doExec(opts);
+      if (result instanceof SandboxError && isSandboxGoneError(result.cause)) {
+        await recoverFromStaleSandbox();
+        return await doExec(opts);
+      }
+      return result;
+    },
+    getDomain: async (port) => {
+      const sandbox2 = await getSandboxInstance();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      try {
+        return sandbox2.domain(port);
+      } catch (e) {
+        return new SandboxError({ reason: String(e), cause: e });
+      }
+    },
+    kill: async ({ commandId, storage: cmdStorage }) => {
+      const instance = await getSandboxInstance();
+      if (instance instanceof Error) {
+        return instance;
+      }
+      const cmd = await cmdStorage.command.get(commandId);
+      if (cmd instanceof Error) {
+        return new SandboxError({ reason: cmd.message, cause: cmd });
+      }
+      if (cmd && cmd.status === "running") {
+        const result = await cmdStorage.command.set({
+          ...cmd,
+          status: "killed"
+        });
+        if (result instanceof Error) {
+          return new SandboxError({ reason: result.message, cause: result });
+        }
+      }
+      return void 0;
+    },
+    readFile: async (opts) => {
+      const instance = await getSandboxInstance();
+      if (instance instanceof Error) {
+        return instance;
+      }
+      return readFileOnInstance(instance, opts);
+    },
+    writeFiles: async (opts) => {
+      const instance = await getSandboxInstance();
+      if (instance instanceof Error) {
+        throw instance;
+      }
+      return writeFilesOnInstance(instance, opts);
+    },
+    lifecycle,
+    updateNetworkPolicy: async (policy) => {
+      const instance = await getSandboxInstance();
+      if (instance instanceof Error) {
+        return instance;
+      }
+      return errore2.tryAsync({
+        try: () => instance.updateNetworkPolicy(policy),
+        catch: (e) => new SandboxError({ reason: String(e), cause: e })
+      });
+    },
+    tag: {
+      list: async () => {
+        const sandboxRecord2 = await storage.sandbox.get(id);
+        if (sandboxRecord2 instanceof Error) {
+          return sandboxRecord2;
+        }
+        return sandboxRecord2.tags ?? {};
+      },
+      get: async (key) => {
+        const sandboxRecord2 = await storage.sandbox.get(id);
+        if (sandboxRecord2 instanceof Error) {
+          return sandboxRecord2;
+        }
+        return sandboxRecord2.tags?.[key];
+      },
+      set: async (key, value) => {
+        const result = await storage.sandbox.tag.set({
+          sandboxId: id,
+          tags: { [key]: value }
+        });
+        if (result instanceof Error) {
+          return result;
+        }
+        return void 0;
+      },
+      setMany: async (tags) => {
+        const result = await storage.sandbox.tag.set({
+          sandboxId: id,
+          tags
+        });
+        if (result instanceof Error) {
+          return result;
+        }
+        return void 0;
+      }
+    }
+  };
+  return sandbox;
+};
+
+// src/sandbox/client.ts
+var log = createLogger({ subsystem: "sandbox" });
+var sandboxCache = /* @__PURE__ */ new Map();
+function getSandbox({
+  sandboxRecord,
+  storageConfig,
+  storage,
+  rpc,
+  enableLifecycleWorkflow = true,
+  setup,
+  onRestart
+}) {
+  const cached = sandboxCache.get(sandboxRecord.id);
+  if (cached) {
+    return cached;
+  }
+  const sbx = createSandbox({
+    sandboxRecord,
+    storageConfig,
+    storage,
+    rpc,
+    enableLifecycleWorkflow,
+    setup,
+    onRestart
+  });
+  cacheSandbox(sandboxRecord.id, sbx);
+  return sbx;
+}
+function evictSandbox(id) {
+  sandboxCache.delete(id);
+}
+function cacheSandbox(id, sandbox) {
+  sandboxCache.set(id, sandbox);
+}
+function createSandbox({
+  sandboxRecord,
+  storageConfig,
+  storage,
+  rpc,
+  enableLifecycleWorkflow = true,
+  setup,
+  onRestart
+}) {
+  let sbx;
+  const scopedSetup = setup ? {
+    ...setup,
+    key: `${sandboxRecord.config.type}:${setup.key}`
+  } : void 0;
+  const recordWithSetupKey = scopedSetup ? { ...sandboxRecord, setupKey: scopedSetup.key } : sandboxRecord;
+  switch (sandboxRecord.config.type) {
+    case "local":
+      sbx = localSandbox({
+        sandboxRecord: recordWithSetupKey,
+        storage,
+        setup: scopedSetup,
+        onRestart
+      });
+      break;
+    case "docker":
+      sbx = dockerSandbox({
+        sandboxRecord: recordWithSetupKey,
+        storage,
+        setup: scopedSetup,
+        onRestart
+      });
+      break;
+    case "vercel":
+      sbx = vercelSandbox({
+        sandboxRecord: recordWithSetupKey,
+        storageConfig,
+        storage,
+        rpc,
+        enableLifecycleWorkflow,
+        setup: scopedSetup,
+        onRestart
+      });
+      break;
+    case "custom":
+      throw new Error("Custom sandboxes are not supported");
+    default:
+      sandboxRecord.config;
+      throw new Error(
+        `Unknown sandbox type: ${// biome-ignore lint/suspicious/noExplicitAny: .
+        sandboxRecord.config.type}`
+      );
+  }
+  let readyPromise = null;
+  let publicOnReady;
+  function ensureReady() {
+    if (readyPromise) {
+      return readyPromise;
+    }
+    readyPromise = (async () => {
+      const done = log.time("ensureReady / lifecycle.start", {
+        sandboxId: sandboxRecord.id
+      });
+      const result = await sbx.lifecycle.start();
+      done();
+      if (result instanceof Error) {
+        throw result;
+      }
+    })().catch((e) => {
+      readyPromise = null;
+      publicOnReady = void 0;
+      throw e;
+    });
+    publicOnReady = readyPromise;
+    return readyPromise;
+  }
+  const autoStart = sandboxRecord.config.type === "vercel" ? sandboxRecord.config.lifecycle?.autoStart !== false : true;
+  if (autoStart) {
+    ensureReady();
+  }
+  return {
+    ...sbx,
+    get _onReady() {
+      return publicOnReady;
+    },
+    exec: async (opts) => {
+      await ensureReady();
+      return sbx.exec(opts);
+    },
+    getDomain: async (port) => {
+      await ensureReady();
+      return sbx.getDomain(port);
+    },
+    readFile: async (opts) => {
+      await ensureReady();
+      return sbx.readFile(opts);
+    },
+    writeFiles: async (opts) => {
+      await ensureReady();
+      return sbx.writeFiles(opts);
+    }
+  };
+}
+
+export {
+  getSandbox,
+  evictSandbox,
+  cacheSandbox,
+  createSandbox
+};
+//# 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 ? [command, ...(args ?? [])] : (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"]
}
