@daytonaio/sdk 0.7.1

package/LICENCE

@@ -0,0 +1,43 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship

package/README.md

@@ -0,0 +1,181 @@
+# Daytona SDK for TypeScript
+
+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:
+
+```bash
+npm install @daytona/sdk
+```
+
+Or using yarn:
+
+```bash
+yarn add @daytona/sdk
+```
+
+## Quick Start
+
+Here's a simple example of using the SDK:
+
+```typescript
+import { Daytona } from '@daytona/sdk'
+
+// Initialize the Daytona client
+const daytona = new Daytona()
+
+// Create the workspace instance
+const workspace = await daytona.create({
+  language: 'typescript',
+})
+
+// Run the code securely inside the workspace
+const response = await workspace.process.code_run('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
+
+## Configuration
+
+The SDK can be configured using environment variables or by passing a configuration object:
+
+```typescript
+import { Daytona, DaytonaConfig } from '@daytona/sdk'
+
+const config: DaytonaConfig = {
+  apiKey: 'your-api-key',
+  serverUrl: 'https://your-daytona-server',
+  target: 'your-target',
+}
+
+const daytona = new Daytona(config)
+```
+
+Or using environment variables:
+
+- `DAYTONA_API_KEY`: Your Daytona API key
+- `DAYTONA_SERVER_URL`: The Daytona server URL
+- `DAYTONA_TARGET`: Your target environment
+
+## Examples
+
+### Execute command
+
+```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)
+}
+```
+
+### File Operations
+
+```typescript
+// Upload a file
+await workspace.fs.uploadFile('/path/to/file.txt', new Blob(['Hello, World!']))
+
+// Download a file
+const content = await workspace.fs.downloadFile('/path/to/file.txt')
+
+// Search for files
+const matches = await workspace.fs.findFiles(root_dir, 'search_pattern')
+```
+
+### Git Operations
+
+```typescript
+// Clone a repository
+await workspace.git.clone('https://github.com/example/repo', '/path/to/clone')
+
+// List branches
+const branches = await workspace.git.branches('/path/to/repo')
+
+// Add files
+await workspace.git.add('/path/to/repo', ['file1.txt', 'file2.txt'])
+```
+
+### Language Server Protocol
+
+```typescript
+// Create and start a language server
+const lsp = workspace.createLspServer('typescript', '/path/to/project')
+await lsp.start()
+
+// Notify the lsp for the file
+await lsp.didOpen('/path/to/file.ts')
+
+// Get document symbols
+const symbols = await lsp.documentSymbols('/path/to/file.ts')
+
+// Get completions
+const completions = await lsp.completions('/path/to/file.ts', {
+  line: 10,
+  character: 15,
+})
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the Apache License, Version 2.0 - see below for details:
+
+```
+Copyright 2024 Daytona
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+For the full license text, please see the [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0).

package/dist/Daytona.d.ts

@@ -0,0 +1,106 @@
+import { Workspace } from './Workspace';
+import { CreateWorkspaceTargetEnum } from '@daytonaio/api-client';
+/**
+ * Configuration options for initializing the Daytona client
+ * @interface DaytonaConfig
+ */
+export interface DaytonaConfig {
+    /** API key for authentication with Daytona server */
+    apiKey: string;
+    /** URL of the Daytona server */
+    serverUrl: string;
+    /** Target environment for workspaces */
+    target: CreateWorkspaceTargetEnum;
+}
+/**
+ * Supported programming languages for code execution
+ */
+export type CodeLanguage = 'python' | 'javascript' | 'typescript';
+/**
+ * Resource allocation for a workspace
+ * @interface WorkspaceResources
+ */
+export interface WorkspaceResources {
+    /** CPU allocation for the workspace */
+    cpu?: number;
+    /** GPU allocation for the workspace */
+    gpu?: number;
+    /** Memory allocation for the workspace in MB */
+    memory?: number;
+    /** Disk space allocation for the workspace in MB */
+    disk?: number;
+}
+/**
+ * Parameters for creating a new workspace
+ * @interface CreateWorkspaceParams
+ */
+export type CreateWorkspaceParams = {
+    /** Optional workspace ID. If not provided, a random ID will be generated */
+    id?: string;
+    /** Optional Docker image to use for the workspace */
+    image?: string;
+    /** Optional os user to use for the workspace */
+    user?: string;
+    /** Programming language for direct code execution */
+    language?: CodeLanguage;
+    /** Optional environment variables to set in the workspace */
+    envVars?: Record<string, string>;
+    /** Workspace labels */
+    labels?: Record<string, string>;
+    /** Is the workspace port preview public */
+    public?: boolean;
+    /** Target location for the workspace */
+    target?: string;
+    /** Resource allocation for the workspace */
+    resources?: WorkspaceResources;
+    /** If true, will not wait for the workspace to be ready before returning */
+    async?: boolean;
+};
+/**
+ * Main class for interacting with Daytona Server API
+ * @class Daytona
+ */
+export declare class Daytona {
+    private readonly workspaceApi;
+    private readonly toolboxApi;
+    private readonly target;
+    private readonly apiKey;
+    private readonly serverUrl;
+    /**
+     * Creates a new Daytona client instance
+     * @param {DaytonaConfig} [config] - Configuration options
+     * @throws {Error} When API key or server URL is missing
+     */
+    constructor(config?: DaytonaConfig);
+    /**
+     * Creates a new workspace
+     * @param {CreateWorkspaceParams} [params] - Parameters for workspace creation
+     * @returns {Promise<Workspace>} The created workspace instance
+     */
+    create(params?: CreateWorkspaceParams): Promise<Workspace>;
+    /**
+     * Gets a workspace by its ID
+     * @param {string} workspaceId - The ID of the workspace to retrieve
+     * @returns {Promise<Workspace>} The workspace instance
+     */
+    get(workspaceId: string): Promise<Workspace>;
+    /**
+     * Starts a workspace
+     * @param {Workspace} workspace - The workspace to start
+     */
+    start(workspace: Workspace): Promise<void>;
+    /**
+     * Stops a workspace
+     * @param {Workspace} workspace - The workspace to stop
+     * @returns {Promise<void>}
+     */
+    stop(workspace: Workspace): Promise<void>;
+    /**
+     * Removes a workspace
+     * @param {Workspace} workspace - The workspace to remove
+     * @returns {Promise<void>}
+     */
+    remove(workspace: Workspace): Promise<void>;
+    waitUntilReady(workspace: Workspace): Promise<void>;
+    private getCodeToolbox;
+}

package/dist/Daytona.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Daytona = void 0;
+const uuid_1 = require("uuid");
+const WorkspacePythonCodeToolbox_1 = require("./code-toolbox/WorkspacePythonCodeToolbox");
+const Workspace_1 = require("./Workspace");
+const api_client_1 = require("@daytonaio/api-client");
+const WorkspaceTsCodeToolbox_1 = require("./code-toolbox/WorkspaceTsCodeToolbox");
+/**
+ * Main class for interacting with Daytona Server API
+ * @class Daytona
+ */
+class Daytona {
+    /**
+     * Creates a new Daytona client instance
+     * @param {DaytonaConfig} [config] - Configuration options
+     * @throws {Error} When API key or server URL is missing
+     */
+    constructor(config) {
+        const apiKey = (config === null || config === void 0 ? void 0 : config.apiKey) || process.env.DAYTONA_API_KEY;
+        if (!apiKey) {
+            throw new Error('API key is required');
+        }
+        const serverUrl = (config === null || config === void 0 ? void 0 : config.serverUrl) || process.env.DAYTONA_SERVER_URL;
+        if (!serverUrl) {
+            throw new Error('Server URL is required');
+        }
+        const envTarget = process.env.DAYTONA_TARGET;
+        const target = (config === null || config === void 0 ? void 0 : config.target) || envTarget;
+        this.apiKey = apiKey;
+        this.serverUrl = serverUrl;
+        this.target = target;
+        const configuration = new api_client_1.Configuration({
+            basePath: this.serverUrl,
+            baseOptions: {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+            },
+        });
+        this.workspaceApi = new api_client_1.WorkspaceApi(configuration);
+        this.toolboxApi = new api_client_1.ToolboxApi(configuration);
+    }
+    /**
+     * Creates a new workspace
+     * @param {CreateWorkspaceParams} [params] - Parameters for workspace creation
+     * @returns {Promise<Workspace>} The created workspace instance
+     */
+    async create(params) {
+        var _a, _b, _c, _d;
+        const workspaceId = (params === null || params === void 0 ? void 0 : params.id) || `sandbox-${(0, uuid_1.v4)().slice(0, 8)}`;
+        const codeToolbox = this.getCodeToolbox(params === null || params === void 0 ? void 0 : params.language);
+        const labels = (params === null || params === void 0 ? void 0 : params.labels) || {};
+        if (params === null || params === void 0 ? void 0 : params.language) {
+            labels[`code-toolbox-language`] = params.language;
+        }
+        const reponse = await this.workspaceApi.createWorkspace({
+            id: workspaceId,
+            name: workspaceId, //  todo: remove this after project refactor
+            image: params === null || params === void 0 ? void 0 : params.image,
+            user: params === null || params === void 0 ? void 0 : params.user,
+            env: (params === null || params === void 0 ? void 0 : params.envVars) || {},
+            target: this.target,
+            cpu: (_a = params === null || params === void 0 ? void 0 : params.resources) === null || _a === void 0 ? void 0 : _a.cpu,
+            gpu: (_b = params === null || params === void 0 ? void 0 : params.resources) === null || _b === void 0 ? void 0 : _b.gpu,
+            memory: (_c = params === null || params === void 0 ? void 0 : params.resources) === null || _c === void 0 ? void 0 : _c.memory,
+            disk: (_d = params === null || params === void 0 ? void 0 : params.resources) === null || _d === void 0 ? void 0 : _d.disk,
+        });
+        const workspaceInstance = reponse.data;
+        const workspace = new Workspace_1.Workspace(workspaceId, workspaceInstance, this.workspaceApi, this.toolboxApi, codeToolbox);
+        if (!(params === null || params === void 0 ? void 0 : params.async)) {
+            await this.waitUntilReady(workspace);
+        }
+        return workspace;
+    }
+    /**
+     * Gets a workspace by its ID
+     * @param {string} workspaceId - The ID of the workspace to retrieve
+     * @returns {Promise<Workspace>} The workspace instance
+     */
+    async get(workspaceId) {
+        const response = await this.workspaceApi.getWorkspace(workspaceId);
+        const workspaceInstance = response.data;
+        const language = workspaceInstance.labels && workspaceInstance.labels[`code-toolbox-language`];
+        const codeToolbox = this.getCodeToolbox(language);
+        return new Workspace_1.Workspace(workspaceId, workspaceInstance, this.workspaceApi, this.toolboxApi, codeToolbox);
+    }
+    /**
+     * Starts a workspace
+     * @param {Workspace} workspace - The workspace to start
+     */
+    async start(workspace) {
+        await this.workspaceApi.startWorkspace(workspace.id);
+    }
+    /**
+     * Stops a workspace
+     * @param {Workspace} workspace - The workspace to stop
+     * @returns {Promise<void>}
+     */
+    async stop(workspace) {
+        await this.workspaceApi.stopWorkspace(workspace.id);
+    }
+    /**
+     * Removes a workspace
+     * @param {Workspace} workspace - The workspace to remove
+     * @returns {Promise<void>}
+     */
+    async remove(workspace) {
+        await this.workspaceApi.deleteWorkspace(workspace.id, true);
+    }
+    async waitUntilReady(workspace) {
+        const maxAttempts = 60; // 5 minutes with 5 second intervals
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const response = await this.workspaceApi.getWorkspace(workspace.id);
+            const state = response.data.state;
+            if (state === 'started') {
+                return;
+            }
+            if (state === 'error') {
+                throw new Error(`Workspace failed to start with status: ${status}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100 ms between checks
+            attempts++;
+        }
+        throw new Error('Workspace failed to become ready within the timeout period');
+    }
+    getCodeToolbox(language) {
+        switch (language) {
+            case 'javascript':
+            case 'typescript':
+                return new WorkspaceTsCodeToolbox_1.WorkspaceTsCodeToolbox();
+            case 'python':
+            case undefined:
+                return new WorkspacePythonCodeToolbox_1.WorkspacePythonCodeToolbox();
+            default:
+                throw new Error(`Unsupported language: ${language}`);
+        }
+    }
+}
+exports.Daytona = Daytona;

package/dist/FileSystem.d.ts

@@ -0,0 +1,97 @@
+import { FileInfo, Match, ReplaceResult, SearchFilesResponse, Workspace as WorkspaceInstance, ToolboxApi } from '@daytonaio/api-client';
+/**
+ * Parameters for setting file permissions
+ * @interface FilePermissionsParams
+ */
+type FilePermissionsParams = {
+    /** Group owner of the file */
+    group?: string;
+    /** File mode/permissions in octal format (e.g. "644") */
+    mode?: string;
+    /** User owner of the file */
+    owner?: string;
+};
+/**
+ * Provides file system operations within a workspace
+ * @class FileSystem
+ */
+export declare class FileSystem {
+    private readonly instance;
+    private readonly toolboxApi;
+    constructor(instance: WorkspaceInstance, toolboxApi: ToolboxApi);
+    /**
+     * Creates a new folder in the workspace
+     * @param {string} path - Path where the folder should be created
+     * @param {string} mode - Folder permissions in octal format
+     * @returns {Promise<void>}
+     */
+    createFolder(path: string, mode: string): Promise<void>;
+    /**
+     * Deletes a file from the workspace
+     * @param {string} path - Path to the file to delete
+     * @returns {Promise<void>}
+     */
+    deleteFile(path: string): Promise<void>;
+    /**
+     * Downloads a file from the workspace
+     * @param {string} path - Path to the file to download
+     * @returns {Promise<Blob>} The file contents as a Blob
+     */
+    downloadFile(path: string): Promise<Blob>;
+    /**
+     * Searches for files matching a pattern
+     * @param {string} path - Directory to search in
+     * @param {string} pattern - Search pattern
+     * @returns {Promise<Array<Match>>} Array of matching files
+     */
+    findFiles(path: string, pattern: string): Promise<Array<Match>>;
+    /**
+     * Gets details about a file
+     * @param {string} path - Path to the file
+     * @returns {Promise<FileInfo>} File information
+     */
+    getFileDetails(path: string): Promise<FileInfo>;
+    /**
+     * Lists files in a directory
+     * @param {string} path - Directory path to list
+     * @returns {Promise<FileInfo[]>} Array of file information
+     */
+    listFiles(path: string): Promise<FileInfo[]>;
+    /**
+     * Moves/renames files
+     * @param {string} source - Source path
+     * @param {string} destination - Destination path
+     * @returns {Promise<void>}
+     */
+    moveFiles(source: string, destination: string): Promise<void>;
+    /**
+     * Replaces text in multiple files
+     * @param {string[]} files - Array of file paths
+     * @param {string} pattern - Pattern to replace
+     * @param {string} newValue - Replacement value
+     * @returns {Promise<Array<ReplaceResult>>} Results of the replace operation
+     */
+    replaceInFiles(files: string[], pattern: string, newValue: string): Promise<Array<ReplaceResult>>;
+    /**
+     * Searches for files by name pattern
+     * @param {string} path - Directory to search in
+     * @param {string} pattern - Search pattern
+     * @returns {Promise<SearchFilesResponse>} Search results
+     */
+    searchFiles(path: string, pattern: string): Promise<SearchFilesResponse>;
+    /**
+     * Sets file permissions
+     * @param {string} path - Path to the file
+     * @param {FilePermissionsParams} permissions - Permission settings
+     * @returns {Promise<void>}
+     */
+    setFilePermissions(path: string, permissions: FilePermissionsParams): Promise<void>;
+    /**
+     * Uploads a file to the workspace
+     * @param {string} path - Destination path
+     * @param {Blob} file - File contents to upload
+     * @returns {Promise<void>}
+     */
+    uploadFile(path: string, file: File): Promise<void>;
+}
+export {};

package/dist/FileSystem.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystem = void 0;
+/**
+ * Provides file system operations within a workspace
+ * @class FileSystem
+ */
+class FileSystem {
+    constructor(instance, toolboxApi) {
+        this.instance = instance;
+        this.toolboxApi = toolboxApi;
+    }
+    /**
+     * Creates a new folder in the workspace
+     * @param {string} path - Path where the folder should be created
+     * @param {string} mode - Folder permissions in octal format
+     * @returns {Promise<void>}
+     */
+    async createFolder(path, mode) {
+        const response = await this.toolboxApi.createFolder(this.instance.id, path, mode);
+        return response.data;
+    }
+    /**
+     * Deletes a file from the workspace
+     * @param {string} path - Path to the file to delete
+     * @returns {Promise<void>}
+     */
+    async deleteFile(path) {
+        const response = await this.toolboxApi.deleteFile(this.instance.id, path);
+        return response.data;
+    }
+    /**
+     * Downloads a file from the workspace
+     * @param {string} path - Path to the file to download
+     * @returns {Promise<Blob>} The file contents as a Blob
+     */
+    async downloadFile(path) {
+        const response = await this.toolboxApi.downloadFile(this.instance.id, path);
+        return response.data;
+    }
+    /**
+     * Searches for files matching a pattern
+     * @param {string} path - Directory to search in
+     * @param {string} pattern - Search pattern
+     * @returns {Promise<Array<Match>>} Array of matching files
+     */
+    async findFiles(path, pattern) {
+        const response = await this.toolboxApi.findInFiles(this.instance.id, path, pattern);
+        return response.data;
+    }
+    /**
+     * Gets details about a file
+     * @param {string} path - Path to the file
+     * @returns {Promise<FileInfo>} File information
+     */
+    async getFileDetails(path) {
+        const response = await this.toolboxApi.getFileInfo(this.instance.id, path);
+        return response.data;
+    }
+    /**
+     * Lists files in a directory
+     * @param {string} path - Directory path to list
+     * @returns {Promise<FileInfo[]>} Array of file information
+     */
+    async listFiles(path) {
+        const response = await this.toolboxApi.listFiles(this.instance.id, path);
+        return response.data;
+    }
+    /**
+     * Moves/renames files
+     * @param {string} source - Source path
+     * @param {string} destination - Destination path
+     * @returns {Promise<void>}
+     */
+    async moveFiles(source, destination) {
+        const response = await this.toolboxApi.moveFile(this.instance.id, source, destination);
+        return response.data;
+    }
+    /**
+     * Replaces text in multiple files
+     * @param {string[]} files - Array of file paths
+     * @param {string} pattern - Pattern to replace
+     * @param {string} newValue - Replacement value
+     * @returns {Promise<Array<ReplaceResult>>} Results of the replace operation
+     */
+    async replaceInFiles(files, pattern, newValue) {
+        const replaceRequest = {
+            files,
+            newValue,
+            pattern,
+        };
+        const response = await this.toolboxApi.replaceInFiles(this.instance.id, replaceRequest);
+        return response.data;
+    }
+    /**
+     * Searches for files by name pattern
+     * @param {string} path - Directory to search in
+     * @param {string} pattern - Search pattern
+     * @returns {Promise<SearchFilesResponse>} Search results
+     */
+    async searchFiles(path, pattern) {
+        const response = await this.toolboxApi.searchFiles(this.instance.id, path, pattern);
+        return response.data;
+    }
+    /**
+     * Sets file permissions
+     * @param {string} path - Path to the file
+     * @param {FilePermissionsParams} permissions - Permission settings
+     * @returns {Promise<void>}
+     */
+    async setFilePermissions(path, permissions) {
+        const response = await this.toolboxApi.setFilePermissions(this.instance.id, path, permissions.owner, permissions.group, permissions.mode);
+        return response.data;
+    }
+    /**
+     * Uploads a file to the workspace
+     * @param {string} path - Destination path
+     * @param {Blob} file - File contents to upload
+     * @returns {Promise<void>}
+     */
+    async uploadFile(path, file) {
+        const response = await this.toolboxApi.uploadFile(this.instance.id, path, file);
+        return response.data;
+    }
+}
+exports.FileSystem = FileSystem;