experimental-agent 0.0.3 → 0.0.5

package/dist/chunk-ZWP7RQZT.mjs

@@ -0,0 +1,1239 @@
+import {
+  sandboxLifecycleWorkflow
+} from "./chunk-CQB6AOJ7.mjs";
+import {
+  SandboxError,
+  SandboxNotFoundError
+} from "./chunk-HJGPUEFC.mjs";
+
+// src/utils/debug.ts
+var enabled = process.env.AGENT_DEBUG === "1" || process.env.AGENT_DEBUG === "true";
+function debug(...args) {
+  if (enabled) {
+    console.log(...args);
+  }
+}
+
+// src/sandbox/bindings/local.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path2 from "node:path";
+import * as errore from "errore";
+import { ulid } from "ulid";
+
+// src/sandbox/write-files.ts
+import * as path from "node:path";
+var MAX_RETRIES = 2;
+var RETRY_BASE_MS = 500;
+async function execChecked(sandbox, opts, errorLabel) {
+  for (let attempt = 0; ; attempt++) {
+    const execResult = await sandbox.exec(opts);
+    if (execResult instanceof Error) {
+      throw execResult;
+    }
+    const result = await execResult.result;
+    if (result.exitCode === 0) {
+      return result;
+    }
+    const isTransient = result.exitCode === 255 && !result.stderr.trim();
+    if (isTransient && attempt < MAX_RETRIES) {
+      await new Promise((r) => setTimeout(r, RETRY_BASE_MS * (attempt + 1)));
+      continue;
+    }
+    throw new Error(
+      `${errorLabel} with exit code ${result.exitCode}: ${result.stderr}`
+    );
+  }
+}
+async function writeFiles(opts) {
+  const { sandbox, files, destPath } = opts;
+  if (files.length === 0) {
+    return;
+  }
+  const filePaths = files.map((file) => path.posix.join(destPath, file.path));
+  const parentDirs = Array.from(
+    new Set(filePaths.map((p) => path.posix.dirname(p)))
+  );
+  const shellScripts = filePaths.filter((p) => p.endsWith(".sh"));
+  const mkdirResult = await sandbox.exec({
+    command: "mkdir",
+    args: ["-p", ...parentDirs]
+  });
+  if (mkdirResult instanceof Error) {
+    throw mkdirResult;
+  }
+  await mkdirResult.result;
+  const CHUNK_SIZE = 5e4;
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const fullPath = filePaths[i];
+    const base64Content = toBase64(file.content);
+    if (base64Content.length < CHUNK_SIZE) {
+      const marker = `EOF_${i}`;
+      await execChecked(
+        sandbox,
+        {
+          command: "bash",
+          args: [
+            "-c",
+            `base64 -d > ${quote(fullPath)} << '${marker}'
+${base64Content}
+${marker}`
+          ]
+        },
+        "writeFiles failed"
+      );
+    } else {
+      const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;
+      const clearResult = await sandbox.exec({
+        command: "bash",
+        args: ["-c", `> ${quote(tempB64)}`]
+      });
+      if (clearResult instanceof Error) {
+        throw clearResult;
+      }
+      await clearResult.result;
+      for (let offset = 0; offset < base64Content.length; offset += CHUNK_SIZE) {
+        const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);
+        const marker = `CHUNK_${offset}`;
+        await execChecked(
+          sandbox,
+          {
+            command: "bash",
+            args: [
+              "-c",
+              `cat >> ${quote(tempB64)} << '${marker}'
+${chunk}
+${marker}`
+            ]
+          },
+          "writeFiles chunk failed"
+        );
+      }
+      await execChecked(
+        sandbox,
+        {
+          command: "bash",
+          args: [
+            "-c",
+            `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`
+          ]
+        },
+        "writeFiles decode failed"
+      );
+    }
+  }
+  if (shellScripts.length > 0) {
+    const chmodResult = await sandbox.exec({
+      command: "chmod",
+      args: ["+x", ...shellScripts]
+    });
+    if (chmodResult instanceof Error) {
+      throw chmodResult;
+    }
+    await chmodResult.result;
+  }
+}
+function toBase64(content) {
+  if (typeof content === "string") {
+    return Buffer.from(content).toString("base64");
+  }
+  return content.toString("base64");
+}
+function quote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// src/sandbox/bindings/local.ts
+var localSandbox = ({
+  sandboxRecord,
+  storage,
+  setup,
+  onRestart
+}) => {
+  const config = sandboxRecord.config;
+  const basePath = config.path ?? process.cwd();
+  const processes = /* @__PURE__ */ new Map();
+  const sandbox = {
+    id: sandboxRecord.id,
+    config: sandboxRecord.config,
+    exec: ({ command, args, signal }) => {
+      return errore.tryAsync({
+        try: () => {
+          const commandId = `command_${ulid()}`;
+          const child = spawn(command, args, {
+            cwd: basePath,
+            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 result2 = new Promise((resolve, reject) => {
+            child.on("error", (err) => {
+              processes.delete(commandId);
+              closed = true;
+              logResolve?.();
+              reject(err);
+            });
+            child.on("close", (code) => {
+              processes.delete(commandId);
+              closed = true;
+              logResolve?.();
+              resolve({ 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((resolve) => {
+                  logResolve = resolve;
+                });
+                logResolve = null;
+              }
+            }
+          }
+          return Promise.resolve({ commandId, logs, result: result2 });
+        },
+        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 result2 = await storage2.command.set({
+          ...cmd,
+          status: "killed"
+        });
+        if (result2 instanceof Error) {
+          return new SandboxError({ reason: result2.message, cause: result2 });
+        }
+      }
+    },
+    readFile: async ({ path: filePath }) => {
+      const fullPath = path2.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"
+      })
+    ),
+    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 result2 = await storage.sandbox.tag.set({
+          sandboxId: sandbox.id,
+          tags: { [key]: value }
+        });
+        if (result2 instanceof Error) {
+          return result2;
+        }
+        return void 0;
+      },
+      setMany: async (tags) => {
+        const result2 = await storage.sandbox.tag.set({
+          sandboxId: sandbox.id,
+          tags
+        });
+        if (result2 instanceof Error) {
+          return result2;
+        }
+        return void 0;
+      }
+    }
+  };
+  const result = sandbox;
+  if (setup || onRestart) {
+    result._onReady = (async () => {
+      let needsSetup = !!setup;
+      if (setup) {
+        const existing = await storage.setup.get(setup.key);
+        if (!(existing instanceof Error) && existing) {
+          debug(
+            `[sandbox:setup] setup already complete for key "${setup.key}", skipping`
+          );
+          needsSetup = false;
+        }
+      }
+      if (needsSetup && setup) {
+        debug(`[sandbox:setup] running setup.run (local, key="${setup.key}")`);
+        await setup.run(sandbox);
+        await storage.setup.set({
+          key: setup.key,
+          snapshotId: null,
+          createdAt: Date.now(),
+          lastUsedAt: null,
+          acquiringLockId: null,
+          acquiringLockAt: null
+        });
+        debug(
+          `[sandbox:setup] setup complete, stored record (key="${setup.key}")`
+        );
+      }
+      if (onRestart) {
+        debug("[sandbox:setup] running onRestart (local)");
+        await onRestart(sandbox);
+      }
+    })();
+  }
+  return result;
+};
+
+// src/sandbox/bindings/vercel.ts
+import * as path3 from "node:path";
+import * as errore2 from "errore";
+import { Sandbox as VercelSandboxSDK } from "@vercel/sandbox";
+import { start } from "workflow/api";
+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 sandboxPromise = null;
+  let recoveredFromStale = false;
+  let createdFromSnapshot = false;
+  let needsSetupRun = false;
+  const HOME_DIR = "/home/vercel-sandbox";
+  async function pollForSandboxId() {
+    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));
+      const record = await storage.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) {
+        return vercelSandboxId;
+      }
+      if (!record?.acquiringLockAt) {
+        const finalCheck = await storage.sandbox.get(id);
+        if (finalCheck instanceof Error) {
+          return new SandboxError({
+            reason: finalCheck.message,
+            cause: finalCheck
+          });
+        }
+        const finalVercelSandboxId = finalCheck?.providerMetadata?.provider === "vercel" ? finalCheck.providerMetadata.sandboxId : null;
+        if (finalVercelSandboxId) {
+          return finalVercelSandboxId;
+        }
+        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,
+          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,
+          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,
+    signal
+  }) {
+    return errore2.tryAsync({
+      try: async () => {
+        const output = await instance.runCommand({
+          cwd: HOME_DIR,
+          args,
+          cmd: command,
+          signal,
+          detached: true
+        });
+        let stdout = "";
+        let stderr = "";
+        const logBuffer = [];
+        const state = {
+          resolve: null,
+          consumed: false
+        };
+        const consumeLogs = (async () => {
+          try {
+            for await (const log of output.logs()) {
+              const entry = log.stream === "stdout" ? { stream: "stdout", data: log.data } : { stream: "stderr", data: log.data };
+              if (log.stream === "stdout") {
+                stdout += log.data;
+              } else {
+                stderr += log.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((resolve) => {
+                state.resolve = resolve;
+              });
+              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: path4 }) {
+    return errore2.tryAsync({
+      try: () => instance.readFileToBuffer({ path: path4, cwd: HOME_DIR }),
+      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 = path3.posix.join(destPath, file.path);
+      const absolutePath = path3.posix.isAbsolute(filePath) ? filePath : path3.posix.join(HOME_DIR, 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 tempSandbox = {
+      id: `__setup_temp_${Date.now()}`,
+      config,
+      exec: (opts) => execOnInstance(instance, opts),
+      readFile: (opts) => readFileOnInstance(instance, opts),
+      getDomain: () => Promise.resolve(
+        new SandboxError({ reason: "not available during setup" })
+      ),
+      kill: () => Promise.resolve(
+        new SandboxError({ reason: "not available during setup" })
+      ),
+      writeFiles: (opts) => writeFilesOnInstance(instance, opts),
+      updateNetworkPolicy: (policy) => errore2.tryAsync({
+        try: () => instance.updateNetworkPolicy(policy),
+        catch: (e) => new SandboxError({ reason: String(e), cause: e })
+      }),
+      tag: {
+        list: async () => ({}),
+        get: async () => void 0,
+        set: async () => void 0,
+        setMany: async () => void 0
+      }
+    };
+    return tempSandbox;
+  }
+  async function pollForSetupSnapshot(key) {
+    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));
+      const record = await storage.setup.get(key);
+      if (record instanceof Error) {
+        return null;
+      }
+      if (record?.snapshotId) {
+        return record.snapshotId;
+      }
+      if (!record?.acquiringLockId) {
+        return null;
+      }
+    }
+    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;
+      }
+    }
+    debug(`[sandbox:setup] acquiring lock for setup key "${setupKey}"`);
+    const lockId = crypto.randomUUID();
+    const locked = await storage.setup.acquireLock(
+      setupKey,
+      lockId,
+      LOCK_TIMEOUT_MS
+    );
+    if (locked instanceof Error || !locked) {
+      debug(
+        `[sandbox:setup] lock not acquired for key "${setupKey}" (another process holds it)`
+      );
+      return;
+    }
+    if (!opts?.force && locked.snapshotId) {
+      debug(
+        `[sandbox:setup] snapshot already exists after lock for key "${setupKey}", skipping`
+      );
+      return;
+    }
+    let tempInstance = null;
+    try {
+      debug(
+        `[sandbox:setup] creating temp sandbox for snapshot (key="${setupKey}")`
+      );
+      tempInstance = await VercelSandboxSDK.create({
+        resources: { vcpus },
+        timeout: VERCEL_MAX_TIMEOUT_MS,
+        ports,
+        networkPolicy,
+        ...getTestCredentials()
+      });
+      const tempSandbox = createTempSandbox(
+        tempInstance
+      );
+      await setup.run(tempSandbox);
+      debug(
+        `[sandbox:setup] setup.run complete, snapshotting (key="${setupKey}")`
+      );
+      const snapshot = await tempInstance.snapshot();
+      await storage.setup.set({
+        key: setupKey,
+        snapshotId: snapshot.snapshotId,
+        createdAt: locked.createdAt,
+        lastUsedAt: null,
+        acquiringLockId: null,
+        acquiringLockAt: null
+      });
+      debug(
+        `[sandbox:setup] snapshot stored: ${snapshot.snapshotId} (key="${setupKey}")`
+      );
+      await tempInstance.stop().catch(() => void 0);
+    } catch (e) {
+      console.error(
+        `[sandbox:setup] failed to create setup snapshot (key="${setupKey}"):`,
+        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() {
+    if (initialVercel?.sandboxId && !recoveredFromStale) {
+      return initialVercel.sandboxId;
+    }
+    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 existingVercel.sandboxId;
+    }
+    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,
+        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.set({
+        ...lockedRecord,
+        acquiringLockId: null,
+        acquiringLockAt: null
+      }).catch(() => void 0);
+    }
+    const lockedVercel = lockedRecord.providerMetadata?.provider === "vercel" ? lockedRecord.providerMetadata : null;
+    if (lockedVercel?.sandboxId) {
+      await releaseSandboxLock();
+      return lockedVercel.sandboxId;
+    }
+    const snapshotId = lockedVercel?.snapshotId ?? initialVercel?.snapshotId ?? config.lifecycle?.snapshotId;
+    if (snapshotId) {
+      const result = await createSandboxFromSnapshot(snapshotId);
+      if (!(result instanceof Error)) {
+        createdFromSnapshot = true;
+        return result;
+      }
+    }
+    if (setup) {
+      let forceRecreateSnapshot = false;
+      const setupRecord = await storage.setup.get(setup.key);
+      if (!(setupRecord instanceof Error) && setupRecord) {
+        if (setupRecord.snapshotId) {
+          debug(
+            `[sandbox:setup] found setup snapshot ${setupRecord.snapshotId} for key "${setup.key}"`
+          );
+          const result = await createSandboxFromSnapshot(
+            setupRecord.snapshotId
+          );
+          if (!(result instanceof Error)) {
+            createdFromSnapshot = true;
+            storage.setup.set({
+              ...setupRecord,
+              lastUsedAt: Date.now()
+            }).catch(() => void 0);
+            return result;
+          }
+          debug(
+            `[sandbox:setup] snapshot ${setupRecord.snapshotId} failed (expired?), will recreate`
+          );
+          forceRecreateSnapshot = true;
+        } else if (setupRecord.acquiringLockId && setupRecord.acquiringLockAt && Date.now() - setupRecord.acquiringLockAt < LOCK_TIMEOUT_MS) {
+          debug(
+            `[sandbox:setup] snapshot in progress for key "${setup.key}", waiting...`
+          );
+          const snapshotId2 = await pollForSetupSnapshot(setup.key);
+          if (snapshotId2) {
+            debug(
+              `[sandbox:setup] snapshot ready: ${snapshotId2} for key "${setup.key}"`
+            );
+            const result = await createSandboxFromSnapshot(snapshotId2);
+            if (!(result instanceof Error)) {
+              createdFromSnapshot = true;
+              return result;
+            }
+          }
+        }
+      }
+      debug(
+        `[sandbox:setup] no snapshot for key "${setup.key}", will run setup on this sandbox`
+      );
+      needsSetupRun = true;
+      createSetupSnapshot({ force: forceRecreateSnapshot }).catch((e) => {
+        console.error(
+          "[sandbox:setup] failed to create background snapshot:",
+          e
+        );
+      });
+    }
+    const freshResult = await createFreshSandbox();
+    if (freshResult instanceof Error) {
+      await releaseSandboxLock();
+    }
+    return freshResult;
+  }
+  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 vercelSandboxId = await getOrCreateSandboxId();
+    if (vercelSandboxId instanceof Error) {
+      return vercelSandboxId;
+    }
+    return errore2.tryAsync({
+      try: () => VercelSandboxSDK.get({
+        sandboxId: vercelSandboxId,
+        ...getTestCredentials()
+      }),
+      catch: (e) => new SandboxError({ reason: String(e), cause: e })
+    });
+  }
+  function getSandbox2() {
+    if (!sandboxPromise) {
+      sandboxPromise = doGetSandbox();
+    }
+    return sandboxPromise;
+  }
+  async function recoverFromStaleSandbox() {
+    sandboxPromise = 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.set({
+        id: existing.id,
+        config: existing.config,
+        tags: existing.tags,
+        createdAt: existing.createdAt,
+        lastActivityAt: existing.lastActivityAt,
+        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.set({
+      id: existing.id,
+      config: existing.config,
+      tags: existing.tags,
+      createdAt: existing.createdAt,
+      lastActivityAt: now,
+      acquiringLockId: null,
+      acquiringLockAt: null,
+      providerMetadata: existingVercel ?? {
+        provider: "vercel",
+        sandboxId: null,
+        snapshotId: null
+      }
+    });
+  }
+  const lifecycle = {
+    start: async () => {
+      const sandbox2 = await getSandbox2();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      await updateLastActivity();
+      return sandbox2.status;
+    },
+    snapshot: async () => {
+      const sandbox2 = await getSandbox2();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return errore2.tryAsync({
+        try: async () => {
+          const existing = await storage.sandbox.get(id);
+          const snapshot = await sandbox2.snapshot();
+          await storage.sandbox.set({
+            id,
+            config,
+            tags: existing instanceof Error ? null : existing?.tags ?? null,
+            createdAt: existing instanceof Error ? null : existing?.createdAt ?? null,
+            lastActivityAt: existing instanceof Error ? null : existing?.lastActivityAt ?? null,
+            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 getSandbox2();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return errore2.tryAsync({
+        try: async () => {
+          await sandbox2.stop();
+          const existing = await storage.sandbox.get(id);
+          if (existing instanceof Error || !existing) {
+            return void 0;
+          }
+          await storage.sandbox.set({
+            id: existing.id,
+            config: existing.config,
+            tags: existing.tags,
+            createdAt: existing.createdAt,
+            lastActivityAt: existing.lastActivityAt,
+            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 getSandbox2();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return sandbox2.status;
+    },
+    getCreatedAt: async () => {
+      const sandbox2 = await getSandbox2();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return sandbox2.createdAt;
+    },
+    getRemainingTimeout: async () => {
+      const sandbox2 = await getSandbox2();
+      if (sandbox2 instanceof Error) {
+        return sandbox2;
+      }
+      return sandbox2.timeout;
+    }
+  };
+  async function doExec(opts) {
+    const instance = await getSandbox2();
+    if (instance instanceof Error) {
+      return instance;
+    }
+    const updatePromise = updateLastActivity();
+    const execResult = await execOnInstance(instance, opts);
+    await updatePromise;
+    return execResult;
+  }
+  const sandbox = {
+    id,
+    config,
+    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 getSandbox2();
+      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 getSandbox2();
+      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 getSandbox2();
+      if (instance instanceof Error) {
+        return instance;
+      }
+      return readFileOnInstance(instance, opts);
+    },
+    writeFiles: async (opts) => {
+      const instance = await getSandbox2();
+      if (instance instanceof Error) {
+        throw instance;
+      }
+      return writeFilesOnInstance(instance, opts);
+    },
+    lifecycle,
+    updateNetworkPolicy: async (policy) => {
+      const instance = await getSandbox2();
+      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;
+      }
+    }
+  };
+  let onReadyPromise = Promise.resolve();
+  if (config.lifecycle?.autoStart !== false) {
+    sandboxPromise = doGetSandbox();
+    onReadyPromise = sandboxPromise.then(async (instance) => {
+      if (instance instanceof Error) {
+        return;
+      }
+      if (needsSetupRun && setup) {
+        debug(
+          `[sandbox:setup] running setup.run on session sandbox (key="${setup.key}")`
+        );
+        await setup.run(sandbox);
+        debug("[sandbox:setup] setup.run complete on session sandbox");
+      }
+      if (createdFromSnapshot && onRestart) {
+        debug("[sandbox:setup] running onRestart (created from snapshot)");
+        await onRestart(sandbox);
+      }
+    });
+  }
+  sandbox._onReady = onReadyPromise;
+  return sandbox;
+};
+
+// src/sandbox/client.ts
+var sandboxCache = /* @__PURE__ */ new Map();
+async function getSandbox({
+  sandboxRecord,
+  storageConfig,
+  storage,
+  rpc,
+  enableLifecycleWorkflow = true,
+  setup,
+  onRestart
+}) {
+  const canCache = !(setup || onRestart);
+  if (canCache) {
+    const cached = sandboxCache.get(sandboxRecord.id);
+    if (cached) {
+      debug("[getSandbox] cache hit for", sandboxRecord.id);
+      return cached;
+    }
+  }
+  const promise = createSandbox({
+    sandboxRecord,
+    storageConfig,
+    storage,
+    rpc,
+    enableLifecycleWorkflow,
+    setup,
+    onRestart
+  });
+  if (canCache) {
+    sandboxCache.set(sandboxRecord.id, promise);
+    promise.catch(() => {
+      sandboxCache.delete(sandboxRecord.id);
+    });
+  }
+  return await promise;
+}
+async function createSandbox({
+  sandboxRecord,
+  storageConfig,
+  storage,
+  rpc,
+  enableLifecycleWorkflow = true,
+  setup,
+  onRestart
+}) {
+  let sbx;
+  switch (sandboxRecord.config.type) {
+    case "local":
+      sbx = localSandbox({
+        sandboxRecord,
+        storage,
+        setup,
+        onRestart
+      });
+      break;
+    case "vercel":
+      sbx = vercelSandbox({
+        sandboxRecord,
+        storageConfig,
+        storage,
+        rpc,
+        enableLifecycleWorkflow,
+        setup,
+        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}`
+      );
+  }
+  if (sbx._onReady) {
+    await sbx._onReady;
+  }
+  return sbx;
+}
+
+export {
+  getSandbox
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/utils/debug.ts", "../src/sandbox/bindings/local.ts", "../src/sandbox/write-files.ts", "../src/sandbox/bindings/vercel.ts", "../src/sandbox/client.ts"],
  "sourcesContent": ["const enabled =\n  process.env.AGENT_DEBUG === \"1\" || process.env.AGENT_DEBUG === \"true\";\n\nexport function debug(...args: unknown[]) {\n  if (enabled) {\n    console.log(...args);\n  }\n}\n", "import type { ChildProcess } from \"node:child_process\";\nimport { spawn } from \"node:child_process\";\nimport * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport * as errore from \"errore\";\nimport { ulid } from \"ulid\";\nimport { SandboxError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport type { SandboxRecord, Storage } from \"../../storage\";\nimport { debug } from \"../../utils/debug\";\nimport type { 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> & { _onReady?: Promise<void> } => {\n  const config = sandboxRecord.config;\n  const basePath = config.path ?? process.cwd();\n  const processes = new Map<string, ChildProcess>();\n\n  const sandbox: Sandbox<TTags> = {\n    id: sandboxRecord.id,\n    config: sandboxRecord.config,\n    exec: ({ command, args, signal }) => {\n      return errore.tryAsync({\n        try: () => {\n          const commandId = `command_${ulid()}`;\n\n          const child = spawn(command, args, {\n            cwd: basePath,\n            signal,\n          });\n\n          processes.set(commandId, child);\n\n          let stdout = \"\";\n          let stderr = \"\";\n          const logQueue: LogEntry[] = [];\n          let logResolve: (() => void) | null = null;\n          let closed = false;\n\n          child.stdout.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stdout += str;\n            logQueue.push({ stream: \"stdout\", data: str });\n            logResolve?.();\n          });\n\n          child.stderr.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stderr += str;\n            logQueue.push({ stream: \"stderr\", data: str });\n            logResolve?.();\n          });\n\n          const result = new Promise<{\n            stdout: string;\n            stderr: string;\n            exitCode: number;\n          }>((resolve, reject) => {\n            child.on(\"error\", (err) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              reject(err);\n            });\n\n            child.on(\"close\", (code: number | null) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              resolve({ stdout, stderr, exitCode: code ?? 0 });\n            });\n          });\n\n          async function* logs(): AsyncIterable<LogEntry> {\n            while (!closed || logQueue.length > 0) {\n              const entry = logQueue.shift();\n              if (entry) {\n                yield entry;\n              } else if (!closed) {\n                await new Promise<void>((resolve) => {\n                  logResolve = resolve;\n                });\n                logResolve = null;\n              }\n            }\n          }\n\n          return Promise.resolve({ commandId, logs, result });\n        },\n        catch: (e: unknown) =>\n          new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getDomain: (port) => {\n      return Promise.resolve(`http://localhost:${port}`);\n    },\n\n    kill: async ({ commandId, storage }) => {\n      const child = processes.get(commandId);\n      if (!child) {\n        return new SandboxError({\n          reason: `Command ${commandId} not found or already finished`,\n        });\n      }\n\n      child.kill(\"SIGTERM\");\n\n      const cmd = await storage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await storage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n    },\n\n    readFile: async ({ path: filePath }) => {\n      const fullPath = path.join(basePath, filePath);\n      try {\n        return await fs.readFile(fullPath);\n      } catch (e: unknown) {\n        if (\n          e instanceof Error &&\n          \"code\" in e &&\n          (e as NodeJS.ErrnoException).code === \"ENOENT\"\n        ) {\n          return null;\n        }\n        return new SandboxError({ reason: String(e), cause: e });\n      }\n    },\n\n    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\n\n    updateNetworkPolicy: () =>\n      Promise.resolve(\n        new SandboxError({\n          reason: \"updateNetworkPolicy is only available for Vercel sandboxes\",\n        })\n      ),\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  const result: Sandbox<TTags> & { _onReady?: Promise<void> } = sandbox;\n\n  if (setup || onRestart) {\n    result._onReady = (async () => {\n      let needsSetup = !!setup;\n      if (setup) {\n        const existing = await storage.setup.get(setup.key);\n        if (!(existing instanceof Error) && existing) {\n          debug(\n            `[sandbox:setup] setup already complete for key \"${setup.key}\", skipping`\n          );\n          needsSetup = false;\n        }\n      }\n      if (needsSetup && setup) {\n        debug(`[sandbox:setup] running setup.run (local, key=\"${setup.key}\")`);\n        await setup.run(sandbox);\n        await storage.setup.set({\n          key: setup.key,\n          snapshotId: null,\n          createdAt: Date.now(),\n          lastUsedAt: null,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n        });\n        debug(\n          `[sandbox:setup] setup complete, stored record (key=\"${setup.key}\")`\n        );\n      }\n      if (onRestart) {\n        debug(\"[sandbox:setup] running onRestart (local)\");\n        await onRestart(sandbox);\n      }\n    })();\n  }\n\n  return result;\n};\n", "import * as path from \"node:path\";\nimport type { UploadableFile } from \"../skills/types\";\nimport type { Sandbox } from \"./types\";\n\nconst MAX_RETRIES = 2;\nconst RETRY_BASE_MS = 500;\n\n/**\n * Exec a command and assert exit code 0. Retries on transient failures\n * (exit code 255 with empty stderr \u2014 typically a sandbox process killed\n * before it could produce output).\n */\nasync function execChecked(\n  sandbox: Pick<Sandbox, \"exec\">,\n  opts: { command: string; args?: string[] },\n  errorLabel: string\n): Promise<{ stdout: string; stderr: string; exitCode: number }> {\n  for (let attempt = 0; ; attempt++) {\n    const execResult = await sandbox.exec(opts);\n    if (execResult instanceof Error) {\n      throw execResult;\n    }\n    const result = await execResult.result;\n    if (result.exitCode === 0) {\n      return result;\n    }\n\n    const isTransient = result.exitCode === 255 && !result.stderr.trim();\n    if (isTransient && attempt < MAX_RETRIES) {\n      await new Promise((r) => setTimeout(r, RETRY_BASE_MS * (attempt + 1)));\n      continue;\n    }\n\n    throw new Error(\n      `${errorLabel} with exit code ${result.exitCode}: ${result.stderr}`\n    );\n  }\n}\n\n/**\n * Writes files to a sandbox at the specified destination path.\n * Shell scripts (.sh files) are automatically made executable.\n *\n * For small files (<100KB total), uses single exec with heredoc.\n * For large files, writes base64 chunks then decodes to avoid ARG_MAX limits.\n */\nexport async function writeFiles(opts: {\n  sandbox: Pick<Sandbox, \"exec\">;\n  files: UploadableFile[];\n  destPath: string;\n}): Promise<void> {\n  const { sandbox, files, destPath } = opts;\n\n  if (files.length === 0) {\n    return;\n  }\n\n  const filePaths = files.map((file) => path.posix.join(destPath, file.path));\n  const parentDirs = Array.from(\n    new Set(filePaths.map((p) => path.posix.dirname(p)))\n  );\n  const shellScripts = filePaths.filter((p) => p.endsWith(\".sh\"));\n\n  const mkdirResult = await sandbox.exec({\n    command: \"mkdir\",\n    args: [\"-p\", ...parentDirs],\n  });\n  if (mkdirResult instanceof Error) {\n    throw mkdirResult;\n  }\n  await mkdirResult.result;\n\n  const CHUNK_SIZE = 50_000;\n\n  for (let i = 0; i < files.length; i++) {\n    const file = files[i];\n    const fullPath = filePaths[i];\n    const base64Content = toBase64(file.content);\n\n    if (base64Content.length < CHUNK_SIZE) {\n      const marker = `EOF_${i}`;\n      await execChecked(\n        sandbox,\n        {\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `base64 -d > ${quote(fullPath)} << '${marker}'\n${base64Content}\n${marker}`,\n          ],\n        },\n        \"writeFiles failed\"\n      );\n    } else {\n      const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;\n\n      const clearResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\"-c\", `> ${quote(tempB64)}`],\n      });\n      if (clearResult instanceof Error) {\n        throw clearResult;\n      }\n      await clearResult.result;\n\n      for (\n        let offset = 0;\n        offset < base64Content.length;\n        offset += CHUNK_SIZE\n      ) {\n        const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);\n        const marker = `CHUNK_${offset}`;\n        await execChecked(\n          sandbox,\n          {\n            command: \"bash\",\n            args: [\n              \"-c\",\n              `cat >> ${quote(tempB64)} << '${marker}'\n${chunk}\n${marker}`,\n            ],\n          },\n          \"writeFiles chunk failed\"\n        );\n      }\n\n      await execChecked(\n        sandbox,\n        {\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`,\n          ],\n        },\n        \"writeFiles decode failed\"\n      );\n    }\n  }\n\n  if (shellScripts.length > 0) {\n    const chmodResult = await sandbox.exec({\n      command: \"chmod\",\n      args: [\"+x\", ...shellScripts],\n    });\n    if (chmodResult instanceof Error) {\n      throw chmodResult;\n    }\n    await chmodResult.result;\n  }\n}\n\nfunction toBase64(content: string | Buffer): string {\n  if (typeof content === \"string\") {\n    return Buffer.from(content).toString(\"base64\");\n  }\n  return content.toString(\"base64\");\n}\n\nfunction quote(s: string): string {\n  return `'${s.replace(/'/g, \"'\\\\''\")}'`;\n}\n", "import * as path from \"node:path\";\nimport * as errore from \"errore\";\nimport { Sandbox as VercelSandboxSDK } from \"@vercel/sandbox\";\nimport { start } from \"workflow/api\";\nimport { SandboxError, SandboxNotFoundError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport type {\n  RpcFn,\n  SandboxRecord,\n  Storage,\n  StorageConfig,\n} from \"../../storage\";\nimport { debug } from \"../../utils/debug\";\nimport type {\n  LogEntry,\n  OnRestart,\n  Sandbox,\n  SandboxLifecycle,\n  SandboxLifecycleInput,\n  SandboxSetup,\n  SandboxStatus,\n} from \"../types\";\nimport { sandboxLifecycleWorkflow } from \"./lifecycle-workflow\";\n\nexport type VercelSandboxCreateOptions = Extract<\n  Parameters<typeof VercelSandboxSDK.create>[0],\n  // biome-ignore lint/complexity/noBannedTypes: .\n  {}\n>;\n\nexport const VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1000; // 5 hours\nconst LOCK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes - if lock older than this, consider it stale\nconst LOCK_POLL_INTERVAL_MS = 200;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\n/**\n * Module-level cache for in-flight sandbox creation promises.\n * Prevents parallel requests within the same process from creating duplicate sandboxes.\n */\nconst createPromises = new Map<string, Promise<SandboxError | string>>();\n\nconst ACTIVITY_THROTTLE_MS = 10_000;\nconst lastActivitySent = new Map<string, number>();\n\nconst DEFAULT_VCPUS = 2;\n\nfunction isSandboxGoneError(e: unknown): boolean {\n  if (!(e instanceof Error)) {\n    return false;\n  }\n\n  const errorWithResponse = e as { response?: { status?: number } };\n  const errorWithCause = e as { cause?: { response?: { status?: number } } };\n\n  const status =\n    errorWithResponse.response?.status ??\n    errorWithCause.cause?.response?.status;\n\n  if (status === 410 || status === 422) {\n    return true;\n  }\n\n  const message = e.message || String(e);\n  if (\n    message.includes(\"Expected a stream of command data\") ||\n    message.includes(\"Expected a stream of logs\")\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\nexport const vercelSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n  enableLifecycleWorkflow,\n  storage,\n  rpc,\n  setup,\n  onRestart,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"vercel\" } };\n  storageConfig: StorageConfig;\n  enableLifecycleWorkflow: boolean;\n  storage: Storage;\n  rpc: RpcFn;\n  setup?: SandboxSetup;\n  onRestart?: OnRestart;\n}): Sandbox<TTags> & { _onReady?: Promise<void> } => {\n  const { id, config } = sandboxRecord;\n  const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;\n  const ports = config.ports;\n  const networkPolicy = config.networkPolicy;\n  const initialVercel =\n    sandboxRecord.providerMetadata?.provider === \"vercel\"\n      ? sandboxRecord.providerMetadata\n      : null;\n\n  type SandboxInstance = Awaited<ReturnType<typeof VercelSandboxSDK.get>>;\n  let sandboxPromise: Promise<SandboxError | SandboxInstance> | null = null;\n  let recoveredFromStale = false;\n  let createdFromSnapshot = false;\n  let needsSetupRun = false;\n  const HOME_DIR = \"/home/vercel-sandbox\";\n\n  async function pollForSandboxId(): Promise<SandboxError | string> {\n    const deadline = Date.now() + LOCK_TIMEOUT_MS;\n    while (Date.now() < deadline) {\n      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));\n      const record = await storage.sandbox.get(id);\n      if (record instanceof Error) {\n        return new SandboxError({ reason: record.message, cause: record });\n      }\n      const vercelSandboxId =\n        record?.providerMetadata?.provider === \"vercel\"\n          ? record.providerMetadata.sandboxId\n          : null;\n      if (vercelSandboxId) {\n        return vercelSandboxId;\n      }\n      if (!record?.acquiringLockAt) {\n        const finalCheck = await storage.sandbox.get(id);\n        if (finalCheck instanceof Error) {\n          return new SandboxError({\n            reason: finalCheck.message,\n            cause: finalCheck,\n          });\n        }\n        const finalVercelSandboxId =\n          finalCheck?.providerMetadata?.provider === \"vercel\"\n            ? finalCheck.providerMetadata.sandboxId\n            : null;\n        if (finalVercelSandboxId) {\n          return finalVercelSandboxId;\n        }\n        return doGetOrCreateSandboxId();\n      }\n    }\n    return new SandboxError({\n      reason: \"Timed out waiting for sandbox creation by another process\",\n    });\n  }\n\n  async function startLifecycleWorkflow(\n    vercelSandboxId: string\n  ): Promise<void> {\n    if (!enableLifecycleWorkflow) {\n      return;\n    }\n    const lifecycleInput: SandboxLifecycleInput = {\n      id,\n      vercelSandboxId,\n      storageConfig,\n      rpc,\n    };\n    await start(sandboxLifecycleWorkflow, [{ input: lifecycleInput }]).catch(\n      // biome-ignore lint/suspicious/noEmptyBlockStatements: intentionally ignored - workflow start is fire-and-forget\n      () => {}\n    );\n  }\n\n  async function createSandboxFromSnapshot(\n    snapshotId: string\n  ): Promise<SandboxError | string> {\n    return await errore.tryAsync({\n      try: async () => {\n        const sandbox = await VercelSandboxSDK.create({\n          source: { type: \"snapshot\", snapshotId },\n          resources: { vcpus },\n          timeout: VERCEL_MAX_TIMEOUT_MS,\n          ports,\n          networkPolicy,\n          ...getTestCredentials(),\n        });\n        const now = Date.now();\n        await storage.sandbox.set({\n          id,\n          config,\n          tags: sandboxRecord.tags,\n          createdAt: now,\n          lastActivityAt: now,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n          providerMetadata: {\n            provider: \"vercel\",\n            sandboxId: sandbox.sandboxId,\n            snapshotId,\n          },\n        });\n        await startLifecycleWorkflow(sandbox.sandboxId);\n        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function createFreshSandbox(): Promise<SandboxError | string> {\n    return await errore.tryAsync({\n      try: async () => {\n        const sandbox = await VercelSandboxSDK.create({\n          resources: { vcpus },\n          timeout: VERCEL_MAX_TIMEOUT_MS,\n          ports,\n          networkPolicy,\n          ...getTestCredentials(),\n        });\n        const now = Date.now();\n        await storage.sandbox.set({\n          id,\n          config,\n          tags: sandboxRecord.tags,\n          createdAt: now,\n          lastActivityAt: now,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n          providerMetadata: {\n            provider: \"vercel\",\n            sandboxId: sandbox.sandboxId,\n            snapshotId: null,\n          },\n        });\n        await startLifecycleWorkflow(sandbox.sandboxId);\n        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  /**\n   * Core exec logic against a raw Vercel SDK instance.\n   * Shared between the main sandbox wrapper and temporary setup sandboxes.\n   */\n  function execOnInstance(\n    instance: SandboxInstance,\n    {\n      command,\n      args,\n      signal,\n    }: { command: string; args?: string[]; signal?: AbortSignal }\n  ): Promise<\n    | SandboxError\n    | {\n        commandId: string;\n        logs: () => AsyncIterable<LogEntry>;\n        result: Promise<{ stdout: string; stderr: string; exitCode: number }>;\n      }\n  > {\n    return errore.tryAsync({\n      try: async () => {\n        const output = await instance.runCommand({\n          cwd: HOME_DIR,\n          args,\n          cmd: command,\n          signal,\n          detached: true,\n        });\n\n        let stdout = \"\";\n        let stderr = \"\";\n        const logBuffer: LogEntry[] = [];\n        const state = {\n          resolve: null as (() => void) | null,\n          consumed: false,\n        };\n\n        const consumeLogs = (async () => {\n          try {\n            for await (const log of output.logs()) {\n              const entry: LogEntry =\n                log.stream === \"stdout\"\n                  ? { stream: \"stdout\", data: log.data }\n                  : { stream: \"stderr\", data: log.data };\n\n              if (log.stream === \"stdout\") {\n                stdout += log.data;\n              } else {\n                stderr += log.data;\n              }\n\n              logBuffer.push(entry);\n              state.resolve?.();\n            }\n          } catch {\n            // Sandbox may have been stopped - logs endpoint returns 422\n          }\n          state.consumed = true;\n          state.resolve?.();\n        })();\n\n        async function* logs(): AsyncIterable<LogEntry> {\n          let index = 0;\n          while (!state.consumed || index < logBuffer.length) {\n            if (index < logBuffer.length) {\n              yield logBuffer[index++];\n            } else {\n              await new Promise<void>((resolve) => {\n                state.resolve = resolve;\n              });\n              state.resolve = null;\n            }\n          }\n        }\n\n        const result = consumeLogs.then(async () => {\n          try {\n            const finished = await output.wait();\n            return {\n              stdout,\n              stderr,\n              exitCode: finished.exitCode,\n            };\n          } catch (e) {\n            if (isSandboxGoneError(e)) {\n              return { stdout, stderr, exitCode: 1 };\n            }\n            throw e;\n          }\n        });\n\n        return { commandId: output.cmdId, logs, result };\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  function readFileOnInstance(\n    instance: SandboxInstance,\n    { path }: { path: string }\n  ): Promise<SandboxError | Buffer | null> {\n    return errore.tryAsync({\n      try: () => instance.readFileToBuffer({ path, cwd: HOME_DIR }),\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function writeFilesOnInstance(\n    instance: SandboxInstance,\n    opts: {\n      files: { path: string; content: string | Buffer }[];\n      destPath: string;\n    }\n  ): Promise<void> {\n    const { files, destPath } = opts;\n    if (files.length === 0) {\n      return;\n    }\n\n    const nativeFiles = files.map((file) => {\n      const filePath = path.posix.join(destPath, file.path);\n      const absolutePath = path.posix.isAbsolute(filePath)\n        ? filePath\n        : path.posix.join(HOME_DIR, filePath);\n      return {\n        path: absolutePath,\n        content:\n          typeof file.content === \"string\"\n            ? Buffer.from(file.content)\n            : file.content,\n      };\n    });\n\n    await instance.writeFiles(nativeFiles);\n\n    const shellScripts = nativeFiles.filter((f) => f.path.endsWith(\".sh\"));\n    if (shellScripts.length > 0) {\n      const chmodResult = await execOnInstance(instance, {\n        command: \"chmod\",\n        args: [\"+x\", ...shellScripts.map((f) => f.path)],\n      });\n      if (chmodResult instanceof Error) {\n        throw chmodResult;\n      }\n      await chmodResult.result;\n    }\n  }\n\n  /**\n   * Creates a minimal Sandbox wrapper around a raw Vercel SDK instance.\n   * Used for running setup.run() on a temporary sandbox for snapshot creation.\n   */\n  function createTempSandbox(instance: SandboxInstance): Sandbox {\n    const tempSandbox: Sandbox = {\n      id: `__setup_temp_${Date.now()}`,\n      config,\n      exec: (opts) => execOnInstance(instance, opts),\n      readFile: (opts) => readFileOnInstance(instance, opts),\n      getDomain: () =>\n        Promise.resolve(\n          new SandboxError({ reason: \"not available during setup\" })\n        ),\n      kill: () =>\n        Promise.resolve(\n          new SandboxError({ reason: \"not available during setup\" })\n        ),\n      writeFiles: (opts) => writeFilesOnInstance(instance, opts),\n      updateNetworkPolicy: (policy) =>\n        errore.tryAsync({\n          try: () => instance.updateNetworkPolicy(policy),\n          catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n        }),\n      tag: {\n        list: async () => ({}) as TTags,\n        get: async () => undefined,\n        set: async () => undefined,\n        setMany: async () => undefined,\n      },\n    };\n    return tempSandbox;\n  }\n\n  /**\n   * Polls for a setup snapshot to become available. Returns the snapshotId\n   * if one appears before the lock times out, or null if it doesn't.\n   */\n  async function pollForSetupSnapshot(key: string): Promise<string | null> {\n    const deadline = Date.now() + LOCK_TIMEOUT_MS;\n    while (Date.now() < deadline) {\n      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));\n      const record = await storage.setup.get(key);\n      if (record instanceof Error) {\n        return null;\n      }\n      if (record?.snapshotId) {\n        return record.snapshotId;\n      }\n      // Lock released but no snapshot \u2014 creation failed\n      if (!record?.acquiringLockId) {\n        return null;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Creates a background sandbox, runs setup, snapshots it, and stores the\n   * snapshot ID. Uses atomic locking to ensure only one process creates it.\n   *\n   * @param force - Skip the \"snapshot already exists\" early exit. Used when\n   *   the caller knows the existing snapshot is stale/expired.\n   */\n  async function createSetupSnapshot(opts?: {\n    force?: boolean;\n  }): Promise<void> {\n    if (!setup) {\n      return;\n    }\n    const setupKey = setup.key;\n\n    // Check if snapshot already exists (fast path \u2014 avoids lock attempt)\n    if (!opts?.force) {\n      const existing = await storage.setup.get(setupKey);\n      if (!(existing instanceof Error) && existing?.snapshotId) {\n        return;\n      }\n    }\n\n    // Atomically acquire lock (handles active-lock detection internally)\n    debug(`[sandbox:setup] acquiring lock for setup key \"${setupKey}\"`);\n    const lockId = crypto.randomUUID();\n    const locked = await storage.setup.acquireLock(\n      setupKey,\n      lockId,\n      LOCK_TIMEOUT_MS\n    );\n    if (locked instanceof Error || !locked) {\n      debug(\n        `[sandbox:setup] lock not acquired for key \"${setupKey}\" (another process holds it)`\n      );\n      return;\n    }\n\n    // Re-check: another worker may have created the snapshot between our\n    // pre-check and lock acquisition. If so, skip unless force (stale snapshot).\n    if (!opts?.force && locked.snapshotId) {\n      debug(\n        `[sandbox:setup] snapshot already exists after lock for key \"${setupKey}\", skipping`\n      );\n      return;\n    }\n\n    let tempInstance: Awaited<\n      ReturnType<typeof VercelSandboxSDK.create>\n    > | null = null;\n    try {\n      // Create a temporary sandbox for snapshotting.\n      debug(\n        `[sandbox:setup] creating temp sandbox for snapshot (key=\"${setupKey}\")`\n      );\n      tempInstance = await VercelSandboxSDK.create({\n        resources: { vcpus },\n        timeout: VERCEL_MAX_TIMEOUT_MS,\n        ports,\n        networkPolicy,\n        ...getTestCredentials(),\n      });\n\n      const tempSandbox = createTempSandbox(\n        tempInstance as unknown as SandboxInstance\n      );\n      await setup.run(tempSandbox);\n      debug(\n        `[sandbox:setup] setup.run complete, snapshotting (key=\"${setupKey}\")`\n      );\n      const snapshot = await tempInstance.snapshot();\n\n      await storage.setup.set({\n        key: setupKey,\n        snapshotId: snapshot.snapshotId,\n        createdAt: locked.createdAt,\n        lastUsedAt: null,\n        acquiringLockId: null,\n        acquiringLockAt: null,\n      });\n      debug(\n        `[sandbox:setup] snapshot stored: ${snapshot.snapshotId} (key=\"${setupKey}\")`\n      );\n\n      // Stop the temp sandbox \u2014 no longer needed after snapshotting\n      await tempInstance.stop().catch(() => undefined);\n    } catch (e) {\n      console.error(\n        `[sandbox:setup] failed to create setup snapshot (key=\"${setupKey}\"):`,\n        e\n      );\n      // Stop the temp sandbox on failure\n      if (tempInstance) {\n        await tempInstance.stop().catch(() => undefined);\n      }\n      // Clean up lock on failure\n      await storage.setup\n        .set({\n          key: setupKey,\n          snapshotId: null,\n          createdAt: locked.createdAt,\n          lastUsedAt: null,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n        })\n        .catch(() => undefined);\n    }\n  }\n\n  async function doGetOrCreateSandboxId(): Promise<SandboxError | string> {\n    if (initialVercel?.sandboxId && !recoveredFromStale) {\n      return initialVercel.sandboxId;\n    }\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error) {\n      if (existing instanceof SandboxNotFoundError) {\n        // Sandbox doesn't exist yet, continue with creation\n      } else {\n        return new SandboxError({ reason: existing.message, cause: existing });\n      }\n    }\n\n    const existingRecord =\n      existing instanceof SandboxNotFoundError ? null : existing;\n    const existingVercel =\n      existingRecord?.providerMetadata?.provider === \"vercel\"\n        ? existingRecord.providerMetadata\n        : null;\n\n    if (existingVercel?.sandboxId) {\n      return existingVercel.sandboxId;\n    }\n\n    const hasActiveLock =\n      existingRecord?.acquiringLockId &&\n      existingRecord.acquiringLockAt &&\n      Date.now() - existingRecord.acquiringLockAt < LOCK_TIMEOUT_MS;\n\n    if (hasActiveLock) {\n      return pollForSandboxId();\n    }\n\n    const lockId = crypto.randomUUID();\n    const now = Date.now();\n    const locked = await storage.sandbox.acquireLock(\n      {\n        id,\n        config,\n        tags: existingRecord?.tags ?? sandboxRecord.tags,\n        createdAt: existingRecord?.createdAt ?? sandboxRecord.createdAt,\n        lastActivityAt:\n          existingRecord?.lastActivityAt ?? sandboxRecord.lastActivityAt,\n        acquiringLockId: lockId,\n        acquiringLockAt: now,\n        providerMetadata: {\n          provider: \"vercel\",\n          sandboxId: null,\n          snapshotId:\n            existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? null,\n        },\n      },\n      LOCK_TIMEOUT_MS\n    );\n\n    if (locked instanceof Error) {\n      return new SandboxError({ reason: locked.message, cause: locked });\n    }\n    if (!locked) {\n      return pollForSandboxId();\n    }\n\n    // Capture the locked record for use in the release helper.\n    // TS can't narrow `locked` inside nested functions, so we bind it here.\n    const lockedRecord = locked;\n\n    // Release the sandbox lock so other workers can retry quickly\n    // instead of waiting for lock timeout.\n    async function releaseSandboxLock(): Promise<void> {\n      await storage.sandbox\n        .set({\n          ...lockedRecord,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n        })\n        .catch(() => undefined);\n    }\n\n    // Re-check after lock: another worker may have created the sandbox\n    // between our initial check and lock acquisition.\n    const lockedVercel =\n      lockedRecord.providerMetadata?.provider === \"vercel\"\n        ? lockedRecord.providerMetadata\n        : null;\n    if (lockedVercel?.sandboxId) {\n      await releaseSandboxLock();\n      return lockedVercel.sandboxId;\n    }\n\n    const snapshotId =\n      lockedVercel?.snapshotId ??\n      initialVercel?.snapshotId ??\n      config.lifecycle?.snapshotId;\n    if (snapshotId) {\n      const result = await createSandboxFromSnapshot(snapshotId);\n      if (!(result instanceof Error)) {\n        createdFromSnapshot = true;\n        return result;\n      }\n    }\n\n    // Check for setup snapshot\n    if (setup) {\n      let forceRecreateSnapshot = false;\n      const setupRecord = await storage.setup.get(setup.key);\n      if (!(setupRecord instanceof Error) && setupRecord) {\n        if (setupRecord.snapshotId) {\n          debug(\n            `[sandbox:setup] found setup snapshot ${setupRecord.snapshotId} for key \"${setup.key}\"`\n          );\n          const result = await createSandboxFromSnapshot(\n            setupRecord.snapshotId\n          );\n          if (!(result instanceof Error)) {\n            createdFromSnapshot = true;\n            // Update lastUsedAt (fire-and-forget)\n            storage.setup\n              .set({\n                ...setupRecord,\n                lastUsedAt: Date.now(),\n              })\n              .catch(() => undefined);\n            return result;\n          }\n          // Snapshot is stale/expired \u2014 force background to overwrite it\n          debug(\n            `[sandbox:setup] snapshot ${setupRecord.snapshotId} failed (expired?), will recreate`\n          );\n          forceRecreateSnapshot = true;\n        } else if (\n          setupRecord.acquiringLockId &&\n          setupRecord.acquiringLockAt &&\n          Date.now() - setupRecord.acquiringLockAt < LOCK_TIMEOUT_MS\n        ) {\n          // Another process is creating the setup snapshot \u2014 wait for it\n          debug(\n            `[sandbox:setup] snapshot in progress for key \"${setup.key}\", waiting...`\n          );\n          const snapshotId = await pollForSetupSnapshot(setup.key);\n          if (snapshotId) {\n            debug(\n              `[sandbox:setup] snapshot ready: ${snapshotId} for key \"${setup.key}\"`\n            );\n            const result = await createSandboxFromSnapshot(snapshotId);\n            if (!(result instanceof Error)) {\n              createdFromSnapshot = true;\n              return result;\n            }\n          }\n          // Poll failed or snapshot creation failed \u2014 fall through to cold path\n        }\n      }\n      // No setup snapshot available \u2014 create fresh and run setup later.\n      // Kick off background snapshot immediately so it runs in parallel\n      // with setup.run on the session sandbox.\n      debug(\n        `[sandbox:setup] no snapshot for key \"${setup.key}\", will run setup on this sandbox`\n      );\n      needsSetupRun = true;\n      createSetupSnapshot({ force: forceRecreateSnapshot }).catch((e) => {\n        console.error(\n          \"[sandbox:setup] failed to create background snapshot:\",\n          e\n        );\n      });\n    }\n\n    const freshResult = await createFreshSandbox();\n    if (freshResult instanceof Error) {\n      await releaseSandboxLock();\n    }\n    return freshResult;\n  }\n\n  function getOrCreateSandboxId(): Promise<SandboxError | string> {\n    const cached = createPromises.get(id);\n    if (cached) {\n      return cached;\n    }\n\n    const promise = doGetOrCreateSandboxId().finally(() => {\n      createPromises.delete(id);\n    });\n    createPromises.set(id, promise);\n    return promise;\n  }\n\n  async function doGetSandbox(): Promise<SandboxError | SandboxInstance> {\n    const vercelSandboxId = await getOrCreateSandboxId();\n    if (vercelSandboxId instanceof Error) {\n      return vercelSandboxId;\n    }\n\n    return errore.tryAsync({\n      try: () =>\n        VercelSandboxSDK.get({\n          sandboxId: vercelSandboxId,\n          ...getTestCredentials(),\n        }),\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  function getSandbox(): Promise<SandboxError | SandboxInstance> {\n    if (!sandboxPromise) {\n      sandboxPromise = doGetSandbox();\n    }\n    return sandboxPromise;\n  }\n\n  async function recoverFromStaleSandbox(): Promise<void> {\n    sandboxPromise = null;\n    recoveredFromStale = true;\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error || !existing) {\n      return;\n    }\n\n    const existingVercel =\n      existing.providerMetadata?.provider === \"vercel\"\n        ? existing.providerMetadata\n        : null;\n\n    if (existingVercel?.sandboxId) {\n      await storage.sandbox.set({\n        id: existing.id,\n        config: existing.config,\n        tags: existing.tags,\n        createdAt: existing.createdAt,\n        lastActivityAt: existing.lastActivityAt,\n        acquiringLockId: null,\n        acquiringLockAt: null,\n        providerMetadata: {\n          provider: \"vercel\",\n          sandboxId: null,\n          snapshotId: existingVercel.snapshotId,\n        },\n      });\n    }\n  }\n\n  async function updateLastActivity(): Promise<void> {\n    const now = Date.now();\n    const lastSent = lastActivitySent.get(id);\n    if (lastSent && now - lastSent < ACTIVITY_THROTTLE_MS) {\n      return;\n    }\n    lastActivitySent.set(id, now);\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error || !existing) {\n      return;\n    }\n    const existingVercel =\n      existing.providerMetadata?.provider === \"vercel\"\n        ? existing.providerMetadata\n        : null;\n    await storage.sandbox.set({\n      id: existing.id,\n      config: existing.config,\n      tags: existing.tags,\n      createdAt: existing.createdAt,\n      lastActivityAt: now,\n      acquiringLockId: null,\n      acquiringLockAt: null,\n      providerMetadata: existingVercel ?? {\n        provider: \"vercel\",\n        sandboxId: null,\n        snapshotId: null,\n      },\n    });\n  }\n\n  const lifecycle: SandboxLifecycle = {\n    start: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      await updateLastActivity();\n      return sandbox.status as SandboxStatus;\n    },\n\n    snapshot: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      return errore.tryAsync({\n        try: async () => {\n          const existing = await storage.sandbox.get(id);\n          const snapshot = await sandbox.snapshot();\n          await storage.sandbox.set({\n            id,\n            config,\n            tags: existing instanceof Error ? null : (existing?.tags ?? null),\n            createdAt:\n              existing instanceof Error ? null : (existing?.createdAt ?? null),\n            lastActivityAt:\n              existing instanceof Error\n                ? null\n                : (existing?.lastActivityAt ?? null),\n            acquiringLockId: null,\n            acquiringLockAt: null,\n            providerMetadata: {\n              provider: \"vercel\",\n              sandboxId: null,\n              snapshotId: snapshot.snapshotId,\n            },\n          });\n          return { snapshotId: snapshot.snapshotId };\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    stop: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      return errore.tryAsync({\n        try: async () => {\n          await sandbox.stop();\n          const existing = await storage.sandbox.get(id);\n          if (existing instanceof Error || !existing) {\n            return undefined;\n          }\n          await storage.sandbox.set({\n            id: existing.id,\n            config: existing.config,\n            tags: existing.tags,\n            createdAt: existing.createdAt,\n            lastActivityAt: existing.lastActivityAt,\n            acquiringLockId: null,\n            acquiringLockAt: null,\n            providerMetadata: {\n              provider: \"vercel\",\n              sandboxId: null,\n              snapshotId: null,\n            },\n          });\n          return undefined;\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getStatus: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.status as SandboxStatus;\n    },\n\n    getCreatedAt: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.createdAt;\n    },\n\n    getRemainingTimeout: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.timeout;\n    },\n  };\n\n  async function doExec(opts: {\n    command: string;\n    args?: string[];\n    signal?: AbortSignal;\n  }) {\n    const instance = await getSandbox();\n    if (instance instanceof Error) {\n      return instance;\n    }\n\n    const updatePromise = updateLastActivity();\n    const execResult = await execOnInstance(instance, opts);\n    await updatePromise;\n    return execResult;\n  }\n\n  const sandbox: Sandbox<TTags> & { _onReady?: Promise<void> } = {\n    id,\n    config,\n    exec: async (opts) => {\n      const result = await doExec(opts);\n\n      if (result instanceof SandboxError && isSandboxGoneError(result.cause)) {\n        await recoverFromStaleSandbox();\n        return await doExec(opts);\n      }\n\n      return result;\n    },\n\n    getDomain: async (port) => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      try {\n        return sandbox.domain(port);\n      } catch (e) {\n        return new SandboxError({ reason: String(e), cause: e });\n      }\n    },\n\n    kill: async ({ commandId, storage: cmdStorage }) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n\n      const cmd = await cmdStorage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await cmdStorage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n      return undefined;\n    },\n\n    readFile: async (opts) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n      return readFileOnInstance(instance, opts);\n    },\n\n    writeFiles: async (opts) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        throw instance;\n      }\n      return writeFilesOnInstance(instance, opts);\n    },\n\n    lifecycle,\n\n    updateNetworkPolicy: async (policy) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n      return errore.tryAsync({\n        try: () => instance.updateNetworkPolicy(policy),\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  let onReadyPromise: Promise<void> = Promise.resolve();\n\n  if (config.lifecycle?.autoStart !== false) {\n    sandboxPromise = doGetSandbox();\n\n    // After sandbox instance is ready, run setup and/or onRestart.\n    // sandboxPromise is already resolved by the time .then() runs,\n    // so setup.run / onRestart calling sandbox.exec() won't deadlock.\n    onReadyPromise = sandboxPromise.then(async (instance) => {\n      if (instance instanceof Error) {\n        return;\n      }\n\n      if (needsSetupRun && setup) {\n        debug(\n          `[sandbox:setup] running setup.run on session sandbox (key=\"${setup.key}\")`\n        );\n        await setup.run(sandbox);\n        debug(\"[sandbox:setup] setup.run complete on session sandbox\");\n      }\n\n      if (createdFromSnapshot && onRestart) {\n        debug(\"[sandbox:setup] running onRestart (created from snapshot)\");\n        await onRestart(sandbox);\n      }\n    });\n  }\n\n  sandbox._onReady = onReadyPromise;\n  return sandbox;\n};\n", "import type { TagsSchema } from \"../index\";\nimport type { RpcFn, SandboxRecord, Storage, StorageConfig } from \"../storage\";\nimport { debug } from \"../utils/debug\";\nimport { localSandbox } from \"./bindings/local\";\nimport { vercelSandbox } from \"./bindings/vercel\";\nimport type { OnRestart, Sandbox, SandboxSetup } from \"./types\";\n\n/**\n * Module-level cache for sandbox instances keyed by sandbox record ID.\n *\n * Only used for the \"simple\" path (no setup/onRestart) which is the hot path\n * called repeatedly from streamTextStep and rpc-dispatch tools.execute.\n * Session-creation calls that provide setup/onRestart always create fresh.\n */\nconst sandboxCache = new Map<string, Promise<Sandbox>>();\n\nexport async 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}): Promise<Sandbox<TTags>> {\n  // Only cache the simple hot-path calls (no setup/onRestart).\n  // Session creation passes setup/onRestart and should always create fresh.\n  const canCache = !(setup || onRestart);\n\n  if (canCache) {\n    const cached = sandboxCache.get(sandboxRecord.id);\n    if (cached) {\n      debug(\"[getSandbox] cache hit for\", sandboxRecord.id);\n      return cached as Promise<Sandbox<TTags>>;\n    }\n  }\n\n  const promise = createSandbox<TTags>({\n    sandboxRecord,\n    storageConfig,\n    storage,\n    rpc,\n    enableLifecycleWorkflow,\n    setup,\n    onRestart,\n  });\n\n  if (canCache) {\n    sandboxCache.set(sandboxRecord.id, promise as Promise<Sandbox>);\n\n    // If creation fails, remove from cache so next call retries\n    promise.catch(() => {\n      sandboxCache.delete(sandboxRecord.id);\n    });\n  }\n\n  return await promise;\n}\n\nasync 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}): Promise<Sandbox<TTags>> {\n  let sbx: Sandbox<TTags> & { _onReady?: Promise<void> };\n\n  switch (sandboxRecord.config.type) {\n    case \"local\":\n      sbx = localSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"local\" };\n        },\n        storage,\n        setup,\n        onRestart,\n      });\n      break;\n    case \"vercel\":\n      sbx = vercelSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"vercel\" };\n        },\n        storageConfig,\n        storage,\n        rpc,\n        enableLifecycleWorkflow,\n        setup,\n        onRestart,\n      });\n      break;\n    case \"custom\":\n      throw new Error(\"Custom sandboxes are not supported\");\n    default:\n      sandboxRecord.config satisfies never;\n      throw new Error(\n        `Unknown sandbox type: ${\n          // biome-ignore lint/suspicious/noExplicitAny: .\n          (sandboxRecord.config as any).type\n        }`\n      );\n  }\n\n  if (sbx._onReady) {\n    await sbx._onReady;\n  }\n  return sbx;\n}\n"],
  "mappings": "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",
  "names": ["path", "result", "storage", "sandboxRecord", "path", "errore", "sandbox", "path", "snapshotId", "getSandbox", "sandboxRecord"]
}
