qa360 2.1.7 → 2.2.0

package/core/src/serve/diagnostics-collector.ts

@@ -0,0 +1,201 @@
+/**
+ * QA360 Diagnostics Collector
+ * Collecte des diagnostics actionnables pour /diag
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { HealthChecker } from './health-checker.js';
+
+export interface DiagnosticProblem {
+  code: string;
+  title: string;
+  fix: string;
+}
+
+export interface DiagnosticSuggestion {
+  message: string;
+}
+
+export interface LastRun {
+  runId: string;
+  trust: number;
+  ts: string;
+  status?: 'success' | 'failed' | 'cancelled';
+}
+
+export interface DiagnosticsReport {
+  problems: DiagnosticProblem[];
+  suggestions: string[];
+  last_runs: LastRun[];
+}
+
+export class DiagnosticsCollector {
+  private healthChecker: HealthChecker;
+
+  constructor() {
+    this.healthChecker = new HealthChecker();
+  }
+
+  async collect(): Promise<DiagnosticsReport> {
+    const health = await this.healthChecker.check();
+    const problems = this.analyzeProblems(health);
+    const suggestions = this.generateSuggestions(health);
+    const lastRuns = await this.getLastRuns();
+
+    return {
+      problems,
+      suggestions,
+      last_runs: lastRuns
+    };
+  }
+
+  private analyzeProblems(health: any): DiagnosticProblem[] {
+    const problems: DiagnosticProblem[] = [];
+
+    // Configuration problems
+    if (health.checks.config === 'error') {
+      problems.push({
+        code: 'DOC001',
+        title: 'QA360 directory not accessible',
+        fix: 'qa360 doctor --fix config'
+      });
+    }
+
+    // Tool problems
+    if (health.checks.tools.playwright === 'missing') {
+      problems.push({
+        code: 'DOC201',
+        title: 'Playwright not found',
+        fix: 'qa360 doctor --fix tools=playwright'
+      });
+    }
+
+    if (health.checks.tools.k6 === 'missing') {
+      problems.push({
+        code: 'DOC202',
+        title: 'k6 not found',
+        fix: 'qa360 doctor --fix tools=k6'
+      });
+    }
+
+    if (health.checks.tools.zap === 'missing') {
+      problems.push({
+        code: 'DOC203',
+        title: 'ZAP not found',
+        fix: 'qa360 doctor --fix tools=zap'
+      });
+    }
+
+    // Secrets problems
+    if (health.checks.secrets === 'missing') {
+      problems.push({
+        code: 'SEC101',
+        title: 'Secrets file missing',
+        fix: 'qa360 secrets add API_TOKEN'
+      });
+    }
+
+    // System problems
+    if (!health.checks.tmp_writable) {
+      problems.push({
+        code: 'SYS001',
+        title: 'Temporary directory not writable',
+        fix: 'Check permissions on ' + require('os').tmpdir()
+      });
+    }
+
+    if (health.checks.disk_free_mb < 500) {
+      problems.push({
+        code: 'SYS002',
+        title: 'Low disk space',
+        fix: 'Free up disk space (< 500MB available)'
+      });
+    }
+
+    return problems;
+  }
+
+  private generateSuggestions(health: any): string[] {
+    const suggestions: string[] = [];
+
+    // Performance suggestions
+    if (health.checks.tools.k6 === 'missing') {
+      suggestions.push('Enable Docker fallback: qa360 run --docker');
+    }
+
+    // Security suggestions
+    if (health.checks.tools.zap === 'missing') {
+      suggestions.push('Install ZAP for DAST security testing');
+    }
+
+    // Configuration suggestions
+    const packPath = join(process.cwd(), '.qa360', 'pack.yml');
+    if (!existsSync(packPath)) {
+      suggestions.push('Generate pack configuration: qa360 ask "Test my web app"');
+    }
+
+    // Budget suggestions based on common patterns
+    suggestions.push('Reduce perf budget p95_ms to 900 for demo profile');
+    suggestions.push('Enable strict mode for production: budgets.mode=strict');
+
+    return suggestions;
+  }
+
+  private async getLastRuns(): Promise<LastRun[]> {
+    try {
+      const runsDir = join(process.cwd(), '.qa360', 'runs');
+      if (!existsSync(runsDir)) {
+        return [];
+      }
+
+      const fs = require('fs');
+      const runFiles = fs.readdirSync(runsDir)
+        .filter((f: string) => f.endsWith('.json'))
+        .sort()
+        .slice(-5); // Last 5 runs
+
+      const runs: LastRun[] = [];
+      
+      for (const file of runFiles) {
+        try {
+          const runPath = join(runsDir, file);
+          const runData = JSON.parse(fs.readFileSync(runPath, 'utf8'));
+          
+          runs.push({
+            runId: runData.runId || file.replace('.json', ''),
+            trust: runData.trustScore || runData.trust_score || 0,
+            ts: runData.timestamp || runData.ts || new Date().toISOString(),
+            status: this.inferRunStatus(runData)
+          });
+        } catch {
+          // Skip invalid run files
+        }
+      }
+
+      return runs.reverse(); // Most recent first
+    } catch {
+      return [];
+    }
+  }
+
+  private inferRunStatus(runData: any): 'success' | 'failed' | 'cancelled' {
+    if (runData.status) {
+      return runData.status;
+    }
+    
+    if (runData.cancelled || runData.error?.includes('cancelled')) {
+      return 'cancelled';
+    }
+    
+    if (runData.error || runData.errors?.length > 0) {
+      return 'failed';
+    }
+    
+    if (runData.trustScore >= 70 || runData.trust_score >= 70) {
+      return 'success';
+    }
+    
+    return 'failed';
+  }
+}

package/core/src/serve/health-checker.ts

@@ -0,0 +1,274 @@
+/**
+ * QA360 Health Checker
+ * Vérifie liveness, readiness et état des outils
+ */
+
+import { existsSync, statSync, writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, resolve } from 'path';
+import { spawn, SpawnOptions } from 'child_process';
+import { EventEmitter } from 'events';
+import { PackConfigV1 } from '../types/pack-v1.js';
+
+export interface HealthStatus {
+  status: 'ok' | 'degraded' | 'error';
+  version: string;
+  commit: string;
+  env: {
+    node: string;
+    platform: string;
+  };
+  checks: {
+    config: 'ok' | 'error';
+    tools: {
+      playwright: 'ok' | 'missing';
+      k6: 'ok' | 'missing';
+      zap: 'ok' | 'missing';
+    };
+    secrets: 'ok' | 'missing';
+    disk_free_mb: number;
+    tmp_writable: boolean;
+    errors?: string[];
+  };
+  readiness: {
+    ready: boolean;
+    reason: string | null;
+  };
+}
+
+export class HealthChecker {
+  private packageInfo: any;
+
+  constructor() {
+    try {
+      this.packageInfo = require('../../package.json');
+    } catch {
+      this.packageInfo = { version: '0.9.0-core', name: '@qa360/core' };
+    }
+  }
+
+  async check(): Promise<HealthStatus> {
+    const checks = await this.performChecks();
+    const readiness = this.assessReadiness(checks);
+    
+    // Determine overall status
+    let status: 'ok' | 'degraded' | 'error' = 'ok';
+    
+    if (!readiness.ready) {
+      status = 'error';
+    } else if (
+      checks.tools.playwright === 'missing' ||
+      checks.tools.k6 === 'missing' ||
+      checks.secrets === 'missing'
+    ) {
+      status = 'degraded';
+    }
+
+    return {
+      status,
+      version: this.packageInfo.version,
+      commit: this.getCommitHash(),
+      env: {
+        node: process.version,
+        platform: process.platform
+      },
+      checks,
+      readiness
+    };
+  }
+
+  private async performChecks() {
+    const [
+      configCheck,
+      toolsCheck,
+      secretsCheck,
+      diskCheck,
+      tmpCheck
+    ] = await Promise.all([
+      this.checkConfig(),
+      this.checkTools(),
+      this.checkSecrets(),
+      this.checkDiskSpace(),
+      this.checkTmpWritable()
+    ]);
+
+    // Collect error codes
+    const errors: string[] = [];
+    if (!tmpCheck.ok) errors.push(tmpCheck.code!);
+    if (configCheck.code) errors.push(configCheck.code);
+
+    return {
+      config: configCheck.ok ? 'ok' as const : 'error' as const,
+      tools: toolsCheck,
+      secrets: secretsCheck,
+      disk_free_mb: diskCheck,
+      tmp_writable: tmpCheck.ok,
+      ...(errors.length > 0 && { errors })
+    };
+  }
+
+  private checkConfigDir(): { ok: boolean; code?: 'HLT002'; reason?: string } {
+    const dir = resolve(process.cwd(), '.qa360');
+    try {
+      const s = statSync(dir);
+      if (!s.isDirectory()) throw new Error('not a dir');
+      return { ok: true };
+    } catch {
+      return { ok: false, code: 'HLT002', reason: 'Configuration error - cannot access .qa360 directory' };
+    }
+  }
+
+  private async checkConfig(): Promise<{ ok: boolean; code?: 'HLT002'; reason?: string }> {
+    try {
+      // Check if basic pack structure can be loaded
+      const packPath = join(process.cwd(), '.qa360', 'pack.yml');
+      if (existsSync(packPath)) {
+        return { ok: true };
+      }
+      
+      // Check if we can create .qa360 directory
+      return this.checkConfigDir();
+    } catch {
+      return { ok: false, code: 'HLT002', reason: 'Configuration error - cannot access .qa360 directory' };
+    }
+  }
+
+  private async checkTools(): Promise<{
+    playwright: 'ok' | 'missing';
+    k6: 'ok' | 'missing';
+    zap: 'ok' | 'missing';
+  }> {
+    const [playwright, k6, zap] = await Promise.all([
+      this.checkTool('npx playwright --version'),
+      this.checkTool('k6 version'),
+      this.checkTool('zap-baseline.py --help')
+    ]);
+
+    return { 
+      playwright: playwright === 'error' ? 'missing' : playwright,
+      k6: k6 === 'error' ? 'missing' : k6,
+      zap: zap === 'error' ? 'missing' : zap
+    };
+  }
+
+  private async checkTool(command: string): Promise<'ok' | 'missing' | 'error'> {
+    try {
+      const [cmd, ...args] = command.split(' ');
+      const child = spawn(cmd, args, { stdio: 'ignore' } as SpawnOptions);
+
+      // NEW: garde-fous pour mocks qui renvoient undefined
+      if (!child || typeof (child as unknown as EventEmitter).on !== 'function') {
+        return 'missing';
+      }
+
+      return await new Promise(resolve => {
+        let resolved = false;
+        const timer = setTimeout(() => { 
+          if (!resolved) { 
+            resolved = true; 
+            resolve('missing'); 
+          } 
+        }, 3000);
+
+        child.on('error', () => { 
+          if (!resolved) { 
+            resolved = true; 
+            clearTimeout(timer); 
+            resolve('missing'); 
+          } 
+        });
+        
+        child.on('exit', (code) => {
+          if (!resolved) {
+            resolved = true; 
+            clearTimeout(timer);
+            resolve(code === 0 ? 'ok' : 'missing');
+          }
+        });
+      });
+    } catch {
+      return 'missing';
+    }
+  }
+
+  private async checkSecrets(): Promise<'ok' | 'missing'> {
+    try {
+      const secretsPath = join(process.cwd(), '.qa360', 'secrets.json');
+      return existsSync(secretsPath) ? 'ok' : 'missing';
+    } catch {
+      return 'missing';
+    }
+  }
+
+  private async checkDiskSpace(): Promise<number> {
+    try {
+      const stats = statSync(process.cwd());
+      // Approximation - in real scenario, use statvfs or similar
+      return 2048; // Default 2GB assumption
+    } catch {
+      return 0;
+    }
+  }
+
+  private checkTmpWritable(): { code?: 'HLT001'; ok: boolean; reason?: string } {
+    try {
+      const p = join(tmpdir(), `qa360-${Date.now()}.tmp`);
+      writeFileSync(p, 'ok'); 
+      unlinkSync(p);
+      return { ok: true };
+    } catch {
+      return { ok: false, code: 'HLT001', reason: 'tmp not writable' };
+    }
+  }
+
+  private assessReadiness(checks: any): { ready: boolean; reason: string | null } {
+    // Critical checks for readiness
+    if (!checks.tmp_writable) {
+      return {
+        ready: false,
+        reason: 'HLT001: Temporary directory not writable'
+      };
+    }
+
+    if (checks.config === 'error') {
+      return {
+        ready: false,
+        reason: 'HLT002: Configuration error - cannot access .qa360 directory'
+      };
+    }
+
+    if (checks.disk_free_mb < 100) {
+      return {
+        ready: false,
+        reason: 'HLT003: Insufficient disk space (< 100MB)'
+      };
+    }
+
+    // All critical checks passed
+    return {
+      ready: true,
+      reason: null
+    };
+  }
+
+  private getCommitHash(): string {
+    try {
+      const fs = require('fs');
+      const gitHead = join(process.cwd(), '.git', 'HEAD');
+      if (existsSync(gitHead)) {
+        const head = fs.readFileSync(gitHead, 'utf8').trim();
+        if (head.startsWith('ref: ')) {
+          const refPath = join(process.cwd(), '.git', head.substring(5));
+          if (existsSync(refPath)) {
+            return fs.readFileSync(refPath, 'utf8').trim().substring(0, 7);
+          }
+        } else {
+          return head.substring(0, 7);
+        }
+      }
+      return 'unknown';
+    } catch {
+      return 'unknown';
+    }
+  }
+}

package/core/src/serve/index.ts

@@ -0,0 +1,9 @@
+/**
+ * QA360 Serve Module Exports
+ */
+
+export { QA360Server, ServeConfig, ServeResponse } from './server';
+export { HealthChecker, HealthStatus } from './health-checker';
+export { DiagnosticsCollector, DiagnosticsReport, DiagnosticProblem, LastRun } from './diagnostics-collector';
+export { MetricsCollector, MetricValue } from './metrics-collector';
+export { ProcessManager, RunProcess, CancelResult } from './process-manager';