@monoes/monobrowse 1.0.9 → 1.0.12

package/src/browser/adapters/gemini.ts

@@ -1,5 +1,5 @@
 // src/browser/adapters/gemini.ts
-import type { PlatformAdapter, PageInterface } from './index.js';
+import type { PageInterface, PlatformAdapter } from './index.js';
 
 export const geminiAdapter: PlatformAdapter = {
   platform: 'gemini',
@@ -7,9 +7,13 @@ export const geminiAdapter: PlatformAdapter = {
   reservedPaths: ['/app', '/chat'],
   loginURL: () => 'https://accounts.google.com/signin/v2/identifier',
   async isLoggedIn(page: PageInterface): Promise<boolean> {
-    return page.evaluate<boolean>("!!(document.querySelector('bard-sidenav') || document.querySelector('.ql-editor'))");
+    return page.evaluate<boolean>(
+      "!!(document.querySelector('bard-sidenav') || document.querySelector('.ql-editor'))",
+    );
   },
   async extractUsername(page: PageInterface): Promise<string> {
-    return page.evaluate<string>("document.querySelector('.gb_A.gb_Sa')?.textContent?.trim() ?? ''");
+    return page.evaluate<string>(
+      "document.querySelector('.gb_A.gb_Sa')?.textContent?.trim() ?? ''",
+    );
   },
 };

package/src/browser/adapters/google.ts

@@ -1,5 +1,5 @@
 // src/browser/adapters/google.ts
-import type { PlatformAdapter, PageInterface } from './index.js';
+import type { PageInterface, PlatformAdapter } from './index.js';
 
 export const googleAdapter: PlatformAdapter = {
   platform: 'google',
@@ -10,11 +10,13 @@ export const googleAdapter: PlatformAdapter = {
     const url = await page.url();
     // Logged in if we're on a Google service page (not the sign-in page)
     if (url.includes('accounts.google.com/signin')) return false;
-    return page.evaluate<boolean>("!!(document.querySelector('[aria-label*=\"Google Account\"]') || document.querySelector('.gb_A') || document.cookie.includes('SSID'))");
+    return page.evaluate<boolean>(
+      "!!(document.querySelector('[aria-label*=\"Google Account\"]') || document.querySelector('.gb_A') || document.cookie.includes('SSID'))",
+    );
   },
   async extractUsername(page: PageInterface): Promise<string> {
     return page.evaluate<string>(
-      "document.querySelector('[data-email]')?.getAttribute('data-email') ?? document.querySelector('.gb_A.gb_Sa')?.textContent?.trim() ?? ''"
+      "document.querySelector('[data-email]')?.getAttribute('data-email') ?? document.querySelector('.gb_A.gb_Sa')?.textContent?.trim() ?? ''",
     );
   },
 };

package/src/browser/adapters/index.ts

@@ -14,12 +14,12 @@ export interface PlatformAdapter {
   extractUsername(page: PageInterface): Promise<string>;
 }
 
-import { linkedinAdapter } from './linkedin.js';
-import { instagramAdapter } from './instagram.js';
-import { xAdapter } from './x.js';
 import { geminiAdapter } from './gemini.js';
 import { googleAdapter } from './google.js';
+import { instagramAdapter } from './instagram.js';
+import { linkedinAdapter } from './linkedin.js';
 import { microsoftAdapter } from './microsoft.js';
+import { xAdapter } from './x.js';
 
 export const adapters: Map<string, PlatformAdapter> = new Map([
   ['linkedin', linkedinAdapter],
@@ -32,6 +32,7 @@ export const adapters: Map<string, PlatformAdapter> = new Map([
 
 export function getAdapter(platform: string): PlatformAdapter {
   const adapter = adapters.get(platform);
-  if (!adapter) throw new Error(`Unknown platform: ${platform}. Supported: ${[...adapters.keys()].join(', ')}`);
+  if (!adapter)
+    throw new Error(`Unknown platform: ${platform}. Supported: ${[...adapters.keys()].join(', ')}`);
   return adapter;
 }

package/src/browser/adapters/instagram.ts

@@ -1,5 +1,5 @@
 // src/browser/adapters/instagram.ts
-import type { PlatformAdapter, PageInterface } from './index.js';
+import type { PageInterface, PlatformAdapter } from './index.js';
 
 export const instagramAdapter: PlatformAdapter = {
   platform: 'instagram',
@@ -11,6 +11,8 @@ export const instagramAdapter: PlatformAdapter = {
   },
   async extractUsername(page: PageInterface): Promise<string> {
     // Use getAttribute to get the raw path-relative href (not the resolved absolute URL)
-    return page.evaluate<string>("document.querySelector('a[href^=\"/\"]')?.getAttribute('href')?.split('/').filter(Boolean)[0] ?? ''");
+    return page.evaluate<string>(
+      "document.querySelector('a[href^=\"/\"]')?.getAttribute('href')?.split('/').filter(Boolean)[0] ?? ''",
+    );
   },
 };

package/src/browser/adapters/linkedin.ts

@@ -1,5 +1,5 @@
 // src/browser/adapters/linkedin.ts
-import type { PlatformAdapter, PageInterface } from './index.js';
+import type { PageInterface, PlatformAdapter } from './index.js';
 
 export const linkedinAdapter: PlatformAdapter = {
   platform: 'linkedin',
@@ -10,6 +10,8 @@ export const linkedinAdapter: PlatformAdapter = {
     return page.evaluate<boolean>("!!document.querySelector('.global-nav__me-photo')");
   },
   async extractUsername(page: PageInterface): Promise<string> {
-    return page.evaluate<string>("document.querySelector('.profile-rail-card__actor-link')?.textContent?.trim() ?? ''");
+    return page.evaluate<string>(
+      "document.querySelector('.profile-rail-card__actor-link')?.textContent?.trim() ?? ''",
+    );
   },
 };

package/src/browser/adapters/microsoft.ts

@@ -1,19 +1,23 @@
 // src/browser/adapters/microsoft.ts
-import type { PlatformAdapter, PageInterface } from './index.js';
+import type { PageInterface, PlatformAdapter } from './index.js';
 
 export const microsoftAdapter: PlatformAdapter = {
   platform: 'microsoft',
   baseURL: 'https://login.microsoftonline.com',
   reservedPaths: ['/oauth2', '/common/oauth2', '/kmsi'],
-  loginURL: () => 'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id=common&response_type=code&scope=openid+profile+email',
+  loginURL: () =>
+    'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id=common&response_type=code&scope=openid+profile+email',
   async isLoggedIn(page: PageInterface): Promise<boolean> {
     const url = await page.url();
-    if (url.includes('login.microsoftonline.com') || url.includes('login.microsoft.com')) return false;
-    return page.evaluate<boolean>("!!(document.querySelector('[data-tid=\"user-email\"]') || document.querySelector('.mectrl_currentAccount') || document.cookie.includes('ESTSAUTH'))");
+    if (url.includes('login.microsoftonline.com') || url.includes('login.microsoft.com'))
+      return false;
+    return page.evaluate<boolean>(
+      "!!(document.querySelector('[data-tid=\"user-email\"]') || document.querySelector('.mectrl_currentAccount') || document.cookie.includes('ESTSAUTH'))",
+    );
   },
   async extractUsername(page: PageInterface): Promise<string> {
     return page.evaluate<string>(
-      "document.querySelector('[data-tid=\"user-email\"]')?.textContent?.trim() ?? document.querySelector('.mectrl_headerEmail')?.textContent?.trim() ?? ''"
+      "document.querySelector('[data-tid=\"user-email\"]')?.textContent?.trim() ?? document.querySelector('.mectrl_headerEmail')?.textContent?.trim() ?? ''",
     );
   },
 };

package/src/browser/adapters/x.ts

@@ -1,5 +1,5 @@
 // src/browser/adapters/x.ts
-import type { PlatformAdapter, PageInterface } from './index.js';
+import type { PageInterface, PlatformAdapter } from './index.js';
 
 export const xAdapter: PlatformAdapter = {
   platform: 'x',
@@ -7,9 +7,13 @@ export const xAdapter: PlatformAdapter = {
   reservedPaths: ['/home', '/explore', '/notifications', '/messages'],
   loginURL: () => 'https://x.com/i/flow/login',
   async isLoggedIn(page: PageInterface): Promise<boolean> {
-    return page.evaluate<boolean>('!!document.querySelector(\'[data-testid="SideNav_AccountSwitcher_Button"]\')');
+    return page.evaluate<boolean>(
+      '!!document.querySelector(\'[data-testid="SideNav_AccountSwitcher_Button"]\')',
+    );
   },
   async extractUsername(page: PageInterface): Promise<string> {
-    return page.evaluate<string>("document.querySelector('[data-testid=\"SideNav_AccountSwitcher_Button\"] span')?.textContent?.trim() ?? ''");
+    return page.evaluate<string>(
+      "document.querySelector('[data-testid=\"SideNav_AccountSwitcher_Button\"] span')?.textContent?.trim() ?? ''",
+    );
   },
 };

package/src/browser/browser.ts

@@ -1,14 +1,14 @@
-import { spawn, execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { connect } from 'net';
-import { CdpClient, fetchTargets, fetchNewTarget } from './cdp.js';
-import type { BrowserConfig, CdpTarget } from './types.js';
-import { CHROME_EXECUTABLES } from './types.js';
+import { execSync, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { connect } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CdpClient, fetchNewTarget, fetchTargets } from './cdp.js';
 import { enableConsoleCapture, setupConsoleCapture } from './console-log.js';
 import { setupDialogAutoHandling } from './dialog.js';
-import { loadActivePortInfo } from './ref-cache.js';
+import { clearActivePort, loadActivePortInfo } from './ref-cache.js';
+import type { BrowserConfig, CdpTarget } from './types.js';
+import { CHROME_EXECUTABLES } from './types.js';
 
 const DEFAULT_PORT = 9222;
 const LAUNCH_TIMEOUT = 10_000;
@@ -22,6 +22,10 @@ const PROCESS_EXIT_POLL_MS = 50;
 // A cross-process persisted PID older than this is not trusted for the
 // SIGKILL fallback in closeBrowser() — see the call site for why.
 const PERSISTED_PID_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+// A browser WE launched that has had no targets for longer than this is
+// reaped at the next launch/attach — see reapIdleLaunchedBrowser().
+const IDLE_REAP_AFTER_MS = 30 * 60 * 1000;
+const REAP_CONNECT_TIMEOUT_MS = 3000;
 
 // Tracks the PID of Chrome instances *we* spawned, keyed by CDP port, so
 // closeBrowser() has a kill fallback when the graceful `Browser.close` CDP
@@ -53,14 +57,17 @@ function findChrome(executablePath?: string): string {
   }
   // Try PATH
   try {
-    const result = execSync('which google-chrome chromium-browser chromium microsoft-edge microsoft-edge-stable 2>/dev/null', { encoding: 'utf8' }).trim();
+    const result = execSync(
+      'which google-chrome chromium-browser chromium microsoft-edge microsoft-edge-stable 2>/dev/null',
+      { encoding: 'utf8' },
+    ).trim();
     const first = result.split('\n')[0];
     if (first) return first;
   } catch {
     // ignore
   }
   throw new Error(
-    'No supported browser found. Install Google Chrome, Microsoft Edge, or Chromium — or pass executablePath in BrowserConfig.'
+    'No supported browser found. Install Google Chrome, Microsoft Edge, or Chromium — or pass executablePath in BrowserConfig.',
   );
 }
 
@@ -81,7 +88,9 @@ export async function isPortOpen(port: number): Promise<boolean> {
  */
 async function isChromeIdentity(port: number): Promise<boolean> {
   try {
-    const res = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(1000) });
+    const res = await fetch(`http://127.0.0.1:${port}/json/version`, {
+      signal: AbortSignal.timeout(1000),
+    });
     if (!res.ok) return false;
     const info = (await res.json()) as { Browser?: string };
     // Edge's Browser field is "Edg/<version>" with no "chrome"/"chromium"
@@ -124,6 +133,12 @@ export async function launchBrowser(config: BrowserConfig = {}): Promise<number>
     throw new Error(`Invalid port: ${rawPort}. Must be an integer between 1024 and 65535.`);
   }
 
+  // Every launch/attach is this tool's only chance to notice that a previous
+  // session abandoned a browser on a CDP port and never gave it back — there
+  // is no daemon to do it on a timer. Bounded and non-throwing; a stale
+  // instance on the port we are about to use is freed before we probe it.
+  await reapIdleLaunchedBrowser();
+
   // strictPort: fail fast on the exact requested port, matching the old
   // behavior (Vite has the same escape hatch for the same reason) — for
   // callers that treat the error as a signal ("this port is taken by
@@ -133,14 +148,15 @@ export async function launchBrowser(config: BrowserConfig = {}): Promise<number>
       if (await isChromeIdentity(rawPort)) return rawPort;
       throw new Error(
         `Port ${rawPort} is occupied by a process that does not identify as Chrome/Chromium. ` +
-        `Refusing to attach — pass a different port or free port ${rawPort}.`
+          `Refusing to attach — pass a different port or free port ${rawPort}.`,
       );
     }
     return launchOnFreePort(config, rawPort);
   }
 
   const candidates: number[] = [];
-  for (let i = 0; i < LAUNCH_PORT_SCAN_TRIES && rawPort + i <= 65535; i++) candidates.push(rawPort + i);
+  for (let i = 0; i < LAUNCH_PORT_SCAN_TRIES && rawPort + i <= 65535; i++)
+    candidates.push(rawPort + i);
 
   // Attach-if-already-Chrome only applies to the EXACT requested port — the
   // original, deliberate, single-port risk ("don't silently take over an
@@ -170,7 +186,7 @@ export async function launchBrowser(config: BrowserConfig = {}): Promise<number>
   }
   throw new Error(
     `Ports ${candidates[0]}-${candidates[candidates.length - 1]} are all occupied and port ${candidates[0]} ` +
-    `isn't a Chrome/Chromium instance to attach to. Pass a different --port.`
+      `isn't a Chrome/Chromium instance to attach to. Pass a different --port.`,
   );
 }
 
@@ -223,7 +239,7 @@ async function launchOnFreePort(config: BrowserConfig, port: number): Promise<nu
       if (await isChromeIdentity(port)) return port;
       throw new Error(
         `Port ${port} is occupied by a CDP-speaking process that does not identify as Chrome/Chromium. ` +
-        `Refusing to attach — pass a different port or free port ${port}.`
+          `Refusing to attach — pass a different port or free port ${port}.`,
       );
     }
   }
@@ -234,7 +250,7 @@ async function launchOnFreePort(config: BrowserConfig, port: number): Promise<nu
   if (await isTcpPortOpen(port)) {
     throw new Error(
       `Port ${port} is occupied by a non-Chrome process (TCP connection succeeds but no CDP response within ${launchTimeout}ms). ` +
-      `Free the port or pass a different one.`
+        `Free the port or pass a different one.`,
     );
   }
 
@@ -254,7 +270,10 @@ export async function enableSessionDomains(client: CdpClient, sessionId: string)
   setupDialogAutoHandling(client, sessionId);
 }
 
-export async function connectToTarget(port: number, targetId?: string): Promise<{ client: CdpClient; target: CdpTarget; sessionId: string }> {
+export async function connectToTarget(
+  port: number,
+  targetId?: string,
+): Promise<{ client: CdpClient; target: CdpTarget; sessionId: string }> {
   const targets = await fetchTargets(port);
   const pageTargets = targets.filter((t) => t.type === 'page');
 
@@ -306,7 +325,10 @@ export async function closeBrowser(client: CdpClient, port: number): Promise<voi
     await Promise.race([
       client.send('Browser.close', {}),
       new Promise<never>((_, reject) => {
-        const t = setTimeout(() => reject(new Error('Browser.close timed out')), BROWSER_CLOSE_TIMEOUT_MS);
+        const t = setTimeout(
+          () => reject(new Error('Browser.close timed out')),
+          BROWSER_CLOSE_TIMEOUT_MS,
+        );
         t.unref?.();
       }),
     ]);
@@ -351,7 +373,9 @@ export async function closeBrowser(client: CdpClient, port: number): Promise<voi
     try {
       process.kill(pid, 0);
       process.kill(pid, 'SIGKILL');
-    } catch { /* already exited, or never was — nothing to do */ }
+    } catch {
+      /* already exited, or never was — nothing to do */
+    }
     return;
   }
 
@@ -384,6 +408,90 @@ async function waitForProcessExit(pid: number): Promise<boolean> {
   }
 }
 
+/**
+ * Give back the CDP port of a browser we launched that nothing is using any
+ * more. A launched Chrome is deliberately detached and unref'd so it outlives
+ * the command that spawned it and later commands can reattach — but nothing
+ * reaped it afterwards, so an abandoned session kept listening on its port
+ * (9222 by convention, which other local tools want) indefinitely. A foreign
+ * CDP server *answers* there rather than refusing the connection, so those
+ * tools retry the wrong port and report misleading errors instead of moving on.
+ *
+ * Nothing long-lived exists to run this on a timer — every CLI command is its
+ * own short-lived process — so it runs at the next launch/attach instead
+ * (see launchBrowser). A browser is reaped only when ALL of these hold:
+ *   - the persisted session says WE launched it — `connect` records
+ *     launched:false for a browser that belongs to the user, never touched;
+ *   - that session is older than IDLE_REAP_AFTER_MS;
+ *   - the CDP endpoint still answers and reports ZERO targets. An open tab,
+ *     or a client attached to one (Chrome drops webSocketDebuggerUrl from an
+ *     attached target but still lists it), means the session is live and
+ *     reattach-across-commands must keep working.
+ *
+ * Shutdown goes through closeBrowser() on the browser-level websocket — the
+ * only connection left once every target is gone — so a recycled PID can
+ * never be signaled by mistake: graceful `Browser.close` reaches whatever is
+ * actually listening on that port, at any age, and the persisted PID is only
+ * ever used for closeBrowser's own age-bounded force-kill.
+ *
+ * Never throws: a failed reap must not stop a launch. Returns the reaped
+ * port, or null when there was nothing to reap.
+ */
+export async function reapIdleLaunchedBrowser(): Promise<number | null> {
+  try {
+    const session = await loadActivePortInfo();
+    if (!session?.launched || session.savedAt === undefined) return null;
+    if (Date.now() - session.savedAt < IDLE_REAP_AFTER_MS) return null;
+
+    const wsUrl = await fetchBrowserWebSocketUrl(session.port);
+    if (!wsUrl) return null;
+    if ((await fetchTargets(session.port)).length > 0) return null;
+
+    const client = new CdpClient();
+    try {
+      // CdpClient.connect() has no timeout of its own — a socket that never
+      // opens (and never errors) would hang the launch this reap is running
+      // inside of, which is strictly worse than leaving the port squatted.
+      await Promise.race([
+        client.connect(wsUrl),
+        new Promise<never>((_, reject) => {
+          const t = setTimeout(
+            () => reject(new Error('Reap: CDP connect timed out')),
+            REAP_CONNECT_TIMEOUT_MS,
+          );
+          t.unref?.();
+        }),
+      ]);
+      await closeBrowser(client, session.port);
+    } finally {
+      try {
+        client.close();
+      } catch {
+        /* already gone */
+      }
+    }
+    launchedPids.delete(session.port);
+    launchedUserDataDirs.delete(session.port);
+    await clearActivePort();
+    return session.port;
+  } catch {
+    return null;
+  }
+}
+
+/** Chrome's browser-level debugger endpoint, from /json/version — the
+ *  connection `Browser.close` belongs on. Null if the port isn't answering as
+ *  a Chrome/Chromium CDP endpoint (same identity check as isChromeIdentity). */
+async function fetchBrowserWebSocketUrl(port: number): Promise<string | null> {
+  const res = await fetch(`http://127.0.0.1:${port}/json/version`, {
+    signal: AbortSignal.timeout(1000),
+  });
+  if (!res.ok) return null;
+  const info = (await res.json()) as { Browser?: string; webSocketDebuggerUrl?: string };
+  if (typeof info.Browser !== 'string' || !/chrom(e|ium)|edg/i.test(info.Browser)) return null;
+  return typeof info.webSocketDebuggerUrl === 'string' ? info.webSocketDebuggerUrl : null;
+}
+
 export async function openUrl(client: CdpClient, sessionId: string, url: string): Promise<void> {
   // Cap to 2 MB to prevent OOM in CDP message serializer (e.g. data: URI attacks)
   if (url.length > 2_097_152) throw new Error('URL exceeds 2 MB limit');
@@ -400,14 +508,24 @@ export async function waitForLoad(
   client: CdpClient,
   sessionId: string,
   condition: 'load' | 'networkidle' | 'domcontentloaded' = 'load',
-  timeout = 30_000
+  timeout = 30_000,
 ): Promise<void> {
   if (condition === 'load' || condition === 'domcontentloaded') {
     // Guard against race where the page loads before the listener is registered
-    const readyExpr = condition === 'load' ? 'document.readyState === "complete"' : 'document.readyState !== "loading"';
-    const readyCheck = await client.send<{ result: { value?: boolean } }>('Runtime.evaluate', {
-      expression: readyExpr, returnByValue: true,
-    }, sessionId).catch(() => ({ result: { value: false } }));
+    const readyExpr =
+      condition === 'load'
+        ? 'document.readyState === "complete"'
+        : 'document.readyState !== "loading"';
+    const readyCheck = await client
+      .send<{ result: { value?: boolean } }>(
+        'Runtime.evaluate',
+        {
+          expression: readyExpr,
+          returnByValue: true,
+        },
+        sessionId,
+      )
+      .catch(() => ({ result: { value: false } }));
     if (readyCheck.result?.value) return;
 
     const event = condition === 'load' ? 'Page.loadEventFired' : 'Page.domContentEventFired';
@@ -415,7 +533,10 @@ export async function waitForLoad(
     let timedOut = false;
     let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
     const timeoutPromise = new Promise<void>((resolve) => {
-      timeoutHandle = setTimeout(() => { timedOut = true; resolve(); }, timeout);
+      timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        resolve();
+      }, timeout);
     });
     try {
       await Promise.race([eventPromise, timeoutPromise]);
@@ -435,7 +556,7 @@ async function waitForNetworkIdle(
   client: CdpClient,
   sessionId: string,
   idleMs: number,
-  timeout: number
+  timeout: number,
 ): Promise<void> {
   return new Promise((resolve, reject) => {
     let pending = 0;
@@ -447,9 +568,16 @@ async function waitForNetworkIdle(
     }, timeout);
 
     const cleanup = () => {
-      if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; }
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
       clearTimeout(killTimer);
-      offReq(); offResp(); offFail(); offCache(); offResp2();
+      offReq();
+      offResp();
+      offFail();
+      offCache();
+      offResp2();
     };
 
     const settle = () => {
@@ -462,24 +590,34 @@ async function waitForNetworkIdle(
         if (idleTimer) clearTimeout(idleTimer);
         idleTimer = setTimeout(settle, idleMs);
       } else {
-        if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; }
+        if (idleTimer) {
+          clearTimeout(idleTimer);
+          idleTimer = null;
+        }
       }
     };
 
     const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
       if (sid !== sessionId) return;
       const id = params.requestId as string;
-      if (!inflight.has(id)) { inflight.add(id); pending++; check(); }
+      if (!inflight.has(id)) {
+        inflight.add(id);
+        pending++;
+        check();
+      }
     });
 
     const decrement = (params: Record<string, unknown>, sid?: string) => {
       if (sid !== sessionId) return;
       const id = params.requestId as string;
-      if (inflight.delete(id)) { pending = Math.max(0, pending - 1); check(); }
+      if (inflight.delete(id)) {
+        pending = Math.max(0, pending - 1);
+        check();
+      }
     };
 
-    const offResp  = client.on('Network.loadingFinished',        decrement);
-    const offFail  = client.on('Network.loadingFailed',          decrement);
+    const offResp = client.on('Network.loadingFinished', decrement);
+    const offFail = client.on('Network.loadingFailed', decrement);
     const offCache = client.on('Network.requestServedFromCache', decrement);
     // Guard against requests that never fire loadingFinished/loadingFailed (e.g. data: URLs)
     // Skip 3xx redirect responses — the request continues under the same requestId
@@ -494,18 +632,26 @@ async function waitForNetworkIdle(
 }
 
 export async function getCurrentUrl(client: CdpClient, sessionId: string): Promise<string> {
-  const result = await client.send<{ result: { value: string } }>('Runtime.evaluate', {
-    expression: 'location.href',
-    returnByValue: true,
-  }, sessionId);
+  const result = await client.send<{ result: { value: string } }>(
+    'Runtime.evaluate',
+    {
+      expression: 'location.href',
+      returnByValue: true,
+    },
+    sessionId,
+  );
   return result.result?.value ?? '';
 }
 
 export async function getCurrentTitle(client: CdpClient, sessionId: string): Promise<string> {
-  const result = await client.send<{ result: { value: string } }>('Runtime.evaluate', {
-    expression: 'document.title',
-    returnByValue: true,
-  }, sessionId);
+  const result = await client.send<{ result: { value: string } }>(
+    'Runtime.evaluate',
+    {
+      expression: 'document.title',
+      returnByValue: true,
+    },
+    sessionId,
+  );
   return result.result?.value ?? '';
 }
 

package/src/browser/cdp.ts

@@ -13,8 +13,18 @@ export const DEFAULT_CDP_SEND_TIMEOUT_MS = 30_000;
 
 export class CdpClient {
   private ws: WebSocket | null = null;
-  private pendingCommands = new Map<number, { resolve: (r: CdpResponse) => void; reject: (e: Error) => void; timer?: ReturnType<typeof setTimeout> }>();
-  private eventListeners = new Map<string, Set<(params: Record<string, unknown>, sessionId?: string) => void>>();
+  private pendingCommands = new Map<
+    number,
+    {
+      resolve: (r: CdpResponse) => void;
+      reject: (e: Error) => void;
+      timer?: ReturnType<typeof setTimeout>;
+    }
+  >();
+  private eventListeners = new Map<
+    string,
+    Set<(params: Record<string, unknown>, sessionId?: string) => void>
+  >();
   private nextId = 1;
   private connected = false;
 
@@ -73,7 +83,11 @@ export class CdpClient {
             const listeners = this.eventListeners.get(msg.method);
             if (listeners) {
               for (const fn of listeners) {
-                try { fn(msg.params ?? {}, msg.sessionId); } catch { /* isolate per-listener errors */ }
+                try {
+                  fn(msg.params ?? {}, msg.sessionId);
+                } catch {
+                  /* isolate per-listener errors */
+                }
               }
             }
           }
@@ -88,7 +102,7 @@ export class CdpClient {
     method: string,
     params?: Record<string, unknown>,
     sessionId?: string,
-    timeoutMs: number = DEFAULT_CDP_SEND_TIMEOUT_MS
+    timeoutMs: number = DEFAULT_CDP_SEND_TIMEOUT_MS,
   ): Promise<T> {
     return new Promise((resolve, reject) => {
       if (!this.ws || !this.connected) {
@@ -114,8 +128,14 @@ export class CdpClient {
       }
 
       this.pendingCommands.set(id, {
-        resolve: (r) => { if (timer) clearTimeout(timer); resolve((r.result ?? {}) as T); },
-        reject: (e) => { if (timer) clearTimeout(timer); reject(e); },
+        resolve: (r) => {
+          if (timer) clearTimeout(timer);
+          resolve((r.result ?? {}) as T);
+        },
+        reject: (e) => {
+          if (timer) clearTimeout(timer);
+          reject(e);
+        },
         timer,
       });
       this.ws.send(JSON.stringify(cmd), (err) => {
@@ -188,7 +208,9 @@ export async function fetchTargets(port: number): Promise<CdpTarget[]> {
 
 export async function fetchNewTarget(port: number, url: string): Promise<CdpTarget> {
   // Chrome v92+ requires PUT for /json/new; GET returns 405. URL must be encoded.
-  const res = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`, { method: 'PUT' });
+  const res = await fetch(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(url)}`, {
+    method: 'PUT',
+  });
   if (!res.ok) throw new Error(`Failed to create target: ${res.statusText}`);
   return readCdpJson(res) as Promise<CdpTarget>;
 }
@@ -203,7 +225,10 @@ export async function createBrowserPage(url: string, port = 9222): Promise<Brows
   const target = await fetchNewTarget(port, url);
   const wsDebuggerUrl = target.webSocketDebuggerUrl;
   if (!wsDebuggerUrl) {
-    throw new Error('Chrome did not return a WebSocket debugger URL. Ensure Chrome is running with --remote-debugging-port=' + port);
+    throw new Error(
+      'Chrome did not return a WebSocket debugger URL. Ensure Chrome is running with --remote-debugging-port=' +
+        port,
+    );
   }
 
   const client = new CdpClient();
@@ -218,7 +243,9 @@ export async function createBrowserPage(url: string, port = 9222): Promise<Brows
     await Promise.race([
       loadPromise,
       new Promise<void>((_, reject) =>
-        AbortSignal.timeout(30_000).addEventListener('abort', () => reject(new Error('Page load timeout after 30s')))
+        AbortSignal.timeout(30_000).addEventListener('abort', () =>
+          reject(new Error('Page load timeout after 30s')),
+        ),
       ),
     ]);
   } catch (err) {
@@ -228,7 +255,9 @@ export async function createBrowserPage(url: string, port = 9222): Promise<Brows
 
   const closeTab = async (): Promise<void> => {
     try {
-      await fetch(`http://127.0.0.1:${port}/json/close/${encodeURIComponent(target.id)}`, { method: 'GET' });
+      await fetch(`http://127.0.0.1:${port}/json/close/${encodeURIComponent(target.id)}`, {
+        method: 'GET',
+      });
     } catch {
       // best-effort: tab may already be gone
     }
@@ -243,7 +272,10 @@ export async function createBrowserPage(url: string, port = 9222): Promise<Brows
       return result.result.value;
     },
     evaluate: async <T>(expression: string): Promise<T> => {
-      const result = await client.send<{ result: { value: T; }; exceptionDetails?: { text: string } }>('Runtime.evaluate', {
+      const result = await client.send<{
+        result: { value: T };
+        exceptionDetails?: { text: string };
+      }>('Runtime.evaluate', {
         expression,
         returnByValue: true,
       });