@claxedo/sandbox-manager 0.5.1 → 0.5.2

package/README.md

@@ -13,6 +13,55 @@ The package owns the generic pieces:
 
 It deliberately does not own Claxedo product auth, billing, Convex schema, SQLite app storage, routes, or relay tokens. Applications provide those through adapters and call `createSandboxManager`.
 
+## Install
+
+```sh
+npm install @claxedo/sandbox-manager
+```
+
+## Quickstart
+
+A `SandboxManager` is three parts wired together: a `SandboxLeaseStore` (where
+lease state lives), a `SandboxDriver` (how a sandbox is actually placed), and
+`createSandboxManager` (the epoch/retry orchestration on top of both). This
+example uses the in-memory lease store and the Docker driver, so it runs
+end-to-end with only a local Docker daemon — no provider account needed:
+
+```ts
+import { createSandboxManager } from "@claxedo/sandbox-manager"
+import { createMemoryLeaseStore } from "@claxedo/sandbox-manager/stores/memory"
+import { createDockerSandboxDriver } from "@claxedo/sandbox-manager/drivers/docker"
+import { SANDBOX_IMAGE } from "@claxedo/sandbox-manager/image"
+
+const manager = createSandboxManager({
+  leaseStore: createMemoryLeaseStore(),
+  driver: createDockerSandboxDriver({ image: SANDBOX_IMAGE }),
+})
+
+const result = await manager.ensure("workspace-1", { homeRegion: "local" })
+
+if (result.status === "ready") {
+  console.log(`sandbox ready at ${result.url} (sandboxId: ${result.sandboxId})`)
+} else if (result.status === "provisioning") {
+  console.log(`still provisioning, retry in ${result.retryAfterMs}ms`)
+} else {
+  console.error(`unavailable: ${result.error}`)
+}
+
+// Later, on the same workspace: `ensure` re-resolves the existing lease
+// instead of placing a new sandbox.
+await manager.stop("workspace-1")
+```
+
+Swap `createDockerSandboxDriver` for `createDaytonaSandboxDriver`,
+`createModalSandboxDriver`, `createVercelSandboxDriver`,
+`createCloudflareSandboxDriver`, or `createBoxSandboxDriver` (all under
+`@claxedo/sandbox-manager/drivers/*`) to place on a hosted provider instead —
+see [`docs/architecture.md`](docs/architecture.md) for the full driver
+comparison and each provider's required options. Swap `createMemoryLeaseStore`
+for a persisted `SandboxLeaseStore` implementation (e.g. backed by SQLite or
+Convex) to survive process restarts.
+
 ## Credentials & secrets
 
 There are two distinct channels for getting values into a sandbox, chosen by

package/dist/command.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/command.ts
 import path from "path";
 function shell(input) {

package/dist/constants.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/constants.ts
 var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
 export {

package/dist/daytona-allow-list.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/daytona-allow-list.ts
 function formatDaytonaAllowList(cidrs) {
   return cidrs.slice(0, 10).join(",");

package/dist/defaults.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/constants.ts
 var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
 

package/dist/driver-catalog.d.ts

@@ -1,5 +1,5 @@
 import type { SandboxDriverMetadata } from "./index";
-export declare const sandboxDriverIds: readonly ["daytona", "modal", "vercel", "cloudflare", "docker"];
+export declare const sandboxDriverIds: readonly ["daytona", "modal", "vercel", "cloudflare", "box", "docker"];
 export type SandboxDriverID = (typeof sandboxDriverIds)[number];
 export type SandboxDriverAuth = {
     daytona?: {
@@ -18,6 +18,9 @@ export type SandboxDriverAuth = {
         api_token?: string;
         worker_url?: string;
     };
+    box?: {
+        api_key?: string;
+    };
     docker?: {
         image?: string;
     };
@@ -38,15 +41,15 @@ export type SandboxDriverCatalogEntry = {
 };
 export declare const sandboxDriverCatalog: Record<SandboxDriverID, SandboxDriverCatalogEntry>;
 export declare function isSandboxDriverID(input: string | undefined): input is SandboxDriverID;
-export declare function sandboxDriverId(input: string | undefined, cfg?: SandboxDriverConfig, env?: SandboxDriverEnv): "daytona" | "modal" | "vercel" | "cloudflare" | "docker" | undefined;
+export declare function sandboxDriverId(input: string | undefined, cfg?: SandboxDriverConfig, env?: SandboxDriverEnv): "box" | "cloudflare" | "daytona" | "docker" | "modal" | "vercel" | undefined;
 export declare function defaultSandboxDriverID(cfg?: SandboxDriverConfig, env?: SandboxDriverEnv): SandboxDriverID;
 export declare function sandboxDriverAuth<T extends SandboxDriverID>(cfg: SandboxDriverConfig | undefined, id: T, env?: SandboxDriverEnv): SandboxDriverAuth[T] | undefined;
 export declare function hasSandboxDriverAuth(cfg: SandboxDriverConfig | undefined, id: SandboxDriverID, env?: SandboxDriverEnv): boolean;
 export declare function dockerSandboxDriverEnabled(env?: SandboxDriverEnv): boolean;
 export declare function listSandboxDrivers(cfg?: SandboxDriverConfig, env?: SandboxDriverEnv, managedDriverIds?: ReadonlySet<string>): {
-    default_driver: "daytona" | "modal" | "vercel" | "cloudflare" | "docker";
+    default_driver: "box" | "cloudflare" | "daytona" | "docker" | "modal" | "vercel";
     drivers: {
-        id: "daytona" | "modal" | "vercel" | "cloudflare" | "docker";
+        id: "box" | "cloudflare" | "daytona" | "docker" | "modal" | "vercel";
         label: string;
         fields: {
             key: string;
@@ -54,7 +57,7 @@ export declare function listSandboxDrivers(cfg?: SandboxDriverConfig, env?: Sand
             secret?: boolean;
         }[];
         configured: boolean;
-        source: "none" | "config" | "managed";
+        source: "config" | "managed" | "none";
         default: boolean;
     }[];
 };

package/dist/driver-catalog.mjs

@@ -1,8 +1,5 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/runtime-version.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
+var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 var versionCache;
 function workspaceRuntimeVersion() {
   if (versionCache) return versionCache;
@@ -11,12 +8,7 @@ function workspaceRuntimeVersion() {
     versionCache = envVersion;
     return versionCache;
   }
-  try {
-    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
-    return versionCache;
-  } catch {
-  }
-  versionCache = "0.0.0";
+  versionCache = DEFAULT_WORKSPACE_RUNTIME_VERSION;
   return versionCache;
 }
 
@@ -39,7 +31,7 @@ function defaultSandboxImage(version = workspaceRuntimeVersion(), buildId, env =
 }
 
 // src/driver-catalog.ts
-var sandboxDriverIds = ["daytona", "modal", "vercel", "cloudflare", "docker"];
+var sandboxDriverIds = ["daytona", "modal", "vercel", "cloudflare", "box", "docker"];
 var sandboxDriverCatalog = {
   daytona: {
     id: "daytona",
@@ -99,6 +91,18 @@ var sandboxDriverCatalog = {
       secretBrokering: "proxy"
     }
   },
+  box: {
+    id: "box",
+    label: "Box",
+    credentialFields: [{ key: "api_key", label: "API Key", secret: true }],
+    metadata: {
+      driverRunsIn: ["node"],
+      hostStopBehavior: "suspends-host",
+      hostResumeBehavior: "same-host",
+      targetAccess: "relay",
+      secretBrokering: "none"
+    }
+  },
   docker: {
     id: "docker",
     label: "Docker",
@@ -128,6 +132,7 @@ function sandboxDriverAuth(cfg, id, env = process.env) {
   if (id === "modal") return authModal(cfg, env);
   if (id === "vercel") return authVercel(cfg, env);
   if (id === "cloudflare") return authCloudflare(cfg, env);
+  if (id === "box") return authBox(cfg, env);
   return authDocker(cfg, env);
 }
 function hasSandboxDriverAuth(cfg, id, env = process.env) {
@@ -187,6 +192,10 @@ function authCloudflare(cfg, env) {
   const worker_url = clean(cfg?.auth?.cloudflare?.worker_url) ?? clean(env.CLOUDFLARE_SANDBOX_WORKER_URL);
   return api_token && worker_url ? { api_token, worker_url } : void 0;
 }
+function authBox(cfg, env) {
+  const api_key = clean(cfg?.auth?.box?.api_key) ?? clean(env.BOX_API_KEY);
+  return api_key ? { api_key } : void 0;
+}
 function authDocker(cfg, env) {
   if (!dockerSandboxEnabled(env)) return;
   return {

package/dist/drivers/box.d.ts

@@ -0,0 +1,52 @@
+import type { SandboxDriver, SandboxDriverEnsureInput } from "..";
+export type BoxApiBox = {
+    id: string;
+    name?: string;
+    state: string;
+    url?: string | null;
+    ip?: string | null;
+    subdomain?: string | null;
+    createdAt?: string | null;
+};
+export type BoxCommandResult = {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+};
+export type BoxFetch = (input: string, init?: RequestInit) => Promise<Response>;
+export type BoxSandboxDriverOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    image?: string;
+    runtimePort?: number;
+    runtimeCommand?: string;
+    workspaceDir?: string;
+    runner?: string;
+    /** Container name used for the runtime container inside the box. */
+    containerName?: string;
+    /**
+     * Box auto-archives after this many seconds of inactivity. `null` (default)
+     * disables auto-archival so the SandboxManager owns the lifecycle; a number
+     * lets Box reclaim idle boxes to save cost.
+     */
+    ttlSeconds?: number | null;
+    /**
+     * Optional `docker login` before the pull, for a private runtime registry
+     * (the default image lives on ghcr.io). Omit for public images.
+     */
+    registryAuth?: {
+        server: string;
+        username: string;
+        password: string;
+    };
+    env?: (input: SandboxDriverEnsureInput, host: {
+        id: string;
+    }) => Record<string, string> | Promise<Record<string, string>>;
+    provisionTimeoutMs?: number;
+    provisionIntervalMs?: number;
+    healthTimeoutMs?: number;
+    healthIntervalMs?: number;
+    operationTimeoutMs?: number;
+    fetchImpl?: BoxFetch;
+};
+export declare function createBoxSandboxDriver(options: BoxSandboxDriverOptions): SandboxDriver;

package/dist/drivers/box.mjs

@@ -0,0 +1,304 @@
+// 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
+var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
+var versionCache;
+function workspaceRuntimeVersion() {
+  if (versionCache) return versionCache;
+  const envVersion = process.env.WORKSPACE_RUNTIME_VERSION;
+  if (envVersion) {
+    versionCache = envVersion;
+    return versionCache;
+  }
+  versionCache = DEFAULT_WORKSPACE_RUNTIME_VERSION;
+  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/box.ts
+var DEFAULT_BASE_URL = "https://ascii.dev/api/box/v1";
+var DEFAULT_RUNTIME_COMMAND = "/usr/local/bin/workspace-runtime";
+var DEFAULT_WORKSPACE_DIR = "/workspace";
+var DEFAULT_CONTAINER_NAME = "claxedo-runtime";
+var DEFAULT_PROVISION_TIMEOUT_MS = 12e4;
+var DEFAULT_PROVISION_INTERVAL_MS = 2e3;
+var DEFAULT_HEALTH_TIMEOUT_MS = 6e4;
+var DEFAULT_HEALTH_INTERVAL_MS = 1e3;
+var DEFAULT_OPERATION_TIMEOUT_MS = 12e4;
+var READY_STATES = /* @__PURE__ */ new Set(["ready", "idle", "running"]);
+var PENDING_STATES = /* @__PURE__ */ new Set(["init", "provisioning", "provisioned", "cloning"]);
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function clean(input) {
+  const txt = input?.trim();
+  return txt ? txt : void 0;
+}
+function transientDriverError(err) {
+  const shaped = err;
+  if (typeof shaped.status === "number" && shaped.status >= 500) return true;
+  const text = `${shaped.code ?? ""} ${shaped.name ?? ""} ${shaped.message ?? ""}`.toLowerCase();
+  return text.includes("timeout") || text.includes("unavailable") || text.includes("econnreset") || text.includes("network");
+}
+var BoxApiError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "BoxApiError";
+    this.status = status;
+  }
+};
+function createBoxSandboxDriver(options) {
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const image = options.image ?? SANDBOX_IMAGE;
+  const runtimeCommand = options.runtimeCommand ?? DEFAULT_RUNTIME_COMMAND;
+  const workspaceDir = options.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
+  const containerName = options.containerName ?? DEFAULT_CONTAINER_NAME;
+  const ttlSeconds = options.ttlSeconds === void 0 ? null : options.ttlSeconds;
+  const provisionTimeoutMs = options.provisionTimeoutMs ?? DEFAULT_PROVISION_TIMEOUT_MS;
+  const provisionIntervalMs = options.provisionIntervalMs ?? DEFAULT_PROVISION_INTERVAL_MS;
+  const healthTimeoutMs = options.healthTimeoutMs ?? DEFAULT_HEALTH_TIMEOUT_MS;
+  const healthIntervalMs = options.healthIntervalMs ?? DEFAULT_HEALTH_INTERVAL_MS;
+  const operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  async function api(path, init) {
+    let res;
+    try {
+      res = await fetchImpl(`${baseUrl}${path}`, {
+        method: init?.method ?? "GET",
+        headers: {
+          Authorization: `Bearer ${options.apiKey}`,
+          ...init?.body !== void 0 ? { "Content-Type": "application/json" } : {}
+        },
+        ...init?.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
+        signal: AbortSignal.timeout(operationTimeoutMs)
+      });
+    } catch (err) {
+      throw new BoxApiError(err instanceof Error ? err.message : String(err));
+    }
+    const text = await res.text();
+    const body = text ? JSON.parse(text) : {};
+    if (!res.ok || body.ok === false) {
+      const detail = clean(body.error) ?? clean(body.message) ?? res.statusText;
+      throw new BoxApiError(`Box API ${init?.method ?? "GET"} ${path} failed: ${detail}`, res.status);
+    }
+    return body;
+  }
+  function runtimePort(input) {
+    return input.workspaceRuntimePort ?? options.runtimePort ?? DEFAULT_WORKSPACE_RUNTIME_PORT;
+  }
+  function workspaceDirectory(input) {
+    return input.workspaceRoot ?? workspaceDir;
+  }
+  function resolveImage(input) {
+    if (input.bootSource?.kind === "image") return input.bootSource.image;
+    return input.snapshot ?? image;
+  }
+  function bootEnv(input, hostId) {
+    const env = {
+      ...workspaceRuntimeTargetEnv({
+        workspaceId: input.workspaceId,
+        hostId,
+        directory: workspaceDirectory(input),
+        port: runtimePort(input),
+        host: "0.0.0.0"
+      }),
+      ...workspaceRuntimeSourceEnv({ source: input.source }),
+      ...input.env
+    };
+    if (options.runner) env.WORKSPACE_RUNTIME_RUNNER = options.runner;
+    return env;
+  }
+  async function exec(boxId, command) {
+    const body = await api(`/boxes/${boxId}/commands`, {
+      method: "POST",
+      body: { command }
+    });
+    const result = body.result ?? body;
+    return {
+      stdout: typeof result.stdout === "string" ? result.stdout : "",
+      stderr: typeof result.stderr === "string" ? result.stderr : "",
+      exitCode: typeof result.exitCode === "number" ? result.exitCode : 0
+    };
+  }
+  async function execOrThrow(boxId, command, label) {
+    const result = await exec(boxId, command);
+    if ((result.exitCode ?? 0) !== 0) {
+      throw new BoxApiError(`Box ${boxId} ${label} failed (exit ${result.exitCode}): ${clean(result.stderr) ?? clean(result.stdout) ?? ""}`);
+    }
+    return result;
+  }
+  async function waitUntilReady(boxId) {
+    const until = Date.now() + provisionTimeoutMs;
+    for (; ; ) {
+      const { box } = await api(`/boxes/${boxId}`);
+      if (READY_STATES.has(box.state)) return true;
+      if (!PENDING_STATES.has(box.state)) {
+        throw new BoxApiError(`Box ${boxId} entered non-ready state: ${box.state}`);
+      }
+      if (Date.now() >= until) return false;
+      await sleep(provisionIntervalMs);
+    }
+  }
+  function dockerRunScript(input, env) {
+    const port = runtimePort(input);
+    const directory = workspaceDirectory(input);
+    const bootScript = [`mkdir -p ${shell(directory)}`, `cd ${shell(directory)}`, `exec ${runtimeCommand}`].join(" && ");
+    const envArgs = Object.entries(env).map(([key, value]) => `--env ${shell(`${key}=${value}`)}`).join(" ");
+    const login = options.registryAuth ? `echo ${shell(options.registryAuth.password)} | docker login ${shell(options.registryAuth.server)} --username ${shell(options.registryAuth.username)} --password-stdin && ` : "";
+    return `${login}docker rm -f ${containerName} >/dev/null 2>&1 || true; docker run -d --name ${containerName} -p ${port}:${port} ${envArgs} --entrypoint sh ${shell(resolveImage(input))} -lc ${shell(bootScript)}`;
+  }
+  async function waitForHealth(boxId, input) {
+    const port = runtimePort(input);
+    const until = Date.now() + healthTimeoutMs;
+    let last = "workspace runtime not ready";
+    while (Date.now() < until) {
+      const probe = await exec(
+        boxId,
+        `curl -sf -o /dev/null -w '%{http_code}' http://127.0.0.1:${port}/global/health || true`
+      );
+      const code = clean(probe.stdout);
+      if (code === "200") return;
+      last = `health probe returned ${code ?? "no response"}`;
+      await sleep(healthIntervalMs);
+    }
+    throw new BoxApiError(`Box ${boxId} runtime did not become healthy: ${last}`);
+  }
+  async function boot(boxId, input, hostId) {
+    const env = {
+      ...bootEnv(input, hostId),
+      ...await options.env?.(input, { id: hostId })
+    };
+    const port = runtimePort(input);
+    await execOrThrow(boxId, dockerRunScript(input, env), "docker run");
+    await execOrThrow(boxId, `host ${port}`, "host publish");
+    await waitForHealth(boxId, input);
+    const urlResult = await execOrThrow(boxId, `host url ${port}`, "host url");
+    const url = clean(urlResult.stdout?.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).pop());
+    if (!url) throw new BoxApiError(`Box ${boxId} did not return a public URL for port ${port}`);
+    return {
+      workspaceId: input.workspaceId,
+      sandboxId: boxId,
+      url,
+      hostId,
+      driverResourceId: boxId,
+      driver: { id: "box", resourceId: boxId },
+      labels: input.labels
+    };
+  }
+  function assertNetwork(input) {
+    if (input.net && input.net.mode !== "allow-all") {
+      throw new BoxApiError("Box SandboxDriver cannot enforce host-based network policy");
+    }
+  }
+  async function ensureHost(input) {
+    assertNetwork(input);
+    const hostId = input.hostId ?? `box-${input.workspaceId}`;
+    const created = await api("/boxes", {
+      method: "POST",
+      body: { ttlSeconds }
+    }).catch((err) => {
+      if (transientDriverError(err)) return void 0;
+      throw err;
+    });
+    if (!created) return { provisioning: true, retryAfterMs: provisionIntervalMs };
+    const boxId = created.box.id;
+    const ready = await waitUntilReady(boxId);
+    if (!ready) return { provisioning: true, retryAfterMs: provisionIntervalMs };
+    return boot(boxId, input, hostId);
+  }
+  async function resumeHost(input) {
+    const boxId = input.lease.sandboxId;
+    if (!boxId) return ensureHost(input.ensure);
+    assertNetwork(input.ensure);
+    const hostId = input.ensure.hostId ?? input.lease.hostId ?? `box-${input.ensure.workspaceId}`;
+    try {
+      await api(`/boxes/${boxId}/resume`, { method: "POST" });
+      const ready = await waitUntilReady(boxId);
+      if (!ready) return { provisioning: true, retryAfterMs: provisionIntervalMs };
+      return await boot(boxId, input.ensure, hostId);
+    } catch (err) {
+      if (transientDriverError(err)) return { provisioning: true, retryAfterMs: provisionIntervalMs };
+      return ensureHost(input.ensure);
+    }
+  }
+  async function stop(target) {
+    await api(`/boxes/${target.sandboxId}/stop`, { method: "POST" });
+  }
+  async function destroy(target) {
+    await api(`/boxes/${target.sandboxId}`, { method: "DELETE" });
+  }
+  return {
+    id: "box",
+    metadata: {
+      driverRunsIn: ["node"],
+      hostStopBehavior: "suspends-host",
+      hostResumeBehavior: "same-host",
+      targetAccess: "relay",
+      secretBrokering: "none"
+    },
+    ensureHost,
+    resumeHost,
+    async touch() {
+    },
+    suspend: stop,
+    stop,
+    destroy
+  };
+}
+export {
+  createBoxSandboxDriver
+};

package/dist/drivers/cloudflare-egress.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/drivers/cloudflare-egress.ts
 function b64urlEncode(bytes) {
   let binary = "";

package/dist/drivers/cloudflare.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/constants.ts
 var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
 
@@ -25,7 +23,7 @@ function workspaceRuntimeSourceEnv(input) {
 // src/drivers/cloudflare.ts
 var DEFAULT_WORKSPACE_DIR = "/workspace";
 var DEFAULT_RUNTIME_COMMAND = "/usr/local/bin/workspace-runtime";
-var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_TIMEOUT_MS = 45e3;
 function cleanUrl(input) {
   return input.replace(/\/+$/, "");
 }
@@ -94,7 +92,7 @@ function createCloudflareSandboxDriver(options) {
     const sandboxId = sandboxIdFor(input.workspaceId);
     const hostId = sandboxId;
     const egress = egressRegistrations(input);
-    const { status, data } = await call(
+    const response = await call(
       sandboxId,
       "ensure-runtime",
       {
@@ -103,7 +101,12 @@ function createCloudflareSandboxDriver(options) {
         command: runtimeCommand,
         ...egress ? { egress } : {}
       }
-    );
+    ).catch((error) => {
+      if (error instanceof Error && error.name === "TimeoutError") return void 0;
+      throw error;
+    });
+    if (!response) return { provisioning: true, retryAfterMs: 2e3 };
+    const { status, data } = response;
     if (status >= 500) return { provisioning: true, retryAfterMs: 2e3 };
     if (status >= 400 || !data?.url) {
       throw new Error(`Cloudflare ensure-runtime failed (${status}): ${data?.error ?? "no runtime url"}`);

package/dist/drivers/daytona.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/drivers/daytona.ts
 import { Daytona } from "@daytona/sdk";
 

package/dist/drivers/docker.d.ts

@@ -5,6 +5,7 @@ export type DockerCommandResult = {
     stderr?: string | Buffer;
 };
 export type DockerCommandRunner = (args: string[], timeoutMs?: number) => Promise<DockerCommandResult>;
+export type DockerHealthFetch = (input: string, init?: RequestInit) => Promise<Response>;
 export type DockerSandboxDriverOptions = {
     image: string;
     runtimePort?: number;
@@ -17,6 +18,10 @@ export type DockerSandboxDriverOptions = {
     syncLocalAuth?: boolean;
     authHome?: string;
     operationTimeoutMs?: number;
+    waitForHealth?: boolean;
+    healthTimeoutMs?: number;
+    healthIntervalMs?: number;
+    healthFetch?: DockerHealthFetch;
     docker?: DockerCommandRunner;
 };
 export declare function dockerSandboxSyncLocalAuth(env?: SandboxEnv): boolean;

package/dist/drivers/docker.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/drivers/docker.ts
 import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
@@ -38,8 +36,7 @@ var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
 import { Image, DaytonaNotFoundError } from "@daytona/sdk";
 
 // src/runtime-version.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
+var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 var versionCache;
 function workspaceRuntimeVersion() {
   if (versionCache) return versionCache;
@@ -48,12 +45,7 @@ function workspaceRuntimeVersion() {
     versionCache = envVersion;
     return versionCache;
   }
-  try {
-    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
-    return versionCache;
-  } catch {
-  }
-  versionCache = "0.0.0";
+  versionCache = DEFAULT_WORKSPACE_RUNTIME_VERSION;
   return versionCache;
 }
 
@@ -86,6 +78,8 @@ var SNAPSHOT_NAME = process.env.CLAXEDO_SNAPSHOT_NAME || defaultSnapshotName();
 // src/drivers/docker.ts
 var execFileAsync = promisify(execFile);
 var DEFAULT_OPERATION_TIMEOUT_MS = 6e4;
+var DEFAULT_HEALTH_TIMEOUT_MS = 2e4;
+var DEFAULT_HEALTH_INTERVAL_MS = 250;
 var DEFAULT_RUNTIME_COMMAND = "/usr/local/bin/workspace-runtime";
 var DEFAULT_WORKSPACE_DIR = "/workspace";
 var DOCKER_LABEL = "claxedo";
@@ -145,6 +139,9 @@ async function docker(args, timeoutMs = DEFAULT_OPERATION_TIMEOUT_MS) {
     timeout: timeoutMs
   });
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function stageLocalAgentAuth(containerId, input) {
   if (!input.syncLocalAuth) return;
   const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "claxedo-docker-auth-"));
@@ -203,6 +200,9 @@ function createDockerSandboxDriver(options) {
   const runtimeCommand = options.runtimeCommand ?? DEFAULT_RUNTIME_COMMAND;
   const workspaceDir = options.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
   const timeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+  const healthTimeoutMs = options.healthTimeoutMs ?? DEFAULT_HEALTH_TIMEOUT_MS;
+  const healthIntervalMs = options.healthIntervalMs ?? DEFAULT_HEALTH_INTERVAL_MS;
+  const healthFetch = options.healthFetch ?? fetch;
   const syncLocalAuth = options.syncLocalAuth ?? dockerSandboxSyncLocalAuth();
   const authHome = options.authHome ?? dockerSandboxAuthHome();
   function runtimePort(input) {
@@ -236,6 +236,7 @@ function createDockerSandboxDriver(options) {
     const out = await dockerCommand(["port", sandboxId, `${runtimePort(input)}/tcp`], timeoutMs);
     const url = parseDockerPort(String(out.stdout ?? ""));
     if (!url) throw new Error(`Docker container ${sandboxId} does not expose workspace runtime port ${runtimePort(input)}`);
+    if (options.waitForHealth !== false) await waitForHealth(url);
     return {
       workspaceId: input.workspaceId,
       sandboxId,
@@ -249,6 +250,23 @@ function createDockerSandboxDriver(options) {
       labels: input.labels
     };
   }
+  async function waitForHealth(url) {
+    const until = Date.now() + healthTimeoutMs;
+    let error = "workspace runtime not ready";
+    while (Date.now() < until) {
+      try {
+        const res = await healthFetch(`${url}/global/health`, {
+          signal: AbortSignal.timeout(Math.min(2e3, Math.max(1, healthTimeoutMs)))
+        });
+        if (res.ok) return;
+        error = `${res.status} ${res.statusText}`;
+      } catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+      }
+      await sleep(healthIntervalMs);
+    }
+    throw new Error(error);
+  }
   async function ensureHost(input) {
     if (input.net && input.net.mode !== "allow-all") {
       throw new Error("Docker SandboxDriver cannot enforce restricted network policies");

package/dist/drivers/fetch-bridge.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/drivers/fetch-bridge.ts
 function cleanUrl(input) {
   return input.replace(/\/+$/, "");

package/dist/drivers/modal.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/drivers/modal.ts
 import { ModalClient, Probe } from "modal";
 
@@ -34,8 +32,7 @@ var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
 import { Image, DaytonaNotFoundError } from "@daytona/sdk";
 
 // src/runtime-version.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
+var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 var versionCache;
 function workspaceRuntimeVersion() {
   if (versionCache) return versionCache;
@@ -44,12 +41,7 @@ function workspaceRuntimeVersion() {
     versionCache = envVersion;
     return versionCache;
   }
-  try {
-    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
-    return versionCache;
-  } catch {
-  }
-  versionCache = "0.0.0";
+  versionCache = DEFAULT_WORKSPACE_RUNTIME_VERSION;
   return versionCache;
 }
 

package/dist/drivers/vercel.d.ts

@@ -94,6 +94,7 @@ export type VercelSandboxDriverOptions = {
     keepAliveMs?: number;
     sandbox?: VercelSandboxFactoryLike;
     snapshotCache?: Map<string, string>;
+    now?: () => number;
 };
 /**
  * Brokered-secret egress policy: Vercel's firewall injects the credential as

package/dist/drivers/vercel.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/drivers/vercel.ts
 import { Sandbox } from "@vercel/sandbox";
 
@@ -23,8 +21,7 @@ function workspaceRuntimeSourceEnv(input) {
 }
 
 // src/runtime-version.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
+var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 var versionCache;
 function workspaceRuntimeVersion() {
   if (versionCache) return versionCache;
@@ -33,12 +30,7 @@ function workspaceRuntimeVersion() {
     versionCache = envVersion;
     return versionCache;
   }
-  try {
-    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
-    return versionCache;
-  } catch {
-  }
-  versionCache = "0.0.0";
+  versionCache = DEFAULT_WORKSPACE_RUNTIME_VERSION;
   return versionCache;
 }
 
@@ -63,7 +55,9 @@ 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 SNAPSHOT_CACHE_TTL_MS = 60 * 60 * 1e3;
 var snapshotCache = /* @__PURE__ */ new Map();
+var snapshotCacheState = /* @__PURE__ */ new WeakMap();
 function nameFor(workspaceId) {
   return `claxedo-${workspaceId}`;
 }
@@ -106,6 +100,12 @@ function createVercelSandboxDriver(options) {
   const operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
   const keepAliveMs = options.keepAliveMs ?? DEFAULT_KEEP_ALIVE_MS;
   const cache = options.snapshotCache ?? snapshotCache;
+  const now = options.now ?? Date.now;
+  const cacheState = snapshotCacheState.get(cache) ?? {
+    expires: /* @__PURE__ */ new Map(),
+    builds: /* @__PURE__ */ new Map()
+  };
+  snapshotCacheState.set(cache, cacheState);
   function workspaceDirectory(input) {
     return input.workspaceRoot ?? workspaceDir;
   }
@@ -143,56 +143,72 @@ function createVercelSandboxDriver(options) {
     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;
+    const expiresAt = cacheState.expires.get(cacheKey);
+    if (hit && expiresAt === void 0) {
+      cacheState.expires.set(cacheKey, now() + SNAPSHOT_CACHE_TTL_MS);
+      return hit;
+    }
+    if (hit && expiresAt !== void 0 && expiresAt > now()) return hit;
+    const running = cacheState.builds.get(cacheKey);
+    if (running) return running;
+    const build = (async () => {
+      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);
+      cacheState.expires.set(cacheKey, now() + SNAPSHOT_CACHE_TTL_MS);
+      return snapshot.snapshotId;
+    })();
+    cacheState.builds.set(cacheKey, build);
+    try {
+      return await build;
+    } finally {
+      if (cacheState.builds.get(cacheKey) === build) cacheState.builds.delete(cacheKey);
+    }
   }
   async function source(input) {
     if (input.bootSource?.kind === "image") {

package/dist/image.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/image.ts
 import { Image, DaytonaNotFoundError } from "@daytona/sdk";
 
@@ -12,8 +10,7 @@ var WORKSPACE_DIR = "/workspace";
 var RUNTIME_DIR = "/opt/workspace-runtime";
 
 // src/runtime-version.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
+var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 var versionCache;
 function workspaceRuntimeVersion() {
   if (versionCache) return versionCache;
@@ -22,12 +19,7 @@ function workspaceRuntimeVersion() {
     versionCache = envVersion;
     return versionCache;
   }
-  try {
-    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
-    return versionCache;
-  } catch {
-  }
-  versionCache = "0.0.0";
+  versionCache = DEFAULT_WORKSPACE_RUNTIME_VERSION;
   return versionCache;
 }
 

package/dist/index.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/constants.ts
 var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
 

package/dist/lease-policy.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/lease-policy.ts
 var DEFAULT_WORKSPACE_HOST_DECISION_CONFIG = {
   maxRetries: 8,
@@ -36,6 +34,13 @@ var DRIVER_PLACEMENT = {
     canStopExplicitly: false,
     hasHealthProbe: true
   },
+  box: {
+    canPauseAndRestartSameResource: true,
+    canCreateFilesystemSnapshot: false,
+    canStartFromPreparedImage: true,
+    canStopExplicitly: true,
+    hasHealthProbe: true
+  },
   docker: {
     canPauseAndRestartSameResource: true,
     canCreateFilesystemSnapshot: false,

package/dist/lease-types.mjs

@@ -1 +0,0 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);

package/dist/runtime-env.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/runtime-env.ts
 function workspaceRuntimeTargetEnv(input) {
   return {

package/dist/runtime-version.mjs

@@ -1,8 +1,5 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/runtime-version.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
+var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 var versionCache;
 function workspaceRuntimeVersion() {
   if (versionCache) return versionCache;
@@ -11,12 +8,7 @@ function workspaceRuntimeVersion() {
     versionCache = envVersion;
     return versionCache;
   }
-  try {
-    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
-    return versionCache;
-  } catch {
-  }
-  versionCache = "0.0.0";
+  versionCache = DEFAULT_WORKSPACE_RUNTIME_VERSION;
   return versionCache;
 }
 export {

package/dist/service-url-exposure.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/runtime-env.ts
 function workspaceRuntimeServiceExposureEnv(input) {
   return {

package/dist/stores/memory.mjs

@@ -1,5 +1,3 @@
-import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
-
 // src/index.ts
 function applySandboxLeasePatch(current, patch, updatedAt) {
   return {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@claxedo/sandbox-manager",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "type": "module",
-  "description": "Sandbox lifecycle manager with epoch-based leases and pluggable drivers for Daytona, Modal, Vercel Sandbox, Cloudflare, and Docker",
+  "description": "Sandbox lifecycle manager with epoch-based leases and pluggable drivers for Daytona, Modal, Vercel Sandbox, Cloudflare, Box, and Docker",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -14,6 +14,10 @@
     "sandbox",
     "daytona",
     "modal",
+    "vercel",
+    "cloudflare",
+    "docker",
+    "box",
     "agents"
   ],
   "main": "./dist/index.mjs",
@@ -54,6 +58,13 @@
       "import": "./dist/driver-catalog.mjs",
       "default": "./dist/driver-catalog.mjs"
     },
+    "./drivers/box": {
+      "types": "./dist/drivers/box.d.ts",
+      "bun": "./dist/drivers/box.mjs",
+      "development": "./dist/drivers/box.mjs",
+      "import": "./dist/drivers/box.mjs",
+      "default": "./dist/drivers/box.mjs"
+    },
     "./drivers/cloudflare": {
       "types": "./dist/drivers/cloudflare.d.ts",
       "bun": "./dist/drivers/cloudflare.mjs",
@@ -155,7 +166,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@claxedo/workspace-runtime": "0.5.1",
     "@daytona/sdk": "0.192.0",
     "@vercel/sandbox": "1.10.2",
     "modal": "0.7.5"
@@ -172,7 +182,7 @@
     "@types/node": "24.12.2",
     "esbuild": "0.25.12",
     "tsx": "4.22.3",
-    "typescript": "5.8.2",
+    "typescript": "catalog:",
     "vitest": "2.1.9"
   }
 }