qa360 2.1.2 → 2.1.4

package/cli/src/commands/scan.ts

@@ -0,0 +1,177 @@
+/**
+ * Scan Command - Discover UI elements from a web page
+ */
+
+import { Command } from 'commander';
+import { chromium, type Browser, type BrowserContext, type Page } from '@playwright/test';
+import { DOMScanner } from '../scanners/dom-scanner.js';
+import { JSONReporter } from '../generators/json-reporter.js';
+import { TestGenerator } from '../generators/test-generator.js';
+import type { ScanOptions, ElementType, ScanResult, ScanSummary } from '../types/scan.js';
+import { resolve } from 'path';
+import { mkdirSync } from 'fs';
+
+export const scanCommand = new Command('scan');
+
+scanCommand
+  .description('Scan a web page for UI elements and generate test configurations')
+  .argument('<url>', 'URL of the page to scan')
+  .option('-o, --output <file>', 'Output file path (default: ".qa360/discovery/elements.json")')
+  .option('-i, --include <types>', 'Element types to include: buttons,links,forms,inputs,images,headings,all (default: "all")')
+  .option('-e, --exclude <selectors>', 'CSS selectors to exclude (comma-separated)')
+  .option('-s, --screenshot', 'Capture screenshots of elements (not yet implemented)')
+  .option('-a, --auto-generate-test', 'Auto-generate QA360 test file')
+  .option('-t, --timeout <ms>', 'Navigation timeout in milliseconds', '30000')
+  .option('--headed', 'Run in headed mode (show browser)')
+  .action(async (url: string, options) => {
+    const startTime = Date.now();
+
+    // Validate URL
+    try {
+      new URL(url);
+    } catch {
+      console.error(`❌ Invalid URL: ${url}`);
+      process.exit(1);
+    }
+
+    // Parse include types
+    const includeTypes = options.include || 'all';
+    const include: ElementType[] = includeTypes
+      .split(',')
+      .map((t: string) => t.trim().toLowerCase() as ElementType);
+
+    // Validate element types
+    const validTypes: ElementType[] = ['buttons', 'links', 'forms', 'inputs', 'images', 'headings', 'all'];
+    for (const type of include) {
+      if (!validTypes.includes(type)) {
+        console.error(`❌ Invalid element type: ${type}`);
+        console.error(`   Valid types: ${validTypes.join(', ')}`);
+        process.exit(1);
+      }
+    }
+
+    // Parse exclude selectors
+    const exclude = options.exclude
+      ? options.exclude.split(',').map((s: string) => s.trim())
+      : [];
+
+    const scanOptions: ScanOptions = {
+      url,
+      output: options.output || '.qa360/discovery/elements.json',
+      include,
+      exclude,
+      screenshot: options.screenshot || false,
+      autoGenerateTest: options.autoGenerateTest || false,
+      timeout: parseInt(options.timeout, 10) || 30000,
+      headless: !options.headed
+    };
+
+    console.log(`🔍 Scanning page: ${url}`);
+    console.log('━'.repeat(50));
+
+    let browser: Browser | null = null;
+    let context: BrowserContext | null = null;
+    let page: Page | null = null;
+
+    try {
+      // Launch browser
+      browser = await chromium.launch({
+        headless: scanOptions.headless
+      });
+
+      context = await browser.newContext({
+        viewport: { width: 1280, height: 720 }
+      });
+
+      page = await context.newPage();
+
+      // Navigate to URL
+      await page.goto(url, {
+        timeout: scanOptions.timeout,
+        waitUntil: 'networkidle'
+      });
+
+      // Run scan
+      const scanner = new DOMScanner(page, url);
+      const elements = await scanner.scan(scanOptions);
+
+      // Generate summary
+      const summary: ScanSummary = {
+        totalElements: elements.length,
+        buttons: elements.filter(e => e.type === 'button').length,
+        links: elements.filter(e => e.type === 'link').length,
+        forms: elements.filter(e => e.type === 'form').length,
+        inputs: elements.filter(e => e.type === 'input').length,
+        images: elements.filter(e => e.type === 'image').length,
+        headings: elements.filter(e => e.type === 'heading').length
+      };
+
+      // Print summary
+      console.log(`✅ Buttons found:      ${summary.buttons}`);
+      console.log(`✅ Links found:        ${summary.links}`);
+      console.log(`✅ Forms found:        ${summary.forms}`);
+      console.log(`✅ Inputs found:       ${summary.inputs}`);
+      console.log(`✅ Images found:       ${summary.images}`);
+      console.log(`✅ Headings found:     ${summary.headings}`);
+      console.log('━'.repeat(50));
+      console.log(`📦 Total elements:     ${summary.totalElements}`);
+      console.log();
+
+      // Create output directory
+      const outputPath = resolve(scanOptions.output!);
+      const outputDir = outputPath.substring(0, outputPath.lastIndexOf('/'));
+      mkdirSync(outputDir, { recursive: true });
+
+      // Generate scan result
+      const result: ScanResult = {
+        scanDate: new Date().toISOString(),
+        url,
+        duration: Date.now() - startTime,
+        summary,
+        elements
+      };
+
+      // Generate JSON report
+      const reporter = new JSONReporter();
+      await reporter.generate(result, outputPath);
+      console.log(`💾 Saved to: ${outputPath}`);
+
+      // Auto-generate test if requested
+      if (options.autoGenerateTest) {
+        const testGenerator = new TestGenerator();
+        const testPath = outputPath.replace('.json', '.yml');
+        await testGenerator.generate(result, testPath);
+        console.log(`📄 Test generated: ${testPath}`);
+      }
+
+      // Screenshots (placeholder for future implementation)
+      if (options.screenshot) {
+        console.log(`📸 Screenshots: ${outputDir}/screenshots/ (not yet implemented)`);
+      }
+
+      // Cleanup
+      await page.close();
+      await context.close();
+      await browser.close();
+
+      console.log();
+      console.log(`✨ Scan completed in ${((Date.now() - startTime) / 1000).toFixed(1)}s`);
+      console.log();
+      console.log('💡 Next steps:');
+      console.log(`   • Review the discovered elements`);
+      if (options.autoGenerateTest) {
+        console.log(`   • Run the auto-generated test: qa360 run ${outputPath.replace('.json', '.yml')}`);
+      }
+      console.log(`   • Edit the test to remove unwanted elements`);
+
+    } catch (error) {
+      // Cleanup on error
+      if (page) await page.close().catch(() => {});
+      if (context) await context.close().catch(() => {});
+      if (browser) await browser.close().catch(() => {});
+
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`❌ Scan failed: ${errorMessage}`);
+      process.exit(1);
+    }
+  });

package/cli/src/commands/secrets.ts

@@ -0,0 +1,340 @@
+/**
+ * QA360 Secrets Commands
+ * Implements secrets add, list, remove, doctor, export commands
+ */
+
+import { readFileSync } from 'fs';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { SecretsManager, SecretsCrypto } from 'qa360-core';
+
+export class QA360Secrets {
+  private manager: SecretsManager;
+
+  constructor() {
+    this.manager = new SecretsManager();
+  }
+
+  /**
+   * Add a secret
+   */
+  async add(secretName?: string, options: { value?: string; nonInteractive?: boolean } = {}): Promise<{ success: boolean; exitCode: number }> {
+    try {
+      let name = secretName;
+      let value: string;
+
+      // Interactive mode if no name provided (and not non-interactive)
+      if (!name) {
+        if (options.nonInteractive) {
+          console.log(chalk.red('❌ Nom du secret requis en mode non-interactif'));
+          console.log(chalk.yellow('💡 Usage: qa360 secrets add <NOM> --value <VALUE> --non-interactive'));
+          return { success: false, exitCode: 1 };
+        }
+        const nameAnswer = await inquirer.prompt([{
+          type: 'input',
+          name: 'secretName',
+          message: 'Nom du secret (ex: API_TOKEN):',
+          validate: (input: string) => {
+            if (!/^[A-Z_][A-Z0-9_]*$/.test(input)) {
+              return 'Le nom doit être en majuscules avec des underscores (ex: API_TOKEN)';
+            }
+            return true;
+          }
+        }]);
+        name = nameAnswer.secretName;
+      }
+
+      // Validate name format
+      if (!/^[A-Z_][A-Z0-9_]*$/.test(name!)) {
+        console.log(chalk.red('❌ Nom invalide'));
+        console.log(chalk.yellow('💡 Format requis: MAJUSCULES_AVEC_UNDERSCORES (ex: API_TOKEN)'));
+        return { success: false, exitCode: 1 };
+      }
+
+      // Get secret value
+      if (options.value) {
+        // Non-interactive mode: value provided via option
+        value = options.value;
+      } else {
+        // Interactive mode: prompt for value
+        const valueAnswer = await inquirer.prompt([{
+          type: 'password',
+          name: 'secretValue',
+          message: `Valeur pour ${name}:`,
+          mask: '*',
+          validate: (input: string) => {
+            if (!input.trim()) {
+              return 'La valeur ne peut pas être vide';
+            }
+            return true;
+          }
+        }]);
+        value = valueAnswer.secretValue;
+      }
+
+      // Check if it looks like a secret (skip in non-interactive mode)
+      if (!options.nonInteractive && !SecretsCrypto.looksLikeSecret(value)) {
+        const confirmAnswer = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Cette valeur ne ressemble pas à un secret. Continuer ?',
+          default: false
+        }]);
+
+        if (!confirmAnswer.confirm) {
+          console.log(chalk.yellow('⚠️  Opération annulée'));
+          return { success: false, exitCode: 0 };
+        }
+      }
+
+      const spinner = ora('🔐 Ajout du secret...').start();
+
+      // Add secret
+      await this.manager.addSecret(name!, value);
+
+      spinner.succeed(chalk.green('✅ Secret ajouté avec succès'));
+      console.log(chalk.blue(`🔑 Secret: ${name}`));
+      console.log(chalk.gray(`📁 Stocké dans: .qa360/secrets.enc`));
+      console.log(chalk.blue(`💡 Utilisation: \${{ secrets.${name} }}`));
+
+      return { success: true, exitCode: 0 };
+
+    } catch (error) {
+      console.log(chalk.red('❌ Erreur lors de l\'ajout du secret'));
+      console.log(chalk.red(`🔍 Erreur: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      return { success: false, exitCode: 1 };
+    }
+  }
+
+  /**
+   * List secrets
+   */
+  async list(): Promise<{ success: boolean; exitCode: number }> {
+    const spinner = ora('🔍 Chargement des secrets...').start();
+
+    try {
+      const secrets = await this.manager.listSecrets();
+
+      if (secrets.length === 0) {
+        spinner.succeed(chalk.yellow('📭 Aucun secret configuré'));
+        console.log(chalk.blue('💡 Utilisez: qa360 secrets add <NOM>'));
+        return { success: true, exitCode: 0 };
+      }
+
+      spinner.succeed(chalk.green(`✅ ${secrets.length} secret(s) trouvé(s)`));
+
+      console.log(chalk.blue('\n🔐 Secrets configurés:'));
+      for (const secret of secrets) {
+        const createdDate = new Date(secret.createdAt).toLocaleDateString('fr-FR');
+        const updatedDate = new Date(secret.updatedAt).toLocaleDateString('fr-FR');
+        
+        console.log(chalk.green(`  • ${secret.name}`));
+        console.log(chalk.gray(`    📅 Créé: ${createdDate}`));
+        if (secret.createdAt !== secret.updatedAt) {
+          console.log(chalk.gray(`    🔄 Modifié: ${updatedDate}`));
+        }
+        console.log(chalk.blue(`    💡 Usage: \${{ secrets.${secret.name} }}`));
+      }
+
+      return { success: true, exitCode: 0 };
+
+    } catch (error) {
+      spinner.fail(chalk.red('❌ Erreur lors du chargement'));
+      console.log(chalk.red(`🔍 Erreur: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      return { success: false, exitCode: 1 };
+    }
+  }
+
+  /**
+   * Remove a secret
+   */
+  async remove(secretName?: string): Promise<{ success: boolean; exitCode: number }> {
+    try {
+      let name = secretName;
+
+      // Interactive selection if no name provided
+      if (!name) {
+        const secrets = await this.manager.listSecrets();
+        
+        if (secrets.length === 0) {
+          console.log(chalk.yellow('📭 Aucun secret à supprimer'));
+          return { success: true, exitCode: 0 };
+        }
+
+        const selectAnswer = await inquirer.prompt([{
+          type: 'list',
+          name: 'secretName',
+          message: 'Secret à supprimer:',
+          choices: secrets.map(s => s.name)
+        }]);
+        name = selectAnswer.secretName;
+      }
+
+      // Confirm deletion
+      const confirmAnswer = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: `Supprimer définitivement le secret "${name}" ?`,
+        default: false
+      }]);
+
+      if (!confirmAnswer.confirm) {
+        console.log(chalk.yellow('⚠️  Suppression annulée'));
+        return { success: false, exitCode: 0 };
+      }
+
+      const spinner = ora('🗑️  Suppression du secret...').start();
+
+      const removed = await this.manager.removeSecret(name!);
+
+      if (removed) {
+        spinner.succeed(chalk.green('✅ Secret supprimé'));
+        console.log(chalk.blue(`🔑 Secret supprimé: ${name}`));
+      } else {
+        spinner.fail(chalk.red('❌ Secret non trouvé'));
+        return { success: false, exitCode: 1 };
+      }
+
+      return { success: true, exitCode: 0 };
+
+    } catch (error) {
+      console.log(chalk.red('❌ Erreur lors de la suppression'));
+      console.log(chalk.red(`🔍 Erreur: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      return { success: false, exitCode: 1 };
+    }
+  }
+
+  /**
+   * Doctor check for secrets
+   */
+  async doctor(): Promise<{ success: boolean; exitCode: number }> {
+    const spinner = ora('🔍 Diagnostic des secrets...').start();
+
+    try {
+      const diagnosis = await this.manager.doctor();
+
+      if (diagnosis.errors.length === 0) {
+        spinner.succeed(chalk.green('✅ Système de secrets opérationnel'));
+        
+        console.log(chalk.blue('\n📋 État des secrets:'));
+        console.log(chalk.gray(`  📁 Fichier: ${diagnosis.exists ? 'Présent' : 'Absent'}`));
+        console.log(chalk.gray(`  🔓 Accessible: ${diagnosis.accessible ? 'Oui' : 'Non'}`));
+        console.log(chalk.gray(`  🔢 Nombre: ${diagnosis.count} secret(s)`));
+
+        if (diagnosis.count === 0) {
+          console.log(chalk.yellow('\n💡 Aucun secret configuré'));
+          console.log(chalk.blue('   Utilisez: qa360 secrets add <NOM>'));
+        }
+
+        return { success: true, exitCode: 0 };
+      } else {
+        spinner.fail(chalk.red('❌ Problèmes détectés'));
+        
+        console.log(chalk.red('\n🔍 Erreurs:'));
+        for (const error of diagnosis.errors) {
+          console.log(chalk.red(`  • ${error}`));
+        }
+
+        console.log(chalk.blue('\n💡 Solutions:'));
+        console.log(chalk.blue('  • Vérifiez les permissions du fichier .qa360/secrets.enc'));
+        console.log(chalk.blue('  • Essayez: qa360 secrets add <NOM> pour initialiser'));
+
+        return { success: false, exitCode: 1 };
+      }
+
+    } catch (error) {
+      spinner.fail(chalk.red('❌ Erreur de diagnostic'));
+      console.log(chalk.red(`🔍 Erreur: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      return { success: false, exitCode: 1 };
+    }
+  }
+
+  /**
+   * Export secrets in redacted format
+   */
+  async export(options: { redacted?: boolean } = {}): Promise<{ success: boolean; exitCode: number }> {
+    const spinner = ora('📤 Export des secrets...').start();
+
+    try {
+      const redacted = options.redacted !== false; // Default to redacted
+      
+      if (redacted) {
+        const secrets = await this.manager.exportRedacted();
+        
+        spinner.succeed(chalk.green('✅ Export réussi (valeurs masquées)'));
+        
+        if (Object.keys(secrets).length === 0) {
+          console.log(chalk.yellow('\n📭 Aucun secret à exporter'));
+          return { success: true, exitCode: 0 };
+        }
+
+        console.log(chalk.blue('\n🔐 Secrets (valeurs masquées):'));
+        for (const [name, redactedValue] of Object.entries(secrets)) {
+          console.log(chalk.green(`  ${name}: ${redactedValue}`));
+        }
+      } else {
+        // Non-redacted export (dangerous, require confirmation)
+        const confirmAnswer = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirm',
+          message: '⚠️  ATTENTION: Export des valeurs en clair. Continuer ?',
+          default: false
+        }]);
+
+        if (!confirmAnswer.confirm) {
+          spinner.stop();
+          console.log(chalk.yellow('⚠️  Export annulé'));
+          return { success: false, exitCode: 0 };
+        }
+
+        const secrets = await this.manager.listSecrets();
+        spinner.succeed(chalk.yellow('⚠️  Export réussi (valeurs en clair)'));
+        
+        console.log(chalk.red('\n⚠️  SECRETS EN CLAIR - NE PAS PARTAGER:'));
+        for (const secret of secrets) {
+          const value = await this.manager.getSecret(secret.name);
+          console.log(chalk.red(`  ${secret.name}: ${value}`));
+        }
+      }
+
+      return { success: true, exitCode: 0 };
+
+    } catch (error) {
+      spinner.fail(chalk.red('❌ Erreur d\'export'));
+      console.log(chalk.red(`🔍 Erreur: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      return { success: false, exitCode: 1 };
+    }
+  }
+}
+
+// Command handlers
+export async function secretsAddCommand(secretName?: string, options?: { value?: string; nonInteractive?: boolean }) {
+  const secrets = new QA360Secrets();
+  const result = await secrets.add(secretName, options);
+  process.exit(result.exitCode);
+}
+
+export async function secretsListCommand() {
+  const secrets = new QA360Secrets();
+  const result = await secrets.list();
+  process.exit(result.exitCode);
+}
+
+export async function secretsRemoveCommand(secretName?: string) {
+  const secrets = new QA360Secrets();
+  const result = await secrets.remove(secretName);
+  process.exit(result.exitCode);
+}
+
+export async function secretsDoctorCommand() {
+  const secrets = new QA360Secrets();
+  const result = await secrets.doctor();
+  process.exit(result.exitCode);
+}
+
+export async function secretsExportCommand(options: { redacted?: boolean } = {}) {
+  const secrets = new QA360Secrets();
+  const result = await secrets.export(options);
+  process.exit(result.exitCode);
+}