withruntime 0.2.1 → 0.3.0

package/dist/mcp.js

@@ -0,0 +1,221 @@
+import process from "node:process";
+import { resolveCredential } from "./credentials.js";
+import { RuntimeError } from "./errors.js";
+import { beginDeviceLogin } from "./login.js";
+import { apiOrigin, VERSION } from "./transport.js";
+const CONNECT_INSTRUCTIONS = "Runtime is not connected on this machine yet. Call runtime_connect: it gives you a link and a code for the person you work for to approve in their browser (no key to copy). Once they have, call runtime_connect again; Runtime's tools then appear (sandboxes, commands, files and the rest).";
+const connectTool = {
+    name: "runtime_connect",
+    title: "Connect this machine to Runtime",
+    description: "Connect Runtime on this machine with a browser approval. The first call returns a link and a code: show them to the person you work for and ask them to approve. Call again after they have; it waits up to 45 seconds for the approval, then Runtime's tools appear.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+};
+/** Bridges an MCP client that speaks stdio to Runtime's hosted MCP endpoint.
+ * Newline-delimited JSON-RPC in, the same out; every message is forwarded as
+ * it is, so the server's tools, schemas and `instructions` reach the client
+ * unchanged, and nothing here keeps a second catalogue. No dependencies:
+ * starting it costs a process and one TLS connection.
+ *
+ * With no key on this machine it does not fail: it serves one tool,
+ * runtime_connect, that walks the agent and its person through the browser
+ * approval, then connects to Runtime and tells the client its tools changed.
+ * So `claude mcp add runtime -- npx -y withruntime mcp` is the whole
+ * setup. */
+export async function serveMcp(env = process.env, options = {}) {
+    const fetcher = options.fetch ?? fetch;
+    let key;
+    try {
+        key = await resolveCredential(env);
+    }
+    catch (error) {
+        if (!(error instanceof RuntimeError && error.code === "missing_api_key"))
+            throw error;
+    }
+    const origin = apiOrigin(env.RUNTIME_API_URL ?? "https://api.withruntime.com");
+    const endpoint = new URL("/mcp", origin).href;
+    let protocolVersion;
+    let session;
+    let initialize;
+    let pending;
+    const inFlight = new Set();
+    const write = (message) => {
+        process.stdout.write(`${JSON.stringify(message)}\n`);
+    };
+    const failure = (id, message, data) => ({
+        jsonrpc: "2.0",
+        id: id ?? null,
+        error: { code: -32000, message, ...(data === undefined ? {} : { data }) },
+    });
+    /** One message to the hosted endpoint, and the messages it answered. */
+    async function post(body) {
+        const response = await fetcher(endpoint, {
+            method: "POST",
+            redirect: "error",
+            headers: {
+                authorization: `Bearer ${key}`,
+                "content-type": "application/json",
+                accept: "application/json, text/event-stream",
+                "x-runtime-client": `mcp-bridge/${VERSION}`,
+                ...(protocolVersion ? { "mcp-protocol-version": protocolVersion } : {}),
+                ...(session ? { "mcp-session-id": session } : {}),
+            },
+            body,
+            signal: AbortSignal.timeout(600_000),
+        });
+        session = response.headers.get("mcp-session-id") ?? session;
+        const text = await response.text();
+        const messages = [];
+        if (response.ok && response.status !== 202 && response.status !== 204) {
+            if ((response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+                for (const block of text.split(/\n\n/))
+                    for (const data of block.split("\n").filter((l) => l.startsWith("data:")))
+                        messages.push(JSON.parse(data.slice(5).trim()));
+            }
+            else if (text.trim())
+                messages.push(JSON.parse(text));
+        }
+        for (const reply of messages) {
+            const result = reply.result;
+            if (result?.protocolVersion)
+                protocolVersion = result.protocolVersion;
+        }
+        return { status: response.status, messages, text };
+    }
+    async function forward(line, id, isRequest) {
+        let answer;
+        try {
+            answer = await post(line);
+        }
+        catch {
+            if (isRequest)
+                write(failure(id, "Runtime could not be reached. Check the network and retry."));
+            return;
+        }
+        if (answer.status >= 400) {
+            let detail;
+            try {
+                detail = JSON.parse(answer.text).error;
+            }
+            catch {
+                detail = answer.text.slice(0, 500);
+            }
+            const hint = answer.status === 401
+                ? "The key was refused. Run `npx -y withruntime login` again, or set RUNTIME_API_KEY."
+                : `Runtime answered ${answer.status}.`;
+            if (isRequest)
+                write(failure(id, hint, detail));
+            return;
+        }
+        for (const reply of answer.messages)
+            write(reply);
+    }
+    /** Not connected yet: answer the client here, with one tool that connects. */
+    async function connectMode(message, id) {
+        const method = message.method;
+        const reply = (result) => write({ jsonrpc: "2.0", id, result });
+        if (method === "initialize") {
+            initialize = message.params ?? {};
+            return reply({
+                protocolVersion: initialize.protocolVersion ?? "2025-06-18",
+                capabilities: { tools: { listChanged: true } },
+                serverInfo: { name: "runtime-cloud", version: VERSION },
+                instructions: CONNECT_INSTRUCTIONS,
+            });
+        }
+        if (typeof method === "string" && method.startsWith("notifications/"))
+            return;
+        if (method === "ping")
+            return reply({});
+        if (method === "tools/list")
+            return reply({ tools: [connectTool] });
+        if (method !== "tools/call" ||
+            message.params?.name !== "runtime_connect")
+            return write(failure(id, "Runtime is not connected yet: call runtime_connect first."));
+        const text = (words) => reply({ content: [{ type: "text", text: words }] });
+        try {
+            if (!pending) {
+                pending = await beginDeviceLogin(env, env.RUNTIME_AGENT_NAME ?? "MCP agent", {
+                    ...(options.fetch ? { fetch: options.fetch } : {}),
+                });
+                if (!env.RUNTIME_NO_BROWSER && !pending.resumed)
+                    await (options.openBrowser ?? openBrowser)(pending.url).catch(() => undefined);
+                return text(`Ask the person you work for to open ${pending.url} (it may already be open in their browser), sign in to Runtime, check that it shows the code ${pending.userCode}, and choose Connect agent. Then call runtime_connect again.`);
+            }
+            const until = Math.min(pending.expiresAt, Date.now() + 45_000);
+            while (Date.now() < until) {
+                const outcome = await pending.check();
+                if (outcome === "expired")
+                    break;
+                if (outcome !== "pending") {
+                    key = await resolveCredential(env);
+                    pending = undefined;
+                    await post(JSON.stringify({
+                        jsonrpc: "2.0",
+                        id: "runtime-connect",
+                        method: "initialize",
+                        params: initialize ?? {},
+                    }));
+                    await post(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }));
+                    write({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+                    return text(`Connected as ${outcome.agentName}. Runtime's tools are available now: list the tools again, then start with runtime_sandboxes_create.`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, 3000));
+            }
+            if (Date.now() >= pending.expiresAt) {
+                pending = undefined;
+                return text("The link expired before it was approved. Call runtime_connect for a new one.");
+            }
+            return text(`Not approved yet. The person you work for should open ${pending.url} and choose Connect agent; then call runtime_connect again.`);
+        }
+        catch (error) {
+            pending = undefined;
+            return write(failure(id, error instanceof Error
+                ? error.message
+                : "The connection failed. Call runtime_connect again."));
+        }
+    }
+    async function handle(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+            return;
+        }
+        const first = Array.isArray(message) ? message[0] : message;
+        const id = first?.id;
+        const isRequest = id !== undefined && first.method !== undefined;
+        if (key === undefined && first && typeof first === "object")
+            return connectMode(first, id);
+        return forward(line, id, isRequest);
+    }
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    await new Promise((resolve) => {
+        process.stdin.on("data", (chunk) => {
+            buffer += chunk;
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                if (line) {
+                    const task = handle(line).finally(() => inFlight.delete(task));
+                    inFlight.add(task);
+                }
+                newline = buffer.indexOf("\n");
+            }
+        });
+        const finish = () => void Promise.allSettled([...inFlight]).then(() => resolve());
+        process.stdin.once("end", finish);
+        process.once("SIGINT", finish);
+        process.once("SIGTERM", finish);
+    });
+}
+async function openBrowser(url) {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "rundll32" : "xdg-open";
+    const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+    await promisify(execFile)(command, args, { timeout: 10_000 });
+}

package/dist/page.d.ts

@@ -0,0 +1,13 @@
+/** A list you can await for one page or iterate for every item. */
+export declare class Page<T> implements AsyncIterable<T> {
+    readonly data: T[];
+    readonly nextCursor: string | null;
+    private readonly fetchPage;
+    constructor(data: T[], nextCursor: string | null, fetchPage: (cursor: string) => Promise<Page<T>>);
+    get hasMore(): boolean;
+    next(): Promise<Page<T> | null>;
+    /** Every page, fetched as you go. */
+    pages(): AsyncGenerator<Page<T>>;
+    [Symbol.asyncIterator](): AsyncGenerator<T>;
+    toArray(limit?: number): Promise<T[]>;
+}

package/dist/page.js

@@ -0,0 +1,39 @@
+/** A list you can await for one page or iterate for every item. */
+export class Page {
+    data;
+    nextCursor;
+    fetchPage;
+    constructor(data, nextCursor, fetchPage) {
+        this.data = data;
+        this.nextCursor = nextCursor;
+        this.fetchPage = fetchPage;
+    }
+    get hasMore() {
+        return this.nextCursor !== null;
+    }
+    async next() {
+        return this.nextCursor === null ? null : this.fetchPage(this.nextCursor);
+    }
+    /** Every page, fetched as you go. */
+    async *pages() {
+        yield this;
+        let page = await this.next();
+        while (page) {
+            yield page;
+            page = await page.next();
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (const page of this.pages())
+            yield* page.data;
+    }
+    async toArray(limit = 10_000) {
+        const all = [];
+        for await (const item of this) {
+            all.push(item);
+            if (all.length >= limit)
+                break;
+        }
+        return all;
+    }
+}

package/dist/products/desktop.d.ts

@@ -0,0 +1,103 @@
+import type { Sandbox } from "../sandbox.js";
+import type { RequestOptions, Transport } from "../transport.js";
+import type { Preview } from "./previews.js";
+export type MouseButton = "left" | "middle" | "right";
+export type DesktopWindow = {
+    id: string;
+    desktop: number;
+    pid: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    className: string;
+    title: string;
+};
+export type DesktopStart = {
+    ok: boolean;
+    display: string;
+    size: string;
+    /** Opens the live desktop (noVNC) in a browser; carries a private preview token. */
+    streamUrl: string;
+    preview: Preview;
+};
+/** `sbx.desktop`: a Linux desktop in the sandbox, driven like a person would.
+ *
+ *   const { streamUrl } = await sbx.desktop.start();
+ *   await sbx.desktop.open("https://example.com");
+ *   await sbx.desktop.click(640, 400);
+ *   await sbx.desktop.type("hello");
+ *   const png = await sbx.desktop.screenshot();
+ *
+ * Coordinates are pixels from the top left of the screen. */
+export declare function sandboxDesktop(t: Transport, sandbox: Sandbox): {
+    start: (size?: {
+        width?: number;
+        height?: number;
+    }, options?: RequestOptions) => Promise<DesktopStart>;
+    stop: (options?: RequestOptions) => Promise<{
+        ok: boolean;
+    }>;
+    /** PNG bytes, or JPEG with `format: "jpeg"`. */
+    screenshot: (input?: {
+        format?: "png" | "jpeg";
+        quality?: number;
+    }, options?: RequestOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+    move: (x: number, y: number, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    click: (x?: number, y?: number, input?: {
+        button?: MouseButton;
+        double?: boolean;
+    }, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    doubleClick: (x?: number, y?: number, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    rightClick: (x?: number, y?: number, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    mouseDown: (button?: MouseButton, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    mouseUp: (button?: MouseButton, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    drag: (from: [number, number], to: [number, number], options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    /** Wheel clicks: positive `dy` scrolls down, positive `dx` right. */
+    scroll: (dy: number, input?: {
+        dx?: number;
+        x?: number;
+        y?: number;
+    }, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    type: (text: string, input?: {
+        delayMs?: number;
+    }, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    /** xdotool key names, space separated: "ctrl+l", "Return", "alt+Tab". */
+    press: (keys: string, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    cursor: (options?: RequestOptions) => Promise<{
+        x: number;
+        y: number;
+    }>;
+    windows: (options?: RequestOptions) => Promise<DesktopWindow[]>;
+    focus: (windowId: string, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    /** Opens `url` in Firefox on the desktop. */
+    open: (url: string, options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+    /** Starts a program on the desktop, detached. */
+    launch: (argv: string[], options?: RequestOptions) => Promise<{
+        ok: true;
+    }>;
+};

package/dist/products/desktop.js

@@ -0,0 +1,38 @@
+/** `sbx.desktop`: a Linux desktop in the sandbox, driven like a person would.
+ *
+ *   const { streamUrl } = await sbx.desktop.start();
+ *   await sbx.desktop.open("https://example.com");
+ *   await sbx.desktop.click(640, 400);
+ *   await sbx.desktop.type("hello");
+ *   const png = await sbx.desktop.screenshot();
+ *
+ * Coordinates are pixels from the top left of the screen. */
+export function sandboxDesktop(t, sandbox) {
+    const base = () => `/v1/sandboxes/${encodeURIComponent(sandbox.id)}/desktop`;
+    const act = (body, options) => t.json({ method: "POST", path: `${base()}:act`, body, ...options });
+    return {
+        start: (size = {}, options) => t.json({ method: "POST", path: `${base()}:start`, body: size, ...options }),
+        stop: (options) => t.json({ method: "POST", path: `${base()}:stop`, ...options }),
+        /** PNG bytes, or JPEG with `format: "jpeg"`. */
+        screenshot: (input = {}, options) => t.bytes({ method: "GET", path: `${base()}/screenshot`, query: input, ...options }),
+        move: (x, y, options) => act({ action: "move", x, y }, options),
+        click: (x, y, input = {}, options) => act({ action: "click", ...(x === undefined ? {} : { x, y }), ...input }, options),
+        doubleClick: (x, y, options) => act({ action: "click", double: true, ...(x === undefined ? {} : { x, y }) }, options),
+        rightClick: (x, y, options) => act({ action: "click", button: "right", ...(x === undefined ? {} : { x, y }) }, options),
+        mouseDown: (button = "left", options) => act({ action: "mouseDown", button }, options),
+        mouseUp: (button = "left", options) => act({ action: "mouseUp", button }, options),
+        drag: (from, to, options) => act({ action: "drag", from, to }, options),
+        /** Wheel clicks: positive `dy` scrolls down, positive `dx` right. */
+        scroll: (dy, input = {}, options) => act({ action: "scroll", dy, ...input }, options),
+        type: (text, input = {}, options) => act({ action: "type", text, ...input }, options),
+        /** xdotool key names, space separated: "ctrl+l", "Return", "alt+Tab". */
+        press: (keys, options) => act({ action: "key", keys }, options),
+        cursor: (options) => act({ action: "cursor" }, options),
+        windows: async (options) => (await act({ action: "windows" }, options)).windows,
+        focus: (windowId, options) => act({ action: "focus", windowId }, options),
+        /** Opens `url` in Firefox on the desktop. */
+        open: (url, options) => act({ action: "open", url }, options),
+        /** Starts a program on the desktop, detached. */
+        launch: (argv, options) => act({ action: "launch", argv }, options),
+    };
+}

package/dist/products/images.d.ts

@@ -0,0 +1,121 @@
+import { Page } from "../page.js";
+import type { RequestOptions, Transport } from "../transport.js";
+/** A file for a Dockerfile's build context or a recipe. */
+export type ImageFile = {
+    path: string;
+    content: string;
+    encoding?: "utf8" | "base64";
+    mode?: number;
+};
+export type ImageRecipe = {
+    /** "runtime" (the default) or a public image reference. */
+    base?: string;
+    apt?: string[];
+    pip?: string[];
+    npm?: string[];
+    commands?: string[];
+    env?: Record<string, string>;
+    files?: ImageFile[];
+    workdir?: string;
+};
+export type ImageBuildLimits = {
+    vcpu?: number;
+    memoryMiB?: number;
+    diskMiB?: number;
+    maxImageMiB?: number;
+    timeoutSeconds?: number;
+};
+/** Exactly one of `image`, `dockerfile` or `recipe`. */
+export type CreateImage = {
+    name?: string;
+    labels?: Record<string, string>;
+    region?: string;
+    build?: ImageBuildLimits;
+    env?: Record<string, string>;
+} & ({
+    image: string;
+    dockerfile?: never;
+    recipe?: never;
+} | {
+    dockerfile: string;
+    files?: ImageFile[];
+    buildArgs?: Record<string, string>;
+    image?: never;
+    recipe?: never;
+} | {
+    recipe: ImageRecipe;
+    image?: never;
+    dockerfile?: never;
+});
+export type ImageState = "queued" | "building" | "ready" | "failed" | "deleting" | "deleted";
+export type Image = {
+    id: string;
+    kind: "image";
+    status: string;
+    state: ImageState;
+    name: string | null;
+    labels: Record<string, string>;
+    region: string;
+    source: {
+        kind: "dockerfile" | "oci" | "recipe";
+        digest: string;
+        base: unknown;
+        steps: number;
+    };
+    build: ImageBuildLimits & {
+        startedAt: string | null;
+        endedAt: string | null;
+        cachedSteps: number;
+        builderVersion: string | null;
+    };
+    sizeBytes: number | null;
+    sizeMiB: number | null;
+    storedBytes: number | null;
+    rootfsSha256: string | null;
+    env: Record<string, string>;
+    workdir: string;
+    error: string | null;
+    logs: {
+        bytes: number;
+        lines: number;
+        truncated: boolean;
+    };
+    createdAt: string;
+    readyAt: string | null;
+    /** What the source asked for that an image does not carry (on create). */
+    notes?: string[];
+};
+export type ImageLogLine = {
+    seq: number;
+    at: string;
+    stream: "build" | "system";
+    text: string;
+};
+export type ImageLogs = {
+    lines: ImageLogLine[];
+    nextAfter: number;
+    state: ImageState;
+    truncated: boolean;
+    done: boolean;
+};
+/** Custom images: `runtime.images.build({ recipe: { pip: ["pandas"] } })`, then
+ * `runtime.sandboxes.create({ image: image.id })`. */
+export declare function images(t: Transport): {
+    /** Queue a build and return at once, state "queued". */
+    create: (input: CreateImage, options?: RequestOptions) => Promise<Image>;
+    /** Build and wait until the image is ready or failed, streaming log lines
+     * to `onLog`. Throws when the build fails, with the build's own error. */
+    build(input: CreateImage, options?: RequestOptions & {
+        onLog?: (line: ImageLogLine) => void;
+        pollMs?: number;
+    }): Promise<Image>;
+    get: (id: string, options?: RequestOptions) => Promise<Image>;
+    logs: (id: string, after?: number, options?: RequestOptions) => Promise<ImageLogs>;
+    list: (query?: {
+        state?: ImageState;
+        name?: string;
+        limit?: number;
+        cursor?: string;
+    }, options?: RequestOptions) => Promise<Page<Image>>;
+    delete: (id: string, options?: RequestOptions) => Promise<Image>;
+};

package/dist/products/images.js

@@ -0,0 +1,64 @@
+import { Page } from "../page.js";
+/** Custom images: `runtime.images.build({ recipe: { pip: ["pandas"] } })`, then
+ * `runtime.sandboxes.create({ image: image.id })`. */
+export function images(t) {
+    const get = (id, options) => t.json({ method: "GET", path: `/v1/images/${encodeURIComponent(id)}`, ...options });
+    const logs = (id, after = 0, options) => t.json({
+        method: "GET",
+        path: `/v1/images/${encodeURIComponent(id)}/logs`,
+        query: { after },
+        ...options,
+    });
+    const list = async (query = {}, options) => {
+        const page = await t.json({
+            method: "GET",
+            path: "/v1/images",
+            query,
+            ...options,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => list({ ...query, cursor }, options));
+    };
+    return {
+        /** Queue a build and return at once, state "queued". */
+        create: (input, options) => t.json({ method: "POST", path: "/v1/images", body: input, ...options }),
+        /** Build and wait until the image is ready or failed, streaming log lines
+         * to `onLog`. Throws when the build fails, with the build's own error. */
+        async build(input, options = {}) {
+            const { onLog, pollMs = 1000, ...request } = options;
+            let image = await t.json({
+                method: "POST",
+                path: "/v1/images",
+                body: input,
+                ...request,
+            });
+            let after = 0;
+            for (;;) {
+                if (onLog) {
+                    const page = await logs(image.id, after, { signal: request.signal });
+                    for (const line of page.lines)
+                        onLog(line);
+                    after = page.nextAfter;
+                }
+                image = await get(image.id, { signal: request.signal });
+                if (image.state !== "queued" && image.state !== "building")
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, pollMs));
+            }
+            if (onLog)
+                for (const line of (await logs(image.id, after)).lines)
+                    onLog(line);
+            if (image.state !== "ready")
+                throw new Error(`Image ${image.id} ${image.state}: ${image.error ?? "no error given"}`);
+            return image;
+        },
+        get,
+        logs,
+        list,
+        delete: (id, options) => t.json({
+            method: "POST",
+            path: `/v1/images/${encodeURIComponent(id)}:delete`,
+            body: {},
+            ...options,
+        }),
+    };
+}

package/dist/products/index.d.ts

@@ -0,0 +1,29 @@
+import type { Transport } from "../transport.js";
+import type { Sandbox } from "../sandbox.js";
+import { images } from "./images.js";
+import { sandboxDesktop } from "./desktop.js";
+import { sandboxInterpreter } from "./interpreter.js";
+import { sandboxNetwork } from "./network.js";
+import { sandboxPreviews } from "./previews.js";
+import { referrals } from "./referrals.js";
+import { volumes } from "./volumes.js";
+export declare const clientExtensions: {
+    images: typeof images;
+    volumes: typeof volumes;
+    referrals: typeof referrals;
+};
+export declare const sandboxExtensions: {
+    interpreter: typeof sandboxInterpreter;
+    previews: typeof sandboxPreviews;
+    network: typeof sandboxNetwork;
+    desktop: typeof sandboxDesktop;
+};
+export type ClientExtensions = {
+    readonly [K in keyof typeof clientExtensions]: ReturnType<(typeof clientExtensions)[K]>;
+};
+export type SandboxExtensions = {
+    readonly [K in keyof typeof sandboxExtensions]: ReturnType<(typeof sandboxExtensions)[K]>;
+};
+/** The factories as plain pairs, for the constructors that install them. */
+export declare function clientFactories(): Array<[string, (t: Transport) => unknown]>;
+export declare function sandboxFactories(): Array<[string, (t: Transport, sandbox: Sandbox) => unknown]>;

package/dist/products/index.js

@@ -0,0 +1,36 @@
+import { images } from "./images.js";
+import { sandboxDesktop } from "./desktop.js";
+import { sandboxInterpreter } from "./interpreter.js";
+import { sandboxNetwork } from "./network.js";
+import { sandboxPreviews } from "./previews.js";
+import { referrals } from "./referrals.js";
+import { volumes } from "./volumes.js";
+/* HOW A LANE ADDS A PRODUCT TO THE SDK
+ *
+ * 1. Write src/products/<name>.ts exporting a factory:
+ *      export function images(t: Transport) {
+ *        return {
+ *          create: (input: CreateImage, options?: RequestOptions) =>
+ *            t.json<Image>({ method: "POST", path: "/v1/images", body: input, ...options }),
+ *          ...
+ *        };
+ *      }
+ *    and, for methods that belong on a sandbox (sbx.previews.create(3000)):
+ *      export function sandboxPreviews(t: Transport, sandbox: Sandbox) { return { ... } }
+ * 2. Add ONE line to the matching object below. The Runtime client and every
+ *    Sandbox pick it up, typed, with the shared auth, retries, keys and errors.
+ */
+export const clientExtensions = { images, volumes, referrals };
+export const sandboxExtensions = {
+    interpreter: sandboxInterpreter,
+    previews: sandboxPreviews,
+    network: sandboxNetwork,
+    desktop: sandboxDesktop,
+};
+/** The factories as plain pairs, for the constructors that install them. */
+export function clientFactories() {
+    return Object.entries(clientExtensions);
+}
+export function sandboxFactories() {
+    return Object.entries(sandboxExtensions);
+}