withruntime 0.9.0 → 0.10.0

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,13 +15,14 @@ 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 { verifyWebhook, WebhookVerificationError, type MetricPoint, type MetricRange, type OtelExport, type RuntimeEvent, type SandboxMetrics, type Webhook, type WebhookDelivery, type WebhookEventType, } from "./products/observability.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/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",

package/dist/network-cli.js

@@ -1,4 +1,7 @@
-import { chmod, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, rename, unlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 import { RuntimeError } from "./errors.js";
 import { named } from "./cli-name.js";
 import { generateWireGuardKeyPair } from "./wireguard.js";
@@ -92,15 +95,63 @@ function portNumber(product, text) {
         throw usage(product, "Give a port from 1 to 65535.");
     return value;
 }
+/** A fresh private inode prevents disclosure through permissive files, symlinks
+ * and hard links. Rename publishes complete contents without a readable window. */
+async function privateOutput(path, text) {
+    const temporary = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+    try {
+        const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 0o600);
+        try {
+            await handle.writeFile(text);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        return temporary;
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => undefined);
+        throw error;
+    }
+}
+/** Check and stage before changing a remote peer. If the request or final write
+ * fails, this private draft preserves the newly generated key for recovery. */
+async function prepareOutput(path, privateKey) {
+    try {
+        const info = await lstat(path);
+        if (!info.isFile() || info.isSymbolicLink())
+            throw usage("tunnel", "The output must be a regular file, not a directory or symbolic link.");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const recovery = await privateOutput(path, `# DRAFT: request or output incomplete. Keep this file for recovery.\n[Interface]\nPrivateKey = ${privateKey ?? "<your private key>"}\n`);
+    return {
+        recovery,
+        async publish(config) {
+            const temporary = await privateOutput(path, config);
+            try {
+                await rename(temporary, path);
+            }
+            finally {
+                await unlink(temporary).catch(() => undefined);
+            }
+            await unlink(recovery);
+        },
+    };
+}
 /** Writes a wg-quick file readable by its owner alone, or prints it. */
-async function deliver(out, config, path, hint, ready = true) {
+async function deliver(out, config, path, hint, ready = true, prepared) {
     if (!config) {
         out.error(hint);
         return;
     }
     if (path) {
-        await writeFile(path, config, { mode: 0o600 });
-        await chmod(path, 0o600);
+        if (!prepared)
+            throw new Error("Tunnel output was not prepared.");
+        await prepared.publish(config);
         out.error(ready
             ? `Wrote ${path}. Bring it up with: sudo wg-quick up ${path.startsWith("/") ? path : `./${path}`}`
             : `Wrote ${path}. ${hint}`);
@@ -276,52 +327,69 @@ export async function networkProductCommand(product, argv, args, out, client) {
             case "peers": {
                 const action = rest[0];
                 if (action === "add" || action === "rotate") {
+                    const argument = need(rest[1], action === "add" ? "the peer's name, such as office" : "a peer id");
                     // The pair is made here unless a key is given: the private key never
                     // leaves this machine, and goes only into the file written below.
                     const given = flag("public-key");
                     const pair = given ? undefined : generateWireGuardKeyPair();
                     const publicKey = given ?? pair.publicKey;
-                    const answer = action === "add"
-                        ? await runtime.tunnel.addPeer({
-                            name: need(rest[1], "the peer's name, such as office"),
-                            publicKey,
-                            routes: args.flags.get("route") ?? [],
-                        })
-                        : await runtime.tunnel.rotatePeer(need(rest[1], "a peer id"), { publicKey });
-                    const configReady = answer.configReady ?? !!answer.config;
-                    const draftHint = "Keep this file: it preserves your private key. Read runtime tunnel get when the gateway is ready, replace PublicKey in [Peer] with gatewayPublicKey, then run wg-quick up.";
-                    // Older servers returned no config while the gateway was starting.
-                    // Preserve the locally generated key in a draft rather than discard it.
-                    const supplied = answer.config ??
-                        [
-                            "# DRAFT: gateway key missing. Keep this file; it preserves your private key.",
-                            "[Interface]",
-                            `PrivateKey = ${pair?.privateKey ?? "<your private key>"}`,
-                            `Address = ${answer.peer.address}/32`,
-                            "",
-                            "[Peer]",
-                            `PublicKey = ${answer.tunnel.gatewayPublicKey ?? "<gatewayPublicKey from runtime tunnel get>"}`,
-                            `Endpoint = ${answer.tunnel.endpoint}`,
-                            `AllowedIPs = ${answer.tunnel.subnet}`,
-                            "PersistentKeepalive = 25",
-                            "",
-                        ].join("\n");
-                    const config = pair
-                        ? supplied.replace(/^PrivateKey = .*$/m, `PrivateKey = ${pair.privateKey}`)
-                        : supplied;
-                    if (out.json) {
-                        print("", {
-                            ...answer,
-                            config,
-                            configReady,
-                            ...(!configReady ? { hint: draftHint } : {}),
-                        });
+                    const path = out.json ? undefined : (flag("out") ?? (pair ? "runtime.conf" : undefined));
+                    const prepared = path ? await prepareOutput(path, pair?.privateKey) : undefined;
+                    try {
+                        const answer = action === "add"
+                            ? await runtime.tunnel.addPeer({
+                                name: argument,
+                                publicKey,
+                                routes: args.flags.get("route") ?? [],
+                            })
+                            : await runtime.tunnel.rotatePeer(argument, { publicKey });
+                        const configReady = answer.configReady ?? !!answer.config;
+                        const draftHint = "Keep this file: it preserves your private key. Read runtime tunnel get when the gateway is ready, replace PublicKey in [Peer] with gatewayPublicKey, then run wg-quick up.";
+                        // Older servers returned no config while the gateway was starting.
+                        // Preserve the locally generated key in a draft rather than discard it.
+                        const supplied = answer.config ??
+                            [
+                                "# DRAFT: gateway key missing. Keep this file; it preserves your private key.",
+                                "[Interface]",
+                                `PrivateKey = ${pair?.privateKey ?? "<your private key>"}`,
+                                `Address = ${answer.peer.address}/32`,
+                                "",
+                                "[Peer]",
+                                `PublicKey = ${answer.tunnel.gatewayPublicKey ?? "<gatewayPublicKey from runtime tunnel get>"}`,
+                                `Endpoint = ${answer.tunnel.endpoint}`,
+                                `AllowedIPs = ${answer.tunnel.subnet}`,
+                                "PersistentKeepalive = 25",
+                                "",
+                            ].join("\n");
+                        const privateKeyRow = /^[ \t]*PrivateKey[ \t]*=[^\r\n]*$/gm;
+                        if (pair && (supplied.match(privateKeyRow)?.length ?? 0) !== 1)
+                            throw new RuntimeError({
+                                code: "invalid_response",
+                                status: 0,
+                                message: "Runtime returned a tunnel configuration without exactly one private-key field.",
+                            });
+                        const config = pair
+                            ? supplied.replace(privateKeyRow, `PrivateKey = ${pair.privateKey}`)
+                            : supplied;
+                        if (out.json) {
+                            print("", {
+                                ...answer,
+                                config,
+                                configReady,
+                                ...(!configReady ? { hint: draftHint } : {}),
+                            });
+                            return 0;
+                        }
+                        if (answer.tunnel.funded === false)
+                            out.error(fundingState(answer.tunnel));
+                        await deliver(out, config, path, configReady ? answer.hint : draftHint, configReady, prepared);
                         return 0;
                     }
-                    if (answer.tunnel.funded === false)
-                        out.error(fundingState(answer.tunnel));
-                    await deliver(out, config, flag("out") ?? (pair ? "runtime.conf" : undefined), configReady ? answer.hint : draftHint, configReady);
-                    return 0;
+                    catch (error) {
+                        if (prepared)
+                            out.error(`The peer request or output did not finish. Your private draft is saved at ${prepared.recovery}; keep it for recovery.`);
+                        throw error;
+                    }
                 }
                 if (action === "rm" || action === "remove") {
                     const after = await runtime.tunnel.removePeer(need(rest[1], "a peer id"));

package/dist/openai-agents/index.js

@@ -531,29 +531,11 @@ export class RuntimeCloudSandboxSession {
     // Workspace archives.
     async persistWorkspace() {
         const root = this.state.manifest.root;
-        const staging = `${STAGING}/${crypto.randomUUID()}.tar`;
-        const skip = root === FILES_HOME ? ["--exclude=./.openai-agents-staging"] : [];
-        try {
-            const packed = await this.#call((sbx) => sbx.exec([
-                "sh",
-                "-c",
-                `mkdir -p -- ${STAGING} && tar ${skip.join(" ")} -C "$1" -cf - . > "$2"`,
-                "sh",
-                root,
-                staging,
-            ], {
-                cwd: "/",
-                timeoutMs: this.state.execTimeoutMs,
-            }));
-            if (packed.exitCode !== 0)
-                throw new SandboxProviderError(`${PROVIDER} could not archive the workspace.`, {
-                    stderr: packed.stderr,
-                });
-            return await this.#call((sbx) => sbx.files.read(staging));
-        }
-        finally {
-            await this.#call((sbx) => sbx.files.remove(staging)).catch(() => undefined);
-        }
+        return this.#call((sbx) => sbx.files.archive(root, {
+            gzip: false,
+            ...(root === FILES_HOME ? { exclude: [".openai-agents-staging"] } : {}),
+            timeoutMs: this.state.execTimeoutMs,
+        }));
     }
     async hydrateWorkspace(data) {
         const bytes = typeof data === "string"
@@ -561,28 +543,10 @@ export class RuntimeCloudSandboxSession {
             : data instanceof Uint8Array
                 ? data
                 : new Uint8Array(data);
-        const staging = `${STAGING}/${crypto.randomUUID()}.tar`;
-        try {
-            await this.#call((sbx) => sbx.files.write(staging, bytes));
-            const unpacked = await this.#call((sbx) => sbx.exec([
-                "sh",
-                "-c",
-                'mkdir -p -- "$1" && tar -C "$1" -xf "$2"',
-                "sh",
-                this.state.manifest.root,
-                staging,
-            ], {
-                cwd: "/",
-                timeoutMs: this.state.execTimeoutMs,
-            }));
-            if (unpacked.exitCode !== 0)
-                throw new SandboxProviderError(`${PROVIDER} could not restore the workspace.`, {
-                    stderr: unpacked.stderr,
-                });
-        }
-        finally {
-            await this.#call((sbx) => sbx.files.remove(staging)).catch(() => undefined);
-        }
+        await this.#call((sbx) => sbx.files.unarchive(this.state.manifest.root, bytes, {
+            gzip: false,
+            timeoutMs: this.state.execTimeoutMs,
+        }));
     }
     // Lifecycle.
     async running() {