@toolstackhq/cdpwright 1.0.0

package/dist/index.js

@@ -0,0 +1,878 @@
+import {
+  AssertionError,
+  Frame,
+  Locator,
+  Page,
+  expect
+} from "./chunk-6BPF3IEU.js";
+
+// src/browser/ChromiumManager.ts
+import fs2 from "fs";
+import path2 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/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 fs from "fs";
+import path 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 || path.join(os.homedir(), "AppData", "Local");
+    return path.join(localAppData, "cdpwright");
+  }
+  return path.join(os.homedir(), ".cache", "cdpwright");
+}
+function ensureWithinRoot(root, target) {
+  const resolvedRoot = path.resolve(root);
+  const resolvedTarget = path.resolve(target);
+  if (resolvedTarget === resolvedRoot) {
+    return;
+  }
+  if (!resolvedTarget.startsWith(resolvedRoot + path.sep)) {
+    throw new Error(`Path escapes cache root: ${resolvedTarget}`);
+  }
+}
+function chromiumExecutableRelativePath(platform) {
+  if (platform === "linux") return path.join("chrome-linux", "chrome");
+  if (platform === "mac") return path.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium");
+  return path.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 = path.join(cacheRoot, platform);
+  const revisionDir = path.join(platformDir, revision);
+  ensureWithinRoot(cacheRoot, revisionDir);
+  const executablePath = path.join(revisionDir, chromiumExecutableRelativePath(platform));
+  const markerFile = path.join(revisionDir, "INSTALLATION_COMPLETE");
+  if (fs.existsSync(executablePath) && fs.existsSync(markerFile)) {
+    return { executablePath, revisionDir };
+  }
+  fs.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 = path.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);
+  fs.writeFileSync(markerFile, (/* @__PURE__ */ new Date()).toISOString());
+  fs.unlinkSync(tempZipPath);
+  if (!fs.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 = fs.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) => {
+      fs.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 = path.join(destDir, entryPath);
+        try {
+          ensureWithinRoot(destDir, targetPath);
+        } catch (error) {
+          zipfile.close();
+          reject(error);
+          return;
+        }
+        if (/\/$/.test(entry.fileName)) {
+          fs.mkdirSync(targetPath, { recursive: true });
+          zipfile.readEntry();
+          return;
+        }
+        fs.mkdirSync(path.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 = fs.createWriteStream(targetPath);
+          readStream.pipe(writeStream);
+          writeStream.on("error", (writeErr) => {
+            zipfile.close();
+            reject(writeErr);
+          });
+          writeStream.on("close", () => {
+            if (mode && mode <= 511) {
+              try {
+                fs.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 = fs.statSync(executablePath);
+    const isExecutable = (stat.mode & 73) !== 0;
+    if (!isExecutable) {
+      fs.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 = path2.resolve(overrideExecutable);
+    } else {
+      const downloaded = await ensureDownloaded({
+        cacheRoot,
+        platform,
+        revision,
+        logger: this.logger
+      });
+      executablePath = downloaded.executablePath;
+      revisionDir = downloaded.revisionDir;
+    }
+    if (!fs2.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 || !fs2.existsSync(resolvedExecutable)) {
+      throw new Error(`Chromium executable not found: ${resolvedExecutable}`);
+    }
+    const stats = fs2.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 = fs2.mkdtempSync(path2.join(os2.tmpdir(), "cdpwright-"));
+      cleanupTasks.push(() => fs2.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 path2.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 = fs2.statSync(executablePath);
+    const isExecutable = (stat.mode & 73) !== 0;
+    if (!isExecutable) {
+      fs2.chmodSync(executablePath, 493);
+    }
+  } catch {
+  }
+  const dir = path2.dirname(executablePath);
+  const helpers = [
+    "chrome_crashpad_handler",
+    "chrome_sandbox",
+    "chrome-wrapper",
+    "xdg-mime",
+    "xdg-settings"
+  ];
+  for (const name of helpers) {
+    const helperPath = path2.join(dir, name);
+    if (!fs2.existsSync(helperPath)) {
+      continue;
+    }
+    try {
+      const stat = fs2.statSync(helperPath);
+      const isExecutable = (stat.mode & 73) !== 0;
+      if (!isExecutable) {
+        fs2.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/index.ts
+var automaton = {
+  async launch(options = {}) {
+    const manager = new ChromiumManager(options.logger);
+    return manager.launch(options);
+  }
+};
+var chromium = automaton;
+export {
+  AssertionError,
+  AutomationEvents,
+  Browser,
+  BrowserContext,
+  Frame,
+  Locator,
+  Logger,
+  Page,
+  automaton,
+  chromium,
+  expect
+};
+//# sourceMappingURL=index.js.map