qa360 2.1.2 → 2.1.4

package/dist/core/hooks/compose.d.ts

@@ -1,61 +0,0 @@
-/**
- * QA360 Docker Compose Helper
- * Safe Docker Compose operations with health checks and error handling
- */
-export interface ComposeOptions {
-    workingDir: string;
-    composeFile?: string;
-}
-export interface ComposeError extends Error {
-    code: string;
-    suggestion: string;
-}
-export declare class ComposeHelper {
-    private workingDir;
-    private composeFile;
-    private isUp;
-    constructor(options: ComposeOptions);
-    /**
-     * Start services with Docker Compose
-     */
-    up(timeout?: number): Promise<void>;
-    /**
-     * Stop and remove services
-     */
-    down(timeout?: number): Promise<void>;
-    /**
-     * Get service status
-     */
-    getStatus(): Promise<{
-        service: string;
-        status: string;
-        ports: string[];
-    }[]>;
-    /**
-     * Check if Docker is available
-     */
-    private checkDockerAvailable;
-    /**
-     * Execute Docker Compose command
-     */
-    private executeCompose;
-    /**
-     * Execute shell command with timeout
-     */
-    private executeCommand;
-    /**
-     * Validate compose file syntax
-     */
-    validateComposeFile(): Promise<{
-        valid: boolean;
-        errors: string[];
-    }>;
-    /**
-     * Get compose file path
-     */
-    getComposeFilePath(): string;
-    /**
-     * Check if services are currently up
-     */
-    isServicesUp(): boolean;
-}

package/dist/core/hooks/compose.js

@@ -1,225 +0,0 @@
-/**
- * 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 class ComposeHelper {
-    workingDir;
-    composeFile;
-    isUp = false;
-    constructor(options) {
-        this.workingDir = options.workingDir;
-        this.composeFile = options.composeFile || 'services.yml';
-    }
-    /**
-     * Start services with Docker Compose
-     */
-    async up(timeout = 120000) {
-        // 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}`);
-            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}`);
-                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}`);
-            composeError.code = 'QH003';
-            composeError.suggestion = 'Verify Docker installation and compose file configuration';
-            throw composeError;
-        }
-    }
-    /**
-     * Stop and remove services
-     */
-    async down(timeout = 60000) {
-        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() {
-        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) => p.trim()) : []
-                        };
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter((service) => service !== null);
-                return services;
-            }
-        }
-        catch (error) {
-            console.log(chalk.yellow(`    ⚠️  Could not get service status: ${error}`));
-        }
-        return [];
-    }
-    /**
-     * Check if Docker is available
-     */
-    async checkDockerAvailable() {
-        try {
-            const result = await this.executeCommand('docker --version', 5000);
-            if (!result.success) {
-                const error = new Error('Docker not available');
-                error.code = 'QH004';
-                error.suggestion = 'Install Docker Desktop or Docker Engine';
-                throw error;
-            }
-        }
-        catch (error) {
-            const dockerError = new Error('Docker daemon not running');
-            dockerError.code = 'QH005';
-            dockerError.suggestion = 'Start Docker Desktop or Docker daemon service';
-            throw dockerError;
-        }
-    }
-    /**
-     * Execute Docker Compose command
-     */
-    async executeCompose(args, timeout) {
-        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
-     */
-    async executeCommand(command, timeout) {
-        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() {
-        const errors = [];
-        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() {
-        return join(this.workingDir, this.composeFile);
-    }
-    /**
-     * Check if services are currently up
-     */
-    isServicesUp() {
-        return this.isUp;
-    }
-}

package/dist/core/hooks/runner.d.ts

@@ -1,68 +0,0 @@
-/**
- * QA360 Hooks Runner
- * Executes declarative hooks with timeouts, failure handling, and security
- */
-import { PackHooks, PackExecution } from '../types/pack-v1.js';
-import { SecurityRedactor } from '../security/redactor.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 declare class HooksRunner {
-    private workingDir;
-    private hooks;
-    private execution;
-    private redactor;
-    private composeHelper;
-    constructor(options: HookRunnerOptions);
-    /**
-     * Execute hooks for a specific lifecycle phase
-     */
-    executeHooks(phase: keyof PackHooks): Promise<HookExecutionResult[]>;
-    /**
-     * Execute a single hook action
-     */
-    private executeHook;
-    /**
-     * Execute a shell command
-     */
-    private executeCommand;
-    /**
-     * Execute Docker Compose command
-     */
-    private executeCompose;
-    /**
-     * Execute wait-on for service readiness
-     */
-    private executeWaitOn;
-    /**
-     * Wait for HTTP endpoint to be ready
-     */
-    private waitForHttp;
-    /**
-     * Wait for TCP port to be ready
-     */
-    private waitForTcp;
-    /**
-     * Get human-readable description of hook action
-     */
-    private getHookDescription;
-    /**
-     * Execute all lifecycle hooks in order
-     */
-    executeLifecycle(): Promise<{
-        beforeAll: HookExecutionResult[];
-        beforeEach: HookExecutionResult[];
-        afterEach: HookExecutionResult[];
-        afterAll: HookExecutionResult[];
-    }>;
-}

package/dist/core/hooks/runner.js

@@ -1,303 +0,0 @@
-/**
- * QA360 Hooks Runner
- * Executes declarative hooks with timeouts, failure handling, and security
- */
-import { spawn } from 'child_process';
-import chalk from 'chalk';
-import { SecurityRedactor } from '../security/redactor.js';
-import { ComposeHelper } from './compose.js';
-export class HooksRunner {
-    workingDir;
-    hooks;
-    execution;
-    redactor;
-    composeHelper;
-    constructor(options) {
-        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) {
-        const hooks = this.hooks[phase];
-        if (!hooks || hooks.length === 0) {
-            return [];
-        }
-        console.log(chalk.blue(`🔗 Executing ${phase} hooks (${hooks.length} actions)`));
-        const results = [];
-        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 = {
-                    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
-     */
-    async executeHook(hook) {
-        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
-     */
-    async executeCommand(command, timeout) {
-        return new Promise((resolve) => {
-            const startTime = Date.now();
-            let output = '';
-            let error = '';
-            const options = {
-                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
-     */
-    async executeCompose(action, timeout) {
-        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
-     */
-    async executeWaitOn(target, timeout, method) {
-        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
-     */
-    async waitForHttp(url, timeout) {
-        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
-     */
-    async waitForTcp(target, timeout) {
-        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((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
-     */
-    getHookDescription(hook) {
-        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() {
-        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;
-    }
-}