@daytonaio/sdk 0.0.0-dev

package/src/Process.js

@@ -0,0 +1,290 @@
+"use strict";
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Process = exports.CodeRunParams = void 0;
+const ArtifactParser_1 = require("./utils/ArtifactParser");
+const Stream_1 = require("./utils/Stream");
+/**
+ * Parameters for code execution.
+ */
+class CodeRunParams {
+    /**
+     * Command line arguments
+     */
+    argv;
+    /**
+     * Environment variables
+     */
+    env;
+}
+exports.CodeRunParams = CodeRunParams;
+/**
+ * Handles process and code execution within a Sandbox.
+ *
+ * @class
+ */
+class Process {
+    sandboxId;
+    codeToolbox;
+    toolboxApi;
+    getRootDir;
+    constructor(sandboxId, codeToolbox, toolboxApi, getRootDir) {
+        this.sandboxId = sandboxId;
+        this.codeToolbox = codeToolbox;
+        this.toolboxApi = toolboxApi;
+        this.getRootDir = getRootDir;
+    }
+    /**
+     * Executes a shell command in the Sandbox.
+     *
+     * @param {string} command - Shell command to execute
+     * @param {string} [cwd] - Working directory for command execution. If not specified, uses the Sandbox root directory.
+     * Default is the user's root directory.
+     * @param {Record<string, string>} [env] - Environment variables to set for the command
+     * @param {number} [timeout] - Maximum time in seconds to wait for the command to complete. 0 means wait indefinitely.
+     * @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.artifacts.stdout);  // Prints: Hello
+     *
+     * @example
+     * // Command with working directory
+     * const result = await process.executeCommand('ls', 'workspace/src');
+     *
+     * @example
+     * // Command with timeout
+     * const result = await process.executeCommand('sleep 10', undefined, 5);
+     */
+    async executeCommand(command, cwd, env, timeout) {
+        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.sandboxId, {
+            command,
+            timeout,
+            cwd: cwd ?? (await this.getRootDir()),
+        });
+        // 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
+     * const response = await process.codeRun(`
+     *   const x = 10;
+     *   const y = 20;
+     *   console.log(\`Sum: \${x + y}\`);
+     * `);
+     * 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);
+        return this.executeCommand(runCommand, undefined, params?.env, timeout);
+    }
+    /**
+     * Creates a new long-running background session in the Sandbox.
+     *
+     * Sessions are background processes that maintain state between commands, making them ideal for
+     * scenarios requiring multiple related commands or persistent environment setup. You can run
+     * long-running commands and monitor process status.
+     *
+     * @param {string} sessionId - Unique identifier for the new session
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Create a new session
+     * const sessionId = 'my-session';
+     * await process.createSession(sessionId);
+     * const session = await process.getSession(sessionId);
+     * // Do work...
+     * await process.deleteSession(sessionId);
+     */
+    async createSession(sessionId) {
+        await this.toolboxApi.createSession(this.sandboxId, {
+            sessionId,
+        });
+    }
+    /**
+     * Get a session in the sandbox.
+     *
+     * @param {string} sessionId - Unique identifier of the session to retrieve
+     * @returns {Promise<Session>} Session information including:
+     *                            - sessionId: The session's unique identifier
+     *                            - commands: List of commands executed in the session
+     *
+     * @example
+     * const session = await process.getSession('my-session');
+     * session.commands.forEach(cmd => {
+     *   console.log(`Command: ${cmd.command}`);
+     * });
+     */
+    async getSession(sessionId) {
+        const response = await this.toolboxApi.getSession(this.sandboxId, sessionId);
+        return response.data;
+    }
+    /**
+     * Gets information about a specific command executed in a session.
+     *
+     * @param {string} sessionId - Unique identifier of the session
+     * @param {string} commandId - Unique identifier of the command
+     * @returns {Promise<Command>} Command information including:
+     *                            - id: The command's unique identifier
+     *                            - command: The executed command string
+     *                            - exitCode: Command's exit status (if completed)
+     *
+     * @example
+     * const cmd = await process.getSessionCommand('my-session', 'cmd-123');
+     * if (cmd.exitCode === 0) {
+     *   console.log(`Command ${cmd.command} completed successfully`);
+     * }
+     */
+    async getSessionCommand(sessionId, commandId) {
+        const response = await this.toolboxApi.getSessionCommand(this.sandboxId, sessionId, commandId);
+        return response.data;
+    }
+    /**
+     * Executes a command in an existing session.
+     *
+     * @param {string} sessionId - Unique identifier of the session to use
+     * @param {SessionExecuteRequest} req - Command execution request containing:
+     *                                     - command: The command to execute
+     *                                     - 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
+     *                                           - output: Command output (if synchronous execution)
+     *                                           - exitCode: Command exit status (if synchronous execution)
+     *
+     * @example
+     * // Execute commands in sequence, maintaining state
+     * const sessionId = 'my-session';
+     *
+     * // Change directory
+     * await process.executeSessionCommand(sessionId, {
+     *   command: 'cd /home/daytona'
+     * });
+     *
+     * // Run command in new directory
+     * const result = await process.executeSessionCommand(sessionId, {
+     *   command: 'pwd'
+     * });
+     * console.log(result.output);  // Prints: /home/daytona
+     */
+    async executeSessionCommand(sessionId, req, timeout) {
+        const response = await this.toolboxApi.executeSessionCommand(this.sandboxId, sessionId, req, undefined, timeout ? { timeout: timeout * 1000 } : {});
+        return response.data;
+    }
+    async getSessionCommandLogs(sessionId, commandId, onLogs) {
+        if (!onLogs) {
+            const response = await this.toolboxApi.getSessionCommandLogs(this.sandboxId, sessionId, commandId);
+            return response.data;
+        }
+        await (0, Stream_1.processStreamingResponse)(() => this.toolboxApi.getSessionCommandLogs(this.sandboxId, sessionId, commandId, undefined, true, {
+            responseType: 'stream',
+        }), onLogs, () => this.getSessionCommand(sessionId, commandId).then((res) => res.exitCode !== null && res.exitCode !== undefined));
+    }
+    /**
+     * Lists all active sessions in the Sandbox.
+     *
+     * @returns {Promise<Session[]>} Array of active sessions
+     *
+     * @example
+     * const sessions = await process.listSessions();
+     * sessions.forEach(session => {
+     *   console.log(`Session ${session.sessionId}:`);
+     *   session.commands.forEach(cmd => {
+     *     console.log(`- ${cmd.command} (${cmd.exitCode})`);
+     *   });
+     * });
+     */
+    async listSessions() {
+        const response = await this.toolboxApi.listSessions(this.sandboxId);
+        return response.data;
+    }
+    /**
+     * Delete a session from the Sandbox.
+     *
+     * @param {string} sessionId - Unique identifier of the session to delete
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Clean up a completed session
+     * await process.deleteSession('my-session');
+     */
+    async deleteSession(sessionId) {
+        await this.toolboxApi.deleteSession(this.sandboxId, sessionId);
+    }
+}
+exports.Process = Process;
+//# sourceMappingURL=Process.js.map

package/src/Process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Process.js","sourceRoot":"","sources":["../../../../libs/sdk-typescript/src/Process.ts"],"names":[],"mappings":"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"}

package/src/Sandbox.d.ts

@@ -0,0 +1,266 @@
+import { ToolboxApi, SandboxState, SandboxApi, Sandbox as SandboxDto, PortPreviewUrl, SandboxVolume, BuildInfo, SandboxBackupStateEnum } from '@daytonaio/api-client';
+import { FileSystem } from './FileSystem';
+import { Git } from './Git';
+import { CodeRunParams, Process } from './Process';
+import { LspLanguageId, LspServer } from './LspServer';
+/**
+ * Interface defining methods that a code toolbox must implement
+ * @interface
+ */
+export interface SandboxCodeToolbox {
+    /** Generates a command to run the provided code */
+    getRunCommand(code: string, params?: CodeRunParams): string;
+}
+/**
+ * Represents a Daytona Sandbox.
+ *
+ * @property {FileSystem} fs - File system operations interface
+ * @property {Git} git - Git operations interface
+ * @property {Process} process - Process execution interface
+ * @property {string} id - Unique identifier for the Sandbox
+ * @property {string} organizationId - Organization ID of the Sandbox
+ * @property {string} [snapshot] - Daytona snapshot used to create the Sandbox
+ * @property {string} user - OS user running in the Sandbox
+ * @property {Record<string, string>} env - Environment variables set in the Sandbox
+ * @property {Record<string, string>} labels - Custom labels attached to the Sandbox
+ * @property {boolean} public - Whether the Sandbox is publicly accessible
+ * @property {string} target - Target location of the runner where the Sandbox runs
+ * @property {number} cpu - Number of CPUs allocated to the Sandbox
+ * @property {number} gpu - Number of GPUs allocated to the Sandbox
+ * @property {number} memory - Amount of memory allocated to the Sandbox in GiB
+ * @property {number} disk - Amount of disk space allocated to the Sandbox in GiB
+ * @property {SandboxState} state - Current state of the Sandbox (e.g., "started", "stopped")
+ * @property {string} [errorReason] - Error message if Sandbox is in error state
+ * @property {SandboxBackupStateEnum} [backupState] - Current state of Sandbox backup
+ * @property {string} [backupCreatedAt] - When the backup was created
+ * @property {number} [autoStopInterval] - Auto-stop interval in minutes
+ * @property {number} [autoArchiveInterval] - Auto-archive interval in minutes
+ * @property {string} [runnerDomain] - Domain name of the Sandbox runner
+ * @property {Array<SandboxVolume>} [volumes] - Volumes attached to the Sandbox
+ * @property {BuildInfo} [buildInfo] - Build information for the Sandbox if it was created from dynamic build
+ * @property {string} [createdAt] - When the Sandbox was created
+ * @property {string} [updatedAt] - When the Sandbox was last updated
+ *
+ * @class
+ */
+export declare class Sandbox implements SandboxDto {
+    private readonly sandboxApi;
+    private readonly toolboxApi;
+    private readonly codeToolbox;
+    readonly fs: FileSystem;
+    readonly git: Git;
+    readonly process: Process;
+    id: string;
+    organizationId: string;
+    snapshot?: string;
+    user: string;
+    env: Record<string, string>;
+    labels: Record<string, string>;
+    public: boolean;
+    target: string;
+    cpu: number;
+    gpu: number;
+    memory: number;
+    disk: number;
+    state?: SandboxState;
+    errorReason?: string;
+    backupState?: SandboxBackupStateEnum;
+    backupCreatedAt?: string;
+    autoStopInterval?: number;
+    autoArchiveInterval?: number;
+    runnerDomain?: string;
+    volumes?: Array<SandboxVolume>;
+    buildInfo?: BuildInfo;
+    createdAt?: string;
+    updatedAt?: string;
+    private rootDir;
+    /**
+     * Creates a new Sandbox instance
+     *
+     * @param {SandboxDto} sandboxDto - The API Sandbox instance
+     * @param {SandboxApi} sandboxApi - API client for Sandbox operations
+     * @param {ToolboxApi} toolboxApi - API client for toolbox operations
+     * @param {SandboxCodeToolbox} codeToolbox - Language-specific toolbox implementation
+     */
+    constructor(sandboxDto: SandboxDto, sandboxApi: SandboxApi, toolboxApi: ToolboxApi, codeToolbox: SandboxCodeToolbox);
+    /**
+     * Gets the root directory path for the logged in user inside the Sandbox.
+     *
+     * @returns {Promise<string | undefined>} The absolute path to the Sandbox root directory for the logged in user
+     *
+     * @example
+     * const rootDir = await sandbox.getUserRootDir();
+     * console.log(`Sandbox root: ${rootDir}`);
+     */
+    getUserRootDir(): Promise<string | undefined>;
+    /**
+     * Creates a new Language Server Protocol (LSP) server instance.
+     *
+     * The LSP server provides language-specific features like code completion,
+     * diagnostics, and more.
+     *
+     * @param {LspLanguageId} languageId - The language server type (e.g., "typescript")
+     * @param {string} pathToProject - Path to the project root directory. Relative paths are resolved based on the user's
+     * root directory.
+     * @returns {LspServer} A new LSP server instance configured for the specified language
+     *
+     * @example
+     * const lsp = await sandbox.createLspServer('typescript', 'workspace/project');
+     */
+    createLspServer(languageId: LspLanguageId | string, pathToProject: string): Promise<LspServer>;
+    /**
+     * Sets labels for the Sandbox.
+     *
+     * Labels are key-value pairs that can be used to organize and identify Sandboxes.
+     *
+     * @param {Record<string, string>} labels - Dictionary of key-value pairs representing Sandbox labels
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Set sandbox labels
+     * await sandbox.setLabels({
+     *   project: 'my-project',
+     *   environment: 'development',
+     *   team: 'backend'
+     * });
+     */
+    setLabels(labels: Record<string, string>): Promise<Record<string, string>>;
+    /**
+     * Start the Sandbox.
+     *
+     * This method starts the Sandbox and waits for it to be ready.
+     *
+     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+     *                            Defaults to 60-second timeout.
+     * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If Sandbox fails to start or times out
+     *
+     * @example
+     * const sandbox = await daytona.getCurrentSandbox('my-sandbox');
+     * await sandbox.start(40);  // Wait up to 40 seconds
+     * console.log('Sandbox started successfully');
+     */
+    start(timeout?: number): Promise<void>;
+    /**
+     * Stops the Sandbox.
+     *
+     * This method stops the Sandbox and waits for it to be fully stopped.
+     *
+     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+     *                            Defaults to 60-second timeout.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * const sandbox = await daytona.getCurrentSandbox('my-sandbox');
+     * await sandbox.stop();
+     * console.log('Sandbox stopped successfully');
+     */
+    stop(timeout?: number): Promise<void>;
+    /**
+     * Deletes the Sandbox.
+     * @returns {Promise<void>}
+     */
+    delete(timeout?: number): Promise<void>;
+    /**
+     * Waits for the Sandbox to reach the 'started' state.
+     *
+     * This method polls the Sandbox status until it reaches the 'started' state
+     * or encounters an error.
+     *
+     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+     *                               Defaults to 60 seconds.
+     * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If the sandbox ends up in an error state or fails to start within the timeout period.
+     */
+    waitUntilStarted(timeout?: number): Promise<void>;
+    /**
+     * Wait for Sandbox to reach 'stopped' state.
+     *
+     * This method polls the Sandbox status until it reaches the 'stopped' state
+     * or encounters an error.
+     *
+     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+     *                               Defaults to 60 seconds.
+     * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If the sandbox fails to stop within the timeout period.
+     */
+    waitUntilStopped(timeout?: number): Promise<void>;
+    /**
+     * Refreshes the Sandbox data from the API.
+     *
+     * @returns {Promise<void>}
+     *
+     * @example
+     * await sandbox.refreshData();
+     * console.log(`Sandbox ${sandbox.id}:`);
+     * console.log(`State: ${sandbox.state}`);
+     * console.log(`Resources: ${sandbox.cpu} CPU, ${sandbox.memory} GiB RAM`);
+     */
+    refreshData(): Promise<void>;
+    /**
+     * Set the auto-stop interval for the Sandbox.
+     *
+     * The Sandbox will automatically stop after being idle (no new events) for the specified interval.
+     * Events include any state changes or interactions with the Sandbox through the sdk.
+     * Interactions using Sandbox Previews are not included.
+     *
+     * @param {number} interval - Number of minutes of inactivity before auto-stopping.
+     *                           Set to 0 to disable auto-stop. Default is 15 minutes.
+     * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If interval is not a non-negative integer
+     *
+     * @example
+     * // Auto-stop after 1 hour
+     * await sandbox.setAutostopInterval(60);
+     * // Or disable auto-stop
+     * await sandbox.setAutostopInterval(0);
+     */
+    setAutostopInterval(interval: number): Promise<void>;
+    /**
+     * Set the auto-archive interval for the Sandbox.
+     *
+     * The Sandbox will automatically archive after being continuously stopped for the specified interval.
+     *
+     * @param {number} interval - Number of minutes after which a continuously stopped Sandbox will be auto-archived.
+     *                           Set to 0 for the maximum interval. Default is 7 days.
+     * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If interval is not a non-negative integer
+     *
+     * @example
+     * // Auto-archive after 1 hour
+     * await sandbox.setAutoArchiveInterval(60);
+     * // Or use the maximum interval
+     * await sandbox.setAutoArchiveInterval(0);
+     */
+    setAutoArchiveInterval(interval: number): Promise<void>;
+    /**
+     * Retrieves the preview link for the sandbox at the specified port. If the port is closed,
+     * it will be opened automatically. For private sandboxes, a token is included to grant access
+     * to the URL.
+     *
+     * @param {number} port - The port to open the preview link on.
+     * @returns {PortPreviewUrl} The response object for the preview link, which includes the `url`
+     * and the `token` (to access private sandboxes).
+     *
+     * @example
+     * const previewLink = await sandbox.getPreviewLink(3000);
+     * console.log(`Preview URL: ${previewLink.url}`);
+     * console.log(`Token: ${previewLink.token}`);
+     */
+    getPreviewLink(port: number): Promise<PortPreviewUrl>;
+    /**
+     * Archives the sandbox, making it inactive and preserving its state. When sandboxes are archived, the entire filesystem
+     * state is moved to cost-effective object storage, making it possible to keep sandboxes available for an extended period.
+     * The tradeoff between archived and stopped states is that starting an archived sandbox takes more time, depending on its size.
+     * Sandbox must be stopped before archiving.
+     */
+    archive(): Promise<void>;
+    private getRootDir;
+    /**
+     * Assigns the API sandbox data to the Sandbox object.
+     *
+     * @param {SandboxDto} sandboxDto - The API sandbox instance to assign data from
+     * @returns {void}
+     */
+    private processSandboxDto;
+}