@sandboxrouter/sdk 0.2.0 → 0.3.1

package/dist/computers.js

@@ -34,21 +34,147 @@ export class RoutedComputer {
     writeFile(path, content) {
         return this.c.writeFile(path, content);
     }
-    viewer(mode, opts) {
+    /** What this computer's provider supports beyond the core actions. */
+    get supports() {
+        return { viewer: typeof this.c.viewer === "function", sleep: typeof this.c.sleep === "function" };
+    }
+    async viewer(mode, opts) {
+        if (!this.c.viewer)
+            throw new RouterError(`${this.provider} has no shareable live view`);
         return this.c.viewer(mode, opts);
     }
-    sleep() {
-        return this.c.sleep();
+    async sleep() {
+        if (!this.c.sleep)
+            throw new RouterError(`${this.provider} can't sleep a computer; delete it instead`);
+        await this.c.sleep();
     }
     delete() {
         return this.c.delete();
     }
 }
-/** Pick a computer provider that offers this OS and has credentials, in the given order. */
+export const COMPUTER_ENTRIES = [
+    {
+        id: "maritime",
+        name: "Maritime",
+        os: { linux: 0.12, windows: 0.18, android: 0.15 },
+        note: "per second while awake; Starter $20/mo includes $20 usage; asleep pays $0.08/GB-month of disk; Windows needs Growth $100/mo incl. $100 usage",
+        source: "https://maritime.sh/pricing",
+        checked: "2026-11-05",
+        takeover: true,
+        size: "2 vCPU · 4 GB",
+        credentials: [["MARITIME_API_KEY"]],
+        docs: "https://maritime.sh/docs/computers",
+    },
+    {
+        id: "daytona",
+        name: "Daytona",
+        // (1 vCPU x $0.0504 + 1 GiB x $0.0162) per hour, billed per second; 3 GiB disk is inside the 5 GiB free
+        os: { linux: 0.0666 },
+        note: "per second while running; default container snapshot is 1 vCPU / 1 GiB / 3 GiB (daytona-small in daytona.io/docs/en/sandboxes), larger snapshots cost more; stopped keeps the disk ($0.000108/GiB-h past 5 GiB); live view is a signed noVNC preview URL, watch mode is client-side view-only; Windows needs a Tier 3 org, not routed",
+        source: "https://www.daytona.io/pricing",
+        checked: "2026-11-04",
+        takeover: true,
+        size: "1 vCPU · 1 GB",
+        credentials: [["DAYTONA_API_KEY"]],
+        docs: "https://www.daytona.io/docs/en/computer-use",
+    },
+    {
+        id: "e2b",
+        name: "E2B",
+        // (8 vCPU x $0.000014 + 8 GiB x $0.0000045) per second x 3600
+        os: { linux: 0.5328 },
+        note: "per second while running; the public `desktop` template is 8 vCPU / 8 GiB (cpu_count=8, memory_mb=8192 in github.com/e2b-dev/desktop template/build_prod.py); live view is noVNC with a password in the URL, watch mode is client-side view-only; Hobby caps a session at 1 h, Pro at 24 h",
+        source: "https://e2b.dev/pricing",
+        checked: "2026-11-04",
+        takeover: true,
+        size: "8 vCPU · 8 GB",
+        credentials: [["E2B_API_KEY"]],
+        docs: "https://docs.e2b.dev/use-cases/computer-use",
+    },
+];
+COMPUTER_ENTRIES.push({
+    id: "orgo",
+    name: "Orgo",
+    os: { linux: 0.055 },
+    planOnly: ["windows"],
+    size: "2 vCPU · 8 GB",
+    note: "Medium Linux by the hour from credit, billed per second; stopped pays only its 40 GB disk. Other sizes need a paid plan (Starter $29/mo). Windows is not hourly: Scale plan ($399/mo) or a $15/mo licence plus a Medium. The live view is a VNC websockify URL whose token is full control, for a noVNC client",
+    source: "https://www.orgo.ai/pricing.md",
+    checked: "2026-11-04",
+    takeover: false,
+    credentials: [["ORGO_API_KEY"]],
+    docs: "https://docs.orgo.ai/api-reference/introduction",
+});
+COMPUTER_ENTRIES.push({
+    id: "mobilerun",
+    name: "Mobilerun",
+    os: { android: 1.8 },
+    size: "Android cloud phone (virtual, EU)",
+    note: "$0.03 per device minute past the plan allowance (Developer $20/mo incl. 600 min, Startup $99, Scaleup $299); Free has 60 min/month; stopped phones keep apps and data and bill no minutes; live view is a WebRTC stream for @mobilerun/react, always controllable; no shell",
+    source: "https://mobilerun.ai/pricing",
+    checked: "2026-11-04",
+    takeover: true,
+    credentials: [["MOBILERUN_CLOUD_API_KEY"]],
+    docs: "https://docs.mobilerun.ai",
+}, {
+    id: "limrun",
+    name: "Limrun",
+    os: { android: 3.0, ios: 6.0 },
+    size: "Android 15 phone emulator / iPhone simulator",
+    note: "per-minute credits (Android 1/min, iOS 2/min); displayed hourly prices use paid overage $0.05/credit; optional no-subscription Trial overage $0.06/credit ($3.60/h Android, $7.20/h iOS); Trial 120 one-time credits, Entry $20/mo incl. 500, Individual $200/mo incl. 5,000; no pause, idle devices deleted at timeout; interactive stream; iOS has no shell",
+    source: "https://limrun.com/pricing",
+    checked: "2026-11-05",
+    takeover: true,
+    credentials: [["LIM_API_KEY"]],
+    docs: "https://docs.limrun.com/docs/reference/sdk.md",
+});
+COMPUTER_ENTRIES.push({
+    id: "aws-workspaces",
+    name: "AWS WorkSpaces (agent access)",
+    // stream.standard.medium (AWS's own agent-access example size) + the $0.05/h MCP session fee, us-east-1
+    os: { windows: 0.15, linux: 0.138 },
+    size: "2 vCPU · 4 GB (stream.standard.medium)",
+    note: "us-east-1, Always-On/On-Demand fleet you provision once (fleet + stack), plus $0.05/h MCP session fee (first 10 h per region per month free); Windows adds $6.42 per AI-agent user per month; watch link is truly view-only but a person can't take control; no shell or files",
+    source: "https://aws.amazon.com/workspaces/applications/pricing/",
+    checked: "2026-11-04",
+    takeover: false,
+    credentials: [["AWS_REGION", "WORKSPACES_AGENT_STACK", "WORKSPACES_AGENT_FLEET"]],
+    docs: "https://docs.aws.amazon.com/appstream2/latest/developerguide/agent-access-mcp-server.html",
+});
+export function computerCatalog() {
+    return [...COMPUTER_ENTRIES].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function computerHourly(id, os) {
+    return COMPUTER_ENTRIES.find((e) => e.id === id)?.os[os];
+}
+/** The order a computer create would try, with the reason any provider is skipped. */
+export function planComputer(providers, os = "linux", prefer) {
+    const ids = prefer ?? providers.map((p) => p.id);
+    const list = ids.map((id) => {
+        const p = providers.find((x) => x.id === id);
+        const c = { provider: id, estimatedHourlyUsd: computerHourly(id, os) };
+        if (!p)
+            c.skip = "unknown provider";
+        else if (!p.computerOs.includes(os))
+            c.skip = `no ${os} computers`;
+        else if (!p.configured())
+            c.skip = "not configured";
+        return c;
+    });
+    if (!prefer) {
+        list.sort((a, b) => (a.estimatedHourlyUsd ?? Infinity) - (b.estimatedHourlyUsd ?? Infinity) || a.provider.localeCompare(b.provider));
+    }
+    return list;
+}
+/**
+ * Start a computer on the cheapest provider that offers this OS and has credentials (ties
+ * alphabetical), falling back down the list. An explicit `prefer` list keeps its order.
+ */
 export async function createComputer(providers, spec = {}, prefer) {
     const os = spec.os ?? "linux";
-    const ordered = prefer ? prefer.map((id) => providers.find((p) => p.id === id)).filter((p) => !!p) : providers;
-    const usable = ordered.filter((p) => p.computerOs.includes(os) && p.configured());
+    const usable = planComputer(providers, os, prefer)
+        .filter((c) => !c.skip)
+        .map((c) => providers.find((p) => p.id === c.provider));
     if (usable.length === 0) {
         const offering = providers.filter((p) => p.computerOs.includes(os)).map((p) => p.id);
         throw new RouterError(offering.length ? `no configured provider for a ${os} computer (offered by: ${offering.join(", ")})` : `no provider offers a ${os} computer`);

package/dist/conformance.d.ts

@@ -0,0 +1,46 @@
+import { type CheckReport, type CheckStatus } from "./check.js";
+import type { ProviderId } from "./types.js";
+/** A `sandboxrouter check --save` file: one real run of every check step on one provider. */
+export interface SavedCheck extends CheckReport {
+    tool: "sandboxrouter-check";
+    version: string;
+    date: string;
+    platform: string;
+}
+export interface ConformanceRow {
+    provider: ProviderId;
+    name: string;
+    /** Null when nobody has saved a real run for this provider yet. */
+    run: null | {
+        date: string;
+        version: string;
+        passed: number;
+        /** Steps that ran and failed, with why. */
+        failed: {
+            step: string;
+            detail?: string;
+        }[];
+        /** Steps that don't apply (pause on adapters without it). */
+        skipped: string[];
+        /** Steps added to `check` after this run, so not covered by it. */
+        notRun: string[];
+        /** Steps that passed with a caveat, e.g. output only arrives at the end. */
+        notes: {
+            step: string;
+            detail?: string;
+        }[];
+        steps: Record<string, CheckStatus | "not run">;
+    };
+}
+/**
+ * One-word status of a provider's last real-account run, for tables: "passed" (every step that applies),
+ * "failing" (the last run had failures), or "untested" (only mock-tested; no real run saved yet).
+ */
+export declare function liveStatus(row: ConformanceRow): {
+    status: "passed" | "failing" | "untested";
+    label: string;
+};
+/** Saved check runs in `dir` (default results/conformance), keyed by provider. */
+export declare function loadConformance(dir?: string): Map<ProviderId, SavedCheck>;
+/** One row per sandbox provider in the catalog, scored against the current list of check steps. */
+export declare function conformanceTable(saved?: Map<ProviderId, SavedCheck>): ConformanceRow[];

package/dist/conformance.js

@@ -0,0 +1,65 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { CATALOG } from "./catalog.js";
+import { CHECK_STEPS } from "./check.js";
+/**
+ * One-word status of a provider's last real-account run, for tables: "passed" (every step that applies),
+ * "failing" (the last run had failures), or "untested" (only mock-tested; no real run saved yet).
+ */
+export function liveStatus(row) {
+    const r = row.run;
+    if (!r)
+        return { status: "untested", label: "not run yet" };
+    const day = r.date.slice(0, 10);
+    if (r.failed.length)
+        return { status: "failing", label: `failed ${r.failed.length} step${r.failed.length > 1 ? "s" : ""} (${day})` };
+    return { status: "passed", label: `passed (${day})` };
+}
+/** Saved check runs in `dir` (default results/conformance), keyed by provider. */
+export function loadConformance(dir = "results/conformance") {
+    const out = new Map();
+    let files;
+    try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return out;
+    }
+    for (const f of files) {
+        try {
+            const r = JSON.parse(readFileSync(join(dir, f), "utf8"));
+            if (r?.tool === "sandboxrouter-check" && Array.isArray(r.results))
+                out.set(r.provider, r);
+        }
+        catch {
+            // Not a check file.
+        }
+    }
+    return out;
+}
+/** One row per sandbox provider in the catalog, scored against the current list of check steps. */
+export function conformanceTable(saved = loadConformance()) {
+    return CATALOG.map((c) => {
+        const r = saved.get(c.id);
+        if (!r)
+            return { provider: c.id, name: c.name, run: null };
+        const by = new Map(r.results.map((x) => [x.step, x]));
+        const steps = Object.fromEntries(CHECK_STEPS.map((s) => [s, by.get(s)?.status ?? "not run"]));
+        const pick = (st) => r.results.filter((x) => x.status === st);
+        return {
+            provider: c.id,
+            name: c.name,
+            run: {
+                date: r.date,
+                version: r.version,
+                passed: pick("pass").length + pick("info").length,
+                failed: pick("fail").map((x) => ({ step: x.step, detail: x.detail })),
+                skipped: pick("skip").map((x) => x.step),
+                // A failed create ends the run early; that's a failure, not missing coverage.
+                notRun: by.get("create")?.status === "fail" ? [] : CHECK_STEPS.filter((s) => !by.has(s)),
+                notes: pick("info").map((x) => ({ step: x.step, detail: x.detail })),
+                steps,
+            },
+        };
+    });
+}

package/dist/cost.d.ts

@@ -0,0 +1,67 @@
+import { Router } from "./router.js";
+import type { ProviderId, SandboxSpec } from "./types.js";
+/**
+ * Real-cost check: does what a provider bills match what the catalog predicts?
+ *
+ * `costRun` starts one sandbox per provider at a known size, measures the size it really got
+ * (nproc, MemTotal), keeps every core busy for a fixed time (some providers bill active CPU only),
+ * kills it, and records the predicted cost from list price × wall time. `settle` later reads what
+ * the provider actually charged for that sandbox from its usage API, where it has one. Billing
+ * lags (Blaxel minutes, Daytona up to 48 h), so settle can be run again until every row has a bill.
+ */
+export interface Delivered {
+    vcpu: number;
+    memoryMb: number;
+}
+export interface Bill {
+    /** What the provider says it charged for this sandbox, USD. Undefined when it can't be read. */
+    usd?: number;
+    /** Seconds the provider billed, when it reports them. */
+    seconds?: number;
+    /** Where the number came from, or why there is none. */
+    source: string;
+    at: string;
+}
+export interface CostEntry {
+    provider: ProviderId;
+    sandboxId?: string;
+    requested: {
+        vcpu: number;
+        memoryGb: number;
+    };
+    delivered?: Delivered;
+    startedAt?: string;
+    endedAt?: string;
+    /** Wall time from the create call until kill returned. */
+    seconds?: number;
+    /** Catalog list price for the requested size. */
+    listUsdHour: number;
+    predictedUsd?: number;
+    /** Catalog list price for the size the sandbox really had. */
+    deliveredUsdHour?: number;
+    error?: string;
+    bill?: Bill;
+}
+export interface CostRun {
+    tool: "sandboxrouter-cost";
+    version: string;
+    date: string;
+    minutes: number;
+    load: boolean;
+    entries: CostEntry[];
+}
+export declare function costRun(opts: {
+    providers: ProviderId[];
+    minutes: number;
+    spec?: SandboxSpec;
+    load?: boolean;
+    router?: Router;
+    version: string;
+    onProgress?: (msg: string) => void;
+}): Promise<CostRun>;
+type Reader = (e: CostEntry) => Promise<Omit<Bill, "at">>;
+/** Per-provider readers of the real charge for one sandbox. */
+export declare const BILL_READERS: Partial<Record<ProviderId, Reader>>;
+export declare function settle(run: CostRun): Promise<CostRun>;
+export declare function costMarkdown(run: CostRun): string;
+export {};

package/dist/cost.js

@@ -0,0 +1,153 @@
+import { fittingSpec, hourlyCost } from "./catalog.js";
+import { Router } from "./router.js";
+const PROBE = `echo "$(nproc) $(awk '/MemTotal/{printf "%d", $2/1024}' /proc/meminfo)"`;
+// One `yes` per core, detached so the exec returns; they die with the sandbox.
+const LOAD = `nohup sh -c 'for i in $(seq $(nproc)); do yes > /dev/null & done; wait' > /dev/null 2>&1 &`;
+const round = (n, d = 6) => Math.round(n * 10 ** d) / 10 ** d;
+export async function costRun(opts) {
+    const router = opts.router ?? new Router();
+    const load = opts.load ?? true;
+    const log = opts.onProgress ?? (() => { });
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    const one = async (provider) => {
+        // Asked-for size, or else one the provider can take: its default size if that's fixed.
+        const sized = opts.spec?.vcpu !== undefined || opts.spec?.memoryGb !== undefined;
+        const { vcpu, memoryGb } = sized ? { vcpu: opts.spec?.vcpu ?? 2, memoryGb: opts.spec?.memoryGb ?? 4 } : fittingSpec(provider);
+        const entry = { provider, requested: { vcpu, memoryGb }, listUsdHour: hourlyCost(provider, { vcpu, memoryGb }) };
+        let box;
+        const t0 = Date.now();
+        try {
+            entry.startedAt = new Date(t0).toISOString();
+            box = await router.create({ vcpu, memoryGb, timeoutMinutes: opts.minutes + 10 }, { provider, fallback: false });
+            entry.sandboxId = box.nativeId;
+            const [cpus, mem] = (await box.exec(PROBE)).stdout.trim().split(/\s+/).map(Number);
+            if (cpus > 0 && mem > 0) {
+                entry.delivered = { vcpu: cpus, memoryMb: mem };
+                entry.deliveredUsdHour = round(hourlyCost(provider, { vcpu: cpus, memoryGb: mem / 1024 }));
+            }
+            if (load)
+                await box.exec(LOAD);
+            log(`${provider}: running ${box.nativeId} for ${opts.minutes} min`);
+            await sleep(opts.minutes * 60_000 - (Date.now() - t0));
+        }
+        catch (err) {
+            entry.error = err.message.slice(0, 300);
+            log(`${provider}: ${entry.error}`);
+        }
+        finally {
+            if (box) {
+                await box.kill().catch((e) => (entry.error = `kill failed: ${e.message.slice(0, 200)}`));
+                const t1 = Date.now();
+                entry.endedAt = new Date(t1).toISOString();
+                entry.seconds = Math.round((t1 - t0) / 1000);
+                entry.predictedUsd = round((entry.listUsdHour * entry.seconds) / 3600);
+            }
+        }
+        return entry;
+    };
+    const entries = await Promise.all(opts.providers.map(one));
+    return { tool: "sandboxrouter-cost", version: opts.version, date: new Date().toISOString(), minutes: opts.minutes, load, entries };
+}
+async function getJson(url, headers) {
+    const r = await fetch(url, { headers, signal: AbortSignal.timeout(30_000) });
+    if (!r.ok)
+        throw new Error(`${r.status} ${(await r.text()).slice(0, 200)}`);
+    return r.json();
+}
+const hourFloor = (iso) => new Date(Math.floor(Date.parse(iso) / 3_600_000) * 3_600_000).toISOString();
+const hourCeil = (iso) => new Date(Math.ceil(Date.parse(iso) / 3_600_000 + 1) * 3_600_000).toISOString();
+/** Per-provider readers of the real charge for one sandbox. */
+export const BILL_READERS = {
+    async daytona(e) {
+        const h = { Authorization: `Bearer ${process.env.DAYTONA_API_KEY}` };
+        const api = process.env.DAYTONA_API_URL ?? "https://app.daytona.io/api";
+        const { organizationId } = await getJson(`${api}/api-keys/current`, h);
+        const q = new URLSearchParams({ from: hourFloor(e.startedAt), to: hourCeil(e.endedAt) });
+        const rows = await getJson(`https://analytics.app.daytona.io/organization/${organizationId}/usage/sandbox?${q}`, h);
+        const row = rows.find((r) => r.sandboxId === e.sandboxId);
+        if (!row)
+            return { source: "daytona usage API: not posted yet (can take up to 48 h)" };
+        const seconds = row.firstStart && row.lastEnd ? Math.round((Date.parse(row.lastEnd) - Date.parse(row.firstStart)) / 1000) : undefined;
+        return { usd: round(row.totalPrice), seconds, source: "daytona analytics /usage/sandbox totalPrice" };
+    },
+    async blaxel(e) {
+        const h = { Authorization: `Bearer ${process.env.BL_API_KEY}` };
+        if (process.env.BL_WORKSPACE)
+            h["X-Blaxel-Workspace"] = process.env.BL_WORKSPACE;
+        const [acct] = await getJson("https://api.blaxel.ai/v0/accounts", h);
+        const q = new URLSearchParams({ startTime: hourFloor(e.startedAt), endTime: hourCeil(e.endedAt), groupBy: "resource_name" });
+        const j = await getJson(`https://api.blaxel.ai/v0/accounts/${acct.metadata.id}/metrics?${q}`, h);
+        const row = (j.data ?? []).find((d) => d.resourceName === e.sandboxId);
+        if (!row)
+            return { source: "blaxel metrics API: not posted yet (lags a few minutes)" };
+        return { usd: round(row.summary?.cost ?? 0), source: "blaxel /metrics cost (USD)" };
+    },
+    async maritime(e) {
+        const h = { Authorization: `Bearer ${process.env.MARITIME_API_KEY}` };
+        const api = process.env.MARITIME_API_URL ?? "https://api.maritime.sh";
+        const j = await getJson(`${api}/api/billing/metered-usage`, h);
+        const days = j.byMachineDay?.[`sandbox:${e.sandboxId}`] ?? [];
+        if (!days.length)
+            return { source: "maritime metered-usage: not posted yet" };
+        const cents = days.reduce((n, d) => n + (d.cents ?? 0), 0);
+        const seconds = days.reduce((n, d) => n + (d.seconds ?? 0), 0);
+        const model = j.plan ? `plan ${j.plan}` : "no usage plan on this account";
+        return { usd: round(cents / 100), seconds: Math.round(seconds), source: `maritime metered-usage (integer cents; ${model})` };
+    },
+    async sail(e) {
+        const h = { Authorization: `Bearer ${process.env.SAIL_API_KEY}` };
+        const api = (process.env.SAILBOX_API_URL ?? "https://sailbox-api.sailresearch.com").replace(/\/+$/, "").replace(/\/v1$/, "");
+        const q = new URLSearchParams({ from: hourFloor(e.startedAt), to: hourCeil(e.endedAt), sailbox_id: e.sandboxId });
+        const j = await getJson(`${api}/v1/sailboxes/spend?${q}`, h);
+        const row = (j.sailboxes ?? []).find((s) => s.sailbox_id === e.sandboxId);
+        if (!row)
+            return { source: "sail /sailboxes/spend: not posted yet (a few minutes)" };
+        const fees = j.creation_fees_waived ? "creation fee waived" : `${row.creation_count ?? 0} creation charge`;
+        return {
+            usd: round((row.cost_usd_nanos ?? 0) / 1e9),
+            seconds: Math.round(row.running_seconds ?? 0),
+            source: `sail /sailboxes/spend cost_usd_nanos (estimate at list rates; ${fees}; ${Math.round(row.vcpu_seconds ?? 0)} vCPU-s, ${Math.round(row.memory_gib_seconds ?? 0)} GiB-s)`,
+        };
+    },
+    async e2b() {
+        return { source: "no billing API: compare the console usage tab (console.e2b.dev, Usage)" };
+    },
+    async openscale() {
+        return { source: "no billing HTTP API: `openscale balance` before and after, or the dashboard" };
+    },
+};
+export async function settle(run) {
+    for (const e of run.entries) {
+        if (!e.sandboxId || !e.startedAt || !e.endedAt)
+            continue;
+        if (e.bill?.usd !== undefined)
+            continue;
+        const read = BILL_READERS[e.provider];
+        const at = new Date().toISOString();
+        if (!read) {
+            e.bill = { source: "no reader for this provider yet", at };
+            continue;
+        }
+        try {
+            e.bill = { ...(await read(e)), at };
+        }
+        catch (err) {
+            e.bill = { source: `could not read: ${err.message.slice(0, 200)}`, at };
+        }
+    }
+    return run;
+}
+const usd = (n) => (n === undefined ? "n/a" : n < 0.01 ? `$${n.toFixed(5)}` : `$${n.toFixed(4)}`);
+export function costMarkdown(run) {
+    const lines = [
+        "| Provider | Asked for | Got | Ran | Predicted (list × time) | Billed | Billed ÷ predicted | Source |",
+        "|---|---|---|---|---|---|---|---|",
+    ];
+    for (const e of run.entries) {
+        const got = e.delivered ? `${e.delivered.vcpu} vCPU / ${(e.delivered.memoryMb / 1024).toFixed(1)} GB` : "n/a";
+        const ratio = e.bill?.usd !== undefined && e.predictedUsd ? `${((e.bill.usd / e.predictedUsd) * 100).toFixed(0)}%` : "n/a";
+        const ran = e.seconds !== undefined ? `${e.seconds} s${e.bill?.seconds !== undefined ? ` (billed ${e.bill.seconds} s)` : ""}` : "n/a";
+        lines.push(`| ${e.provider} | ${e.requested.vcpu} vCPU / ${e.requested.memoryGb} GB | ${got} | ${ran} | ${usd(e.predictedUsd)} | ${usd(e.bill?.usd)} | ${ratio} | ${e.error ? `error: ${e.error}` : (e.bill?.source ?? "not settled")} |`);
+    }
+    return lines.join("\n");
+}

package/dist/gc.d.ts

@@ -0,0 +1,29 @@
+import type { LedgerEntry } from "./ledger.js";
+import type { Router } from "./router.js";
+export interface OpenSandbox extends LedgerEntry {
+    ageMinutes: number;
+    /** True once its requested lifetime has run out. */
+    expired: boolean;
+    /** List price times how long it has been up, capped at its lifetime (most providers stop it there). */
+    estimatedUsdSoFar: number;
+}
+export interface GcResult {
+    id: string;
+    action: "killed" | "gone" | "would kill" | "failed";
+    detail?: string;
+}
+/** Every sandbox in the router's ledger that hasn't been seen killed. */
+export declare function listOpen(router: Router, now?: number): OpenSandbox[];
+/** Errors that mean the sandbox no longer exists, so there is nothing left to kill. */
+export declare function isGone(err: unknown): boolean;
+/**
+ * Kill leaked sandboxes from the ledger. By default only those past their lifetime; `all` kills
+ * every open one; `olderThanMinutes` kills those up at least that long. A sandbox that turns out
+ * to be gone already is just dropped from the ledger.
+ */
+export declare function gc(router: Router, opts?: {
+    all?: boolean;
+    olderThanMinutes?: number;
+    dryRun?: boolean;
+    now?: number;
+}): Promise<GcResult[]>;

package/dist/gc.js

@@ -0,0 +1,54 @@
+import { ProviderError } from "./types.js";
+/** Every sandbox in the router's ledger that hasn't been seen killed. */
+export function listOpen(router, now = Date.now()) {
+    return (router.ledger?.list() ?? []).map((e) => {
+        const created = Date.parse(e.createdAt);
+        const expires = Date.parse(e.expiresAt);
+        const upMs = Math.max(0, Math.min(now, expires) - created);
+        return {
+            ...e,
+            ageMinutes: Math.round((now - created) / 60_000),
+            expired: now >= expires,
+            estimatedUsdSoFar: Math.round(e.usdHour * (upMs / 3_600_000) * 10_000) / 10_000,
+        };
+    });
+}
+/** Errors that mean the sandbox no longer exists, so there is nothing left to kill. */
+export function isGone(err) {
+    if (err instanceof ProviderError && (err.status === 404 || err.status === 410))
+        return true;
+    return /\b(404|410)\b|not found|no such|does not exist|doesn't exist|not exist|unknown sandbox|already (deleted|terminated|stopped)|\bgone\b/i.test(err?.message ?? String(err));
+}
+/**
+ * Kill leaked sandboxes from the ledger. By default only those past their lifetime; `all` kills
+ * every open one; `olderThanMinutes` kills those up at least that long. A sandbox that turns out
+ * to be gone already is just dropped from the ledger.
+ */
+export async function gc(router, opts = {}) {
+    const open = listOpen(router, opts.now);
+    const pick = open.filter((s) => opts.all || s.expired || (opts.olderThanMinutes !== undefined && s.ageMinutes >= opts.olderThanMinutes));
+    const results = [];
+    for (const s of pick) {
+        if (opts.dryRun) {
+            results.push({ id: s.id, action: "would kill", detail: s.expired ? "past its lifetime" : `up ${s.ageMinutes} min` });
+            continue;
+        }
+        try {
+            const box = await router.get(s.id);
+            await box.kill(); // closes the ledger entry
+            results.push({ id: s.id, action: "killed" });
+        }
+        catch (err) {
+            if (isGone(err)) {
+                router.ledger?.close(s.id, "gone");
+                results.push({ id: s.id, action: "gone", detail: err.message });
+            }
+            else {
+                results.push({ id: s.id, action: "failed", detail: err?.message ?? String(err) });
+            }
+        }
+    }
+    if (!opts.dryRun && results.length)
+        router.ledger?.compact();
+    return results;
+}

package/dist/index.d.ts

@@ -1,7 +1,11 @@
-export { Router, RoutedSandbox, defaultProviders, parseId, type Candidate, type RouterOptions } from "./router.js";
+export { checkProvider, CHECK_STEPS, type CheckReport, type CheckResult, type CheckStatus } from "./check.js";
+export { Ledger, defaultLedgerFile, type LedgerEntry } from "./ledger.js";
+export { conformanceTable, loadConformance, type ConformanceRow, type SavedCheck } from "./conformance.js";
+export { gc, listOpen, isGone, type GcResult, type OpenSandbox } from "./gc.js";
+export { Router, RoutedSandbox, defaultProviders, defaultComputerProviders, parseId, type Candidate, type RouterOptions } from "./router.js";
 export { CATALOG, hourlyCost, unfit, info, type ProviderInfo } from "./catalog.js";
 export { createApp } from "./server.js";
-export { RoutedComputer, createComputer, type ActionResult, type ComputerAction, type ComputerActionName, type ComputerInfo, type ComputerOs, type ComputerProvider, type ComputerSpec, type ProviderComputer, } from "./computers.js";
+export { RoutedComputer, createComputer, planComputer, computerCatalog, computerHourly, COMPUTER_ENTRIES, type ComputerCatalogEntry, type ComputerCandidate, type ComputerProviderId, type ActionResult, type ComputerAction, type ComputerActionName, type ComputerInfo, type ComputerOs, type ComputerProvider, type ComputerSpec, type ProviderComputer, } from "./computers.js";
 export { bench, benchMarkdown, type BenchRow } from "./bench.js";
 export { aggregate, loadReports, makeReport, renderLeaderboard, type BenchReport, type LeaderRow } from "./leaderboard.js";
 export { MaritimeProvider } from "./providers/maritime.js";
@@ -20,4 +24,26 @@ export { CloudflareProvider } from "./providers/cloudflare.js";
 export { NorthflankProvider } from "./providers/northflank.js";
 export { BoatProvider } from "./providers/boat.js";
 export { ExeDevProvider } from "./providers/exedev.js";
+export { AgentCoreProvider } from "./providers/agentcore.js";
+export { AzureSessionsProvider } from "./providers/azure.js";
+export { LambdaMicrovmProvider, writeLambdaMicrovmBundle } from "./providers/lambda.js";
+export { AlibabaProvider } from "./providers/alibaba.js";
+export { BeamProvider } from "./providers/beam.js";
+export { CodeSandboxProvider } from "./providers/codesandbox.js";
+export { DenoProvider } from "./providers/deno.js";
+export { FreestyleProvider } from "./providers/freestyle.js";
+export { KoyebProvider } from "./providers/koyeb.js";
+export { DedalusProvider } from "./providers/dedalus.js";
+export { OpenScaleProvider } from "./providers/openscale.js";
+export { SuperserveProvider } from "./providers/superserve.js";
+export { SailProvider } from "./providers/sail.js";
+export { InstaboxProvider, INSTABOX_SIZES, instaboxSize } from "./providers/instabox.js";
+export { Agent37Provider, AGENT37_SHAPES, agent37Shape } from "./providers/agent37.js";
+export { NovitaProvider } from "./providers/novita.js";
+export { LangSmithProvider, langsmithSize } from "./providers/langsmith.js";
+export { UpstashProvider } from "./providers/upstash.js";
+export { OrgoProvider } from "./providers/orgo.js";
+export { MobilerunProvider } from "./providers/mobilerun.js";
+export { LimrunProvider } from "./providers/limrun.js";
+export { WorkspacesAgentProvider } from "./providers/workspaces.js";
 export * from "./types.js";

package/dist/index.js

@@ -1,7 +1,11 @@
-export { Router, RoutedSandbox, defaultProviders, parseId } from "./router.js";
+export { checkProvider, CHECK_STEPS } from "./check.js";
+export { Ledger, defaultLedgerFile } from "./ledger.js";
+export { conformanceTable, loadConformance } from "./conformance.js";
+export { gc, listOpen, isGone } from "./gc.js";
+export { Router, RoutedSandbox, defaultProviders, defaultComputerProviders, parseId } from "./router.js";
 export { CATALOG, hourlyCost, unfit, info } from "./catalog.js";
 export { createApp } from "./server.js";
-export { RoutedComputer, createComputer, } from "./computers.js";
+export { RoutedComputer, createComputer, planComputer, computerCatalog, computerHourly, COMPUTER_ENTRIES, } from "./computers.js";
 export { bench, benchMarkdown } from "./bench.js";
 export { aggregate, loadReports, makeReport, renderLeaderboard } from "./leaderboard.js";
 export { MaritimeProvider } from "./providers/maritime.js";
@@ -20,4 +24,26 @@ export { CloudflareProvider } from "./providers/cloudflare.js";
 export { NorthflankProvider } from "./providers/northflank.js";
 export { BoatProvider } from "./providers/boat.js";
 export { ExeDevProvider } from "./providers/exedev.js";
+export { AgentCoreProvider } from "./providers/agentcore.js";
+export { AzureSessionsProvider } from "./providers/azure.js";
+export { LambdaMicrovmProvider, writeLambdaMicrovmBundle } from "./providers/lambda.js";
+export { AlibabaProvider } from "./providers/alibaba.js";
+export { BeamProvider } from "./providers/beam.js";
+export { CodeSandboxProvider } from "./providers/codesandbox.js";
+export { DenoProvider } from "./providers/deno.js";
+export { FreestyleProvider } from "./providers/freestyle.js";
+export { KoyebProvider } from "./providers/koyeb.js";
+export { DedalusProvider } from "./providers/dedalus.js";
+export { OpenScaleProvider } from "./providers/openscale.js";
+export { SuperserveProvider } from "./providers/superserve.js";
+export { SailProvider } from "./providers/sail.js";
+export { InstaboxProvider, INSTABOX_SIZES, instaboxSize } from "./providers/instabox.js";
+export { Agent37Provider, AGENT37_SHAPES, agent37Shape } from "./providers/agent37.js";
+export { NovitaProvider } from "./providers/novita.js";
+export { LangSmithProvider, langsmithSize } from "./providers/langsmith.js";
+export { UpstashProvider } from "./providers/upstash.js";
+export { OrgoProvider } from "./providers/orgo.js";
+export { MobilerunProvider } from "./providers/mobilerun.js";
+export { LimrunProvider } from "./providers/limrun.js";
+export { WorkspacesAgentProvider } from "./providers/workspaces.js";
 export * from "./types.js";