@daytonaio/sdk 0.0.0-dev

package/src/ObjectStorage.js

@@ -0,0 +1,231 @@
+"use strict";
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectStorage = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const lib_storage_1 = require("@aws-sdk/lib-storage");
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const tar = __importStar(require("tar"));
+const stream_1 = require("stream");
+const DaytonaError_1 = require("./errors/DaytonaError");
+/**
+ * ObjectStorage class for interacting with object storage services.
+ *
+ * @class
+ * @param {ObjectStorageConfig} config - The configuration for the object storage service.
+ */
+class ObjectStorage {
+    bucketName;
+    s3Client;
+    constructor(config) {
+        this.bucketName = config.bucketName || 'daytona-volume-builds';
+        this.s3Client = new client_s3_1.S3Client({
+            region: this.extractAwsRegion(config.endpointUrl) || 'us-east-1',
+            endpoint: config.endpointUrl,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+                sessionToken: config.sessionToken,
+            },
+            forcePathStyle: true,
+        });
+    }
+    /**
+     * Upload a file or directory to object storage.
+     *
+     * @param {string} path - The path to the file or directory to upload.
+     * @param {string} organizationId - The organization ID to use for the upload.
+     * @param {string} [archiveBasePath] - The base path to use for the archive.
+     * @returns {Promise<string>} The hash of the uploaded file or directory.
+     */
+    async upload(path, organizationId, archiveBasePath) {
+        if (!fs.existsSync(path)) {
+            const errMsg = `Path does not exist: ${path}`;
+            throw new DaytonaError_1.DaytonaError(errMsg);
+        }
+        // Compute hash for the path
+        const pathHash = await this.computeHashForPathMd5(path, archiveBasePath);
+        // Define the S3 prefix
+        const prefix = `${organizationId}/${pathHash}/`;
+        const s3Key = `${prefix}context.tar`;
+        // Check if it already exists in S3
+        if (await this.folderExistsInS3(prefix)) {
+            return pathHash;
+        }
+        // Upload to S3
+        await this.uploadAsTar(s3Key, path, archiveBasePath);
+        return pathHash;
+    }
+    /**
+     * Compute a hash for a file or directory.
+     *
+     * @param {string} pathStr - The path to the file or directory to hash.
+     * @param {string} [archiveBasePath] - The base path to use for the archive.
+     * @returns {Promise<string>} The hash of the file or directory.
+     */
+    async computeHashForPathMd5(pathStr, archiveBasePath) {
+        const md5Hasher = crypto.createHash('md5');
+        const absPathStr = path.resolve(pathStr);
+        if (!archiveBasePath) {
+            archiveBasePath = ObjectStorage.computeArchiveBasePath(pathStr);
+        }
+        md5Hasher.update(archiveBasePath);
+        if (fs.statSync(absPathStr).isFile()) {
+            // For files, hash the content
+            await this.hashFile(absPathStr, md5Hasher);
+        }
+        else {
+            // For directories, recursively hash all files and their paths
+            await this.hashDirectory(absPathStr, pathStr, md5Hasher);
+        }
+        return md5Hasher.digest('hex');
+    }
+    /**
+     * Recursively hash a directory and its contents.
+     *
+     * @param {string} dirPath - The path to the directory to hash.
+     * @param {string} basePath - The base path to use for the hash.
+     * @param {crypto.Hash} hasher - The hasher to use for the hash.
+     * @returns {Promise<void>} A promise that resolves when the directory has been hashed.
+     */
+    async hashDirectory(dirPath, basePath, hasher) {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        const hasSubdirs = entries.some((e) => e.isDirectory());
+        const hasFiles = entries.some((e) => e.isFile());
+        if (!hasSubdirs && !hasFiles) {
+            // Empty directory
+            const relDir = path.relative(basePath, dirPath);
+            hasher.update(relDir);
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                await this.hashDirectory(fullPath, basePath, hasher);
+            }
+            else if (entry.isFile()) {
+                const relPath = path.relative(basePath, fullPath);
+                hasher.update(relPath);
+                await this.hashFile(fullPath, hasher);
+            }
+        }
+    }
+    /**
+     * Hash a file.
+     *
+     * @param {string} filePath - The path to the file to hash.
+     * @param {crypto.Hash} hasher - The hasher to use for the hash.
+     * @returns {Promise<void>} A promise that resolves when the file has been hashed.
+     */
+    async hashFile(filePath, hasher) {
+        await new Promise((resolve, reject) => {
+            const stream = fs.createReadStream(filePath, { highWaterMark: 8192 });
+            stream.on('data', (chunk) => hasher.update(chunk));
+            stream.on('end', resolve);
+            stream.on('error', reject);
+        });
+    }
+    /**
+     * Check if a prefix (folder) exists in S3.
+     *
+     * @param {string} prefix - The prefix to check.
+     * @returns {Promise<boolean>} True if the prefix exists, false otherwise.
+     */
+    async folderExistsInS3(prefix) {
+        const response = await this.s3Client.send(new client_s3_1.ListObjectsV2Command({
+            Bucket: this.bucketName,
+            Prefix: prefix,
+            MaxKeys: 1,
+        }));
+        return !!response.Contents && response.Contents.length > 0;
+    }
+    /**
+     * Create a tar archive of the specified path and upload it to S3.
+     *
+     * @param {string} s3Key - The key to use for the uploaded file.
+     * @param {string} sourcePath - The path to the file or directory to upload.
+     * @param {string} [archiveBasePath] - The base path to use for the archive.
+     */
+    async uploadAsTar(s3Key, sourcePath, archiveBasePath) {
+        sourcePath = path.resolve(sourcePath);
+        archiveBasePath ??= ObjectStorage.computeArchiveBasePath(sourcePath);
+        const tarStream = tar.create({
+            cwd: path.dirname(sourcePath),
+            portable: true,
+            gzip: false,
+            prefix: archiveBasePath,
+        }, [sourcePath]);
+        const pass = new stream_1.PassThrough();
+        tarStream.pipe(pass);
+        const uploader = new lib_storage_1.Upload({
+            client: this.s3Client,
+            params: {
+                Bucket: this.bucketName,
+                Key: s3Key,
+                Body: pass,
+            },
+        });
+        await uploader.done();
+    }
+    extractAwsRegion(endpoint) {
+        const match = endpoint.match(/s3[.-]([a-z0-9-]+)\.amazonaws\.com/);
+        return match?.[1];
+    }
+    /**
+     * Compute the base path for an archive. Returns normalized path without the root (drive letter or leading slash).
+     *
+     * @param {string} pathStr - The path to compute the base path for.
+     * @returns {string} The base path for the archive.
+     */
+    static computeArchiveBasePath(pathStr) {
+        // Normalize the path to remove redundant segments
+        pathStr = path.normalize(pathStr);
+        // On Windows, path.parse().root includes the drive letter (e.g., 'C:\\')
+        const parsedPath = path.parse(pathStr);
+        const root = parsedPath.root;
+        // Remove the root (drive letter or leading slash) from the path
+        let pathWithoutRoot = pathStr.slice(root.length);
+        // Remove any leading slashes or backslashes
+        pathWithoutRoot = pathWithoutRoot.replace(/^[/\\]+/, '');
+        return pathWithoutRoot;
+    }
+}
+exports.ObjectStorage = ObjectStorage;
+//# sourceMappingURL=ObjectStorage.js.map

package/src/ObjectStorage.js.map

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

package/src/Process.d.ts

@@ -0,0 +1,246 @@
+import { Command, Session, SessionExecuteRequest, SessionExecuteResponse, ToolboxApi } from '@daytonaio/api-client';
+import { SandboxCodeToolbox } from './Sandbox';
+import { ExecuteResponse } from './types/ExecuteResponse';
+/**
+ * Parameters for code execution.
+ */
+export declare class CodeRunParams {
+    /**
+     * Command line arguments
+     */
+    argv?: string[];
+    /**
+     * Environment variables
+     */
+    env?: Record<string, string>;
+}
+/**
+ * Handles process and code execution within a Sandbox.
+ *
+ * @class
+ */
+export declare class Process {
+    private readonly sandboxId;
+    private readonly codeToolbox;
+    private readonly toolboxApi;
+    private readonly getRootDir;
+    constructor(sandboxId: string, codeToolbox: SandboxCodeToolbox, toolboxApi: ToolboxApi, getRootDir: () => Promise<string>);
+    /**
+     * 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);
+     */
+    executeCommand(command: string, cwd?: string, env?: Record<string, string>, timeout?: number): Promise<ExecuteResponse>;
+    /**
+     * 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 })
+     *   }
+     * }
+     */
+    codeRun(code: string, params?: CodeRunParams, timeout?: number): Promise<ExecuteResponse>;
+    /**
+     * 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);
+     */
+    createSession(sessionId: string): Promise<void>;
+    /**
+     * 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}`);
+     * });
+     */
+    getSession(sessionId: string): Promise<Session>;
+    /**
+     * 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`);
+     * }
+     */
+    getSessionCommand(sessionId: string, commandId: string): Promise<Command>;
+    /**
+     * 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
+     */
+    executeSessionCommand(sessionId: string, req: SessionExecuteRequest, timeout?: number): Promise<SessionExecuteResponse>;
+    /**
+     * Get the logs for a command executed in a session.
+     *
+     * @param {string} sessionId - Unique identifier of the session
+     * @param {string} commandId - Unique identifier of the command
+     * @returns {Promise<string>} Command logs
+     *
+     * @example
+     * const logs = await process.getSessionCommandLogs('my-session', 'cmd-123');
+     * console.log('Command output:', logs);
+     */
+    getSessionCommandLogs(sessionId: string, commandId: string): Promise<string>;
+    /**
+     * Asynchronously retrieve and process the logs for a command executed in a session as they become available.
+     *
+     * @param {string} sessionId - Unique identifier of the session
+     * @param {string} commandId - Unique identifier of the command
+     * @param {function} onLogs - Callback function to handle each log chunk
+     * @returns {Promise<void>}
+     *
+     * @example
+     * const logs = await process.getSessionCommandLogs('my-session', 'cmd-123', (chunk) => {
+     *   console.log('Log chunk:', chunk);
+     * });
+     */
+    getSessionCommandLogs(sessionId: string, commandId: string, onLogs: (chunk: string) => void): Promise<void>;
+    /**
+     * 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})`);
+     *   });
+     * });
+     */
+    listSessions(): Promise<Session[]>;
+    /**
+     * 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');
+     */
+    deleteSession(sessionId: string): Promise<void>;
+}