@daytonaio/sdk 0.16.0-alpha.2 → 0.16.0

package/README.md

@@ -99,12 +99,12 @@ console.log(response.result)
 ```typescript
 // Upload a file
 await sandbox.fs.uploadFile(
-  '/path/to/file.txt',
+  'path/to/file.txt',
   new File([Buffer.from('Hello, World!')], 'file.txt', { type: 'text/plain' }),
 )
 
 // Download a file
-const content = await sandbox.fs.downloadFile('/path/to/file.txt')
+const content = await sandbox.fs.downloadFile('path/to/file.txt')
 
 // Search for files
 const matches = await sandbox.fs.findFiles(root_dir, 'search_pattern')
@@ -114,30 +114,30 @@ const matches = await sandbox.fs.findFiles(root_dir, 'search_pattern')
 
 ```typescript
 // Clone a repository
-await sandbox.git.clone('https://github.com/example/repo', '/path/to/clone')
+await sandbox.git.clone('https://github.com/example/repo', 'path/to/clone')
 
 // List branches
-const branches = await sandbox.git.branches('/path/to/repo')
+const branches = await sandbox.git.branches('path/to/repo')
 
 // Add files
-await sandbox.git.add('/path/to/repo', ['file1.txt', 'file2.txt'])
+await sandbox.git.add('path/to/repo', ['file1.txt', 'file2.txt'])
 ```
 
 ### Language Server Protocol
 
 ```typescript
 // Create and start a language server
-const lsp = sandbox.createLspServer('typescript', '/path/to/project')
+const lsp = await sandbox.createLspServer('typescript', 'path/to/project')
 await lsp.start()
 
 // Notify the lsp for the file
-await lsp.didOpen('/path/to/file.ts')
+await lsp.didOpen('path/to/file.ts')
 
 // Get document symbols
-const symbols = await lsp.documentSymbols('/path/to/file.ts')
+const symbols = await lsp.documentSymbols('path/to/file.ts')
 
 // Get completions
-const completions = await lsp.completions('/path/to/file.ts', {
+const completions = await lsp.completions('path/to/file.ts', {
   line: 10,
   character: 15,
 })

package/dist/Daytona.d.ts

@@ -1,5 +1,4 @@
 import { CreateWorkspaceTargetEnum as SandboxTargetRegion } from '@daytonaio/api-client';
-import { Image } from './Image';
 import { Sandbox, Sandbox as Workspace } from './Sandbox';
 /**
  * Configuration options for initializing the Daytona client.
@@ -77,7 +76,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
@@ -102,8 +101,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 */
@@ -166,8 +165,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?;
@@ -303,24 +300,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?: {
-        verbose?: boolean;
-        timeout?: number;
-    }): Promise<void>;
     /**
      * Gets the appropriate code toolbox based on language.
      *
@@ -330,12 +309,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,8 +43,6 @@ 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");
 /**
  * Supported programming languages for code execution
@@ -129,7 +127,9 @@ class Daytona {
                 },
             },
         });
-        const axiosInstance = axios_1.default.create();
+        const axiosInstance = axios_1.default.create({
+            timeout: 24 * 60 * 60 * 1000, // 24 hours
+        });
         axiosInstance.interceptors.response.use((response) => {
             return response;
         }, (error) => {
@@ -151,8 +151,6 @@ class Daytona {
         });
         this.sandboxApi = new api_client_1.WorkspaceApi(configuration, '', axiosInstance);
         this.toolboxApi = new api_client_1.ToolboxApi(configuration, '', axiosInstance);
-        this.imagesApi = new api_client_1.ImagesApi(configuration, '', axiosInstance);
-        this.objectStorageApi = new api_client_1.ObjectStorageApi(configuration, '', axiosInstance);
     }
     /**
      * Creates Sandboxes with default or custom configurations. You can specify various parameters,
@@ -184,8 +182,8 @@ class Daytona {
      * const sandbox = await daytona.create(params, 40);
      */
     async create(params, timeout = 60) {
+        // const startTime = Date.now();
         var _a, _b, _c, _d;
-        const startTime = Date.now();
         if (params == null) {
             params = { language: 'python' };
         }
@@ -204,22 +202,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,
@@ -240,10 +224,10 @@ class Daytona {
                 name: '',
             };
             const sandbox = new Sandbox_1.Sandbox(sandboxInstance.id, sandboxInstance, this.sandboxApi, this.toolboxApi, codeToolbox);
-            if (!params.async && sandbox.instance.state !== 'started') {
-                const timeElapsed = Date.now() - startTime;
-                await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - timeElapsed / 1000 : 0);
-            }
+            // if (!params.async) {
+            //   const timeElapsed = Date.now() - startTime;
+            //   await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - (timeElapsed / 1000) : 0);
+            // }
             return sandbox;
         }
         catch (error) {
@@ -386,48 +370,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;
-        let previousState = null;
-        while (builtImage.state !== api_client_1.ImageState.ACTIVE && builtImage.state !== api_client_1.ImageState.ERROR) {
-            if (options.verbose && previousState !== builtImage.state) {
-                console.log(`Building image ${builtImage.name} (${builtImage.state})`);
-                previousState = builtImage.state;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-            const response = await this.imagesApi.getImage(builtImage.id);
-            builtImage = response.data;
-        }
-        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}`);
-        }
-        if (options.verbose) {
-            console.log(`Built image ${builtImage.name} (${builtImage.state})`);
-        }
-    }
     /**
      * Gets the appropriate code toolbox based on language.
      *
@@ -448,30 +390,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,
-        });
-        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

@@ -44,52 +44,57 @@ export interface FileUpload {
 export declare class FileSystem {
     private readonly instance;
     private readonly toolboxApi;
-    constructor(instance: SandboxInstance, toolboxApi: ToolboxApi);
+    private readonly getRootDir;
+    constructor(instance: SandboxInstance, toolboxApi: ToolboxApi, getRootDir: () => Promise<string>);
     /**
      * Create a new directory in the Sandbox with specified permissions.
      *
-     * @param {string} path - Path where the directory should be created
+     * @param {string} path - Path where the directory should be created. Relative paths are resolved based on the user's
+     * root 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');
+     * await fs.createFolder('app/data', '755');
      */
     createFolder(path: string, mode: string): Promise<void>;
     /**
      * Deletes a file or directory from the Sandbox.
      *
-     * @param {string} path - Path to the file or directory to delete
+     * @param {string} path - Path to the file or directory to delete. Relative paths are resolved based on the user's
+     * root directory.
      * @returns {Promise<void>}
      *
      * @example
      * // Delete a file
-     * await fs.deleteFile('/app/temp.log');
+     * await fs.deleteFile('app/temp.log');
      */
     deleteFile(path: string): Promise<void>;
     /**
      * Downloads a file from the Sandbox.
      *
-     * @param {string} path - Path to the file to download
+     * @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');
+     * const fileBlob = await fs.downloadFile('app/data.json');
      * console.log('File content:', fileBlob.toString());
      */
     downloadFile(path: string): Promise<Blob>;
     /**
      * Searches for text patterns within files in the Sandbox.
      *
-     * @param {string} path - Directory to search in
+     * @param {string} path - Directory to search in. Relative paths are resolved based on the user's
+     * root 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:');
+     * const matches = await fs.findFiles('app/src', 'TODO:');
      * matches.forEach(match => {
      *   console.log(`${match.file}:${match.line}: ${match.content}`);
      * });
@@ -98,24 +103,26 @@ export declare class FileSystem {
     /**
      * Retrieves detailed information about a file or directory.
      *
-     * @param {string} path - Path to the file or directory
+     * @param {string} path - Path to the file or directory. Relative paths are resolved based on the user's
+     * root directory.
      * @returns {Promise<FileInfo>} Detailed file information including size, permissions, modification time
      *
      * @example
      * // Get file details
-     * const info = await fs.getFileDetails('/app/config.json');
+     * const info = await fs.getFileDetails('app/config.json');
      * console.log(`Size: ${info.size}, Modified: ${info.modTime}`);
      */
     getFileDetails(path: string): Promise<FileInfo>;
     /**
      * Lists contents of a directory in the Sandbox.
      *
-     * @param {string} path - Directory path to list
+     * @param {string} path - Directory path to list. Relative paths are resolved based on the user's
+     * root directory.
      * @returns {Promise<FileInfo[]>} Array of file and directory information
      *
      * @example
      * // List directory contents
-     * const files = await fs.listFiles('/app/src');
+     * const files = await fs.listFiles('app/src');
      * files.forEach(file => {
      *   console.log(`${file.name} (${file.size} bytes)`);
      * });
@@ -124,19 +131,21 @@ export declare class FileSystem {
     /**
      * Moves or renames a file or directory.
      *
-     * @param {string} source - Source path
-     * @param {string} destination - Destination path
+     * @param {string} source - Source path. Relative paths are resolved based on the user's
+     * root directory.
+     * @param {string} destination - Destination path. Relative paths are resolved based on the user's
+     * root directory.
      * @returns {Promise<void>}
      *
      * @example
      * // Move a file to a new location
-     * await fs.moveFiles('/app/temp/data.json', '/app/data/data.json');
+     * await fs.moveFiles('app/temp/data.json', 'app/data/data.json');
      */
     moveFiles(source: string, destination: string): Promise<void>;
     /**
      * Replaces text content in multiple files.
      *
-     * @param {string[]} files - Array of file paths to process
+     * @param {string[]} files - Array of file paths to process. Relative paths are resolved based on the user's
      * @param {string} pattern - Pattern to replace
      * @param {string} newValue - Replacement text
      * @returns {Promise<Array<ReplaceResult>>} Results of the replace operation for each file
@@ -144,7 +153,7 @@ export declare class FileSystem {
      * @example
      * // Update version number across multiple files
      * const results = await fs.replaceInFiles(
-     *   ['/app/package.json', '/app/version.ts'],
+     *   ['app/package.json', 'app/version.ts'],
      *   '"version": "1.0.0"',
      *   '"version": "1.1.0"'
      * );
@@ -153,26 +162,27 @@ export declare class FileSystem {
     /**
      * Searches for files and directories by name pattern in the Sandbox.
      *
-     * @param {string} path - Directory to search in
+     * @param {string} path - Directory to search in. Relative paths are resolved based on the user's
      * @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');
+     * const result = await fs.searchFiles('app', '*.ts');
      * result.files.forEach(file => console.log(file));
      */
     searchFiles(path: string, pattern: string): Promise<SearchFilesResponse>;
     /**
      * Sets permissions and ownership for a file or directory.
      *
-     * @param {string} path - Path to the file or directory
+     * @param {string} path - Path to the file or directory. Relative paths are resolved based on the user's
+     * root directory.
      * @param {FilePermissionsParams} permissions - Permission settings
      * @returns {Promise<void>}
      *
      * @example
      * // Set file permissions and ownership
-     * await fs.setFilePermissions('/app/script.sh', {
+     * await fs.setFilePermissions('app/script.sh', {
      *   owner: 'daytona',
      *   group: 'users',
      *   mode: '755'  // Execute permission for shell script
@@ -182,36 +192,38 @@ export declare class FileSystem {
     /**
      * Uploads a file to the Sandbox.
      *
-     * @param {string} path - Destination path in 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);
+     * await fs.uploadFile('app/config.json', configFile);
      */
     uploadFile(path: string, file: File): 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.
      *
-     * @param {FileUpload[]} files - Array of files to upload
+     * @param {FileUpload[]} files - Array of files to upload. Relative paths are resolved based on the user's
+     * root directory.
      * @returns {Promise<void>}
      *
      * @example
      * // Upload multiple text files
      * const files = [
      *   {
-     *     path: '/app/data/file1.txt',
+     *     path: 'app/data/file1.txt',
      *     content: new File(['Content of file 1'], 'file1.txt')
      *   },
      *   {
-     *     path: '/app/data/file2.txt',
+     *     path: 'app/data/file2.txt',
      *     content: new File(['Content of file 2'], 'file2.txt')
      *   },
      *   {
-     *     path: '/app/config/settings.json',
+     *     path: 'app/config/settings.json',
      *     content: new File(['{"key": "value"}'], 'settings.json')
      *   }
      * ];