@crouton-kit/capture 1.3.6 → 1.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crouton-kit/capture",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "description": "Browser automation and UI validation via CDP — session-based screenshots, HAR, a11y, click/type, and JS exec",
   "bin": {
     "capture": "./bin/capture"

package/src/capture.ts

@@ -72,6 +72,8 @@ async function main(): Promise<void> {
     case "lib":
     case "network":
     case "list":
+    case "cdp":
+    case "__bridge-serve":
       return cdpMain();
 
     default:
@@ -126,6 +128,24 @@ DIAGNOSTICS & ONE-OFFS (no session needed)
   network <offline|online>                 Toggle connectivity for a tab
   har create | read [id] | delete <id>     Manage standalone HAR recordings
 
+RAW CDP ESCAPE HATCH
+
+  cdp <Domain.method> [--params json]      Send any CDP command capture doesn't wrap
+                      [--browser]          Target the browser connection (Browser.*, ServiceWorker.*)
+                      [--wait-event name]  Wait for a CDP event, e.g. after ServiceWorker.enable
+
+  Browser-level state (permission grants, ServiceWorker enablement) reverts
+  the instant its connection closes. session start --hold keeps ONE browser
+  connection open across commands so that state survives between them:
+
+    capture session start --url http://localhost:3000 --hold
+    capture cdp Browser.grantPermissions --browser --params '{"origin":"...","permissions":["notifications"]}'
+    capture cdp ServiceWorker.enable --browser --target <pageTabId>
+    capture cdp ServiceWorker.deliverPushMessage --browser --target <pageTabId> --params '{...}'
+    capture session stop <session-id>
+
+  capture cdp --help                       Full reference
+
 LIBRARY (vault libs — dev checkout only)
 
   lib list                                 List available libs

package/src/cdp/args.ts

@@ -94,6 +94,20 @@ export function parseCliArgs(argv: string[]): ParsedArgs {
     } else if (arg === '--limit' && next) {
       parsed.limit = parseInt(next, 10);
       i++;
+    } else if (arg === '--browser') {
+      parsed.browser = true;
+    } else if (arg === '--params' && next) {
+      parsed.params = next;
+      i++;
+    } else if (arg === '--wait-event' && next) {
+      parsed.waitEvent = next;
+      i++;
+    } else if (arg === '--timeout' && next) {
+      parsed.timeoutMs = parseInt(next, 10);
+      i++;
+    } else if (arg === '--socket' && next) {
+      parsed.socket = next;
+      i++;
     } else if (arg === '--help' || arg === '-h') {
       parsed.help = true;
     } else if (arg.startsWith('--')) {

package/src/cdp/bridge/client.ts

@@ -0,0 +1,49 @@
+/**
+ * Client side of the bridge protocol \u2014 used by `capture cdp --browser` to
+ * relay one request to an already-running bridge server over its socket.
+ */
+
+import * as net from 'net';
+import { type BridgeRequest, type BridgeResponse } from './protocol.js';
+
+let reqCounter = 0;
+
+export function sendBridgeRequest(
+  socketPath: string,
+  req: Omit<BridgeRequest, 'reqId'>,
+): Promise<BridgeResponse> {
+  const wireTimeoutMs = (req.timeoutMs ?? 10000) + 5000;
+  return new Promise((resolve, reject) => {
+    const reqId = ++reqCounter;
+    const socket = net.createConnection(socketPath);
+    let buffer = '';
+
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new Error(`Bridge request timed out after ${wireTimeoutMs}ms (socket: ${socketPath})`));
+    }, wireTimeoutMs);
+
+    socket.on('connect', () => {
+      socket.write(JSON.stringify({ ...req, reqId } satisfies BridgeRequest) + '\n');
+    });
+
+    socket.on('data', (chunk) => {
+      buffer += chunk.toString('utf-8');
+      const idx = buffer.indexOf('\n');
+      if (idx < 0) return;
+      clearTimeout(timer);
+      const line = buffer.slice(0, idx);
+      socket.end();
+      try {
+        resolve(JSON.parse(line) as BridgeResponse);
+      } catch (err) {
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+
+    socket.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}

package/src/cdp/bridge/protocol.ts

@@ -0,0 +1,38 @@
+/**
+ * Wire protocol between `capture cdp --browser` and the held bridge process
+ * (`capture __bridge-serve`). Newline-delimited JSON over a Unix domain
+ * socket — one request per connection, one response, then the socket closes.
+ */
+
+export interface BridgeRequest {
+  reqId: number;
+  /** CDP method, e.g. "Browser.grantPermissions". Omit when only waiting for an event. */
+  method?: string;
+  params?: Record<string, unknown>;
+  /**
+   * Target (page or worker) to scope this call to, via a flattened
+   * `Target.attachToTarget` session on the SAME held browser websocket.
+   * Required for domains that live on a target rather than the browser
+   * itself (`ServiceWorker.*`, `Page.*`, ...) — omit for pure browser-level
+   * domains (`Browser.*`, `Target.*`).
+   */
+  targetId?: string;
+  /** CDP event name to wait for (consumes the next occurrence, FIFO, buffered if it already fired). */
+  waitEvent?: string;
+  timeoutMs?: number;
+}
+
+export interface BridgeResponseOk {
+  reqId: number;
+  ok: true;
+  result?: unknown;
+  event?: unknown;
+}
+
+export interface BridgeResponseErr {
+  reqId: number;
+  ok: false;
+  error: string;
+}
+
+export type BridgeResponse = BridgeResponseOk | BridgeResponseErr;

package/src/cdp/bridge/server.ts

@@ -0,0 +1,179 @@
+/**
+ * The bridge server: holds ONE browser-level CDP connection open for the
+ * lifetime of a held session and exposes it to (many, sequential) `capture
+ * cdp --browser` invocations over a Unix socket.
+ *
+ * Why this exists: `Browser.grantPermissions`, `ServiceWorker.enable`, and
+ * other browser-scoped CDP state are per-CLIENT and revert the instant the
+ * granting websocket disconnects. `capture` normally opens/closes a fresh
+ * websocket per command, so that state was gone by the next command. Running
+ * this as a long-lived detached process is what keeps ONE websocket (and
+ * therefore that state) alive across many separate `capture` invocations.
+ */
+
+import * as fs from 'fs';
+import * as net from 'net';
+import * as path from 'path';
+import { getBrowserClient } from '../targets.js';
+import { type CDPClient } from '../client.js';
+import { type BridgeRequest, type BridgeResponse } from './protocol.js';
+
+interface EventWaiter {
+  resolve: (v: unknown) => void;
+}
+
+class EventBroker {
+  private queues = new Map<string, unknown[]>();
+  private waiters = new Map<string, EventWaiter[]>();
+  private listening = new Set<string>();
+
+  constructor(private client: CDPClient) {}
+
+  private ensureListening(eventName: string): void {
+    if (this.listening.has(eventName)) return;
+    this.listening.add(eventName);
+    this.client.on(eventName, (params) => {
+      const waiters = this.waiters.get(eventName);
+      if (waiters && waiters.length > 0) {
+        waiters.shift()!.resolve(params);
+        return;
+      }
+      const q = this.queues.get(eventName) ?? [];
+      q.push(params);
+      // Cap the buffer so an event nobody ever asks for can't leak memory.
+      if (q.length > 50) q.shift();
+      this.queues.set(eventName, q);
+    });
+  }
+
+  wait(eventName: string, timeoutMs: number): Promise<unknown> {
+    this.ensureListening(eventName);
+    const q = this.queues.get(eventName);
+    if (q && q.length > 0) {
+      return Promise.resolve(q.shift());
+    }
+    return new Promise((resolve, reject) => {
+      const list = this.waiters.get(eventName) ?? [];
+      const entry: EventWaiter = {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+      };
+      const timer = setTimeout(() => {
+        const current = this.waiters.get(eventName);
+        if (current) {
+          const idx = current.indexOf(entry);
+          if (idx >= 0) current.splice(idx, 1);
+        }
+        reject(new Error(`Timed out after ${timeoutMs}ms waiting for event "${eventName}"`));
+      }, timeoutMs);
+      list.push(entry);
+      this.waiters.set(eventName, list);
+    });
+  }
+}
+
+export async function runBridgeServer(socketPath: string, port?: number): Promise<void> {
+  const { client } = await getBrowserClient(await resolvePort(port));
+  const events = new EventBroker(client);
+
+  // Cache flattened Target.attachToTarget sessions so repeated requests
+  // against the same target (e.g. ServiceWorker.enable then
+  // ServiceWorker.deliverPushMessage) reuse one attach instead of piling up.
+  const targetSessions = new Map<string, string>();
+  async function attach(targetId: string): Promise<string> {
+    const cached = targetSessions.get(targetId);
+    if (cached) return cached;
+    const result = (await client.send('Target.attachToTarget', { targetId, flatten: true })) as {
+      sessionId: string;
+    };
+    targetSessions.set(targetId, result.sessionId);
+    return result.sessionId;
+  }
+
+  fs.mkdirSync(path.dirname(socketPath), { recursive: true });
+  try {
+    fs.unlinkSync(socketPath);
+  } catch {
+    // No stale socket to remove.
+  }
+
+  const server = net.createServer((socket) => {
+    let buffer = '';
+    socket.on('data', (chunk) => {
+      buffer += chunk.toString('utf-8');
+      let idx: number;
+      while ((idx = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 1);
+        if (line.trim()) void handleLine(line, socket);
+      }
+    });
+  });
+
+  async function handleLine(line: string, socket: net.Socket): Promise<void> {
+    let req: BridgeRequest;
+    try {
+      req = JSON.parse(line);
+    } catch {
+      return;
+    }
+    let resp: BridgeResponse;
+    try {
+      const sessionId = req.targetId ? await attach(req.targetId) : undefined;
+      const eventPromise = req.waitEvent ? events.wait(req.waitEvent, req.timeoutMs ?? 10000) : undefined;
+      const result = req.method ? await client.send(req.method, req.params ?? {}, 60000, sessionId) : undefined;
+      const event = eventPromise ? await eventPromise : undefined;
+      resp = { reqId: req.reqId, ok: true, result, event };
+    } catch (err) {
+      resp = { reqId: req.reqId, ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    socket.write(JSON.stringify(resp) + '\n');
+  }
+
+  const cleanup = (): void => {
+    try {
+      server.close();
+    } catch {
+      // Already closed.
+    }
+    try {
+      client.close();
+    } catch {
+      // Already closed.
+    }
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {
+      // Already gone.
+    }
+  };
+  process.on('SIGTERM', () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on('SIGINT', () => {
+    cleanup();
+    process.exit(0);
+  });
+  client.onDisconnect(() => {
+    // The browser (or its CDP endpoint) went away — nothing left to bridge.
+    cleanup();
+    process.exit(0);
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.on('error', reject);
+    server.listen(socketPath, () => resolve());
+  });
+  // Intentionally does not resolve further work here: the open server and
+  // the live websocket keep the event loop (and this detached process) alive
+  // until `stopBridge()` sends SIGTERM.
+}
+
+async function resolvePort(port?: number): Promise<number> {
+  if (port) return port;
+  const { detectCdpPort } = await import('../detect.js');
+  return detectCdpPort();
+}

package/src/cdp/bridge/spawn.ts

@@ -0,0 +1,65 @@
+/**
+ * Spawns/stops the detached bridge process for a held session
+ * (`capture session start --hold`). Mirrors the existing detached-child +
+ * pid-tracking pattern used for session log tailers (`session/commands.ts`).
+ */
+
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export function bridgeSocketPath(sessionDir: string): string {
+  return path.join(sessionDir, 'bridge.sock');
+}
+
+export async function startBridge(
+  sessionDir: string,
+  port: number,
+  timeoutMs = 5000,
+): Promise<{ socketPath: string; pid: number }> {
+  const socketPath = bridgeSocketPath(sessionDir);
+  // Re-invoke the currently-running capture entrypoint in a hidden mode.
+  // Only works against the built bin (a bundled, plain-node-runnable JS
+  // file) \u2014 running `npm run dev` (tsx) can't self-spawn this way.
+  const scriptPath = process.argv[1];
+  const child = spawn(
+    process.execPath,
+    [scriptPath, '__bridge-serve', '--socket', socketPath, '--port', String(port)],
+    { detached: true, stdio: 'ignore' },
+  );
+  child.unref();
+  const pid = child.pid;
+  if (!pid) {
+    throw new Error('Failed to spawn CDP bridge process.');
+  }
+
+  const start = Date.now();
+  while (!fs.existsSync(socketPath)) {
+    if (Date.now() - start > timeoutMs) {
+      throw new Error(
+        `CDP bridge (pid ${pid}) did not come up within ${timeoutMs}ms. ` +
+          `Check that a browser is reachable on port ${port} (capture detect).`,
+      );
+    }
+    await new Promise((r) => setTimeout(r, 50));
+  }
+
+  return { socketPath, pid };
+}
+
+export function stopBridge(pid: number | null | undefined, socketPath: string | null | undefined): void {
+  if (pid) {
+    try {
+      process.kill(pid, 'SIGTERM');
+    } catch {
+      // Already dead.
+    }
+  }
+  if (socketPath) {
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {
+      // Already gone.
+    }
+  }
+}

package/src/cdp/client.ts

@@ -60,13 +60,14 @@ export class CDPClient {
     method: string,
     params: Record<string, unknown> = {},
     timeout = 60000,
+    sessionId?: string,
   ): Promise<unknown> {
     await this.ready;
     const id = ++this.messageId;
 
     return new Promise((resolve, reject) => {
       this.pendingRequests.set(id, { resolve, reject });
-      this.ws.send(JSON.stringify({ id, method, params }));
+      this.ws.send(JSON.stringify(sessionId ? { id, method, params, sessionId } : { id, method, params }));
 
       const timer = setTimeout(() => {
         if (this.pendingRequests.has(id)) {
@@ -86,6 +87,11 @@ export class CDPClient {
     this.eventHandlers.get(event)!.push(handler);
   }
 
+  /** Fires when the underlying websocket goes away (browser closed, crashed, CDP endpoint dropped). */
+  onDisconnect(handler: () => void): void {
+    this.ws.on('close', handler);
+  }
+
   close(): void {
     // Clear all pending timeouts to allow process to exit
     for (const timer of this.pendingTimeouts.values()) {

package/src/cdp/commands/bridge-serve.ts

@@ -0,0 +1,18 @@
+import { runBridgeServer } from '../bridge/server.js';
+import { type ParsedArgs } from '../types.js';
+
+/**
+ * Hidden entrypoint spawned detached by `capture session start --hold`
+ * (see `bridge/spawn.ts`). Not documented in `capture --help` \u2014 nothing
+ * calls this directly.
+ */
+export async function cmdBridgeServe(parsed: ParsedArgs, _args: string[]): Promise<void> {
+  if (!parsed.socket) {
+    console.error('Usage: capture __bridge-serve --socket <path> [--port <cdpPort>]');
+    process.exit(1);
+  }
+  await runBridgeServer(parsed.socket, parsed.port);
+  // Deliberately does not exit: the open Unix socket server and the live
+  // browser websocket keep this detached process alive until `session stop`
+  // sends it SIGTERM.
+}

package/src/cdp/commands/cdp.ts

@@ -0,0 +1,175 @@
+/**
+ * Raw CDP passthrough \u2014 the escape hatch for domains no other capture
+ * command wraps (`Browser.grantPermissions`, `ServiceWorker.*`, etc.).
+ *
+ * `--browser` routes through the HELD connection (see `session start
+ * --hold` / `src/cdp/bridge/`) instead of a fresh page/tab websocket.
+ * Browser-scoped state (permission grants) and target-scoped state that was
+ * enabled on that same connection (`ServiceWorker.enable`, ...) is
+ * per-CLIENT and reverts the instant its websocket disconnects, so a plain
+ * one-shot call here only lasts for that single command \u2014 running inside a
+ * held session is what keeps it alive across commands.
+ */
+
+import * as fs from 'fs';
+import { getActiveSession } from '../../session-context.js';
+import { connectForCommand } from '../connection.js';
+import { getBrowserClient } from '../targets.js';
+import { detectCdpPort } from '../detect.js';
+import { sendBridgeRequest } from '../bridge/client.js';
+import { type CDPClient } from '../client.js';
+import { type ParsedArgs } from '../types.js';
+
+const DEFAULT_TIMEOUT_MS = 10000;
+
+function printHelp(): void {
+  console.log(
+    `Usage: capture cdp <Domain.method> [--params '<json>'] [--browser] [--target <id>] [--wait-event <Domain.event>] [--timeout <ms>]
+
+Send a raw CDP command \u2014 the escape hatch for domains no other capture
+command wraps (Browser.grantPermissions, ServiceWorker.*, Target.*, ...).
+
+  --browser           Route through the held connection (session --hold)
+                       instead of a fresh page/tab websocket. Required for
+                       state that must survive across separate commands.
+  --target <id>       With --browser: attach to this target (a flattened CDP
+                       session on the SAME held connection) for target-scoped
+                       domains, e.g. ServiceWorker.enable / .deliverPushMessage.
+                       Without --browser: the page target to run against, as
+                       with every other capture command.
+  --params '<json>'   JSON-encoded params object for the method.
+  --wait-event <name> Wait for (and return) the next occurrence of a CDP
+                       event, e.g. ServiceWorker.workerRegistrationUpdated.
+                       Can be combined with a method (sent first) or alone.
+  --timeout <ms>      Wait timeout (default: ${DEFAULT_TIMEOUT_MS}ms).
+
+Browser-level and target-enablement state reverts the instant its connection
+disconnects \u2014 a one-shot call here only lasts for that single command. Run
+inside a held session to keep it alive across commands:
+
+  capture session start --url http://localhost:3000 --hold
+  capture cdp Browser.grantPermissions --browser \\
+    --params '{"origin":"http://localhost:3000","permissions":["notifications"]}'
+  capture cdp ServiceWorker.enable --browser --target <pageTabId>
+  capture cdp --browser --target <pageTabId> --wait-event ServiceWorker.workerRegistrationUpdated
+  capture cdp ServiceWorker.deliverPushMessage --browser --target <pageTabId> \\
+    --params '{"origin":"...","registrationId":"...","data":"..."}'
+  capture session stop <session-id>
+
+Without --browser, the method runs against the current page target (session
+context or --target), like any other capture command \u2014 e.g. DOM.* or
+Accessibility.* calls beyond what \`capture a11y\` exposes.`,
+  );
+}
+
+export async function cmdCdp(parsed: ParsedArgs, _args: string[]): Promise<void> {
+  if (parsed.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const method = parsed.positional[0];
+  if (!method && !parsed.waitEvent) {
+    console.error('ERROR: Provide a CDP method (e.g. Browser.grantPermissions) or --wait-event.\n');
+    printHelp();
+    process.exit(1);
+  }
+
+  let params: Record<string, unknown> | undefined;
+  if (parsed.params) {
+    try {
+      params = JSON.parse(parsed.params);
+    } catch (err) {
+      console.error(`ERROR: --params is not valid JSON: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  }
+
+  const timeoutMs = parsed.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  if (parsed.browser) {
+    await runBrowserScope(method, params, parsed, timeoutMs);
+    return;
+  }
+
+  await runPageScope(method, params, parsed, timeoutMs);
+}
+
+async function runBrowserScope(
+  method: string | undefined,
+  params: Record<string, unknown> | undefined,
+  parsed: ParsedArgs,
+  timeoutMs: number,
+): Promise<void> {
+  const session = getActiveSession();
+  if (session?.bridgeSocket && fs.existsSync(session.bridgeSocket)) {
+    const resp = await sendBridgeRequest(session.bridgeSocket, {
+      method,
+      params,
+      targetId: parsed.target,
+      waitEvent: parsed.waitEvent,
+      timeoutMs,
+    });
+    if (!resp.ok) {
+      console.error(`ERROR: ${resp.error}`);
+      process.exit(1);
+    }
+    console.log(JSON.stringify({ result: resp.result, event: resp.event }, null, 2));
+    return;
+  }
+
+  console.error(
+    'No held session bridge active \u2014 this connection closes when the command exits, ' +
+      'so any browser-level grant or target enablement made here reverts immediately after.\n' +
+      'For state that must survive multiple commands: capture session start --hold\n',
+  );
+
+  const port = parsed.port ?? (await detectCdpPort());
+  const { client } = await getBrowserClient(port);
+  try {
+    let sessionId: string | undefined;
+    if (parsed.target) {
+      const attached = (await client.send('Target.attachToTarget', {
+        targetId: parsed.target,
+        flatten: true,
+      })) as { sessionId: string };
+      sessionId = attached.sessionId;
+    }
+    const eventPromise = parsed.waitEvent ? waitForEventOnce(client, parsed.waitEvent, timeoutMs) : undefined;
+    const result = method ? await client.send(method, params ?? {}, 60000, sessionId) : undefined;
+    const event = eventPromise ? await eventPromise : undefined;
+    console.log(JSON.stringify({ result, event }, null, 2));
+  } finally {
+    client.close();
+  }
+}
+
+async function runPageScope(
+  method: string | undefined,
+  params: Record<string, unknown> | undefined,
+  parsed: ParsedArgs,
+  timeoutMs: number,
+): Promise<void> {
+  const { client } = await connectForCommand(parsed);
+  try {
+    const eventPromise = parsed.waitEvent ? waitForEventOnce(client, parsed.waitEvent, timeoutMs) : undefined;
+    const result = method ? await client.send(method, params ?? {}) : undefined;
+    const event = eventPromise ? await eventPromise : undefined;
+    console.log(JSON.stringify({ result, event }, null, 2));
+  } finally {
+    client.close();
+  }
+}
+
+function waitForEventOnce(client: CDPClient, eventName: string, timeoutMs: number): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`Timed out after ${timeoutMs}ms waiting for event "${eventName}"`)),
+      timeoutMs,
+    );
+    client.on(eventName, (params) => {
+      clearTimeout(timer);
+      resolve(params);
+    });
+  });
+}

package/src/cdp/dispatch.ts

@@ -6,6 +6,8 @@ import { cmdScreenshot, cmdClick, cmdType, cmdA11y } from './commands/ui.js';
 import { cmdRecord, cmdNavigate, cmdNetwork } from './commands/traffic.js';
 import { cmdHar } from './commands/har.js';
 import { cmdLib } from './commands/lib.js';
+import { cmdCdp } from './commands/cdp.js';
+import { cmdBridgeServe } from './commands/bridge-serve.js';
 
 export async function cdpMain(): Promise<void> {
   const args = process.argv.slice(2);
@@ -26,6 +28,8 @@ export async function cdpMain(): Promise<void> {
     case 'network': return cmdNetwork(parsed, args);
     case 'har': return cmdHar(parsed, args);
     case 'lib': return cmdLib(parsed, args);
+    case 'cdp': return cmdCdp(parsed, args);
+    case '__bridge-serve': return cmdBridgeServe(parsed, args);
     default:
       console.log(CDP_USAGE);
   }

package/src/cdp/targets.ts

@@ -2,7 +2,14 @@ import { CDPClient } from './client.js';
 import { detectCdpPortsAsync } from './detect.js';
 import { type CDPTarget } from './types.js';
 
-async function getBrowserClient(
+/**
+ * Connects to the BROWSER-level CDP websocket (not a page/tab target).
+ * Browser-scoped domains (`Browser.grantPermissions`, `ServiceWorker.*`,
+ * `Target.*`) only take effect on this connection — and only for as long as
+ * it stays open, which is why `capture cdp --browser` routes through the
+ * session bridge (`src/cdp/bridge/`) instead of opening a fresh one per call.
+ */
+export async function getBrowserClient(
   port: number,
 ): Promise<{ client: CDPClient; browserWsUrl: string }> {
   const versionResp = await fetch(`http://localhost:${port}/json/version`);

package/src/cdp/types.ts

@@ -34,4 +34,9 @@ export interface ParsedArgs {
   filterStatus?: string;
   filterMethod?: string;
   limit?: number;
+  browser?: boolean;
+  params?: string;
+  waitEvent?: string;
+  timeoutMs?: number;
+  socket?: string;
 }