@daytonaio/sdk 0.14.0 → 0.16.0-alpha.0

package/README.md

@@ -34,7 +34,7 @@ const response = await sandbox.process.codeRun('console.log("Hello World!")')
 console.log(response.result)
 
 // Clean up when done
-await daytona.remove(sandbox)
+await daytona.delete(sandbox)
 ```
 
 ## Configuration

package/dist/Daytona.d.ts

@@ -1,5 +1,18 @@
-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
+ * @extends {WorkspaceVolume}
+ */
+export interface VolumeMount extends WorkspaceVolume {
+    volumeId: string;
+    mountPath: string;
+}
 /**
  * Configuration options for initializing the Daytona client.
  *
@@ -76,7 +89,6 @@ export interface SandboxResources {
  * Parameters for creating a new Sandbox.
  *
  * @interface
- * @property {string} [id] - Optional Sandbox ID. If not provided, a random ID will be generated
  * @property {string} [image] - Optional Docker image to use for the Sandbox
  * @property {string} [user] - Optional os user to use for the Sandbox
  * @property {CodeLanguage | string} [language] - Programming language for direct code execution
@@ -102,8 +114,6 @@ export interface SandboxResources {
  * const sandbox = await daytona.create(params, 50);
  */
 export type CreateSandboxParams = {
-    /** Optional Sandbox ID. If not provided, a random ID will be generated */
-    id?: string;
     /** Optional Docker image to use for the Sandbox */
     image?: string;
     /** Optional os user to use for the Sandbox */
@@ -129,13 +139,26 @@ 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[];
 };
 /**
- * Main class for interacting with the Daytona API.
+ * Filter for Sandboxes.
  *
+ * @interface
+ * @property {string} [id] - The ID of the Sandbox to retrieve
+ * @property {Record<string, string>} [labels] - Labels to filter Sandboxes
+ */
+export type SandboxFilter = {
+    id?: string;
+    labels?: Record<string, string>;
+};
+/**
+ * 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
@@ -162,6 +185,7 @@ export declare class Daytona {
     private readonly jwtToken?;
     private readonly organizationId?;
     private readonly apiUrl;
+    readonly volume: VolumeService;
     /**
      * Creates a new Daytona client instance.
      *
@@ -211,17 +235,29 @@ export declare class Daytona {
      */
     get(sandboxId: string): Promise<Sandbox>;
     /**
-     * Lists all Sandboxes.
+     * 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()}`);
+     */
+    findOne(filter: SandboxFilter): Promise<Sandbox>;
+    /**
+     * Lists all Sandboxes filtered by labels.
      *
-     * @returns {Promise<Sandbox[]>} Array of Sandboxes
+     * @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();
+     * const sandboxes = await daytona.list({ 'my-label': 'my-value' });
      * for (const sandbox of sandboxes) {
      *     console.log(`${sandbox.id}: ${sandbox.instance.state}`);
      * }
      */
-    list(): Promise<Sandbox[]>;
+    list(labels?: Record<string, string>): Promise<Sandbox[]>;
     /**
      * Starts a Sandbox and waits for it to be ready.
      *
@@ -247,17 +283,19 @@ export declare class Daytona {
      */
     stop(sandbox: Sandbox): Promise<void>;
     /**
-     * Removes a Sandbox.
+     * Deletes a Sandbox.
      *
-     * @param {Sandbox} sandbox - The Sandbox to remove
+     * @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.remove(sandbox);
+     * await daytona.delete(sandbox);
      */
-    remove(sandbox: Sandbox, timeout?: number): Promise<void>;
+    delete(sandbox: Sandbox, timeout?: number): Promise<void>;
+    /** @hidden */
+    remove: (sandbox: Sandbox, timeout?: number) => Promise<void>;
     /**
      * Gets the Sandbox by ID.
      *

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
@@ -86,6 +87,7 @@ class Daytona {
      */
     constructor(config) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
+        this.remove = this.delete.bind(this);
         dotenv_1.default.config();
         dotenv_1.default.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) || ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.DAYTONA_API_KEY);
@@ -148,6 +150,7 @@ 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));
     }
     /**
      * Creates Sandboxes with default or custom configurations. You can specify various parameters,
@@ -200,8 +203,6 @@ class Daytona {
         const codeToolbox = this.getCodeToolbox(params.language);
         try {
             const response = await this.sandboxApi.createWorkspace({
-                id: params.id,
-                name: params.id,
                 image: params.image,
                 user: params.user,
                 env: params.envVars || {},
@@ -213,12 +214,16 @@ 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,
             });
             const sandboxInstance = response.data;
             const sandboxInfo = Sandbox_1.Sandbox.toSandboxInfo(sandboxInstance);
-            sandboxInstance.info = sandboxInfo;
+            sandboxInstance.info = {
+                ...sandboxInfo,
+                name: '',
+            };
             const sandbox = new Sandbox_1.Sandbox(sandboxInstance.id, sandboxInstance, this.sandboxApi, this.toolboxApi, codeToolbox);
             // if (!params.async) {
             //   const timeElapsed = Date.now() - startTime;
@@ -227,7 +232,6 @@ class Daytona {
             return sandbox;
         }
         catch (error) {
-            void this.sandboxApi.deleteWorkspace(params.id, true).catch(() => { });
             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.`);
             }
@@ -250,27 +254,54 @@ class Daytona {
         const language = sandboxInstance.labels && sandboxInstance.labels['code-toolbox-language'];
         const codeToolbox = this.getCodeToolbox(language);
         const sandboxInfo = Sandbox_1.Sandbox.toSandboxInfo(sandboxInstance);
-        sandboxInstance.info = sandboxInfo;
+        sandboxInstance.info = {
+            ...sandboxInfo,
+            name: '',
+        };
         return new Sandbox_1.Sandbox(sandboxId, sandboxInstance, this.sandboxApi, this.toolboxApi, codeToolbox);
     }
     /**
-     * Lists all Sandboxes.
+     * 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.
      *
-     * @returns {Promise<Sandbox[]>} Array of Sandboxes
+     * @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();
+     * const sandboxes = await daytona.list({ 'my-label': 'my-value' });
      * for (const sandbox of sandboxes) {
      *     console.log(`${sandbox.id}: ${sandbox.instance.state}`);
      * }
      */
-    async list() {
-        const response = await this.sandboxApi.listWorkspaces();
+    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;
+            sandbox.info = {
+                ...sandboxInfo,
+                name: '',
+            };
             return new Sandbox_1.Sandbox(sandbox.id, sandbox, this.sandboxApi, this.toolboxApi, this.getCodeToolbox(language));
         });
     }
@@ -303,17 +334,17 @@ class Daytona {
         await sandbox.stop();
     }
     /**
-     * Removes a Sandbox.
+     * Deletes a Sandbox.
      *
-     * @param {Sandbox} sandbox - The Sandbox to remove
+     * @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.remove(sandbox);
+     * await daytona.delete(sandbox);
      */
-    async remove(sandbox, timeout = 60) {
+    async delete(sandbox, timeout = 60) {
         await this.sandboxApi.deleteWorkspace(sandbox.id, true, undefined, { timeout: timeout * 1000 });
     }
     /**

package/dist/Process.js

@@ -45,21 +45,23 @@ class Process {
      * const result = await process.executeCommand('sleep 10', undefined, 5);
      */
     async executeCommand(command, cwd, env, timeout) {
-        const envVars = env
-            ? Object.entries(env)
-                .map(([key, value]) => `${key}=${value}`)
-                .join(' ')
-            : undefined;
-        if (envVars) {
-            const base64Cmd = Buffer.from(command).toString('base64');
-            command = `sh -c '${envVars} sh -c "echo '${base64Cmd}' | base64 -d | sh"'`;
+        const base64UserCmd = Buffer.from(command).toString('base64');
+        command = `echo '${base64UserCmd}' | base64 -d | sh`;
+        if (env && Object.keys(env).length > 0) {
+            const safeEnvExports = Object.entries(env)
+                .map(([key, value]) => {
+                const encodedValue = Buffer.from(value).toString('base64');
+                return `export ${key}=$(echo '${encodedValue}' | base64 -d)`;
+            })
+                .join(';') + ';';
+            command = `${safeEnvExports} ${command}`;
         }
+        command = `sh -c "${command}"`;
         const response = await this.toolboxApi.executeCommand(this.instance.id, {
             command,
             timeout,
             cwd,
         });
-        // console.log(response)
         // Parse artifacts from the output
         const artifacts = ArtifactParser_1.ArtifactParser.parseArtifacts(response.data.result);
         // Return enhanced response with parsed artifacts
@@ -129,7 +131,7 @@ class Process {
      */
     async codeRun(code, params, timeout) {
         const runCommand = this.codeToolbox.getRunCommand(code, params);
-        return this.executeCommand(runCommand, undefined, undefined, timeout);
+        return this.executeCommand(runCommand, undefined, params === null || params === void 0 ? void 0 : params.env, timeout);
     }
     /**
      * Creates a new long-running background session in the Sandbox.

package/dist/Sandbox.d.ts

@@ -43,7 +43,6 @@ export interface SandboxResources {
  *
  * @interface
  * @property {string} id - Unique identifier for the Sandbox
- * @property {string} name - Display name of the Sandbox
  * @property {string} image - Docker image used for the Sandbox
  * @property {string} user - OS user running in the Sandbox
  * @property {Record<string, string>} env - Environment variables set in the Sandbox
@@ -54,7 +53,7 @@ export interface SandboxResources {
  * @property {string} state - Current state of the Sandbox (e.g., "started", "stopped")
  * @property {string | null} errorReason - Error message if Sandbox is in error state
  * @property {string | null} snapshotState - Current state of Sandbox snapshot
- * @property {Date | null} snapshotCreatedAt - When the snapshot was created
+ * @property {string | null} snapshotCreatedAt - When the snapshot was created
  * @property {string} nodeDomain - Domain name of the Sandbox node
  * @property {string} region - Region of the Sandbox node
  * @property {string} class - Sandbox class
@@ -65,14 +64,12 @@ export interface SandboxResources {
  * @example
  * const sandbox = await daytona.create();
  * const info = await sandbox.info();
- * console.log(`Sandbox ${info.name} is ${info.state}`);
+ * console.log(`Sandbox ${info.id} is ${info.state}`);
  * console.log(`Resources: ${info.resources.cpu} CPU, ${info.resources.memory} RAM`);
  */
-export interface SandboxInfo extends ApiSandboxInfo {
+export interface SandboxInfo extends Omit<ApiSandboxInfo, 'name'> {
     /** Unique identifier */
     id: string;
-    /** Sandbox name */
-    name: string;
     /** Docker image */
     image: string;
     /** OS user */
@@ -93,8 +90,8 @@ export interface SandboxInfo extends ApiSandboxInfo {
     errorReason: string | null;
     /** Snapshot state */
     snapshotState: string | null;
-    /** Snapshot creation timestamp */
-    snapshotCreatedAt: Date | null;
+    /** Snapshot creation time */
+    snapshotCreatedAt: string | null;
     /** Node domain */
     nodeDomain: string;
     /** Region */
@@ -269,7 +266,7 @@ export declare class Sandbox {
      *
      * @example
      * const info = await sandbox.info();
-     * console.log(`Sandbox ${info.name}:`);
+     * console.log(`Sandbox ${info.id}:`);
      * console.log(`State: ${info.state}`);
      * console.log(`Resources: ${info.resources.cpu} CPU, ${info.resources.memory} RAM`);
      */

package/dist/Sandbox.js

@@ -217,7 +217,7 @@ class Sandbox {
      *
      * @example
      * const info = await sandbox.info();
-     * console.log(`Sandbox ${info.name}:`);
+     * console.log(`Sandbox ${info.id}:`);
      * console.log(`State: ${info.state}`);
      * console.log(`Resources: ${info.resources.cpu} CPU, ${info.resources.memory} RAM`);
      */
@@ -255,7 +255,6 @@ class Sandbox {
         };
         return {
             id: instance.id,
-            name: instance.name,
             image: instance.image,
             user: instance.user,
             env: instance.env || {},
@@ -266,7 +265,7 @@ class Sandbox {
             state: instance.state || api_client_1.WorkspaceState.UNKNOWN,
             errorReason: instance.errorReason || null,
             snapshotState: instance.snapshotState || null,
-            snapshotCreatedAt: instance.snapshotCreatedAt ? new Date(instance.snapshotCreatedAt) : null,
+            snapshotCreatedAt: instance.snapshotCreatedAt || null,
             autoStopInterval: instance.autoStopInterval || 15,
             created: ((_d = instance.info) === null || _d === void 0 ? void 0 : _d.created) || '',
             nodeDomain: providerMetadata.nodeDomain || '',

package/dist/Volume.d.ts

@@ -0,0 +1,78 @@
+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
+     * @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");
+     * console.log(`Volume ${volume.name} is in state ${volume.state}`);
+     */
+    get(name: string): 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,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolumeService = void 0;
+/**
+ * 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
+     * @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");
+     * console.log(`Volume ${volume.name} is in state ${volume.state}`);
+     */
+    async get(name) {
+        const response = await this.volumesApi.getVolumeByName(name);
+        return response.data;
+    }
+    /**
+     * 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/code-toolbox/SandboxPythonCodeToolbox.js

@@ -14,17 +14,11 @@ class SandboxPythonCodeToolbox {
             code_wrapper = code_wrapper.replace('{encoded_code}', base64Code);
             base64Code = Buffer.from(code_wrapper).toString('base64');
         }
-        // Build environment variables string
-        const envVars = (params === null || params === void 0 ? void 0 : params.env)
-            ? Object.entries(params.env)
-                .map(([key, value]) => `${key}='${value}'`)
-                .join(' ')
-            : '';
         // Build command-line arguments string
         const argv = (params === null || params === void 0 ? void 0 : params.argv) ? params.argv.join(' ') : '';
         // Execute the bootstrapper code directly
         // Use -u flag to ensure unbuffered output for real-time error reporting
-        return `sh -c '${envVars} python3 -u -c "exec(__import__(\\\"base64\\\").b64decode(\\\"${base64Code}\\\").decode())" ${argv}'`;
+        return `sh -c 'python3 -u -c "exec(__import__(\\\"base64\\\").b64decode(\\\"${base64Code}\\\").decode())" ${argv}'`;
     }
     /**
      * Checks if matplotlib is imported in the given Python code string.

package/dist/code-toolbox/SandboxTsCodeToolbox.js

@@ -7,13 +7,8 @@ class SandboxTsCodeToolbox {
     }
     getRunCommand(code, params) {
         const base64Code = Buffer.from(code).toString('base64');
-        const envVars = (params === null || params === void 0 ? void 0 : params.env)
-            ? Object.entries(params.env)
-                .map(([key, value]) => `${key}='${value}'`)
-                .join(' ')
-            : '';
         const argv = (params === null || params === void 0 ? void 0 : params.argv) ? params.argv.join(' ') : '';
-        return `sh -c 'echo ${base64Code} | base64 --decode | ${envVars} npx ts-node -O "{\\\"module\\\":\\\"CommonJS\\\"}" -e "$(cat)" x ${argv} 2>&1 | grep -vE "npm notice|npm warn exec"'`;
+        return `sh -c 'echo ${base64Code} | base64 --decode | npx ts-node -O "{\\\"module\\\":\\\"CommonJS\\\"}" -e "$(cat)" x ${argv} 2>&1 | grep -vE "npm notice"'`;
     }
 }
 exports.SandboxTsCodeToolbox = SandboxTsCodeToolbox;

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.14.0",
+  "version": "0.16.0-alpha.0",
   "description": "Daytona client library for AI Agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,7 +34,7 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@daytonaio/api-client": "^0.16.0",
+    "@daytonaio/api-client": "^0.18.0-alpha.0",
     "uuid": "^11.0.3",
     "@dotenvx/dotenvx": "^1.25.1"
   }