@daytonaio/sdk 0.11.2 → 0.12.0

package/README.md

@@ -1,6 +1,6 @@
 # Daytona SDK for TypeScript
 
-A TypeScript SDK for interacting with Daytona Server API, providing a simple interface for Daytona Sandbox management, Git operations, file system operations, and language server protocol support.
+A TypeScript SDK for interacting with the Daytona API, providing a simple interface for Daytona Sandbox management, Git operations, file system operations, and language server protocol support.
 
 ## Installation
 
@@ -47,7 +47,7 @@ import { Daytona } from '@daytonaio/sdk'
 // Initialize with configuration
 const daytona = new Daytona({
   apiKey: 'your-api-key',
-  serverUrl: 'your-server-url',
+  apiUrl: 'your-api-url',
   target: 'us',
 })
 ```
@@ -55,7 +55,7 @@ const daytona = new Daytona({
 Or using environment variables:
 
 - `DAYTONA_API_KEY`: Your Daytona API key
-- `DAYTONA_SERVER_URL`: The Daytona server URL
+- `DAYTONA_API_URL`: The Daytona API URL
 - `DAYTONA_TARGET`: Your target environment
 
 You can also customize sandbox creation:

package/dist/Daytona.d.ts

@@ -1,72 +1,31 @@
-/**
- * Sandboxes are isolated development environments managed by Daytona.
- * This guide covers how to create, manage, and remove Sandboxes using the SDK.
- *
- * @module Daytona
- *
- * @example
- * // Initialize using environment variables (DAYTONA_API_KEY, DAYTONA_SERVER_URL, DAYTONA_TARGET)
- * const daytona = new Daytona();
- *
- * // Create and use a sandbox
- * const sandbox = await daytona.create({
- *     language: 'typescript',
- *     envVars: { NODE_ENV: 'development' }
- * });
- *
- * // Execute commands in the sandbox
- * const response = await sandbox.process.executeCommand('echo "Hello, World!"');
- * console.log(response.result);
- *
- * // Execute code in the sandbox
- * const response = await sandbox.process.codeRun('console.log("Hello, World!")');
- * console.log(response.result);
- *
- * @example
- * // Initialize with explicit configuration
- * const daytona = new Daytona({
- *     apiKey: process.env.CUSTOM_API_KEY,
- *     serverUrl: 'https://daytona.example.com',
- *     target: 'us'
- * });
- *
- * // Create a custom sandbox
- * const sandbox = await daytona.create({
- *     language: 'typescript',
- *     image: 'node:18',
- *     resources: {
- *         cpu: 2,
- *         memory: 4 // 4GB RAM
- *     },
- *     autoStopInterval: 60 // Auto-stop after 1 hour of inactivity
- * });
- *
- * // Use sandbox features
- * await sandbox.git.clone('https://github.com/user/repo.git');
- * await sandbox.process.executeCommand('npm test');
- */
 import { Sandbox, Sandbox as Workspace } from './Sandbox';
 import { CreateWorkspaceTargetEnum as SandboxTargetRegion } from '@daytonaio/api-client';
 /**
  * Configuration options for initializing the Daytona client.
  *
  * @interface
- * @property {string} apiKey - API key for authentication with Daytona server
- * @property {string} serverUrl - URL of the Daytona server
+ * @property {string} apiKey - API key for authentication with the Daytona API
+ * @property {string} apiUrl - URL of the Daytona API. Defaults to 'https://app.daytona.io/api'
+ * if not set here and not set in environment variable DAYTONA_API_URL.
  * @property {CreateSandboxTargetEnum} target - Target location for Sandboxes
  *
  * @example
  * const config: DaytonaConfig = {
  *     apiKey: "your-api-key",
- *     serverUrl: "https://your-server.com",
+ *     apiUrl: "https://your-api.com",
  *     target: "us"
  * };
  * const daytona = new Daytona(config);
  */
 export interface DaytonaConfig {
-    /** API key for authentication with Daytona server */
+    /** API key for authentication with the Daytona API */
     apiKey?: string;
-    /** URL of the Daytona server */
+    /** URL of the Daytona API.
+     */
+    apiUrl?: string;
+    /**
+     * @deprecated Use `apiUrl` instead. This property will be removed in future versions.
+     */
     serverUrl?: string;
     /** Target environment for sandboxes */
     target?: SandboxTargetRegion;
@@ -112,11 +71,11 @@ export interface SandboxResources {
  * @property {string} [id] - Optional Sandbox ID. If not provided, a random ID will be generated
  * @property {string} [image] - Optional Docker image to use for the Sandbox
  * @property {string} [user] - Optional os user to use for the Sandbox
- * @property {CodeLanguage} [language] - Programming language for direct code execution
+ * @property {CodeLanguage | string} [language] - Programming language for direct code execution
  * @property {Record<string, string>} [envVars] - Optional environment variables to set in the Sandbox
  * @property {Record<string, string>} [labels] - Sandbox labels
  * @property {boolean} [public] - Is the Sandbox port preview public
- * @property {string} [target] - Target location for the Sandbox
+ * @property {SandboxTargetRegion | string} [target] - Target location for the Sandbox
  * @property {SandboxResources} [resources] - Resource allocation for the Sandbox
  * @property {boolean} [async] - If true, will not wait for the Sandbox to be ready before returning
  * @property {number} [timeout] - Timeout in seconds for the Sandbox to be ready (0 means no timeout)
@@ -164,7 +123,7 @@ export type CreateSandboxParams = {
     autoStopInterval?: number;
 };
 /**
- * Main class for interacting with Daytona Server API.
+ * Main class for interacting with the Daytona API.
  *
  * Provides methods for creating, managing, and interacting with Daytona Sandboxes.
  * Can be initialized either with explicit configuration or using environment variables.
@@ -172,7 +131,7 @@ export type CreateSandboxParams = {
  *
  * @example
  * // Using environment variables
- * // Uses DAYTONA_API_KEY, DAYTONA_SERVER_URL, DAYTONA_TARGET
+ * // Uses DAYTONA_API_KEY, DAYTONA_API_URL, DAYTONA_TARGET
  * const daytona = new Daytona();
  * const sandbox = await daytona.create();
  *
@@ -180,7 +139,7 @@ export type CreateSandboxParams = {
  * // Using explicit configuration
  * const config: DaytonaConfig = {
  *     apiKey: "your-api-key",
- *     serverUrl: "https://your-server.com",
+ *     apiUrl: "https://your-api.com",
  *     target: "us"
  * };
  * const daytona = new Daytona(config);
@@ -192,12 +151,12 @@ export declare class Daytona {
     private readonly toolboxApi;
     private readonly target;
     private readonly apiKey;
-    private readonly serverUrl;
+    private readonly apiUrl;
     /**
      * Creates a new Daytona client instance.
      *
      * @param {DaytonaConfig} [config] - Configuration options
-     * @throws {DaytonaError} - `DaytonaError` - When API key or server URL is missing
+     * @throws {DaytonaError} - `DaytonaError` - When API key is missing
      */
     constructor(config?: DaytonaConfig);
     /**

package/dist/Daytona.js

@@ -1,51 +1,4 @@
 "use strict";
-/**
- * Sandboxes are isolated development environments managed by Daytona.
- * This guide covers how to create, manage, and remove Sandboxes using the SDK.
- *
- * @module Daytona
- *
- * @example
- * // Initialize using environment variables (DAYTONA_API_KEY, DAYTONA_SERVER_URL, DAYTONA_TARGET)
- * const daytona = new Daytona();
- *
- * // Create and use a sandbox
- * const sandbox = await daytona.create({
- *     language: 'typescript',
- *     envVars: { NODE_ENV: 'development' }
- * });
- *
- * // Execute commands in the sandbox
- * const response = await sandbox.process.executeCommand('echo "Hello, World!"');
- * console.log(response.result);
- *
- * // Execute code in the sandbox
- * const response = await sandbox.process.codeRun('console.log("Hello, World!")');
- * console.log(response.result);
- *
- * @example
- * // Initialize with explicit configuration
- * const daytona = new Daytona({
- *     apiKey: process.env.CUSTOM_API_KEY,
- *     serverUrl: 'https://daytona.example.com',
- *     target: 'us'
- * });
- *
- * // Create a custom sandbox
- * const sandbox = await daytona.create({
- *     language: 'typescript',
- *     image: 'node:18',
- *     resources: {
- *         cpu: 2,
- *         memory: 4 // 4GB RAM
- *     },
- *     autoStopInterval: 60 // Auto-stop after 1 hour of inactivity
- * });
- *
- * // Use sandbox features
- * await sandbox.git.clone('https://github.com/user/repo.git');
- * await sandbox.process.executeCommand('npm test');
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -101,7 +54,7 @@ var CodeLanguage;
     CodeLanguage["JAVASCRIPT"] = "javascript";
 })(CodeLanguage || (exports.CodeLanguage = CodeLanguage = {}));
 /**
- * Main class for interacting with Daytona Server API.
+ * Main class for interacting with the Daytona API.
  *
  * Provides methods for creating, managing, and interacting with Daytona Sandboxes.
  * Can be initialized either with explicit configuration or using environment variables.
@@ -109,7 +62,7 @@ var CodeLanguage;
  *
  * @example
  * // Using environment variables
- * // Uses DAYTONA_API_KEY, DAYTONA_SERVER_URL, DAYTONA_TARGET
+ * // Uses DAYTONA_API_KEY, DAYTONA_API_URL, DAYTONA_TARGET
  * const daytona = new Daytona();
  * const sandbox = await daytona.create();
  *
@@ -117,7 +70,7 @@ var CodeLanguage;
  * // Using explicit configuration
  * const config: DaytonaConfig = {
  *     apiKey: "your-api-key",
- *     serverUrl: "https://your-server.com",
+ *     apiUrl: "https://your-api.com",
  *     target: "us"
  * };
  * const daytona = new Daytona(config);
@@ -129,7 +82,7 @@ class Daytona {
      * Creates a new Daytona client instance.
      *
      * @param {DaytonaConfig} [config] - Configuration options
-     * @throws {DaytonaError} - `DaytonaError` - When API key or server URL is missing
+     * @throws {DaytonaError} - `DaytonaError` - When API key is missing
      */
     constructor(config) {
         dotenv_1.default.config();
@@ -138,14 +91,21 @@ class Daytona {
         if (!apiKey) {
             throw new DaytonaError_1.DaytonaError('API key is required');
         }
-        const serverUrl = (config === null || config === void 0 ? void 0 : config.serverUrl) || process.env.DAYTONA_SERVER_URL || 'https://app.daytona.io/api';
+        const apiUrl = (config === null || config === void 0 ? void 0 : config.apiUrl) ||
+            (config === null || config === void 0 ? void 0 : config.serverUrl) ||
+            process.env.DAYTONA_API_URL ||
+            process.env.DAYTONA_SERVER_URL ||
+            'https://app.daytona.io/api';
         const envTarget = process.env.DAYTONA_TARGET;
         const target = (config === null || config === void 0 ? void 0 : config.target) || envTarget || api_client_1.CreateWorkspaceTargetEnum.US;
+        if (process.env.DAYTONA_SERVER_URL && !process.env.DAYTONA_API_URL) {
+            console.warn('[Deprecation Warning] Environment variable `DAYTONA_SERVER_URL` is deprecated and will be removed in future versions. Use `DAYTONA_API_URL` instead.');
+        }
         this.apiKey = apiKey;
-        this.serverUrl = serverUrl;
+        this.apiUrl = apiUrl;
         this.target = target;
         const configuration = new api_client_1.Configuration({
-            basePath: this.serverUrl,
+            basePath: this.apiUrl,
             baseOptions: {
                 headers: {
                     Authorization: `Bearer ${this.apiKey}`,

package/dist/FileSystem.d.ts

@@ -1,72 +1,9 @@
-/**
- * The Daytona SDK provides comprehensive file system operations through the `fs` module in Sandboxes.
- * You can perform various operations like listing files, creating directories, reading and writing files, and more.
- * This guide covers all available file system operations and best practices.
- *
- * @module FileSystem
- *
- * @example
- * // Basic file operations
- * // Create a sandbox
- * const sandbox = await daytona.create();
- *
- * // Create a directory
- * await sandbox.fs.createFolder('/workspace/data', '755');
- *
- * // Upload a file
- * const fileContent = new File(['content'], 'local_file.txt');
- * await sandbox.fs.uploadFile('/workspace/data/file.txt', fileContent);
- *
- * // List directory contents
- * const files = await sandbox.fs.listFiles('/workspace');
- * files.forEach(file => {
- *   console.log(`Name: ${file.name}`);
- *   console.log(`Is directory: ${file.isDir}`);
- *   console.log(`Size: ${file.size}`);
- *   console.log(`Modified: ${file.modTime}`);
- * });
- *
- * // Search file contents
- * const matches = await sandbox.fs.findFiles(
- *   '/workspace/src',
- *   'text-of-interest'
- * );
- * matches.forEach(match => {
- *   console.log(`Absolute file path: ${match.file}`);
- *   console.log(`Line number: ${match.line}`);
- *   console.log(`Line content: ${match.content}\n`);
- * });
- *
- * @example
- * // File manipulation
- * // Move files
- * await sandbox.fs.moveFiles(
- *   '/workspace/data/old.txt',
- *   '/workspace/data/new.txt'
- * );
- *
- * // Replace text in files
- * const results = await sandbox.fs.replaceInFiles(
- *   ['/workspace/data/new.txt'],
- *   'old_version',
- *   'new_version'
- * );
- *
- * // Set permissions
- * await sandbox.fs.setFilePermissions(
- *   '/workspace/data/script.sh',
- *   {
- *     mode: '755',
- *     owner: 'daytona'
- *   }
- * );
- */
 import { FileInfo, Match, ReplaceResult, SearchFilesResponse, ToolboxApi } from '@daytonaio/api-client';
 import { SandboxInstance } from './Sandbox';
 /**
  * Parameters for setting file permissions in the Sandbox.
  *
- * @interface FilePermissionsParams
+ * @interface
  * @property {string} [mode] - File mode/permissions in octal format (e.g. "644")
  * @property {string} [owner] - User owner of the file
  * @property {string} [group] - Group owner of the file
@@ -89,10 +26,7 @@ export type FilePermissionsParams = {
 /**
  * Provides file system operations within a Sandbox.
  *
- * This class implements a high-level interface to file system operations that can
- * be performed within a Daytona Sandbox. It supports common operations like
- * creating, deleting, and moving files, as well as searching file contents and
- * managing permissions.
+ * @class
  */
 export declare class FileSystem {
     private readonly instance;

package/dist/FileSystem.js

@@ -1,76 +1,10 @@
 "use strict";
-/**
- * The Daytona SDK provides comprehensive file system operations through the `fs` module in Sandboxes.
- * You can perform various operations like listing files, creating directories, reading and writing files, and more.
- * This guide covers all available file system operations and best practices.
- *
- * @module FileSystem
- *
- * @example
- * // Basic file operations
- * // Create a sandbox
- * const sandbox = await daytona.create();
- *
- * // Create a directory
- * await sandbox.fs.createFolder('/workspace/data', '755');
- *
- * // Upload a file
- * const fileContent = new File(['content'], 'local_file.txt');
- * await sandbox.fs.uploadFile('/workspace/data/file.txt', fileContent);
- *
- * // List directory contents
- * const files = await sandbox.fs.listFiles('/workspace');
- * files.forEach(file => {
- *   console.log(`Name: ${file.name}`);
- *   console.log(`Is directory: ${file.isDir}`);
- *   console.log(`Size: ${file.size}`);
- *   console.log(`Modified: ${file.modTime}`);
- * });
- *
- * // Search file contents
- * const matches = await sandbox.fs.findFiles(
- *   '/workspace/src',
- *   'text-of-interest'
- * );
- * matches.forEach(match => {
- *   console.log(`Absolute file path: ${match.file}`);
- *   console.log(`Line number: ${match.line}`);
- *   console.log(`Line content: ${match.content}\n`);
- * });
- *
- * @example
- * // File manipulation
- * // Move files
- * await sandbox.fs.moveFiles(
- *   '/workspace/data/old.txt',
- *   '/workspace/data/new.txt'
- * );
- *
- * // Replace text in files
- * const results = await sandbox.fs.replaceInFiles(
- *   ['/workspace/data/new.txt'],
- *   'old_version',
- *   'new_version'
- * );
- *
- * // Set permissions
- * await sandbox.fs.setFilePermissions(
- *   '/workspace/data/script.sh',
- *   {
- *     mode: '755',
- *     owner: 'daytona'
- *   }
- * );
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSystem = void 0;
 /**
  * Provides file system operations within a Sandbox.
  *
- * This class implements a high-level interface to file system operations that can
- * be performed within a Daytona Sandbox. It supports common operations like
- * creating, deleting, and moving files, as well as searching file contents and
- * managing permissions.
+ * @class
  */
 class FileSystem {
     constructor(instance, toolboxApi) {

package/dist/Git.d.ts

@@ -1,56 +1,26 @@
+import { ToolboxApi, ListBranchResponse, GitStatus } from '@daytonaio/api-client';
+import { Sandbox, SandboxInstance } from './Sandbox';
 /**
- * The Daytona SDK provides built-in Git support. This guide covers all available Git
- * operations and best practices. Daytona SDK provides an option to clone, check status,
- * and manage Git repositories in Sandboxes. You can interact with Git repositories using
- * the `git` module.
- *
- * @module Git
- *
- * @example
- * // Basic Git workflow
- * // Create and initialize sandbox
- * const sandbox = await daytona.create();
- *
- * // Clone a repository
- * await sandbox.git.clone(
- *   'https://github.com/user/repo.git',
- *   '/workspace/repo'
- * );
+ * Response from the git commit.
  *
- * // Make some changes
- * await sandbox.fs.uploadFile(
- *   '/workspace/repo/test.txt',
- *   new File([Buffer.from('Hello, World!')], 'test.txt')
- * );
- *
- * // Stage and commit changes
- * await sandbox.git.add('/workspace/repo', ['test.txt']);
- * await sandbox.git.commit(
- *   '/workspace/repo',
- *   'Add test file',
- *   'John Doe',
- *   'john@example.com'
- * );
- *
- * // Push changes (with authentication)
- * await sandbox.git.push(
- *   '/workspace/repo',
- *   'user',
- *   'token'
- * );
+ * @interface
+ * @property {string} sha - The SHA of the commit
+ */
+export interface GitCommitResponse {
+    sha: string;
+}
+/**
+ * Provides Git operations within a Sandbox.
  *
+ * @class
  */
-import { ToolboxApi, ListBranchResponse, GitStatus } from '@daytonaio/api-client';
-import { Sandbox, SandboxInstance } from './Sandbox';
 export declare class Git {
     private readonly sandbox;
     private readonly toolboxApi;
     private readonly instance;
     constructor(sandbox: Sandbox, toolboxApi: ToolboxApi, instance: SandboxInstance);
     /**
-     * Stages files for commit.
-     *
-     * This method stages the specified files for the next commit, similar to
+     * Stages the specified files for the next commit, similar to
      * running 'git add' on the command line.
      *
      * @param {string} path - Absolute path to the Git repository root
@@ -69,8 +39,6 @@ export declare class Git {
     /**
      * List branches in the repository.
      *
-     * This method returns information about all branches in the repository.
-     *
      * @param {string} path - Absolute path to the Git repository root
      * @returns {Promise<ListBranchResponse>} List of branches in the repository
      *
@@ -80,9 +48,7 @@ export declare class Git {
      */
     branches(path: string): Promise<ListBranchResponse>;
     /**
-     * Clones a Git repository.
-     *
-     * This method clones a Git repository into the specified path. It supports
+     * Clones a Git repository into the specified path. It supports
      * cloning specific branches or commits, and can authenticate with the remote
      * repository if credentials are provided.
      *
@@ -123,9 +89,6 @@ export declare class Git {
     /**
      * Commits staged changes.
      *
-     * This method creates a new commit with the staged changes. Make sure to stage
-     * changes using the add() method before committing.
-     *
      * @param {string} path - Absolute path to the Git repository root
      * @param {string} message - Commit message describing the changes
      * @param {string} author - Name of the commit author
@@ -142,13 +105,10 @@ export declare class Git {
      *   'john@example.com'
      * );
      */
-    commit(path: string, message: string, author: string, email: string): Promise<void>;
+    commit(path: string, message: string, author: string, email: string): Promise<GitCommitResponse>;
     /**
      * Push local changes to the remote repository.
      *
-     * This method pushes committed changes to the remote repository. If the remote
-     * requires authentication, username and password/token must be provided.
-     *
      * @param {string} path - Absolute path to the Git repository root
      * @param {string} [username] - Git username for authentication
      * @param {string} [password] - Git password or token for authentication
@@ -170,9 +130,6 @@ export declare class Git {
     /**
      * Pulls changes from the remote repository.
      *
-     * This method fetches and merges changes from the remote repository. If the remote
-     * requires authentication, username and password/token must be provided.
-     *
      * @param {string} path - Absolute path to the Git repository root
      * @param {string} [username] - Git username for authentication
      * @param {string} [password] - Git password or token for authentication
@@ -194,9 +151,6 @@ export declare class Git {
     /**
      * Gets the current status of the Git repository.
      *
-     * This method returns information about the current state of the repository,
-     * including staged and unstaged changes, current branch, and untracked files.
-     *
      * @param {string} path - Absolute path to the Git repository root
      * @returns {Promise<GitStatus>} Current repository status including:
      *                               - currentBranch: Name of the current branch