withruntime 0.12.0 → 0.14.0

package/dist/machine.d.ts

@@ -146,7 +146,7 @@ export declare abstract class Machines<M extends Machine<Info, object, Deleted>,
     #private;
     constructor(product: MachineProduct, t: Transport, wrap: (t: Transport, info: Info) => M);
     /** Creates a sandbox and waits until it is running. Every field is optional:
-     * with none you get the included usage while it lasts, the default region and a
+     * with none you get the free usage while it lasts, the default region and a
      * 2 vCPU / 4 GiB machine from a warm template. `wait: false` returns at once.
      * When every slot without credit or the account's quota is taken, it waits for one to
      * free, up to `waitForCapacityMs` (the client's, two minutes by default). */
@@ -186,4 +186,18 @@ export declare abstract class Machines<M extends Machine<Info, object, Deleted>,
             error: unknown;
         }[];
     }>;
+    /** Deletes for good every sandbox whose labels all match, stopped ones
+     * included, eight at a time, as `delete()` does one: its disk and paused
+     * memory go, its snapshots stay. Says which were deleted and which failed;
+     * one failure does not stop the rest. Needs at least one label, so deleting
+     * everything is never one call. */
+    deleteAll(filter: {
+        labels: Record<string, string>;
+    }, options?: RequestOptions): Promise<{
+        deleted: string[];
+        failed: {
+            id: string;
+            error: unknown;
+        }[];
+    }>;
 }

package/dist/machine.js

@@ -408,7 +408,7 @@ export class Machines {
         this.#wrap = wrap;
     }
     /** Creates a sandbox and waits until it is running. Every field is optional:
-     * with none you get the included usage while it lasts, the default region and a
+     * with none you get the free usage while it lasts, the default region and a
      * 2 vCPU / 4 GiB machine from a warm template. `wait: false` returns at once.
      * When every slot without credit or the account's quota is taken, it waits for one to
      * free, up to `waitForCapacityMs` (the client's, two minutes by default). */
@@ -493,29 +493,44 @@ export class Machines {
      * says which stopped and which failed; one failure does not stop the rest.
      * Needs at least one label, so stopping everything is never one call. */
     async stopAll(filter, options = {}) {
+        const { done, failed } = await this.#eachLabelled("stop", filter, false, options, (m, each) => m.stop(each));
+        return { stopped: done, failed };
+    }
+    /** Deletes for good every sandbox whose labels all match, stopped ones
+     * included, eight at a time, as `delete()` does one: its disk and paused
+     * memory go, its snapshots stay. Says which were deleted and which failed;
+     * one failure does not stop the rest. Needs at least one label, so deleting
+     * everything is never one call. */
+    async deleteAll(filter, options = {}) {
+        const { done, failed } = await this.#eachLabelled("delete", filter, true, options, (m, each) => m.delete(each));
+        return { deleted: done, failed };
+    }
+    /** Lists every match first, then acts on each, eight at a time: acting
+     * while paging would move the pages under the cursor. */
+    async #eachLabelled(verb, filter, includeStopped, options, act) {
         if (!filter?.labels || Object.keys(filter.labels).length === 0) {
             const one = this.#product.noun.toLowerCase();
             throw new RuntimeError({
-                message: "stopAll needs at least one label to match.",
+                message: `${verb}All needs at least one label to match.`,
                 code: "invalid_request",
                 status: 0,
-                hint: `Stop one ${one} with ${one}.stop(), or label the ones to stop together.`,
+                hint: `${verb === "stop" ? "Stop" : "Delete"} one ${one} with ${one}.${verb}(), or label the ones to ${verb} together.`,
             });
         }
-        const live = await (await this.list({ labels: filter.labels, limit: 100 }, options)).toArray(Infinity);
-        // One key cannot name several stops: each stop makes its own.
+        const matches = await (await this.list({ labels: filter.labels, limit: 100, ...(includeStopped ? { includeStopped } : {}) }, options)).toArray(Infinity);
+        // One key cannot name several acts: each makes its own.
         const { idempotencyKey: _one, ...each } = options;
         // In list order, oldest first, whichever finishes first.
-        const errors = new Array(live.length);
+        const errors = new Array(matches.length);
         let next = 0;
         const worker = async () => {
-            for (let at = next++; at < live.length; at = next++)
-                await live[at].stop(each).catch((error) => (errors[at] = error ?? "failed"));
+            for (let at = next++; at < matches.length; at = next++)
+                await act(matches[at], each).catch((error) => (errors[at] = error ?? "failed"));
         };
-        await Promise.all(Array.from({ length: Math.min(8, live.length) }, worker));
+        await Promise.all(Array.from({ length: Math.min(8, matches.length) }, worker));
         return {
-            stopped: live.filter((_, at) => errors[at] === undefined).map((m) => m.id),
-            failed: live.flatMap((m, at) => errors[at] === undefined ? [] : [{ id: m.id, error: errors[at] }]),
+            done: matches.filter((_, at) => errors[at] === undefined).map((m) => m.id),
+            failed: matches.flatMap((m, at) => errors[at] === undefined ? [] : [{ id: m.id, error: errors[at] }]),
         };
     }
 }

package/dist/mcp.js

@@ -1,16 +1,61 @@
 import process from "node:process";
-import { resolveCredential } from "./credentials.js";
+import { checkBrowserOrigins, connectionOrigins, resolveCredential, saveWalletConnection, } from "./credentials.js";
 import { RuntimeError } from "./errors.js";
 import { beginDeviceLogin } from "./login.js";
 import { envFetch } from "./proxy.js";
 import { apiOrigin, defaultBaseUrl, 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 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). No person to approve? Open an account paid in USDC: runtime_wallet_open gives an address and the exact amount to send, and runtime_wallet_claim connects once the payment lands (in a shell, `npx withruntime billing topup 20 --new-account --accept-terms --wait` does the same; then call runtime_connect). There is no free trial on that path.";
 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 },
 };
+const walletOpenTool = {
+    name: "runtime_wallet_open",
+    title: "Open a Runtime account paid with a wallet",
+    description: "For an agent with no person to approve a browser login: opens a Runtime account and its first top-up, paid in USDC on Base, Solana or Tempo. No free trial: the account gets its key only once the payment lands. Answers with an address per network, the exact amount to send and a claim code, shown once: keep it secret, it is the only way to the account. Send exactly that amount from any wallet, then call runtime_wallet_claim with the claim code. Opening an account means agreeing to https://withruntime.com/legal/terms for whoever you act for.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            usd: {
+                type: "number",
+                description: "Dollars of credit to buy: $10 to $500 in an account's first week.",
+            },
+            acceptTerms: {
+                type: "boolean",
+                description: "true agrees to https://withruntime.com/legal/terms. Required.",
+            },
+        },
+        required: ["usd", "acceptTerms"],
+        additionalProperties: false,
+    },
+};
+const walletClaimTool = {
+    name: "runtime_wallet_claim",
+    title: "Connect to a Runtime account opened with a wallet",
+    description: "Once a runtime_wallet_open top-up is paid, saves the account's key on this machine (not shown) and connects; Runtime's tools then appear. Until the payment lands it waits up to 45 seconds and says the top-up's status: call it again.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            claimCode: { type: "string", description: "The claim code runtime_wallet_open gave." },
+        },
+        required: ["claimCode"],
+        additionalProperties: false,
+    },
+};
+/** Where to send a wallet account's first top-up, for an agent to act on. */
+function describeOpened(opened) {
+    const lines = [
+        `Opened a Runtime account. Send exactly ${opened.amount} USDC (for $${opened.amountUsd} of credit), on one of these networks:`,
+        "",
+    ];
+    for (const network of opened.networks)
+        for (const token of network.tokens)
+            lines.push(`- ${network.network}: ${token.currency.toUpperCase()} to ${network.address} (token contract ${token.contract})`);
+    lines.push("", ...(opened.payBy ? [`Send before ${opened.payBy}.`] : []), "A different amount, token or network cannot be matched or returned automatically.", "", `Claim code (shown once, keep it secret): ${opened.claimCode}`, "Once sent, call runtime_wallet_claim with this claim code: it connects when the payment lands, a few minutes after the transfer.", "A person can take the account over at https://withruntime.com/account/claim with the same code.");
+    return lines.join("\n");
+}
 /** 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
@@ -115,7 +160,73 @@ export async function serveMcp(env = process.env, options = {}) {
         for (const reply of answer.messages)
             write(reply);
     }
-    /** Not connected yet: answer the client here, with one tool that connects. */
+    /** The website's wallet sign-up, at the same origins a login would use. */
+    function wallet() {
+        const origins = connectionOrigins(env);
+        checkBrowserOrigins(origins);
+        const walletOptions = {
+            authUrl: origins.auth,
+            ...(options.fetch ? { fetch: options.fetch } : {}),
+        };
+        return {
+            open: async (input) => (await import("./wallet.js")).openWalletAccount(input, walletOptions),
+            claim: async (code) => (await import("./wallet.js")).claimWalletAccount(code, walletOptions),
+        };
+    }
+    /** A wallet account's claim: once paid, saves its key and connects. Waits up
+     * to 45 seconds for a payment on its way, as runtime_connect does. */
+    async function claimWallet(code) {
+        const until = Date.now() + 45_000;
+        for (;;) {
+            const claim = await wallet().claim(code);
+            if (claim.status === "paid") {
+                // The website issues the key once: a save that fails must not lose it.
+                let unsaved;
+                try {
+                    await saveWalletConnection(env, claim.apiKey, claim.orgId);
+                }
+                catch (error) {
+                    unsaved = error.message;
+                }
+                const said = await connected(claim.apiKey, "a wallet account");
+                return [
+                    unsaved === undefined
+                        ? said
+                        : `${said}\nThe key could not be saved (${unsaved}), and it is issued only once: keep it secret and safe now, as RUNTIME_API_KEY: ${claim.apiKey}`,
+                ];
+            }
+            if (claim.status === "expired" || claim.status === "failed")
+                return [
+                    `The top-up ${claim.status}: nothing was credited. Open a new one with runtime_wallet_open.`,
+                    true,
+                ];
+            // A top-up that never reached Stripe has no address: waiting cannot help.
+            if (claim.topup?.status === "open" && !claim.topup.networks.length)
+                return [claim.next ?? "This top-up has no address to pay to yet.", true];
+            if (Date.now() + 10_000 > until)
+                return [
+                    claim.status === "pending"
+                        ? "The payment has arrived and is being confirmed. Call runtime_wallet_claim again in a minute."
+                        : "Not paid yet. Once the transfer has gone through, call runtime_wallet_claim again with the same claim code.",
+                ];
+            await new Promise((resolve) => setTimeout(resolve, 10_000));
+        }
+    }
+    /** Starts forwarding with this key and tells the client its tools changed. */
+    async function connected(found, agentName) {
+        key = found;
+        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 `Connected${agentName ? ` as ${agentName}` : ""}. Runtime's tools are available now: list the tools again, then start with runtime_sandboxes_create.`;
+    }
+    /** Not connected yet: answer the client here, with the tools that connect. */
     async function connectMode(message, id) {
         const method = message.method;
         const reply = (result) => write({ jsonrpc: "2.0", id, result });
@@ -133,38 +244,51 @@ export async function serveMcp(env = process.env, options = {}) {
         if (method === "ping")
             return reply({});
         if (method === "tools/list")
-            return reply({ tools: [connectTool] });
+            return reply({ tools: [connectTool, walletOpenTool, walletClaimTool] });
+        const params = (message.params ?? {});
         if (method !== "tools/call" ||
-            message.params?.name !== "runtime_connect")
+            !["runtime_connect", "runtime_wallet_open", "runtime_wallet_claim"].includes(params.name))
             return write(failure(id, "Runtime is not connected yet: call runtime_connect first."));
-        const text = (words) => reply({ content: [{ type: "text", text: words }] });
+        const text = (words, isError = false) => reply({ content: [{ type: "text", text: words }], ...(isError ? { isError } : {}) });
+        if (params.name !== "runtime_connect") {
+            const input = (params.arguments ?? {});
+            try {
+                if (params.name === "runtime_wallet_open") {
+                    if (input.acceptTerms !== true)
+                        return text("Opening an account means agreeing to https://withruntime.com/legal/terms. Call again with acceptTerms: true to agree to them for whoever you act for.", true);
+                    if (typeof input.usd !== "number" || !(input.usd > 0))
+                        return text("Say how many dollars of credit to buy in usd, such as 20.", true);
+                    return text(describeOpened(await wallet().open({ usd: input.usd, acceptTerms: true })));
+                }
+                if (typeof input.claimCode !== "string" || !input.claimCode.trim())
+                    return text("Give the claimCode runtime_wallet_open answered.", true);
+                return text(...(await claimWallet(input.claimCode.trim())));
+            }
+            catch (error) {
+                return text(error instanceof Error ? error.message : String(error), true);
+            }
+        }
         try {
+            // A key saved since this server started (a wallet account's claim, a
+            // login in a shell) connects without a browser.
+            const saved = await resolveCredential(env).catch(() => undefined);
+            if (saved)
+                return text(await connected(saved));
             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.`);
+                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. No person to approve? See this server's instructions to open an account paid in USDC.`);
             }
             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.`);
-                }
+                if (outcome !== "pending")
+                    return text(await connected(await resolveCredential(env), outcome.agentName));
                 await new Promise((resolve) => setTimeout(resolve, 3000));
             }
             if (Date.now() >= pending.expiresAt) {

package/dist/products/api-keys.d.ts

@@ -0,0 +1,73 @@
+import type { RequestOptions, Transport } from "../transport.js";
+export type NewKey = {
+    /** The key's name, and its agent's: up to 80 characters. */
+    name: string;
+    /** full (the default): every action. read: every read, nothing else. */
+    access?: "full" | "read";
+    /** agent (the default): the key sees and acts on only what it makes.
+     *  account: everything in the account; only an account-wide key makes one. */
+    reach?: "agent" | "account";
+    /** The most its agent may commit in any 24 hours, or null for none. Needed
+     *  when the making key has a limit: the limits of the keys a key made add
+     *  up to at most its own. */
+    dailyLimitMicros?: number | null;
+};
+export type MadeKey = {
+    /** The key itself. Shown once: store it now. */
+    key: string;
+    keyId: string;
+    agentId: string;
+    orgId: string;
+    name: string;
+    access: "full" | "read";
+    reach: "agent" | "account";
+    dailyLimitMicros: number | null;
+    /** The making key's expiry, or null for until revoked. */
+    expires: string | null;
+    /** The id of the key that made it. */
+    madeBy: string;
+};
+export type ListedKey = {
+    keyId: string;
+    agentId: string;
+    name: string;
+    access: "full" | "read" | "selected";
+    reach: "agent" | "account";
+    dailyLimitMicros: number | null;
+    /** Committed in the last 24 hours: settled plus held, as the limit counts. */
+    dailyUsedMicros: number;
+    /** The key that made it, or null for one made on the website. */
+    madeBy: string | null;
+    createdAt: string;
+    expiresAt: string | null;
+    revokedAt: string | null;
+};
+/** One key's spend, from `GET /v1/usage?key=`. Microdollars as strings. */
+export type KeyUsage = {
+    keyId: string;
+    agentId: string;
+    name: string;
+    madeBy: string | null;
+    revokedAt: string | null;
+    dailyLimitMicros: string | null;
+    dailyUsedMicros: string;
+    spentMicros: string;
+    heldMicros: string;
+    runningSandboxes: number;
+    resources: number;
+};
+export declare function keys(t: Transport): {
+    /** Make a key with this one. It never has more than this key, and is in
+     *  the audit log as made by it. At most 100 live in an account. */
+    create: (input: NewKey, options?: RequestOptions) => Promise<MadeKey>;
+    /** This key and the keys it made (every key, for an account-wide key),
+     *  live first, with what each spent in the last 24 hours. */
+    list: (options?: RequestOptions) => Promise<ListedKey[]>;
+    /** Revoke this key or one it made: a worker's, when the worker is done. */
+    revoke: (keyId: string, options?: RequestOptions) => Promise<{
+        keyId: string;
+        revokedAt: string;
+    }>;
+    /** What one key spent: itself, or a key it made. */
+    usage: (keyId: string, options?: RequestOptions) => Promise<KeyUsage>;
+};

package/dist/products/api-keys.js

@@ -0,0 +1,23 @@
+export function keys(t) {
+    return {
+        /** Make a key with this one. It never has more than this key, and is in
+         *  the audit log as made by it. At most 100 live in an account. */
+        create: (input, options) => t.json({ method: "POST", path: "/v1/keys", body: input, ...options }),
+        /** This key and the keys it made (every key, for an account-wide key),
+         *  live first, with what each spent in the last 24 hours. */
+        list: async (options) => (await t.json({ method: "GET", path: "/v1/keys", ...options })).keys,
+        /** Revoke this key or one it made: a worker's, when the worker is done. */
+        revoke: (keyId, options) => t.json({
+            method: "DELETE",
+            path: `/v1/keys/${encodeURIComponent(keyId)}`,
+            ...options,
+        }),
+        /** What one key spent: itself, or a key it made. */
+        usage: async (keyId, options) => (await t.json({
+            method: "GET",
+            path: "/v1/usage",
+            query: { key: keyId },
+            ...options,
+        })).key,
+    };
+}

package/dist/products/apps.d.ts

@@ -1,5 +1,5 @@
-import { Page } from "../page.js";
 import type { RequestOptions, Transport } from "../transport.js";
+import { type ResourceDeleteOptions, type ResourceGetOptions, type ResourceListQuery, type ResourceWaitOptions } from "./resources.js";
 /** Private until launch. A deployment's completion follows its own record,
  * not the app's state. */
 export type AppState = "waiting" | "live" | "failed" | "deleting" | "deleted";
@@ -112,36 +112,17 @@ export type DeployGetOptions = RequestOptions & {
     waitFor?: DeployState;
     timeoutSeconds?: number;
 };
-export type AppListQuery = {
-    name?: string;
-    /** Repeated key:value filters; all must match. */
-    label?: readonly string[];
-    /** Defaults to waiting, live and failed. */
-    state?: readonly AppState[];
-    /** 1 to 100; defaults to 50. */
-    limit?: number;
-    cursor?: string;
-};
-export type AppGetOptions = RequestOptions & {
-    waitFor?: AppState;
-    /** Server wait, 1 to 60 seconds; defaults to 30. Check the returned state. */
-    timeoutSeconds?: number;
-};
-export type AppWaitOptions = RequestOptions & {
-    /** Whole wait, including retries; defaults to 300000 ms. 0 disables it. */
-    timeoutMs?: number;
-    /** Delay between reads; defaults to 250 ms. */
-    pollMs?: number;
-};
-export type AppDeleteOptions = AppWaitOptions & {
-    wait?: boolean;
-};
+/** Defaults to waiting, live and failed. */
+export type AppListQuery = ResourceListQuery<AppState>;
+export type AppGetOptions = ResourceGetOptions<AppState>;
+export type AppWaitOptions = ResourceWaitOptions;
+export type AppDeleteOptions = ResourceDeleteOptions;
 export declare function apps(t: Transport): {
     /** Create a resource waiting for its first version. Defaults belong to
      * the API, so the SDK does not override them. */
     create: (input: CreateApp, options?: RequestOptions) => Promise<App>;
-    get: (id: string, options?: AppGetOptions) => Promise<App>;
-    list: (query?: AppListQuery, options?: RequestOptions) => Promise<Page<App>>;
+    get: (id: string, options?: ResourceGetOptions<AppState>) => Promise<App>;
+    list: (query?: ResourceListQuery<AppState>, options?: RequestOptions) => Promise<import("../page.js").Page<App>>;
     deploy: (id: string, input: DeployApp, options?: AppWaitOptions) => Promise<AppDeploy>;
     getDeploy: (id: string, deployId: string, options?: DeployGetOptions) => Promise<AppDeploy>;
     /** Resume by deploy id after a process restart, without creating another version. */
@@ -153,14 +134,14 @@ export declare function apps(t: Transport): {
     /** Follow resource state, not a deployment: an
      * older live version can survive a failed rollout of a newer version. */
     wait: (id: string, target: "live" | "deleted", options?: AppWaitOptions) => Promise<App>;
-    delete: (id: string, options?: AppDeleteOptions) => Promise<App>;
+    delete: (id: string, options?: ResourceDeleteOptions) => Promise<App>;
 };
 export declare function functions(t: Transport): {
     /** Create a resource waiting for its first version. Defaults belong to
      * the API, so the SDK does not override them. */
     create: (input: CreateFunction, options?: RequestOptions) => Promise<RuntimeFunction>;
-    get: (id: string, options?: AppGetOptions) => Promise<RuntimeFunction>;
-    list: (query?: AppListQuery, options?: RequestOptions) => Promise<Page<RuntimeFunction>>;
+    get: (id: string, options?: ResourceGetOptions<AppState>) => Promise<RuntimeFunction>;
+    list: (query?: ResourceListQuery<AppState>, options?: RequestOptions) => Promise<import("../page.js").Page<RuntimeFunction>>;
     deploy: (id: string, input: DeployApp, options?: AppWaitOptions) => Promise<AppDeploy>;
     getDeploy: (id: string, deployId: string, options?: DeployGetOptions) => Promise<AppDeploy>;
     /** Resume by deploy id after a process restart, without creating another version. */
@@ -172,5 +153,5 @@ export declare function functions(t: Transport): {
     /** Follow resource state, not a deployment: an
      * older live version can survive a failed rollout of a newer version. */
     wait: (id: string, target: "live" | "deleted", options?: AppWaitOptions) => Promise<RuntimeFunction>;
-    delete: (id: string, options?: AppDeleteOptions) => Promise<RuntimeFunction>;
+    delete: (id: string, options?: ResourceDeleteOptions) => Promise<RuntimeFunction>;
 };

package/dist/products/apps.js

@@ -1,106 +1,7 @@
-import { RuntimeError } from "../errors.js";
-import { Page } from "../page.js";
-import { pause } from "../wait.js";
-const enc = encodeURIComponent;
-function invalid(field) {
-    return new RuntimeError({
-        code: "invalid_request",
-        status: 0,
-        message: `${field} must be a finite, nonnegative number.`,
-        hint: "Fix the option and call again; nothing was sent.",
-        details: { field },
-    });
-}
-/** One deadline covers the write, retries and every read. A timed-out delete
- * can be retried after a process restart with this same key. */
-async function following(options, work) {
-    const { pollMs = 250, timeoutMs = 300_000, signal, ...rest } = options;
-    if (!Number.isFinite(pollMs) || pollMs < 0)
-        throw invalid("pollMs");
-    if (!Number.isFinite(timeoutMs) || timeoutMs < 0)
-        throw invalid("timeoutMs");
-    const deadline = new AbortController();
-    const combined = signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal;
-    const timer = timeoutMs > 0 ? setTimeout(() => deadline.abort(), timeoutMs) : undefined;
-    const request = { ...rest, timeoutMs: 0, signal: combined };
-    const poll = () => pause(pollMs, combined);
-    try {
-        combined.throwIfAborted();
-        const result = await work(request, poll);
-        combined.throwIfAborted();
-        return result;
-    }
-    catch (cause) {
-        if (!combined.aborted) {
-            // A read failure still belongs to the write that started this wait.
-            // Keep its key so a caller can recover after losing the reply.
-            if (cause instanceof RuntimeError && rest.idempotencyKey && !cause.idempotencyKey)
-                throw new RuntimeError({
-                    message: cause.message,
-                    code: cause.code,
-                    status: cause.status,
-                    requestId: cause.requestId,
-                    hint: cause.hint,
-                    details: cause.details,
-                    retryAfterMs: cause.retryAfterMs,
-                    idempotencyKey: rest.idempotencyKey,
-                    cause,
-                });
-            throw cause;
-        }
-        throw new RuntimeError({
-            code: "timeout",
-            status: 0,
-            message: "Waiting was cancelled or reached its deadline; the resource may still change.",
-            hint: "Read the resource to resume waiting. Retry a write with the same idempotencyKey.",
-            ...(rest.idempotencyKey === undefined ? {} : { idempotencyKey: rest.idempotencyKey }),
-            cause,
-        });
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
+import { enc, following, resource, } from "./resources.js";
 function copies(t, plural) {
-    const base = `/v1/${plural}`;
-    const get = (id, options = {}) => {
-        const { waitFor, timeoutSeconds, ...request } = options;
-        return t.json({
-            method: "GET",
-            path: `${base}/${enc(id)}`,
-            query: { waitFor, timeoutSeconds },
-            ...request,
-        });
-    };
-    const list = async (query = {}, options) => {
-        const page = await t.json({
-            method: "GET",
-            path: base,
-            query,
-            ...options,
-        });
-        return new Page(page.data, page.nextCursor, (cursor) => list({ ...query, cursor }, options));
-    };
-    const follow = async (id, target, request, pause, initial) => {
-        let record = initial ?? (await get(id, request));
-        for (;;) {
-            if (record.state === target)
-                return record;
-            if (["failed", "deleted", "live"].includes(record.state))
-                throw new RuntimeError({
-                    code: record.error?.code ?? "unexpected_state",
-                    status: 0,
-                    message: record.error?.message ?? `Expected ${target}, but ${id} reached ${record.state}.`,
-                    hint: "Read the resource and inspect its error before starting another change.",
-                    details: { id, state: record.state, target, resource: record },
-                    ...(request.idempotencyKey === undefined
-                        ? {}
-                        : { idempotencyKey: request.idempotencyKey }),
-                });
-            await pause();
-            record = await get(id, request);
-        }
-    };
+    const shape = resource(t, plural, ["failed", "deleted", "live"]);
+    const { base, get } = shape;
     const getDeploy = (id, deployId, options = {}) => {
         const { waitFor, timeoutSeconds, ...request } = options;
         return t.json({
@@ -128,9 +29,9 @@ function copies(t, plural) {
     return {
         /** Create a resource waiting for its first version. Defaults belong to
          * the API, so the SDK does not override them. */
-        create: (input, options) => t.json({ method: "POST", path: base, body: input, ...options }),
+        create: shape.create,
         get,
-        list,
+        list: shape.list,
         deploy: (id, input, options = {}) => {
             const { wait = false, ...body } = input;
             return writeDeploy(id, "deploys", body, wait, options);
@@ -144,17 +45,11 @@ function copies(t, plural) {
         },
         versions: (id, options) => t.json({ method: "GET", path: `${base}/${enc(id)}/versions`, ...options }),
         copies: (id, options) => t.json({ method: "GET", path: `${base}/${enc(id)}/copies`, ...options }),
-        update: (id, input, options) => t.json({ method: "POST", path: `${base}/${enc(id)}:update`, body: input, ...options }),
+        update: shape.update,
         /** Follow resource state, not a deployment: an
          * older live version can survive a failed rollout of a newer version. */
-        wait: (id, target, options = {}) => following(options, (request, pause) => follow(id, target, request, pause)),
-        delete: (id, options = {}) => {
-            const { wait = false, pollMs, ...request } = options;
-            const remove = (rest) => t.json({ method: "DELETE", path: `${base}/${enc(id)}`, ...rest });
-            if (!wait)
-                return remove(request);
-            return following({ ...request, pollMs, idempotencyKey: request.idempotencyKey ?? crypto.randomUUID() }, async (rest, pause) => follow(id, "deleted", rest, pause, await remove(rest)));
-        },
+        wait: (id, target, options = {}) => shape.wait(id, target, options),
+        delete: shape.delete,
     };
 }
 export function apps(t) {