Browsing

node_modules/
package-lock.json
IMPLEMENTATION_SUMMARY.md
TEST_RESULTS.md
test-*.png
test-*.md

#!/usr/bin/env node

const process = require('process');

// Parse --port=N flag from anywhere in argv (filter it out of positional args)
const allArgs = process.argv.slice(2);
const portArg = allArgs.find(a => a.startsWith('--port='));
const positionalArgs = allArgs.filter(a => !a.startsWith('--port='));
const [command, wsUrlOrIndex, ...args] = positionalArgs;

// Handle --help and --version before any other processing
if (command === '--help' || command === '-h' || !command) {
  console.log(`Usage: chrome-ws <command> [args]

Commands:
  start [port]                                  Start Chrome with remote debugging
  stop                                           Kill Chrome
  pid                                            Print Chrome PID
  info                                           Print Chrome info (JSON)
  tabs                                           List open tabs
  new <url>                                      Open a new tab
  close <tab>                                    Close a tab
  navigate <tab> <url>                           Navigate tab to URL
  extract <tab> <selector>                       Extract element text content
  attr <tab> <selector> <attribute>             Get element attribute
  html <tab> [selector]                         Get HTML content
  click <tab> <selector>                         Click an element
  fill <tab> <selector> <text>                   Fill an input field
  select <tab> <selector> <value>               Select a dropdown option
  eval <tab> <js>                                Evaluate JavaScript
  wait-for <tab> <selector> [timeout-ms]        Wait for element to appear
  wait-text <tab> <text> [timeout-ms]           Wait for text to appear
  screenshot <tab> <filename.png> [--fullpage]  Take a screenshot
  markdown <tab> <filename.md>                  Save page as markdown
  har <tab> <filename.har>                      Export HAR (after har-start)
  raw <ws-url> <json-rpc-payload>               Send raw CDP command

  --help, -h                                     Show this help
  --version, -v                                  Show version
  --port=N                                       Override CHROME_WS_PORT env var

Tab arg: numeric index (0, 1, 2...) or full ws:// URL.
`);
  process.exit(0);
}
if (command === '--version' || command === '-v') {
  const pkg = require('../../package.json');
  console.log(pkg.version);
  process.exit(0);
}

const hostOverride = require('./host-override').createOverride();
const { createSession } = require('./chrome-ws-lib');
const CHROME_DEBUG_HOST = hostOverride.getHost();
const CHROME_DEBUG_PORT = hostOverride.getPort();
const WS_OVERRIDE_ENABLED = hostOverride.isOverrideEnabled();
const rewriteWsUrl = hostOverride.rewriteWsUrl;

// Effective port: --port=N flag overrides CHROME_WS_PORT env / default 9222
const effectivePort = portArg ? parseInt(portArg.split('=')[1], 10) : CHROME_DEBUG_PORT;

// Session pointed at the effective port. Built after effectivePort is known
// so the lib's pooled connections target the right Chrome instance.
const session = createSession({ host: CHROME_DEBUG_HOST, port: effectivePort });

// Minimal WebSocket client implementation (dependency-free)
class WebSocketClient {
  constructor(url) {
    this.url = new URL(url);
    this.callbacks = {};
    this.socket = null;
    this.buffer = Buffer.alloc(0);
  }

  on(event, callback) {
    this.callbacks[event] = callback;
  }

  connect() {
    return new Promise((resolve, reject) => {
      const http = require('http');
      const crypto = require('crypto');

      const key = crypto.randomBytes(16).toString('base64');

      const options = {
        hostname: this.url.hostname,
        port: this.url.port || 80,
        path: this.url.pathname + this.url.search,
        headers: {
          'Upgrade': 'websocket',
          'Connection': 'Upgrade',
          'Sec-WebSocket-Key': key,
          'Sec-WebSocket-Version': '13'
        }
      };

      const req = http.request(options);

      req.on('upgrade', (res, socket) => {
        this.socket = socket;

        socket.on('data', (data) => {
          this.buffer = Buffer.concat([this.buffer, data]);
          this.processFrames();
        });

        socket.on('error', (err) => {
          if (this.callbacks.error) this.callbacks.error(err);
        });

        if (this.callbacks.open) this.callbacks.open();
        resolve();
      });

      req.on('error', reject);
      req.end();
    });
  }

  processFrames() {
    while (this.buffer.length >= 2) {
      const firstByte = this.buffer[0];
      const secondByte = this.buffer[1];

      const fin = (firstByte & 0x80) !== 0;
      const opcode = firstByte & 0x0F;
      const masked = (secondByte & 0x80) !== 0;
      let payloadLen = secondByte & 0x7F;

      let offset = 2;

      if (payloadLen === 126) {
        if (this.buffer.length < 4) return;
        payloadLen = this.buffer.readUInt16BE(2);
        offset = 4;
      } else if (payloadLen === 127) {
        if (this.buffer.length < 10) return;
        payloadLen = Number(this.buffer.readBigUInt64BE(2));
        offset = 10;
      }

      if (this.buffer.length < offset + payloadLen) return;

      let payload = this.buffer.slice(offset, offset + payloadLen);
      this.buffer = this.buffer.slice(offset + payloadLen);

      if (opcode === 0x1 && this.callbacks.message) {
        this.callbacks.message(payload.toString('utf8'));
      }
    }
  }

  send(data) {
    const payload = Buffer.from(data, 'utf8');
    const payloadLen = payload.length;

    let frame;
    let offset = 2;

    if (payloadLen < 126) {
      frame = Buffer.alloc(payloadLen + 6);
      frame[1] = payloadLen | 0x80;
    } else if (payloadLen < 65536) {
      frame = Buffer.alloc(payloadLen + 8);
      frame[1] = 126 | 0x80;
      frame.writeUInt16BE(payloadLen, 2);
      offset = 4;
    } else {
      frame = Buffer.alloc(payloadLen + 14);
      frame[1] = 127 | 0x80;
      frame.writeBigUInt64BE(BigInt(payloadLen), 2);
      offset = 10;
    }

    frame[0] = 0x81; // FIN + text frame

    const mask = Buffer.alloc(4);
    require('crypto').randomFillSync(mask);
    mask.copy(frame, offset);
    offset += 4;

    for (let i = 0; i < payloadLen; i++) {
      frame[offset + i] = payload[i] ^ mask[i % 4];
    }

    this.socket.write(frame);
  }

  close() {
    if (this.socket) {
      this.socket.end();
      this.socket = null;
    }
  }
}

// Helper to convert string tab specifier to the type expected by session methods.
// session.fill/evaluate/etc. use getPageSession which accepts a number (index) or
// a ws:// string — but NOT a numeric string like "0".
function resolveTabArg(wsUrlOrIndex) {
  if (wsUrlOrIndex && wsUrlOrIndex.startsWith('ws://')) {
    return wsUrlOrIndex; // Already a ws URL string
  }
  const index = parseInt(wsUrlOrIndex, 10);
  if (!isNaN(index)) {
    return index; // Numeric tab index as a number
  }
  throw new Error(`Invalid tab specifier: ${wsUrlOrIndex}`);
}

// Helper to resolve tab index or ws URL to actual ws URL
async function resolveWsUrl(wsUrlOrIndex) {
  // If it's already a WebSocket URL, return it
  if (wsUrlOrIndex && wsUrlOrIndex.startsWith('ws://')) {
    return wsUrlOrIndex;
  }

  // If it's a number (tab index), resolve it
  const index = parseInt(wsUrlOrIndex);
  if (!isNaN(index)) {
    const tabs = await chromeHttp('/json');
    const pageTabs = Array.isArray(tabs)
      ? tabs
          .filter(t => t.type === 'page')
          .map(tab => WS_OVERRIDE_ENABLED
            ? { ...tab, webSocketDebuggerUrl: rewriteWsUrl(tab.webSocketDebuggerUrl) }
            : tab
          )
      : [];

    // Auto-create tab if none exist (similar to auto-start Chrome behavior)
    if (pageTabs.length === 0) {
      const newTabInfo = await chromeHttp('/json/new?about:blank', 'PUT');
      return WS_OVERRIDE_ENABLED ? rewriteWsUrl(newTabInfo.webSocketDebuggerUrl) : newTabInfo.webSocketDebuggerUrl;
    }

    if (index < 0 || index >= pageTabs.length) {
      throw new Error(`Tab index ${index} out of range (0-${pageTabs.length - 1})`);
    }
    return WS_OVERRIDE_ENABLED ? rewriteWsUrl(pageTabs[index].webSocketDebuggerUrl) : pageTabs[index].webSocketDebuggerUrl;
  }

  throw new Error(`Invalid tab specifier: ${wsUrlOrIndex}`);
}

// Helper to make HTTP requests to Chrome on the effective port
async function chromeHttp(path, method = 'GET') {
  const http = require('http');

  return new Promise((resolve, reject) => {
    const options = {
      hostname: CHROME_DEBUG_HOST,
      port: effectivePort,
      path,
      method: method
    };

    const req = http.request(options, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => {
        if (!data) {
          resolve({});
          return;
        }
        try {
          resolve(JSON.parse(data));
        } catch (e) {
          // Some endpoints return plain text (e.g., "Target is closing")
          resolve({ message: data });
        }
      });
    });

    req.on('error', reject);
    req.end();
  });
}

// Command: start - launch Chrome with remote debugging
if (command === 'start') {
  const { spawn } = require('child_process');
  const { existsSync } = require('fs');
  const os = require('os');

  // Platform-specific Chrome paths
  const chromePaths = {
    darwin: [
      '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
      '/Applications/Chromium.app/Contents/MacOS/Chromium'
    ],
    linux: [
      '/usr/bin/google-chrome',
      '/usr/bin/google-chrome-stable',
      '/usr/bin/chromium',
      '/usr/bin/chromium-browser'
    ],
    win32: [
      'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
      'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
      'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
      'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe'
    ]
  };

  const platform = os.platform();
  const paths = chromePaths[platform];

  if (!paths) {
    console.error(`Unsupported platform: ${platform}`);
    process.exit(1);
  }

  // Find Chrome executable (CHROME_WS_BROWSER env var overrides auto-detection)
  const chromePath = process.env.CHROME_WS_BROWSER || paths.find(p => existsSync(p));

  if (!chromePath) {
    console.error('Chrome not found. Searched:');
    paths.forEach(p => console.error(`  ${p}`));
    process.exit(1);
  }

  // Launch Chrome
  const userDataDir = platform === 'win32'
    ? 'C:\\temp\\chrome-debug'
    : '/tmp/chrome-debug';

  const chromeArgs = [
    `--remote-debugging-port=${effectivePort}`,
    `--user-data-dir=${userDataDir}`
  ];

  console.log(`Starting Chrome: ${chromePath}`);
  const chrome = spawn(chromePath, chromeArgs, {
    detached: true,
    stdio: 'ignore'
  });
  chrome.unref();

  const debugBase = `http://${CHROME_DEBUG_HOST}:${effectivePort}`;

  // Wait and verify
  setTimeout(async () => {
    try {
      const version = await chromeHttp('/json/version');
      console.log(`Chrome started: ${version.Browser}`);
      console.log(`Remote debugging: ${debugBase}`);
    } catch (e) {
      console.error('Chrome started but remote debugging not accessible');
      console.error(`Try: curl ${debugBase}/json/version`);
      process.exit(1);
    }
  }, 2000);

  return;
}

// Command: stop - kill the Chrome process this session manages
if (command === 'stop') {
  (async () => {
    try {
      await session.killChrome();
      console.log('Chrome stopped');
    } catch (e) {
      console.error('Failed to stop Chrome:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: pid - print Chrome PID (for X11 window management, etc.)
if (command === 'pid') {
  const pid = session.getChromePid();
  if (pid === null) {
    console.error('Chrome is not running (started via MCP). PID is only available when Chrome was started in this process.');
    process.exit(1);
  }
  console.log(pid);
  return;
}

// Command: info - print Chrome info as JSON (pid, mode, profile, port)
if (command === 'info') {
  (async () => {
    try {
      const mode = await session.getBrowserMode();
      // Also try to get PID from meta.json if available
      const meta = session.readProfileMeta ? session.readProfileMeta(mode.profile) : null;
      const info = {
        pid: meta ? meta.pid : mode.pid,
        port: meta ? meta.port : mode.port,
        mode: meta ? (meta.headless ? 'headless' : 'headed') : mode.mode,
        profile: mode.profile,
        profileDir: mode.profileDir,
        running: meta !== null
      };
      console.log(JSON.stringify(info, null, 2));
    } catch (e) {
      console.error('Failed to get Chrome info:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: tabs - list all tabs
if (command === 'tabs') {
  (async () => {
    try {
      const tabs = await chromeHttp('/json');
      tabs.forEach(tab => {
        if (tab.type === 'page') {
          console.log(`${tab.id}\t${tab.url}\t${tab.title}`);
        }
      });
    } catch (e) {
      console.error('Failed to list tabs:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: new - create new tab
if (command === 'new') {
  // For this command, wsUrlOrIndex variable contains the URL parameter
  if (!wsUrlOrIndex) {
    console.error('Usage: chrome-ws new <url>');
    process.exit(1);
  }
  const url = wsUrlOrIndex;
  (async () => {
    try {
      const encoded = encodeURIComponent(url);
      const tab = await chromeHttp(`/json/new?${encoded}`, 'PUT');
      const wsUrl = WS_OVERRIDE_ENABLED ? rewriteWsUrl(tab.webSocketDebuggerUrl) : tab.webSocketDebuggerUrl;
      console.log(wsUrl);
    } catch (e) {
      console.error('Failed to create tab:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: close - close tab by ws URL or numeric index
if (command === 'close') {
  if (!wsUrlOrIndex) {
    console.error('Usage: chrome-ws close <tab>');
    process.exit(1);
  }
  (async () => {
    try {
      const tabWsUrl = await resolveWsUrl(wsUrlOrIndex);
      // Extract tab ID from ws URL
      const match = tabWsUrl.match(/\/devtools\/page\/([A-F0-9-]+)/i);
      if (!match) {
        console.error('Invalid WebSocket URL');
        process.exit(1);
      }
      await chromeHttp(`/json/close/${match[1]}`);
      console.log('Tab closed');
    } catch (e) {
      console.error('Failed to close tab:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Helper to send CDP command via WebSocket
async function sendCdpCommand(wsUrl, method, params = {}) {
  return new Promise(async (resolve, reject) => {
    const ws = new WebSocketClient(wsUrl);
    const id = Math.floor(Math.random() * 1000000);

    const timeout = setTimeout(() => {
      ws.close();
      reject(new Error('Timeout after 30s'));
    }, 30000);

    ws.on('message', (data) => {
      const response = JSON.parse(data);
      if (response.id === id) {
        clearTimeout(timeout);
        if (response.error) {
          ws.close();
          reject(new Error(response.error.message));
        } else {
          ws.close();
          resolve(response.result);
        }
      }
    });

    ws.on('error', (err) => {
      clearTimeout(timeout);
      reject(err);
    });

    try {
      await ws.connect();
      ws.send(JSON.stringify({ id, method, params }));
    } catch (err) {
      clearTimeout(timeout);
      reject(err);
    }
  });
}

// Command: navigate
if (command === 'navigate') {
  const [url] = args;
  if (!wsUrlOrIndex || !url) {
    console.error('Usage: chrome-ws navigate <tab-index-or-ws-url> <url>');
    process.exit(1);
  }
  (async () => {
    try {
      const wsUrl = await resolveWsUrl(wsUrlOrIndex);
      await sendCdpCommand(wsUrl, 'Page.navigate', { url });
      console.log(`Navigated to ${url}`);
    } catch (e) {
      console.error('Navigation failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: wait-for - wait for selector to appear
if (command === 'wait-for') {
  const [selector, timeoutArg] = args;
  if (!wsUrlOrIndex || !selector) {
    console.error('Usage: chrome-ws wait-for <tab-index-or-ws-url> <selector> [timeout-ms]');
    process.exit(1);
  }
  const timeout = timeoutArg ? parseInt(timeoutArg, 10) : 5000;
  if (Number.isNaN(timeout) || timeout < 0) {
    console.error(`Invalid timeout: ${timeoutArg}`);
    process.exit(1);
  }
  (async () => {
    try {
      await session.waitForElement(resolveTabArg(wsUrlOrIndex), selector, timeout);
      console.log(`Element found: ${selector}`);
      process.exit(0);
    } catch (e) {
      console.error('Wait failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: click
if (command === 'click') {
  const [selector] = args;
  if (!wsUrlOrIndex || !selector) {
    console.error('Usage: chrome-ws click <tab-index-or-ws-url> <selector>');
    process.exit(1);
  }
  (async () => {
    try {
      const wsUrl = await resolveWsUrl(wsUrlOrIndex);
      const js = `document.querySelector(${JSON.stringify(selector)}).click()`;
      await sendCdpCommand(wsUrl, 'Runtime.evaluate', { expression: js });
      console.log(`Clicked: ${selector}`);
    } catch (e) {
      console.error('Click failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: fill
if (command === 'fill') {
  const [selector, value] = args;
  if (!wsUrlOrIndex || !selector || value === undefined) {
    console.error('Usage: chrome-ws fill <tab-index-or-ws-url> <selector> <value>');
    process.exit(1);
  }
  (async () => {
    try {
      await session.fill(resolveTabArg(wsUrlOrIndex), selector, value);
      console.log(`Filled: ${selector}`);
      process.exit(0);
    } catch (e) {
      console.error('Fill failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: select - select dropdown option
if (command === 'select') {
  const [selector, value] = args;
  if (!wsUrlOrIndex || !selector || value === undefined) {
    console.error('Usage: chrome-ws select <tab-index-or-ws-url> <selector> <value-or-label-or-json-array>');
    process.exit(1);
  }
  (async () => {
    try {
      // Accept JSON array (multi-select) or plain string (value or label).
      let selectValue = value;
      if (typeof value === 'string' && value.trim().startsWith('[')) {
        try {
          const parsed = JSON.parse(value);
          if (Array.isArray(parsed) && parsed.every(v => typeof v === 'string')) {
            selectValue = parsed;
          }
        } catch (_e) { /* not JSON, treat as plain string */ }
      }
      const result = await session.selectOption(resolveTabArg(wsUrlOrIndex), selector, selectValue);
      console.log(JSON.stringify(result.matched.map(o => o.value)));
      process.exit(0);
    } catch (e) {
      console.error('Select failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: eval - evaluate JavaScript
if (command === 'eval') {
  const expression = args.join(' ');
  if (!wsUrlOrIndex || !expression) {
    console.error('Usage: chrome-ws eval <tab-index-or-ws-url> <js-expression>');
    process.exit(1);
  }
  (async () => {
    try {
      const value = await session.evaluate(resolveTabArg(wsUrlOrIndex), expression);
      console.log(JSON.stringify(value, null, 2));
      process.exit(0);
    } catch (e) {
      console.error('Eval failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: extract - get element text content
if (command === 'extract') {
  const [selector] = args;
  if (!wsUrlOrIndex || !selector) {
    console.error('Usage: chrome-ws extract <tab-index-or-ws-url> <selector>');
    process.exit(1);
  }
  (async () => {
    try {
      const wsUrl = await resolveWsUrl(wsUrlOrIndex);
      const js = `document.querySelector(${JSON.stringify(selector)})?.textContent`;
      const result = await sendCdpCommand(wsUrl, 'Runtime.evaluate', {
        expression: js,
        returnByValue: true
      });
      console.log(result.result.value);
    } catch (e) {
      console.error('Extract failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: attr - get element attribute
if (command === 'attr') {
  const [selector, attrName] = args;
  if (!wsUrlOrIndex || !selector || !attrName) {
    console.error('Usage: chrome-ws attr <tab-index-or-ws-url> <selector> <attribute>');
    process.exit(1);
  }
  (async () => {
    try {
      const wsUrl = await resolveWsUrl(wsUrlOrIndex);
      const js = `document.querySelector(${JSON.stringify(selector)})?.getAttribute(${JSON.stringify(attrName)})`;
      const result = await sendCdpCommand(wsUrl, 'Runtime.evaluate', {
        expression: js,
        returnByValue: true
      });
      console.log(result.result.value);
    } catch (e) {
      console.error('Attr failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: html - get HTML content
if (command === 'html') {
  const [selector] = args;
  if (!wsUrlOrIndex) {
    console.error('Usage: chrome-ws html <tab-index-or-ws-url> [selector]');
    process.exit(1);
  }
  (async () => {
    try {
      const wsUrl = await resolveWsUrl(wsUrlOrIndex);
      const js = selector
        ? `document.querySelector(${JSON.stringify(selector)})?.innerHTML`
        : 'document.documentElement.outerHTML';
      const result = await sendCdpCommand(wsUrl, 'Runtime.evaluate', {
        expression: js,
        returnByValue: true
      });
      console.log(result.result.value);
    } catch (e) {
      console.error('HTML failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: wait-text - wait for text to appear
if (command === 'wait-text') {
  // Last positional arg is treated as timeout if it parses as a non-negative
  // integer; otherwise everything is text. This handles both:
  //   wait-text 0 "the text" 3000
  //   wait-text 0 "text without timeout"
  if (!wsUrlOrIndex || args.length === 0) {
    console.error('Usage: chrome-ws wait-text <tab-index-or-ws-url> <text> [timeout-ms]');
    process.exit(1);
  }
  let textArgs = args;
  let timeout = 5000;
  const last = args[args.length - 1];
  const parsedLast = parseInt(last, 10);
  if (args.length >= 2 && Number.isFinite(parsedLast) && parsedLast >= 0 && String(parsedLast) === last.trim()) {
    timeout = parsedLast;
    textArgs = args.slice(0, -1);
  }
  const text = textArgs.join(' ');
  if (!text) {
    console.error('Usage: chrome-ws wait-text <tab-index-or-ws-url> <text> [timeout-ms]');
    process.exit(1);
  }
  (async () => {
    try {
      await session.waitForText(resolveTabArg(wsUrlOrIndex), text, timeout);
      console.log(`Text found: ${text}`);
      process.exit(0);
    } catch (e) {
      console.error('Wait failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: screenshot - capture screenshot
if (command === 'screenshot') {
  const fullPage = args.includes('--fullpage');
  const cleanArgs = args.filter(a => a !== '--fullpage');
  const [filename] = cleanArgs;
  if (!wsUrlOrIndex || !filename) {
    console.error('Usage: chrome-ws screenshot <tab-index-or-ws-url> <filename.png> [--fullpage]');
    process.exit(1);
  }
  (async () => {
    try {
      const savedPath = await session.screenshot(resolveTabArg(wsUrlOrIndex), filename, null, fullPage);
      console.log(`Screenshot saved to ${savedPath}`);
      process.exit(0);
    } catch (e) {
      console.error('Screenshot failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: markdown - save page as markdown
if (command === 'markdown') {
  const [filename] = args;
  if (!wsUrlOrIndex || !filename) {
    console.error('Usage: chrome-ws markdown <tab-index-or-ws-url> <filename.md>');
    process.exit(1);
  }
  (async () => {
    try {
      const wsUrl = await resolveWsUrl(wsUrlOrIndex);

      // Extract page content intelligently
      const js = `
        (() => {
          const title = document.title;
          const url = window.location.href;

          // Get main content (try article, main, or body)
          let content = document.querySelector('article') ||
                       document.querySelector('main') ||
                       document.body;

          // Convert to markdown-ish text
          function nodeToMarkdown(node, level = 0) {
            let md = '';

            if (node.nodeType === Node.TEXT_NODE) {
              const text = node.textContent.trim();
              return text ? text + ' ' : '';
            }

            if (node.nodeType !== Node.ELEMENT_NODE) return '';

            const tag = node.tagName.toLowerCase();

            // Headers
            if (/^h[1-6]$/.test(tag)) {
              const hLevel = parseInt(tag[1]);
              md += '\\n' + '#'.repeat(hLevel) + ' ' + node.textContent.trim() + '\\n\\n';
              return md;
            }

            // Paragraphs
            if (tag === 'p') {
              md += node.textContent.trim() + '\\n\\n';
              return md;
            }

            // Links
            if (tag === 'a') {
              const href = node.getAttribute('href') || '';
              const text = node.textContent.trim();
              return \`[\${text}](\${href}) \`;
            }

            // Lists
            if (tag === 'li') {
              return '- ' + node.textContent.trim() + '\\n';
            }

            // Code
            if (tag === 'code' || tag === 'pre') {
              return '\`' + node.textContent.trim() + '\` ';
            }

            // Recurse for other elements
            for (const child of node.childNodes) {
              md += nodeToMarkdown(child, level + 1);
            }

            if (tag === 'div' || tag === 'section') md += '\\n';

            return md;
          }

          const markdown = nodeToMarkdown(content);

          return \`# \${title}\\n\\nSource: \${url}\\n\\n\${markdown}\`;
        })()
      `;

      const result = await sendCdpCommand(wsUrl, 'Runtime.evaluate', {
        expression: js,
        returnByValue: true
      });

      const fs = require('fs');
      fs.writeFileSync(filename, result.result.value);
      console.log(`Markdown saved to ${filename}`);
    } catch (e) {
      console.error('Markdown conversion failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Command: har - save network traffic as HAR
if (command === 'har') {
  const [filename] = args;
  if (!wsUrlOrIndex || !filename) {
    console.error('Usage: chrome-ws har <tab-index-or-ws-url> <filename.har>');
    console.error('Note: Start recording with "chrome-ws har-start <tab>" first');
    process.exit(1);
  }
  (async () => {
    try {
      const wsUrl = await resolveWsUrl(wsUrlOrIndex);

      // Get HAR data
      const js = `window.__chrome_ws_har__ || []`;
      const result = await sendCdpCommand(wsUrl, 'Runtime.evaluate', {
        expression: js,
        returnByValue: true
      });

      const har = {
        log: {
          version: '1.2',
          creator: { name: 'chrome-ws', version: '1.0.0' },
          entries: result.result.value || []
        }
      };

      const fs = require('fs');
      fs.writeFileSync(filename, JSON.stringify(har, null, 2));
      console.log(`HAR saved to ${filename} (${har.log.entries.length} entries)`);
    } catch (e) {
      console.error('HAR export failed:', e.message);
      process.exit(1);
    }
  })();
  return;
}

// Past all the named-command dispatches without a return → either it's the
// raw escape hatch or it's a typo. Separate those cases so users get an
// actionable error instead of a confusing "Usage: chrome-ws raw ..." banner.
if (command !== 'raw') {
  console.error(`Unknown command: ${command}`);
  console.error(`Run 'chrome-ws --help' for the list of commands.`);
  process.exit(1);
}

if (!wsUrlOrIndex || args.length === 0) {
  console.error('Usage: chrome-ws raw <tab-index-or-ws-url> <json-rpc-payload>');
  process.exit(1);
}

const payload = args.join(' ');
let message;
try {
  message = JSON.parse(payload);
} catch (e) {
  console.error('Invalid JSON payload:', e.message);
  process.exit(1);
}

// For raw command, wsUrlOrIndex must be a full WebSocket URL (not an index)
// since this is the low-level escape hatch
if (!wsUrlOrIndex.startsWith('ws://')) {
  console.error('raw command requires full WebSocket URL, not tab index');
  console.error('Use: chrome-ws tabs  # to get WebSocket URLs');
  process.exit(1);
}

(async () => {
  const ws = new WebSocketClient(wsUrlOrIndex);

  const timeout = setTimeout(() => {
    console.error('Timeout after 30s');
    ws.close();
    process.exit(1);
  }, 30000);

  ws.on('message', (data) => {
    const response = JSON.parse(data);
    if (response.id === message.id) {
      clearTimeout(timeout);
      console.log(JSON.stringify(response, null, 2));
      ws.close();
      process.exit(0);
    }
  });

  ws.on('error', (error) => {
    clearTimeout(timeout);
    console.error('WebSocket error:', error.message);
    process.exit(1);
  });

  try {
    await ws.connect();
    ws.send(JSON.stringify(message));
  } catch (err) {
    clearTimeout(timeout);
    console.error('Connection failed:', err.message);
    process.exit(1);
  }
})();

/**
 * Chrome WebSocket Library - Core CDP automation functions
 * Used by both CLI and MCP server
 *
 * Fixes implemented:
 * - JRV-130: Connection pooling for persistent focus
 * - JRV-127: keyboard_press action for special keys
 * - JRV-123: React-compatible input via Input.insertText
 * - JRV-124: React-compatible click via Input.dispatchMouseEvent
 * - JRV-125: Tab key handling (via keyboard_press)
 * - JRV-126: Better eval return handling
 * - JRV-128: SPA navigation support
 * - JRV-129: Multi-element selector warnings
 */


const { getElementSelector } = require('./lib/element-selector');
const { KEY_DEFINITIONS } = require('./lib/key-definitions');
const { generateHtmlDiff } = require('./lib/html-diff');
const { createState } = require('./lib/session-state');
const { attachCookies } = require('./lib/cookies');
const { attachViewport } = require('./lib/viewport');
const { attachEvaluation } = require('./lib/evaluation');
const { attachMouse } = require('./lib/mouse');
const { attachChromeProcess } = require('./lib/chrome-process');
const { attachCapture } = require('./lib/capture');
const { attachNavigation } = require('./lib/navigation');
const { attachKeyboardInput } = require('./lib/keyboard-input');
const { attachExtraction } = require('./lib/extraction');
const { attachScreenshot } = require('./lib/screenshot');
const { attachTabs, createPageSessionResolver } = require('./lib/tabs');
const { createBrowserSession } = require('./lib/browser-session');
const { attachBrowserBridge } = require('./lib/browser-bridge');
const { attachFileUpload } = require('./lib/file-upload');
const { attachConsoleLogging } = require('./lib/console-logging');
const { attachSelectOption } = require('./lib/select-option');
const { attachDialogs, DialogRefusedError } = require('./lib/dialogs');
const { renderSyntheticArtifacts } = require('./lib/dialogs-render');
const {
  getXdgCacheHome,
  getChromeProfileDir,
  getProfileMetaPath,
  readProfileMeta,
  writeProfileMeta,
  clearProfileMeta,
  findAvailablePort,
  buildChromeArgs,
} = require('./lib/chrome-launcher-helpers');

/**
 * Session methods whose CDP work targets the page (tab) target.
 * When a native browser dialog is open, these methods will wedge waiting for a
 * CDP response that never arrives because the dialog blocks the JS runtime.
 * The session-boundary wrapper below refuses them with a descriptive error
 * rather than hanging until timeout.
 *
 * Browser-target methods (getTabs, newTab, closeTab, startChrome, …) are NOT
 * listed here — they route through the browser target and work fine while a
 * dialog is open.
 */
const PAGE_TARGET_SESSION_METHODS = new Set([
  'navigate',
  'back',
  'forward',
  'click',
  'fill',
  'selectOption',
  'evaluate',
  'extractText',
  'getHtml',
  'getAttribute',
  'waitForElement',
  'waitForText',
  'screenshot',
  'hover',
  'drag',
  'mouseMove',
  'scroll',
  'doubleClick',
  'rightClick',
  'humanType',
  'fileUpload',
  'keyboardPress',
  'clickWithCapture',
  'fillWithCapture',
  'selectOptionWithCapture',
  'evaluateWithCapture',
  // captureActionWithDiff is intentionally excluded: it is a meta-wrapper whose
  // second arg is an action-type string ('type', 'click', …), not a selector.
  // The inner actions it wraps (humanType, click, hover, etc.) are individually
  // listed above and each have their own dialog gating via
  // withDialogAwarenessForSession in capture.js.  Re-gating the wrapper at this
  // boundary would cause it to refuse dialog::* selectors before the inner action
  // ever sees them (scenario 10C basic-auth typing bug).
  'setViewport',
  'clearViewport',
  'getViewport',
]);

/**
 * Build a fresh Chrome session — a state-bag scoped to a single Chrome target.
 *
 * Pre-factory, every consumer that required this file shared module-level
 * state: the connection pool, console-message buffers, the chosen profile
 * name, the launched Chrome process handle, the active CDP port, and the
 * host-override config. Two consumers in the same process therefore drove a
 * single Chrome — fine for the CLI and the MCP server (each owns its
 * process), but a hazard for any caller that wants to drive multiple Chromes
 * concurrently from one Node process (different ports, different profiles).
 *
 * `createSession({ host, port })` returns a fresh instance with private state
 * and methods bound to that state. Two instances do not share a connection
 * pool, console-message map, profile, Chrome process, or host-override —
 * mutating one (e.g. setProfileName, startChrome) has no effect on the other.
 * Pass `host`/`port` to seed the host-override; omit them to seed from the
 * `CHROME_WS_HOST` / `CHROME_WS_PORT` env vars exactly as before.
 *
 * The returned object preserves the legacy module-level export shape — the
 * one-line consumer migration is `require(...)` becomes
 * `require(...).createSession()`.
 */
function createSession({ host, port, _testFakes } = {}) {
  const state = createState({ host, port });

  // =============================================================================
  const dialogs = attachDialogs({ state });

  const { chromeHttp, resolveWsUrl, getTabs, newTab, closeTab } = attachTabs({ state });

  // Bridge primitives — single root WebSocket with flatten-mode page sessions.
  // The browser-session is constructed immediately (lazy connect on first use).
  // attachBrowserBridge issues Target.setDiscoverTargets which connects the root
  // WS, so we defer it behind state.ensureBridge() (lazy).
  const effectiveChromeHttp = (_testFakes && _testFakes.chromeHttp) ? _testFakes.chromeHttp : chromeHttp;
  const browserSessionFactory = () => createBrowserSession({
    host: state.hostOverride.getHost(),
    port: state.hostOverride.getPort(),
    rewriteWsUrl: state.rewriteWsUrl,
    chromeHttp: effectiveChromeHttp,
    WebSocketClient: _testFakes && _testFakes.WebSocketClient,
  });
  state.browserSession = browserSessionFactory();

  let bridgePromise = null;

  // Reset all bridge-layer state so the next ensureBridge() call re-attaches from
  // scratch. Called by killChrome (explicit kill) and ensureBridge (stale detection).
  // Does NOT call detach on cached pageSessions — the underlying WebSocket is
  // already dead at call time, so detach would fail. Use resolver.release() per-tab
  // before calling resetBridge if graceful cleanup is possible.
  state.resetBridge = () => {
    if (state.pageSessionResolver) {
      state.pageSessionResolver.releaseAll();
    }
    state.pageSessionResolver = null;
    state.browserBridge = null;
    state.browserSession = browserSessionFactory();
    bridgePromise = null;
  };

  state.ensureBridge = () => {
    // Detect stale bridge: if the cached browserSession is no longer connected,
    // reset everything so we re-attach to the restarted Chrome process.
    if (state.browserBridge && state.browserSession && !state.browserSession.isConnected()) {
      state.resetBridge();
    }
    if (state.browserBridge) return Promise.resolve(state.browserBridge);
    if (bridgePromise) return bridgePromise;
    bridgePromise = (async () => {
      const bridge = await attachBrowserBridge({
        browser: state.browserSession,
        host: state.hostOverride.getHost(),
        port: state.hostOverride.getPort(),
        rewriteWsUrl: state.rewriteWsUrl,
        autoAttach: true,
        onPageSession: async (ps) => {
          // Install dialog shim before the paused target resumes.
          // This gives popups, OAuth windows, and child frames dialog
          // handling from their very first script.
          try {
            await dialogs.attachToPageSession(ps);
          } catch (e) {
            console.error('onPageSession dialog attach failed:', e);
          }
          // Prime the pageSession resolver cache so subsequent getPageSession(popup)
          // calls return THIS session rather than issuing a duplicate Target.attachToTarget.
          // The dialog is registered under THIS session's sessionId; agent commands
          // must route through the same session to handle the dialog.
          if (state.pageSessionResolver && ps.targetId) {
            state.pageSessionResolver.prime(ps.targetId, ps);
          }
        },
      });
      state.browserBridge = bridge;
      state.pageSessionResolver = createPageSessionResolver({ bridge });
      return bridge;
    })();
    // Clear bridgePromise on failure so the next call retries
    bridgePromise.catch(() => { bridgePromise = null; });
    return bridgePromise;
  };

  // getPageSession(tabIndexOrWsUrl) — shared resolver for pageSession-migrated libs.
  // Accepts either a numeric tab index or a ws:// URL, lazy-boots the bridge, and
  // returns a cached pageSession for the target. Reused by E2-E13 migration libs.
  async function getPageSession(tabIndexOrWsUrl) {
    await state.ensureBridge();
    let tab;
    if (typeof tabIndexOrWsUrl === 'number') {
      const tabs = await getTabs();
      tab = tabs[tabIndexOrWsUrl];
      if (!tab) throw new Error(`No tab at index ${tabIndexOrWsUrl}`);
    } else if (typeof tabIndexOrWsUrl === 'string') {
      // Extract targetId from a ws URL like ws://host:port/devtools/page/<targetId>
      const m = /\/devtools\/page\/([^/]+)$/.exec(tabIndexOrWsUrl);
      if (!m) throw new Error(`Cannot extract targetId from: ${tabIndexOrWsUrl}`);
      tab = { id: m[1] };
    } else if (tabIndexOrWsUrl && tabIndexOrWsUrl.id) {
      // Already a tab handle
      tab = tabIndexOrWsUrl;
    } else {
      throw new Error('Unrecognized tabIndexOrWsUrl');
    }
    const ps = await state.pageSessionResolver(tab);
    // Ensure dialog event listeners are wired up on the bridge session the first
    // time a page session is obtained. This enables Page.javascriptDialogOpening
    // events to arrive via the bridge path (stored under sessionId).
    await dialogs.attachToPageSession(ps);
    return ps;
  }

  const { click, hover, drag, mouseMove, scroll, doubleClick, rightClick } =
    attachMouse({ getPageSession, dialogs });

  const { keyboardPress, fill, humanType } =
    attachKeyboardInput({ state, getPageSession, click, dialogs });

  const { fileUpload } = attachFileUpload({ getPageSession });

  const { selectOption } = attachSelectOption({ getPageSession });

  const { evaluate } = attachEvaluation({ getPageSession });

  // =============================================================================

  const { extractText, getHtml, getAttribute } = attachExtraction({ getPageSession });


  // getSessionDir is a lazy thunk: capture.js populates state.sessionDir via
  // initializeSession(). We close over `state` so screenshot.js always reads
  // the freshly-set value. If no capture has happened yet, we delegate to
  // captureInitializer (set below after attachCapture) to create the dir.
  // The ref itself must live before attachScreenshot and attachCapture, but the
  // actual initializeSession function is injected after attachCapture runs.
  const screenshotDirRef = { initializeSession: null };

  const { screenshot } = attachScreenshot({
    getPageSession,
    state,
    initializeSession: () => {
      if (screenshotDirRef.initializeSession) return screenshotDirRef.initializeSession();
      // Fallback if called before attachCapture (shouldn't happen in normal flow).
      if (state.sessionDir) return state.sessionDir;
      throw new Error('Session directory not yet initialized. Call an auto-capture action first.');
    },
  });

  const { startChrome, killChrome, showBrowser, hideBrowser, getBrowserMode, getChromePid, getActivePort, getProfileName, setProfileName } =
    attachChromeProcess({ state, chromeHttp, getTabs, newTab });

  const { enableConsoleLogging, getConsoleMessages, clearConsoleMessages } =
    attachConsoleLogging({ state, getPageSession });

  const {
    initializeSession,
    cleanupSession,
    createCapturePrefix,
    generateDomSummary,
    getPageSize,
    generateMarkdown,
    capturePageArtifacts,
    captureActionWithDiff,
    clickWithCapture,
    fillWithCapture,
    selectOptionWithCapture,
    evaluateWithCapture,
  } = attachCapture({
    state,
    getPageSession,
    getHtml,
    screenshot,
    actions: { click, fill, selectOption, evaluate },
    dialogs,
  });

  // Wire the forward reference so screenshot.js can call initializeSession.
  screenshotDirRef.initializeSession = initializeSession;

  const { navigate, waitForElement, waitForText, back, forward } =
    attachNavigation({ state, getPageSession, capturePageArtifacts, evaluate });

  const { setViewport, clearViewport, getViewport } = attachViewport({ getPageSession });
  const { clearCookies } = attachCookies({ getPageSession });

  // ---------------------------------------------------------------------------
  // Session-boundary dialog gate
  //
  // Wraps every page-target method so that any call issued while a native dialog
  // is open returns a structured refusal instead of hanging until a CDP timeout.
  //
  // Convention (mirrors all other page-target methods in this library):
  //   fn(tabIndexOrWsUrl, selectorOrArg, ...rest)
  //
  // If the second argument is a string beginning with "dialog::", it is a
  // dialog-selector call (e.g. click("dialog::accept")) and must be allowed
  // through so the existing internal routers in mouse.js and keyboard-input.js
  // can handle it.
  // ---------------------------------------------------------------------------
  function wrapWithDialogGate(_name, fn) {
    return async function dialogGated(tabIndexOrWsUrl, secondArg, ...rest) {
      // Resolve the ws URL so we can look up dialog state.
      // resolveWsUrl may throw (e.g., no Chrome running) — let it propagate
      // naturally; that's not a dialog problem.
      let wsUrl;
      try {
        wsUrl = await resolveWsUrl(tabIndexOrWsUrl);
      } catch {
        // Can't resolve the URL — delegate and let the method surface the error.
        return fn(tabIndexOrWsUrl, secondArg, ...rest);
      }

      // Look up dialog state keyed by sessionId (via targetId→sessionId map populated
      // by attachToPageSession). dialogs.getOpen() handles both direct sessionId keys
      // and wsUrl paths by extracting the targetId from the URL.
      const open = dialogs.getOpen(wsUrl);

      const isDialogSelector = typeof secondArg === 'string' && secondArg.startsWith('dialog::');

      if (open && !isDialogSelector) {
        throw new DialogRefusedError({ dialog: open, artifacts: renderSyntheticArtifacts(open) });
      }

      return fn(tabIndexOrWsUrl, secondArg, ...rest);
    };
  }

  // Build the raw session object, then wrap page-target methods.
  const rawSession = {
    // State bag (exposed for bridge consumers and testing)
    state,

    // Internal helpers (exported for testing)
    getElementSelector,

    // Core browser actions (click/fill now use CDP events by default for React compatibility)
    getTabs,
    newTab,
    closeTab,
    navigate,
    click,           // Uses CDP mouse events, falls back to el.click()
    fill,            // Uses CDP insertText, falls back to el.value=
    selectOption,    // Warns if selector matches multiple elements
    evaluate,
    extractText,
    getHtml,
    getAttribute,
    waitForElement,
    waitForText,
    back,
    forward,
    screenshot,

    // Mouse actions (CDP-level, bypasses synthetic event restrictions)
    hover,            // Move mouse over element (CSS :hover, tooltips)
    drag,             // Drag-and-drop via native mouse event sequence
    mouseMove,        // Raw coordinate mouse movement
    scroll,           // Mouse wheel scrolling
    doubleClick,      // Double-click with dblclick event
    rightClick,       // Right-click with contextmenu event

    // Human-like typing (individual keyDown/keyUp with realistic timing)
    humanType,

    // File upload (DOM.setFileInputFiles — can't be done via JS)
    fileUpload,

    // Keyboard support for special keys (Tab, Enter, Escape, Arrow keys, etc.)
    keyboardPress,
    KEY_DEFINITIONS,

    // Chrome lifecycle
    startChrome,
    buildChromeArgs,
    killChrome,
    showBrowser,
    hideBrowser,
    getBrowserMode,
    getChromePid,

    // Profile management
    getChromeProfileDir,
    getProfileName,
    setProfileName,

    // Console logging
    enableConsoleLogging,
    getConsoleMessages,
    clearConsoleMessages,

    // Session management
    getXdgCacheHome,
    initializeSession,
    cleanupSession,
    createCapturePrefix,

    // Auto-capture utilities
    generateDomSummary,
    getPageSize,
    generateMarkdown,
    capturePageArtifacts,
    clickWithCapture,
    fillWithCapture,
    selectOptionWithCapture,
    evaluateWithCapture,

    // DOM diff capture (before/after with diff)
    generateHtmlDiff,
    captureActionWithDiff,

    // Dynamic port allocation and per-profile meta.json
    getActivePort,
    findAvailablePort,
    getProfileMetaPath,
    readProfileMeta,
    writeProfileMeta,
    clearProfileMeta,

    // Viewport/device emulation
    setViewport,
    clearViewport,
    getViewport,

    // Cookie management
    clearCookies,

    // Dialog awareness
    dialogs,

  };

  // Apply the session-boundary dialog gate to every page-target method.
  for (const name of PAGE_TARGET_SESSION_METHODS) {
    if (typeof rawSession[name] === 'function') {
      rawSession[name] = wrapWithDialogGate(name, rawSession[name]);
    }
  }

  return rawSession;
}

module.exports = { createSession, PAGE_TARGET_SESSION_METHODS, DialogRefusedError };

const DEFAULT_PORT = 9222;
const DEFAULT_HOST = '127.0.0.1';

/**
 * Build a per-instance host-override configuration.
 *
 * The legacy module-level constants and `rewriteWsUrl` above are baked at
 * module-load time and shared across every consumer that requires this
 * file. That's fine for the single-Chrome use case — the CLI and the MCP
 * server each own their process, so module-level state is effectively
 * per-process. It breaks down when one process needs to drive several
 * independent Chrome instances concurrently (different host/port pairs):
 * the load-time constants can only describe one of them.
 *
 * `createOverride({ host, port })` returns a fresh state-bag with its own
 * host/port/override-enabled flag, plus methods (`getHost`, `getPort`,
 * `getBase`, `isOverrideEnabled`, `rewriteWsUrl`, `setDefaults`) bound to
 * that state. Two instances do not share state — mutating one via
 * `setDefaults()` does not affect the other. Callers that don't need
 * per-instance isolation can keep using the module-level constants and
 * `rewriteWsUrl` exactly as before; nothing about the legacy API has
 * changed.
 *
 * Defaults: if both `host` and `port` are omitted, the instance seeds from
 * the `CHROME_WS_HOST` / `CHROME_WS_PORT` env vars. If either argument is
 * supplied, both are taken from the arguments (filling in defaults for the
 * missing one) and the instance's `overrideEnabled` flag starts true —
 * matching `setDefaults()` semantics.
 */
function createOverride({ host, port } = {}) {
  let instanceHost;
  let instancePort;
  let instanceOverrideEnabled;

  if (host !== undefined || port !== undefined) {
    instanceHost = host !== undefined ? host : DEFAULT_HOST;
    instancePort = port !== undefined ? port : DEFAULT_PORT;
    instanceOverrideEnabled = true;
  } else {
    instanceHost = process.env.CHROME_WS_HOST || DEFAULT_HOST;
    const parsed = parseInt(process.env.CHROME_WS_PORT || `${DEFAULT_PORT}`, 10);
    instancePort = Number.isNaN(parsed) ? DEFAULT_PORT : parsed;
    instanceOverrideEnabled =
      process.env.CHROME_WS_HOST !== undefined || process.env.CHROME_WS_PORT !== undefined;
  }

  function setDefaults(nextHost, nextPort) {
    instanceHost = nextHost;
    instancePort = nextPort;
    instanceOverrideEnabled = true;
  }

  function getHost() {
    return instanceHost;
  }

  function getPort() {
    return instancePort;
  }

  function getBase() {
    return `http://${instanceHost}:${instancePort}`;
  }

  function isOverrideEnabled() {
    return instanceOverrideEnabled;
  }

  function instanceRewriteWsUrl(originalUrl, overrideHost, overridePort) {
    if (!originalUrl || typeof originalUrl !== 'string') {
      return originalUrl;
    }
    if (!instanceOverrideEnabled) {
      return originalUrl;
    }
    const useHost = overrideHost !== undefined ? overrideHost : instanceHost;
    const usePort = overridePort !== undefined ? overridePort : instancePort;
    try {
      const url = new URL(originalUrl);
      url.hostname = useHost;
      url.port = `${usePort}`;
      return url.toString();
    } catch {
      return originalUrl;
    }
  }

  return {
    setDefaults,
    getHost,
    getPort,
    getBase,
    isOverrideEnabled,
    rewriteWsUrl: instanceRewriteWsUrl,
  };
}

module.exports = { createOverride };

'use strict';

const { createCdpRouter } = require('./cdp-router');
const { attachPageSession, buildPageSessionFromAttached } = require('./page-session');

/**
 * attachBrowserBridge({browser, host, port, rewriteWsUrl}) — consumer-facing
 * bridge over the browser-session.
 *
 * Exposes:
 *   targets.list()                 — synchronous snapshot of current targets
 *   targets.onCreated(handler)     — register listener; returns unsub fn
 *   targets.onDestroyed(handler)
 *   targets.waitForNew(predicate, {timeoutMs})
 *   createBrowserContext({proxyServer?}) -> {browserContextId, createPage, dispose}
 *   attachPageSession(targetId)    — page session over the browser-WS via flatten mode
 *
 * host/port/rewriteWsUrl are needed by createBrowserContext.createPage to construct
 * per-page WS URLs for callers that still want one (the bridge itself never uses
 * them — page sessions ride the browser-WS).
 */
async function attachBrowserBridge({ browser, host, port, rewriteWsUrl, autoAttach = false, onPageSession = null }) {
  // The cdp-router sits between browser-session and bridge consumers.
  // Page-session-tagged messages dispatch to the right session; root-session
  // events (Target.*, etc.) fire root listeners. Command responses without
  // sessionId stay correlated by browser-session.js's pendingRequests
  // (single source of truth for root-session correlation).
  const router = createCdpRouter({ browser });

  const targetMap = new Map();      // targetId -> targetInfo
  const onCreatedFns = new Set();
  const onDestroyedFns = new Set();

  router.getRootListeners().add((msg) => {
    if (msg.method === 'Target.targetCreated') {
      const t = msg.params.targetInfo;
      targetMap.set(t.targetId, t);
      for (const fn of onCreatedFns) {
        try { fn(t); } catch (e) { console.error('targets onCreated handler threw:', e); }
      }
    } else if (msg.method === 'Target.targetInfoChanged') {
      const t = msg.params.targetInfo;
      targetMap.set(t.targetId, t);
    } else if (msg.method === 'Target.targetDestroyed') {
      const t = targetMap.get(msg.params.targetId);
      targetMap.delete(msg.params.targetId);
      if (t) {
        for (const fn of onDestroyedFns) {
          try { fn(t); } catch (e) { console.error('targets onDestroyed handler threw:', e); }
        }
      }
    }
  });

  // Handle auto-attached targets (popups, child frames, etc.) when autoAttach is on.
  // Chrome emits this with an already-allocated sessionId — no Target.attachToTarget needed.
  //
  // Only act on targets that are paused (waitingForDebugger: true). Existing tabs
  // that Chrome retrospectively reports via attachedToTarget (waitingForDebugger: false)
  // are not paused and will be set up through the normal getPageSession/attachPageSession
  // path. Installing a page session here for those targets would register the same
  // sessionId twice in the cdp-router, causing duplicate-id protocol errors.
  router.getRootListeners().add(async (msg) => {
    if (msg.method !== 'Target.attachedToTarget') return;
    const { sessionId, targetInfo, waitingForDebugger } = msg.params;

    if (!waitingForDebugger) return;

    const ps = buildPageSessionFromAttached({ browser, router, sessionId, targetId: targetInfo.targetId });

    // Only run the onPageSession hook for page-type targets. Non-page targets
    // (service_worker, background_page, etc.) don't support the Page CDP domain
    // and would cause 'Page.enable' wasn't found errors in the hook.
    if (onPageSession && targetInfo.type === 'page') {
      try { await onPageSession(ps); }
      catch (e) { console.error('onPageSession hook threw:', e); }
    }

    // Resume the paused target AFTER the hook so any shims (e.g. dialog) are
    // installed before the page's scripts run.
    try { await ps.send('Runtime.runIfWaitingForDebugger', {}); }
    catch (e) { console.error('Runtime.runIfWaitingForDebugger failed:', e); }
  });

  // Subscribe — replays existing targets as targetCreated events.
  await browser.send('Target.setDiscoverTargets', { discover: true });

  if (autoAttach) {
    await browser.send('Target.setAutoAttach', {
      autoAttach: true,
      waitForDebuggerOnStart: true,
      flatten: true,
    });
  }

  function list() { return Array.from(targetMap.values()); }
  function onCreated(fn) { onCreatedFns.add(fn); return () => onCreatedFns.delete(fn); }
  function onDestroyed(fn) { onDestroyedFns.add(fn); return () => onDestroyedFns.delete(fn); }

  function waitForNew(predicate, { timeoutMs = 15000 } = {}) {
    return new Promise((resolve, reject) => {
      let unsub = null;
      const timeout = setTimeout(() => {
        if (unsub) unsub();
        reject(new Error(`waitForNew: timed out after ${timeoutMs}ms`));
      }, timeoutMs);
      unsub = onCreated((t) => {
        let match;
        try { match = predicate(t); }
        catch (e) {
          clearTimeout(timeout);
          if (unsub) unsub();
          reject(e);
          return;
        }
        if (match) {
          clearTimeout(timeout);
          if (unsub) unsub();
          resolve(t);
        }
      });
    });
  }

  /**
   * createBrowserContext({proxyServer?}) — creates a Chrome BrowserContext.
   * Returns {browserContextId, createPage, dispose}.
   *
   * createPage(url) calls Target.createTarget({url, browserContextId}) and
   * constructs a tab-shape-compatible page handle whose webSocketDebuggerUrl
   * is run through rewriteWsUrl.
   *
   * dispose() is atomic — Chrome tears down cookies/storage/IDB/SW for the
   * context in one call.
   */
  async function createBrowserContext(opts = {}) {
    const params = {};
    if (opts.proxyServer) params.proxyServer = opts.proxyServer;
    const { browserContextId } = await browser.send('Target.createBrowserContext', params);
    let disposed = false;

    async function createPage(url = 'about:blank') {
      if (disposed) throw new Error('BrowserContext disposed');
      const { targetId } = await browser.send('Target.createTarget', { url, browserContextId });
      const rawWsUrl = `ws://${host}:${port}/devtools/page/${targetId}`;
      return {
        id: targetId, targetId,
        webSocketDebuggerUrl: rewriteWsUrl(rawWsUrl, host, port),
        type: 'page', url, browserContextId,
      };
    }

    async function dispose() {
      if (disposed) return;
      disposed = true;
      try { await browser.send('Target.disposeBrowserContext', { browserContextId }); }
      catch (e) { console.warn('BrowserContext.dispose() failed:', e && e.message); }
    }

    return { browserContextId, createPage, dispose };
  }

  async function attachPage(targetId) {
    return attachPageSession({ browser, router }, targetId);
  }

  return {
    targets: { list, onCreated, onDestroyed, waitForNew },
    createBrowserContext,
    attachPageSession: attachPage,
    router,
  };
}

module.exports = { attachBrowserBridge };

'use strict';

const { WebSocketClient: DefaultWebSocketClient } = require('./websocket-client');

/**
 * createBrowserSession({host, port, rewriteWsUrl, chromeHttp, WebSocketClient?}) -> bridge handle.
 *
 * Owns the one root WebSocket to /devtools/browser/<id>. Page-action commands ride
 * per-page sessions (attached via Target.attachToTarget({flatten:true})) and envelope
 * messages with a sessionId via sendRaw — the page session manages its own pendingRequests
 * (in the cdp-router). browser-session correlates ROOT-session command responses only.
 *
 * Returned API:
 *   send(method, params?, {timeoutMs?})  -> Promise<result>  // root command
 *   onEvent(handler)                     -> unsub fn
 *   close()                              -> Promise<void>
 *   isConnected()                        -> boolean
 *   sendRaw(json)                        -> void
 */
function createBrowserSession({ host, port, rewriteWsUrl, chromeHttp, WebSocketClient = DefaultWebSocketClient }) {
  let ws = null;
  const pendingRequests = new Map(); // id -> {resolve, reject, timeout}
  let messageIdCounter = 1;
  const eventListeners = new Set();
  let connectPromise = null;
  let closed = false;

  async function ensureConnected() {
    if (ws && ws.isConnected()) return;
    if (connectPromise) { await connectPromise; return; }
    connectPromise = (async () => {
      try {
        const versionInfo = await chromeHttp('/json/version');
        if (!versionInfo || !versionInfo.webSocketDebuggerUrl) {
          throw new Error('chromeHttp(/json/version) returned no webSocketDebuggerUrl');
        }
        const url = rewriteWsUrl(versionInfo.webSocketDebuggerUrl, host, port);
        const next = new WebSocketClient(url);
        next.on('message', (raw) => {
          let data;
          try { data = JSON.parse(raw); } catch (e) {
            console.error('browser-session: bad JSON from CDP:', e);
            return;
          }
          // Correlate ROOT-session command responses (id without sessionId). Page-session
          // responses carry {id, result, sessionId} and fall through to event listeners
          // for the cdp-router to dispatch.
          if (data.id !== undefined && data.sessionId === undefined) {
            const pending = pendingRequests.get(data.id);
            if (pending) {
              clearTimeout(pending.timeout);
              pendingRequests.delete(data.id);
              if (data.error) {
                pending.reject(new Error(data.error.message || JSON.stringify(data.error)));
              } else {
                pending.resolve(data.result);
              }
              return;
            }
          }
          for (const fn of eventListeners) {
            try { fn(data); } catch (e) { console.error('browser-session listener threw:', e); }
          }
        });
        next.on('close', () => {
          for (const [, p] of pendingRequests) {
            clearTimeout(p.timeout);
            p.reject(new Error('Browser session WS closed'));
          }
          pendingRequests.clear();
        });
        await next.connect();
        // Assign ws only after a successful connect so concurrent callers that hit the
        // `ws && ws.isConnected()` early-return don't see a half-initialized socket.
        ws = next;
      } catch (e) {
        // Allow retry after a transient failure (network blip, Chrome not yet ready, etc.).
        // We do NOT null on success — leaving the resolved promise in place makes subsequent
        // ensureConnected() awaits a no-op.
        connectPromise = null;
        throw e;
      }
    })();
    await connectPromise;
  }

  async function send(method, params = {}, { timeoutMs = 10000 } = {}) {
    if (closed) throw new Error('Browser session closed');
    await ensureConnected();
    if (closed) throw new Error('Browser session closed');
    const id = messageIdCounter++;
    return new Promise((resolve, reject) => {
      const timeout = setTimeout(() => {
        pendingRequests.delete(id);
        reject(new Error(`Browser session timeout: ${method}`));
      }, timeoutMs);
      pendingRequests.set(id, { resolve, reject, timeout });
      try {
        ws.send(JSON.stringify({ id, method, params }));
      } catch (e) {
        clearTimeout(timeout);
        pendingRequests.delete(id);
        reject(e);
      }
    });
  }

  function onEvent(handler) {
    eventListeners.add(handler);
    return () => eventListeners.delete(handler);
  }

  async function close() {
    closed = true;
    if (ws) { ws.close(); ws = null; }
    for (const [, p] of pendingRequests) {
      clearTimeout(p.timeout);
      p.reject(new Error('Browser session closed'));
    }
    pendingRequests.clear();
    eventListeners.clear();
  }

  function isConnected() { return ws !== null && ws.isConnected(); }

  function sendRaw(json) {
    if (closed) throw new Error('Browser session closed');
    if (!ws || !ws.isConnected()) {
      throw new Error('Browser WS not connected (call send() first to lazy-open)');
    }
    ws.send(json);
  }

  return { send, onEvent, close, isConnected, sendRaw };
}

module.exports = { createBrowserSession };

'use strict';

/**
 * createCdpRouter({browser}) — sessionId-aware dispatcher for browser-WS messages.
 *
 * Routing rules:
 *   - msg.sessionId set         -> per-session pendingRequests (if msg.id) or eventListeners (if msg.method)
 *   - msg.method, no sessionId  -> root listeners (target events, etc.)
 *   - msg.id, no sessionId      -> falls through (browser-session.js owns root correlation)
 *
 * Per-session message-id counters are independent. {id:1, sessionId:"A"} and
 * {id:1, sessionId:"B"} correlate independently on one WS — collapsing id space
 * across sessions would silently break correlation.
 */
function createCdpRouter({ browser }) {
  const sessions = new Map(); // sessionId -> { pendingRequests, eventListeners }
  const rootListeners = new Set();

  browser.onEvent((msg) => {
    const sid = msg.sessionId;
    if (sid) {
      const sess = sessions.get(sid);
      if (!sess) return; // detached or never registered — drop silently
      if (msg.id !== undefined) {
        const pending = sess.pendingRequests.get(msg.id);
        if (pending) {
          clearTimeout(pending.timeout);
          sess.pendingRequests.delete(msg.id);
          if (msg.error) {
            pending.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
          } else {
            pending.resolve(msg.result);
          }
        }
      } else if (msg.method) {
        for (const fn of sess.eventListeners) {
          try { fn(msg); } catch (e) { console.error('cdp-router page listener threw:', e); }
        }
      }
    } else if (msg.method) {
      for (const fn of rootListeners) {
        try { fn(msg); } catch (e) { console.error('cdp-router root listener threw:', e); }
      }
    }
    // Untagged responses (msg.id with no sessionId, no method) intentionally
    // fall through — browser-session.js's pendingRequests Map handles them.
  });

  function registerSession(sessionId) {
    const sess = { pendingRequests: new Map(), eventListeners: new Set() };
    sessions.set(sessionId, sess);
    return sess;
  }

  function unregisterSession(sessionId) {
    const sess = sessions.get(sessionId);
    if (!sess) return;
    for (const [, p] of sess.pendingRequests) {
      clearTimeout(p.timeout);
      p.reject(new Error('Page session detached'));
    }
    sess.pendingRequests.clear();
    sess.eventListeners.clear();
    sessions.delete(sessionId);
  }

  function getRootListeners() { return rootListeners; }

  return { registerSession, unregisterSession, getRootListeners };
}

module.exports = { createCdpRouter };

/**
 * Shared utilities for CDP responses.
 *
 * `throwIfExceptionDetails(result)` inspects a `Runtime.evaluate` reply and
 * throws if the page-side JS threw or a Promise rejected. Without this,
 * callers silently see `undefined` instead of the actual error — which has
 * caused real bugs (waitForElement timeouts swallowed, evaluate returning {}
 * for thrown errors). Use after every `sendCdpCommand(...,'Runtime.evaluate',...)`.
 */
function throwIfExceptionDetails(result) {
  if (!result || !result.exceptionDetails) return;
  const desc = result.exceptionDetails.exception?.description
    || result.exceptionDetails.text
    || 'unknown evaluation error';
  throw new Error(`evaluate failed: ${desc}`);
}

module.exports = { throwIfExceptionDetails };

/**
 * Page console-message capture.
 *
 * `enableConsoleLogging` subscribes to `Runtime.consoleAPICalled` events on
 * the existing pageSession (bridge) connection and streams console output into
 * `state.consoleMessages` keyed by `sessionId`.
 *
 * `getConsoleMessages` reads the buffer — optionally filtered by timestamp.
 * `clearConsoleMessages` resets the buffer for a tab.
 *
 * `attachConsoleLogging({ state, getPageSession })` returns the bound API.
 */
function attachConsoleLogging({ state, getPageSession }) {
  async function enableConsoleLogging(tabIndexOrWsUrl) {
    const ps = await getPageSession(tabIndexOrWsUrl);

    if (!state.consoleMessages.has(ps.sessionId)) {
      state.consoleMessages.set(ps.sessionId, []);
    }

    await ps.enableDomain('Runtime');

    ps.onEvent((msg) => {
      if (msg.method === 'Runtime.consoleAPICalled') {
        const entry = msg.params;
        const timestamp = new Date().toISOString();
        const level = entry.type || 'log';
        const args = entry.args || [];

        const text = args.map(arg => {
          if (arg.type === 'string') return arg.value;
          if (arg.type === 'number') return String(arg.value);
          if (arg.type === 'boolean') return String(arg.value);
          if (arg.type === 'object') return arg.description || '[Object]';
          return String(arg.value || arg.description || arg.type);
        }).join(' ');

        const messages = state.consoleMessages.get(ps.sessionId) || [];
        // Dedup: skip if the last entry has the same level+text at the same
        // timestamp (prevents double-fire when multiple CDP event listeners
        // route the same console call through the same handler).
        const last = messages[messages.length - 1];
        if (!last || last.timestamp !== timestamp || last.level !== level || last.text !== text) {
          messages.push({ timestamp, level, text });
          state.consoleMessages.set(ps.sessionId, messages);
        }
      }
    });
  }

  async function getConsoleMessages(tabIndexOrWsUrl, sinceTime = null) {
    const ps = await getPageSession(tabIndexOrWsUrl);
    const messages = state.consoleMessages.get(ps.sessionId) || [];

    if (!sinceTime) {
      return messages;
    }

    return messages.filter(msg => new Date(msg.timestamp) > sinceTime);
  }

  async function clearConsoleMessages(tabIndexOrWsUrl) {
    const ps = await getPageSession(tabIndexOrWsUrl);
    state.consoleMessages.set(ps.sessionId, []);
  }

  return { enableConsoleLogging, getConsoleMessages, clearConsoleMessages };
}

module.exports = { attachConsoleLogging };

/**
 * Cookie management — currently just a single "clear everything" action.
 *
 * Takes `getPageSession(tabIndexOrWsUrl)`: a resolver provided by chrome-ws-lib
 * that handles both tab-index and ws-url inputs, lazy-bootstraps the CDP bridge,
 * and returns a pageSession driving CDP via flatten mode.
 */
function attachCookies({ getPageSession }) {
  async function clearCookies(tabIndexOrWsUrl) {
    const ps = await getPageSession(tabIndexOrWsUrl);
    await ps.send('Network.clearBrowserCookies', {});
  }

  return { clearCookies };
}

module.exports = { attachCookies };

'use strict';

function renderSyntheticArtifacts(s) {
  const origin = s.payload.url || '(unknown)';
  let markdown;

  if (s.kind === 'alert') {
    markdown = [
      `# Dialog: alert`,
      `Tab origin: ${origin}`,
      ``,
      `> ${s.payload.message}`,
      ``,
      `Buttons:`,
      `  - dialog::accept   (OK)`,
      ``,
      `To interact:`,
      `  click selector="dialog::accept"`,
    ].join('\n');
  } else if (s.kind === 'confirm') {
    markdown = [
      `# Dialog: confirm`,
      `Tab origin: ${origin}`,
      ``,
      `> ${s.payload.message}`,
      ``,
      `Buttons:`,
      `  - dialog::accept   (OK)`,
      `  - dialog::dismiss  (Cancel)`,
      ``,
      `To interact:`,
      `  click selector="dialog::accept"`,
      `  click selector="dialog::dismiss"`,
    ].join('\n');
  } else if (s.kind === 'prompt') {
    const lines = [
      `# Dialog: prompt`,
      `Tab origin: ${origin}`,
      ``,
      `> ${s.payload.message}`,
    ];
    if (s.payload.defaultPrompt) lines.push(`Default: "${s.payload.defaultPrompt}"`);
    lines.push(``, `Input: dialog::prompt   (type text here, then click dialog::accept)`);
    lines.push(`Buttons:`, `  - dialog::accept`, `  - dialog::dismiss`);
    markdown = lines.join('\n');
  } else if (s.kind === 'beforeunload') {
    markdown = [
      `# Dialog: beforeunload`,
      `Tab origin: ${origin}`,
      ``,
      `> ${s.payload.message || 'The page wants to confirm you really want to leave.'}`,
      ``,
      `Buttons:`,
      `  - dialog::accept   (Leave)`,
      `  - dialog::dismiss  (Stay)`,
      ``,
      `To interact:`,
      `  click selector="dialog::accept"`,
      `  click selector="dialog::dismiss"`,
    ].join('\n');
  } else if (s.kind === 'device-chooser') {
    const kindLabel = { usb: 'USB', bluetooth: 'Bluetooth', serial: 'Serial', hid: 'HID' }[s.payload.deviceKind] || s.payload.deviceKind;
    const lines = [
      `# Dialog: device-chooser (${s.payload.deviceKind})`,
      `Origin requested a ${kindLabel} device.`,
      ``,
    ];
    if (s.payload.devices.length === 0) {
      lines.push(`(No devices visible.)`);
    } else {
      lines.push(`Devices:`);
      for (const d of s.payload.devices) {
        lines.push(`  - dialog::device[id="${d.id}"]   "${d.name}"`);
      }
    }
    lines.push(``, `Buttons:`, `  - dialog::dismiss   (Cancel)`);
    markdown = lines.join('\n');
  } else if (s.kind === 'permission') {
    markdown = [
      `# Dialog: permission`,
      `Origin ${s.payload.origin} requested: ${s.payload.name}`,
      `JS API: ${s.payload.jsApi}`,
      ``,
      `Buttons:`,
      `  - dialog::accept   (grant for this origin)`,
      `  - dialog::dismiss  (deny for this origin)`,
    ].join('\n');
  } else if (s.kind === 'basic-auth') {
    const header = s.payload.realm
      ? `Origin ${s.payload.origin} — realm "${s.payload.realm}"`
      : `Origin ${s.payload.origin}`;
    markdown = [
      `# Dialog: basic-auth`,
      header,
      ``,
      `Inputs:`,
      `  dialog::username`,
      `  dialog::password`,
      ``,
      `Buttons:`,
      `  - dialog::accept`,
      `  - dialog::dismiss`,
    ].join('\n');
  } else {
    markdown = `# Dialog: ${s.kind}\n(unsupported in this render path)`;
  }

  const htmlParts = [
    '<!doctype html>',
    '<html><head><title>Dialog</title></head><body>',
    `<h1>Dialog: ${s.kind}</h1>`,
  ];
  if (s.kind === 'prompt') {
    htmlParts.push('<input id="dialog-prompt" type="text">');
  }
  if (s.kind === 'basic-auth') {
    htmlParts.push('<input id="dialog-username" type="text">');
    htmlParts.push('<input id="dialog-password" type="password">');
  }
  if (s.kind === 'device-chooser') {
    for (const d of s.payload.devices) {
      htmlParts.push(`<button data-device-id="${d.id}">${d.name}</button>`);
    }
  }
  const acceptKinds = new Set(['alert', 'confirm', 'prompt', 'beforeunload', 'permission', 'basic-auth']);
  const dismissKinds = new Set(['confirm', 'prompt', 'beforeunload', 'device-chooser', 'permission', 'basic-auth']);
  if (acceptKinds.has(s.kind)) htmlParts.push('<button id="dialog-accept">Accept</button>');
  if (dismissKinds.has(s.kind)) htmlParts.push('<button id="dialog-dismiss">Dismiss</button>');
  htmlParts.push('</body></html>');
  const html = htmlParts.join('\n');

  return { markdown, html, consoleSnapshot: '' };
}

function renderResponseSummary(s, tabIndex) {
  const lines = [];
  lines.push(`Dialog open on tab ${tabIndex}: ${s.kind}`);
  if (s.payload.message) lines.push(`  Message: "${s.payload.message}"`);
  if (s.kind === 'alert') {
    lines.push(`  Handle with: click dialog::accept`);
  } else if (s.kind === 'device-chooser') {
    lines.push(`  Handle with: click dialog::device[id="..."] | click dialog::dismiss`);
  } else if (s.kind === 'basic-auth') {
    lines.push(`  Handle with: type dialog::username, type dialog::password, click dialog::accept | click dialog::dismiss`);
  } else if (s.kind === 'prompt') {
    lines.push(`  Handle with: type dialog::prompt, click dialog::accept | click dialog::dismiss`);
  } else {
    lines.push(`  Handle with: click dialog::accept | click dialog::dismiss`);
  }
  lines.push(`(no screenshot — dialog overlay is browser-native UI)`);
  return lines.join('\n');
}

module.exports = { renderSyntheticArtifacts, renderResponseSummary };