@quitecode/chromium-automaton 0.1.0-beta.1

package/dist/cli.js

@@ -0,0 +1,1492 @@
+#!/usr/bin/env node
+
+// src/browser/ChromiumManager.ts
+import fs3 from "fs";
+import path3 from "path";
+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;
+  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));
+  }
+  async waitForOpen() {
+    if (this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      this.ws.once("open", () => resolve());
+      this.ws.once("error", (err) => reject(err));
+    });
+  }
+  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());
+      this.ws.close();
+    });
+  }
+  onError(err) {
+    this.logger.error("CDP socket error", err);
+  }
+  onMessage(message) {
+    const parsed = JSON.parse(message);
+    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 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();
+  return {
+    type: isXPathSelector(value) ? "xpath" : "css",
+    value
+  };
+}
+
+// src/core/ShadowDom.ts
+function querySelectorDeep(root, selector) {
+  const elements = Array.from(root.querySelectorAll("*"));
+  for (const el of elements) {
+    if (el.matches(selector)) {
+      return el;
+    }
+    const shadow = el.shadowRoot;
+    if (shadow) {
+      const found = querySelectorDeep(shadow, selector);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+function querySelectorAllDeep(root, selector) {
+  const results = [];
+  const elements = Array.from(root.querySelectorAll("*"));
+  for (const el of elements) {
+    if (el.matches(selector)) {
+      results.push(el);
+    }
+    const shadow = el.shadowRoot;
+    if (shadow) {
+      results.push(...querySelectorAllDeep(shadow, selector));
+    }
+  }
+  return results;
+}
+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();
+    this.events.emit("action:start", { name: "type", selector, frameId: this.id });
+    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 = ${options.pierceShadowDom ? "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 });
+    this.logger.debug("Type", selector, `${duration}ms`);
+  }
+  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 = {}) {
+    const helpers = serializeShadowDomHelpers();
+    const expression = `(function() {
+      const querySelectorDeep = ${helpers.querySelectorDeep};
+      const root = document;
+      const selector = ${JSON.stringify(selector)};
+      const el = ${options.pierceShadowDom ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+      return el ? el.textContent || "" : null;
+    })()`;
+    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 ?? null;
+  }
+  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 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(options.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(options.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() } : parseSelector(selector);
+    const pierce = Boolean(options.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() } : parseSelector(selector);
+    const pierce = Boolean(options.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() } : parseSelector(selector);
+    const pierce = Boolean(options.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, options) {
+    return new Locator(this.mainFrame(), selector, options);
+  }
+  async goto(url, options = {}) {
+    ensureAllowedUrl(url, { allowFileUrl: options.allowFileUrl });
+    const waitUntil = options.waitUntil ?? "load";
+    const lifecycleName = waitUntil === "domcontentloaded" ? "DOMContentLoaded" : "load";
+    const timeoutMs = options.timeoutMs ?? this.defaultTimeout;
+    this.events.emit("action:start", { name: "goto", selector: url, frameId: this.mainFrameId });
+    const start = Date.now();
+    await this.session.send("Page.navigate", { url });
+    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.info("Goto", url, `${duration}ms`);
+  }
+  async query(selector, options) {
+    return this.mainFrame().query(selector, options);
+  }
+  async queryAll(selector, options) {
+    return this.mainFrame().queryAll(selector, options);
+  }
+  async queryXPath(selector, options) {
+    return this.mainFrame().queryXPath(selector, options);
+  }
+  async queryAllXPath(selector, options) {
+    return this.mainFrame().queryAllXPath(selector, options);
+  }
+  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 evaluate(fnOrString, ...args) {
+    return this.mainFrame().evaluate(fnOrString, ...args);
+  }
+  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 = path.resolve(options.path);
+      fs.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 Browser = class {
+  connection;
+  process;
+  logger;
+  events;
+  constructor(connection, child, logger, events) {
+    this.connection = connection;
+    this.process = child;
+    this.logger = logger;
+    this.events = events;
+  }
+  on(event, handler) {
+    this.events.on(event, handler);
+  }
+  async newPage() {
+    const { targetId } = await this.connection.send("Target.createTarget", { url: "about:blank" });
+    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 close() {
+    try {
+      await this.connection.send("Browser.close");
+    } catch {
+    }
+    await this.connection.close();
+    if (!this.process.killed) {
+      this.process.kill();
+    }
+  }
+};
+
+// src/browser/Downloader.ts
+import fs2 from "fs";
+import path2 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 || path2.join(os.homedir(), "AppData", "Local");
+    return path2.join(localAppData, "chromium-automaton");
+  }
+  return path2.join(os.homedir(), ".cache", "chromium-automaton");
+}
+function ensureWithinRoot(root, target) {
+  const resolvedRoot = path2.resolve(root);
+  const resolvedTarget = path2.resolve(target);
+  if (resolvedTarget === resolvedRoot) {
+    return;
+  }
+  if (!resolvedTarget.startsWith(resolvedRoot + path2.sep)) {
+    throw new Error(`Path escapes cache root: ${resolvedTarget}`);
+  }
+}
+function chromiumExecutableRelativePath(platform) {
+  if (platform === "linux") return path2.join("chrome-linux", "chrome");
+  if (platform === "mac") return path2.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium");
+  return path2.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 = path2.join(cacheRoot, platform);
+  const revisionDir = path2.join(platformDir, revision);
+  ensureWithinRoot(cacheRoot, revisionDir);
+  const executablePath = path2.join(revisionDir, chromiumExecutableRelativePath(platform));
+  const markerFile = path2.join(revisionDir, "INSTALLATION_COMPLETE");
+  if (fs2.existsSync(executablePath) && fs2.existsSync(markerFile)) {
+    return { executablePath, revisionDir };
+  }
+  fs2.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 = path2.join(os.tmpdir(), `chromium-automaton-${platform}-${revision}.zip`);
+  logger.info("Downloading Chromium snapshot", downloadUrl);
+  await downloadFile(downloadUrl, tempZipPath, logger);
+  logger.info("Extracting Chromium snapshot", tempZipPath);
+  await extractZipSafe(tempZipPath, revisionDir);
+  fs2.writeFileSync(markerFile, (/* @__PURE__ */ new Date()).toISOString());
+  fs2.unlinkSync(tempZipPath);
+  if (!fs2.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 = fs2.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) => {
+      fs2.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 = path2.join(destDir, entryPath);
+        try {
+          ensureWithinRoot(destDir, targetPath);
+        } catch (error) {
+          zipfile.close();
+          reject(error);
+          return;
+        }
+        if (/\/$/.test(entry.fileName)) {
+          fs2.mkdirSync(targetPath, { recursive: true });
+          zipfile.readEntry();
+          return;
+        }
+        fs2.mkdirSync(path2.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 = fs2.createWriteStream(targetPath);
+          readStream.pipe(writeStream);
+          writeStream.on("error", (writeErr) => {
+            zipfile.close();
+            reject(writeErr);
+          });
+          writeStream.on("close", () => {
+            if (mode && mode <= 511) {
+              try {
+                fs2.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 = fs2.statSync(executablePath);
+    const isExecutable = (stat.mode & 73) !== 0;
+    if (!isExecutable) {
+      fs2.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.CHROMIUM_AUTOMATON_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.CHROMIUM_AUTOMATON_EXECUTABLE_PATH;
+    let revision = options.latest ? await fetchLatestRevision(platform) : resolveRevision(process.env.CHROMIUM_AUTOMATON_REVISION);
+    let executablePath;
+    let revisionDir = "";
+    if (overrideExecutable) {
+      executablePath = path3.resolve(overrideExecutable);
+    } else {
+      const downloaded = await ensureDownloaded({
+        cacheRoot,
+        platform,
+        revision,
+        logger: this.logger
+      });
+      executablePath = downloaded.executablePath;
+      revisionDir = downloaded.revisionDir;
+    }
+    if (!fs3.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.CHROMIUM_AUTOMATON_EXECUTABLE_PATH;
+    let resolvedExecutable = executablePath;
+    if (!resolvedExecutable) {
+      const platform = detectPlatform();
+      const cacheRoot = this.resolveCacheRoot(platform);
+      const revision = resolveRevision(process.env.CHROMIUM_AUTOMATON_REVISION);
+      const downloaded = await ensureDownloaded({
+        cacheRoot,
+        platform,
+        revision,
+        logger
+      });
+      resolvedExecutable = downloaded.executablePath;
+    }
+    if (!resolvedExecutable || !fs3.existsSync(resolvedExecutable)) {
+      throw new Error(`Chromium executable not found: ${resolvedExecutable}`);
+    }
+    const stats = fs3.statSync(resolvedExecutable);
+    if (!stats.isFile()) {
+      throw new Error(`Chromium executable is not a file: ${resolvedExecutable}`);
+    }
+    ensureExecutable2(resolvedExecutable);
+    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 (process.platform === "linux") {
+      args.push("--disable-crash-reporter", "--disable-crashpad");
+    }
+    if (options.headless ?? true) {
+      args.push("--headless=new");
+    }
+    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);
+    const events = new AutomationEvents();
+    const browser = new Browser(connection, child, logger, events);
+    return browser;
+  }
+  resolveCacheRoot(platform) {
+    const envRoot = process.env.CHROMIUM_AUTOMATON_CACHE_DIR;
+    if (envRoot && envRoot.trim()) {
+      return path3.resolve(envRoot.trim());
+    }
+    return defaultCacheRoot(platform);
+  }
+};
+function ensureExecutable2(executablePath) {
+  if (process.platform === "win32") {
+    return;
+  }
+  try {
+    const stat = fs3.statSync(executablePath);
+    const isExecutable = (stat.mode & 73) !== 0;
+    if (!isExecutable) {
+      fs3.chmodSync(executablePath, 493);
+    }
+  } catch {
+  }
+  const dir = path3.dirname(executablePath);
+  const helpers = [
+    "chrome_crashpad_handler",
+    "chrome_sandbox",
+    "chrome-wrapper",
+    "xdg-mime",
+    "xdg-settings"
+  ];
+  for (const name of helpers) {
+    const helperPath = path3.join(dir, name);
+    if (!fs3.existsSync(helperPath)) {
+      continue;
+    }
+    try {
+      const stat = fs3.statSync(helperPath);
+      const isExecutable = (stat.mode & 73) !== 0;
+      if (!isExecutable) {
+        fs3.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("chromium-automaton 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