@daytonaio/sdk 0.16.0 → 0.17.0-alpha.1

package/dist/Daytona.d.ts

@@ -1,5 +1,17 @@
-import { CreateWorkspaceTargetEnum as SandboxTargetRegion } from '@daytonaio/api-client';
+import { CreateWorkspaceTargetEnum as SandboxTargetRegion, WorkspaceVolume } from '@daytonaio/api-client';
 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
+ */
+export interface VolumeMount extends WorkspaceVolume {
+    volumeId: string;
+    mountPath: string;
+}
 /**
  * Configuration options for initializing the Daytona client.
  *
@@ -126,6 +138,8 @@ 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.
@@ -140,10 +154,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
@@ -170,6 +184,7 @@ export declare class Daytona {
     private readonly jwtToken?;
     private readonly organizationId?;
     private readonly apiUrl;
+    readonly volume: VolumeService;
     /**
      * Creates a new Daytona client instance.
      *

package/dist/Daytona.js

@@ -44,6 +44,7 @@ const SandboxPythonCodeToolbox_1 = require("./code-toolbox/SandboxPythonCodeTool
 const SandboxTsCodeToolbox_1 = require("./code-toolbox/SandboxTsCodeToolbox");
 const DaytonaError_1 = require("./errors/DaytonaError");
 const Sandbox_1 = require("./Sandbox");
+const Volume_1 = require("./Volume");
 /**
  * Supported programming languages for code execution
  */
@@ -55,10 +56,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
@@ -133,7 +134,7 @@ class Daytona {
         axiosInstance.interceptors.response.use((response) => {
             return response;
         }, (error) => {
-            var _a, _b, _c;
+            var _a, _b, _c, _d, _e;
             let errorMessage;
             if (error instanceof axios_1.AxiosError && error.message.includes('timeout of')) {
                 errorMessage = 'Operation timed out';
@@ -144,13 +145,19 @@ class Daytona {
             try {
                 errorMessage = JSON.stringify(errorMessage);
             }
-            catch (_d) {
+            catch (_f) {
                 errorMessage = String(errorMessage);
             }
-            throw new DaytonaError_1.DaytonaError(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));
     }
     /**
      * Creates Sandboxes with default or custom configurations. You can specify various parameters,
@@ -182,8 +189,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' };
         }
@@ -214,6 +221,7 @@ 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,
             });
@@ -224,10 +232,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) {
+                const timeElapsed = Date.now() - startTime;
+                await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - timeElapsed / 1000 : 0);
+            }
             return sandbox;
         }
         catch (error) {

package/dist/Process.d.ts

@@ -168,7 +168,7 @@ export declare class Process {
      * @param {string} sessionId - Unique identifier of the session to use
      * @param {SessionExecuteRequest} req - Command execution request containing:
      *                                     - command: The command to execute
-     *                                     - async: Whether to execute asynchronously
+     *                                     - runAsync: Whether to execute asynchronously
      * @param {number} timeout - Timeout in seconds
      * @returns {Promise<SessionExecuteResponse>} Command execution results containing:
      *                                           - cmdId: Unique identifier for the executed command

package/dist/Process.js

@@ -202,7 +202,7 @@ class Process {
      * @param {string} sessionId - Unique identifier of the session to use
      * @param {SessionExecuteRequest} req - Command execution request containing:
      *                                     - command: The command to execute
-     *                                     - async: Whether to execute asynchronously
+     *                                     - runAsync: Whether to execute asynchronously
      * @param {number} timeout - Timeout in seconds
      * @returns {Promise<SessionExecuteResponse>} Command execution results containing:
      *                                           - cmdId: Unique identifier for the executed command

package/dist/Sandbox.d.ts

@@ -71,7 +71,7 @@ export interface SandboxInfo extends Omit<ApiSandboxInfo, 'name'> {
     /** Unique identifier */
     id: string;
     /** Docker image */
-    image: string;
+    image?: string;
     /** OS user */
     user: string;
     /** Environment variables */

package/dist/Volume.d.ts

@@ -0,0 +1,79 @@
+import { VolumeDto, VolumesApi } from '@daytonaio/api-client';
+/**
+ * Represents a Daytona Volume which is a shared storage volume for Sandboxes.
+ *
+ * @property {string} id - Unique identifier for the Volume
+ * @property {string} name - Name of the Volume
+ * @property {string} organizationId - Organization ID that owns the Volume
+ * @property {string} state - Current state of the Volume
+ * @property {string} createdAt - Date and time when the Volume was created
+ * @property {string} updatedAt - Date and time when the Volume was last updated
+ * @property {string} lastUsedAt - Date and time when the Volume was last used
+ */
+export type Volume = VolumeDto & {
+    __brand: 'Volume';
+};
+/**
+ * Service for managing Daytona Volumes.
+ *
+ * This service provides methods to list, get, create, and delete Volumes.
+ *
+ * @class
+ */
+export declare class VolumeService {
+    private volumesApi;
+    constructor(volumesApi: VolumesApi);
+    /**
+     * Lists all available Volumes.
+     *
+     * @returns {Promise<Volume[]>} List of all Volumes accessible to the user
+     *
+     * @example
+     * const daytona = new Daytona();
+     * const volumes = await daytona.volume.list();
+     * console.log(`Found ${volumes.length} volumes`);
+     * volumes.forEach(vol => console.log(`${vol.name} (${vol.id})`));
+     */
+    list(): Promise<Volume[]>;
+    /**
+     * Gets a Volume by its name.
+     *
+     * @param {string} name - Name of the Volume to retrieve
+     * @param {boolean} create - Whether to create the Volume if it does not exist
+     * @returns {Promise<Volume>} The requested Volume
+     * @throws {Error} If the Volume does not exist or cannot be accessed
+     *
+     * @example
+     * const daytona = new Daytona();
+     * const volume = await daytona.volume.get("volume-name", true);
+     * console.log(`Volume ${volume.name} is in state ${volume.state}`);
+     */
+    get(name: string, create?: boolean): Promise<Volume>;
+    /**
+     * Creates a new Volume with the specified name.
+     *
+     * @param {string} name - Name for the new Volume
+     * @returns {Promise<Volume>} The newly created Volume
+     * @throws {Error} If the Volume cannot be created
+     *
+     * @example
+     * const daytona = new Daytona();
+     * const volume = await daytona.volume.create("my-data-volume");
+     * console.log(`Created volume ${volume.name} with ID ${volume.id}`);
+     */
+    create(name: string): Promise<Volume>;
+    /**
+     * Deletes a Volume.
+     *
+     * @param {Volume} volume - Volume to delete
+     * @returns {Promise<void>}
+     * @throws {Error} If the Volume does not exist or cannot be deleted
+     *
+     * @example
+     * const daytona = new Daytona();
+     * const volume = await daytona.volume.get("volume-name");
+     * await daytona.volume.delete(volume);
+     * console.log("Volume deleted successfully");
+     */
+    delete(volume: Volume): Promise<void>;
+}

package/dist/Volume.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolumeService = void 0;
+const DaytonaError_1 = require("./errors/DaytonaError");
+/**
+ * Service for managing Daytona Volumes.
+ *
+ * This service provides methods to list, get, create, and delete Volumes.
+ *
+ * @class
+ */
+class VolumeService {
+    constructor(volumesApi) {
+        this.volumesApi = volumesApi;
+    }
+    /**
+     * Lists all available Volumes.
+     *
+     * @returns {Promise<Volume[]>} List of all Volumes accessible to the user
+     *
+     * @example
+     * const daytona = new Daytona();
+     * const volumes = await daytona.volume.list();
+     * console.log(`Found ${volumes.length} volumes`);
+     * volumes.forEach(vol => console.log(`${vol.name} (${vol.id})`));
+     */
+    async list() {
+        const response = await this.volumesApi.listVolumes();
+        return response.data;
+    }
+    /**
+     * Gets a Volume by its name.
+     *
+     * @param {string} name - Name of the Volume to retrieve
+     * @param {boolean} create - Whether to create the Volume if it does not exist
+     * @returns {Promise<Volume>} The requested Volume
+     * @throws {Error} If the Volume does not exist or cannot be accessed
+     *
+     * @example
+     * const daytona = new Daytona();
+     * const volume = await daytona.volume.get("volume-name", true);
+     * console.log(`Volume ${volume.name} is in state ${volume.state}`);
+     */
+    async get(name, create = false) {
+        try {
+            const response = await this.volumesApi.getVolumeByName(name);
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof DaytonaError_1.DaytonaNotFoundError &&
+                create &&
+                error.message.match(/Volume with name ([\w-]+) not found/)) {
+                return await this.create(name);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Creates a new Volume with the specified name.
+     *
+     * @param {string} name - Name for the new Volume
+     * @returns {Promise<Volume>} The newly created Volume
+     * @throws {Error} If the Volume cannot be created
+     *
+     * @example
+     * const daytona = new Daytona();
+     * const volume = await daytona.volume.create("my-data-volume");
+     * console.log(`Created volume ${volume.name} with ID ${volume.id}`);
+     */
+    async create(name) {
+        const response = await this.volumesApi.createVolume({ name });
+        return response.data;
+    }
+    /**
+     * Deletes a Volume.
+     *
+     * @param {Volume} volume - Volume to delete
+     * @returns {Promise<void>}
+     * @throws {Error} If the Volume does not exist or cannot be deleted
+     *
+     * @example
+     * const daytona = new Daytona();
+     * const volume = await daytona.volume.get("volume-name");
+     * await daytona.volume.delete(volume);
+     * console.log("Volume deleted successfully");
+     */
+    async delete(volume) {
+        await this.volumesApi.deleteVolume(volume.id);
+    }
+}
+exports.VolumeService = VolumeService;

package/dist/errors/DaytonaError.d.ts

@@ -6,3 +6,5 @@
  */
 export declare class DaytonaError extends Error {
 }
+export declare class DaytonaNotFoundError extends DaytonaError {
+}

package/dist/errors/DaytonaError.js

@@ -3,10 +3,13 @@
  * @module Errors
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DaytonaError = void 0;
+exports.DaytonaNotFoundError = exports.DaytonaError = void 0;
 /**
  * Base error for Daytona SDK.
  */
 class DaytonaError extends Error {
 }
 exports.DaytonaError = DaytonaError;
+class DaytonaNotFoundError extends DaytonaError {
+}
+exports.DaytonaNotFoundError = DaytonaNotFoundError;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { CodeLanguage, Daytona } from './Daytona';
-export type { CreateSandboxParams, DaytonaConfig, SandboxResources } from './Daytona';
+export type { CreateSandboxParams, DaytonaConfig, SandboxResources, VolumeMount } from './Daytona';
 export { FileSystem } from './FileSystem';
 export { Git } from './Git';
 export { LspLanguageId } from './LspServer';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daytonaio/sdk",
-  "version": "0.16.0",
+  "version": "0.17.0-alpha.1",
   "description": "Daytona client library for AI Agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,8 +34,9 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@daytonaio/api-client": "^0.17.1",
+    "@daytonaio/api-client": "^0.18.0-alpha.0",
     "uuid": "^11.0.3",
-    "@dotenvx/dotenvx": "^1.25.1"
+    "@dotenvx/dotenvx": "^1.25.1",
+    "axios": "^1.6.0"
   }
 }