@claxedo/sandbox-manager 0.7.0 → 0.9.0

package/README.md

@@ -11,7 +11,7 @@ The package owns the generic pieces:
 - `SandboxDriver`
 - provider drivers for Cloudflare, Daytona, Docker, fetch bridge, Modal, and Vercel
 
-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`.
+It deliberately does not own Claxedo product auth, billing, app storage schema, routes, or relay tokens. Applications provide those through adapters and call `createSandboxManager`.
 
 ## Install
 
@@ -59,8 +59,8 @@ Swap `createDockerSandboxDriver` for `createDaytonaSandboxDriver`,
 `@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.
+for a persisted `SandboxLeaseStore` implementation (e.g. backed by SQLite) to
+survive process restarts.
 
 ## Credentials & secrets
 
@@ -100,25 +100,21 @@ Per-provider mechanism (from each provider's official docs):
 | --- | --- | --- |
 | Daytona | `native` | `daytona.secret.create({name, value, hosts})`; the sandbox env holds an opaque `dtn_secret_…` placeholder and an egress proxy substitutes the real value only for allowlisted hosts ([docs](https://www.daytona.io/docs/en/secrets/)). |
 | Vercel | `native` | Firewall header-transform (`updateNetworkPolicy`): the value is spliced onto egress to the allowlisted hosts as `header`, so the sandbox makes an unauthenticated request ([docs](https://vercel.com/docs/sandbox/concepts/firewall)). `updateNetworkPolicy` replaces the whole policy, so the driver sends the **union** of the create-time allow-list and the brokered hosts — attaching a credential must not revoke egress the caller was already granted (a mid-run `npm install` would start failing), nor widen it to a brokered host the create-time policy never approved. |
-| Cloudflare | `proxy` | Implemented via the official [Worker-proxy pattern](https://developers.cloudflare.com/sandbox/guides/proxy-requests/): the driver sends the value to the sandbox Worker (API-token-gated, never into the container); the Worker stores it in KV, mints a short-lived per-sandbox JWT, and sets `CLAXEDO_EGRESS_PROXY_URL`/`CLAXEDO_EGRESS_TOKEN`/`CLAXEDO_EGRESS_HOSTS` in the container. The sandbox routes brokered-host egress through the Worker, which validates the JWT and injects the credential as `header` — the raw value never enters the sandbox. The reusable core is `@claxedo/sandbox-manager/drivers/cloudflare-egress` (mint/verify + `handleEgressRequest`). |
+| Cloudflare | `native` | The driver sends named registrations to the API-token-gated Worker. KV holds the values outside the container; native HTTPS outbound handlers replace named placeholders in registered headers. Each request reads KV, so there is no expiring container JWT. KV propagation delay still applies to rotation and withdrawal. |
 | Modal | `none` | Modal [Secrets](https://modal.com/docs/guide/secrets) are an encrypted by-reference store, but exposed as **readable env vars** inside the sandbox — they cannot satisfy the never-readable contract. |
 | Docker, fetch | `none` | Plaintext env only. |
 
 **Fail-closed contract.** A brokered secret is never silently downgraded to
-readable env. `native` (transparent egress) and `proxy` (Cloudflare Worker
-egress proxy) both keep the value out of the sandbox and provision normally;
-only a `none` driver makes the manager refuse to provision (`status:
+readable env. Only `native` keeps the value out of the sandbox and provisions
+normally; a `none` driver makes the manager refuse to provision (`status:
 "unavailable", error: "secret_brokering_unsupported"`) rather than expose or
 drop the credential. Brokered secret values are also never written to labels,
 never logged, and never captured in a driver snapshot.
 
-> Consumption note: `native` brokering is transparent (existing code reaches
-> the real host and the platform injects). Cloudflare `proxy` is NOT
-> transparent — the sandbox must route brokered-host requests through
-> `CLAXEDO_EGRESS_PROXY_URL` (with the `CLAXEDO_EGRESS_TOKEN` bearer and the
-> `x-claxedo-egress-target` header). Modal stays `none`; its secret store
-> improves storage hygiene for *readable* credentials but does not hide them
-> from the sandbox.
+> Native brokering keeps the original upstream URL. Cloudflare accepts its
+> named placeholder as the complete credential header, or with a Bearer prefix
+> for Authorization API-key clients. Modal remains `none`: its encrypted store
+> exposes credentials as readable environment variables inside the sandbox.
 
 ## Egress containment
 

package/dist/driver-catalog.d.ts

@@ -1,42 +1,11 @@
 import { validateSandboxPersistenceCapabilities, type SandboxDriverMetadata } from "./index";
-export declare const sandboxDriverIds: readonly ["exe", "daytona", "modal", "vercel", "cloudflare", "box", "docker"];
-export type SandboxDriverID = (typeof sandboxDriverIds)[number];
-export type SandboxDriverAuth = {
-    exe?: {
-        api_token?: string;
-    };
-    daytona?: {
-        api_key?: string;
-    };
-    modal?: {
-        token_id?: string;
-        token_secret?: string;
-    };
-    vercel?: {
-        access_token?: string;
-        team_id?: string;
-        project_id?: string;
-    };
-    cloudflare?: {
-        api_token?: string;
-        worker_url?: string;
-    };
-    box?: {
-        api_key?: string;
-    };
-    docker?: {
-        image?: string;
-    };
-};
-export type SandboxDriverConfig = {
-    default_driver?: SandboxDriverID;
-    auth?: SandboxDriverAuth;
-};
+import { defaultSandboxDriverID, listSandboxDrivers, sandboxDriverId, type SandboxDriverAuth, type SandboxDriverConfig, type SandboxDriverEnv, type SandboxDriverID } from "@claxedo/sandbox-contract";
+export { defaultSandboxDriverID, listSandboxDrivers, sandboxDriverId };
 export type SandboxDriverCatalogEntry = {
     id: SandboxDriverID;
     label: string;
     metadata: SandboxDriverMetadata;
-    credentialFields: Array<{
+    credentialFields: ReadonlyArray<{
         key: string;
         label: string;
         secret?: boolean;
@@ -44,25 +13,6 @@ export type SandboxDriverCatalogEntry = {
 };
 export { validateSandboxPersistenceCapabilities };
 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): "box" | "cloudflare" | "daytona" | "docker" | "exe" | "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: "box" | "cloudflare" | "daytona" | "docker" | "exe" | "modal" | "vercel";
-    drivers: {
-        id: "box" | "cloudflare" | "daytona" | "docker" | "exe" | "modal" | "vercel";
-        label: string;
-        fields: {
-            key: string;
-            label: string;
-            secret?: boolean;
-        }[];
-        configured: boolean;
-        source: "config" | "managed" | "none";
-        default: boolean;
-    }[];
-};
-type SandboxDriverEnv = Record<string, string | undefined>;

package/dist/driver-catalog.mjs

@@ -68,13 +68,120 @@ function defaultSandboxImage(version = workspaceRuntimeVersion(), buildId, env =
   return `${sandboxImageRepository(env)}:workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}-v${SNAPSHOT_SCHEMA_VERSION}`;
 }
 
-// src/driver-catalog.ts
+// ../sandbox-contract/dist/index.mjs
+function isString(value) {
+  return typeof value === "string";
+}
+function trimToUndefined(value) {
+  if (!isString(value))
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
 var sandboxDriverIds = ["exe", "daytona", "modal", "vercel", "cloudflare", "box", "docker"];
+var sandboxDriverCredentialFields = {
+  exe: [{ key: "api_token", label: "API Token", secret: true }],
+  daytona: [{ key: "api_key", label: "API Key", secret: true }],
+  modal: [
+    { key: "token_id", label: "Token ID", secret: true },
+    { key: "token_secret", label: "Token Secret", secret: true }
+  ],
+  vercel: [
+    { key: "access_token", label: "Access Token", secret: true },
+    { key: "team_id", label: "Team ID" },
+    { key: "project_id", label: "Project ID" }
+  ],
+  cloudflare: [
+    { key: "api_token", label: "API Token", secret: true },
+    { key: "worker_url", label: "Worker URL" }
+  ],
+  box: [{ key: "api_key", label: "API Key", secret: true }],
+  docker: [{ key: "image", label: "Image" }]
+};
+var sandboxDriverLabels = {
+  exe: "exe.dev",
+  daytona: "Daytona",
+  modal: "Modal",
+  vercel: "Vercel",
+  cloudflare: "Cloudflare",
+  box: "Box",
+  docker: "Docker"
+};
+function isSandboxDriverID(input) {
+  return !!input && sandboxDriverIds.includes(input);
+}
+function enabled(input) {
+  return ["1", "true", "yes", "on"].includes(input?.trim().toLowerCase() ?? "");
+}
+function dockerSandboxDriverEnabled(env = process.env) {
+  return enabled(env.CLAXEDO_ENABLE_DOCKER_SANDBOX) || enabled(env.CLAXEDO_DEV_DOCKER_SANDBOX);
+}
+function sandboxDriverAuthValues(cfg, id, env = process.env) {
+  if (id === "daytona") {
+    const api_key = trimToUndefined(cfg?.auth?.daytona?.api_key);
+    return api_key ? { api_key } : void 0;
+  }
+  if (id === "exe") {
+    const api_token = trimToUndefined(cfg?.auth?.exe?.api_token) ?? trimToUndefined(env.EXE_DEV_API_TOKEN);
+    return api_token ? { api_token } : void 0;
+  }
+  if (id === "modal") {
+    const token_id = trimToUndefined(cfg?.auth?.modal?.token_id) ?? trimToUndefined(env.MODAL_TOKEN_ID);
+    const token_secret = trimToUndefined(cfg?.auth?.modal?.token_secret) ?? trimToUndefined(env.MODAL_TOKEN_SECRET);
+    return token_id && token_secret ? { token_id, token_secret } : void 0;
+  }
+  if (id === "vercel") {
+    const access_token = trimToUndefined(cfg?.auth?.vercel?.access_token) ?? trimToUndefined(env.VERCEL_TOKEN);
+    const team_id = trimToUndefined(cfg?.auth?.vercel?.team_id) ?? trimToUndefined(env.VERCEL_TEAM_ID);
+    const project_id = trimToUndefined(cfg?.auth?.vercel?.project_id) ?? trimToUndefined(env.VERCEL_PROJECT_ID);
+    return access_token && team_id && project_id ? { access_token, team_id, project_id } : void 0;
+  }
+  if (id === "cloudflare") {
+    const api_token = trimToUndefined(cfg?.auth?.cloudflare?.api_token) ?? trimToUndefined(env.CLOUDFLARE_API_TOKEN);
+    const worker_url = trimToUndefined(cfg?.auth?.cloudflare?.worker_url) ?? trimToUndefined(env.CLOUDFLARE_SANDBOX_WORKER_URL);
+    return api_token && worker_url ? { api_token, worker_url } : void 0;
+  }
+  if (id === "box") {
+    const api_key = trimToUndefined(cfg?.auth?.box?.api_key) ?? trimToUndefined(env.BOX_API_KEY);
+    return api_key ? { api_key } : void 0;
+  }
+  if (!dockerSandboxDriverEnabled(env)) return void 0;
+  const image = trimToUndefined(cfg?.auth?.docker?.image) ?? trimToUndefined(env.CLAXEDO_DOCKER_SANDBOX_IMAGE) ?? trimToUndefined(env.CLAXEDO_SANDBOX_IMAGE);
+  return image ? { image } : {};
+}
+function sandboxDriverId(input, cfg, env = process.env) {
+  if (!isSandboxDriverID(input)) return void 0;
+  if (input === "docker" && !sandboxDriverAuthValues(cfg, input, env)) return void 0;
+  return input;
+}
+function defaultSandboxDriverID(cfg, env = process.env) {
+  return sandboxDriverId(cfg?.default_driver, cfg, env) ?? (enabled(env.CLAXEDO_DOCKER_SANDBOX_DEFAULT) && sandboxDriverAuthValues(cfg, "docker", env) ? "docker" : "daytona");
+}
+function listSandboxDrivers(cfg, env = process.env, managedDriverIds = /* @__PURE__ */ new Set()) {
+  const defaultDriver = defaultSandboxDriverID(cfg, env);
+  return {
+    default_driver: defaultDriver,
+    drivers: sandboxDriverIds.filter((id) => id !== "docker" || !!sandboxDriverAuthValues(cfg, "docker", env)).map((id) => {
+      const configuredFromConfigOrEnv = !!sandboxDriverAuthValues(cfg, id, env);
+      const configured = id === "docker" ? configuredFromConfigOrEnv : configuredFromConfigOrEnv || managedDriverIds.has(id);
+      return {
+        id,
+        label: sandboxDriverLabels[id],
+        fields: sandboxDriverCredentialFields[id],
+        configured,
+        source: configuredFromConfigOrEnv ? "config" : configured ? "managed" : "none",
+        default: id === defaultDriver
+      };
+    })
+  };
+}
+
+// src/driver-catalog.ts
 var sandboxDriverCatalog = {
   exe: {
     id: "exe",
-    label: "exe.dev",
-    credentialFields: [{ key: "api_token", label: "API Token", secret: true }],
+    label: sandboxDriverLabels.exe,
+    credentialFields: sandboxDriverCredentialFields.exe,
     metadata: {
       driverRunsIn: ["worker", "node"],
       hostStopBehavior: "not-supported",
@@ -94,17 +201,15 @@ var sandboxDriverCatalog = {
   },
   daytona: {
     id: "daytona",
-    label: "Daytona",
-    credentialFields: [{ key: "api_key", label: "API Key", secret: true }],
+    label: sandboxDriverLabels.daytona,
+    credentialFields: sandboxDriverCredentialFields.daytona,
     metadata: {
       driverRunsIn: ["worker", "node"],
       hostStopBehavior: "suspends-host",
       hostResumeBehavior: "same-host",
       targetAccess: "relay",
       secretBrokering: "native",
-      // Daytona is the only driver that can filter egress by NAME as well as
-      // by address: `domainAllowList` (names) alongside `networkAllowList`
-      // (CIDRs), with `networkBlockAll` as the deny-all floor.
+      // The driver translates names to domainAllowList, or addresses to networkAllowList.
       egressControl: "hosts-and-cidrs",
       persistence: {
         resume: "same-sandbox",
@@ -118,20 +223,15 @@ var sandboxDriverCatalog = {
   },
   modal: {
     id: "modal",
-    label: "Modal",
-    credentialFields: [
-      { key: "token_id", label: "Token ID", secret: true },
-      { key: "token_secret", label: "Token Secret", secret: true }
-    ],
+    label: sandboxDriverLabels.modal,
+    credentialFields: sandboxDriverCredentialFields.modal,
     metadata: {
       driverRunsIn: ["node"],
       hostStopBehavior: "terminates-host",
       hostResumeBehavior: "replacement-host",
       targetAccess: "relay",
       secretBrokering: "none",
-      // Modal can cut the network entirely (`blockNetwork`) but cannot express
-      // an allowlist, and its driver throws on a host policy. A blackout is
-      // not containment for a workspace that has to clone and reach a model.
+      // The driver does not install Modal's domain allowlist or alpha sidecar.
       egressControl: "none",
       persistence: {
         resume: "replacement-restore",
@@ -145,20 +245,15 @@ var sandboxDriverCatalog = {
   },
   vercel: {
     id: "vercel",
-    label: "Vercel",
-    credentialFields: [
-      { key: "access_token", label: "Access Token", secret: true },
-      { key: "team_id", label: "Team ID" },
-      { key: "project_id", label: "Project ID" }
-    ],
+    label: sandboxDriverLabels.vercel,
+    credentialFields: sandboxDriverCredentialFields.vercel,
     metadata: {
       driverRunsIn: ["node"],
       hostStopBehavior: "terminates-host",
       hostResumeBehavior: "replacement-host",
       targetAccess: "relay",
       secretBrokering: "native",
-      // Vercel's sandbox firewall takes a hostname allow list (or "deny-all"),
-      // never CIDRs.
+      // The driver translates hosts only; the SDK's subnet rules are not wired to net.cidrs.
       egressControl: "hosts",
       persistence: {
         resume: "replacement-restore",
@@ -172,23 +267,15 @@ var sandboxDriverCatalog = {
   },
   cloudflare: {
     id: "cloudflare",
-    label: "Cloudflare",
-    credentialFields: [
-      { key: "api_token", label: "API Token", secret: true },
-      { key: "worker_url", label: "Worker URL" }
-    ],
+    label: sandboxDriverLabels.cloudflare,
+    credentialFields: sandboxDriverCredentialFields.cloudflare,
     metadata: {
       driverRunsIn: ["worker"],
       hostStopBehavior: "not-supported",
       hostResumeBehavior: "same-host",
       targetAccess: "relay",
-      secretBrokering: "proxy",
-      // The Cloudflare Sandbox Worker exposes no egress filter: its broker
-      // (drivers/cloudflare-egress.ts) is an OPT-IN proxy the sandbox chooses
-      // to route brokered-credential requests through, not a boundary. The
-      // driver therefore drops `net` entirely — which is exactly why this
-      // must be declared, so the manager refuses instead of provisioning a
-      // sandbox the caller believes is contained.
+      secretBrokering: "native",
+      // Credential handlers do not restrict unrelated destinations.
       egressControl: "none",
       persistence: {
         resume: "replacement-restore",
@@ -202,8 +289,8 @@ var sandboxDriverCatalog = {
   },
   box: {
     id: "box",
-    label: "Box",
-    credentialFields: [{ key: "api_key", label: "API Key", secret: true }],
+    label: sandboxDriverLabels.box,
+    credentialFields: sandboxDriverCredentialFields.box,
     metadata: {
       driverRunsIn: ["node"],
       hostStopBehavior: "suspends-host",
@@ -223,8 +310,8 @@ var sandboxDriverCatalog = {
   },
   docker: {
     id: "docker",
-    label: "Docker",
-    credentialFields: [{ key: "image", label: "Image" }],
+    label: sandboxDriverLabels.docker,
+    credentialFields: sandboxDriverCredentialFields.docker,
     metadata: {
       driverRunsIn: ["local"],
       hostStopBehavior: "terminates-host",
@@ -243,106 +330,28 @@ var sandboxDriverCatalog = {
     }
   }
 };
-function isSandboxDriverID(input) {
-  return !!input && sandboxDriverIds.includes(input);
-}
-function sandboxDriverId(input, cfg, env = process.env) {
-  if (!isSandboxDriverID(input)) return;
-  if (input === "docker" && !sandboxDriverAuth(cfg, input, env)) return;
-  return input;
-}
-function defaultSandboxDriverID(cfg, env = process.env) {
-  return sandboxDriverId(cfg?.default_driver, cfg, env) ?? (dockerSandboxDefault(env) && sandboxDriverAuth(cfg, "docker", env) ? "docker" : "daytona");
-}
 function sandboxDriverAuth(cfg, id, env = process.env) {
-  if (id === "daytona") return authDaytona(cfg);
-  if (id === "exe") return authExe(cfg, 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);
+  if (id === "docker") {
+    const configured = sandboxDriverAuthValues(cfg, "docker", env);
+    if (!configured) return void 0;
+    const image = configured.image ?? defaultSandboxImage(workspaceRuntimeVersion(), void 0, env);
+    return { image };
+  }
+  return sandboxDriverAuthValues(cfg, id, env);
 }
 function hasSandboxDriverAuth(cfg, id, env = process.env) {
   return !!sandboxDriverAuth(cfg, id, env);
 }
-function dockerSandboxDriverEnabled(env = process.env) {
-  return dockerSandboxEnabled(env);
-}
-function listSandboxDrivers(cfg, env = process.env, managedDriverIds = /* @__PURE__ */ new Set()) {
-  const def = defaultSandboxDriverID(cfg, env);
-  return {
-    default_driver: def,
-    drivers: sandboxDriverIds.filter((id) => id !== "docker" || !!sandboxDriverAuth(cfg, "docker", env)).map((id) => {
-      const configuredFromConfigOrEnv = !!sandboxDriverAuth(cfg, id, env);
-      const configured = id === "docker" ? configuredFromConfigOrEnv : configuredFromConfigOrEnv || managedDriverIds.has(id);
-      return {
-        id,
-        label: sandboxDriverCatalog[id].label,
-        fields: sandboxDriverCatalog[id].credentialFields,
-        configured,
-        source: configuredFromConfigOrEnv ? "config" : configured ? "managed" : "none",
-        default: id === def
-      };
-    })
-  };
-}
-function clean(input) {
-  const txt = input?.trim();
-  return txt ? txt : void 0;
-}
-function enabled(input) {
-  return ["1", "true", "yes", "on"].includes(input?.trim().toLowerCase() ?? "");
-}
-function dockerSandboxEnabled(env) {
-  return enabled(env.CLAXEDO_ENABLE_DOCKER_SANDBOX) || enabled(env.CLAXEDO_DEV_DOCKER_SANDBOX);
-}
-function dockerSandboxDefault(env) {
-  return enabled(env.CLAXEDO_DOCKER_SANDBOX_DEFAULT);
-}
-function authDaytona(cfg) {
-  const api_key = clean(cfg?.auth?.daytona?.api_key);
-  return api_key ? { api_key } : void 0;
-}
-function authExe(cfg, env) {
-  const api_token = clean(cfg?.auth?.exe?.api_token) ?? clean(env.EXE_DEV_API_TOKEN);
-  return api_token ? { api_token } : void 0;
-}
-function authModal(cfg, env) {
-  const token_id = clean(cfg?.auth?.modal?.token_id) ?? clean(env.MODAL_TOKEN_ID);
-  const token_secret = clean(cfg?.auth?.modal?.token_secret) ?? clean(env.MODAL_TOKEN_SECRET);
-  return token_id && token_secret ? { token_id, token_secret } : void 0;
-}
-function authVercel(cfg, env) {
-  const access_token = clean(cfg?.auth?.vercel?.access_token) ?? clean(env.VERCEL_TOKEN);
-  const team_id = clean(cfg?.auth?.vercel?.team_id) ?? clean(env.VERCEL_TEAM_ID);
-  const project_id = clean(cfg?.auth?.vercel?.project_id) ?? clean(env.VERCEL_PROJECT_ID);
-  return access_token && team_id && project_id ? { access_token, team_id, project_id } : void 0;
-}
-function authCloudflare(cfg, env) {
-  const api_token = clean(cfg?.auth?.cloudflare?.api_token) ?? clean(env.CLOUDFLARE_API_TOKEN);
-  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 {
-    image: clean(cfg?.auth?.docker?.image) ?? clean(env.CLAXEDO_DOCKER_SANDBOX_IMAGE) ?? clean(env.CLAXEDO_SANDBOX_IMAGE) ?? defaultSandboxImage(workspaceRuntimeVersion(), void 0, env)
-  };
+function dockerSandboxDriverEnabled2(env = process.env) {
+  return dockerSandboxDriverEnabled(env);
 }
 export {
   defaultSandboxDriverID,
-  dockerSandboxDriverEnabled,
+  dockerSandboxDriverEnabled2 as dockerSandboxDriverEnabled,
   hasSandboxDriverAuth,
-  isSandboxDriverID,
   listSandboxDrivers,
   sandboxDriverAuth,
   sandboxDriverCatalog,
   sandboxDriverId,
-  sandboxDriverIds,
   validateSandboxPersistenceCapabilities
 };