@sandboxrouter/sdk 0.1.0 → 0.2.0

package/README.md

@@ -1,85 +1,112 @@
 # sandboxrouter
 
-**OpenRouter for sandboxes.** One API for every place an AI agent can run code: Maritime, E2B, Daytona, Modal, Vercel Sandbox, Morph, Fly.io Sprites, Blaxel, Tensorlake and Runloop. Routes on price, latency or capability, and falls back to the next provider when one is down or rate-limited. Also drives desktops and phones for computer-use agents.
+**One API for every sandbox.** A free, open-source router for the places an AI agent can run code: Blaxel, Boat, Cloudflare, Daytona, E2B, exe.dev, Fly.io Sprites, HOPX, Maritime, Modal, Morph, Northflank, Runloop, Tensorlake and Vercel, plus Docker on your own machine. It picks a provider by price, speed or capability, and falls back to the next one when a provider is down or rate-limited.
 
 ```ts
 import { Router } from "@sandboxrouter/sdk";
 
-const router = new Router();                       // reads provider keys from env
+const router = new Router();                       // uses whichever provider keys you've set
 await using sbx = await router.create({ vcpu: 2, memoryGb: 4 });
 
 const r = await sbx.exec("python3 -c 'print(6*7)'");
-console.log(r.stdout, "ran on", sbx.provider);     // 42 ran on maritime
+console.log(r.stdout, "ran on", sbx.provider);
 ```
 
 Change providers without changing code. If one returns a 429, the next one takes the sandbox.
 
+Site: [sandboxrouter.vercel.app](https://sandboxrouter.vercel.app) · npm: [`@sandboxrouter/sdk`](https://www.npmjs.com/package/@sandboxrouter/sdk)
+
 ## Why
 
-Agents need a disposable computer: to run code a model wrote, install packages, run tests, scrape, or do an RL rollout. In 2026 there are more than a dozen sandbox providers, each with its own SDK, auth, lifecycle and price. A 2 vCPU / 4 GB box costs anywhere from **$0.022/hr to $0.34/hr** depending on where you start it.
+Agents need a disposable computer: to run code a model wrote, install packages, run tests, scrape, or do an RL rollout. There are more than a dozen sandbox providers, each with its own SDK, auth, lifecycle and price, and the same 2 vCPU / 4 GB box costs anywhere from a few cents to over thirty cents an hour.
 
 So every agent team either locks into one provider or writes its own adapter layer. sandboxrouter is that adapter layer, done once, in the open:
 
 - **One interface.** `create`, `exec`, `writeFile`, `readFile`, `pause`, `kill`, the same on every provider. `exec` streams stdout and stderr as they happen.
-- **Routing.** `default` (catalog order), `cheapest` (by list price for your shape) or `fastest` (by your own measured cold starts).
+- **Routing.** `cheapest` (the default: lowest list price for your size) or `fastest` (lowest cold start you measured with `bench`), or name providers yourself.
 - **Fallback.** A failed create moves to the next candidate, and every attempt is recorded on `sbx.attempts`.
 - **Capability filters.** Ask for a GPU and only GPU-capable providers are tried. Ask for 32 vCPU and providers that can't do it are skipped, with the reason.
-- **BYOK.** Your keys and your accounts. Nothing is proxied through a third party.
+- **Your keys.** Your accounts, your bills. Nothing is proxied through a third party.
 - **HTTP server and Python client.** Run `sandboxrouter serve` and any language gets the same API.
-- **Computers.** Linux and Windows desktops and Android phones for computer-use models: actions, screenshots, and a takeover link for a person when the model hits a login.
-- **Open leaderboard.** `bench --share` produces a report; the leaderboard is built from submitted reports in [`results/`](results/).
+- **Computers.** Desktops and phones for computer-use models (Maritime today): actions, screenshots, and a takeover link for a person when the model hits a login.
+- **Open benchmark.** `bench --share` produces a report; cold starts on the site come from reports submitted to [`results/`](results/).
+
+## Fair by construction
+
+No provider gets a better slot, and none pays for placement.
+
+- With no strategy, a sandbox goes to the **lowest list price for the size you asked for**, among providers you have keys for. Ties break **alphabetically**.
+- `fastest` uses only cold starts **you** measured with `bench`, then price.
+- Prices are each provider's public rate, with a source link, in [`src/catalog.ts`](src/catalog.ts). There's a test that the catalog has no privileged ordering.
+- Docker is never picked automatically, because it always "costs" $0 and isolates less than a cloud micro-VM. Name it to use it.
+
+If a price is wrong, open a PR with the source link.
 
 ## Prices
 
-Estimated list price while running, 2 vCPU / 4 GB (`npx @sandboxrouter/sdk providers --vcpu 2 --memory 4`):
+Estimated list price while running, 2 vCPU / 4 GB (`npx @sandboxrouter/sdk providers --vcpu 2 --memory 4`), in the order the router would try them:
 
 | Provider | $/hr | Notes | Source |
 |---|---|---|---|
-| **Maritime** | **$0.022** | Per second, disk included. Firecracker micro-VMs. Also runs stock E2B SDK code. | [pricing](https://maritime.sh/pricing) |
-| Morph Cloud | $0.100 | $0.05 per MCU; an MCU-hour is the larger of 1 vCPU, 4 GB RAM or 16 GB disk. | [pricing](https://cloud.morph.so/web/pricing) |
-| Fly.io Sprites | $0.165 | Bills actual CPU and memory use; this is the full-use price. Storage extra. | [pricing](https://fly.io/sprites) |
-| E2B | $0.166 | Per second. Pro plan $150/mo. | [pricing](https://e2b.dev/pricing) |
-| Daytona | $0.166 | Per second, plus disk above 5 GiB. | [pricing](https://www.daytona.io/pricing) |
-| Blaxel | $0.166 | Billed on memory only; CPU scales with memory. | [pricing](https://blaxel.ai/pricing) |
-| Tensorlake | $0.200 | Bills active CPU (20% floor); this is the full-use price. Pro plan is cheaper. | [pricing](https://www.tensorlake.ai/pricing) |
-| Modal | $0.239 | Sandbox rates. GPUs available. | [pricing](https://modal.com/pricing) |
-| Runloop | $0.317 | Per second, plus disk. Suspend/resume is a Pro feature. | [pricing](https://www.runloop.ai/pricing) |
-| Vercel Sandbox | $0.341 | Bills active CPU only. This is the 100%-CPU price; mostly idle work costs less. | [pricing](https://vercel.com/docs/vercel-sandbox/pricing) |
-
-Checked 2026-11-04. Prices live in [`src/catalog.ts`](src/catalog.ts). If one is wrong, open a PR with the source link.
-
-**Why Maritime is the default:** it's first in catalog order because it's the cheapest per hour at every shape in this table (there's a test that checks this against the catalog), so `default` and `cheapest` agree. Don't take that on trust: run `sandboxrouter bench` on your own accounts and route with `strategy: "fastest"` if latency matters more to you than price.
+| Boat | $0.018 | Fixed sizes billed per second ($0.018/h for 2 vCPU / 4 GB up to $0.20/h for 16 / 32); needs a plan from $20/mo, paid back as VM time | [pricing](https://docs.boat.dev/pricing.md) |
+| Maritime | $0.022 | Per second, disk included | [pricing](https://maritime.sh/pricing) |
+| Northflank | $0.067 | Per second on Northflank Cloud, ephemeral disk included; sandboxes run as deployment services (microVMs) | [pricing](https://northflank.com/pricing) |
+| Morph Cloud | $0.100 | $0.05/MCU; MCU-hours = max(vCPU, RAM/4 GB, disk/16 GB); snapshots extra | [pricing](https://cloud.morph.so/web/pricing) |
+| exe.dev | $0.105 | $0.105/h per 2 vCPU + 4 GiB, per second, up to 2 GiB per vCPU; needs an exe.dev subscription | [pricing](https://exe.dev/docs/standalone-vms.md) |
+| Fly.io Sprites | $0.164 | Bills actual CPU and memory use; this is the full-use price; storage extra | [pricing](https://fly.io/sprites) |
+| Blaxel | $0.166 | Billed on memory only ($0.0000115/GB-s), CPU scales with memory (~2 GB per core) | [pricing](https://blaxel.ai/pricing) |
+| Daytona | $0.166 | Per second, plus disk above 5 GiB | [pricing](https://www.daytona.io/pricing) |
+| E2B | $0.166 | Per second; Pro plan $150/mo | [pricing](https://e2b.dev/pricing) |
+| HOPX | $0.166 | Per second, plus storage; size comes from the template, not the request | [pricing](https://hopx.ai/pricing) |
+| Tensorlake | $0.200 | Bills active CPU (floor 20% of allocation); this is the full-use price; Pro plan is lower | [pricing](https://www.tensorlake.ai/pricing) |
+| Cloudflare Sandbox | $0.216 | Bills active CPU and provisioned memory of the instance type; this is the full-CPU price; needs Workers Paid ($5/mo) and the bridge Worker in bridges/cloudflare | [pricing](https://developers.cloudflare.com/containers/platform/pricing/) |
+| Modal | $0.239 | Sandbox rates, GPUs extra; region pinning x1.15-1.75 | [pricing](https://modal.com/pricing) |
+| Runloop | $0.317 | Per second, plus disk; pause (suspend) is a Pro-plan feature | [pricing](https://www.runloop.ai/pricing) |
+| Vercel Sandbox | $0.341 | Bills active CPU only; this is the 100%-CPU price, idle work costs less | [pricing](https://vercel.com/docs/vercel-sandbox/pricing) |
+| Docker (local) | free | Runs on your own machine; free, but shares your kernel, so weaker isolation than a cloud micro-VM | [pricing](https://docs.docker.com/engine/) |
+
+Checked 2026-11-04.
 
 ## Install
 
 ```bash
 npm i @sandboxrouter/sdk
-# then install the SDK of each provider you use (Maritime needs none, it's plain REST):
-npm i e2b                 # E2B
-npm i @daytonaio/sdk      # Daytona
-npm i modal               # Modal
-npm i @vercel/sandbox     # Vercel Sandbox
-npm i morphcloud          # Morph Cloud
-npm i @fly/sprites        # Fly.io Sprites (needs Node 24+ per its package)
-npm i @blaxel/core        # Blaxel
+# then the SDK of each provider you use (Boat, Cloudflare, exe.dev, Maritime and Docker need none):
+npm i e2b                       # E2B
+npm i @daytonaio/sdk            # Daytona
+npm i modal                     # Modal
+npm i @vercel/sandbox           # Vercel Sandbox
+npm i morphcloud                # Morph Cloud
+npm i @fly/sprites              # Fly.io Sprites (its package asks for Node 24+)
+npm i @blaxel/core              # Blaxel
 npm i @tensorlakeai/tensorlake  # Tensorlake
-npm i @runloop/api-client # Runloop
+npm i @runloop/api-client       # Runloop
+npm i @hopx-ai/sdk              # HOPX
+npm i @northflank/js-client     # Northflank
 ```
 
-Set the keys for the providers you want. Unconfigured providers are skipped.
+Cloudflare sandboxes only run inside a Cloudflare Worker, so you deploy a small bridge Worker to your own account first: see [`bridges/cloudflare`](bridges/cloudflare).
+
+Set the keys for the providers you want. Providers without keys are skipped.
 
 | Provider | Env |
 |---|---|
-| Maritime | `MARITIME_API_KEY` (an `mk_` key with the `sandboxes` scope: `maritime keys create`) |
-| E2B | `E2B_API_KEY` |
+| Blaxel | `BL_API_KEY` + `BL_WORKSPACE` |
+| Boat | `BOAT_API_KEY` |
+| Cloudflare Sandbox | `CLOUDFLARE_SANDBOX_URL` + `CLOUDFLARE_SANDBOX_TOKEN` |
 | Daytona | `DAYTONA_API_KEY` |
-| Modal | `MODAL_TOKEN_ID` + `MODAL_TOKEN_SECRET`, or `~/.modal.toml` |
-| Vercel | `VERCEL_OIDC_TOKEN`, or `VERCEL_TOKEN` + `VERCEL_TEAM_ID` + `VERCEL_PROJECT_ID` |
-| Morph | `MORPH_API_KEY` |
+| Docker (local) | none: Docker running locally |
+| E2B | `E2B_API_KEY` |
+| exe.dev | `EXE_TOKEN` |
 | Fly.io Sprites | `SPRITES_TOKEN` |
-| Blaxel | `BL_API_KEY` + `BL_WORKSPACE` (optional `BL_REGION`, default `us-pdx-1`) |
-| Tensorlake | `TENSORLAKE_API_KEY` |
+| HOPX | `HOPX_API_KEY` |
+| Maritime | `MARITIME_API_KEY` |
+| Modal | `MODAL_TOKEN_ID` + `MODAL_TOKEN_SECRET` |
+| Morph Cloud | `MORPH_API_KEY` |
+| Northflank | `NORTHFLANK_API_TOKEN` + `NORTHFLANK_PROJECT_ID` |
 | Runloop | `RUNLOOP_API_KEY` |
+| Tensorlake | `TENSORLAKE_API_KEY` |
+| Vercel Sandbox | `VERCEL_OIDC_TOKEN`, or `VERCEL_TOKEN` + `VERCEL_TEAM_ID` + `VERCEL_PROJECT_ID` |
 
 ## Library
 
@@ -218,18 +245,24 @@ with sr.create(vcpu=2, memory_gb=4, strategy="cheapest") as sbx:
 | Blaxel | memory (CPU follows) | `ttl` | image | yes (archive, disk only) | Idle sandboxes go to free standby on their own. |
 | Tensorlake | `cpus`, `memoryMb` | idle timeout | image | yes (memory + disk) | Output is line-based. |
 | Runloop | snapped to Runloop's custom sizes | `keep_alive_time_seconds` (max 48 h) | blueprint | yes (Pro plan) | Commands start in the home directory. |
+| HOPX | set by the template | timeout | template | yes (memory + disk) | Size requests aren't applied, so the router only sends default-size work. |
+| Northflank | cheapest `nf-compute` plan that fits | `expiryTime` (5 min to 7 days) | any public image | no | Runs as a deployment service; files move as base64 over exec. |
+| Cloudflare | smallest instance type that fits | alarm in the bridge Worker | Dockerfile in the bridge | no | Through the bridge Worker you deploy ([`bridges/cloudflare`](bridges/cloudflare)). |
+| Boat | smallest of 4 fixed sizes that fits | auto-stop timer | saved snapshot | yes (stop: disk kept, processes end) | Plain REST. Commands that wait are capped at 600 s; files API up to 5 MiB. |
+| exe.dev | `--cpu`, `--memory` (2 GiB per vCPU max) | none: `kill()` deletes | `--image` | no | Plain REST over exe.dev's `/exec`; long commands run detached and are polled. |
+| Docker (local) | `--cpus`, `--memory` | container exits at the lifetime | any image | yes (`docker pause`) | Your machine, shared kernel. Never auto-routed; use `{ provider: "docker" }`. |
 
 Capabilities in the catalog describe what each **adapter** implements, not everything a provider sells. Size limits are self-serve defaults and may be higher on your plan.
 
 ## Roadmap
 
-- [x] More providers: Morph, Fly.io Sprites, Blaxel, Tensorlake, Runloop
+- [x] More providers: Morph, Fly.io Sprites, Blaxel, Tensorlake, Runloop, HOPX, Northflank, Boat, exe.dev, Cloudflare (via a bridge Worker), Docker (local)
+- [x] Neutral routing: price decides, ties alphabetical, no privileged slot
 - [x] Desktops and phones (Maritime: Linux, Windows, Android)
 - [x] Streaming exec output
 - [x] Pause/resume where providers support it
 - [x] Python client
 - [x] Leaderboard built from `bench --share` reports
-- [ ] Cloudflare Sandbox. Its SDK runs only inside a Worker with a Durable Object binding, so it needs a small Worker shim the router can call
 - [ ] Computers on more providers (E2B Desktop, Daytona computer use)
 - [ ] Snapshots and forks as a routed operation
 - [ ] A hosted copy of the leaderboard page

package/dist/catalog.d.ts

@@ -16,16 +16,86 @@ export interface ProviderInfo {
         maxVcpu: number;
         maxMemoryGb: number;
     };
+    /** Runs on your own machine (Docker). Never chosen automatically; name it to use it. */
+    local?: boolean;
     /** Env vars the adapter reads. Any one group being fully set means "configured". */
     credentials: string[][];
     docs: string;
 }
-/**
- * Catalog order is the default routing order. Maritime is first because it is the cheapest
- * managed sandbox per hour in this list at every shape; `npx @sandboxrouter/sdk providers` prints the
- * numbers so you can check, and PRs that correct a price are welcome.
- */
 export declare const CATALOG: ProviderInfo[];
+/** Cloudflare only rents fixed instance types: https://developers.cloudflare.com/containers/platform/limits/ */
+export declare const CLOUDFLARE_INSTANCES: readonly [{
+    readonly name: "lite";
+    readonly vcpu: number;
+    readonly memoryGb: 0.25;
+}, {
+    readonly name: "basic";
+    readonly vcpu: number;
+    readonly memoryGb: 1;
+}, {
+    readonly name: "standard-1";
+    readonly vcpu: number;
+    readonly memoryGb: 4;
+}, {
+    readonly name: "standard-2";
+    readonly vcpu: 1;
+    readonly memoryGb: 6;
+}, {
+    readonly name: "standard-3";
+    readonly vcpu: 2;
+    readonly memoryGb: 8;
+}, {
+    readonly name: "standard-4";
+    readonly vcpu: 4;
+    readonly memoryGb: 12;
+}];
+/** Boat's fixed machine sizes and hourly prices: https://docs.boat.dev/machines.md */
+export declare const BOAT_SIZES: readonly [{
+    readonly type: "small";
+    readonly vcpu: 2;
+    readonly memoryGb: 4;
+    readonly usdHour: 0.018;
+}, {
+    readonly type: "default";
+    readonly vcpu: 4;
+    readonly memoryGb: 8;
+    readonly usdHour: 0.036;
+}, {
+    readonly type: "large";
+    readonly vcpu: 8;
+    readonly memoryGb: 16;
+    readonly usdHour: 0.072;
+}, {
+    readonly type: "xlarge";
+    readonly vcpu: 16;
+    readonly memoryGb: 32;
+    readonly usdHour: 0.2;
+}];
+export declare function cloudflareInstance(vcpu: number, memoryGb: number): {
+    readonly name: "lite";
+    readonly vcpu: number;
+    readonly memoryGb: 0.25;
+} | {
+    readonly name: "basic";
+    readonly vcpu: number;
+    readonly memoryGb: 1;
+} | {
+    readonly name: "standard-1";
+    readonly vcpu: number;
+    readonly memoryGb: 4;
+} | {
+    readonly name: "standard-2";
+    readonly vcpu: 1;
+    readonly memoryGb: 6;
+} | {
+    readonly name: "standard-3";
+    readonly vcpu: 2;
+    readonly memoryGb: 8;
+} | {
+    readonly name: "standard-4";
+    readonly vcpu: 4;
+    readonly memoryGb: 12;
+};
 export declare function info(id: ProviderId): ProviderInfo;
 export declare const DEFAULT_VCPU = 2;
 export declare const DEFAULT_MEMORY_GB = 4;

package/dist/catalog.js

@@ -1,9 +1,25 @@
 /**
- * Catalog order is the default routing order. Maritime is first because it is the cheapest
- * managed sandbox per hour in this list at every shape; `npx @sandboxrouter/sdk providers` prints the
- * numbers so you can check, and PRs that correct a price are welcome.
+ * Every provider is treated the same: the router orders candidates by list price for the requested
+ * size (or by your measured cold starts), ties broken alphabetically. Nobody gets a better slot.
+ * Prices come from each provider's public pricing page; PRs that correct one are welcome.
  */
-export const CATALOG = [
+const ENTRIES = [
+    {
+        id: "docker",
+        name: "Docker (local)",
+        pricing: {
+            vcpuHour: 0,
+            gbHour: 0,
+            note: "runs on your own machine; free, but shares your kernel, so weaker isolation than a cloud micro-VM",
+            source: "https://docs.docker.com/engine/",
+            checked: "2026-11-04",
+        },
+        capabilities: ["pause", "custom-image"],
+        limits: { maxVcpu: 64, maxMemoryGb: 256 },
+        local: true,
+        credentials: [],
+        docs: "https://docs.docker.com/engine/",
+    },
     {
         id: "maritime",
         name: "Maritime",
@@ -157,6 +173,99 @@ export const CATALOG = [
         docs: "https://docs.runloop.ai",
     },
 ];
+ENTRIES.push({
+    id: "boat",
+    name: "Boat",
+    pricing: {
+        vcpuHour: 0.009,
+        gbHour: 0,
+        note: "fixed sizes billed per second ($0.018/h for 2 vCPU / 4 GB up to $0.20/h for 16 / 32); needs a plan from $20/mo, paid back as VM time",
+        source: "https://docs.boat.dev/pricing.md",
+        checked: "2026-11-04",
+    },
+    // "pause" here is Boat's stop: the disk is kept, running processes end.
+    capabilities: ["pause", "custom-image"],
+    limits: { maxVcpu: 16, maxMemoryGb: 32 },
+    credentials: [["BOAT_API_KEY"]],
+    docs: "https://docs.boat.dev",
+}, {
+    id: "exedev",
+    name: "exe.dev",
+    pricing: {
+        vcpuHour: 0.0525,
+        gbHour: 0,
+        note: "$0.105/h per 2 vCPU + 4 GiB, per second, up to 2 GiB per vCPU; needs an exe.dev subscription",
+        source: "https://exe.dev/docs/standalone-vms.md",
+        checked: "2026-11-04",
+    },
+    capabilities: ["custom-image"],
+    limits: { maxVcpu: 16, maxMemoryGb: 32 },
+    credentials: [["EXE_TOKEN"]],
+    docs: "https://exe.dev/docs/https-api.md",
+}, {
+    id: "northflank",
+    name: "Northflank",
+    pricing: {
+        vcpuHour: 0.01667,
+        gbHour: 0.00833,
+        note: "per second on Northflank Cloud, ephemeral disk included; sandboxes run as deployment services (microVMs)",
+        source: "https://northflank.com/pricing",
+        checked: "2026-11-04",
+    },
+    capabilities: ["custom-image"],
+    limits: { maxVcpu: 8, maxMemoryGb: 16 },
+    credentials: [["NORTHFLANK_API_TOKEN", "NORTHFLANK_PROJECT_ID"]],
+    docs: "https://northflank.com/docs/v1/application/overview",
+}, {
+    id: "hopx",
+    name: "HOPX",
+    pricing: {
+        vcpuHour: 0.0504,
+        gbHour: 0.0162,
+        note: "per second, plus storage; size comes from the template, not the request",
+        source: "https://hopx.ai/pricing",
+        checked: "2026-11-04",
+    },
+    capabilities: ["pause", "custom-image"],
+    // HOPX takes no size at create; capped at the default size so bigger requests go elsewhere.
+    limits: { maxVcpu: 2, maxMemoryGb: 4 },
+    credentials: [["HOPX_API_KEY"]],
+    docs: "https://docs.hopx.ai",
+}, {
+    id: "cloudflare",
+    name: "Cloudflare Sandbox",
+    pricing: {
+        vcpuHour: 0.072,
+        gbHour: 0.009,
+        note: "bills active CPU and provisioned memory of the instance type; this is the full-CPU price; needs Workers Paid ($5/mo) and the bridge Worker in bridges/cloudflare",
+        source: "https://developers.cloudflare.com/containers/platform/pricing/",
+        checked: "2026-11-04",
+    },
+    capabilities: [],
+    limits: { maxVcpu: 4, maxMemoryGb: 12 },
+    credentials: [["CLOUDFLARE_SANDBOX_URL", "CLOUDFLARE_SANDBOX_TOKEN"]],
+    docs: "https://developers.cloudflare.com/sandbox/",
+});
+export const CATALOG = [...ENTRIES].sort((a, b) => a.name.localeCompare(b.name));
+/** Cloudflare only rents fixed instance types: https://developers.cloudflare.com/containers/platform/limits/ */
+export const CLOUDFLARE_INSTANCES = [
+    { name: "lite", vcpu: 1 / 16, memoryGb: 0.25 },
+    { name: "basic", vcpu: 1 / 4, memoryGb: 1 },
+    { name: "standard-1", vcpu: 1 / 2, memoryGb: 4 },
+    { name: "standard-2", vcpu: 1, memoryGb: 6 },
+    { name: "standard-3", vcpu: 2, memoryGb: 8 },
+    { name: "standard-4", vcpu: 4, memoryGb: 12 },
+];
+/** Boat's fixed machine sizes and hourly prices: https://docs.boat.dev/machines.md */
+export const BOAT_SIZES = [
+    { type: "small", vcpu: 2, memoryGb: 4, usdHour: 0.018 },
+    { type: "default", vcpu: 4, memoryGb: 8, usdHour: 0.036 },
+    { type: "large", vcpu: 8, memoryGb: 16, usdHour: 0.072 },
+    { type: "xlarge", vcpu: 16, memoryGb: 32, usdHour: 0.2 },
+];
+export function cloudflareInstance(vcpu, memoryGb) {
+    return CLOUDFLARE_INSTANCES.find((t) => t.vcpu >= vcpu && t.memoryGb >= memoryGb) ?? CLOUDFLARE_INSTANCES[CLOUDFLARE_INSTANCES.length - 1];
+}
 export function info(id) {
     const p = CATALOG.find((c) => c.id === id);
     if (!p)
@@ -176,6 +285,19 @@ export function hourlyCost(id, spec = {}) {
     // Blaxel sizes by memory, about 2 GB per core.
     if (id === "blaxel")
         mem = Math.max(mem, vcpu * 2);
+    // Boat rents the smallest fixed size that fits.
+    if (id === "boat") {
+        const s = BOAT_SIZES.find((b) => b.vcpu >= vcpu && b.memoryGb >= mem) ?? BOAT_SIZES[BOAT_SIZES.length - 1];
+        return s.usdHour;
+    }
+    // exe.dev bills per vCPU with up to 2 GiB each, so memory beyond that adds vCPUs.
+    if (id === "exedev")
+        return Math.max(Math.ceil(vcpu), Math.ceil(mem / 2)) * pricing.vcpuHour;
+    // Cloudflare bills the instance type that fits, not the exact request.
+    if (id === "cloudflare") {
+        const t = cloudflareInstance(vcpu, mem);
+        return t.vcpu * pricing.vcpuHour + t.memoryGb * pricing.gbHour;
+    }
     // Morph bills whole MCUs: the larger of vCPUs and 4 GB blocks of memory.
     if (id === "morph")
         return Math.max(vcpu, Math.ceil(mem / 4)) * pricing.vcpuHour;

package/dist/cli.js

@@ -21,7 +21,7 @@ Usage:
   sandboxrouter serve     [--port 8787] [--host 127.0.0.1] [--cors https://site.example,http://localhost:3000]
 
 Spec flags:   --vcpu N  --memory GB  --gpu T4  --timeout MIN
-Route flags:  --provider maritime[,e2b,...]  --strategy default|cheapest|fastest
+Route flags:  --provider e2b[,modal,...]  --strategy cheapest|fastest
               --no-fallback  --require gpu,custom-image
 
 Keys: MARITIME_API_KEY, E2B_API_KEY, DAYTONA_API_KEY, MODAL_TOKEN_ID+MODAL_TOKEN_SECRET,

package/dist/index.d.ts

@@ -14,4 +14,10 @@ export { SpritesProvider } from "./providers/sprites.js";
 export { BlaxelProvider } from "./providers/blaxel.js";
 export { TensorlakeProvider } from "./providers/tensorlake.js";
 export { RunloopProvider } from "./providers/runloop.js";
+export { DockerProvider } from "./providers/docker.js";
+export { HopxProvider } from "./providers/hopx.js";
+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 * from "./types.js";

package/dist/index.js

@@ -14,4 +14,10 @@ export { SpritesProvider } from "./providers/sprites.js";
 export { BlaxelProvider } from "./providers/blaxel.js";
 export { TensorlakeProvider } from "./providers/tensorlake.js";
 export { RunloopProvider } from "./providers/runloop.js";
+export { DockerProvider } from "./providers/docker.js";
+export { HopxProvider } from "./providers/hopx.js";
+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 * from "./types.js";

package/dist/providers/boat.d.ts

@@ -0,0 +1,25 @@
+import { type Provider, type ProviderSandbox, type SandboxSpec } from "../types.js";
+export declare class BoatProvider implements Provider {
+    private apiKey;
+    private baseUrl;
+    readonly id: "boat";
+    constructor(apiKey?: string | undefined, baseUrl?: string);
+    configured(): boolean;
+    /** @internal */
+    request(method: string, path: string, init?: {
+        json?: unknown;
+        headers?: Record<string, string>;
+    }): Promise<Response>;
+    /** @internal */
+    json<T>(method: string, path: string, json?: unknown, headers?: Record<string, string>): Promise<T>;
+    /** @internal Poll until the sandbox can take commands. Resumes it first when it is stopped. */
+    ready(id: string, timeoutMs?: number): Promise<BoatSandboxObject>;
+    create(spec: SandboxSpec): Promise<ProviderSandbox>;
+    connect(nativeId: string): Promise<ProviderSandbox>;
+}
+interface BoatSandboxObject {
+    id: string;
+    state: string;
+    error?: string | null;
+}
+export {};