@daytonaio/sdk 0.17.0 → 0.18.0-alpha.1

package/dist/Daytona.d.ts

@@ -1,4 +1,5 @@
 import { CreateWorkspaceTargetEnum as SandboxTargetRegion, WorkspaceVolume } from '@daytonaio/api-client';
+import { Image } from './Image';
 import { Sandbox, Sandbox as Workspace } from './Sandbox';
 import { VolumeService } from './Volume';
 /**
@@ -88,7 +89,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
@@ -113,8 +114,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 */
@@ -179,6 +180,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?;
@@ -193,6 +196,8 @@ 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.
      *
@@ -221,7 +226,45 @@ export declare class Daytona {
      * };
      * const sandbox = await daytona.create(params, 40);
      */
-    create(params?: CreateSandboxParams, timeout?: number): Promise<Sandbox>;
+    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>;
     /**
      * Gets a Sandbox by its ID.
      *
@@ -315,6 +358,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?: {
+        onLogs?: (chunk: string) => void;
+        timeout?: number;
+    }): Promise<void>;
     /**
      * Gets the appropriate code toolbox based on language.
      *
@@ -324,4 +385,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,7 +43,10 @@ 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
@@ -158,39 +161,16 @@ 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);
     }
-    /**
-     * 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) {
+    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' };
         }
@@ -199,7 +179,7 @@ class Daytona {
             labels['code-toolbox-language'] = params.language;
         }
         // remove this when params.timeout is removed
-        const effectiveTimeout = params.timeout || timeout;
+        const effectiveTimeout = params.timeout || options.timeout;
         if (effectiveTimeout < 0) {
             throw new DaytonaError_1.DaytonaError('Timeout must be a non-negative number');
         }
@@ -209,8 +189,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,
@@ -225,14 +219,21 @@ class Daytona {
             }, undefined, {
                 timeout: effectiveTimeout * 1000,
             });
-            const sandboxInstance = response.data;
+            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 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) {
+            if (!params.async && sandbox.instance.state !== 'started') {
                 const timeElapsed = Date.now() - startTime;
                 await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - timeElapsed / 1000 : 0);
             }
@@ -378,6 +379,58 @@ 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.
      *
@@ -398,5 +451,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 {};