withruntime 0.9.0 → 0.11.0

package/dist/daytona/context.d.ts

@@ -11,6 +11,8 @@ export interface SandboxContext {
     /** Makes /home/daytona (Daytona's home) lead to /workspace (Runtime's),
      * once, the first time something names it. */
     ensureHome(text: string | undefined): Promise<void>;
+    /** The Linux user commands run as (create's `user`), when not the owner. */
+    readonly user?: string;
 }
 /** Daytona's home, and the working directory relative paths resolve from. */
 export declare const DAYTONA_HOME = "/home/daytona";
@@ -29,3 +31,11 @@ export declare const WHOLE_OUTPUT: {
 export declare function resolvePath(path: string): string;
 /** Quotes a word for bash. */
 export declare function quote(word: string): string;
+/** A command and its environment as Runtime runs them: as given for the
+ * sandbox owner; for another user through sudo, its environment carried on
+ * the command line (sudo resets it) and umask 002, so files it makes in the
+ * shared working directory stay writable by the owner's group. */
+export declare function runAs(user: string | undefined, argv: readonly string[], env?: Record<string, string>): {
+    argv: string[];
+    env?: Record<string, string>;
+};

package/dist/daytona/context.js

@@ -24,3 +24,27 @@ export function resolvePath(path) {
 export function quote(word) {
     return `'${word.replace(/'/g, `'\\''`)}'`;
 }
+/** A command and its environment as Runtime runs them: as given for the
+ * sandbox owner; for another user through sudo, its environment carried on
+ * the command line (sudo resets it) and umask 002, so files it makes in the
+ * shared working directory stay writable by the owner's group. */
+export function runAs(user, argv, env = {}) {
+    if (!user)
+        return { argv: [...argv], ...(Object.keys(env).length ? { env } : {}) };
+    return {
+        argv: [
+            "sudo",
+            "-u",
+            user,
+            "-H",
+            "--",
+            "env",
+            ...Object.entries(env).map(([name, value]) => `${name}=${value}`),
+            "sh",
+            "-c",
+            'umask 002; exec "$@"',
+            "sh",
+            ...argv,
+        ],
+    };
+}

package/dist/daytona/daytona.d.ts

@@ -13,6 +13,8 @@ export declare const DEFAULT_RESOURCES: {
 export declare const DEFAULT_AUTO_STOP_MINUTES = 15;
 /** Daytona's label for a sandbox's code language. */
 export declare const LANGUAGE_LABEL = "code-toolbox-language";
+/** The Linux user given at create, so get() and list() run as it too. */
+export declare const USER_LABEL = "compat.daytona-user";
 export declare enum CodeLanguage {
     PYTHON = "python",
     TYPESCRIPT = "typescript",
@@ -69,10 +71,28 @@ export type ForkSandboxParams = {
     name?: string;
 };
 export interface ListSandboxesQuery {
+    /** Daytona's page size; every sandbox is still listed. */
     limit?: number;
+    sort?: "name" | "cpu" | "memoryGib" | "diskGib" | "lastActivityAt" | "createdAt";
+    order?: "asc" | "desc";
+    /** An id prefix, any case. */
+    id?: string;
+    /** A name prefix, any case. */
     name?: string;
     labels?: Record<string, string>;
     states?: SandboxState[];
+    targets?: string[];
+    minCpu?: number;
+    maxCpu?: number;
+    minMemoryGib?: number;
+    maxMemoryGib?: number;
+    minDiskGib?: number;
+    maxDiskGib?: number;
+    isRecoverable?: boolean;
+    createdAtAfter?: Date;
+    createdAtBefore?: Date;
+    lastActivityAfter?: Date;
+    lastActivityBefore?: Date;
     [other: string]: unknown;
 }
 /** A Daytona snapshot: on Runtime, an image (or a snapshot made with

package/dist/daytona/daytona.js

@@ -1,6 +1,6 @@
 import { clientFor, } from "./client.js";
 import { DaytonaError, DaytonaNotFoundError, guard, NotSupportedError } from "./errors.js";
-import { networkRules, notFound, retentionDays, Sandbox, windowSeconds, } from "./sandbox.js";
+import { idleSeconds, networkRules, notFound, retentionDays, Sandbox, windowSeconds, } from "./sandbox.js";
 /* Daytona's client over Runtime's. `new Daytona()` then `daytona.create()`
    makes a Runtime sandbox with Daytona's defaults. */
 /** Daytona's default machine: 1 vCPU, 1 GiB memory, 3 GiB disk (checked
@@ -14,6 +14,10 @@ const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const STOCK_SNAPSHOT = /^daytona(io)?[-/:]|^daytona$/;
 /** Daytona's label for a sandbox's code language. */
 export const LANGUAGE_LABEL = "code-toolbox-language";
+/** The Linux user given at create, so get() and list() run as it too. */
+export const USER_LABEL = "compat.daytona-user";
+/** The sandbox owner's names: Daytona's and Runtime's. */
+const OWNER = new Set(["daytona", "runtime"]);
 export var CodeLanguage;
 (function (CodeLanguage) {
     CodeLanguage["PYTHON"] = "python";
@@ -105,6 +109,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,18 +189,20 @@ 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);
         // Daytona keeps the language in this label, so a sandbox found later with
         // get() or list() runs codeRun in the language it was made for.
-        const labels = params.language && params.language !== "python"
-            ? { ...params.labels, [LANGUAGE_LABEL]: params.language }
-            : params.labels && Object.keys(params.labels).length
-                ? params.labels
-                : undefined;
+        const user = params.user !== undefined && !OWNER.has(params.user) ? params.user : undefined;
+        const tagged = {
+            ...params.labels,
+            ...(params.language && params.language !== "python"
+                ? { [LANGUAGE_LABEL]: params.language }
+                : {}),
+            ...(user ? { [USER_LABEL]: user } : {}),
+        };
+        const labels = Object.keys(tagged).length ? tagged : undefined;
         const input = {
             ...(source.snapshot
                 ? {}
@@ -216,6 +224,8 @@ export class Daytona {
             ...params.withruntime?.create,
         };
         const runtime = await guard("sandbox", () => client.sandboxes.create(input));
+        if (user)
+            await asUser(runtime, user);
         if (lifecycle.autoDeleteInterval > 0)
             await guard("sandbox", () => runtime.setRetention(retentionDays(lifecycle.autoDeleteInterval))).catch(async (error) => {
                 await runtime.stop({ wait: false }).catch(() => undefined);
@@ -233,6 +243,7 @@ export class Daytona {
             public: params.public ?? false,
             lifecycle,
             ...("snapshot" in params && params.snapshot ? { snapshot: params.snapshot } : {}),
+            ...(user ? { user } : {}),
         });
     }
     async #source(client, params, onLogs) {
@@ -267,8 +278,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 })))
@@ -288,12 +297,15 @@ export class Daytona {
     }
     #adopt(runtime) {
         const onLeaseEnd = runtime.info.onLeaseEnd;
+        const user = runtime.info.labels[USER_LABEL];
         return new Sandbox(runtime, this.#client, {
             env: {},
             language: runtime.info.labels[LANGUAGE_LABEL] ?? "python",
             public: false,
+            ...(user ? { user } : {}),
             lifecycle: {
                 windowSeconds: runtime.info.timeoutSeconds,
+                idleSeconds: runtime.info.timeoutSeconds,
                 ephemeral: onLeaseEnd === "stop",
                 autoStopInterval: Math.round(runtime.info.timeoutSeconds / 60),
                 autoArchiveInterval: 0,
@@ -304,10 +316,15 @@ export class Daytona {
     /** Live and stopped (paused) sandboxes, oldest first. Await it for the old
      * paginated shape, `{ items, total, page, totalPages }`. */
     list(query = {}) {
-        const known = new Set(["limit", "name", "labels", "states"]);
-        const other = Object.keys(query).find((key) => query[key] !== undefined && !known.has(key));
+        const other = Object.keys(query).find((key) => query[key] !== undefined && !LISTED.has(key));
         if (other)
-            throw new NotSupportedError(`Listing sandboxes by ${other}`, "Filter by name, labels or states, and sort or narrow the result yourself.");
+            throw new NotSupportedError(`Listing sandboxes by ${other}`, other === "isPublic"
+                ? "Runtime previews are public or private per port: filter by a label you set at create."
+                : "Filter by a label you set at create, or narrow the result yourself.");
+        if (query.sort !== undefined && !SORTS[query.sort])
+            throw new RangeError(`sort is one of ${Object.keys(SORTS).join(", ")}.`);
+        if (query.order !== undefined && query.order !== "asc" && query.order !== "desc")
+            throw new RangeError('order is "asc" or "desc".');
         const states = query.states?.flatMap((state) => state === "started"
             ? ["running"]
             : state === "starting"
@@ -317,15 +334,24 @@ export class Daytona {
                     : state === "stopped" || state === "paused"
                         ? ["paused"]
                         : []);
-        const client = this.#client;
-        const adopt = (runtime) => this.#adopt(runtime);
         const filter = {
             ...(query.labels ? { labels: query.labels } : {}),
-            ...(query.name ? { name: query.name } : {}),
             ...(states ? { state: states } : {}),
             ...(query.limit ? { limit: Math.min(query.limit, 100) } : {}),
         };
+        const here = Object.keys(query).some((key) => query[key] !== undefined && !["limit", "labels", "states"].includes(key));
+        const client = this.#client;
+        const adopt = (runtime) => this.#adopt(runtime);
+        const everything = async () => {
+            const page = await guard("other", () => client.sandboxes.list(filter));
+            return arrange(await page.toArray(10_000), query);
+        };
         async function* iterate() {
+            if (here) {
+                for (const runtime of await everything())
+                    yield adopt(runtime);
+                return;
+            }
             const page = await guard("other", () => client.sandboxes.list(filter));
             for await (const runtime of page)
                 yield adopt(runtime);
@@ -334,8 +360,7 @@ export class Daytona {
         return Object.assign(iterator, {
             then(onFulfilled, onRejected) {
                 const all = (async () => {
-                    const page = await guard("other", () => client.sandboxes.list(filter));
-                    const items = (await page.toArray(10_000)).map(adopt);
+                    const items = (await everything()).map(adopt);
                     return { items, total: items.length, page: 1, totalPages: 1 };
                 })();
                 return all.then(onFulfilled, onRejected);
@@ -363,6 +388,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."],
         [
@@ -384,8 +418,8 @@ function refuseCreate(params) {
     for (const [field, feature, alternative] of refusals)
         if (params[field] !== undefined)
             throw new NotSupportedError(feature, alternative);
-    if (params.user !== undefined && params.user !== "daytona")
-        throw new NotSupportedError(`Running as the user "${params.user}"`, 'Commands run as the sandbox owner with passwordless sudo: prefix a command with "sudo" to run it as root.');
+    if (params.user !== undefined && !/^[a-z_][a-z0-9_-]{0,31}$/.test(params.user))
+        throw new DaytonaError(`Invalid user name ${JSON.stringify(params.user)}.`, 400);
     if (params.language !== undefined &&
         !["python", "javascript", "typescript"].includes(params.language))
         throw new NotSupportedError(`The language ${params.language}`, "Use python, javascript or typescript; run anything else with process.executeCommand.");
@@ -401,6 +435,7 @@ export function lifecycleOf(params) {
     const autoDelete = params.ephemeral ? 0 : (params.autoDeleteInterval ?? -1);
     return {
         windowSeconds: windowSeconds(autoStop),
+        idleSeconds: idleSeconds(autoStop),
         ...(params.ttlMinutes ? { deadline: Date.now() + params.ttlMinutes * 60_000 } : {}),
         ephemeral: autoDelete === 0,
         autoStopInterval: autoStop,
@@ -408,6 +443,85 @@ export function lifecycleOf(params) {
         autoDeleteInterval: autoDelete,
     };
 }
+/** What list() takes; isPublic, snapshots and autoDestroyAt are refused. */
+const LISTED = new Set([
+    "limit",
+    "sort",
+    "order",
+    "id",
+    "name",
+    "labels",
+    "states",
+    "targets",
+    "minCpu",
+    "maxCpu",
+    "minMemoryGib",
+    "maxMemoryGib",
+    "minDiskGib",
+    "maxDiskGib",
+    "isRecoverable",
+    "createdAtAfter",
+    "createdAtBefore",
+    "lastActivityAfter",
+    "lastActivityBefore",
+]);
+const lastActivity = (one) => Date.parse(one.info.lastActiveAt ?? one.info.readyAt ?? one.info.createdAt);
+const SORTS = {
+    name: (one) => one.info.name ?? one.id,
+    cpu: (one) => one.info.vcpu,
+    memoryGib: (one) => one.info.memoryMiB / 1024,
+    diskGib: (one) => one.info.diskMiB / 1024,
+    lastActivityAt: lastActivity,
+    createdAt: (one) => Date.parse(one.info.createdAt),
+};
+/** Daytona's list filters and sorting, applied here: Runtime filters by
+ * labels and state only. Sorted descending unless `order` says, as Daytona
+ * does; unsorted lists keep Runtime's order, oldest first. */
+function arrange(all, query) {
+    const within = (value, min, max) => (min === undefined || value >= min) && (max === undefined || value <= max);
+    const time = (date) => (date === undefined ? undefined : date.getTime());
+    const kept = all.filter((one) => (query.id === undefined || one.id.toLowerCase().startsWith(query.id.toLowerCase())) &&
+        (query.name === undefined ||
+            (one.info.name ?? one.id).toLowerCase().startsWith(query.name.toLowerCase())) &&
+        (query.targets === undefined || query.targets.includes("us")) &&
+        (query.isRecoverable === undefined || query.isRecoverable === false) &&
+        within(one.info.vcpu, query.minCpu, query.maxCpu) &&
+        within(one.info.memoryMiB / 1024, query.minMemoryGib, query.maxMemoryGib) &&
+        within(one.info.diskMiB / 1024, query.minDiskGib, query.maxDiskGib) &&
+        within(Date.parse(one.info.createdAt), time(query.createdAtAfter), time(query.createdAtBefore)) &&
+        within(lastActivity(one), time(query.lastActivityAfter), time(query.lastActivityBefore)));
+    const key = query.sort === undefined ? undefined : SORTS[query.sort];
+    if (!key)
+        return query.order === "desc" ? kept.reverse() : kept;
+    const sign = query.order === "asc" ? 1 : -1;
+    return kept.sort((a, b) => {
+        const x = key(a);
+        const y = key(b);
+        return sign * (typeof x === "string" ? x.localeCompare(y) : x - y);
+    });
+}
+/** Readies a new sandbox to run as `user`: the user must be in the image, as
+ * on Daytona. It joins the owner's group, and the working directory takes
+ * that group for what is made in it, so both may change each other's files.
+ * A user the image lacks ends the sandbox and says how to add it. */
+async function asUser(runtime, user) {
+    const ready = await guard("sandbox", () => runtime.exec([
+        "sh",
+        "-c",
+        'id -u "$1" >/dev/null 2>&1 || exit 3; [ "$1" = root ] || { sudo usermod -aG runtime "$1" && sudo chmod 2775 /workspace; }',
+        "sh",
+        user,
+    ])).catch(async (error) => {
+        await runtime.stop({ wait: false }).catch(() => undefined);
+        throw error;
+    });
+    if (ready.exitCode === 0)
+        return;
+    await runtime.stop({ wait: false }).catch(() => undefined);
+    throw new DaytonaError(ready.exitCode === 3
+        ? `The user "${user}" does not exist in this sandbox's image. Add it to the image (RUN useradd -m ${user}), or leave user out to run as the sandbox owner, who has passwordless sudo.`
+        : `The sandbox could not be readied for the user "${user}": ${ready.stderr.trim() || `exit ${ready.exitCode}`}`, 400);
+}
 /** The sandbox with this Runtime id, or the newest live one with this name. */
 async function find(client, idOrName) {
     if (UUID.test(idOrName))

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 {
@@ -58,6 +81,13 @@ export class FileSystem {
     async createFolder(path, mode) {
         const target = await this.#path(path);
         await this.#run(["mkdir", "-p", "-m", mode, "--", target]);
+        await this.#own(target);
+    }
+    /** Gives what this client wrote to create's `user`, so its commands may
+     * change it; the owner's files stay the owner's. */
+    async #own(target) {
+        if (this.#ctx.user)
+            await this.#run(["sudo", "chown", this.#ctx.user, "--", target]);
     }
     async deleteFile(path, recursive = false) {
         const target = await this.#path(path);
@@ -66,36 +96,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 +235,65 @@ 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 } : {}),
+                }));
+            await this.#own(target);
+        }
+        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);
         }
     }
 }