@daytonaio/sdk 0.7.2 → 0.9.2

package/README.md

@@ -34,13 +34,13 @@ To use the SDK, you'll need two essential pieces of information:
 You can install the package using npm:
 
 ```bash
-npm install @daytona/sdk
+npm install @daytonaio/sdk
 ```
 
 Or using yarn:
 
 ```bash
-yarn add @daytona/sdk
+yarn add @daytonaio/sdk
 ```
 
 ## Quick Start
@@ -48,7 +48,7 @@ yarn add @daytona/sdk
 Here's a simple example of using the SDK:
 
 ```typescript
-import { Daytona } from '@daytona/sdk'
+import { Daytona } from '@daytonaio/sdk'
 
 // Initialize the Daytona client
 const daytona = new Daytona()
@@ -76,7 +76,7 @@ console.log(response.result)
 The SDK can be configured using environment variables or by passing a configuration object:
 
 ```typescript
-import { Daytona, DaytonaConfig } from '@daytona/sdk'
+import { Daytona, DaytonaConfig } from '@daytonaio/sdk'
 
 const config: DaytonaConfig = {
   apiKey: 'your-api-key',

package/dist/Daytona.d.ts

@@ -55,6 +55,10 @@ export type CreateWorkspaceParams = {
     resources?: WorkspaceResources;
     /** If true, will not wait for the workspace to be ready before returning */
     async?: boolean;
+    /** Timeout in seconds, for the workspace to be ready (0 means no timeout) */
+    timeout?: number;
+    /** Auto-stop interval in minutes (0 means disabled) (must be a non-negative integer) */
+    autoStopInterval?: number;
 };
 /**
  * Main class for interacting with Daytona Server API
@@ -84,11 +88,16 @@ export declare class Daytona {
      * @returns {Promise<Workspace>} The workspace instance
      */
     get(workspaceId: string): Promise<Workspace>;
+    /**
+     * Lists all workspaces
+     * @returns {Promise<Workspace[]>} The list of workspaces
+     */
+    list(): Promise<Workspace[]>;
     /**
      * Starts a workspace
      * @param {Workspace} workspace - The workspace to start
      */
-    start(workspace: Workspace): Promise<void>;
+    start(workspace: Workspace, timeout?: number): Promise<void>;
     /**
      * Stops a workspace
      * @param {Workspace} workspace - The workspace to stop
@@ -101,6 +110,11 @@ export declare class Daytona {
      * @returns {Promise<void>}
      */
     remove(workspace: Workspace): Promise<void>;
-    waitUntilReady(workspace: Workspace): Promise<void>;
+    /**
+     * Gets the current workspace by ID
+     * @param {string} workspaceId - The ID of the workspace to retrieve
+     * @returns {Promise<Workspace>} The workspace instance
+     */
+    getCurrentWorkspace(workspaceId: string): Promise<Workspace>;
     private getCodeToolbox;
 }

package/dist/Daytona.js

@@ -48,13 +48,19 @@ class Daytona {
      */
     async create(params) {
         var _a, _b, _c, _d;
+        if ((params === null || params === void 0 ? void 0 : params.autoStopInterval) !== undefined && (!Number.isInteger(params.autoStopInterval) || params.autoStopInterval < 0)) {
+            throw new Error('autoStopInterval must be a non-negative integer');
+        }
         const workspaceId = (params === null || params === void 0 ? void 0 : params.id) || `sandbox-${(0, uuid_1.v4)().slice(0, 8)}`;
         const codeToolbox = this.getCodeToolbox(params === null || params === void 0 ? void 0 : params.language);
         const labels = (params === null || params === void 0 ? void 0 : params.labels) || {};
         if (params === null || params === void 0 ? void 0 : params.language) {
             labels[`code-toolbox-language`] = params.language;
         }
-        const reponse = await this.workspaceApi.createWorkspace({
+        if ((params === null || params === void 0 ? void 0 : params.timeout) && params.timeout < 0) {
+            throw new Error('Timeout must be a non-negative number');
+        }
+        const response = await this.workspaceApi.createWorkspace({
             id: workspaceId,
             name: workspaceId, //  todo: remove this after project refactor
             image: params === null || params === void 0 ? void 0 : params.image,
@@ -65,11 +71,12 @@ class Daytona {
             gpu: (_b = params === null || params === void 0 ? void 0 : params.resources) === null || _b === void 0 ? void 0 : _b.gpu,
             memory: (_c = params === null || params === void 0 ? void 0 : params.resources) === null || _c === void 0 ? void 0 : _c.memory,
             disk: (_d = params === null || params === void 0 ? void 0 : params.resources) === null || _d === void 0 ? void 0 : _d.disk,
+            autoStopInterval: params === null || params === void 0 ? void 0 : params.autoStopInterval,
         });
-        const workspaceInstance = reponse.data;
+        const workspaceInstance = response.data;
         const workspace = new Workspace_1.Workspace(workspaceId, workspaceInstance, this.workspaceApi, this.toolboxApi, codeToolbox);
         if (!(params === null || params === void 0 ? void 0 : params.async)) {
-            await this.waitUntilReady(workspace);
+            await workspace.waitUntilStarted(params === null || params === void 0 ? void 0 : params.timeout);
         }
         return workspace;
     }
@@ -85,12 +92,27 @@ class Daytona {
         const codeToolbox = this.getCodeToolbox(language);
         return new Workspace_1.Workspace(workspaceId, workspaceInstance, this.workspaceApi, this.toolboxApi, codeToolbox);
     }
+    /**
+     * Lists all workspaces
+     * @returns {Promise<Workspace[]>} The list of workspaces
+     */
+    async list() {
+        const response = await this.workspaceApi.listWorkspaces();
+        return response.data.map((workspace) => {
+            var _a;
+            const language = (_a = workspace.labels) === null || _a === void 0 ? void 0 : _a[`code-toolbox-language`];
+            if (language && !['python', 'javascript', 'typescript'].includes(language)) {
+                throw new Error(`Invalid code-toolbox-language: ${language}`);
+            }
+            return new Workspace_1.Workspace(workspace.id, workspace, this.workspaceApi, this.toolboxApi, this.getCodeToolbox(language));
+        });
+    }
     /**
      * Starts a workspace
      * @param {Workspace} workspace - The workspace to start
      */
-    async start(workspace) {
-        await this.workspaceApi.startWorkspace(workspace.id);
+    async start(workspace, timeout) {
+        await workspace.start(timeout);
     }
     /**
      * Stops a workspace
@@ -98,7 +120,7 @@ class Daytona {
      * @returns {Promise<void>}
      */
     async stop(workspace) {
-        await this.workspaceApi.stopWorkspace(workspace.id);
+        await workspace.stop();
     }
     /**
      * Removes a workspace
@@ -108,22 +130,13 @@ class Daytona {
     async remove(workspace) {
         await this.workspaceApi.deleteWorkspace(workspace.id, true);
     }
-    async waitUntilReady(workspace) {
-        const maxAttempts = 60; // 5 minutes with 5 second intervals
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const response = await this.workspaceApi.getWorkspace(workspace.id);
-            const state = response.data.state;
-            if (state === 'started') {
-                return;
-            }
-            if (state === 'error') {
-                throw new Error(`Workspace failed to start with status: ${status}`);
-            }
-            await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100 ms between checks
-            attempts++;
-        }
-        throw new Error('Workspace failed to become ready within the timeout period');
+    /**
+     * Gets the current workspace by ID
+     * @param {string} workspaceId - The ID of the workspace to retrieve
+     * @returns {Promise<Workspace>} The workspace instance
+     */
+    async getCurrentWorkspace(workspaceId) {
+        return this.get(workspaceId);
     }
     getCodeToolbox(language) {
         switch (language) {

package/dist/Process.d.ts

@@ -1,4 +1,4 @@
-import { ExecuteResponse, Session, SessionExecuteRequest, SessionExecuteResponse, ToolboxApi, Workspace } from '@daytonaio/api-client';
+import { Command, ExecuteResponse, Session, SessionExecuteRequest, SessionExecuteResponse, ToolboxApi, Workspace } from '@daytonaio/api-client';
 import { WorkspaceCodeToolbox } from './Workspace';
 /**
  * Handles process and code execution within a workspace
@@ -14,7 +14,7 @@ export declare class Process {
      * @param {string} command - Command to execute
      * @returns {Promise<ExecuteResponse>} Command execution results
      */
-    processExecuteCommand(command: string, timeout?: number): Promise<ExecuteResponse>;
+    executeCommand(command: string, cwd?: string, timeout?: number): Promise<ExecuteResponse>;
     /**
      * Executes code in the workspace using the appropriate language runtime
      * @param {string} code - Code to execute
@@ -33,14 +33,27 @@ export declare class Process {
      * @param {SessionExecuteRequest} req - Command to execute and async flag
      * @returns {Promise<SessionExecuteResponse>} Command execution results
      */
-    executeSession(sessionId: string, req: SessionExecuteRequest): Promise<SessionExecuteResponse>;
+    executeSessionCommand(sessionId: string, req: SessionExecuteRequest): Promise<SessionExecuteResponse>;
     /**
      * Gets the logs for a command in the session
      * @param {string} sessionId - Unique identifier for the session
      * @param {string} commandId - Unique identifier for the command
      * @returns {Promise<string>} Command logs
      */
-    getExecuteSessionCommandLogs(sessionId: string, commandId: string): Promise<string>;
+    getSessionCommandLogs(sessionId: string, commandId: string): Promise<string>;
+    /**
+     * Gets the session
+     * @param {string} sessionId - Unique identifier for the session
+     * @returns {Promise<Session>} Session
+     */
+    getSession(sessionId: string): Promise<Session>;
+    /**
+     * Gets the session command
+     * @param {string} sessionId - Unique identifier for the session
+     * @param {string} commandId - Unique identifier for the command
+     * @returns {Promise<Command>} Session command
+     */
+    getSessionCommand(sessionId: string, commandId: string): Promise<Command>;
     /**
      * Lists all sessions in the workspace
      * @returns {Promise<Session[]>} List of sessions

package/dist/Process.js

@@ -16,10 +16,11 @@ class Process {
      * @param {string} command - Command to execute
      * @returns {Promise<ExecuteResponse>} Command execution results
      */
-    async processExecuteCommand(command, timeout) {
+    async executeCommand(command, cwd, timeout) {
         const response = await this.toolboxApi.executeCommand(this.instance.id, {
             command,
             timeout,
+            cwd,
         });
         return response.data;
     }
@@ -51,7 +52,7 @@ class Process {
      * @param {SessionExecuteRequest} req - Command to execute and async flag
      * @returns {Promise<SessionExecuteResponse>} Command execution results
      */
-    async executeSession(sessionId, req) {
+    async executeSessionCommand(sessionId, req) {
         const response = await this.toolboxApi.executeSessionCommand(this.instance.id, sessionId, req);
         return response.data;
     }
@@ -61,10 +62,29 @@ class Process {
      * @param {string} commandId - Unique identifier for the command
      * @returns {Promise<string>} Command logs
      */
-    async getExecuteSessionCommandLogs(sessionId, commandId) {
+    async getSessionCommandLogs(sessionId, commandId) {
         const response = await this.toolboxApi.getSessionCommandLogs(this.instance.id, sessionId, commandId);
         return response.data;
     }
+    /**
+     * Gets the session
+     * @param {string} sessionId - Unique identifier for the session
+     * @returns {Promise<Session>} Session
+     */
+    async getSession(sessionId) {
+        const response = await this.toolboxApi.getSession(this.instance.id, sessionId);
+        return response.data;
+    }
+    /**
+     * Gets the session command
+     * @param {string} sessionId - Unique identifier for the session
+     * @param {string} commandId - Unique identifier for the command
+     * @returns {Promise<Command>} Session command
+     */
+    async getSessionCommand(sessionId, commandId) {
+        const response = await this.toolboxApi.getSessionCommand(this.instance.id, sessionId, commandId);
+        return response.data;
+    }
     /**
      * Lists all sessions in the workspace
      * @returns {Promise<Session[]>} List of sessions

package/dist/Workspace.d.ts

@@ -4,6 +4,52 @@ import { FileSystem } from './FileSystem';
 import { Git } from './Git';
 import { Process } from './Process';
 import { LspLanguageId, LspServer } from './LspServer';
+/**
+ * Resources allocated to a workspace
+ * @interface WorkspaceResources
+ */
+export interface WorkspaceResources {
+    /** CPU allocation */
+    cpu: string;
+    /** GPU allocation */
+    gpu: string | null;
+    /** Memory allocation */
+    memory: string;
+    /** Disk allocation */
+    disk: string;
+}
+/**
+ * Structured information about a workspace
+ * @interface WorkspaceInfo
+ */
+export interface WorkspaceInfo {
+    /** Unique identifier */
+    id: string;
+    /** Workspace name */
+    name: string;
+    /** Docker image */
+    image: string;
+    /** OS user */
+    user: string;
+    /** Environment variables */
+    env: Record<string, string>;
+    /** Workspace labels */
+    labels: Record<string, string>;
+    /** Public access flag */
+    public: boolean;
+    /** Target location */
+    target: string;
+    /** Resource allocations */
+    resources: WorkspaceResources;
+    /** Current state */
+    state: string;
+    /** Error reason if any */
+    errorReason: string | null;
+    /** Snapshot state */
+    snapshotState: string | null;
+    /** Snapshot state creation timestamp */
+    snapshotStateCreatedAt: Date | null;
+}
 /**
  * Interface defining methods that a code toolbox must implement
  * @interface WorkspaceCodeToolbox
@@ -50,4 +96,37 @@ export declare class Workspace {
      * @returns {LspServer} A new LSP server instance
      */
     createLspServer(languageId: LspLanguageId, pathToProject: string): LspServer;
+    /**
+     * Sets labels for the workspace
+     * @param {Record<string, string>} labels - The labels to set
+     */
+    setLabels(labels: Record<string, string>): Promise<void>;
+    /**
+     * Starts the workspace
+     * @returns {Promise<void>}
+     */
+    start(timeout?: number): Promise<void>;
+    /**
+     * Stops the workspace
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * Deletes the workspace
+     * @returns {Promise<void>}
+     */
+    delete(): Promise<void>;
+    waitUntilStarted(timeout?: number): Promise<void>;
+    waitUntilStopped(): Promise<void>;
+    /**
+     * Get structured information about the workspace
+     * @returns {Promise<WorkspaceInfo>} Structured workspace information
+     */
+    info(): Promise<WorkspaceInfo>;
+    /**
+     * Sets the auto-stop interval for the workspace
+     * @param {number} interval - Number of minutes after which the workspace will automatically stop (must be an integer). Set to 0 to disable auto-stop.
+     * @throws {Error} If interval is negative
+     */
+    setAutostopInterval(interval: number): Promise<void>;
 }

package/dist/Workspace.js

@@ -47,5 +47,121 @@ class Workspace {
     createLspServer(languageId, pathToProject) {
         return new LspServer_1.LspServer(languageId, pathToProject, this.toolboxApi, this.instance);
     }
+    /**
+     * Sets labels for the workspace
+     * @param {Record<string, string>} labels - The labels to set
+     */
+    async setLabels(labels) {
+        await this.workspaceApi.replaceLabels(this.instance.id, { labels });
+    }
+    /**
+     * Starts the workspace
+     * @returns {Promise<void>}
+     */
+    async start(timeout) {
+        if (timeout != undefined && timeout < 0) {
+            throw new Error('Timeout must be a non-negative number');
+        }
+        await this.workspaceApi.startWorkspace(this.instance.id);
+        await this.waitUntilStarted(timeout);
+    }
+    /**
+     * Stops the workspace
+     * @returns {Promise<void>}
+     */
+    async stop() {
+        await this.workspaceApi.stopWorkspace(this.instance.id);
+        await this.waitUntilStopped();
+    }
+    /**
+     * Deletes the workspace
+     * @returns {Promise<void>}
+     */
+    async delete() {
+        await this.workspaceApi.deleteWorkspace(this.instance.id, true);
+    }
+    async waitUntilStarted(timeout = 60) {
+        if (timeout < 0) {
+            throw new Error('Timeout must be a non-negative number');
+        }
+        const checkInterval = 100; // Wait 100 ms between checks
+        const startTime = Date.now();
+        while (timeout === 0 || (Date.now() - startTime) < (timeout * 1000)) {
+            const response = await this.workspaceApi.getWorkspace(this.id);
+            const state = response.data.state;
+            if (state === 'started') {
+                return;
+            }
+            if (state === 'error') {
+                throw new Error(`Workspace failed to start with status: ${state}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+        }
+        throw new Error('Workspace failed to become ready within the timeout period');
+    }
+    async waitUntilStopped() {
+        const maxAttempts = 600;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const response = await this.workspaceApi.getWorkspace(this.id);
+            const state = response.data.state;
+            if (state === 'stopped') {
+                return;
+            }
+            if (state === 'error') {
+                throw new Error(`Workspace failed to stop with status: ${state}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100 ms between checks
+            attempts++;
+        }
+        throw new Error('Workspace failed to become stopped within the timeout period');
+    }
+    /**
+     * Get structured information about the workspace
+     * @returns {Promise<WorkspaceInfo>} Structured workspace information
+     */
+    async info() {
+        var _a;
+        const response = await this.workspaceApi.getWorkspace(this.id);
+        const instance = response.data;
+        const providerMetadata = JSON.parse(((_a = instance.info) === null || _a === void 0 ? void 0 : _a.providerMetadata) || '{}');
+        // Extract resources with defaults
+        const resourcesData = providerMetadata.resources || {};
+        const resources = {
+            cpu: String(resourcesData.cpu || '1'),
+            gpu: resourcesData.gpu ? String(resourcesData.gpu) : null,
+            memory: String(resourcesData.memory || '2Gi'),
+            disk: String(resourcesData.disk || '10Gi')
+        };
+        return {
+            id: instance.id,
+            name: instance.name,
+            image: instance.image,
+            user: instance.user,
+            env: instance.env || {},
+            labels: instance.labels || {},
+            public: instance.public || false,
+            target: instance.target,
+            resources,
+            state: providerMetadata.state || '',
+            errorReason: providerMetadata.errorReason || null,
+            snapshotState: providerMetadata.snapshotState || null,
+            snapshotStateCreatedAt: providerMetadata.snapshotStateCreatedAt
+                ? new Date(providerMetadata.snapshotStateCreatedAt)
+                : null
+        };
+    }
+    /**
+     * Sets the auto-stop interval for the workspace
+     * @param {number} interval - Number of minutes after which the workspace will automatically stop (must be an integer). Set to 0 to disable auto-stop.
+     * @throws {Error} If interval is negative
+     */
+    async setAutostopInterval(interval) {
+        if (!Number.isInteger(interval) || interval < 0) {
+            throw new Error('autoStopInterval must be a non-negative integer');
+        }
+        await this.workspaceApi.setAutostopInterval(this.id, interval);
+        this.instance.autoStopInterval = interval;
+    }
 }
 exports.Workspace = Workspace;

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@daytonaio/sdk",
-  "version": "0.7.2",
+  "version": "0.9.2",
   "description": "Daytona client library for AI Agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/daytonaio/daytona-client.git"
+    "url": "git+https://github.com/daytonaio/sdk.git"
   },
   "author": "",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/daytonaio/daytona-client/issues"
+    "url": "https://github.com/daytonaio/sdk/issues"
   },
-  "homepage": "https://github.com/daytonaio/daytona-client#readme",
+  "homepage": "https://github.com/daytonaio/sdk#readme",
   "scripts": {
     "build": "tsc",
     "test": "jest",
@@ -29,7 +29,6 @@
     "@babel/preset-typescript": "^7.22.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^22.10.0",
-    "@daytonaio/api-client": "~0.9.8",
     "jest": "^29.5.0",
     "ts-jest": "^29.1.0",
     "typescript": "^5.0.0",
@@ -37,6 +36,7 @@
     "typedoc-plugin-markdown": "^3.17.1"
   },
   "dependencies": {
-    "uuid": "^11.0.3"
+    "uuid": "^11.0.3",
+    "@daytonaio/api-client": "~0.13.0"
   }
 }