qa360 2.1.2 → 2.1.4

package/cli/src/commands/doctor.ts

@@ -0,0 +1,610 @@
+/**
+ * QA360 Doctor Command - Environment diagnostic and auto-fix
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export interface DoctorCheck {
+  id: string;
+  name: string;
+  status: 'ok' | 'warning' | 'error';
+  message: string;
+  code?: string;
+  fix?: () => Promise<void>;
+}
+
+export interface DoctorResult {
+  checks: DoctorCheck[];
+  summary: {
+    total: number;
+    ok: number;
+    warnings: number;
+    errors: number;
+    fixed: number;
+  };
+  exitCode: 0 | 1;
+  decision: 'ok' | 'fail_after_fix' | 'fail_strict' | 'info';
+}
+
+export class QA360Doctor {
+  private qa360Dir = process.env.QA360_HOME || join(process.cwd(), '.qa360');
+  private keysDir = join(this.qa360Dir, 'keys');
+  private runsDir = join(this.qa360Dir, 'runs');
+
+  async diagnose(options: { fix?: boolean; strict?: boolean; json?: boolean; skip?: string[] } = {}): Promise<DoctorResult> {
+    // In JSON mode, disable colors to avoid ANSI codes pollution
+    if (options.json) {
+      process.env.FORCE_COLOR = '0';
+    }
+    
+    // Log QA360_HOME for debugging (verbose mode) - use stderr in JSON mode
+    if (process.env.DEBUG || process.env.VERBOSE) {
+      const logFn = options.json ? console.error : console.log;
+      logFn(`[DEBUG] Using QA360_HOME: ${this.qa360Dir}`);
+    }
+    
+    // In JSON mode, spinner output goes to stderr to keep stdout clean
+    const spinner = options.json 
+      ? ora({ text: '🔍 Diagnostic QA360 en cours...', stream: process.stderr }).start()
+      : ora('🔍 Diagnostic QA360 en cours...').start();
+    
+    let fixedCount = 0;
+
+    try {
+      // Parse skip list from options or env
+      const skipList = options.skip || (process.env.QA360_SKIP_CHECKS ? process.env.QA360_SKIP_CHECKS.split(',').map(s => s.trim()) : []);
+      
+      // Run initial checks
+      let checks = await this.runAllChecks();
+      
+      // Filter out skipped checks
+      checks = checks.filter(c => !skipList.includes(c.id));
+
+      // Auto-fix if requested
+      if (options.fix) {
+        fixedCount = await this.performFixes(checks, { json: options.json });
+        
+        // CRITICAL: Re-run ALL checks after fixes to get accurate final state
+        if (fixedCount > 0) {
+          spinner.text = '🔄 Re-diagnostic après corrections...';
+          checks = await this.runAllChecks();
+          // Re-apply skip filter
+          checks = checks.filter(c => !skipList.includes(c.id));
+        }
+      }
+
+      // If strict mode, always re-run checks to ensure fresh state
+      if (options.strict && fixedCount === 0) {
+        checks = await this.runAllChecks();
+        // Re-apply skip filter
+        checks = checks.filter(c => !skipList.includes(c.id));
+      }
+
+      spinner.stop();
+      return this.generateResult(checks, fixedCount, options);
+    } catch (error) {
+      spinner.fail('Erreur lors du diagnostic');
+      throw error;
+    }
+  }
+
+  private async runAllChecks(): Promise<DoctorCheck[]> {
+    const checks: DoctorCheck[] = [];
+    
+    // 1. Node.js version check
+    checks.push(await this.checkNodeVersion());
+    
+    // 2. QA360 directories structure
+    checks.push(await this.checkDirectories());
+    
+    // 3. Required tools availability
+    checks.push(...await this.checkTools());
+    
+    // 4. Network connectivity
+    checks.push(await this.checkNetwork());
+    
+    // 5. Secrets management
+    checks.push(await this.checkSecrets());
+    
+    // 6. Crypto keys
+    checks.push(await this.checkCryptoKeys());
+
+    // 7. Proof System (Phase 2)
+    checks.push(await this.checkProofKeys());
+    checks.push(await this.checkProofRoundtrip());
+    
+    return checks;
+  }
+
+  private async checkNodeVersion(): Promise<DoctorCheck> {
+    try {
+      const version = process.version;
+      const major = parseInt(version.slice(1).split('.')[0]);
+      
+      if (major >= 18) {
+        return {
+          id: 'node_js_version',
+          name: 'Node.js Version',
+          status: 'ok',
+          message: `Node.js ${version} ✅`
+        };
+      } else {
+        return {
+          id: 'node_js_version',
+          name: 'Node.js Version',
+          status: 'error',
+          message: `Node.js ${version} non supporté (requis: ≥18.0.0)`,
+          code: 'QX001'
+        };
+      }
+    } catch (error) {
+      return {
+        id: 'node_js_version',
+        name: 'Node.js Version',
+        status: 'error',
+        message: 'Impossible de détecter la version Node.js',
+        code: 'QX001'
+      };
+    }
+  }
+
+  private async checkDirectories(): Promise<DoctorCheck> {
+    // Only check essential directories - tools/ is deprecated
+    const dirs = [this.qa360Dir, this.keysDir, this.runsDir];
+    const missing = dirs.filter(dir => !existsSync(dir));
+
+    if (missing.length === 0) {
+      return {
+        id: 'structure_qa360',
+        name: 'Structure QA360',
+        status: 'ok',
+        message: 'Répertoires QA360 présents ✅'
+      };
+    }
+
+    return {
+      id: 'structure_qa360',
+      name: 'Structure QA360',
+      status: 'warning',
+      message: `Répertoires manquants: ${missing.map(d => d.split('/').pop()).join(', ')}`,
+      code: 'QX002',
+      fix: async () => {
+        missing.forEach(dir => mkdirSync(dir, { recursive: true }));
+      }
+    };
+  }
+
+  private async checkTools(): Promise<DoctorCheck[]> {
+    const tools = [
+      { id: 'playwright', name: 'Playwright', command: 'npx playwright --version', code: 'QX003' }
+    ];
+
+    const checks: DoctorCheck[] = [];
+
+    for (const tool of tools) {
+      try {
+        const output = execSync(tool.command, { encoding: 'utf8', stdio: 'pipe' });
+        checks.push({
+          id: tool.id,
+          name: tool.name,
+          status: 'ok',
+          message: `${tool.name} disponible (${output.trim()}) ✅`
+        });
+      } catch (error) {
+        checks.push({
+          id: tool.id,
+          name: tool.name,
+          status: 'warning',
+          message: `${tool.name} non disponible`,
+          code: tool.code,
+          fix: async () => {
+            if (tool.name === 'Playwright') {
+              execSync('npx playwright install chromium', { stdio: 'inherit' });
+            }
+          }
+        });
+      }
+    }
+
+    return checks;
+  }
+
+  private async checkNetwork(): Promise<DoctorCheck> {
+    try {
+      // Use native fetch (Node 18+)
+      const response = await fetch('https://httpbin.org/status/200', { 
+        signal: AbortSignal.timeout(5000) 
+      });
+      
+      if (response.ok) {
+        return {
+          id: 'connectivity_network',
+          name: 'Connectivité Réseau',
+          status: 'ok',
+          message: 'Accès Internet disponible ✅'
+        };
+      } else {
+        throw new Error(`HTTP ${response.status}`);
+      }
+    } catch (error) {
+      return {
+        id: 'connectivity_network',
+        name: 'Connectivité Réseau',
+        status: 'warning',
+        message: 'Accès Internet limité ou proxy détecté',
+        code: 'QX005'
+      };
+    }
+  }
+
+  private async checkSecrets(): Promise<DoctorCheck> {
+    const secretsFile = join(this.qa360Dir, 'secrets.enc');
+    const oldSecretsFile = join(this.qa360Dir, 'secrets.json');
+
+    // Secrets are optional - this is informational only
+    if (existsSync(secretsFile)) {
+      return {
+        id: 'gestion_secrets',
+        name: 'Gestion Secrets',
+        status: 'ok',
+        message: 'Fichier secrets configuré ✅'
+      };
+    }
+
+    // Old secrets file exists but not new one
+    if (existsSync(oldSecretsFile)) {
+      return {
+        id: 'gestion_secrets',
+        name: 'Gestion Secrets',
+        status: 'ok',
+        message: 'Fichier secrets (ancien format) configuré ℹ️'
+      };
+    }
+
+    // No secrets file is OK - secrets are optional
+    return {
+      id: 'gestion_secrets',
+      name: 'Gestion Secrets',
+      status: 'ok',
+      message: 'Aucun fichier secrets (optionnel) ℹ️'
+    };
+  }
+
+  private async checkCryptoKeys(): Promise<DoctorCheck> {
+    // Updated to use new key filenames (ed25519.key / ed25519.pub)
+    const privateKeyFile = join(this.keysDir, 'ed25519.key');
+    const publicKeyFile = join(this.keysDir, 'ed25519.pub');
+
+    // Also check for old filenames for backward compatibility
+    const oldPrivateKeyFile = join(this.keysDir, 'qa360.key');
+    const oldPublicKeyFile = join(this.keysDir, 'qa360.pub');
+
+    const hasNewKeys = existsSync(privateKeyFile) && existsSync(publicKeyFile);
+    const hasOldKeys = existsSync(oldPrivateKeyFile) && existsSync(oldPublicKeyFile);
+
+    if (hasNewKeys) {
+      return {
+        id: 'crypto_keys',
+        name: 'Clés Cryptographiques',
+        status: 'ok',
+        message: 'Paire de clés Ed25519 présente ✅'
+      };
+    }
+
+    if (hasOldKeys) {
+      return {
+        id: 'crypto_keys',
+        name: 'Clés Cryptographiques',
+        status: 'ok',
+        message: 'Paire de clés Ed25519 présente (ancien format) ℹ️'
+      };
+    }
+
+    // Note: Keys are auto-generated by ensureProofKeys, so this is just informational
+    return {
+      id: 'crypto_keys',
+      name: 'Clés Cryptographiques',
+      status: 'ok',
+      message: 'Clés Ed25519 seront générées automatiquement ℹ️'
+    };
+  }
+
+  private async checkProofKeys(): Promise<DoctorCheck> {
+    try {
+      const { ensureProofKeys } = await import('qa360-core');
+      
+      const result = await ensureProofKeys(this.qa360Dir);
+      
+      // Validate result
+      if (!result) {
+        throw new Error('ensureProofKeys returned undefined');
+      }
+      
+      if (result.created && !result.keys) {
+        throw new Error('Key generation failed (no keys returned)');
+      }
+      
+      // Validate key sizes if keys were returned
+      if (result.keys) {
+        if (!result.keys.publicKey || result.keys.publicKey.length !== 32) {
+          throw new Error(`Invalid public key size: ${result.keys.publicKey?.length || 0} (expected 32)`);
+        }
+        if (!result.keys.secretKey || result.keys.secretKey.length !== 64) {
+          throw new Error(`Invalid secret key size: ${result.keys.secretKey?.length || 0} (expected 64)`);
+        }
+      }
+      
+      if (result.created) {
+        return {
+          id: 'proof_system_keys',
+          name: 'Proof System Keys',
+          status: 'ok',
+          message: `Ed25519 keys generated (${result.paths.priv}) ✅`
+        };
+      }
+      
+      return {
+        id: 'proof_system_keys',
+        name: 'Proof System Keys',
+        status: 'ok',
+        message: `Ed25519 keys ready (${result.paths.priv}) ✅`
+      };
+    } catch (error) {
+      return {
+        id: 'proof_system_keys',
+        name: 'Proof System Keys',
+        status: 'error',
+        message: `Failed to ensure keys: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        code: 'D001'
+      };
+    }
+  }
+
+  private async checkProofRoundtrip(): Promise<DoctorCheck> {
+    try {
+      const coreModule = await import('qa360-core');
+      const { 
+        generateKeys, 
+        createProofBundle, 
+        verifyProofBundle 
+      } = coreModule;
+      
+      // Guard: Verify exports are functions
+      if (typeof generateKeys !== 'function') {
+        return {
+          id: 'proof_roundtrip',
+          name: 'Proof Roundtrip',
+          status: 'error',
+          message: 'Roundtrip test failed: generateKeys export not found',
+          code: 'D003'
+        };
+      }
+      
+      if (typeof createProofBundle !== 'function') {
+        return {
+          id: 'proof_roundtrip',
+          name: 'Proof Roundtrip',
+          status: 'error',
+          message: 'Roundtrip test failed: createProofBundle export not found',
+          code: 'D003'
+        };
+      }
+      
+      if (typeof verifyProofBundle !== 'function') {
+        return {
+          id: 'proof_roundtrip',
+          name: 'Proof Roundtrip',
+          status: 'error',
+          message: 'Roundtrip test failed: verifyProofBundle export not found',
+          code: 'D003'
+        };
+      }
+      
+      // Generate test keys
+      const keyPair = generateKeys();
+      
+      // Create minimal proof bundle
+      const bundle = await createProofBundle({
+        startedAt: new Date(),
+        finishedAt: new Date(),
+        packHash: 'sha256-' + '0'.repeat(64),
+        artifacts: [],
+        trustScore: 100,
+        gates: [{ name: 'test', status: 'pass' }],
+        keyPair,
+      });
+      
+      // Verify
+      const result = await verifyProofBundle(bundle, keyPair.publicKey);
+      
+      if (result.valid) {
+        return {
+          id: 'proof_roundtrip',
+          name: 'Proof Roundtrip',
+          status: 'ok',
+          message: 'Sign/verify roundtrip OK ✅'
+        };
+      }
+      
+      return {
+        id: 'proof_roundtrip',
+        name: 'Proof Roundtrip',
+        status: 'error',
+        message: 'Sign/verify roundtrip failed',
+        code: 'D003'
+      };
+    } catch (error) {
+      return {
+        id: 'proof_roundtrip',
+        name: 'Proof Roundtrip',
+        status: 'error',
+        message: `Roundtrip test failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        code: 'D003'
+      };
+    }
+  }
+
+  private async performFixes(checks: DoctorCheck[], options: { json?: boolean } = {}): Promise<number> {
+    const fixableChecks = checks.filter(check => check.fix && check.status !== 'ok');
+    
+    // In JSON mode, all human logs go to stderr
+    const log = options.json ? console.error : console.log;
+    
+    if (fixableChecks.length === 0) {
+      log(chalk.green('✅ Aucune correction nécessaire'));
+      return 0;
+    }
+
+    log(chalk.blue(`🔧 Application de ${fixableChecks.length} correction(s)...`));
+
+    let fixedCount = 0;
+    for (const check of fixableChecks) {
+      try {
+        // In JSON mode, spinner goes to stderr
+        const spinner = options.json
+          ? ora({ text: `Correction: ${check.name}`, stream: process.stderr }).start()
+          : ora(`Correction: ${check.name}`).start();
+        await check.fix!();
+        spinner.succeed(`${check.name} corrigé`);
+        check.status = 'ok';
+        check.message = `${check.name} corrigé automatiquement ✅`;
+        delete check.code; // Remove error code after fix
+        fixedCount++;
+      } catch (error) {
+        // Always use stderr for error messages
+        console.error(chalk.red(`❌ Échec correction ${check.name}: ${error}`));
+        // Keep status as error if fix failed
+      }
+    }
+    
+    return fixedCount;
+  }
+
+  private generateResult(checks: DoctorCheck[], fixedCount: number, options: { fix?: boolean; strict?: boolean } = {}): DoctorResult {
+    // Calculate summary based on FINAL state (after re-diagnostic)
+    const summary = {
+      total: checks.length,
+      ok: checks.filter(c => c.status === 'ok').length,
+      warnings: checks.filter(c => c.status === 'warning').length,
+      errors: checks.filter(c => c.status === 'error').length,
+      fixed: fixedCount
+    };
+
+    // Exit code logic (clear and deterministic):
+    let exitCode: 0 | 1;
+    let decision: 'ok' | 'fail_after_fix' | 'fail_strict' | 'info';
+    
+    if (options.strict) {
+      // --strict: exit 0 only if errors=0 AND warnings=0
+      const okStrict = summary.errors === 0 && summary.warnings === 0;
+      exitCode = okStrict ? 0 : 1;
+      decision = okStrict ? 'ok' : 'fail_strict';
+    } else if (options.fix) {
+      // --fix: exit 0 if errors=0 after fixes (warnings tolerated)
+      const okAfterFix = summary.errors === 0;
+      exitCode = okAfterFix ? 0 : 1;
+      decision = okAfterFix ? 'ok' : 'fail_after_fix';
+    } else {
+      // default (info mode): always exit 0
+      exitCode = 0;
+      decision = 'info';
+    }
+
+    return { checks, summary, exitCode, decision };
+  }
+
+  displayResult(result: DoctorResult, options: { json?: boolean } = {}): void {
+    // In JSON mode, this should never be called, but guard anyway
+    const log = options.json ? console.error : console.log;
+    
+    log(chalk.bold('\n📋 Rapport de Diagnostic QA360\n'));
+
+    result.checks.forEach(check => {
+      const icon = check.status === 'ok' ? '✅' : 
+                   check.status === 'warning' ? '⚠️' : '❌';
+      
+      log(`${icon} ${check.name}: ${check.message}`);
+      
+      if (check.code) {
+        log(chalk.gray(`   Code: ${check.code} - Utilisez 'qa360 explain ${check.code}' pour plus d'infos`));
+      }
+    });
+
+    log(chalk.bold('\n📊 Résumé:'));
+    log(`   Total: ${result.summary.total}`);
+    log(chalk.green(`   ✅ OK: ${result.summary.ok}`));
+    if (result.summary.fixed > 0) {
+      log(chalk.blue(`   🔧 Corrigés: ${result.summary.fixed}`));
+    }
+    log(chalk.yellow(`   ⚠️  Avertissements: ${result.summary.warnings}`));
+    log(chalk.red(`   ❌ Erreurs: ${result.summary.errors}`));
+    
+    // Show final decision
+    const decisionMsg = result.exitCode === 0 
+      ? chalk.green(`\n✅ After fixes: errors=${result.summary.errors} warnings=${result.summary.warnings} → exit 0`)
+      : chalk.red(`\n❌ After fixes: errors=${result.summary.errors} warnings=${result.summary.warnings} → exit 1`);
+    log(decisionMsg);
+
+    if (result.summary.warnings > 0 || result.summary.errors > 0) {
+      log(chalk.blue('\n💡 Conseil: Utilisez "qa360 doctor --fix" pour corriger automatiquement les problèmes'));
+    }
+  }
+}
+
+export async function doctorCommand(options: { 
+  fix?: boolean;
+  json?: boolean;
+  strict?: boolean;
+  skip?: string[];
+} = {}): Promise<void> {
+  const doctor = new QA360Doctor();
+  
+  try {
+    const result = await doctor.diagnose(options);
+    
+    if (options.json) {
+      // JSON output (stable for CI) - stdout ONLY, single line
+      process.stdout.write(JSON.stringify({
+        ok: result.exitCode === 0,
+        fixed: result.summary.fixed,
+        errors: result.summary.errors,
+        warnings: result.summary.warnings,
+        qa360Home: process.env.QA360_HOME || join(process.cwd(), '.qa360'),
+        decision: result.decision,
+        checks: result.checks.map(c => ({
+          id: c.id,
+          name: c.name,
+          status: c.status,
+          message: c.message,
+          code: c.code,
+          fixed: c.message.includes('corrigé automatiquement')
+        })),
+        summary: result.summary,
+      }) + '\n');
+    } else {
+      // Human-readable output
+      doctor.displayResult(result, options);
+    }
+    
+    // Exit code handling
+    if (options.strict && result.exitCode !== 0) {
+      process.exit(1);
+    } else {
+      process.exit(result.exitCode);
+    }
+  } catch (error) {
+    if (options.json) {
+      process.stdout.write(JSON.stringify({
+        ok: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      }) + '\n');
+    } else {
+      console.error(chalk.red('❌ Erreur lors du diagnostic:'), error);
+    }
+    process.exit(1);
+  }
+}