@claxedo/sandbox-manager 0.10.2 → 0.10.4

package/dist/drivers/agent37.mjs

@@ -0,0 +1,886 @@
+// ../claxedo-helpers/dist/index.mjs
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// ../claxedo-helpers/dist/deadline.mjs
+async function withDeadlineSignal(timeoutMs, work, parent) {
+  const deadline = new AbortController();
+  const timer = setTimeout(() => deadline.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
+  try {
+    return await work(parent ? AbortSignal.any([parent, deadline.signal]) : deadline.signal);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/constants.ts
+var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
+
+// src/contract.ts
+var SANDBOX_IMAGE_LABEL = "image";
+
+// src/command.ts
+function shell(input) {
+  return `'${input.replace(/'/g, `'"'"'`)}'`;
+}
+function envFile(input) {
+  return Object.entries(input).map(([key, value]) => {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new Error(`environment variable ${JSON.stringify(key)} cannot be exported through an env file`);
+    }
+    return `export ${key}=${shell(value)}`;
+  }).join("\n") + "\n";
+}
+
+// src/driver-billing.ts
+var HOUR_SECONDS = 3600;
+var boatBilling = {
+  source: { url: "https://docs.boat.dev/pricing", readOn: "2026-10-12" },
+  meter: "Boat bills machine time per second while a sandbox runs, at an hourly rate per size; a stopped sandbox costs nothing.",
+  rates: {
+    small: { size: "small", vcpu: 2, memoryGb: 4, usdPerHour: 0.018 },
+    default: { size: "default", vcpu: 4, memoryGb: 8, usdPerHour: 0.036 },
+    large: { size: "large", vcpu: 8, memoryGb: 16, usdPerHour: 0.072 }
+  }
+};
+var AGENT37_USD_PER_MONTH = { vcpu: 0.8, memoryGb: 0.7, diskGb: 0.09 };
+var AGENT37_MONTH_HOURS = 730;
+var agent37MachineShapes = {
+  small: { cpu: 2, memory: 4, disk: 10 },
+  default: { cpu: 4, memory: 8, disk: 20 },
+  large: { cpu: 4, memory: 16, disk: 40 }
+};
+function agent37Rate(shape) {
+  const usdPerMonth = shape.cpu * AGENT37_USD_PER_MONTH.vcpu + shape.memory * AGENT37_USD_PER_MONTH.memoryGb + shape.disk * AGENT37_USD_PER_MONTH.diskGb;
+  return { size: `${shape.cpu} vCPU / ${shape.memory} GB`, vcpu: shape.cpu, memoryGb: shape.memory, usdPerHour: usdPerMonth / AGENT37_MONTH_HOURS };
+}
+var agent37Billing = {
+  source: { url: "https://www.agent37.com/docs/agents-api/billing", readOn: "2026-11-11" },
+  meter: "Agent37 meters an instance per minute at a monthly rate over 730 hours: $0.80 per vCPU, $0.70 per GB of memory and $0.09 per GB of disk while it runs, and the disk alone while it is stopped.",
+  rates: {
+    small: agent37Rate(agent37MachineShapes.small),
+    default: agent37Rate(agent37MachineShapes.default),
+    large: agent37Rate(agent37MachineShapes.large)
+  },
+  excludes: `the disk of a stopped instance, billed at $${AGENT37_USD_PER_MONTH.diskGb} per GB a month until the instance is deleted`
+};
+var CLOUDFLARE_USD_PER_GIB_SECOND_MEMORY = 25e-7;
+var CLOUDFLARE_USD_PER_GB_SECOND_DISK = 7e-8;
+var CLOUDFLARE_USD_PER_VCPU_SECOND_ACTIVE = 2e-5;
+var CLOUDFLARE_STANDARD_1 = { size: "standard-1", vcpu: 0.5, memoryGb: 4, diskGb: 8 };
+var cloudflareBilling = {
+  source: { url: "https://developers.cloudflare.com/containers/pricing/", readOn: "2026-10-12" },
+  meter: "Cloudflare bills a container for every 10 ms it runs: memory at $0.0000025 per GiB-second and disk at $0.00000007 per GB-second for the whole run, plus CPU at $0.00002 per vCPU-second of active use.",
+  rates: {
+    default: {
+      size: CLOUDFLARE_STANDARD_1.size,
+      vcpu: CLOUDFLARE_STANDARD_1.vcpu,
+      memoryGb: CLOUDFLARE_STANDARD_1.memoryGb,
+      usdPerHour: (CLOUDFLARE_STANDARD_1.memoryGb * CLOUDFLARE_USD_PER_GIB_SECOND_MEMORY + CLOUDFLARE_STANDARD_1.diskGb * CLOUDFLARE_USD_PER_GB_SECOND_DISK) * HOUR_SECONDS
+    }
+  },
+  excludes: `active CPU, billed at $${CLOUDFLARE_USD_PER_VCPU_SECOND_ACTIVE} per vCPU-second and not measured by Claxedo, and the monthly allowance a Workers Paid plan includes`
+};
+
+// ../sandbox-contract/dist/index.mjs
+var sandboxDriverCredentialFields = {
+  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" }
+  ],
+  boat: [{ key: "api_key", label: "API Key", secret: true }],
+  agent37: [{ key: "api_key", label: "API Key", secret: true }],
+  docker: [{ key: "image", label: "Image" }]
+};
+var sandboxDriverLabels = {
+  modal: "Modal",
+  vercel: "Vercel",
+  cloudflare: "Cloudflare",
+  boat: "Boat",
+  agent37: "Agent37",
+  docker: "Docker"
+};
+
+// src/driver-catalog.ts
+var sandboxDriverCatalog = {
+  modal: {
+    id: "modal",
+    label: sandboxDriverLabels.modal,
+    credentialFields: sandboxDriverCredentialFields.modal,
+    runtimeNetwork: { controlPlane: "direct", relay: "configured" },
+    runtimeEnv: "callback",
+    preparedImage: true,
+    metadata: {
+      driverRunsIn: ["node"],
+      hostStopBehavior: "terminates-host",
+      hostResumeBehavior: "replacement-host",
+      targetAccess: "relay",
+      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: sandboxDriverLabels.vercel,
+    credentialFields: sandboxDriverCredentialFields.vercel,
+    runtimeNetwork: { controlPlane: "direct", relay: "configured" },
+    runtimeEnv: "callback",
+    preparedImage: false,
+    metadata: {
+      driverRunsIn: ["node"],
+      hostStopBehavior: "terminates-host",
+      hostResumeBehavior: "replacement-host",
+      targetAccess: "relay",
+      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: sandboxDriverLabels.cloudflare,
+    credentialFields: sandboxDriverCredentialFields.cloudflare,
+    runtimeNetwork: { controlPlane: "direct", relay: "configured" },
+    runtimeEnv: "callback",
+    preparedImage: false,
+    billing: cloudflareBilling,
+    metadata: {
+      driverRunsIn: ["worker"],
+      hostStopBehavior: "terminates-host",
+      hostResumeBehavior: "same-host",
+      hostWatchesIdle: true,
+      targetAccess: "relay",
+      secretBrokering: "native",
+      // The sandbox Worker starts the container without internet and routes each allowed host through itself; a Worker that cannot confirm that refuses the start.
+      egressControl: "hosts",
+      // A container snapshot holds the whole root filesystem; the platform keeps it 30 days past its last restore and offers no deletion.
+      persistence: {
+        resume: "replacement-restore",
+        capture: "filesystem",
+        clone: false,
+        captureSource: "preserved",
+        retention: "provider-managed",
+        restoreMount: "new-resource"
+      }
+    }
+  },
+  boat: {
+    id: "boat",
+    label: sandboxDriverLabels.boat,
+    credentialFields: sandboxDriverCredentialFields.boat,
+    runtimeNetwork: { controlPlane: "direct", relay: "configured" },
+    runtimeEnv: "callback",
+    preparedImage: true,
+    billing: boatBilling,
+    metadata: {
+      driverRunsIn: ["worker", "node"],
+      hostStopBehavior: "suspends-host",
+      hostResumeBehavior: "same-host",
+      targetAccess: "relay",
+      secretBrokering: "none",
+      egressControl: "none",
+      persistence: {
+        resume: "same-sandbox",
+        capture: "none",
+        clone: false,
+        captureSource: "not-applicable",
+        retention: "provider-managed",
+        restoreMount: "same-resource"
+      },
+      machineClasses: ["small", "default", "large"]
+    }
+  },
+  agent37: {
+    id: "agent37",
+    label: sandboxDriverLabels.agent37,
+    credentialFields: sandboxDriverCredentialFields.agent37,
+    runtimeNetwork: { controlPlane: "direct", relay: "configured" },
+    runtimeEnv: "callback",
+    preparedImage: true,
+    billing: agent37Billing,
+    metadata: {
+      driverRunsIn: ["worker", "node"],
+      hostStopBehavior: "suspends-host",
+      hostResumeBehavior: "same-host",
+      targetAccess: "relay",
+      secretBrokering: "none",
+      // An instance's network policy lists domains, reached over HTTPS on 443 alone, and IPv4 ranges; private ranges stay blocked whatever it lists.
+      egressControl: "hosts-and-cidrs",
+      persistence: {
+        resume: "same-sandbox",
+        capture: "none",
+        clone: false,
+        captureSource: "not-applicable",
+        retention: "provider-managed",
+        restoreMount: "same-resource"
+      },
+      machineClasses: ["small", "default", "large"]
+    }
+  },
+  docker: {
+    id: "docker",
+    label: sandboxDriverLabels.docker,
+    credentialFields: sandboxDriverCredentialFields.docker,
+    runtimeNetwork: { controlPlane: "docker-host", relay: "configured" },
+    runtimeEnv: "callback",
+    preparedImage: true,
+    metadata: {
+      driverRunsIn: ["local"],
+      hostStopBehavior: "terminates-host",
+      hostResumeBehavior: "same-host",
+      targetAccess: "loopback",
+      secretBrokering: "none",
+      egressControl: "none",
+      persistence: {
+        resume: "replacement-restore",
+        capture: "same-resource",
+        clone: false,
+        captureSource: "preserved",
+        retention: "provider-managed",
+        restoreMount: "same-resource"
+      }
+    }
+  }
+};
+
+// src/runtime-version.ts
+var SERVED_WORKSPACE_RUNTIME_FLOOR = {
+  version: "0.10.1",
+  image: "ghcr.io/kyashrathore/claxedo-sandbox:workspace-runtime-0-10-1-40706b7356-agent-plugins-v8"
+};
+var MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION = SERVED_WORKSPACE_RUNTIME_FLOOR.version;
+var SANDBOX_IMAGE_RUNTIME_VERSION_FILE = "opt/workspace-runtime/workspace-runtime-version";
+function servedRuntimeVersionTest(file) {
+  return `version=$(cat ${file} 2>/dev/null) && [ -n "$version" ] && [ "$(printf '%s\\n%s\\n' ${MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION} "$version" | sort -V | head -n 1)" = ${MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION} ]`;
+}
+
+// src/image-name.ts
+function assertSandboxImageReference(image) {
+  if (!image || image !== image.trim() || image.startsWith("-") || /\s/.test(image)) {
+    throw new Error(`sandbox image reference is not a legal image identifier: ${JSON.stringify(image)}`);
+  }
+  return image;
+}
+
+// ../claxedo-helpers/dist/guards.mjs
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+
+// src/lease-failure.ts
+var SandboxRuntimeBootError = class extends Error {
+  runtimeBootFailed = true;
+  constructor(reason) {
+    super(reason);
+    this.name = "SandboxRuntimeBootError";
+  }
+};
+var SandboxHostGoneError = class extends Error {
+  hostGone = true;
+  constructor(reason) {
+    super(reason);
+    this.name = "SandboxHostGoneError";
+  }
+};
+var WORKSPACE_RUNTIME_BOOT_FAILED_LINE = "workspace_runtime_boot_failed: ";
+function workspaceRuntimeBootReason(diagnostic) {
+  const at = diagnostic.lastIndexOf(WORKSPACE_RUNTIME_BOOT_FAILED_LINE);
+  if (at < 0) return void 0;
+  const [reason = ""] = diagnostic.slice(at + WORKSPACE_RUNTIME_BOOT_FAILED_LINE.length).split(/\n\s+at /);
+  return reason.trim().replace(/^Error: /, "") || void 0;
+}
+function runtimeBootDiagnostic(log, maxChars) {
+  const trimmed = log.trim();
+  const reason = workspaceRuntimeBootReason(trimmed);
+  if (reason === void 0) return trimmed.slice(-maxChars);
+  return `${WORKSPACE_RUNTIME_BOOT_FAILED_LINE}${reason}`.slice(0, maxChars);
+}
+
+// src/runtime-env.ts
+var WORKSPACE_RUNTIME_IDENTITY_ENV_KEYS = [
+  "WORKSPACE_RUNTIME_WORKSPACE_ID",
+  "WORKSPACE_RUNTIME_HOST_ID",
+  "WORKSPACE_RUNTIME_RELAY_WORKSPACE_IDS"
+];
+function workspaceRuntimeIdentityEnvConflicts(env) {
+  if (!env) return [];
+  return WORKSPACE_RUNTIME_IDENTITY_ENV_KEYS.filter((key) => env[key] !== void 0);
+}
+function assertWorkspaceRuntimeIdentityEnv(env) {
+  const conflicts = workspaceRuntimeIdentityEnvConflicts(env);
+  if (conflicts.length === 0) return;
+  throw new Error(
+    `sandbox env cannot set runtime identity ${conflicts.join(", ")}: the driver's placement owns the identity its target reports and the lease records`
+  );
+}
+var WORKSPACE_RUNTIME_PUBLIC_ENV_KEYS = /* @__PURE__ */ new Set([
+  ...WORKSPACE_RUNTIME_IDENTITY_ENV_KEYS,
+  "WORKSPACE_RUNTIME_DIRECTORY",
+  "WORKSPACE_RUNTIME_PORT",
+  "WORKSPACE_RUNTIME_HOST",
+  "WORKSPACE_RUNTIME_SOURCE_KIND",
+  "WORKSPACE_RUNTIME_GIT_REPO_URL",
+  "WORKSPACE_RUNTIME_GIT_BRANCH",
+  "WORKSPACE_RUNTIME_NATIVE_HARNESS",
+  "WORKSPACE_RUNTIME_RELAY_JWKS_URL",
+  "WORKSPACE_RUNTIME_MANAGEMENT_JWKS_URL",
+  "WORKSPACE_RUNTIME_SESSION_AUTHORITY_URL"
+]);
+function workspaceRuntimeBootSecrets(env) {
+  return Object.entries(env).flatMap(([key, value]) => WORKSPACE_RUNTIME_PUBLIC_ENV_KEYS.has(key) ? [] : [value]);
+}
+var REDACTED_VALUE_MIN_LENGTH = 8;
+function redactWorkspaceRuntimeBootSecrets(text, secrets) {
+  return secrets.filter((secret) => secret.length >= REDACTED_VALUE_MIN_LENGTH).reduce((output, secret) => output.split(secret).join("[redacted]"), text);
+}
+function workspaceRuntimeBootEnv(input) {
+  assertWorkspaceRuntimeIdentityEnv(input.env);
+  const env = {
+    ...workspaceRuntimeTargetEnv(input),
+    ...workspaceRuntimeSourceEnv(input),
+    ...input.env
+  };
+  if (input.nativeHarness) env.WORKSPACE_RUNTIME_NATIVE_HARNESS = input.nativeHarness;
+  if (input.controlEnv?.relayJwksUrl) env.WORKSPACE_RUNTIME_RELAY_JWKS_URL = input.controlEnv.relayJwksUrl;
+  if (input.controlEnv?.relayVerifyPem) env.WORKSPACE_RUNTIME_RELAY_HOST_VERIFY_PEM = input.controlEnv.relayVerifyPem;
+  if (input.controlEnv?.managementJwksUrl) env.WORKSPACE_RUNTIME_MANAGEMENT_JWKS_URL = input.controlEnv.managementJwksUrl;
+  if (input.controlEnv?.sessionAuthorityUrl) env.WORKSPACE_RUNTIME_SESSION_AUTHORITY_URL = input.controlEnv.sessionAuthorityUrl;
+  return env;
+}
+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/drivers/agent37-client.ts
+var INSTANCE_STATUSES = [
+  "provisioning",
+  "running",
+  "stopping",
+  "stopped",
+  "starting",
+  "restarting",
+  "updating",
+  "sleeping",
+  "waking",
+  "failed",
+  "deleting",
+  "deleted"
+];
+var DEFAULT_BASE_URL = "https://api.agent37.com/v1";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var CREATE_TIMEOUT_MS = 5 * 6e4;
+var REGISTER_TIMEOUT_MS = 10 * 6e4;
+var KEY_REFUSED_CODES = /* @__PURE__ */ new Set(["invalid_api_key", "ip_not_allowed"]);
+var Agent37ApiError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "Agent37ApiError";
+    this.providerKeyRefused = KEY_REFUSED_CODES.has(code);
+  }
+  /** Agent37 answers these to the key itself; an instance of another workspace reads as `not_found`. */
+  providerKeyRefused;
+};
+function invalidAgent37Response() {
+  throw new Agent37ApiError("Agent37 API returned an invalid response", "invalid_response");
+}
+function responseCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : invalidAgent37Response();
+}
+function instance(body) {
+  const id = body?.id;
+  const status = INSTANCE_STATUSES.find((name) => name === body?.status);
+  const resources = asRecord(body?.resources);
+  if (typeof id !== "string" || !/^[a-z0-9]{10}$/.test(id) || !status || !resources) invalidAgent37Response();
+  const ports = Array.isArray(body?.public_ports) ? body.public_ports : [];
+  return {
+    id,
+    status,
+    ...typeof body?.image_ref === "string" ? { imageRef: body.image_ref } : {},
+    resources: { cpu: responseCount(resources.cpu), memory: responseCount(resources.memory), disk: responseCount(resources.disk) },
+    metadata: Object.fromEntries(Object.entries(asRecord(body?.metadata) ?? {}).flatMap(([key, value]) => typeof value === "string" ? [[key, value]] : [])),
+    publicPorts: ports.flatMap((entry) => {
+      const port = asRecord(entry);
+      return typeof port?.port === "number" && typeof port.url === "string" && port.url.startsWith("https://") ? [{ port: port.port, url: port.url }] : [];
+    })
+  };
+}
+function createAgent37Client(options) {
+  const base = new URL(options.baseUrl ?? DEFAULT_BASE_URL);
+  if (base.protocol !== "https:" || base.username || base.password || base.search || base.hash) {
+    throw new Error("Agent37 endpoint requires HTTPS without credentials, query or fragment");
+  }
+  const baseUrl = base.href.replace(/\/+$/, "");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  async function api(path2, init) {
+    const method = init?.method ?? "GET";
+    return withDeadlineSignal(init?.timeoutMs ?? options.timeoutMs ?? DEFAULT_TIMEOUT_MS, async (signal) => {
+      let response;
+      try {
+        response = await fetchImpl(`${baseUrl}${path2}`, {
+          method,
+          redirect: "manual",
+          headers: {
+            Authorization: `Bearer ${options.apiKey}`,
+            ...init?.body === void 0 ? {} : { "Content-Type": "application/json" }
+          },
+          ...init?.body === void 0 ? {} : { body: JSON.stringify(init.body) },
+          signal
+        });
+      } catch {
+        throw new Agent37ApiError(`Agent37 ${method} ${path2} failed before acknowledgement`, "transport_failed");
+      }
+      const body = asRecord(await response.json().catch(() => void 0));
+      if (!response.ok) {
+        const code = asRecord(body?.error)?.code ?? body?.error;
+        throw new Agent37ApiError(`Agent37 ${method} ${path2} was rejected (${typeof code === "string" ? code : `http_${response.status}`})`, typeof code === "string" ? code : `http_${response.status}`, response.status);
+      }
+      return body;
+    });
+  }
+  const path = (id) => `/instances/${encodeURIComponent(id)}`;
+  const lifecycle = async (id, action, body, timeoutMs) => {
+    const answer = await api(`${path(id)}/${action}`, { method: "POST", ...body === void 0 ? {} : { body }, ...timeoutMs ? { timeoutMs } : {} });
+    return INSTANCE_STATUSES.find((name) => name === answer?.status) ?? invalidAgent37Response();
+  };
+  return {
+    async templateExists(name) {
+      try {
+        await api(`/templates/${encodeURIComponent(name)}`);
+        return true;
+      } catch (err) {
+        if (err instanceof Agent37ApiError && err.code === "not_found") return false;
+        throw err;
+      }
+    },
+    /** A name another registration took first holds the same image and command, since the name is derived from both. */
+    async registerTemplate(input) {
+      await api("/templates", { method: "POST", body: { name: input.name, image_ref: input.imageRef, entrypoint: input.entrypoint }, timeoutMs: REGISTER_TIMEOUT_MS }).catch((err) => {
+        if (!(err instanceof Agent37ApiError && err.code === "template_conflict")) throw err;
+      });
+    },
+    async create(input) {
+      return instance(await api("/instances", {
+        method: "POST",
+        timeoutMs: CREATE_TIMEOUT_MS,
+        body: {
+          template: input.template,
+          name: input.name,
+          metadata: input.metadata,
+          env: input.env,
+          network: input.network,
+          resources: input.resources,
+          public_ports: [{ port: input.publicPort }],
+          mount_path: input.mountPath
+        }
+      }));
+    },
+    async get(id) {
+      const value = instance(await api(path(id)));
+      return value.id === id ? value : invalidAgent37Response();
+    },
+    async list() {
+      const body = await api("/instances");
+      return (Array.isArray(body?.data) ? body.data : invalidAgent37Response()).map((entry) => instance(asRecord(entry)));
+    },
+    /** `env` reaches the container at its next start, restart, update or resize; `network` applies to a running one within seconds; `metadata` replaces what is stored. */
+    async edit(id, input) {
+      return instance(await api(path(id), { method: "PATCH", body: input }));
+    },
+    start: (id) => lifecycle(id, "start"),
+    stop: (id) => lifecycle(id, "stop"),
+    restart: (id) => lifecycle(id, "restart"),
+    /** Moves the instance onto `template`, keeping only its mount path; a stopped one stays stopped and boots that image at its next start. */
+    update: (id, template) => lifecycle(id, "update", { template }, CREATE_TIMEOUT_MS),
+    /** Recreates the running container at the new size. Disk only grows. */
+    resize: (id, resources) => lifecycle(id, "resize", resources, CREATE_TIMEOUT_MS),
+    async publishPort(id, port) {
+      const body = await api(`${path(id)}/public-ports`, { method: "POST", body: { port } });
+      return typeof body?.url === "string" && body.url.startsWith("https://") ? body.url : invalidAgent37Response();
+    },
+    async delete(id) {
+      await api(path(id), { method: "DELETE" });
+    },
+    /** Runs through `sh -c` as the image's user; a command that exits nonzero is an answer, not an error. */
+    async exec(id, command) {
+      const body = await api(`${path(id)}/exec`, { method: "POST", body: { command } });
+      return { exitCode: responseCount(body?.exit_code), stdout: typeof body?.stdout === "string" ? body.stdout : invalidAgent37Response() };
+    },
+    /** Answers in any state; Agent37 starts a container that exited again, and `restartCount` counts each boot after the first. */
+    async containerHealth(id, tail) {
+      const body = await api(`${path(id)}/logs?tail=${tail}`);
+      const health = asRecord(body?.health);
+      return {
+        logs: typeof body?.logs === "string" ? body.logs : "",
+        running: health?.running === true,
+        restartCount: typeof health?.restart_count === "number" ? health.restart_count : 0
+      };
+    }
+  };
+}
+
+// src/drivers/transient-error.ts
+function textOf(input) {
+  return typeof input === "string" ? input : "";
+}
+function driverErrorSignals(err) {
+  const shaped = isRecord(err) ? err : {};
+  const nested = isRecord(shaped.response) ? shaped.response : {};
+  return {
+    // `response.status` is the axios shape; `statusCode` is what SDK-native
+    // error classes expose instead.
+    status: asNumber(nested.status) ?? asNumber(shaped.status) ?? asNumber(shaped.statusCode),
+    text: `${textOf(shaped.code)} ${textOf(shaped.name)} ${textOf(shaped.message)}`.toLowerCase()
+  };
+}
+function isTransientDriverError(err, markers) {
+  const { status, text } = driverErrorSignals(err);
+  if (status !== void 0 && status >= 500) return true;
+  return markers.some((marker) => text.includes(marker));
+}
+var TRANSIENT_DRIVER_RETRY_MS = 2e3;
+
+// src/drivers/agent37.ts
+var DEFAULT_RUNTIME_COMMAND = "/usr/local/bin/workspace-runtime";
+var DEFAULT_WORKSPACE_DIR = "/workspace";
+var DEFAULT_PROVISION_TIMEOUT_MS = 12e4;
+var STATUS_POLL_MS = 1e3;
+var DEFAULT_HEALTH_TIMEOUT_MS = 10 * 6e4;
+var DEFAULT_HEALTH_INTERVAL_MS = 500;
+var HEALTH_PROBE_TIMEOUT_MS = 1e4;
+var DEFAULT_CONTAINER_CHECK_MS = 5e3;
+var DIAGNOSTIC_LOG_LINES = 40;
+var DIAGNOSTIC_CHARS = 600;
+var PERSISTENT_ROOT = "/claxedo-persistent";
+var PERSISTENT_HOMES = ["claxedo", "workspace-runtime"];
+var RUNTIME_ENV_VARIABLE = "CLAXEDO_RUNTIME_ENV";
+var NETWORK_ALLOW_LIMIT = 100;
+var INSTANCE_NAME_MAX_CHARS = 60;
+var TRANSIENT_MARKERS = ["transport_failed", "try_again", "no_capacity", "capacity_unavailable"];
+var SERVING_STATUSES = /* @__PURE__ */ new Set(["provisioning", "running", "starting", "restarting", "updating", "waking"]);
+var SETTLING_STATUSES = /* @__PURE__ */ new Set(["provisioning", "starting", "restarting", "updating", "waking", "stopping"]);
+var GONE_STATUSES = /* @__PURE__ */ new Set(["deleting", "deleted"]);
+var Agent37DriverError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Agent37DriverError";
+  }
+};
+function instanceGoneOrThrow(err) {
+  if (err instanceof Agent37ApiError && err.code === "not_found") throw new SandboxHostGoneError(err.message);
+  throw err;
+}
+function runtimeEntrypoint(runtimeCommand) {
+  return ["/bin/bash", "-lc", [
+    `eval "$${RUNTIME_ENV_VARIABLE}" || exit 1`,
+    `unset ${RUNTIME_ENV_VARIABLE}`,
+    `link() { mkdir -p "${PERSISTENT_ROOT}/$1" "$(dirname "$2")" && { [ -L "$2" ] || ln -s "${PERSISTENT_ROOT}/$1" "$2"; }; }`,
+    `[ -L "$WORKSPACE_RUNTIME_DIRECTORY" ] || [ ! -e "$WORKSPACE_RUNTIME_DIRECTORY" ] || rmdir "$WORKSPACE_RUNTIME_DIRECTORY" || exit 1`,
+    `link workspace "$WORKSPACE_RUNTIME_DIRECTORY" || exit 1`,
+    `for home in ${PERSISTENT_HOMES.join(" ")}; do [ -L "$HOME/.$home" ] || rm -rf "$HOME/.$home"; link "$home" "$HOME/.$home" || exit 1; done`,
+    `cd "$WORKSPACE_RUNTIME_DIRECTORY" || exit 1`,
+    `${runtimeCommand} &`,
+    `child=$!`,
+    `trap 'kill -TERM "$child" 2>/dev/null' TERM INT`,
+    `while kill -0 "$child" 2>/dev/null; do wait "$child"; status=$?; done`,
+    `exit "$status"`
+  ].join("\n")];
+}
+async function templateName(image, entrypoint) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify([image, entrypoint])));
+  return `claxedo-runtime-${[...new Uint8Array(digest)].slice(0, 8).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function instanceNetwork(input) {
+  if (!input.net || input.net.mode === "allow-all") return "allow-all";
+  const allow = [...input.net.hosts ?? [], ...(input.net.cidrs ?? []).filter((cidr) => !cidr.includes(":"))];
+  if (allow.length > NETWORK_ALLOW_LIMIT) {
+    throw new Agent37DriverError(`Agent37 allows ${NETWORK_ALLOW_LIMIT} network destinations and this workspace names ${allow.length}`);
+  }
+  return allow.length ? { allow } : "deny-all";
+}
+function createAgent37SandboxDriver(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const client = createAgent37Client({
+    apiKey: options.apiKey,
+    ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+    ...options.operationTimeoutMs ? { timeoutMs: options.operationTimeoutMs } : {},
+    fetchImpl
+  });
+  const entrypoint = runtimeEntrypoint(options.runtimeCommand ?? DEFAULT_RUNTIME_COMMAND);
+  const provisionTimeoutMs = options.provisionTimeoutMs ?? DEFAULT_PROVISION_TIMEOUT_MS;
+  const healthTimeoutMs = options.healthTimeoutMs ?? DEFAULT_HEALTH_TIMEOUT_MS;
+  const healthIntervalMs = options.healthIntervalMs ?? DEFAULT_HEALTH_INTERVAL_MS;
+  const containerCheckMs = options.containerCheckMs ?? DEFAULT_CONTAINER_CHECK_MS;
+  const registered = /* @__PURE__ */ new Map();
+  function runtimePort(input) {
+    return input.workspaceRuntimePort ?? options.runtimePort ?? DEFAULT_WORKSPACE_RUNTIME_PORT;
+  }
+  function resolveImage(input) {
+    return assertSandboxImageReference(
+      input.bootSource?.kind === "image" ? input.bootSource.image : input.snapshot ?? options.image
+    );
+  }
+  function templateFor(image) {
+    const known = registered.get(image);
+    if (known) return known;
+    const template = (async () => {
+      const name = await templateName(image, entrypoint);
+      if (!await client.templateExists(name)) await client.registerTemplate({ name, imageRef: image, entrypoint });
+      return name;
+    })();
+    registered.set(image, template);
+    template.catch(() => registered.delete(image));
+    return template;
+  }
+  async function bootEnv(input, hostId) {
+    const env = {
+      ...workspaceRuntimeBootEnv({
+        workspaceId: input.workspaceId,
+        hostId,
+        directory: input.workspaceRoot ?? options.workspaceDir ?? DEFAULT_WORKSPACE_DIR,
+        port: runtimePort(input),
+        host: "0.0.0.0",
+        source: input.source,
+        env: input.env,
+        nativeHarness: options.nativeHarness,
+        controlEnv: options.controlEnv
+      }),
+      ...await options.env?.(input, { id: hostId })
+    };
+    return { variables: { [RUNTIME_ENV_VARIABLE]: envFile(env) }, secrets: workspaceRuntimeBootSecrets(env) };
+  }
+  function metadata(input) {
+    return { ...input.labels };
+  }
+  async function settled(id) {
+    const until = Date.now() + provisionTimeoutMs;
+    for (; ; ) {
+      const instance2 = await client.get(id).catch(instanceGoneOrThrow);
+      if (GONE_STATUSES.has(instance2.status)) throw new SandboxHostGoneError(`Agent37 ${id} is ${instance2.status}`);
+      if (!SETTLING_STATUSES.has(instance2.status)) return instance2;
+      if (Date.now() >= until) return void 0;
+      await sleep(STATUS_POLL_MS);
+    }
+  }
+  async function probe(url) {
+    try {
+      return await withDeadlineSignal(HEALTH_PROBE_TIMEOUT_MS, async (signal) => {
+        const response = await fetchImpl(`${url}/global/health`, { signal });
+        if (!response.ok) return { answer: `health probe returned ${response.status}` };
+        const workspaceId = asRecord(await response.json().catch(() => void 0))?.workspaceId;
+        return typeof workspaceId === "string" ? { workspaceId, answer: `health probe answered for ${workspaceId}` } : { answer: "health probe named no workspace" };
+      });
+    } catch {
+      return { answer: "health probe got no response" };
+    }
+  }
+  async function waitForHealth(id, url, input, secrets, bootRestarts) {
+    const until = Date.now() + healthTimeoutMs;
+    let last = "workspace runtime not ready";
+    let containerReadAt = Date.now();
+    while (Date.now() < until) {
+      const answered = await probe(url);
+      if (answered.workspaceId === input.workspaceId) return;
+      last = answered.answer;
+      if (Date.now() - containerReadAt >= containerCheckMs) {
+        const container = await client.containerHealth(id, 1);
+        containerReadAt = Date.now();
+        if (!container.running || container.restartCount > bootRestarts) {
+          last = "the runtime exited";
+          break;
+        }
+      }
+      await sleep(healthIntervalMs);
+    }
+    const diagnostic = await client.containerHealth(id, DIAGNOSTIC_LOG_LINES).then(
+      (container) => runtimeBootDiagnostic(redactWorkspaceRuntimeBootSecrets(container.logs, secrets), DIAGNOSTIC_CHARS),
+      () => "container diagnostics unavailable"
+    );
+    throw new SandboxRuntimeBootError(`Agent37 ${id} runtime did not become healthy: ${last}; ${diagnostic}`);
+  }
+  async function serve(running, input, hostId, secrets) {
+    const port = runtimePort(input);
+    const { restartCount } = await client.containerHealth(running.id, 1);
+    await input.onMachineReady?.();
+    await input.onImageReady?.();
+    const url = running.publicPorts.find((entry) => entry.port === port)?.url ?? await client.publishPort(running.id, port);
+    await waitForHealth(running.id, url, input, secrets, restartCount);
+    return {
+      workspaceId: input.workspaceId,
+      sandboxId: running.id,
+      url,
+      hostId,
+      driverResourceId: running.id,
+      driver: { id: "agent37", resourceId: running.id },
+      labels: { ...input.labels, ...resolveImage(input) === options.image && running.imageRef ? { [SANDBOX_IMAGE_LABEL]: running.imageRef } : {} }
+    };
+  }
+  function shape(machineClass) {
+    return agent37MachineShapes[machineClass ?? "default"];
+  }
+  async function ensureHost(input) {
+    const hostId = input.hostId ?? `agent37-${input.workspaceId}`;
+    const policy = instanceNetwork(input);
+    const { variables, secrets } = await bootEnv(input, hostId);
+    const created = await templateFor(resolveImage(input)).then((template) => client.create({
+      template,
+      name: `claxedo-${input.workspaceId}`.slice(0, INSTANCE_NAME_MAX_CHARS),
+      metadata: metadata(input),
+      env: variables,
+      network: policy,
+      resources: shape(input.machineClass),
+      publicPort: runtimePort(input),
+      mountPath: PERSISTENT_ROOT
+    })).catch((err) => {
+      if (isTransientDriverError(err, TRANSIENT_MARKERS)) return void 0;
+      throw err;
+    });
+    if (!created) return { provisioning: true, retryAfterMs: TRANSIENT_DRIVER_RETRY_MS };
+    const resource = { sandboxId: created.id, hostId, driverResourceId: created.id, labels: input.labels };
+    const failures = [];
+    try {
+      await input.onResource?.(resource);
+    } catch (handoffError) {
+      failures.push(handoffError);
+      try {
+        await destroy({ ...resource, workspaceId: input.workspaceId });
+      } catch (deleteError) {
+        failures.push(deleteError);
+      }
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) throw new AggregateError(failures, `Agent37 ${created.id} resource handoff and deletion failed`);
+    const running = created.status === "running" ? created : await settled(created.id);
+    if (!running) return { provisioning: true, retryAfterMs: 0 };
+    if (running.status !== "running") throw new Agent37DriverError(`Agent37 ${created.id} entered non-running state: ${running.status}`);
+    return serve(running, input, hostId, secrets);
+  }
+  async function resumeHost(input) {
+    const id = input.lease.sandboxId;
+    if (!id) throw new Agent37DriverError("Cannot resume Agent37 without its instance id");
+    const ensure = input.ensure;
+    const hostId = ensure.hostId ?? input.lease.hostId ?? `agent37-${ensure.workspaceId}`;
+    const policy = instanceNetwork(ensure);
+    const held = await settled(id);
+    if (!held) return { provisioning: true, retryAfterMs: 0 };
+    const image = resolveImage(ensure);
+    const { variables, secrets } = await bootEnv(ensure, hostId);
+    await client.edit(id, { env: variables, network: policy, metadata: metadata(ensure) }).catch(instanceGoneOrThrow);
+    const keepsPreviousImage = held.imageRef !== image && image === options.image && !ensure.updateImage;
+    const moves = held.imageRef !== image && !keepsPreviousImage;
+    let status = held.status;
+    if (status === "sleeping") status = await client.start(id);
+    if (moves || status === "failed") status = await client.update(id, await templateFor(image));
+    else if (status === "running") status = await client.restart(id);
+    if (status === "stopped") status = await client.start(id);
+    let running = status === "running" ? await client.get(id) : await settled(id);
+    if (!running) return { provisioning: true, retryAfterMs: 0 };
+    if (running.status !== "running") throw new Agent37DriverError(`Agent37 ${id} entered non-running state: ${running.status}`);
+    if (keepsPreviousImage) {
+      const served = await client.exec(id, servedRuntimeVersionTest(`/${SANDBOX_IMAGE_RUNTIME_VERSION_FILE}`));
+      if (served.exitCode !== 0) {
+        await client.update(id, await templateFor(image));
+        running = await settled(id);
+        if (!running) return { provisioning: true, retryAfterMs: 0 };
+      }
+    }
+    const wanted = ensure.machineClass ? shape(ensure.machineClass) : void 0;
+    if (wanted && (running.resources.cpu !== wanted.cpu || running.resources.memory !== wanted.memory)) {
+      await client.resize(id, { cpu: wanted.cpu, memory: wanted.memory, disk: Math.max(running.resources.disk, wanted.disk) });
+      running = await settled(id);
+      if (!running) return { provisioning: true, retryAfterMs: 0 };
+    }
+    return serve(running, ensure, hostId, secrets);
+  }
+  async function stop(target) {
+    await client.stop(target.sandboxId).catch(instanceGoneOrThrow);
+  }
+  async function destroy(target) {
+    await client.delete(target.sandboxId).catch((err) => {
+      if (!(err instanceof Agent37ApiError && err.code === "not_found")) throw err;
+    });
+  }
+  async function inspect(target) {
+    try {
+      const { status } = await client.get(target.sandboxId);
+      if (GONE_STATUSES.has(status)) return "gone";
+      return SERVING_STATUSES.has(status) ? "serving" : "stopped";
+    } catch (err) {
+      if (err instanceof Agent37ApiError && err.code === "not_found") return "gone";
+      throw err;
+    }
+  }
+  async function list() {
+    return (await client.list()).flatMap((instance2) => {
+      const url = instance2.publicPorts[0]?.url;
+      return url && !GONE_STATUSES.has(instance2.status) ? [{ sandboxId: instance2.id, url, hostId: `agent37-${instance2.metadata.workspaceId ?? instance2.id}`, driverResourceId: instance2.id, labels: instance2.metadata, driver: { id: "agent37", resourceId: instance2.id } }] : [];
+    });
+  }
+  return {
+    id: "agent37",
+    metadata: sandboxDriverCatalog.agent37.metadata,
+    image: options.image,
+    ensureHost,
+    resumeHost,
+    list,
+    async touch() {
+    },
+    suspend: stop,
+    stop,
+    destroy,
+    inspect
+  };
+}
+export {
+  createAgent37SandboxDriver
+};