withruntime 0.8.4 → 0.10.0

package/dist/credentials.js

@@ -12,6 +12,14 @@ export function connectionOrigins(env) {
         auth: apiOrigin(env.RUNTIME_AUTH_URL ?? "https://withruntime.com"),
     };
 }
+/** Browser-issued production credentials must only reach the production API.
+ * CLI and MCP share this boundary, including resumed device requests. */
+export function checkBrowserOrigins(origins) {
+    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.");
+}
 function defaultDirectory(env) {
     const root = env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
     if (!isAbsolute(root))
@@ -93,8 +101,75 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
                     throw error;
             });
     }
+    const lockFile = join(directory, `${name}.lock`);
+    /** ARCHITECTURE.md section 3.9: concurrent CLI processes keep each account's
+     * connection. Serialize the entire read/modify/write, not only each rename.
+     * Never steal a lock: stale cleanup can otherwise delete a new live lock. */
+    async function updateAccounts(update) {
+        await privateDirectory(true);
+        const until = performance.now() + 10_000;
+        let handle;
+        for (;;) {
+            try {
+                handle = await open(lockFile, "wx", 0o600);
+                break;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+            }
+            const text = await readPrivate(lockFile, 1024, "credential update lock");
+            let pid;
+            try {
+                pid = JSON.parse(text ?? "null")?.pid;
+            }
+            catch {
+                // The holder may not have finished writing its process id yet.
+            }
+            if (typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0) {
+                try {
+                    process.kill(pid, 0);
+                }
+                catch (error) {
+                    if (error.code === "ESRCH")
+                        throw new Error(`A previous Runtime credential update was interrupted. Remove ${lockFile} and retry.`);
+                }
+            }
+            if (performance.now() >= until)
+                throw new Error(`Another Runtime command is updating saved accounts. Retry when it finishes. If no command is running, remove ${lockFile} and retry.`);
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+        try {
+            await handle.writeFile(JSON.stringify({ pid: process.pid }));
+            return await update();
+        }
+        finally {
+            try {
+                await handle.close();
+            }
+            finally {
+                await unlink(lockFile);
+            }
+        }
+    }
     const pendingFile = join(directory, `${name}.pending.json`);
     const accountsFile = join(directory, `${name}.accounts.json`);
+    /** Active and archived connections must satisfy the same contract: switching
+     * accounts cannot publish a credential the next command refuses to read. */
+    function validConnection(value) {
+        if (value === null || typeof value !== "object")
+            return false;
+        const saved = value;
+        return (saved.version === 1 &&
+            saved.apiOrigin === origins.api &&
+            saved.authOrigin === origins.auth &&
+            typeof saved.key === "string" &&
+            /^rtcloud_[a-f0-9-]{36}_[A-Za-z0-9_-]{43}$/.test(saved.key) &&
+            typeof saved.connectionId === "string" &&
+            typeof saved.orgId === "string" &&
+            typeof saved.agentName === "string" &&
+            (saved.orgName === undefined || typeof saved.orgName === "string"));
+    }
     return {
         async read() {
             const text = await readPrivate(file, 4096, "saved connection");
@@ -107,15 +182,7 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
             catch {
                 throw new Error("Runtime's saved connection is invalid. Connect again.");
             }
-            if (saved.version !== 1 ||
-                saved.apiOrigin !== origins.api ||
-                saved.authOrigin !== origins.auth ||
-                typeof saved.key !== "string" ||
-                !/^rtcloud_[a-f0-9-]{36}_[A-Za-z0-9_-]{43}$/.test(saved.key) ||
-                typeof saved.connectionId !== "string" ||
-                typeof saved.orgId !== "string" ||
-                typeof saved.agentName !== "string" ||
-                (saved.orgName !== undefined && typeof saved.orgName !== "string"))
+            if (!validConnection(saved))
                 throw new Error("Runtime's saved connection is invalid. Connect again.");
             return saved;
         },
@@ -125,12 +192,14 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
         async save(connection) {
             if (connection.apiOrigin !== origins.api || connection.authOrigin !== origins.auth)
                 throw new Error("Connection origins do not match.");
-            const previous = await this.read().catch(() => null);
-            if (previous && previous.orgId !== connection.orgId) {
-                const others = (await this.others()).filter((one) => one.orgId !== previous.orgId && one.orgId !== connection.orgId);
-                await writePrivate(accountsFile, JSON.stringify([previous, ...others].slice(0, SAVED_ACCOUNTS)));
-            }
-            await writePrivate(file, JSON.stringify(connection));
+            return updateAccounts(async () => {
+                const previous = await this.read().catch(() => null);
+                if (previous && previous.orgId !== connection.orgId) {
+                    const others = (await this.others()).filter((one) => one.orgId !== previous.orgId && one.orgId !== connection.orgId);
+                    await writePrivate(accountsFile, JSON.stringify([previous, ...others].slice(0, SAVED_ACCOUNTS)));
+                }
+                await writePrivate(file, JSON.stringify(connection));
+            });
         },
         /** The other accounts this machine has connected, newest first. */
         async others() {
@@ -145,15 +214,7 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
                 return [];
             try {
                 const list = JSON.parse(text);
-                return Array.isArray(list)
-                    ? list.filter((one) => one &&
-                        one.version === 1 &&
-                        one.apiOrigin === origins.api &&
-                        one.authOrigin === origins.auth &&
-                        typeof one.key === "string" &&
-                        /^rtcloud_[a-f0-9-]{36}_[A-Za-z0-9_-]{43}$/.test(one.key) &&
-                        typeof one.orgId === "string")
-                    : [];
+                return Array.isArray(list) ? list.filter(validConnection) : [];
             }
             catch {
                 return [];
@@ -162,21 +223,29 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
         /** Use another saved account's connection, by account id or name. The one
          * in use moves to the saved accounts. Null when none matches. */
         async use(which) {
-            const others = await this.others();
-            const wanted = which.trim().toLowerCase();
-            const chosen = others.find((one) => one.orgId === which) ??
-                others.find((one) => one.orgName?.toLowerCase() === wanted) ??
-                null;
-            if (!chosen)
-                return null;
-            const current = await this.read().catch(() => null);
-            const rest = others.filter((one) => one.orgId !== chosen.orgId);
-            await writePrivate(accountsFile, JSON.stringify((current ? [current, ...rest] : rest).slice(0, SAVED_ACCOUNTS)));
-            await writePrivate(file, JSON.stringify(chosen));
-            return chosen;
+            return updateAccounts(async () => {
+                const others = await this.others();
+                const wanted = which.trim().toLowerCase();
+                const chosen = others.find((one) => one.orgId === which) ??
+                    others.find((one) => one.orgName?.toLowerCase() === wanted) ??
+                    null;
+                if (!chosen)
+                    return null;
+                const current = await this.read().catch(() => null);
+                const rest = others.filter((one) => one.orgId !== chosen.orgId);
+                await writePrivate(accountsFile, JSON.stringify((current ? [current, ...rest] : rest).slice(0, SAVED_ACCOUNTS)));
+                await writePrivate(file, JSON.stringify(chosen));
+                return chosen;
+            });
         },
-        async remove() {
-            await removePrivate(file);
+        /** Forget the expected credential after a remote revoke or refusal. A
+         * concurrent login may have saved another connection during that request. */
+        async remove(expectedKey) {
+            await updateAccounts(async () => {
+                if (expectedKey !== undefined && (await this.read())?.key !== expectedKey)
+                    return;
+                await removePrivate(file);
+            });
         },
         /** A browser approval that was started and not yet answered, so a command
          * that was stopped while it waited picks up the same link and code rather

package/dist/daytona/context.js

@@ -17,7 +17,8 @@ export function resolvePath(path) {
         return `${HOME}/${path.slice(2)}`;
     if (path.startsWith("/"))
         return path;
-    return `${HOME}/${path.replace(/^\.\/?/, "")}`.replace(/\/+$/, "") || HOME;
+    // Only "." components are dropped: ".env" and "..x" keep their dots.
+    return `${HOME}/${path.replace(/^(?:\.(?:\/+|$))+/, "")}`.replace(/\/+$/, "") || HOME;
 }
 /** Quotes a word for bash. */
 export function quote(word) {

package/dist/daytona/daytona.js

@@ -105,6 +105,8 @@ export class SnapshotService {
     /** Builds a Runtime image named `name` from a registry image or a Daytona
      * Image, streaming the build log to `onLogs`. */
     async create(params, options = {}) {
+        if (params.regionId)
+            throw new NotSupportedError("Choosing a snapshot region (regionId)", "Omit regionId: Runtime places image builds on its available hosts.");
         if (params.resources)
             throw new NotSupportedError("Resources on a snapshot", "Pass resources when creating each sandbox from it: daytona.create({ snapshot, resources }).");
         if (params.entrypoint)
@@ -183,8 +185,6 @@ export class Daytona {
         const client = params.withruntime?.client ?? this.#client;
         const lifecycle = lifecycleOf(params);
         const resources = { ...DEFAULT_RESOURCES, ...params.resources };
-        if (resources.gpu)
-            throw new NotSupportedError("GPUs", "Runtime runs sandboxes on CPUs; remove gpu from resources.");
         const source = await this.#source(client, params, options.onSnapshotCreateLogs);
         const volumes = await this.#volumes(client, params.volumes);
         const network = networkRules(params);
@@ -267,8 +267,6 @@ export class Daytona {
     async #volumes(client, mounts) {
         const out = [];
         for (const mount of mounts ?? []) {
-            if (mount.subpath)
-                throw new NotSupportedError("Mounting part of a volume (subpath)", "Mount the whole volume.");
             let id = mount.volumeId;
             if (!UUID.test(id)) {
                 const found = (await guard("other", () => client.volumes.list({ name: id, limit: 1 })))
@@ -363,6 +361,15 @@ export class Daytona {
     }
 }
 function refuseCreate(params) {
+    const gpuType = params.resources?.gpuType;
+    if (params.resources?.gpu ||
+        (gpuType !== undefined &&
+            gpuType !== null &&
+            gpuType !== "" &&
+            (!Array.isArray(gpuType) || gpuType.length > 0)))
+        throw new NotSupportedError("GPUs", "Runtime runs sandboxes on CPUs; remove gpu and gpuType from resources.");
+    if (params.volumes?.some((mount) => mount.subpath))
+        throw new NotSupportedError("Mounting part of a volume (subpath)", "Mount the whole volume.");
     const refusals = [
         ["spot", "Spot GPU sandboxes (spot)", "Remove it: Runtime runs sandboxes on CPUs."],
         [

package/dist/daytona/filesystem.d.ts

@@ -49,6 +49,14 @@ export interface FileDownloadResponse {
     };
 }
 export type UploadSource = Buffer | Uint8Array | string | Readable | ReadableStream<Uint8Array>;
+export type UploadProgress = {
+    bytesSent: number;
+};
+export type UploadStreamOptions = {
+    signal?: AbortSignal;
+    timeout?: number;
+    onProgress?: (progress: UploadProgress) => void;
+};
 /** `sandbox.fs`: Daytona's file calls over Runtime's files API. Relative
  * paths resolve from the working directory, /workspace on Runtime. */
 export declare class FileSystem {
@@ -62,9 +70,12 @@ export declare class FileSystem {
     downloadFile(remotePath: string, localPath: string, timeout?: number): Promise<void>;
     /** The file as it arrives, without holding it in memory. It errors with
      * `download_incomplete` if it ends short of the file's length. */
-    downloadFileStream(remotePath: string): Promise<Readable>;
+    downloadFileStream(remotePath: string, timeoutOrOptions?: number | {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<Readable>;
     /** Several files; a file that fails carries `error` instead of `result`. */
-    downloadFiles(files: FileDownloadRequest[]): Promise<FileDownloadResponse[]>;
+    downloadFiles(files: FileDownloadRequest[], timeout?: number): Promise<FileDownloadResponse[]>;
     /** Lines matching `pattern` (a grep pattern) in files under `path`. */
     findFiles(path: string, pattern: string): Promise<Match[]>;
     getFileDetails(path: string): Promise<FileInfo>;
@@ -81,6 +92,8 @@ export declare class FileSystem {
      * directories and replacing one that exists. */
     uploadFile(file: Buffer, remotePath: string, timeout?: number): Promise<void>;
     uploadFile(localPath: string, remotePath: string, timeout?: number): Promise<void>;
-    uploadFileStream(source: UploadSource, remotePath: string): Promise<void>;
-    uploadFiles(files: FileUpload[]): Promise<void>;
+    /** Uploads with bounded memory. Unknown-length streams stage in a private
+     * temporary file before the native atomic upload; local paths avoid staging. */
+    uploadFileStream(source: UploadSource, remotePath: string, options?: UploadStreamOptions): Promise<void>;
+    uploadFiles(files: FileUpload[], timeout?: number): Promise<void>;
 }

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/process.d.ts

@@ -63,7 +63,7 @@ export declare class Process {
     getSessionCommand(sessionId: string, commandId: string): Promise<Command>;
     /** Runs a command in the session. It waits and returns the output and exit
      * code, or with `runAsync: true` returns the cmdId at once. */
-    executeSessionCommand(sessionId: string, req: SessionExecuteRequest, _timeout?: number): Promise<SessionExecuteResponse>;
+    executeSessionCommand(sessionId: string, req: SessionExecuteRequest, timeout?: number): Promise<SessionExecuteResponse>;
     /** A command's output so far, or with callbacks, its output from the start
      * as it happens until it ends. */
     getSessionCommandLogs(sessionId: string, commandId: string): Promise<SessionCommandLogsResponse>;

package/dist/daytona/process.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { HOME, LONGEST_MS, quote, resolvePath, WHOLE_OUTPUT, } from "./context.js";
-import { DaytonaCommandAlreadyCompletedError, DaytonaConflictError, DaytonaNotFoundError, DaytonaProcessExecutionTimeoutError, DaytonaSessionEndedError, guard, NotSupportedError, } from "./errors.js";
+import { DaytonaCommandAlreadyCompletedError, DaytonaConflictError, DaytonaConnectionError, DaytonaNotFoundError, DaytonaProcessExecutionTimeoutError, DaytonaSessionEndedError, guard, NotSupportedError, } from "./errors.js";
 export class CodeRunParams {
     argv;
     env;
@@ -11,7 +11,7 @@ const MARK = "\x1e";
    The command travels base64-encoded and runs through eval, keeping the
    shell's directory, variables and functions from one command to the next;
    the markers say where its output ends and what it exited with. */
-const PRELUDE = '__rt_run() { eval "$(printf %s "$1" | base64 -d)"; __rt_c=$?; ' +
+const PRELUDE = '__rt_eval() { eval "$(printf %s "$1" | base64 -d)"; }; __rt_run() { __rt_eval "$1"; __rt_c=$?; ' +
     'printf \'\\036RT%s:%s\\036\' "$2" "$__rt_c"; printf \'\\036RT%s\\036\' "$2" >&2; return $__rt_c; }\n';
 const TAG = "daytona-session:";
 class SessionCommand {
@@ -78,6 +78,8 @@ export class Process {
             timeoutMs,
             ...WHOLE_OUTPUT,
         }));
+        if (result.stdoutTruncated || result.stderrTruncated)
+            throw new DaytonaConnectionError("Some command output is no longer available.", 502, undefined, "output_truncated");
         if (result.timedOut)
             throw new DaytonaProcessExecutionTimeoutError(`Command timed out after ${timeout} s. Pass a larger timeout, or 0 for none.`, 408);
         const output = result.stdout + result.stderr;
@@ -100,6 +102,8 @@ export class Process {
             timeoutMs,
             ...WHOLE_OUTPUT,
         }));
+        if (result.stdoutTruncated || result.stderrTruncated)
+            throw new DaytonaConnectionError("Some command output is no longer available.", 502, undefined, "output_truncated");
         if (result.timedOut)
             throw new DaytonaProcessExecutionTimeoutError(`Code run timed out after ${timeout} s.`, 408);
         return {
@@ -162,7 +166,7 @@ export class Process {
     }
     /** Runs a command in the session. It waits and returns the output and exit
      * code, or with `runAsync: true` returns the cmdId at once. */
-    async executeSessionCommand(sessionId, req, _timeout) {
+    async executeSessionCommand(sessionId, req, timeout) {
         const session = await this.#session(sessionId);
         await this.#ctx.ensureHome(req.command);
         await this.#ctx.live();
@@ -192,7 +196,22 @@ export class Process {
             command.done.catch(() => undefined);
             return { cmdId: command.id };
         }
-        await command.done;
+        if (timeout && timeout > 0) {
+            let timer;
+            try {
+                await Promise.race([
+                    command.done,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => reject(new DaytonaProcessExecutionTimeoutError(`Waiting for session command timed out after ${timeout} s. The command continues in the session.`, 408)), timeout * 1000);
+                    }),
+                ]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        else
+            await command.done;
         return {
             cmdId: command.id,
             output: command.output,
@@ -216,6 +235,10 @@ export class Process {
         };
         await guard("process", async () => {
             for await (const event of session.process.output({ cursor: session.cursor })) {
+                if (event.type === "truncated") {
+                    session.ended = true;
+                    throw new DaytonaConnectionError("Session command output was lost.", 502, undefined, "output_truncated");
+                }
                 if (event.type === "exit") {
                     session.ended = true;
                     flush("stdout", buffer.stdout.length);

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 } : {}),
     };
 }