@monoes/monobrowse 1.0.11 → 1.0.13

package/src/browser/index.ts

@@ -1,23 +1,24 @@
-export * from './types.js';
-export * from './cdp.js';
-export * from './browser.js';
-export * from './snapshot.js';
+export * from '../report/index.js';
 export * from './actions.js';
-export * from './wait.js';
-export * from './network.js';
-export * from './screenshot.js';
-export * from './session.js';
-export * from './tabs.js';
-export * from './dialog.js';
+export * from './batch.js';
+export * from './browser.js';
+export * from './cdp.js';
 export * from './console-log.js';
-export * from './storage.js';
+export * from './dialog.js';
+export * from './emulation.js';
 export * from './find.js';
+export * from './har.js';
+export * from './network.js';
 export * from './pdf.js';
-export * from './emulation.js';
-export * from './batch.js';
+export * from './profiler.js';
 export * from './record.js';
+export * from './ref-cache.js';
+export * from './screenshot.js';
+export * from './session.js';
+export * from './snapshot.js';
+export * from './storage.js';
+export * from './tabs.js';
 export * from './trace.js';
-export * from './profiler.js';
+export * from './types.js';
 export * from './vitals.js';
-export * from './har.js';
-export * from './ref-cache.js';
+export * from './wait.js';

package/src/browser/network.ts

@@ -2,7 +2,11 @@ import type { CdpClient } from './cdp.js';
 import type { CdpCookie, NetworkRoute } from './types.js';
 
 export async function getCookies(client: CdpClient, sessionId: string): Promise<CdpCookie[]> {
-  const result = await client.send<{ cookies: CdpCookie[] }>('Network.getAllCookies', {}, sessionId);
+  const result = await client.send<{ cookies: CdpCookie[] }>(
+    'Network.getAllCookies',
+    {},
+    sessionId,
+  );
   return result.cookies ?? [];
 }
 
@@ -12,12 +16,24 @@ export async function getCookies(client: CdpClient, sessionId: string): Promise<
  * profile. Used for session save/export so we don't leak session tokens for
  * unrelated domains the user happens to be logged into.
  */
-export async function getCookiesForUrls(client: CdpClient, sessionId: string, urls: string[]): Promise<CdpCookie[]> {
-  const result = await client.send<{ cookies: CdpCookie[] }>('Network.getCookies', { urls }, sessionId);
+export async function getCookiesForUrls(
+  client: CdpClient,
+  sessionId: string,
+  urls: string[],
+): Promise<CdpCookie[]> {
+  const result = await client.send<{ cookies: CdpCookie[] }>(
+    'Network.getCookies',
+    { urls },
+    sessionId,
+  );
   return result.cookies ?? [];
 }
 
-export async function setCookies(client: CdpClient, sessionId: string, cookies: CdpCookie[]): Promise<void> {
+export async function setCookies(
+  client: CdpClient,
+  sessionId: string,
+  cookies: CdpCookie[],
+): Promise<void> {
   await client.send('Network.setCookies', { cookies }, sessionId);
 }
 
@@ -28,15 +44,19 @@ export async function clearCookies(client: CdpClient, sessionId: string): Promis
 export async function setExtraHeaders(
   client: CdpClient,
   sessionId: string,
-  headers: Record<string, string>
+  headers: Record<string, string>,
 ): Promise<void> {
   await client.send('Network.setExtraHTTPHeaders', { headers }, sessionId);
 }
 
 export async function enableInterception(client: CdpClient, sessionId: string): Promise<void> {
-  await client.send('Fetch.enable', {
-    patterns: [{ requestStage: 'Request' }],
-  }, sessionId);
+  await client.send(
+    'Fetch.enable',
+    {
+      patterns: [{ requestStage: 'Request' }],
+    },
+    sessionId,
+  );
 }
 
 const _routeListeners = new Map<string, () => void>();
@@ -44,11 +64,14 @@ const _routeListeners = new Map<string, () => void>();
 export async function setupRoutes(
   client: CdpClient,
   sessionId: string,
-  routes: NetworkRoute[]
+  routes: NetworkRoute[],
 ): Promise<void> {
   // Remove previous route listener for this session before registering a new one
   const prevOff = _routeListeners.get(sessionId);
-  if (prevOff) { prevOff(); _routeListeners.delete(sessionId); }
+  if (prevOff) {
+    prevOff();
+    _routeListeners.delete(sessionId);
+  }
 
   if (routes.length === 0) {
     await client.send('Fetch.disable', {}, sessionId).catch(() => {});
@@ -77,14 +100,21 @@ export async function setupRoutes(
           await client.send('Fetch.failRequest', { requestId, errorReason: 'Failed' }, sessionId);
           break;
         case 'fulfill':
-          await client.send('Fetch.fulfillRequest', {
-            requestId,
-            responseCode: matchedRoute.response?.status ?? 200,
-            responseHeaders: Object.entries(matchedRoute.response?.headers ?? {}).map(([name, value]) => ({ name, value })),
-            body: matchedRoute.response?.body ? Buffer.from(matchedRoute.response.body).toString('base64') : '',
-          }, sessionId);
+          await client.send(
+            'Fetch.fulfillRequest',
+            {
+              requestId,
+              responseCode: matchedRoute.response?.status ?? 200,
+              responseHeaders: Object.entries(matchedRoute.response?.headers ?? {}).map(
+                ([name, value]) => ({ name, value }),
+              ),
+              body: matchedRoute.response?.body
+                ? Buffer.from(matchedRoute.response.body).toString('base64')
+                : '',
+            },
+            sessionId,
+          );
           break;
-        case 'continue':
         default:
           await client.send('Fetch.continueRequest', { requestId }, sessionId);
           break;
@@ -96,15 +126,29 @@ export async function setupRoutes(
   });
   _routeListeners.set(sessionId, off);
 
-  await client.send('Fetch.enable', {
-    patterns: routes.map((r) => ({ urlPattern: globToFetchPattern(r.pattern), requestStage: 'Request' })),
-  }, sessionId);
+  await client.send(
+    'Fetch.enable',
+    {
+      patterns: routes.map((r) => ({
+        urlPattern: globToFetchPattern(r.pattern),
+        requestStage: 'Request',
+      })),
+    },
+    sessionId,
+  );
 }
 
 type CapturedRequest = {
-  id: string; url: string; method: string; status?: number; mimeType?: string;
-  requestHeaders?: Record<string, string>; responseHeaders?: Record<string, string>;
-  startTime: number; endTime?: number; encodedSize?: number;
+  id: string;
+  url: string;
+  method: string;
+  status?: number;
+  mimeType?: string;
+  requestHeaders?: Record<string, string>;
+  responseHeaders?: Record<string, string>;
+  startTime: number;
+  endTime?: number;
+  encodedSize?: number;
 };
 
 const _capturedRequests = new Map<string, Map<string, CapturedRequest>>();
@@ -121,29 +165,53 @@ export function startRequestCapture(client: CdpClient, sessionId: string): void
 
   const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
     if (sid !== sessionId) return;
-    const p = params as { requestId: string; request: { url: string; method: string; headers: Record<string, string> }; timestamp: number };
-    idx().set(p.requestId, { id: p.requestId, url: p.request.url, method: p.request.method, requestHeaders: p.request.headers, startTime: p.timestamp * 1000 });
+    const p = params as {
+      requestId: string;
+      request: { url: string; method: string; headers: Record<string, string> };
+      timestamp: number;
+    };
+    idx().set(p.requestId, {
+      id: p.requestId,
+      url: p.request.url,
+      method: p.request.method,
+      requestHeaders: p.request.headers,
+      startTime: p.timestamp * 1000,
+    });
   });
 
   const offResp = client.on('Network.responseReceived', (params, sid) => {
     if (sid !== sessionId) return;
-    const p = params as { requestId: string; response: { status: number; mimeType: string; headers: Record<string, string> }; timestamp: number };
+    const p = params as {
+      requestId: string;
+      response: { status: number; mimeType: string; headers: Record<string, string> };
+      timestamp: number;
+    };
     const entry = idx().get(p.requestId);
-    if (entry) { entry.status = p.response.status; entry.mimeType = p.response.mimeType; entry.responseHeaders = p.response.headers; entry.endTime = p.timestamp * 1000; }
+    if (entry) {
+      entry.status = p.response.status;
+      entry.mimeType = p.response.mimeType;
+      entry.responseHeaders = p.response.headers;
+      entry.endTime = p.timestamp * 1000;
+    }
   });
 
   const offFinished = client.on('Network.loadingFinished', (params, sid) => {
     if (sid !== sessionId) return;
     const p = params as { requestId: string; encodedDataLength: number; timestamp: number };
     const entry = idx().get(p.requestId);
-    if (entry) { entry.encodedSize = p.encodedDataLength; entry.endTime = p.timestamp * 1000; }
+    if (entry) {
+      entry.encodedSize = p.encodedDataLength;
+      entry.endTime = p.timestamp * 1000;
+    }
   });
 
   const offFailed = client.on('Network.loadingFailed', (params, sid) => {
     if (sid !== sessionId) return;
     const p = params as { requestId: string; timestamp: number };
     const entry = idx().get(p.requestId);
-    if (entry) { entry.endTime = p.timestamp * 1000; }
+    if (entry) {
+      entry.endTime = p.timestamp * 1000;
+    }
   });
 
   _captureListeners.set(sessionId, [offReq, offResp, offFinished, offFailed]);
@@ -151,7 +219,10 @@ export function startRequestCapture(client: CdpClient, sessionId: string): void
 
 export function stopRequestCapture(sessionId: string): void {
   const offs = _captureListeners.get(sessionId);
-  if (offs) { for (const off of offs) off(); _captureListeners.delete(sessionId); }
+  if (offs) {
+    for (const off of offs) off();
+    _captureListeners.delete(sessionId);
+  }
   _capturedRequests.delete(sessionId);
 }
 
@@ -165,20 +236,36 @@ export function clearCapturedRequests(sessionId: string): void {
 
 export async function disableInterception(client: CdpClient, sessionId: string): Promise<void> {
   const prevOff = _routeListeners.get(sessionId);
-  if (prevOff) { prevOff(); _routeListeners.delete(sessionId); }
+  if (prevOff) {
+    prevOff();
+    _routeListeners.delete(sessionId);
+  }
   await client.send('Fetch.disable', {}, sessionId);
 }
 
 export function teardownRouteInterception(sessionId: string): void {
   const prevOff = _routeListeners.get(sessionId);
-  if (prevOff) { prevOff(); _routeListeners.delete(sessionId); }
+  if (prevOff) {
+    prevOff();
+    _routeListeners.delete(sessionId);
+  }
 }
 
-export async function getLocalStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>> {
-  const result = await client.send<{ result: { value?: string }; exceptionDetails?: { text: string; exception?: { description?: string } } }>('Runtime.evaluate', {
-    expression: 'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))',
-    returnByValue: true,
-  }, sessionId);
+export async function getLocalStorage(
+  client: CdpClient,
+  sessionId: string,
+): Promise<Record<string, string>> {
+  const result = await client.send<{
+    result: { value?: string };
+    exceptionDetails?: { text: string; exception?: { description?: string } };
+  }>(
+    'Runtime.evaluate',
+    {
+      expression: 'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))',
+      returnByValue: true,
+    },
+    sessionId,
+  );
   if (result.exceptionDetails) return {};
   try {
     return JSON.parse(result.result?.value ?? '{}');
@@ -190,7 +277,7 @@ export async function getLocalStorage(client: CdpClient, sessionId: string): Pro
 export async function setLocalStorage(
   client: CdpClient,
   sessionId: string,
-  data: Record<string, string>
+  data: Record<string, string>,
 ): Promise<void> {
   const script = Object.entries(data)
     .map(([k, v]) => `localStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`)
@@ -201,16 +288,28 @@ export async function setLocalStorage(
       exceptionDetails?: { text: string; exception?: { description?: string } };
     }>('Runtime.evaluate', { expression: script, returnByValue: true }, sessionId);
     if (result.exceptionDetails) {
-      throw new Error(`setLocalStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`);
+      throw new Error(
+        `setLocalStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`,
+      );
     }
   }
 }
 
-export async function getSessionStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>> {
-  const result = await client.send<{ result: { value?: string }; exceptionDetails?: { text: string; exception?: { description?: string } } }>('Runtime.evaluate', {
-    expression: 'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))',
-    returnByValue: true,
-  }, sessionId);
+export async function getSessionStorage(
+  client: CdpClient,
+  sessionId: string,
+): Promise<Record<string, string>> {
+  const result = await client.send<{
+    result: { value?: string };
+    exceptionDetails?: { text: string; exception?: { description?: string } };
+  }>(
+    'Runtime.evaluate',
+    {
+      expression: 'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))',
+      returnByValue: true,
+    },
+    sessionId,
+  );
   if (result.exceptionDetails) return {};
   try {
     return JSON.parse(result.result?.value ?? '{}');
@@ -222,7 +321,7 @@ export async function getSessionStorage(client: CdpClient, sessionId: string): P
 export async function setSessionStorage(
   client: CdpClient,
   sessionId: string,
-  data: Record<string, string>
+  data: Record<string, string>,
 ): Promise<void> {
   const script = Object.entries(data)
     .map(([k, v]) => `sessionStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`)
@@ -233,7 +332,9 @@ export async function setSessionStorage(
       exceptionDetails?: { text: string; exception?: { description?: string } };
     }>('Runtime.evaluate', { expression: script, returnByValue: true }, sessionId);
     if (result.exceptionDetails) {
-      throw new Error(`setSessionStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`);
+      throw new Error(
+        `setSessionStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`,
+      );
     }
   }
 }

package/src/browser/pdf.ts

@@ -1,7 +1,7 @@
+import { writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
 
 export interface PdfOptions {
   path?: string;
@@ -19,7 +19,7 @@ export interface PdfOptions {
 export async function capturePdf(
   client: CdpClient,
   sessionId: string,
-  options: PdfOptions = {}
+  options: PdfOptions = {},
 ): Promise<string> {
   const params: Record<string, unknown> = {
     landscape: options.landscape ?? false,

package/src/browser/profiler.ts

@@ -1,27 +1,34 @@
+import { writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
 
 export interface ProfilerOptions {
   path?: string;
   samplingInterval?: number;
 }
 
+/** Heap snapshots on a large page take far longer than the 30s CDP default. */
+const HEAP_SNAPSHOT_TIMEOUT_MS = 120_000;
+
 const _sessions = new Set<string>();
 const _heapSessions = new Set<string>();
 
 export async function startCpuProfile(
   client: CdpClient,
   sessionId: string,
-  options: ProfilerOptions = {}
+  options: ProfilerOptions = {},
 ): Promise<void> {
   if (_sessions.has(sessionId)) {
     throw new Error('CPU profiler already running for this session');
   }
   await client.send('Profiler.enable', {}, sessionId);
   if (options.samplingInterval !== undefined) {
-    await client.send('Profiler.setSamplingInterval', { interval: options.samplingInterval }, sessionId);
+    await client.send(
+      'Profiler.setSamplingInterval',
+      { interval: options.samplingInterval },
+      sessionId,
+    );
   }
   await client.send('Profiler.start', {}, sessionId);
   _sessions.add(sessionId);
@@ -30,7 +37,7 @@ export async function startCpuProfile(
 export async function stopCpuProfile(
   client: CdpClient,
   sessionId: string,
-  outputPath?: string
+  outputPath?: string,
 ): Promise<string> {
   if (!_sessions.has(sessionId)) {
     throw new Error('No active CPU profiler for this session');
@@ -57,7 +64,7 @@ export function isProfilingActive(sessionId: string): boolean {
 export async function startHeapSnapshot(
   client: CdpClient,
   sessionId: string,
-  outputPath?: string
+  outputPath?: string,
 ): Promise<string> {
   if (_heapSessions.has(sessionId)) {
     throw new Error('Heap snapshot already in progress for this session');
@@ -72,24 +79,37 @@ export async function startHeapSnapshot(
   });
 
   try {
-    await new Promise<void>((resolve, reject) => {
-      const timeoutHandle = setTimeout(() => {
-        off2();
-        reject(new Error('Timeout waiting for heap snapshot (120s)'));
-      }, 120_000);
-      const off2 = client.on('HeapProfiler.reportHeapSnapshotProgress', (params, sid) => {
-        if (sid !== sessionId) return;
-        if (params.finished) { clearTimeout(timeoutHandle); off2(); resolve(); }
-      });
-      client.send('HeapProfiler.takeHeapSnapshot', { reportProgress: true }, sessionId)
-        .catch((err) => { clearTimeout(timeoutHandle); off2(); reject(err); });
-    });
+    // Resolve on takeHeapSnapshot's own RESPONSE, not on
+    // `HeapProfiler.reportHeapSnapshotProgress` with finished:true. Chrome
+    // emits that progress event once it has finished WALKING the heap, which
+    // is before it has streamed a single addHeapSnapshotChunk (verified
+    // against Chrome 153) — so resolving there detached the chunk listener in
+    // the `finally` below and wrote a 0-byte snapshot every single time. The
+    // command response is the only signal that every chunk has been sent.
+    //
+    // reportProgress is off for the same reason: nothing consumes those
+    // events any more, and they are pure noise on the wire.
+    await client.send(
+      'HeapProfiler.takeHeapSnapshot',
+      { reportProgress: false },
+      sessionId,
+      HEAP_SNAPSHOT_TIMEOUT_MS,
+    );
   } finally {
     off();
     _heapSessions.delete(sessionId);
     await client.send('HeapProfiler.disable', {}, sessionId).catch(() => {});
   }
 
+  // A zero-chunk snapshot is not a snapshot. Writing the empty file anyway is
+  // how this bug stayed invisible — the caller got a path, and only noticed
+  // when DevTools refused to load it.
+  if (chunks.length === 0) {
+    throw new Error(
+      'Heap snapshot produced no data — Chrome accepted HeapProfiler.takeHeapSnapshot but sent no chunks',
+    );
+  }
+
   const path = outputPath ?? join(tmpdir(), `monomind-heap-${Date.now()}.heapsnapshot`);
   await writeFile(path, chunks.join(''));
   return path;

package/src/browser/record.ts

@@ -1,7 +1,7 @@
+import { writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
 
 export interface RecordOptions {
   path?: string;
@@ -34,7 +34,7 @@ const _sessions = new Map<string, RecordingState>();
 export async function startRecording(
   client: CdpClient,
   sessionId: string,
-  options: RecordOptions = {}
+  options: RecordOptions = {},
 ): Promise<void> {
   const existing = _sessions.get(sessionId);
   if (existing && !existing.autoStopped) {
@@ -48,7 +48,12 @@ export async function startRecording(
     _sessions.delete(sessionId);
   }
 
-  const state: RecordingState = { frames: [], offScreencast: null, totalBytes: 0, autoStopped: false };
+  const state: RecordingState = {
+    frames: [],
+    offScreencast: null,
+    totalBytes: 0,
+    autoStopped: false,
+  };
   _sessions.set(sessionId, state);
 
   state.offScreencast = client.on('Page.screencastFrame', async (params, sid) => {
@@ -63,22 +68,28 @@ export async function startRecording(
         // eslint-disable-next-line no-console
         console.error(
           `[monobrowse] Screen recording auto-stopped: reached ${Math.round(MAX_SCREENCAST_BYTES / (1024 * 1024))}MB ` +
-          `of buffered frame data (${state.frames.length} frames). Call "record stop" to save what was captured.`
+            `of buffered frame data (${state.frames.length} frames). Call "record stop" to save what was captured.`,
         );
         await client.send('Page.stopScreencast', {}, sessionId).catch(() => {});
       }
     }
-    await client.send('Page.screencastFrameAck', { sessionId: frameSessionId }, sessionId).catch(() => {});
+    await client
+      .send('Page.screencastFrameAck', { sessionId: frameSessionId }, sessionId)
+      .catch(() => {});
   });
 
   try {
-    await client.send('Page.startScreencast', {
-      format: options.format ?? 'jpeg',
-      quality: options.quality ?? 80,
-      everyNthFrame: options.everyNthFrame ?? 1,
-      ...(options.maxWidth ? { maxWidth: options.maxWidth } : {}),
-      ...(options.maxHeight ? { maxHeight: options.maxHeight } : {}),
-    }, sessionId);
+    await client.send(
+      'Page.startScreencast',
+      {
+        format: options.format ?? 'jpeg',
+        quality: options.quality ?? 80,
+        everyNthFrame: options.everyNthFrame ?? 1,
+        ...(options.maxWidth ? { maxWidth: options.maxWidth } : {}),
+        ...(options.maxHeight ? { maxHeight: options.maxHeight } : {}),
+      },
+      sessionId,
+    );
   } catch (err) {
     state.offScreencast?.();
     _sessions.delete(sessionId);
@@ -89,7 +100,7 @@ export async function startRecording(
 export async function stopRecording(
   client: CdpClient,
   sessionId: string,
-  outputPath?: string
+  outputPath?: string,
 ): Promise<string> {
   const state = _sessions.get(sessionId);
   if (!state) throw new Error('No active recording for this session');
@@ -110,16 +121,24 @@ export async function stopRecording(
   return path;
 }
 
-export function getRecordingStatus(sessionId: string): { recording: boolean; frames: number; autoStopped: boolean } {
+export function getRecordingStatus(sessionId: string): {
+  recording: boolean;
+  frames: number;
+  autoStopped: boolean;
+} {
   const state = _sessions.get(sessionId);
-  return { recording: !!state && !state.autoStopped, frames: state?.frames.length ?? 0, autoStopped: state?.autoStopped ?? false };
+  return {
+    recording: !!state && !state.autoStopped,
+    frames: state?.frames.length ?? 0,
+    autoStopped: state?.autoStopped ?? false,
+  };
 }
 
 export async function saveFrameAsPng(
-  client: CdpClient,
+  _client: CdpClient,
   sessionId: string,
   frameIndex: number,
-  outputPath: string
+  outputPath: string,
 ): Promise<void> {
   const state = _sessions.get(sessionId);
   if (!state || frameIndex >= state.frames.length) {