browser-cdp 0.2.1 → 0.5.1

package/README.md

@@ -1,6 +1,8 @@
 # browser-cdp
 
-Browser automation via Chrome DevTools Protocol. Control Chrome, Brave, Comet, or Edge using your real browser - same fingerprint, real cookies, no automation detection.
+[![npm version](https://img.shields.io/npm/v/browser-cdp.svg)](https://www.npmjs.com/package/browser-cdp)
+
+Browser automation via Chrome DevTools Protocol. Control Chrome, Brave, or Edge using your real browser - same fingerprint, real cookies, no automation detection.
 
 ## Install
 
@@ -12,7 +14,10 @@ npm install -g browser-cdp
 
 ```bash
 # Start browser with CDP enabled
-browser-cdp start [browser] [--isolated] [--port=PORT]
+browser-cdp start [browser] [--profile=NAME] [--isolated] [--port=PORT]
+
+# Close the browser
+browser-cdp close
 
 # Navigate to URL
 browser-cdp nav <url> [--new]
@@ -25,6 +30,15 @@ browser-cdp screenshot
 
 # Interactive element picker
 browser-cdp pick '<message>'
+
+# Stream browser console output (network errors, exceptions, logs)
+browser-cdp console [--duration=SECONDS]
+
+# Show page performance metrics
+browser-cdp insights [--json]
+
+# Run Lighthouse audit (Chrome only)
+browser-cdp lighthouse [--json] [--category=NAME]
 ```
 
 ## Environment Variables
@@ -32,7 +46,7 @@ browser-cdp pick '<message>'
 | Variable | Description | Default |
 |----------|-------------|---------|
 | `DEBUG_PORT` | CDP debugging port | `9222` |
-| `BROWSER` | Browser to use (chrome, brave, comet, edge) | `chrome` |
+| `BROWSER` | Browser to use (chrome, brave, edge) | `chrome` |
 | `BROWSER_PATH` | Custom browser executable path | (auto-detect) |
 
 ## Examples
@@ -41,6 +55,9 @@ browser-cdp pick '<message>'
 # Start Brave with real profile
 browser-cdp start brave
 
+# Start Brave with specific profile (by name)
+browser-cdp start brave --profile=Work
+
 # Start Chrome on custom port
 DEBUG_PORT=9333 browser-cdp start
 
@@ -54,6 +71,26 @@ browser-cdp screenshot
 
 # Pick elements interactively
 browser-cdp pick "Select the login button"
+
+# Stream console output (captures network errors, exceptions, console.log)
+browser-cdp console
+# Then refresh the page to see errors
+
+# Stream console for 10 seconds
+browser-cdp console --duration=10
+
+# Get page performance insights
+browser-cdp insights
+# Returns: TTFB, First Paint, FCP, DOM loaded, resources, memory
+
+# Run Lighthouse audit (Chrome only - Brave blocks CDP debugger)
+browser-cdp start chrome --isolated
+browser-cdp nav https://example.com
+browser-cdp lighthouse
+# Returns: Performance, Accessibility, Best Practices, SEO scores
+
+# Close browser when done
+browser-cdp close
 ```
 
 ## Pre-started Browser
@@ -78,7 +115,6 @@ browser-cdp nav https://example.com
 |---------|---------|
 | Chrome | `chrome` (default) |
 | Brave | `brave` |
-| Comet | `comet` |
 | Edge | `edge` |
 
 ## Platform Support
@@ -101,6 +137,10 @@ Use `BROWSER_PATH` env var to override if your browser is installed elsewhere.
 | Detection | Not detectable as automation | Automation flags present |
 | Use case | Real-world testing, scraping | Isolated E2E tests |
 
+## See Also
+
+- [dev-browser](https://github.com/SawyerHood/dev-browser) - Browser automation plugin for Claude Code with LLM-optimized DOM snapshots
+
 ## License
 
 MIT

package/cli.js

@@ -12,10 +12,15 @@ const args = process.argv.slice(3);
 
 const commands = {
   start: "./start.js",
+  close: "./close.js",
   nav: "./nav.js",
   eval: "./eval.js",
+  dom: "./dom.js",
   screenshot: "./screenshot.js",
   pick: "./pick.js",
+  console: "./console.js",
+  insights: "./insights.js",
+  lighthouse: "./lighthouse.js",
 };
 
 function printUsage() {
@@ -25,21 +30,28 @@ function printUsage() {
   console.log("");
   console.log("Commands:");
   console.log("  start [browser]     Start browser with CDP (uses real profile)");
-  console.log("  nav <url>           Navigate to URL");
-  console.log("  eval '<code>'       Evaluate JavaScript in page");
+  console.log("  close               Close the browser");
+  console.log("  nav <url>           Navigate to URL (--console to capture logs)");
+  console.log("  eval '<code>'       Evaluate JS in page (--console to capture logs)");
+  console.log("  dom                 Capture full page DOM/HTML");
   console.log("  screenshot          Take screenshot of current page");
   console.log("  pick '<message>'    Interactive element picker");
+  console.log("  console             Stream browser console output");
+  console.log("  insights            Show page performance metrics");
+  console.log("  lighthouse          Run Lighthouse audit");
   console.log("");
   console.log("Environment:");
   console.log("  DEBUG_PORT          CDP port (default: 9222)");
-  console.log("  BROWSER             Browser to use (chrome, brave, comet, edge)");
+  console.log("  BROWSER             Browser to use (chrome, brave, edge)");
   console.log("  BROWSER_PATH        Custom browser executable path");
   console.log("");
   console.log("Examples:");
   console.log("  browser-cdp start brave");
   console.log("  browser-cdp nav https://google.com");
   console.log("  browser-cdp eval 'document.title'");
-  console.log("  browser-cdp screenshot");
+  console.log("  browser-cdp dom > page.html");
+  console.log("  browser-cdp console --duration=10");
+  console.log("  browser-cdp insights --json");
   process.exit(0);
 }
 

package/console.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+import { chromium } from "playwright";
+
+const DEFAULT_PORT = process.env.DEBUG_PORT || 9222;
+
+const args = process.argv.slice(2);
+const duration = args.find((a) => a.startsWith("--duration="));
+const durationMs = duration ? parseInt(duration.split("=")[1]) * 1000 : null;
+const shouldReload = args.includes("--reload") || args.includes("-r");
+const showHelp = args.includes("--help") || args.includes("-h");
+
+if (showHelp) {
+  console.log("Usage: console.js [options]");
+  console.log("\nCapture browser console output in real-time.");
+  console.log("\nOptions:");
+  console.log("  --duration=N  Stop after N seconds (default: run until Ctrl+C)");
+  console.log("  --reload, -r  Reload the page before capturing");
+  console.log("\nExamples:");
+  console.log("  console.js              # Stream console logs until Ctrl+C");
+  console.log("  console.js --duration=5 # Capture for 5 seconds");
+  console.log("  console.js --reload     # Reload page and capture logs");
+  process.exit(0);
+}
+
+const browser = await chromium.connectOverCDP(`http://localhost:${DEFAULT_PORT}`);
+const contexts = browser.contexts();
+const context = contexts[0];
+
+if (!context) {
+  console.error("No browser context found");
+  process.exit(1);
+}
+
+const pages = context.pages();
+// Filter out devtools pages and pick a real page
+const realPages = pages.filter(p => {
+  const url = p.url();
+  return url.startsWith("http://") || url.startsWith("https://");
+});
+const page = realPages[realPages.length - 1] || pages[pages.length - 1];
+
+if (!page) {
+  console.error("No active tab found");
+  process.exit(1);
+}
+
+console.error(`Connected to: ${page.url()}`);
+
+const formatTime = () => new Date().toISOString().split("T")[1].slice(0, 12);
+
+const levelColors = {
+  verbose: "\x1b[90m",  // gray
+  info: "\x1b[36m",     // cyan
+  warning: "\x1b[33m",  // yellow
+  error: "\x1b[31m",    // red
+};
+const reset = "\x1b[0m";
+
+// Use CDP directly for Log domain (captures network errors, etc.)
+const cdp = await page.context().newCDPSession(page);
+await cdp.send("Log.enable");
+
+cdp.on("Log.entryAdded", ({ entry }) => {
+  const color = levelColors[entry.level] || levelColors.info;
+  const source = entry.source ? `[${entry.source}]` : "";
+  console.log(`${color}[${formatTime()}] [${entry.level.toUpperCase()}]${source} ${entry.text}${reset}`);
+  if (entry.url) {
+    console.log(`${color}    URL: ${entry.url}${reset}`);
+  }
+});
+
+// Also capture runtime exceptions
+await cdp.send("Runtime.enable");
+cdp.on("Runtime.exceptionThrown", ({ exceptionDetails }) => {
+  const text = exceptionDetails.exception?.description || exceptionDetails.text;
+  console.log(`\x1b[31m[${formatTime()}] [EXCEPTION] ${text}${reset}`);
+});
+
+// Capture network failures (ERR_BLOCKED_BY_CLIENT, etc.)
+await cdp.send("Network.enable");
+cdp.on("Network.loadingFailed", ({ requestId, errorText, blockedReason }) => {
+  const reason = blockedReason ? ` (${blockedReason})` : "";
+  console.log(`\x1b[31m[${formatTime()}] [NETWORK ERROR] ${errorText}${reason}${reset}`);
+});
+
+// Keep Playwright listeners for console.log() calls
+page.on("console", (msg) => {
+  const type = msg.type();
+  const color = levelColors[type] || levelColors.info;
+  const text = msg.text();
+  console.log(`${color}[${formatTime()}] [CONSOLE.${type.toUpperCase()}] ${text}${reset}`);
+});
+
+page.on("pageerror", (error) => {
+  console.log(`\x1b[31m[${formatTime()}] [PAGE ERROR] ${error.message}${reset}`);
+});
+
+if (shouldReload) {
+  console.error("Reloading page...");
+  await page.reload();
+}
+
+console.error(`Listening for console output... (Ctrl+C to stop)`);
+
+if (durationMs) {
+  await new Promise((r) => setTimeout(r, durationMs));
+  await browser.close();
+} else {
+  // Keep running until interrupted
+  process.on("SIGINT", async () => {
+    console.error("\nStopping...");
+    await browser.close();
+    process.exit(0);
+  });
+
+  // Keep the process alive
+  await new Promise(() => {});
+}

package/eval.js

@@ -4,13 +4,25 @@ import { chromium } from "playwright";
 
 const DEFAULT_PORT = process.env.DEBUG_PORT || 9222;
 
-const code = process.argv.slice(2).join(" ");
-if (!code) {
-  console.log("Usage: eval.js 'code'");
+const args = process.argv.slice(2);
+const showHelp = args.includes("--help") || args.includes("-h");
+const captureConsole = args.includes("--console");
+const durationArg = args.find((a) => a.startsWith("--duration="));
+const durationMs = durationArg ? parseInt(durationArg.split("=")[1]) * 1000 : 3000;
+
+// Get code (everything that's not a flag)
+const code = args.filter((a) => !a.startsWith("--")).join(" ");
+
+if (showHelp || !code) {
+  console.log("Usage: eval.js '<code>' [options]");
+  console.log("\nOptions:");
+  console.log("  --console        Capture console output during evaluation");
+  console.log("  --duration=N     With --console, capture for N seconds (default: 3)");
   console.log("\nExamples:");
   console.log('  eval.js "document.title"');
   console.log("  eval.js \"document.querySelectorAll('a').length\"");
-  process.exit(1);
+  console.log("  eval.js \"fetch('/api/data')\" --console");
+  process.exit(showHelp ? 0 : 1);
 }
 
 const browser = await chromium.connectOverCDP(`http://localhost:${DEFAULT_PORT}`);
@@ -23,13 +35,64 @@ if (!context) {
 }
 
 const pages = context.pages();
-const page = pages[pages.length - 1];
+// Filter out devtools pages and pick a real page
+const realPages = pages.filter(p => {
+  const url = p.url();
+  return url.startsWith("http://") || url.startsWith("https://");
+});
+const page = realPages[realPages.length - 1] || pages[pages.length - 1];
 
 if (!page) {
   console.error("No active tab found");
   process.exit(1);
 }
 
+// Set up console capture BEFORE evaluation
+if (captureConsole) {
+  const formatTime = () => new Date().toISOString().split("T")[1].slice(0, 12);
+  const levelColors = {
+    verbose: "\x1b[90m",
+    info: "\x1b[36m",
+    warning: "\x1b[33m",
+    error: "\x1b[31m",
+  };
+  const reset = "\x1b[0m";
+
+  const cdp = await page.context().newCDPSession(page);
+  await cdp.send("Log.enable");
+  await cdp.send("Runtime.enable");
+  await cdp.send("Network.enable");
+
+  cdp.on("Log.entryAdded", ({ entry }) => {
+    const color = levelColors[entry.level] || levelColors.info;
+    const source = entry.source ? `[${entry.source}]` : "";
+    console.log(`${color}[${formatTime()}] [${entry.level.toUpperCase()}]${source} ${entry.text}${reset}`);
+    if (entry.url) {
+      console.log(`${color}    URL: ${entry.url}${reset}`);
+    }
+  });
+
+  cdp.on("Runtime.exceptionThrown", ({ exceptionDetails }) => {
+    const text = exceptionDetails.exception?.description || exceptionDetails.text;
+    console.log(`\x1b[31m[${formatTime()}] [EXCEPTION] ${text}${reset}`);
+  });
+
+  cdp.on("Network.loadingFailed", ({ requestId, errorText, blockedReason }) => {
+    const reason = blockedReason ? ` (${blockedReason})` : "";
+    console.log(`\x1b[31m[${formatTime()}] [NETWORK ERROR] ${errorText}${reason}${reset}`);
+  });
+
+  page.on("console", (msg) => {
+    const type = msg.type();
+    const color = levelColors[type] || levelColors.info;
+    console.log(`${color}[${formatTime()}] [CONSOLE.${type.toUpperCase()}] ${msg.text()}${reset}`);
+  });
+
+  page.on("pageerror", (error) => {
+    console.log(`\x1b[31m[${formatTime()}] [PAGE ERROR] ${error.message}${reset}`);
+  });
+}
+
 let result;
 
 try {
@@ -44,6 +107,7 @@ try {
   process.exit(1);
 }
 
+// Print result
 if (Array.isArray(result)) {
   for (let i = 0; i < result.length; i++) {
     if (i > 0) console.log("");
@@ -59,4 +123,10 @@ if (Array.isArray(result)) {
   console.log(result);
 }
 
+// Wait for async console output
+if (captureConsole) {
+  console.error(`\nListening for ${durationMs / 1000}s...`);
+  await new Promise((r) => setTimeout(r, durationMs));
+}
+
 await browser.close();

package/insights.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+import { chromium } from "playwright";
+
+const DEFAULT_PORT = process.env.DEBUG_PORT || 9222;
+
+const args = process.argv.slice(2);
+const showHelp = args.includes("--help") || args.includes("-h");
+const jsonOutput = args.includes("--json");
+
+if (showHelp) {
+  console.log("Usage: insights.js [--json]");
+  console.log("\nCollect page performance insights and Web Vitals.");
+  console.log("\nOptions:");
+  console.log("  --json    Output as JSON");
+  console.log("\nMetrics collected:");
+  console.log("  - Page load timing (DOM, load, first paint)");
+  console.log("  - Web Vitals (LCP, FID, CLS, FCP, TTFB)");
+  console.log("  - Resource counts and sizes");
+  console.log("  - JavaScript heap usage");
+  process.exit(0);
+}
+
+const browser = await chromium.connectOverCDP(`http://localhost:${DEFAULT_PORT}`);
+const contexts = browser.contexts();
+const context = contexts[0];
+
+if (!context) {
+  console.error("No browser context found");
+  process.exit(1);
+}
+
+const pages = context.pages();
+// Filter out devtools pages and pick a real page
+const realPages = pages.filter(p => {
+  const url = p.url();
+  return url.startsWith("http://") || url.startsWith("https://");
+});
+const page = realPages[realPages.length - 1] || pages[pages.length - 1];
+
+if (!page) {
+  console.error("No active tab found");
+  process.exit(1);
+}
+
+// Collect performance metrics
+const metrics = await page.evaluate(() => {
+  const perf = performance;
+  const timing = perf.timing || {};
+  const navigation = perf.getEntriesByType("navigation")[0] || {};
+  const paint = perf.getEntriesByType("paint") || [];
+  const resources = perf.getEntriesByType("resource") || [];
+
+  // Calculate timing metrics
+  const navStart = timing.navigationStart || navigation.startTime || 0;
+  const domContentLoaded = (timing.domContentLoadedEventEnd || navigation.domContentLoadedEventEnd || 0) - navStart;
+  const loadComplete = (timing.loadEventEnd || navigation.loadEventEnd || 0) - navStart;
+  const firstPaint = paint.find((p) => p.name === "first-paint")?.startTime || 0;
+  const firstContentfulPaint = paint.find((p) => p.name === "first-contentful-paint")?.startTime || 0;
+  const ttfb = (timing.responseStart || navigation.responseStart || 0) - navStart;
+
+  // Resource breakdown
+  const resourceStats = resources.reduce(
+    (acc, r) => {
+      acc.count++;
+      acc.totalSize += r.transferSize || 0;
+      const type = r.initiatorType || "other";
+      acc.byType[type] = (acc.byType[type] || 0) + 1;
+      return acc;
+    },
+    { count: 0, totalSize: 0, byType: {} }
+  );
+
+  // Try to get LCP (requires PerformanceObserver to have recorded it)
+  let lcp = null;
+  try {
+    const lcpEntries = perf.getEntriesByType("largest-contentful-paint");
+    if (lcpEntries.length > 0) {
+      lcp = lcpEntries[lcpEntries.length - 1].startTime;
+    }
+  } catch (e) {}
+
+  // Memory info (Chrome only)
+  let memory = null;
+  if (perf.memory) {
+    memory = {
+      usedJSHeapSize: Math.round(perf.memory.usedJSHeapSize / 1024 / 1024),
+      totalJSHeapSize: Math.round(perf.memory.totalJSHeapSize / 1024 / 1024),
+    };
+  }
+
+  return {
+    url: location.href,
+    timing: {
+      ttfb: Math.round(ttfb),
+      firstPaint: Math.round(firstPaint),
+      firstContentfulPaint: Math.round(firstContentfulPaint),
+      domContentLoaded: Math.round(domContentLoaded),
+      loadComplete: Math.round(loadComplete),
+      lcp: lcp ? Math.round(lcp) : null,
+    },
+    resources: {
+      count: resourceStats.count,
+      totalSizeKB: Math.round(resourceStats.totalSize / 1024),
+      byType: resourceStats.byType,
+    },
+    memory,
+  };
+});
+
+if (jsonOutput) {
+  console.log(JSON.stringify(metrics, null, 2));
+} else {
+  console.log(`Page Insights: ${metrics.url}\n`);
+
+  console.log("Timing:");
+  console.log(`  TTFB:                  ${metrics.timing.ttfb}ms`);
+  console.log(`  First Paint:           ${metrics.timing.firstPaint}ms`);
+  console.log(`  First Contentful Paint: ${metrics.timing.firstContentfulPaint}ms`);
+  console.log(`  DOM Content Loaded:    ${metrics.timing.domContentLoaded}ms`);
+  console.log(`  Load Complete:         ${metrics.timing.loadComplete}ms`);
+  if (metrics.timing.lcp) {
+    console.log(`  Largest Contentful Paint: ${metrics.timing.lcp}ms`);
+  }
+
+  console.log("\nResources:");
+  console.log(`  Total:     ${metrics.resources.count} requests`);
+  console.log(`  Size:      ${metrics.resources.totalSizeKB} KB`);
+  console.log(`  Breakdown: ${Object.entries(metrics.resources.byType).map(([k, v]) => `${k}(${v})`).join(", ")}`);
+
+  if (metrics.memory) {
+    console.log("\nMemory:");
+    console.log(`  JS Heap Used:  ${metrics.memory.usedJSHeapSize} MB`);
+    console.log(`  JS Heap Total: ${metrics.memory.totalJSHeapSize} MB`);
+  }
+}
+
+await browser.close();

package/nav.js

@@ -4,35 +4,106 @@ import { chromium } from "playwright";
 
 const DEFAULT_PORT = process.env.DEBUG_PORT || 9222;
 
-let url = process.argv[2];
-const newTab = process.argv[3] === "--new";
+const args = process.argv.slice(2);
+const showHelp = args.includes("--help") || args.includes("-h");
+const newTab = args.includes("--new");
+const captureConsole = args.includes("--console");
+const durationArg = args.find((a) => a.startsWith("--duration="));
+const durationMs = durationArg ? parseInt(durationArg.split("=")[1]) * 1000 : 5000;
 
-// Add protocol if missing
-if (url && !url.match(/^https?:\/\//i)) {
-  url = "https://" + url;
-}
+// Get URL (first arg that doesn't start with --)
+let url = args.find((a) => !a.startsWith("--"));
 
-if (!url) {
-  console.log("Usage: nav.js <url> [--new]");
+if (showHelp || !url) {
+  console.log("Usage: nav.js <url> [options]");
+  console.log("\nOptions:");
+  console.log("  --new            Open in new tab");
+  console.log("  --console        Capture console output during navigation");
+  console.log("  --duration=N     With --console, capture for N seconds (default: 5)");
   console.log("\nExamples:");
-  console.log("  nav.js example.com       # Navigate current tab");
-  console.log("  nav.js example.com --new # Open in new tab");
-  process.exit(1);
+  console.log("  nav.js example.com              # Navigate current tab");
+  console.log("  nav.js example.com --new        # Open in new tab");
+  console.log("  nav.js example.com --console    # Navigate and capture console");
+  process.exit(showHelp ? 0 : 1);
+}
+
+// Add protocol if missing
+if (!url.match(/^https?:\/\//i)) {
+  url = "https://" + url;
 }
 
 const browser = await chromium.connectOverCDP(`http://localhost:${DEFAULT_PORT}`);
 const contexts = browser.contexts();
 const context = contexts[0] || await browser.newContext();
 
+let page;
 if (newTab) {
-  const page = await context.newPage();
-  await page.goto(url, { waitUntil: "domcontentloaded" });
-  console.log("Opened:", url);
+  page = await context.newPage();
 } else {
   const pages = context.pages();
-  const page = pages[pages.length - 1] || await context.newPage();
-  await page.goto(url, { waitUntil: "domcontentloaded" });
-  console.log("Navigated to:", url);
+  const realPages = pages.filter(p => {
+    const u = p.url();
+    return u.startsWith("http://") || u.startsWith("https://") || u === "about:blank";
+  });
+  page = realPages[realPages.length - 1] || pages[pages.length - 1] || await context.newPage();
+}
+
+// Set up console capture BEFORE navigation
+if (captureConsole) {
+  const formatTime = () => new Date().toISOString().split("T")[1].slice(0, 12);
+  const levelColors = {
+    verbose: "\x1b[90m",
+    info: "\x1b[36m",
+    warning: "\x1b[33m",
+    error: "\x1b[31m",
+  };
+  const reset = "\x1b[0m";
+
+  const cdp = await page.context().newCDPSession(page);
+  await cdp.send("Log.enable");
+  await cdp.send("Runtime.enable");
+  await cdp.send("Network.enable");
+
+  cdp.on("Log.entryAdded", ({ entry }) => {
+    const color = levelColors[entry.level] || levelColors.info;
+    const source = entry.source ? `[${entry.source}]` : "";
+    console.log(`${color}[${formatTime()}] [${entry.level.toUpperCase()}]${source} ${entry.text}${reset}`);
+    if (entry.url) {
+      console.log(`${color}    URL: ${entry.url}${reset}`);
+    }
+  });
+
+  cdp.on("Runtime.exceptionThrown", ({ exceptionDetails }) => {
+    const text = exceptionDetails.exception?.description || exceptionDetails.text;
+    console.log(`\x1b[31m[${formatTime()}] [EXCEPTION] ${text}${reset}`);
+  });
+
+  cdp.on("Network.loadingFailed", ({ requestId, errorText, blockedReason }) => {
+    const reason = blockedReason ? ` (${blockedReason})` : "";
+    console.log(`\x1b[31m[${formatTime()}] [NETWORK ERROR] ${errorText}${reason}${reset}`);
+  });
+
+  page.on("console", (msg) => {
+    const type = msg.type();
+    const color = levelColors[type] || levelColors.info;
+    console.log(`${color}[${formatTime()}] [CONSOLE.${type.toUpperCase()}] ${msg.text()}${reset}`);
+  });
+
+  page.on("pageerror", (error) => {
+    console.log(`\x1b[31m[${formatTime()}] [PAGE ERROR] ${error.message}${reset}`);
+  });
+
+  console.error(`Navigating to ${url} (capturing console for ${durationMs / 1000}s)...`);
+}
+
+await page.goto(url, { waitUntil: "domcontentloaded" });
+
+if (captureConsole) {
+  console.error(`Loaded: ${url}`);
+  await new Promise((r) => setTimeout(r, durationMs));
+  console.error("Done.");
+} else {
+  console.log(newTab ? "Opened:" : "Navigated to:", url);
 }
 
 await browser.close();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "browser-cdp",
-  "version": "0.2.1",
-  "description": "Browser automation via Chrome DevTools Protocol - control Chrome, Brave, Comet, Edge with real browser profiles",
+  "version": "0.5.1",
+  "description": "Browser automation via Chrome DevTools Protocol - control Chrome, Brave, Edge with real browser profiles",
   "type": "module",
   "bin": {
     "browser-cdp": "./cli.js"
@@ -16,6 +16,8 @@
     "eval.js",
     "screenshot.js",
     "pick.js",
+    "console.js",
+    "insights.js",
     "README.md",
     "LICENSE"
   ],
@@ -31,6 +33,7 @@
     "url": "https://github.com/dpaluy/browser-cdp/issues"
   },
   "dependencies": {
+    "lighthouse": "^13.0.1",
     "playwright": "^1.49.0"
   },
   "keywords": [

package/pick.js

@@ -22,7 +22,12 @@ if (!context) {
 }
 
 const pages = context.pages();
-const page = pages[pages.length - 1];
+// Filter out devtools pages and pick a real page
+const realPages = pages.filter(p => {
+  const url = p.url();
+  return url.startsWith("http://") || url.startsWith("https://");
+});
+const page = realPages[realPages.length - 1] || pages[pages.length - 1];
 
 if (!page) {
   console.error("No active tab found");

package/screenshot.js

@@ -16,7 +16,12 @@ if (!context) {
 }
 
 const pages = context.pages();
-const page = pages[pages.length - 1];
+// Filter out devtools pages and pick a real page
+const realPages = pages.filter(p => {
+  const url = p.url();
+  return url.startsWith("http://") || url.startsWith("https://");
+});
+const page = realPages[realPages.length - 1] || pages[pages.length - 1];
 
 if (!page) {
   console.error("No active tab found");

package/start.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { spawn, execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { platform } from "node:os";
 import { chromium } from "playwright";
 
@@ -30,12 +30,6 @@ const BROWSERS = {
       ? `${process.env.HOME}/Library/Application Support/BraveSoftware/Brave-Browser/`
       : `${process.env.HOME}/.config/BraveSoftware/Brave-Browser/`,
   },
-  comet: {
-    name: "Comet",
-    path: isMac ? "/Applications/Comet.app/Contents/MacOS/Comet" : "/usr/bin/comet",
-    process: "Comet",
-    profileSource: null,
-  },
   edge: {
     name: "Microsoft Edge",
     path: isMac
@@ -50,25 +44,53 @@ const BROWSERS = {
 
 const DEFAULT_PORT = 9222;
 
+// Resolve profile name to directory (supports both "Profile 1" and "Suppli" style names)
+function resolveProfileDir(profileSource, profileName) {
+  // If it looks like a directory name already, use it
+  if (profileName === "Default" || profileName.startsWith("Profile ")) {
+    return profileName;
+  }
+
+  // Try to find profile by name in Local State
+  if (profileSource) {
+    try {
+      const localStatePath = `${profileSource}Local State`;
+      const localState = JSON.parse(readFileSync(localStatePath, "utf8"));
+      const profiles = localState.profile?.info_cache || {};
+
+      for (const [dir, info] of Object.entries(profiles)) {
+        if (info.name?.toLowerCase() === profileName.toLowerCase()) {
+          return dir;
+        }
+      }
+    } catch {
+      // Fall through to return original name
+    }
+  }
+
+  return profileName;
+}
+
 function printUsage() {
-  console.log("Usage: start.js [browser] [--isolated] [--port=PORT]");
+  console.log("Usage: start.js [browser] [--profile=NAME] [--isolated] [--port=PORT]");
   console.log("\nBrowsers:");
   console.log("  chrome  - Google Chrome (default)");
   console.log("  brave   - Brave Browser");
-  console.log("  comet   - Comet Browser");
   console.log("  edge    - Microsoft Edge");
   console.log("\nOptions:");
-  console.log("  --isolated  Use isolated profile (default: real profile)");
-  console.log("  --port=N    Use custom debugging port (default: 9222)");
+  console.log("  --profile=NAME  Use specific profile by name or directory");
+  console.log("  --isolated      Use isolated profile (default: real profile)");
+  console.log("  --port=N        Use custom debugging port (default: 9222)");
   console.log("\nEnvironment variables:");
-  console.log("  BROWSER       Default browser (chrome, brave, comet, edge)");
+  console.log("  BROWSER       Default browser (chrome, brave, edge)");
   console.log("  BROWSER_PATH  Custom browser executable path");
   console.log("  DEBUG_PORT    Custom debugging port");
   console.log("\nExamples:");
-  console.log("  start.js                    # Start Chrome with real profile");
-  console.log("  start.js brave              # Start Brave with real profile");
-  console.log("  start.js comet --isolated   # Start Comet with isolated profile");
-  console.log("  start.js --port=9333        # Start Chrome on port 9333");
+  console.log("  start.js                           # Start Chrome with default profile");
+  console.log("  start.js brave                     # Start Brave with default profile");
+  console.log("  start.js brave --profile=Work      # Start Brave with 'Work' profile");
+  console.log("  start.js edge --isolated           # Start Edge with isolated profile");
+  console.log("  start.js --port=9333               # Start Chrome on port 9333");
   process.exit(1);
 }
 
@@ -76,6 +98,7 @@ function printUsage() {
 const args = process.argv.slice(2);
 let browserName = process.env.BROWSER || "chrome";
 let isolated = false;
+let profile = null;
 let port = parseInt(process.env.DEBUG_PORT) || DEFAULT_PORT;
 
 for (const arg of args) {
@@ -83,6 +106,8 @@ for (const arg of args) {
     printUsage();
   } else if (arg === "--isolated") {
     isolated = true;
+  } else if (arg.startsWith("--profile=")) {
+    profile = arg.split("=")[1];
   } else if (arg.startsWith("--port=")) {
     port = parseInt(arg.split("=")[1]);
   } else if (BROWSERS[arg]) {
@@ -162,7 +187,11 @@ if (!isolated && browserConfig.process) {
 }
 
 // Build browser arguments
-const browserArgs = [`--remote-debugging-port=${port}`];
+const browserArgs = [
+  `--remote-debugging-port=${port}`,
+  // Required for Lighthouse/CDP debugger access (prevents bfcache blocking)
+  "--disable-features=ProcessPerSiteUpToMainFrameThreshold",
+];
 
 if (isolated) {
   const cacheBase = isMac
@@ -171,10 +200,15 @@ if (isolated) {
   const profileDir = `${cacheBase}/browser-cdp/${browserName}`;
   execFileSync("mkdir", ["-p", profileDir], { stdio: "ignore" });
   browserArgs.push(`--user-data-dir=${profileDir}`);
+} else if (profile) {
+  // Resolve profile name to directory if needed
+  const profileDir = resolveProfileDir(browserConfig.profileSource, profile);
+  browserArgs.push(`--profile-directory=${profileDir}`);
 }
 
 // Start browser
-console.log(`Starting ${browserConfig.name} on port ${port}${isolated ? " (isolated)" : ""}...`);
+const profileInfo = isolated ? " (isolated)" : profile ? ` (${profile})` : "";
+console.log(`Starting ${browserConfig.name} on port ${port}${profileInfo}...`);
 
 spawn(browserPath, browserArgs, {
   detached: true,
@@ -199,4 +233,4 @@ if (!connected) {
   process.exit(1);
 }
 
-console.log(`${browserConfig.name} started on :${port}${isolated ? " (isolated)" : ""}`);
+console.log(`${browserConfig.name} started on :${port}${profileInfo}`);