qa360 2.1.2 → 2.1.4

package/core/src/hooks/compose.ts

@@ -0,0 +1,268 @@
+/**
+ * QA360 Docker Compose Helper
+ * Safe Docker Compose operations with health checks and error handling
+ */
+
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+
+export interface ComposeOptions {
+  workingDir: string;
+  composeFile?: string;
+}
+
+export interface ComposeError extends Error {
+  code: string;
+  suggestion: string;
+}
+
+export class ComposeHelper {
+  private workingDir: string;
+  private composeFile: string;
+  private isUp: boolean = false;
+
+  constructor(options: ComposeOptions) {
+    this.workingDir = options.workingDir;
+    this.composeFile = options.composeFile || 'services.yml';
+  }
+
+  /**
+   * Start services with Docker Compose
+   */
+  async up(timeout: number = 120000): Promise<void> {
+    // Idempotence check
+    if (this.isUp) {
+      console.log(chalk.yellow('    ⚠️  Services already up, skipping'));
+      return;
+    }
+
+    const composeFilePath = join(this.workingDir, this.composeFile);
+    
+    // Validate compose file exists
+    if (!existsSync(composeFilePath)) {
+      const error = new Error(`Compose file not found: ${composeFilePath}`) as ComposeError;
+      error.code = 'QH001';
+      error.suggestion = `Create ${this.composeFile} in project root or set hooks.compose_file in pack.yml`;
+      throw error;
+    }
+
+    try {
+      // Check if Docker is available
+      await this.checkDockerAvailable();
+      
+      // Execute compose up
+      const result = await this.executeCompose(['up', '-d'], timeout);
+      
+      if (result.success) {
+        this.isUp = true;
+        console.log(chalk.green('    🐳 Services started successfully'));
+      } else {
+        const error = new Error(`Compose up failed: ${result.error}`) as ComposeError;
+        error.code = 'QH002';
+        error.suggestion = 'Check Docker daemon is running and compose file syntax is valid';
+        throw error;
+      }
+    } catch (error) {
+      if (error instanceof Error && 'code' in error) {
+        throw error;
+      }
+      
+      const composeError = new Error(`Compose operation failed: ${error}`) as ComposeError;
+      composeError.code = 'QH003';
+      composeError.suggestion = 'Verify Docker installation and compose file configuration';
+      throw composeError;
+    }
+  }
+
+  /**
+   * Stop and remove services
+   */
+  async down(timeout: number = 60000): Promise<void> {
+    try {
+      const result = await this.executeCompose(['down', '-v'], timeout);
+      
+      if (result.success) {
+        this.isUp = false;
+        console.log(chalk.green('    🐳 Services stopped and cleaned up'));
+      } else {
+        console.log(chalk.yellow(`    ⚠️  Compose down completed with warnings: ${result.error}`));
+        this.isUp = false; // Consider it down even if there were warnings
+      }
+    } catch (error) {
+      // Don't throw on down errors - just log and continue
+      console.log(chalk.yellow(`    ⚠️  Compose down error (continuing): ${error}`));
+      this.isUp = false;
+    }
+  }
+
+  /**
+   * Get service status
+   */
+  async getStatus(): Promise<{ service: string; status: string; ports: string[] }[]> {
+    try {
+      const result = await this.executeCompose(['ps', '--format', 'json'], 10000);
+      
+      if (result.success && result.output) {
+        const services = result.output
+          .split('\n')
+          .filter(line => line.trim())
+          .map(line => {
+            try {
+              const service = JSON.parse(line);
+              return {
+                service: service.Name || service.Service || 'unknown',
+                status: service.State || service.Status || 'unknown',
+                ports: service.Ports ? service.Ports.split(',').map((p: string) => p.trim()) : []
+              };
+            } catch {
+              return null;
+            }
+          })
+          .filter((service): service is { service: string; status: string; ports: string[] } => service !== null);
+        
+        return services;
+      }
+    } catch (error) {
+      console.log(chalk.yellow(`    ⚠️  Could not get service status: ${error}`));
+    }
+    
+    return [];
+  }
+
+  /**
+   * Check if Docker is available
+   */
+  private async checkDockerAvailable(): Promise<void> {
+    try {
+      const result = await this.executeCommand('docker --version', 5000);
+      if (!result.success) {
+        const error = new Error('Docker not available') as ComposeError;
+        error.code = 'QH004';
+        error.suggestion = 'Install Docker Desktop or Docker Engine';
+        throw error;
+      }
+    } catch (error) {
+      const dockerError = new Error('Docker daemon not running') as ComposeError;
+      dockerError.code = 'QH005';
+      dockerError.suggestion = 'Start Docker Desktop or Docker daemon service';
+      throw dockerError;
+    }
+  }
+
+  /**
+   * Execute Docker Compose command
+   */
+  private async executeCompose(args: string[], timeout: number): Promise<{
+    success: boolean;
+    output: string;
+    error?: string;
+  }> {
+    const composeFilePath = join(this.workingDir, this.composeFile);
+    const command = `docker compose -f "${composeFilePath}" ${args.join(' ')}`;
+    
+    return this.executeCommand(command, timeout);
+  }
+
+  /**
+   * Execute shell command with timeout
+   */
+  private async executeCommand(command: string, timeout: number): Promise<{
+    success: boolean;
+    output: string;
+    error?: string;
+  }> {
+    return new Promise((resolve) => {
+      let output = '';
+      let error = '';
+      
+      const child = spawn(command, [], {
+        cwd: this.workingDir,
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      
+      const timer = setTimeout(() => {
+        child.kill('SIGKILL');
+        resolve({
+          success: false,
+          output,
+          error: `Command timed out after ${timeout}ms`
+        });
+      }, timeout);
+      
+      if (child.stdout) {
+        child.stdout.on('data', (data) => {
+          output += data.toString();
+        });
+      }
+      
+      if (child.stderr) {
+        child.stderr.on('data', (data) => {
+          error += data.toString();
+        });
+      }
+      
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        resolve({
+          success: code === 0,
+          output,
+          error: error || undefined
+        });
+      });
+      
+      child.on('error', (err) => {
+        clearTimeout(timer);
+        resolve({
+          success: false,
+          output,
+          error: err.message
+        });
+      });
+    });
+  }
+
+  /**
+   * Validate compose file syntax
+   */
+  async validateComposeFile(): Promise<{ valid: boolean; errors: string[] }> {
+    const errors: string[] = [];
+    const composeFilePath = join(this.workingDir, this.composeFile);
+    
+    if (!existsSync(composeFilePath)) {
+      errors.push(`Compose file not found: ${composeFilePath}`);
+      return { valid: false, errors };
+    }
+
+    try {
+      const result = await this.executeCompose(['config', '--quiet'], 10000);
+      
+      if (!result.success) {
+        errors.push(`Compose file validation failed: ${result.error}`);
+      }
+    } catch (error) {
+      errors.push(`Could not validate compose file: ${error}`);
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Get compose file path
+   */
+  getComposeFilePath(): string {
+    return join(this.workingDir, this.composeFile);
+  }
+
+  /**
+   * Check if services are currently up
+   */
+  isServicesUp(): boolean {
+    return this.isUp;
+  }
+}

package/core/src/hooks/runner.ts

@@ -0,0 +1,364 @@
+/**
+ * QA360 Hooks Runner
+ * Executes declarative hooks with timeouts, failure handling, and security
+ */
+
+import { spawn, SpawnOptions } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { HookAction, PackHooks, PackExecution } from '../types/pack-v1.js';
+import { SecurityRedactor } from '../security/redactor.js';
+import { ComposeHelper } from './compose.js';
+
+export interface HookExecutionResult {
+  success: boolean;
+  duration: number;
+  output: string;
+  error?: string;
+  code?: number;
+}
+
+export interface HookRunnerOptions {
+  workingDir: string;
+  hooks: PackHooks;
+  execution?: PackExecution;
+  redactor?: SecurityRedactor;
+}
+
+export class HooksRunner {
+  private workingDir: string;
+  private hooks: PackHooks;
+  private execution: PackExecution;
+  private redactor: SecurityRedactor;
+  private composeHelper: ComposeHelper;
+
+  constructor(options: HookRunnerOptions) {
+    this.workingDir = options.workingDir;
+    this.hooks = options.hooks;
+    this.execution = options.execution || {};
+    this.redactor = options.redactor || SecurityRedactor.forLogs();
+    this.composeHelper = new ComposeHelper({
+      workingDir: this.workingDir,
+      composeFile: this.execution.compose_file || 'services.yml'
+    });
+  }
+
+  /**
+   * Execute hooks for a specific lifecycle phase
+   */
+  async executeHooks(phase: keyof PackHooks): Promise<HookExecutionResult[]> {
+    const hooks = this.hooks[phase];
+    if (!hooks || hooks.length === 0) {
+      return [];
+    }
+
+    console.log(chalk.blue(`🔗 Executing ${phase} hooks (${hooks.length} actions)`));
+    
+    const results: HookExecutionResult[] = [];
+    
+    for (let i = 0; i < hooks.length; i++) {
+      const hook = hooks[i];
+      const startTime = Date.now();
+      
+      try {
+        console.log(chalk.gray(`  ${i + 1}/${hooks.length} ${this.getHookDescription(hook)}`));
+        
+        const result = await this.executeHook(hook);
+        const duration = Date.now() - startTime;
+        
+        const hookResult: HookExecutionResult = {
+          success: result.success,
+          duration,
+          output: this.redactor.redact(result.output),
+          error: result.error ? this.redactor.redact(result.error) : undefined,
+          code: result.code
+        };
+        
+        results.push(hookResult);
+        
+        if (result.success) {
+          console.log(chalk.green(`    ✅ Completed in ${duration}ms`));
+        } else {
+          console.log(chalk.red(`    ❌ Failed after ${duration}ms (exit ${result.code})`));
+          
+          if (this.execution.on_failure === 'stop') {
+            console.log(chalk.yellow(`    🛑 Stopping execution (on_failure: stop)`));
+            break;
+          } else {
+            console.log(chalk.yellow(`    ⚠️  Continuing execution (on_failure: continue)`));
+          }
+        }
+        
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        
+        console.log(chalk.red(`    💥 Hook failed: ${errorMessage}`));
+        
+        results.push({
+          success: false,
+          duration,
+          output: '',
+          error: this.redactor.redact(errorMessage)
+        });
+        
+        if (this.execution.on_failure === 'stop') {
+          break;
+        }
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Execute a single hook action
+   */
+  private async executeHook(hook: HookAction): Promise<HookExecutionResult> {
+    const timeout = hook.timeout || this.execution.hook_timeout_ms || 180000; // 3 minutes default
+    
+    if ('run' in hook) {
+      return this.executeCommand(hook.run, timeout);
+    } else if ('compose' in hook) {
+      return this.executeCompose(hook.compose, timeout);
+    } else if ('wait_on' in hook) {
+      return this.executeWaitOn(hook.wait_on, timeout, hook.method || 'http');
+    } else {
+      throw new Error('Unknown hook action type');
+    }
+  }
+
+  /**
+   * Execute a shell command
+   */
+  private async executeCommand(command: string, timeout: number): Promise<HookExecutionResult> {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      let output = '';
+      let error = '';
+      
+      const options: SpawnOptions = {
+        cwd: this.workingDir,
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe']
+      };
+      
+      const child = spawn(command, [], options);
+      
+      // Timeout handler
+      const timer = setTimeout(() => {
+        child.kill('SIGKILL');
+        resolve({
+          success: false,
+          duration: Date.now() - startTime,
+          output,
+          error: `Command timed out after ${timeout}ms`,
+          code: -1
+        });
+      }, timeout);
+      
+      // Collect output
+      if (child.stdout) {
+        child.stdout.on('data', (data) => {
+          output += data.toString();
+        });
+      }
+      
+      if (child.stderr) {
+        child.stderr.on('data', (data) => {
+          error += data.toString();
+        });
+      }
+      
+      // Handle completion
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        resolve({
+          success: code === 0,
+          duration: Date.now() - startTime,
+          output,
+          error: error || undefined,
+          code: code || 0
+        });
+      });
+      
+      child.on('error', (err) => {
+        clearTimeout(timer);
+        resolve({
+          success: false,
+          duration: Date.now() - startTime,
+          output,
+          error: err.message,
+          code: -1
+        });
+      });
+    });
+  }
+
+  /**
+   * Execute Docker Compose command
+   */
+  private async executeCompose(action: 'up' | 'down', timeout: number): Promise<HookExecutionResult> {
+    const startTime = Date.now();
+    
+    try {
+      if (action === 'up') {
+        await this.composeHelper.up(timeout);
+      } else {
+        await this.composeHelper.down(timeout);
+      }
+      
+      return {
+        success: true,
+        duration: Date.now() - startTime,
+        output: `Docker Compose ${action} completed successfully`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        duration: Date.now() - startTime,
+        output: '',
+        error: error instanceof Error ? error.message : 'Compose command failed'
+      };
+    }
+  }
+
+  /**
+   * Execute wait-on for service readiness
+   */
+  private async executeWaitOn(target: string, timeout: number, method: 'http' | 'tcp'): Promise<HookExecutionResult> {
+    const startTime = Date.now();
+    
+    try {
+      if (method === 'http') {
+        await this.waitForHttp(target, timeout);
+      } else {
+        await this.waitForTcp(target, timeout);
+      }
+      
+      return {
+        success: true,
+        duration: Date.now() - startTime,
+        output: `Service ${target} is ready (${method})`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        duration: Date.now() - startTime,
+        output: '',
+        error: error instanceof Error ? error.message : 'Wait-on failed'
+      };
+    }
+  }
+
+  /**
+   * Wait for HTTP endpoint to be ready
+   */
+  private async waitForHttp(url: string, timeout: number): Promise<void> {
+    const startTime = Date.now();
+    const interval = 1000; // Check every second
+    
+    while (Date.now() - startTime < timeout) {
+      try {
+        const response = await fetch(url, { 
+          method: 'GET',
+          signal: AbortSignal.timeout(5000) // 5s per request
+        });
+        
+        if (response.ok) {
+          return; // Success
+        }
+      } catch (error) {
+        // Continue waiting
+      }
+      
+      await new Promise(resolve => setTimeout(resolve, interval));
+    }
+    
+    throw new Error(`HTTP endpoint ${url} not ready after ${timeout}ms`);
+  }
+
+  /**
+   * Wait for TCP port to be ready
+   */
+  private async waitForTcp(target: string, timeout: number): Promise<void> {
+    const [host, portStr] = target.split(':');
+    const port = parseInt(portStr, 10);
+    
+    if (!host || !port) {
+      throw new Error(`Invalid TCP target format: ${target} (expected host:port)`);
+    }
+    
+    const startTime = Date.now();
+    const interval = 1000;
+    
+    while (Date.now() - startTime < timeout) {
+      try {
+        const net = await import('net');
+        const socket = new net.Socket();
+        
+        await new Promise<void>((resolve, reject) => {
+          socket.setTimeout(2000);
+          socket.on('connect', () => {
+            socket.destroy();
+            resolve();
+          });
+          socket.on('timeout', () => {
+            socket.destroy();
+            reject(new Error('Connection timeout'));
+          });
+          socket.on('error', reject);
+          socket.connect(port, host);
+        });
+        
+        return; // Success
+      } catch (error) {
+        // Continue waiting
+      }
+      
+      await new Promise(resolve => setTimeout(resolve, interval));
+    }
+    
+    throw new Error(`TCP port ${target} not ready after ${timeout}ms`);
+  }
+
+  /**
+   * Get human-readable description of hook action
+   */
+  private getHookDescription(hook: HookAction): string {
+    if ('run' in hook) {
+      return `Run: ${hook.run.substring(0, 50)}${hook.run.length > 50 ? '...' : ''}`;
+    } else if ('compose' in hook) {
+      return `Compose: ${hook.compose}`;
+    } else if ('wait_on' in hook) {
+      return `Wait-on: ${hook.wait_on} (${hook.method || 'http'})`;
+    }
+    return 'Unknown action';
+  }
+
+  /**
+   * Execute all lifecycle hooks in order
+   */
+  async executeLifecycle(): Promise<{
+    beforeAll: HookExecutionResult[];
+    beforeEach: HookExecutionResult[];
+    afterEach: HookExecutionResult[];
+    afterAll: HookExecutionResult[];
+  }> {
+    const results = {
+      beforeAll: await this.executeHooks('beforeAll'),
+      beforeEach: await this.executeHooks('beforeEach'),
+      afterEach: await this.executeHooks('afterEach'),
+      afterAll: await this.executeHooks('afterAll')
+    };
+
+    // Summary
+    const totalHooks = Object.values(results).flat().length;
+    const successfulHooks = Object.values(results).flat().filter(r => r.success).length;
+    
+    console.log(chalk.blue(`\n🔗 Hooks Summary: ${successfulHooks}/${totalHooks} successful`));
+    
+    return results;
+  }
+}