@toolstackhq/cdpwright 1.0.0

package/dist/cli.js

@@ -0,0 +1,2161 @@
+#!/usr/bin/env node
+
+// src/browser/ChromiumManager.ts
+import fs4 from "fs";
+import path4 from "path";
+import os2 from "os";
+import http from "http";
+import { spawn as spawn2 } from "child_process";
+
+// src/logging/Logger.ts
+var LEVEL_ORDER = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var REDACT_KEYS = ["password", "token", "secret", "authorization", "cookie"];
+function redactValue(value) {
+  if (typeof value === "string") {
+    try {
+      const url = new URL(value);
+      if (url.search) {
+        url.search = "?redacted";
+      }
+      return url.toString();
+    } catch {
+      return value;
+    }
+  }
+  if (value && typeof value === "object") {
+    return JSON.stringify(value, (key, val) => {
+      if (REDACT_KEYS.some((k) => key.toLowerCase().includes(k))) {
+        return "[redacted]";
+      }
+      return val;
+    });
+  }
+  return String(value);
+}
+var Logger = class {
+  level;
+  constructor(level = "info") {
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
+  }
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  trace(message, ...args) {
+    this.log("trace", message, ...args);
+  }
+  log(level, message, ...args) {
+    if (LEVEL_ORDER[level] > LEVEL_ORDER[this.level]) {
+      return;
+    }
+    const time = (/* @__PURE__ */ new Date()).toISOString();
+    const suffix = args.length ? " " + args.map(redactValue).join(" ") : "";
+    const line = `[${time}] [${level}] ${message}${suffix}`;
+    if (level === "error") {
+      console.error(line);
+    } else if (level === "warn") {
+      console.warn(line);
+    } else {
+      console.log(line);
+    }
+  }
+};
+
+// src/core/Events.ts
+import { EventEmitter } from "events";
+var AutomationEvents = class {
+  emitter = new EventEmitter();
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  emit(event, payload) {
+    this.emitter.emit(event, payload);
+  }
+};
+
+// src/cdp/Connection.ts
+import WebSocket from "ws";
+import { EventEmitter as EventEmitter3 } from "events";
+
+// src/cdp/Session.ts
+import { EventEmitter as EventEmitter2 } from "events";
+var Session = class {
+  connection;
+  sessionId;
+  emitter = new EventEmitter2();
+  constructor(connection, sessionId) {
+    this.connection = connection;
+    this.sessionId = sessionId;
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  once(event, handler) {
+    this.emitter.once(event, handler);
+  }
+  async send(method, params = {}) {
+    return this.connection.send(method, params, this.sessionId);
+  }
+  dispatch(method, params) {
+    this.emitter.emit(method, params);
+  }
+};
+
+// src/cdp/Connection.ts
+var Connection = class {
+  ws;
+  id = 0;
+  callbacks = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  emitter = new EventEmitter3();
+  logger;
+  closed = false;
+  constructor(url, logger) {
+    this.logger = logger;
+    this.ws = new WebSocket(url);
+    this.ws.on("message", (data) => this.onMessage(data.toString()));
+    this.ws.on("error", (err) => this.onError(err));
+    this.ws.on("close", (code, reason) => this.onClose(code, reason));
+  }
+  async waitForOpen() {
+    if (this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    if (this.ws.readyState === WebSocket.CLOSED) {
+      throw new Error("CDP socket is closed");
+    }
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const onClose = () => {
+        cleanup();
+        reject(new Error("CDP socket closed before opening"));
+      };
+      const cleanup = () => {
+        this.ws.off("open", onOpen);
+        this.ws.off("error", onError);
+        this.ws.off("close", onClose);
+      };
+      this.ws.on("open", onOpen);
+      this.ws.on("error", onError);
+      this.ws.on("close", onClose);
+    });
+  }
+  createSession(sessionId) {
+    const session = new Session(this, sessionId);
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+  removeSession(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  async send(method, params = {}, sessionId) {
+    await this.waitForOpen();
+    const id = ++this.id;
+    const payload = sessionId ? { id, method, params, sessionId } : { id, method, params };
+    const start = Date.now();
+    const promise = new Promise((resolve, reject) => {
+      this.callbacks.set(id, { resolve, reject, method, start });
+    });
+    if (this.logger) {
+      this.logger.trace("CDP send", method);
+    }
+    this.ws.send(JSON.stringify(payload));
+    return promise;
+  }
+  async close() {
+    if (this.ws.readyState === WebSocket.CLOSED) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this.ws.once("close", () => resolve());
+      if (this.ws.readyState === WebSocket.CLOSING) {
+        return;
+      }
+      this.ws.close();
+    });
+  }
+  onError(err) {
+    this.logger.error("CDP socket error", err);
+  }
+  onClose(code, reason) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    const reasonText = reason.toString() || "no reason";
+    this.failPending(new Error(`CDP socket closed (${code}): ${reasonText}`));
+    this.sessions.clear();
+  }
+  failPending(error) {
+    if (this.callbacks.size === 0) {
+      return;
+    }
+    for (const [, callback] of this.callbacks) {
+      callback.reject(error);
+    }
+    this.callbacks.clear();
+  }
+  onMessage(message) {
+    let parsed;
+    try {
+      parsed = JSON.parse(message);
+    } catch (err) {
+      this.logger.warn("Failed to parse CDP message", err);
+      return;
+    }
+    if (typeof parsed.id === "number") {
+      const callback = this.callbacks.get(parsed.id);
+      if (!callback) {
+        return;
+      }
+      this.callbacks.delete(parsed.id);
+      const duration = Date.now() - callback.start;
+      this.logger.debug("CDP recv", callback.method, `${duration}ms`);
+      if (parsed.error) {
+        callback.reject(new Error(parsed.error.message));
+      } else {
+        callback.resolve(parsed.result);
+      }
+      return;
+    }
+    if (parsed.sessionId) {
+      const session = this.sessions.get(parsed.sessionId);
+      if (session) {
+        session.dispatch(parsed.method, parsed.params);
+      }
+      return;
+    }
+    if (parsed.method) {
+      this.emitter.emit(parsed.method, parsed.params);
+    }
+  }
+};
+
+// src/core/Page.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/core/Frame.ts
+import fs from "fs";
+import path from "path";
+
+// src/core/Waiter.ts
+async function waitFor(predicate, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const intervalMs = options.intervalMs ?? 100;
+  const start = Date.now();
+  let lastError;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const result = await predicate();
+      if (result) {
+        return result;
+      }
+    } catch (err) {
+      lastError = err;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  const description = options.description ? ` (${options.description})` : "";
+  const error = new Error(`Timeout after ${timeoutMs}ms${description}`);
+  error.cause = lastError;
+  throw error;
+}
+
+// src/core/Selectors.ts
+function isXPathSelector(input) {
+  if (input.startsWith("/")) return true;
+  if (input.startsWith("./")) return true;
+  if (input.startsWith(".//")) return true;
+  if (input.startsWith("..")) return true;
+  if (input.startsWith("(")) {
+    const trimmed = input.trimStart();
+    if (trimmed.startsWith("(")) {
+      const inner = trimmed.slice(1).trimStart();
+      return inner.startsWith("/") || inner.startsWith(".");
+    }
+  }
+  return false;
+}
+function parseSelector(input) {
+  const value = input.trim();
+  const pierceShadowDom = value.includes(">>>");
+  return {
+    type: isXPathSelector(value) ? "xpath" : "css",
+    value,
+    pierceShadowDom
+  };
+}
+
+// src/core/ShadowDom.ts
+function getElementCtor(root) {
+  if (typeof Element !== "undefined") return Element;
+  const doc = root.ownerDocument;
+  const view = (doc || root).defaultView;
+  return view?.Element ?? null;
+}
+function isElementNode(node, ElementCtor) {
+  return node instanceof ElementCtor;
+}
+function nodeChildren(node) {
+  if (!("children" in node)) {
+    return [];
+  }
+  return Array.from(node.children);
+}
+function querySelectorDeep(root, selector) {
+  const ElementCtor = getElementCtor(root);
+  if (!ElementCtor) return null;
+  const elementCtor = ElementCtor;
+  function walk(node, sel, results2) {
+    if (isElementNode(node, elementCtor) && node.matches(sel)) {
+      results2.push(node);
+    }
+    if (isElementNode(node, elementCtor) && node.shadowRoot) {
+      walk(node.shadowRoot, sel, results2);
+    }
+    for (const child of nodeChildren(node)) {
+      walk(child, sel, results2);
+    }
+  }
+  function findAll(rootNode, sel) {
+    const results2 = [];
+    walk(rootNode, sel, results2);
+    return results2;
+  }
+  if (selector.includes(">>>")) {
+    const parts = selector.split(">>>").map((p) => p.trim()).filter(Boolean);
+    let scope = [root];
+    for (const part of parts) {
+      const matches = [];
+      for (const item of scope) {
+        matches.push(...findAll(item, part));
+      }
+      if (matches.length === 0) return null;
+      scope = matches;
+    }
+    return scope[0] ?? null;
+  }
+  const results = findAll(root, selector);
+  return results[0] ?? null;
+}
+function querySelectorAllDeep(root, selector) {
+  const ElementCtor = getElementCtor(root);
+  if (!ElementCtor) return [];
+  const elementCtor = ElementCtor;
+  function walk(node, sel, results) {
+    if (isElementNode(node, elementCtor) && node.matches(sel)) {
+      results.push(node);
+    }
+    if (isElementNode(node, elementCtor) && node.shadowRoot) {
+      walk(node.shadowRoot, sel, results);
+    }
+    for (const child of nodeChildren(node)) {
+      walk(child, sel, results);
+    }
+  }
+  function findAll(rootNode, sel) {
+    const results = [];
+    walk(rootNode, sel, results);
+    return results;
+  }
+  if (selector.includes(">>>")) {
+    const parts = selector.split(">>>").map((p) => p.trim()).filter(Boolean);
+    let scope = [root];
+    for (const part of parts) {
+      const matches = [];
+      for (const item of scope) {
+        matches.push(...findAll(item, part));
+      }
+      scope = matches;
+      if (scope.length === 0) return [];
+    }
+    return scope.filter((el) => el instanceof Element);
+  }
+  return findAll(root, selector);
+}
+function serializeShadowDomHelpers() {
+  return {
+    querySelectorDeep: querySelectorDeep.toString(),
+    querySelectorAllDeep: querySelectorAllDeep.toString()
+  };
+}
+
+// src/core/Locator.ts
+var Locator = class {
+  frame;
+  selector;
+  options;
+  constructor(frame, selector, options = {}) {
+    this.frame = frame;
+    this.selector = selector;
+    this.options = options;
+  }
+  async click(options = {}) {
+    return this.frame.click(this.selector, { ...this.options, ...options });
+  }
+  async dblclick(options = {}) {
+    return this.frame.dblclick(this.selector, { ...this.options, ...options });
+  }
+  async type(text, options = {}) {
+    return this.frame.type(this.selector, text, { ...this.options, ...options });
+  }
+  async exists() {
+    return this.frame.exists(this.selector, this.options);
+  }
+  async text() {
+    return this.frame.text(this.selector, this.options);
+  }
+};
+
+// src/core/Frame.ts
+var Frame = class {
+  id;
+  name;
+  url;
+  parentId;
+  session;
+  logger;
+  events;
+  contextId;
+  defaultTimeout = 3e4;
+  constructor(id, session, logger, events) {
+    this.id = id;
+    this.session = session;
+    this.logger = logger;
+    this.events = events;
+  }
+  setExecutionContext(contextId) {
+    this.contextId = contextId;
+  }
+  getExecutionContext() {
+    return this.contextId;
+  }
+  setMeta(meta) {
+    this.name = meta.name;
+    this.url = meta.url;
+    this.parentId = meta.parentId;
+  }
+  async evaluate(fnOrString, ...args) {
+    return this.evaluateInContext(fnOrString, args);
+  }
+  async query(selector, options = {}) {
+    return this.querySelectorInternal(selector, options, false);
+  }
+  async queryAll(selector, options = {}) {
+    return this.querySelectorAllInternal(selector, options, false);
+  }
+  async queryXPath(selector, options = {}) {
+    return this.querySelectorInternal(selector, options, true);
+  }
+  async queryAllXPath(selector, options = {}) {
+    return this.querySelectorAllInternal(selector, options, true);
+  }
+  locator(selector, options = {}) {
+    return new Locator(this, selector, options);
+  }
+  async click(selector, options = {}) {
+    await this.performClick(selector, options, false);
+  }
+  async dblclick(selector, options = {}) {
+    await this.performClick(selector, options, true);
+  }
+  async type(selector, text, options = {}) {
+    const start = Date.now();
+    const parsed = parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    this.events.emit("action:start", { name: "type", selector, frameId: this.id, sensitive: options.sensitive });
+    await waitFor(async () => {
+      const box = await this.resolveElementBox(selector, options);
+      if (!box || !box.visible) {
+        return false;
+      }
+      return true;
+    }, { timeoutMs: options.timeoutMs ?? this.defaultTimeout, description: `type ${selector}` });
+    const helpers = serializeShadowDomHelpers();
+    const focusExpression = `(function() {
+      const querySelectorDeep = ${helpers.querySelectorDeep};
+      const root = document;
+      const selector = ${JSON.stringify(selector)};
+      const el = ${pierce ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+      if (!el) {
+        return;
+      }
+      el.focus();
+    })()`;
+    const focusParams = {
+      expression: focusExpression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      focusParams.contextId = this.contextId;
+    }
+    await this.session.send("Runtime.evaluate", focusParams);
+    await this.session.send("Input.insertText", { text });
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "type", selector, frameId: this.id, durationMs: duration, sensitive: options.sensitive });
+    this.logger.debug("Type", selector, `${duration}ms`);
+  }
+  async typeSecure(selector, text, options = {}) {
+    return this.type(selector, text, { ...options, sensitive: true });
+  }
+  async fillInput(selector, value, options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "fillInput", selector, frameId: this.id });
+    await waitFor(async () => {
+      const expression = `(function() {
+        const selector = ${JSON.stringify(selector)};
+        const findDeep = (sel) => {
+          if (sel.includes(">>>")) {
+            const parts = sel.split(">>>").map((s) => s.trim()).filter(Boolean);
+            let scope = [document];
+            for (const part of parts) {
+              const next = [];
+              for (const node of scope) {
+                const roots = [node];
+                if (node instanceof Element && node.shadowRoot) roots.push(node.shadowRoot);
+                for (const root of roots) {
+                  next.push(...root.querySelectorAll(part));
+                }
+              }
+              if (!next.length) return null;
+              scope = next;
+            }
+            return scope[0] || null;
+          }
+          return document.querySelector(sel);
+        };
+        const el = findDeep(selector);
+        if (!el) return false;
+        if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)) {
+          return false;
+        }
+        el.value = ${JSON.stringify(value)};
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return true;
+      })()`;
+      const params = {
+        expression,
+        returnByValue: true
+      };
+      if (this.contextId) {
+        params.contextId = this.contextId;
+      }
+      const result = await this.session.send("Runtime.evaluate", params);
+      return Boolean(result.result?.value);
+    }, { timeoutMs: options.timeoutMs ?? this.defaultTimeout, description: `fillInput ${selector}` });
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "fillInput", selector, frameId: this.id, durationMs: duration });
+    this.logger.debug("FillInput", selector, `${duration}ms`);
+  }
+  async findLocators(options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "findLocators", frameId: this.id });
+    const artifactsDir = path.resolve(process.cwd(), "artifacts");
+    try {
+      fs.mkdirSync(artifactsDir, { recursive: true });
+    } catch {
+    }
+    const resolveOut = (name) => {
+      if (!name) return null;
+      const base = path.basename(name);
+      return path.join(artifactsDir, base);
+    };
+    const outputJson = resolveOut(options.outputJson || options.outputPath);
+    const outputHtml = resolveOut(options.outputHtml);
+    const expression = `(function() {
+      const highlight = ${options.highlight !== false};
+      const previous = Array.from(document.querySelectorAll(".__cdpwright-locator-overlay"));
+      previous.forEach((el) => el.remove());
+
+      const cssEscape = (value) => {
+        if (typeof CSS !== "undefined" && CSS.escape) return CSS.escape(value);
+        return value.replace(/[^a-zA-Z0-9_-]/g, (c) => "\\\\" + c.charCodeAt(0).toString(16) + " ");
+      };
+
+      const visible = (el) => {
+        const rect = el.getBoundingClientRect();
+        const style = window.getComputedStyle(el);
+        return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none" && Number(style.opacity || "1") > 0;
+      };
+
+      const siblingsIndex = (el) => {
+        if (!el.parentElement) return 1;
+        const sibs = Array.from(el.parentElement.children).filter((n) => n.tagName === el.tagName);
+        return sibs.indexOf(el) + 1;
+      };
+
+      const xpathFor = (el) => {
+        const parts = [];
+        let node = el;
+        while (node && node.nodeType === 1 && node !== document.documentElement) {
+          const idx = siblingsIndex(node);
+          parts.unshift(node.tagName.toLowerCase() + "[" + idx + "]");
+          node = node.parentElement;
+        }
+        return "//" + parts.join("/");
+      };
+
+      const buildLocator = (el) => {
+        const testid = el.getAttribute("data-testid");
+        const id = el.id;
+        const name = el.getAttribute("name");
+        const aria = el.getAttribute("aria-label");
+        const labelledBy = el.getAttribute("aria-labelledby");
+        const placeholder = el.getAttribute("placeholder");
+        const role = el.getAttribute("role");
+        const labelText = (() => {
+          if (labelledBy) {
+            const ref = document.getElementById(labelledBy);
+            if (ref) return ref.textContent?.trim() || "";
+          }
+          if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+            const idRef = el.id && document.querySelector("label[for='" + el.id.replace(/'/g, "\\\\'") + "']");
+            if (idRef) return idRef.textContent?.trim() || "";
+            const wrap = el.closest("label");
+            if (wrap) return wrap.textContent?.trim() || "";
+          }
+          return "";
+        })();
+
+        let css = "";
+        let quality = "low";
+        let reason = "fallback";
+        if (testid) {
+          css = "[data-testid="" + testid.replace(/"/g, '\\\\"') + ""]";
+          quality = "high";
+          reason = "data-testid";
+        } else if (id) {
+          css = "#" + cssEscape(id);
+          quality = "high";
+          reason = "id";
+        } else if (name) {
+          css = "[name="" + name.replace(/"/g, '\\\\"') + ""]";
+          quality = "ok";
+          reason = "name";
+        } else if (aria) {
+          css = "[aria-label="" + aria.replace(/"/g, '\\\\"') + ""]";
+          quality = "ok";
+          reason = "aria-label";
+        } else if (placeholder) {
+          css = "[placeholder="" + placeholder.replace(/"/g, '\\\\"') + ""]";
+          quality = "low";
+          reason = "placeholder";
+        } else if (labelText) {
+          css = el.tagName.toLowerCase() + "[aria-label="" + labelText.replace(/"/g, '\\\\"') + ""]";
+          quality = "low";
+          reason = "label text";
+        } else {
+          const nth = siblingsIndex(el);
+          css = el.tagName.toLowerCase() + ":nth-of-type(" + nth + ")";
+          quality = "low";
+          reason = "nth-of-type";
+        }
+
+        const tag = el.tagName.toLowerCase();
+        const type = el.getAttribute("type") || "";
+        const text = (el.textContent || "").trim().slice(0, 80);
+
+        return {
+          name: labelText || aria || placeholder || name || testid || id || tag,
+          css,
+          xpath: xpathFor(el),
+          quality,
+          reason,
+          visible: true,
+          tag,
+          type,
+          role,
+          text,
+          id,
+          nameAttr: name,
+          dataTestid: testid
+        };
+      };
+
+        const preferredSelectors = ["input", "select", "textarea", "button", "a[href]", "[role='button']", "[contenteditable='true']", "h1", "h2", "h3", "h4", "h5", "h6", "label", "legend", "fieldset"];
+        let nodes = Array.from(document.querySelectorAll(preferredSelectors.join(", ")));
+        if (nodes.length === 0) {
+          nodes = Array.from(document.querySelectorAll("*")).filter((el) => {
+            if (!(el instanceof HTMLElement)) return false;
+            const tag = el.tagName.toLowerCase();
+            if (preferredSelectors.includes(tag)) return true;
+            if (tag === "a" && el.hasAttribute("href")) return true;
+            if (el.getAttribute("role") === "button") return true;
+            if (el.hasAttribute("contenteditable")) return true;
+            return false;
+          });
+        }
+      const results = [];
+      nodes.forEach((el) => {
+        const isVisible = visible(el);
+        const locator = buildLocator(el);
+        locator.visible = isVisible;
+        results.push(locator);
+      });
+
+      if (highlight) {
+        results.forEach((loc, index) => {
+          const el = nodes[index];
+          if (!el) return;
+          const rect = el.getBoundingClientRect();
+          const overlay = document.createElement("div");
+          overlay.className = "__cdpwright-locator-overlay";
+          overlay.style.position = "absolute";
+          overlay.style.left = rect.x + window.scrollX + "px";
+          overlay.style.top = rect.y + window.scrollY + "px";
+          overlay.style.width = rect.width + "px";
+          overlay.style.height = rect.height + "px";
+          overlay.style.border = "2px solid #e67e22";
+          overlay.style.borderRadius = "6px";
+          overlay.style.pointerEvents = "none";
+          overlay.style.zIndex = "99999";
+          const badge = document.createElement("div");
+          badge.textContent = String(index);
+          badge.style.position = "absolute";
+          badge.style.top = "-10px";
+          badge.style.left = "-10px";
+          badge.style.background = "#e67e22";
+          badge.style.color = "#fff";
+          badge.style.fontSize = "12px";
+          badge.style.padding = "2px 6px";
+          badge.style.borderRadius = "10px";
+          overlay.appendChild(badge);
+          document.body.appendChild(overlay);
+        });
+      }
+
+      if (console && console.table) {
+        console.table(results.map((r, idx) => ({ idx, name: r.name, css: r.css, quality: r.quality, reason: r.reason, tag: r.tag, type: r.type })));
+      }
+      return results;
+    })()`;
+    const params = {
+      expression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      params.contextId = this.contextId;
+    }
+    let result = await this.session.send("Runtime.evaluate", params);
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "findLocators", frameId: this.id, durationMs: duration });
+    const value = result.result?.value ?? [];
+    if (Array.isArray(value) && value.length > 0) {
+      this.logger.info("FindLocators", `${value.length} candidates`, value.slice(0, 5).map((v) => v.css || v.name || v.tag));
+      if (outputJson) {
+        try {
+          fs.writeFileSync(outputJson, JSON.stringify(value, null, 2), "utf-8");
+          this.logger.info("FindLocators", `written to ${outputJson}`);
+        } catch (err) {
+          this.logger.warn("FindLocators write failed", err);
+        }
+      }
+      if (outputHtml) {
+        this.writeLocatorHtml(outputHtml, value);
+      }
+      return value;
+    }
+    result = await this.session.send("Runtime.evaluate", {
+      expression: `(function() {
+        const allowed = ["input","select","textarea","button","a","label","legend","fieldset","h1","h2","h3","h4","h5","h6"];
+        const skip = ["html","head","body","meta","link","script","style"];
+        return Array.from(document.querySelectorAll("*"))
+          .filter((el) => {
+            if (!(el instanceof HTMLElement)) return false;
+            const tag = el.tagName.toLowerCase();
+            if (skip.includes(tag)) return false;
+            if (tag === "a" && el.hasAttribute("href")) return true;
+            if (el.getAttribute("role") === "button") return true;
+            if (el.hasAttribute("contenteditable")) return true;
+            return allowed.includes(tag);
+          })
+          .slice(0, 200)
+          .map((el, idx) => ({
+            name: el.getAttribute("aria-label") || el.getAttribute("name") || el.getAttribute("data-testid") || el.id || el.tagName.toLowerCase() + "-" + idx,
+            css: el.id ? "#" + el.id : el.getAttribute("data-testid") ? "[data-testid=\\"" + el.getAttribute("data-testid") + "\\"]" : el.tagName.toLowerCase(),
+            xpath: "",
+            quality: "low",
+            reason: "fallback",
+            visible: true,
+            tag: el.tagName.toLowerCase(),
+            type: el.getAttribute("type") || "",
+            role: el.getAttribute("role") || ""
+          }));
+      })()`,
+      returnByValue: true
+    });
+    const fallback = result.result?.value ?? [];
+    this.logger.info("FindLocators", `${fallback.length} candidates`, fallback.slice(0, 5).map((v) => v.css || v.name || v.tag));
+    if (outputJson) {
+      try {
+        fs.writeFileSync(outputJson, JSON.stringify(fallback, null, 2), "utf-8");
+        this.logger.info("FindLocators", `written to ${outputJson}`);
+      } catch (err) {
+        this.logger.warn("FindLocators write failed", err);
+      }
+    }
+    if (outputHtml) {
+      this.writeLocatorHtml(outputHtml, fallback);
+    }
+    return fallback;
+  }
+  writeLocatorHtml(filePath, data) {
+    const html = `<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Locators</title>
+  <style>
+    body { font-family: "Segoe UI", system-ui, -apple-system, sans-serif; padding: 16px; background: #f8f9fa; color: #222; }
+    h1 { font-size: 20px; margin-bottom: 12px; }
+    table { border-collapse: collapse; width: 100%; background: #fff; box-shadow: 0 2px 6px rgba(0,0,0,0.08); }
+    th, td { border: 1px solid #e5e7eb; padding: 8px; font-size: 13px; text-align: left; }
+    th { background: linear-gradient(180deg, #f6f7fb, #edf0f7); font-weight: 600; }
+    tr:nth-child(even) { background: #fafbfc; }
+    .copy { color: #2563eb; text-decoration: underline dotted; cursor: pointer; font-size: 12px; background: none; border: none; padding: 0; opacity: 0; transition: opacity 0.15s ease; }
+    tr:hover .copy { opacity: 1; }
+    .copy:hover { color: #1d4ed8; }
+    .loc-value { margin-left: 6px; font-family: ui-monospace, SFMono-Regular, SFMono, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; }
+  </style>
+</head>
+<body>
+  <h1>Locator candidates</h1>
+  <table>
+    <thead>
+      <tr><th>#</th><th>Name</th><th>CSS</th><th>XPath</th><th>Quality</th><th>Reason</th><th>Visible</th></tr>
+    </thead>
+    <tbody id="rows"></tbody>
+  </table>
+  <script>
+    const data = ${JSON.stringify(data)};
+    const rows = document.getElementById("rows");
+    data.forEach((loc, idx) => {
+      const tr = document.createElement("tr");
+      const cells = [
+        idx,
+        loc.name || "",
+        loc.css || "",
+        loc.xpath || "",
+        loc.quality || "",
+        loc.reason || "",
+        String(loc.visible)
+      ];
+      cells.forEach((val, i) => {
+        const td = document.createElement("td");
+        if (i === 2 || i === 3) {
+          const link = document.createElement("button");
+          link.className = "copy";
+          link.textContent = "copy";
+          link.addEventListener("click", async (e) => {
+            e.preventDefault();
+            try { await navigator.clipboard.writeText(val); link.textContent = "copied"; setTimeout(() => link.textContent = "copy", 1000); }
+            catch { link.textContent = "error"; }
+          });
+          const span = document.createElement("span");
+          span.className = "loc-value";
+          span.textContent = val;
+          td.appendChild(link);
+          td.appendChild(span);
+        } else {
+          td.textContent = val;
+        }
+        tr.appendChild(td);
+      });
+      rows.appendChild(tr);
+    });
+  </script>
+</body>
+</html>`;
+    try {
+      fs.writeFileSync(filePath, html, "utf-8");
+      this.logger.info("FindLocators", `HTML written to ${filePath}`);
+    } catch (err) {
+      this.logger.warn("FindLocators HTML write failed", err);
+    }
+  }
+  async exists(selector, options = {}) {
+    const handle = await this.query(selector, options);
+    if (handle) {
+      await this.releaseObject(handle.objectId);
+      return true;
+    }
+    return false;
+  }
+  async isVisible(selector, options = {}) {
+    const box = await this.resolveElementBox(selector, options);
+    return Boolean(box && box.visible);
+  }
+  async text(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      return el.textContent || "";
+    `);
+  }
+  async textSecure(selector, options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "text", selector, frameId: this.id, sensitive: true });
+    const result = await this.text(selector, options);
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "text", selector, frameId: this.id, durationMs: duration, sensitive: true });
+    return result;
+  }
+  async selectOption(selector, value) {
+    await this.evaluate(
+      (sel, val) => {
+        const el = document.querySelector(sel);
+        if (!(el instanceof HTMLSelectElement)) return false;
+        el.value = val;
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return true;
+      },
+      selector,
+      value
+    );
+  }
+  async setFileInput(selector, name, contents, options = {}) {
+    await this.evaluate(
+      (sel, fileName, text, mime) => {
+        const input = document.querySelector(sel);
+        if (!(input instanceof HTMLInputElement)) return false;
+        const file = new File([text], fileName, { type: mime || "text/plain" });
+        const data = new DataTransfer();
+        data.items.add(file);
+        input.files = data.files;
+        input.dispatchEvent(new Event("input", { bubbles: true }));
+        input.dispatchEvent(new Event("change", { bubbles: true }));
+        return true;
+      },
+      selector,
+      name,
+      contents,
+      options.mimeType || "text/plain"
+    );
+  }
+  async attribute(selector, name, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el || !(el instanceof Element)) {
+        return null;
+      }
+      return el.getAttribute(${JSON.stringify(name)});
+    `);
+  }
+  async value(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      if ("value" in el) {
+        return el.value ?? "";
+      }
+      return el.getAttribute("value");
+    `);
+  }
+  async valueSecure(selector, options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "value", selector, frameId: this.id, sensitive: true });
+    const result = await this.value(selector, options);
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "value", selector, frameId: this.id, durationMs: duration, sensitive: true });
+    return result;
+  }
+  async isEnabled(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const disabled = Boolean(el.disabled) || el.hasAttribute("disabled");
+      const ariaDisabled = el.getAttribute && el.getAttribute("aria-disabled") === "true";
+      return !(disabled || ariaDisabled);
+    `);
+  }
+  async isChecked(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const aria = el.getAttribute && el.getAttribute("aria-checked");
+      if (aria === "true") {
+        return true;
+      }
+      if (aria === "false") {
+        return false;
+      }
+      if ("checked" in el) {
+        return Boolean(el.checked);
+      }
+      return null;
+    `);
+  }
+  async count(selector, options = {}) {
+    const parsed = parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    const expression = parsed.type === "xpath" ? `(function() {
+          const result = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+          return result.snapshotLength;
+        })()` : `(function() {
+          const querySelectorAllDeep = ${helpers.querySelectorAllDeep};
+          const root = document;
+          const selector = ${JSON.stringify(parsed.value)};
+          const nodes = ${pierce ? "querySelectorAllDeep(root, selector)" : "root.querySelectorAll(selector)"};
+          return nodes.length;
+        })()`;
+    const params = {
+      expression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      params.contextId = this.contextId;
+    }
+    const result = await this.session.send("Runtime.evaluate", params);
+    return result.result.value ?? 0;
+  }
+  async classes(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      if (!el.classList) {
+        return [];
+      }
+      return Array.from(el.classList);
+    `);
+  }
+  async css(selector, property, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const style = window.getComputedStyle(el);
+      return style.getPropertyValue(${JSON.stringify(property)}) || "";
+    `);
+  }
+  async hasFocus(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      return document.activeElement === el;
+    `);
+  }
+  async isInViewport(selector, options = {}, fully = false) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const rect = el.getBoundingClientRect();
+      const viewWidth = window.innerWidth || document.documentElement.clientWidth;
+      const viewHeight = window.innerHeight || document.documentElement.clientHeight;
+      if (${fully ? "true" : "false"}) {
+        return rect.top >= 0 && rect.left >= 0 && rect.bottom <= viewHeight && rect.right <= viewWidth;
+      }
+      return rect.bottom > 0 && rect.right > 0 && rect.top < viewHeight && rect.left < viewWidth;
+    `);
+  }
+  async isEditable(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const disabled = Boolean(el.disabled) || el.hasAttribute("disabled");
+      const readOnly = Boolean(el.readOnly) || el.hasAttribute("readonly");
+      const ariaDisabled = el.getAttribute && el.getAttribute("aria-disabled") === "true";
+      return !(disabled || readOnly || ariaDisabled);
+    `);
+  }
+  async performClick(selector, options, isDouble) {
+    const start = Date.now();
+    const actionName = isDouble ? "dblclick" : "click";
+    this.events.emit("action:start", { name: actionName, selector, frameId: this.id });
+    const box = await waitFor(async () => {
+      const result = await this.resolveElementBox(selector, options);
+      if (!result || !result.visible) {
+        return null;
+      }
+      return result;
+    }, { timeoutMs: options.timeoutMs ?? this.defaultTimeout, description: `${actionName} ${selector}` });
+    const centerX = box.x + box.width / 2;
+    const centerY = box.y + box.height / 2;
+    await this.session.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: centerX, y: centerY });
+    await this.session.send("Input.dispatchMouseEvent", { type: "mousePressed", x: centerX, y: centerY, button: "left", clickCount: 1, buttons: 1 });
+    await this.session.send("Input.dispatchMouseEvent", { type: "mouseReleased", x: centerX, y: centerY, button: "left", clickCount: 1, buttons: 0 });
+    if (isDouble) {
+      await this.session.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: centerX, y: centerY });
+      await this.session.send("Input.dispatchMouseEvent", { type: "mousePressed", x: centerX, y: centerY, button: "left", clickCount: 2, buttons: 1 });
+      await this.session.send("Input.dispatchMouseEvent", { type: "mouseReleased", x: centerX, y: centerY, button: "left", clickCount: 2, buttons: 0 });
+    }
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: actionName, selector, frameId: this.id, durationMs: duration });
+    this.logger.debug("Click", selector, `${duration}ms`);
+  }
+  async resolveElementBox(selector, options) {
+    const parsed = parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    const expression = parsed.type === "xpath" ? `(function() {
+          const result = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+          if (!result || !(result instanceof Element)) {
+            return null;
+          }
+          result.scrollIntoView({ block: 'center', inline: 'center' });
+          const rect = result.getBoundingClientRect();
+          const style = window.getComputedStyle(result);
+          return { x: rect.x, y: rect.y, width: rect.width, height: rect.height, visible: rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none' && Number(style.opacity || '1') > 0 };
+        })()` : `(function() {
+          const querySelectorDeep = ${helpers.querySelectorDeep};
+          const root = document;
+          const selector = ${JSON.stringify(parsed.value)};
+          const el = ${pierce ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+          if (!el) {
+            return null;
+          }
+          el.scrollIntoView({ block: 'center', inline: 'center' });
+          const rect = el.getBoundingClientRect();
+          const style = window.getComputedStyle(el);
+          return { x: rect.x, y: rect.y, width: rect.width, height: rect.height, visible: rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none' && Number(style.opacity || '1') > 0 };
+        })()`;
+    const boxParams = {
+      expression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      boxParams.contextId = this.contextId;
+    }
+    const result = await this.session.send("Runtime.evaluate", boxParams);
+    return result?.result?.value ?? null;
+  }
+  async querySelectorInternal(selector, options, forceXPath) {
+    const parsed = forceXPath ? { type: "xpath", value: selector.trim(), pierceShadowDom: void 0 } : parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    const expression = parsed.type === "xpath" ? `(function() {
+          const result = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+          return result || null;
+        })()` : `(function() {
+          const querySelectorDeep = ${helpers.querySelectorDeep};
+          const root = document;
+          const selector = ${JSON.stringify(parsed.value)};
+          return ${pierce ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+        })()`;
+    const queryParams = {
+      expression,
+      returnByValue: false
+    };
+    if (this.contextId) {
+      queryParams.contextId = this.contextId;
+    }
+    const response = await this.session.send("Runtime.evaluate", queryParams);
+    if (response.result?.subtype === "null" || !response.result?.objectId) {
+      return null;
+    }
+    return { objectId: response.result.objectId, contextId: this.contextId ?? 0 };
+  }
+  async querySelectorAllInternal(selector, options, forceXPath) {
+    const parsed = forceXPath ? { type: "xpath", value: selector.trim(), pierceShadowDom: void 0 } : parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    const expression = parsed.type === "xpath" ? `(function() {
+          const result = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+          const nodes = [];
+          for (let i = 0; i < result.snapshotLength; i += 1) {
+            nodes.push(result.snapshotItem(i));
+          }
+          return nodes;
+        })()` : `(function() {
+          const querySelectorAllDeep = ${helpers.querySelectorAllDeep};
+          const root = document;
+          const selector = ${JSON.stringify(parsed.value)};
+          return ${pierce ? "querySelectorAllDeep(root, selector)" : "Array.from(root.querySelectorAll(selector))"};
+        })()`;
+    const listParams = {
+      expression,
+      returnByValue: false
+    };
+    if (this.contextId) {
+      listParams.contextId = this.contextId;
+    }
+    const response = await this.session.send("Runtime.evaluate", listParams);
+    if (!response.result?.objectId) {
+      return [];
+    }
+    const properties = await this.session.send("Runtime.getProperties", {
+      objectId: response.result.objectId,
+      ownProperties: true
+    });
+    const handles = [];
+    for (const prop of properties.result) {
+      if (prop.name && !/^\d+$/.test(prop.name)) {
+        continue;
+      }
+      const objectId = prop.value?.objectId;
+      if (objectId) {
+        handles.push({ objectId, contextId: this.contextId ?? 0 });
+      }
+    }
+    await this.releaseObject(response.result.objectId);
+    return handles;
+  }
+  async evaluateInContext(fnOrString, args) {
+    if (typeof fnOrString === "string") {
+      const params2 = {
+        expression: fnOrString,
+        returnByValue: true,
+        awaitPromise: true
+      };
+      if (this.contextId) {
+        params2.contextId = this.contextId;
+      }
+      const result2 = await this.session.send("Runtime.evaluate", params2);
+      return result2.result.value;
+    }
+    const serializedArgs = args.map((arg) => serializeArgument(arg)).join(", ");
+    const expression = `(${fnOrString.toString()})(${serializedArgs})`;
+    const params = {
+      expression,
+      returnByValue: true,
+      awaitPromise: true
+    };
+    if (this.contextId) {
+      params.contextId = this.contextId;
+    }
+    const result = await this.session.send("Runtime.evaluate", params);
+    return result.result.value;
+  }
+  async releaseObject(objectId) {
+    try {
+      await this.session.send("Runtime.releaseObject", { objectId });
+    } catch {
+    }
+  }
+  buildElementExpression(selector, options, forceXPath, body) {
+    const parsed = forceXPath ? { type: "xpath", value: selector.trim(), pierceShadowDom: void 0 } : parseSelector(selector);
+    const pierce = options.pierceShadowDom ?? Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    if (parsed.type === "xpath") {
+      return `(function() {
+        const el = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+        ${body}
+      })()`;
+    }
+    return `(function() {
+      const querySelectorDeep = ${helpers.querySelectorDeep};
+      const root = document;
+      const selector = ${JSON.stringify(parsed.value)};
+      const el = ${pierce ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+      ${body}
+    })()`;
+  }
+  async evalOnSelector(selector, options, forceXPath, body) {
+    const expression = this.buildElementExpression(selector, options, forceXPath, body);
+    const params = {
+      expression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      params.contextId = this.contextId;
+    }
+    const result = await this.session.send("Runtime.evaluate", params);
+    return result.result.value;
+  }
+};
+function serializeArgument(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  return JSON.stringify(value);
+}
+
+// src/core/UrlGuard.ts
+function ensureAllowedUrl(url, options = {}) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+    return;
+  }
+  if (parsed.protocol === "file:" && options.allowFileUrl) {
+    return;
+  }
+  throw new Error(`URL protocol not allowed: ${parsed.protocol}`);
+}
+
+// src/core/Page.ts
+var Page = class {
+  session;
+  logger;
+  events;
+  framesById = /* @__PURE__ */ new Map();
+  mainFrameId;
+  lifecycleEvents = /* @__PURE__ */ new Map();
+  defaultTimeout = 3e4;
+  constructor(session, logger, events) {
+    this.session = session;
+    this.logger = logger;
+    this.events = events;
+  }
+  async initialize() {
+    await this.session.send("Page.enable");
+    await this.session.send("DOM.enable");
+    await this.session.send("Runtime.enable");
+    await this.session.send("Network.enable");
+    await this.session.send("Page.setLifecycleEventsEnabled", { enabled: true });
+    this.session.on("Page.frameAttached", (params) => this.onFrameAttached(params));
+    this.session.on("Page.frameNavigated", (params) => this.onFrameNavigated(params));
+    this.session.on("Page.frameDetached", (params) => this.onFrameDetached(params));
+    this.session.on("Runtime.executionContextCreated", (params) => this.onExecutionContextCreated(params));
+    this.session.on("Runtime.executionContextDestroyed", (params) => this.onExecutionContextDestroyed(params));
+    this.session.on("Runtime.executionContextsCleared", () => this.onExecutionContextsCleared());
+    this.session.on("Page.lifecycleEvent", (params) => this.onLifecycleEvent(params));
+    const tree = await this.session.send("Page.getFrameTree");
+    this.buildFrameTree(tree.frameTree);
+  }
+  frames() {
+    return Array.from(this.framesById.values());
+  }
+  mainFrame() {
+    if (!this.mainFrameId) {
+      throw new Error("Main frame not initialized");
+    }
+    const frame = this.framesById.get(this.mainFrameId);
+    if (!frame) {
+      throw new Error("Main frame missing");
+    }
+    return frame;
+  }
+  frame(options) {
+    for (const frame of this.framesById.values()) {
+      if (options.name && frame.name !== options.name) continue;
+      if (options.urlIncludes && !frame.url?.includes(options.urlIncludes)) continue;
+      if (options.predicate && !options.predicate(frame)) continue;
+      return frame;
+    }
+    return null;
+  }
+  locator(selector) {
+    return new Locator(this.mainFrame(), selector);
+  }
+  async goto(url, options = {}) {
+    ensureAllowedUrl(url, { allowFileUrl: options.allowFileUrl });
+    const waitUntil = options.waitUntil ?? "load";
+    const lifecycleName = waitUntil === "domcontentloaded" ? "DOMContentLoaded" : waitUntil === "load" ? "load" : null;
+    if (!lifecycleName) {
+      throw new Error(`Invalid waitUntil "${waitUntil}". Use "load" or "domcontentloaded".`);
+    }
+    const timeoutMs = options.timeoutMs ?? this.defaultTimeout;
+    this.events.emit("action:start", { name: "goto", selector: url, frameId: this.mainFrameId });
+    const start = Date.now();
+    this.lifecycleEvents.clear();
+    const navigation = await this.session.send("Page.navigate", { url });
+    if (navigation?.errorText) {
+      throw new Error(`Navigation failed: ${navigation.errorText}`);
+    }
+    await this.waitForLifecycle(this.mainFrameId, lifecycleName, timeoutMs);
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "goto", selector: url, frameId: this.mainFrameId, durationMs: duration });
+    this.logger.debug("Goto", url, `${duration}ms`);
+  }
+  async query(selector) {
+    return this.mainFrame().query(selector);
+  }
+  async queryAll(selector) {
+    return this.mainFrame().queryAll(selector);
+  }
+  async queryXPath(selector) {
+    return this.mainFrame().queryXPath(selector);
+  }
+  async queryAllXPath(selector) {
+    return this.mainFrame().queryAllXPath(selector);
+  }
+  async click(selector, options) {
+    return this.mainFrame().click(selector, options);
+  }
+  async dblclick(selector, options) {
+    return this.mainFrame().dblclick(selector, options);
+  }
+  async type(selector, text, options) {
+    return this.mainFrame().type(selector, text, options);
+  }
+  async typeSecure(selector, text, options) {
+    return this.mainFrame().typeSecure(selector, text, options);
+  }
+  async fillInput(selector, value, options = {}) {
+    return this.mainFrame().fillInput(selector, value, options);
+  }
+  async evaluate(fnOrString, ...args) {
+    return this.mainFrame().evaluate(fnOrString, ...args);
+  }
+  async textSecure(selector) {
+    return this.mainFrame().textSecure(selector);
+  }
+  async valueSecure(selector) {
+    return this.mainFrame().valueSecure(selector);
+  }
+  async selectOption(selector, value) {
+    return this.mainFrame().selectOption(selector, value);
+  }
+  async setFileInput(selector, name, contents, options = {}) {
+    return this.mainFrame().setFileInput(selector, name, contents, options);
+  }
+  async findLocators(options = {}) {
+    return this.mainFrame().findLocators(options);
+  }
+  async screenshot(options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "screenshot", frameId: this.mainFrameId });
+    const result = await this.session.send("Page.captureScreenshot", {
+      format: options.format ?? "png",
+      quality: options.quality,
+      fromSurface: true
+    });
+    const buffer = Buffer.from(result.data, "base64");
+    if (options.path) {
+      const resolved = path2.resolve(options.path);
+      fs2.writeFileSync(resolved, buffer);
+    }
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "screenshot", frameId: this.mainFrameId, durationMs: duration });
+    return buffer;
+  }
+  async screenshotBase64(options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "screenshotBase64", frameId: this.mainFrameId });
+    const result = await this.session.send("Page.captureScreenshot", {
+      format: options.format ?? "png",
+      quality: options.quality,
+      fromSurface: true
+    });
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "screenshotBase64", frameId: this.mainFrameId, durationMs: duration });
+    return result.data;
+  }
+  getEvents() {
+    return this.events;
+  }
+  getDefaultTimeout() {
+    return this.defaultTimeout;
+  }
+  buildFrameTree(tree) {
+    const frame = this.ensureFrame(tree.frame.id);
+    frame.setMeta({ name: tree.frame.name, url: tree.frame.url, parentId: tree.frame.parentId });
+    if (!tree.frame.parentId) {
+      this.mainFrameId = tree.frame.id;
+    }
+    if (tree.childFrames) {
+      for (const child of tree.childFrames) {
+        this.buildFrameTree(child);
+      }
+    }
+  }
+  ensureFrame(id) {
+    let frame = this.framesById.get(id);
+    if (!frame) {
+      frame = new Frame(id, this.session, this.logger, this.events);
+      this.framesById.set(id, frame);
+    }
+    return frame;
+  }
+  onFrameAttached(params) {
+    const frame = this.ensureFrame(params.frameId);
+    frame.setMeta({ parentId: params.parentFrameId });
+  }
+  onFrameNavigated(params) {
+    const frame = this.ensureFrame(params.frame.id);
+    frame.setMeta({ name: params.frame.name, url: params.frame.url, parentId: params.frame.parentId });
+    if (!params.frame.parentId) {
+      this.mainFrameId = params.frame.id;
+    }
+  }
+  onFrameDetached(params) {
+    this.framesById.delete(params.frameId);
+  }
+  onExecutionContextCreated(params) {
+    const frameId = params.context.auxData?.frameId;
+    if (!frameId) {
+      return;
+    }
+    const frame = this.ensureFrame(frameId);
+    frame.setExecutionContext(params.context.id);
+  }
+  onExecutionContextDestroyed(params) {
+    for (const frame of this.framesById.values()) {
+      if (frame.getExecutionContext() === params.executionContextId) {
+        frame.setExecutionContext(void 0);
+      }
+    }
+  }
+  onExecutionContextsCleared() {
+    for (const frame of this.framesById.values()) {
+      frame.setExecutionContext(void 0);
+    }
+  }
+  onLifecycleEvent(params) {
+    if (!this.lifecycleEvents.has(params.frameId)) {
+      this.lifecycleEvents.set(params.frameId, /* @__PURE__ */ new Set());
+    }
+    this.lifecycleEvents.get(params.frameId).add(params.name);
+  }
+  async waitForLifecycle(frameId, eventName, timeoutMs) {
+    if (!frameId) {
+      throw new Error("Missing frame id for lifecycle wait");
+    }
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const events = this.lifecycleEvents.get(frameId);
+      if (events && events.has(eventName)) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(`Timeout waiting for lifecycle event: ${eventName}`);
+  }
+};
+
+// src/core/Browser.ts
+var BrowserContext = class {
+  browser;
+  id;
+  constructor(browser, id) {
+    this.browser = browser;
+    this.id = id;
+  }
+  getId() {
+    return this.id;
+  }
+  async newPage() {
+    return this.browser.newPage({ browserContextId: this.id });
+  }
+  async close() {
+    await this.browser.disposeContext(this.id);
+  }
+};
+var Browser = class {
+  connection;
+  process;
+  logger;
+  events;
+  cleanupTasks;
+  contexts = /* @__PURE__ */ new Set();
+  constructor(connection, child, logger, events, cleanupTasks = []) {
+    this.connection = connection;
+    this.process = child;
+    this.logger = logger;
+    this.events = events;
+    this.cleanupTasks = cleanupTasks;
+  }
+  on(event, handler) {
+    this.events.on(event, handler);
+  }
+  async newContext() {
+    const { browserContextId } = await this.connection.send("Target.createBrowserContext");
+    this.contexts.add(browserContextId);
+    return new BrowserContext(this, browserContextId);
+  }
+  async newPage(options = {}) {
+    const { browserContextId } = options;
+    const { targetId } = await this.connection.send("Target.createTarget", {
+      url: "about:blank",
+      browserContextId
+    });
+    const { sessionId } = await this.connection.send("Target.attachToTarget", { targetId, flatten: true });
+    const session = this.connection.createSession(sessionId);
+    const page = new Page(session, this.logger, this.events);
+    await page.initialize();
+    return page;
+  }
+  async disposeContext(contextId) {
+    if (!contextId) return;
+    try {
+      await this.connection.send("Target.disposeBrowserContext", { browserContextId: contextId });
+    } catch {
+    }
+    this.contexts.delete(contextId);
+  }
+  async close() {
+    if (this.contexts.size > 0) {
+      for (const contextId of Array.from(this.contexts)) {
+        await this.disposeContext(contextId);
+      }
+    }
+    try {
+      await this.connection.send("Browser.close");
+    } catch {
+    }
+    await this.connection.close();
+    if (!this.process.killed) {
+      this.process.kill();
+    }
+    for (const task of this.cleanupTasks) {
+      try {
+        task();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/browser/Downloader.ts
+import fs3 from "fs";
+import path3 from "path";
+import os from "os";
+import https from "https";
+import { spawn } from "child_process";
+import yauzl from "yauzl";
+var SNAPSHOT_BASE = "https://commondatastorage.googleapis.com/chromium-browser-snapshots";
+function detectPlatform(platform = process.platform) {
+  if (platform === "linux") return "linux";
+  if (platform === "darwin") return "mac";
+  if (platform === "win32") return "win";
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+function platformFolder(platform) {
+  if (platform === "linux") return "Linux_x64";
+  if (platform === "mac") return "Mac";
+  return "Win";
+}
+function defaultCacheRoot(platform) {
+  if (platform === "win") {
+    const localAppData = process.env.LOCALAPPDATA || path3.join(os.homedir(), "AppData", "Local");
+    return path3.join(localAppData, "cdpwright");
+  }
+  return path3.join(os.homedir(), ".cache", "cdpwright");
+}
+function ensureWithinRoot(root, target) {
+  const resolvedRoot = path3.resolve(root);
+  const resolvedTarget = path3.resolve(target);
+  if (resolvedTarget === resolvedRoot) {
+    return;
+  }
+  if (!resolvedTarget.startsWith(resolvedRoot + path3.sep)) {
+    throw new Error(`Path escapes cache root: ${resolvedTarget}`);
+  }
+}
+function chromiumExecutableRelativePath(platform) {
+  if (platform === "linux") return path3.join("chrome-linux", "chrome");
+  if (platform === "mac") return path3.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium");
+  return path3.join("chrome-win", "chrome.exe");
+}
+async function fetchLatestRevision(platform) {
+  const folder = platformFolder(platform);
+  const url = `${SNAPSHOT_BASE}/${folder}/LAST_CHANGE`;
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode && res.statusCode >= 400) {
+        reject(new Error(`Failed to fetch LAST_CHANGE: ${res.statusCode}`));
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => data += chunk.toString());
+      res.on("end", () => resolve(data.trim()));
+    }).on("error", reject);
+  });
+}
+async function ensureDownloaded(options) {
+  const { cacheRoot, platform, revision, logger } = options;
+  ensureWithinRoot(cacheRoot, cacheRoot);
+  const platformDir = path3.join(cacheRoot, platform);
+  const revisionDir = path3.join(platformDir, revision);
+  ensureWithinRoot(cacheRoot, revisionDir);
+  const executablePath = path3.join(revisionDir, chromiumExecutableRelativePath(platform));
+  const markerFile = path3.join(revisionDir, "INSTALLATION_COMPLETE");
+  if (fs3.existsSync(executablePath) && fs3.existsSync(markerFile)) {
+    return { executablePath, revisionDir };
+  }
+  fs3.mkdirSync(revisionDir, { recursive: true });
+  const folder = platformFolder(platform);
+  const zipName = platform === "win" ? "chrome-win.zip" : platform === "mac" ? "chrome-mac.zip" : "chrome-linux.zip";
+  const downloadUrl = `${SNAPSHOT_BASE}/${folder}/${revision}/${zipName}`;
+  const tempZipPath = path3.join(os.tmpdir(), `cdpwright-${platform}-${revision}.zip`);
+  logger.info("Downloading Chromium snapshot", downloadUrl);
+  await downloadFile(downloadUrl, tempZipPath, logger);
+  logger.info("Extracting Chromium snapshot", tempZipPath);
+  await extractZipSafe(tempZipPath, revisionDir);
+  fs3.writeFileSync(markerFile, (/* @__PURE__ */ new Date()).toISOString());
+  fs3.unlinkSync(tempZipPath);
+  if (!fs3.existsSync(executablePath)) {
+    throw new Error(`Executable not found after extraction: ${executablePath}`);
+  }
+  ensureExecutable(executablePath, platform);
+  return { executablePath, revisionDir };
+}
+function downloadFile(url, dest, logger) {
+  return new Promise((resolve, reject) => {
+    const file = fs3.createWriteStream(dest);
+    https.get(url, (res) => {
+      if (res.statusCode && res.statusCode >= 400) {
+        reject(new Error(`Failed to download: ${res.statusCode}`));
+        return;
+      }
+      const total = Number(res.headers["content-length"] || 0);
+      let downloaded = 0;
+      let lastLoggedPercent = -1;
+      let lastLoggedTime = Date.now();
+      res.pipe(file);
+      res.on("data", (chunk) => {
+        downloaded += chunk.length;
+        if (!total) {
+          const now = Date.now();
+          if (now - lastLoggedTime > 2e3) {
+            logger.info("Download progress", `${(downloaded / (1024 * 1024)).toFixed(1)} MB`);
+            lastLoggedTime = now;
+          }
+          return;
+        }
+        const percent = Math.floor(downloaded / total * 100);
+        if (percent >= lastLoggedPercent + 5) {
+          logger.info("Download progress", `${percent}%`);
+          lastLoggedPercent = percent;
+        }
+      });
+      file.on("finish", () => file.close(() => resolve()));
+    }).on("error", (err) => {
+      fs3.unlink(dest, () => reject(err));
+    });
+  });
+}
+async function extractZipSafe(zipPath, destDir) {
+  return new Promise((resolve, reject) => {
+    yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+      if (err || !zipfile) {
+        reject(err || new Error("Unable to open zip"));
+        return;
+      }
+      zipfile.readEntry();
+      zipfile.on("entry", (entry) => {
+        const entryPath = entry.fileName.replace(/\\/g, "/");
+        const targetPath = path3.join(destDir, entryPath);
+        try {
+          ensureWithinRoot(destDir, targetPath);
+        } catch (error) {
+          zipfile.close();
+          reject(error);
+          return;
+        }
+        if (/\/$/.test(entry.fileName)) {
+          fs3.mkdirSync(targetPath, { recursive: true });
+          zipfile.readEntry();
+          return;
+        }
+        fs3.mkdirSync(path3.dirname(targetPath), { recursive: true });
+        zipfile.openReadStream(entry, (streamErr, readStream) => {
+          if (streamErr || !readStream) {
+            zipfile.close();
+            reject(streamErr || new Error("Unable to read zip entry"));
+            return;
+          }
+          const rawMode = entry.externalFileAttributes ? entry.externalFileAttributes >>> 16 & 65535 : 0;
+          const mode = rawMode > 0 ? rawMode : void 0;
+          const writeStream = fs3.createWriteStream(targetPath);
+          readStream.pipe(writeStream);
+          writeStream.on("error", (writeErr) => {
+            zipfile.close();
+            reject(writeErr);
+          });
+          writeStream.on("close", () => {
+            if (mode && mode <= 511) {
+              try {
+                fs3.chmodSync(targetPath, mode);
+              } catch {
+              }
+            }
+            zipfile.readEntry();
+          });
+        });
+      });
+      zipfile.on("end", () => {
+        zipfile.close();
+        resolve();
+      });
+      zipfile.on("error", (zipErr) => {
+        zipfile.close();
+        reject(zipErr);
+      });
+    });
+  });
+}
+async function chromiumVersion(executablePath) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(executablePath, ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
+    let output = "";
+    child.stdout.on("data", (chunk) => output += chunk.toString());
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(output.trim());
+      } else {
+        reject(new Error(`Failed to get Chromium version: ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function ensureExecutable(executablePath, platform) {
+  if (platform === "win") {
+    return;
+  }
+  try {
+    const stat = fs3.statSync(executablePath);
+    const isExecutable = (stat.mode & 73) !== 0;
+    if (!isExecutable) {
+      fs3.chmodSync(executablePath, 493);
+    }
+  } catch {
+  }
+}
+
+// src/browser/Revision.ts
+var PINNED_REVISION = "1567454";
+function resolveRevision(envRevision) {
+  if (envRevision && envRevision.trim()) {
+    return envRevision.trim();
+  }
+  return PINNED_REVISION;
+}
+
+// src/browser/ChromiumManager.ts
+var ChromiumManager = class {
+  logger;
+  constructor(logger) {
+    const envLevel = process.env.CDPWRIGHT_LOG_LEVEL ?? "info";
+    this.logger = logger ?? new Logger(envLevel);
+  }
+  getLogger() {
+    return this.logger;
+  }
+  async download(options = {}) {
+    const platform = detectPlatform();
+    const cacheRoot = this.resolveCacheRoot(platform);
+    const overrideExecutable = process.env.CDPWRIGHT_EXECUTABLE_PATH;
+    let revision = options.latest ? await fetchLatestRevision(platform) : resolveRevision(process.env.CDPWRIGHT_REVISION);
+    let executablePath;
+    let revisionDir = "";
+    if (overrideExecutable) {
+      executablePath = path4.resolve(overrideExecutable);
+    } else {
+      const downloaded = await ensureDownloaded({
+        cacheRoot,
+        platform,
+        revision,
+        logger: this.logger
+      });
+      executablePath = downloaded.executablePath;
+      revisionDir = downloaded.revisionDir;
+    }
+    if (!fs4.existsSync(executablePath)) {
+      throw new Error(`Chromium executable not found: ${executablePath}`);
+    }
+    const version = await chromiumVersion(executablePath);
+    this.logger.info("Chromium cache root", cacheRoot);
+    this.logger.info("Platform", platform);
+    this.logger.info("Revision", revision);
+    this.logger.info("Chromium version", version);
+    return {
+      cacheRoot,
+      platform,
+      revision,
+      executablePath,
+      revisionDir,
+      chromiumVersion: version
+    };
+  }
+  async launch(options = {}) {
+    const logger = this.logger;
+    if (options.logLevel) {
+      logger.setLevel(options.logLevel);
+    }
+    const executablePath = options.executablePath || process.env.CDPWRIGHT_EXECUTABLE_PATH;
+    let resolvedExecutable = executablePath;
+    if (!resolvedExecutable) {
+      const platform = detectPlatform();
+      const cacheRoot = this.resolveCacheRoot(platform);
+      const revision = resolveRevision(process.env.CDPWRIGHT_REVISION);
+      const downloaded = await ensureDownloaded({
+        cacheRoot,
+        platform,
+        revision,
+        logger
+      });
+      resolvedExecutable = downloaded.executablePath;
+    }
+    if (!resolvedExecutable || !fs4.existsSync(resolvedExecutable)) {
+      throw new Error(`Chromium executable not found: ${resolvedExecutable}`);
+    }
+    const stats = fs4.statSync(resolvedExecutable);
+    if (!stats.isFile()) {
+      throw new Error(`Chromium executable is not a file: ${resolvedExecutable}`);
+    }
+    ensureExecutable2(resolvedExecutable);
+    const cleanupTasks = [];
+    let userDataDir = options.userDataDir ?? process.env.CDPWRIGHT_USER_DATA_DIR;
+    if (!userDataDir) {
+      userDataDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "cdpwright-"));
+      cleanupTasks.push(() => fs4.rmSync(userDataDir, { recursive: true, force: true }));
+    }
+    const args = [
+      "--remote-debugging-port=0",
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-background-networking",
+      "--disable-background-timer-throttling",
+      "--disable-backgrounding-occluded-windows",
+      "--disable-renderer-backgrounding"
+    ];
+    if (userDataDir) {
+      args.push(`--user-data-dir=${userDataDir}`);
+    }
+    if (process.platform === "linux") {
+      args.push("--disable-crash-reporter", "--disable-crashpad");
+    }
+    if (options.headless ?? true) {
+      args.push("--headless=new");
+    }
+    if (options.maximize) {
+      args.push("--start-maximized");
+    }
+    if (options.args) {
+      args.push(...options.args);
+    }
+    logger.info("Launching Chromium", resolvedExecutable);
+    const child = spawn2(resolvedExecutable, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const websocketUrl = await waitForWebSocketEndpoint(child, logger, options.timeoutMs ?? 3e4);
+    const httpUrl = toHttpVersionUrl(websocketUrl);
+    const wsEndpoint = await fetchWebSocketDebuggerUrl(httpUrl);
+    const connection = new Connection(wsEndpoint, logger);
+    await closeInitialPages(connection, logger);
+    const events = new AutomationEvents();
+    const logEvents = resolveLogFlag(options.logEvents, process.env.CDPWRIGHT_LOG, true);
+    const logActions = resolveLogFlag(options.logActions, process.env.CDPWRIGHT_LOG_ACTIONS, true);
+    const logAssertions = resolveLogFlag(options.logAssertions, process.env.CDPWRIGHT_LOG_ASSERTIONS, true);
+    if (logEvents && logActions) {
+      events.on("action:end", (payload) => {
+        const selector = payload.sensitive ? void 0 : payload.selector;
+        const args2 = buildLogArgs(selector, payload.durationMs);
+        logger.info(`Action ${payload.name}`, ...args2);
+      });
+    }
+    if (logEvents && logAssertions) {
+      events.on("assertion:end", (payload) => {
+        const args2 = buildLogArgs(payload.selector, payload.durationMs);
+        logger.info(`Assertion ${payload.name}`, ...args2);
+      });
+    }
+    const browser = new Browser(connection, child, logger, events, cleanupTasks);
+    return browser;
+  }
+  resolveCacheRoot(platform) {
+    const envRoot = process.env.CDPWRIGHT_CACHE_DIR;
+    if (envRoot && envRoot.trim()) {
+      return path4.resolve(envRoot.trim());
+    }
+    return defaultCacheRoot(platform);
+  }
+};
+async function closeInitialPages(connection, logger) {
+  try {
+    const targets = await connection.send("Target.getTargets");
+    for (const info of targets.targetInfos) {
+      if (info.type === "page") {
+        await connection.send("Target.closeTarget", { targetId: info.targetId });
+      }
+    }
+  } catch (err) {
+    logger.warn("Failed to close initial pages", err);
+  }
+}
+function resolveLogFlag(explicit, envValue, defaultValue) {
+  if (explicit !== void 0) {
+    return explicit;
+  }
+  if (envValue == null) {
+    return defaultValue;
+  }
+  const normalized = envValue.trim().toLowerCase();
+  return !["0", "false", "no", "off"].includes(normalized);
+}
+function buildLogArgs(selector, durationMs) {
+  const args = [];
+  if (selector) {
+    args.push(selector);
+  }
+  if (typeof durationMs === "number") {
+    args.push(`${durationMs}ms`);
+  }
+  return args;
+}
+function ensureExecutable2(executablePath) {
+  if (process.platform === "win32") {
+    return;
+  }
+  try {
+    const stat = fs4.statSync(executablePath);
+    const isExecutable = (stat.mode & 73) !== 0;
+    if (!isExecutable) {
+      fs4.chmodSync(executablePath, 493);
+    }
+  } catch {
+  }
+  const dir = path4.dirname(executablePath);
+  const helpers = [
+    "chrome_crashpad_handler",
+    "chrome_sandbox",
+    "chrome-wrapper",
+    "xdg-mime",
+    "xdg-settings"
+  ];
+  for (const name of helpers) {
+    const helperPath = path4.join(dir, name);
+    if (!fs4.existsSync(helperPath)) {
+      continue;
+    }
+    try {
+      const stat = fs4.statSync(helperPath);
+      const isExecutable = (stat.mode & 73) !== 0;
+      if (!isExecutable) {
+        fs4.chmodSync(helperPath, 493);
+      }
+    } catch {
+    }
+  }
+}
+function waitForWebSocketEndpoint(child, logger, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const timeout = setTimeout(() => {
+      reject(new Error("Timed out waiting for DevTools endpoint"));
+    }, timeoutMs);
+    const outputLines = [];
+    const pushOutput = (data) => {
+      const text = data.toString();
+      for (const line of text.split(/\r?\n/)) {
+        if (!line.trim()) continue;
+        outputLines.push(line);
+        if (outputLines.length > 50) {
+          outputLines.shift();
+        }
+      }
+    };
+    const onData = (data) => {
+      const text = data.toString();
+      const match = text.match(/DevTools listening on (ws:\/\/[^\s]+)/);
+      if (match) {
+        clearTimeout(timeout);
+        cleanup();
+        logger.info("DevTools endpoint", match[1]);
+        resolve(match[1]);
+      }
+      pushOutput(data);
+    };
+    const onExit = (code, signal) => {
+      cleanup();
+      const tail = outputLines.length ? `
+Chromium output:
+${outputLines.join("\n")}` : "";
+      reject(new Error(`Chromium exited early with code ${code ?? "null"} signal ${signal ?? "null"}${tail}`));
+    };
+    const cleanup = () => {
+      child.stdout?.off("data", onData);
+      child.stderr?.off("data", onData);
+      child.off("exit", onExit);
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.on("exit", onExit);
+    if (Date.now() - start > timeoutMs) {
+      cleanup();
+    }
+  });
+}
+function toHttpVersionUrl(wsUrl) {
+  try {
+    const url = new URL(wsUrl);
+    const port = url.port || "9222";
+    return `http://127.0.0.1:${port}/json/version`;
+  } catch {
+    throw new Error(`Invalid DevTools endpoint: ${wsUrl}`);
+  }
+}
+function fetchWebSocketDebuggerUrl(versionUrl) {
+  return new Promise((resolve, reject) => {
+    http.get(versionUrl, (res) => {
+      if (res.statusCode && res.statusCode >= 400) {
+        reject(new Error(`Failed to fetch /json/version: ${res.statusCode}`));
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => data += chunk.toString());
+      res.on("end", () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (!parsed.webSocketDebuggerUrl) {
+            reject(new Error("webSocketDebuggerUrl missing"));
+            return;
+          }
+          resolve(parsed.webSocketDebuggerUrl);
+        } catch (err) {
+          reject(err);
+        }
+      });
+    }).on("error", reject);
+  });
+}
+
+// src/cli.ts
+function printHelp() {
+  console.log("cdpwright (cpw) download [--latest]");
+}
+async function main() {
+  const [, , command, ...rest] = process.argv;
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+  if (command !== "download") {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+  }
+  const latest = rest.includes("--latest");
+  const manager = new ChromiumManager();
+  await manager.download({ latest });
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map