@daytonaio/sdk 0.18.0-alpha.1 → 0.18.0-alpha.2

package/dist/Daytona.d.ts

@@ -1,5 +1,4 @@
 import { CreateWorkspaceTargetEnum as SandboxTargetRegion, WorkspaceVolume } from '@daytonaio/api-client';
-import { Image } from './Image';
 import { Sandbox, Sandbox as Workspace } from './Sandbox';
 import { VolumeService } from './Volume';
 /**
@@ -89,7 +88,7 @@ export interface SandboxResources {
  * Parameters for creating a new Sandbox.
  *
  * @interface
- * @property {string | Image} [image] - Optional Docker image to use for the Sandbox or an Image instance
+ * @property {string} [image] - Optional Docker image to use for the Sandbox
  * @property {string} [user] - Optional os user to use for the Sandbox
  * @property {CodeLanguage | string} [language] - Programming language for direct code execution
  * @property {Record<string, string>} [envVars] - Optional environment variables to set in the Sandbox
@@ -114,8 +113,8 @@ export interface SandboxResources {
  * const sandbox = await daytona.create(params, 50);
  */
 export type CreateSandboxParams = {
-    /** Optional Docker image to use for the Sandbox or an Image instance */
-    image?: string | Image;
+    /** Optional Docker image to use for the Sandbox */
+    image?: string;
     /** Optional os user to use for the Sandbox */
     user?: string;
     /** Programming language for direct code execution */
@@ -180,8 +179,6 @@ export type SandboxFilter = {
 export declare class Daytona {
     private readonly sandboxApi;
     private readonly toolboxApi;
-    private readonly imagesApi;
-    private readonly objectStorageApi;
     private readonly target;
     private readonly apiKey?;
     private readonly jwtToken?;
@@ -196,8 +193,6 @@ export declare class Daytona {
      */
     constructor(config?: DaytonaConfig);
     /**
-     * @deprecated Use `create` with `options` object instead. This method will be removed in a future version.
-     *
      * Creates Sandboxes with default or custom configurations. You can specify various parameters,
      * including language, image, resources, environment variables, and volumes for the Sandbox.
      *
@@ -226,45 +221,7 @@ export declare class Daytona {
      * };
      * const sandbox = await daytona.create(params, 40);
      */
-    create(params?: CreateSandboxParams, options?: number): Promise<Sandbox>;
-    /**
-     * Creates Sandboxes with default or custom configurations. You can specify various parameters,
-     * including language, image, resources, environment variables, and volumes for the Sandbox.
-     *
-     * @param {CreateSandboxParams} [params] - Parameters for Sandbox creation
-     * @param {object} [options] - Options for the create operation
-     * @param {number} [options.timeout] - Timeout in seconds (0 means no timeout, default is 60)
-     * @param {function} [options.onImageBuildLogs] - Callback function to handle image build logs.
-     * It's invoked only when `params.image` is an instance of `Image` and there's no existing
-     * image in Daytona with the same configuration.
-     * @returns {Promise<Sandbox>} The created Sandbox instance
-     *
-     * @example
-     * const image = Image.debianSlim('3.12').pipInstall('numpy');
-     * const sandbox = await daytona.create({ image }, { timeout: 90, onImageBuildLogs: console.log });
-     *
-     * @example
-     * // Create a custom sandbox
-     * const image = Image.debianSlim('3.12').pipInstall('numpy');
-     * const params: CreateSandboxParams = {
-     *     language: 'typescript',
-     *     image,
-     *     envVars: {
-     *         NODE_ENV: 'development',
-     *         DEBUG: 'true'
-     *     },
-     *     resources: {
-     *         cpu: 2,
-     *         memory: 4 // 4GB RAM
-     *     },
-     *     autoStopInterval: 60
-     * };
-     * const sandbox = await daytona.create(params, { timeout: 100, onImageBuildLogs: console.log });
-     */
-    create(params?: CreateSandboxParams, options?: {
-        onImageBuildLogs?: (chunk: string) => void;
-        timeout?: number;
-    }): Promise<Sandbox>;
+    create(params?: CreateSandboxParams, timeout?: number): Promise<Sandbox>;
     /**
      * Gets a Sandbox by its ID.
      *
@@ -358,24 +315,6 @@ export declare class Daytona {
      * console.log(`Current sandbox state: ${sandbox.instance.state}`);
      */
     getCurrentSandbox(sandboxId: string): Promise<Sandbox>;
-    /**
-     * Creates and registers a new image from the given Image definition.
-     *
-     * @param {string} name - The name of the image to create.
-     * @param {Image} image - The Image instance.
-     * @param {object} options - Options for the create operation.
-     * @param {boolean} options.verbose - Default is false. Whether to log progress information upon each state change of the image.
-     * @param {number} options.timeout - Default is no timeout. Timeout in seconds (0 means no timeout).
-     * @returns {Promise<void>}
-     *
-     * @example
-     * const image = Image.debianSlim('3.12').pipInstall('numpy');
-     * await daytona.createImage('my-python-image', image);
-     */
-    createImage(name: string, image: Image, options?: {
-        onLogs?: (chunk: string) => void;
-        timeout?: number;
-    }): Promise<void>;
     /**
      * Gets the appropriate code toolbox based on language.
      *
@@ -385,12 +324,4 @@ export declare class Daytona {
      * @throws {DaytonaError} - `DaytonaError` - When an unsupported language is specified
      */
     private getCodeToolbox;
-    /**
-     * Processes the image contexts by uploading them to object storage
-     *
-     * @private
-     * @param {Image} image - The Image instance.
-     * @returns {Promise<string[]>} The list of context hashes stored in object storage.
-     */
-    private processImageContext;
 }

package/dist/Daytona.js

@@ -43,10 +43,7 @@ const dotenv_1 = __importDefault(require("dotenv"));
 const SandboxPythonCodeToolbox_1 = require("./code-toolbox/SandboxPythonCodeToolbox");
 const SandboxTsCodeToolbox_1 = require("./code-toolbox/SandboxTsCodeToolbox");
 const DaytonaError_1 = require("./errors/DaytonaError");
-const Image_1 = require("./Image");
-const ObjectStorage_1 = require("./ObjectStorage");
 const Sandbox_1 = require("./Sandbox");
-const Stream_1 = require("./utils/Stream");
 const Volume_1 = require("./Volume");
 /**
  * Supported programming languages for code execution
@@ -161,16 +158,39 @@ class Daytona {
         this.sandboxApi = new api_client_1.WorkspaceApi(configuration, '', axiosInstance);
         this.toolboxApi = new api_client_1.ToolboxApi(configuration, '', axiosInstance);
         this.volume = new Volume_1.VolumeService(new api_client_1.VolumesApi(configuration, '', axiosInstance));
-        this.imagesApi = new api_client_1.ImagesApi(configuration, '', axiosInstance);
-        this.objectStorageApi = new api_client_1.ObjectStorageApi(configuration, '', axiosInstance);
     }
-    async create(params, options = { timeout: 60 }) {
+    /**
+     * Creates Sandboxes with default or custom configurations. You can specify various parameters,
+     * including language, image, resources, environment variables, and volumes for the Sandbox.
+     *
+     * @param {CreateSandboxParams} [params] - Parameters for Sandbox creation
+     * @param {number} [timeout] - Timeout in seconds (0 means no timeout, default is 60)
+     * @returns {Promise<Sandbox>} The created Sandbox instance
+     *
+     * @example
+     * // Create a default sandbox
+     * const sandbox = await daytona.create();
+     *
+     * @example
+     * // Create a custom sandbox
+     * const params: CreateSandboxParams = {
+     *     language: 'typescript',
+     *     image: 'node:18',
+     *     envVars: {
+     *         NODE_ENV: 'development',
+     *         DEBUG: 'true'
+     *     },
+     *     resources: {
+     *         cpu: 2,
+     *         memory: 4 // 4GB RAM
+     *     },
+     *     autoStopInterval: 60
+     * };
+     * const sandbox = await daytona.create(params, 40);
+     */
+    async create(params, timeout = 60) {
         var _a, _b, _c, _d;
         const startTime = Date.now();
-        options = typeof options === 'number' ? { timeout: options } : { ...options };
-        if (options.timeout == undefined || options.timeout == null) {
-            options.timeout = 60;
-        }
         if (params == null) {
             params = { language: 'python' };
         }
@@ -179,7 +199,7 @@ class Daytona {
             labels['code-toolbox-language'] = params.language;
         }
         // remove this when params.timeout is removed
-        const effectiveTimeout = params.timeout || options.timeout;
+        const effectiveTimeout = params.timeout || timeout;
         if (effectiveTimeout < 0) {
             throw new DaytonaError_1.DaytonaError('Timeout must be a non-negative number');
         }
@@ -189,22 +209,8 @@ class Daytona {
         }
         const codeToolbox = this.getCodeToolbox(params.language);
         try {
-            // Handle Image instance if provided
-            let imageStr;
-            let buildInfo;
-            if (typeof params.image === 'string') {
-                imageStr = params.image;
-            }
-            else if (params.image instanceof Image_1.Image) {
-                const contextHashes = await this.processImageContext(params.image);
-                buildInfo = {
-                    contextHashes,
-                    dockerfileContent: params.image.dockerfile,
-                };
-            }
             const response = await this.sandboxApi.createWorkspace({
-                image: imageStr,
-                buildInfo,
+                image: params.image,
                 user: params.user,
                 env: params.envVars || {},
                 labels: params.labels,
@@ -219,21 +225,14 @@ class Daytona {
             }, undefined, {
                 timeout: effectiveTimeout * 1000,
             });
-            let sandboxInstance = response.data;
-            if (sandboxInstance.state === api_client_1.WorkspaceState.PENDING_BUILD && options.onImageBuildLogs) {
-                const terminalStates = [api_client_1.WorkspaceState.STARTED, api_client_1.WorkspaceState.STARTING, api_client_1.WorkspaceState.ERROR];
-                await (0, Stream_1.processStreamingResponse)(() => this.sandboxApi.getBuildLogs(sandboxInstance.id, undefined, true, { responseType: 'stream' }), options.onImageBuildLogs, async () => {
-                    sandboxInstance = (await this.sandboxApi.getWorkspace(sandboxInstance.id)).data;
-                    return sandboxInstance.state !== undefined && terminalStates.includes(sandboxInstance.state);
-                });
-            }
+            const sandboxInstance = response.data;
             const sandboxInfo = Sandbox_1.Sandbox.toSandboxInfo(sandboxInstance);
             sandboxInstance.info = {
                 ...sandboxInfo,
                 name: '',
             };
             const sandbox = new Sandbox_1.Sandbox(sandboxInstance.id, sandboxInstance, this.sandboxApi, this.toolboxApi, codeToolbox);
-            if (!params.async && sandbox.instance.state !== 'started') {
+            if (!params.async) {
                 const timeElapsed = Date.now() - startTime;
                 await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - timeElapsed / 1000 : 0);
             }
@@ -379,58 +378,6 @@ class Daytona {
     async getCurrentSandbox(sandboxId) {
         return await this.get(sandboxId);
     }
-    /**
-     * Creates and registers a new image from the given Image definition.
-     *
-     * @param {string} name - The name of the image to create.
-     * @param {Image} image - The Image instance.
-     * @param {object} options - Options for the create operation.
-     * @param {boolean} options.verbose - Default is false. Whether to log progress information upon each state change of the image.
-     * @param {number} options.timeout - Default is no timeout. Timeout in seconds (0 means no timeout).
-     * @returns {Promise<void>}
-     *
-     * @example
-     * const image = Image.debianSlim('3.12').pipInstall('numpy');
-     * await daytona.createImage('my-python-image', image);
-     */
-    async createImage(name, image, options = {}) {
-        const contextHashes = await this.processImageContext(image);
-        let builtImage = (await this.imagesApi.buildImage({
-            name,
-            buildInfo: {
-                contextHashes,
-                dockerfileContent: image.dockerfile,
-            },
-        }, undefined, {
-            timeout: (options.timeout || 0) * 1000,
-        })).data;
-        const terminalStates = [api_client_1.ImageState.ACTIVE, api_client_1.ImageState.ERROR];
-        const imageRef = { builtImage };
-        let streamPromise;
-        if (options.onLogs) {
-            options.onLogs(`Building image ${builtImage.name} (${builtImage.state})`);
-            streamPromise = (0, Stream_1.processStreamingResponse)(() => this.imagesApi.getImageBuildLogs(builtImage.id, undefined, true, { responseType: 'stream' }), options.onLogs, async () => terminalStates.includes(imageRef.builtImage.state));
-        }
-        let previousState = builtImage.state;
-        while (!terminalStates.includes(builtImage.state)) {
-            if (options.onLogs && previousState !== builtImage.state) {
-                options.onLogs(`Building image ${builtImage.name} (${builtImage.state})`);
-                previousState = builtImage.state;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-            builtImage = (await this.imagesApi.getImage(builtImage.id)).data;
-            imageRef.builtImage = builtImage;
-        }
-        if (options.onLogs) {
-            await streamPromise;
-            if (builtImage.state === api_client_1.ImageState.ACTIVE) {
-                options.onLogs(`Built image ${builtImage.name} (${builtImage.state})`);
-            }
-        }
-        if (builtImage.state === api_client_1.ImageState.ERROR) {
-            throw new DaytonaError_1.DaytonaError(`Failed to build image. Image ended in the ERROR state. name: ${builtImage.name}; error reason: ${builtImage.errorReason}`);
-        }
-    }
     /**
      * Gets the appropriate code toolbox based on language.
      *
@@ -451,31 +398,5 @@ class Daytona {
                 throw new DaytonaError_1.DaytonaError(`Unsupported language: ${language}, supported languages: ${Object.values(CodeLanguage).join(', ')}`);
         }
     }
-    /**
-     * Processes the image contexts by uploading them to object storage
-     *
-     * @private
-     * @param {Image} image - The Image instance.
-     * @returns {Promise<string[]>} The list of context hashes stored in object storage.
-     */
-    async processImageContext(image) {
-        if (!image.contextList || !image.contextList.length) {
-            return [];
-        }
-        const pushAccessCreds = (await this.objectStorageApi.getPushAccess()).data;
-        const objectStorage = new ObjectStorage_1.ObjectStorage({
-            endpointUrl: pushAccessCreds.storageUrl,
-            accessKeyId: pushAccessCreds.accessKey,
-            secretAccessKey: pushAccessCreds.secret,
-            sessionToken: pushAccessCreds.sessionToken,
-            bucketName: pushAccessCreds.bucket,
-        });
-        const contextHashes = [];
-        for (const context of image.contextList) {
-            const contextHash = await objectStorage.upload(context.sourcePath, pushAccessCreds.organizationId, context.archivePath);
-            contextHashes.push(contextHash);
-        }
-        return contextHashes;
-    }
 }
 exports.Daytona = Daytona;

package/dist/FileSystem.d.ts

@@ -27,14 +27,14 @@ export type FilePermissionsParams = {
  * Represents a file to be uploaded to the Sandbox.
  *
  * @interface
- * @property {string} path - Absolute destination path in the Sandbox
- * @property {File} content - File to upload
+ * @property {string | Buffer} source - File to upload. If a Buffer, it is interpreted as the file content which is loaded into memory.
+ * Make sure it fits into memory, otherwise use the local file path which content will be streamed to the Sandbox.
+ * @property {string} destination - Absolute destination path in the Sandbox. Relative paths are resolved based on the user's
+ * root directory.
  */
 export interface FileUpload {
-    /** Absolute destination path in the Sandbox */
-    path: string;
-    /** File to upload */
-    content: File;
+    source: string | Buffer;
+    destination: string;
 }
 /**
  * Provides file system operations within a Sandbox.
@@ -72,18 +72,37 @@ export declare class FileSystem {
      */
     deleteFile(path: string): Promise<void>;
     /**
-     * Downloads a file from the Sandbox.
+     * Downloads a file from the Sandbox. This method loads the entire file into memory, so it is not recommended
+     * for downloading large files.
      *
-     * @param {string} path - Path to the file to download. Relative paths are resolved based on the user's
+     * @param {string} remotePath - Path to the file to download. Relative paths are resolved based on the user's
      * root directory.
-     * @returns {Promise<Blob>} The file contents as a Blob
+     * @param {number} [timeout] - Timeout for the download operation in seconds. 0 means no timeout.
+     * Default is 30 minutes.
+     * @returns {Promise<Buffer>} The file contents as a Buffer.
      *
      * @example
      * // Download and process a file
-     * const fileBlob = await fs.downloadFile('app/data.json');
-     * console.log('File content:', fileBlob.toString());
+     * const fileBuffer = await fs.downloadFile('tmp/data.json');
+     * console.log('File content:', fileBuffer.toString());
      */
-    downloadFile(path: string): Promise<Blob>;
+    downloadFile(remotePath: string, timeout?: number): Promise<Buffer>;
+    /**
+     * Downloads a file from the Sandbox and saves it to a local file. This method uses streaming to download the file,
+     * so it is recommended for downloading larger files.
+     *
+     * @param {string} remotePath - Path to the file to download in the Sandbox. Relative paths are resolved based on the user's
+     * root directory.
+     * @param {string} localPath - Path to save the downloaded file.
+     * @param {number} [timeout] - Timeout for the download operation in seconds. 0 means no timeout.
+     * Default is 30 minutes.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Download and save a file
+     * await fs.downloadFile('tmp/data.json', 'local_file.json');
+     */
+    downloadFile(remotePath: string, localPath: string, timeout?: number): Promise<void>;
     /**
      * Searches for text patterns within files in the Sandbox.
      *
@@ -190,44 +209,63 @@ export declare class FileSystem {
      */
     setFilePermissions(path: string, permissions: FilePermissionsParams): Promise<void>;
     /**
-     * Uploads a file to the Sandbox.
+     * Uploads a file to the Sandbox. This method loads the entire file into memory, so it is not recommended
+     * for uploading large files.
      *
+     * @param {Buffer} file - Buffer of the file to upload.
      * @param {string} path - Destination path in the Sandbox. Relative paths are resolved based on the user's
      * root directory.
-     * @param {File} file - File 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 a configuration file
-     * const configFile = new File(['{"setting": "value"}'], 'config.json');
-     * await fs.uploadFile('app/config.json', configFile);
+     * await fs.uploadFile(Buffer.from('{"setting": "value"}'), 'tmp/config.json');
      */
-    uploadFile(path: string, file: File): Promise<void>;
+    uploadFile(file: Buffer, path: string, timeout?: number): Promise<void>;
     /**
-     * Uploads multiple files to the Sandbox. The parent directories must exist.
-     * If files already exist at the destination paths, they will be overwritten.
+     * Uploads a file from the local file system to the Sandbox. This method uses streaming to upload the file,
+     * so it is recommended for uploading larger files.
      *
-     * @param {FileUpload[]} files - Array of files to upload. Relative paths are resolved based on the user's
+     * @param {string} localPath - Path to the local file to upload.
+     * @param {string} remotePath - Destination path in the Sandbox. Relative paths are resolved based on the user's
      * root directory.
+     * @param {number} [timeout] - Timeout for the upload operation in seconds. 0 means no timeout.
+     * Default is 30 minutes.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Upload a local file
+     * await fs.uploadFile('local_file.txt', 'tmp/file.txt');
+     */
+    uploadFile(localPath: string, remotePath: string, timeout?: number): Promise<void>;
+    /**
+     * 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 = [
      *   {
-     *     path: 'app/data/file1.txt',
-     *     content: new File(['Content of file 1'], 'file1.txt')
+     *     source: Buffer.from('Content of file 1'),
+     *     destination: '/tmp/file1.txt'
      *   },
      *   {
-     *     path: 'app/data/file2.txt',
-     *     content: new File(['Content of file 2'], 'file2.txt')
+     *     source: 'app/data/file2.txt',
+     *     destination: '/tmp/file2.txt'
      *   },
      *   {
-     *     path: 'app/config/settings.json',
-     *     content: new File(['{"key": "value"}'], 'settings.json')
+     *     source: Buffer.from('{"key": "value"}'),
+     *     destination: '/tmp/config.json'
      *   }
      * ];
      * await fs.uploadFiles(files);
      */
-    uploadFiles(files: FileUpload[]): Promise<void>;
+    uploadFiles(files: FileUpload[], timeout?: number): Promise<void>;
 }

package/dist/FileSystem.js

@@ -1,8 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSystem = void 0;
-const DaytonaError_1 = require("./errors/DaytonaError");
 const Path_1 = require("./utils/Path");
+const fs_1 = __importDefault(require("fs"));
+const stream_1 = require("stream");
+const form_data_1 = __importDefault(require("form-data"));
 /**
  * Provides file system operations within a Sandbox.
  *
@@ -45,21 +50,29 @@ class FileSystem {
         const response = await this.toolboxApi.deleteFile(this.instance.id, (0, Path_1.prefixRelativePath)(await this.getRootDir(), path));
         return response.data;
     }
-    /**
-     * Downloads a file from the Sandbox.
-     *
-     * @param {string} path - Path to the file to download. Relative paths are resolved based on the user's
-     * root directory.
-     * @returns {Promise<Blob>} The file contents as a Blob
-     *
-     * @example
-     * // Download and process a file
-     * const fileBlob = await fs.downloadFile('app/data.json');
-     * console.log('File content:', fileBlob.toString());
-     */
-    async downloadFile(path) {
-        const response = await this.toolboxApi.downloadFile(this.instance.id, (0, Path_1.prefixRelativePath)(await this.getRootDir(), path));
-        return response.data;
+    async downloadFile(src, dst, timeout = 30 * 60) {
+        const remotePath = (0, Path_1.prefixRelativePath)(await this.getRootDir(), src);
+        if (typeof dst !== 'string') {
+            timeout = dst;
+            const { data } = await this.toolboxApi.downloadFile(this.instance.id, remotePath, undefined, {
+                responseType: 'arraybuffer',
+                timeout: timeout * 1000,
+            });
+            if (Buffer.isBuffer(data)) {
+                return data;
+            }
+            return Buffer.from(await data.arrayBuffer());
+        }
+        const response = await this.toolboxApi.downloadFile(this.instance.id, remotePath, undefined, {
+            responseType: 'stream',
+            timeout: timeout * 1000,
+        });
+        const writer = fs_1.default.createWriteStream(dst);
+        response.data.pipe(writer);
+        await new Promise((resolve, reject) => {
+            writer.on('finish', () => resolve());
+            writer.on('error', (err) => reject(err));
+        });
     }
     /**
      * Searches for text patterns within files in the Sandbox.
@@ -195,64 +208,51 @@ class FileSystem {
         const response = await this.toolboxApi.setFilePermissions(this.instance.id, (0, Path_1.prefixRelativePath)(await this.getRootDir(), path), undefined, permissions.owner, permissions.group, permissions.mode);
         return response.data;
     }
-    /**
-     * Uploads a file to the Sandbox.
-     *
-     * @param {string} path - Destination path in the Sandbox. Relative paths are resolved based on the user's
-     * root directory.
-     * @param {File} file - File to upload
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Upload a configuration file
-     * const configFile = new File(['{"setting": "value"}'], 'config.json');
-     * await fs.uploadFile('app/config.json', configFile);
-     */
-    async uploadFile(path, file) {
-        const response = await this.toolboxApi.uploadFile(this.instance.id, (0, Path_1.prefixRelativePath)(await this.getRootDir(), path), undefined, file);
-        return response.data;
+    async uploadFile(src, dst, timeout = 30 * 60) {
+        this.uploadFiles([{ source: src, destination: dst }], timeout);
     }
     /**
-     * Uploads multiple files to the Sandbox. The parent directories must exist.
-     * If files already exist at the destination paths, they will be overwritten.
+     * 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. Relative paths are resolved based on the user's
-     * root directory.
+     * @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 = [
      *   {
-     *     path: 'app/data/file1.txt',
-     *     content: new File(['Content of file 1'], 'file1.txt')
+     *     source: Buffer.from('Content of file 1'),
+     *     destination: '/tmp/file1.txt'
      *   },
      *   {
-     *     path: 'app/data/file2.txt',
-     *     content: new File(['Content of file 2'], 'file2.txt')
+     *     source: 'app/data/file2.txt',
+     *     destination: '/tmp/file2.txt'
      *   },
      *   {
-     *     path: 'app/config/settings.json',
-     *     content: new File(['{"key": "value"}'], 'settings.json')
+     *     source: Buffer.from('{"key": "value"}'),
+     *     destination: '/tmp/config.json'
      *   }
      * ];
      * await fs.uploadFiles(files);
      */
-    async uploadFiles(files) {
-        for (const file of files) {
-            file.path = (0, Path_1.prefixRelativePath)(await this.getRootDir(), file.path);
-        }
-        const results = await Promise.allSettled(files.map((file) => this.uploadFile(file.path, file.content)));
-        const failedUploads = results
-            .map((result, index) => ({
-            path: files[index].path,
-            error: result.status === 'rejected' ? result.reason : undefined,
-        }))
-            .filter(({ error }) => error !== undefined);
-        if (failedUploads.length > 0) {
-            const errorMessage = failedUploads.map(({ path, error }) => `\nFailed to upload '${path}': ${error}`).join('');
-            throw new DaytonaError_1.DaytonaError(errorMessage);
-        }
+    async uploadFiles(files, timeout = 30 * 60) {
+        const form = new form_data_1.default();
+        const rootDir = await this.getRootDir();
+        files.forEach(({ source, destination }, i) => {
+            const dst = (0, Path_1.prefixRelativePath)(rootDir, destination);
+            form.append(`files[${i}].path`, dst);
+            const stream = typeof source === 'string' ? fs_1.default.createReadStream(source) : stream_1.Readable.from(source);
+            // the third arg sets filename in Content-Disposition
+            form.append(`files[${i}].file`, stream, dst);
+        });
+        await this.toolboxApi.uploadFiles(this.instance.id, undefined, {
+            data: form,
+            maxRedirects: 0,
+            timeout: timeout * 1000,
+        });
     }
 }
 exports.FileSystem = FileSystem;