@xbrowser/cli 0.16.0 → 1.0.2

package/dist/{chunk-DTJRVA76.js → chunk-ETCO4SNK.js}

@@ -9,12 +9,12 @@ function generateJSScript(recording) {
 // Start URL: ${recording.startUrl}
 // Events: ${events.length}
 
-import { chromium } from 'playwright';
+import { launch } from '@xbrowser/cli';
 
 const START_URL = '${escapeString(recording.startUrl)}';
 
 async function main() {
-  const browser = await chromium.launch({ headless: true });
+  const { browser } = await launch({ headless: true });
   const context = await browser.newContext();
   const page = await context.newPage();
 

package/dist/{chunk-RS6YYWTK.js → chunk-JPA2ZT2R.js}

@@ -1,3 +1,6 @@
+import {
+  launch
+} from "./chunk-PPG4D2EW.js";
 import {
   CDPInterceptorProxy
 } from "./chunk-ZZ2TFWIV.js";
@@ -7,7 +10,6 @@ import { randomUUID } from "crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { chromium } from "playwright";
 
 // src/utils/cdp.ts
 async function fetchNoProxy(url) {
@@ -63,6 +65,7 @@ async function resolveCDPEndpoint(raw) {
 }
 
 // src/browser.ts
+import { SessionStore } from "@dyyz1993/xcli-core";
 function logSessionEvent(event, details) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
   const pid = process.pid;
@@ -75,7 +78,7 @@ function sessionFile(name) {
 function ensureSessionDir() {
   mkdirSync(SESSION_DIR, { recursive: true });
 }
-var sessions = /* @__PURE__ */ new Map();
+var sessions = new SessionStore();
 var _sharedBrowser = null;
 var _sharedCdpProxy = null;
 var IDLE_TIMEOUT_MS = (process.env.XBROWSER_IDLE_TIMEOUT ? parseInt(process.env.XBROWSER_IDLE_TIMEOUT, 10) : 30) * 60 * 1e3;
@@ -86,7 +89,7 @@ function resetIdleTimer() {
     const now = Date.now();
     let allIdle = true;
     const idleSessions = [];
-    for (const [, s] of sessions) {
+    for (const s of sessions) {
       if (now - s.lastActivityAt < IDLE_TIMEOUT_MS) {
         allIdle = false;
       } else {
@@ -109,7 +112,7 @@ function touchSession(id) {
   resetIdleTimer();
 }
 process.on("exit", () => {
-  for (const session of sessions.values()) {
+  for (const session of sessions.list()) {
     if (session.isCDP) {
       logSessionEvent("process_exit", `Session "${session.name}": CDP connection (not closing external browser).`);
     } else {
@@ -192,15 +195,21 @@ async function createBrowser(options) {
     const realEndpoint = await resolveCDPEndpoint(options.cdpEndpoint);
     if (options.intercept) {
       const config = typeof options.intercept === "object" ? { ...options.intercept, cdpEndpoint: realEndpoint } : { cdpEndpoint: realEndpoint };
-      const proxy = new CDPInterceptorProxy(config);
-      const proxyPort = await proxy.start();
+      _sharedCdpProxy = new CDPInterceptorProxy(config);
+      const proxyPort = await _sharedCdpProxy.start();
       console.error(`[CDP Interceptor] Proxy running on ws://localhost:${proxyPort}, forwarding to ${realEndpoint}`);
-      return await chromium.connectOverCDP(`ws://localhost:${proxyPort}`);
+      const { browser: browser3 } = await launch({ cdpEndpoint: `ws://localhost:${proxyPort}` });
+      return browser3;
     }
-    return await chromium.connectOverCDP(realEndpoint);
+    const { browser: browser2 } = await launch({ cdpEndpoint: realEndpoint });
+    await browser2.discoverContexts().catch((err) => {
+      console.error(`[browser] discoverContexts failed: ${err.message}`);
+    });
+    return browser2;
   }
   const executablePath = options?.executablePath || process.env.XBROWSER_CHROMIUM_PATH || discoverChromiumPath();
-  return await chromium.launch({ executablePath, headless: options?.headless ?? true });
+  const { browser } = await launch({ executablePath, headless: options?.headless ?? true });
+  return browser;
 }
 async function getBrowser(options) {
   if (_sharedBrowser) return _sharedBrowser;
@@ -210,10 +219,7 @@ async function getBrowser(options) {
   return _sharedBrowser;
 }
 function findSession(name) {
-  for (const [, session] of sessions) {
-    if (session.name === name) return session;
-  }
-  return void 0;
+  return sessions.find(name);
 }
 function getSessionById(id) {
   return sessions.get(id);
@@ -317,9 +323,14 @@ async function findOrRestoreSession(name, cdpEndpoint) {
       return void 0;
     }
     const targetUrl = meta.conversationUrl || meta.url;
-    if (targetUrl && page.url() !== targetUrl && !page.url().includes(new URL(targetUrl).hostname)) {
-      await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 3e4 }).catch(() => {
-      });
+    if (targetUrl && page.url() !== targetUrl) {
+      try {
+        if (!page.url().includes(new URL(targetUrl).hostname)) {
+          await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 3e4 }).catch(() => {
+          });
+        }
+      } catch {
+      }
     }
     const session = {
       id: meta.id || randomUUID(),
@@ -332,13 +343,13 @@ async function findOrRestoreSession(name, cdpEndpoint) {
       isCDP: true,
       cdpEndpoint: ep
     };
-    for (const [existingId, existingSession] of sessions) {
+    for (const existingSession of sessions.list()) {
       if (existingSession.name === name) {
-        logSessionEvent("remove_stale", `Removing stale session name="${name}" id="${existingId}" during restore`);
-        sessions.delete(existingId);
+        logSessionEvent("remove_stale", `Removing stale session name="${name}" id="${existingSession.id}" during restore`);
+        sessions.removeById(existingSession.id);
       }
     }
-    sessions.set(session.id, session);
+    sessions.set(session);
     resetIdleTimer();
     await installNetworkCapture(page, name);
     return session;
@@ -351,10 +362,15 @@ async function findOrRestoreSession(name, cdpEndpoint) {
 async function createEphemeralContext(options) {
   if (options?.cdpEndpoint) {
     const endpoint = await resolveCDPEndpoint(options.cdpEndpoint);
-    const b2 = await chromium.connectOverCDP(endpoint);
+    const { browser: b2 } = await launch({ cdpEndpoint: endpoint });
     const contexts = b2.contexts();
     const ctx = contexts[0] || await b2.newContext();
-    const page2 = await ctx.newPage();
+    const allPages = ctx.pages();
+    const existingPages = allPages.filter((p) => {
+      const url = p.url();
+      return url !== "about:blank" && !url.startsWith("chrome://");
+    });
+    const page2 = existingPages.length > 0 ? existingPages[0] : allPages.length > 0 ? allPages[0] : await ctx.newPage();
     resetIdleTimer();
     ephemeralConnections.set(page2, b2);
     return { context: ctx, page: page2 };
@@ -386,38 +402,59 @@ async function closeEphemeralContext(context) {
   }
 }
 function getAllSessions() {
-  return Array.from(sessions.values());
+  return sessions.list();
 }
 async function installNetworkCapture(page, sessionName) {
   if (process.env.XBROWSER_DAEMON_WORKER !== "1") return;
-  const { networkStore } = await import("./network-store-BN6QEZ7R.js");
-  page.on("response", async (response) => {
+  const { networkStore } = await import("./network-store-YVDNUREI.js");
+  const requestData = /* @__PURE__ */ new Map();
+  const responseMeta = /* @__PURE__ */ new Map();
+  const xbPage = page;
+  xbPage.on("request", (params) => {
     try {
-      const request = response.request();
-      const url = response.url();
-      const contentType = response.headers()["content-type"] || "";
-      const headers = {};
-      for (const [k, v] of Object.entries(response.headers())) {
-        headers[k] = v;
-      }
-      const requestHeaders = {};
-      for (const [k, v] of Object.entries(request.headers())) {
-        requestHeaders[k] = v;
-      }
+      const p = params;
+      requestData.set(p.requestId, {
+        method: p.request.method,
+        headers: p.request.headers,
+        postData: p.request.postData ?? null,
+        resourceType: p.type
+      });
+    } catch {
+    }
+  });
+  xbPage.on("response", (params) => {
+    try {
+      const p = params;
+      responseMeta.set(p.requestId, {
+        status: p.response.status,
+        url: p.response.url,
+        headers: p.response.headers,
+        mimeType: p.response.mimeType,
+        type: p.type
+      });
+    } catch {
+    }
+  });
+  xbPage.on("requestfinished", async (params) => {
+    try {
+      const p = params;
+      const meta = responseMeta.get(p.requestId);
+      if (!meta) return;
+      const req = requestData.get(p.requestId);
+      const method = req?.method ?? "GET";
+      const contentType = meta.headers["content-type"] || meta.headers["Content-Type"] || "";
+      const resourceType = req?.resourceType ?? meta.type;
+      const requestHeaders = req?.headers ?? {};
       let requestBody = void 0;
-      const method = request.method();
       const isPostLike = ["POST", "PATCH", "PUT"].includes(method);
       if (isPostLike && requestHeaders["content-type"]?.includes("application/json")) {
-        try {
-          const postData = request.postData();
-          if (postData) {
-            try {
-              requestBody = JSON.parse(postData);
-            } catch {
-              requestBody = postData;
-            }
+        const postData = req?.postData;
+        if (postData) {
+          try {
+            requestBody = JSON.parse(postData);
+          } catch {
+            requestBody = postData;
           }
-        } catch {
         }
       }
       let responseBody = void 0;
@@ -425,7 +462,11 @@ async function installNetworkCapture(page, sessionName) {
       const isJsonish = contentType.includes("json") || contentType.includes("javascript") || contentType.includes("text/");
       if (isJsonish) {
         try {
-          const text = await response.text();
+          const bodyResult = await xbPage._cdpSend(
+            "Network.getResponseBody",
+            { requestId: p.requestId }
+          );
+          const text = bodyResult.body ?? "";
           size = text.length;
           if (size <= 10240) {
             try {
@@ -438,8 +479,11 @@ async function installNetworkCapture(page, sessionName) {
         }
       } else {
         try {
-          const text = await response.text();
-          size = text.length;
+          const bodyResult = await xbPage._cdpSend(
+            "Network.getResponseBody",
+            { requestId: p.requestId }
+          );
+          size = bodyResult.body?.length ?? 0;
         } catch {
           size = 0;
         }
@@ -447,17 +491,19 @@ async function installNetworkCapture(page, sessionName) {
       networkStore.add(sessionName, {
         timestamp: Date.now(),
         method,
-        url,
-        path: new URL(url).pathname,
-        status: response.status(),
+        url: meta.url,
+        path: new URL(meta.url).pathname,
+        status: meta.status,
         contentType,
         size,
-        headers,
+        headers: meta.headers,
         body: responseBody,
         requestHeaders,
         requestBody,
-        resourceType: request.resourceType()
+        resourceType
       });
+      requestData.delete(p.requestId);
+      responseMeta.delete(p.requestId);
     } catch {
     }
   });
@@ -481,16 +527,38 @@ async function createSession(name, url, options) {
     }
     context = contexts[0] || await b.newContext();
     let targetPage = null;
-    for (const ctx of contexts) {
-      const pages = ctx.pages();
-      for (const p of pages) {
-        const pUrl = p.url();
-        if (pUrl && pUrl !== "about:blank" && !pUrl.startsWith("chrome://")) {
-          targetPage = p;
-          break;
+    const targetHostname = url ? (() => {
+      try {
+        return new URL(url).hostname;
+      } catch {
+        return "";
+      }
+    })() : "";
+    if (targetHostname) {
+      for (const ctx of contexts) {
+        const pages = ctx.pages();
+        for (const p of pages) {
+          const pUrl = p.url();
+          if (pUrl && pUrl !== "about:blank" && !pUrl.startsWith("chrome://") && pUrl.includes(targetHostname)) {
+            targetPage = p;
+            break;
+          }
+        }
+        if (targetPage) break;
+      }
+    }
+    if (!targetPage) {
+      for (const ctx of contexts) {
+        const pages = ctx.pages();
+        for (const p of pages) {
+          const pUrl = p.url();
+          if (pUrl && pUrl !== "about:blank" && !pUrl.startsWith("chrome://")) {
+            targetPage = p;
+            break;
+          }
         }
+        if (targetPage) break;
       }
-      if (targetPage) break;
     }
     if (!targetPage && options?.cdpEndpoint) {
       const targets = await getCDPTargets(options.cdpEndpoint);
@@ -531,14 +599,14 @@ async function createSession(name, url, options) {
     isCDP,
     cdpEndpoint: options?.cdpEndpoint
   };
-  sessions.set(session.id, session);
+  sessions.set(session);
   logSessionEvent("create_session", `name="${name}" id="${session.id}" url="${url || "(no url)"}" isCDP=${isCDP} cdpEndpoint=${options?.cdpEndpoint || "(none)"}`);
   resetIdleTimer();
   await installNetworkCapture(page, name);
   return session;
 }
 async function closeSessionByName(name) {
-  for (const [id, session] of sessions) {
+  for (const session of sessions) {
     if (session.name === name || session.id === name) {
       logSessionEvent("close_session", `name="${session.name}" id="${session.id}" url="${session.page.url()}"`);
       if (session.isCDP) {
@@ -557,20 +625,20 @@ async function closeSessionByName(name) {
           });
         }
       }
-      sessions.delete(id);
+      sessions.removeById(session.id);
       const file2 = sessionFile(session.name);
       try {
         unlinkSync(file2);
       } catch {
       }
       try {
-        const { networkStore, commandLogStore } = await import("./network-store-BN6QEZ7R.js");
+        const { networkStore, commandLogStore } = await import("./network-store-YVDNUREI.js");
         networkStore.clear(session.name);
         commandLogStore.clear(session.name);
       } catch {
       }
       try {
-        const { SessionRecorder } = await import("./session-recorder-XET3DNML.js");
+        const { SessionRecorder } = await import("./session-recorder-RTDGURIJ.js");
         SessionRecorder.cleanup(session.name);
       } catch {
       }
@@ -585,9 +653,9 @@ async function closeSessionByName(name) {
   return false;
 }
 async function closeAllSessions() {
-  const names = [...sessions.values()].map((s) => `${s.name}(${s.page.url()})`).join(", ");
+  const names = sessions.list().map((s) => `${s.name}(${s.page.url()})`).join(", ");
   if (names) logSessionEvent("close_all_sessions", `Closing ${sessions.size} sessions: ${names}`);
-  for (const [id, session] of sessions) {
+  for (const session of sessions.list()) {
     try {
       if (!session.isCDP) {
         await session.context.close();
@@ -596,9 +664,9 @@ async function closeAllSessions() {
         await session.browser.close().catch(() => {
         });
       }
-      sessions.delete(id);
+      sessions.removeById(session.id);
     } catch {
-      sessions.delete(id);
+      sessions.removeById(session.id);
     }
   }
 }
@@ -636,7 +704,7 @@ async function ensureProcessCanExit() {
     clearTimeout(idleTimer);
     idleTimer = null;
   }
-  for (const session of sessions.values()) {
+  for (const session of sessions.list()) {
     if (session.browser) {
       if (session.isCDP) {
         await session.browser.close().catch(() => {

package/dist/chunk-JPHCY4TC.js

@@ -0,0 +1,260 @@
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/cdp-driver/launcher.ts
+import { spawn } from "child_process";
+import { existsSync as fsExistsSync } from "fs";
+var DEFAULT_CHROME_PATHS = {
+  darwin: [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+  ],
+  linux: [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/usr/bin/microsoft-edge"
+  ],
+  win32: [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe"
+  ]
+};
+var DEFAULT_ARGS = [
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--no-sandbox",
+  "--disable-background-networking",
+  "--disable-background-timer-throttling",
+  "--disable-backgrounding-occluded-windows",
+  "--disable-breakpad",
+  "--disable-client-side-phishing-detection",
+  "--disable-default-apps",
+  "--disable-extensions",
+  "--disable-hang-monitor",
+  "--disable-ipc-flood-protection",
+  "--disable-popup-blocking",
+  "--disable-prompt-on-repost",
+  "--disable-renderer-backgrounding",
+  "--disable-sync",
+  "--disable-translate",
+  "--metrics-recording-only",
+  "--password-store=basic",
+  "--use-mock-keychain"
+];
+var ANTI_DETECT_ARGS = [
+  "--disable-blink-features=AutomationControlled",
+  "--disable-features=IsolateOrigins,site-per-process"
+];
+function findChrome() {
+  const platform = process.platform;
+  const paths = DEFAULT_CHROME_PATHS[platform] ?? [];
+  for (const p of paths) {
+    if (fsExistsSync(p)) return p;
+  }
+  return null;
+}
+async function launchChrome(options = {}) {
+  const {
+    executablePath,
+    headless = true,
+    args: extraArgs = [],
+    userDataDir,
+    timeout = 3e4,
+    env
+  } = options;
+  const chromePath = executablePath ?? findChrome();
+  if (!chromePath) {
+    throw new Error(
+      [
+        "Chrome/Chromium not found.",
+        "",
+        "\u63A8\u8350\uFF1A\u7528 cdp-tunnel \u590D\u7528\u4F60\u5DF2\u6709\u7684 Chrome\uFF08\u542B\u767B\u5F55\u6001\u3001\u53CD\u722C\u53CB\u597D\uFF09",
+        "  npx cdp-tunnel setup          # \u96F6\u5B89\u88C5\u4E00\u952E\u542F\u52A8\u4EE3\u7406 + \u52A0\u8F7D Chrome \u6269\u5C55",
+        "  xbrowser goto https://example.com --cdp http://localhost:9221",
+        "",
+        "\u6216\u6307\u5B9A Chrome \u8DEF\u5F84\uFF1A",
+        '  xbrowser config set browser.executablePath "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"'
+      ].join("\n")
+    );
+  }
+  const port = await findFreePort();
+  const allArgs = [
+    `--remote-debugging-port=${port}`,
+    "--remote-allow-origins=*",
+    "--no-sandbox",
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-background-timer-throttling",
+    "--disable-backgrounding-occluded-windows",
+    "--disable-renderer-backgrounding",
+    "--disable-features=Translate",
+    "--disable-popup-blocking"
+  ];
+  if (headless) {
+    allArgs.push("--headless", "--hide-scrollbars", "--mute-audio");
+  }
+  let tmpDir;
+  if (userDataDir) {
+    allArgs.push(`--user-data-dir=${userDataDir}`);
+  } else {
+    const { mkdirSync } = await import("fs");
+    tmpDir = `/tmp/xbrowser-chrome-${process.pid}-${Date.now()}`;
+    mkdirSync(tmpDir, { recursive: true });
+    allArgs.push(`--user-data-dir=${tmpDir}`);
+  }
+  allArgs.push(...extraArgs, "about:blank");
+  const childEnv = {
+    ...process.env,
+    ...env
+  };
+  const quotedPath = chromePath.includes(" ") ? `"${chromePath}"` : chromePath;
+  const quotedArgs = allArgs.map((a) => {
+    if (a.includes(" ")) return `"${a}"`;
+    return a;
+  }).join(" ");
+  const fullCmd = `${quotedPath} ${quotedArgs}`;
+  const child = process.platform === "darwin" ? spawn("/bin/sh", ["-c", fullCmd], {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: childEnv
+  }) : spawn(chromePath, allArgs, {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: childEnv
+  });
+  const stderrLines = [];
+  child.stderr?.on("data", (data) => {
+    const line = data.toString().trim();
+    if (line) stderrLines.push(line);
+  });
+  child.stdout?.on("data", (data) => {
+    const line = data.toString().trim();
+    if (line) stderrLines.push(`[stdout] ${line}`);
+  });
+  child.on("error", (err) => {
+    if (!child.killed) {
+      console.error(`Chrome process error: ${err.message}`);
+    }
+  });
+  try {
+    const wsEndpoint = await waitForCDPReady(port, timeout, child);
+    return { process: child, wsEndpoint, port, tmpDir };
+  } catch (err) {
+    const stderr = stderrLines.slice(-20).join("\n");
+    const exitInfo = child.exitCode !== null ? ` (exit code: ${child.exitCode})` : " (still running)";
+    throw new Error(`${err.message}${exitInfo}
+Chrome stderr:
+${stderr || "(empty)"}`);
+  }
+}
+async function connectToCDP(rawEndpoint) {
+  if (rawEndpoint.startsWith("ws://") || rawEndpoint.startsWith("wss://")) {
+    return rawEndpoint;
+  }
+  return resolveEndpointFromHTTP(rawEndpoint);
+}
+async function findFreePort() {
+  const { createServer } = await import("net");
+  return new Promise((resolve, reject) => {
+    const srv = createServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      if (addr && typeof addr === "object") {
+        const port = addr.port;
+        srv.close(() => resolve(port));
+      } else {
+        srv.close();
+        reject(new Error("Failed to find free port"));
+      }
+    });
+    srv.on("error", reject);
+  });
+}
+async function waitForCDPReady(port, timeoutMs, child) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null && child.exitCode !== 0) {
+      throw new Error(`Chrome exited with code ${child.exitCode} before CDP became ready`);
+    }
+    try {
+      const wsEndpoint = await resolveEndpointFromHTTP(`http://127.0.0.1:${port}`);
+      return wsEndpoint;
+    } catch {
+      await sleep(200);
+    }
+  }
+  throw new Error(`Chrome CDP not ready after ${timeoutMs}ms (port ${port})`);
+}
+async function resolveEndpointFromHTTP(baseURL) {
+  const url = `${baseURL}/json/version`;
+  const resp = await fetch(url, { signal: AbortSignal.timeout(3e3) });
+  if (!resp.ok) {
+    throw new Error(`CDP HTTP ${resp.status}: ${url}`);
+  }
+  const data = await resp.json();
+  if (!data.webSocketDebuggerUrl) {
+    throw new Error("No webSocketDebuggerUrl in CDP response");
+  }
+  return data.webSocketDebuggerUrl;
+}
+async function getCDPTargets(baseURL) {
+  const url = `${baseURL}/json/list`;
+  const resp = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+  if (!resp.ok) {
+    throw new Error(`CDP list HTTP ${resp.status}: ${url}`);
+  }
+  const targets = await resp.json();
+  return targets;
+}
+async function killChrome(child, tmpDir) {
+  if (child.exitCode !== null) {
+    if (tmpDir) cleanupTmpDir(tmpDir);
+    return;
+  }
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      if (tmpDir) cleanupTmpDir(tmpDir);
+      resolve();
+    }, 5e3);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      if (tmpDir) cleanupTmpDir(tmpDir);
+      resolve();
+    });
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      clearTimeout(timer);
+      if (tmpDir) cleanupTmpDir(tmpDir);
+      resolve();
+    }
+  });
+}
+function cleanupTmpDir(dir) {
+  try {
+    const { rmSync } = __require("fs");
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  DEFAULT_ARGS,
+  ANTI_DETECT_ARGS,
+  findChrome,
+  launchChrome,
+  connectToCDP,
+  getCDPTargets,
+  killChrome
+};