@claxedo/sandbox-manager 0.5.1

package/dist/drivers/modal.mjs

@@ -0,0 +1,227 @@
+import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
+
+// src/drivers/modal.ts
+import { ModalClient, Probe } from "modal";
+
+// src/runtime-env.ts
+function workspaceRuntimeTargetEnv(input) {
+  return {
+    WORKSPACE_RUNTIME_WORKSPACE_ID: input.workspaceId,
+    ...input.hostId ? { WORKSPACE_RUNTIME_HOST_ID: input.hostId } : {},
+    WORKSPACE_RUNTIME_DIRECTORY: input.directory,
+    WORKSPACE_RUNTIME_PORT: String(input.port),
+    ...input.host ? { WORKSPACE_RUNTIME_HOST: input.host } : {}
+  };
+}
+function workspaceRuntimeSourceEnv(input) {
+  if (!input.source || input.source.kind === "empty") return { WORKSPACE_RUNTIME_SOURCE_KIND: "empty" };
+  return {
+    WORKSPACE_RUNTIME_SOURCE_KIND: "git",
+    WORKSPACE_RUNTIME_GIT_REPO_URL: input.source.repoUrl,
+    ...input.source.branch ? { WORKSPACE_RUNTIME_GIT_BRANCH: input.source.branch } : {}
+  };
+}
+
+// src/command.ts
+function shell(input) {
+  return `'${input.replace(/'/g, `'"'"'`)}'`;
+}
+
+// src/constants.ts
+var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
+
+// src/image.ts
+import { Image, DaytonaNotFoundError } from "@daytona/sdk";
+
+// src/runtime-version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var versionCache;
+function workspaceRuntimeVersion() {
+  if (versionCache) return versionCache;
+  const envVersion = process.env.WORKSPACE_RUNTIME_VERSION;
+  if (envVersion) {
+    versionCache = envVersion;
+    return versionCache;
+  }
+  try {
+    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
+    return versionCache;
+  } catch {
+  }
+  versionCache = "0.0.0";
+  return versionCache;
+}
+
+// src/image-name.ts
+var SNAPSHOT_SCHEMA_VERSION = 8;
+var DEFAULT_SANDBOX_IMAGE_REPOSITORY = "ghcr.io/kyashrathore/claxedo-sandbox";
+function snapshotVersion(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function sandboxImageRepository(env = process.env) {
+  const repository = env.CLAXEDO_SANDBOX_IMAGE_REPOSITORY?.trim();
+  return repository ? repository : DEFAULT_SANDBOX_IMAGE_REPOSITORY;
+}
+function buildIdSuffix(buildId, env) {
+  const id = (buildId ?? env.CLAXEDO_SANDBOX_BUILD_ID)?.trim();
+  return id ? `-${snapshotVersion(id)}` : "";
+}
+function defaultSandboxImage(version = workspaceRuntimeVersion(), buildId, env = process.env) {
+  return `${sandboxImageRepository(env)}:workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}-v${SNAPSHOT_SCHEMA_VERSION}`;
+}
+function defaultSnapshotName(version = workspaceRuntimeVersion(), buildId, env = process.env) {
+  return `claxedo-workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}-v${SNAPSHOT_SCHEMA_VERSION}`;
+}
+
+// src/image.ts
+var SANDBOX_IMAGE_REPOSITORY = sandboxImageRepository();
+var SANDBOX_IMAGE = process.env.CLAXEDO_SANDBOX_IMAGE || defaultSandboxImage();
+var SNAPSHOT_NAME = process.env.CLAXEDO_SNAPSHOT_NAME || defaultSnapshotName();
+
+// src/drivers/modal.ts
+var DEFAULT_APP_NAME = "claxedo";
+var DEFAULT_RUNTIME_COMMAND = "/usr/local/bin/workspace-runtime";
+var DEFAULT_WORKSPACE_DIR = "/workspace";
+var DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_TUNNEL_TIMEOUT_MS = 3e4;
+var DEFAULT_OPERATION_TIMEOUT_MS = 6e4;
+function nameFor(workspaceId) {
+  return `claxedo-${workspaceId}`;
+}
+function transientDriverError(err) {
+  const shaped = err;
+  const status = shaped.response?.status ?? shaped.status;
+  if (typeof status === "number" && status >= 500) return true;
+  const text = `${shaped.code ?? ""} ${shaped.name ?? ""} ${shaped.message ?? ""}`.toLowerCase();
+  return text.includes("timeout") || text.includes("unavailable") || text.includes("deadline");
+}
+function createModalSandboxDriver(options) {
+  const client = options.client ?? new ModalClient({
+    tokenId: options.tokenId,
+    tokenSecret: options.tokenSecret
+  });
+  const appName = options.appName ?? DEFAULT_APP_NAME;
+  const runtimePort = options.runtimePort ?? DEFAULT_WORKSPACE_RUNTIME_PORT;
+  const runtimeCommand = options.runtimeCommand ?? DEFAULT_RUNTIME_COMMAND;
+  const workspaceDir = options.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const tunnelTimeoutMs = options.tunnelTimeoutMs ?? DEFAULT_TUNNEL_TIMEOUT_MS;
+  const operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+  const readinessProbe = options.readinessProbe ?? ((port) => Probe.withTcp(port, { intervalMs: 1e3 }));
+  function workspaceDirectory(input) {
+    return input.workspaceRoot ?? workspaceDir;
+  }
+  function bootEnv(input, hostId) {
+    const env = {
+      ...workspaceRuntimeTargetEnv({
+        workspaceId: input.workspaceId,
+        hostId,
+        directory: workspaceDirectory(input),
+        port: runtimePort,
+        host: "0.0.0.0"
+      }),
+      ...workspaceRuntimeSourceEnv({ source: input.source }),
+      ...input.env
+    };
+    if (options.runner) env.WORKSPACE_RUNTIME_RUNNER = options.runner;
+    if (options.controlEnv?.relayJwksUrl) env.WORKSPACE_RUNTIME_RELAY_JWKS_URL = options.controlEnv.relayJwksUrl;
+    if (options.controlEnv?.relayVerifyPem) env.WORKSPACE_RUNTIME_RELAY_HOST_VERIFY_PEM = options.controlEnv.relayVerifyPem;
+    if (options.controlEnv?.managementJwksUrl) env.WORKSPACE_RUNTIME_MANAGEMENT_JWKS_URL = options.controlEnv.managementJwksUrl;
+    return env;
+  }
+  async function image(input) {
+    if (input.bootSource?.kind === "driver-snapshot") return client.images.fromId(input.bootSource.snapshotId);
+    if (input.bootSource?.kind === "image") return client.images.fromId(input.bootSource.image);
+    if (input.snapshot) return client.images.fromId(input.snapshot);
+    return client.images.fromRegistry(options.baseImage ?? SANDBOX_IMAGE);
+  }
+  function network(input) {
+    if (!input.net || input.net.mode === "allow-all") return {};
+    if ((input.net.hosts ?? []).length > 0) {
+      throw new Error("Modal SandboxDriver cannot enforce host-based network policy");
+    }
+    return { blockNetwork: true };
+  }
+  async function readyTarget(input, sandbox, hostId) {
+    await sandbox.setTags(input.labels).catch(() => void 0);
+    const tunnels = await sandbox.tunnels(tunnelTimeoutMs).catch(() => void 0);
+    const tunnel = tunnels?.[runtimePort];
+    if (!tunnel?.url) return { provisioning: true, retryAfterMs: 2e3 };
+    return {
+      workspaceId: input.workspaceId,
+      sandboxId: sandbox.sandboxId,
+      url: tunnel.url,
+      hostId,
+      driverResourceId: sandbox.sandboxId,
+      driver: {
+        id: "modal",
+        resourceId: sandbox.sandboxId
+      },
+      labels: input.labels
+    };
+  }
+  async function ensureHost(input) {
+    const hostId = input.hostId ?? nameFor(input.workspaceId);
+    const directory = workspaceDirectory(input);
+    const env = {
+      ...bootEnv(input, hostId),
+      ...await options.env?.(input, { id: hostId })
+    };
+    const sandbox = await client.sandboxes.create(
+      await client.apps.fromName(appName, { createIfMissing: true }),
+      await image(input),
+      {
+        name: nameFor(input.workspaceId),
+        command: ["bash", "-lc", `mkdir -p ${shell(directory)}; cd ${shell(directory)}; exec ${runtimeCommand}`],
+        workdir: "/",
+        env,
+        encryptedPorts: [runtimePort],
+        timeoutMs,
+        ...options.idleTimeoutMs !== void 0 ? { idleTimeoutMs: options.idleTimeoutMs } : {},
+        tags: { ...input.labels, "claxedo.workspaceId": input.workspaceId },
+        readinessProbe: readinessProbe(runtimePort),
+        ...network(input)
+      }
+    ).catch((err) => {
+      if (transientDriverError(err)) return void 0;
+      throw err;
+    });
+    if (!sandbox) return { provisioning: true, retryAfterMs: 2e3 };
+    return readyTarget(input, sandbox, hostId);
+  }
+  async function sandboxById(target) {
+    return client.sandboxes.fromId(target.sandboxId);
+  }
+  return {
+    id: "modal",
+    metadata: {
+      driverRunsIn: ["node"],
+      hostStopBehavior: "terminates-host",
+      hostResumeBehavior: "replacement-host",
+      targetAccess: "relay",
+      secretBrokering: "none"
+    },
+    ensureHost,
+    resumeHost: (input) => ensureHost(input.ensure),
+    async touch() {
+    },
+    async suspend(target) {
+      await (await sandboxById(target)).terminate();
+    },
+    async stop(target) {
+      await (await sandboxById(target)).terminate();
+    },
+    async destroy(target) {
+      await (await sandboxById(target)).terminate();
+    },
+    async snapshot(target) {
+      const snapshot = await (await sandboxById(target)).snapshotFilesystem(operationTimeoutMs);
+      if (!snapshot.imageId) throw new Error(`Modal snapshot did not return an image id for ${target.sandboxId}`);
+      return { snapshotId: snapshot.imageId };
+    }
+  };
+}
+export {
+  createModalSandboxDriver
+};

package/dist/drivers/vercel.d.ts

@@ -0,0 +1,109 @@
+import { type NetworkPolicy } from "@vercel/sandbox";
+import type { SandboxBrokeredSecret, SandboxDriver, SandboxDriverEnsureInput } from "..";
+type VercelSnapshotLike = {
+    snapshotId: string;
+};
+type VercelCommandLike = {
+    wait?: (params?: {
+        signal?: AbortSignal;
+    }) => Promise<unknown>;
+    kill?: (signal?: string) => Promise<unknown>;
+    stdout?: (params?: {
+        signal?: AbortSignal;
+    }) => Promise<string>;
+};
+export type VercelSandboxLike = {
+    sandboxId: string;
+    domain: (port: number) => string;
+    runCommand: (command: string | {
+        cmd: string;
+        args?: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+        detached?: boolean;
+        sudo?: boolean;
+        signal?: AbortSignal;
+    }, args?: string[], opts?: {
+        signal?: AbortSignal;
+    }) => Promise<VercelCommandLike>;
+    extendTimeout: (duration: number, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
+    stop: (opts?: {
+        signal?: AbortSignal;
+        blocking?: boolean;
+    }) => Promise<unknown>;
+    snapshot: (opts?: {
+        expiration?: number;
+        signal?: AbortSignal;
+    }) => Promise<VercelSnapshotLike>;
+    updateNetworkPolicy: (policy: NetworkPolicy, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<NetworkPolicy>;
+};
+export type VercelSandboxFactoryLike = {
+    create: (params?: {
+        token?: string;
+        teamId?: string;
+        projectId?: string;
+        source?: {
+            type: "snapshot";
+            snapshotId: string;
+        } | {
+            type: "git";
+            url: string;
+            revision?: string;
+            depth?: number;
+        };
+        ports?: number[];
+        timeout?: number;
+        runtime?: string;
+        env?: Record<string, string>;
+        networkPolicy?: NetworkPolicy;
+        signal?: AbortSignal;
+    }) => Promise<VercelSandboxLike>;
+    get: (params: {
+        token?: string;
+        teamId?: string;
+        projectId?: string;
+        sandboxId: string;
+        signal?: AbortSignal;
+    }) => Promise<VercelSandboxLike>;
+};
+export type VercelSandboxDriverOptions = {
+    token: string;
+    teamId: string;
+    projectId: string;
+    baseSnapshotId?: string;
+    runtime?: string;
+    runtimePort?: number;
+    runtimeCommand?: string;
+    workspaceDir?: string;
+    runner?: string;
+    controlEnv?: {
+        relayJwksUrl?: string;
+        relayVerifyPem?: string;
+        managementJwksUrl?: string;
+    };
+    env?: (input: SandboxDriverEnsureInput, host: {
+        id: string;
+    }) => Record<string, string> | Promise<Record<string, string>>;
+    timeoutMs?: number;
+    snapshotBuildTimeoutMs?: number;
+    operationTimeoutMs?: number;
+    keepAliveMs?: number;
+    sandbox?: VercelSandboxFactoryLike;
+    snapshotCache?: Map<string, string>;
+};
+/**
+ * Brokered-secret egress policy: Vercel's firewall injects the credential as
+ * a header on outbound requests to the allowlisted hosts, so the raw value
+ * never enters the sandbox (see @claxedo/sandbox-manager SandboxBrokeredSecret
+ * and https://vercel.com/docs/sandbox/concepts/firewall — credentials
+ * brokering). The resulting policy is deny-all-except-brokered-hosts, which is
+ * the secure default: a sandbox holding a brokered credential should only be
+ * able to reach the host that credential is for.
+ */
+export declare function vercelBrokeredNetworkPolicy(secrets: SandboxBrokeredSecret[]): NetworkPolicy;
+export declare function createVercelSandboxDriver(options: VercelSandboxDriverOptions): SandboxDriver;
+export {};

package/dist/drivers/vercel.mjs

@@ -0,0 +1,297 @@
+import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
+
+// src/drivers/vercel.ts
+import { Sandbox } from "@vercel/sandbox";
+
+// src/runtime-env.ts
+function workspaceRuntimeTargetEnv(input) {
+  return {
+    WORKSPACE_RUNTIME_WORKSPACE_ID: input.workspaceId,
+    ...input.hostId ? { WORKSPACE_RUNTIME_HOST_ID: input.hostId } : {},
+    WORKSPACE_RUNTIME_DIRECTORY: input.directory,
+    WORKSPACE_RUNTIME_PORT: String(input.port),
+    ...input.host ? { WORKSPACE_RUNTIME_HOST: input.host } : {}
+  };
+}
+function workspaceRuntimeSourceEnv(input) {
+  if (!input.source || input.source.kind === "empty") return { WORKSPACE_RUNTIME_SOURCE_KIND: "empty" };
+  return {
+    WORKSPACE_RUNTIME_SOURCE_KIND: "git",
+    WORKSPACE_RUNTIME_GIT_REPO_URL: input.source.repoUrl,
+    ...input.source.branch ? { WORKSPACE_RUNTIME_GIT_BRANCH: input.source.branch } : {}
+  };
+}
+
+// src/runtime-version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var versionCache;
+function workspaceRuntimeVersion() {
+  if (versionCache) return versionCache;
+  const envVersion = process.env.WORKSPACE_RUNTIME_VERSION;
+  if (envVersion) {
+    versionCache = envVersion;
+    return versionCache;
+  }
+  try {
+    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
+    return versionCache;
+  } catch {
+  }
+  versionCache = "0.0.0";
+  return versionCache;
+}
+
+// src/command.ts
+function shell(input) {
+  return `'${input.replace(/'/g, `'"'"'`)}'`;
+}
+
+// src/constants.ts
+var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
+
+// src/defaults.ts
+var RUNTIME_DIR = "/opt/workspace-runtime";
+
+// src/drivers/vercel.ts
+var DEFAULT_RUNTIME = "node22";
+var DEFAULT_RUNTIME_COMMAND = "/usr/local/bin/workspace-runtime";
+var DEFAULT_WORKSPACE_DIR = "/workspace";
+var DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_SNAPSHOT_BUILD_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_OPERATION_TIMEOUT_MS = 6e4;
+var DEFAULT_KEEP_ALIVE_MS = 5 * 60 * 1e3;
+var EXPECTED_RUNTIME_VERSION = workspaceRuntimeVersion();
+var RUNTIME_PKG = `@claxedo/workspace-runtime@${EXPECTED_RUNTIME_VERSION}`;
+var snapshotCache = /* @__PURE__ */ new Map();
+function nameFor(workspaceId) {
+  return `claxedo-${workspaceId}`;
+}
+function transientDriverError(err) {
+  const shaped = err;
+  const status = shaped.response?.status ?? shaped.status;
+  if (typeof status === "number" && status >= 500) return true;
+  const text = `${shaped.code ?? ""} ${shaped.name ?? ""} ${shaped.message ?? ""}`.toLowerCase();
+  return text.includes("timeout") || text.includes("unavailable") || text.includes("deadline") || text.includes("pending");
+}
+function network(input) {
+  if (!input.net || input.net.mode === "allow-all") return void 0;
+  const hosts = input.net.hosts ?? [];
+  if (hosts.length === 0) return "deny-all";
+  return { allow: hosts };
+}
+function vercelBrokeredNetworkPolicy(secrets) {
+  const allow = {};
+  for (const secret of secrets) {
+    if (!secret.header) {
+      throw new Error(
+        `vercel brokered secret "${secret.name}" requires a header \u2014 the firewall injects the value as an HTTP header on egress`
+      );
+    }
+    for (const host of secret.hosts) {
+      ;
+      (allow[host] ??= []).push({ transform: [{ headers: { [secret.header]: secret.value } }] });
+    }
+  }
+  return { allow };
+}
+function createVercelSandboxDriver(options) {
+  const sandboxFactory = options.sandbox ?? Sandbox;
+  const runtime = options.runtime ?? DEFAULT_RUNTIME;
+  const runtimePort = options.runtimePort ?? DEFAULT_WORKSPACE_RUNTIME_PORT;
+  const runtimeCommand = options.runtimeCommand ?? DEFAULT_RUNTIME_COMMAND;
+  const workspaceDir = options.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const snapshotBuildTimeoutMs = options.snapshotBuildTimeoutMs ?? DEFAULT_SNAPSHOT_BUILD_TIMEOUT_MS;
+  const operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+  const keepAliveMs = options.keepAliveMs ?? DEFAULT_KEEP_ALIVE_MS;
+  const cache = options.snapshotCache ?? snapshotCache;
+  function workspaceDirectory(input) {
+    return input.workspaceRoot ?? workspaceDir;
+  }
+  function credentials() {
+    return {
+      token: options.token,
+      teamId: options.teamId,
+      projectId: options.projectId
+    };
+  }
+  function bootEnv(input, hostId) {
+    const env = {
+      ...workspaceRuntimeTargetEnv({
+        workspaceId: input.workspaceId,
+        hostId,
+        directory: workspaceDirectory(input),
+        port: runtimePort,
+        host: "0.0.0.0"
+      }),
+      ...workspaceRuntimeSourceEnv({ source: input.source }),
+      ...input.env
+    };
+    if (options.runner) env.WORKSPACE_RUNTIME_RUNNER = options.runner;
+    if (options.controlEnv?.relayJwksUrl) env.WORKSPACE_RUNTIME_RELAY_JWKS_URL = options.controlEnv.relayJwksUrl;
+    if (options.controlEnv?.relayVerifyPem) env.WORKSPACE_RUNTIME_RELAY_HOST_VERIFY_PEM = options.controlEnv.relayVerifyPem;
+    if (options.controlEnv?.managementJwksUrl) env.WORKSPACE_RUNTIME_MANAGEMENT_JWKS_URL = options.controlEnv.managementJwksUrl;
+    return env;
+  }
+  async function runSetup(sandbox, command) {
+    await sandbox.runCommand("bash", ["-c", command], {
+      signal: AbortSignal.timeout(snapshotBuildTimeoutMs)
+    });
+  }
+  async function ensureSnapshot() {
+    if (options.baseSnapshotId) return options.baseSnapshotId;
+    const cacheKey = `${options.teamId}:${options.projectId}:${runtime}:${EXPECTED_RUNTIME_VERSION}`;
+    const hit = cache.get(cacheKey);
+    if (hit) return hit;
+    const builder = await sandboxFactory.create({
+      ...credentials(),
+      runtime,
+      ports: [runtimePort],
+      timeout: snapshotBuildTimeoutMs
+    });
+    await runSetup(builder, "sudo dnf install -y git make gcc-c++ python3 > /dev/null 2>&1");
+    await runSetup(builder, [
+      "npm i -g --min-release-age=2 tsx@4.22.3 opencode-ai@1.15.10 @anthropic-ai/claude-code@2.1.150 @openai/codex@0.133.0 @google/gemini-cli@0.43.0 @earendil-works/pi-coding-agent@0.75.5",
+      "curl https://cursor.com/install -fsS | bash",
+      "curl -fsSL https://ampcode.com/install.sh | bash",
+      "curl -fsSL https://app.factory.ai/cli | sh",
+      "sudo ln -sf $HOME/.local/bin/agent /usr/local/bin/agent",
+      "sudo ln -sf $HOME/.local/bin/cursor-agent /usr/local/bin/cursor-agent",
+      "sudo ln -sf $HOME/.local/bin/amp /usr/local/bin/amp",
+      "sudo ln -sf $HOME/.local/bin/droid /usr/local/bin/droid",
+      "command -v opencode",
+      "command -v claude",
+      "command -v codex",
+      "command -v gemini",
+      "command -v agent",
+      "command -v cursor-agent",
+      "command -v amp",
+      "command -v droid",
+      "command -v pi"
+    ].join(" && "));
+    await runSetup(builder, [
+      `sudo mkdir -p ${shell(RUNTIME_DIR)}`,
+      `sudo chown $(whoami) ${shell(RUNTIME_DIR)}`,
+      `cd ${shell(RUNTIME_DIR)}`,
+      "npm init -y",
+      `npm install ${RUNTIME_PKG} --min-release-age=2`,
+      `node -e "const fs=require('fs');const actual=JSON.parse(fs.readFileSync('${RUNTIME_DIR}/node_modules/@claxedo/workspace-runtime/package.json','utf8')).version;if(actual!=='${EXPECTED_RUNTIME_VERSION}'){throw new Error('workspace-runtime snapshot package version mismatch: expected ${EXPECTED_RUNTIME_VERSION}, got '+actual)}"`,
+      "test -x node_modules/.bin/workspace-runtime",
+      "test -x node_modules/.bin/claude-agent-acp",
+      "test -x node_modules/.bin/codex-acp",
+      `sudo ln -sf ${RUNTIME_DIR}/node_modules/.bin/workspace-runtime /usr/local/bin/workspace-runtime`,
+      `sudo ln -sf ${RUNTIME_DIR}/node_modules/.bin/claude-agent-acp /usr/local/bin/claude-agent-acp`,
+      `sudo ln -sf ${RUNTIME_DIR}/node_modules/.bin/codex-acp /usr/local/bin/codex-acp`,
+      "command -v workspace-runtime",
+      "command -v claude-agent-acp",
+      "command -v codex-acp"
+    ].join(" && "));
+    const snapshot = await builder.snapshot({
+      expiration: 0,
+      signal: AbortSignal.timeout(snapshotBuildTimeoutMs)
+    });
+    cache.set(cacheKey, snapshot.snapshotId);
+    return snapshot.snapshotId;
+  }
+  async function source(input) {
+    if (input.bootSource?.kind === "image") {
+      throw new Error("Vercel SandboxDriver does not support image boot; use driver snapshots");
+    }
+    const snapshotId = input.bootSource?.kind === "driver-snapshot" ? input.bootSource.snapshotId : input.snapshot ?? await ensureSnapshot();
+    return { type: "snapshot", snapshotId };
+  }
+  async function startRuntime(sandbox, input, env) {
+    const directory = workspaceDirectory(input);
+    await sandbox.runCommand({
+      cmd: "bash",
+      args: ["-lc", `mkdir -p ${shell(directory)}; cd ${shell(directory)}; exec ${runtimeCommand}`],
+      cwd: "/vercel/sandbox",
+      env,
+      detached: true,
+      signal: AbortSignal.timeout(operationTimeoutMs)
+    });
+  }
+  async function readyTarget(input, sandbox, hostId) {
+    const url = sandbox.domain(runtimePort);
+    return {
+      workspaceId: input.workspaceId,
+      sandboxId: sandbox.sandboxId,
+      url,
+      hostId,
+      driverResourceId: sandbox.sandboxId,
+      driver: {
+        id: "vercel",
+        resourceId: sandbox.sandboxId
+      },
+      labels: input.labels
+    };
+  }
+  async function ensureHost(input) {
+    const hostId = input.hostId ?? nameFor(input.workspaceId);
+    const env = {
+      ...bootEnv(input, hostId),
+      ...await options.env?.(input, { id: hostId })
+    };
+    const sandbox = await sandboxFactory.create({
+      ...credentials(),
+      source: await source(input),
+      ports: [runtimePort],
+      timeout: timeoutMs,
+      env,
+      ...network(input) ? { networkPolicy: network(input) } : {}
+    }).catch((err) => {
+      if (transientDriverError(err)) return void 0;
+      throw err;
+    });
+    if (!sandbox) return { provisioning: true, retryAfterMs: 2e3 };
+    if (input.secrets?.length) {
+      await sandbox.updateNetworkPolicy(vercelBrokeredNetworkPolicy(input.secrets), {
+        signal: AbortSignal.timeout(operationTimeoutMs)
+      });
+    }
+    await startRuntime(sandbox, input, env);
+    return readyTarget(input, sandbox, hostId);
+  }
+  async function sandboxById(target) {
+    return sandboxFactory.get({
+      ...credentials(),
+      sandboxId: target.sandboxId
+    });
+  }
+  return {
+    id: "vercel",
+    metadata: {
+      driverRunsIn: ["node"],
+      hostStopBehavior: "terminates-host",
+      hostResumeBehavior: "replacement-host",
+      targetAccess: "relay",
+      secretBrokering: "native"
+    },
+    ensureHost,
+    resumeHost: (input) => ensureHost(input.ensure),
+    async touch(target) {
+      await (await sandboxById(target)).extendTimeout(keepAliveMs).catch(() => void 0);
+    },
+    async suspend(target) {
+      await (await sandboxById(target)).stop({ blocking: false });
+    },
+    async stop(target) {
+      await (await sandboxById(target)).stop({ blocking: false });
+    },
+    async destroy(target) {
+      await (await sandboxById(target)).stop({ blocking: true });
+    },
+    async snapshot(target) {
+      const snapshot = await (await sandboxById(target)).snapshot({
+        expiration: 0,
+        signal: AbortSignal.timeout(snapshotBuildTimeoutMs)
+      });
+      return { snapshotId: snapshot.snapshotId };
+    }
+  };
+}
+export {
+  createVercelSandboxDriver,
+  vercelBrokeredNetworkPolicy
+};

package/dist/image-name.d.ts

@@ -0,0 +1,7 @@
+export declare const SNAPSHOT_SCHEMA_VERSION = 8;
+export declare const DEFAULT_SANDBOX_IMAGE_REPOSITORY = "ghcr.io/kyashrathore/claxedo-sandbox";
+export type SandboxImageEnv = Record<string, string | undefined>;
+export declare function snapshotVersion(value: string): string;
+export declare function sandboxImageRepository(env?: SandboxImageEnv): string;
+export declare function defaultSandboxImage(version?: string, buildId?: string, env?: SandboxImageEnv): string;
+export declare function defaultSnapshotName(version?: string, buildId?: string, env?: SandboxImageEnv): string;

package/dist/image.d.ts

@@ -0,0 +1,8 @@
+import { Daytona, Image } from "@daytona/sdk";
+export { RUNTIME_DIR, WORKSPACE_RUNTIME_PORT, WORKSPACE_DIR } from "./defaults";
+export { SNAPSHOT_SCHEMA_VERSION, snapshotVersion, defaultSandboxImage, defaultSnapshotName, } from "./image-name";
+export declare const SANDBOX_IMAGE_REPOSITORY: string;
+export declare const SANDBOX_IMAGE: string;
+export declare const SNAPSHOT_NAME: string;
+export declare function buildSandboxImage(): Image;
+export declare function ensureSnapshot(daytona: Daytona): Promise<string>;