@daytona/sdk 0.175.1-alpha.1 → 0.179.0

package/esm/FileSystem.js

@@ -2,7 +2,7 @@
  * Copyright 2025 Daytona Platforms Inc.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { __decorate, __metadata } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import * as pathe from 'pathe';
 import axios from 'axios';
 import { dynamicImport } from './utils/Import.js';
@@ -21,551 +21,523 @@ function createFileDownloadError(error, errorDetails) {
  *
  * @class
  */
-export class FileSystem {
-    clientConfig;
-    apiClient;
-    constructor(clientConfig, apiClient) {
-        this.clientConfig = clientConfig;
-        this.apiClient = apiClient;
-    }
-    /**
-     * Create a new directory in the Sandbox with specified permissions.
-     *
-     * @param {string} path - Path where the directory should be created. Relative paths are resolved based on the sandbox working directory.
-     * @param {string} mode - Directory permissions in octal format (e.g. "755")
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Create a directory with standard permissions
-     * await fs.createFolder('app/data', '755');
-     */
-    async createFolder(path, mode) {
-        const response = await this.apiClient.createFolder(path, mode);
-        return response.data;
-    }
-    /**
-     * Deletes a file or directory from the Sandbox.
-     *
-     * @param {string} path - Path to the file or directory to delete. Relative paths are resolved based on the sandbox working directory.
-     * @param {boolean} [recursive] - If the file is a directory, this must be true to delete it.
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Delete a file
-     * await fs.deleteFile('app/temp.log');
-     */
-    async deleteFile(path, recursive) {
-        const response = await this.apiClient.deleteFile(path, recursive);
-        return response.data;
-    }
-    async downloadFile(src, dst, timeout = 30 * 60) {
-        const remotePath = src;
-        if (typeof dst !== 'string') {
-            if (dst) {
-                timeout = dst;
-            }
-            const response = await this.downloadFiles([{ source: remotePath }], timeout);
-            if (response[0].error) {
-                throw createFileDownloadError(response[0].error, response[0].errorDetails);
-            }
-            return response[0].result;
-        }
-        const response = await this.downloadFiles([{ source: remotePath, destination: dst }], timeout);
-        if (response[0].error) {
-            throw createFileDownloadError(response[0].error, response[0].errorDetails);
+let FileSystem = (() => {
+    let _instanceExtraInitializers = [];
+    let _createFolder_decorators;
+    let _deleteFile_decorators;
+    let _downloadFile_decorators;
+    let _downloadFileStream_decorators;
+    let _downloadFiles_decorators;
+    let _findFiles_decorators;
+    let _getFileDetails_decorators;
+    let _listFiles_decorators;
+    let _moveFiles_decorators;
+    let _replaceInFiles_decorators;
+    let _searchFiles_decorators;
+    let _setFilePermissions_decorators;
+    let _uploadFile_decorators;
+    let _uploadFileStream_decorators;
+    let _uploadFiles_decorators;
+    return class FileSystem {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _createFolder_decorators = [WithInstrumentation()];
+            _deleteFile_decorators = [WithInstrumentation()];
+            _downloadFile_decorators = [WithInstrumentation()];
+            _downloadFileStream_decorators = [WithInstrumentation()];
+            _downloadFiles_decorators = [WithInstrumentation()];
+            _findFiles_decorators = [WithInstrumentation()];
+            _getFileDetails_decorators = [WithInstrumentation()];
+            _listFiles_decorators = [WithInstrumentation()];
+            _moveFiles_decorators = [WithInstrumentation()];
+            _replaceInFiles_decorators = [WithInstrumentation()];
+            _searchFiles_decorators = [WithInstrumentation()];
+            _setFilePermissions_decorators = [WithInstrumentation()];
+            _uploadFile_decorators = [WithInstrumentation()];
+            _uploadFileStream_decorators = [WithInstrumentation()];
+            _uploadFiles_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _createFolder_decorators, { kind: "method", name: "createFolder", static: false, private: false, access: { has: obj => "createFolder" in obj, get: obj => obj.createFolder }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteFile_decorators, { kind: "method", name: "deleteFile", static: false, private: false, access: { has: obj => "deleteFile" in obj, get: obj => obj.deleteFile }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _downloadFile_decorators, { kind: "method", name: "downloadFile", static: false, private: false, access: { has: obj => "downloadFile" in obj, get: obj => obj.downloadFile }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _downloadFileStream_decorators, { kind: "method", name: "downloadFileStream", static: false, private: false, access: { has: obj => "downloadFileStream" in obj, get: obj => obj.downloadFileStream }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _downloadFiles_decorators, { kind: "method", name: "downloadFiles", static: false, private: false, access: { has: obj => "downloadFiles" in obj, get: obj => obj.downloadFiles }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _findFiles_decorators, { kind: "method", name: "findFiles", static: false, private: false, access: { has: obj => "findFiles" in obj, get: obj => obj.findFiles }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getFileDetails_decorators, { kind: "method", name: "getFileDetails", static: false, private: false, access: { has: obj => "getFileDetails" in obj, get: obj => obj.getFileDetails }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listFiles_decorators, { kind: "method", name: "listFiles", static: false, private: false, access: { has: obj => "listFiles" in obj, get: obj => obj.listFiles }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _moveFiles_decorators, { kind: "method", name: "moveFiles", static: false, private: false, access: { has: obj => "moveFiles" in obj, get: obj => obj.moveFiles }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _replaceInFiles_decorators, { kind: "method", name: "replaceInFiles", static: false, private: false, access: { has: obj => "replaceInFiles" in obj, get: obj => obj.replaceInFiles }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _searchFiles_decorators, { kind: "method", name: "searchFiles", static: false, private: false, access: { has: obj => "searchFiles" in obj, get: obj => obj.searchFiles }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setFilePermissions_decorators, { kind: "method", name: "setFilePermissions", static: false, private: false, access: { has: obj => "setFilePermissions" in obj, get: obj => obj.setFilePermissions }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _uploadFile_decorators, { kind: "method", name: "uploadFile", static: false, private: false, access: { has: obj => "uploadFile" in obj, get: obj => obj.uploadFile }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _uploadFileStream_decorators, { kind: "method", name: "uploadFileStream", static: false, private: false, access: { has: obj => "uploadFileStream" in obj, get: obj => obj.uploadFileStream }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _uploadFiles_decorators, { kind: "method", name: "uploadFiles", static: false, private: false, access: { has: obj => "uploadFiles" in obj, get: obj => obj.uploadFiles }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-    }
-    async downloadFileStream(remotePath, timeoutOrOptions) {
-        const options = typeof timeoutOrOptions === 'number' ? { timeout: timeoutOrOptions } : (timeoutOrOptions ?? {});
-        const timeout = options.timeout ?? 30 * 60;
-        const isNonStreamingRuntime = RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS;
-        if (isNonStreamingRuntime) {
-            throw new DaytonaError('downloadFileStream is not supported in browser or serverless environments. Use downloadFile instead.');
+        clientConfig = __runInitializers(this, _instanceExtraInitializers);
+        apiClient;
+        constructor(clientConfig, apiClient) {
+            this.clientConfig = clientConfig;
+            this.apiClient = apiClient;
         }
-        if (options.signal?.aborted) {
-            throw new DaytonaError('Download cancelled');
+        /**
+         * Create a new directory in the Sandbox with specified permissions.
+         *
+         * @param {string} path - Path where the directory should be created. Relative paths are resolved based on the sandbox working directory.
+         * @param {string} mode - Directory permissions in octal format (e.g. "755")
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Create a directory with standard permissions
+         * await fs.createFolder('app/data', '755');
+         */
+        async createFolder(path, mode) {
+            const response = await this.apiClient.createFolder(path, mode);
+            return response.data;
         }
-        const toDownloadCancelledError = () => new DaytonaError('Download cancelled');
-        const isCanceledError = (err) => {
-            const error = err;
-            return Boolean(axios.isCancel?.(err) || error?.name === 'CanceledError' || error?.code === 'ERR_CANCELED');
-        };
-        let response;
-        try {
-            response = await this.apiClient.downloadFiles({ paths: [remotePath] }, {
-                responseType: 'stream',
-                timeout: timeout * 1000,
-                signal: options.signal,
-            });
+        /**
+         * Deletes a file or directory from the Sandbox.
+         *
+         * @param {string} path - Path to the file or directory to delete. Relative paths are resolved based on the sandbox working directory.
+         * @param {boolean} [recursive] - If the file is a directory, this must be true to delete it.
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Delete a file
+         * await fs.deleteFile('app/temp.log');
+         */
+        async deleteFile(path, recursive) {
+            const response = await this.apiClient.deleteFile(path, recursive);
+            return response.data;
         }
-        catch (err) {
-            if (options.signal?.aborted || isCanceledError(err)) {
-                throw toDownloadCancelledError();
+        async downloadFile(src, dst, timeout = 30 * 60) {
+            const remotePath = src;
+            if (typeof dst !== 'string') {
+                if (dst) {
+                    timeout = dst;
+                }
+                const response = await this.downloadFiles([{ source: remotePath }], timeout);
+                if (response[0].error) {
+                    throw createFileDownloadError(response[0].error, response[0].errorDetails);
+                }
+                return response[0].result;
+            }
+            const response = await this.downloadFiles([{ source: remotePath, destination: dst }], timeout);
+            if (response[0].error) {
+                throw createFileDownloadError(response[0].error, response[0].errorDetails);
             }
-            throw err;
         }
-        const responseStream = normalizeResponseStream(response.data);
-        const metadataMap = new Map();
-        metadataMap.set(remotePath, {});
-        return new Promise((resolve, reject) => {
-            let resolvedStream = null;
-            processDownloadFilesResponseWithBusboy(responseStream, response.headers, metadataMap, (_source, fileStream, totalBytes) => {
-                if (options.onProgress) {
-                    const { Transform } = require('stream');
-                    let bytesReceived = 0;
-                    const progress = new Transform({
-                        transform(chunk, _encoding, callback) {
-                            bytesReceived += chunk.length;
-                            options.onProgress({ bytesReceived, totalBytes });
-                            callback(null, chunk);
-                        },
-                    });
-                    fileStream.pipe(progress);
-                    fileStream.on('error', (err) => {
-                        if (!progress.destroyed)
-                            progress.destroy(err);
-                    });
-                    resolvedStream = progress;
-                }
-                else {
-                    resolvedStream = fileStream;
+        async downloadFileStream(remotePath, timeoutOrOptions) {
+            const options = typeof timeoutOrOptions === 'number' ? { timeout: timeoutOrOptions } : (timeoutOrOptions ?? {});
+            const timeout = options.timeout ?? 30 * 60;
+            const isNonStreamingRuntime = RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS;
+            if (isNonStreamingRuntime) {
+                throw new DaytonaError('downloadFileStream is not supported in browser or serverless environments. Use downloadFile instead.');
+            }
+            if (options.signal?.aborted) {
+                throw new DaytonaError('Download cancelled');
+            }
+            // Pre-resolve `stream` so the sync `onFileStream` callback below is await-free.
+            const { Transform } = await dynamicImport('stream', 'downloadFileStream progress tracking is not supported: ');
+            const toDownloadCancelledError = () => new DaytonaError('Download cancelled');
+            const isCanceledError = (err) => {
+                const error = err;
+                return Boolean(axios.isCancel?.(err) || error?.name === 'CanceledError' || error?.code === 'ERR_CANCELED');
+            };
+            let response;
+            try {
+                response = await this.apiClient.downloadFiles({ paths: [remotePath] }, {
+                    responseType: 'stream',
+                    timeout: timeout * 1000,
+                    signal: options.signal,
+                });
+            }
+            catch (err) {
+                if (options.signal?.aborted || isCanceledError(err)) {
+                    throw toDownloadCancelledError();
                 }
-                resolve(resolvedStream);
-            })
-                .then(() => {
-                if (!resolvedStream) {
-                    const metadata = metadataMap.get(remotePath);
-                    if (metadata?.error) {
-                        reject(createFileDownloadError(metadata.error, metadata.errorDetails));
+                throw err;
+            }
+            const responseStream = normalizeResponseStream(response.data);
+            const metadataMap = new Map();
+            metadataMap.set(remotePath, {});
+            return new Promise((resolve, reject) => {
+                let resolvedStream = null;
+                processDownloadFilesResponseWithBusboy(responseStream, response.headers, metadataMap, (_source, fileStream, totalBytes) => {
+                    if (options.onProgress) {
+                        let bytesReceived = 0;
+                        const progress = new Transform({
+                            transform(chunk, _encoding, callback) {
+                                bytesReceived += chunk.length;
+                                options.onProgress({ bytesReceived, totalBytes });
+                                callback(null, chunk);
+                            },
+                        });
+                        fileStream.pipe(progress);
+                        // busboy's teardown can emit 'error' on the file stream after 'end',
+                        // even when every byte was delivered — ignore those late errors.
+                        let fileStreamEnded = false;
+                        fileStream.once('end', () => {
+                            fileStreamEnded = true;
+                        });
+                        fileStream.on('error', (err) => {
+                            if (fileStreamEnded)
+                                return;
+                            if (!progress.destroyed)
+                                progress.destroy(err);
+                        });
+                        resolvedStream = progress;
                     }
                     else {
-                        reject(new DaytonaError(`No file data received for: ${remotePath}`));
+                        resolvedStream = fileStream;
                     }
+                    resolve(resolvedStream);
+                })
+                    .then(() => {
+                    if (!resolvedStream) {
+                        const metadata = metadataMap.get(remotePath);
+                        if (metadata?.error) {
+                            reject(createFileDownloadError(metadata.error, metadata.errorDetails));
+                        }
+                        else {
+                            reject(new DaytonaError(`No file data received for: ${remotePath}`));
+                        }
+                    }
+                })
+                    .catch((err) => {
+                    const normalizedError = options.signal?.aborted || isCanceledError(err) ? toDownloadCancelledError() : err;
+                    if (!resolvedStream) {
+                        reject(normalizedError);
+                        return;
+                    }
+                    const stream = resolvedStream;
+                    if (stream.destroyed || stream.readableEnded) {
+                        return;
+                    }
+                    stream.destroy(normalizedError instanceof Error ? normalizedError : new Error(String(normalizedError)));
+                });
+            });
+        }
+        /**
+         * Downloads multiple files from the Sandbox. If the files already exist locally, they will be overwritten.
+         *
+         * @param {FileDownloadRequest[]} files - Array of file download requests.
+         * @param {number} [timeoutSec] - Timeout for the download operation in seconds. 0 means no timeout.
+         * Default is 30 minutes.
+         * @returns {Promise<FileDownloadResponse[]>} Array of download results.
+         *
+         * @throws {DaytonaError} If the request itself fails (network issues, invalid request/response, etc.). Individual
+         * file download errors are returned in `FileDownloadResponse.error`. When the daemon provides structured
+         * per-file metadata, it is also available in `FileDownloadResponse.errorDetails`.
+         *
+         * @example
+         * // Download multiple files
+         * const results = await fs.downloadFiles([
+         *   { source: 'tmp/data.json' },
+         *   { source: 'tmp/config.json', destination: 'local_config.json' }
+         * ]);
+         * results.forEach(result => {
+         *   if (result.error) {
+         *     console.error(`Error downloading ${result.source}: ${result.error}`);
+         *   } else if (result.result) {
+         *     console.log(`Downloaded ${result.source} to ${result.result}`);
+         *   }
+         * });
+         */
+        async downloadFiles(files, timeoutSec = 30 * 60) {
+            if (files.length === 0)
+                return [];
+            const isNonStreamingRuntime = RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS;
+            // Prepare destinations and metadata
+            const metadataMap = new Map();
+            for (const f of files) {
+                metadataMap.set(f.source, { destination: f.destination });
+                if (f.destination) {
+                    const fs = await dynamicImport('fs', 'Downloading files to local files is not supported: ');
+                    await fs.promises.mkdir(pathe.dirname(f.destination), { recursive: true });
                 }
-            })
-                .catch((err) => {
-                const normalizedError = options.signal?.aborted || isCanceledError(err) ? toDownloadCancelledError() : err;
-                if (!resolvedStream) {
-                    reject(normalizedError);
-                    return;
-                }
-                const stream = resolvedStream;
-                if (stream.destroyed || stream.readableEnded) {
-                    return;
-                }
-                stream.destroy(normalizedError instanceof Error ? normalizedError : new Error(String(normalizedError)));
+            }
+            const response = await this.apiClient.downloadFiles({ paths: files.map((f) => f.source) }, {
+                responseType: isNonStreamingRuntime ? 'arraybuffer' : 'stream',
+                timeout: timeoutSec * 1000,
             });
-        });
-    }
-    /**
-     * Downloads multiple files from the Sandbox. If the files already exist locally, they will be overwritten.
-     *
-     * @param {FileDownloadRequest[]} files - Array of file download requests.
-     * @param {number} [timeoutSec] - Timeout for the download operation in seconds. 0 means no timeout.
-     * Default is 30 minutes.
-     * @returns {Promise<FileDownloadResponse[]>} Array of download results.
-     *
-     * @throws {DaytonaError} If the request itself fails (network issues, invalid request/response, etc.). Individual
-     * file download errors are returned in `FileDownloadResponse.error`. When the daemon provides structured
-     * per-file metadata, it is also available in `FileDownloadResponse.errorDetails`.
-     *
-     * @example
-     * // Download multiple files
-     * const results = await fs.downloadFiles([
-     *   { source: 'tmp/data.json' },
-     *   { source: 'tmp/config.json', destination: 'local_config.json' }
-     * ]);
-     * results.forEach(result => {
-     *   if (result.error) {
-     *     console.error(`Error downloading ${result.source}: ${result.error}`);
-     *   } else if (result.result) {
-     *     console.log(`Downloaded ${result.source} to ${result.result}`);
-     *   }
-     * });
-     */
-    async downloadFiles(files, timeoutSec = 30 * 60) {
-        if (files.length === 0)
-            return [];
-        const isNonStreamingRuntime = RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS;
-        // Prepare destinations and metadata
-        const metadataMap = new Map();
-        for (const f of files) {
-            metadataMap.set(f.source, { destination: f.destination });
-            if (f.destination) {
-                const fs = await dynamicImport('fs', 'Downloading files to local files is not supported: ');
-                await fs.promises.mkdir(pathe.dirname(f.destination), { recursive: true });
+            const stream = normalizeResponseStream(response.data);
+            // Node.js path: use busboy for efficient streaming
+            if (isNonStreamingRuntime) {
+                await processDownloadFilesResponseWithBuffered(stream, response.headers, metadataMap);
+            }
+            else {
+                await processDownloadFilesResponseWithBusboy(stream, response.headers, metadataMap);
             }
+            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,
+                    errorDetails: error ? metadata?.errorDetails : undefined,
+                };
+            });
+        }
+        /**
+         * Searches for text patterns within files in the Sandbox.
+         *
+         * @param {string} path - Directory to search in. Relative paths are resolved based on the sandbox working directory.
+         * @param {string} pattern - Search pattern
+         * @returns {Promise<Array<Match>>} Array of matches with file and line information
+         *
+         * @example
+         * // Find all TODO comments in TypeScript files
+         * const matches = await fs.findFiles('app/src', 'TODO:');
+         * matches.forEach(match => {
+         *   console.log(`${match.file}:${match.line}: ${match.content}`);
+         * });
+         */
+        async findFiles(path, pattern) {
+            const response = await this.apiClient.findInFiles(path, pattern);
+            return response.data;
         }
-        const response = await this.apiClient.downloadFiles({ paths: files.map((f) => f.source) }, {
-            responseType: isNonStreamingRuntime ? 'arraybuffer' : 'stream',
-            timeout: timeoutSec * 1000,
-        });
-        const stream = normalizeResponseStream(response.data);
-        // Node.js path: use busboy for efficient streaming
-        if (isNonStreamingRuntime) {
-            await processDownloadFilesResponseWithBuffered(stream, response.headers, metadataMap);
+        /**
+         * Retrieves detailed information about a file or directory.
+         *
+         * @param {string} path - Path to the file or directory. Relative paths are resolved based on the sandbox working directory.
+         * @returns {Promise<FileInfo>} Detailed file information including size, permissions, modification time
+         *
+         * @example
+         * // Get file details
+         * const info = await fs.getFileDetails('app/config.json');
+         * console.log(`Size: ${info.size}, Modified: ${info.modTime}`);
+         */
+        async getFileDetails(path) {
+            const response = await this.apiClient.getFileInfo(path);
+            return response.data;
         }
-        else {
-            await processDownloadFilesResponseWithBusboy(stream, response.headers, metadataMap);
+        /**
+         * Lists contents of a directory in the Sandbox.
+         *
+         * @param {string} path - Directory path to list. Relative paths are resolved based on the sandbox working directory.
+         * @returns {Promise<FileInfo[]>} Array of file and directory information
+         *
+         * @example
+         * // List directory contents
+         * const files = await fs.listFiles('app/src');
+         * files.forEach(file => {
+         *   console.log(`${file.name} (${file.size} bytes)`);
+         * });
+         */
+        async listFiles(path) {
+            const response = await this.apiClient.listFiles(path);
+            return response.data;
         }
-        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,
-                errorDetails: error ? metadata?.errorDetails : undefined,
+        /**
+         * Moves or renames a file or directory.
+         *
+         * @param {string} source - Source path. Relative paths are resolved based on the sandbox working directory.
+         * @param {string} destination - Destination path. Relative paths are resolved based on the sandbox working directory.
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Move a file to a new location
+         * await fs.moveFiles('app/temp/data.json', 'app/data/data.json');
+         */
+        async moveFiles(source, destination) {
+            const response = await this.apiClient.moveFile(source, destination);
+            return response.data;
+        }
+        /**
+         * Replaces text content in multiple files.
+         *
+         * @param {string[]} files - Array of file paths to process. Relative paths are resolved based on the sandbox working directory.
+         * @param {string} pattern - Pattern to replace
+         * @param {string} newValue - Replacement text
+         * @returns {Promise<Array<ReplaceResult>>} Results of the replace operation for each file
+         *
+         * @example
+         * // Update version number across multiple files
+         * const results = await fs.replaceInFiles(
+         *   ['app/package.json', 'app/version.ts'],
+         *   '"version": "1.0.0"',
+         *   '"version": "1.1.0"'
+         * );
+         */
+        async replaceInFiles(files, pattern, newValue) {
+            const replaceRequest = {
+                files,
+                newValue,
+                pattern,
             };
-        });
-    }
-    /**
-     * Searches for text patterns within files in the Sandbox.
-     *
-     * @param {string} path - Directory to search in. Relative paths are resolved based on the sandbox working directory.
-     * @param {string} pattern - Search pattern
-     * @returns {Promise<Array<Match>>} Array of matches with file and line information
-     *
-     * @example
-     * // Find all TODO comments in TypeScript files
-     * const matches = await fs.findFiles('app/src', 'TODO:');
-     * matches.forEach(match => {
-     *   console.log(`${match.file}:${match.line}: ${match.content}`);
-     * });
-     */
-    async findFiles(path, pattern) {
-        const response = await this.apiClient.findInFiles(path, pattern);
-        return response.data;
-    }
-    /**
-     * Retrieves detailed information about a file or directory.
-     *
-     * @param {string} path - Path to the file or directory. Relative paths are resolved based on the sandbox working directory.
-     * @returns {Promise<FileInfo>} Detailed file information including size, permissions, modification time
-     *
-     * @example
-     * // Get file details
-     * const info = await fs.getFileDetails('app/config.json');
-     * console.log(`Size: ${info.size}, Modified: ${info.modTime}`);
-     */
-    async getFileDetails(path) {
-        const response = await this.apiClient.getFileInfo(path);
-        return response.data;
-    }
-    /**
-     * Lists contents of a directory in the Sandbox.
-     *
-     * @param {string} path - Directory path to list. Relative paths are resolved based on the sandbox working directory.
-     * @returns {Promise<FileInfo[]>} Array of file and directory information
-     *
-     * @example
-     * // List directory contents
-     * const files = await fs.listFiles('app/src');
-     * files.forEach(file => {
-     *   console.log(`${file.name} (${file.size} bytes)`);
-     * });
-     */
-    async listFiles(path) {
-        const response = await this.apiClient.listFiles(path);
-        return response.data;
-    }
-    /**
-     * Moves or renames a file or directory.
-     *
-     * @param {string} source - Source path. Relative paths are resolved based on the sandbox working directory.
-     * @param {string} destination - Destination path. Relative paths are resolved based on the sandbox working directory.
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Move a file to a new location
-     * await fs.moveFiles('app/temp/data.json', 'app/data/data.json');
-     */
-    async moveFiles(source, destination) {
-        const response = await this.apiClient.moveFile(source, destination);
-        return response.data;
-    }
-    /**
-     * Replaces text content in multiple files.
-     *
-     * @param {string[]} files - Array of file paths to process. Relative paths are resolved based on the sandbox working directory.
-     * @param {string} pattern - Pattern to replace
-     * @param {string} newValue - Replacement text
-     * @returns {Promise<Array<ReplaceResult>>} Results of the replace operation for each file
-     *
-     * @example
-     * // Update version number across multiple files
-     * const results = await fs.replaceInFiles(
-     *   ['app/package.json', 'app/version.ts'],
-     *   '"version": "1.0.0"',
-     *   '"version": "1.1.0"'
-     * );
-     */
-    async replaceInFiles(files, pattern, newValue) {
-        const replaceRequest = {
-            files,
-            newValue,
-            pattern,
-        };
-        const response = await this.apiClient.replaceInFiles(replaceRequest);
-        return response.data;
-    }
-    /**
-     * Searches for files and directories by name pattern in the Sandbox.
-     *
-     * @param {string} path - Directory to search in. Relative paths are resolved based on the sandbox working directory.
-     * @param {string} pattern - File name pattern (supports globs)
-     * @returns {Promise<SearchFilesResponse>} Search results with matching files
-     *
-     * @example
-     * // Find all TypeScript files
-     * const result = await fs.searchFiles('app', '*.ts');
-     * result.files.forEach(file => console.log(file));
-     */
-    async searchFiles(path, pattern) {
-        const response = await this.apiClient.searchFiles(path, pattern);
-        return response.data;
-    }
-    /**
-     * Sets permissions and ownership for a file or directory.
-     *
-     * @param {string} path - Path to the file or directory. Relative paths are resolved based on the sandbox working directory.
-     * @param {FilePermissionsParams} permissions - Permission settings
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Set file permissions and ownership
-     * await fs.setFilePermissions('app/script.sh', {
-     *   owner: 'daytona',
-     *   group: 'users',
-     *   mode: '755'  // Execute permission for shell script
-     * });
-     */
-    async setFilePermissions(path, permissions) {
-        const response = await this.apiClient.setFilePermissions(path, permissions.owner, permissions.group, permissions.mode);
-        return response.data;
-    }
-    async uploadFile(src, dst, timeout = 30 * 60) {
-        await this.uploadFiles([{ source: src, destination: dst }], timeout);
-    }
-    /**
-     * Uploads a single file to the Sandbox using true streaming, with optional progress
-     * tracking and cancellation. Memory usage stays flat regardless of source size: the
-     * SDK pipes the source through a transform that counts bytes and forwards to the
-     * underlying multipart upload without buffering the whole payload. The HTTP layer
-     * uses chunked transfer encoding, so the source's natural EOF terminates the upload —
-     * no advance size is needed.
-     *
-     * @param {UploadSource} source - The data to upload. Accepts the same `Buffer | string`
-     *   inputs as {@link FileSystem.uploadFile}, plus Node `Readable` streams and Web
-     *   `ReadableStream` instances. When a string is passed, it is treated as a local
-     *   file path and read in streaming chunks.
-     * @param {string} remotePath - Destination path in the Sandbox. Relative paths are
-     *   resolved against the sandbox working directory.
-     * @param {UploadStreamOptions} [options] - Streaming options: AbortSignal, onProgress
-     *   callback, timeout.
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Upload a 2 GB file with progress tracking and the ability to cancel
-     * import { createReadStream } from 'fs';
-     * const controller = new AbortController();
-     * await sandbox.fs.uploadFileStream(createReadStream('big.bin'), 'tmp/big.bin', {
-     *   signal: controller.signal,
-     *   onProgress: ({ bytesSent }) => console.log(`${bytesSent} bytes sent`),
-     * });
-     */
-    async uploadFileStream(source, remotePath, options = {}) {
-        const isNonStreamingRuntime = RUNTIME === Runtime.DENO || RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS;
-        if (isNonStreamingRuntime) {
-            throw new DaytonaError('uploadFileStream is not supported in browser, Deno, or serverless runtimes. Use uploadFile instead.');
+            const response = await this.apiClient.replaceInFiles(replaceRequest);
+            return response.data;
         }
-        if (options.signal?.aborted) {
-            throw createAbortError(remotePath);
+        /**
+         * Searches for files and directories by name pattern in the Sandbox.
+         *
+         * @param {string} path - Directory to search in. Relative paths are resolved based on the sandbox working directory.
+         * @param {string} pattern - File name pattern (supports globs)
+         * @returns {Promise<SearchFilesResponse>} Search results with matching files
+         *
+         * @example
+         * // Find all TypeScript files
+         * const result = await fs.searchFiles('app', '*.ts');
+         * result.files.forEach(file => console.log(file));
+         */
+        async searchFiles(path, pattern) {
+            const response = await this.apiClient.searchFiles(path, pattern);
+            return response.data;
         }
-        const timeout = options.timeout ?? 30 * 60;
-        const sourceStream = await coerceUploadSource(source);
-        const tracked = wrapWithUploadProgress(sourceStream, options.onProgress, options.signal);
-        const FormDataClass = (await dynamicImport('form-data', 'Uploading files is not supported: '));
-        const form = new FormDataClass();
-        form.append('files[0].path', remotePath);
-        // No knownLength: form-data falls back to chunked transfer encoding, which the
-        // daemon's MultipartReader handles transparently. The source's EOF terminates
-        // the upload — no advance byte count needed.
-        form.append('files[0].file', tracked, { filename: remotePath });
-        try {
-            await this.apiClient.uploadFiles({
-                data: form,
-                maxRedirects: 0,
-                timeout: timeout * 1000,
-                signal: options.signal,
-            });
+        /**
+         * Sets permissions and ownership for a file or directory.
+         *
+         * @param {string} path - Path to the file or directory. Relative paths are resolved based on the sandbox working directory.
+         * @param {FilePermissionsParams} permissions - Permission settings
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Set file permissions and ownership
+         * await fs.setFilePermissions('app/script.sh', {
+         *   owner: 'daytona',
+         *   group: 'users',
+         *   mode: '755'  // Execute permission for shell script
+         * });
+         */
+        async setFilePermissions(path, permissions) {
+            const response = await this.apiClient.setFilePermissions(path, permissions.owner, permissions.group, permissions.mode);
+            return response.data;
+        }
+        async uploadFile(src, dst, timeout = 30 * 60) {
+            await this.uploadFiles([{ source: src, destination: dst }], timeout);
         }
-        catch (err) {
+        /**
+         * Uploads a single file to the Sandbox using true streaming, with optional progress
+         * tracking and cancellation. Memory usage stays flat regardless of source size: the
+         * SDK pipes the source through a transform that counts bytes and forwards to the
+         * underlying multipart upload without buffering the whole payload. The HTTP layer
+         * uses chunked transfer encoding, so the source's natural EOF terminates the upload —
+         * no advance size is needed.
+         *
+         * @param {UploadSource} source - The data to upload. Accepts the same `Buffer | string`
+         *   inputs as {@link FileSystem.uploadFile}, plus Node `Readable` streams and Web
+         *   `ReadableStream` instances. When a string is passed, it is treated as a local
+         *   file path and read in streaming chunks.
+         * @param {string} remotePath - Destination path in the Sandbox. Relative paths are
+         *   resolved against the sandbox working directory.
+         * @param {UploadStreamOptions} [options] - Streaming options: AbortSignal, onProgress
+         *   callback, timeout.
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Upload a 2 GB file with progress tracking and the ability to cancel
+         * import { createReadStream } from 'fs';
+         * const controller = new AbortController();
+         * await sandbox.fs.uploadFileStream(createReadStream('big.bin'), 'tmp/big.bin', {
+         *   signal: controller.signal,
+         *   onProgress: ({ bytesSent }) => console.log(`${bytesSent} bytes sent`),
+         * });
+         */
+        async uploadFileStream(source, remotePath, options = {}) {
+            const isNonStreamingRuntime = RUNTIME === Runtime.DENO || RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS;
+            if (isNonStreamingRuntime) {
+                throw new DaytonaError('uploadFileStream is not supported in browser, Deno, or serverless runtimes. Use uploadFile instead.');
+            }
             if (options.signal?.aborted) {
                 throw createAbortError(remotePath);
             }
-            throw err;
-        }
-    }
-    /**
-     * Uploads multiple files to the Sandbox. If files already exist at the destination paths,
-     * they will be overwritten.
-     *
-     * @param {FileUpload[]} files - Array of files to upload.
-     * @param {number} [timeout] - Timeout for the upload operation in seconds. 0 means no timeout.
-     * Default is 30 minutes.
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Upload multiple text files
-     * const files = [
-     *   {
-     *     source: Buffer.from('Content of file 1'),
-     *     destination: '/tmp/file1.txt'
-     *   },
-     *   {
-     *     source: 'app/data/file2.txt',
-     *     destination: '/tmp/file2.txt'
-     *   },
-     *   {
-     *     source: Buffer.from('{"key": "value"}'),
-     *     destination: '/tmp/config.json'
-     *   }
-     * ];
-     * await fs.uploadFiles(files);
-     */
-    async uploadFiles(files, timeout = 30 * 60) {
-        const isNonStreamingRuntime = RUNTIME === Runtime.DENO || RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS;
-        const FormDataClass = isNonStreamingRuntime
-            ? FormData
-            : (await 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);
-            form.append(`files[${i}].file`, payload, destination);
-        }
-        if (isNonStreamingRuntime) {
-            const url = `${this.clientConfig.basePath}/files/bulk-upload`;
-            await fetch(url, {
-                method: 'POST',
-                headers: this.clientConfig.baseOptions.headers,
-                body: form,
-                signal: timeout ? AbortSignal.timeout(timeout * 1000) : undefined,
-            });
-        }
-        else {
-            await this.apiClient.uploadFiles({
-                data: form,
-                maxRedirects: 0,
-                timeout: timeout * 1000,
-            });
+            const timeout = options.timeout ?? 30 * 60;
+            const sourceStream = await coerceUploadSource(source);
+            const tracked = wrapWithUploadProgress(sourceStream, options.onProgress, options.signal);
+            const FormDataClass = (await dynamicImport('form-data', 'Uploading files is not supported: '));
+            const form = new FormDataClass();
+            form.append('files[0].path', remotePath);
+            // No knownLength: form-data falls back to chunked transfer encoding, which the
+            // daemon's MultipartReader handles transparently. The source's EOF terminates
+            // the upload — no advance byte count needed.
+            form.append('files[0].file', tracked, { filename: remotePath });
+            try {
+                await this.apiClient.uploadFiles({
+                    data: form,
+                    maxRedirects: 0,
+                    timeout: timeout * 1000,
+                    signal: options.signal,
+                });
+            }
+            catch (err) {
+                if (options.signal?.aborted) {
+                    throw createAbortError(remotePath);
+                }
+                throw err;
+            }
         }
-    }
-    async makeFilePayload(source) {
-        // String = file path
-        if (typeof source === 'string') {
-            const fs = await dynamicImport('fs', 'Uploading file from local file system is not supported: ');
-            return fs.createReadStream(source);
+        /**
+         * Uploads multiple files to the Sandbox. If files already exist at the destination paths,
+         * they will be overwritten.
+         *
+         * @param {FileUpload[]} files - Array of files to upload.
+         * @param {number} [timeout] - Timeout for the upload operation in seconds. 0 means no timeout.
+         * Default is 30 minutes.
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Upload multiple text files
+         * const files = [
+         *   {
+         *     source: Buffer.from('Content of file 1'),
+         *     destination: '/tmp/file1.txt'
+         *   },
+         *   {
+         *     source: 'app/data/file2.txt',
+         *     destination: '/tmp/file2.txt'
+         *   },
+         *   {
+         *     source: Buffer.from('{"key": "value"}'),
+         *     destination: '/tmp/config.json'
+         *   }
+         * ];
+         * await fs.uploadFiles(files);
+         */
+        async uploadFiles(files, timeout = 30 * 60) {
+            const isNonStreamingRuntime = RUNTIME === Runtime.DENO || RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS;
+            const FormDataClass = isNonStreamingRuntime
+                ? FormData
+                : (await 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);
+                form.append(`files[${i}].file`, payload, destination);
+            }
+            if (isNonStreamingRuntime) {
+                const url = `${this.clientConfig.basePath}/files/bulk-upload`;
+                await fetch(url, {
+                    method: 'POST',
+                    headers: this.clientConfig.baseOptions.headers,
+                    body: form,
+                    signal: timeout ? AbortSignal.timeout(timeout * 1000) : undefined,
+                });
+            }
+            else {
+                await this.apiClient.uploadFiles({
+                    data: form,
+                    maxRedirects: 0,
+                    timeout: timeout * 1000,
+                });
+            }
         }
-        // Blob
-        if (RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS || RUNTIME === Runtime.DENO) {
-            // Use .slice() to ensure we have a concrete ArrayBuffer, not ArrayBufferLike
-            return new Blob([source.slice()], { type: 'application/octet-stream' });
+        async makeFilePayload(source) {
+            // String = file path
+            if (typeof source === 'string') {
+                const fs = await dynamicImport('fs', 'Uploading file from local file system is not supported: ');
+                return fs.createReadStream(source);
+            }
+            // Blob
+            if (RUNTIME === Runtime.BROWSER || RUNTIME === Runtime.SERVERLESS || RUNTIME === Runtime.DENO) {
+                // Use .slice() to ensure we have a concrete ArrayBuffer, not ArrayBufferLike
+                return new Blob([source.slice()], { type: 'application/octet-stream' });
+            }
+            // Readable stream
+            const stream = await dynamicImport('stream', 'Uploading file is not supported: ');
+            return stream.Readable.from(source);
         }
-        // Readable stream
-        const stream = await dynamicImport('stream', 'Uploading file is not supported: ');
-        return stream.Readable.from(source);
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "createFolder", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Boolean]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "deleteFile", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Number]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "downloadFile", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "downloadFileStream", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Number]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "downloadFiles", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "findFiles", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "getFileDetails", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "listFiles", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "moveFiles", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, String, String]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "replaceInFiles", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "searchFiles", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "setFilePermissions", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, String, Number]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "uploadFile", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, String, Object]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "uploadFileStream", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Number]),
-    __metadata("design:returntype", Promise)
-], FileSystem.prototype, "uploadFiles", null);
+    };
+})();
+export { FileSystem };
 //# sourceMappingURL=FileSystem.js.map