withruntime 0.9.0 → 0.11.0

package/dist/e2b/users.d.ts

@@ -0,0 +1,30 @@
+import type { FileEntry } from "../types.js";
+import type { RequestOptions } from "../transport.js";
+import type { SandboxContext, Username } from "./commands.js";
+/** The Linux user a call runs as, or undefined for the sandbox's own. Refuses
+ * a user the sandbox does not have, once per user and sandbox. */
+export declare function runAs(ctx: SandboxContext, user: Username | undefined, options: RequestOptions): Promise<string | undefined>;
+/** `bash -c script` as `user`, keeping the environment Runtime gives the
+ * command. Without a `cwd` it starts in the user's home, as E2B's does. */
+export declare function commandAs(user: string, script: string, cwdGiven: boolean): string[];
+/** An interactive login shell as `user`, for a PTY. */
+export declare function shellAs(user: string, cwdGiven: boolean): string[];
+/** E2B's file calls as another Linux user: each one a short script run with
+ * `sudo -u`, since Runtime's file API acts as the sandbox's own user. Output
+ * streams, so a read of any size comes back whole. */
+export declare class FilesAs {
+    #private;
+    private readonly ctx;
+    private readonly user;
+    private readonly options;
+    constructor(ctx: SandboxContext, user: string, options: RequestOptions);
+    read(path: string): Promise<Uint8Array>;
+    write(path: string, bytes: Uint8Array): Promise<void>;
+    list(path: string, depth: number): Promise<FileEntry[]>;
+    stat(path: string): Promise<FileEntry>;
+    exists(path: string): Promise<boolean>;
+    /** False when it was there already. */
+    makeDir(path: string): Promise<boolean>;
+    rename(from: string, to: string): Promise<void>;
+    remove(path: string): Promise<void>;
+}

package/dist/e2b/users.js

@@ -0,0 +1,185 @@
+import { FileNotFoundError, guard, InvalidArgumentError, SandboxError } from "./errors.js";
+/* E2B's `user` option, on Runtime. A sandbox's own user is `runtime`, with
+   passwordless sudo; E2B's default user is called "user". So "user" (or no
+   user) runs as the sandbox's own user, and any other name runs through
+   `sudo -u <name>`. The user must already exist: the adapter never makes one,
+   and a name the sandbox does not know is refused before anything runs. */
+const NAME = /^[a-z_][a-z0-9_.-]{0,31}$/i;
+/** Exit codes the scripts below use to say what went wrong. */
+const MISSING = 44;
+const NOT_DIRECTORY = 45;
+const IS_DIRECTORY = 46;
+const EXISTS = 47;
+/** Base64 text per exec: under the 1 MiB an exec's input may carry. */
+const WRITE_CHUNK = 786_432;
+/** Only the caller's signal: an exec's own `timeoutMs` is the command's. */
+const signalOf = (options) => (options.signal ? { signal: options.signal } : {});
+const checked = new WeakMap();
+/** The Linux user a call runs as, or undefined for the sandbox's own. Refuses
+ * a user the sandbox does not have, once per user and sandbox. */
+export async function runAs(ctx, user, options) {
+    if (user === undefined || user === "user")
+        return undefined;
+    if (typeof user !== "string" || !NAME.test(user))
+        throw new InvalidArgumentError(`"${String(user)}" is not a Linux user name.`);
+    if (user === "root")
+        return user;
+    let users = checked.get(ctx);
+    if (!users)
+        checked.set(ctx, (users = new Map()));
+    let check = users.get(user);
+    if (!check) {
+        check = (async () => {
+            const found = await guard("sandbox", () => ctx.runtime.exec(["id", "-u", "--", user], signalOf(options)));
+            if (found.exitCode !== 0)
+                throw new InvalidArgumentError(`This sandbox has no user "${user}", and Runtime never creates one for you. ` +
+                    `Make it first, as root: sandbox.commands.run("useradd -m ${user}", { user: "root" }). ` +
+                    `"user" is the sandbox's own user and "root" is root.`);
+        })();
+        users.set(user, check);
+        check.catch(() => users.delete(user));
+    }
+    await check;
+    return user;
+}
+/** `bash -c script` as `user`, keeping the environment Runtime gives the
+ * command. Without a `cwd` it starts in the user's home, as E2B's does. */
+export function commandAs(user, script, cwdGiven) {
+    return [
+        "sudo",
+        "-n",
+        "-E",
+        "-H",
+        "-u",
+        user,
+        "--",
+        "/bin/bash",
+        "-c",
+        cwdGiven ? script : `cd ~ 2>/dev/null\n${script}`,
+    ];
+}
+/** An interactive login shell as `user`, for a PTY. */
+export function shellAs(user, cwdGiven) {
+    return commandAs(user, "exec /bin/bash -i -l", cwdGiven);
+}
+/** One `sh -c` script as `user`, with its arguments passed apart, never
+ * pasted into the script. */
+function script(user, text, ...args) {
+    return ["sudo", "-n", "-u", user, "--", "/bin/sh", "-c", text, "sh", ...args];
+}
+/** Each entry `find -printf` prints: eight fields, each ended by NUL. */
+const FIELDS = "%y\\0%s\\0%m\\0%u\\0%g\\0%T@\\0%p\\0%l\\0";
+const TYPES = { f: "file", d: "directory", l: "symlink" };
+function entries(output) {
+    const fields = output.split("\0");
+    const out = [];
+    for (let i = 0; i + 8 <= fields.length; i += 8) {
+        const [kind, size, mode, owner, group, mtime, path, link] = fields.slice(i, i + 8);
+        out.push({
+            name: path.split("/").filter(Boolean).pop() ?? path,
+            path,
+            type: TYPES[kind] ?? "other",
+            size: Number(size) || 0,
+            mode: `0${mode}`,
+            modifiedAt: new Date(Math.round(Number(mtime) * 1000)).toISOString(),
+            owner,
+            group,
+            ...(kind === "l" && link ? { symlinkTarget: link } : {}),
+        });
+    }
+    return out;
+}
+/** E2B's file calls as another Linux user: each one a short script run with
+ * `sudo -u`, since Runtime's file API acts as the sandbox's own user. Output
+ * streams, so a read of any size comes back whole. */
+export class FilesAs {
+    ctx;
+    user;
+    options;
+    constructor(ctx, user, options) {
+        this.ctx = ctx;
+        this.user = user;
+        this.options = options;
+    }
+    async #run(argv, stdin) {
+        const result = await guard("sandbox", () => this.ctx.runtime.exec(argv, {
+            ...(stdin === undefined ? {} : { stdin }),
+            // A callback makes the exec stream, so its output is never cut.
+            onStdout: () => undefined,
+            ...signalOf(this.options),
+        }));
+        if (result.stdoutTruncated)
+            throw new SandboxError("Part of the answer was lost on the way; try again.");
+        return result;
+    }
+    #fail(path, result) {
+        if (result.exitCode === MISSING)
+            throw new FileNotFoundError(`${path} does not exist.`);
+        if (result.exitCode === NOT_DIRECTORY)
+            throw new InvalidArgumentError(`${path} is not a directory.`);
+        if (result.exitCode === IS_DIRECTORY)
+            throw new InvalidArgumentError(`${path} is a directory.`);
+        throw new SandboxError(`As the user "${this.user}": ${result.stderr.trim() || `exit status ${result.exitCode}`}`);
+    }
+    async read(path) {
+        const result = await this.#run(script(this.user, `[ -e "$1" ] || exit ${MISSING}; [ -d "$1" ] && exit ${IS_DIRECTORY}; exec base64 -w 0 -- "$1"`, path));
+        if (result.exitCode !== 0)
+            this.#fail(path, result);
+        return Uint8Array.from(atob(result.stdout.trim()), (c) => c.charCodeAt(0));
+    }
+    async write(path, bytes) {
+        let text = "";
+        for (let i = 0; i < bytes.length; i += 32_768)
+            text += String.fromCharCode(...bytes.subarray(i, i + 32_768));
+        const encoded = btoa(text);
+        let offset = 0;
+        do {
+            const chunk = encoded.slice(offset, offset + WRITE_CHUNK);
+            const result = await this.#run(script(this.user, offset === 0
+                ? `mkdir -p -- "$(dirname -- "$1")" && base64 -d > "$1"`
+                : `base64 -d >> "$1"`, path), chunk);
+            if (result.exitCode !== 0)
+                this.#fail(path, result);
+            offset += WRITE_CHUNK;
+        } while (offset < encoded.length);
+    }
+    async list(path, depth) {
+        const result = await this.#run(script(this.user, `[ -e "$1" ] || exit ${MISSING}; [ -d "$1" ] || exit ${NOT_DIRECTORY}; ` +
+            `exec find "$1" -mindepth 1 -maxdepth "$2" -printf '${FIELDS}'`, path, String(depth)));
+        if (result.exitCode !== 0)
+            this.#fail(path, result);
+        return entries(result.stdout);
+    }
+    async stat(path) {
+        const result = await this.#run(script(this.user, `[ -e "$1" ] || [ -L "$1" ] || exit ${MISSING}; exec find "$1" -maxdepth 0 -printf '${FIELDS}'`, path));
+        if (result.exitCode !== 0)
+            this.#fail(path, result);
+        const [entry] = entries(result.stdout);
+        if (!entry)
+            throw new FileNotFoundError(`${path} does not exist.`);
+        return entry;
+    }
+    async exists(path) {
+        const result = await this.#run(script(this.user, `[ -e "$1" ] || [ -L "$1" ]`, path));
+        return result.exitCode === 0;
+    }
+    /** False when it was there already. */
+    async makeDir(path) {
+        const result = await this.#run(script(this.user, `[ -d "$1" ] && exit ${EXISTS}; mkdir -p -- "$1"`, path));
+        if (result.exitCode === EXISTS)
+            return false;
+        if (result.exitCode !== 0)
+            this.#fail(path, result);
+        return true;
+    }
+    async rename(from, to) {
+        const result = await this.#run(script(this.user, `[ -e "$1" ] || [ -L "$1" ] || exit ${MISSING}; mv -fT -- "$1" "$2"`, from, to));
+        if (result.exitCode !== 0)
+            this.#fail(from, result);
+    }
+    async remove(path) {
+        const result = await this.#run(script(this.user, `rm -rf -- "$1"`, path));
+        if (result.exitCode !== 0)
+            this.#fail(path, result);
+    }
+}

package/dist/file-source.d.ts

@@ -0,0 +1,16 @@
+export type StreamUploadSource = string | Blob | AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>;
+export type UploadScope = {
+    signal?: AbortSignal;
+    check(): void;
+    wait<T>(pending: Promise<T>): Promise<T>;
+};
+export type PreparedFileSource = {
+    size: number;
+    sha256: string;
+    chunkAt(offset: number, length: number): Promise<Uint8Array>;
+    close(): Promise<void>;
+};
+/** ARCHITECTURE.md section 10, Folders over HTTP: unknown-length inputs use
+ * bounded private disk staging; known files and Blobs remain repeatable inputs.
+ * Size and digest are established before the remote upload can begin. */
+export declare function prepareFileSource(input: StreamUploadSource, scope: UploadScope): Promise<PreparedFileSource>;

package/dist/file-source.js

@@ -0,0 +1,162 @@
+import { RuntimeError } from "./errors.js";
+const CHUNK = 1_048_576;
+function failure(message, code, cause) {
+    return new RuntimeError({ message, code, status: 0, ...(cause === undefined ? {} : { cause }) });
+}
+async function exact(handle, offset, length) {
+    const data = new Uint8Array(length);
+    let held = 0;
+    while (held < length) {
+        const read = await handle.read(data, held, length - held, offset + held);
+        if (read.bytesRead === 0)
+            throw failure("The local upload source changed or ended before its declared size.", "source_changed");
+        held += read.bytesRead;
+    }
+    return data;
+}
+/** ARCHITECTURE.md section 10, Folders over HTTP: unknown-length inputs use
+ * bounded private disk staging; known files and Blobs remain repeatable inputs.
+ * Size and digest are established before the remote upload can begin. */
+export async function prepareFileSource(input, scope) {
+    const fs = await import("node:fs/promises");
+    const { createHash } = await import("node:crypto");
+    const { Readable } = await import("node:stream");
+    scope.check();
+    const hash = createHash("sha256");
+    let size = 0;
+    let handle;
+    let staging;
+    let iterator;
+    // What is used of a reader, so the code compiles against Node's stream types
+    // as well as the DOM's (packages/cloud compiles this file without DOM).
+    let reader;
+    const cleanup = async () => {
+        try {
+            await handle?.close();
+        }
+        finally {
+            if (staging)
+                await fs.rm(staging, { recursive: true, force: true });
+        }
+    };
+    try {
+        if (typeof input === "string") {
+            handle = await fs.open(input, "r");
+            const info = await handle.stat();
+            if (!info.isFile() || !Number.isSafeInteger(info.size))
+                throw failure("A streamed file upload requires a regular local file.", "invalid_upload_source");
+            size = info.size;
+            for (let offset = 0; offset < size; offset += CHUNK) {
+                scope.check();
+                hash.update(await scope.wait(exact(handle, offset, Math.min(CHUNK, size - offset))));
+            }
+        }
+        else if (input instanceof Blob) {
+            // Bun's types leave out Blob.slice when the DOM library is off, as it is
+            // where packages/cloud compiles this file; every runtime has it.
+            const blob = input;
+            size = blob.size;
+            for (let offset = 0; offset < size; offset += CHUNK) {
+                scope.check();
+                hash.update(new Uint8Array(await scope.wait(blob.slice(offset, offset + CHUNK).arrayBuffer())));
+            }
+            return {
+                size,
+                sha256: hash.digest("hex"),
+                chunkAt: async (offset, length) => new Uint8Array(await blob.slice(offset, offset + length).arrayBuffer()),
+                close: async () => undefined,
+            };
+        }
+        else {
+            if (!input ||
+                (typeof input.getReader !== "function" &&
+                    typeof input[Symbol.asyncIterator] !== "function"))
+                throw failure("A streamed upload requires a byte stream or local file.", "invalid_upload_source");
+            const { tmpdir } = await import("node:os");
+            const path = await import("node:path");
+            staging = await fs.mkdtemp(path.join(tmpdir(), "runtime-upload-"));
+            await fs.chmod(staging, 0o700);
+            handle = await fs.open(path.join(staging, "source"), "wx+", 0o600);
+            const space = await fs.statfs(staging, { bigint: true });
+            const available = space.bavail * space.bsize;
+            if ("getReader" in input)
+                reader = input.getReader();
+            else
+                iterator = input[Symbol.asyncIterator]();
+            for (;;) {
+                scope.check();
+                const next = await scope.wait(reader ? reader.read() : iterator.next());
+                if (next.done)
+                    break;
+                if (!(next.value instanceof Uint8Array))
+                    throw failure("A streamed upload must produce byte chunks.", "invalid_upload_source");
+                for (let offset = 0; offset < next.value.length; offset += CHUNK) {
+                    scope.check();
+                    const part = next.value.subarray(offset, offset + CHUNK);
+                    if (!Number.isSafeInteger(size + part.length))
+                        throw failure("The streamed upload exceeds the native file size range.", "upload_too_large");
+                    if (BigInt(size + part.length) > available)
+                        throw failure("There is not enough local temporary disk space to stage the streamed upload.", "local_disk_full");
+                    let written = 0;
+                    while (written < part.length) {
+                        scope.check();
+                        const result = await handle.write(part, written, part.length - written, size + written);
+                        if (result.bytesWritten === 0)
+                            throw failure("The local temporary file accepted no upload bytes.", "local_disk_full");
+                        written += result.bytesWritten;
+                    }
+                    size += part.length;
+                    hash.update(part);
+                }
+            }
+        }
+        scope.check();
+        const owned = handle;
+        if (!owned)
+            throw failure("The local upload file did not open.", "invalid_upload_source");
+        return {
+            size,
+            sha256: hash.digest("hex"),
+            chunkAt: (offset, length) => exact(owned, offset, length),
+            close: cleanup,
+        };
+    }
+    catch (error) {
+        // Calling return/cancel can itself throw synchronously. Cleanup still owns
+        // the file and directory, and must preserve the original source failure.
+        let timer;
+        try {
+            // Node's pending next() must settle before iterator.return() can finish.
+            // Web readers own cancellation directly; arbitrary iterators may not.
+            if (input instanceof Readable)
+                input.destroy();
+            const closing = reader ? reader.cancel(scope.signal?.reason) : iterator?.return?.();
+            if (closing)
+                await Promise.race([
+                    closing,
+                    new Promise((resolve) => {
+                        timer = setTimeout(resolve, 1000);
+                    }),
+                ]);
+        }
+        catch {
+            /* Preserve the caller's original failure. */
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            await cleanup().catch(() => undefined);
+        }
+        if (error?.code === "ENOSPC")
+            throw failure("There is not enough local temporary disk space to stage the streamed upload.", "local_disk_full", error);
+        throw error;
+    }
+    finally {
+        try {
+            reader?.releaseLock();
+        }
+        catch {
+            /* Cancellation may leave a pending caller-owned read. */
+        }
+    }
+}

package/dist/freestyle/index.d.ts

@@ -38,22 +38,29 @@ export declare class VmsNamespace {
             id: string;
             sourceVmId: string;
             slug: string | null;
+            displayName: string | null;
             public: boolean;
             createdAt: string;
             updatedAt: string;
             ttlSeconds: number;
         }>;
         delete: (id: string) => Promise<void>;
-        list: () => Promise<{
+        list: (options?: {
+            sourceVmId?: string;
+            limit?: number;
+            offset?: number;
+        }) => Promise<{
             snapshots: {
                 id: string;
                 sourceVmId: string;
                 slug: string | null;
+                displayName: string | null;
                 public: boolean;
                 createdAt: string;
                 updatedAt: string;
                 ttlSeconds: number;
             }[];
+            totalCount: number;
         }>;
     };
     constructor(runtime: Runtime);
@@ -292,6 +299,7 @@ export declare class Vm {
             id: string;
             sourceVmId: string;
             slug: string | null;
+            displayName: string | null;
             public: boolean;
             createdAt: string;
             updatedAt: string;

package/dist/freestyle/index.js

@@ -1,6 +1,11 @@
 import { all, client, CompatibilityError, create, destroy, execOptions, lookup, only, ready, } from "../compat/core.js";
 import { GuestFiles } from "../compat/files.js";
 export { CompatibilityError };
+function validateMetadata(metadata) {
+    for (const key of ["compat.provider", "fs.displayName"])
+        if (metadata !== undefined && Object.prototype.hasOwnProperty.call(metadata, key))
+            throw new CompatibilityError("Freestyle", `metadata key ${key} reserved by this adapter`);
+}
 const data = (s) => ({
     id: s.id,
     state: s.state,
@@ -18,6 +23,7 @@ const snapshotData = (s) => ({
     id: s.id,
     sourceVmId: s.sourceSandboxId,
     slug: s.name,
+    displayName: s.labels?.["fs.displayName"] ?? null,
     public: false,
     createdAt: s.createdAt,
     updatedAt: s.createdAt,
@@ -37,9 +43,32 @@ export class VmsNamespace {
         this.snapshots = {
             get: async (id) => snapshotData(await this.resolveSnapshot(id)),
             delete: async (id) => runtime.snapshots.delete((await this.resolveSnapshot(id)).id),
-            list: async () => ({
-                snapshots: (await (await runtime.snapshots.list()).toArray()).map(snapshotData),
-            }),
+            list: async (options = {}) => {
+                only("Freestyle snapshot list", options, ["sourceVmId", "limit", "offset"]);
+                if (options.sourceVmId !== undefined && typeof options.sourceVmId !== "string")
+                    throw new TypeError("sourceVmId must be a string");
+                if (options.limit !== undefined &&
+                    (!Number.isSafeInteger(options.limit) || options.limit <= 0))
+                    throw new TypeError("limit must be a positive safe integer");
+                if (options.offset !== undefined &&
+                    (!Number.isSafeInteger(options.offset) || options.offset < 0))
+                    throw new TypeError("offset must be a nonnegative safe integer");
+                const offset = options.offset ?? 0;
+                const snapshots = [];
+                let totalCount = 0;
+                // Count the filtered catalog across every native page without retaining
+                // snapshots outside the requested page or Page.toArray's default cap.
+                const page = await runtime.snapshots.list(options.sourceVmId === undefined ? {} : { sandboxId: options.sourceVmId });
+                for await (const snapshot of page) {
+                    if (options.sourceVmId !== undefined && snapshot.sourceSandboxId !== options.sourceVmId)
+                        continue;
+                    if (totalCount >= offset &&
+                        (options.limit === undefined || snapshots.length < options.limit))
+                        snapshots.push(snapshotData(snapshot));
+                    totalCount++;
+                }
+                return { snapshots, totalCount };
+            },
         };
     }
     async resolveSnapshot(id) {
@@ -59,6 +88,7 @@ export class VmsNamespace {
             "metadata",
             "firewall",
         ]);
+        validateMetadata(options.metadata);
         if (!options.firewall || !Array.isArray(options.firewall.rules))
             throw new TypeError("firewall.rules is required");
         only("Freestyle firewall", options.firewall, ["rules"]);
@@ -266,6 +296,7 @@ export class Vm {
     }
     async update(options) {
         only("Freestyle update", options, ["slug", "displayName", "idleTimeoutSeconds", "metadata"]);
+        validateMetadata(options.metadata);
         const s = await lookup(this.runtime, this.id);
         await s.update({
             name: options.slug,
@@ -298,8 +329,10 @@ export class Vm {
     async snapshot(options = {}) {
         only("Freestyle snapshot", options, ["slug", "displayName", "ttlSeconds"]);
         if (options.ttlSeconds !== undefined &&
-            (options.ttlSeconds <= 0 || options.ttlSeconds % 86400 !== 0))
-            throw new CompatibilityError("Freestyle", "snapshot retention other than whole positive days");
+            (options.ttlSeconds <= 0 ||
+                options.ttlSeconds > 365 * 86400 ||
+                options.ttlSeconds % 86400 !== 0))
+            throw new CompatibilityError("Freestyle", "snapshot retention outside 1 to 365 whole days");
         const s = await (await lookup(this.runtime, this.id)).snapshot({
             name: options.slug,
             labels: options.displayName ? { "fs.displayName": options.displayName } : undefined,

package/dist/index.d.ts

@@ -15,15 +15,17 @@ export { Tunnel, TunnelStream, type PortForward } from "./tunnel.js";
 export { Page } from "./page.js";
 export type { KeyLimits } from "./products/limits.js";
 export type { AuditEvent, AuditPage } from "./products/audit.js";
+export type { UsageExportQuery, UsageExportRow, UsageExportPage, } from "./products/observability.js";
 export type { JobSecret, Secret, SecretRule, SecretUse, SetSecret } from "./products/secrets.js";
 export { SecretPartlyStoredError } from "./products/secrets.js";
 export type { McpCatalogEntry, McpGateway, McpServerRequest } from "./products/mcp.js";
 export type { FileEvent, FileEventType, WatchHandle, WatchNotice, WatchOptions, } from "./products/watch.js";
 export type { Mount, MountBucket } from "./products/mounts.js";
 export type { TailscaleJoin, TailscaleJoined, TailscaleNode, TailscaleStatus, } from "./products/tailscale.js";
-export type { Volume, VolumeBackup, CreateVolume } from "./products/volumes.js";
+export type { Volume, VolumeBackup, CreateVolume, VolumeAttachment } from "./products/volumes.js";
 export type { CreateJob, Job, JobCompute, JobDefinition, JobLogs, JobRun, JobRunState, JobSchedule, } from "./products/jobs.js";
 export type { CheckedDomain, DnsRecord, Domain, EgressAddress, TcpPort, Tunnel as PrivateTunnel, TunnelPeer, TunnelPeerCreated, SetUpstreamProxy, UpstreamProxy, } from "./products/network-products.js";
+export type { PrivateNetwork } from "./products/private-network.js";
 export { verifyWebhook, WebhookVerificationError, type MetricPoint, type MetricRange, type OtelExport, type RuntimeEvent, type SandboxMetrics, type Webhook, type WebhookDelivery, type WebhookEventType, } from "./products/observability.js";
 export { Snapshots, type Snapshot, type SnapshotOptions } from "./snapshots.js";
 export { Transport, VERSION, apiOrigin, type RequestOptions, type Call } from "./transport.js";

package/dist/login.js

@@ -4,7 +4,7 @@ import { hostname } from "node:os";
 import { promisify } from "node:util";
 import { me, named } from "./cli-name.js";
 import { Runtime } from "./client.js";
-import { connectionOrigins, connectionStore } from "./credentials.js";
+import { checkBrowserOrigins, connectionOrigins, connectionStore } from "./credentials.js";
 import { describeRoute, envFetch } from "./proxy.js";
 class ConnectionError extends Error {
     status;
@@ -100,7 +100,16 @@ function connection(env, options) {
                 : response.status === 429
                     ? "Too many connection attempts. Try again later."
                     : "Runtime could not complete this connection. Try again.");
-        return (await response.json());
+        try {
+            return (await response.json());
+        }
+        catch (error) {
+            // A complete malformed answer remains terminal. A failed body read can
+            // hide an issued token, so keep its private key and retry the same request.
+            if (error instanceof SyntaxError)
+                throw error;
+            throw new ConnectionError(503, "Runtime's connection response was interrupted. Retry the connection.");
+        }
     }
     return { origins, store, request, fetcher };
 }
@@ -118,7 +127,7 @@ export async function authenticationCommand(args, env, options = {}) {
         // A pasted key belongs to the website's key list: forget it here, and
         // revoke it there if it should stop working everywhere.
         if (saved.connectionId === PASTED) {
-            await store.remove();
+            await store.remove(saved.key);
             return { disconnected: true };
         }
         try {
@@ -128,7 +137,7 @@ export async function authenticationCommand(args, env, options = {}) {
             if (!(error instanceof ConnectionError && error.status === 401))
                 throw error;
         }
-        await store.remove();
+        await store.remove(saved.key);
         return { disconnected: true };
     }
     if (command !== "login")
@@ -160,11 +169,7 @@ export async function authenticationCommand(args, env, options = {}) {
         agentName.length > 80 ||
         [...agentName].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
         throw new Error("Give the agent a name of up to 80 characters.");
-    // Never obtain a production key and then direct it at an unrelated API.
-    const local = (origin) => ["localhost", "127.0.0.1", "[::1]"].includes(new URL(origin).hostname);
-    if (!((origins.auth === "https://withruntime.com" && origins.api === "https://api.withruntime.com") ||
-        (local(origins.auth) && local(origins.api))))
-        throw new Error("Browser login supports Runtime's production endpoints or local test endpoints. Check RUNTIME_AUTH_URL and RUNTIME_API_URL.");
+    checkBrowserOrigins(origins);
     if (withKey) {
         // The fallback to a browser approval: a key from the website, read from
         // standard input so it never sits in a command line or shell history.
@@ -200,7 +205,7 @@ export async function authenticationCommand(args, env, options = {}) {
         catch (error) {
             if (!(error instanceof ConnectionError && error.status === 401))
                 throw error;
-            await store.remove();
+            await store.remove(saved.key);
         }
     }
     const pending = await beginDeviceLogin(env, agentName, options);
@@ -245,6 +250,7 @@ export async function authenticationCommand(args, env, options = {}) {
  * the agent, which shows it to the person it works for. */
 export async function beginDeviceLogin(env, agentName, options = {}) {
     const { origins, store, request } = connection(env, options);
+    checkBrowserOrigins(origins);
     // A request this machine already started and nobody has answered yet: pick
     // it up, so a command stopped while it waited (an agent's tool timing out)
     // shows the same link and code again rather than a new one to approve.

package/dist/mcp.d.ts

@@ -1,7 +1,8 @@
 /** Bridges an MCP client that speaks stdio to Runtime's hosted MCP endpoint.
  * Newline-delimited JSON-RPC in, the same out; every message is forwarded as
  * it is, so the server's tools, schemas and `instructions` reach the client
- * unchanged, and nothing here keeps a second catalogue. Starting it costs a
+ * unchanged, and nothing here keeps a second catalogue. The one change: the
+ * initialize answer's serverInfo.version is this package's. Starting it costs a
  * process and one TLS connection (undici loads only behind a proxy).
  *
  * With no key on this machine it does not fail: it serves one tool,

package/dist/mcp.js

@@ -14,7 +14,8 @@ const connectTool = {
 /** Bridges an MCP client that speaks stdio to Runtime's hosted MCP endpoint.
  * Newline-delimited JSON-RPC in, the same out; every message is forwarded as
  * it is, so the server's tools, schemas and `instructions` reach the client
- * unchanged, and nothing here keeps a second catalogue. Starting it costs a
+ * unchanged, and nothing here keeps a second catalogue. The one change: the
+ * initialize answer's serverInfo.version is this package's. Starting it costs a
  * process and one TLS connection (undici loads only behind a proxy).
  *
  * With no key on this machine it does not fail: it serves one tool,
@@ -79,6 +80,10 @@ export async function serveMcp(env = process.env, options = {}) {
             const result = reply.result;
             if (result?.protocolVersion)
                 protocolVersion = result.protocolVersion;
+            // The client runs this package: it reports the package's version, as
+            // before connecting, not the hosted API's contract version (0.2.0).
+            if (result?.serverInfo)
+                result.serverInfo.version = VERSION;
         }
         return { status: response.status, messages, text };
     }

package/dist/modal/index.js

@@ -149,6 +149,7 @@ export class SandboxService {
             throw new CompatibilityError("Modal", "fractional CPU reservations");
         if (params.blockNetwork && (params.outboundDomainAllowlist || params.outboundCidrAllowlist))
             throw new TypeError("blockNetwork cannot be combined with allowlists");
+        const placement = region("Modal", params.regions?.[0]);
         const built = await image.build(app);
         let primary;
         const s = await create(this.runtime, "modal", {
@@ -162,7 +163,7 @@ export class SandboxService {
             cpu: "reserved",
             vcpu: params.cpu,
             memoryMiB: params.memoryMiB,
-            region: region("Modal", params.regions?.[0]),
+            region: placement,
             timeoutSeconds: Math.ceil((params.timeoutMs ?? 300_000) / 1000),
             idlePauseSeconds: 0,
             onLeaseEnd: "stop",