@xbrowser/cli 1.0.0 → 1.0.2

package/dist/{chunk-42RPMJ76.js → chunk-PPG4D2EW.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/cdp-driver/browser.ts
 import { EventEmitter as EventEmitter3 } from "events";
@@ -244,36 +244,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));
@@ -968,7 +968,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,
@@ -1006,6 +1006,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);
+      }
     }
   };
 }
@@ -1227,6 +1237,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(
@@ -1442,6 +1471,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;
@@ -1605,6 +1654,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(
@@ -1618,7 +1701,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();
       })
     );
@@ -1630,7 +1723,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(
@@ -1716,14 +1813,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);
@@ -1747,16 +1851,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);
@@ -1817,7 +1927,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 {
@@ -1984,6 +2105,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(() => {
       });
@@ -2025,7 +2147,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) {
@@ -2062,7 +2187,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;
@@ -2087,6 +2236,7 @@ var XBContextImpl = class {
           });
         }
         this._pages.push(page);
+        this.forwardPageEvents(page);
         this._emitter.emit("page", page);
       });
     };
@@ -2103,10 +2253,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");
@@ -2150,7 +2307,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();
@@ -2180,6 +2337,10 @@ var XBBrowserImpl = class {
       contextId,
       context
     });
+    if (this.childProcess) {
+      this._enableAutoAttach().catch(() => {
+      });
+    }
     return context;
   }
   contexts() {
@@ -2208,6 +2369,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 };
@@ -2224,10 +2402,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: getCDPTargets2 } = await import("./launcher-QUJ4M2VS.js");
+        const httpPages = await getCDPTargets2(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
@@ -2507,7 +2772,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 };
 }
 

package/dist/{chunk-IDVD44ED.js → chunk-Q4IGYTKR.js}

@@ -110,6 +110,12 @@ async function ensureDaemonRunning() {
     _ensurePromise = null;
     throw new Error("Daemon not available");
   }
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const ready = await fetch(`${DAEMON_BASE}/health`, { signal: AbortSignal.timeout(1e3) }).then((r) => r.ok ? r.json() : null).then((d) => d?.status === "ok").catch(() => false);
+    if (ready) return;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  throw new Error("Daemon HTTP server not ready after 4s");
 }
 async function rpcCall(method, params = {}, timeoutMs = 1e4) {
   await ensureDaemonRunning();
@@ -120,7 +126,13 @@ async function rpcCall(method, params = {}, timeoutMs = 1e4) {
     signal: AbortSignal.timeout(timeoutMs)
   });
   if (!resp.ok) {
-    throw new Error(`Daemon error: ${resp.statusText}`);
+    let detail = resp.statusText;
+    try {
+      const body = await resp.json();
+      if (body?.error) detail = body.error;
+    } catch {
+    }
+    throw new Error(`Daemon error: ${detail}`);
   }
   return resp.json();
 }
@@ -157,8 +169,8 @@ async function forwardExec(command, params, session = "default", cdpEndpoint, ti
   if (cdpEndpoint) rpcParams.cdpEndpoint = cdpEndpoint;
   try {
     return await rpcCall("exec", rpcParams, timeoutMs);
-  } catch {
-    return { success: false, data: null, message: `Daemon error: exec failed`, duration: 0 };
+  } catch (e) {
+    return { success: false, data: null, message: e.message, duration: 0 };
   }
 }
 async function forwardChain(input, session = "default", cdpEndpoint) {
@@ -166,8 +178,8 @@ async function forwardChain(input, session = "default", cdpEndpoint) {
   if (cdpEndpoint) params.cdpEndpoint = cdpEndpoint;
   try {
     return await rpcCall("chain", params, 12e4);
-  } catch {
-    return { success: false, steps: [], totalDuration: 0, stoppedReason: "Daemon error" };
+  } catch (e) {
+    return { success: false, steps: [], totalDuration: 0, stoppedReason: e.message };
   }
 }
 async function forwardAgentObserve(session = "default", options) {
@@ -223,8 +235,8 @@ async function forwardNetworkExport(sessionName, id, lang) {
 async function forwardNetworkInspect(sessionName, id) {
   return rpcCall("network:inspect", { session: sessionName, id }, 1e4);
 }
-async function forwardRecordStart(session, url) {
-  return rpcCall("record:start", { session, url }, 15e3);
+async function forwardRecordStart(session, url, cdpEndpoint) {
+  return rpcCall("record:start", { session, url, cdpEndpoint }, 15e3);
 }
 async function forwardRecordStop(session) {
   return rpcCall("record:stop", { session }, 1e4);