@daytonaio/sdk 0.16.0-alpha.3 → 0.16.0-alpha.5

package/README.md

@@ -127,7 +127,7 @@ await sandbox.git.add('path/to/repo', ['file1.txt', 'file2.txt'])
 
 ```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

package/dist/Daytona.d.ts

@@ -1,4 +1,5 @@
 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.
@@ -76,7 +77,7 @@ export interface SandboxResources {
  * Parameters for creating a new Sandbox.
  *
  * @interface
- * @property {string} [image] - Optional Docker image to use for the Sandbox
+ * @property {string | Image} [image] - Optional Docker image to use for the Sandbox or an Image instance
  * @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
@@ -101,8 +102,8 @@ export interface SandboxResources {
  * const sandbox = await daytona.create(params, 50);
  */
 export type CreateSandboxParams = {
-    /** Optional Docker image to use for the Sandbox */
-    image?: string;
+    /** Optional Docker image to use for the Sandbox or an Image instance */
+    image?: string | Image;
     /** Optional os user to use for the Sandbox */
     user?: string;
     /** Programming language for direct code execution */
@@ -165,6 +166,8 @@ 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?;
@@ -300,6 +303,24 @@ 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.
      *
@@ -309,4 +330,12 @@ 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,6 +43,8 @@ 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
@@ -127,7 +129,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) => {
@@ -149,6 +153,8 @@ 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,
@@ -180,8 +186,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' };
         }
@@ -200,8 +206,22 @@ 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: params.image,
+                image: imageStr,
+                buildInfo,
                 user: params.user,
                 env: params.envVars || {},
                 labels: params.labels,
@@ -222,10 +242,10 @@ class Daytona {
                 name: '',
             };
             const sandbox = new Sandbox_1.Sandbox(sandboxInstance.id, sandboxInstance, this.sandboxApi, this.toolboxApi, codeToolbox);
-            // if (!params.async) {
-            //   const timeElapsed = Date.now() - startTime;
-            //   await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - (timeElapsed / 1000) : 0);
-            // }
+            if (!params.async && sandbox.instance.state !== 'started') {
+                const timeElapsed = Date.now() - startTime;
+                await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - timeElapsed / 1000 : 0);
+            }
             return sandbox;
         }
         catch (error) {
@@ -368,6 +388,48 @@ 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.
      *
@@ -388,5 +450,31 @@ 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/Image.d.ts

@@ -0,0 +1,261 @@
+declare const SUPPORTED_PYTHON_SERIES: readonly ["3.9", "3.10", "3.11", "3.12", "3.13"];
+type SupportedPythonSeries = (typeof SUPPORTED_PYTHON_SERIES)[number];
+/**
+ * Represents a context file to be added to the image.
+ *
+ * @interface
+ * @property {string} sourcePath - The path to the source file or directory.
+ * @property {string} archivePath - The path inside the archive file in object storage.
+ */
+export interface Context {
+    sourcePath: string;
+    archivePath?: string;
+}
+/**
+ * Options for the pip install command.
+ *
+ * @interface
+ * @property {string[]} findLinks - The find-links to use for the pip install command.
+ * @property {string} indexUrl - The index URL to use for the pip install command.
+ * @property {string[]} extraIndexUrls - The extra index URLs to use for the pip install command.
+ * @property {boolean} pre - Whether to install pre-release versions.
+ * @property {string} extraOptions - The extra options to use for the pip install command. Given string is passed directly to the pip install command.
+ */
+export interface PipInstallOptions {
+    findLinks?: string[];
+    indexUrl?: string;
+    extraIndexUrls?: string[];
+    pre?: boolean;
+    extraOptions?: string;
+}
+/**
+ * Options for the pip install command from a pyproject.toml file.
+ *
+ * @interface
+ * @property {string[]} optionalDependencies - The optional dependencies to install.
+ *
+ * @extends {PipInstallOptions}
+ */
+export interface PyprojectOptions extends PipInstallOptions {
+    optionalDependencies?: string[];
+}
+/**
+ * Represents an image definition for a Daytona sandbox.
+ * Do not construct this class directly. Instead use one of its static factory methods,
+ * such as `Image.base()`, `Image.debianSlim()` or `Image.fromDockerfile()`.
+ *
+ * @class
+ * @property {string} dockerfile - The Dockerfile content.
+ * @property {Context[]} contextList - The list of context files to be added to the image.
+ */
+export declare class Image {
+    private _dockerfile;
+    private _contextList;
+    private constructor();
+    get dockerfile(): string;
+    get contextList(): Context[];
+    /**
+     * Adds commands to install packages using pip.
+     *
+     * @param {string | string[]} packages - The packages to install.
+     * @param {Object} options - The options for the pip install command.
+     * @param {string[]} options.findLinks - The find-links to use for the pip install command.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.debianSlim('3.12').pipInstall('numpy', { findLinks: ['https://pypi.org/simple'] })
+     */
+    pipInstall(packages: string | string[], options?: PipInstallOptions): Image;
+    /**
+     * Installs dependencies from a requirements.txt file.
+     *
+     * @param {string} requirementsTxt - The path to the requirements.txt file.
+     * @param {PipInstallOptions} options - The options for the pip install command.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.debianSlim('3.12')
+     * image.pipInstallFromRequirements('requirements.txt', { findLinks: ['https://pypi.org/simple'] })
+     */
+    pipInstallFromRequirements(requirementsTxt: string, options?: PipInstallOptions): Image;
+    /**
+     * Installs dependencies from a pyproject.toml file.
+     *
+     * @param {string} pyprojectToml - The path to the pyproject.toml file.
+     * @param {PyprojectOptions} options - The options for the pip install command.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.debianSlim('3.12')
+     * image.pipInstallFromPyproject('pyproject.toml', { optionalDependencies: ['dev'] })
+     */
+    pipInstallFromPyproject(pyprojectToml: string, options?: PyprojectOptions): Image;
+    /**
+     * Adds a local file to the image.
+     *
+     * @param {string} localPath - The path to the local file.
+     * @param {string} remotePath - The path of the file in the image.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .addLocalFile('requirements.txt', '/home/daytona/requirements.txt')
+     */
+    addLocalFile(localPath: string, remotePath: string): Image;
+    /**
+     * Adds a local directory to the image.
+     *
+     * @param {string} localPath - The path to the local directory.
+     * @param {string} remotePath - The path of the directory in the image.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .addLocalDir('src', '/home/daytona/src')
+     */
+    addLocalDir(localPath: string, remotePath: string): Image;
+    /**
+     * Runs commands in the image.
+     *
+     * @param {string | string[]} commands - The commands to run.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .runCommands('echo "Hello, world!"')
+     */
+    runCommands(...commands: (string | string[])[]): Image;
+    /**
+     * Sets environment variables in the image.
+     *
+     * @param {Record<string, string>} envVars - The environment variables to set.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .env({ FOO: 'bar' })
+     */
+    env(envVars: Record<string, string>): Image;
+    /**
+     * Sets the working directory in the image.
+     *
+     * @param {string} dirPath - The path to the working directory.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .workdir('/home/daytona')
+     */
+    workdir(dirPath: string): Image;
+    /**
+     * Sets the entrypoint for the image.
+     *
+     * @param {string[]} entrypointCommands - The commands to set as the entrypoint.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .entrypoint(['/bin/bash'])
+     */
+    entrypoint(entrypointCommands: string[]): Image;
+    /**
+     * Sets the default command for the image.
+     *
+     * @param {string[]} cmd - The command to set as the default command.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .cmd(['/bin/bash'])
+     */
+    cmd(cmd: string[]): Image;
+    /**
+     * Extends an image with arbitrary Dockerfile-like commands.
+     *
+     * @param {string | string[]} dockerfileCommands - The commands to add to the Dockerfile.
+     * @param {string} contextDir - The path to the context directory.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .dockerfileCommands(['RUN echo "Hello, world!"'])
+     */
+    dockerfileCommands(dockerfileCommands: (string | string[])[], contextDir?: string): Image;
+    /**
+     * Creates an Image from an existing Dockerfile.
+     *
+     * @param {string} path - The path to the Dockerfile.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.fromDockerfile('Dockerfile')
+     */
+    static fromDockerfile(path: string): Image;
+    /**
+     * Creates an Image from an existing base image.
+     *
+     * @param {string} image - The base image to use.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.base('python:3.12-slim-bookworm')
+     */
+    static base(image: string): Image;
+    /**
+     * Creates a Debian slim image based on the official Python Docker image.
+     *
+     * @param {string} pythonVersion - The Python version to use.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.debianSlim('3.12')
+     */
+    static debianSlim(pythonVersion?: SupportedPythonSeries): Image;
+    /**
+     * Formats pip install arguments in a single string.
+     *
+     * @param {PipInstallOptions} options - The options for the pip install command.
+     * @returns {string} The formatted pip install arguments.
+     */
+    private formatPipInstallArgs;
+    /**
+     * Flattens a string argument.
+     *
+     * @param {string} functionName - The name of the function.
+     * @param {string} argName - The name of the argument.
+     * @param {any} args - The argument to flatten.
+     * @returns {string[]} The flattened argument.
+     */
+    private flattenStringArgs;
+    /**
+     * Processes the Python version.
+     *
+     * @param {string} pythonVersion - The Python version to use.
+     * @returns {string} The processed Python version.
+     */
+    private static processPythonVersion;
+    /**
+     * Extracts source files from COPY commands in a Dockerfile.
+     *
+     * @param {string} dockerfileContent - The content of the Dockerfile.
+     * @param {string} pathPrefix - The path prefix to use for the sources.
+     * @returns {Array<[string, string]>} The list of the actual file path and its corresponding COPY-command source path.
+     */
+    private static extractCopySources;
+    /**
+     * Parses a COPY command to extract sources and destination.
+     *
+     * @param {string} line - The line to parse.
+     * @returns {Object} The parsed sources and destination.
+     */
+    private static parseCopyCommand;
+}
+export {};