cbrowser 2.3.0 → 3.0.0

package/dist/cli.js

@@ -8,11 +8,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const browser_js_1 = require("./browser.js");
 const personas_js_1 = require("./personas.js");
+const types_js_1 = require("./types.js");
 function showHelp() {
     console.log(`
 ╔══════════════════════════════════════════════════════════════════════════════╗
-║                           CBrowser CLI v2.3.0                                ║
-║         AI-powered browser automation with multi-browser support             ║
+║                           CBrowser CLI v3.0.0                                ║
+║    AI-powered browser automation with natural language & fluent API          ║
 ╚══════════════════════════════════════════════════════════════════════════════╝
 
 NAVIGATION
@@ -30,6 +31,7 @@ AUTONOMOUS JOURNEYS
   journey <persona>           Run autonomous exploration
     --start <url>             Starting URL (required)
     --goal <goal>             What to accomplish
+    --record-video            Record journey as video
 
 PERSONAS
   persona list                List available personas
@@ -41,6 +43,90 @@ SESSION MANAGEMENT
   session list                List all saved sessions
   session delete <name>       Delete a saved session
 
+COOKIE MANAGEMENT
+  cookie list                 List all cookies for current page
+    --url <url>               Navigate to URL first
+  cookie set <name> <value>   Set a cookie
+    --domain <domain>         Cookie domain
+    --path <path>             Cookie path (default: /)
+  cookie delete <name>        Delete a cookie
+    --domain <domain>         Only delete for this domain
+  cookie clear                Clear all cookies
+
+DEVICE EMULATION
+  device list                 List available device presets
+  device set <name>           Set device emulation for session
+    Example: cbrowser device set iphone-15
+
+GEOLOCATION
+  geo list                    List available location presets
+  geo set <location>          Set geolocation (preset name or lat,lon)
+    Examples:
+      cbrowser geo set new-york
+      cbrowser geo set 37.7749,-122.4194
+
+PERFORMANCE
+  perf [url]                  Collect performance metrics
+  perf audit [url]            Run performance audit against budget
+    --budget-lcp <ms>         LCP budget (default: 2500)
+    --budget-fcp <ms>         FCP budget (default: 1800)
+    --budget-cls <score>      CLS budget (default: 0.1)
+
+NETWORK / HAR
+  har start                   Start recording HAR
+  har stop [output]           Stop and save HAR file
+  network list                List captured network requests
+
+VISUAL REGRESSION (v2.5.0)
+  visual save <name>          Save baseline screenshot
+    --url <url>               Navigate to URL first
+  visual compare <name>       Compare current page against baseline
+    --threshold <n>           Diff threshold 0-1 (default: 0.1)
+  visual list                 List all saved baselines
+  visual delete <name>        Delete a baseline
+
+ACCESSIBILITY (v2.5.0)
+  a11y audit                  Run WCAG accessibility audit
+    --url <url>               Navigate to URL first
+  a11y audit [url]            Audit a specific URL
+
+TEST RECORDING (v2.5.0)
+  record start                Start recording interactions
+    --url <url>               Navigate to URL to begin recording
+  record stop                 Stop recording and show actions
+  record save <name>          Save recorded test
+  record list                 List saved recordings
+  record generate <name>      Generate Playwright test code
+
+TEST EXPORT (v2.5.0)
+  export junit <name> [output]   Export test results as JUnit XML
+  export tap <name> [output]     Export test results as TAP format
+
+WEBHOOKS (v2.5.0)
+  webhook add <name> <url>    Add webhook notification
+    --events <events>         Comma-separated: test.pass,test.fail,journey.complete
+    --format <format>         slack, discord, or generic
+  webhook list                List configured webhooks
+  webhook delete <name>       Delete a webhook
+  webhook test <name>         Send test notification
+
+PARALLEL EXECUTION (v2.5.0)
+  parallel devices <url>      Run same URL across multiple devices
+    --devices <list>          Comma-separated device names (default: all)
+    --concurrency <n>         Max parallel browsers (default: 3)
+  parallel urls <urls>        Run same task across multiple URLs
+    --concurrency <n>         Max parallel browsers (default: 3)
+  parallel perf <urls>        Performance audit multiple URLs in parallel
+    --concurrency <n>         Max parallel browsers (default: 3)
+
+NATURAL LANGUAGE (v3.0.0)
+  run "<command>"             Execute natural language command
+    Examples:
+      cbrowser run "go to https://example.com"
+      cbrowser run "click the login button"
+      cbrowser run "type 'hello' in the search box"
+  script <file>               Execute script file with natural language commands
+
 STORAGE & CLEANUP
   storage                     Show storage usage statistics
   cleanup                     Clean up old files
@@ -50,23 +136,53 @@ STORAGE & CLEANUP
     --keep-journeys <n>       Keep at least N journeys (default: 5)
 
 OPTIONS
-  --browser <type>            Browser engine: chromium, firefox, webkit (default: chromium)
+  --browser <type>            Browser: chromium, firefox, webkit (default: chromium)
+  --device <name>             Device preset: iphone-15, pixel-8, ipad-pro-12, etc.
+  --geo <location>            Location preset or lat,lon coordinates
+  --locale <locale>           Browser locale (e.g., en-US, fr-FR)
+  --timezone <tz>             Timezone (e.g., America/New_York)
+  --record-video              Enable video recording
   --force                     Bypass red zone safety checks
   --headless                  Run browser in headless mode
 
 ENVIRONMENT VARIABLES
   CBROWSER_DATA_DIR           Custom data directory (default: ~/.cbrowser)
   CBROWSER_BROWSER            Browser engine (chromium/firefox/webkit)
+  CBROWSER_DEVICE             Device preset name
+  CBROWSER_LOCALE             Browser locale
+  CBROWSER_TIMEZONE           Timezone
   CBROWSER_HEADLESS           Run headless by default (true/false)
   CBROWSER_TIMEOUT            Default timeout in ms (default: 30000)
+  CBROWSER_RECORD_VIDEO       Record video by default (true/false)
+
+CONFIG FILE
+  CBrowser looks for config in these locations:
+    .cbrowserrc.json          Project config
+    .cbrowserrc               Project config
+    cbrowser.config.json      Project config
+    ~/.cbrowser/config.json   User config
+    ~/.cbrowserrc.json        User config
+
+  Example .cbrowserrc.json:
+    {
+      "browser": "chromium",
+      "device": "iphone-15",
+      "geolocation": "new-york",
+      "locale": "en-US",
+      "recordVideo": true,
+      "performanceBudget": {
+        "lcp": 2500,
+        "cls": 0.1
+      }
+    }
 
 EXAMPLES
   npx cbrowser navigate "https://example.com"
-  npx cbrowser click "Sign in"
-  npx cbrowser fill "email" "user@example.com"
-  npx cbrowser journey first-timer --start "https://example.com" --goal "Find products"
-  npx cbrowser session save "logged-in" --url "https://myapp.com"
-  npx cbrowser cleanup --dry-run
+  npx cbrowser navigate "https://example.com" --device iphone-15
+  npx cbrowser navigate "https://example.com" --geo san-francisco
+  npx cbrowser perf audit "https://example.com" --budget-lcp 2000
+  npx cbrowser journey first-timer --start "https://example.com" --record-video
+  npx cbrowser cookie list --url "https://example.com"
 `);
 }
 function parseArgs(args) {
@@ -98,6 +214,22 @@ function formatBytes(bytes) {
         return `${(bytes / 1024).toFixed(1)} KB`;
     return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
+function parseGeoLocation(location) {
+    // Check if it's a preset
+    if (types_js_1.LOCATION_PRESETS[location]) {
+        return types_js_1.LOCATION_PRESETS[location];
+    }
+    // Try parsing as lat,lon
+    const parts = location.split(",");
+    if (parts.length === 2) {
+        const lat = parseFloat(parts[0]);
+        const lon = parseFloat(parts[1]);
+        if (!isNaN(lat) && !isNaN(lon)) {
+            return { latitude: lat, longitude: lon };
+        }
+    }
+    return null;
+}
 async function main() {
     const { command, args, options } = parseArgs(process.argv.slice(2));
     if (command === "help" || options.help) {
@@ -108,9 +240,24 @@ async function main() {
     const browserType = options.browser === "firefox" ? "firefox"
         : options.browser === "webkit" ? "webkit"
             : "chromium";
+    // Parse geolocation
+    let geolocation = undefined;
+    if (options.geo) {
+        geolocation = parseGeoLocation(options.geo);
+        if (!geolocation) {
+            console.error(`Invalid geolocation: ${options.geo}`);
+            console.error("Use a preset name (new-york, london, etc.) or lat,lon format");
+            process.exit(1);
+        }
+    }
     const browser = new browser_js_1.CBrowser({
         browser: browserType,
         headless: options.headless === true || options.headless === "true",
+        device: options.device,
+        geolocation,
+        locale: options.locale,
+        timezone: options.timezone,
+        recordVideo: options["record-video"] === true,
     });
     try {
         switch (command) {
@@ -332,6 +479,805 @@ async function main() {
                 console.log(`  TOTAL: ${result.deleted} files | ${formatBytes(result.freedBytes)} ${cleanupOptions.dryRun ? "would be " : ""}freed`);
                 break;
             }
+            // =========================================================================
+            // Cookie Management
+            // =========================================================================
+            case "cookie": {
+                const subcommand = args[0];
+                switch (subcommand) {
+                    case "list": {
+                        if (options.url) {
+                            await browser.navigate(options.url);
+                        }
+                        const cookies = await browser.getCookies();
+                        if (cookies.length === 0) {
+                            console.log("No cookies found");
+                        }
+                        else {
+                            console.log("\n🍪 Cookies:\n");
+                            for (const cookie of cookies) {
+                                console.log(`  ${cookie.name}`);
+                                console.log(`    Value: ${cookie.value.substring(0, 50)}${cookie.value.length > 50 ? "..." : ""}`);
+                                console.log(`    Domain: ${cookie.domain}`);
+                                console.log(`    Path: ${cookie.path}`);
+                                console.log(`    Expires: ${cookie.expires === -1 ? "Session" : new Date(cookie.expires * 1000).toISOString()}`);
+                                console.log("");
+                            }
+                        }
+                        break;
+                    }
+                    case "set": {
+                        const name = args[1];
+                        const value = args[2];
+                        if (!name || !value) {
+                            console.error("Usage: cbrowser cookie set <name> <value> [--domain <domain>]");
+                            process.exit(1);
+                        }
+                        if (options.url) {
+                            await browser.navigate(options.url);
+                        }
+                        const domain = options.domain || "localhost";
+                        const path = options.path || "/";
+                        await browser.setCookies([{
+                                name,
+                                value,
+                                domain,
+                                path,
+                                expires: -1,
+                                httpOnly: false,
+                                secure: false,
+                                sameSite: "Lax",
+                            }]);
+                        console.log(`✓ Cookie set: ${name}=${value}`);
+                        break;
+                    }
+                    case "delete": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser cookie delete <name> [--domain <domain>]");
+                            process.exit(1);
+                        }
+                        if (options.url) {
+                            await browser.navigate(options.url);
+                        }
+                        await browser.deleteCookie(name, options.domain);
+                        console.log(`✓ Cookie deleted: ${name}`);
+                        break;
+                    }
+                    case "clear": {
+                        await browser.clearCookies();
+                        console.log("✓ All cookies cleared");
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser cookie [list|set|delete|clear]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Device Emulation
+            // =========================================================================
+            case "device": {
+                const subcommand = args[0];
+                switch (subcommand) {
+                    case "list": {
+                        console.log("\n📱 Available Device Presets:\n");
+                        for (const [name, device] of Object.entries(types_js_1.DEVICE_PRESETS)) {
+                            console.log(`  ${name}`);
+                            console.log(`    ${device.name}`);
+                            console.log(`    ${device.viewport.width}x${device.viewport.height} @${device.deviceScaleFactor}x`);
+                            console.log(`    Mobile: ${device.isMobile} | Touch: ${device.hasTouch}`);
+                            console.log("");
+                        }
+                        break;
+                    }
+                    case "set": {
+                        const deviceName = args[1];
+                        if (!deviceName) {
+                            console.error("Usage: cbrowser device set <name>");
+                            process.exit(1);
+                        }
+                        if (!types_js_1.DEVICE_PRESETS[deviceName]) {
+                            console.error(`Unknown device: ${deviceName}`);
+                            console.error("Run 'cbrowser device list' to see available devices");
+                            process.exit(1);
+                        }
+                        console.log(`✓ Device set: ${deviceName}`);
+                        console.log("  Note: Device emulation applies to new browser sessions");
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser device [list|set]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Geolocation
+            // =========================================================================
+            case "geo": {
+                const subcommand = args[0];
+                switch (subcommand) {
+                    case "list": {
+                        console.log("\n🌍 Available Location Presets:\n");
+                        for (const [name, loc] of Object.entries(types_js_1.LOCATION_PRESETS)) {
+                            console.log(`  ${name}`);
+                            console.log(`    Lat: ${loc.latitude}, Lon: ${loc.longitude}`);
+                            console.log("");
+                        }
+                        break;
+                    }
+                    case "set": {
+                        const location = args[1];
+                        if (!location) {
+                            console.error("Usage: cbrowser geo set <location>");
+                            console.error("  Location can be a preset name or lat,lon coordinates");
+                            process.exit(1);
+                        }
+                        const geo = parseGeoLocation(location);
+                        if (!geo) {
+                            console.error(`Invalid location: ${location}`);
+                            process.exit(1);
+                        }
+                        await browser.setGeolocationRuntime(geo);
+                        console.log(`✓ Geolocation set: ${geo.latitude}, ${geo.longitude}`);
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser geo [list|set]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Performance
+            // =========================================================================
+            case "perf": {
+                const subcommand = args[0];
+                if (subcommand === "audit") {
+                    const url = args[1];
+                    if (url) {
+                        await browser.navigate(url);
+                    }
+                    else if (options.url) {
+                        await browser.navigate(options.url);
+                    }
+                    // Create performance budget from options
+                    const budget = {
+                        lcp: options["budget-lcp"] ? parseInt(options["budget-lcp"]) : 2500,
+                        fcp: options["budget-fcp"] ? parseInt(options["budget-fcp"]) : 1800,
+                        cls: options["budget-cls"] ? parseFloat(options["budget-cls"]) : 0.1,
+                    };
+                    // Temporarily set budget in config
+                    browser.config.performanceBudget = budget;
+                    const result = await browser.auditPerformance();
+                    console.log("\n📊 Performance Audit:\n");
+                    console.log(`  URL: ${result.url}`);
+                    console.log(`  Result: ${result.passed ? "✓ PASSED" : "✗ FAILED"}`);
+                    console.log("");
+                    console.log("  Metrics:");
+                    if (result.metrics.lcp)
+                        console.log(`    LCP: ${result.metrics.lcp.toFixed(0)}ms (${result.metrics.lcpRating})`);
+                    if (result.metrics.fcp)
+                        console.log(`    FCP: ${result.metrics.fcp.toFixed(0)}ms`);
+                    if (result.metrics.cls !== undefined)
+                        console.log(`    CLS: ${result.metrics.cls.toFixed(3)} (${result.metrics.clsRating})`);
+                    if (result.metrics.ttfb)
+                        console.log(`    TTFB: ${result.metrics.ttfb.toFixed(0)}ms`);
+                    if (result.metrics.load)
+                        console.log(`    Load: ${result.metrics.load.toFixed(0)}ms`);
+                    if (result.metrics.resourceCount)
+                        console.log(`    Resources: ${result.metrics.resourceCount}`);
+                    if (result.metrics.transferSize)
+                        console.log(`    Transfer: ${formatBytes(result.metrics.transferSize)}`);
+                    if (result.violations.length > 0) {
+                        console.log("");
+                        console.log("  ⚠️  Budget Violations:");
+                        for (const v of result.violations) {
+                            console.log(`    - ${v}`);
+                        }
+                    }
+                }
+                else {
+                    // Just collect metrics
+                    const url = args[0];
+                    if (url) {
+                        await browser.navigate(url);
+                    }
+                    else if (options.url) {
+                        await browser.navigate(options.url);
+                    }
+                    const metrics = await browser.getPerformanceMetrics();
+                    console.log("\n📊 Performance Metrics:\n");
+                    if (metrics.lcp)
+                        console.log(`  LCP: ${metrics.lcp.toFixed(0)}ms (${metrics.lcpRating})`);
+                    if (metrics.fcp)
+                        console.log(`  FCP: ${metrics.fcp.toFixed(0)}ms`);
+                    if (metrics.cls !== undefined)
+                        console.log(`  CLS: ${metrics.cls.toFixed(3)} (${metrics.clsRating})`);
+                    if (metrics.ttfb)
+                        console.log(`  TTFB: ${metrics.ttfb.toFixed(0)}ms`);
+                    if (metrics.domContentLoaded)
+                        console.log(`  DOMContentLoaded: ${metrics.domContentLoaded.toFixed(0)}ms`);
+                    if (metrics.load)
+                        console.log(`  Load: ${metrics.load.toFixed(0)}ms`);
+                    if (metrics.resourceCount)
+                        console.log(`  Resources: ${metrics.resourceCount}`);
+                    if (metrics.transferSize)
+                        console.log(`  Transfer Size: ${formatBytes(metrics.transferSize)}`);
+                }
+                break;
+            }
+            // =========================================================================
+            // HAR Recording
+            // =========================================================================
+            case "har": {
+                const subcommand = args[0];
+                switch (subcommand) {
+                    case "start": {
+                        browser.startHarRecording();
+                        console.log("✓ HAR recording started");
+                        console.log("  Navigate and interact with pages, then run 'cbrowser har stop'");
+                        break;
+                    }
+                    case "stop": {
+                        const output = args[1];
+                        const filename = await browser.exportHar(output);
+                        console.log(`✓ HAR saved: ${filename}`);
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser har [start|stop]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Network
+            // =========================================================================
+            case "network": {
+                const subcommand = args[0];
+                switch (subcommand) {
+                    case "list": {
+                        const requests = browser.getNetworkRequests();
+                        if (requests.length === 0) {
+                            console.log("No network requests captured");
+                            console.log("Navigate to a page first to capture requests");
+                        }
+                        else {
+                            console.log(`\n🌐 Network Requests (${requests.length}):\n`);
+                            for (const req of requests.slice(-20)) {
+                                console.log(`  ${req.method} ${req.url.substring(0, 80)}${req.url.length > 80 ? "..." : ""}`);
+                                console.log(`    Type: ${req.resourceType} | Time: ${req.timestamp}`);
+                            }
+                            if (requests.length > 20) {
+                                console.log(`\n  ... and ${requests.length - 20} more requests`);
+                            }
+                        }
+                        break;
+                    }
+                    case "clear": {
+                        browser.clearNetworkHistory();
+                        console.log("✓ Network history cleared");
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser network [list|clear]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Visual Regression (Tier 2)
+            // =========================================================================
+            case "visual": {
+                const subcommand = args[0];
+                switch (subcommand) {
+                    case "save": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser visual save <name> [--url <url>]");
+                            process.exit(1);
+                        }
+                        if (options.url) {
+                            await browser.navigate(options.url);
+                        }
+                        const path = await browser.saveBaseline(name);
+                        console.log(`✓ Baseline saved: ${name}`);
+                        console.log(`  Path: ${path}`);
+                        break;
+                    }
+                    case "compare": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser visual compare <name> [--threshold <n>]");
+                            process.exit(1);
+                        }
+                        if (options.url) {
+                            await browser.navigate(options.url);
+                        }
+                        const threshold = options.threshold ? parseFloat(options.threshold) : 0.1;
+                        const result = await browser.compareBaseline(name, threshold);
+                        console.log("\n🔍 Visual Comparison:\n");
+                        console.log(`  Baseline: ${name}`);
+                        console.log(`  Difference: ${(result.diffPercentage * 100).toFixed(2)}%`);
+                        console.log(`  Threshold: ${(threshold * 100).toFixed(0)}%`);
+                        console.log(`  Result: ${result.passed ? "✓ PASSED" : "✗ FAILED"}`);
+                        if (result.diffPath) {
+                            console.log(`  Diff image: ${result.diffPath}`);
+                        }
+                        if (!result.passed) {
+                            process.exit(1);
+                        }
+                        break;
+                    }
+                    case "list": {
+                        const baselines = browser.listBaselines();
+                        if (baselines.length === 0) {
+                            console.log("No baselines saved");
+                        }
+                        else {
+                            console.log("\n📸 Visual Baselines:\n");
+                            for (const b of baselines) {
+                                console.log(`  - ${b}`);
+                            }
+                        }
+                        break;
+                    }
+                    case "delete": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser visual delete <name>");
+                            process.exit(1);
+                        }
+                        // Delete baseline file
+                        const fs = await import("fs");
+                        const path = await import("path");
+                        const baselinePath = path.join(browser.getDataDir(), "baselines", `${name}.png`);
+                        if (fs.existsSync(baselinePath)) {
+                            fs.unlinkSync(baselinePath);
+                            console.log(`✓ Baseline deleted: ${name}`);
+                        }
+                        else {
+                            console.error(`✗ Baseline not found: ${name}`);
+                            process.exit(1);
+                        }
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser visual [save|compare|list|delete]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Accessibility (Tier 2)
+            // =========================================================================
+            case "a11y": {
+                const subcommand = args[0];
+                if (subcommand === "audit") {
+                    const url = args[1];
+                    if (url) {
+                        await browser.navigate(url);
+                    }
+                    else if (options.url) {
+                        await browser.navigate(options.url);
+                    }
+                    const result = await browser.auditAccessibility();
+                    console.log("\n♿ Accessibility Audit:\n");
+                    console.log(`  URL: ${result.url}`);
+                    console.log(`  Score: ${result.score}/100`);
+                    console.log(`  Passes: ${result.passes}`);
+                    console.log(`  Violations: ${result.violations.length}`);
+                    if (result.violations.length > 0) {
+                        console.log("\n  ⚠️  Violations:\n");
+                        for (const v of result.violations) {
+                            console.log(`    [${v.impact.toUpperCase()}] ${v.id}`);
+                            console.log(`      ${v.description}`);
+                            console.log(`      Help: ${v.helpUrl}`);
+                            console.log("");
+                        }
+                    }
+                }
+                else {
+                    console.error("Usage: cbrowser a11y audit [url]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Test Recording (Tier 2)
+            // =========================================================================
+            case "record": {
+                const subcommand = args[0];
+                switch (subcommand) {
+                    case "start": {
+                        const url = options.url;
+                        await browser.startRecording(url);
+                        console.log("✓ Recording started");
+                        if (url) {
+                            console.log(`  Navigated to: ${url}`);
+                        }
+                        console.log("  Interact with the page, then run 'cbrowser record stop'");
+                        break;
+                    }
+                    case "stop": {
+                        const actions = browser.stopRecording();
+                        console.log(`✓ Recording stopped`);
+                        console.log(`  Captured ${actions.length} actions`);
+                        if (actions.length > 0) {
+                            console.log("\n  Actions:");
+                            for (const action of actions) {
+                                console.log(`    ${action.type}: ${action.selector || action.url || action.value || ""}`);
+                            }
+                        }
+                        break;
+                    }
+                    case "save": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser record save <name>");
+                            process.exit(1);
+                        }
+                        const path = browser.saveRecording(name);
+                        console.log(`✓ Recording saved: ${name}`);
+                        console.log(`  Path: ${path}`);
+                        break;
+                    }
+                    case "list": {
+                        const fs = await import("fs");
+                        const path = await import("path");
+                        const recordingsDir = path.join(browser.getDataDir(), "recordings");
+                        if (!fs.existsSync(recordingsDir)) {
+                            console.log("No recordings saved");
+                        }
+                        else {
+                            const files = fs.readdirSync(recordingsDir).filter((f) => f.endsWith(".json"));
+                            if (files.length === 0) {
+                                console.log("No recordings saved");
+                            }
+                            else {
+                                console.log("\n🎬 Saved Recordings:\n");
+                                for (const f of files) {
+                                    console.log(`  - ${f.replace(".json", "")}`);
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case "generate": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser record generate <name>");
+                            process.exit(1);
+                        }
+                        const fs = await import("fs");
+                        const path = await import("path");
+                        const recordingPath = path.join(browser.getDataDir(), "recordings", `${name}.json`);
+                        if (!fs.existsSync(recordingPath)) {
+                            console.error(`Recording not found: ${name}`);
+                            process.exit(1);
+                        }
+                        const recording = JSON.parse(fs.readFileSync(recordingPath, "utf-8"));
+                        const code = browser.generateTestCode(name, recording.actions);
+                        console.log(code);
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser record [start|stop|save|list|generate]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Test Export (Tier 2)
+            // =========================================================================
+            case "export": {
+                const format = args[0];
+                const name = args[1];
+                const output = args[2];
+                if (!format || !name) {
+                    console.error("Usage: cbrowser export [junit|tap] <name> [output]");
+                    process.exit(1);
+                }
+                // Load test results (for now, create a mock suite)
+                const fs = await import("fs");
+                const path = await import("path");
+                const resultsPath = path.join(browser.getDataDir(), "results", `${name}.json`);
+                let suite;
+                if (fs.existsSync(resultsPath)) {
+                    suite = JSON.parse(fs.readFileSync(resultsPath, "utf-8"));
+                }
+                else {
+                    console.error(`Test results not found: ${name}`);
+                    console.error("Run tests first to generate results");
+                    process.exit(1);
+                }
+                if (format === "junit") {
+                    const exportPath = browser.exportJUnit(suite, output);
+                    console.log(`✓ JUnit XML exported: ${exportPath}`);
+                }
+                else if (format === "tap") {
+                    const exportPath = browser.exportTAP(suite, output);
+                    console.log(`✓ TAP exported: ${exportPath}`);
+                }
+                else {
+                    console.error("Unknown export format. Use 'junit' or 'tap'");
+                    process.exit(1);
+                }
+                break;
+            }
+            // =========================================================================
+            // Webhooks (Tier 2)
+            // =========================================================================
+            case "webhook": {
+                const subcommand = args[0];
+                const fs = await import("fs");
+                const path = await import("path");
+                const webhooksPath = path.join(browser.getDataDir(), "webhooks.json");
+                // Load existing webhooks
+                let webhooks = [];
+                if (fs.existsSync(webhooksPath)) {
+                    webhooks = JSON.parse(fs.readFileSync(webhooksPath, "utf-8"));
+                }
+                switch (subcommand) {
+                    case "add": {
+                        const name = args[1];
+                        const url = args[2];
+                        if (!name || !url) {
+                            console.error("Usage: cbrowser webhook add <name> <url> [--events <events>] [--format <format>]");
+                            process.exit(1);
+                        }
+                        const events = options.events
+                            ? options.events.split(",")
+                            : ["test.fail", "journey.complete"];
+                        const format = options.format || "generic";
+                        // Remove existing webhook with same name
+                        webhooks = webhooks.filter(w => w.name !== name);
+                        webhooks.push({ name, url, events, format });
+                        fs.writeFileSync(webhooksPath, JSON.stringify(webhooks, null, 2));
+                        console.log(`✓ Webhook added: ${name}`);
+                        console.log(`  URL: ${url}`);
+                        console.log(`  Events: ${events.join(", ")}`);
+                        console.log(`  Format: ${format}`);
+                        break;
+                    }
+                    case "list": {
+                        if (webhooks.length === 0) {
+                            console.log("No webhooks configured");
+                        }
+                        else {
+                            console.log("\n🔔 Configured Webhooks:\n");
+                            for (const w of webhooks) {
+                                console.log(`  ${w.name}`);
+                                console.log(`    URL: ${w.url}`);
+                                console.log(`    Events: ${w.events.join(", ")}`);
+                                console.log(`    Format: ${w.format}`);
+                                console.log("");
+                            }
+                        }
+                        break;
+                    }
+                    case "delete": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser webhook delete <name>");
+                            process.exit(1);
+                        }
+                        const originalLength = webhooks.length;
+                        webhooks = webhooks.filter(w => w.name !== name);
+                        if (webhooks.length < originalLength) {
+                            fs.writeFileSync(webhooksPath, JSON.stringify(webhooks, null, 2));
+                            console.log(`✓ Webhook deleted: ${name}`);
+                        }
+                        else {
+                            console.error(`✗ Webhook not found: ${name}`);
+                            process.exit(1);
+                        }
+                        break;
+                    }
+                    case "test": {
+                        const name = args[1];
+                        if (!name) {
+                            console.error("Usage: cbrowser webhook test <name>");
+                            process.exit(1);
+                        }
+                        const webhook = webhooks.find(w => w.name === name);
+                        if (!webhook) {
+                            console.error(`✗ Webhook not found: ${name}`);
+                            process.exit(1);
+                        }
+                        // Send test notification
+                        const testPayload = webhook.format === "slack"
+                            ? { text: "🔔 CBrowser test notification" }
+                            : webhook.format === "discord"
+                                ? { content: "🔔 CBrowser test notification" }
+                                : { event: "test", message: "CBrowser test notification", timestamp: new Date().toISOString() };
+                        try {
+                            const response = await fetch(webhook.url, {
+                                method: "POST",
+                                headers: { "Content-Type": "application/json" },
+                                body: JSON.stringify(testPayload),
+                            });
+                            if (response.ok) {
+                                console.log(`✓ Test notification sent to: ${name}`);
+                            }
+                            else {
+                                console.error(`✗ Webhook returned ${response.status}`);
+                                process.exit(1);
+                            }
+                        }
+                        catch (e) {
+                            console.error(`✗ Failed to send notification: ${e.message}`);
+                            process.exit(1);
+                        }
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser webhook [add|list|delete|test]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Parallel Execution (Tier 2)
+            // =========================================================================
+            case "parallel": {
+                const subcommand = args[0];
+                switch (subcommand) {
+                    case "devices": {
+                        const url = args[1];
+                        if (!url) {
+                            console.error("Usage: cbrowser parallel devices <url> [--devices <list>] [--concurrency <n>]");
+                            process.exit(1);
+                        }
+                        const deviceList = options.devices
+                            ? options.devices.split(",")
+                            : Object.keys(types_js_1.DEVICE_PRESETS);
+                        const concurrency = options.concurrency ? parseInt(options.concurrency) : 3;
+                        console.log(`\n🚀 Running parallel device tests...`);
+                        console.log(`   URL: ${url}`);
+                        console.log(`   Devices: ${deviceList.length}`);
+                        console.log(`   Concurrency: ${concurrency}\n`);
+                        const results = await browser_js_1.CBrowser.parallelDevices(deviceList, async (b, device) => {
+                            const nav = await b.navigate(url);
+                            const screenshot = await b.screenshot();
+                            return { title: nav.title, loadTime: nav.loadTime, screenshot };
+                        }, { maxConcurrency: concurrency });
+                        console.log("📊 Results:\n");
+                        for (const r of results) {
+                            if (r.error) {
+                                console.log(`  ✗ ${r.device}: ${r.error} (${r.duration}ms)`);
+                            }
+                            else {
+                                console.log(`  ✓ ${r.device}: ${r.result?.title} - ${r.result?.loadTime}ms (${r.duration}ms total)`);
+                            }
+                        }
+                        const passed = results.filter(r => !r.error).length;
+                        console.log(`\n  Summary: ${passed}/${results.length} passed`);
+                        break;
+                    }
+                    case "urls": {
+                        const urls = args.slice(1);
+                        if (urls.length === 0) {
+                            console.error("Usage: cbrowser parallel urls <url1> <url2> ... [--concurrency <n>]");
+                            process.exit(1);
+                        }
+                        const concurrency = options.concurrency ? parseInt(options.concurrency) : 3;
+                        console.log(`\n🚀 Running parallel URL tests...`);
+                        console.log(`   URLs: ${urls.length}`);
+                        console.log(`   Concurrency: ${concurrency}\n`);
+                        const results = await browser_js_1.CBrowser.parallelUrls(urls, async (b, url) => {
+                            const nav = await b.navigate(url);
+                            return { title: nav.title, loadTime: nav.loadTime };
+                        }, { maxConcurrency: concurrency });
+                        console.log("📊 Results:\n");
+                        for (const r of results) {
+                            if (r.error) {
+                                console.log(`  ✗ ${r.url}: ${r.error}`);
+                            }
+                            else {
+                                console.log(`  ✓ ${r.url}: ${r.result?.title} (${r.result?.loadTime}ms)`);
+                            }
+                        }
+                        break;
+                    }
+                    case "perf": {
+                        const urls = args.slice(1);
+                        if (urls.length === 0) {
+                            console.error("Usage: cbrowser parallel perf <url1> <url2> ... [--concurrency <n>]");
+                            process.exit(1);
+                        }
+                        const concurrency = options.concurrency ? parseInt(options.concurrency) : 3;
+                        console.log(`\n🚀 Running parallel performance audits...`);
+                        console.log(`   URLs: ${urls.length}`);
+                        console.log(`   Concurrency: ${concurrency}\n`);
+                        const results = await browser_js_1.CBrowser.parallelUrls(urls, async (b, url) => {
+                            await b.navigate(url);
+                            return await b.getPerformanceMetrics();
+                        }, { maxConcurrency: concurrency });
+                        console.log("📊 Performance Results:\n");
+                        for (const r of results) {
+                            if (r.error) {
+                                console.log(`  ✗ ${r.url}: ${r.error}`);
+                            }
+                            else {
+                                const m = r.result;
+                                console.log(`  ✓ ${r.url}`);
+                                if (m?.lcp)
+                                    console.log(`      LCP: ${m.lcp.toFixed(0)}ms (${m.lcpRating})`);
+                                if (m?.fcp)
+                                    console.log(`      FCP: ${m.fcp.toFixed(0)}ms`);
+                                if (m?.cls !== undefined)
+                                    console.log(`      CLS: ${m.cls.toFixed(3)}`);
+                            }
+                        }
+                        break;
+                    }
+                    default:
+                        console.error("Usage: cbrowser parallel [devices|urls|perf]");
+                }
+                break;
+            }
+            // =========================================================================
+            // Natural Language (Tier 3)
+            // =========================================================================
+            case "run": {
+                const nlCommand = args.join(" ");
+                if (!nlCommand) {
+                    console.error("Usage: cbrowser run \"<natural language command>\"");
+                    console.error("Examples:");
+                    console.error("  cbrowser run \"go to https://example.com\"");
+                    console.error("  cbrowser run \"click the login button\"");
+                    console.error("  cbrowser run \"type 'hello' in the search box\"");
+                    process.exit(1);
+                }
+                console.log(`\n🗣️  Executing: "${nlCommand}"\n`);
+                const result = await (0, browser_js_1.executeNaturalLanguage)(browser, nlCommand);
+                if (result.success) {
+                    console.log(`✓ Action: ${result.action}`);
+                    if (result.result && typeof result.result === "object") {
+                        const r = result.result;
+                        if (r.url)
+                            console.log(`  URL: ${r.url}`);
+                        if (r.title)
+                            console.log(`  Title: ${r.title}`);
+                        if (r.message)
+                            console.log(`  ${r.message}`);
+                        if (r.screenshot)
+                            console.log(`  Screenshot: ${r.screenshot}`);
+                    }
+                }
+                else {
+                    console.error(`✗ ${result.error}`);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "script": {
+                const scriptFile = args[0];
+                if (!scriptFile) {
+                    console.error("Usage: cbrowser script <file>");
+                    process.exit(1);
+                }
+                const fs = await import("fs");
+                if (!fs.existsSync(scriptFile)) {
+                    console.error(`Script file not found: ${scriptFile}`);
+                    process.exit(1);
+                }
+                const content = fs.readFileSync(scriptFile, "utf-8");
+                const commands = content.split("\n").filter(line => line.trim() && !line.trim().startsWith("#"));
+                console.log(`\n📜 Executing script: ${scriptFile}`);
+                console.log(`   Commands: ${commands.length}\n`);
+                const results = await (0, browser_js_1.executeNaturalLanguageScript)(browser, commands);
+                for (const r of results) {
+                    if (r.success) {
+                        console.log(`✓ ${r.command}`);
+                    }
+                    else {
+                        console.log(`✗ ${r.command}`);
+                        console.log(`  Error: ${r.error}`);
+                    }
+                }
+                const passed = results.filter(r => r.success).length;
+                console.log(`\n  Summary: ${passed}/${results.length} commands succeeded`);
+                if (passed < results.length) {
+                    process.exit(1);
+                }
+                break;
+            }
             default:
                 console.error(`Unknown command: ${command}`);
                 console.error("Run 'cbrowser help' for usage");