experimental-agent 0.0.0 → 0.0.2

package/dist/chunk-4RGMKC2M.mjs

@@ -0,0 +1,755 @@
+import {
+  SandboxError,
+  SandboxNotFoundError,
+  getStorage
+} from "./chunk-24DJSI7C.mjs";
+
+// src/sandbox/bindings/local.ts
+import { spawn } from "node:child_process";
+import * as errore from "errore";
+import { ulid } from "ulid";
+
+// src/sandbox/write-files.ts
+import * as path from "node:path";
+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}`;
+      const execResult = await sandbox.exec({
+        command: "bash",
+        args: [
+          "-c",
+          `base64 -d > ${quote(fullPath)} << '${marker}'
+${base64Content}
+${marker}`
+        ]
+      });
+      if (execResult instanceof Error) {
+        throw execResult;
+      }
+      const { exitCode, stderr } = await execResult.result;
+      if (exitCode !== 0) {
+        throw new Error(
+          `writeFiles failed with exit code ${exitCode}: ${stderr}`
+        );
+      }
+    } 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}`;
+        const appendResult = await sandbox.exec({
+          command: "bash",
+          args: [
+            "-c",
+            `cat >> ${quote(tempB64)} << '${marker}'
+${chunk}
+${marker}`
+          ]
+        });
+        if (appendResult instanceof Error) {
+          throw appendResult;
+        }
+        const { exitCode: exitCode2, stderr: stderr2 } = await appendResult.result;
+        if (exitCode2 !== 0) {
+          throw new Error(
+            `writeFiles chunk failed with exit code ${exitCode2}: ${stderr2}`
+          );
+        }
+      }
+      const decodeResult = await sandbox.exec({
+        command: "bash",
+        args: [
+          "-c",
+          `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`
+        ]
+      });
+      if (decodeResult instanceof Error) {
+        throw decodeResult;
+      }
+      const { exitCode, stderr } = await decodeResult.result;
+      if (exitCode !== 0) {
+        throw new Error(
+          `writeFiles decode failed with exit code ${exitCode}: ${stderr}`
+        );
+      }
+    }
+  }
+  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,
+  storageConfig
+}) => {
+  const config = sandboxRecord.config;
+  const basePath = config.path ?? process.cwd();
+  const processes = /* @__PURE__ */ new Map();
+  const storage = getStorage(storageConfig);
+  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 result = 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 });
+        },
+        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 });
+        }
+      }
+    },
+    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),
+    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 errore2 from "errore";
+import { Sandbox as VercelSandboxSDK } from "sandbox";
+var VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1e3;
+var LOCK_TIMEOUT_MS = 2 * 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;
+var vercelSandbox = ({
+  sandboxRecord,
+  storageConfig,
+  enableLifecycleWorkflow = true,
+  storage: storageOverride
+}) => {
+  const { id, config } = sandboxRecord;
+  const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;
+  const ports = config.ports;
+  const storage = storageOverride ?? getStorage(storageConfig);
+  const initialVercel = sandboxRecord.providerMetadata?.provider === "vercel" ? sandboxRecord.providerMetadata : null;
+  let sandboxPromise = null;
+  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 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,
+          ...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
+          }
+        });
+        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,
+          ...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
+          }
+        });
+        return sandbox2.sandboxId;
+      },
+      catch: (e) => new SandboxError({ reason: String(e), cause: e })
+    });
+  }
+  async function doGetOrCreateSandboxId() {
+    if (initialVercel?.sandboxId) {
+      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();
+    await storage.sandbox.set({
+      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
+      }
+    });
+    const afterLock = await storage.sandbox.get(id);
+    if (afterLock instanceof Error) {
+      return new SandboxError({ reason: afterLock.message, cause: afterLock });
+    }
+    if (afterLock?.acquiringLockId !== lockId) {
+      return pollForSandboxId();
+    }
+    const snapshotId = existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? config.lifecycle?.snapshotId;
+    if (snapshotId) {
+      const result = await createSandboxFromSnapshot(snapshotId);
+      if (!(result instanceof Error)) {
+        return result;
+      }
+    }
+    return createFreshSandbox();
+  }
+  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 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
+      }
+    });
+    if (enableLifecycleWorkflow) {
+    }
+  }
+  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;
+    }
+  };
+  const sandbox = {
+    id,
+    config,
+    exec: async ({ command, args, signal }) => {
+      const instance = await getSandbox2();
+      if (instance instanceof Error) {
+        return instance;
+      }
+      const updatePromise = updateLastActivity();
+      const execResult = await errore2.tryAsync({
+        try: async () => {
+          const output = await instance.runCommand({
+            cwd: HOME_DIR,
+            args,
+            cmd: command,
+            signal
+          });
+          let stdout = "";
+          let stderr = "";
+          const logBuffer = [];
+          const state = {
+            resolve: null,
+            consumed: false
+          };
+          const consumeLogs = (async () => {
+            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?.();
+            }
+            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(() => ({
+            stdout,
+            stderr,
+            exitCode: output.exitCode
+          }));
+          return { commandId: output.cmdId, logs, result };
+        },
+        catch: (e) => new SandboxError({ reason: String(e), cause: e })
+      });
+      await updatePromise;
+      return execResult;
+    },
+    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;
+    },
+    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),
+    lifecycle,
+    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;
+      }
+    }
+  };
+  if (config.lifecycle?.autoStart !== false) {
+    sandboxPromise = doGetSandbox();
+  }
+  return sandbox;
+};
+
+// src/sandbox/client.ts
+function getSandbox({
+  sandboxRecord,
+  storageConfig
+}) {
+  const { config } = sandboxRecord;
+  switch (config.type) {
+    case "local":
+      return localSandbox({
+        sandboxRecord,
+        storageConfig
+      });
+    case "vercel":
+      return vercelSandbox({
+        sandboxRecord,
+        storageConfig
+      });
+    case "custom":
+      throw new Error("Custom sandboxes are not supported");
+    default:
+      config;
+      throw new Error(
+        `Unknown sandbox type: ${// biome-ignore lint/suspicious/noExplicitAny: .
+        config.type}`
+      );
+  }
+}
+
+export {
+  getSandbox
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/local.ts", "../src/sandbox/write-files.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 errore from \"errore\";\nimport { ulid } from \"ulid\";\nimport { SandboxError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport {\n  getStorage,\n  type SandboxRecord,\n  type StorageConfig,\n} from \"../../storage\";\nimport type { LogEntry, Sandbox } from \"../types\";\nimport { writeFiles } from \"../write-files\";\n\nexport const localSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"local\" } };\n  storageConfig: StorageConfig;\n}): Sandbox<TTags> => {\n  const config = sandboxRecord.config;\n  const basePath = config.path ?? process.cwd();\n  const processes = new Map<string, ChildProcess>();\n  const storage = getStorage(storageConfig);\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    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\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 type { UploadableFile } from \"../skills/types\";\nimport type { Sandbox } from \"./types\";\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) =>\n    path.posix.join(destPath, file.path)\n  );\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      const execResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\n          \"-c\",\n          `base64 -d > ${quote(fullPath)} << '${marker}'\n${base64Content}\n${marker}`,\n        ],\n      });\n\n      if (execResult instanceof Error) {\n        throw execResult;\n      }\n\n      const { exitCode, stderr } = await execResult.result;\n      if (exitCode !== 0) {\n        throw new Error(\n          `writeFiles failed with exit code ${exitCode}: ${stderr}`\n        );\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        const appendResult = await sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `cat >> ${quote(tempB64)} << '${marker}'\n${chunk}\n${marker}`,\n          ],\n        });\n\n        if (appendResult instanceof Error) {\n          throw appendResult;\n        }\n\n        const { exitCode, stderr } = await appendResult.result;\n        if (exitCode !== 0) {\n          throw new Error(\n            `writeFiles chunk failed with exit code ${exitCode}: ${stderr}`\n          );\n        }\n      }\n\n      const decodeResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\n          \"-c\",\n          `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`,\n        ],\n      });\n\n      if (decodeResult instanceof Error) {\n        throw decodeResult;\n      }\n\n      const { exitCode, stderr } = await decodeResult.result;\n      if (exitCode !== 0) {\n        throw new Error(\n          `writeFiles decode failed with exit code ${exitCode}: ${stderr}`\n        );\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 errore from \"errore\";\nimport { Sandbox as VercelSandboxSDK } from \"sandbox\";\nimport { SandboxError, SandboxNotFoundError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport {\n  getStorage,\n  type SandboxRecord,\n  type Storage,\n  type StorageConfig,\n} from \"../../storage\";\nimport type {\n  LogEntry,\n  Sandbox,\n  SandboxLifecycle,\n  SandboxStatus,\n} from \"../types\";\nimport { writeFiles } from \"../write-files\";\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 = 2 * 60 * 1000; // 2 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\nexport const vercelSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n  enableLifecycleWorkflow = true,\n  storage: storageOverride,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"vercel\" } };\n  storageConfig: StorageConfig;\n  enableLifecycleWorkflow?: boolean;\n  storage?: Storage;\n}): Sandbox<TTags> => {\n  const { id, config } = sandboxRecord;\n  const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;\n  const ports = config.ports;\n  const storage = storageOverride ?? getStorage(storageConfig);\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  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 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          ...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        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          ...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        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function doGetOrCreateSandboxId(): Promise<SandboxError | string> {\n    if (initialVercel?.sandboxId) {\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    await storage.sandbox.set({\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\n    const afterLock = await storage.sandbox.get(id);\n    if (afterLock instanceof Error) {\n      return new SandboxError({ reason: afterLock.message, cause: afterLock });\n    }\n    if (afterLock?.acquiringLockId !== lockId) {\n      return pollForSandboxId();\n    }\n\n    const snapshotId =\n      existingVercel?.snapshotId ??\n      initialVercel?.snapshotId ??\n      config.lifecycle?.snapshotId;\n    if (snapshotId) {\n      const result = await createSandboxFromSnapshot(snapshotId);\n      if (!(result instanceof Error)) {\n        return result;\n      }\n    }\n\n    return createFreshSandbox();\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 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    if (enableLifecycleWorkflow) {\n      // todo re-enable once we figure out why workflow throws a bunch of errors in dev\n      // const lifecycleInput: SandboxLifecycleInput = {\n      //   id,\n      //   storageConfig,\n      //   initialConfig: config,\n      // };\n      // try {\n      //   await sandboxActivityHook.resume(id, {\n      //     type: \"activity\",\n      //     newConfig: config,\n      //   });\n      // } catch {\n      //   await start(sandboxLifecycleWorkflow, [{ input: lifecycleInput }]);\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  const sandbox: Sandbox<TTags> = {\n    id,\n    config,\n    exec: async ({ command, args, signal }) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n\n      const updatePromise = updateLastActivity();\n\n      const execResult = await errore.tryAsync({\n        try: async () => {\n          const output = await instance.runCommand({\n            cwd: HOME_DIR,\n            args,\n            cmd: command,\n            signal,\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            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            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(() => ({\n            stdout,\n            stderr,\n            exitCode: output.exitCode,\n          }));\n\n          return { commandId: output.cmdId, logs, result };\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n\n      await updatePromise;\n      return execResult;\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    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\n\n    lifecycle,\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  if (config.lifecycle?.autoStart !== false) {\n    sandboxPromise = doGetSandbox();\n  }\n\n  return sandbox;\n};\n", "import type { TagsSchema } from \"../index\";\nimport type { SandboxRecord, StorageConfig } from \"../storage\";\nimport { localSandbox } from \"./bindings/local\";\nimport { vercelSandbox } from \"./bindings/vercel\";\nimport type { Sandbox } from \"./types\";\n\nexport function getSandbox<TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n}: {\n  storageConfig: StorageConfig;\n  sandboxRecord: SandboxRecord;\n}): Sandbox<TTags> {\n  const { config } = sandboxRecord;\n  switch (config.type) {\n    case \"local\":\n      return localSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"local\" };\n        },\n        storageConfig,\n      });\n    case \"vercel\":\n      return vercelSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"vercel\" };\n        },\n        storageConfig,\n      });\n    case \"custom\":\n      throw new Error(\"Custom sandboxes are not supported\");\n    default:\n      config satisfies never;\n      throw new Error(\n        `Unknown sandbox type: ${\n          // biome-ignore lint/suspicious/noExplicitAny: .\n          (config as any).type\n        }`\n      );\n  }\n}\n"],
  "mappings": "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",
  "names": ["exitCode", "stderr", "storage", "sandboxRecord", "errore", "sandbox", "getSandbox", "sandboxRecord"]
}
