claude-flow 1.0.0

package/src/terminal/pool.ts

@@ -0,0 +1,271 @@
+/**
+ * Terminal pool management
+ */
+
+import { Terminal, ITerminalAdapter } from './adapters/base.ts';
+import { ILogger } from '../core/logger.ts';
+import { TerminalError } from '../utils/errors.ts';
+import { delay } from '../utils/helpers.ts';
+
+interface PooledTerminal {
+  terminal: Terminal;
+  useCount: number;
+  lastUsed: Date;
+  inUse: boolean;
+}
+
+/**
+ * Terminal pool for efficient resource management
+ */
+export class TerminalPool {
+  private terminals = new Map<string, PooledTerminal>();
+  private availableQueue: string[] = [];
+  private initializationPromise?: Promise<void>;
+
+  constructor(
+    private maxSize: number,
+    private recycleAfter: number,
+    private adapter: ITerminalAdapter,
+    private logger: ILogger,
+  ) {}
+
+  async initialize(): Promise<void> {
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+
+    this.initializationPromise = this.doInitialize();
+    return this.initializationPromise;
+  }
+
+  private async doInitialize(): Promise<void> {
+    this.logger.info('Initializing terminal pool', { 
+      maxSize: this.maxSize,
+      recycleAfter: this.recycleAfter,
+    });
+
+    // Pre-create some terminals
+    const preCreateCount = Math.min(2, this.maxSize);
+    const promises: Promise<void>[] = [];
+
+    for (let i = 0; i < preCreateCount; i++) {
+      promises.push(this.createPooledTerminal());
+    }
+
+    await Promise.all(promises);
+    
+    this.logger.info('Terminal pool initialized', { 
+      created: preCreateCount,
+    });
+  }
+
+  async shutdown(): Promise<void> {
+    this.logger.info('Shutting down terminal pool');
+
+    // Destroy all terminals
+    const terminals = Array.from(this.terminals.values());
+    await Promise.all(
+      terminals.map(({ terminal }) => this.adapter.destroyTerminal(terminal)),
+    );
+
+    this.terminals.clear();
+    this.availableQueue = [];
+  }
+
+  async acquire(): Promise<Terminal> {
+    // Try to get an available terminal
+    while (this.availableQueue.length > 0) {
+      const terminalId = this.availableQueue.shift()!;
+      const pooled = this.terminals.get(terminalId);
+
+      if (pooled && pooled.terminal.isAlive()) {
+        pooled.inUse = true;
+        pooled.lastUsed = new Date();
+        
+        this.logger.debug('Terminal acquired from pool', { 
+          terminalId,
+          useCount: pooled.useCount,
+        });
+
+        return pooled.terminal;
+      }
+
+      // Terminal is dead, remove it
+      if (pooled) {
+        this.terminals.delete(terminalId);
+      }
+    }
+
+    // No available terminals, create new one if under limit
+    if (this.terminals.size < this.maxSize) {
+      await this.createPooledTerminal();
+      return this.acquire(); // Recursive call to get the newly created terminal
+    }
+
+    // Pool is full, wait for a terminal to become available
+    this.logger.info('Terminal pool full, waiting for available terminal');
+    
+    const startTime = Date.now();
+    const timeout = 30000; // 30 seconds
+
+    while (Date.now() - startTime < timeout) {
+      await delay(100);
+
+      // Check if any terminal became available
+      const available = Array.from(this.terminals.values()).find(
+        (pooled) => !pooled.inUse && pooled.terminal.isAlive(),
+      );
+
+      if (available) {
+        available.inUse = true;
+        available.lastUsed = new Date();
+        return available.terminal;
+      }
+    }
+
+    throw new TerminalError('No terminal available in pool (timeout)');
+  }
+
+  async release(terminal: Terminal): Promise<void> {
+    const pooled = this.terminals.get(terminal.id);
+    if (!pooled) {
+      this.logger.warn('Attempted to release unknown terminal', { 
+        terminalId: terminal.id,
+      });
+      return;
+    }
+
+    pooled.useCount++;
+    pooled.inUse = false;
+
+    // Check if terminal should be recycled
+    if (pooled.useCount >= this.recycleAfter || !terminal.isAlive()) {
+      this.logger.info('Recycling terminal', { 
+        terminalId: terminal.id,
+        useCount: pooled.useCount,
+      });
+
+      // Destroy old terminal
+      this.terminals.delete(terminal.id);
+      await this.adapter.destroyTerminal(terminal);
+
+      // Create replacement if under limit
+      if (this.terminals.size < this.maxSize) {
+        await this.createPooledTerminal();
+      }
+    } else {
+      // Return to available queue
+      this.availableQueue.push(terminal.id);
+      
+      this.logger.debug('Terminal returned to pool', { 
+        terminalId: terminal.id,
+        useCount: pooled.useCount,
+      });
+    }
+  }
+
+  async getHealthStatus(): Promise<{
+    healthy: boolean;
+    size: number;
+    available: number;
+    recycled: number;
+  }> {
+    const aliveTerminals = Array.from(this.terminals.values()).filter(
+      (pooled) => pooled.terminal.isAlive(),
+    );
+
+    const available = aliveTerminals.filter((pooled) => !pooled.inUse).length;
+    const recycled = Array.from(this.terminals.values()).filter(
+      (pooled) => pooled.useCount >= this.recycleAfter,
+    ).length;
+
+    return {
+      healthy: aliveTerminals.length > 0,
+      size: this.terminals.size,
+      available,
+      recycled,
+    };
+  }
+
+  async performMaintenance(): Promise<void> {
+    this.logger.debug('Performing terminal pool maintenance');
+
+    // Remove dead terminals
+    const deadTerminals: string[] = [];
+    for (const [id, pooled] of this.terminals.entries()) {
+      if (!pooled.terminal.isAlive()) {
+        deadTerminals.push(id);
+      }
+    }
+
+    // Clean up dead terminals
+    for (const id of deadTerminals) {
+      this.logger.warn('Removing dead terminal from pool', { terminalId: id });
+      this.terminals.delete(id);
+      const index = this.availableQueue.indexOf(id);
+      if (index !== -1) {
+        this.availableQueue.splice(index, 1);
+      }
+    }
+
+    // Ensure minimum pool size
+    const currentSize = this.terminals.size;
+    const minSize = Math.min(2, this.maxSize);
+    
+    if (currentSize < minSize) {
+      const toCreate = minSize - currentSize;
+      this.logger.info('Replenishing terminal pool', { 
+        currentSize, 
+        minSize, 
+        creating: toCreate,
+      });
+
+      const promises: Promise<void>[] = [];
+      for (let i = 0; i < toCreate; i++) {
+        promises.push(this.createPooledTerminal());
+      }
+      
+      await Promise.all(promises);
+    }
+
+    // Check for stale terminals that should be recycled
+    const now = Date.now();
+    const staleTimeout = 300000; // 5 minutes
+    
+    for (const [id, pooled] of this.terminals.entries()) {
+      if (!pooled.inUse && pooled.terminal.isAlive()) {
+        const idleTime = now - pooled.lastUsed.getTime();
+        if (idleTime > staleTimeout) {
+          this.logger.info('Recycling stale terminal', { 
+            terminalId: id, 
+            idleTime,
+          });
+          
+          // Mark for recycling
+          pooled.useCount = this.recycleAfter;
+        }
+      }
+    }
+  }
+
+  private async createPooledTerminal(): Promise<void> {
+    try {
+      const terminal = await this.adapter.createTerminal();
+      
+      const pooled: PooledTerminal = {
+        terminal,
+        useCount: 0,
+        lastUsed: new Date(),
+        inUse: false,
+      };
+
+      this.terminals.set(terminal.id, pooled);
+      this.availableQueue.push(terminal.id);
+
+      this.logger.debug('Created pooled terminal', { terminalId: terminal.id });
+    } catch (error) {
+      this.logger.error('Failed to create pooled terminal', error);
+      throw error;
+    }
+  }
+}

package/src/terminal/session.ts

@@ -0,0 +1,250 @@
+/**
+ * Terminal session management
+ */
+
+import { Terminal } from './adapters/base.ts';
+import { AgentProfile } from '../utils/types.ts';
+import { ILogger } from '../core/logger.ts';
+import { TerminalCommandError } from '../utils/errors.ts';
+import { generateId, timeout } from '../utils/helpers.ts';
+
+/**
+ * Terminal session wrapper
+ */
+export class TerminalSession {
+  readonly id: string;
+  readonly startTime: Date;
+  private initialized = false;
+  private commandHistory: string[] = [];
+  private lastCommandTime?: Date;
+  private outputListeners = new Set<(output: string) => void>();
+
+  constructor(
+    public readonly terminal: Terminal,
+    public readonly profile: AgentProfile,
+    private commandTimeout: number,
+    private logger: ILogger,
+  ) {
+    this.id = generateId('session');
+    this.startTime = new Date();
+  }
+
+  get lastActivity(): Date {
+    return this.lastCommandTime || this.startTime;
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    this.logger.debug('Initializing terminal session', { 
+      sessionId: this.id,
+      agentId: this.profile.id,
+    });
+
+    try {
+      // Set up environment
+      await this.setupEnvironment();
+
+      // Run initialization commands
+      await this.runInitializationCommands();
+
+      this.initialized = true;
+      
+      this.logger.info('Terminal session initialized', { 
+        sessionId: this.id,
+        agentId: this.profile.id,
+      });
+    } catch (error) {
+      this.logger.error('Failed to initialize terminal session', error);
+      throw error;
+    }
+  }
+
+  async executeCommand(command: string): Promise<string> {
+    if (!this.initialized) {
+      throw new TerminalCommandError('Session not initialized');
+    }
+
+    if (!this.terminal.isAlive()) {
+      throw new TerminalCommandError('Terminal is not alive');
+    }
+
+    this.logger.debug('Executing command', { 
+      sessionId: this.id,
+      command: command.substring(0, 100),
+    });
+
+    try {
+      // Notify listeners of command
+      this.notifyOutputListeners(`$ ${command}\n`);
+
+      // Execute with timeout
+      const result = await timeout(
+        this.terminal.executeCommand(command),
+        this.commandTimeout,
+        `Command timeout after ${this.commandTimeout}ms`,
+      );
+
+      // Notify listeners of output
+      this.notifyOutputListeners(result);
+
+      // Update history
+      this.commandHistory.push(command);
+      this.lastCommandTime = new Date();
+
+      this.logger.debug('Command executed successfully', { 
+        sessionId: this.id,
+        outputLength: result.length,
+      });
+
+      return result;
+    } catch (error) {
+      this.logger.error('Command execution failed', { 
+        sessionId: this.id,
+        command,
+        error,
+      });
+      throw new TerminalCommandError('Command execution failed', { 
+        command,
+        error,
+      });
+    }
+  }
+
+  async cleanup(): Promise<void> {
+    this.logger.debug('Cleaning up terminal session', { sessionId: this.id });
+
+    try {
+      // Run cleanup commands
+      await this.runCleanupCommands();
+    } catch (error) {
+      this.logger.warn('Error during session cleanup', { 
+        sessionId: this.id,
+        error,
+      });
+    }
+  }
+
+  isHealthy(): boolean {
+    if (!this.terminal.isAlive()) {
+      return false;
+    }
+
+    // Check if terminal is responsive
+    if (this.lastCommandTime) {
+      const timeSinceLastCommand = Date.now() - this.lastCommandTime.getTime();
+      if (timeSinceLastCommand > 300000) { // 5 minutes
+        // Terminal might be stale, do a health check
+        this.performHealthCheck().catch((error) => {
+          this.logger.warn('Health check failed', { sessionId: this.id, error });
+        });
+      }
+    }
+
+    return true;
+  }
+
+  getCommandHistory(): string[] {
+    return [...this.commandHistory];
+  }
+
+  private async setupEnvironment(): Promise<void> {
+    // Set environment variables
+    const envVars = {
+      CLAUDE_FLOW_SESSION: this.id,
+      CLAUDE_FLOW_AGENT: this.profile.id,
+      CLAUDE_FLOW_AGENT_TYPE: this.profile.type,
+    };
+
+    for (const [key, value] of Object.entries(envVars)) {
+      await this.terminal.executeCommand(`export ${key}="${value}"`);
+    }
+
+    // Set working directory if specified
+    if (this.profile.metadata?.workingDirectory) {
+      await this.terminal.executeCommand(
+        `cd "${this.profile.metadata.workingDirectory}"`,
+      );
+    }
+  }
+
+  private async runInitializationCommands(): Promise<void> {
+    // Run any profile-specific initialization commands
+    if (this.profile.metadata?.initCommands) {
+      const commands = this.profile.metadata.initCommands as string[];
+      for (const command of commands) {
+        await this.terminal.executeCommand(command);
+      }
+    }
+
+    // Set up command prompt
+    await this.terminal.executeCommand('export PS1="[claude-flow]$ "');
+  }
+
+  private async runCleanupCommands(): Promise<void> {
+    // Run any profile-specific cleanup commands
+    if (this.profile.metadata?.cleanupCommands) {
+      const commands = this.profile.metadata.cleanupCommands as string[];
+      for (const command of commands) {
+        try {
+          await this.terminal.executeCommand(command);
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    }
+  }
+
+  private async performHealthCheck(): Promise<void> {
+    try {
+      const result = await timeout(
+        this.terminal.executeCommand('echo "HEALTH_CHECK_OK"'),
+        5000,
+        'Health check timeout',
+      );
+
+      if (!result.includes('HEALTH_CHECK_OK')) {
+        throw new Error('Invalid health check response');
+      }
+
+      this.lastCommandTime = new Date();
+    } catch (error) {
+      throw new Error(`Health check failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Stream terminal output
+   */
+  streamOutput(callback: (output: string) => void): () => void {
+    this.outputListeners.add(callback);
+    
+    // Set up terminal output listener if supported
+    if (this.terminal.addOutputListener) {
+      this.terminal.addOutputListener(callback);
+    }
+    
+    // Return unsubscribe function
+    return () => {
+      this.outputListeners.delete(callback);
+      if (this.terminal.removeOutputListener) {
+        this.terminal.removeOutputListener(callback);
+      }
+    };
+  }
+
+  /**
+   * Notify output listeners
+   */
+  private notifyOutputListeners(output: string): void {
+    this.outputListeners.forEach(listener => {
+      try {
+        listener(output);
+      } catch (error) {
+        this.logger.error('Error in output listener', { sessionId: this.id, error });
+      }
+    });
+  }
+}