qa360 2.1.2 → 2.1.4

package/packages/mcp/src/cli/up.ts

@@ -0,0 +1,178 @@
+/**
+ * qa360-mcp up - Start MCP Server with auto-recovery
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { spawn, ChildProcess } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+interface UpOptions {
+  stdio?: boolean;
+  port?: string;
+  allowRun?: boolean;
+  allowSecrets?: boolean;
+  verbose?: boolean;
+}
+
+let serverProcess: ChildProcess | null = null;
+let restartCount = 0;
+const MAX_RESTARTS = 3;
+
+export async function upCommand(options: UpOptions): Promise<void> {
+  console.log(chalk.blue.bold('\n🚀 Starting QA360 MCP Server...\n'));
+
+  const mode = options.port ? 'http' : 'stdio';
+  const spinner = ora(`Starting server (mode: ${mode})`).start();
+
+  try {
+    // 1. Resolve MCP server path
+    const serverPath = await resolveMCPServerPath();
+    
+    if (!serverPath) {
+      spinner.fail('MCP server not found');
+      console.log(chalk.red('\n❌ @qa360/mcp-server not installed'));
+      console.log(chalk.yellow('💡 Try: qa360-mcp fix\n'));
+      process.exit(1);
+    }
+
+    spinner.succeed(`Server found: ${chalk.gray(serverPath)}`);
+
+    // 2. Build command args
+    const args: string[] = [];
+    
+    if (options.allowRun) {
+      args.push('--allow-run');
+    }
+    
+    if (options.allowSecrets) {
+      args.push('--allow-secrets');
+    }
+
+    if (options.port) {
+      args.push('--port', options.port);
+    }
+
+    // 3. Start server process
+    spinner.start('Launching MCP server');
+    
+    serverProcess = spawn('node', [serverPath, ...args], {
+      stdio: options.stdio ? ['inherit', 'inherit', 'inherit'] : 'pipe',
+      env: {
+        ...process.env,
+        QA360_HOME: process.env.QA360_HOME || path.join(process.env.HOME || '', '.qa360')
+      }
+    });
+
+    // 4. Handle server events
+    serverProcess.on('error', (error) => {
+      spinner.fail('Server failed to start');
+      console.error(chalk.red('\n❌ Error:'), error.message);
+      
+      if (restartCount < MAX_RESTARTS) {
+        console.log(chalk.yellow(`\n⚠️  Auto-restarting (${restartCount + 1}/${MAX_RESTARTS})...\n`));
+        restartCount++;
+        setTimeout(() => upCommand(options), 2000);
+      } else {
+        console.log(chalk.red('\n❌ Max restarts reached. Exiting.\n'));
+        process.exit(1);
+      }
+    });
+
+    serverProcess.on('exit', (code, signal) => {
+      if (code === 0) {
+        spinner.succeed('Server stopped gracefully');
+      } else {
+        spinner.fail(`Server exited with code ${code}`);
+        
+        if (restartCount < MAX_RESTARTS && !signal) {
+          console.log(chalk.yellow(`\n⚠️  Auto-restarting (${restartCount + 1}/${MAX_RESTARTS})...\n`));
+          restartCount++;
+          setTimeout(() => upCommand(options), 2000);
+        }
+      }
+    });
+
+    // 5. Wait for server ready
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    spinner.succeed('QA360 MCP Server started');
+
+    // 6. Display info
+    console.log(chalk.green.bold('\n✅ Server running\n'));
+    console.log(chalk.white('Mode:'), chalk.cyan(mode));
+    
+    if (options.port) {
+      console.log(chalk.white('Port:'), chalk.cyan(options.port));
+      console.log(chalk.white('URL:'), chalk.cyan(`http://localhost:${options.port}`));
+    }
+    
+    console.log(chalk.white('Permissions:'));
+    console.log(chalk.white('  --allow-run:'), options.allowRun ? chalk.green('✓') : chalk.gray('✗'));
+    console.log(chalk.white('  --allow-secrets:'), options.allowSecrets ? chalk.green('✓') : chalk.gray('✗'));
+    
+    console.log(chalk.white('\nTools loaded:'));
+    console.log(chalk.gray('  23 tools available (qa360.run, qa360.history.*, qa360.pack.*, etc.)'));
+    
+    console.log(chalk.white('\nNext:'));
+    console.log(chalk.cyan('  Try /qa360.health in \n'));
+
+    // 7. Graceful shutdown handlers
+    process.on('SIGINT', async () => {
+      console.log(chalk.yellow('\n\n⚠️  Shutting down gracefully...'));
+      if (serverProcess) {
+        serverProcess.kill('SIGTERM');
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        if (serverProcess && !serverProcess.killed) {
+          serverProcess.kill('SIGKILL');
+        }
+      }
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+      if (serverProcess) {
+        serverProcess.kill('SIGTERM');
+      }
+      process.exit(0);
+    });
+
+    // Keep process alive
+    await new Promise(() => {});
+
+  } catch (error) {
+    spinner.fail('Failed to start server');
+    console.error(chalk.red('\n❌ Error:'), error instanceof Error ? error.message : error);
+    console.log(chalk.yellow('\n💡 Try: qa360-mcp doctor\n'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Resolve MCP server path
+ */
+async function resolveMCPServerPath(): Promise<string | null> {
+  const fs = await import('fs-extra');
+  
+  const possiblePaths = [
+    // Built-in full server (merged from mcp-server-qa360)
+    path.join(path.dirname(fileURLToPath(import.meta.url)), '../server/full-server.js'),
+    // Workspace (development)
+    path.join(process.cwd(), '../../mcp-server-qa360/dist/index.js'),
+    // Global npm
+    path.join(process.env.HOME || '', '.npm-global/lib/node_modules/@qa360/mcp-server/dist/index.js'),
+    // Local node_modules
+    path.join(process.cwd(), 'node_modules/@qa360/mcp-server/dist/index.js'),
+    // Package relative
+    path.join(path.dirname(fileURLToPath(import.meta.url)), '../../node_modules/@qa360/mcp-server/dist/index.js')
+  ];
+  
+  for (const p of possiblePaths) {
+    if (await fs.pathExists(p)) {
+      return p;
+    }
+  }
+
+  return null;
+}

package/packages/mcp/src/index.ts

@@ -0,0 +1,12 @@
+/**
+ * QA360 MCP CLI - Main entry point
+ * Export all commands for programmatic use
+ */
+
+export { initCommand } from './cli/init.js';
+export { upCommand } from './cli/up.js';
+export { doctorCommand } from './cli/doctor.js';
+export { fixCommand } from './cli/fix.js';
+export { resetCommand } from './cli/reset.js';
+export { uninstallCommand } from './cli/uninstall.js';
+export { testDxCommand } from './cli/test-dx.js';

package/packages/mcp/src/scripts/e2e-local.ts

@@ -0,0 +1,337 @@
+/**
+ * e2e-local.ts - Local E2E black-box testing
+ * 
+ * Simulates fresh user installation and validates:
+ * 1. Installation time < 3 min
+ * 2. Zero manual configuration
+ * 3. Auto-config 
+ * 4. Server startup
+ * 5. Health checks
+ * 6. Clean uninstall
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+const execAsync = promisify(exec);
+
+interface TestResult {
+  name: string;
+  passed: boolean;
+  duration: number;
+  message: string;
+  error?: string;
+}
+
+async function measureTime<T>(fn: () => Promise<T>): Promise<[T, number]> {
+  const start = Date.now();
+  const result = await fn();
+  const duration = Date.now() - start;
+  return [result, duration];
+}
+
+async function testInstallation(): Promise<TestResult> {
+  console.log('📦 Testing installation...');
+  
+  try {
+    const [, duration] = await measureTime(async () => {
+      // Simulate global install (in real scenario, would be npm i -g)
+      // For local testing, just verify binary exists
+      const { stdout } = await execAsync('which qa360-mcp');
+      return stdout.trim();
+    });
+
+    if (duration > 180000) { // 3 minutes
+      return {
+        name: 'Installation',
+        passed: false,
+        duration,
+        message: `Installation took ${(duration / 1000).toFixed(1)}s (> 180s limit)`
+      };
+    }
+
+    return {
+      name: 'Installation',
+      passed: true,
+      duration,
+      message: `Completed in ${(duration / 1000).toFixed(1)}s`
+    };
+  } catch (error) {
+    return {
+      name: 'Installation',
+      passed: false,
+      duration: 0,
+      message: 'Binary not found',
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+async function testInit(): Promise<TestResult> {
+  console.log('⚙️  Testing init (non-interactive)...');
+  
+  try {
+    const [, duration] = await measureTime(async () => {
+      const { stdout, stderr } = await execAsync('qa360-mcp init --non-interactive --force');
+      return { stdout, stderr };
+    });
+
+    // Verify settings.json was modified with proper JSON parsing
+    const settingsPaths = [
+      path.join(os.homedir(), 'Library/Application Support/Code/User/settings.json'),
+      path.join(os.homedir(), '.config/Code/User/settings.json'),
+      path.join(os.homedir(), 'AppData/Roaming/Code/User/settings.json')
+    ];
+
+    let settingsFound = false;
+    let settingsPath = '';
+    for (const p of settingsPaths) {
+      if (await fs.pathExists(p)) {
+        settingsPath = p;
+        try {
+          const content = await fs.readFile(p, 'utf-8');
+          // Remove comments and parse JSON
+          const jsonContent = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+          const settings = JSON.parse(jsonContent);
+          
+          // Check for QA360 in either MCP key variant
+          if (settings['claude.mcpServers']?.qa360 || settings['claude.experimental.mcpServers']?.qa360) {
+            settingsFound = true;
+            break;
+          }
+        } catch (parseError) {
+          // If JSON parsing fails, fall back to simple string check
+          const content = await fs.readFile(p, 'utf-8');
+          if (content.includes('"qa360"') && content.includes('qa360-mcp-server')) {
+            settingsFound = true;
+            break;
+          }
+        }
+      }
+    }
+
+    if (!settingsFound) {
+      return {
+        name: 'Init',
+        passed: false,
+        duration,
+        message: 'Settings.json not configured',
+        error: `QA360 MCP block not found in VS Code settings (checked: ${settingsPath})`
+      };
+    }
+
+    return {
+      name: 'Init',
+      passed: true,
+      duration,
+      message: `Configured in ${(duration / 1000).toFixed(1)}s`
+    };
+  } catch (error) {
+    return {
+      name: 'Init',
+      passed: false,
+      duration: 0,
+      message: 'Init failed',
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+async function testDoctor(): Promise<TestResult> {
+  console.log('🔍 Testing doctor (JSON output)...');
+  
+  try {
+    const [result, duration] = await measureTime(async () => {
+      const { stdout } = await execAsync('qa360-mcp doctor --json');
+      return JSON.parse(stdout);
+    });
+
+    // Validate JSON structure
+    if (!result.summary || !result.checks) {
+      return {
+        name: 'Doctor',
+        passed: false,
+        duration,
+        message: 'Invalid JSON output',
+        error: 'Missing required fields: summary, checks'
+      };
+    }
+
+    const status = result.summary.status;
+    if (status === 'error') {
+      return {
+        name: 'Doctor',
+        passed: false,
+        duration,
+        message: 'Health checks failed',
+        error: `${result.summary.errors} error(s) detected`
+      };
+    }
+
+    return {
+      name: 'Doctor',
+      passed: true,
+      duration,
+      message: `All checks passed (${result.summary.passed}/${result.summary.total})`
+    };
+  } catch (error) {
+    return {
+      name: 'Doctor',
+      passed: false,
+      duration: 0,
+      message: 'Doctor failed',
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+async function testServerStartup(): Promise<TestResult> {
+  console.log('🚀 Testing server startup...');
+  
+  try {
+    const [, duration] = await measureTime(async () => {
+      // Start server in background, wait 5s, then kill
+      const child = exec('qa360-mcp up --stdio');
+      
+      await new Promise(resolve => setTimeout(resolve, 5000));
+      
+      if (child.pid) {
+        process.kill(child.pid, 'SIGTERM');
+      }
+      
+      return true;
+    });
+
+    return {
+      name: 'Server Startup',
+      passed: true,
+      duration,
+      message: `Started successfully (tested for 5s)`
+    };
+  } catch (error) {
+    return {
+      name: 'Server Startup',
+      passed: false,
+      duration: 0,
+      message: 'Server failed to start',
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+async function testUninstall(): Promise<TestResult> {
+  console.log('🗑️  Testing uninstall...');
+  
+  try {
+    const [, duration] = await measureTime(async () => {
+      await execAsync('qa360-mcp uninstall --force');
+      return true;
+    });
+
+    // Verify settings.json was cleaned
+    const settingsPaths = [
+      path.join(os.homedir(), 'Library/Application Support/Code/User/settings.json'),
+      path.join(os.homedir(), '.config/Code/User/settings.json'),
+      path.join(os.homedir(), 'AppData/Roaming/Code/User/settings.json')
+    ];
+
+    for (const p of settingsPaths) {
+      if (await fs.pathExists(p)) {
+        const content = await fs.readFile(p, 'utf-8');
+        if (content.includes('qa360')) {
+          return {
+            name: 'Uninstall',
+            passed: false,
+            duration,
+            message: 'Settings.json not cleaned',
+            error: 'QA360 MCP block still present after uninstall'
+          };
+        }
+      }
+    }
+
+    return {
+      name: 'Uninstall',
+      passed: true,
+      duration,
+      message: `Cleaned in ${(duration / 1000).toFixed(1)}s`
+    };
+  } catch (error) {
+    return {
+      name: 'Uninstall',
+      passed: false,
+      duration: 0,
+      message: 'Uninstall failed',
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+async function main() {
+  console.log('🧪 QA360 MCP CLI - E2E Black-Box Testing\n');
+  console.log('─'.repeat(60));
+  console.log();
+
+  const results: TestResult[] = [];
+
+  // Test 1: Installation
+  const installResult = await testInstallation();
+  results.push(installResult);
+  console.log(installResult.passed ? '✅' : '❌', installResult.message);
+  if (installResult.error) console.log('   Error:', installResult.error);
+  console.log();
+
+  // Test 2: Init
+  const initResult = await testInit();
+  results.push(initResult);
+  console.log(initResult.passed ? '✅' : '❌', initResult.message);
+  if (initResult.error) console.log('   Error:', initResult.error);
+  console.log();
+
+  // Test 3: Doctor
+  const doctorResult = await testDoctor();
+  results.push(doctorResult);
+  console.log(doctorResult.passed ? '✅' : '❌', doctorResult.message);
+  if (doctorResult.error) console.log('   Error:', doctorResult.error);
+  console.log();
+
+  // Test 4: Server Startup
+  const serverResult = await testServerStartup();
+  results.push(serverResult);
+  console.log(serverResult.passed ? '✅' : '❌', serverResult.message);
+  if (serverResult.error) console.log('   Error:', serverResult.error);
+  console.log();
+
+  // Test 5: Uninstall
+  const uninstallResult = await testUninstall();
+  results.push(uninstallResult);
+  console.log(uninstallResult.passed ? '✅' : '❌', uninstallResult.message);
+  if (uninstallResult.error) console.log('   Error:', uninstallResult.error);
+  console.log();
+
+  // Summary
+  console.log('─'.repeat(60));
+  const passed = results.filter(r => r.passed).length;
+  const total = results.length;
+  const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+
+  console.log(`\n📊 Results: ${passed}/${total} tests passed`);
+  console.log(`⏱️  Total duration: ${(totalDuration / 1000).toFixed(1)}s`);
+  console.log();
+
+  if (passed === total) {
+    console.log('✅ All E2E tests passed\n');
+    process.exit(0);
+  } else {
+    console.log('❌ Some E2E tests failed\n');
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error('💥 Fatal error:', error);
+  process.exit(1);
+});