@daytonaio/sdk 0.9.0 → 0.10.0

package/dist/Daytona.js

@@ -1,32 +1,134 @@
 "use strict";
+/**
+ * Sandboxes are isolated development environments managed by Daytona.
+ * This guide covers how to create, manage, and remove Sandboxes using the SDK.
+ *
+ * @module Daytona
+ *
+ * @example
+ * // Initialize using environment variables (DAYTONA_API_KEY, DAYTONA_SERVER_URL, DAYTONA_TARGET)
+ * const daytona = new Daytona();
+ *
+ * // Create and use a workspace
+ * const workspace = await daytona.create({
+ *     language: 'typescript',
+ *     envVars: { NODE_ENV: 'development' }
+ * });
+ *
+ * // Execute commands in the workspace
+ * const response = await workspace.process.executeCommand('echo "Hello, World!"');
+ * console.log(response.result);
+ *
+ * // Execute code in the workspace
+ * const response = await workspace.process.codeRun('console.log("Hello, World!")');
+ * console.log(response.result);
+ *
+ * @example
+ * // Initialize with explicit configuration
+ * const daytona = new Daytona({
+ *     apiKey: process.env.CUSTOM_API_KEY,
+ *     serverUrl: 'https://daytona.example.com',
+ *     target: 'us'
+ * });
+ *
+ * // Create a custom workspace
+ * const workspace = await daytona.create({
+ *     language: 'typescript',
+ *     image: 'node:18',
+ *     resources: {
+ *         cpu: 2,
+ *         memory: 4 // 4GB RAM
+ *     },
+ *     autoStopInterval: 60 // Auto-stop after 1 hour of inactivity
+ * });
+ *
+ * // Use workspace features
+ * await workspace.git.clone('https://github.com/user/repo.git');
+ * await workspace.process.executeCommand('npm test');
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Daytona = void 0;
+exports.Daytona = exports.CodeLanguage = void 0;
 const uuid_1 = require("uuid");
 const WorkspacePythonCodeToolbox_1 = require("./code-toolbox/WorkspacePythonCodeToolbox");
 const Workspace_1 = require("./Workspace");
 const api_client_1 = require("@daytonaio/api-client");
 const WorkspaceTsCodeToolbox_1 = require("./code-toolbox/WorkspaceTsCodeToolbox");
+const axios_1 = __importStar(require("axios"));
+const DaytonaError_1 = require("./errors/DaytonaError");
+/**
+ * Supported programming languages for code execution
+ */
+var CodeLanguage;
+(function (CodeLanguage) {
+    CodeLanguage["PYTHON"] = "python";
+    CodeLanguage["TYPESCRIPT"] = "typescript";
+    CodeLanguage["JAVASCRIPT"] = "javascript";
+})(CodeLanguage || (exports.CodeLanguage = CodeLanguage = {}));
 /**
- * Main class for interacting with Daytona Server API
- * @class Daytona
+ * Main class for interacting with Daytona Server API.
+ *
+ * Provides methods for creating, managing, and interacting with Daytona Sandboxes.
+ * Can be initialized either with explicit configuration or using environment variables.
+ *
+ *
+ * @example
+ * // Using environment variables
+ * // Uses DAYTONA_API_KEY, DAYTONA_SERVER_URL, DAYTONA_TARGET
+ * const daytona = new Daytona();
+ * const workspace = await daytona.create();
+ *
+ * @example
+ * // Using explicit configuration
+ * const config: DaytonaConfig = {
+ *     apiKey: "your-api-key",
+ *     serverUrl: "https://your-server.com",
+ *     target: "us"
+ * };
+ * const daytona = new Daytona(config);
+ *
+ * @class
  */
 class Daytona {
     /**
-     * Creates a new Daytona client instance
+     * Creates a new Daytona client instance.
+     *
      * @param {DaytonaConfig} [config] - Configuration options
-     * @throws {Error} When API key or server URL is missing
+     * @throws {DaytonaError} - `DaytonaError` - When API key or server URL is missing
      */
     constructor(config) {
         const apiKey = (config === null || config === void 0 ? void 0 : config.apiKey) || process.env.DAYTONA_API_KEY;
         if (!apiKey) {
-            throw new Error('API key is required');
+            throw new DaytonaError_1.DaytonaError('API key is required');
         }
         const serverUrl = (config === null || config === void 0 ? void 0 : config.serverUrl) || process.env.DAYTONA_SERVER_URL;
         if (!serverUrl) {
-            throw new Error('Server URL is required');
+            throw new DaytonaError_1.DaytonaError('Server URL is required');
         }
         const envTarget = process.env.DAYTONA_TARGET;
-        const target = (config === null || config === void 0 ? void 0 : config.target) || envTarget;
+        const target = (config === null || config === void 0 ? void 0 : config.target) || envTarget || api_client_1.CreateWorkspaceTargetEnum.US;
         this.apiKey = apiKey;
         this.serverUrl = serverUrl;
         this.target = target;
@@ -38,109 +140,225 @@ class Daytona {
                 },
             },
         });
-        this.workspaceApi = new api_client_1.WorkspaceApi(configuration);
-        this.toolboxApi = new api_client_1.ToolboxApi(configuration);
+        const axiosInstance = axios_1.default.create();
+        axiosInstance.interceptors.response.use((response) => {
+            return response;
+        }, (error) => {
+            var _a, _b, _c;
+            let errorMessage;
+            if (error instanceof axios_1.AxiosError && error.message.includes('timeout of')) {
+                errorMessage = "Operation timed out";
+            }
+            else {
+                errorMessage =
+                    ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) ||
+                        ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data) ||
+                        error.message ||
+                        String(error);
+            }
+            throw new DaytonaError_1.DaytonaError(errorMessage);
+        });
+        this.workspaceApi = new api_client_1.WorkspaceApi(configuration, '', axiosInstance);
+        this.toolboxApi = new api_client_1.ToolboxApi(configuration, '', axiosInstance);
     }
     /**
-     * Creates a new workspace
-     * @param {CreateWorkspaceParams} [params] - Parameters for workspace creation
-     * @returns {Promise<Workspace>} The created workspace instance
+     * Creates Sandboxes with default or custom configurations. You can specify various parameters,
+     * including language, image, resources, environment variables, and volumes for the Sandbox.
+     *
+     * @param {CreateWorkspaceParams} [params] - Parameters for Sandbox creation
+     * @param {number} [timeout] - Timeout in seconds (0 means no timeout, default is 60)
+     * @returns {Promise<Workspace>} The created Sandbox instance
+     *
+     * @example
+     * // Create a default workspace
+     * const workspace = await daytona.create();
+     *
+     * @example
+     * // Create a custom workspace
+     * const params: CreateWorkspaceParams = {
+     *     language: 'typescript',
+     *     image: 'node:18',
+     *     envVars: {
+     *         NODE_ENV: 'development',
+     *         DEBUG: 'true'
+     *     },
+     *     resources: {
+     *         cpu: 2,
+     *         memory: 4 // 4GB RAM
+     *     },
+     *     autoStopInterval: 60
+     * };
+     * const workspace = await daytona.create(params, 40);
      */
-    async create(params) {
+    async create(params, timeout = 60) {
         var _a, _b, _c, _d;
-        const workspaceId = (params === null || params === void 0 ? void 0 : params.id) || `sandbox-${(0, uuid_1.v4)().slice(0, 8)}`;
-        const codeToolbox = this.getCodeToolbox(params === null || params === void 0 ? void 0 : params.language);
-        const labels = (params === null || params === void 0 ? void 0 : params.labels) || {};
-        if (params === null || params === void 0 ? void 0 : params.language) {
+        const startTime = Date.now();
+        if (params == null) {
+            params = { language: 'python' };
+        }
+        const labels = params.labels || {};
+        if (params.language) {
             labels[`code-toolbox-language`] = params.language;
         }
-        const reponse = await this.workspaceApi.createWorkspace({
-            id: workspaceId,
-            name: workspaceId, //  todo: remove this after project refactor
-            image: params === null || params === void 0 ? void 0 : params.image,
-            user: params === null || params === void 0 ? void 0 : params.user,
-            env: (params === null || params === void 0 ? void 0 : params.envVars) || {},
-            target: this.target,
-            cpu: (_a = params === null || params === void 0 ? void 0 : params.resources) === null || _a === void 0 ? void 0 : _a.cpu,
-            gpu: (_b = params === null || params === void 0 ? void 0 : params.resources) === null || _b === void 0 ? void 0 : _b.gpu,
-            memory: (_c = params === null || params === void 0 ? void 0 : params.resources) === null || _c === void 0 ? void 0 : _c.memory,
-            disk: (_d = params === null || params === void 0 ? void 0 : params.resources) === null || _d === void 0 ? void 0 : _d.disk,
-        });
-        const workspaceInstance = reponse.data;
-        const workspace = new Workspace_1.Workspace(workspaceId, workspaceInstance, this.workspaceApi, this.toolboxApi, codeToolbox);
-        if (!(params === null || params === void 0 ? void 0 : params.async)) {
-            await workspace.waitUntilStarted();
+        params.id = params.id || `sandbox-${(0, uuid_1.v4)().slice(0, 8)}`;
+        // remove this when params.timeout is removed
+        const effectiveTimeout = params.timeout || timeout;
+        if (effectiveTimeout < 0) {
+            throw new DaytonaError_1.DaytonaError('Timeout must be a non-negative number');
+        }
+        if (params.autoStopInterval !== undefined && (!Number.isInteger(params.autoStopInterval) || params.autoStopInterval < 0)) {
+            throw new DaytonaError_1.DaytonaError('autoStopInterval must be a non-negative integer');
+        }
+        const codeToolbox = this.getCodeToolbox(params.language);
+        try {
+            const response = await this.workspaceApi.createWorkspace({
+                id: params.id,
+                name: params.id,
+                image: params.image,
+                user: params.user,
+                env: params.envVars || {},
+                labels: params.labels,
+                public: params.public,
+                target: this.target,
+                cpu: (_a = params.resources) === null || _a === void 0 ? void 0 : _a.cpu,
+                gpu: (_b = params.resources) === null || _b === void 0 ? void 0 : _b.gpu,
+                memory: (_c = params.resources) === null || _c === void 0 ? void 0 : _c.memory,
+                disk: (_d = params.resources) === null || _d === void 0 ? void 0 : _d.disk,
+                autoStopInterval: params.autoStopInterval,
+            }, {
+                timeout: effectiveTimeout * 1000
+            });
+            const workspaceInstance = response.data;
+            const workspaceInfo = Workspace_1.Workspace.toWorkspaceInfo(workspaceInstance);
+            workspaceInstance.info = workspaceInfo;
+            const workspace = new Workspace_1.Workspace(params.id, workspaceInstance, this.workspaceApi, this.toolboxApi, codeToolbox);
+            if (!params.async) {
+                const timeElapsed = Date.now() - startTime;
+                await workspace.waitUntilStarted(effectiveTimeout ? effectiveTimeout - (timeElapsed / 1000) : 0);
+            }
+            return workspace;
+        }
+        catch (error) {
+            void this.workspaceApi.deleteWorkspace(params.id, true).catch(() => { });
+            if (error instanceof DaytonaError_1.DaytonaError && error.message.includes("Operation timed out")) {
+                throw new DaytonaError_1.DaytonaError(`Failed to create and start workspace within ${effectiveTimeout} seconds. Operation timed out.`);
+            }
+            throw error;
         }
-        return workspace;
     }
     /**
-     * Gets a workspace by its ID
-     * @param {string} workspaceId - The ID of the workspace to retrieve
-     * @returns {Promise<Workspace>} The workspace instance
+     * Gets a Sandbox by its ID.
+     *
+     * @param {string} workspaceId - The ID of the Sandbox to retrieve
+     * @returns {Promise<Workspace>} The Sandbox
+     *
+     * @example
+     * const workspace = await daytona.get('my-workspace-id');
+     * console.log(`Workspace state: ${workspace.instance.state}`);
      */
     async get(workspaceId) {
         const response = await this.workspaceApi.getWorkspace(workspaceId);
         const workspaceInstance = response.data;
         const language = workspaceInstance.labels && workspaceInstance.labels[`code-toolbox-language`];
         const codeToolbox = this.getCodeToolbox(language);
+        const workspaceInfo = Workspace_1.Workspace.toWorkspaceInfo(workspaceInstance);
+        workspaceInstance.info = workspaceInfo;
         return new Workspace_1.Workspace(workspaceId, workspaceInstance, this.workspaceApi, this.toolboxApi, codeToolbox);
     }
     /**
-     * Lists all workspaces
-     * @returns {Promise<Workspace[]>} The list of workspaces
+     * Lists all Sandboxes.
+     *
+     * @returns {Promise<Workspace[]>} Array of Sandboxes
+     *
+     * @example
+     * const workspaces = await daytona.list();
+     * for (const workspace of workspaces) {
+     *     console.log(`${workspace.id}: ${workspace.instance.state}`);
+     * }
      */
     async list() {
         const response = await this.workspaceApi.listWorkspaces();
         return response.data.map((workspace) => {
             var _a;
             const language = (_a = workspace.labels) === null || _a === void 0 ? void 0 : _a[`code-toolbox-language`];
-            if (language && !['python', 'javascript', 'typescript'].includes(language)) {
-                throw new Error(`Invalid code-toolbox-language: ${language}`);
-            }
+            const workspaceInfo = Workspace_1.Workspace.toWorkspaceInfo(workspace);
+            workspace.info = workspaceInfo;
             return new Workspace_1.Workspace(workspace.id, workspace, this.workspaceApi, this.toolboxApi, this.getCodeToolbox(language));
         });
     }
     /**
-     * Starts a workspace
-     * @param {Workspace} workspace - The workspace to start
+     * Starts a Sandbox and waits for it to be ready.
+     *
+     * @param {Workspace} workspace - The Sandbox to start
+     * @param {number} [timeout] - Optional timeout in seconds (0 means no timeout)
+     * @returns {Promise<void>}
+     *
+     * @example
+     * const workspace = await daytona.get('my-workspace-id');
+     * // Wait up to 60 seconds for the workspace to start
+     * await daytona.start(workspace, 60);
      */
-    async start(workspace) {
-        await workspace.start();
+    async start(workspace, timeout) {
+        await workspace.start(timeout);
     }
     /**
-     * Stops a workspace
-     * @param {Workspace} workspace - The workspace to stop
+     * Stops a Sandbox.
+     *
+     * @param {Workspace} workspace - The Sandbox to stop
      * @returns {Promise<void>}
+     *
+     * @example
+     * const workspace = await daytona.get('my-workspace-id');
+     * await daytona.stop(workspace);
      */
     async stop(workspace) {
         await workspace.stop();
     }
     /**
-     * Removes a workspace
-     * @param {Workspace} workspace - The workspace to remove
+     * Removes a Sandbox.
+     *
+     * @param {Workspace} workspace - The Sandbox to remove
+     * @param {number} timeout - Timeout in seconds (0 means no timeout, default is 60)
      * @returns {Promise<void>}
+     *
+     * @example
+     * const workspace = await daytona.get('my-workspace-id');
+     * await daytona.remove(workspace);
      */
-    async remove(workspace) {
-        await this.workspaceApi.deleteWorkspace(workspace.id, true);
+    async remove(workspace, timeout = 60) {
+        await this.workspaceApi.deleteWorkspace(workspace.id, true, { timeout: timeout * 1000 });
     }
     /**
-     * Gets the current workspace by ID
-     * @param {string} workspaceId - The ID of the workspace to retrieve
-     * @returns {Promise<Workspace>} The workspace instance
+     * Gets the Sandbox by ID.
+     *
+     * @param {string} workspaceId - The ID of the Sandbox to retrieve
+     * @returns {Promise<Workspace>} The Sandbox
+     *
+     * @example
+     * const workspace = await daytona.getCurrentWorkspace('my-workspace-id');
+     * console.log(`Current workspace state: ${workspace.instance.state}`);
      */
     async getCurrentWorkspace(workspaceId) {
         return this.get(workspaceId);
     }
+    /**
+     * Gets the appropriate code toolbox based on language.
+     *
+     * @private
+     * @param {CodeLanguage} [language] - Programming language for the toolbox
+     * @returns {WorkspaceCodeToolbox} The appropriate code toolbox instance
+     * @throws {DaytonaError} - `DaytonaError` - When an unsupported language is specified
+     */
     getCodeToolbox(language) {
         switch (language) {
-            case 'javascript':
-            case 'typescript':
+            case CodeLanguage.JAVASCRIPT:
+            case CodeLanguage.TYPESCRIPT:
                 return new WorkspaceTsCodeToolbox_1.WorkspaceTsCodeToolbox();
-            case 'python':
+            case CodeLanguage.PYTHON:
             case undefined:
                 return new WorkspacePythonCodeToolbox_1.WorkspacePythonCodeToolbox();
             default:
-                throw new Error(`Unsupported language: ${language}`);
+                throw new DaytonaError_1.DaytonaError(`Unsupported language: ${language}, supported languages: ${Object.values(CodeLanguage).join(', ')}`);
         }
     }
 }