qa360 2.1.2 → 2.1.4

package/dist/core/parallel/parallel-runner.js

@@ -1,192 +0,0 @@
-/**
- * QA360 Parallel Test Runner
- *
- * Runs multiple UI tests concurrently for faster execution.
- * Supports worker pools, load balancing, and resource limits.
- */
-import { cpus } from 'os';
-/**
- * Parallel Test Runner
- *
- * Executes multiple tests concurrently using worker threads.
- * Each test runs in isolation with its own browser instance.
- */
-export class ParallelTestRunner {
-    maxWorkers;
-    timeout;
-    retries;
-    workerPool;
-    activeJobs;
-    constructor(config) {
-        this.maxWorkers = config?.maxWorkers || Math.max(2, cpus().length - 1);
-        this.timeout = config?.timeout || 60000; // 60s default per test
-        this.retries = config?.retries || 1;
-        this.workerPool = new Map();
-        this.activeJobs = new Map();
-    }
-    /**
-     * Run tests in parallel
-     */
-    async runParallel(tests, target) {
-        const startTime = Date.now();
-        console.log(`\n🚀 Parallel Test Runner`);
-        console.log(`   Workers: ${this.maxWorkers}`);
-        console.log(`   Tests: ${tests.length}`);
-        const results = [];
-        const jobs = tests.map((test, i) => ({
-            id: `test-${i}`,
-            test,
-            target,
-            retries: this.retries,
-        }));
-        // Process jobs in batches
-        let completed = 0;
-        let workerId = 0;
-        while (jobs.length > 0 || this.activeJobs.size > 0) {
-            // Start new jobs up to max workers
-            while (this.activeJobs.size < this.maxWorkers && jobs.length > 0) {
-                const job = jobs.shift();
-                job.workerId = workerId;
-                this.activeJobs.set(job.id, job);
-                this.runWorker(workerId, job)
-                    .then((result) => {
-                    results.push(result);
-                    completed++;
-                    const progress = Math.round((completed / tests.length) * 100);
-                    console.log(`   [${completed}/${tests.length}] ${progress}% - ${result.test.name || job.id}: ${result.success ? 'PASS' : 'FAIL'}`);
-                })
-                    .catch((error) => {
-                    results.push({
-                        test: job.test,
-                        success: false,
-                        duration: 0,
-                        error: error.message,
-                        workerId,
-                    });
-                    completed++;
-                })
-                    .finally(() => {
-                    this.activeJobs.delete(job.id);
-                });
-                workerId = (workerId + 1) % this.maxWorkers;
-            }
-            // Wait a bit before checking again
-            await this.sleep(100);
-        }
-        const duration = Date.now() - startTime;
-        const passed = results.filter((r) => r.success).length;
-        const failed = results.filter((r) => !r.success).length;
-        const workerStats = {
-            totalWorkers: this.maxWorkers,
-            totalJobs: results.length,
-            avgJobDuration: results.length > 0 ? duration / results.length : 0,
-        };
-        console.log(`\n✅ Parallel execution complete`);
-        console.log(`   Duration: ${duration}ms`);
-        console.log(`   Throughput: ${Math.round(results.length / (duration / 1000))} tests/sec`);
-        return {
-            success: failed === 0,
-            totalTests: results.length,
-            passed,
-            failed,
-            skipped: 0,
-            duration,
-            results,
-            workerStats,
-        };
-    }
-    /**
-     * Run a single worker job
-     */
-    async runWorker(workerId, job) {
-        // For now, run in-process (worker threads setup is complex)
-        // In production, this would spawn a worker thread
-        const startTime = Date.now();
-        try {
-            // Import adapter dynamically to run test
-            const { PlaywrightNativeAdapter } = await import('../adapters/playwright-native-adapter.js');
-            const adapter = new PlaywrightNativeAdapter({
-                target: job.target,
-                timeout: this.timeout,
-                screenshots: 'only-on-failure',
-                video: 'never',
-                trace: 'never',
-            });
-            const result = await adapter.runTest(job.test);
-            // Retry on failure
-            if (!result.success && job.retries > 0) {
-                console.log(`   🔄 Retrying ${job.test.name || job.id} (${job.retries} retries left)`);
-                job.retries--;
-                return this.runWorker(workerId, job);
-            }
-            return {
-                test: job.test,
-                success: result.success,
-                duration: Date.now() - startTime,
-                error: result.error,
-                artifacts: result.artifacts,
-                workerId,
-            };
-        }
-        catch (error) {
-            // Retry on error
-            if (job.retries > 0) {
-                console.log(`   🔄 Retrying ${job.test.name || job.id} after error (${job.retries} retries left)`);
-                job.retries--;
-                return this.runWorker(workerId, job);
-            }
-            return {
-                test: job.test,
-                success: false,
-                duration: Date.now() - startTime,
-                error: error instanceof Error ? error.message : String(error),
-                workerId,
-            };
-        }
-    }
-    /**
-     * Sleep utility
-     */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    /**
-     * Clean up all workers
-     */
-    async cleanup() {
-        for (const [id, worker] of this.workerPool) {
-            await worker.terminate();
-            this.workerPool.delete(id);
-        }
-        this.activeJobs.clear();
-    }
-    /**
-     * Get optimal worker count based on resources
-     */
-    static getOptimalWorkerCount() {
-        const cpuCount = cpus().length;
-        const memGB = require('os').totalmem() / (1024 ** 3);
-        // Each worker uses ~500MB RAM
-        const memBasedWorkers = Math.floor(memGB / 0.5);
-        const cpuBasedWorkers = Math.max(2, cpuCount - 1);
-        return Math.min(cpuBasedWorkers, memBasedWorkers);
-    }
-}
-/**
- * Create a parallel test runner
- */
-export function createParallelRunner(config) {
-    return new ParallelTestRunner(config);
-}
-/**
- * Run tests in parallel (convenience function)
- */
-export async function runParallelTests(tests, target, config) {
-    const runner = new ParallelTestRunner(config);
-    try {
-        return await runner.runParallel(tests, target);
-    }
-    finally {
-        await runner.cleanup();
-    }
-}

package/dist/core/proof/bundle.d.ts

@@ -1,137 +0,0 @@
-/**
- * Proof Bundle Creation
- *
- * Creates cryptographically signed proof bundles from test run data.
- *
- * @see docs/rfc/proof-bundle-v1.md#3-data-model
- */
-import { type KeyPair } from './signer.js';
-/**
- * Proof Bundle structure (matches RFC spec)
- */
-export interface ProofBundle {
-    spec: 'qa360.proof.v1';
-    run: RunMetadata;
-    artifacts: Artifact[];
-    results: TestResults;
-    signing: SigningMetadata;
-    signature: string;
-}
-/**
- * Run metadata
- */
-export interface RunMetadata {
-    id: string;
-    startedAt: string;
-    finishedAt: string;
-    environment: Environment;
-    packHash: string;
-    ciContext: CIContext;
-}
-/**
- * Environment information
- */
-export interface Environment {
-    os: 'windows' | 'linux' | 'darwin';
-    node: string;
-    arch: 'x64' | 'arm64';
-    ci: boolean;
-}
-/**
- * CI context
- */
-export interface CIContext {
-    provider: string | null;
-}
-/**
- * Artifact metadata
- */
-export interface Artifact {
-    name: string;
-    sha256: string;
-    size: number;
-    path?: string;
-}
-/**
- * Test results
- */
-export interface TestResults {
-    trustScore: number;
-    gates: Gate[];
-}
-/**
- * Gate result
- */
-export interface Gate {
-    name: string;
-    status: 'pass' | 'fail' | 'skip';
-    metrics?: Record<string, any>;
-}
-/**
- * Signing metadata
- */
-export interface SigningMetadata {
-    algo: 'ed25519';
-    signerId: string;
-    timestamp: TimestampInfo;
-    identity: IdentityInfo;
-}
-/**
- * Timestamp information (Phase 1: none, Phase 2: rfc3161)
- */
-export interface TimestampInfo {
-    type: 'none' | 'rfc3161';
-    token: string | null;
-}
-/**
- * Identity information (Phase 1: none, Phase 2: did/sigstore)
- */
-export interface IdentityInfo {
-    type: 'none' | 'did' | 'sigstore';
-    evidence: string | object | null;
-}
-/**
- * Parameters for creating a proof bundle
- */
-export interface ProofBundleParams {
-    runId?: string;
-    startedAt: Date;
-    finishedAt: Date;
-    packHash: string;
-    artifacts: Artifact[];
-    trustScore: number;
-    gates: Gate[];
-    signerId?: string;
-    keyPair?: KeyPair;
-}
-/**
- * Compute SHA-256 hash of string
- */
-export declare function computeSHA256(data: string): string;
-/**
- * Create and sign a proof bundle
- *
- * @param params - Bundle parameters
- * @returns Signed proof bundle
- *
- * @example
- * ```ts
- * const bundle = await createProofBundle({
- *   startedAt: new Date('2025-01-01T00:00:00Z'),
- *   finishedAt: new Date('2025-01-01T00:01:00Z'),
- *   packHash: 'sha256-abc123...',
- *   artifacts: [],
- *   trustScore: 87,
- *   gates: [{ name: 'api_smoke', status: 'pass' }],
- * });
- * ```
- */
-export declare function createProofBundle(params: ProofBundleParams): Promise<ProofBundle>;
-/**
- * Create proof bundle from pack file content
- *
- * @param packContent - Pack YAML/JSON content
- * @param params - Other bundle parameters
- * @returns Signed proof bundle
- */
-export declare function createProofBundleFromPack(packContent: string, params: Omit<ProofBundleParams, 'packHash'>): Promise<ProofBundle>;

package/dist/core/proof/bundle.js

@@ -1,160 +0,0 @@
-/**
- * Proof Bundle Creation
- *
- * Creates cryptographically signed proof bundles from test run data.
- *
- * @see docs/rfc/proof-bundle-v1.md#3-data-model
- */
-import { randomUUID } from 'crypto';
-import { platform, arch } from 'os';
-import { createHash } from 'crypto';
-import { canonicalizeForSigning } from './canonicalize.js';
-import { sign, initializeKeys } from './signer.js';
-import { validateProofBundle } from './schema.js';
-/**
- * Get current OS in RFC format
- */
-function getCurrentOS() {
-    const p = platform();
-    if (p === 'win32')
-        return 'windows';
-    if (p === 'darwin')
-        return 'darwin';
-    return 'linux';
-}
-/**
- * Get current architecture in RFC format
- */
-function getCurrentArch() {
-    const a = arch();
-    if (a === 'arm64')
-        return 'arm64';
-    return 'x64';
-}
-/**
- * Get Node.js version (semver format)
- */
-function getNodeVersion() {
-    return process.version.replace(/^v/, '');
-}
-/**
- * Detect if running in CI
- */
-function isCI() {
-    return !!(process.env.CI ||
-        process.env.GITHUB_ACTIONS ||
-        process.env.GITLAB_CI ||
-        process.env.CIRCLECI ||
-        process.env.JENKINS_URL);
-}
-/**
- * Detect CI provider
- */
-function getCIProvider() {
-    if (process.env.GITHUB_ACTIONS)
-        return 'github-actions';
-    if (process.env.GITLAB_CI)
-        return 'gitlab-ci';
-    if (process.env.CIRCLECI)
-        return 'circleci';
-    if (process.env.JENKINS_URL)
-        return 'jenkins';
-    return null;
-}
-/**
- * Compute SHA-256 hash of string
- */
-export function computeSHA256(data) {
-    const hash = createHash('sha256').update(data, 'utf-8').digest('hex');
-    return `sha256-${hash}`;
-}
-/**
- * Create unsigned proof bundle (without signature)
- */
-function createUnsignedBundle(params) {
-    return {
-        spec: 'qa360.proof.v1',
-        run: {
-            id: params.runId || randomUUID(),
-            startedAt: params.startedAt.toISOString(),
-            finishedAt: params.finishedAt.toISOString(),
-            environment: {
-                os: getCurrentOS(),
-                node: getNodeVersion(),
-                arch: getCurrentArch(),
-                ci: isCI(),
-            },
-            packHash: params.packHash,
-            ciContext: {
-                provider: getCIProvider(),
-            },
-        },
-        artifacts: params.artifacts,
-        results: {
-            trustScore: params.trustScore,
-            gates: params.gates,
-        },
-        signing: {
-            algo: 'ed25519',
-            signerId: params.signerId || 'local@qa360',
-            timestamp: {
-                type: 'none',
-                token: null,
-            },
-            identity: {
-                type: 'none',
-                evidence: null,
-            },
-        },
-    };
-}
-/**
- * Create and sign a proof bundle
- *
- * @param params - Bundle parameters
- * @returns Signed proof bundle
- *
- * @example
- * ```ts
- * const bundle = await createProofBundle({
- *   startedAt: new Date('2025-01-01T00:00:00Z'),
- *   finishedAt: new Date('2025-01-01T00:01:00Z'),
- *   packHash: 'sha256-abc123...',
- *   artifacts: [],
- *   trustScore: 87,
- *   gates: [{ name: 'api_smoke', status: 'pass' }],
- * });
- * ```
- */
-export async function createProofBundle(params) {
-    // Load or initialize keys
-    const keyPair = params.keyPair || await initializeKeys();
-    // Create unsigned bundle
-    const unsigned = createUnsignedBundle(params);
-    // Canonicalize for signing (removes signature field, adds newline)
-    const canonical = canonicalizeForSigning(unsigned);
-    // Sign the canonical form
-    const signature = sign(canonical, keyPair.secretKey);
-    // Create final bundle
-    const bundle = {
-        ...unsigned,
-        signature,
-    };
-    // Validate against schema
-    const validation = validateProofBundle(bundle);
-    if (!validation.valid) {
-        throw new Error(`Invalid proof bundle: ${validation.errors?.join(', ')}`);
-    }
-    return bundle;
-}
-/**
- * Create proof bundle from pack file content
- *
- * @param packContent - Pack YAML/JSON content
- * @param params - Other bundle parameters
- * @returns Signed proof bundle
- */
-export async function createProofBundleFromPack(packContent, params) {
-    const packHash = computeSHA256(packContent);
-    return createProofBundle({ ...params, packHash });
-}

package/dist/core/proof/canonicalize.d.ts

@@ -1,47 +0,0 @@
-/**
- * JSON Canonicalization for deterministic hashing
- *
- * Implements RFC 8785-like canonicalization:
- * - Alphabetically sorted keys (recursive)
- * - UTF-8 NFC normalization
- * - No whitespace (compact)
- * - Deterministic across platforms
- *
- * @see docs/rfc/proof-bundle-v1.md#4-canonicalization
- */
-/**
- * Canonicalize a JavaScript object into deterministic JSON string
- *
- * @param obj - Object to canonicalize
- * @returns Canonical JSON string (compact, sorted keys, UTF-8 NFC)
- *
- * @example
- * ```ts
- * const obj = { b: 2, a: 1 };
- * const canonical = canonicalize(obj);
- * // Returns: '{"a":1,"b":2}\n'
- * ```
- */
-export declare function canonicalize(obj: any): string;
-/**
- * Canonicalize and append newline (standard format)
- *
- * @param obj - Object to canonicalize
- * @returns Canonical JSON string with trailing newline
- */
-export declare function canonicalizeWithNewline(obj: any): string;
-/**
- * Remove signature field and canonicalize
- * Used for signature verification
- *
- * @param bundle - Proof bundle (may contain signature field)
- * @returns Canonical JSON without signature field
- */
-export declare function canonicalizeForSigning(bundle: any): string;
-/**
- * Verify canonicalization is deterministic
- *
- * @param obj - Object to test
- * @returns true if canonicalization is stable
- */
-export declare function isCanonicalStable(obj: any): boolean;

package/dist/core/proof/canonicalize.js

@@ -1,105 +0,0 @@
-/**
- * JSON Canonicalization for deterministic hashing
- *
- * Implements RFC 8785-like canonicalization:
- * - Alphabetically sorted keys (recursive)
- * - UTF-8 NFC normalization
- * - No whitespace (compact)
- * - Deterministic across platforms
- *
- * @see docs/rfc/proof-bundle-v1.md#4-canonicalization
- */
-/**
- * Canonicalize a JavaScript object into deterministic JSON string
- *
- * @param obj - Object to canonicalize
- * @returns Canonical JSON string (compact, sorted keys, UTF-8 NFC)
- *
- * @example
- * ```ts
- * const obj = { b: 2, a: 1 };
- * const canonical = canonicalize(obj);
- * // Returns: '{"a":1,"b":2}\n'
- * ```
- */
-export function canonicalize(obj) {
-    // Handle primitives
-    if (obj === null)
-        return 'null';
-    if (obj === undefined)
-        return 'null'; // Treat undefined as null
-    const type = typeof obj;
-    if (type === 'boolean')
-        return obj ? 'true' : 'false';
-    if (type === 'number') {
-        // Ensure decimal notation (no scientific notation)
-        if (!isFinite(obj)) {
-            throw new Error('Cannot canonicalize non-finite number');
-        }
-        return String(obj);
-    }
-    if (type === 'string') {
-        // Unicode NFC normalization
-        const normalized = obj.normalize('NFC');
-        // JSON.stringify handles escaping
-        return JSON.stringify(normalized);
-    }
-    // Handle arrays
-    if (Array.isArray(obj)) {
-        const items = obj.map(item => canonicalize(item));
-        return `[${items.join(',')}]`;
-    }
-    // Handle objects
-    if (type === 'object') {
-        // Get keys and sort alphabetically
-        const keys = Object.keys(obj).sort();
-        // Build key-value pairs
-        const pairs = keys.map(key => {
-            const value = obj[key];
-            const canonicalKey = canonicalize(key);
-            const canonicalValue = canonicalize(value);
-            return `${canonicalKey}:${canonicalValue}`;
-        });
-        return `{${pairs.join(',')}}`;
-    }
-    throw new Error(`Cannot canonicalize type: ${type}`);
-}
-/**
- * Canonicalize and append newline (standard format)
- *
- * @param obj - Object to canonicalize
- * @returns Canonical JSON string with trailing newline
- */
-export function canonicalizeWithNewline(obj) {
-    return canonicalize(obj) + '\n';
-}
-/**
- * Remove signature field and canonicalize
- * Used for signature verification
- *
- * @param bundle - Proof bundle (may contain signature field)
- * @returns Canonical JSON without signature field
- */
-export function canonicalizeForSigning(bundle) {
-    // Clone to avoid mutating original
-    const clone = JSON.parse(JSON.stringify(bundle));
-    // Remove signature field
-    delete clone.signature;
-    return canonicalizeWithNewline(clone);
-}
-/**
- * Verify canonicalization is deterministic
- *
- * @param obj - Object to test
- * @returns true if canonicalization is stable
- */
-export function isCanonicalStable(obj) {
-    try {
-        const first = canonicalize(obj);
-        const second = canonicalize(obj);
-        return first === second;
-    }
-    catch {
-        return false;
-    }
-}

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

@@ -1,13 +0,0 @@
-/**
- * QA360 Proof Bundle System
- *
- * Cryptographically signed, verifiable proof bundles for test results.
- *
- * @module @qa360/core/proof
- * @see docs/rfc/proof-bundle-v1.md
- */
-export { canonicalize, canonicalizeWithNewline, canonicalizeForSigning, isCanonicalStable, } from './canonicalize.js';
-export { generateKeys, saveKeys, loadKeys, keysExist, initializeKeys, ensureProofKeys, sha256, sign, verify, testRoundtrip, getKeyDirectory, getKeyPaths, type KeyPair, type KeyPaths, } from './signer.js';
-export { validateProofBundle, getSchema, patterns, type ValidationResult, } from './schema.js';
-export { createProofBundle, createProofBundleFromPack, computeSHA256, type ProofBundle, type RunMetadata, type Environment, type CIContext, type Artifact, type TestResults, type Gate, type SigningMetadata, type TimestampInfo, type IdentityInfo, type ProofBundleParams, } from './bundle.js';
-export { verifyProofBundle, verifyArtifact, verifyArtifacts, verifyComplete, verifyProofFile, verifyPhase3Proof, VerificationCode, type VerificationResult, type VerificationDetails, type ArtifactVerificationOptions, } from './verifier.js';

package/dist/core/proof/index.js

@@ -1,18 +0,0 @@
-/**
- * QA360 Proof Bundle System
- *
- * Cryptographically signed, verifiable proof bundles for test results.
- *
- * @module @qa360/core/proof
- * @see docs/rfc/proof-bundle-v1.md
- */
-// Canonicalization
-export { canonicalize, canonicalizeWithNewline, canonicalizeForSigning, isCanonicalStable, } from './canonicalize.js';
-// Signing
-export { generateKeys, saveKeys, loadKeys, keysExist, initializeKeys, ensureProofKeys, sha256, sign, verify, testRoundtrip, getKeyDirectory, getKeyPaths, } from './signer.js';
-// Schema validation
-export { validateProofBundle, getSchema, patterns, } from './schema.js';
-// Bundle creation
-export { createProofBundle, createProofBundleFromPack, computeSHA256, } from './bundle.js';
-// Verification
-export { verifyProofBundle, verifyArtifact, verifyArtifacts, verifyComplete, verifyProofFile, verifyPhase3Proof, VerificationCode, } from './verifier.js';