withruntime 0.8.4 → 0.9.0

package/dist/tar.js

@@ -1,6 +1,8 @@
-import { chmod, lstat, mkdir, readdir, readFile, realpath, symlink, unlink, writeFile, } from "node:fs/promises";
+import { chmod, lstat, mkdir, mkdtemp, open, readdir, readFile, realpath, rename, rm, symlink, unlink, } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { gunzipSync, gzipSync } from "node:zlib";
+import { Readable } from "node:stream";
+import { createGunzip, gzipSync } from "node:zlib";
+import { RuntimeError } from "./errors.js";
 /* A small ustar writer and reader for directory uploads and downloads, so the
    SDK needs no dependency. Regular files, directories and symbolic links;
    names up to 255 bytes through the ustar prefix field. */
@@ -111,34 +113,119 @@ async function linkStaysInside(root, directory, link) {
     }
     return true;
 }
-/** Unpacks into `target`, refusing any entry that would land outside it. */
-export async function unpackArchive(archive, target) {
-    const data = gunzipSync(archive);
-    await mkdir(resolve(target), { recursive: true });
-    const root = await realpath(resolve(target));
-    const text = (start, length) => {
-        const slice = data.subarray(start, start + length);
+/** A folder that did not arrive whole: tar in the sandbox stopped part way
+ * (a file it may not read, one that changed as it was read), which ends the
+ * gzip stream short, or the connection was lost (ARCHITECTURE.md section 10,
+ * "Folders over HTTP"). */
+function cutShort(cause) {
+    return new RuntimeError({
+        message: "The folder's archive arrived cut short: tar in the sandbox stopped part way, or the connection was lost. Nothing was written.",
+        hint: "Try again. If it fails the same way, a file in the folder cannot be read by the sandbox user or changes as it is read.",
+        code: "download_incomplete",
+        status: 0,
+        ...(cause === undefined ? {} : { cause }),
+    });
+}
+/** The gzip stream's bytes, decompressed as they arrive. */
+function gunzipped(source) {
+    const input = Readable.from(source, { objectMode: false });
+    const output = createGunzip();
+    input.on("error", (error) => output.destroy(error));
+    input.pipe(output);
+    output.on("close", () => input.destroy());
+    return output;
+}
+/** Exact byte counts from a stream of chunks, holding at most one chunk. */
+class Bytes {
+    #chunks;
+    #held = new Uint8Array(0);
+    constructor(source) {
+        this.#chunks = source[Symbol.asyncIterator]();
+    }
+    async #more() {
+        let next;
+        try {
+            next = await this.#chunks.next();
+        }
+        catch (error) {
+            throw error instanceof RuntimeError ? error : cutShort(error);
+        }
+        if (next.done)
+            return false;
+        this.#held = this.#held.length ? Buffer.concat([this.#held, next.value]) : next.value;
+        return true;
+    }
+    /** `n` bytes, or undefined at a clean end before any of them. */
+    async exactly(n) {
+        while (this.#held.length < n) {
+            if (await this.#more())
+                continue;
+            if (this.#held.length === 0)
+                return undefined;
+            throw cutShort();
+        }
+        const out = this.#held.subarray(0, n);
+        this.#held = this.#held.subarray(n);
+        return out;
+    }
+    /** The next `n` bytes as they arrive. */
+    async *take(n) {
+        while (n > 0) {
+            if (this.#held.length === 0 && !(await this.#more()))
+                throw cutShort();
+            const out = this.#held.subarray(0, n);
+            this.#held = this.#held.subarray(out.length);
+            n -= out.length;
+            yield out;
+        }
+    }
+    /** Reads to the end, so the gzip stream's own check has run. */
+    async drain() {
+        this.#held = new Uint8Array(0);
+        while (await this.#more())
+            this.#held = new Uint8Array(0);
+    }
+}
+/** Unpacks a tar stream into `root`, a fresh folder: files and folders as they
+ * arrive, links noted to make at the end. Throws unless the archive's end
+ * arrived. */
+async function unpackEntries(bytes, root) {
+    const links = [];
+    const decode = (slice) => {
         const end = slice.indexOf(0);
         return new TextDecoder().decode(end < 0 ? slice : slice.subarray(0, end));
     };
-    const links = [];
     let longName;
     let longLink;
-    for (let offset = 0; offset + 512 <= data.length;) {
-        if (data.subarray(offset, offset + 512).every((byte) => byte === 0))
-            break;
-        const size = parseInt(text(offset + 124, 12).trim() || "0", 8);
-        const type = String.fromCharCode(data[offset + 156] ?? 48);
-        const prefix = text(offset + 345, 155);
-        let name = longName ?? (prefix ? `${prefix}/${text(offset, 100)}` : text(offset, 100));
-        const link = longLink ?? text(offset + 157, 100);
+    for (;;) {
+        const header = await bytes.exactly(512);
+        if (!header)
+            throw cutShort();
+        if (header.every((byte) => byte === 0)) {
+            await bytes.drain();
+            return links;
+        }
+        const text = (start, length) => decode(header.subarray(start, start + length));
+        const size = parseInt(text(124, 12).trim() || "0", 8);
+        const type = String.fromCharCode(header[156] ?? 48);
+        const prefix = text(345, 155);
+        let name = longName ?? (prefix ? `${prefix}/${text(0, 100)}` : text(0, 100));
+        const link = longLink ?? text(157, 100);
         longName = undefined;
         longLink = undefined;
-        const mode = parseInt(text(offset + 100, 8).trim() || "644", 8);
-        const body = data.subarray(offset + 512, offset + 512 + size);
-        offset += 512 + Math.ceil(size / 512) * 512;
+        const mode = parseInt(text(100, 8).trim() || "644", 8);
+        const padding = Math.ceil(size / 512) * 512 - size;
+        const skip = async () => {
+            for await (const _ of bytes.take(size + padding))
+                ;
+        };
         if (type === "L" || type === "K") {
-            const value = new TextDecoder().decode(body).replace(/\0.*$/s, "");
+            const parts = [];
+            for await (const part of bytes.take(size))
+                parts.push(Uint8Array.from(part));
+            for await (const _ of bytes.take(padding))
+                ;
+            const value = new TextDecoder().decode(Buffer.concat(parts)).replace(/\0.*$/s, "");
             if (type === "L")
                 longName = value;
             else
@@ -146,29 +233,92 @@ export async function unpackArchive(archive, target) {
             continue;
         }
         name = name.replace(/^\.\//, "");
-        if (!name || name === "." || name === "./")
+        if (!name || name === "." || name === "./") {
+            await skip();
             continue;
+        }
         const destination = resolve(root, name);
         await assertPlain(root, destination, name);
-        if (type === "5")
+        if (type === "5") {
             await mkdir(destination, { recursive: true });
-        else if (type === "2")
+            await skip();
+        }
+        else if (type === "2") {
             links.push({ destination, link, name });
+            await skip();
+        }
         else if (type === "0" || type === "\0" || type === "7") {
             await mkdir(dirname(destination), { recursive: true });
-            await writeFile(destination, body);
+            const file = await open(destination, "w");
+            try {
+                for await (const part of bytes.take(size))
+                    await file.write(part);
+            }
+            finally {
+                await file.close();
+            }
             await chmod(destination, mode & 0o777);
+            for await (const _ of bytes.take(padding))
+                ;
         }
+        else
+            await skip();
     }
-    for (const { destination, link, name } of links) {
-        await assertPlain(root, destination, name);
-        await mkdir(dirname(destination), { recursive: true });
-        await symlink(link, destination).catch(() => undefined);
+}
+/** Moves what was unpacked in `from` into `to`, merging with what is there
+ * and replacing files of the same name, never through a link in `to`. */
+async function merge(from, to, root) {
+    for (const name of await readdir(from)) {
+        const source = join(from, name);
+        const destination = join(to, name);
+        await assertPlain(root, destination, relative(root, destination));
+        const [kind, there] = await Promise.all([
+            lstat(source),
+            lstat(destination).catch(() => undefined),
+        ]);
+        if (kind.isDirectory() && there?.isDirectory())
+            await merge(source, destination, root);
+        else
+            await rename(source, destination);
     }
-    for (const { destination, link, name } of links) {
-        if (await linkStaysInside(root, dirname(destination), link))
-            continue;
-        await unlink(destination).catch(() => undefined);
-        throw new Error(`Refusing an archive link that leads outside the target: ${name} -> ${link}`);
+}
+/** Unpacks a gzipped tar that arrives as a stream into `target`, refusing any
+ * entry that would land outside it, holding no more than a chunk at a time.
+ * It unpacks into a folder beside the target and moves it into place only
+ * once the whole archive arrived, so an archive cut short leaves nothing
+ * behind that could pass for the folder. A target that exists is merged
+ * into, files of the same name replaced. */
+export async function unpackStream(source, target) {
+    const final = resolve(target);
+    await mkdir(dirname(final), { recursive: true });
+    const staging = await mkdtemp(`${final}.runtime-partial-`);
+    const stream = gunzipped(source);
+    try {
+        const root = await realpath(staging);
+        const links = await unpackEntries(new Bytes(stream), root);
+        for (const { destination, link, name } of links) {
+            await assertPlain(root, destination, name);
+            await mkdir(dirname(destination), { recursive: true });
+            await symlink(link, destination).catch(() => undefined);
+        }
+        for (const { destination, link, name } of links) {
+            if (await linkStaysInside(root, dirname(destination), link))
+                continue;
+            await unlink(destination).catch(() => undefined);
+            throw new Error(`Refusing an archive link that leads outside the target: ${name} -> ${link}`);
+        }
+        const there = await lstat(final).catch(() => undefined);
+        if (!there)
+            await rename(staging, final);
+        else
+            await merge(root, await realpath(final), await realpath(final));
+    }
+    finally {
+        stream.destroy();
+        await rm(staging, { recursive: true, force: true });
     }
 }
+/** Unpacks a whole gzipped tar held in memory, by the same rules. */
+export function unpackArchive(archive, target) {
+    return unpackStream([archive], target);
+}

package/dist/tools/index.js

@@ -10,6 +10,7 @@
  * chooses commands and paths, never the sandbox, the account or the key.
  * Relative paths are under /workspace, and output is capped so one noisy
  * command cannot flood the model's context. */
+import { TOOL_EXEC_TIMEOUT_SECONDS } from "../api-defaults.js";
 import { NotFoundError } from "../errors.js";
 const WORKSPACE = "/workspace";
 /** A POSIX path joined and normalized: `..` cannot climb past `/`. */
@@ -34,7 +35,7 @@ export function clip(text, limit) {
 /** runtime_exec, runtime_read_file, runtime_write_file and runtime_list_files, bound to `sandbox`. */
 export function sandboxTools(sandbox, options = {}) {
     const root = resolvePath("/", options.root ?? WORKSPACE);
-    const timeoutSeconds = options.timeoutSeconds ?? 300;
+    const timeoutSeconds = options.timeoutSeconds ?? TOOL_EXEC_TIMEOUT_SECONDS;
     const limit = options.maxOutputChars ?? 20_000;
     const inFilesApi = (path) => path.startsWith(`${WORKSPACE}/`);
     return [

package/dist/transport.d.ts

@@ -1,17 +1,35 @@
 import { RuntimeError } from "./errors.js";
-export declare const VERSION = "0.8.4";
+export declare const VERSION = "0.9.0";
 export declare const DEFAULT_BASE_URL = "https://api.withruntime.com";
+/** Runtime's API as code inside a Runtime sandbox reaches it: the sandbox's
+ * own host sends each request on to DEFAULT_BASE_URL over HTTPS. The API runs
+ * on that host, whose addresses a sandbox cannot reach directly. Plain HTTP
+ * because the hop never leaves the machine: it goes from the program to the
+ * guest's own proxy and over the sandbox's private channel to its host. */
+export declare const SANDBOX_BASE_URL = "http://runtime.internal";
+/** True in a Runtime sandbox. Node and Bun only; a browser is never one. */
+export declare function inRuntimeSandbox(marker?: string): boolean;
+/** Where calls go when no base URL is given: RUNTIME_API_URL, then Runtime's
+ * public API, which `reachable` turns into runtime.internal in a sandbox. */
+export declare function defaultBaseUrl(env?: Record<string, string | undefined>, inSandbox?: typeof inRuntimeSandbox): string;
+/** The origin calls for `origin` are sent to from here. In a sandbox the
+ * public API is its own host, which it cannot reach directly, so calls for it
+ * go to runtime.internal; every other origin is left as it is. */
+export declare function reachable(origin: string, inSandbox?: typeof inRuntimeSandbox): string;
 export type RequestOptions = {
     /** Sent as Idempotency-Key. Omit it: the SDK makes one per call and keeps
      * it across its own retries, so a retried write never happens twice. Pass
      * your own only to retry a call yourself after the process restarted. */
     idempotencyKey?: string;
     signal?: AbortSignal;
-    /** Deadline for this call, retries included. */
+    /** Deadline for this call, retries included. 0 disables this deadline;
+     * an explicit signal can still cancel the call. */
     timeoutMs?: number;
 };
 export type Query = Record<string, string | number | boolean | readonly string[] | undefined>;
 export type Call = RequestOptions & {
+    /** Internal protocol hook: successful headers arrived, before reading the body. */
+    onResponse?: (response: Response) => void;
     method: "GET" | "POST" | "PUT" | "DELETE";
     path: string;
     query?: Query;

package/dist/transport.js

@@ -1,17 +1,52 @@
-import { ConnectionError, errorFor, RuntimeError, WAITS_FOR_ROOM } from "./errors.js";
+import { ConnectionError, DELIBERATE, errorFor, RuntimeError, WAITS_FOR_ROOM } from "./errors.js";
 import { describeRoute, envFetch, openWebSocket } from "./proxy.js";
-export const VERSION = "0.8.4";
+export const VERSION = "0.9.0";
 export const DEFAULT_BASE_URL = "https://api.withruntime.com";
+/** Runtime's API as code inside a Runtime sandbox reaches it: the sandbox's
+ * own host sends each request on to DEFAULT_BASE_URL over HTTPS. The API runs
+ * on that host, whose addresses a sandbox cannot reach directly. Plain HTTP
+ * because the hop never leaves the machine: it goes from the program to the
+ * guest's own proxy and over the sandbox's private channel to its host. */
+export const SANDBOX_BASE_URL = "http://runtime.internal";
+/** Every Runtime sandbox has this file; guest-net.py keeps it current. */
+const SANDBOX_MARKER = "/run/runtime/environment.json";
+/** True in a Runtime sandbox. Node and Bun only; a browser is never one. */
+export function inRuntimeSandbox(marker = SANDBOX_MARKER) {
+    try {
+        const host = globalThis.process;
+        return host?.getBuiltinModule?.("node:fs")?.existsSync?.(marker) === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Where calls go when no base URL is given: RUNTIME_API_URL, then Runtime's
+ * public API, which `reachable` turns into runtime.internal in a sandbox. */
+export function defaultBaseUrl(env = processEnv(), inSandbox = inRuntimeSandbox) {
+    return reachable(env.RUNTIME_API_URL || DEFAULT_BASE_URL, inSandbox);
+}
+/** The origin calls for `origin` are sent to from here. In a sandbox the
+ * public API is its own host, which it cannot reach directly, so calls for it
+ * go to runtime.internal; every other origin is left as it is. */
+export function reachable(origin, inSandbox = inRuntimeSandbox) {
+    return apiOrigin(origin) === DEFAULT_BASE_URL && inSandbox() ? SANDBOX_BASE_URL : origin;
+}
+function processEnv() {
+    return (globalThis.process?.env ?? {});
+}
 export function apiOrigin(value) {
     const url = new URL(value);
-    const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    // runtime.internal is reserved and never resolves outside a sandbox, so a
+    // key sent there in plain HTTP never leaves the sandbox's host.
+    const local = ["localhost", "127.0.0.1", "[::1]", "runtime.internal"].includes(url.hostname);
     if ((url.protocol !== "https:" && !(local && url.protocol === "http:")) ||
+        (url.hostname === "runtime.internal" && (url.protocol !== "http:" || url.port !== "")) ||
         url.username ||
         url.password ||
         url.search ||
         url.hash ||
         url.pathname !== "/")
-        throw new Error("Use an HTTPS API origin (or http://localhost for tests).");
+        throw new Error("Use an HTTPS API origin (or http://runtime.internal inside a sandbox, http://localhost for tests).");
     return url.origin;
 }
 export function encodeQuery(query) {
@@ -30,10 +65,6 @@ export function encodeQuery(query) {
     const text = params.toString();
     return text ? `?${text}` : "";
 }
-/** 503s that are a deliberate state, not a passing one: a product switched
- * off here, or paused on purpose. Retrying cannot change them, so they fail
- * at once with their own words. host_unavailable and busy are still retried. */
-const DELIBERATE = new Set(["fork_unavailable", "previews_unavailable", "unavailable"]);
 const sleep = (ms, signal) => new Promise((resolve, reject) => {
     const timer = setTimeout(done, ms);
     function done() {
@@ -99,7 +130,7 @@ export class Transport {
             throw missingKey();
         else
             this.#apiKey = options.apiKey;
-        this.baseUrl = apiOrigin(options.baseUrl ?? DEFAULT_BASE_URL);
+        this.baseUrl = apiOrigin(options.baseUrl ? reachable(options.baseUrl) : defaultBaseUrl());
         // The environment's proxy (HTTPS_PROXY, NO_PROXY) on Node and Bun alike;
         // a fetch passed in is used as it is.
         this.#fetch = options.fetch ?? envFetch;
@@ -147,7 +178,8 @@ export class Transport {
         const roomMs = Math.max(0, call.waitForCapacityMs ?? 0);
         const roomUntil = performance.now() + roomMs;
         let roomAttempt = 0;
-        const deadline = AbortSignal.timeout((call.timeoutMs ?? this.#timeoutMs) + roomMs);
+        const timeoutMs = call.timeoutMs ?? this.#timeoutMs;
+        const deadline = timeoutMs === 0 ? new AbortController().signal : AbortSignal.timeout(timeoutMs + roomMs);
         const signal = call.signal ? AbortSignal.any([call.signal, deadline]) : deadline;
         const url = `${this.baseUrl}${call.path}${encodeQuery(call.query)}`;
         const body = call.bytes ?? (call.body === undefined ? undefined : JSON.stringify(call.body));
@@ -211,8 +243,10 @@ export class Transport {
                     return new Response(text, { headers: response.headers });
                 late = { status: failed, text };
             }
-            else if (response.ok)
+            else if (response.ok) {
+                call.onResponse?.(response);
                 return response;
+            }
             const status = late?.status ?? response.status;
             // Runtime never answers 407: it is a proxy refusing the tunnel, which
             // Bun's fetch hands back as a response rather than an error.
@@ -336,12 +370,14 @@ export class Transport {
         let buffer = "";
         try {
             for (;;) {
+                call.signal?.throwIfAborted();
                 const { value, done } = await reader.read();
                 if (done)
                     break;
                 buffer += value;
                 let newline = buffer.indexOf("\n");
                 while (newline >= 0) {
+                    call.signal?.throwIfAborted();
                     const line = buffer.slice(0, newline).trim();
                     buffer = buffer.slice(newline + 1);
                     if (line)
@@ -349,6 +385,7 @@ export class Transport {
                     newline = buffer.indexOf("\n");
                 }
             }
+            call.signal?.throwIfAborted();
             if (buffer.trim())
                 yield JSON.parse(buffer);
         }

package/dist/types.d.ts

@@ -39,8 +39,14 @@ export type SandboxInfo = {
     heldMicros: number;
     simulated?: boolean;
     replayed?: boolean;
+    /** The names of its own environment variables (`env`), on a create, an
+     * update and a read of one sandbox. Values are never shown. */
+    envNames?: string[];
     /** On a create from an image with a start command: whether it started,
-     * became ready (readyMs), timed out, or exited first. */
+     * became ready (readyMs), timed out, or exited first. The create's answer
+     * alone carries it, and the Sandbox that create returned keeps it through
+     * later reads; `sandboxes.get` and `list` have none, because the API keeps
+     * no record of it. */
     start?: {
         state: "started" | "ready" | "timeout" | "exited" | "not_running";
         processId?: string;
@@ -54,6 +60,11 @@ export type SandboxInfo = {
 export type CreateSandbox = {
     name?: string;
     labels?: Record<string, string>;
+    /** Environment variables for every command, process, terminal, SSH session
+     * and the image's start command in this sandbox, under each command's own
+     * `env`. At most 32 variables and 32 KiB. Values are never shown again;
+     * answers list only `envNames`. Copies made by fork() keep them. */
+    env?: Record<string, string>;
     /** Omit to use the free trial while it lasts, then prepaid credit. */
     funding?: "trial" | "paid";
     region?: string;
@@ -103,6 +114,13 @@ export type CreateSandbox = {
         path: string;
         mode?: "rw" | "snapshot";
     }[];
+    /** Paid only: join your Tailscale network once running. `authKeySecret`
+     * names a job secret holding the auth key. */
+    tailscale?: {
+        authKeySecret: string;
+        hostname?: string;
+        tags?: string[];
+    };
 };
 export type CommandResult = {
     exitCode: number | null;
@@ -124,8 +142,8 @@ export type ExecOptions = {
     /** Default 60 000, or 24 hours when the output streams (onStdout, onStderr or
      * execStream); up to 24 hours. A timeout is a result (timedOut), not an error. */
     timeoutMs?: number;
-    onStdout?: (text: string) => void;
-    onStderr?: (text: string) => void;
+    onStdout?: (text: string) => unknown;
+    onStderr?: (text: string) => unknown;
     /** Throw CommandError when the exit code is not 0. */
     check?: boolean;
     signal?: AbortSignal;
@@ -141,6 +159,7 @@ export type ProcessInfo = {
     pty: boolean;
     stdinOpen: boolean;
     stdinOffset: number;
+    outputEncoding?: "utf8" | "base64";
     startedAt: string;
     endedAt: string | null;
     timeoutMs: number | null;
@@ -155,6 +174,7 @@ export type OutputEvent = {
     type: "stdout" | "stderr";
     data: string;
     offset: number;
+    base64?: string;
 } | {
     type: "exit";
     exitCode: number | null;
@@ -177,6 +197,13 @@ export type OutputEvent = {
         requestId?: string;
     };
 };
+export type BinaryOutputEvent = Exclude<OutputEvent, {
+    type: "stdout" | "stderr";
+}> | {
+    type: "stdout" | "stderr";
+    data: Uint8Array;
+    offset: number;
+};
 export type FileEntry = {
     name: string;
     path: string;
@@ -184,6 +211,11 @@ export type FileEntry = {
     size: number;
     mode: string;
     modifiedAt: string;
+    uid?: number;
+    gid?: number;
+    owner?: string;
+    group?: string;
+    symlinkTarget?: string;
 };
 /** GET /v1/usage. Money is integer microdollars in strings (1,000,000 = $1),
  * exact past 2^53: available = credited - spent - expired - held. */
@@ -226,6 +258,9 @@ export type FeedbackKind = "bug" | "missing_feature" | "competitor_gap" | "migra
 export type SandboxSettings = {
     name?: string;
     labels?: Record<string, string>;
+    /** Changes its environment: a value sets a variable, null removes it, and
+     * the rest stay. Commands started afterwards get the change. */
+    env?: Record<string, string | null>;
     /** A request to a paused sandbox wakes it. */
     autoWake?: boolean;
     /** Pause after this many seconds with no activity, counted from now; 0
@@ -236,6 +271,20 @@ export type SandboxSettings = {
     /** Lifetime cap in microdollars; null removes it. */
     maxTotalCostMicros?: number | null;
 };
+/** A deleted sandbox, as `delete()` answers it the first time and every time
+ * after. It reads nowhere else afterwards. */
+export type DeletedSandbox = {
+    id: string;
+    kind: "sandbox";
+    name: string | null;
+    labels: Record<string, string>;
+    status: "deleted";
+    /** "stopping" until its machine has stopped, usually well under a second. */
+    state: string;
+    deletedAt: string;
+    endedAt: string | null;
+    replayed?: boolean;
+};
 /** How `sandbox.keepAlive()` extends the lease. */
 export type KeepAliveOptions = {
     /** How often it checks, in seconds. Default 60. */

package/dist/vercel/command.js

@@ -47,18 +47,25 @@ export class Command {
     logs(opts = {}) {
         const abort = new AbortController();
         const forward = () => abort.abort();
-        opts.signal?.addEventListener("abort", forward, { once: true });
+        if (opts.signal?.aborted)
+            abort.abort();
+        else
+            opts.signal?.addEventListener("abort", forward, { once: true });
         const lines = this.init.lines;
         const process = this.init.process;
         const sandboxName = this.init.sandboxName;
         async function* read() {
             try {
+                if (abort.signal.aborted)
+                    return;
                 if (lines) {
                     yield* lines;
                     return;
                 }
                 try {
                     for await (const event of process.output({ signal: abort.signal })) {
+                        if (event.type === "truncated")
+                            throw new StreamError("output_truncated", "Some command output is no longer available.", process.id);
                         if (event.type === "stdout" || event.type === "stderr")
                             yield { stream: event.type, data: event.data };
                         if (event.type === "exit")
@@ -68,6 +75,8 @@ export class Command {
                 catch (error) {
                     if (abort.signal.aborted)
                         return;
+                    if (error instanceof StreamError)
+                        throw error;
                     const translated = translate(error, sandboxName);
                     throw translated instanceof Error && translated !== error
                         ? translated
@@ -94,6 +103,8 @@ export class Command {
         let exit;
         await guard(async () => {
             for await (const event of this.init.process.output(params.signal ? { signal: params.signal } : {})) {
+                if (event.type === "truncated")
+                    throw new StreamError("output_truncated", "Some command output is no longer available.", this.init.process.id);
                 if (event.type === "stdout" || event.type === "stderr")
                     lines.push({ stream: event.type, data: event.data });
                 else if (event.type === "exit")

package/dist/vercel/errors.d.ts

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

package/dist/vercel/errors.js

@@ -102,8 +102,19 @@ export function fsError(code, syscall, path) {
         EEXIST: "file already exists",
         EISDIR: "illegal operation on a directory",
         ENOTDIR: "not a directory",
+        EACCES: "permission denied",
+        ENOTEMPTY: "directory not empty",
+        EINVAL: "invalid argument",
+    }[code];
+    const errno = {
+        ENOENT: -2,
+        EEXIST: -17,
+        EISDIR: -21,
+        ENOTDIR: -20,
+        EACCES: -13,
+        ENOTEMPTY: -39,
+        EINVAL: -22,
     }[code];
-    const errno = { ENOENT: -2, EEXIST: -17, EISDIR: -21, ENOTDIR: -20 }[code];
     return Object.assign(new Error(`${code}: ${text}, ${syscall} '${path}'`), {
         code,
         errno,