@sandboxrouter/sdk 0.0.0-stage → 0.2.0

package/dist/computers.js

@@ -0,0 +1,66 @@
+import { RouterError } from "./types.js";
+export class RoutedComputer {
+    provider;
+    c;
+    id;
+    constructor(provider, c) {
+        this.provider = provider;
+        this.c = c;
+        this.id = `${provider}:${c.nativeId}`;
+    }
+    get nativeId() {
+        return this.c.nativeId;
+    }
+    info() {
+        return this.c.info();
+    }
+    act(action) {
+        return this.c.act(action);
+    }
+    actBatch(actions) {
+        if (actions.length > 50)
+            throw new RouterError("at most 50 actions per batch");
+        return this.c.actBatch(actions);
+    }
+    screenshot(opts) {
+        return this.c.screenshot(opts);
+    }
+    exec(command, timeoutSeconds) {
+        return this.c.exec(command, timeoutSeconds);
+    }
+    readFile(path) {
+        return this.c.readFile(path);
+    }
+    writeFile(path, content) {
+        return this.c.writeFile(path, content);
+    }
+    viewer(mode, opts) {
+        return this.c.viewer(mode, opts);
+    }
+    sleep() {
+        return this.c.sleep();
+    }
+    delete() {
+        return this.c.delete();
+    }
+}
+/** Pick a computer provider that offers this OS and has credentials, in the given 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());
+    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`);
+    }
+    const errors = [];
+    for (const p of usable) {
+        try {
+            return new RoutedComputer(p.id, await p.createComputer({ ...spec, os }));
+        }
+        catch (err) {
+            errors.push(`${p.id}: ${err.message}`);
+        }
+    }
+    throw new RouterError(`all computer providers failed: ${errors.join(" | ")}`);
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { Router, RoutedSandbox, defaultProviders, 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 { 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";
+export { E2BProvider } from "./providers/e2b.js";
+export { DaytonaProvider } from "./providers/daytona.js";
+export { ModalProvider } from "./providers/modal.js";
+export { VercelProvider } from "./providers/vercel.js";
+export { MorphProvider } from "./providers/morph.js";
+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

@@ -0,0 +1,23 @@
+export { Router, RoutedSandbox, defaultProviders, parseId } from "./router.js";
+export { CATALOG, hourlyCost, unfit, info } from "./catalog.js";
+export { createApp } from "./server.js";
+export { RoutedComputer, createComputer, } from "./computers.js";
+export { bench, benchMarkdown } from "./bench.js";
+export { aggregate, loadReports, makeReport, renderLeaderboard } from "./leaderboard.js";
+export { MaritimeProvider } from "./providers/maritime.js";
+export { E2BProvider } from "./providers/e2b.js";
+export { DaytonaProvider } from "./providers/daytona.js";
+export { ModalProvider } from "./providers/modal.js";
+export { VercelProvider } from "./providers/vercel.js";
+export { MorphProvider } from "./providers/morph.js";
+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/leaderboard.d.ts

@@ -0,0 +1,39 @@
+import type { BenchRow } from "./bench.js";
+import type { ProviderId, SandboxSpec } from "./types.js";
+/**
+ * A shareable bench result. People submit these as PRs to results/, and `sandboxrouter
+ * leaderboard` renders every submission into one static page. No server, nothing to trust but
+ * the files in the repo.
+ */
+export interface BenchReport {
+    tool: "sandboxrouter";
+    version: string;
+    date: string;
+    /** Free text from the submitter, e.g. "us-east-1 c7g.large" or "Berlin, home fiber". */
+    label?: string;
+    runs: number;
+    spec: SandboxSpec;
+    node: string;
+    platform: string;
+    rows: BenchRow[];
+}
+export declare function makeReport(rows: BenchRow[], opts: {
+    version: string;
+    runs: number;
+    spec: SandboxSpec;
+    label?: string;
+}): BenchReport;
+export declare function loadReports(dir: string): BenchReport[];
+export interface LeaderRow {
+    provider: ProviderId;
+    name: string;
+    submissions: number;
+    medianCreateMs?: number;
+    medianExecMs?: number;
+    successRate: number;
+    hourlyUsd: number;
+}
+/** Median of each submission's medians, so one heavy submitter can't skew a provider. */
+export declare function aggregate(reports: BenchReport[]): LeaderRow[];
+/** One self-contained HTML page: a sorted table with an inline bar per measure, each on its own scale. */
+export declare function renderLeaderboard(reports: BenchReport[]): string;

package/dist/leaderboard.js

@@ -0,0 +1,184 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CATALOG, hourlyCost } from "./catalog.js";
+import { median } from "./bench-store.js";
+export function makeReport(rows, opts) {
+    return {
+        tool: "sandboxrouter",
+        version: opts.version,
+        date: new Date().toISOString(),
+        label: opts.label,
+        runs: opts.runs,
+        // Only the shape matters for comparison; never ship env or metadata.
+        spec: { vcpu: opts.spec.vcpu, memoryGb: opts.spec.memoryGb },
+        node: process.version,
+        platform: `${process.platform}-${process.arch}`,
+        rows: rows.map(({ lastError: _drop, ...r }) => r),
+    };
+}
+export function loadReports(dir) {
+    let files;
+    try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files.sort()) {
+        try {
+            const r = JSON.parse(readFileSync(join(dir, f), "utf8"));
+            if (r?.tool === "sandboxrouter" && Array.isArray(r.rows))
+                out.push(r);
+        }
+        catch {
+            /* skip unreadable files */
+        }
+    }
+    return out;
+}
+const KNOWN = new Set(CATALOG.map((c) => c.id));
+/** Median of each submission's medians, so one heavy submitter can't skew a provider. */
+export function aggregate(reports) {
+    const by = new Map();
+    for (const rep of reports)
+        for (const r of rep.rows)
+            if (KNOWN.has(r.provider))
+                by.set(r.provider, [...(by.get(r.provider) ?? []), r]);
+    const rows = [...by.entries()].map(([id, rs]) => {
+        const runs = rs.reduce((n, r) => n + r.runs, 0);
+        const ok = rs.reduce((n, r) => n + (r.runs - r.failures), 0);
+        return {
+            provider: id,
+            name: CATALOG.find((c) => c.id === id).name,
+            submissions: rs.length,
+            medianCreateMs: median(rs.map((r) => r.medianCreateMs).filter((n) => typeof n === "number")),
+            medianExecMs: median(rs.map((r) => r.medianExecMs).filter((n) => typeof n === "number")),
+            successRate: runs ? ok / runs : 0,
+            hourlyUsd: hourlyCost(id),
+        };
+    });
+    return rows.sort((a, b) => (a.medianCreateMs ?? Infinity) - (b.medianCreateMs ?? Infinity));
+}
+const esc = (s) => String(s).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+function bar(value, max, text, tip) {
+    if (value === undefined)
+        return `<td class="num muted">n/a</td>`;
+    const pct = max > 0 ? Math.max(1.5, (value / max) * 100) : 0;
+    return `<td class="barcell" tabindex="0" data-tip="${esc(tip)}" aria-label="${esc(tip)}">
+    <div class="track"><div class="bar" style="width:${pct.toFixed(1)}%"></div></div><span class="val">${esc(text)}</span></td>`;
+}
+/** One self-contained HTML page: a sorted table with an inline bar per measure, each on its own scale. */
+export function renderLeaderboard(reports) {
+    const rows = aggregate(reports);
+    const maxCreate = Math.max(0, ...rows.map((r) => r.medianCreateMs ?? 0));
+    const maxPrice = Math.max(0, ...rows.map((r) => r.hourlyUsd));
+    const dates = reports.map((r) => r.date).sort();
+    const span = dates.length ? `${dates[0].slice(0, 10)} to ${dates.at(-1).slice(0, 10)}` : "no submissions yet";
+    const body = rows
+        .map((r, i) => `<tr>
+  <td class="num rank">${i + 1}</td>
+  <th scope="row">${esc(r.name)}</th>
+  ${bar(r.medianCreateMs, maxCreate, r.medianCreateMs === undefined ? "" : `${r.medianCreateMs.toLocaleString("en-US")} ms`, `${r.name}: median cold start ${r.medianCreateMs} ms across ${r.submissions} submission${r.submissions === 1 ? "" : "s"}`)}
+  <td class="num">${r.medianExecMs === undefined ? "n/a" : `${r.medianExecMs} ms`}</td>
+  ${bar(r.hourlyUsd, maxPrice, `$${r.hourlyUsd.toFixed(3)}`, `${r.name}: $${r.hourlyUsd.toFixed(4)} per hour at list price, 2 vCPU / 4 GB`)}
+  <td class="num">${(r.successRate * 100).toFixed(0)}%</td>
+  <td class="num muted">${r.submissions}</td>
+</tr>`)
+        .join("\n");
+    const subs = reports
+        .map((r) => `<li>${esc(r.date.slice(0, 10))} · ${esc(r.label ?? "unlabeled")} · ${esc(r.platform)} · ${r.runs} runs · ${r.rows.length} providers</li>`)
+        .join("\n");
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>sandboxrouter leaderboard</title>
+<style>
+.viz-root {
+  color-scheme: light;
+  --page: #f9f9f7; --surface-1: #fcfcfb; --text-primary: #0b0b0b; --text-secondary: #52514e;
+  --text-muted: #898781; --grid: #e1e0d9; --baseline: #c3c2b7; --border: rgba(11,11,11,0.10);
+  --series-1: #2a78d6;
+}
+@media (prefers-color-scheme: dark) {
+  :root:where(:not([data-theme="light"])) .viz-root {
+    color-scheme: dark;
+    --page: #0d0d0d; --surface-1: #1a1a19; --text-primary: #f0efec; --text-secondary: #c3c2b7;
+    --text-muted: #898781; --grid: #2c2c2a; --baseline: #383835; --border: rgba(255,255,255,0.10);
+    --series-1: #3987e5;
+  }
+}
+:root[data-theme="dark"] .viz-root {
+  color-scheme: dark;
+  --page: #0d0d0d; --surface-1: #1a1a19; --text-primary: #f0efec; --text-secondary: #c3c2b7;
+  --text-muted: #898781; --grid: #2c2c2a; --baseline: #383835; --border: rgba(255,255,255,0.10);
+  --series-1: #3987e5;
+}
+* { box-sizing: border-box; }
+body { margin: 0; }
+.viz-root { background: var(--page); color: var(--text-primary); min-height: 100vh;
+  font: 15px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif; padding: 48px 24px; }
+main { max-width: 1040px; margin: 0 auto; }
+h1 { font-size: 28px; margin: 0 0 4px; letter-spacing: -0.01em; }
+.sub { color: var(--text-secondary); margin: 0 0 24px; }
+.card { background: var(--surface-1); border: 1px solid var(--border); border-radius: 12px; padding: 8px 16px; overflow-x: auto; }
+table { width: 100%; border-collapse: collapse; }
+caption { text-align: left; color: var(--text-muted); font-size: 13px; padding: 12px 0 4px; caption-side: bottom; }
+th, td { padding: 10px 8px; border-bottom: 1px solid var(--grid); text-align: left; white-space: nowrap; }
+thead th { color: var(--text-muted); font-weight: 500; font-size: 13px; border-bottom-color: var(--baseline); }
+tbody tr:last-child > * { border-bottom: 0; }
+tbody th { font-weight: 600; }
+.num { font-variant-numeric: tabular-nums; }
+.rank, .muted { color: var(--text-muted); }
+.barcell { min-width: 220px; position: relative; outline: none; }
+.barcell { display: table-cell; }
+.track { display: inline-block; vertical-align: middle; width: 140px; height: 12px; border-left: 1px solid var(--baseline); }
+.bar { height: 12px; background: var(--series-1); border-radius: 0 4px 4px 0; }
+.val { display: inline-block; vertical-align: middle; margin-left: 8px; color: var(--text-primary); font-variant-numeric: tabular-nums; }
+.barcell:hover .bar, .barcell:focus .bar { filter: brightness(1.12); }
+#tip { position: fixed; pointer-events: none; background: var(--surface-1); color: var(--text-primary);
+  border: 1px solid var(--border); border-radius: 8px; padding: 6px 10px; font-size: 13px;
+  box-shadow: 0 4px 16px rgba(0,0,0,0.12); opacity: 0; transition: opacity 80ms; max-width: 320px; white-space: normal; }
+.notes { color: var(--text-secondary); font-size: 14px; margin-top: 24px; }
+.notes ul { padding-left: 18px; color: var(--text-muted); }
+a { color: inherit; }
+</style>
+</head>
+<body class="viz-root">
+<main>
+  <h1>Sandbox cold starts</h1>
+  <p class="sub">Time from <code>create()</code> to a usable sandbox, measured by <a href="https://github.com/gigialc/sandboxrouter">sandboxrouter bench</a>. ${reports.length} submission${reports.length === 1 ? "" : "s"}, ${esc(span)}.</p>
+  <div class="card">
+    <table>
+      <thead><tr>
+        <th>#</th><th>Provider</th><th>Cold start (median)</th><th>Exec round trip</th>
+        <th>List price, 2 vCPU / 4 GB</th><th>Success</th><th>Submissions</th>
+      </tr></thead>
+      <tbody>
+${body || `<tr><td colspan="7" class="muted">No results yet. Run <code>npx @sandboxrouter/sdk bench --share</code> and open a PR.</td></tr>`}
+      </tbody>
+    </table>
+  </div>
+  <div class="notes">
+    <p>Sorted by cold start. Each bar column has its own scale. Cold start and exec are the median of each submission's medians, so one submitter can't dominate a provider. Latency includes the network between the submitter and each provider. Prices are list prices from each provider's pricing page (sources in <code>src/catalog.ts</code>); some bill active CPU only, so idle work costs less.</p>
+    <p>Submissions:</p>
+    <ul>${subs}</ul>
+  </div>
+</main>
+<div id="tip" role="tooltip"></div>
+<script>
+  const tip = document.getElementById("tip");
+  const show = (el, x, y) => { tip.textContent = el.dataset.tip; tip.style.left = (x + 14) + "px"; tip.style.top = (y + 14) + "px"; tip.style.opacity = 1; };
+  for (const el of document.querySelectorAll("[data-tip]")) {
+    el.addEventListener("mousemove", (e) => show(el, e.clientX, e.clientY));
+    el.addEventListener("mouseleave", () => (tip.style.opacity = 0));
+    el.addEventListener("focus", () => { const r = el.getBoundingClientRect(); show(el, r.left, r.bottom - 8); });
+    el.addEventListener("blur", () => (tip.style.opacity = 0));
+  }
+</script>
+</body>
+</html>
+`;
+}

package/dist/providers/blaxel.d.ts

@@ -0,0 +1,21 @@
+import { type Provider, type ProviderSandbox, type SandboxSpec } from "../types.js";
+/**
+ * Blaxel sandboxes via `@blaxel/core`. Auth: BL_API_KEY + BL_WORKSPACE (or `bl login`).
+ * Region: BL_REGION, else us-pdx-1. Blaxel sizes by memory only and gives 1 vCPU per 2 GB,
+ * so memory is max(memoryGb, 2 × vcpu) GB. Idle sandboxes drop to standby on their own and
+ * wake on the next call; pause() archives explicitly.
+ */
+export declare class BlaxelProvider implements Provider {
+    private apiKey;
+    private workspace;
+    private region;
+    readonly id: "blaxel";
+    private ready?;
+    constructor(apiKey?: string | undefined, workspace?: string | undefined, region?: string);
+    configured(): boolean;
+    /** Load the SDK once and point its (global) settings at our credentials. */
+    private sdk;
+    create(spec: SandboxSpec): Promise<ProviderSandbox>;
+    /** Reattach by sandbox name; an archived (paused) sandbox is unarchived first. */
+    connect(nativeId: string): Promise<ProviderSandbox>;
+}

package/dist/providers/blaxel.js

@@ -0,0 +1,152 @@
+import { DEFAULT_MEMORY_GB, DEFAULT_VCPU } from "../catalog.js";
+import { ProviderError } from "../types.js";
+import { optionalImport, toBytes } from "../util.js";
+/** Blaxel's public base image (the SDK's own default). Set image.blaxel for another image or a `bl deploy` template. */
+const DEFAULT_IMAGE = "blaxel/base-image:latest";
+/** Blaxel rejects a max-age ttl under 5 minutes. */
+const MIN_TTL_MINUTES = 5;
+/**
+ * Blaxel sandboxes via `@blaxel/core`. Auth: BL_API_KEY + BL_WORKSPACE (or `bl login`).
+ * Region: BL_REGION, else us-pdx-1. Blaxel sizes by memory only and gives 1 vCPU per 2 GB,
+ * so memory is max(memoryGb, 2 × vcpu) GB. Idle sandboxes drop to standby on their own and
+ * wake on the next call; pause() archives explicitly.
+ */
+export class BlaxelProvider {
+    apiKey;
+    workspace;
+    region;
+    id = "blaxel";
+    ready;
+    constructor(apiKey = process.env.BL_API_KEY, workspace = process.env.BL_WORKSPACE, region = process.env.BL_REGION ?? "us-pdx-1") {
+        this.apiKey = apiKey;
+        this.workspace = workspace;
+        this.region = region;
+    }
+    configured() {
+        return !!this.apiKey && !!this.workspace;
+    }
+    /** Load the SDK once and point its (global) settings at our credentials. */
+    sdk() {
+        this.ready ??= optionalImport("@blaxel/core", "blaxel").then((m) => {
+            if (this.apiKey && this.workspace)
+                m.initialize({ apiKey: this.apiKey, workspace: this.workspace });
+            return m;
+        });
+        return this.ready;
+    }
+    async create(spec) {
+        const { SandboxInstance } = await this.sdk();
+        const memoryGb = Math.max(spec.memoryGb ?? DEFAULT_MEMORY_GB, (spec.vcpu ?? DEFAULT_VCPU) * 2);
+        const ttlMinutes = Math.max(MIN_TTL_MINUTES, Math.round(spec.timeoutMinutes ?? 30));
+        try {
+            const sbx = await SandboxInstance.create({
+                image: spec.image?.blaxel ?? DEFAULT_IMAGE,
+                memory: Math.round(memoryGb * 1024),
+                region: this.region,
+                envs: Object.entries(spec.env ?? {}).map(([name, value]) => ({ name, value })),
+                labels: spec.metadata,
+                // Max-age from creation, not an idle timeout.
+                ttl: `${ttlMinutes}m`,
+            });
+            return new BlaxelBox(sbx);
+        }
+        catch (err) {
+            throw wrap(err);
+        }
+    }
+    /** Reattach by sandbox name; an archived (paused) sandbox is unarchived first. */
+    async connect(nativeId) {
+        const { SandboxInstance } = await this.sdk();
+        try {
+            let sbx = await SandboxInstance.get(nativeId);
+            if (sbx.status === "ARCHIVED" || sbx.status === "ARCHIVING")
+                sbx = await SandboxInstance.unarchive(nativeId);
+            return new BlaxelBox(sbx);
+        }
+        catch (err) {
+            throw wrap(err);
+        }
+    }
+}
+class BlaxelBox {
+    sbx;
+    nativeId;
+    constructor(sbx) {
+        this.sbx = sbx;
+        const name = sbx.metadata.name;
+        if (!name)
+            throw new ProviderError("blaxel", "sandbox has no name");
+        this.nativeId = name;
+    }
+    async exec(cmd, opts = {}) {
+        const t0 = Date.now();
+        const timeoutSeconds = opts.timeoutSeconds ?? 60;
+        let r;
+        try {
+            // With onStdout/onStderr the SDK streams logs from the same request as the command runs.
+            r = await this.sbx.process.exec({
+                command: cmd,
+                workingDir: opts.cwd,
+                env: opts.env,
+                timeout: timeoutSeconds,
+                waitForCompletion: true,
+                onStdout: opts.onStdout,
+                onStderr: opts.onStderr,
+            });
+            if (r.status === "running")
+                r = await this.sbx.process.wait(r.pid, { maxWait: timeoutSeconds * 1000 });
+        }
+        catch (err) {
+            throw wrap(err);
+        }
+        if (r.status === "killed" || r.status === "stopped") {
+            throw new ProviderError("blaxel", `command ${r.status} (timeout ${timeoutSeconds}s?)`);
+        }
+        // A nonzero exit is a result (status "failed"), not an error.
+        return { exitCode: r.exitCode, stdout: r.stdout ?? "", stderr: r.stderr ?? "", durationMs: Date.now() - t0 };
+    }
+    async writeFile(path, content) {
+        try {
+            await this.sbx.fs.writeBinary(path, toBytes(content));
+        }
+        catch (err) {
+            throw wrap(err);
+        }
+    }
+    async readFile(path) {
+        try {
+            return new Uint8Array(await (await this.sbx.fs.readBinary(path)).arrayBuffer());
+        }
+        catch (err) {
+            throw wrap(err);
+        }
+    }
+    /**
+     * Archive: the filesystem is kept, memory and processes are lost. The max-age ttl is cleared
+     * first so the archive survives until kill(). router.get() unarchives it.
+     */
+    async pause() {
+        const { SandboxInstance } = await optionalImport("@blaxel/core", "blaxel");
+        try {
+            await SandboxInstance.updateTtl(this.nativeId, null);
+            await this.sbx.archive();
+        }
+        catch (err) {
+            throw wrap(err);
+        }
+    }
+    async kill() {
+        try {
+            await this.sbx.delete();
+        }
+        catch (err) {
+            throw wrap(err);
+        }
+    }
+}
+function wrap(err) {
+    if (err instanceof ProviderError)
+        return err;
+    const status = typeof err?.status === "number" ? err.status : err?.response?.status;
+    return new ProviderError("blaxel", err?.message ?? String(err), status);
+}

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 {};