@xbrowser/cli 1.0.0 → 1.0.2

package/dist/{chunk-E4O5ZU3H.js → chunk-CAFNSGYM.js}

@@ -1,10 +1,10 @@
 import {
   connectToCDP,
   launchChrome
-} from "./chunk-T4J4C2NZ.js";
+} from "./chunk-BBMRDUYQ.js";
 import {
   __require
-} from "./chunk-3RG5ZIWI.js";
+} from "./chunk-KFQGP6VL.js";
 
 // src/browser.ts
 import { randomUUID } from "crypto";
@@ -250,36 +250,36 @@ function resolveKeyMapping(key) {
   return { key, code: key };
 }
 var KEY_MAP = {
-  Enter: { key: "Enter", code: "Enter", text: "\r" },
-  Tab: { key: "Tab", code: "Tab", text: "	" },
-  Escape: { key: "Escape", code: "Escape" },
-  Backspace: { key: "Backspace", code: "Backspace" },
-  Delete: { key: "Delete", code: "Delete" },
-  Space: { key: " ", code: "Space", text: " " },
-  ArrowUp: { key: "ArrowUp", code: "ArrowUp" },
-  ArrowDown: { key: "ArrowDown", code: "ArrowDown" },
-  ArrowLeft: { key: "ArrowLeft", code: "ArrowLeft" },
-  ArrowRight: { key: "ArrowRight", code: "ArrowRight" },
-  Home: { key: "Home", code: "Home" },
-  End: { key: "End", code: "End" },
-  PageUp: { key: "PageUp", code: "PageUp" },
-  PageDown: { key: "PageDown", code: "PageDown" },
-  Control: { key: "Control", code: "ControlLeft" },
-  Shift: { key: "Shift", code: "ShiftLeft" },
-  Alt: { key: "Alt", code: "AltLeft" },
-  Meta: { key: "Meta", code: "MetaLeft" },
-  F1: { key: "F1", code: "F1" },
-  F2: { key: "F2", code: "F2" },
-  F3: { key: "F3", code: "F3" },
-  F4: { key: "F4", code: "F4" },
-  F5: { key: "F5", code: "F5" },
-  F6: { key: "F6", code: "F6" },
-  F7: { key: "F7", code: "F7" },
-  F8: { key: "F8", code: "F8" },
-  F9: { key: "F9", code: "F9" },
-  F10: { key: "F10", code: "F10" },
-  F11: { key: "F11", code: "F11" },
-  F12: { key: "F12", code: "F12" }
+  Enter: { key: "Enter", code: "Enter", text: "\r", keyCode: 13 },
+  Tab: { key: "Tab", code: "Tab", text: "	", keyCode: 9 },
+  Escape: { key: "Escape", code: "Escape", keyCode: 27 },
+  Backspace: { key: "Backspace", code: "Backspace", keyCode: 8 },
+  Delete: { key: "Delete", code: "Delete", keyCode: 46 },
+  Space: { key: " ", code: "Space", text: " ", keyCode: 32 },
+  ArrowUp: { key: "ArrowUp", code: "ArrowUp", keyCode: 38 },
+  ArrowDown: { key: "ArrowDown", code: "ArrowDown", keyCode: 40 },
+  ArrowLeft: { key: "ArrowLeft", code: "ArrowLeft", keyCode: 37 },
+  ArrowRight: { key: "ArrowRight", code: "ArrowRight", keyCode: 39 },
+  Home: { key: "Home", code: "Home", keyCode: 36 },
+  End: { key: "End", code: "End", keyCode: 35 },
+  PageUp: { key: "PageUp", code: "PageUp", keyCode: 33 },
+  PageDown: { key: "PageDown", code: "PageDown", keyCode: 34 },
+  Control: { key: "Control", code: "ControlLeft", keyCode: 17 },
+  Shift: { key: "Shift", code: "ShiftLeft", keyCode: 16 },
+  Alt: { key: "Alt", code: "AltLeft", keyCode: 18 },
+  Meta: { key: "Meta", code: "MetaLeft", keyCode: 91 },
+  F1: { key: "F1", code: "F1", keyCode: 112 },
+  F2: { key: "F2", code: "F2", keyCode: 113 },
+  F3: { key: "F3", code: "F3", keyCode: 114 },
+  F4: { key: "F4", code: "F4", keyCode: 115 },
+  F5: { key: "F5", code: "F5", keyCode: 116 },
+  F6: { key: "F6", code: "F6", keyCode: 117 },
+  F7: { key: "F7", code: "F7", keyCode: 118 },
+  F8: { key: "F8", code: "F8", keyCode: 119 },
+  F9: { key: "F9", code: "F9", keyCode: 120 },
+  F10: { key: "F10", code: "F10", keyCode: 121 },
+  F11: { key: "F11", code: "F11", keyCode: 122 },
+  F12: { key: "F12", code: "F12", keyCode: 123 }
 };
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -974,7 +974,7 @@ function createXBRequest(page, data) {
     }
   };
 }
-function createXBRouteFetch(conn, sessionId, params) {
+function createXBRouteFetch(conn, sessionId, params, emitter) {
   const request = createXBRequest(null, {
     requestId: params.requestId,
     url: params.request.url,
@@ -1012,6 +1012,16 @@ function createXBRouteFetch(conn, sessionId, params) {
         responseHeaders: Object.entries(headers).map(([k, v]) => ({ name: k, value: v })),
         body: bodyBytes.toString("base64")
       }, sessionId);
+      if (emitter) {
+        const responseData = {
+          requestId: params.requestId,
+          status: opts.status ?? 200,
+          url: params.request.url,
+          headers
+        };
+        const response = createXBResponse(responseData, conn, sessionId);
+        emitter.emit("response", response);
+      }
     }
   };
 }
@@ -1233,6 +1243,25 @@ Last error: ${lastError.message}` : "";
     }
     return result.result?.value;
   }
+  /** evaluateHandle — evaluates fn and returns a handle for element bounding box */
+  async evaluateHandle(fn, ...args) {
+    let expression;
+    if (typeof fn === "string") {
+      expression = fn;
+    } else {
+      const argStr = args.length > 0 ? `...${JSON.stringify(args)}` : "";
+      expression = `(()=>{const __fn=(${fn.toString()});const __el=__fn(${argStr});if(__el&&typeof __el.getBoundingClientRect==='function'){const r=__el.getBoundingClientRect();return JSON.parse(JSON.stringify({x:r.x,y:r.y,w:r.width,h:r.height}));}return null;})()`;
+    }
+    const result = await this.conn.send("Runtime.evaluate", { expression, returnByValue: true }).catch(() => ({ result: { value: null } }));
+    let box = null;
+    try {
+      box = JSON.parse(result.result?.value);
+    } catch {
+    }
+    return {
+      asElement: () => box ? { boundingBox: async () => box } : null
+    };
+  }
   async $eval(selector, fn, ...args) {
     const fnBody = typeof fn === "function" ? fn.toString() : fn;
     return this.evaluate(
@@ -1448,6 +1477,26 @@ Last error: ${lastError.message}` : "";
   off(event, handler) {
     this._emitter.off(event, handler);
   }
+  /**
+   * Wait for a one-shot event (Playwright-compatible subset).
+   * Used to listen for 'filechooser', 'dialog', 'popup', 'framenavigated', etc.
+   */
+  async waitForEvent(event, opts = {}) {
+    const timeout = opts.timeout ?? 3e4;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._emitter.off(event, handler);
+        reject(new Error(`waitForEvent('${event}') timeout after ${timeout}ms`));
+      }, timeout);
+      const handler = (...args) => {
+        if (opts.predicate && !opts.predicate(...args)) return;
+        clearTimeout(timer);
+        this._emitter.off(event, handler);
+        resolve(args.length === 1 ? args[0] : args);
+      };
+      this._emitter.on(event, handler);
+    });
+  }
   // ── Lifecycle ───────────────────────────────────────────────
   async close() {
     if (this._closed) return;
@@ -1611,6 +1660,40 @@ Last error: ${lastError.message}` : "";
         this._emit("dialog", dialog);
       })
     );
+    this._subscriptions.push(
+      this.conn.subscribe("Page.fileChooserOpened", this.sessionId, async (params) => {
+        const p = params;
+        let selector = "";
+        try {
+          const result = await this.conn.send("DOM.describeNode", { backendNodeId: p.backendNodeId }, this.sessionId);
+          const attrs = result.node?.attributes || [];
+          const idIdx = attrs.indexOf("id");
+          if (idIdx >= 0) selector = "#" + attrs[idIdx + 1];
+        } catch {
+        }
+        if (!selector) {
+          try {
+            const result = await this.conn.send("DOM.resolveNode", { backendNodeId: p.backendNodeId }, this.sessionId);
+            const evalResult = await this.conn.send("Runtime.callFunctionOn", {
+              objectId: result.objectId,
+              functionDeclaration: 'function() { return this.id || this.name || "" }',
+              returnByValue: true
+            }, this.sessionId);
+            if (evalResult.result?.value) selector = "#" + evalResult.result.value;
+          } catch {
+          }
+        }
+        const fileChooser = {
+          selector,
+          isMultiple: p.mode === "selectMultiple",
+          setFiles: async (files) => {
+            const fileArray = Array.isArray(files) ? files : [files];
+            await this.setInputFiles(selector || 'input[type="file"]', fileArray);
+          }
+        };
+        this._emit("filechooser", fileChooser);
+      })
+    );
   }
   setupNetworkEvents() {
     this._subscriptions.push(
@@ -1624,7 +1707,17 @@ Last error: ${lastError.message}` : "";
           postData: p.request.postData ?? null,
           resourceType: p.type
         });
-        this._emit("request", p);
+        this._emit("request", createXBRequest(
+          null,
+          {
+            requestId: p.requestId,
+            url: p.request.url,
+            method: p.request.method,
+            headers: p.request.headers,
+            postData: p.request.postData ?? null,
+            resourceType: p.type
+          }
+        ));
         this.checkNetworkIdle();
       })
     );
@@ -1636,7 +1729,11 @@ Last error: ${lastError.message}` : "";
           url: p.response.url,
           headers: p.response.headers
         });
-        this._emit("response", p);
+        this._emit("response", createXBResponse(
+          { requestId: p.requestId, status: p.response.status, url: p.response.url, headers: p.response.headers },
+          this.conn,
+          this.sessionId
+        ));
       })
     );
     this._subscriptions.push(
@@ -1722,14 +1819,21 @@ Last error: ${lastError.message}` : "";
         reject(new Error(`waitForResponse timed out after ${timeout}ms`));
       }, timeout);
       const handler = (params) => {
-        const p = params;
-        const data = {
-          requestId: p.requestId,
-          status: p.response.status,
-          url: p.response.url,
-          headers: p.response.headers
-        };
-        const response = createXBResponse(data, this.conn, this.sessionId);
+        let response;
+        const respObj = params;
+        if (respObj.response) {
+          const data = {
+            requestId: respObj.requestId || "",
+            status: respObj.response.status || 0,
+            url: respObj.response.url || "",
+            headers: respObj.response.headers || {}
+          };
+          response = createXBResponse(data, this.conn, this.sessionId);
+        } else if (typeof params.status === "function") {
+          response = params;
+        } else {
+          return;
+        }
         if (predicate(response)) {
           clearTimeout(timer);
           this._emitter.removeListener("response", handler);
@@ -1753,16 +1857,22 @@ Last error: ${lastError.message}` : "";
         reject(new Error(`waitForRequest timed out after ${timeout}ms`));
       }, timeout);
       const handler = (params) => {
-        const p = params;
-        const data = {
-          requestId: p.requestId,
-          url: p.request.url,
-          method: p.request.method,
-          headers: p.request.headers,
-          postData: p.request.postData ?? null,
-          resourceType: p.type
-        };
-        const request = createXBRequest(this, data);
+        let request;
+        const reqObj = params;
+        if (reqObj.request) {
+          request = createXBRequest(this, {
+            requestId: reqObj.requestId || "",
+            url: reqObj.request.url || "",
+            method: reqObj.request.method || "",
+            headers: reqObj.request.headers || {},
+            postData: reqObj.request.postData ?? null,
+            resourceType: reqObj.type || ""
+          });
+        } else if (typeof params.url === "function") {
+          request = params;
+        } else {
+          return;
+        }
         if (predicate(request)) {
           clearTimeout(timer);
           this._emitter.removeListener("request", handler);
@@ -1823,7 +1933,18 @@ Last error: ${lastError.message}` : "";
     const requestUrl = params.request.url;
     for (const { regex, handler } of this._routeHandlers) {
       if (regex.test(requestUrl)) {
-        const route = createXBRouteFetch(this.conn, this.sessionId, params);
+        this._emit("request", createXBRequest(
+          null,
+          {
+            requestId: params.requestId,
+            url: params.request.url,
+            method: params.request.method,
+            headers: params.request.headers,
+            postData: params.request.postData ?? null,
+            resourceType: params.resourceType
+          }
+        ));
+        const route = createXBRouteFetch(this.conn, this.sessionId, params, this._emitter);
         try {
           await handler(route);
         } catch {
@@ -1990,6 +2111,7 @@ var XBContextImpl = class {
     const page = new XBPageImpl(this.conn, sessionId, targetId, this, this._browser);
     await page._init();
     this._pages.push(page);
+    this.forwardPageEvents(page);
     if (this.options.viewport) {
       await page.setViewportSize(this.options.viewport).catch(() => {
       });
@@ -2031,7 +2153,10 @@ var XBContextImpl = class {
     }
     this._browser._removeContext(this.contextId);
   }
-  async newCDPSession(_page) {
+  async newCDPSession(page) {
+    if (page instanceof XBPageImpl) {
+      return new XBCDPSessionImpl(this.conn, page.sessionId);
+    }
     return new XBCDPSessionImpl(this.conn);
   }
   async addInitScript(script) {
@@ -2068,7 +2193,31 @@ var XBContextImpl = class {
   off(event, handler) {
     this._emitter.off(event, handler);
   }
+  /**
+   * Register a page that was attached to an existing target (discovered via
+   * Target.getTargets). Used by XBBrowserImpl.discoverContexts() to wire up
+   * pages from the user's existing browser session into the context wrapper
+   * so they appear in `context.pages()` and can be reused by plugins.
+   */
+  _addDiscoveredPage(page) {
+    const exists = this._pages.some((p) => p._targetId === page._targetId);
+    if (exists) return;
+    this._pages.push(page);
+    this.forwardPageEvents(page);
+  }
   // ── Private ─────────────────────────────────────────────────
+  /** Forward page-level events (request, response, etc.) to context listeners */
+  forwardPageEvents(page) {
+    const forward = (event) => {
+      page.on(event, (...args) => {
+        this._emitter.emit(event, ...args);
+      });
+    };
+    forward("request");
+    forward("response");
+    forward("requestfailed");
+    forward("requestfinished");
+  }
   setupAutoAttach() {
     this.targetAttachedHandler = (paramsRaw) => {
       const params = paramsRaw;
@@ -2093,6 +2242,7 @@ var XBContextImpl = class {
           });
         }
         this._pages.push(page);
+        this.forwardPageEvents(page);
         this._emitter.emit("page", page);
       });
     };
@@ -2109,10 +2259,17 @@ var XBBrowserImpl = class {
   childProcess = null;
   tmpDir;
   _exitHandler = null;
-  constructor(conn, childProcess, tmpDir) {
+  /**
+   * Original CDP endpoint (HTTP or ws URL) used to construct this browser.
+   * Used by discoverContexts() as a fallback to HTTP /json/list when
+   * Target.getTargets doesn't return page-type targets (e.g. cdp-tunnel proxy).
+   */
+  cdpEndpoint;
+  constructor(conn, childProcess, tmpDir, cdpEndpoint) {
     this.conn = conn;
     this.childProcess = childProcess ?? null;
     this.tmpDir = tmpDir;
+    this.cdpEndpoint = cdpEndpoint;
     conn.on("disconnect", () => {
       this._disconnected = true;
       this._emitter.emit("disconnected");
@@ -2156,7 +2313,7 @@ var XBBrowserImpl = class {
       this._exitHandler = null;
     }
     if (this.childProcess) {
-      const { killChrome: killChrome2 } = await import("./launcher-KA7J32K5.js");
+      const { killChrome: killChrome2 } = await import("./launcher-QUJ4M2VS.js");
       await killChrome2(this.childProcess, this.tmpDir);
     }
     await this.conn.close();
@@ -2186,6 +2343,10 @@ var XBBrowserImpl = class {
       contextId,
       context
     });
+    if (this.childProcess) {
+      this._enableAutoAttach().catch(() => {
+      });
+    }
     return context;
   }
   contexts() {
@@ -2214,6 +2375,23 @@ var XBBrowserImpl = class {
   async _detachFromTarget(sessionId) {
     await this.conn.send("Target.detachFromTarget", { sessionId });
   }
+  /**
+   * Derive the HTTP /json base URL from the original cdpEndpoint for use
+   * as a fallback when Target.getTargets doesn't return page targets.
+   * Supports both http:// and ws:// input formats.
+   */
+  _httpFallbackURL() {
+    if (!this.cdpEndpoint) return void 0;
+    if (this.cdpEndpoint.startsWith("http://") || this.cdpEndpoint.startsWith("https://")) {
+      return this.cdpEndpoint;
+    }
+    if (this.cdpEndpoint.startsWith("ws://") || this.cdpEndpoint.startsWith("wss://")) {
+      const url = this.cdpEndpoint.replace(/^ws/, "http");
+      const slashIdx = url.indexOf("/", url.indexOf("//") + 2);
+      return slashIdx >= 0 ? url.substring(0, slashIdx) : url;
+    }
+    return void 0;
+  }
   /** Create a new page target within a browser context */
   async _createTarget(contextId, url = "about:blank") {
     const params = { url };
@@ -2230,10 +2408,97 @@ var XBBrowserImpl = class {
   async _enableAutoAttach() {
     await this.conn.send("Target.setAutoAttach", {
       autoAttach: true,
-      waitForDebuggerOnStart: true,
+      waitForDebuggerOnStart: false,
       flatten: true
     });
   }
+  /**
+   * Discover existing browser contexts and pages via Target.getTargets.
+   *
+   * For CDP tunnel connections (cdp-tunnel, attach scenarios), the
+   * Target.attachedToTarget auto-attach flow is unreliable. Without this
+   * call, `b.contexts()` would return [] and callers would fall back to
+   * `b.newContext()` — which creates an isolated context with NO cookies
+   * shared with the user's existing browser session (causing login failures).
+   *
+   * This method:
+   *  1. Queries Target.getTargets to enumerate all page targets
+   *  2. Groups them by browserContextId
+   *  3. Attaches to each existing page via Target.attachToTarget
+   *  4. Wraps the discovered pages in a XBContextImpl and registers it in
+   *     this._contexts so `contexts()` returns the user's actual contexts
+   *  5. Enables Target.setAutoAttach for future pages
+   *
+   * No-op for self-launched browsers (they already populated contexts via
+   * newContext() + childProcess-gated auto-attach).
+   */
+  async discoverContexts() {
+    if (this._disconnected) return;
+    let targetInfos = [];
+    try {
+      const result = await this.conn.send(
+        "Target.getTargets"
+      );
+      targetInfos = result.targetInfos ?? [];
+    } catch {
+      return;
+    }
+    const pageTargets = targetInfos.filter((t) => t.type === "page");
+    const httpFallbackUrl = this._httpFallbackURL();
+    if (pageTargets.length === 0 && httpFallbackUrl) {
+      console.log(`[discoverContexts] Target.getTargets returned ${targetInfos.length} targets (0 page type). Falling back to HTTP /json/list at ${httpFallbackUrl}`);
+      try {
+        const { getCDPTargets: getCDPTargets3 } = await import("./launcher-QUJ4M2VS.js");
+        const httpPages = await getCDPTargets3(httpFallbackUrl);
+        console.log(`[discoverContexts] HTTP /json/list returned ${httpPages.length} pages`);
+        for (const p of httpPages) {
+          if (p.type !== "page") continue;
+          if (!p.url || p.url.startsWith("chrome://") || p.url.startsWith("devtools://")) continue;
+          targetInfos.push({
+            targetId: p.id,
+            type: "page",
+            url: p.url,
+            title: p.title
+          });
+        }
+        console.log(`[discoverContexts] After HTTP fallback: ${targetInfos.length} total targets, ${targetInfos.filter((t) => t.type === "page").length} pages`);
+      } catch (err) {
+        console.log(`[discoverContexts] HTTP fallback failed: ${err.message}`);
+      }
+    }
+    const pagesByContext = /* @__PURE__ */ new Map();
+    for (const t of targetInfos) {
+      if (t.type !== "page") continue;
+      if (!t.url || t.url.startsWith("chrome://") || t.url.startsWith("devtools://")) {
+        continue;
+      }
+      const ctxId = t.browserContextId || "default";
+      if (!pagesByContext.has(ctxId)) pagesByContext.set(ctxId, []);
+      pagesByContext.get(ctxId).push(t);
+    }
+    for (const [ctxId, pages] of pagesByContext) {
+      if (this._contexts.has(ctxId)) continue;
+      const context = new XBContextImpl(this.conn, ctxId, this, {});
+      for (const p of pages) {
+        try {
+          const sessionId = await this._attachToTarget(p.targetId);
+          const page = new XBPageImpl(this.conn, sessionId, p.targetId, context, this);
+          await page._init();
+          context._addDiscoveredPage(page);
+        } catch {
+        }
+      }
+      this._contexts.set(ctxId, { contextId: ctxId, context });
+    }
+    try {
+      await this.conn.send("Target.setAutoAttach", {
+        autoAttach: true,
+        waitForDebuggerOnStart: false,
+        flatten: true
+      });
+    } catch {
+    }
+  }
 };
 
 // src/cdp-driver/connection.ts
@@ -2453,7 +2718,8 @@ async function launch(options = {}) {
   }
   const conn = new CDPConnection(wsEndpoint);
   await conn.ready();
-  const browser = new XBBrowserImpl(conn, childProcess, tmpDir);
+  const httpEndpoint = options.cdpEndpoint && !options.cdpEndpoint.startsWith("ws") ? options.cdpEndpoint : void 0;
+  const browser = new XBBrowserImpl(conn, childProcess, tmpDir, httpEndpoint);
   return { browser, wsEndpoint };
 }
 
@@ -3879,6 +4145,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;
@@ -3891,7 +4158,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;
@@ -3902,7 +4169,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 {
@@ -3925,7 +4192,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 {
@@ -4015,6 +4282,9 @@ async function createBrowser(options) {
       return browser3;
     }
     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();
@@ -4029,10 +4299,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);
@@ -4136,9 +4403,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(),
@@ -4151,13 +4423,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;
@@ -4173,7 +4445,12 @@ async function createEphemeralContext(options) {
     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 };
@@ -4205,11 +4482,11 @@ 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-66A2RATI.js");
+  const { networkStore } = await import("./network-store-YVDNUREI.js");
   const requestData = /* @__PURE__ */ new Map();
   const responseMeta = /* @__PURE__ */ new Map();
   const xbPage = page;
@@ -4330,16 +4607,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 getCDPTargets2(options.cdpEndpoint);
@@ -4380,14 +4679,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) {
@@ -4406,20 +4705,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-66A2RATI.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-MA75PKTQ.js");
+        const { SessionRecorder } = await import("./session-recorder-RTDGURIJ.js");
         SessionRecorder.cleanup(session.name);
       } catch {
       }
@@ -4434,9 +4733,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();
@@ -4445,9 +4744,9 @@ async function closeAllSessions() {
         await session.browser.close().catch(() => {
         });
       }
-      sessions.delete(id);
+      sessions.removeById(session.id);
     } catch {
-      sessions.delete(id);
+      sessions.removeById(session.id);
     }
   }
 }
@@ -4485,7 +4784,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(() => {
@@ -4511,7 +4810,6 @@ async function ensureProcessCanExit() {
 
 export {
   createRuleEngine,
-  resolveCDPEndpoint,
   touchSession,
   findTargetPage,
   resolveLaunchOpts,