cbrowser 6.3.2 → 6.5.0

package/dist/cli.js

@@ -10,11 +10,12 @@ const browser_js_1 = require("./browser.js");
 const personas_js_1 = require("./personas.js");
 const types_js_1 = require("./types.js");
 const mcp_server_js_1 = require("./mcp-server.js");
+const daemon_js_1 = require("./daemon.js");
 function showHelp() {
     console.log(`
 ╔══════════════════════════════════════════════════════════════════════════════╗
-║                           CBrowser CLI v6.3.0                                ║
-║    AI-powered browser automation with flaky test detection                   ║
+║                           CBrowser CLI v6.5.0                                ║
+║    AI-powered browser automation with test coverage mapping                  ║
 ╚══════════════════════════════════════════════════════════════════════════════╝
 
 NAVIGATION
@@ -98,6 +99,26 @@ FLAKY TEST DETECTION (v6.3.0)
       cbrowser flaky-check tests.txt --runs 10
       cbrowser flaky-check tests.txt --runs 5 --threshold 30 --output flaky-report.json
 
+TEST COVERAGE MAP (v6.5.0)
+  coverage <url>               Generate test coverage map for a site
+    --tests <glob>             Test files to analyze (default: tests/*.txt)
+    --sitemap <url>            Use sitemap.xml instead of crawling
+    --max-pages <n>            Max pages to crawl (default: 100)
+    --include <pattern>        Only include paths matching pattern
+    --exclude <pattern>        Exclude paths matching pattern
+    --min-coverage <n>         Min coverage % to not flag (default: 50)
+    --html                     Generate HTML report
+    --output <file>            Save JSON report to file
+    Examples:
+      cbrowser coverage "https://example.com" --tests "tests/*.txt"
+      cbrowser coverage "https://example.com" --sitemap "https://example.com/sitemap.xml"
+      cbrowser coverage "https://example.com" --html --output coverage.html
+      cbrowser coverage "https://example.com" --exclude "/admin" --min-coverage 70
+
+  coverage gaps <url>          Show only untested pages (quick analysis)
+    --tests <glob>             Test files to analyze
+    --sitemap <url>            Use sitemap.xml
+
 PERSONAS
   persona list                List all personas (built-in + custom)
   persona create "<desc>"     Create persona from natural language description
@@ -147,6 +168,27 @@ PERFORMANCE
     --budget-fcp <ms>         FCP budget (default: 1800)
     --budget-cls <score>      CLS budget (default: 0.1)
 
+PERFORMANCE REGRESSION (v6.4.0)
+  perf-baseline save <url>    Capture and save performance baseline
+    --name <name>             Human-readable name for baseline
+    --runs <n>                Number of runs to average (default: 3)
+    Examples:
+      cbrowser perf-baseline save "https://example.com" --name "homepage"
+      cbrowser perf-baseline save "https://example.com/checkout" --runs 5
+
+  perf-baseline list          List all saved baselines
+  perf-baseline show <name>   Show baseline details
+  perf-baseline delete <name> Delete a baseline
+
+  perf-regression <url> <baseline>  Compare current performance against baseline
+    --threshold-lcp <n>       Max LCP increase % (default: 20)
+    --threshold-cls <n>       Max CLS increase (default: 0.1)
+    --threshold-fcp <n>       Max FCP increase % (default: 20)
+    --output <file>           Save JSON report to file
+    Examples:
+      cbrowser perf-regression "https://example.com" homepage
+      cbrowser perf-regression "https://example.com" homepage --threshold-lcp 30
+
 NETWORK / HAR
   har start                   Start recording HAR
   har stop [output]           Stop and save HAR file
@@ -259,6 +301,16 @@ MCP SERVER (v5.0.0)
   mcp-server                  Start CBrowser as MCP server for Claude integration
                               Use with Claude Desktop or other MCP-compatible clients
 
+DAEMON MODE (v6.4.0)
+  daemon start                Start background daemon (keeps browser running)
+    --port <port>             Daemon port (default: 9222)
+    --timeout <min>           Idle timeout in minutes (default: 30)
+  daemon stop                 Stop the running daemon
+  daemon status               Check if daemon is running
+  daemon run                  Run daemon in foreground (internal use)
+    Note: When daemon is running, all commands automatically connect to it
+          instead of launching a new browser - much faster for iteration!
+
 STORAGE & CLEANUP
   storage                     Show storage usage statistics
   cleanup                     Clean up old files
@@ -661,6 +713,90 @@ async function main() {
         await (0, mcp_server_js_1.startMcpServer)();
         return;
     }
+    // Daemon mode commands
+    if (command === "daemon") {
+        const subCommand = args[0];
+        const port = parseInt(options.port) || 9222;
+        switch (subCommand) {
+            case "start": {
+                console.log("🚀 Starting CBrowser daemon...");
+                const result = await (0, daemon_js_1.startDaemon)(port);
+                console.log(result.success ? `✓ ${result.message}` : `✗ ${result.message}`);
+                process.exit(result.success ? 0 : 1);
+                break;
+            }
+            case "stop": {
+                console.log("🛑 Stopping CBrowser daemon...");
+                const result = await (0, daemon_js_1.stopDaemon)();
+                console.log(result.success ? `✓ ${result.message}` : `✗ ${result.message}`);
+                process.exit(0);
+                break;
+            }
+            case "status": {
+                const status = await (0, daemon_js_1.getDaemonStatus)();
+                console.log(status);
+                process.exit(0);
+                break;
+            }
+            case "run": {
+                // Internal: run daemon in foreground
+                console.log("🔧 Running daemon in foreground mode...");
+                const browserType = options.browser === "firefox" ? "firefox"
+                    : options.browser === "webkit" ? "webkit"
+                        : "chromium";
+                // runDaemonServer will merge with defaults internally
+                await (0, daemon_js_1.runDaemonServer)({
+                    browser: browserType,
+                    headless: options.headless !== false && options.headless !== "false",
+                }, port);
+                return;
+            }
+            default:
+                console.error(`Unknown daemon command: ${subCommand}`);
+                console.error("Use: daemon start | daemon stop | daemon status");
+                process.exit(1);
+        }
+        return;
+    }
+    // Check if daemon is running and use it for supported commands
+    const daemonRunning = await (0, daemon_js_1.isDaemonRunning)();
+    if (daemonRunning && ["navigate", "click", "fill", "screenshot", "extract", "run"].includes(command)) {
+        console.log("🔌 Connected to running daemon");
+        let daemonCommand = command;
+        let daemonArgs = {};
+        switch (command) {
+            case "navigate":
+                daemonArgs = { url: args[0] };
+                break;
+            case "click":
+                daemonArgs = { selector: args[0] };
+                break;
+            case "fill":
+                daemonArgs = { selector: args[0], value: args[1] };
+                break;
+            case "screenshot":
+                daemonArgs = { path: args[0] };
+                break;
+            case "extract":
+                daemonArgs = { what: args[0] };
+                break;
+            case "run":
+                daemonArgs = { command: args.join(" ") };
+                break;
+        }
+        const result = await (0, daemon_js_1.sendToDaemon)(daemonCommand, daemonArgs);
+        if (result.success) {
+            console.log("✓ Command executed via daemon");
+            if (result.result) {
+                console.log(JSON.stringify(result.result, null, 2));
+            }
+        }
+        else {
+            console.error(`✗ Daemon error: ${result.error}`);
+            process.exit(1);
+        }
+        return;
+    }
     // Parse browser type
     const browserType = options.browser === "firefox" ? "firefox"
         : options.browser === "webkit" ? "webkit"
@@ -2551,6 +2687,303 @@ async function main() {
                 }
                 break;
             }
+            // =========================================================================
+            // Performance Regression Detection (Tier 6 - v6.4.0)
+            // =========================================================================
+            case "perf-baseline": {
+                const subcommand = args[0];
+                const fs = await import("fs");
+                switch (subcommand) {
+                    case "save": {
+                        const url = args[1];
+                        if (!url) {
+                            console.error("Usage: cbrowser perf-baseline save <url> [--name <name>] [--runs <n>]");
+                            process.exit(1);
+                        }
+                        console.log(`\n📊 Capturing performance baseline for: ${url}`);
+                        const baselineOptions = {
+                            headless,
+                            name: options.name,
+                            runs: options.runs ? parseInt(options.runs) : 3,
+                        };
+                        console.log(`   Running ${baselineOptions.runs} measurement(s)...`);
+                        const baseline = await (0, browser_js_1.capturePerformanceBaseline)(url, baselineOptions);
+                        console.log(`\n✅ Baseline saved: ${baseline.name}`);
+                        console.log(`   ID: ${baseline.id}`);
+                        console.log(`   URL: ${baseline.url}`);
+                        console.log(`   Timestamp: ${new Date(baseline.timestamp).toLocaleString()}`);
+                        console.log(`\n📈 Metrics (averaged over ${baseline.runsAveraged} runs):`);
+                        if (baseline.metrics.lcp !== undefined) {
+                            console.log(`   LCP: ${baseline.metrics.lcp.toFixed(0)}ms (${baseline.metrics.lcpRating})`);
+                        }
+                        if (baseline.metrics.fcp !== undefined) {
+                            console.log(`   FCP: ${baseline.metrics.fcp.toFixed(0)}ms`);
+                        }
+                        if (baseline.metrics.cls !== undefined) {
+                            console.log(`   CLS: ${baseline.metrics.cls.toFixed(3)} (${baseline.metrics.clsRating})`);
+                        }
+                        if (baseline.metrics.ttfb !== undefined) {
+                            console.log(`   TTFB: ${baseline.metrics.ttfb.toFixed(0)}ms`);
+                        }
+                        if (baseline.metrics.tti !== undefined) {
+                            console.log(`   TTI: ${baseline.metrics.tti.toFixed(0)}ms`);
+                        }
+                        if (baseline.metrics.transferSize !== undefined) {
+                            console.log(`   Transfer: ${(baseline.metrics.transferSize / 1024).toFixed(1)}KB`);
+                        }
+                        break;
+                    }
+                    case "list": {
+                        const baselines = (0, browser_js_1.listPerformanceBaselines)();
+                        if (baselines.length === 0) {
+                            console.log("\n📊 No performance baselines saved yet.");
+                            console.log("   Use: cbrowser perf-baseline save <url> --name <name>");
+                        }
+                        else {
+                            console.log(`\n📊 Performance Baselines (${baselines.length}):\n`);
+                            for (const b of baselines) {
+                                const date = new Date(b.timestamp).toLocaleDateString();
+                                const lcp = b.metrics.lcp ? `LCP: ${b.metrics.lcp.toFixed(0)}ms` : "";
+                                console.log(`   ${b.name}`);
+                                console.log(`     ID: ${b.id}`);
+                                console.log(`     URL: ${b.url}`);
+                                console.log(`     Date: ${date} | ${lcp}`);
+                                console.log("");
+                            }
+                        }
+                        break;
+                    }
+                    case "show": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser perf-baseline show <name|id>");
+                            process.exit(1);
+                        }
+                        const baseline = (0, browser_js_1.loadPerformanceBaseline)(name);
+                        if (!baseline) {
+                            console.error(`Baseline not found: ${name}`);
+                            process.exit(1);
+                        }
+                        console.log(`\n📊 Performance Baseline: ${baseline.name}`);
+                        console.log(`   ID: ${baseline.id}`);
+                        console.log(`   URL: ${baseline.url}`);
+                        console.log(`   Timestamp: ${new Date(baseline.timestamp).toLocaleString()}`);
+                        console.log(`   Runs Averaged: ${baseline.runsAveraged}`);
+                        console.log(`\n📈 Metrics:`);
+                        console.log(JSON.stringify(baseline.metrics, null, 2));
+                        console.log(`\n🖥️  Environment:`);
+                        console.log(JSON.stringify(baseline.environment, null, 2));
+                        break;
+                    }
+                    case "delete": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser perf-baseline delete <name|id>");
+                            process.exit(1);
+                        }
+                        const deleted = (0, browser_js_1.deletePerformanceBaseline)(name);
+                        if (deleted) {
+                            console.log(`\n✅ Deleted baseline: ${name}`);
+                        }
+                        else {
+                            console.error(`Baseline not found: ${name}`);
+                            process.exit(1);
+                        }
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser perf-baseline <save|list|show|delete>");
+                        console.error("");
+                        console.error("Subcommands:");
+                        console.error("  save <url>        Capture and save performance baseline");
+                        console.error("  list              List all saved baselines");
+                        console.error("  show <name>       Show baseline details");
+                        console.error("  delete <name>     Delete a baseline");
+                        process.exit(1);
+                }
+                break;
+            }
+            case "perf-regression": {
+                const url = args[0];
+                const baselineName = args[1];
+                if (!url || !baselineName) {
+                    console.error("Usage: cbrowser perf-regression <url> <baseline-name> [options]");
+                    console.error("");
+                    console.error("Options:");
+                    console.error("  --threshold-lcp <n>   Max LCP increase % (default: 20)");
+                    console.error("  --threshold-cls <n>   Max CLS increase absolute (default: 0.1)");
+                    console.error("  --threshold-fcp <n>   Max FCP increase % (default: 20)");
+                    console.error("  --threshold-ttfb <n>  Max TTFB increase % (default: 30)");
+                    console.error("  --output <file>       Save JSON report to file");
+                    console.error("");
+                    console.error("Examples:");
+                    console.error("  cbrowser perf-regression https://example.com homepage");
+                    console.error("  cbrowser perf-regression https://example.com homepage --threshold-lcp 30");
+                    process.exit(1);
+                }
+                console.log(`\n🔍 Checking for performance regressions...`);
+                console.log(`   URL: ${url}`);
+                console.log(`   Baseline: ${baselineName}`);
+                const thresholds = {};
+                if (options["threshold-lcp"])
+                    thresholds.lcp = parseInt(options["threshold-lcp"]);
+                if (options["threshold-cls"])
+                    thresholds.cls = parseFloat(options["threshold-cls"]);
+                if (options["threshold-fcp"])
+                    thresholds.fcp = parseInt(options["threshold-fcp"]);
+                if (options["threshold-ttfb"])
+                    thresholds.ttfb = parseInt(options["threshold-ttfb"]);
+                if (options["threshold-tti"])
+                    thresholds.tti = parseInt(options["threshold-tti"]);
+                if (options["threshold-tbt"])
+                    thresholds.tbt = parseInt(options["threshold-tbt"]);
+                const regressionOptions = {
+                    headless,
+                    thresholds: Object.keys(thresholds).length > 0 ? thresholds : undefined,
+                };
+                try {
+                    const result = await (0, browser_js_1.detectPerformanceRegression)(url, baselineName, regressionOptions);
+                    // Print formatted report
+                    const report = (0, browser_js_1.formatPerformanceRegressionReport)(result);
+                    console.log("\n" + report);
+                    // Save JSON report if requested
+                    const fs = await import("fs");
+                    if (options.output) {
+                        fs.writeFileSync(options.output, JSON.stringify(result, null, 2));
+                        console.log(`\n📄 JSON report saved: ${options.output}`);
+                    }
+                    // Exit with error code if regressions found
+                    if (!result.passed) {
+                        process.exit(1);
+                    }
+                }
+                catch (error) {
+                    console.error(`\n❌ Error: ${error.message}`);
+                    process.exit(1);
+                }
+                break;
+            }
+            // =========================================================================
+            // Test Coverage Map (Tier 6 - v6.5.0)
+            // =========================================================================
+            case "coverage": {
+                const fs = await import("fs");
+                const path = await import("path");
+                const subcommand = args[0];
+                // Simple glob function for test files
+                function findTestFiles(pattern) {
+                    const files = [];
+                    const parts = pattern.split("/");
+                    const dir = parts.slice(0, -1).join("/") || ".";
+                    const filePattern = parts[parts.length - 1];
+                    const regex = new RegExp("^" + filePattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+                    try {
+                        const dirFiles = fs.readdirSync(dir);
+                        for (const file of dirFiles) {
+                            if (regex.test(file)) {
+                                files.push(path.join(dir, file));
+                            }
+                        }
+                    }
+                    catch {
+                        // Directory doesn't exist
+                    }
+                    return files;
+                }
+                // Handle "coverage gaps" subcommand
+                if (subcommand === "gaps") {
+                    const url = args[1];
+                    if (!url) {
+                        console.error("Usage: cbrowser coverage gaps <url> [--tests <glob>] [--sitemap <url>]");
+                        process.exit(1);
+                    }
+                    console.log(`\n🔍 Finding untested pages for: ${url}`);
+                    const testPattern = options.tests || "tests/*.txt";
+                    const testFiles = findTestFiles(testPattern);
+                    if (testFiles.length === 0) {
+                        console.error(`No test files found matching: ${testPattern}`);
+                        process.exit(1);
+                    }
+                    console.log(`   Analyzing ${testFiles.length} test file(s)...`);
+                    const coverageOptions = {
+                        sitemapUrl: options.sitemap,
+                        maxPages: 50, // Quick mode
+                        minCoverage: 50,
+                    };
+                    const result = await (0, browser_js_1.generateCoverageMap)(url, testFiles, coverageOptions);
+                    // Show only gaps
+                    console.log(`\n🕳️  Coverage Gaps (${result.gaps.length} found):\n`);
+                    const priorityEmoji = { critical: "🚨", high: "🔴", medium: "🟡", low: "🟢" };
+                    for (const gap of result.gaps) {
+                        const emoji = priorityEmoji[gap.priority];
+                        console.log(`  ${emoji} ${gap.page.path}`);
+                        console.log(`     Priority: ${gap.priority} | Reason: ${gap.reason}`);
+                    }
+                    console.log(`\n📊 Coverage: ${result.analysis.coveragePercent}% (${result.analysis.testedPages}/${result.analysis.totalPages} pages)`);
+                    break;
+                }
+                // Main coverage command
+                const url = subcommand;
+                if (!url || url.startsWith("-")) {
+                    console.error("Usage: cbrowser coverage <url> [--tests <glob>] [--sitemap <url>] [--html] [--output <file>]");
+                    process.exit(1);
+                }
+                console.log(`\n📊 Generating test coverage map for: ${url}`);
+                const testPattern = options.tests || "tests/*.txt";
+                const testFiles = findTestFiles(testPattern);
+                if (testFiles.length === 0) {
+                    console.error(`No test files found matching: ${testPattern}`);
+                    console.error("Use --tests <glob> to specify test files");
+                    process.exit(1);
+                }
+                console.log(`   Found ${testFiles.length} test file(s)`);
+                for (const f of testFiles.slice(0, 5)) {
+                    console.log(`     - ${f}`);
+                }
+                if (testFiles.length > 5) {
+                    console.log(`     ... and ${testFiles.length - 5} more`);
+                }
+                const coverageOptions = {
+                    sitemapUrl: options.sitemap,
+                    maxPages: options["max-pages"] ? parseInt(options["max-pages"]) : 100,
+                    includePattern: options.include,
+                    excludePattern: options.exclude,
+                    minCoverage: options["min-coverage"] ? parseInt(options["min-coverage"]) : 50,
+                };
+                if (coverageOptions.sitemapUrl) {
+                    console.log(`   Using sitemap: ${coverageOptions.sitemapUrl}`);
+                }
+                else {
+                    console.log(`   Crawling site (max ${coverageOptions.maxPages} pages)...`);
+                }
+                const result = await (0, browser_js_1.generateCoverageMap)(url, testFiles, coverageOptions);
+                // Output format
+                if (options.html) {
+                    const htmlReport = (0, browser_js_1.generateCoverageHtmlReport)(result);
+                    const outputPath = options.output || "coverage-report.html";
+                    fs.writeFileSync(outputPath, htmlReport);
+                    console.log(`\n✅ HTML report saved: ${outputPath}`);
+                }
+                else if (options.output && options.output.endsWith(".json")) {
+                    fs.writeFileSync(options.output, JSON.stringify(result, null, 2));
+                    console.log(`\n✅ JSON report saved: ${options.output}`);
+                }
+                else {
+                    // Print text report
+                    const report = (0, browser_js_1.formatCoverageReport)(result);
+                    console.log(report);
+                    if (options.output) {
+                        fs.writeFileSync(options.output, report);
+                        console.log(`\n📄 Report saved: ${options.output}`);
+                    }
+                }
+                // Exit with error if coverage too low
+                if (result.analysis.coveragePercent < (coverageOptions.minCoverage || 50)) {
+                    console.log(`\n⚠️  Coverage (${result.analysis.coveragePercent}%) is below threshold (${coverageOptions.minCoverage}%)`);
+                    process.exit(1);
+                }
+                break;
+            }
             default:
                 console.error(`Unknown command: ${command}`);
                 console.error("Run 'cbrowser help' for usage");