withruntime 0.9.0 → 0.10.0

package/dist/daytona/filesystem.js

@@ -1,6 +1,43 @@
 import { resolvePath, WHOLE_OUTPUT } from "./context.js";
 import { DaytonaError, DaytonaFileNotFoundError, guard } from "./errors.js";
 const PERMISSIONS = ["---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"];
+function downloadRequest(timeout, signal) {
+    if (!Number.isFinite(timeout) || timeout < 0)
+        throw new DaytonaError("Download timeout must be a nonnegative finite number.");
+    signal?.throwIfAborted();
+    const deadline = timeout > 0 ? AbortSignal.timeout(Math.ceil(timeout * 1000)) : undefined;
+    return {
+        timeoutMs: 0,
+        ...(deadline || signal
+            ? {
+                signal: deadline && signal ? AbortSignal.any([deadline, signal]) : (deadline ?? signal),
+            }
+            : {}),
+    };
+}
+/** Wait on client-local setup within the transfer's existing deadline. The
+ * setup may finish later; the caller cannot proceed to an upload after abort. */
+function waitForRequest(pending, request) {
+    const signal = request.signal;
+    if (!signal)
+        return pending;
+    return new Promise((resolve, 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
+        const abort = () => reject(signal.reason);
+        if (signal.aborted)
+            abort();
+        else
+            signal.addEventListener("abort", abort, { once: true });
+        pending.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- passes the pending call's own failure through unchanged
+            reject(error);
+        });
+    });
+}
 function fileInfo(entry) {
     const bits = (parseInt(entry.mode, 8) || 0) & 0o777;
     const kind = entry.type === "directory" ? "d" : entry.type === "symlink" ? "l" : "-";
@@ -15,20 +52,6 @@ function fileInfo(entry) {
         group: "",
     };
 }
-async function bytesOf(source) {
-    if (typeof source === "string") {
-        const { readFile } = await import("node:fs/promises");
-        return readFile(source);
-    }
-    if (source instanceof Uint8Array)
-        return source;
-    if (typeof source.getReader === "function")
-        return new Uint8Array(await new Response(source).arrayBuffer());
-    const chunks = [];
-    for await (const chunk of source)
-        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
-    return Buffer.concat(chunks);
-}
 /** `sandbox.fs`: Daytona's file calls over Runtime's files API. Relative
  * paths resolve from the working directory, /workspace on Runtime. */
 export class FileSystem {
@@ -66,36 +89,56 @@ export class FileSystem {
         if (!removed)
             throw new DaytonaFileNotFoundError(`${target} does not exist.`, 404);
     }
-    async downloadFile(remotePath, localOrTimeout) {
+    async downloadFile(remotePath, localOrTimeout, timeout = 30 * 60) {
+        // The numeric second argument is the published buffer overload. In that
+        // overload zero falls back to the default, as the pinned SDK does.
+        const request = downloadRequest(typeof localOrTimeout === "number" && localOrTimeout !== 0 ? localOrTimeout : timeout);
+        return this.#downloadFile(remotePath, typeof localOrTimeout === "string" ? localOrTimeout : undefined, request);
+    }
+    async #downloadFile(remotePath, localPath, request) {
+        request.signal?.throwIfAborted();
         const target = await this.#path(remotePath);
         const files = await this.#files();
-        if (typeof localOrTimeout !== "string")
-            return Buffer.from(await guard("file", () => files.read(target)));
+        request.signal?.throwIfAborted();
+        if (localPath === undefined)
+            return Buffer.from(await guard("file", () => files.read(target, request)));
         // Streamed to disk, any size, checked against the file's length.
-        await guard("file", () => files.download(target, localOrTimeout));
+        await guard("file", () => files.download(target, localPath, request));
     }
     /** The file as it arrives, without holding it in memory. It errors with
      * `download_incomplete` if it ends short of the file's length. */
-    async downloadFileStream(remotePath) {
+    async downloadFileStream(remotePath, timeoutOrOptions) {
+        const options = typeof timeoutOrOptions === "number"
+            ? { timeout: timeoutOrOptions }
+            : (timeoutOrOptions ?? {});
+        const request = downloadRequest(options.timeout ?? 30 * 60, options.signal);
         const { Readable } = await import("node:stream");
         const target = await this.#path(remotePath);
         const files = await this.#files();
-        const stream = await guard("file", () => files.readStream(target));
+        request.signal?.throwIfAborted();
+        const stream = await guard("file", () => files.readStream(target, request));
         return Readable.fromWeb(stream);
     }
     /** Several files; a file that fails carries `error` instead of `result`. */
-    async downloadFiles(files) {
+    async downloadFiles(files, timeout = 30 * 60) {
+        const request = downloadRequest(timeout);
         const out = [];
         for (const file of files) {
+            request.signal?.throwIfAborted();
             try {
                 if (file.destination) {
-                    await this.downloadFile(file.source, file.destination);
+                    await this.#downloadFile(file.source, file.destination, request);
                     out.push({ source: file.source, result: file.destination });
                 }
                 else
-                    out.push({ source: file.source, result: await this.downloadFile(file.source) });
+                    out.push({
+                        source: file.source,
+                        result: (await this.#downloadFile(file.source, undefined, request)),
+                    });
             }
             catch (error) {
+                if (request.signal?.aborted)
+                    throw error;
                 const failure = error;
                 out.push({
                     source: file.source,
@@ -185,24 +228,64 @@ export class FileSystem {
                 target,
             ]);
     }
-    async uploadFile(source, remotePath) {
-        const target = await this.#path(remotePath);
-        const bytes = await bytesOf(source);
-        const files = await this.#files();
-        await guard("file", () => files.write(target, bytes));
+    async uploadFile(source, remotePath, timeout = 30 * 60) {
+        await this.#uploadFile(source, remotePath, downloadRequest(timeout));
     }
-    async uploadFileStream(source, remotePath) {
-        const target = await this.#path(remotePath);
-        const bytes = await bytesOf(source);
-        const files = await this.#files();
-        await guard("file", () => files.write(target, bytes));
+    async #uploadFile(source, remotePath, request, onProgress) {
+        request.signal?.throwIfAborted();
+        const readable = typeof source !== "string" && typeof source.destroy === "function"
+            ? source
+            : undefined;
+        const stopInput = () => {
+            readable?.destroy();
+        };
+        request.signal?.addEventListener("abort", stopInput, { once: true });
+        try {
+            const target = await waitForRequest(this.#path(remotePath), request);
+            request.signal?.throwIfAborted();
+            const files = await waitForRequest(this.#files(), request);
+            request.signal?.throwIfAborted();
+            // Node Readables can emit strings after setEncoding; Daytona uploads
+            // their UTF-8 bytes. The generator retains only the current source chunk.
+            const input = typeof source === "string" ||
+                source instanceof Uint8Array ||
+                typeof source.getReader === "function"
+                ? source
+                : (async function* () {
+                    for await (const chunk of source)
+                        yield typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+                })();
+            await guard("file", () => input instanceof Uint8Array && !onProgress
+                ? files.write(target, input, request)
+                : files.writeStream(target, input, {
+                    ...request,
+                    ...(onProgress ? { onProgress } : {}),
+                }));
+        }
+        finally {
+            request.signal?.removeEventListener("abort", stopInput);
+        }
+    }
+    /** Uploads with bounded memory. Unknown-length streams stage in a private
+     * temporary file before the native atomic upload; local paths avoid staging. */
+    async uploadFileStream(source, remotePath, options = {}) {
+        const cancelled = () => new DaytonaError(`Upload cancelled: ${remotePath}`);
+        if (options.signal?.aborted)
+            throw cancelled();
+        const request = downloadRequest(options.timeout ?? 30 * 60, options.signal);
+        try {
+            await this.#uploadFile(source, remotePath, request, options.onProgress);
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw cancelled();
+            throw error;
+        }
     }
-    async uploadFiles(files) {
+    async uploadFiles(files, timeout = 30 * 60) {
+        const request = downloadRequest(timeout);
         for (const file of files) {
-            const target = await this.#path(file.destination);
-            const bytes = await bytesOf(file.source);
-            const api = await this.#files();
-            await guard("file", () => api.write(target, bytes));
+            await this.#uploadFile(file.source, file.destination, request);
         }
     }
 }

package/dist/daytona/index.d.ts

@@ -1,7 +1,7 @@
 export { Daytona, CodeLanguage, SnapshotService, VolumeService, DEFAULT_RESOURCES, DEFAULT_AUTO_STOP_MINUTES, lifecycleOf, type CreateSandboxBaseParams, type CreateSandboxFromImageParams, type CreateSandboxFromSnapshotParams, type CreateSnapshotParams, type ForkSandboxParams, type ListSandboxesQuery, type PaginatedSnapshots, type Resources, type Snapshot, type Volume, type VolumeMount, } from "./daytona.js";
 export { Sandbox, CodeInterpreter, networkRules, windowSeconds, type ExecutionError, type ExecutionResult, type InterpreterContext, type OutputMessage, type PortPreviewUrl, } from "./sandbox.js";
 export { Process, CodeRunParams, type Command, type ExecuteResponse, type Session, type SessionCommandLogsResponse, type SessionExecuteRequest, type SessionExecuteResponse, } from "./process.js";
-export { FileSystem, type FileDownloadRequest, type FileDownloadResponse, type FileInfo, type FilePermissionsParams, type FileUpload, type Match, type ReplaceResult, type SearchFilesResponse, type UploadSource, } from "./filesystem.js";
+export { FileSystem, type FileDownloadRequest, type FileDownloadResponse, type FileInfo, type FilePermissionsParams, type FileUpload, type Match, type ReplaceResult, type SearchFilesResponse, type UploadSource, type UploadProgress, type UploadStreamOptions, } from "./filesystem.js";
 export { Git, type GitStatus, type ListBranchResponse } from "./git.js";
 export { Image } from "./image.js";
 export { resolvePath } from "./context.js";

package/dist/daytona/sandbox.d.ts

@@ -162,7 +162,7 @@ export declare class Sandbox {
     createSnapshot(name: string, _timeout?: number): Promise<void>;
     _experimental_createSnapshot(name: string, timeout?: number): Promise<void>;
     get computerUse(): never;
-    setLabels(): Promise<never>;
+    setLabels(labels: Record<string, string>): Promise<Record<string, string>>;
     recover(): Promise<never>;
     resize(): Promise<never>;
     waitForResizeComplete(): Promise<never>;

package/dist/daytona/sandbox.js

@@ -22,11 +22,18 @@ export class CodeInterpreter {
         const env = this.#env();
         if (!Object.keys(env).length)
             return "python";
-        this.#envContext ??= (async () => {
-            const runtime = await this.#sandbox();
-            const made = await guard("sandbox", () => runtime.interpreter.contexts.create({ language: "python", cwd: HOME, env }));
-            return made.id;
-        })();
+        if (!this.#envContext) {
+            const pending = (async () => {
+                const runtime = await this.#sandbox();
+                const made = await guard("sandbox", () => runtime.interpreter.contexts.create({ language: "python", cwd: HOME, env }));
+                return made.id;
+            })();
+            this.#envContext = pending;
+            pending.catch(() => {
+                if (this.#envContext === pending)
+                    this.#envContext = undefined;
+            });
+        }
         return this.#envContext;
     }
     async runCode(code, options = {}) {
@@ -373,8 +380,10 @@ export class Sandbox {
     get computerUse() {
         throw new NotSupportedError("Daytona's computer use", "Use Runtime's desktop: `await sandbox.withruntime.desktop.start()` (see the desktop guide).");
     }
-    setLabels() {
-        return refusal("Changing a sandbox's labels", "Runtime sets labels once, at create: pass labels to daytona.create.");
+    async setLabels(labels) {
+        const internal = Object.fromEntries(Object.entries(this.#rt.info.labels).filter(([key]) => key === "code-toolbox-language" || key.startsWith("compat.")));
+        await guard("sandbox", () => this.#rt.update({ labels: { ...labels, ...internal } }));
+        return this.labels;
     }
     recover() {
         return refusal("Recovering a failed sandbox", "Create a new sandbox, or start one from a snapshot.");

package/dist/e2b/client.js

@@ -60,7 +60,7 @@ export function resetClients() {
 /** Request options for a Runtime call from E2B's. */
 export function request(opts = {}) {
     return {
-        ...(opts.requestTimeoutMs ? { timeoutMs: opts.requestTimeoutMs } : {}),
+        ...(opts.requestTimeoutMs === undefined ? {} : { timeoutMs: opts.requestTimeoutMs }),
         ...(opts.signal ? { signal: opts.signal } : {}),
     };
 }

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 {
@@ -37,13 +39,29 @@ export interface ProcessInfo {
  * keep: it is the sandbox's own `env`, added to every command there. */
 export interface SandboxContext {
     readonly runtime: RuntimeSandbox;
+    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>;
 }
@@ -83,6 +101,10 @@ export declare class CommandHandle {
         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;
@@ -96,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>;
 }