@daytonaio/sdk 0.110.2-alpha.9 → 0.111.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daytonaio/sdk",
-  "version": "0.110.2-alpha.9",
+  "version": "0.111.0",
   "description": "TypeScript SDK for Daytona",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
@@ -26,7 +26,6 @@
     "@aws-sdk/lib-storage": "^3.798.0",
     "@iarna/toml": "^2.2.5",
     "axios": "^1.11.0",
-    "buffer": "^6.0.3",
     "busboy": "^1.0.0",
     "dotenv": "^17.0.1",
     "expand-tilde": "^2.0.2",
@@ -36,7 +35,7 @@
     "pathe": "^2.0.3",
     "shell-quote": "^1.8.2",
     "tar": "^6.2.0",
-    "@daytonaio/api-client": "0.110.2-alpha.9"
+    "@daytonaio/api-client": "0.111.0"
   },
   "packageManager": "yarn@4.6.0",
   "type": "commonjs"

package/src/FileSystem.d.ts

@@ -1,5 +1,4 @@
 import { Configuration, FileInfo, Match, ReplaceResult, SearchFilesResponse, ToolboxApi } from '@daytonaio/api-client';
-import { Buffer } from 'buffer';
 /**
  * Parameters for setting file permissions in the Sandbox.
  *
@@ -44,7 +43,7 @@ export interface FileUpload {
  * @property {string} [destination] - Destination path in the local filesystem where the file content will be
  * streamed to. If not provided, the file will be downloaded in the bytes buffer (might cause memory issues if the file is large).
  */
-interface FileDownloadRequest {
+export interface FileDownloadRequest {
     source: string;
     destination?: string;
 }
@@ -57,11 +56,25 @@ interface FileDownloadRequest {
  * or bytes content (if no destination in the request), undefined if failed or no data received.
  * @property {string | undefined} [error] - Error message if the download failed, undefined if successful.
  */
-interface FileDownloadResponse {
+export interface FileDownloadResponse {
     source: string;
     result?: Buffer | string;
     error?: string;
 }
+/**
+ * Represents metadata for a file download operation.
+ *
+ * @interface
+ * @property {string | undefined} [destination] - Destination path in the local filesystem where the file content will be streamed to.
+ * @property {string | undefined} [error] - Error message if the download failed, undefined if successful.
+ * @property {Buffer | string | Uint8Array | undefined} [result] - The download result - file path (if destination provided in the request)
+ * or bytes content (if no destination in the request), undefined if failed or no data received.
+ */
+export interface DownloadMetadata {
+    destination?: string;
+    error?: string;
+    result?: Buffer | string | Uint8Array;
+}
 /**
  * Provides file system operations within a Sandbox.
  *
@@ -311,4 +324,3 @@ export declare class FileSystem {
     uploadFiles(files: FileUpload[], timeout?: number): Promise<void>;
     private makeFilePayload;
 }
-export {};

package/src/FileSystem.js

@@ -7,12 +7,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSystem = void 0;
 const tslib_1 = require("tslib");
 const pathe = tslib_1.__importStar(require("pathe"));
-const form_data_1 = tslib_1.__importDefault(require("form-data"));
+const DaytonaError_1 = require("./errors/DaytonaError");
+const FileTransfer_1 = require("./utils/FileTransfer");
 const Import_1 = require("./utils/Import");
 const Runtime_1 = require("./utils/Runtime");
-const busboy_1 = tslib_1.__importDefault(require("busboy"));
-const DaytonaError_1 = require("./errors/DaytonaError");
-const buffer_1 = require("buffer");
 /**
  * Provides file system operations within a Sandbox.
  *
@@ -102,247 +100,37 @@ class FileSystem {
     async downloadFiles(files, timeoutSec = 30 * 60) {
         if (files.length === 0)
             return [];
-        const isNodeLike = typeof process !== 'undefined' &&
-            !!process.versions?.node &&
-            typeof globalThis.Buffer !== 'undefined';
-        const srcFileMetaMap = new Map();
-        const fileTasks = [];
-        // Validate & prepare destinations
+        const isNonStreamingRuntime = Runtime_1.RUNTIME === Runtime_1.Runtime.BROWSER || Runtime_1.RUNTIME === Runtime_1.Runtime.SERVERLESS;
+        // Prepare destinations and metadata
+        const metadataMap = new Map();
         for (const f of files) {
-            srcFileMetaMap.set(f.source, { dst: f.destination });
+            metadataMap.set(f.source, { destination: f.destination });
             if (f.destination) {
-                if (isNodeLike) {
-                    const fs = await (0, Import_1.dynamicImport)('fs', 'Downloading files to local files is not supported: ');
-                    await fs.promises.mkdir(pathe.dirname(f.destination), { recursive: true });
-                }
-                else {
-                    throw new DaytonaError_1.DaytonaError('Downloading files to local files is not supported in this runtime.');
-                }
+                const fs = await (0, Import_1.dynamicImport)('fs', 'Downloading files to local files is not supported: ');
+                await fs.promises.mkdir(pathe.dirname(f.destination), { recursive: true });
             }
         }
-        const response = await this.toolboxApi.downloadFiles(this.sandboxId, { paths: Array.from(srcFileMetaMap.keys()) }, undefined, {
-            responseType: 'stream',
+        const response = await this.toolboxApi.downloadFiles(this.sandboxId, { paths: files.map((f) => f.source) }, undefined, {
+            responseType: isNonStreamingRuntime ? 'arraybuffer' : 'stream',
             timeout: timeoutSec * 1000,
         });
-        const contentType = getHeader(response.headers, 'content-type') || '';
-        let responseData = response.data;
-        // Normalize responseData across adapters
-        if (responseData && typeof responseData === 'object') {
-            if (responseData.body && typeof responseData.body.getReader === 'function') {
-                responseData = responseData.body; // WHATWG ReadableStream
-            }
-            else if (responseData.stream) {
-                responseData = responseData.stream; // Some adapters use .stream
-            }
-        }
-        // -------------------- NODE PATH (busboy) --------------------
-        if (isNodeLike) {
-            await new Promise((resolve, reject) => {
-                const bb = (0, busboy_1.default)({
-                    headers: response.headers,
-                    preservePath: true,
-                });
-                // busboy emits: ('file', fieldName, fileStream, fileInfo)
-                bb.on('file', (fieldName, fileStream, fileInfo) => {
-                    const source = fileInfo?.filename;
-                    if (!source) {
-                        safeAbort(responseData);
-                        reject(new DaytonaError_1.DaytonaError(`Received unexpected file "${fileInfo?.filename}".`));
-                        return;
-                    }
-                    const meta = srcFileMetaMap.get(source);
-                    if (!meta) {
-                        safeAbort(responseData);
-                        reject(new DaytonaError_1.DaytonaError(`Target metadata missing for valid source: ${source}`));
-                        return;
-                    }
-                    if (fieldName === 'error') {
-                        let buf = buffer_1.Buffer.alloc(0);
-                        fileStream.on('data', (chunk) => {
-                            buf = buffer_1.Buffer.concat([buf, chunk]);
-                        });
-                        fileStream.on('end', () => {
-                            meta.error = buf.toString('utf-8').trim();
-                        });
-                        fileStream.on('error', (err) => {
-                            meta.error = `Stream error: ${err.message}`;
-                        });
-                    }
-                    else if (fieldName === 'file') {
-                        if (meta.dst) {
-                            fileTasks.push(new Promise((resolveInner) => {
-                                (0, Import_1.dynamicImport)('fs', 'Downloading files to local files is not supported: ').then((fs) => {
-                                    const writeStream = fs.createWriteStream(meta.dst, { autoClose: true });
-                                    fileStream.pipe(writeStream);
-                                    writeStream.on('finish', () => {
-                                        meta.result = meta.dst;
-                                        resolveInner();
-                                    });
-                                    writeStream.on('error', (err) => {
-                                        meta.error = `Write stream failed: ${err.message}`;
-                                        resolveInner();
-                                    });
-                                    fileStream.on('error', (err) => {
-                                        meta.error = `Read stream failed: ${err.message}`;
-                                    });
-                                });
-                            }));
-                        }
-                        else {
-                            const chunks = [];
-                            fileStream.on('data', (chunk) => {
-                                // Ensure chunk is Buffer (it is in Node)
-                                chunks.push(buffer_1.Buffer.isBuffer(chunk) ? chunk : buffer_1.Buffer.from(chunk));
-                            });
-                            fileStream.on('end', () => {
-                                meta.result = buffer_1.Buffer.concat(chunks);
-                            });
-                            fileStream.on('error', (err) => {
-                                meta.error = `Read failed: ${err.message}`;
-                            });
-                        }
-                    }
-                    else {
-                        // Unknown fieldname; drain
-                        fileStream.resume();
-                    }
-                });
-                bb.on('error', (err) => {
-                    safeAbort(responseData);
-                    reject(err);
-                });
-                bb.on('finish', resolve);
-                // Feed body into busboy, coercing to Buffer as needed
-                if (typeof responseData?.pipe === 'function') {
-                    responseData.pipe(bb);
-                }
-                else if (typeof responseData === 'string' ||
-                    responseData instanceof ArrayBuffer ||
-                    ArrayBuffer.isView(responseData)) {
-                    try {
-                        const u8 = toUint8Array(responseData);
-                        bb.write(buffer_1.Buffer.from(u8));
-                        bb.end();
-                    }
-                    catch (err) {
-                        bb.destroy(err);
-                    }
-                }
-                else if (typeof responseData?.getReader === 'function') {
-                    ;
-                    (async () => {
-                        try {
-                            const reader = responseData.getReader();
-                            while (true) {
-                                const { done, value } = await reader.read();
-                                if (done)
-                                    break;
-                                bb.write(buffer_1.Buffer.from(value));
-                            }
-                            bb.end();
-                        }
-                        catch (err) {
-                            bb.destroy(err);
-                        }
-                    })();
-                }
-                else if (responseData?.[Symbol.asyncIterator]) {
-                    ;
-                    (async () => {
-                        try {
-                            for await (const chunk of responseData) {
-                                const buf = buffer_1.Buffer.isBuffer(chunk) ? chunk : buffer_1.Buffer.from(toUint8Array(chunk));
-                                bb.write(buf);
-                            }
-                            bb.end();
-                        }
-                        catch (err) {
-                            bb.destroy(err);
-                        }
-                    })();
-                }
-                else {
-                    const typeInfo = responseData
-                        ? `type: ${typeof responseData}, constructor: ${responseData.constructor?.name}, keys: ${Object.keys(responseData)
-                            .slice(0, 10)
-                            .join(', ')}`
-                        : 'null or undefined';
-                    reject(new DaytonaError_1.DaytonaError(`Unsupported stream type for response data. ${typeInfo}`));
-                }
-            });
-            await Promise.all(fileTasks);
-            return finalizeResults(files, srcFileMetaMap);
-        }
-        // -------------------- BROWSER / EDGE PATH (no busboy) --------------------
-        // Collect all bytes first
-        const bodyBytes = await collectBodyBytes(responseData);
-        // Path A: multipart/form-data → let platform parse it
-        if (/^multipart\/form-data/i.test(contentType) && typeof Response !== 'undefined') {
-            try {
-                // Make a fresh Uint8Array so its .buffer is a concrete ArrayBuffer (not ArrayBufferLike/SAB)
-                const bytesCopy = new Uint8Array(bodyBytes.byteLength);
-                bytesCopy.set(bodyBytes);
-                // Use the ArrayBuffer directly to satisfy BodyInit/BlobPart typing
-                const blob = new Blob([bytesCopy.buffer], { type: contentType });
-                const res = new Response(blob);
-                const fd = await res.formData();
-                // No fd.entries() (avoids dom.iterable). Use forEach + Promise bucket.
-                const ops = [];
-                fd.forEach((value, field) => {
-                    ops.push((async () => {
-                        if (isRuntimeFile(value)) {
-                            const file = value;
-                            const source = file.name;
-                            const meta = srcFileMetaMap.get(source);
-                            if (!meta)
-                                return;
-                            if (field === 'error') {
-                                const text = await file.text();
-                                meta.error = String(text).trim();
-                            }
-                            else if (field === 'file') {
-                                const ab = await file.arrayBuffer();
-                                meta.result = toBufferIfAvailable(new Uint8Array(ab));
-                            }
-                        }
-                        else {
-                            // Non-file field (rare)
-                            if (field === 'error') {
-                                for (const meta of srcFileMetaMap.values()) {
-                                    meta.error = String(value);
-                                }
-                            }
-                        }
-                    })());
-                });
-                await Promise.all(ops);
-                return finalizeResults(files, srcFileMetaMap);
-            }
-            catch {
-                // Fall through to manual multipart parsing
-            }
+        const stream = (0, FileTransfer_1.normalizeResponseStream)(response.data);
+        // Node.js path: use busboy for efficient streaming
+        if (isNonStreamingRuntime) {
+            await (0, FileTransfer_1.processDownloadFilesResponseWithBuffered)(stream, response.headers, metadataMap);
         }
-        // Path B: generic multipart/* parser (handles multipart/mixed, etc.)
-        const boundary = getMultipartBoundary(contentType);
-        if (!boundary) {
-            throw new DaytonaError_1.DaytonaError(`Missing multipart boundary in Content-Type: "${contentType}"`);
-        }
-        const parts = parseMultipart(bodyBytes, boundary);
-        for (const p of parts) {
-            const source = p.filename;
-            if (!source)
-                continue;
-            const meta = srcFileMetaMap.get(source);
-            if (!meta)
-                continue;
-            if (p.name === 'error') {
-                meta.error = utf8Decode(p.data).trim();
-            }
-            else if (p.name === 'file') {
-                meta.result = toBufferIfAvailable(p.data);
-            }
+        else {
+            await (0, FileTransfer_1.processDownloadFilesResponseWithBusboy)(stream, response.headers, metadataMap);
         }
-        return finalizeResults(files, srcFileMetaMap);
+        return files.map((f) => {
+            const metadata = metadataMap.get(f.source);
+            const error = metadata?.error || (!metadata?.result ? 'No data received for this file' : undefined);
+            return {
+                source: f.source,
+                result: error ? undefined : metadata.result,
+                error,
+            };
+        });
     }
     /**
      * Searches for text patterns within files in the Sandbox.
@@ -500,18 +288,18 @@ class FileSystem {
      * await fs.uploadFiles(files);
      */
     async uploadFiles(files, timeout = 30 * 60) {
+        const isNonStreamingRuntime = Runtime_1.RUNTIME === Runtime_1.Runtime.DENO || Runtime_1.RUNTIME === Runtime_1.Runtime.BROWSER || Runtime_1.RUNTIME === Runtime_1.Runtime.SERVERLESS;
         // Use native FormData in Deno
-        const FormDataClass = Runtime_1.RUNTIME === Runtime_1.Runtime.DENO || Runtime_1.RUNTIME === Runtime_1.Runtime.SERVERLESS || Runtime_1.RUNTIME === Runtime_1.Runtime.BROWSER
-            ? form_data_1.default
+        const FormDataClass = isNonStreamingRuntime
+            ? FormData
             : (await (0, Import_1.dynamicImport)('form-data', 'Uploading files is not supported: '));
         const form = new FormDataClass();
         for (const [i, { source, destination }] of files.entries()) {
             form.append(`files[${i}].path`, destination);
             const payload = await this.makeFilePayload(source);
-            // the third arg sets filename in Content-Disposition
             form.append(`files[${i}].file`, payload, destination);
         }
-        if (Runtime_1.RUNTIME === Runtime_1.Runtime.SERVERLESS || Runtime_1.RUNTIME === Runtime_1.Runtime.BROWSER) {
+        if (isNonStreamingRuntime) {
             const url = `${this.clientConfig.basePath}/toolbox/${this.sandboxId}/toolbox/files/bulk-upload`;
             await fetch(url, {
                 method: 'POST',
@@ -529,231 +317,20 @@ class FileSystem {
         }
     }
     async makeFilePayload(source) {
-        // 1) file‐path
+        // String = file path
         if (typeof source === 'string') {
             const fs = await (0, Import_1.dynamicImport)('fs', 'Uploading file from local file system is not supported: ');
             return fs.createReadStream(source);
         }
-        // 2) browser → Blob
-        if (Runtime_1.RUNTIME === Runtime_1.Runtime.BROWSER || Runtime_1.RUNTIME === Runtime_1.Runtime.SERVERLESS) {
-            return new Blob([source], { type: 'application/octet-stream' });
+        // Blob
+        if (Runtime_1.RUNTIME === Runtime_1.Runtime.BROWSER || Runtime_1.RUNTIME === Runtime_1.Runtime.SERVERLESS || Runtime_1.RUNTIME === Runtime_1.Runtime.DENO) {
+            // Use .slice() to ensure we have a concrete ArrayBuffer, not ArrayBufferLike
+            return new Blob([source.slice()], { type: 'application/octet-stream' });
         }
-        // 3) Node (or other server runtimes) → stream.Readable
+        // Readable stream
         const stream = await (0, Import_1.dynamicImport)('stream', 'Uploading file is not supported: ');
         return stream.Readable.from(source);
     }
 }
 exports.FileSystem = FileSystem;
-/* ==================== Helpers (keep in same file) ==================== */
-function getHeader(headers, key) {
-    if (!headers)
-        return undefined;
-    // Axios can give lowercase keys; some envs may differ
-    const k = Object.keys(headers).find((h) => h.toLowerCase() === key.toLowerCase());
-    const val = k ? headers[k] : undefined;
-    // Flatten array-ish values
-    return Array.isArray(val) ? val[0] : val;
-}
-function safeAbort(streamish) {
-    if (streamish && typeof streamish.destroy === 'function')
-        streamish.destroy();
-    else if (streamish && typeof streamish.cancel === 'function')
-        streamish.cancel();
-}
-function toUint8Array(data) {
-    if (typeof data === 'string') {
-        return new TextEncoder().encode(data);
-    }
-    if (data instanceof ArrayBuffer)
-        return new Uint8Array(data);
-    if (ArrayBuffer.isView(data)) {
-        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    }
-    throw new DaytonaError_1.DaytonaError('Unsupported data type for byte conversion.');
-}
-async function collectBodyBytes(body) {
-    if (!body)
-        return new Uint8Array(0);
-    if (typeof body.getReader === 'function') {
-        const reader = body.getReader();
-        const chunks = [];
-        let total = 0;
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            if (value && value.byteLength) {
-                chunks.push(value);
-                total += value.byteLength;
-            }
-        }
-        return concatU8(chunks, total);
-    }
-    if (body?.[Symbol.asyncIterator]) {
-        const chunks = [];
-        let total = 0;
-        for await (const chunk of body) {
-            const u8 = toUint8Array(chunk);
-            chunks.push(u8);
-            total += u8.byteLength;
-        }
-        return concatU8(chunks, total);
-    }
-    if (typeof body === 'string' || body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
-        return toUint8Array(body);
-    }
-    if (typeof Blob !== 'undefined' && body instanceof Blob) {
-        const ab = await body.arrayBuffer();
-        return new Uint8Array(ab);
-    }
-    if (typeof Response !== 'undefined' && body instanceof Response) {
-        const ab = await body.arrayBuffer();
-        return new Uint8Array(ab);
-    }
-    throw new DaytonaError_1.DaytonaError('Unsupported response body for browser parsing.');
-}
-function concatU8(parts, total) {
-    const size = total ?? parts.reduce((s, p) => s + p.byteLength, 0);
-    const out = new Uint8Array(size);
-    let off = 0;
-    for (const p of parts) {
-        out.set(p, off);
-        off += p.byteLength;
-    }
-    return out;
-}
-function getMultipartBoundary(ct) {
-    const m = /boundary="?([^";]+)"?/i.exec(ct || '');
-    return m ? m[1] : null;
-}
-/** Minimal multipart parser (binary-safe), supports CRLF line breaks. */
-function parseMultipart(body, boundary) {
-    const enc = new TextEncoder();
-    const dashBoundary = enc.encode(`--${boundary}`);
-    const crlf = enc.encode('\r\n');
-    const boundaryLine = concatU8([dashBoundary, crlf]);
-    const starts = findAll(body, dashBoundary);
-    if (starts.length === 0)
-        return [];
-    const parts = [];
-    for (let i = 0; i < starts.length; i++) {
-        const start = starts[i];
-        // Part header starts after "--boundary\r\n"
-        const headerStart = indexAfter(body, start, boundaryLine);
-        if (headerStart < 0)
-            continue;
-        // Part ends before next "--boundary" (trim trailing CRLF)
-        const nextStart = starts[i + 1] ?? body.length;
-        let partEnd = nextStart - 2;
-        if (partEnd < headerStart)
-            partEnd = headerStart;
-        // Split headers/body by \r\n\r\n
-        const sep = findSequence(body, headerStart, partEnd, enc.encode('\r\n\r\n'));
-        if (sep < 0)
-            continue;
-        const headersBytes = body.subarray(headerStart, sep);
-        const dataStart = sep + 4;
-        const data = body.subarray(dataStart, partEnd);
-        const headersText = new TextDecoder('utf-8').decode(headersBytes);
-        const headers = {};
-        for (const line of headersText.split(/\r\n/)) {
-            const idx = line.indexOf(':');
-            if (idx > -1) {
-                const k = line.slice(0, idx).trim().toLowerCase();
-                const v = line.slice(idx + 1).trim();
-                headers[k] = v;
-            }
-        }
-        const cd = headers['content-disposition'] || '';
-        const name = getDispositionParam(cd, 'name');
-        const filename = getDispositionParam(cd, 'filename');
-        parts.push({ name, filename, headers, data });
-    }
-    return parts;
-}
-function findAll(hay, needle) {
-    const res = [];
-    let i = 0;
-    while (i <= hay.length - needle.length) {
-        let ok = true;
-        for (let j = 0; j < needle.length; j++) {
-            if (hay[i + j] !== needle[j]) {
-                ok = false;
-                break;
-            }
-        }
-        if (ok) {
-            res.push(i);
-            i += needle.length;
-        }
-        else {
-            i++;
-        }
-    }
-    return res;
-}
-function findSequence(hay, start, end, needle) {
-    let i = start;
-    while (i <= end - needle.length) {
-        let ok = true;
-        for (let j = 0; j < needle.length; j++) {
-            if (hay[i + j] !== needle[j]) {
-                ok = false;
-                break;
-            }
-        }
-        if (ok)
-            return i;
-        i++;
-    }
-    return -1;
-}
-function indexAfter(hay, start, seq) {
-    for (let j = 0; j < seq.length; j++) {
-        if (hay[start + j] !== seq[j])
-            return -1;
-    }
-    return start + seq.length;
-}
-function getDispositionParam(cd, key) {
-    const re = new RegExp(`${key}\\*?=("(?:[^"]+)"|[^;]+)`, 'i');
-    const m = re.exec(cd);
-    if (!m)
-        return undefined;
-    let val = m[1];
-    if (val.startsWith('"') && val.endsWith('"'))
-        val = val.slice(1, -1);
-    return val;
-}
-function utf8Decode(u8) {
-    return new TextDecoder('utf-8').decode(u8);
-}
-/** Return Buffer in Node / with polyfill, else keep Uint8Array. */
-function toBufferIfAvailable(u8) {
-    const B = globalThis.Buffer;
-    return B && typeof B.from === 'function' ? B.from(u8) : u8;
-}
-function finalizeResults(files, metaMap) {
-    const results = [];
-    for (const f of files) {
-        const meta = metaMap.get(f.source);
-        let err = meta?.error;
-        if (!err && !meta?.result)
-            err = 'No data received for this file';
-        let res;
-        if (!err && meta) {
-            // In browsers this may be Uint8Array; cast so public type stays Buffer|string
-            res = meta.result;
-        }
-        else if (!meta) {
-            err = 'No writer metadata found';
-        }
-        results.push({ source: f.source, result: res, error: err });
-    }
-    return results;
-}
-function isRuntimeFile(v) {
-    const F = globalThis.File;
-    return typeof F !== 'undefined' && v instanceof F;
-}
 //# sourceMappingURL=FileSystem.js.map