@xbrowser/cli 0.14.0

package/dist/chunk-RS6YYWTK.js

@@ -0,0 +1,685 @@
+import {
+  CDPInterceptorProxy
+} from "./chunk-ZZ2TFWIV.js";
+
+// src/browser.ts
+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) {
+  const savedProxy = {
+    http_proxy: process.env.http_proxy,
+    https_proxy: process.env.https_proxy,
+    HTTP_PROXY: process.env.HTTP_PROXY,
+    HTTPS_PROXY: process.env.HTTPS_PROXY,
+    all_proxy: process.env.all_proxy,
+    ALL_PROXY: process.env.ALL_PROXY
+  };
+  for (const key of Object.keys(savedProxy)) delete process.env[key];
+  try {
+    return await fetch(url);
+  } finally {
+    for (const [key, val] of Object.entries(savedProxy)) {
+      if (val !== void 0) process.env[key] = val;
+    }
+  }
+}
+async function resolveCDPEndpoint(raw) {
+  if (raw === "auto") {
+    const httpResp = await fetchNoProxy("http://localhost:9222/json/version");
+    const data = await httpResp.json();
+    if (!data.webSocketDebuggerUrl) {
+      throw new Error("Could not auto-discover CDP endpoint from localhost:9222");
+    }
+    return data.webSocketDebuggerUrl;
+  }
+  if (/^\d+$/.test(raw)) {
+    const port = raw;
+    const httpResp = await fetchNoProxy(`http://localhost:${port}/json/version`);
+    const data = await httpResp.json();
+    if (!data.webSocketDebuggerUrl) {
+      throw new Error(`Could not discover CDP endpoint from localhost:${port}`);
+    }
+    return data.webSocketDebuggerUrl;
+  }
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    try {
+      const httpResp = await fetchNoProxy(`${raw}/json/version`);
+      const data = await httpResp.json();
+      if (!data.webSocketDebuggerUrl) {
+        throw new Error(`Could not discover CDP endpoint from ${raw}`);
+      }
+      return data.webSocketDebuggerUrl;
+    } catch (error) {
+      console.warn(`Failed to fetch WebSocket URL from ${raw}, using endpoint directly: ${error instanceof Error ? error.message : String(error)}`);
+      return raw;
+    }
+  }
+  return raw;
+}
+
+// src/browser.ts
+function logSessionEvent(event, details) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
+  const pid = process.pid;
+  console.error(`[SESSION] ${ts} [PID:${pid}] ${event} | ${details}`);
+}
+var SESSION_DIR = join(homedir(), ".xbrowser", "sessions");
+function sessionFile(name) {
+  return join(SESSION_DIR, `${name}.json`);
+}
+function ensureSessionDir() {
+  mkdirSync(SESSION_DIR, { recursive: true });
+}
+var sessions = /* @__PURE__ */ new Map();
+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;
+var idleTimer = null;
+function resetIdleTimer() {
+  if (idleTimer) clearTimeout(idleTimer);
+  idleTimer = setTimeout(async () => {
+    const now = Date.now();
+    let allIdle = true;
+    const idleSessions = [];
+    for (const [, s] of sessions) {
+      if (now - s.lastActivityAt < IDLE_TIMEOUT_MS) {
+        allIdle = false;
+      } else {
+        idleSessions.push(`${s.name}(${(now - s.lastActivityAt) / 1e3}s idle)`);
+      }
+    }
+    if (allIdle && (sessions.size > 0 || _sharedBrowser)) {
+      logSessionEvent("idle_timeout", `Sessions idle for >${IDLE_TIMEOUT_MS / 6e4}min. Sessions: ${idleSessions.join(", ") || "all"}. Calling destroyBrowser()`);
+      await destroyBrowser().catch(() => {
+      });
+    }
+  }, IDLE_TIMEOUT_MS);
+  if (idleTimer && typeof idleTimer.unref === "function") {
+    idleTimer.unref();
+  }
+}
+function touchSession(id) {
+  const s = sessions.get(id);
+  if (s) s.lastActivityAt = Date.now();
+  resetIdleTimer();
+}
+process.on("exit", () => {
+  for (const session of sessions.values()) {
+    if (session.isCDP) {
+      logSessionEvent("process_exit", `Session "${session.name}": CDP connection (not closing external browser).`);
+    } else {
+      logSessionEvent("process_exit", `Session "${session.name}": Closing browser.`);
+      try {
+        session.browser?.close();
+      } catch {
+      }
+    }
+  }
+  if (_sharedBrowser) {
+    logSessionEvent("process_exit", "Closing shared browser.");
+    try {
+      _sharedBrowser.close();
+    } catch {
+    }
+    _sharedBrowser = null;
+  }
+  if (_sharedCdpProxy) {
+    try {
+      _sharedCdpProxy.stop();
+    } catch {
+    }
+    _sharedCdpProxy = null;
+  }
+  sessions.clear();
+});
+async function getCDPTargets(cdpEndpoint) {
+  try {
+    const ep = String(cdpEndpoint);
+    let host = "localhost";
+    let port = "9222";
+    if (ep.startsWith("http://") || ep.startsWith("https://")) {
+      const u = new URL(ep);
+      host = u.hostname;
+      port = u.port || "9222";
+    } else if (/^\d+$/.test(ep)) {
+      port = ep;
+    }
+    const url = `http://${host}:${port}/json/list`;
+    const resp = await fetch(url);
+    return await resp.json();
+  } catch {
+    return [];
+  }
+}
+async function findTargetPage(cdpEndpoint, target) {
+  const targets = await getCDPTargets(cdpEndpoint);
+  const pages = targets.filter((t) => t.url && !t.url.startsWith("about:blank") && !t.url.startsWith("chrome://"));
+  const byId = pages.find((t) => t.id === target);
+  if (byId) return { pageId: byId.id, wsUrl: byId.webSocketDebuggerUrl, title: byId.title, url: byId.url };
+  const lowerTarget = target.toLowerCase();
+  const byTitle = pages.find((t) => t.title && t.title.toLowerCase().includes(lowerTarget));
+  if (byTitle) return { pageId: byTitle.id, wsUrl: byTitle.webSocketDebuggerUrl, title: byTitle.title, url: byTitle.url };
+  const byUrl = pages.find((t) => t.url.toLowerCase().includes(lowerTarget));
+  if (byUrl) return { pageId: byUrl.id, wsUrl: byUrl.webSocketDebuggerUrl, title: byUrl.title, url: byUrl.url };
+  return null;
+}
+function resolveLaunchOpts(ctx) {
+  if (ctx.cdpEndpoint) {
+    return { cdpEndpoint: ctx.cdpEndpoint };
+  }
+  return { headless: true };
+}
+var CHROMIUM_CANDIDATES = [
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/usr/bin/chromium-browser",
+  "/usr/bin/chromium",
+  "/usr/bin/google-chrome"
+];
+function discoverChromiumPath() {
+  for (const p of CHROMIUM_CANDIDATES) {
+    if (existsSync(p)) return p;
+  }
+  return void 0;
+}
+async function createBrowser(options) {
+  if (options?.cdpEndpoint) {
+    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();
+      console.error(`[CDP Interceptor] Proxy running on ws://localhost:${proxyPort}, forwarding to ${realEndpoint}`);
+      return await chromium.connectOverCDP(`ws://localhost:${proxyPort}`);
+    }
+    return await chromium.connectOverCDP(realEndpoint);
+  }
+  const executablePath = options?.executablePath || process.env.XBROWSER_CHROMIUM_PATH || discoverChromiumPath();
+  return await chromium.launch({ executablePath, headless: options?.headless ?? true });
+}
+async function getBrowser(options) {
+  if (_sharedBrowser) return _sharedBrowser;
+  _sharedBrowser = await createBrowser(options);
+  if (options?.cdpEndpoint && options.intercept) {
+  }
+  return _sharedBrowser;
+}
+function findSession(name) {
+  for (const [, session] of sessions) {
+    if (session.name === name) return session;
+  }
+  return void 0;
+}
+function getSessionById(id) {
+  return sessions.get(id);
+}
+function setActivePage(session, page) {
+  session.page = page;
+  session.lastActivityAt = Date.now();
+}
+function saveSessionDiskMeta(name, data) {
+  ensureSessionDir();
+  const file = sessionFile(name);
+  let existing = {};
+  try {
+    existing = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+  }
+  Object.assign(existing, data, { name });
+  writeFileSync(file, JSON.stringify(existing, null, 2));
+}
+function readSessionDiskMeta(name) {
+  const file = sessionFile(name);
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function deleteSessionDiskMeta(name) {
+  const file = sessionFile(name);
+  try {
+    unlinkSync(file);
+  } catch {
+  }
+}
+async function findOrRestoreSession(name, cdpEndpoint) {
+  const inMem = findSession(name);
+  if (inMem) return inMem;
+  const meta = readSessionDiskMeta(name);
+  if (!meta) return void 0;
+  const ep = cdpEndpoint || meta.cdpEndpoint;
+  if (!ep) return void 0;
+  try {
+    const b = await createBrowser({ cdpEndpoint: ep });
+    await new Promise((r) => setTimeout(r, 500));
+    let contexts = b.contexts();
+    if (contexts.length === 0) {
+      await new Promise((r) => setTimeout(r, 500));
+      contexts = b.contexts();
+    }
+    const context = contexts[0] || await b.newContext();
+    const savedUrl = meta.conversationUrl || meta.url;
+    const targetHostname = savedUrl ? (() => {
+      try {
+        return new URL(savedUrl).hostname;
+      } catch {
+        return "";
+      }
+    })() : "";
+    let page = null;
+    let fallbackPage = 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://")) {
+          if (targetHostname && pUrl.includes(targetHostname)) {
+            page = p;
+            break;
+          }
+          if (!fallbackPage) {
+            fallbackPage = p;
+          }
+        }
+      }
+      if (page) break;
+    }
+    page = page || fallbackPage;
+    if (!page) {
+      const targets = await getCDPTargets(ep);
+      const matchTarget = targets.find(
+        (t) => t.url && t.url !== "about:blank" && !t.url.startsWith("chrome://") && (targetHostname ? t.url.includes(targetHostname) : true)
+      );
+      if (matchTarget && matchTarget.url) {
+        page = await context.newPage();
+        await page.goto(matchTarget.url, { waitUntil: "domcontentloaded", timeout: 15e3 }).catch(() => {
+        });
+      }
+    }
+    if (!page) {
+      const pages = context.pages();
+      page = pages.length > 0 ? pages[0] : await context.newPage();
+    }
+    try {
+      await Promise.race([
+        page.evaluate(() => true),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 3e3))
+      ]);
+    } catch {
+      console.log(`[Session] "${name}" restored page unresponsive, creating fresh session`);
+      deleteSessionDiskMeta(name);
+      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(() => {
+      });
+    }
+    const session = {
+      id: meta.id || randomUUID(),
+      name,
+      context,
+      page,
+      browser: b,
+      createdAt: meta.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+      lastActivityAt: Date.now(),
+      isCDP: true,
+      cdpEndpoint: ep
+    };
+    for (const [existingId, existingSession] of sessions) {
+      if (existingSession.name === name) {
+        logSessionEvent("remove_stale", `Removing stale session name="${name}" id="${existingId}" during restore`);
+        sessions.delete(existingId);
+      }
+    }
+    sessions.set(session.id, session);
+    resetIdleTimer();
+    await installNetworkCapture(page, name);
+    return session;
+  } catch (e) {
+    console.error(`[Session Restore] Failed for "${name}":`, e.message);
+    deleteSessionDiskMeta(name);
+    return void 0;
+  }
+}
+async function createEphemeralContext(options) {
+  if (options?.cdpEndpoint) {
+    const endpoint = await resolveCDPEndpoint(options.cdpEndpoint);
+    const b2 = await chromium.connectOverCDP(endpoint);
+    const contexts = b2.contexts();
+    const ctx = contexts[0] || await b2.newContext();
+    const page2 = await ctx.newPage();
+    resetIdleTimer();
+    ephemeralConnections.set(page2, b2);
+    return { context: ctx, page: page2 };
+  }
+  const b = await getBrowser(options);
+  const context = await b.newContext();
+  const page = await context.newPage();
+  resetIdleTimer();
+  return { context, page };
+}
+var ephemeralConnections = /* @__PURE__ */ new WeakMap();
+async function closeEphemeralContext(context) {
+  try {
+    const pages = context.pages();
+    for (const p of pages) {
+      const conn = ephemeralConnections.get(p);
+      if (conn) {
+        ephemeralConnections.delete(p);
+        await conn.close();
+        break;
+      }
+    }
+    await context.close();
+  } catch {
+  }
+  if (sessions.size === 0 && idleTimer) {
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  }
+}
+function getAllSessions() {
+  return Array.from(sessions.values());
+}
+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) => {
+    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;
+      }
+      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;
+            }
+          }
+        } catch {
+        }
+      }
+      let responseBody = void 0;
+      let size = 0;
+      const isJsonish = contentType.includes("json") || contentType.includes("javascript") || contentType.includes("text/");
+      if (isJsonish) {
+        try {
+          const text = await response.text();
+          size = text.length;
+          if (size <= 10240) {
+            try {
+              responseBody = JSON.parse(text);
+            } catch {
+              responseBody = text.slice(0, 200);
+            }
+          }
+        } catch {
+        }
+      } else {
+        try {
+          const text = await response.text();
+          size = text.length;
+        } catch {
+          size = 0;
+        }
+      }
+      networkStore.add(sessionName, {
+        timestamp: Date.now(),
+        method,
+        url,
+        path: new URL(url).pathname,
+        status: response.status(),
+        contentType,
+        size,
+        headers,
+        body: responseBody,
+        requestHeaders,
+        requestBody,
+        resourceType: request.resourceType()
+      });
+    } catch {
+    }
+  });
+}
+async function createSession(name, url, options) {
+  const existing = findSession(name);
+  if (existing) {
+    logSessionEvent("replace_session", `name="${name}" id="${existing.id}" \u2014 closing existing session before creating new one`);
+    await closeSessionByName(name);
+  }
+  const b = await createBrowser(options);
+  const isCDP = !!options?.cdpEndpoint;
+  let context;
+  let page;
+  if (isCDP) {
+    await new Promise((r) => setTimeout(r, 500));
+    let contexts = b.contexts();
+    if (contexts.length === 0) {
+      await new Promise((r) => setTimeout(r, 500));
+      contexts = b.contexts();
+    }
+    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;
+        }
+      }
+      if (targetPage) break;
+    }
+    if (!targetPage && options?.cdpEndpoint) {
+      const targets = await getCDPTargets(options.cdpEndpoint);
+      const matchTarget = targets.find(
+        (t) => t.url && t.url !== "about:blank" && !t.url.startsWith("chrome://") && (url ? t.url.includes(new URL(url).hostname) : true)
+      );
+      if (matchTarget && matchTarget.url) {
+        targetPage = await context.newPage();
+        await targetPage.goto(matchTarget.url, { waitUntil: "domcontentloaded", timeout: 15e3 }).catch(() => {
+        });
+      }
+    }
+    if (!targetPage) {
+      const pages = context.pages();
+      if (pages.length > 0) {
+        targetPage = pages[0];
+      } else {
+        targetPage = await context.newPage();
+      }
+    }
+    page = targetPage;
+  } else {
+    context = await b.newContext({ viewport: { width: 1920, height: 1080 } });
+    page = await context.newPage();
+  }
+  if (url && page.url() !== url) {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 15e3 }).catch(() => {
+    });
+  }
+  const session = {
+    id: randomUUID(),
+    name,
+    context,
+    page,
+    browser: b,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActivityAt: Date.now(),
+    isCDP,
+    cdpEndpoint: options?.cdpEndpoint
+  };
+  sessions.set(session.id, 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) {
+    if (session.name === name || session.id === name) {
+      logSessionEvent("close_session", `name="${session.name}" id="${session.id}" url="${session.page.url()}"`);
+      if (session.isCDP) {
+        try {
+          await session.page.close();
+        } catch {
+        }
+        if (session.browser) {
+          await session.browser.close().catch(() => {
+          });
+        }
+      } else {
+        await session.context.close();
+        if (session.browser) {
+          await session.browser.close().catch(() => {
+          });
+        }
+      }
+      sessions.delete(id);
+      const file2 = sessionFile(session.name);
+      try {
+        unlinkSync(file2);
+      } catch {
+      }
+      try {
+        const { networkStore, commandLogStore } = await import("./network-store-BN6QEZ7R.js");
+        networkStore.clear(session.name);
+        commandLogStore.clear(session.name);
+      } catch {
+      }
+      try {
+        const { SessionRecorder } = await import("./session-recorder-XET3DNML.js");
+        SessionRecorder.cleanup(session.name);
+      } catch {
+      }
+      return true;
+    }
+  }
+  const file = sessionFile(name);
+  try {
+    unlinkSync(file);
+  } catch {
+  }
+  return false;
+}
+async function closeAllSessions() {
+  const names = [...sessions.values()].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) {
+    try {
+      if (!session.isCDP) {
+        await session.context.close();
+      }
+      if (session.browser) {
+        await session.browser.close().catch(() => {
+        });
+      }
+      sessions.delete(id);
+    } catch {
+      sessions.delete(id);
+    }
+  }
+}
+async function destroyBrowser() {
+  logSessionEvent("destroy_browser", `Sessions count: ${sessions.size}. Clearing idle timer and closing all browsers.`);
+  if (idleTimer) {
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  }
+  await closeAllSessions();
+  if (_sharedBrowser) {
+    await _sharedBrowser.close().catch(() => {
+    });
+    _sharedBrowser = null;
+  }
+  if (_sharedCdpProxy) {
+    await _sharedCdpProxy.stop().catch(() => {
+    });
+    _sharedCdpProxy = null;
+  }
+}
+function resetForTesting() {
+  sessions.clear();
+  _sharedBrowser = null;
+  _sharedCdpProxy = null;
+  try {
+    for (const f of readdirSync(SESSION_DIR)) {
+      unlinkSync(join(SESSION_DIR, f));
+    }
+  } catch {
+  }
+}
+async function ensureProcessCanExit() {
+  if (idleTimer) {
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  }
+  for (const session of sessions.values()) {
+    if (session.browser) {
+      if (session.isCDP) {
+        await session.browser.close().catch(() => {
+        });
+      } else {
+        await session.browser.close().catch(() => {
+        });
+      }
+    }
+  }
+  sessions.clear();
+  if (_sharedBrowser) {
+    await _sharedBrowser.close().catch(() => {
+    });
+    _sharedBrowser = null;
+  }
+  if (_sharedCdpProxy) {
+    await _sharedCdpProxy.stop().catch(() => {
+    });
+    _sharedCdpProxy = null;
+  }
+}
+
+export {
+  touchSession,
+  findTargetPage,
+  resolveLaunchOpts,
+  createBrowser,
+  getBrowser,
+  findSession,
+  getSessionById,
+  setActivePage,
+  saveSessionDiskMeta,
+  readSessionDiskMeta,
+  deleteSessionDiskMeta,
+  findOrRestoreSession,
+  createEphemeralContext,
+  closeEphemeralContext,
+  getAllSessions,
+  createSession,
+  closeSessionByName,
+  closeAllSessions,
+  destroyBrowser,
+  resetForTesting,
+  ensureProcessCanExit
+};