@claxedo/sandbox-manager 0.7.0 → 0.10.0

package/dist/drivers/daytona.d.ts

@@ -1,127 +0,0 @@
-import type { SandboxDriver, SandboxDriverEnsureInput } from "..";
-export type DaytonaSandboxLike = {
-    id: string;
-    state?: string;
-    labels?: Record<string, string>;
-    process: {
-        executeCommand: (command: string, cwd?: string, env?: Record<string, string>, timeout?: number) => Promise<unknown>;
-    };
-    getPreviewLink: (port: number) => Promise<{
-        url?: string;
-        token?: string;
-    }>;
-    getSignedPreviewUrl: (port: number, expiresInSeconds?: number) => Promise<{
-        url?: string;
-        token?: string;
-    }>;
-    refreshActivity: () => Promise<void>;
-    start: (timeout?: number) => Promise<void>;
-    stop: (timeout?: number) => Promise<void>;
-    delete: (timeout?: number) => Promise<void>;
-    /**
-     * Replace the sandbox's outbound egress policy in place, without stopping it
-     * — the Daytona SDK's `Sandbox.updateNetworkSettings`, which drives the same
-     * runner-side iptables mechanism as `create`'s `networkBlockAll` /
-     * `networkAllowList` / `domainAllowList`. This is what makes the create-time
-     * policy reappliable on reuse and resume; see `applyNetworkPolicy` below.
-     *
-     * Optional because a client injected by an embedder may predate it. When it
-     * is absent and a restricted policy was requested, reuse is REFUSED rather
-     * than silently served on the creation-time policy.
-     */
-    updateNetworkSettings?: (settings: {
-        networkBlockAll?: boolean;
-        networkAllowList?: string;
-        domainAllowList?: string;
-    }) => Promise<void>;
-    _experimental_createSnapshot?: (name: string, timeout?: number) => Promise<void>;
-};
-export type DaytonaClientLike = {
-    findByLabels?: (labels: Record<string, string>) => Promise<DaytonaSandboxLike | undefined>;
-    /**
-     * One page of sandboxes matching `labels`. Pages are 1-based; a page that
-     * returns fewer than `limit` items (or none) is the last one — that is the
-     * termination rule `list()` below relies on, and any implementation must
-     * honor it or the sweep loops forever.
-     *
-     * `createDefaultClient` satisfies it by returning every match on page 1 and
-     * nothing after: the Daytona SDK's `list()` is an `AsyncIterableIterator`
-     * that paginates internally, so `limit` is its per-page fetch size and NOT a
-     * cap on the total (see @daytona/sdk `ListSandboxesQuery.limit`). There is no
-     * cursor to hand back, so re-slicing per page would re-walk the whole account
-     * on every call.
-     */
-    list?: (labels?: Record<string, string>, page?: number, limit?: number) => Promise<{
-        items?: DaytonaSandboxLike[];
-    }>;
-    create: (params: {
-        name?: string;
-        image?: string;
-        snapshot?: string;
-        envVars?: Record<string, string>;
-        /** Env-var-name → Daytona secret-name references (brokered secrets). */
-        secrets?: Record<string, string>;
-        labels?: Record<string, string>;
-        public?: boolean;
-        autoStopInterval?: number;
-        autoDeleteInterval?: number;
-        networkBlockAll?: boolean;
-        /** Comma-separated allowed CIDR network addresses. */
-        networkAllowList?: string;
-        /** Comma-separated allowed domains — the name-based egress allowlist. */
-        domainAllowList?: string;
-    }, options?: {
-        timeout?: number;
-    }) => Promise<DaytonaSandboxLike>;
-    get: (sandboxIdOrName: string) => Promise<DaytonaSandboxLike>;
-    /**
-     * Create-or-update an org secret whose value is only substituted by
-     * Daytona's egress proxy for requests to `hosts`
-     * (https://www.daytona.io/docs/en/secrets/). Referenced from `create`'s
-     * `secrets` map; inside the sandbox the env var holds only an opaque
-     * `dtn_secret_…` placeholder, never the value.
-     */
-    upsertSecret?: (params: {
-        name: string;
-        value: string;
-        hosts: string[];
-    }) => Promise<void>;
-};
-export type DaytonaSandboxDriverOptions = {
-    /** Daytona API base URL. Defaults to the SDK default. */
-    apiUrl?: string;
-    /** Daytona API key. */
-    apiKey: string;
-    /** Optional Daytona organization id. */
-    organizationId?: string;
-    /** Optional Daytona target/region. */
-    target?: string;
-    /** Snapshot the sandbox boots from. */
-    baseSnapshot: string;
-    /** Port the workspace-runtime listens on inside the sandbox. */
-    runtimePort?: number;
-    /** Path to the workspace-runtime binary inside the image. */
-    runtimeCommand?: string;
-    /** Workspace directory inside the sandbox. */
-    workspaceDir?: string;
-    /** Default runner injected as WORKSPACE_RUNTIME_RUNNER. */
-    runner?: string;
-    /** Static control-plane config injected so the runtime verifies relay-proxied requests. */
-    controlEnv?: {
-        relayJwksUrl?: string;
-        relayVerifyPem?: string;
-        managementJwksUrl?: string;
-    };
-    /** Dynamic runtime env that needs the acquired sandbox id or current lease. */
-    env?: (input: SandboxDriverEnsureInput, sandbox: DaytonaSandboxLike) => Record<string, string> | Promise<Record<string, string>>;
-    /** Auto-stop / auto-delete policy, in minutes. */
-    autoStopMinutes?: number;
-    autoDeleteMinutes?: number;
-    /** Signed preview URL expiry, in seconds. */
-    previewExpirySeconds?: number;
-    /** Daytona SDK operation timeout, in seconds. */
-    operationTimeoutSeconds?: number;
-    /** Injected for tests. */
-    client?: DaytonaClientLike;
-};
-export declare function createDaytonaSandboxDriver(options: DaytonaSandboxDriverOptions): SandboxDriver;

package/dist/drivers/daytona.mjs

@@ -1,541 +0,0 @@
-// src/drivers/daytona.ts
-import { Daytona } from "@daytona/sdk";
-
-// src/daytona-allow-list.ts
-function formatDaytonaAllowList(cidrs) {
-  return cidrs.slice(0, 10).join(",");
-}
-function formatDaytonaDomainAllowList(hosts) {
-  return [...new Set(hosts)].join(",");
-}
-
-// 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/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/driver-catalog.ts
-var sandboxDriverCatalog = {
-  exe: {
-    id: "exe",
-    label: "exe.dev",
-    credentialFields: [{ key: "api_token", label: "API Token", secret: true }],
-    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 }],
-    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.
-      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 }
-    ],
-    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.
-      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" }
-    ],
-    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.
-      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" }
-    ],
-    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.
-      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 }],
-    metadata: {
-      driverRunsIn: ["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"
-      }
-    }
-  },
-  docker: {
-    id: "docker",
-    label: "Docker",
-    credentialFields: [{ key: "image", label: "Image" }],
-    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/drivers/daytona.ts
-var DEFAULT_RUNTIME_COMMAND = "/usr/local/bin/workspace-runtime";
-var DEFAULT_WORKSPACE_DIR = "/workspace";
-var DEFAULT_PREVIEW_EXPIRY_S = 3600;
-var DEFAULT_OPERATION_TIMEOUT_S = 60;
-var LIST_PAGE_SIZE = 100;
-var MAX_LIST_PAGES = 100;
-function labelName(workspaceId) {
-  return `claxedo-${workspaceId}`;
-}
-function daytonaSecretName(workspaceId, secretName) {
-  const safe = (value) => value.replace(/[^a-zA-Z0-9_-]+/g, "-");
-  return `claxedo-${safe(workspaceId)}-${safe(secretName)}`;
-}
-function transientDriverError(err) {
-  const shaped = err;
-  const status = shaped.response?.status ?? shaped.status;
-  if (typeof status === "number" && status >= 500) return true;
-  const text = `${shaped.name ?? ""} ${shaped.message ?? ""}`.toLowerCase();
-  return text.includes("timeout") || text.includes("pending") || text.includes("starting");
-}
-function createDefaultClient(options) {
-  const sdk = new Daytona({
-    apiKey: options.apiKey,
-    ...options.apiUrl ? { apiUrl: options.apiUrl } : {},
-    ...options.organizationId ? { organizationId: options.organizationId } : {},
-    ...options.target ? { target: options.target } : {},
-    _experimental: { otelEnabled: false }
-  });
-  return {
-    async findByLabels(labels) {
-      for await (const sandbox of sdk.list({ labels })) return sandbox;
-      return void 0;
-    },
-    // Page 1 carries everything; later pages are empty. See DaytonaClientLike.list.
-    async list(labels, page = 1, limit) {
-      if (page > 1) return { items: [] };
-      const items = [];
-      for await (const sandbox of sdk.list({ ...labels ? { labels } : {}, ...limit ? { limit } : {} })) {
-        items.push(sandbox);
-      }
-      return { items };
-    },
-    create(params, operation) {
-      if (params.image) return sdk.create({ ...params, image: params.image }, operation);
-      return sdk.create(params, operation);
-    },
-    get: (sandboxIdOrName) => sdk.get(sandboxIdOrName),
-    async upsertSecret({ name, value, hosts }) {
-      await sdk.secret.create({ name, value, hosts });
-    }
-  };
-}
-function createDaytonaSandboxDriver(options) {
-  const client = options.client ?? createDefaultClient(options);
-  const runtimePort = options.runtimePort ?? DEFAULT_WORKSPACE_RUNTIME_PORT;
-  const runtimeCommand = options.runtimeCommand ?? DEFAULT_RUNTIME_COMMAND;
-  const workspaceDir = options.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
-  const previewExpiry = options.previewExpirySeconds ?? DEFAULT_PREVIEW_EXPIRY_S;
-  const operationTimeout = options.operationTimeoutSeconds ?? DEFAULT_OPERATION_TIMEOUT_S;
-  function workspaceDirectory(input) {
-    return input.workspaceRoot ?? workspaceDir;
-  }
-  function staticBootEnv(input, hostId, directory) {
-    const env = {
-      ...workspaceRuntimeTargetEnv({
-        workspaceId: input.workspaceId,
-        hostId,
-        directory,
-        port: runtimePort
-      }),
-      ...workspaceRuntimeSourceEnv({ source: input.source }),
-      ...input.env
-    };
-    if (options.runner) env.WORKSPACE_RUNTIME_RUNNER = options.runner;
-    if (options.controlEnv?.relayJwksUrl) env.WORKSPACE_RUNTIME_RELAY_JWKS_URL = options.controlEnv.relayJwksUrl;
-    if (options.controlEnv?.relayVerifyPem) env.WORKSPACE_RUNTIME_RELAY_HOST_VERIFY_PEM = options.controlEnv.relayVerifyPem;
-    if (options.controlEnv?.managementJwksUrl) env.WORKSPACE_RUNTIME_MANAGEMENT_JWKS_URL = options.controlEnv.managementJwksUrl;
-    return env;
-  }
-  async function bootEnv(input, sandbox, hostId) {
-    return {
-      ...staticBootEnv(input, hostId, workspaceDirectory(input)),
-      ...await options.env?.(input, sandbox)
-    };
-  }
-  async function findExisting(workspaceId) {
-    const labels = { "claxedo.workspaceId": workspaceId };
-    if (client.findByLabels) return client.findByLabels(labels).catch(() => void 0);
-    const result = await client.list?.(labels, 1, 1).catch(() => void 0);
-    return result?.items?.[0];
-  }
-  async function sandboxById(sandboxId) {
-    return client.get(sandboxId);
-  }
-  async function previewUrl(sandbox) {
-    const signed = await sandbox.getSignedPreviewUrl(runtimePort, previewExpiry).catch(() => void 0);
-    if (signed?.url) return signed;
-    return sandbox.getPreviewLink(runtimePort).catch(() => void 0);
-  }
-  async function startRuntime(sandbox, input, env) {
-    const directory = workspaceDirectory(input);
-    const script = `if (command -v ss >/dev/null && ss -ltn 2>/dev/null | grep -q :${runtimePort}); then exit 0; fi; mkdir -p ${shell(directory)}; cd ${shell(directory)}; nohup ${runtimeCommand} > /tmp/claxedo-wr.log 2>&1 & sleep 1`;
-    await sandbox.process.executeCommand(`sh -lc ${shell(script)}`, directory, env, operationTimeout).catch(() => void 0);
-  }
-  async function ensureStarted(sandbox) {
-    if (!sandbox.state || sandbox.state === "started") return true;
-    if (sandbox.state === "starting") return false;
-    await sandbox.start(operationTimeout).catch(() => void 0);
-    return sandbox.state === "started";
-  }
-  async function readyTarget(input, sandbox, hostId) {
-    await startRuntime(sandbox, input, await bootEnv(input, sandbox, hostId));
-    const preview = await previewUrl(sandbox);
-    if (!preview?.url) return { provisioning: true, retryAfterMs: 2e3 };
-    const target = {
-      workspaceId: input.workspaceId,
-      sandboxId: sandbox.id,
-      url: preview.url,
-      hostId,
-      driverResourceId: sandbox.id,
-      driver: {
-        id: "daytona",
-        resourceId: sandbox.id
-      },
-      labels: { ...input.labels, ...preview.token ? { "daytona.previewToken": preview.token } : {} }
-    };
-    return target;
-  }
-  async function brokeredSecretReferences(input) {
-    if (!input.secrets?.length) return {};
-    if (!client.upsertSecret) {
-      throw new Error("daytona sandbox client does not support secret brokering");
-    }
-    const references = {};
-    for (const secret of input.secrets) {
-      if (secret.hosts.length === 0) {
-        throw new Error(`daytona brokered secret "${secret.name}" requires at least one host in its egress allowlist`);
-      }
-      const secretName = daytonaSecretName(input.workspaceId, secret.name);
-      await client.upsertSecret({ name: secretName, value: secret.value, hosts: secret.hosts });
-      references[secret.name] = secretName;
-    }
-    return references;
-  }
-  async function applyNetworkPolicy(sandbox, input) {
-    const net = network(input);
-    if (Object.keys(net).length === 0) return "applied";
-    if (!sandbox.updateNetworkSettings) {
-      throw new Error(
-        `daytona sandbox client cannot reapply egress policy to existing sandbox ${sandbox.id}: the client does not support updateNetworkSettings, so the requested restricted policy cannot be guaranteed on reuse \u2014 refusing rather than serving the creation-time policy`
-      );
-    }
-    try {
-      await sandbox.updateNetworkSettings(net);
-    } catch (err) {
-      if (transientDriverError(err)) return "retry";
-      throw err;
-    }
-    return "applied";
-  }
-  async function ensureHost(input) {
-    const hostId = labelName(input.workspaceId);
-    const bootSource = input.bootSource?.kind === "image" ? { image: input.bootSource.image } : { snapshot: input.bootSource?.kind === "driver-snapshot" ? input.bootSource.snapshotId : input.snapshot ?? options.baseSnapshot };
-    const net = network(input);
-    const secrets = await brokeredSecretReferences(input);
-    const existing = await findExisting(input.workspaceId);
-    const sandbox = existing ?? await client.create({
-      name: labelName(input.workspaceId),
-      ...bootSource,
-      envVars: staticBootEnv(input, hostId, workspaceDirectory(input)),
-      ...Object.keys(secrets).length ? { secrets } : {},
-      labels: { ...input.labels, "claxedo.workspaceId": input.workspaceId },
-      public: false,
-      ...net,
-      ...options.autoStopMinutes !== void 0 ? { autoStopInterval: options.autoStopMinutes } : {},
-      ...options.autoDeleteMinutes !== void 0 ? { autoDeleteInterval: options.autoDeleteMinutes } : {}
-    }, { timeout: operationTimeout }).catch((err) => {
-      if (transientDriverError(err)) return void 0;
-      throw err;
-    });
-    if (!sandbox) return { provisioning: true, retryAfterMs: 2e3 };
-    if (!await ensureStarted(sandbox)) return { provisioning: true, retryAfterMs: 2e3 };
-    if (existing && await applyNetworkPolicy(existing, input) === "retry") {
-      return { provisioning: true, retryAfterMs: 2e3 };
-    }
-    return readyTarget(input, sandbox, hostId);
-  }
-  return {
-    id: "daytona",
-    metadata: {
-      driverRunsIn: ["worker", "node"],
-      hostStopBehavior: "suspends-host",
-      hostResumeBehavior: "same-host",
-      targetAccess: "relay",
-      secretBrokering: "native",
-      egressControl: "hosts-and-cidrs",
-      persistence: sandboxDriverCatalog.daytona.metadata.persistence
-    },
-    ensureHost,
-    // Provider-state enumeration for `garbageCollect()`.
-    //
-    // Two label sets exist on a sandbox this driver created (`ensureHost`
-    // above): the manager's flat set — `app`, `workspaceId`, `epoch`,
-    // `homeRegion` (built at index.ts `ensureHostInput`) — and the dotted
-    // `claxedo.workspaceId` this driver adds for `findExisting`. Every target
-    // returned here carries `sandbox.labels` **as the provider reports them**,
-    // never labels reconstructed from ensure inputs: GC's ownership check reads
-    // `labels.app` and its identity check reads flat `labels.workspaceId` /
-    // `labels.epoch`, so a synthesized label set would decide the fate of a
-    // sandbox using values that never left this process. (That is the bug in
-    // the `exe` driver's `list()`, which sources labels from a per-process
-    // `Map` — after a restart it reports `labels: undefined` and GC skips
-    // every sandbox as unlabeled. Not fixed here; different owner.)
-    //
-    // The filter is deliberately WIDE: any claxedo ownership marker qualifies.
-    // Narrowing it here would re-create the defect W1 exists to remove — an
-    // orphan the sweep cannot see is an orphan that lives forever — and the
-    // authority on what may be DESTROYED is the manager's `app`-label check,
-    // which skips anything else as `unmanaged_app_label`. Visibility is this
-    // function's job; destruction is not.
-    //
-    // No preview URL is resolved: `getSignedPreviewUrl` is a per-sandbox
-    // round-trip and GC only needs identity, so a sweep over N orphans would
-    // cost N extra API calls to fill a field it then discards.
-    async list() {
-      if (!client.list) {
-        throw new Error("daytona sandbox client does not support listing");
-      }
-      const targets = [];
-      const seen = /* @__PURE__ */ new Set();
-      for (let page = 1; page <= MAX_LIST_PAGES; page++) {
-        const result = await client.list(void 0, page, LIST_PAGE_SIZE);
-        const items = result?.items ?? [];
-        for (const sandbox of items) {
-          const labels = sandbox.labels;
-          const workspaceId = labels?.workspaceId ?? labels?.["claxedo.workspaceId"];
-          if (!workspaceId || seen.has(sandbox.id)) continue;
-          seen.add(sandbox.id);
-          targets.push({
-            workspaceId,
-            sandboxId: sandbox.id,
-            // Identity, not a reachable address — never routed through.
-            url: sandbox.id,
-            // Must equal what `ensureHost` stored on the lease, or a LIVE
-            // sandbox fails GC's identity check and gets destroyed. Both paths
-            // derive it from `labelName(workspaceId)`.
-            hostId: labelName(workspaceId),
-            driverResourceId: sandbox.id,
-            labels,
-            driver: { id: "daytona", resourceId: sandbox.id }
-          });
-        }
-        if (items.length < LIST_PAGE_SIZE) break;
-      }
-      return targets;
-    },
-    async resumeHost(input) {
-      const sandbox = await sandboxById(input.lease.sandboxId);
-      if (!await ensureStarted(sandbox)) return { provisioning: true, retryAfterMs: 2e3 };
-      if (await applyNetworkPolicy(sandbox, input.ensure) === "retry") {
-        return { provisioning: true, retryAfterMs: 2e3 };
-      }
-      return readyTarget(input.ensure, sandbox, input.ensure.hostId ?? labelName(input.ensure.workspaceId));
-    },
-    async touch(target) {
-      await sandboxById(target.sandboxId).then((sandbox) => sandbox.refreshActivity()).catch(() => void 0);
-    },
-    async suspend(target) {
-      await sandboxById(target.sandboxId).then((sandbox) => sandbox.stop(operationTimeout)).catch(() => void 0);
-    },
-    async stop(target) {
-      await sandboxById(target.sandboxId).then((sandbox) => sandbox.stop(operationTimeout)).catch(() => void 0);
-    },
-    async destroy(target) {
-      await sandboxById(target.sandboxId).then((sandbox) => sandbox.delete(operationTimeout)).catch((err) => {
-        const status = err.response?.status ?? err.status;
-        if (status !== 404) throw err;
-      });
-    },
-    async snapshot(target) {
-      const sandbox = await sandboxById(target.sandboxId);
-      if (!sandbox._experimental_createSnapshot) {
-        throw new Error("Daytona sandbox client does not support filesystem snapshots");
-      }
-      const snapshotId = `claxedo-${target.workspaceId ?? target.sandboxId}-${Date.now()}`;
-      await sandbox._experimental_createSnapshot(snapshotId, operationTimeout);
-      return { snapshotId };
-    }
-  };
-}
-function network(input) {
-  if (!input.net || input.net.mode === "allow-all") return {};
-  const hosts = input.net.hosts ?? [];
-  if (hosts.length > 0) return { domainAllowList: formatDaytonaDomainAllowList(hosts) };
-  const cidrs = input.net.cidrs ?? [];
-  if (cidrs.length === 0) return { networkBlockAll: true };
-  return { networkAllowList: formatDaytonaAllowList(cidrs) };
-}
-export {
-  createDaytonaSandboxDriver
-};

package/dist/drivers/exe.d.ts

@@ -1,26 +0,0 @@
-import type { SandboxDriver, SandboxDriverEnsureInput } from "..";
-type ExeVm = {
-    vm_name: string;
-    https_url?: string;
-    ssh_dest?: string;
-    status?: string;
-    /** Provider-side tags, written at create — the durable half of our labels. */
-    tags?: string[];
-};
-export type ExeSandboxDriverOptions = {
-    apiToken: string;
-    endpoint?: string;
-    image?: string;
-    runtimeCommand?: string;
-    workspaceDir?: string;
-    runtimePort?: number;
-    runner?: string;
-    operationTimeoutMs?: number;
-    healthTimeoutMs?: number;
-    healthIntervalMs?: number;
-    fetchImpl?: typeof fetch;
-    env?: (input: SandboxDriverEnsureInput, vm: ExeVm) => Record<string, string> | Promise<Record<string, string>>;
-};
-export declare function exeWorkspaceName(workspaceId: string, epoch: number): string;
-export declare function createExeSandboxDriver(options: ExeSandboxDriverOptions): SandboxDriver;
-export {};