@intella/sdk 0.0.1 → 0.0.3

package/src/sandbox/daytona-provider.ts

@@ -1,462 +0,0 @@
-import { BaseSandboxProvider } from './base-provider.js';
-import type { SandboxConfig, CommandResult, CodeExecutionResult, SandboxInfo } from '../types.js';
-import { Daytona, Sandbox } from '@daytonaio/sdk';
-
-/**
- * Daytona Sandbox Provider
- * Provides sandbox execution capabilities using Daytona
- */
-export class DaytonaSandboxProvider extends BaseSandboxProvider {
-  protected client: Daytona | null = null;
-  private sandboxInstance: Sandbox | null = null;
-
-  constructor(config?: SandboxConfig) {
-    super('daytona');
-    if (config) {
-      this.config = config;
-    }
-  }
-
-
-  getClient(): Daytona {
-    if (!this.client) {
-      const apiKey =
-        this.config.apiKey ||
-        process.env.DAYTONA_API_KEY ||
-        process.env.DAYTONA_API_TOKEN ||
-        null;
-
-      if (!apiKey) {
-        throw new Error(
-          'Daytona API key is required. Set DAYTONA_API_KEY or DAYTONA_API_TOKEN environment variable or provide apiKey in config.'
-        );
-      }
-      this.client = new Daytona({ apiKey });
-    }
-    return this.client;
-  }
-
-  /**
-   * Initialize/create a Daytona sandbox
-   */
-  protected async initializeSandbox(config?: SandboxConfig): Promise<void> {
-    if (config) {
-      this.config = { ...this.config, ...config };
-    }
-
-    try {
-      // Dynamic import to handle optional dependency
-
-      const daytonaClient = this.getClient();
-
-      // Create sandbox with language/template configuration
-      const createOptions: any = {
-        envVars: this.config.env || {},
-      };
-
-      // If templateId is provided, use it (could be a language or template name)
-      if (this.config.templateId) {
-        // Check if it's a language identifier
-        const languageMap: Record<string, string> = {
-          typescript: 'typescript',
-          javascript: 'typescript', // Daytona uses typescript for JS
-          python: 'python',
-          java: 'java',
-          go: 'go',
-          rust: 'rust',
-        };
-
-        const language = languageMap[this.config.templateId.toLowerCase()];
-        if (language) {
-          createOptions.language = language;
-        } else {
-          // Assume it's a template ID
-          createOptions.template = this.config.templateId;
-        }
-      }
-
-      // Create the sandbox
-      this.sandboxInstance = await daytonaClient.create(createOptions);
-      this.sandboxId = this.sandboxInstance!.id;
-      this.initialized = true;
-    } catch (error) {
-      throw new Error(
-        `Failed to initialize Daytona sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Connect to an existing Daytona sandbox by ID
-   */
-  async fromSandbox(sandboxId: string, config?: SandboxConfig): Promise<Sandbox> {
-    if (config) {
-      this.config = { ...this.config, ...config };
-    }
-
-    try {
-      const daytonaClient = this.getClient();
-
-      // Get existing sandbox by ID
-      // Note: Daytona SDK may have a method to get sandbox by ID
-      // If not available, we'll need to use the client's get method
-      
-      
-      // Try to get sandbox by ID
-      this.sandboxInstance = await daytonaClient.get(sandboxId);
-
-      await daytonaClient.start(this.sandboxInstance!);
-
-      this.sandboxId = this.sandboxInstance!.id || sandboxId;
-      this.initialized = true;
-      return this.sandboxInstance;
-    } catch (error) {
-      throw new Error(
-        `Failed to connect to Daytona sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Close/cleanup the Daytona sandbox
-   */
-  async close(): Promise<void> {
-    if (this.sandboxInstance && this.initialized) {
-      try {
-        await this.sandboxInstance.delete();
-      } catch (error) {
-        // Ignore errors during cleanup
-        console.warn('Error closing Daytona sandbox:', error);
-      }
-      this.sandboxInstance = null;
-      this.client = null;
-      this.sandboxId = null;
-      this.initialized = false;
-    }
-  }
-
-  /**
-   * Execute a command in the Daytona sandbox
-   * @param command - Command to execute
-   * @param options - Execution options (cwd, env, timeout)
-   */
-  async executeCommand(
-    command: string,
-    options?: {
-      cwd?: string;
-      env?: Record<string, string>;
-      timeout?: number;
-    }
-  ): Promise<CommandResult> {
-    this.ensureInitialized();
-
-    const startTime = Date.now();
-    try {
-      // Use process.executeCommand for shell commands
-      // According to docs: https://www.daytona.io/docs/en/process-code-execution/
-      const execOptions: any = {};
-      if (options?.cwd) {
-        execOptions.cwd = options.cwd;
-      }
-      if (options?.env) {
-        execOptions.env = { ...this.config.env, ...options.env };
-      }
-      if (options?.timeout) {
-        execOptions.timeout = options.timeout;
-      }
-
-      const response: any = await this.sandboxInstance!.process.executeCommand(
-        command,
-        Object.keys(execOptions).length > 0 ? execOptions : undefined
-      );
-
-      const executionTime = Date.now() - startTime;
-
-      return {
-        exitCode: response.exitCode || response.code || 0,
-        stdout: response.result || response.stdout || '',
-        stderr: response.stderr || response.error || '',
-        executionTime,
-      };
-    } catch (error) {
-      const executionTime = Date.now() - startTime;
-      return {
-        exitCode: 1,
-        stdout: '',
-        stderr: error instanceof Error ? error.message : String(error),
-        executionTime,
-      };
-    }
-  }
-
-  /**
-   * Run code (e.g., Python, JavaScript, TypeScript) in the Daytona sandbox
-   * Uses the stateless codeRun method: https://www.daytona.io/docs/en/process-code-execution/
-   */
-  async runCode(
-    code: string,
-    options?: {
-      language?: string;
-      env?: Record<string, string>;
-      timeout?: number;
-      onStdout?: (data: string) => void;
-      onStderr?: (data: string) => void;
-    }
-  ): Promise<CodeExecutionResult> {
-    this.ensureInitialized();
-
-    const startTime = Date.now();
-    try {
-      // Use process.codeRun for stateless code execution
-      // According to docs: https://www.daytona.io/docs/en/process-code-execution/
-      const codeRunOptions: any = {};
-      if (options?.env) {
-        codeRunOptions.env = { ...this.config.env, ...options.env };
-      }
-      if (options?.timeout) {
-        codeRunOptions.timeout = options.timeout;
-      }
-
-      const response: any = await this.sandboxInstance!.process.codeRun(
-        code,
-        Object.keys(codeRunOptions).length > 0 ? codeRunOptions : undefined,
-        options?.timeout
-      );
-
-      const executionTime = Date.now() - startTime;
-
-      // Handle stdout/stderr callbacks if provided
-      if (options?.onStdout && response.result) {
-        options.onStdout(response.result);
-      }
-      if (options?.onStderr && response.stderr) {
-        options.onStderr(response.stderr);
-      }
-
-      return {
-        text: response.result || undefined,
-        results: response.result ? [{ text: response.result }] : [],
-        stdout: response.result ? [response.result] : [],
-        stderr: response.stderr ? [response.stderr] : [],
-        error: response.exitCode !== 0 || response.code !== 0
-          ? {
-              name: 'CodeExecutionError',
-              value: response.stderr || response.error || 'Code execution failed',
-              traceback: response.stderr || response.error || '',
-            }
-          : undefined,
-        executionTime,
-      };
-    } catch (error) {
-      const executionTime = Date.now() - startTime;
-      return {
-        text: undefined,
-        results: [],
-        stdout: [],
-        stderr: [error instanceof Error ? error.message : String(error)],
-        error: {
-          name: 'CodeExecutionError',
-          value: error instanceof Error ? error.message : String(error),
-          traceback: error instanceof Error ? (error.stack || '') : '',
-        },
-        executionTime,
-      };
-    }
-  }
-
-  /**
-   * Upload a file to the Daytona sandbox
-   * Uses fs.uploadFile: https://www.daytona.io/docs/en/file-system-operations/
-   */
-  async uploadFile(localPath: string, remotePath: string): Promise<void> {
-    this.ensureInitialized();
-
-    try {
-      const fs = await import('fs/promises');
-      const content = await fs.readFile(localPath);
-      
-      // Use SDK fs.uploadFile method (takes Buffer and remote path)
-      await this.sandboxInstance!.fs.uploadFile(content, remotePath);
-    } catch (error) {
-      throw new Error(
-        `Failed to upload file to Daytona sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Download a file from the Daytona sandbox
-   * Uses fs.downloadFile: https://www.daytona.io/docs/en/file-system-operations/
-   */
-  async downloadFile(remotePath: string, localPath: string): Promise<void> {
-    this.ensureInitialized();
-
-    try {
-      // Use SDK fs.downloadFile method (returns Buffer)
-      const content = await this.sandboxInstance!.fs.downloadFile(remotePath);
-      const fs = await import('fs/promises');
-      
-      // Write Buffer to local file
-      await fs.writeFile(localPath, content);
-    } catch (error) {
-      throw new Error(
-        `Failed to download file from Daytona sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Read a file from the Daytona sandbox
-   * Uses fs.downloadFile: https://www.daytona.io/docs/en/file-system-operations/
-   */
-  async readFile(path: string): Promise<string> {
-    this.ensureInitialized();
-
-    try {
-      // Use SDK fs.downloadFile method (returns Buffer)
-      const content = await this.sandboxInstance!.fs.downloadFile(path);
-      return content.toString('utf-8');
-    } catch (error) {
-      throw new Error(
-        `Failed to read file from Daytona sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Write a file to the Daytona sandbox
-   * Uses fs.uploadFile: https://www.daytona.io/docs/en/file-system-operations/
-   */
-  async writeFile(path: string, content: string): Promise<void> {
-    this.ensureInitialized();
-
-    try {
-      // Use SDK fs.uploadFile method (takes Buffer and remote path)
-      const buffer = Buffer.from(content, 'utf-8');
-      await this.sandboxInstance!.fs.uploadFile(buffer, path);
-    } catch (error) {
-      throw new Error(
-        `Failed to write file to Daytona sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * List files in a directory
-   * Uses fs.listFiles: https://www.daytona.io/docs/en/file-system-operations/
-   */
-  async listFiles(path: string): Promise<string[]> {
-    this.ensureInitialized();
-
-    try {
-      // Use SDK fs.listFiles method (returns File[] with name, isDir, size, modTime)
-      const files = await this.sandboxInstance!.fs.listFiles(path);
-      // Return array of file/directory names
-      return files.map((file: any) => file.name || file.path);
-    } catch (error) {
-      throw new Error(
-        `Failed to list files in Daytona sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Check if a file exists
-   */
-  async fileExists(path: string): Promise<boolean> {
-    this.ensureInitialized();
-
-    try {
-      await this.readFile(path);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Delete a file
-   * Uses fs.deleteFile: https://www.daytona.io/docs/en/file-system-operations/
-   */
-  async deleteFile(path: string): Promise<void> {
-    this.ensureInitialized();
-
-    try {
-      // Use SDK fs.deleteFile method
-      await this.sandboxInstance!.fs.deleteFile(path);
-    } catch (error) {
-      throw new Error(
-        `Failed to delete file in Daytona sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  /**
-   * Get sandbox status
-   */
-  async getStatus(): Promise<{
-    isRunning: boolean;
-    createdAt?: number;
-    [key: string]: unknown;
-  }> {
-    this.ensureInitialized();
-
-    try {
-      // Check if sandbox instance is available
-      if (!this.sandboxInstance) {
-        return {
-          isRunning: false,
-        };
-      }
-
-      // Try to get status from sandbox instance
-      const sandboxAny = this.sandboxInstance as any;
-      const status = sandboxAny.status || sandboxAny.state;
-      const isRunning = status === 'running' || status === 'active' || this.initialized;
-
-      return {
-        isRunning,
-        sandboxId: this.sandboxId,
-        status,
-      };
-    } catch {
-      return {
-        isRunning: false,
-      };
-    }
-  }
-
-  /**
-   * Get detailed sandbox information
-   */
-  async getInfo(sandboxId?: string): Promise<SandboxInfo> {
-
-    if (!sandboxId && this.sandboxInstance) {
-      this.ensureInitialized();
-      const info = this.sandboxInstance
-      return {
-        sandboxId: info.id,
-        provider: this.type,
-        isRunning: info.state === 'started',
-        isInitialized: this.initialized,
-        createdAt: new Date(info.createdAt!),
-        metadata: {},
-        info: info,
-      };
-    } else if (sandboxId) {
-      const sandbox = await this.client!.get(sandboxId);
-      return {
-        sandboxId: sandbox.id,
-        provider: this.type,
-        isRunning: sandbox.state === 'started',
-        isInitialized: this.initialized,
-        createdAt: new Date(sandbox.createdAt!),
-        metadata: {},
-        info: sandbox,
-      };
-    } else {
-      throw new Error('Sandbox ID or active instance is required to get sandbox info');
-    }
-  }
-}
-