@daytonaio/sdk 0.7.2 → 0.9.0

package/dist/Daytona.d.ts

@@ -84,6 +84,11 @@ 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
@@ -101,6 +106,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

@@ -69,7 +69,7 @@ class Daytona {
         const workspaceInstance = reponse.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();
         }
         return workspace;
     }
@@ -85,12 +85,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);
+        await workspace.start();
     }
     /**
      * Stops a workspace
@@ -98,7 +113,7 @@ class Daytona {
      * @returns {Promise<void>}
      */
     async stop(workspace) {
-        await this.workspaceApi.stopWorkspace(workspace.id);
+        await workspace.stop();
     }
     /**
      * Removes a workspace
@@ -108,22 +123,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,31 @@ 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(): Promise<void>;
+    /**
+     * Stops the workspace
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * Deletes the workspace
+     * @returns {Promise<void>}
+     */
+    delete(): Promise<void>;
+    waitUntilStarted(): Promise<void>;
+    waitUntilStopped(): Promise<void>;
+    /**
+     * Get structured information about the workspace
+     * @returns {Promise<WorkspaceInfo>} Structured workspace information
+     */
+    info(): Promise<WorkspaceInfo>;
 }

package/dist/Workspace.js

@@ -47,5 +47,104 @@ 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() {
+        await this.workspaceApi.startWorkspace(this.instance.id);
+        await this.waitUntilStarted();
+    }
+    /**
+     * 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() {
+        const maxAttempts = 600;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            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: ${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');
+    }
+    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: ${status}`);
+            }
+            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
+        };
+    }
 }
 exports.Workspace = Workspace;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daytonaio/sdk",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Daytona client library for AI Agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,7 +29,7 @@
     "@babel/preset-typescript": "^7.22.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^22.10.0",
-    "@daytonaio/api-client": "~0.9.8",
+    "@daytonaio/api-client": "~0.12.2",
     "jest": "^29.5.0",
     "ts-jest": "^29.1.0",
     "typescript": "^5.0.0",