withruntime 0.8.4 → 0.10.0

package/dist/e2b/code-interpreter.d.ts

@@ -3,8 +3,7 @@
  *   import { Sandbox } from "withruntime/e2b/code-interpreter";
  *
  * runCode runs in Runtime's interpreter (sandbox.runtime.interpreter):
- * stateful Python and JavaScript contexts, as in E2B. Other languages throw
- * NotSupportedError. */
+ * stateful contexts in every E2B interpreter language. */
 import type { Runtime } from "../client.js";
 import type { ConnectionOpts } from "./client.js";
 import { Sandbox as BaseSandbox } from "./sandbox.js";
@@ -13,11 +12,11 @@ export type RunCodeLanguage = "python" | "javascript" | "typescript" | "r" | "ja
 /** A line of output, as E2B's callbacks receive it. */
 export declare class OutputMessage {
     readonly line: string;
-    /** Unix epoch in nanoseconds (from the client's clock). */
+    /** Unix epoch in microseconds (from the client's clock), as in E2B. */
     readonly timestamp: number;
     readonly error: boolean;
     constructor(line: string, 
-    /** Unix epoch in nanoseconds (from the client's clock). */
+    /** Unix epoch in microseconds (from the client's clock), as in E2B. */
     timestamp: number, error: boolean);
     toString(): string;
 }
@@ -110,7 +109,7 @@ export interface RunCodeOpts {
     envs?: Record<string, string>;
     /** Default 60 000, as in E2B. */
     timeoutMs?: number;
-    /** Accepted and ignored: Runtime's SDK allows the run its timeout plus a minute. */
+    /** Deadline for receiving response headers; 0 disables it. */
     requestTimeoutMs?: number;
 }
 export interface CreateCodeContextOpts {

package/dist/e2b/code-interpreter.js

@@ -8,7 +8,7 @@ export class OutputMessage {
     timestamp;
     error;
     constructor(line, 
-    /** Unix epoch in nanoseconds (from the client's clock). */
+    /** Unix epoch in microseconds (from the client's clock), as in E2B. */
     timestamp, error) {
         this.line = line;
         this.timestamp = timestamp;
@@ -122,50 +122,18 @@ function lines(text) {
     return text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
 }
 function language(requested) {
-    if (requested === undefined || requested === "python")
-        return "python";
-    if (requested === "javascript" || requested === "js")
-        return "javascript";
-    throw new NotSupportedError(`Running ${requested} code in the interpreter`, requested === "bash"
-        ? "Use sandbox.commands.run(code)."
-        : "Runtime's interpreter runs Python and JavaScript; install the language and run it with sandbox.commands.run(...).");
+    const selected = requested === "js" ? "javascript" : (requested ?? "python");
+    if (["python", "javascript", "typescript", "r", "java", "bash", "go"].includes(selected))
+        return selected;
+    throw new NotSupportedError(`Running ${requested} code in the interpreter`, "Use Python, JavaScript, TypeScript, R, Java, Bash or Go.");
 }
 /** The code interpreter sandbox: everything the base Sandbox has, plus runCode
  * and code contexts. */
 export class Sandbox extends BaseSandbox {
     static defaultTemplate = "code-interpreter-v1";
-    /** Contexts made to carry the sandbox's envs, one per language. */
-    #envContexts = new Map();
     get #interpreter() {
         return this.runtime.interpreter;
     }
-    /** The context a run goes to: the one asked for; else, when the sandbox has
-     * envs, a context made once with them; else Runtime's default one. */
-    async #contextFor(lang, context) {
-        if (context)
-            return context.id;
-        if (!Object.keys(this.envs).length)
-            return undefined;
-        let id = this.#envContexts.get(lang);
-        if (!id) {
-            id = guard("sandbox", async () => {
-                const made = await this.#interpreter.contexts.create({
-                    id: `e2b-${lang}`,
-                    language: lang,
-                    env: this.envs,
-                });
-                return made.id;
-            }).catch(async (error) => {
-                // Made already, by another object connected to this sandbox.
-                const existing = (await this.#interpreter.contexts.list()).find((one) => one.id === `e2b-${lang}`);
-                if (existing)
-                    return existing.id;
-                throw error;
-            });
-            this.#envContexts.set(lang, id);
-        }
-        return id;
-    }
     async #inline(result) {
         const data = { ...result.data };
         for (const [mime, ref] of Object.entries(result.refs ?? {})) {
@@ -186,28 +154,59 @@ export class Sandbox extends BaseSandbox {
         if (opts.envs && Object.keys(opts.envs).length)
             throw new NotSupportedError("Environment variables for one run (runCode envs)", "Make a context with them: sandbox.runtime.interpreter.contexts.create({ env }), then runCode(code, { context: { id } }).");
         const lang = language(opts.context?.language ?? opts.language);
-        const context = await this.#contextFor(lang, opts.context);
-        const now = () => Date.now() * 1_000_000;
-        const streaming = opts.onStdout || opts.onStderr || opts.onResult || opts.onError;
-        const execution = await guard("sandbox", () => this.#interpreter.run(code, {
-            ...(context ? { context } : { language: lang }),
-            timeoutMs: opts.timeoutMs ?? 60_000,
-            ...(streaming
-                ? {
-                    onStdout: (text) => void opts.onStdout?.(new OutputMessage(text, now(), false)),
-                    onStderr: (text) => void opts.onStderr?.(new OutputMessage(text, now(), true)),
-                    onError: (error) => void opts.onError?.(new ExecutionError(error.name, error.value, error.traceback)),
-                }
-                : {}),
-        }));
+        const context = opts.context?.id;
+        const now = () => Date.now() * 1_000;
+        const streamedResults = [];
+        const controller = new AbortController();
+        const requestTimeout = opts.requestTimeoutMs ?? this.requestTimeoutMs;
+        const timeout = opts.timeoutMs ?? 60_000;
+        let stage = "Request";
+        let timer;
+        const arm = (milliseconds) => {
+            clearTimeout(timer);
+            if (milliseconds)
+                timer = setTimeout(() => controller.abort(), milliseconds);
+        };
+        arm(requestTimeout);
+        let execution;
+        try {
+            execution = await guard("sandbox", () => this.#interpreter.run(code, {
+                ...(context ? { context } : { language: lang }),
+                // E2B times out its reader; it does not send a kernel deadline.
+                timeoutMs: 0,
+                requestTimeoutMs: 0,
+                interruptOnDisconnect: false,
+                signal: controller.signal,
+                onResponse: () => {
+                    stage = "Execution";
+                    arm(timeout);
+                },
+                // Stream even without callbacks: the header/body deadlines are separate.
+                onStdout: (text) => opts.onStdout?.(new OutputMessage(text, now(), false)),
+                onStderr: (text) => opts.onStderr?.(new OutputMessage(text, now(), true)),
+                onError: (error) => opts.onError?.(new ExecutionError(error.name, error.value, error.traceback)),
+                onResult: async (result) => {
+                    const mapped = new Result(await this.#inline(result), result.main);
+                    streamedResults.push(mapped);
+                    await opts.onResult?.(mapped);
+                },
+            }));
+        }
+        catch (error) {
+            if (controller.signal.aborted)
+                throw new TimeoutError(`${stage} timed out — the '${stage === "Request" ? "requestTimeoutMs" : "timeoutMs"}' option can be used to increase this timeout`);
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
         if (execution.status === "timeout")
             throw new TimeoutError(`Execution timed out after ${opts.timeoutMs ?? 60_000} ms: pass a larger 'timeoutMs'.`);
         if (execution.status === "lost")
             throw new SandboxError("The interpreter lost this run (its context stopped); run it again.");
-        const results = await Promise.all(execution.results.map(async (result) => new Result(await this.#inline(result), result.main)));
-        if (opts.onResult)
-            for (const result of results)
-                await opts.onResult(result);
+        const results = streamedResults.length === execution.results.length
+            ? streamedResults
+            : await Promise.all(execution.results.map(async (result) => new Result(await this.#inline(result), result.main)));
         return new Execution(results, { stdout: lines(execution.stdout), stderr: lines(execution.stderr) }, execution.error
             ? new ExecutionError(execution.error.name, execution.error.value, execution.error.traceback)
             : undefined, execution.executionCount ?? undefined);
@@ -217,7 +216,6 @@ export class Sandbox extends BaseSandbox {
         const made = await guard("sandbox", () => this.#interpreter.contexts.create({
             language: lang,
             ...(opts.cwd ? { cwd: opts.cwd } : {}),
-            ...(Object.keys(this.envs).length ? { env: this.envs } : {}),
         }));
         return { id: made.id, language: made.language, cwd: made.cwd };
     }

package/dist/e2b/commands.d.ts

@@ -1,6 +1,8 @@
 import type { Process } from "../sandbox.js";
+import type { ProcessInfo as RuntimeProcessInfo } from "../types.js";
+import type { RequestOptions } from "../transport.js";
 import type { RuntimeSandbox } from "./client.js";
-import { type CommandResult } from "./errors.js";
+import { TimeoutError, type CommandResult } from "./errors.js";
 export type { CommandResult };
 export type Username = "user" | "root" | (string & {});
 export interface CommandRequestOpts {
@@ -18,7 +20,7 @@ export interface CommandStartOpts extends CommandRequestOpts {
     onStdout?: (data: string) => void | Promise<void>;
     onStderr?: (data: string) => void | Promise<void>;
     stdin?: boolean;
-    /** Default 60 000, as in E2B. 0 is no limit (Runtime's longest, 24 hours). */
+    /** Stream connection deadline, 60 000 by default. Zero waits without a deadline. */
     timeoutMs?: number;
 }
 export type CommandConnectOpts = Pick<CommandStartOpts, "onStderr" | "onStdout" | "timeoutMs"> & CommandRequestOpts;
@@ -32,18 +34,34 @@ export interface ProcessInfo {
     envs: Record<string, string>;
     cwd?: string;
 }
-/** The shared state a sandbox's modules need: the Runtime sandbox, the
- * environment given at create, and the one-time /home/user link. */
+/** The shared state a sandbox's modules need: the Runtime sandbox and the
+ * one-time /home/user link. The environment given at create is Runtime's to
+ * keep: it is the sandbox's own `env`, added to every command there. */
 export interface SandboxContext {
     readonly runtime: RuntimeSandbox;
-    readonly envs: Record<string, string>;
+    readonly requestTimeoutMs?: number;
     /** Makes /home/user (E2B's home) lead to /workspace (Runtime's), once, when
      * something names it. */
-    ensureHome(text: string | undefined): Promise<void>;
+    ensureHome(text: string | undefined, options?: RequestOptions): Promise<void>;
 }
 /** E2B's pids are numbers; Runtime's process ids are strings. The number is a
  * 31-bit FNV-1a hash of the id, so every client derives the same one. */
 export declare function pidOf(processId: string): number;
+export declare function refuseUser(user: Username | undefined): void;
+export declare function timeoutFor(timeoutMs: number | undefined): number;
+/** One budget for lookup and mutation, including retries and queued input. */
+export declare function commandRequest(opts: CommandRequestOpts, defaultTimeoutMs?: number): RequestOptions;
+export declare function findProcess(ctx: SandboxContext, pid: number, options: RequestOptions): Promise<RuntimeProcessInfo | undefined>;
+export declare function resolveProcess(ctx: SandboxContext, pid: number, options: RequestOptions): Promise<Process>;
+export declare function killProcess(ctx: SandboxContext, pid: number, options: RequestOptions): Promise<boolean>;
+export declare function timedOut(timeoutMs: number): TimeoutError;
+/** The subscription deadline includes the opening handshake. */
+export declare function connectionRequest(opts: CommandConnectOpts, defaultTimeoutMs?: number): {
+    timeoutMs: number;
+    deadline: number | undefined;
+    request: RequestOptions;
+    failure: (error: unknown) => never;
+};
 /** `sandbox.commands`: E2B's command module over Runtime's exec and processes. */
 export declare class Commands {
     #private;
@@ -61,12 +79,12 @@ export declare class Commands {
         background?: boolean;
     }): Promise<CommandHandle | CommandResult>;
     /** Running commands. */
-    list(_opts?: CommandRequestOpts): Promise<ProcessInfo[]>;
+    list(opts?: CommandRequestOpts): Promise<ProcessInfo[]>;
     /** Kills a command with SIGKILL, as E2B does. False when there is none. */
-    kill(pid: number, _opts?: CommandRequestOpts): Promise<boolean>;
+    kill(pid: number, opts?: CommandRequestOpts): Promise<boolean>;
     /** Sends input to a command started with `stdin: true`. */
-    sendStdin(pid: number, data: string | Uint8Array, _opts?: CommandRequestOpts): Promise<void>;
-    closeStdin(pid: number, _opts?: CommandRequestOpts): Promise<void>;
+    sendStdin(pid: number, data: string | Uint8Array, opts?: CommandRequestOpts): Promise<void>;
+    closeStdin(pid: number, opts?: CommandRequestOpts): Promise<void>;
     /** Attaches to a running command; output from now on reaches the handle. */
     connect(pid: number, opts?: CommandConnectOpts): Promise<CommandHandle>;
 }
@@ -80,8 +98,13 @@ export declare class CommandHandle {
         stdin: boolean;
         timeoutMs: number;
         cursor?: number;
+        signal?: AbortSignal;
         onStdout?: (data: string) => void | Promise<void>;
         onStderr?: (data: string) => void | Promise<void>;
+        onData?: (data: Uint8Array) => void | Promise<void>;
+        pty?: boolean;
+        requestTimeoutMs?: number;
+        deadline?: number;
     });
     /** The exit code, or undefined while the command runs. */
     get exitCode(): number | undefined;
@@ -95,6 +118,6 @@ export declare class CommandHandle {
     disconnect(): Promise<void>;
     /** Kills the command with SIGKILL. False when it had already ended. */
     kill(): Promise<boolean>;
-    sendStdin(data: string | Uint8Array, _opts?: CommandRequestOpts): Promise<void>;
-    closeStdin(_opts?: CommandRequestOpts): Promise<void>;
+    sendStdin(data: string | Uint8Array, opts?: CommandRequestOpts): Promise<void>;
+    closeStdin(opts?: CommandRequestOpts): Promise<void>;
 }

package/dist/e2b/commands.js

@@ -1,7 +1,5 @@
-import { request } from "./client.js";
 import { CommandExitError, guard, InvalidArgumentError, NotSupportedError, SandboxError, TimeoutError, translate, } from "./errors.js";
 const DEFAULT_TIMEOUT_MS = 60_000;
-const LONGEST_MS = 86_400_000;
 /** E2B's pids are numbers; Runtime's process ids are strings. The number is a
  * 31-bit FNV-1a hash of the id, so every client derives the same one. */
 export function pidOf(processId) {
@@ -12,18 +10,57 @@ export function pidOf(processId) {
     }
     return hash >>> 1 || 1;
 }
-function refuseUser(user) {
+export function refuseUser(user) {
     if (user !== undefined && user !== "user")
         throw new NotSupportedError(`Running as the user "${user}"`, 'Runtime runs commands as its sandbox owner, with passwordless sudo: prefix the command with "sudo" to run it as root.');
 }
-function timeoutFor(timeoutMs) {
+export function timeoutFor(timeoutMs) {
     if (timeoutMs === undefined)
         return DEFAULT_TIMEOUT_MS;
-    if (timeoutMs === 0)
-        return LONGEST_MS;
-    return Math.min(timeoutMs, LONGEST_MS);
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0)
+        throw new InvalidArgumentError("timeoutMs must be a nonnegative whole number.");
+    return timeoutMs;
 }
-function timedOut(timeoutMs) {
+/** One budget for lookup and mutation, including retries and queued input. */
+export function commandRequest(opts, defaultTimeoutMs = 60_000) {
+    opts.signal?.throwIfAborted();
+    const timeoutMs = timeoutFor(opts.requestTimeoutMs ?? defaultTimeoutMs);
+    const deadline = timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : undefined;
+    const signal = opts.signal && deadline ? AbortSignal.any([opts.signal, deadline]) : (opts.signal ?? deadline);
+    return { timeoutMs: 0, ...(signal ? { signal } : {}) };
+}
+export async function findProcess(ctx, pid, options) {
+    options.signal?.throwIfAborted();
+    const processes = await guard("sandbox", () => ctx.runtime.processes.list(options));
+    options.signal?.throwIfAborted();
+    const matches = processes.filter((info) => pidOf(info.id) === pid && info.state === "running");
+    if (matches.length > 1)
+        throw new SandboxError(`More than one running command has pid ${pid}; use the native process id instead.`);
+    return matches[0];
+}
+export async function resolveProcess(ctx, pid, options) {
+    const info = await findProcess(ctx, pid, options);
+    if (!info)
+        throw new SandboxError(`No running command with pid ${pid}.`);
+    return guard("sandbox", () => ctx.runtime.processes.get(info.id, options));
+}
+export async function killProcess(ctx, pid, options) {
+    const info = await findProcess(ctx, pid, options);
+    if (!info)
+        return false;
+    try {
+        const process = await guard("sandbox", () => ctx.runtime.processes.get(info.id, options));
+        options.signal?.throwIfAborted();
+        await guard("sandbox", () => process.kill("SIGKILL", options));
+        return true;
+    }
+    catch (error) {
+        if (error instanceof SandboxError && error.statusCode === 404)
+            return false;
+        throw error;
+    }
+}
+export function timedOut(timeoutMs) {
     return new TimeoutError(`Command timed out after ${timeoutMs} ms: this error is likely due to exceeding 'timeoutMs'. ` +
         "Pass a larger 'timeoutMs', or 0 for no limit.");
 }
@@ -37,13 +74,32 @@ function toResult(result) {
         stdout: result.stdout,
         stderr: result.stderr,
         ...(exitCode === 0
-            ? {}
+            ? { error: "" }
             : {
                 error: result.exitCode === null ? "terminated by a signal" : `exit status ${exitCode}`,
             }),
         ...(result.truncated ? { truncated: true } : {}),
     };
 }
+/** The subscription deadline includes the opening handshake. */
+export function connectionRequest(opts, defaultTimeoutMs) {
+    const timeoutMs = timeoutFor(opts.timeoutMs);
+    const deadline = timeoutMs > 0 ? performance.now() + timeoutMs : undefined;
+    const connectionTimeout = timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : undefined;
+    const signal = connectionTimeout && opts.signal
+        ? AbortSignal.any([connectionTimeout, opts.signal])
+        : (connectionTimeout ?? opts.signal);
+    return {
+        timeoutMs,
+        deadline,
+        request: commandRequest({ ...opts, signal }, defaultTimeoutMs),
+        failure: (error) => {
+            if (connectionTimeout?.aborted)
+                throw timedOut(timeoutMs);
+            throw error;
+        },
+    };
+}
 function settle(result, timeoutMs) {
     if (result.timedOut)
         throw timedOut(timeoutMs);
@@ -61,88 +117,72 @@ export class Commands {
         this.#ctx = ctx;
     }
     #env(envs) {
-        const merged = { ...this.#ctx.envs, ...envs };
-        return Object.keys(merged).length ? { env: merged } : {};
+        return envs && Object.keys(envs).length ? { env: envs } : {};
     }
     async run(cmd, opts = {}) {
+        const opening = connectionRequest(opts, this.#ctx.requestTimeoutMs);
         refuseUser(opts.user);
-        await this.#ctx.ensureHome(`${cmd}\n${opts.cwd ?? ""}`);
-        const timeoutMs = timeoutFor(opts.timeoutMs);
-        if (opts.background || opts.stdin) {
-            const handle = await this.#start(cmd, opts, timeoutMs);
-            return opts.background ? handle : handle.wait();
-        }
-        /* Always streamed, so the result holds the whole output as E2B's does: an
-           exec with no output callback returns at most 64 KiB of each stream. */
-        const onStdout = opts.onStdout;
-        const onStderr = opts.onStderr;
-        const result = await guard("sandbox", () => this.#ctx.runtime.exec(cmd, {
-            ...(opts.cwd === undefined ? {} : { cwd: opts.cwd }),
-            ...this.#env(opts.envs),
-            timeoutMs,
-            onStdout: (text) => void onStdout?.(text),
-            ...(onStderr ? { onStderr: (text) => void onStderr(text) } : {}),
-            ...(opts.signal ? { signal: opts.signal } : {}),
-        }));
-        return settle({ ...result, truncated: result.stdoutTruncated === true || result.stderrTruncated === true }, timeoutMs);
+        const handle = await (async () => {
+            await this.#ctx.ensureHome(`${cmd}\n${opts.cwd ?? ""}`, opening.request);
+            opening.request.signal?.throwIfAborted();
+            return this.#start(cmd, opts, opening.timeoutMs, opening.request, opening.deadline);
+        })().catch(opening.failure);
+        return opts.background ? handle : handle.wait();
     }
-    async #start(cmd, opts, timeoutMs) {
+    async #start(cmd, opts, timeoutMs, request, deadline) {
+        request.signal?.throwIfAborted();
         const process = await guard("sandbox", () => this.#ctx.runtime.spawn(cmd, {
             ...(opts.cwd === undefined ? {} : { cwd: opts.cwd }),
             ...this.#env(opts.envs),
-            timeoutMs,
             ...(opts.stdin ? { stdin: "pipe" } : {}),
-            ...request(opts),
+            request,
         }));
         return new CommandHandle(process, {
             stdin: opts.stdin === true,
             timeoutMs,
+            deadline,
+            requestTimeoutMs: this.#ctx.requestTimeoutMs,
+            signal: opts.signal,
             ...(opts.onStdout ? { onStdout: opts.onStdout } : {}),
             ...(opts.onStderr ? { onStderr: opts.onStderr } : {}),
         });
     }
     /** Running commands. */
-    async list(_opts = {}) {
-        const processes = await guard("sandbox", () => this.#ctx.runtime.processes.list());
+    async list(opts = {}) {
+        const request = commandRequest(opts, this.#ctx.requestTimeoutMs);
+        const processes = await guard("sandbox", () => this.#ctx.runtime.processes.list(request));
         return processes.filter((info) => info.state === "running").map(describe);
     }
-    async #find(pid) {
-        const processes = await guard("sandbox", () => this.#ctx.runtime.processes.list());
-        return processes.find((info) => pidOf(info.id) === pid && info.state === "running");
-    }
-    async #process(pid) {
-        const info = await this.#find(pid);
-        if (!info)
-            throw new SandboxError(`No running command with pid ${pid}.`);
-        return guard("sandbox", () => this.#ctx.runtime.processes.get(info.id));
-    }
     /** Kills a command with SIGKILL, as E2B does. False when there is none. */
-    async kill(pid, _opts = {}) {
-        const info = await this.#find(pid);
-        if (!info)
-            return false;
-        const process = await guard("sandbox", () => this.#ctx.runtime.processes.get(info.id));
-        await guard("sandbox", () => process.kill("SIGKILL"));
-        return true;
+    async kill(pid, opts = {}) {
+        return killProcess(this.#ctx, pid, commandRequest(opts, this.#ctx.requestTimeoutMs));
     }
     /** Sends input to a command started with `stdin: true`. */
-    async sendStdin(pid, data, _opts = {}) {
-        const process = await this.#process(pid);
+    async sendStdin(pid, data, opts = {}) {
+        const request = commandRequest(opts, this.#ctx.requestTimeoutMs);
+        const process = await resolveProcess(this.#ctx, pid, request);
         if (!process.info.stdinOpen)
             throw new InvalidArgumentError(`The command with pid ${pid} was not started with stdin: true, so its input is closed.`);
-        await guard("sandbox", () => process.write(data));
+        request.signal?.throwIfAborted();
+        await guard("sandbox", () => process.write(data, request));
     }
-    async closeStdin(pid, _opts = {}) {
-        const process = await this.#process(pid);
-        await guard("sandbox", () => process.write("", { eof: true }));
+    async closeStdin(pid, opts = {}) {
+        const request = commandRequest(opts, this.#ctx.requestTimeoutMs);
+        const process = await resolveProcess(this.#ctx, pid, request);
+        request.signal?.throwIfAborted();
+        await guard("sandbox", () => process.write("", { ...request, eof: true }));
     }
     /** Attaches to a running command; output from now on reaches the handle. */
     async connect(pid, opts = {}) {
-        const process = await this.#process(pid);
+        const opening = connectionRequest(opts, this.#ctx.requestTimeoutMs);
+        const process = await resolveProcess(this.#ctx, pid, opening.request).catch(opening.failure);
         return new CommandHandle(process, {
             stdin: process.info.stdinOpen,
-            timeoutMs: timeoutFor(opts.timeoutMs),
+            timeoutMs: opening.timeoutMs,
+            deadline: opening.deadline,
+            signal: opts.signal,
             cursor: process.info.outputBytes,
+            requestTimeoutMs: this.#ctx.requestTimeoutMs,
             ...(opts.onStdout ? { onStdout: opts.onStdout } : {}),
             ...(opts.onStderr ? { onStderr: opts.onStderr } : {}),
         });
@@ -157,6 +197,28 @@ function describe(info) {
         cwd: info.cwd,
     };
 }
+/** Reader cancellation also releases a callback whose promise never settles. */
+async function deliver(signal, callback) {
+    signal.throwIfAborted();
+    let cancelled;
+    const aborted = new Promise((_, reject) => {
+        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- rejects with the caller's abort reason as is, as the upstream SDK does
+        cancelled = () => reject(signal.reason);
+        signal.addEventListener("abort", cancelled, { once: true });
+    });
+    try {
+        await Promise.race([
+            Promise.resolve().then(() => {
+                signal.throwIfAborted();
+                return callback();
+            }),
+            aborted,
+        ]);
+    }
+    finally {
+        signal.removeEventListener("abort", cancelled);
+    }
+}
 /** A command started in the background: E2B's CommandHandle over a Runtime
  * process. Output streams into `stdout`/`stderr` and the callbacks as it
  * arrives. */
@@ -165,6 +227,7 @@ export class CommandHandle {
     #process;
     #stdin;
     #timeoutMs;
+    #requestTimeoutMs;
     #abort = new AbortController();
     #done;
     #stdout = "";
@@ -173,26 +236,53 @@ export class CommandHandle {
     #truncated = false;
     #failure;
     #disconnected = false;
+    #deadline;
     constructor(process, options) {
         this.#process = process;
         this.pid = pidOf(process.id);
         this.#stdin = options.stdin;
         this.#timeoutMs = options.timeoutMs;
+        this.#requestTimeoutMs = options.requestTimeoutMs;
+        // E2B's timeout limits the subscription. It never asks us to kill the
+        // process: the sandbox lease still bounds the workload after disconnect.
+        if (options.timeoutMs > 0) {
+            this.#deadline = setTimeout(() => {
+                this.#failure = timedOut(options.timeoutMs);
+                this.#abort.abort();
+            }, options.deadline === undefined
+                ? options.timeoutMs
+                : Math.max(0, options.deadline - performance.now()));
+            this.#deadline.unref?.();
+        }
         this.#done = this.#follow(options);
     }
     async #follow(options) {
+        const signal = options.signal
+            ? AbortSignal.any([options.signal, this.#abort.signal])
+            : this.#abort.signal;
         try {
-            for await (const event of this.#process.output({
+            const outputOptions = {
                 ...(options.cursor ? { cursor: options.cursor } : {}),
-                signal: this.#abort.signal,
-            })) {
-                if (event.type === "stdout") {
+                signal,
+            };
+            const output = options.pty
+                ? this.#process.outputBytes(outputOptions)
+                : this.#process.output(outputOptions);
+            for await (const event of output) {
+                if (this.#disconnected)
+                    break;
+                signal.throwIfAborted();
+                if ((event.type === "stdout" || event.type === "stderr") &&
+                    event.data instanceof Uint8Array) {
+                    await deliver(signal, () => options.onData?.(event.data));
+                }
+                else if (event.type === "stdout" && typeof event.data === "string") {
                     this.#stdout += event.data;
-                    await options.onStdout?.(event.data);
+                    await deliver(signal, () => options.onStdout?.(event.data));
                 }
-                else if (event.type === "stderr") {
+                else if (event.type === "stderr" && typeof event.data === "string") {
                     this.#stderr += event.data;
-                    await options.onStderr?.(event.data);
+                    await deliver(signal, () => options.onStderr?.(event.data));
                 }
                 else if (event.type === "truncated") {
                     this.#truncated = true;
@@ -203,12 +293,16 @@ export class CommandHandle {
             }
         }
         catch (error) {
-            if (!this.#disconnected) {
+            if (!this.#disconnected && !this.#failure) {
                 const translated = translate(error, "sandbox");
                 this.#failure =
                     translated instanceof Error ? translated : new SandboxError(String(translated));
             }
         }
+        finally {
+            if (this.#deadline !== undefined)
+                clearTimeout(this.#deadline);
+        }
     }
     /** The exit code, or undefined while the command runs. */
     get exitCode() {
@@ -259,7 +353,7 @@ export class CommandHandle {
         if (this.#exit)
             return false;
         try {
-            await guard("sandbox", () => this.#process.kill("SIGKILL"));
+            await guard("sandbox", () => this.#process.kill("SIGKILL", commandRequest({}, this.#requestTimeoutMs)));
             return true;
         }
         catch (error) {
@@ -268,14 +362,16 @@ export class CommandHandle {
             throw error;
         }
     }
-    async sendStdin(data, _opts = {}) {
+    async sendStdin(data, opts = {}) {
+        const request = commandRequest(opts, this.#requestTimeoutMs);
         if (!this.#stdin)
             throw new InvalidArgumentError("The command was not started with stdin: true, so its input is closed.");
-        await guard("sandbox", () => this.#process.write(data));
+        await guard("sandbox", () => this.#process.write(data, request));
     }
-    async closeStdin(_opts = {}) {
+    async closeStdin(opts = {}) {
+        const request = commandRequest(opts, this.#requestTimeoutMs);
         if (!this.#stdin)
             throw new InvalidArgumentError("The command was not started with stdin: true.");
-        await guard("sandbox", () => this.#process.write("", { eof: true }));
+        await guard("sandbox", () => this.#process.write("", { ...request, eof: true }));
     }
 }

package/dist/e2b/errors.js

@@ -77,7 +77,7 @@ export class NotSupportedError extends SandboxError {
 export class CommandExitError extends SandboxError {
     #result;
     constructor(result) {
-        super(`Command exited with code ${result.exitCode} and error:\n${result.stderr}`);
+        super(result.error);
         this.#result = result;
     }
     get exitCode() {