@claxedo/sandbox-manager 0.6.0 → 0.9.0

package/dist/driver-catalog.mjs

@@ -1,15 +1,53 @@
+// src/hosted-network-policy.ts
+var SANDBOX_MODEL_PROVIDER_HOSTS = [
+  "api.anthropic.com",
+  "api.openai.com",
+  "generativelanguage.googleapis.com",
+  "openrouter.ai",
+  // Model catalog + engine config, fetched on runner startup.
+  "models.dev",
+  "opencode.ai"
+];
+var SANDBOX_PACKAGE_REGISTRY_HOSTS = [
+  "registry.npmjs.org",
+  "nodejs.org",
+  "pypi.org",
+  "files.pythonhosted.org",
+  "crates.io",
+  "static.crates.io",
+  "index.crates.io",
+  "proxy.golang.org",
+  "sum.golang.org"
+];
+var SANDBOX_BASELINE_EGRESS_HOSTS = [
+  ...SANDBOX_MODEL_PROVIDER_HOSTS,
+  ...SANDBOX_PACKAGE_REGISTRY_HOSTS
+];
+
+// src/index.ts
+function validateSandboxPersistenceCapabilities(input) {
+  if (input.resume === "replacement-restore" && input.capture === "none") {
+    return { valid: false, reason: "replacement restore requires a capture source" };
+  }
+  if (input.capture === "none" && input.captureSource !== "not-applicable") {
+    return { valid: false, reason: "capture source behavior requires capture support" };
+  }
+  if (input.capture !== "none" && input.captureSource === "not-applicable") {
+    return { valid: false, reason: "capture support requires source behavior" };
+  }
+  if (input.capture === "same-resource" && input.restoreMount !== "same-resource") {
+    return { valid: false, reason: "same-resource capture requires same-resource restore" };
+  }
+  if (input.restoreMount === "copy-on-write" && input.capture !== "directories") {
+    return { valid: false, reason: "copy-on-write restore requires directory capture" };
+  }
+  return { valid: true };
+}
+
 // 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;
+  return process.env.WORKSPACE_RUNTIME_VERSION || DEFAULT_WORKSPACE_RUNTIME_VERSION;
 }
 
 // src/image-name.ts
@@ -30,186 +68,290 @@ function defaultSandboxImage(version = workspaceRuntimeVersion(), buildId, env =
   return `${sandboxImageRepository(env)}:workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}-v${SNAPSHOT_SCHEMA_VERSION}`;
 }
 
+// ../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 sandboxDriverIds = ["daytona", "modal", "vercel", "cloudflare", "box", "docker"];
 var sandboxDriverCatalog = {
+  exe: {
+    id: "exe",
+    label: sandboxDriverLabels.exe,
+    credentialFields: sandboxDriverCredentialFields.exe,
+    metadata: {
+      driverRunsIn: ["worker", "node"],
+      hostStopBehavior: "not-supported",
+      hostResumeBehavior: "same-host",
+      targetAccess: "relay",
+      secretBrokering: "none",
+      egressControl: "none",
+      persistence: {
+        resume: "same-sandbox",
+        capture: "none",
+        clone: true,
+        captureSource: "not-applicable",
+        retention: "provider-managed",
+        restoreMount: "same-resource"
+      }
+    }
+  },
   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"
+      secretBrokering: "native",
+      // The driver translates names to domainAllowList, or addresses to networkAllowList.
+      egressControl: "hosts-and-cidrs",
+      persistence: {
+        resume: "same-sandbox",
+        capture: "filesystem",
+        clone: false,
+        captureSource: "preserved",
+        retention: "provider-managed",
+        restoreMount: "new-resource"
+      }
     }
   },
   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"
+      secretBrokering: "none",
+      // The driver does not install Modal's domain allowlist or alpha sidecar.
+      egressControl: "none",
+      persistence: {
+        resume: "replacement-restore",
+        capture: "filesystem",
+        clone: false,
+        captureSource: "preserved",
+        retention: "provider-managed",
+        restoreMount: "new-resource"
+      }
     }
   },
   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"
+      secretBrokering: "native",
+      // The driver translates hosts only; the SDK's subnet rules are not wired to net.cidrs.
+      egressControl: "hosts",
+      persistence: {
+        resume: "replacement-restore",
+        capture: "filesystem",
+        clone: false,
+        captureSource: "stopped",
+        retention: "explicit",
+        restoreMount: "new-resource"
+      }
     }
   },
   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"
+      secretBrokering: "native",
+      // Credential handlers do not restrict unrelated destinations.
+      egressControl: "none",
+      persistence: {
+        resume: "replacement-restore",
+        capture: "directories",
+        clone: false,
+        captureSource: "preserved",
+        retention: "provider-managed",
+        restoreMount: "copy-on-write"
+      }
     }
   },
   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",
       hostResumeBehavior: "same-host",
       targetAccess: "relay",
-      secretBrokering: "none"
+      secretBrokering: "none",
+      egressControl: "none",
+      persistence: {
+        resume: "same-sandbox",
+        capture: "none",
+        clone: false,
+        captureSource: "not-applicable",
+        retention: "provider-managed",
+        restoreMount: "same-resource"
+      }
     }
   },
   docker: {
     id: "docker",
-    label: "Docker",
-    credentialFields: [{ key: "image", label: "Image" }],
+    label: sandboxDriverLabels.docker,
+    credentialFields: sandboxDriverCredentialFields.docker,
     metadata: {
       driverRunsIn: ["local"],
       hostStopBehavior: "terminates-host",
       hostResumeBehavior: "same-host",
       targetAccess: "loopback",
-      secretBrokering: "none"
+      secretBrokering: "none",
+      egressControl: "none",
+      persistence: {
+        resume: "replacement-restore",
+        capture: "same-resource",
+        clone: false,
+        captureSource: "preserved",
+        retention: "provider-managed",
+        restoreMount: "same-resource"
+      }
     }
   }
 };
-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 === "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 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
 };