@daytonaio/sdk 0.19.0-alpha.3 → 0.19.0-alpha.4

package/dist/Daytona.js

@@ -0,0 +1,497 @@
+"use strict";
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: AGPL-3.0
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Daytona = exports.CodeLanguage = void 0;
+const api_client_1 = require("@daytonaio/api-client");
+const axios_1 = __importStar(require("axios"));
+const dotenv = __importStar(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
+ */
+var CodeLanguage;
+(function (CodeLanguage) {
+    CodeLanguage["PYTHON"] = "python";
+    CodeLanguage["TYPESCRIPT"] = "typescript";
+    CodeLanguage["JAVASCRIPT"] = "javascript";
+})(CodeLanguage || (exports.CodeLanguage = CodeLanguage = {}));
+/**
+ * Main class for interacting with the Daytona API.
+ * Provides methods for creating, managing, and interacting with Daytona Sandboxes.
+ * Can be initialized either with explicit configuration or using environment variables.
+ *
+ * @property {VolumeService} volume - Service for managing Daytona Volumes
+ *
+ * @example
+ * // Using environment variables
+ * // Uses DAYTONA_API_KEY, DAYTONA_API_URL, DAYTONA_TARGET
+ * const daytona = new Daytona();
+ * const sandbox = await daytona.create();
+ *
+ * @example
+ * // Using explicit configuration
+ * const config: DaytonaConfig = {
+ *     apiKey: "your-api-key",
+ *     apiUrl: "https://your-api.com",
+ *     target: "us"
+ * };
+ * const daytona = new Daytona(config);
+ *
+ * @class
+ */
+class Daytona {
+    /**
+     * Creates a new Daytona client instance.
+     *
+     * @param {DaytonaConfig} [config] - Configuration options
+     * @throws {DaytonaError} - `DaytonaError` - When API key is missing
+     */
+    constructor(config) {
+        this.remove = this.delete.bind(this);
+        dotenv.config();
+        dotenv.config({ path: '.env.local', override: true });
+        const apiKey = !(config === null || config === void 0 ? void 0 : config.apiKey) && (config === null || config === void 0 ? void 0 : config.jwtToken) ? undefined : (config === null || config === void 0 ? void 0 : config.apiKey) || (process === null || process === void 0 ? void 0 : process.env['DAYTONA_API_KEY']);
+        const jwtToken = (config === null || config === void 0 ? void 0 : config.jwtToken) || (process === null || process === void 0 ? void 0 : process.env['DAYTONA_JWT_TOKEN']);
+        const organizationId = (config === null || config === void 0 ? void 0 : config.organizationId) || (process === null || process === void 0 ? void 0 : process.env['DAYTONA_ORGANIZATION_ID']);
+        if (!apiKey && !jwtToken) {
+            throw new DaytonaError_1.DaytonaError('API key or JWT token is required');
+        }
+        const apiUrl = (config === null || config === void 0 ? void 0 : config.apiUrl) ||
+            (config === null || config === void 0 ? void 0 : config.serverUrl) ||
+            (process === null || process === void 0 ? void 0 : process.env['DAYTONA_API_URL']) ||
+            (process === null || process === void 0 ? void 0 : process.env['DAYTONA_SERVER_URL']) ||
+            'https://app.daytona.io/api';
+        const envTarget = process === null || process === void 0 ? void 0 : process.env['DAYTONA_TARGET'];
+        const target = (config === null || config === void 0 ? void 0 : config.target) || envTarget || api_client_1.CreateWorkspaceTargetEnum.US;
+        if ((process === null || process === void 0 ? void 0 : process.env['DAYTONA_SERVER_URL']) && !(process === null || process === void 0 ? void 0 : process.env['DAYTONA_API_URL'])) {
+            console.warn('[Deprecation Warning] Environment variable `DAYTONA_SERVER_URL` is deprecated and will be removed in future versions. Use `DAYTONA_API_URL` instead.');
+        }
+        this.apiKey = apiKey;
+        this.jwtToken = jwtToken;
+        this.organizationId = organizationId;
+        this.apiUrl = apiUrl;
+        this.target = target;
+        const orgHeader = {};
+        if (!this.apiKey) {
+            if (!this.organizationId) {
+                throw new DaytonaError_1.DaytonaError('Organization ID is required when using JWT token');
+            }
+            orgHeader['X-Daytona-Organization-ID'] = this.organizationId;
+        }
+        const configuration = new api_client_1.Configuration({
+            basePath: this.apiUrl,
+            baseOptions: {
+                headers: {
+                    Authorization: `Bearer ${this.apiKey || this.jwtToken}`,
+                    'X-Daytona-Source': 'typescript-sdk',
+                    ...orgHeader,
+                },
+            },
+        });
+        const axiosInstance = axios_1.default.create({
+            timeout: 24 * 60 * 60 * 1000, // 24 hours
+        });
+        axiosInstance.interceptors.response.use((response) => {
+            return response;
+        }, (error) => {
+            var _a, _b, _c, _d, _e;
+            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);
+            }
+            try {
+                errorMessage = JSON.stringify(errorMessage);
+            }
+            catch (_f) {
+                errorMessage = String(errorMessage);
+            }
+            switch ((_e = (_d = error.response) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.statusCode) {
+                case 404:
+                    throw new DaytonaError_1.DaytonaNotFoundError(errorMessage);
+                default:
+                    throw new DaytonaError_1.DaytonaError(errorMessage);
+            }
+        });
+        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 }) {
+        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' };
+        }
+        const labels = params.labels || {};
+        if (params.language) {
+            labels['code-toolbox-language'] = params.language;
+        }
+        // remove this when params.timeout is removed
+        const effectiveTimeout = params.timeout || options.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 {
+            // 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,
+                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,
+                volumes: params.volumes,
+            }, 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];
+                while (sandboxInstance.state === api_client_1.WorkspaceState.PENDING_BUILD) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    sandboxInstance = (await this.sandboxApi.getWorkspace(sandboxInstance.id)).data;
+                }
+                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 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') {
+                const timeElapsed = Date.now() - startTime;
+                await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - timeElapsed / 1000 : 0);
+            }
+            return sandbox;
+        }
+        catch (error) {
+            if (error instanceof DaytonaError_1.DaytonaError && error.message.includes('Operation timed out')) {
+                throw new DaytonaError_1.DaytonaError(`Failed to create and start sandbox within ${effectiveTimeout} seconds. Operation timed out.`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Gets a Sandbox by its ID.
+     *
+     * @param {string} sandboxId - The ID of the Sandbox to retrieve
+     * @returns {Promise<Sandbox>} The Sandbox
+     *
+     * @example
+     * const sandbox = await daytona.get('my-sandbox-id');
+     * console.log(`Sandbox state: ${sandbox.instance.state}`);
+     */
+    async get(sandboxId) {
+        const response = await this.sandboxApi.getWorkspace(sandboxId);
+        const sandboxInstance = response.data;
+        const language = sandboxInstance.labels && sandboxInstance.labels['code-toolbox-language'];
+        const codeToolbox = this.getCodeToolbox(language);
+        const sandboxInfo = Sandbox_1.Sandbox.toSandboxInfo(sandboxInstance);
+        sandboxInstance.info = {
+            ...sandboxInfo,
+            name: '',
+        };
+        return new Sandbox_1.Sandbox(sandboxId, sandboxInstance, this.sandboxApi, this.toolboxApi, codeToolbox);
+    }
+    /**
+     * Finds a Sandbox by its ID or labels.
+     *
+     * @param {SandboxFilter} filter - Filter for Sandboxes
+     * @returns {Promise<Sandbox>} First Sandbox that matches the ID or labels.
+     *
+     * @example
+     * const sandbox = await daytona.findOne({ labels: { 'my-label': 'my-value' } });
+     * console.log(`Sandbox: ${await sandbox.info()}`);
+     */
+    async findOne(filter) {
+        if (filter.id) {
+            return this.get(filter.id);
+        }
+        const sandboxes = await this.list(filter.labels);
+        if (sandboxes.length === 0) {
+            throw new DaytonaError_1.DaytonaError(`No sandbox found with labels ${JSON.stringify(filter.labels)}`);
+        }
+        return sandboxes[0];
+    }
+    /**
+     * Lists all Sandboxes filtered by labels.
+     *
+     * @param {Record<string, string>} [labels] - Labels to filter Sandboxes
+     * @returns {Promise<Sandbox[]>} Array of Sandboxes that match the labels.
+     *
+     * @example
+     * const sandboxes = await daytona.list({ 'my-label': 'my-value' });
+     * for (const sandbox of sandboxes) {
+     *     console.log(`${sandbox.id}: ${sandbox.instance.state}`);
+     * }
+     */
+    async list(labels) {
+        const response = await this.sandboxApi.listWorkspaces(undefined, undefined, labels ? JSON.stringify(labels) : undefined);
+        return response.data.map((sandbox) => {
+            var _a;
+            const language = (_a = sandbox.labels) === null || _a === void 0 ? void 0 : _a['code-toolbox-language'];
+            const sandboxInfo = Sandbox_1.Sandbox.toSandboxInfo(sandbox);
+            sandbox.info = {
+                ...sandboxInfo,
+                name: '',
+            };
+            return new Sandbox_1.Sandbox(sandbox.id, sandbox, this.sandboxApi, this.toolboxApi, this.getCodeToolbox(language));
+        });
+    }
+    /**
+     * Starts a Sandbox and waits for it to be ready.
+     *
+     * @param {Sandbox} sandbox - The Sandbox to start
+     * @param {number} [timeout] - Optional timeout in seconds (0 means no timeout)
+     * @returns {Promise<void>}
+     *
+     * @example
+     * const sandbox = await daytona.get('my-sandbox-id');
+     * // Wait up to 60 seconds for the sandbox to start
+     * await daytona.start(sandbox, 60);
+     */
+    async start(sandbox, timeout) {
+        await sandbox.start(timeout);
+    }
+    /**
+     * Stops a Sandbox.
+     *
+     * @param {Sandbox} sandbox - The Sandbox to stop
+     * @returns {Promise<void>}
+     *
+     * @example
+     * const sandbox = await daytona.get('my-sandbox-id');
+     * await daytona.stop(sandbox);
+     */
+    async stop(sandbox) {
+        await sandbox.stop();
+    }
+    /**
+     * Deletes a Sandbox.
+     *
+     * @param {Sandbox} sandbox - The Sandbox to delete
+     * @param {number} timeout - Timeout in seconds (0 means no timeout, default is 60)
+     * @returns {Promise<void>}
+     *
+     * @example
+     * const sandbox = await daytona.get('my-sandbox-id');
+     * await daytona.delete(sandbox);
+     */
+    async delete(sandbox, timeout = 60) {
+        await this.sandboxApi.deleteWorkspace(sandbox.id, true, undefined, { timeout: timeout * 1000 });
+    }
+    /**
+     * Gets the Sandbox by ID.
+     *
+     * @param {string} workspaceId - The ID of the Sandbox to retrieve
+     * @returns {Promise<Workspace>} The Sandbox
+     *
+     * @deprecated Use `getCurrentSandbox` instead. This method will be removed in a future version.
+     */
+    async getCurrentWorkspace(workspaceId) {
+        return await this.getCurrentSandbox(workspaceId);
+    }
+    /**
+     * Gets the Sandbox by ID.
+     *
+     * @param {string} sandboxId - The ID of the Sandbox to retrieve
+     * @returns {Promise<Sandbox>} The Sandbox
+     *
+     * @example
+     * const sandbox = await daytona.getCurrentSandbox('my-sandbox-id');
+     * console.log(`Current sandbox state: ${sandbox.instance.state}`);
+     */
+    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;
+        const startLogStreaming = async () => {
+            if (!streamPromise) {
+                streamPromise = (0, Stream_1.processStreamingResponse)(() => this.imagesApi.getImageBuildLogs(builtImage.id, undefined, true, { responseType: 'stream' }), options.onLogs, async () => terminalStates.includes(imageRef.builtImage.state));
+            }
+        };
+        if (options.onLogs) {
+            options.onLogs(`Building image ${builtImage.name} (${builtImage.state})`);
+            if (builtImage.state !== api_client_1.ImageState.BUILD_PENDING) {
+                await startLogStreaming();
+            }
+        }
+        let previousState = builtImage.state;
+        while (!terminalStates.includes(builtImage.state)) {
+            if (options.onLogs && previousState !== builtImage.state) {
+                if (builtImage.state !== api_client_1.ImageState.BUILD_PENDING && !streamPromise) {
+                    await startLogStreaming();
+                }
+                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) {
+            if (streamPromise) {
+                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.
+     *
+     * @private
+     * @param {CodeLanguage} [language] - Programming language for the toolbox
+     * @returns {SandboxCodeToolbox} The appropriate code toolbox instance
+     * @throws {DaytonaError} - `DaytonaError` - When an unsupported language is specified
+     */
+    getCodeToolbox(language) {
+        switch (language) {
+            case CodeLanguage.JAVASCRIPT:
+            case CodeLanguage.TYPESCRIPT:
+                return new SandboxTsCodeToolbox_1.SandboxTsCodeToolbox();
+            case CodeLanguage.PYTHON:
+            case undefined:
+                return new SandboxPythonCodeToolbox_1.SandboxPythonCodeToolbox();
+            default:
+                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;