@daytonaio/sdk 0.7.1

package/dist/Git.d.ts

@@ -0,0 +1,67 @@
+import { Workspace as WorkspaceInstance, ToolboxApi, ListBranchResponse, GitStatus } from '@daytonaio/api-client';
+import { Workspace } from './Workspace';
+/**
+ * Provides Git operations within a workspace
+ * @class Git
+ */
+export declare class Git {
+    private readonly workspace;
+    private readonly toolboxApi;
+    private readonly instance;
+    constructor(workspace: Workspace, toolboxApi: ToolboxApi, instance: WorkspaceInstance);
+    /**
+     * Stages files for commit
+     * @param {string} path - Repository path
+     * @param {string[]} files - Array of file paths to stage
+     * @returns {Promise<void>}
+     */
+    add(path: string, files: string[]): Promise<void>;
+    /**
+     * Lists branches in the repository
+     * @param {string} path - Repository path
+     * @returns {Promise<ListBranchResponse>} List of branches
+     */
+    branches(path: string): Promise<ListBranchResponse>;
+    /**
+     * Clones a Git repository
+     * @param {string} url - Repository URL
+     * @param {string} path - Destination path
+     * @param {string} [branch] - Branch to clone
+     * @param {string} [commitId] - Specific commit to clone
+     * @param {string} [username] - Git username for authentication
+     * @param {string} [password] - Git password/token for authentication
+     * @returns {Promise<void>}
+     */
+    clone(url: string, path: string, branch?: string, commitId?: string, username?: string, password?: string): Promise<void>;
+    /**
+     * Creates a new commit with staged changes
+     * @param {string} path - Repository path
+     * @param {string} message - Commit message
+     * @param {string} author - Author name
+     * @param {string} email - Author email
+     * @returns {Promise<void>}
+     */
+    commit(path: string, message: string, author: string, email: string): Promise<void>;
+    /**
+     * Pushes local commits to remote repository
+     * @param {string} path - Repository path
+     * @param {string} [username] - Git username for authentication
+     * @param {string} [password] - Git password/token for authentication
+     * @returns {Promise<void>}
+     */
+    push(path: string, username?: string, password?: string): Promise<void>;
+    /**
+     * Pulls changes from remote repository
+     * @param {string} path - Repository path
+     * @param {string} [username] - Git username for authentication
+     * @param {string} [password] - Git password/token for authentication
+     * @returns {Promise<void>}
+     */
+    pull(path: string, username?: string, password?: string): Promise<void>;
+    /**
+     * Gets the current Git repository status
+     * @param {string} path - Repository path
+     * @returns {Promise<GitStatus>} Repository status information
+     */
+    status(path: string): Promise<GitStatus>;
+}

package/dist/Git.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Git = void 0;
+/**
+ * Provides Git operations within a workspace
+ * @class Git
+ */
+class Git {
+    constructor(workspace, toolboxApi, instance) {
+        this.workspace = workspace;
+        this.toolboxApi = toolboxApi;
+        this.instance = instance;
+    }
+    /**
+     * Stages files for commit
+     * @param {string} path - Repository path
+     * @param {string[]} files - Array of file paths to stage
+     * @returns {Promise<void>}
+     */
+    async add(path, files) {
+        await this.toolboxApi.gitAddFiles(this.instance.id, {
+            path,
+            files,
+        });
+    }
+    /**
+     * Lists branches in the repository
+     * @param {string} path - Repository path
+     * @returns {Promise<ListBranchResponse>} List of branches
+     */
+    async branches(path) {
+        const response = await this.toolboxApi.gitListBranches(this.instance.id, path);
+        return response.data;
+    }
+    /**
+     * Clones a Git repository
+     * @param {string} url - Repository URL
+     * @param {string} path - Destination path
+     * @param {string} [branch] - Branch to clone
+     * @param {string} [commitId] - Specific commit to clone
+     * @param {string} [username] - Git username for authentication
+     * @param {string} [password] - Git password/token for authentication
+     * @returns {Promise<void>}
+     */
+    async clone(url, path, branch, commitId, username, password) {
+        await this.toolboxApi.gitCloneRepository(this.instance.id, {
+            url: url,
+            branch: branch,
+            path,
+            username,
+            password,
+            commit_id: commitId
+        });
+    }
+    /**
+     * Creates a new commit with staged changes
+     * @param {string} path - Repository path
+     * @param {string} message - Commit message
+     * @param {string} author - Author name
+     * @param {string} email - Author email
+     * @returns {Promise<void>}
+     */
+    async commit(path, message, author, email) {
+        await this.toolboxApi.gitCommitChanges(this.instance.id, {
+            path,
+            message,
+            author,
+            email,
+        });
+    }
+    /**
+     * Pushes local commits to remote repository
+     * @param {string} path - Repository path
+     * @param {string} [username] - Git username for authentication
+     * @param {string} [password] - Git password/token for authentication
+     * @returns {Promise<void>}
+     */
+    async push(path, username, password) {
+        await this.toolboxApi.gitPushChanges(this.instance.id, {
+            path,
+            username,
+            password,
+        });
+    }
+    /**
+     * Pulls changes from remote repository
+     * @param {string} path - Repository path
+     * @param {string} [username] - Git username for authentication
+     * @param {string} [password] - Git password/token for authentication
+     * @returns {Promise<void>}
+     */
+    async pull(path, username, password) {
+        await this.toolboxApi.gitPullChanges(this.instance.id, {
+            path,
+            username,
+            password,
+        });
+    }
+    /**
+     * Gets the current Git repository status
+     * @param {string} path - Repository path
+     * @returns {Promise<GitStatus>} Repository status information
+     */
+    async status(path) {
+        const response = await this.toolboxApi.gitGetStatus(this.instance.id, path);
+        return response.data;
+    }
+}
+exports.Git = Git;

package/dist/LspServer.d.ts

@@ -0,0 +1,68 @@
+import { CompletionList, LspSymbol, Workspace as WorkspaceInstance, ToolboxApi } from '@daytonaio/api-client';
+/**
+ * Supported language server types
+ * @typedef {('typescript')} LspLanguageId
+ */
+export type LspLanguageId = 'typescript';
+/**
+ * Position in a text document
+ * @interface Position
+ */
+export type Position = {
+    /** Zero-based line number */
+    line: number;
+    /** Zero-based character offset */
+    character: number;
+};
+/**
+ * Provides Language Server Protocol (LSP) functionality
+ * @class LspServer
+ */
+export declare class LspServer {
+    private readonly languageId;
+    private readonly pathToProject;
+    private readonly toolboxApi;
+    private readonly instance;
+    constructor(languageId: LspLanguageId, pathToProject: string, toolboxApi: ToolboxApi, instance: WorkspaceInstance);
+    /**
+     * Starts the language server
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the language server
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * Notifies the server that a file has been opened
+     * @param {string} path - Path to the opened file
+     * @returns {Promise<void>}
+     */
+    didOpen(path: string): Promise<void>;
+    /**
+     * Notifies the server that a file has been closed
+     * @param {string} path - Path to the closed file
+     * @returns {Promise<void>}
+     */
+    didClose(path: string): Promise<void>;
+    /**
+     * Gets document symbols (functions, classes, etc.)
+     * @param {string} path - Path to the file
+     * @returns {Promise<LspSymbol[]>} Array of document symbols
+     */
+    documentSymbols(path: string): Promise<LspSymbol[]>;
+    /**
+     * Searches for symbols across the workspace
+     * @param {string} query - Search query
+     * @returns {Promise<LspSymbol[]>} Array of matching symbols
+     */
+    workspaceSymbols(query: string): Promise<LspSymbol[]>;
+    /**
+     * Gets code completion suggestions
+     * @param {string} path - Path to the file
+     * @param {Position} position - Cursor position
+     * @returns {Promise<CompletionList>} List of completion suggestions
+     */
+    completions(path: string, position: Position): Promise<CompletionList>;
+}

package/dist/LspServer.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LspServer = void 0;
+/**
+ * Provides Language Server Protocol (LSP) functionality
+ * @class LspServer
+ */
+class LspServer {
+    constructor(languageId, pathToProject, toolboxApi, instance) {
+        this.languageId = languageId;
+        this.pathToProject = pathToProject;
+        this.toolboxApi = toolboxApi;
+        this.instance = instance;
+    }
+    /**
+     * Starts the language server
+     * @returns {Promise<void>}
+     */
+    async start() {
+        await this.toolboxApi.lspStart(this.instance.id, {
+            languageId: this.languageId,
+            pathToProject: this.pathToProject,
+        });
+    }
+    /**
+     * Stops the language server
+     * @returns {Promise<void>}
+     */
+    async stop() {
+        await this.toolboxApi.lspStop(this.instance.id, {
+            languageId: this.languageId,
+            pathToProject: this.pathToProject,
+        });
+    }
+    /**
+     * Notifies the server that a file has been opened
+     * @param {string} path - Path to the opened file
+     * @returns {Promise<void>}
+     */
+    async didOpen(path) {
+        await this.toolboxApi.lspDidOpen(this.instance.id, {
+            languageId: this.languageId,
+            pathToProject: this.pathToProject,
+            uri: 'file://' + path,
+        });
+    }
+    /**
+     * Notifies the server that a file has been closed
+     * @param {string} path - Path to the closed file
+     * @returns {Promise<void>}
+     */
+    async didClose(path) {
+        await this.toolboxApi.lspDidClose(this.instance.id, {
+            languageId: this.languageId,
+            pathToProject: this.pathToProject,
+            uri: 'file://' + path,
+        });
+    }
+    /**
+     * Gets document symbols (functions, classes, etc.)
+     * @param {string} path - Path to the file
+     * @returns {Promise<LspSymbol[]>} Array of document symbols
+     */
+    async documentSymbols(path) {
+        const response = await this.toolboxApi.lspDocumentSymbols(this.instance.id, this.languageId, this.pathToProject, 'file://' + path);
+        return response.data;
+    }
+    /**
+     * Searches for symbols across the workspace
+     * @param {string} query - Search query
+     * @returns {Promise<LspSymbol[]>} Array of matching symbols
+     */
+    async workspaceSymbols(query) {
+        const response = await this.toolboxApi.lspWorkspaceSymbols(this.instance.id, this.languageId, this.pathToProject, query);
+        return response.data;
+    }
+    /**
+     * Gets code completion suggestions
+     * @param {string} path - Path to the file
+     * @param {Position} position - Cursor position
+     * @returns {Promise<CompletionList>} List of completion suggestions
+     */
+    async completions(path, position) {
+        const response = await this.toolboxApi.lspCompletions(this.instance.id, {
+            languageId: this.languageId,
+            pathToProject: this.pathToProject,
+            uri: 'file://' + path,
+            position,
+        });
+        return response.data;
+    }
+}
+exports.LspServer = LspServer;

package/dist/Process.d.ts

@@ -0,0 +1,54 @@
+import { ExecuteResponse, Session, SessionExecuteRequest, SessionExecuteResponse, ToolboxApi, Workspace } from '@daytonaio/api-client';
+import { WorkspaceCodeToolbox } from './Workspace';
+/**
+ * Handles process and code execution within a workspace
+ * @class Process
+ */
+export declare class Process {
+    private readonly codeToolbox;
+    private readonly toolboxApi;
+    private readonly instance;
+    constructor(codeToolbox: WorkspaceCodeToolbox, toolboxApi: ToolboxApi, instance: Workspace);
+    /**
+     * Executes a shell command in the workspace
+     * @param {string} command - Command to execute
+     * @returns {Promise<ExecuteResponse>} Command execution results
+     */
+    processExecuteCommand(command: string, timeout?: number): Promise<ExecuteResponse>;
+    /**
+     * Executes code in the workspace using the appropriate language runtime
+     * @param {string} code - Code to execute
+     * @returns {Promise<ExecuteResponse>} Code execution results
+     */
+    codeRun(code: string): Promise<ExecuteResponse>;
+    /**
+     * Creates a new exec session in the workspace
+     * @param {string} sessionId - Unique identifier for the session
+     * @returns {Promise<ExecuteResponse>} Code execution results
+     */
+    createSession(sessionId: string): Promise<void>;
+    /**
+     * Executes a command in the session
+     * @param {string} sessionId - Unique identifier for the session
+     * @param {SessionExecuteRequest} req - Command to execute and async flag
+     * @returns {Promise<SessionExecuteResponse>} Command execution results
+     */
+    executeSession(sessionId: string, req: SessionExecuteRequest): Promise<SessionExecuteResponse>;
+    /**
+     * Gets the logs for a command in the session
+     * @param {string} sessionId - Unique identifier for the session
+     * @param {string} commandId - Unique identifier for the command
+     * @returns {Promise<string>} Command logs
+     */
+    getExecuteSessionCommandLogs(sessionId: string, commandId: string): Promise<string>;
+    /**
+     * Lists all sessions in the workspace
+     * @returns {Promise<Session[]>} List of sessions
+     */
+    listSessions(): Promise<Session[]>;
+    /**
+     * Deletes a session in the workspace
+     * @param {string} sessionId - Unique identifier for the session
+     */
+    deleteSession(sessionId: string): Promise<void>;
+}

package/dist/Process.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Process = void 0;
+/**
+ * Handles process and code execution within a workspace
+ * @class Process
+ */
+class Process {
+    constructor(codeToolbox, toolboxApi, instance) {
+        this.codeToolbox = codeToolbox;
+        this.toolboxApi = toolboxApi;
+        this.instance = instance;
+    }
+    /**
+     * Executes a shell command in the workspace
+     * @param {string} command - Command to execute
+     * @returns {Promise<ExecuteResponse>} Command execution results
+     */
+    async processExecuteCommand(command, timeout) {
+        const response = await this.toolboxApi.executeCommand(this.instance.id, {
+            command,
+            timeout,
+        });
+        return response.data;
+    }
+    /**
+     * Executes code in the workspace using the appropriate language runtime
+     * @param {string} code - Code to execute
+     * @returns {Promise<ExecuteResponse>} Code execution results
+     */
+    async codeRun(code) {
+        const runCommand = this.codeToolbox.getRunCommand(code);
+        const response = await this.toolboxApi.executeCommand(this.instance.id, {
+            command: runCommand,
+        });
+        return response.data;
+    }
+    /**
+     * Creates a new exec session in the workspace
+     * @param {string} sessionId - Unique identifier for the session
+     * @returns {Promise<ExecuteResponse>} Code execution results
+     */
+    async createSession(sessionId) {
+        await this.toolboxApi.createSession(this.instance.id, {
+            sessionId,
+        });
+    }
+    /**
+     * Executes a command in the session
+     * @param {string} sessionId - Unique identifier for the session
+     * @param {SessionExecuteRequest} req - Command to execute and async flag
+     * @returns {Promise<SessionExecuteResponse>} Command execution results
+     */
+    async executeSession(sessionId, req) {
+        const response = await this.toolboxApi.executeSessionCommand(this.instance.id, sessionId, req);
+        return response.data;
+    }
+    /**
+     * Gets the logs for a command in the session
+     * @param {string} sessionId - Unique identifier for the session
+     * @param {string} commandId - Unique identifier for the command
+     * @returns {Promise<string>} Command logs
+     */
+    async getExecuteSessionCommandLogs(sessionId, commandId) {
+        const response = await this.toolboxApi.getSessionCommandLogs(this.instance.id, sessionId, commandId);
+        return response.data;
+    }
+    /**
+     * Lists all sessions in the workspace
+     * @returns {Promise<Session[]>} List of sessions
+     */
+    async listSessions() {
+        const response = await this.toolboxApi.listSessions(this.instance.id);
+        return response.data;
+    }
+    /**
+     * Deletes a session in the workspace
+     * @param {string} sessionId - Unique identifier for the session
+     */
+    async deleteSession(sessionId) {
+        await this.toolboxApi.deleteSession(this.instance.id, sessionId);
+    }
+}
+exports.Process = Process;

package/dist/Workspace.d.ts

@@ -0,0 +1,53 @@
+import { ToolboxApi, WorkspaceApi } from '@daytonaio/api-client';
+import { Workspace as WorkspaceInstance } from '@daytonaio/api-client';
+import { FileSystem } from './FileSystem';
+import { Git } from './Git';
+import { Process } from './Process';
+import { LspLanguageId, LspServer } from './LspServer';
+/**
+ * Interface defining methods that a code toolbox must implement
+ * @interface WorkspaceCodeToolbox
+ */
+export interface WorkspaceCodeToolbox {
+    /** Generates a command to run the provided code */
+    getRunCommand(code: string): string;
+}
+/**
+ * Represents a Daytona workspace instance with file system, git, and process management capabilities
+ * @class Workspace
+ */
+export declare class Workspace {
+    readonly id: string;
+    private readonly instance;
+    readonly workspaceApi: WorkspaceApi;
+    readonly toolboxApi: ToolboxApi;
+    private readonly codeToolbox;
+    /** File system operations for the workspace */
+    readonly fs: FileSystem;
+    /** Git operations for the workspace */
+    readonly git: Git;
+    /** Process and code execution operations */
+    readonly process: Process;
+    /**
+     * Creates a new workspace instance
+     * @param {string} id - Unique identifier for the workspace
+     * @param {WorkspaceInstance} instance - The underlying workspace instance
+     * @param {WorkspaceApi} workspaceApi - API client for workspace operations
+     * @param {ToolboxApi} toolboxApi - API client for toolbox operations
+     *
+     * @param {WorkspaceCodeToolbox} codeToolbox - Language-specific toolbox implementation
+     */
+    constructor(id: string, instance: WorkspaceInstance, workspaceApi: WorkspaceApi, toolboxApi: ToolboxApi, codeToolbox: WorkspaceCodeToolbox);
+    /**
+     * Gets the root directory path of the workspace
+     * @returns {Promise<string>} The absolute path to the workspace root
+     */
+    getWorkspaceRootDir(): Promise<string | undefined>;
+    /**
+     * Creates a new Language Server Protocol (LSP) server instance
+     * @param {LspLanguageId} languageId - The language server type
+     * @param {string} pathToProject - Path to the project root
+     * @returns {LspServer} A new LSP server instance
+     */
+    createLspServer(languageId: LspLanguageId, pathToProject: string): LspServer;
+}

package/dist/Workspace.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workspace = void 0;
+const FileSystem_1 = require("./FileSystem");
+const Git_1 = require("./Git");
+//  import { LspLanguageId, LspServer } from './LspServer'
+const Process_1 = require("./Process");
+const LspServer_1 = require("./LspServer");
+/**
+ * Represents a Daytona workspace instance with file system, git, and process management capabilities
+ * @class Workspace
+ */
+class Workspace {
+    /**
+     * Creates a new workspace instance
+     * @param {string} id - Unique identifier for the workspace
+     * @param {WorkspaceInstance} instance - The underlying workspace instance
+     * @param {WorkspaceApi} workspaceApi - API client for workspace operations
+     * @param {ToolboxApi} toolboxApi - API client for toolbox operations
+     *
+     * @param {WorkspaceCodeToolbox} codeToolbox - Language-specific toolbox implementation
+     */
+    constructor(id, instance, workspaceApi, toolboxApi, codeToolbox) {
+        this.id = id;
+        this.instance = instance;
+        this.workspaceApi = workspaceApi;
+        this.toolboxApi = toolboxApi;
+        this.codeToolbox = codeToolbox;
+        this.fs = new FileSystem_1.FileSystem(instance, this.toolboxApi);
+        this.git = new Git_1.Git(this, this.toolboxApi, instance);
+        this.process = new Process_1.Process(this.codeToolbox, this.toolboxApi, instance);
+    }
+    /**
+     * Gets the root directory path of the workspace
+     * @returns {Promise<string>} The absolute path to the workspace root
+     */
+    async getWorkspaceRootDir() {
+        const response = await this.toolboxApi.getProjectDir(this.instance.id);
+        return response.data.dir;
+    }
+    /**
+     * Creates a new Language Server Protocol (LSP) server instance
+     * @param {LspLanguageId} languageId - The language server type
+     * @param {string} pathToProject - Path to the project root
+     * @returns {LspServer} A new LSP server instance
+     */
+    createLspServer(languageId, pathToProject) {
+        return new LspServer_1.LspServer(languageId, pathToProject, this.toolboxApi, this.instance);
+    }
+}
+exports.Workspace = Workspace;

package/dist/client/apis/ApiKeyApi.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Daytona Server API
+ * Daytona Server API
+ *
+ * The version of the OpenAPI document: v0.0.0-dev
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import type { ApiKey } from '../models/index';
+export interface GenerateApiKeyRequest {
+    apiKeyName: string;
+}
+export interface RevokeApiKeyRequest {
+    apiKeyName: string;
+}
+/**
+ *
+ */
+export declare class ApiKeyApi extends runtime.BaseAPI {
+    /**
+     * Generate an API key
+     * Generate an API key
+     */
+    generateApiKeyRaw(requestParameters: GenerateApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>>;
+    /**
+     * Generate an API key
+     * Generate an API key
+     */
+    generateApiKey(requestParameters: GenerateApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string>;
+    /**
+     * List API keys
+     * List API keys
+     */
+    listClientApiKeysRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ApiKey>>>;
+    /**
+     * List API keys
+     * List API keys
+     */
+    listClientApiKeys(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ApiKey>>;
+    /**
+     * Revoke API key
+     * Revoke API key
+     */
+    revokeApiKeyRaw(requestParameters: RevokeApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Revoke API key
+     * Revoke API key
+     */
+    revokeApiKey(requestParameters: RevokeApiKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+}