withruntime 0.17.1 → 0.18.0

package/dist/cli.d.ts

@@ -24,9 +24,13 @@ declare const kit: {
     pairs: (args: Args, name: string) => {
         [k: string]: string;
     };
+    envPairs: (args: Args, from: NodeJS.ProcessEnv) => {
+        [k: string]: string;
+    };
     need: (value: string | undefined, what: string) => string;
     table: (rows: string[][]) => string;
     usage: (message: string) => RuntimeError;
+    unknown: (what: string, word: string, choices: readonly string[]) => RuntimeError;
 };
 export type CliKit = typeof kit;
 export declare function run(argv: string[], env?: NodeJS.ProcessEnv, out?: Out): Promise<number>;

package/dist/cli.js

@@ -109,6 +109,8 @@ Products
   images     Custom images from a Dockerfile, any public or private image, or a package list
   volumes    Persistent disks to attach to sandboxes
   jobs       A command in a fresh sandbox, once or on a cron schedule, with its logs
+  apps       Your web server from an image or a build, copies started by requests (beta)
+  builds     A connected repository's commits built into what an App deploys (beta)
   domains    Your own hostname for a sandbox's port, with HTTPS
   ports      A public TCP port to a sandbox: databases, game servers
   ips        A dedicated outbound address, for allow-lists
@@ -357,9 +359,11 @@ const kit = {
     has,
     integer,
     pairs,
+    envPairs,
     need: (value, what) => need(value, what),
     table: (rows) => table(rows),
     usage: (message) => usage(message),
+    unknown: (what, word, choices) => unknown(what, word, choices),
 };
 /** The product being run, so a mistake points at its own help. */
 let product = "";
@@ -421,6 +425,8 @@ const COMMANDS = [
     "images",
     "volumes",
     "jobs",
+    "apps",
+    "builds",
     "domains",
     "ports",
     "ips",
@@ -439,6 +445,8 @@ const OWN_HELP = [
     "images",
     "volumes",
     "jobs",
+    "apps",
+    "builds",
     "keys",
     "webhooks",
     "webhook",
@@ -837,6 +845,7 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
             ],
             ["used, last 24 hours", usd(l.daily.usedMicros)],
             ...(l.daily.remainingMicros === null ? [] : [["left", usd(l.daily.remainingMicros)]]),
+            ...(l.credit ? [["credit", creditLine(l.credit, usd)]] : []),
             ...(l.trial ? [["free time", trialLeft(l.trial)]] : []),
             ...(spend?.pilot
                 ? [
@@ -845,6 +854,8 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
                 ]
                 : []),
         ]), l);
+        if (l.credit?.addedBy === "agent" && !out.json)
+            out.write(`No person pays for this account, so add credit yourself: \`${me} billing topup <usd>\`.`);
         return 0;
     }
     if (command === "secrets")
@@ -929,8 +940,8 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
     if (command === "billing") {
         product = "billing";
         const origins = connectionOrigins(env);
-        const { claimWalletAccount, openWalletAccount } = await import("./wallet.js");
-        return billingCommand(rest, parse(rest, ["wait", "new-account", "accept-terms"], ["below", "amount", "monthly"]), out, () => client(env), undefined, {
+        const { claimWalletAccount, openWalletAccount, rekeyWalletAccount } = await import("./wallet.js");
+        return billingCommand(rest, parse(rest, ["wait", "new-account", "accept-terms", "new-key"], ["below", "amount", "monthly"]), out, () => client(env), undefined, {
             open: (input) => {
                 checkBrowserOrigins(origins);
                 return openWalletAccount(input, { authUrl: origins.auth });
@@ -939,6 +950,10 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
                 checkBrowserOrigins(origins);
                 return claimWalletAccount(code, { authUrl: origins.auth });
             },
+            rekey: (code) => {
+                checkBrowserOrigins(origins);
+                return rekeyWalletAccount(code, { authUrl: origins.auth });
+            },
             save: (key, orgId) => {
                 checkBrowserOrigins(origins);
                 return connectionStore(env).save({
@@ -1088,6 +1103,14 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
         product = "job";
         return jobCommand(rest, env, out);
     }
+    if (command === "app" || command === "apps") {
+        product = "apps";
+        return (await import("./apps-cli.js")).appsCommand(rest, env, out, () => client(env), kit);
+    }
+    if (command === "build" || command === "builds") {
+        product = "builds";
+        return (await import("./apps-cli.js")).buildsCommand(rest, out, () => client(env), kit);
+    }
     // WireGuard is inside networks: `runtime networks wireguard peer add`.
     const wireguard = command === "networks" && rest[0] === "wireguard";
     const networkProduct = wireguard ? "wireguard" : command;
@@ -1356,6 +1379,14 @@ export function outOfMemoryLines(memory) {
 /** Dollars from integer microdollars: cents from a dollar up, four places
  * below one, and every place below a hundredth of a cent, so a short trial
  * test never reads as $0.0000. */
+function creditLine(c, usd) {
+    if (c.state === "empty")
+        return "none left: add credit to keep going";
+    const days = c.runwayDays === null
+        ? "nothing is being spent"
+        : `lasts about ${Math.max(1, Math.round(c.runwayDays))} ${Math.round(c.runwayDays) <= 1 ? "day" : "days"} at this month's pace`;
+    return `${usd(c.availableMicros)} left, ${days}${c.state === "low" ? " (low)" : ""}`;
+}
 function dollars(micros) {
     const value = BigInt(micros);
     const sign = value < 0n ? "-" : "";

package/dist/daytona/index.d.ts

@@ -19,6 +19,67 @@ export declare const SandboxState: {
     readonly DESTROYED: "destroyed";
 };
 export type SandboxState = (typeof SandboxState)[keyof typeof SandboxState];
+export declare const GpuType: {
+    readonly H100: "H100";
+    readonly H200: "H200";
+    readonly B200: "B200";
+    readonly B300: "B300";
+    readonly RTX_PRO_6000: "RTX-PRO-6000";
+    readonly RTX_4090: "RTX-4090";
+    readonly RTX_5090: "RTX-5090";
+    readonly MI355X: "MI355X";
+    readonly UNKNOWN_DEFAULT_OPEN_API: "11184809";
+};
+export type GpuType = (typeof GpuType)[keyof typeof GpuType];
+export declare const SnapshotState: {
+    readonly BUILDING: "building";
+    readonly PENDING: "pending";
+    readonly PULLING: "pulling";
+    readonly SNAPSHOTTING: "snapshotting";
+    readonly ACTIVE: "active";
+    readonly INACTIVE: "inactive";
+    readonly ERROR: "error";
+    readonly BUILD_FAILED: "build_failed";
+    readonly REMOVING: "removing";
+    readonly UNKNOWN_DEFAULT_OPEN_API: "11184809";
+};
+export type SnapshotState = (typeof SnapshotState)[keyof typeof SnapshotState];
+export declare const SandboxListSortField: {
+    readonly NAME: "name";
+    readonly CPU: "cpu";
+    readonly MEMORY_GIB: "memoryGib";
+    readonly DISK_GIB: "diskGib";
+    readonly LAST_ACTIVITY_AT: "lastActivityAt";
+    readonly CREATED_AT: "createdAt";
+    readonly UNKNOWN_DEFAULT_OPEN_API: "11184809";
+};
+export type SandboxListSortField = (typeof SandboxListSortField)[keyof typeof SandboxListSortField];
+export declare const SandboxListSortDirection: {
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+    readonly UNKNOWN_DEFAULT_OPEN_API: "11184809";
+};
+export type SandboxListSortDirection = (typeof SandboxListSortDirection)[keyof typeof SandboxListSortDirection];
+export declare const SandboxClass: {
+    readonly LINUX_VM: "linux-vm";
+    readonly CONTAINER: "container";
+    readonly WINDOWS: "windows";
+    readonly UNKNOWN_DEFAULT_OPEN_API: "11184809";
+};
+export type SandboxClass = (typeof SandboxClass)[keyof typeof SandboxClass];
+export declare const ListSecretsPaginatedSortEnum: {
+    readonly NAME: "name";
+    readonly CREATED_AT: "createdAt";
+    readonly UPDATED_AT: "updatedAt";
+    readonly UNKNOWN_DEFAULT_OPEN_API: "11184809";
+};
+export type ListSecretsPaginatedSortEnum = (typeof ListSecretsPaginatedSortEnum)[keyof typeof ListSecretsPaginatedSortEnum];
+export declare const ListSecretsPaginatedOrderEnum: {
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+    readonly UNKNOWN_DEFAULT_OPEN_API: "11184809";
+};
+export type ListSecretsPaginatedOrderEnum = (typeof ListSecretsPaginatedOrderEnum)[keyof typeof ListSecretsPaginatedOrderEnum];
 export declare const LspLanguageId: {
     (...args: unknown[]): never;
     new (...args: unknown[]): never;

package/dist/daytona/index.js

@@ -26,6 +26,63 @@ export const SandboxState = {
     DESTROYING: "destroying",
     DESTROYED: "destroyed",
 };
+/* Daytona's other enums, re-exported by @daytona/sdk from its API client, so
+   code importing them loads. A GPU type on create is refused (Runtime runs
+   sandboxes on CPUs); the sort field and direction drive daytona.list. */
+export const GpuType = {
+    H100: "H100",
+    H200: "H200",
+    B200: "B200",
+    B300: "B300",
+    RTX_PRO_6000: "RTX-PRO-6000",
+    RTX_4090: "RTX-4090",
+    RTX_5090: "RTX-5090",
+    MI355X: "MI355X",
+    UNKNOWN_DEFAULT_OPEN_API: "11184809",
+};
+export const SnapshotState = {
+    BUILDING: "building",
+    PENDING: "pending",
+    PULLING: "pulling",
+    SNAPSHOTTING: "snapshotting",
+    ACTIVE: "active",
+    INACTIVE: "inactive",
+    ERROR: "error",
+    BUILD_FAILED: "build_failed",
+    REMOVING: "removing",
+    UNKNOWN_DEFAULT_OPEN_API: "11184809",
+};
+export const SandboxListSortField = {
+    NAME: "name",
+    CPU: "cpu",
+    MEMORY_GIB: "memoryGib",
+    DISK_GIB: "diskGib",
+    LAST_ACTIVITY_AT: "lastActivityAt",
+    CREATED_AT: "createdAt",
+    UNKNOWN_DEFAULT_OPEN_API: "11184809",
+};
+export const SandboxListSortDirection = {
+    ASC: "asc",
+    DESC: "desc",
+    UNKNOWN_DEFAULT_OPEN_API: "11184809",
+};
+export const SandboxClass = {
+    LINUX_VM: "linux-vm",
+    CONTAINER: "container",
+    WINDOWS: "windows",
+    UNKNOWN_DEFAULT_OPEN_API: "11184809",
+};
+export const ListSecretsPaginatedSortEnum = {
+    NAME: "name",
+    CREATED_AT: "createdAt",
+    UPDATED_AT: "updatedAt",
+    UNKNOWN_DEFAULT_OPEN_API: "11184809",
+};
+export const ListSecretsPaginatedOrderEnum = {
+    ASC: "asc",
+    DESC: "desc",
+    UNKNOWN_DEFAULT_OPEN_API: "11184809",
+};
 /** A stand-in for a Daytona export Runtime has no counterpart for. Importing
  * it works; using it throws NotSupportedError naming the alternative. */
 function unsupportedExport(name, alternative) {

package/dist/daytona/sandbox.d.ts

@@ -126,7 +126,8 @@ export declare class Sandbox {
     /** Pauses the sandbox with its memory. */
     pause(_timeout?: number): Promise<void>;
     /** Runtime has no archive tier: a stopped sandbox stays paused, kept for
-     * its retention (30 days paid, 7 without credit, or autoDeleteInterval). */
+     * its retention (while the account has credit, 7 days without, or
+     * autoDeleteInterval rounded up to whole days). */
     archive(): Promise<void>;
     /** Ends the sandbox for good. */
     delete(_timeout?: number): Promise<void>;

package/dist/daytona/sandbox.js

@@ -270,7 +270,8 @@ export class Sandbox {
         this.#pausedByPause = true;
     }
     /** Runtime has no archive tier: a stopped sandbox stays paused, kept for
-     * its retention (30 days paid, 7 without credit, or autoDeleteInterval). */
+     * its retention (while the account has credit, 7 days without, or
+     * autoDeleteInterval rounded up to whole days). */
     async archive() {
         await this.stop();
     }

package/dist/identity.js

@@ -5,8 +5,24 @@ async function requestCredentials() {
     const token = process.env.RUNTIME_ID_TOKEN_REQUEST_TOKEN;
     if (url && token)
         return { url, token };
-    // A process started before the guest wrote its environment still finds it.
-    return fileCredentials();
+    // A process started without them (a server started before the guest wrote
+    // its environment, a sandbox whose guest software predates the variables)
+    // asks the host, which answers every running sandbox whatever its image or
+    // age, then the guest's file. Only inside a sandbox: elsewhere nothing is
+    // asked over the network.
+    if (!(await exists(sandboxMarker.path)))
+        return null;
+    return currentCredentials();
+}
+async function exists(path) {
+    try {
+        const { access } = await import("node:fs/promises");
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 async function fileCredentials() {
     try {

package/dist/index.d.ts

@@ -72,7 +72,7 @@ export declare class Sandbox extends SandboxClass {
 }
 export type { RuntimeOptions as ClientOptions };
 export { identityToken, type IdentityToken } from "./identity.js";
-export { openWalletAccount, claimWalletAccount, type OpenedWalletAccount, type WalletClaim, type WalletOptions, } from "./wallet.js";
+export { openWalletAccount, claimWalletAccount, rekeyWalletAccount, type OpenedWalletAccount, type WalletClaim, type WalletRekey, type WalletOptions, } from "./wallet.js";
 export type { Topup } from "./products/billing.js";
 export type { NewKey, LimitedKey, LimitedKeyAction, MadeKey, ListedKey, KeyUsage, } from "./products/api-keys.js";
 export type { SsoConnection, SsoStatus } from "./products/sso.js";

package/dist/index.js

@@ -47,4 +47,4 @@ export class Sandbox extends SandboxClass {
     }
 }
 export { identityToken } from "./identity.js";
-export { openWalletAccount, claimWalletAccount, } from "./wallet.js";
+export { openWalletAccount, claimWalletAccount, rekeyWalletAccount, } from "./wallet.js";

package/dist/products/apps.d.ts

@@ -82,6 +82,8 @@ export type AppDeploy = {
         lastOutput: string;
     };
 });
+/** `image`: an image of this account (id, name, name:tag or name@version),
+ * ready; the version records its id. */
 export type DeployApp = ({
     image: string;
     build?: never;
@@ -93,8 +95,10 @@ export type DeployApp = ({
     /** Carry the last deploy's environment, still sealed. With env, that
      * environment with env's names set: change one value without sending the rest
      * (needs a key that may reveal the App's secrets, secrets_reveal; else 403).
-     * Only for a build a push to the production branch made, from the repository the
-     * environment came with; otherwise refused with keep_env_refused (409). */
+     * For a build: only one a push to the production branch made, from the
+     * repository the environment came with. For an image: only from a key that
+     * may reveal the App's secrets, and only an environment named with an image
+     * deploy. Otherwise refused with keep_env_refused (409). */
     keepEnv?: boolean;
     port?: number;
     healthPath?: string;

package/dist/products/browser.d.ts

@@ -37,8 +37,10 @@ export type BrowserStartOptions = {
  *
  * Inside the sandbox the same browser is at http://127.0.0.1:9222. */
 export declare function sandboxBrowser(t: Transport, sandbox: Sandbox): {
-    /** Starts Chromium and returns its CDP address. The first start in a
-     * sandbox installs Chromium, about a minute; this waits for it (up to 10
+    /** Starts Chromium and returns its CDP address. A start in a new
+     * sandbox takes about 1 to 2 seconds: Chromium comes from the host. A
+     * sandbox from a custom image that is not Ubuntu 24.04 x86_64 installs it
+     * on the first start, about a minute; this waits for it (up to 10
      * minutes, or the call's timeoutMs). Starting a running browser returns it
      * as it is. */
     start(input?: BrowserStartOptions, options?: RequestOptions): Promise<{

package/dist/products/browser.js

@@ -8,8 +8,10 @@ import { whileInstalling } from "../wait.js";
 export function sandboxBrowser(t, sandbox) {
     const base = () => `/v1/sandboxes/${encodeURIComponent(sandbox.id)}/browser`;
     return {
-        /** Starts Chromium and returns its CDP address. The first start in a
-         * sandbox installs Chromium, about a minute; this waits for it (up to 10
+        /** Starts Chromium and returns its CDP address. A start in a new
+         * sandbox takes about 1 to 2 seconds: Chromium comes from the host. A
+         * sandbox from a custom image that is not Ubuntu 24.04 x86_64 installs it
+         * on the first start, about a minute; this waits for it (up to 10
          * minutes, or the call's timeoutMs). Starting a running browser returns it
          * as it is. */
         async start(input = {}, options) {

package/dist/products/builds.d.ts

@@ -86,8 +86,12 @@ export type ListBuilds = {
     name?: string;
     label?: string[];
     state?: BuildState[];
+    /** Only this connected repository's builds. */
+    repositoryId?: string;
+    /** Only builds of this commit, by its full sha. */
+    commit?: string;
 };
-export type ListRepositories = Omit<ListBuilds, "state"> & {
+export type ListRepositories = Omit<ListBuilds, "state" | "repositoryId" | "commit"> & {
     state?: Repository["state"][];
 };
 export type BuildLine = {
@@ -151,6 +155,12 @@ export declare function builds(t: Transport): {
         list: (query?: ListRepositories, options?: RequestOptions) => Promise<Page<Repository>>;
         update: (id: string, change: ChangeRepository, options?: RequestOptions) => Promise<Repository>;
         disconnect: (id: string, options?: RequestOptions) => Promise<Repository>;
+        /** A link to install Runtime's GitHub App, open for 15 minutes: a
+         * private repository builds once its owner installs it. */
+        installGithub: (options?: RequestOptions) => Promise<{
+            url: string;
+            expiresAt: string;
+        }>;
     };
 };
 export {};

package/dist/products/builds.js

@@ -222,6 +222,13 @@ export function builds(t) {
                 path: `/v1/repositories/${encodeURIComponent(id)}`,
                 ...options,
             }),
+            /** A link to install Runtime's GitHub App, open for 15 minutes: a
+             * private repository builds once its owner installs it. */
+            installGithub: (options) => t.json({
+                method: "POST",
+                path: "/v1/repositories/github:install",
+                ...options,
+            }),
         },
     };
 }

package/dist/products/limits.d.ts

@@ -22,6 +22,24 @@ export type KeyLimits = {
      * numbers a create past one is refused `quota_exceeded` by (its
      * `details.limit` names the row). Null when they can't be read. */
     account: AccountLimit[] | null;
+    /** The account's prepaid credit and how long it lasts. */
+    credit: {
+        /** Credit left to spend now, in microdollars. */
+        availableMicros: string;
+        /** What the account spends in a day at this month's pace, or null when
+         * nothing has been spent yet. */
+        dailyPaceMicros: string | null;
+        /** Days the credit lasts at that pace, or null when nothing is being spent. */
+        runwayDays: number | null;
+        /** `state` is "low" when the runway is under this many days. */
+        lowBelowDays: number;
+        /** ok: enough. low: under `lowBelowDays` of runway. empty: none left. */
+        state: "ok" | "low" | "empty";
+        /** owner: a person pays for this account. agent: it was opened with a
+         * wallet and no person pays, so its own agent adds credit with
+         * `runtime billing topup <usd>`. */
+        addedBy: "owner" | "agent";
+    };
 };
 /** One of the account's limits, as https://withruntime.com/account/limits shows it. */
 export type AccountLimit = {

package/dist/products/observability.d.ts

@@ -35,7 +35,7 @@ export type SandboxMetrics = {
     latest: MetricPoint | null;
     points: MetricPoint[];
 };
-export type WebhookEventType = "sandbox.created" | "sandbox.running" | "sandbox.paused" | "sandbox.woken" | "sandbox.stopped" | "sandbox.start_failed" | "sandbox.wake_failed" | "sandbox.host_unreachable" | "sandbox.host_reachable" | "sandbox.recovered" | "sandbox.recovery_failed" | "sandbox.files.changed" | "sandbox.out_of_memory" | "sandbox.secret_not_applied" | "snapshot.ready" | "snapshot.failed" | "snapshot.deleted" | "volume.ready" | "volume.failed" | "volume.deleted" | "volume.recovered" | "egress_secret.created" | "egress_secret.updated" | "egress_secret.deleted" | "upstream_proxy.set" | "upstream_proxy.removed";
+export type WebhookEventType = "sandbox.created" | "sandbox.running" | "sandbox.paused" | "sandbox.woken" | "sandbox.stopped" | "sandbox.start_failed" | "sandbox.wake_failed" | "sandbox.host_unreachable" | "sandbox.host_reachable" | "sandbox.recovered" | "sandbox.recovery_failed" | "sandbox.files.changed" | "sandbox.out_of_memory" | "sandbox.secret_not_applied" | "snapshot.ready" | "snapshot.failed" | "snapshot.deleted" | "volume.ready" | "volume.failed" | "volume.deleted" | "volume.recovered" | "egress_secret.created" | "egress_secret.updated" | "egress_secret.deleted" | "upstream_proxy.set" | "upstream_proxy.removed" | "credit.low" | "credit.empty";
 /** An event as /v1/events lists it and a webhook delivers it. */
 export type RuntimeEvent = {
     id: string;

package/dist/transport.d.ts

@@ -1,5 +1,5 @@
 import { RuntimeError } from "./errors.js";
-export declare const VERSION = "0.17.1";
+export declare const VERSION = "0.18.0";
 export declare const DEFAULT_BASE_URL = "https://api.withruntime.com";
 /** Runtime's API as code inside a Runtime sandbox reaches it: the sandbox's
  * own host sends each request on to DEFAULT_BASE_URL over HTTPS. The API runs

package/dist/transport.js

@@ -1,7 +1,7 @@
 import { ConnectionError, DELIBERATE, errorFor, NOTHING_RAN, RuntimeError, WAITS_FOR_ROOM, } from "./errors.js";
 import { describeRoute, envFetch, openWebSocket } from "./proxy.js";
 import { warningText } from "./product-renames.js";
-export const VERSION = "0.17.1";
+export const VERSION = "0.18.0";
 export const DEFAULT_BASE_URL = "https://api.withruntime.com";
 /** Runtime's API as code inside a Runtime sandbox reaches it: the sandbox's
  * own host sends each request on to DEFAULT_BASE_URL over HTTPS. The API runs

package/dist/vercel/errors.d.ts

@@ -45,7 +45,7 @@ export declare function translate(error: unknown, sandboxName?: string): unknown
 export declare function guard<T>(work: () => Promise<T>, sandboxName?: string): Promise<T>;
 /** A node:fs-style error, as Vercel's `sandbox.fs` throws. */
 export declare function fsError(code: "ENOENT" | "EEXIST" | "EISDIR" | "ENOTDIR" | "EACCES" | "ENOTEMPTY" | "EINVAL", syscall: string, path: string): Error & {
-    code: "ENOENT" | "ENOTDIR" | "EEXIST" | "EISDIR" | "EACCES" | "ENOTEMPTY" | "EINVAL";
+    code: "ENOENT" | "EEXIST" | "ENOTDIR" | "EISDIR" | "EACCES" | "ENOTEMPTY" | "EINVAL";
     errno: number;
     syscall: string;
     path: string;

package/dist/wallet.d.ts

@@ -20,6 +20,14 @@ export type WalletClaim = {
     /** What to do now, such as sending the top-up again when it has no address. */
     next?: string;
 };
+export type WalletRekey = {
+    status: "replaced";
+    orgId: string;
+    /** The new key, shown once. The old one no longer works. */
+    apiKey: string;
+    /** The id of the key this replaced, or null when there was none to revoke. */
+    revokedKeyId: string | null;
+};
 /** Opens an account and a stablecoin top-up of `usd` dollars ($10 to $500,
  *  a new account's first week).
  *  `acceptTerms` must be true: opening one means agreeing to
@@ -31,3 +39,7 @@ export declare function openWalletAccount(input: {
 /** Exchanges a paid account's claim code for its API key, once. Until the
  *  payment arrives it answers the top-up's status instead; call it again. */
 export declare function claimWalletAccount(claimCode: string, options?: WalletOptions): Promise<WalletClaim>;
+/** Replaces a lost API key with a new one, using the account's claim code. The
+ *  account's every other key stops working. Refused (409) when the first key was never claimed or
+ *  a person took the account over, and (429) past 3 times in 24 hours. */
+export declare function rekeyWalletAccount(claimCode: string, options?: WalletOptions): Promise<WalletRekey>;

package/dist/wallet.js

@@ -47,3 +47,10 @@ export async function claimWalletAccount(claimCode, options = {}) {
     const [, claim] = await post(options, "/api/wallet/claim", { claimCode });
     return claim;
 }
+/** Replaces a lost API key with a new one, using the account's claim code. The
+ *  account's every other key stops working. Refused (409) when the first key was never claimed or
+ *  a person took the account over, and (429) past 3 times in 24 hours. */
+export async function rekeyWalletAccount(claimCode, options = {}) {
+    const [, rekey] = await post(options, "/api/wallet/rekey", { claimCode });
+    return rekey;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "withruntime",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "license": "Apache-2.0",
   "mcpName": "com.withruntime/runtime",
   "type": "module",