withruntime 0.16.1 → 0.17.2

package/DAYTONA.md

@@ -17,8 +17,8 @@ from withruntime.daytona import AsyncDaytona  # was: from daytona import AsyncDa
 ```
 
 The mapping was written against `@daytona/sdk` 0.220.0 and `daytona` 0.220.0
-on PyPI, and checked against `@daytona/sdk` and `daytona` 0.224.1 on
-15 October 2026 (below, "0.224.1"). The exact releases and artifact hashes
+on PyPI, and checked against `@daytona/sdk` and `daytona` 0.225.0 on
+18 October 2026 (below, "0.225.0"). The exact releases and artifact hashes
 are kept in `compatibility-lock.json`.
 
 ## Keys
@@ -126,6 +126,37 @@ Some differences are not refusals:
 - `autoArchiveInterval` is recorded only: Runtime has no archive tier.
 - Runtime's stock image is Ubuntu 24.04 with Python 3.12, Node.js 24 and Bun.
 
+## 0.225.0, 18 October 2026
+
+Reviewed the published npm tarballs for `@daytona/sdk`, `@daytona/api-client`,
+`@daytona/toolbox-api-client` and `@daytona/analytics-api-client` 0.224.1 →
+0.225.0, and the PyPI wheel and sdist for `daytona` 0.224.1 → 0.225.0, each its
+registry's latest when checked. Every pinned file matched the hash already in
+`compatibility-lock.json`, every new file its registry's SHA-512 integrity or
+SHA-256 digest, and the wheel's Python source is byte for byte its sdist's.
+Nothing was installed, imported or run. No declaration of `@daytona/sdk` and no
+Python source of `daytona` changed: only versions and the exact pins on the
+three API clients. The one API change is in `@daytona/api-client` (and its
+PyPI twins): `GpuType` gains `B200`.
+
+| Upstream change | Drop-in disposition                                                                                                                                            |
+| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `GpuType.B200`  | Exported, with every other `GpuType`. A create naming any GPU type is refused (`NotSupportedError`, "Runtime runs sandboxes on CPUs") before anything is made. |
+
+Two gaps near it are closed with the review. `@daytona/sdk` re-exports
+`GpuType`, `SnapshotState`, `SandboxListSortField`, `SandboxListSortDirection`,
+`SandboxClass`, `ListSecretsPaginatedSortEnum` and
+`ListSecretsPaginatedOrderEnum`, and `daytona` exports `GpuType`,
+`SandboxClass`, `SandboxListSortField` and `SandboxListSortDirection`; the
+drop-ins exported none of them, so code importing one failed. They are exported
+now with upstream's values, and the sort enums drive `list`. Python refused
+`Resources(gpu=...)` but made a CPU sandbox for `Resources(gpu_type=...)`
+alone, which Daytona sends as a GPU request; it is refused now, as in
+TypeScript. `tests/daytona/daytona-0-225-0.test.ts` and
+`sdks/python/tests/test_daytona_0_225_0.py` fail without this change. The
+oracle was not run against the new release, since it executes Daytona's code;
+the provider remains marked `partial`.
+
 ## 0.224.1, 15 October 2026
 
 Reviewed the published npm tarballs for `@daytona/sdk`, `@daytona/api-client`,

package/compatibility-lock.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "checkedAt": "2026-10-11",
+  "checkedAt": "2026-10-18",
   "providers": [
     {
       "id": "e2b",
@@ -49,42 +49,42 @@
         {
           "registry": "npm",
           "name": "@daytona/sdk",
-          "version": "0.224.1",
+          "version": "0.225.0",
           "artifacts": {
-            "0.224.1": "sha512-ZQCY9qOXnAXpYD8KhMzn27VNk6KYfBYCpHhij5Th36+fMXfG8qpxvnb3xau/H7ZWN1HPBhlzjaHHn/J+ZhH/OQ=="
+            "0.225.0": "sha512-PeE4INyipIP6HzSNAZTfR+As2u+rwddCAniCk9a/gEjEh4JpvyCyTNASjikpsTcZSn1XvksmxhxKFodv6x0YYQ=="
           }
         },
         {
           "registry": "pypi",
           "name": "daytona",
-          "version": "0.224.1",
+          "version": "0.225.0",
           "artifacts": {
-            "daytona-0.224.1-py3-none-any.whl": "sha256-2dedf1ef0c5f98dd0c3a70ab130284abdd7414a3b8a6f6452842c4f5dcc2a583",
-            "daytona-0.224.1.tar.gz": "sha256-02d5a2fa8099f18503310a80b6b807c5fb18863738c13026ea4dad21a454a831"
+            "daytona-0.225.0-py3-none-any.whl": "sha256-8cdeb78e5d34b08c4818bd9dfa67fb693152c37eb0907067980fc1bd031256e5",
+            "daytona-0.225.0.tar.gz": "sha256-7fd2e9422360ca2d3b393af137231f4fd9d9a128c9a4070d231f8c776e446dc8"
           }
         },
         {
           "registry": "npm",
           "name": "@daytona/api-client",
-          "version": "0.224.1",
+          "version": "0.225.0",
           "artifacts": {
-            "0.224.1": "sha512-RFsDcGuifpyKnUHlfTLC9jDXXg7ZwciKlzmy0MBGcG5VKSRdwlRyqCaM9g6/k7m5eQ+N1ieQR2JAjZnVWn23YQ=="
+            "0.225.0": "sha512-P0HJOfLc3LGzeRdRhIogaA2q4+Of84UBCMWCFfnDeJ91pxQ4FExJ2KY5uF631MoNx1F+u2tc7fl0z0JuBNa/Uw=="
           }
         },
         {
           "registry": "npm",
           "name": "@daytona/toolbox-api-client",
-          "version": "0.224.1",
+          "version": "0.225.0",
           "artifacts": {
-            "0.224.1": "sha512-fiuBJedfubBMoLh1Z7VdAWsgnQaYGsQMZoAGV12IZ3R5D/ELFATd4tq/jW1mhSl7X27lxqSmtkHvaQt3ELRNPA=="
+            "0.225.0": "sha512-+LGQtqZTY0SBGMut3bhCPNU/cvfwKQcU1tAoVStZD9mM7EHWPey2TkMF+ZW0Fq2waWPEH2g7JhWWz9YFBUBQeQ=="
           }
         },
         {
           "registry": "npm",
           "name": "@daytona/analytics-api-client",
-          "version": "0.224.1",
+          "version": "0.225.0",
           "artifacts": {
-            "0.224.1": "sha512-CDW5CWbf5Ql0h31uZDD0vcOjJ8T0KimARqgni6gc9YICAoN0tx3getO4CDySTgjJpiYwH1qw4zlJs+h36L0T8w=="
+            "0.225.0": "sha512-zsj9YjBpXmQ2owhJF7+LEpKnekYy9D4wA52U6P7jsB7ng5KeSQ+3+0MFR3Bj3Cy3HIcKNW96e30F6olbiK/q+A=="
           }
         }
       ]
@@ -248,10 +248,10 @@
         {
           "registry": "pypi",
           "name": "prime-sandboxes",
-          "version": "0.4.5",
+          "version": "0.4.6",
           "artifacts": {
-            "prime_sandboxes-0.4.5-py3-none-any.whl": "sha256-3f24ed4830d2d823169fdb2df75de3b8355224bf867c0208d47eab0d3b33bb33",
-            "prime_sandboxes-0.4.5.tar.gz": "sha256-4f7b7e50d3d60d3b459fb3ace5713e7d9eb136ac0aa79cf0e7ee7c75c63b0d82"
+            "prime_sandboxes-0.4.6-py3-none-any.whl": "sha256-e97c6e70c032e0b6d7defdb26d6192a02643ad279af1a4726ebceb35ee89d70c",
+            "prime_sandboxes-0.4.6.tar.gz": "sha256-23204a465500e9c20639e3043e92d703712d8c80b94d6434bfeb82c787102915"
           }
         }
       ]

package/dist/billing-cli.d.ts

@@ -1,5 +1,5 @@
 import type { Runtime } from "./client.js";
-import type { claimWalletAccount, openWalletAccount } from "./wallet.js";
+import type { claimWalletAccount, openWalletAccount, rekeyWalletAccount } from "./wallet.js";
 type Out = {
     json: boolean;
     write: (text: string) => void;
@@ -9,11 +9,13 @@ type Args = {
     positional: string[];
     flags: Map<string, string[]>;
 };
-export declare const BILLING_HELP = "runtime billing <command>\n\n  topup <usd> [--wait]      Buy credit with stablecoins (USDC on Base, Solana or Tempo).\n                            Prints an address per network and the exact amount to send.\n                            Send exactly that, from any wallet, before the time shown.\n                            --wait keeps checking until the credit lands.\n  status <id> [--wait]      Whether a top-up's payment has arrived\n\n  auto-top-up               Show auto top-up: the card is charged when credit runs low\n  auto-top-up on [--below <usd>] [--amount <usd>] [--monthly <usd>]\n                            Charge <amount> plus tax when credit falls below <below>,\n                            at most <monthly> a month: $10, $20 and $500 unless given,\n                            or as last set. At least $10, $20 and $100. 5% more as\n                            credit each time, and 200 sandboxes at once while on.\n                            A person saves the card at\n                            https://withruntime.com/account/billing\n  auto-top-up off           Turn it off. Running sandboxes are never stopped.\n\n  No account yet? An agent can open one with a wallet alone:\n  topup <usd> --new-account --accept-terms [--wait]\n                            Opens an account and its first top-up. Prints a claim code,\n                            shown once. --wait saves the key here once the money lands.\n  claim <code> [--wait]     Exchange a paid account's claim code for its key, saved here\n\n  $10 to $10,000 a top-up; $500 in an account's first week. By card:\n  https://withruntime.com/account/billing\n";
+export declare const BILLING_HELP = "runtime billing <command>\n\n  topup <usd> [--wait]      Buy credit with stablecoins (USDC on Base, Solana or Tempo).\n                            Prints an address per network and the exact amount to send.\n                            Send exactly that, from any wallet, before the time shown.\n                            --wait keeps checking until the credit lands.\n  status <id> [--wait]      Whether a top-up's payment has arrived\n\n  auto-top-up               Show auto top-up: the card is charged when credit runs low\n  auto-top-up on [--below <usd>] [--amount <usd>] [--monthly <usd>]\n                            Charge <amount> plus tax when credit falls below <below>,\n                            at most <monthly> a month: $10, $20 and $500 unless given,\n                            or as last set. At least $10, $20 and $100. 5% more as\n                            credit each time, and 200 sandboxes at once while on.\n                            A person saves the card at\n                            https://withruntime.com/account/billing\n  auto-top-up off           Turn it off. Running sandboxes are never stopped.\n\n  No account yet? An agent can open one with a wallet alone:\n  topup <usd> --new-account --accept-terms [--wait]\n                            Opens an account and its first top-up. Prints a claim code,\n                            shown once. --wait saves the key here once the money lands.\n  claim <code> [--wait]     Exchange a paid account's claim code for its key, saved here\n  claim <code> --new-key    Lost the key? Replace it with the claim code. The new key is\n                            saved here; every other key stops working.\n\n  $10 to $10,000 a top-up; $500 in an account's first week. By card:\n  https://withruntime.com/account/billing\n";
 /** Wallet-account commands need no key, and the claim saves the one they get. */
 export type WalletDeps = {
     open: typeof openWalletAccount;
     claim: typeof claimWalletAccount;
+    /** Replaces a lost key with the claim code. */
+    rekey: typeof rekeyWalletAccount;
     /** Saves a claimed key as this machine's connection, as `login --with-key` does. */
     save: (key: string, orgId: string) => Promise<void>;
 };

package/dist/billing-cli.js

@@ -23,6 +23,8 @@ export const BILLING_HELP = `runtime billing <command>
                             Opens an account and its first top-up. Prints a claim code,
                             shown once. --wait saves the key here once the money lands.
   claim <code> [--wait]     Exchange a paid account's claim code for its key, saved here
+  claim <code> --new-key    Lost the key? Replace it with the claim code. The new key is
+                            saved here; every other key stops working.
 
   $10 to $10,000 a top-up; $500 in an account's first week. By card:
   https://withruntime.com/account/billing
@@ -53,7 +55,15 @@ function describe(topup) {
     lines.push("", ...(topup.payBy ? [`Send before ${topup.payBy}.`] : []), "A different amount, token or network cannot be matched or returned automatically.", `The credit lands a few minutes after the transfer: \`${me} billing status ${topup.purchaseId}\`.`);
     return lines.join("\n");
 }
-const FLAGS = new Set(["wait", "new-account", "accept-terms", "below", "amount", "monthly"]);
+const FLAGS = new Set([
+    "wait",
+    "new-account",
+    "accept-terms",
+    "below",
+    "amount",
+    "monthly",
+    "new-key",
+]);
 export async function billingCommand(argv, args, out, client, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), wallet) {
     const [verb, value] = args.positional;
     const has = (name) => args.flags.get(name)?.at(-1) === "true";
@@ -68,6 +78,11 @@ export async function billingCommand(argv, args, out, client, sleep = (ms) => ne
     if ((verb === "topup" && has("new-account")) || verb === "claim") {
         if (!wallet)
             throw usage("Wallet accounts are not available here.");
+        if (has("new-key")) {
+            if (verb !== "claim")
+                throw usage("--new-key is for `billing claim <code> --new-key`.");
+            return rekeyCommand(value, out, wallet);
+        }
         return walletCommand(verb, value, has("accept-terms"), wait, out, sleep, wallet);
     }
     if (verb === "auto-top-up")
@@ -177,6 +192,17 @@ function dollarsOf(value) {
         throw usage("Say how many dollars of credit to buy, such as `billing topup 20`.");
     return usd;
 }
+/** `claim <code> --new-key`: the key was lost; the claim code makes a new one. */
+async function rekeyCommand(code, out, wallet) {
+    if (!code)
+        throw usage("Give the claim code.");
+    const replaced = await wallet.rekey(code);
+    await wallet.save(replaced.apiKey, replaced.orgId);
+    out.write(out.json
+        ? JSON.stringify({ status: "replaced", orgId: replaced.orgId, connected: true })
+        : "Replaced. This machine is connected with the new key, saved and not shown. Every other key of this account no longer works.");
+    return 0;
+}
 /** `topup <usd> --new-account` and `claim <code>`: an account with no key. */
 async function walletCommand(verb, value, acceptTerms, wait, out, sleep, wallet) {
     const me = named("runtime");

package/dist/cli.js

@@ -124,12 +124,12 @@ const SANDBOX_HELP = `runtime sandboxes <command>
 
   Every <id> below can also be the sandbox's name.
 
-  run [--keep] [create options] -- <command>                  A fresh sandbox runs one command, then is deleted
+  run [--keep] [--root] [create options] -- <command>         A fresh sandbox runs one command, then is deleted
   ssh <id|name> [-- <command...>] | ssh config [--install]    Log in over SSH, also from VS Code and JetBrains
   code <id|name> [--editor vscode|cursor|windsurf] [--path /workspace] [--print]
                                                               Open it in your editor over SSH, in one step
   port-forward <id|name> <port|local:remote>...               Forward local ports to ports in it
-  create [--name n] [--label k=v]... [--env K=V]... [--vcpu 2] [--memory 4096] [--disk 4096]
+  create [--name n] [--label k=v]... [--env K[=V]]... [--vcpu 2] [--memory 4096] [--disk 4096]
          [--cpu shared|reserved] [--cpu-floor <thousandths>] [--max-cost <usd>] [--max-total-cost <usd>]
          [--timeout <60-86400>] [--on-timeout pause|stop|delete] [--no-wait]
          [--no-internet] [--allow <host>]... [--deny <host>]... [--connect <host:port>]...
@@ -139,15 +139,16 @@ const SANDBOX_HELP = `runtime sandboxes <command>
                                                               Create one; prints its id
   ls [--all] [--label k=v]... [--state running]               List (live ones unless --all)
   get <id>                                                    One sandbox, in full
-  exec <id> [--cwd /workspace] [--env K=V]... [--timeout <s>] -- <command...>
-                                              Run and stream output; exits with its code
-  spawn <id> [--pty] -- <command...>          Start in the background; prints a process id
+  exec <id> [--cwd /workspace] [--env K[=V]]... [--timeout <s>] [--root] -- <command...>
+                                              Run and stream output; exits with its code.
+                                              --root runs it as root: no sudo needed
+  spawn <id> [--pty] [--root] -- <command...> Start in the background; prints a process id
   ps <id>                                     Running and recent processes
   logs <id> <processId> [-f] [--raw]          A process's output so far; -f follows it to the end;
                                               on a terminal control characters show as \\uXXXX
                                               unless --raw
   kill <id> <processId> [--signal SIGTERM]
-  shell <id> [--command "bash -l"]            An interactive terminal
+  shell <id> [--command "bash -l"] [--root]   An interactive terminal
   cp <src> <dst>                              Copy files or directories; name a sandbox
                                               path as <id>:/path, e.g. cp ./app sbx:/workspace/app
   cat <id> <path>                             Print a file
@@ -166,10 +167,12 @@ const SANDBOX_HELP = `runtime sandboxes <command>
                                               --disk only grows it; programs stop (snapshot it first
                                               to keep memory)
   extend <id> <seconds>                       Move a time limit on (one with none needs nothing)
-  update <id> [--name n] [--label k=v]... [--env K=V]... [--unset-env K]... [--idle-pause <seconds>] [--auto-wake on|off]
+  update <id> [--name n] [--label k=v]... [--env K[=V]]... [--unset-env K]... [--idle-pause <seconds>] [--auto-wake on|off]
               [--persistent on|off] [--max-total-cost <usd>|none]
               [--timeout <60-86400 from now>|0] [--on-timeout pause|stop|delete]
-                                              Change its settings; persistent keeps it running until stopped
+                                              Change its settings; persistent keeps it running until stopped;
+                                              --env K alone sends K's value from your own environment,
+                                              so it is in no command line or shell history
   snapshot <id> [--name n] [--retention days|credit] Keep its whole machine; prints the snapshot id
   mount <id> <s3|r2|gcs>://<bucket>[/prefix] <path> [--secret NAME] [--region r]
         [--endpoint https://...] [--account-id id] [--read-only]
@@ -333,6 +336,20 @@ const pairs = (args, name) => Object.fromEntries((args.flags.get(name) ?? []).ma
         throw usage(`--${name} takes KEY=VALUE.`);
     return [pair.slice(0, at), pair.slice(at + 1)];
 }));
+/** --env KEY=VALUE, or --env KEY alone to take KEY's value from the CLI's own
+ * environment, as docker run -e does: the value stays out of the process's
+ * arguments and the shell's history. */
+const envPairs = (args, from) => Object.fromEntries((args.flags.get("env") ?? []).map((pair) => {
+    const at = pair.indexOf("=");
+    if (at > 0)
+        return [pair.slice(0, at), pair.slice(at + 1)];
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(pair))
+        throw usage(`--env takes KEY=VALUE, or KEY alone to send KEY's value from your environment.`);
+    const value = from[pair];
+    if (value === undefined)
+        throw usage(`--env ${pair} sends ${pair} from your environment, and it is not set there.`);
+    return [pair, value];
+}));
 /** What the commands in cli-extras.ts use of this file. */
 const kit = {
     parse: (argv, booleans, values) => parse(argv, booleans, values),
@@ -648,13 +665,13 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
         return 0;
     }
     if (command === "run") {
-        const args = parse(rest, [...CREATE_FLAGS, "keep"], [...CREATE_VALUES, "cwd", "env"], `${me} sandboxes run -- python3 < invoice.py`);
+        const args = parse(rest, [...CREATE_FLAGS, "keep", "root"], [...CREATE_VALUES, "cwd", "env"], `${me} sandboxes run -- python3 < invoice.py`);
         const commandLine = args.rest ?? args.positional;
         if (!commandLine.length)
             throw usage(`Give the command after --: ${me} sandboxes run -- python3 < invoice.py`);
         const runtime = await client(env);
         const timeout = integer(args, "timeout");
-        const { timeoutSeconds: _lease, ...input } = createInput(args);
+        const { timeoutSeconds: _lease, ...input } = createInput(args, env);
         const onCapacityWait = waiting(out);
         const sbx = await withVolumeRelease((options) => runtime.sandboxes.create(input, { ...options, onCapacityWait }), out);
         let cleanup;
@@ -685,7 +702,7 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
             process.once("SIGINT", interrupted);
         let code = 1;
         try {
-            code = await execute(sbx, commandLine, args, out, timeout, has(args, "keep"));
+            code = await execute(sbx, commandLine, args, out, timeout, env, has(args, "keep"));
         }
         finally {
             try {
@@ -820,6 +837,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
                 ? [
@@ -828,6 +846,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")
@@ -912,8 +932,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 });
@@ -922,6 +942,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({
@@ -1339,6 +1363,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 ? "-" : "";
@@ -1655,7 +1687,7 @@ async function sandbox(argv, env, out) {
     switch (verb) {
         case "create": {
             const args = parse(rest, CREATE_FLAGS, CREATE_VALUES);
-            const input = createInput(args);
+            const input = createInput(args, env);
             const onCapacityWait = waiting(out);
             const sbx = await withVolumeRelease((options) => runtime.sandboxes.create(input, { ...options, onCapacityWait }), out);
             print(sbx.id, sbx.info);
@@ -1883,14 +1915,14 @@ async function sandbox(argv, env, out) {
             const cost = flag(args, "max-total-cost");
             if (cost !== undefined && cost !== "none" && !/^\d+(\.\d{1,6})?$/.test(cost))
                 throw usage("--max-total-cost takes dollars, such as 25 or 2.50, or none.");
-            const env = {
-                ...(args.flags.has("env") ? pairs(args, "env") : {}),
+            const variables = {
+                ...(args.flags.has("env") ? envPairs(args, env) : {}),
                 ...Object.fromEntries((args.flags.get("unset-env") ?? []).map((name) => [name, null])),
             };
             const settings = {
                 ...(flag(args, "name") ? { name: flag(args, "name") } : {}),
                 ...(args.flags.has("label") ? { labels: pairs(args, "label") } : {}),
-                ...(Object.keys(env).length ? { env } : {}),
+                ...(Object.keys(variables).length ? { env: variables } : {}),
                 ...(integer(args, "idle-pause") !== undefined
                     ? { idlePauseSeconds: integer(args, "idle-pause") }
                     : {}),
@@ -1922,23 +1954,24 @@ async function sandbox(argv, env, out) {
             return 0;
         }
         case "exec": {
-            const args = parse(rest, [], ["cwd", "env", "timeout"], `${me} sandboxes exec <id> -- ls -la`);
+            const args = parse(rest, ["root"], ["cwd", "env", "timeout"], `${me} sandboxes exec <id> -- ls -la`);
             const command = args.rest ?? args.positional.slice(1);
             if (!command.length)
                 throw usage("Give the command after --: runtime sandboxes exec <id> -- ls -la");
             const sbx = await use(args.positional[0]);
-            return execute(sbx, command, args, out, integer(args, "timeout"));
+            return execute(sbx, command, args, out, integer(args, "timeout"), env);
         }
         case "spawn": {
-            const args = parse(rest, ["pty"], ["cwd", "env"], `${me} sandboxes spawn <id> -- npm run dev`);
+            const args = parse(rest, ["pty", "root"], ["cwd", "env"], `${me} sandboxes spawn <id> -- npm run dev`);
             const command = args.rest ?? [];
             if (!command.length)
                 throw usage("Give the command after --: runtime sandboxes spawn <id> -- npm run dev");
             const sbx = await use(args.positional[0]);
             const proc = await sbx.spawn(command.length === 1 ? command[0] : command, {
                 ...(has(args, "pty") ? { pty: { cols: 120, rows: 40 } } : {}),
+                ...(has(args, "root") ? { user: "root" } : {}),
                 ...(flag(args, "cwd") ? { cwd: flag(args, "cwd") } : {}),
-                ...(args.flags.has("env") ? { env: pairs(args, "env") } : {}),
+                ...(args.flags.has("env") ? { env: envPairs(args, env) } : {}),
             });
             print(proc.id, proc.info);
             return 0;
@@ -1948,12 +1981,13 @@ async function sandbox(argv, env, out) {
             const list = await sbx.processes.list();
             print(list.length
                 ? table([
-                    ["PROCESS", "STATE", "EXIT", "COMMAND"],
+                    ["PROCESS", "STATE", "EXIT", "USER", "COMMAND"],
                     // The command line is the guest's report: escaped, as a log is.
                     ...list.map((p) => [
                         terminalSafe(String(p.id)),
                         terminalSafe(String(p.state)),
                         `${typeof p.exitCode === "number" ? p.exitCode : "-"}${p.outOfMemory ? " (out of memory)" : ""}`,
+                        p.user === "root" ? "root" : "sandbox",
                         terminalSafe(String(p.command ?? "")),
                     ]),
                 ])
@@ -2021,9 +2055,9 @@ async function sandbox(argv, env, out) {
             return 0;
         }
         case "shell": {
-            const args = parse(rest, [], ["command"]);
+            const args = parse(rest, ["root"], ["command"]);
             const sbx = await use(args.positional[0]);
-            return shell(sbx, flag(args, "command"));
+            return shell(sbx, flag(args, "command"), has(args, "root"));
         }
         case "cat": {
             const sbx = await use(rest[0]);
@@ -2614,12 +2648,20 @@ const KEYS_HELP = `runtime keys <command>
       stdout, and lasts until revoked. --json prints it as JSON, still alone on
       stdout. --account-wide makes a key that sees and uses every sandbox and
       other resource in the account; without it, a key sees only what it makes.
+  create --sandbox <id,...> --actions <action,...> [--name <name>] [--daily-limit <usd>]
+      A key limited to those sandboxes (up to 20, by id) and those actions on
+      them, made by the saved key: get reads them; create starts, wakes and
+      restarts them, and needs --daily-limit when the making key has one; stop
+      stops and pauses them; exec runs commands; read_file and write_file reach
+      their files. It is served nothing else: no list, no other sandbox, no
+      account route, no MCP.
   ls                      This key and the keys it made, with what each spent today
   usage <keyId>           What one of them has spent and holds
   revoke <keyId>          Revoke one: a worker's key when the worker is done
 
   runtime keys create --name worker-1 --daily-limit 5
   runtime keys create --name ci --daily-limit 25 --browser | gh secret set RUNTIME_API_KEY
+  runtime keys create --name watcher --sandbox sbx_id --actions get,create --daily-limit 2
 
 Making, listing and revoking keys with a key needs one an owner or admin made.
 Every key is also at https://withruntime.com/account/keys.
@@ -2788,8 +2830,16 @@ async function keys(argv, env, out) {
     }
     if (verb !== "create")
         throw unknown("keys command", verb, ["create", "ls", "usage", "revoke"]);
-    const args = parse(rest, ["read-only", "account-wide", "browser"], ["name", "daily-limit"]);
-    const known = new Set(["name", "read-only", "daily-limit", "account-wide", "browser"]);
+    const args = parse(rest, ["read-only", "account-wide", "browser"], ["name", "daily-limit", "sandbox", "actions"]);
+    const known = new Set([
+        "name",
+        "read-only",
+        "daily-limit",
+        "account-wide",
+        "browser",
+        "sandbox",
+        "actions",
+    ]);
     for (const name of args.flags.keys())
         if (!known.has(name))
             throw usage(`Unknown option --${name}.`);
@@ -2797,6 +2847,8 @@ async function keys(argv, env, out) {
         throw usage(`Unexpected ${args.positional[0] ?? "--"}.`);
     const readOnly = has(args, "read-only");
     const limit = flag(args, "daily-limit");
+    if (flag(args, "sandbox") !== undefined || flag(args, "actions") !== undefined)
+        return limitedKey(args, env, out, limit === undefined ? null : limit);
     if (readOnly && limit !== undefined)
         throw usage("A read-only key cannot spend, so it takes no --daily-limit.");
     if (readOnly && has(args, "account-wide"))
@@ -2846,6 +2898,32 @@ async function keys(argv, env, out) {
     await confirm?.();
     return 0;
 }
+/** `runtime keys create --sandbox ... --actions ...`: a key limited to
+ * sandboxes, made by the saved key (never in the browser: the keys page
+ * makes none). */
+async function limitedKey(args, env, out, limit) {
+    for (const refused of ["read-only", "account-wide", "browser"])
+        if (has(args, refused))
+            throw usage(`A key limited to sandboxes reaches only them and is made by this machine's key, so it takes no --${refused}.`);
+    const list = (name) => (flag(args, name) ?? "")
+        .split(",")
+        .map((each) => each.trim())
+        .filter(Boolean);
+    const sandboxes = list("sandbox");
+    const actions = list("actions");
+    if (!sandboxes.length || !actions.length)
+        throw usage(`Usage: ${named("runtime keys create --sandbox <id,...> --actions <get,create,stop,exec,read_file,write_file> [--daily-limit <usd>]")}`);
+    const { dailyLimitMicros } = await import("./keys.js");
+    const made = await (await client(env)).keys.create({
+        name: flag(args, "name") ?? "Sandbox key",
+        sandboxes,
+        actions: actions,
+        dailyLimitMicros: limit === null ? null : dailyLimitMicros(limit),
+    });
+    out.write(out.json ? JSON.stringify(made) : made.key);
+    out.error(`Created key "${made.name}", limited to ${made.sandboxes?.length === 1 ? "sandbox" : "sandboxes"} ${(made.sandboxes ?? []).join(", ")} for ${(made.actions ?? []).join(", ")}${made.dailyLimitMicros === null ? "" : `, daily limit ${usdOf(made.dailyLimitMicros)}`}, made by this machine's key. Store it now: it is not shown again.\nIt calls those sandboxes by id and nothing else; revoke it with ${named("runtime keys revoke")} ${made.keyId}.`);
+    return 0;
+}
 const SNAPSHOT_HELP = `runtime snapshots <command>
 
   ls [--sandbox <id>] [--name n]              Your snapshots
@@ -3743,7 +3821,7 @@ function usdMicros(args, name) {
     return Number(micros);
 }
 /** A create body from the command line's flags. */
-function createInput(args) {
+function createInput(args, env) {
     for (const name of ["image", "snapshot", "volume", "name", "region", "connect"])
         if (args.flags.get(name)?.some((value) => !value.trim()))
             throw usage(`--${name} needs a non-empty value.`);
@@ -3774,7 +3852,7 @@ function createInput(args) {
             : {}),
         ...(flag(args, "name") ? { name: flag(args, "name") } : {}),
         ...(args.flags.has("label") ? { labels: pairs(args, "label") } : {}),
-        ...(args.flags.has("env") ? { env: pairs(args, "env") } : {}),
+        ...(args.flags.has("env") ? { env: envPairs(args, env) } : {}),
         ...(integer(args, "vcpu") !== undefined ? { vcpu: integer(args, "vcpu") } : {}),
         ...(integer(args, "memory") !== undefined ? { memoryMiB: integer(args, "memory") } : {}),
         ...(integer(args, "disk") !== undefined ? { diskMiB: integer(args, "disk") } : {}),
@@ -3811,7 +3889,7 @@ function createInput(args) {
 }
 /** Runs a command in a sandbox, streaming its output, and answers its exit code
  * (124 on a timeout), so a script's `set -e` behaves. */
-async function execute(sbx, command, args, out, timeout, 
+async function execute(sbx, command, args, out, timeout, env, 
 /** `run` stops its whole sandbox on Ctrl-C, so it handles the signal itself. */
 ownInterrupt = true) {
     const target = command.length === 1 ? command[0] : command;
@@ -3820,7 +3898,8 @@ ownInterrupt = true) {
     const options = {
         ...(stdin ? { stdin } : {}),
         ...(flag(args, "cwd") ? { cwd: flag(args, "cwd") } : {}),
-        ...(args.flags.has("env") ? { env: pairs(args, "env") } : {}),
+        ...(args.flags.has("env") ? { env: envPairs(args, env) } : {}),
+        ...(has(args, "root") ? { user: "root" } : {}),
         ...(timeout !== undefined ? { timeoutMs: timeout * 1000 } : {}),
     };
     // Ctrl-C stops the command in the sandbox too, and says so; without this
@@ -3869,12 +3948,13 @@ ownInterrupt = true) {
     const code = result.timedOut ? 124 : Math.min(255, exit < 0 ? 128 - exit : exit);
     return lost && code === 0 ? 1 : code;
 }
-async function shell(sbx, command) {
+async function shell(sbx, command, root = false) {
     const stdin = process.stdin;
     const size = () => ({ cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 });
     const terminal = await sbx.terminal({
         ...size(),
         ...(command ? { command } : {}),
+        ...(root ? { user: "root" } : {}),
         onData: (data) => process.stdout.write(data),
     });
     if (stdin.isTTY)

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/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, MadeKey, ListedKey, KeyUsage } from "./products/api-keys.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/api-keys.d.ts

@@ -1,5 +1,11 @@
 import type { RequestOptions, Transport } from "../transport.js";
-export type NewKey = {
+/** What a key limited to sandboxes may do to them. get reads them; create
+ *  starts, wakes and restarts them (never makes one), and is the one that
+ *  spends; stop stops and pauses them; exec runs commands and processes;
+ *  read_file and write_file reach their files. */
+export type LimitedKeyAction = "get" | "create" | "stop" | "exec" | "read_file" | "write_file";
+export type NewKey = FullOrReadKey | LimitedKey;
+type FullOrReadKey = {
     /** The key's name, and its agent's: up to 80 characters. */
     name: string;
     /** full (the default): every action. read: every read, nothing else. */
@@ -11,6 +17,19 @@ export type NewKey = {
      *  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;
+    sandboxes?: never;
+    actions?: never;
+};
+/** A key limited to these sandboxes and these actions on them. */
+export type LimitedKey = {
+    name: string;
+    /** 1 to 20 sandbox ids this key acts on, outside every compartment. */
+    sandboxes: string[];
+    actions: LimitedKeyAction[];
+    /** Only with create, the one action that spends. */
+    dailyLimitMicros?: number | null;
+    access?: never;
+    reach?: never;
 };
 export type MadeKey = {
     /** The key itself. Shown once: store it now. */
@@ -19,9 +38,15 @@ export type MadeKey = {
     agentId: string;
     orgId: string;
     name: string;
-    access: "full" | "read";
-    reach: "agent" | "account";
+    /** selected: a key limited to sandboxes. */
+    access: "full" | "read" | "selected";
+    /** sandboxes: only the sandboxes it names. */
+    reach: "agent" | "account" | "sandboxes";
     dailyLimitMicros: number | null;
+    /** The sandboxes it is limited to, or null. */
+    sandboxes: string[] | null;
+    /** Its actions, when it has named ones, or null. */
+    actions: string[] | null;
     /** The making key's expiry, or null for until revoked. */
     expires: string | null;
     /** The id of the key that made it. */
@@ -32,8 +57,10 @@ export type ListedKey = {
     agentId: string;
     name: string;
     access: "full" | "read" | "selected";
-    reach: "agent" | "account";
+    reach: "agent" | "account" | "sandboxes";
     dailyLimitMicros: number | null;
+    sandboxes: string[] | null;
+    actions: string[] | 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. */
@@ -71,3 +98,4 @@ export declare function keys(t: Transport): {
     /** What one key spent: itself, or a key it made. */
     usage: (keyId: string, options?: RequestOptions) => Promise<KeyUsage>;
 };
+export {};

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;
@@ -90,6 +92,14 @@ export type DeployApp = ({
     image?: never;
 }) & {
     env?: Record<string, string>;
+    /** 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).
+     * 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;
     /** Return live, failed or superseded, including its URL/version or failure details. */
@@ -100,6 +110,10 @@ export type AppVersion = {
     live: boolean;
     previous: boolean;
     saved: boolean;
+    /** Its deploy's id, for GET /v1/apps/{id}/deploys/{deploy}. */
+    deploy: string;
+    /** The build it was deployed from, or null for an image. */
+    build: string | null;
 };
 export type AppCopy = {
     id: 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/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/sandbox.d.ts

@@ -73,6 +73,8 @@ export declare class Sandbox extends Machine<SandboxInfo, SandboxSettings, Delet
         rows?: number;
         command?: string;
         cwd?: string;
+        /** "root" opens the shell (or runs `command`) as root. */
+        user?: "sandbox" | "root";
         /** Attach to a process started with a pty instead of a new shell. */
         processId?: string;
         onData?: (data: Uint8Array) => void;

package/dist/sandbox.js

@@ -79,6 +79,7 @@ function commandBody(command, options) {
         ...(typeof command === "string" ? { command } : { argv: [...command] }),
         ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
         ...(options.env === undefined ? {} : { env: options.env }),
+        ...(options.user === undefined ? {} : { user: options.user }),
         ...(options.stdin === undefined
             ? {}
             : typeof options.stdin === "string"
@@ -314,6 +315,7 @@ export class Sandbox extends Machine {
             rows: options.rows,
             command: options.command,
             cwd: options.cwd,
+            user: options.user,
             processId: options.processId,
         });
         return Terminal.open(socket, options.onData);

package/dist/transport.d.ts

@@ -1,5 +1,5 @@
 import { RuntimeError } from "./errors.js";
-export declare const VERSION = "0.16.1";
+export declare const VERSION = "0.17.2";
 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.16.1";
+export const VERSION = "0.17.2";
 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/types.d.ts

@@ -200,6 +200,10 @@ export type CommandResult = {
 };
 export type ExecOptions = {
     cwd?: string;
+    /** Who runs it: "sandbox" (the default, uid 1000, HOME=/workspace) or
+     * "root", through the sandbox's passwordless sudo with the same
+     * environment and PATH and HOME=/root: no need to prefix it with sudo. */
+    user?: "sandbox" | "root";
     /** Merged over the sandbox's environment. Put secrets here, never in the command. */
     env?: Record<string, string>;
     /** Given to standard input, then closed. */
@@ -220,6 +224,8 @@ export type ProcessInfo = {
     state: "running" | "exited" | "killed" | "timed_out" | "unknown";
     exitCode: number | null;
     command: string;
+    /** Who it runs as; absent from APIs before 17 October 2026. */
+    user?: "sandbox" | "root";
     cwd: string;
     pty: boolean;
     stdinOpen: boolean;

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.16.1",
+  "version": "0.17.2",
   "license": "Apache-2.0",
   "mcpName": "com.withruntime/runtime",
   "type": "module",