@daytonaio/sdk 0.11.2 → 0.12.0

package/dist/Process.js

@@ -1,47 +1,18 @@
 "use strict";
-/**
- * The Daytona SDK provides powerful process and code execution capabilities through
- * the `process` module in Sandboxes. This guide covers all available process operations
- * and best practices.
- *
- * @module Process
- *
- * @example
- * // Execute a shell command
- * const response = await sandbox.process.executeCommand('ls -la');
- * console.log(response.result);
- *
- * // Run TypeScript code
- * const response = await sandbox.process.codeRun('console.log("Hello, World!")');
- * console.log(response.result);
- *
- * @example
- * // Using interactive sessions
- * // Create a new session
- * const sessionId = 'my-session';
- * await sandbox.process.createSession(sessionId);
- *
- * // Execute commands in the session
- * const response = await sandbox.process.executeSessionCommand(sessionId, {
- *   command: 'cd /workspace'
- * });
- *
- * const response2 = await sandbox.process.executeSessionCommand(sessionId, {
- *   command: 'pwd'
- * });
- * console.log(response2.result);  // Should print "/workspace"
- *
- * // Clean up
- * await sandbox.process.deleteSession(sessionId);
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Process = exports.CodeRunParams = void 0;
+const ArtifactParser_1 = require("./utils/ArtifactParser");
 /**
- * Parameters for code execution
+ * Parameters for code execution.
  */
 class CodeRunParams {
 }
 exports.CodeRunParams = CodeRunParams;
+/**
+ * Handles process and code execution within a Sandbox.
+ *
+ * @class
+ */
 class Process {
     constructor(codeToolbox, toolboxApi, instance) {
         this.codeToolbox = codeToolbox;
@@ -57,11 +28,12 @@ class Process {
      * @returns {Promise<ExecuteResponse>} Command execution results containing:
      *                                    - exitCode: The command's exit status
      *                                    - result: Standard output from the command
+     *                                    - artifacts: ExecutionArtifacts object containing `stdout` (same as result) and `charts` (matplotlib charts metadata)
      *
      * @example
      * // Simple command
      * const response = await process.executeCommand('echo "Hello"');
-     * console.log(response.result);  // Prints: Hello
+     * console.log(response.artifacts.stdout);  // Prints: Hello
      *
      * @example
      * // Command with working directory
@@ -77,16 +49,26 @@ class Process {
             timeout,
             cwd,
         });
-        return response.data;
+        // console.log(response)
+        // Parse artifacts from the output
+        const artifacts = ArtifactParser_1.ArtifactParser.parseArtifacts(response.data.result);
+        // Return enhanced response with parsed artifacts
+        return {
+            ...response.data,
+            result: artifacts.stdout,
+            artifacts,
+        };
     }
     /**
      * Executes code in the Sandbox using the appropriate language runtime.
      *
      * @param {string} code - Code to execute
      * @param {CodeRunParams} params - Parameters for code execution
+     * @param {number} [timeout] - Maximum time in seconds to wait for execution to complete
      * @returns {Promise<ExecuteResponse>} Code execution results containing:
      *                                    - exitCode: The execution's exit status
      *                                    - result: Standard output from the code
+     *                                    - artifacts: ExecutionArtifacts object containing `stdout` (same as result) and `charts` (matplotlib charts metadata)
      *
      * @example
      * // Run TypeScript code
@@ -95,12 +77,49 @@ class Process {
      *   const y = 20;
      *   console.log(\`Sum: \${x + y}\`);
      * `);
-     * console.log(response.result);  // Prints: Sum: 30
+     * console.log(response.artifacts.stdout);  // Prints: Sum: 30
+     *
+     * @example
+     * // Run Python code with matplotlib
+     * const response = await process.codeRun(`
+     * import matplotlib.pyplot as plt
+     * import numpy as np
+     *
+     * x = np.linspace(0, 10, 30)
+     * y = np.sin(x)
+     *
+     * plt.figure(figsize=(8, 5))
+     * plt.plot(x, y, 'b-', linewidth=2)
+     * plt.title('Line Chart')
+     * plt.xlabel('X-axis (seconds)')
+     * plt.ylabel('Y-axis (amplitude)')
+     * plt.grid(True)
+     * plt.show()
+     * `);
+     *
+     * if (response.artifacts?.charts) {
+     *   const chart = response.artifacts.charts[0];
+     *
+     *   console.log(`Type: ${chart.type}`);
+     *   console.log(`Title: ${chart.title}`);
+     *   if (chart.type === ChartType.LINE) {
+     *     const lineChart = chart as LineChart
+     *     console.log('X Label:', lineChart.x_label)
+     *     console.log('Y Label:', lineChart.y_label)
+     *     console.log('X Ticks:', lineChart.x_ticks)
+     *     console.log('Y Ticks:', lineChart.y_ticks)
+     *     console.log('X Tick Labels:', lineChart.x_tick_labels)
+     *     console.log('Y Tick Labels:', lineChart.y_tick_labels)
+     *     console.log('X Scale:', lineChart.x_scale)
+     *     console.log('Y Scale:', lineChart.y_scale)
+     *     console.log('Elements:')
+     *     console.dir(lineChart.elements, { depth: null })
+     *   }
+     * }
      */
     async codeRun(code, params, timeout) {
         const runCommand = this.codeToolbox.getRunCommand(code, params);
-        const response = await this.executeCommand(runCommand, undefined, timeout);
-        return response;
+        return this.executeCommand(runCommand, undefined, timeout);
     }
     /**
      * Creates a new long-running background session in the Sandbox.

package/dist/Sandbox.d.ts

@@ -1,43 +1,3 @@
-/**
- * The Daytona SDK core Sandbox functionality.
- *
- * Provides the main Sandbox class representing a Daytona Sandbox that coordinates file system,
- * Git, process execution, and LSP functionality. It serves as the central point
- * for interacting with Daytona Sandboxes.
- *
- * The Sandbox must be in a 'started' state before performing operations.
- *
- * @module Sandbox
- *
- * @example
- * // Create and initialize sandbox
- * const daytona = new Daytona();
- * const sandbox = await daytona.create();
- *
- * // File operations
- * await sandbox.fs.uploadFile(
- *   '/app/config.json',
- *   new File(['{"setting": "value"}'], 'config.json')
- * );
- * const contentBlob = await sandbox.fs.downloadFile('/app/config.json');
- *
- * // Git operations
- * await sandbox.git.clone('https://github.com/user/repo.git');
- *
- * // Process execution
- * const response = await sandbox.process.executeCommand('ls -la');
- * console.log(response.result);
- *
- * // LSP functionality
- * const lsp = sandbox.createLspServer('typescript', '/workspace/project');
- * await lsp.didOpen('/workspace/project/src/index.ts');
- * const completions = await lsp.completions('/workspace/project/src/index.ts', {
- *   line: 10,
- *   character: 15
- * });
- * console.log(completions);
- *
- */
 import { ToolboxApi, WorkspaceState as SandboxState, WorkspaceApi as SandboxApi, Workspace as ApiSandbox, WorkspaceInfo as ApiSandboxInfo, CreateNodeClassEnum as SandboxClass, CreateNodeRegionEnum as SandboxTargetRegion, Workspace as ApiWorkspace } from '@daytonaio/api-client';
 import { FileSystem } from './FileSystem';
 import { Git } from './Git';
@@ -51,7 +11,7 @@ export interface SandboxInstance extends Omit<ApiSandbox, 'info'> {
 /**
  * Resources allocated to a Sandbox
  *
- * @interface SandboxResources
+ * @interface
  * @property {string} cpu - Number of CPU cores allocated (e.g., "1", "2")
  * @property {string | null} gpu - Number of GPUs allocated (e.g., "1") or null if no GPU
  * @property {string} memory - Amount of memory allocated with unit (e.g., "2Gi", "4Gi")
@@ -81,7 +41,7 @@ export interface SandboxResources {
  * This interface provides detailed information about a Sandbox's configuration,
  * resources, and current state.
  *
- * @interface SandboxInfo
+ * @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
@@ -148,7 +108,7 @@ export interface SandboxInfo extends ApiSandboxInfo {
 }
 /**
  * Interface defining methods that a code toolbox must implement
- * @interface SandboxCodeToolbox
+ * @interface
  */
 export interface SandboxCodeToolbox {
     /** Generates a command to run the provided code */
@@ -157,10 +117,6 @@ export interface SandboxCodeToolbox {
 /**
  * Represents a Daytona Sandbox.
  *
- * A Sandbox provides file system operations, Git operations, process execution,
- * and LSP functionality. It serves as the main interface for interacting with
- * a Daytona sandbox.
- *
  * @property {string} id - Unique identifier for the Sandbox
  * @property {SandboxInstance} instance - The underlying Sandbox instance
  * @property {SandboxApi} sandboxApi - API client for Sandbox operations
@@ -169,6 +125,8 @@ export interface SandboxCodeToolbox {
  * @property {FileSystem} fs - File system operations interface
  * @property {Git} git - Git operations interface
  * @property {Process} process - Process execution interface
+ *
+ * @class
  */
 export declare class Sandbox {
     readonly id: string;

package/dist/Sandbox.js

@@ -1,44 +1,4 @@
 "use strict";
-/**
- * The Daytona SDK core Sandbox functionality.
- *
- * Provides the main Sandbox class representing a Daytona Sandbox that coordinates file system,
- * Git, process execution, and LSP functionality. It serves as the central point
- * for interacting with Daytona Sandboxes.
- *
- * The Sandbox must be in a 'started' state before performing operations.
- *
- * @module Sandbox
- *
- * @example
- * // Create and initialize sandbox
- * const daytona = new Daytona();
- * const sandbox = await daytona.create();
- *
- * // File operations
- * await sandbox.fs.uploadFile(
- *   '/app/config.json',
- *   new File(['{"setting": "value"}'], 'config.json')
- * );
- * const contentBlob = await sandbox.fs.downloadFile('/app/config.json');
- *
- * // Git operations
- * await sandbox.git.clone('https://github.com/user/repo.git');
- *
- * // Process execution
- * const response = await sandbox.process.executeCommand('ls -la');
- * console.log(response.result);
- *
- * // LSP functionality
- * const lsp = sandbox.createLspServer('typescript', '/workspace/project');
- * await lsp.didOpen('/workspace/project/src/index.ts');
- * const completions = await lsp.completions('/workspace/project/src/index.ts', {
- *   line: 10,
- *   character: 15
- * });
- * console.log(completions);
- *
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sandbox = void 0;
 const FileSystem_1 = require("./FileSystem");
@@ -49,10 +9,6 @@ const DaytonaError_1 = require("./errors/DaytonaError");
 /**
  * Represents a Daytona Sandbox.
  *
- * A Sandbox provides file system operations, Git operations, process execution,
- * and LSP functionality. It serves as the main interface for interacting with
- * a Daytona sandbox.
- *
  * @property {string} id - Unique identifier for the Sandbox
  * @property {SandboxInstance} instance - The underlying Sandbox instance
  * @property {SandboxApi} sandboxApi - API client for Sandbox operations
@@ -61,6 +17,8 @@ const DaytonaError_1 = require("./errors/DaytonaError");
  * @property {FileSystem} fs - File system operations interface
  * @property {Git} git - Git operations interface
  * @property {Process} process - Process execution interface
+ *
+ * @class
  */
 class Sandbox {
     /**

package/dist/code-toolbox/SandboxPythonCodeToolbox.d.ts

@@ -3,4 +3,10 @@ import { CodeRunParams } from '../Process';
 export declare class SandboxPythonCodeToolbox implements SandboxCodeToolbox {
     getDefaultImage(): string;
     getRunCommand(code: string, params?: CodeRunParams): string;
+    /**
+     * Checks if matplotlib is imported in the given Python code string.
+     * @param codeString Python code as a string
+     * @returns True if matplotlib is imported, false otherwise
+     */
+    private static isMatplotlibImported;
 }