claude-flow 1.0.0

package/src/terminal/adapters/vscode.ts

@@ -0,0 +1,340 @@
+/**
+ * VSCode terminal adapter implementation
+ */
+
+import { ITerminalAdapter, Terminal } from './base.ts';
+import { ILogger } from '../../core/logger.ts';
+import { TerminalError } from '../../utils/errors.ts';
+import { generateId, delay, timeout, createDeferred } from '../../utils/helpers.ts';
+
+/**
+ * VSCode API interface (injected via extension)
+ */
+interface VSCodeAPI {
+  window: {
+    createTerminal(options: {
+      name: string;
+      shellPath?: string;
+      shellArgs?: string[];
+      env?: Record<string, string>;
+    }): VSCodeTerminal;
+    onDidCloseTerminal(listener: (terminal: VSCodeTerminal) => void): { dispose(): void };
+  };
+}
+
+interface VSCodeTerminal {
+  name: string;
+  processId: Promise<number | undefined>;
+  sendText(text: string, addNewLine?: boolean): void;
+  show(preserveFocus?: boolean): void;
+  hide(): void;
+  dispose(): void;
+}
+
+/**
+ * VSCode terminal implementation
+ */
+class VSCodeTerminalWrapper implements Terminal {
+  id: string;
+  pid?: number;
+  private vscodeTerminal?: VSCodeTerminal;
+  private outputBuffer = '';
+  private commandMarker: string;
+  private outputDeferred = createDeferred<string>();
+  private isDisposed = false;
+
+  constructor(
+    private vscodeApi: VSCodeAPI,
+    private shellType: string,
+    private logger: ILogger,
+  ) {
+    this.id = generateId('vscode-term');
+    this.commandMarker = `__CLAUDE_FLOW_${this.id}__`;
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      // Create VSCode terminal
+      const shellPath = this.getShellPath();
+      const terminalOptions: any = {
+        name: `Claude-Flow Terminal ${this.id}`,
+        shellArgs: this.getShellArgs(),
+        env: {
+          CLAUDE_FLOW_TERMINAL: 'true',
+          CLAUDE_FLOW_TERMINAL_ID: this.id,
+          PS1: '$ ', // Simple prompt
+        },
+      };
+      if (shellPath !== undefined) {
+        terminalOptions.shellPath = shellPath;
+      }
+      this.vscodeTerminal = this.vscodeApi.window.createTerminal(terminalOptions);
+
+      // Get process ID
+      const processId = await this.vscodeTerminal.processId;
+      if (processId !== undefined) {
+        this.pid = processId;
+      }
+
+      // Show terminal (but don't steal focus)
+      this.vscodeTerminal.show(true);
+
+      // Wait for terminal to be ready
+      await this.waitForReady();
+
+      this.logger.debug('VSCode terminal initialized', { id: this.id, pid: this.pid });
+    } catch (error) {
+      throw new TerminalError('Failed to create VSCode terminal', { error });
+    }
+  }
+
+  async executeCommand(command: string): Promise<string> {
+    if (!this.vscodeTerminal || !this.isAlive()) {
+      throw new TerminalError('Terminal is not alive');
+    }
+
+    try {
+      // Clear output buffer
+      this.outputBuffer = '';
+      this.outputDeferred = createDeferred<string>();
+
+      // Send command with marker
+      const markedCommand = `${command} && echo "${this.commandMarker}"`;
+      this.vscodeTerminal.sendText(markedCommand, true);
+
+      // Wait for command to complete
+      const output = await timeout(
+        this.outputDeferred.promise,
+        30000,
+        'Command execution timeout',
+      );
+
+      return output;
+    } catch (error) {
+      throw new TerminalError('Failed to execute command', { command, error });
+    }
+  }
+
+  async write(data: string): Promise<void> {
+    if (!this.vscodeTerminal || !this.isAlive()) {
+      throw new TerminalError('Terminal is not alive');
+    }
+
+    this.vscodeTerminal.sendText(data, false);
+  }
+
+  async read(): Promise<string> {
+    if (!this.vscodeTerminal || !this.isAlive()) {
+      throw new TerminalError('Terminal is not alive');
+    }
+
+    // Return buffered output
+    const output = this.outputBuffer;
+    this.outputBuffer = '';
+    return output;
+  }
+
+  isAlive(): boolean {
+    return !this.isDisposed && this.vscodeTerminal !== undefined;
+  }
+
+  async kill(): Promise<void> {
+    if (this.vscodeTerminal && !this.isDisposed) {
+      try {
+        // Try graceful shutdown first
+        this.vscodeTerminal.sendText('exit', true);
+        await delay(500);
+
+        // Dispose terminal
+        this.vscodeTerminal.dispose();
+        this.isDisposed = true;
+      } catch (error) {
+        this.logger.warn('Error killing VSCode terminal', { id: this.id, error });
+      }
+    }
+  }
+
+  /**
+   * Process terminal output (called by extension)
+   */
+  processOutput(data: string): void {
+    this.outputBuffer += data;
+
+    // Check for command completion marker
+    const markerIndex = this.outputBuffer.indexOf(this.commandMarker);
+    if (markerIndex !== -1) {
+      // Extract output before marker
+      const output = this.outputBuffer.substring(0, markerIndex).trim();
+      
+      // Clear buffer up to after marker
+      this.outputBuffer = this.outputBuffer.substring(
+        markerIndex + this.commandMarker.length,
+      ).trim();
+
+      // Resolve pending command
+      this.outputDeferred.resolve(output);
+    }
+  }
+
+  private getShellPath(): string | undefined {
+    switch (this.shellType) {
+      case 'bash':
+        return '/bin/bash';
+      case 'zsh':
+        return '/bin/zsh';
+      case 'powershell':
+        return Deno.build.os === 'windows' ? 'powershell.exe' : 'pwsh';
+      case 'cmd':
+        return Deno.build.os === 'windows' ? 'cmd.exe' : undefined;
+      default:
+        return undefined;
+    }
+  }
+
+  private getShellArgs(): string[] {
+    switch (this.shellType) {
+      case 'bash':
+        return ['--norc', '--noprofile'];
+      case 'zsh':
+        return ['--no-rcs'];
+      case 'powershell':
+        return ['-NoProfile', '-NonInteractive'];
+      case 'cmd':
+        return ['/Q'];
+      default:
+        return [];
+    }
+  }
+
+  private async waitForReady(): Promise<void> {
+    // Send a test command to ensure terminal is ready
+    this.vscodeTerminal!.sendText('echo "READY"', true);
+    
+    const startTime = Date.now();
+    while (Date.now() - startTime < 5000) {
+      if (this.outputBuffer.includes('READY')) {
+        this.outputBuffer = '';
+        return;
+      }
+      await delay(100);
+    }
+    
+    throw new TerminalError('Terminal failed to become ready');
+  }
+}
+
+/**
+ * VSCode terminal adapter
+ */
+export class VSCodeAdapter implements ITerminalAdapter {
+  private terminals = new Map<string, VSCodeTerminalWrapper>();
+  private vscodeApi?: VSCodeAPI;
+  private shellType: string;
+  private terminalCloseListener?: { dispose(): void };
+
+  constructor(private logger: ILogger) {
+    this.shellType = this.detectShell();
+  }
+
+  async initialize(): Promise<void> {
+    this.logger.info('Initializing VSCode terminal adapter');
+    
+    // Check if running in VSCode extension context
+    if (!this.isVSCodeExtensionContext()) {
+      throw new TerminalError('Not running in VSCode extension context');
+    }
+
+    // Get VSCode API from global
+    this.vscodeApi = (globalThis as any).vscode;
+    if (!this.vscodeApi) {
+      throw new TerminalError('VSCode API not available');
+    }
+
+    // Register terminal close listener
+    this.terminalCloseListener = this.vscodeApi.window.onDidCloseTerminal((terminal) => {
+      // Find and clean up closed terminal
+      for (const [id, wrapper] of this.terminals.entries()) {
+        if ((wrapper as any).vscodeTerminal === terminal) {
+          this.logger.info('VSCode terminal closed', { id });
+          this.terminals.delete(id);
+          break;
+        }
+      }
+    });
+
+    this.logger.info('VSCode terminal adapter initialized');
+  }
+
+  async shutdown(): Promise<void> {
+    this.logger.info('Shutting down VSCode terminal adapter');
+    
+    // Dispose listener
+    if (this.terminalCloseListener) {
+      this.terminalCloseListener.dispose();
+    }
+
+    // Kill all terminals
+    const terminals = Array.from(this.terminals.values());
+    await Promise.all(terminals.map(term => term.kill()));
+    
+    this.terminals.clear();
+  }
+
+  async createTerminal(): Promise<Terminal> {
+    if (!this.vscodeApi) {
+      throw new TerminalError('VSCode API not initialized');
+    }
+
+    const terminal = new VSCodeTerminalWrapper(
+      this.vscodeApi,
+      this.shellType,
+      this.logger,
+    );
+    
+    await terminal.initialize();
+    this.terminals.set(terminal.id, terminal);
+    
+    // Register output processor if extension provides it
+    const outputProcessor = (globalThis as any).registerTerminalOutputProcessor;
+    if (outputProcessor) {
+      outputProcessor(terminal.id, (data: string) => terminal.processOutput(data));
+    }
+    
+    return terminal;
+  }
+
+  async destroyTerminal(terminal: Terminal): Promise<void> {
+    await terminal.kill();
+    this.terminals.delete(terminal.id);
+  }
+
+  private isVSCodeExtensionContext(): boolean {
+    // Check for VSCode extension environment
+    return typeof (globalThis as any).vscode !== 'undefined' &&
+           typeof (globalThis as any).vscode.window !== 'undefined';
+  }
+
+  private detectShell(): string {
+    // Get default shell from VSCode settings or environment
+    const platform = Deno.build.os;
+    
+    if (platform === 'windows') {
+      // Windows defaults
+      const comspec = Deno.env.get('COMSPEC');
+      if (comspec?.toLowerCase().includes('powershell')) {
+        return 'powershell';
+      }
+      return 'cmd';
+    } else {
+      // Unix-like defaults
+      const shell = Deno.env.get('SHELL');
+      if (shell) {
+        const shellName = shell.split('/').pop();
+        if (shellName && ['bash', 'zsh', 'fish', 'sh'].includes(shellName)) {
+          return shellName;
+        }
+      }
+      return 'bash';
+    }
+  }
+}

package/src/terminal/manager.ts

@@ -0,0 +1,308 @@
+/**
+ * Terminal manager interface and implementation
+ */
+
+import { AgentProfile, AgentSession, TerminalConfig } from '../utils/types.ts';
+import { IEventBus } from '../core/event-bus.ts';
+import { ILogger } from '../core/logger.ts';
+import { TerminalError, TerminalSpawnError } from '../utils/errors.ts';
+import { ITerminalAdapter } from './adapters/base.ts';
+import { VSCodeAdapter } from './adapters/vscode.ts';
+import { NativeAdapter } from './adapters/native.ts';
+import { TerminalPool } from './pool.ts';
+import { TerminalSession } from './session.ts';
+
+export interface ITerminalManager {
+  initialize(): Promise<void>;
+  shutdown(): Promise<void>;
+  spawnTerminal(profile: AgentProfile): Promise<string>;
+  terminateTerminal(terminalId: string): Promise<void>;
+  executeCommand(terminalId: string, command: string): Promise<string>;
+  getHealthStatus(): Promise<{ healthy: boolean; error?: string; metrics?: Record<string, number> }>;
+  performMaintenance(): Promise<void>;
+}
+
+/**
+ * Terminal manager implementation
+ */
+export class TerminalManager implements ITerminalManager {
+  private adapter: ITerminalAdapter;
+  private pool: TerminalPool;
+  private sessions = new Map<string, TerminalSession>();
+  private initialized = false;
+
+  constructor(
+    private config: TerminalConfig,
+    private eventBus: IEventBus,
+    private logger: ILogger,
+  ) {
+    // Select adapter based on configuration
+    this.adapter = this.createAdapter();
+    
+    // Create terminal pool
+    this.pool = new TerminalPool(
+      this.config.poolSize,
+      this.config.recycleAfter,
+      this.adapter,
+      this.logger,
+    );
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    this.logger.info('Initializing terminal manager...');
+
+    try {
+      // Initialize adapter
+      await this.adapter.initialize();
+
+      // Initialize pool
+      await this.pool.initialize();
+
+      this.initialized = true;
+      this.logger.info('Terminal manager initialized');
+    } catch (error) {
+      this.logger.error('Failed to initialize terminal manager', error);
+      throw new TerminalError('Terminal manager initialization failed', { error });
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    if (!this.initialized) {
+      return;
+    }
+
+    this.logger.info('Shutting down terminal manager...');
+
+    try {
+      // Terminate all sessions
+      const sessionIds = Array.from(this.sessions.keys());
+      await Promise.all(
+        sessionIds.map((id) => this.terminateTerminal(id)),
+      );
+
+      // Shutdown pool
+      await this.pool.shutdown();
+
+      // Shutdown adapter
+      await this.adapter.shutdown();
+
+      this.initialized = false;
+      this.logger.info('Terminal manager shutdown complete');
+    } catch (error) {
+      this.logger.error('Error during terminal manager shutdown', error);
+      throw error;
+    }
+  }
+
+  async spawnTerminal(profile: AgentProfile): Promise<string> {
+    if (!this.initialized) {
+      throw new TerminalError('Terminal manager not initialized');
+    }
+
+    this.logger.debug('Spawning terminal', { agentId: profile.id });
+
+    try {
+      // Get terminal from pool
+      const terminal = await this.pool.acquire();
+
+      // Create session
+      const session = new TerminalSession(
+        terminal,
+        profile,
+        this.config.commandTimeout,
+        this.logger,
+      );
+
+      // Initialize session
+      await session.initialize();
+
+      // Store session
+      this.sessions.set(session.id, session);
+
+      this.logger.info('Terminal spawned', { 
+        terminalId: session.id, 
+        agentId: profile.id,
+      });
+
+      return session.id;
+    } catch (error) {
+      this.logger.error('Failed to spawn terminal', error);
+      throw new TerminalSpawnError('Failed to spawn terminal', { error });
+    }
+  }
+
+  async terminateTerminal(terminalId: string): Promise<void> {
+    const session = this.sessions.get(terminalId);
+    if (!session) {
+      throw new TerminalError(`Terminal not found: ${terminalId}`);
+    }
+
+    this.logger.debug('Terminating terminal', { terminalId });
+
+    try {
+      // Cleanup session
+      await session.cleanup();
+
+      // Return terminal to pool
+      await this.pool.release(session.terminal);
+
+      // Remove session
+      this.sessions.delete(terminalId);
+
+      this.logger.info('Terminal terminated', { terminalId });
+    } catch (error) {
+      this.logger.error('Failed to terminate terminal', error);
+      throw error;
+    }
+  }
+
+  async executeCommand(terminalId: string, command: string): Promise<string> {
+    const session = this.sessions.get(terminalId);
+    if (!session) {
+      throw new TerminalError(`Terminal not found: ${terminalId}`);
+    }
+
+    return await session.executeCommand(command);
+  }
+
+  async getHealthStatus(): Promise<{ 
+    healthy: boolean; 
+    error?: string; 
+    metrics?: Record<string, number>;
+  }> {
+    try {
+      const poolHealth = await this.pool.getHealthStatus();
+      const activeSessions = this.sessions.size;
+      const healthySessions = Array.from(this.sessions.values())
+        .filter((session) => session.isHealthy()).length;
+
+      const metrics = {
+        activeSessions,
+        healthySessions,
+        poolSize: poolHealth.size,
+        availableTerminals: poolHealth.available,
+        recycledTerminals: poolHealth.recycled,
+      };
+
+      const healthy = poolHealth.healthy && healthySessions === activeSessions;
+
+      if (healthy) {
+        return {
+          healthy,
+          metrics,
+        };
+      } else {
+        return {
+          healthy,
+          metrics,
+          error: 'Some terminals are unhealthy',
+        };
+      }
+    } catch (error) {
+      return {
+        healthy: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  async performMaintenance(): Promise<void> {
+    if (!this.initialized) {
+      return;
+    }
+
+    this.logger.debug('Performing terminal manager maintenance');
+
+    try {
+      // Clean up dead sessions
+      const deadSessions = Array.from(this.sessions.entries())
+        .filter(([_, session]) => !session.isHealthy());
+
+      for (const [terminalId, _] of deadSessions) {
+        this.logger.warn('Cleaning up dead terminal session', { terminalId });
+        await this.terminateTerminal(terminalId).catch(error => 
+          this.logger.error('Failed to clean up terminal', { terminalId, error })
+        );
+      }
+
+      // Perform pool maintenance
+      await this.pool.performMaintenance();
+
+      // Emit maintenance event
+      this.eventBus.emit('terminal:maintenance', {
+        deadSessions: deadSessions.length,
+        activeSessions: this.sessions.size,
+        poolStatus: await this.pool.getHealthStatus(),
+      });
+
+      this.logger.debug('Terminal manager maintenance completed');
+    } catch (error) {
+      this.logger.error('Error during terminal manager maintenance', error);
+    }
+  }
+
+  /**
+   * Get all active sessions
+   */
+  getActiveSessions(): AgentSession[] {
+    return Array.from(this.sessions.values()).map(session => ({
+      id: session.id,
+      agentId: session.profile.id,
+      terminalId: session.terminal.id,
+      startTime: session.startTime,
+      status: session.isHealthy() ? 'active' : 'error',
+      lastActivity: session.lastActivity,
+      memoryBankId: '', // TODO: Link to memory bank
+    }));
+  }
+
+  /**
+   * Get session by ID
+   */
+  getSession(sessionId: string): TerminalSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  /**
+   * Stream terminal output
+   */
+  async streamOutput(terminalId: string, callback: (output: string) => void): Promise<() => void> {
+    const session = this.sessions.get(terminalId);
+    if (!session) {
+      throw new TerminalError(`Terminal not found: ${terminalId}`);
+    }
+
+    return session.streamOutput(callback);
+  }
+
+  private createAdapter(): ITerminalAdapter {
+    switch (this.config.type) {
+      case 'vscode':
+        return new VSCodeAdapter(this.logger);
+      case 'native':
+        return new NativeAdapter(this.logger);
+      case 'auto':
+        // Detect environment and choose appropriate adapter
+        if (this.isVSCodeEnvironment()) {
+          this.logger.info('Detected VSCode environment, using VSCode adapter');
+          return new VSCodeAdapter(this.logger);
+        } else {
+          this.logger.info('Using native terminal adapter');
+          return new NativeAdapter(this.logger);
+        }
+      default:
+        throw new TerminalError(`Unknown terminal type: ${this.config.type}`);
+    }
+  }
+
+  private isVSCodeEnvironment(): boolean {
+    // Check for VSCode-specific environment variables
+    return Deno.env.get('TERM_PROGRAM') === 'vscode' ||
+           Deno.env.get('VSCODE_PID') !== undefined ||
+           Deno.env.get('VSCODE_IPC_HOOK') !== undefined;
+  }
+}