@intella/sdk 0.0.1

package/src/sandbox/e2b-provider.ts

@@ -0,0 +1,419 @@
+import { BaseSandboxProvider } from './base-provider.js';
+import type { SandboxConfig, CommandResult, CodeExecutionResult, SandboxInfo } from '../types.js';
+import { Sandbox } from '@e2b/code-interpreter';
+import 'dotenv/config';
+
+/**
+ * E2B Sandbox Provider
+ * Provides sandbox execution capabilities using E2B Code Interpreter SDK
+ */
+export class E2BSandboxProvider extends BaseSandboxProvider {
+  private sandboxInstance: Sandbox | null = null;
+  protected client: Record<string, any> | null = null;
+
+  constructor(config?: SandboxConfig) {
+    super('e2b');
+    if (config) {
+      this.config = config;
+    }
+  }
+
+
+  getClient(): Record<string, any> {
+    if (!this.client) {
+      const apiKey = this.config.apiKey || process.env.E2B_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          'E2B API key is required. Set E2B_API_KEY environment variable or provide apiKey in config.'
+        );
+      }
+      this.client = {
+        apiKey: apiKey,
+        ...this.config,
+      };
+
+      if (this.config.apiKey) {
+        process.env['E2B_API_KEY'] = this.config.apiKey;
+      }
+    }
+    return this.client;
+  }
+
+  /**
+   * Initialize/create an E2B sandbox
+   */
+  protected async initializeSandbox(config?: SandboxConfig): Promise<void> {
+    if (config) {
+      this.config = { ...this.config, ...config };
+    }
+
+    try {
+      // Dynamic import to handle optional dependency
+      const client = this.getClient();
+
+      const envs = this.config.env || {};
+
+      // Create sandbox instance using @e2b/code-interpreter
+      // The code-interpreter SDK uses 'envs' instead of 'env'
+      const sandboxOpts: any = {
+        apiKey: client.apiKey,
+      };
+
+      if (Object.keys(envs).length > 0) {
+        sandboxOpts.envs = envs;
+      }
+
+      this.sandboxInstance = await Sandbox.create(sandboxOpts);
+
+      this.sandboxId = this.sandboxInstance.sandboxId;
+      this.initialized = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize E2B sandbox: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Connect to an existing E2B sandbox by ID
+   */
+  async fromSandbox(sandboxId: string, config?: SandboxConfig): Promise<Sandbox> {
+    if (config) {
+      this.config = { ...this.config, ...config };
+    }
+    try {
+
+      const client = this.getClient();
+
+      const sandbox = await Sandbox.connect(sandboxId, {
+        apiKey: client.apiKey,
+      });
+
+      this.sandboxInstance = sandbox;
+      this.sandboxId = sandbox.sandboxId;
+      this.initialized = true;
+      return this.sandboxInstance;
+    } catch (error) {
+
+      throw new Error(
+        `Failed to connect to E2B sandbox: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Close/cleanup the E2B sandbox
+   */
+  async close(): Promise<void> {
+    if (this.sandboxInstance) {
+      try {
+        await this.sandboxInstance.kill();
+      } catch (error) {
+        // Ignore errors during cleanup
+        console.warn('Error closing E2B sandbox:', error);
+      }
+      this.sandboxInstance = null;
+      this.sandboxId = null;
+      this.initialized = false;
+    }
+  }
+
+  /**
+   * Execute a command in the E2B sandbox
+   */
+  async executeCommand(
+    command: string,
+    options?: {
+      cwd?: string;
+      env?: Record<string, string>;
+      timeout?: number;
+    }
+  ): Promise<CommandResult> {
+    this.ensureInitialized();
+
+    const startTime = Date.now();
+    try {
+      // Use commands.run() which takes the command string directly
+      // and options as the second parameter
+      const commandOpts: any = {};
+      if (options?.cwd) {
+        commandOpts.cwd = options.cwd;
+      }
+      if (options?.env) {
+        commandOpts.envs = options.env; // E2B uses 'envs' not 'env'
+      }
+
+      const timeout = options?.timeout || this.config.timeout || 60000;
+      const result = await Promise.race([
+        this.sandboxInstance!.commands.run(command, commandOpts),
+        new Promise<CommandResult>((_, reject) =>
+          setTimeout(() => reject(new Error('Command timeout')), timeout)
+        ),
+      ]);
+
+      const executionTime = Date.now() - startTime;
+
+      return {
+        exitCode: result.exitCode || 0,
+        stdout: result.stdout || '',
+        stderr: result.stderr || '',
+        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) in the E2B sandbox
+   */
+  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 {
+      const runCodeOpts: any = {};
+
+      if (options?.language) {
+        runCodeOpts.language = options.language;
+      }
+
+      if (options?.env) {
+        runCodeOpts.envs = options.env; // E2B uses 'envs' not 'env'
+      }
+
+      if (options?.timeout) {
+        runCodeOpts.timeoutMs = options.timeout;
+      }
+
+      // Handle streaming callbacks for stdout/stderr
+      if (options?.onStdout) {
+        runCodeOpts.onStdout = (output: { line: string }) => {
+          options.onStdout!(output.line);
+        };
+      }
+
+      if (options?.onStderr) {
+        runCodeOpts.onStderr = (output: { line: string }) => {
+          options.onStderr!(output.line);
+        };
+      }
+
+      const execution = await this.sandboxInstance!.runCode(code, runCodeOpts);
+      const executionTime = Date.now() - startTime;
+
+      return {
+        text: execution.text,
+        results: execution.results.map((result) => result.toJSON()),
+        stdout: execution.logs.stdout,
+        stderr: execution.logs.stderr,
+        error: execution.error
+          ? {
+            name: execution.error.name,
+            value: execution.error.value,
+            traceback: execution.error.traceback,
+          }
+          : undefined,
+        executionTime,
+      };
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      return {
+        text: undefined,
+        results: [],
+        stdout: [],
+        stderr: [],
+        error: {
+          name: 'ExecutionError',
+          value: error instanceof Error ? error.message : String(error),
+          traceback: error instanceof Error ? error.stack || '' : '',
+        },
+        executionTime,
+      };
+    }
+  }
+
+  /**
+   * Upload a file to the E2B sandbox
+   */
+  async uploadFile(localPath: string, remotePath: string): Promise<void> {
+    this.ensureInitialized();
+
+    try {
+      const fs = await import('fs/promises');
+      const content = await fs.readFile(localPath);
+      // Convert Buffer to Uint8Array for E2B filesystem
+      const uint8Array = new Uint8Array(content);
+      await this.sandboxInstance!.files.write(remotePath, uint8Array.buffer);
+    } catch (error) {
+      throw new Error(
+        `Failed to upload file to E2B sandbox: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Download a file from the E2B sandbox
+   */
+  async downloadFile(remotePath: string, localPath: string): Promise<void> {
+    this.ensureInitialized();
+
+    try {
+      const content = await this.sandboxInstance!.files.read(remotePath, { format: 'bytes' });
+      const fs = await import('fs/promises');
+      await fs.writeFile(localPath, Buffer.from(content));
+    } catch (error) {
+      throw new Error(
+        `Failed to download file from E2B sandbox: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Read a file from the E2B sandbox
+   */
+  async readFile(path: string): Promise<string> {
+    this.ensureInitialized();
+
+    try {
+      const content = await this.sandboxInstance!.files.read(path);
+      return content;
+    } catch (error) {
+      throw new Error(
+        `Failed to read file from E2B sandbox: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Write a file to the E2B sandbox
+   */
+  async writeFile(path: string, content: string): Promise<void> {
+    this.ensureInitialized();
+
+    try {
+      await this.sandboxInstance!.files.write(path, content);
+    } catch (error) {
+      throw new Error(
+        `Failed to write file to E2B sandbox: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * List files in a directory
+   */
+  async listFiles(path: string): Promise<string[]> {
+    this.ensureInitialized();
+
+    try {
+      const entries = await this.sandboxInstance!.files.list(path);
+      return entries.map((entry) => entry.name || entry.path);
+    } catch (error) {
+      throw new Error(
+        `Failed to list files in E2B sandbox: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Check if a file exists
+   */
+  async fileExists(path: string): Promise<boolean> {
+    this.ensureInitialized();
+
+    try {
+      return await this.sandboxInstance!.files.exists(path);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Delete a file
+   */
+  async deleteFile(path: string): Promise<void> {
+    this.ensureInitialized();
+
+    try {
+      await this.sandboxInstance!.files.remove(path);
+    } catch (error) {
+      throw new Error(
+        `Failed to delete file in E2B sandbox: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Get sandbox status
+   */
+  async getStatus(): Promise<{
+    isRunning: boolean;
+    createdAt?: number;
+    [key: string]: unknown;
+  }> {
+    this.ensureInitialized();
+
+    try {
+      // E2B doesn't expose a direct status endpoint, but we can check if sandbox is accessible
+      return {
+        isRunning: this.initialized && this.sandboxInstance !== null,
+        sandboxId: this.sandboxId,
+      };
+    } catch {
+      return {
+        isRunning: false,
+      };
+    }
+  }
+
+  /**
+   * Get detailed sandbox information
+   */
+  async getInfo(sandboxId?: string): Promise<SandboxInfo> {
+
+    if (!sandboxId && this.sandboxInstance) {
+
+      const info = await this.sandboxInstance.getInfo();
+      return {
+        sandboxId: info.sandboxId,
+        provider: this.type,
+        isRunning: info.state === 'running',
+        isInitialized: this.initialized,
+        createdAt: info.startedAt,
+        metadata: info.metadata,
+        info: info,
+      };
+    } else if (sandboxId) {
+      const sandbox = await this.fromSandbox(sandboxId);
+      const info = await sandbox.getInfo();
+      return {
+        sandboxId: sandbox.sandboxId,
+        provider: this.type,
+        isRunning: info.state === 'running',
+        isInitialized: this.initialized,
+        createdAt: info.startedAt,
+        metadata: info.metadata,
+        info: info,
+      };
+    } else {
+      throw new Error('Sandbox ID or active instance is required to get sandbox info');
+    }
+  }
+}
+