@daytonaio/sdk 0.16.0-alpha.0 → 0.16.0-alpha.2

package/dist/Daytona.d.ts

@@ -1,18 +1,6 @@
-import { CreateWorkspaceTargetEnum as SandboxTargetRegion, WorkspaceVolume } from '@daytonaio/api-client';
+import { CreateWorkspaceTargetEnum as SandboxTargetRegion } from '@daytonaio/api-client';
+import { Image } from './Image';
 import { Sandbox, Sandbox as Workspace } from './Sandbox';
-import { VolumeService } from './Volume';
-/**
- * Represents a volume mount for a Sandbox.
- *
- * @interface
- * @property {string} volumeId - ID of the Volume to mount
- * @property {string} mountPath - Path on the Sandbox to mount the Volume
- * @extends {WorkspaceVolume}
- */
-export interface VolumeMount extends WorkspaceVolume {
-    volumeId: string;
-    mountPath: string;
-}
 /**
  * Configuration options for initializing the Daytona client.
  *
@@ -89,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
@@ -114,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 */
@@ -139,8 +127,6 @@ export type CreateSandboxParams = {
     timeout?: number;
     /** Auto-stop interval in minutes (0 means disabled) (must be a non-negative integer) */
     autoStopInterval?: number;
-    /** List of volumes to mount in the Sandbox */
-    volumes?: VolumeMount[];
 };
 /**
  * Filter for Sandboxes.
@@ -155,10 +141,10 @@ export type SandboxFilter = {
 };
 /**
  * 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
@@ -180,12 +166,13 @@ 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?;
     private readonly organizationId?;
     private readonly apiUrl;
-    readonly volume: VolumeService;
     /**
      * Creates a new Daytona client instance.
      *
@@ -316,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.
      *
@@ -325,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,8 +43,9 @@ 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 Volume_1 = require("./Volume");
 /**
  * Supported programming languages for code execution
  */
@@ -56,10 +57,10 @@ var CodeLanguage;
 })(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
@@ -150,7 +151,8 @@ 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,
@@ -182,8 +184,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' };
         }
@@ -202,8 +204,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,
@@ -214,7 +230,6 @@ class Daytona {
                 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,
             });
@@ -225,10 +240,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) {
@@ -371,6 +386,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.
      *
@@ -391,5 +448,30 @@ 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/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 {};