qa360 1.0.4 → 1.1.0

package/dist/core/hooks/compose.js

@@ -0,0 +1,225 @@
+/**
+ * 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

@@ -0,0 +1,69 @@
+/**
+ * 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[];
+    }>;
+}
+//# sourceMappingURL=runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/runner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,EAAc,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC7B;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,KAAK,CAAY;IACzB,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,aAAa,CAAgB;gBAEzB,OAAO,EAAE,iBAAiB;IAWtC;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,SAAS,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAiE1E;;OAEG;YACW,WAAW;IAczB;;OAEG;YACW,cAAc;IAgE5B;;OAEG;YACW,cAAc;IAyB5B;;OAEG;YACW,aAAa;IAyB3B;;OAEG;YACW,WAAW;IAwBzB;;OAEG;YACW,UAAU;IAyCxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC;QAChC,SAAS,EAAE,mBAAmB,EAAE,CAAC;QACjC,UAAU,EAAE,mBAAmB,EAAE,CAAC;QAClC,SAAS,EAAE,mBAAmB,EAAE,CAAC;QACjC,QAAQ,EAAE,mBAAmB,EAAE,CAAC;KACjC,CAAC;CAgBH"}

package/dist/core/hooks/runner.js

@@ -0,0 +1,303 @@
+/**
+ * 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;
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * QA360 Core Engine
+ *
+ * The heart of QA360 - handles proof generation, cryptographic signatures,
+ * and evidence vault for verifiable quality assurance.
+ */
+export interface Pack {
+    name: string;
+    version: string;
+    description?: string;
+    adapters: string[];
+    tests: TestSpec[];
+    hooks?: PackHooks;
+}
+export interface TestSpec {
+    name: string;
+    adapter: string;
+    config: Record<string, any>;
+}
+export interface PackHooks {
+    beforeAll?: string[];
+    afterAll?: string[];
+    beforeEach?: string[];
+    afterEach?: string[];
+}
+export interface Proof {
+    id: string;
+    pack: Pack;
+    results: TestResult[];
+    signature: string;
+    trustScore: number;
+    timestamp: string;
+    metadata: ProofMetadata;
+}
+export interface TestResult {
+    testName: string;
+    adapter: string;
+    status: 'passed' | 'failed' | 'skipped';
+    duration: number;
+    evidence: Evidence[];
+    error?: string;
+}
+export interface Evidence {
+    type: 'screenshot' | 'log' | 'metric' | 'artifact';
+    data: string | Buffer;
+    metadata: Record<string, any>;
+}
+export interface ProofMetadata {
+    environment: string;
+    platform: string;
+    qa360Version: string;
+    generatedBy: string;
+}
+export declare class QA360Core {
+    constructor();
+    generateProof(pack: Pack, results: TestResult[]): Promise<Proof>;
+    verifyProof(proof: Proof): Promise<boolean>;
+    calculateTrustScore(results: TestResult[]): Promise<number>;
+}
+export declare const VERSION = "0.9.0-core";
+export * from './proof/index.js';
+export { EvidenceVault } from './vault/index.js';
+export type { RunRecord, GateRecord, FindingRecord } from './vault/index.js';
+export { SecurityRedactor } from './security/redactor.js';
+export { SecretsManager } from './secrets/manager.js';
+export { SecretsCrypto } from './secrets/crypto.js';
+export { PackValidator } from './pack/validator.js';
+export { PackMigrator } from './pack/migrator.js';
+export type { PackConfigV1 } from './types/pack-v1.js';
+export { QA360Server } from './serve/server.js';
+export type { ServeConfig } from './serve/server.js';
+export { Phase3Runner } from './runner/phase3-runner.js';
+export type { Phase3RunnerOptions, Phase3RunResult, GateResult } from './runner/phase3-runner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"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"}