@daytonaio/sdk 0.10.0 → 0.10.2

package/README.md

@@ -2,33 +2,6 @@
 
 A TypeScript SDK for interacting with Daytona Server API, providing a simple interface for Daytona Workspace management, Git operations, file system operations, and language server protocol support.
 
-## Prerequisites
-
-Before using the Daytona SDK, you need to have a running Daytona server instance and proper configuration.
-
-### Server Installation
-
-For detailed instructions on installing and setting up the Daytona server, please refer to the official installation guide at:
-[https://github.com/daytonaio/daytona](https://github.com/daytonaio/daytona)
-
-### Configuration
-
-To use the SDK, you'll need two essential pieces of information:
-
-1. **Server Address**:
-
-   - Run `daytona server config` to get your server's configuration
-   - Look for the `API URL` value in the output
-   - For testing and development, you can use the FRP address provided
-   - For production environments, it's recommended to use a static address
-
-2. **API Key**:
-   - Generate a new API key by running:
-     ```bash
-     daytona api-key generate
-     ```
-   - Save this key securely as it will be needed to authenticate with the server
-
 ## Installation
 
 You can install the package using npm:
@@ -50,41 +23,33 @@ Here's a simple example of using the SDK:
 ```typescript
 import { Daytona } from '@daytonaio/sdk'
 
-// Initialize the Daytona client
+// Initialize using environment variables
 const daytona = new Daytona()
 
-// Create the workspace instance
-const workspace = await daytona.create({
-  language: 'typescript',
-})
+// Create a workspace
+const workspace = await daytona.create()
 
-// Run the code securely inside the workspace
-const response = await workspace.process.code_run('console.log("Hello World!")')
+// Run code in the workspace
+const response = await workspace.process.codeRun('console.log("Hello World!")')
 console.log(response.result)
-```
-
-## Features
 
-- **Workspace Management**: Create, manage and remove workspaces
-- **Git Operations**: Clone repositories, manage branches, and more
-- **File System Operations**: Upload, download, search and manipulate files
-- **Language Server Protocol**: Interact with language servers for code intelligence
-- **Process Management**: Execute code and commands in workspaces
+// Clean up when done
+await daytona.remove(workspace)
+```
 
 ## Configuration
 
 The SDK can be configured using environment variables or by passing a configuration object:
 
 ```typescript
-import { Daytona, DaytonaConfig } from '@daytonaio/sdk'
+import { Daytona } from '@daytonaio/sdk'
 
-const config: DaytonaConfig = {
+// Initialize with configuration
+const daytona = new Daytona({
   apiKey: 'your-api-key',
-  serverUrl: 'https://your-daytona-server',
-  target: 'your-target',
-}
-
-const daytona = new Daytona(config)
+  serverUrl: 'your-server-url',
+  target: 'us',
+})
 ```
 
 Or using environment variables:
@@ -93,26 +58,54 @@ Or using environment variables:
 - `DAYTONA_SERVER_URL`: The Daytona server URL
 - `DAYTONA_TARGET`: Your target environment
 
+You can also customize workspace creation:
+
+```typescript
+const workspace = await daytona.create({
+  language: 'typescript',
+  envVars: { NODE_ENV: 'development' },
+  autoStopInterval: 60, // Auto-stop after 1 hour of inactivity
+})
+```
+
+## Features
+
+- **Workspace Management**: Create, manage and remove workspaces
+- **Git Operations**: Clone repositories, manage branches, and more
+- **File System Operations**: Upload, download, search and manipulate files
+- **Language Server Protocol**: Interact with language servers for code intelligence
+- **Process Management**: Execute code and commands in workspaces
+
 ## Examples
 
-### Execute command
+### Execute Commands
 
 ```typescript
-const response = await workspace.process.code_run(
-  'print("Sum of 3 and 4 is " + str(3 + 4))',
-)
-if (response.code !== 0) {
-  console.log(`Error: ${response.code} ${response.result}`)
-} else {
-  console.log(response.result)
-}
+// Execute a shell command
+const response = await workspace.process.executeCommand('echo "Hello, World!"')
+console.log(response.result)
+
+// Run TypeScript code
+const response = await workspace.process.codeRun(`
+const x = 10
+const y = 20
+console.log(\`Sum: \${x + y}\`)
+`)
+console.log(response.result)
 ```
 
 ### File Operations
 
 ```typescript
 // Upload a file
-await workspace.fs.uploadFile('/path/to/file.txt', new Blob(['Hello, World!']))
+await workspace.fs.uploadFile(
+  '/path/to/file.txt',
+  new File(
+    [Buffer.from('Hello, World!')],
+    'file.txt',
+    { type: 'text/plain' }
+  )
+)
 
 // Download a file
 const content = await workspace.fs.downloadFile('/path/to/file.txt')

package/dist/Daytona.d.ts

@@ -229,7 +229,7 @@ export declare class Daytona {
      * };
      * const workspace = await daytona.create(params, 40);
      */
-    create(params: CreateWorkspaceParams, timeout?: number): Promise<Workspace>;
+    create(params?: CreateWorkspaceParams, timeout?: number): Promise<Workspace>;
     /**
      * Gets a Sandbox by its ID.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daytonaio/sdk",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Daytona client library for AI Agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/utils/Axios.d.ts

@@ -1,6 +0,0 @@
-import { AxiosInstance } from 'axios';
-export declare class Axios {
-    private static instance;
-    private constructor();
-    static getInstance(): AxiosInstance;
-}

package/dist/utils/Axios.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Axios = void 0;
-const axios_1 = __importDefault(require("axios"));
-class Axios {
-    constructor() { }
-    static getInstance() {
-        if (!Axios.instance) {
-            Axios.instance = axios_1.default.create();
-            Axios.instance.interceptors.response.use((response) => {
-                return response;
-            }, (error) => {
-                var _a, _b, _c;
-                const errorMessage = ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) ||
-                    ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data) ||
-                    error.message ||
-                    String(error);
-                throw new Error(errorMessage);
-                // return Promise.reject(errorMessage);
-            });
-        }
-        return Axios.instance;
-    }
-}
-exports.Axios = Axios;

package/dist/utils/errors.d.ts

@@ -1,10 +0,0 @@
-/**
- * Helper method to parse API errors and extract meaningful messages.
- * Checks if error is an AxiosError and has response data with a message field.
- * If it does, it will return the message from the response.
- * If it doesn't, it will return the original error message.
- *
- * @param error - The error to parse
- * @returns A formatted error message string
- */
-export declare function parseApiError(error: unknown): string;

package/dist/utils/errors.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseApiError = parseApiError;
-const axios_1 = require("axios");
-/**
- * Helper method to parse API errors and extract meaningful messages.
- * Checks if error is an AxiosError and has response data with a message field.
- * If it does, it will return the message from the response.
- * If it doesn't, it will return the original error message.
- *
- * @param error - The error to parse
- * @returns A formatted error message string
- */
-function parseApiError(error) {
-    var _a;
-    try {
-        // Handle Axios errors
-        if (error instanceof axios_1.AxiosError) {
-            // Check if we have response data
-            if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) {
-                const errorData = error.response.data;
-                // If errorData is an object with a message field
-                if (typeof errorData === 'object' && errorData !== null) {
-                    if ('message' in errorData && typeof errorData.message === 'string') {
-                        return errorData.message;
-                    }
-                    // If no message field, we can stringify the error data
-                    return JSON.stringify(errorData);
-                }
-            }
-            return error.message;
-        }
-    }
-    catch (_b) { }
-    return String(error);
-}

package/dist/utils/timeout.d.ts

@@ -1,35 +0,0 @@
-/**
- * Custom error class for timeout-related exceptions
- * @extends Error
- */
-declare class TimeoutError extends Error {
-    constructor(message?: string);
-    /**
-     * Checks if an error is a TimeoutError
-     * @param error - The error to check
-     */
-    static isTimeoutError(error: unknown): error is TimeoutError;
-}
-/**
- * Configuration options for timeout behavior
- */
-interface TimeoutOptions {
-    /** Timeout duration in seconds */
-    timeout: number;
-    /** Whether the operation supports abortion */
-    abortable?: boolean;
-    /** Optional callback to execute on timeout */
-    onTimeout?: () => void;
-    /** Optional custom error message for TimeoutError */
-    errorMessage?: string;
-}
-/**
- * Wraps a promise with a timeout mechanism
- * @template T - The type of the promise result
- * @param promise - The promise to wrap
- * @param options - Timeout configuration options
- * @returns A promise that will reject if the timeout is exceeded
- * @throws {TimeoutError} When the operation times out
- */
-declare function withTimeout<T>(promise: Promise<T>, options: TimeoutOptions): Promise<T>;
-export { withTimeout, TimeoutError };

package/dist/utils/timeout.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeoutError = void 0;
-exports.withTimeout = withTimeout;
-/**
- * Custom error class for timeout-related exceptions
- * @extends Error
- */
-class TimeoutError extends Error {
-    constructor(message = "Operation timed out") {
-        super(message);
-        this.name = "TimeoutError";
-        this.message = message;
-        Object.setPrototypeOf(this, TimeoutError.prototype);
-    }
-    /**
-     * Checks if an error is a TimeoutError
-     * @param error - The error to check
-     */
-    static isTimeoutError(error) {
-        return error instanceof TimeoutError;
-    }
-}
-exports.TimeoutError = TimeoutError;
-/**
- * Wraps a promise with a timeout mechanism
- * @template T - The type of the promise result
- * @param promise - The promise to wrap
- * @param options - Timeout configuration options
- * @returns A promise that will reject if the timeout is exceeded
- * @throws {TimeoutError} When the operation times out
- */
-async function withTimeout(promise, options) {
-    const { timeout, abortable = false, onTimeout, errorMessage } = options;
-    if (timeout == null || timeout === 0) {
-        return promise;
-    }
-    if (timeout <= 0) {
-        throw new Error("Timeout must be a non-negative number");
-    }
-    const defaultErrorMessage = `Operation exceeded timeout of ${timeout} seconds.`;
-    if (abortable) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => {
-            console.log("timeout triggered, aborting operation...");
-            controller.abort();
-            onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout();
-        }, timeout * 1000);
-        try {
-            const result = await promise;
-            clearTimeout(timeoutId);
-            return result;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof DOMException && error.name === "AbortError") {
-                console.log("abort error caught");
-                throw new TimeoutError(errorMessage || defaultErrorMessage);
-            }
-            throw error;
-        }
-    }
-    else {
-        return Promise.race([
-            promise,
-            new Promise((_, reject) => setTimeout(() => {
-                console.log("timeout error thrown (no abort)");
-                onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout();
-                reject(new TimeoutError(errorMessage || defaultErrorMessage));
-            }, timeout * 1000)),
-        ]);
-    }
-}