browser-debugger-cli 0.12.0 → 0.14.0

package/dist/daemon/session/commandRegistry.js

@@ -17,10 +17,12 @@ import { inspectElement } from '../../runtime/dom/inspect.js';
 import { inspectLayout } from '../../runtime/dom/layout.js';
 import { onScriptTarget } from '../../runtime/dom/targetNode.js';
 import { waitForCondition } from '../../runtime/dom/wait.js';
+import { evaluateInBdgWorld, sendForBdgScript } from '../../runtime/page/bdgWorld.js';
 import { emulatePage, pageAppearance } from '../../runtime/page/emulation.js';
 import { readDocumentReadyState } from '../../runtime/page/loadingState.js';
 import { navigatePage } from '../../runtime/page/navigation.js';
-import { skippedBodyReason } from '../../telemetry/network.js';
+import { skippedBodyReason } from '../../telemetry/networkRetention.js';
+import { consoleMessageDroppedError } from '../../ui/messages/consoleMessages.js';
 import { sessionCommand } from '../../ui/messages/sessionCommand.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
 import { filterDefined } from '../../utils/objects.js';
@@ -138,6 +140,20 @@ function webSocketAsRequest(connection) {
         webSocket: { frames: connection.frames, ...(closedTime !== undefined && { closedTime }) },
     };
 }
+/**
+ * Status activity counts of what the network capture let go at its limits,
+ * left out when nothing was.
+ *
+ * @param store - Telemetry store
+ * @returns `networkRequestsDropped` and `networkBodiesEvicted` when non-zero
+ */
+function networkEvictionActivity(store) {
+    const { requestsDropped, bodiesEvicted } = store.networkEvictions;
+    return {
+        ...(requestsDropped > 0 && { networkRequestsDropped: requestsDropped }),
+        ...(bodiesEvicted > 0 && { networkBodiesEvicted: bodiesEvicted }),
+    };
+}
 /**
  * All captured network activity: finished and in-flight requests and
  * WebSocket connections, in start order.
@@ -187,24 +203,28 @@ function findNetworkRequestOrThrow(store, id) {
     return request;
 }
 /**
- * Find console message by index or throw.
+ * Find console message by its session index or throw.
  *
- * @param messages - Array of console messages
+ * @param messages - Console messages kept
  * @param indexStr - Index as string
+ * @param dropped - Messages dropped before the first kept one (its index)
  * @returns Found message
- * @throws Error if invalid index or not found
+ * @throws CommandError if the index is invalid, dropped or not found
  */
-function findConsoleMessageOrThrow(messages, indexStr) {
+function findConsoleMessageOrThrow(messages, indexStr, dropped) {
     if (!/^\d+$/.test(indexStr)) {
         throw new CommandError(`Invalid console message index: ${indexStr}`, { suggestion: `Use a 0-based index from: ${sessionCommand('bdg console --list')}` }, EXIT_CODES.INVALID_ARGUMENTS);
     }
     const index = parseInt(indexStr, 10);
-    if (index >= messages.length) {
+    if (index < dropped) {
+        throw new CommandError(consoleMessageDroppedError(index, dropped), { suggestion: `List messages with: ${sessionCommand('bdg console --list')}` }, EXIT_CODES.RESOURCE_NOT_FOUND);
+    }
+    if (index - dropped >= messages.length) {
         throw new CommandError(messages.length === 0
             ? `Console message not found at index: ${indexStr} (no messages captured yet)`
-            : `Console message not found at index: ${indexStr} (available: 0-${messages.length - 1})`, { suggestion: `List messages with: ${sessionCommand('bdg console --list')}` }, EXIT_CODES.RESOURCE_NOT_FOUND);
+            : `Console message not found at index: ${indexStr} (available: ${dropped}-${dropped + messages.length - 1})`, { suggestion: `List messages with: ${sessionCommand('bdg console --list')}` }, EXIT_CODES.RESOURCE_NOT_FOUND);
     }
-    const message = messages[index];
+    const message = messages[index - dropped];
     if (!message) {
         throw new CommandError(`Console message not found at index: ${indexStr}`, {}, EXIT_CODES.RESOURCE_NOT_FOUND);
     }
@@ -312,6 +332,8 @@ export function createCommandRegistry(store, emulation) {
             const allNetwork = allNetworkRequests(store);
             const totalNetwork = allNetwork.length;
             const totalConsole = store.consoleMessages.length;
+            const dropped = store.consoleDropped;
+            const { requestsDropped, bodiesEvicted } = store.networkEvictions;
             const networkBounds = calculateSliceBounds(totalNetwork, lastN, offset);
             const consoleBounds = calculateSliceBounds(totalConsole, lastN, offset);
             const recentNetwork = params.only === 'console'
@@ -323,7 +345,7 @@ export function createCommandRegistry(store, emulation) {
                 ? []
                 : store.consoleMessages
                     .slice(consoleBounds.start, consoleBounds.end)
-                    .map((msg, i) => mapConsoleMessageToPreview(msg, consoleBounds.start + i));
+                    .map((msg, i) => mapConsoleMessageToPreview(msg, dropped + consoleBounds.start + i));
             return Promise.resolve({
                 version: VERSION,
                 startTime: store.sessionStartTime,
@@ -334,10 +356,14 @@ export function createCommandRegistry(store, emulation) {
                 },
                 activeTelemetry: store.activeTelemetry,
                 currentNavigationId: store.getCurrentNavigationId?.() ?? 0,
+                ...(store.pageCrashedAt !== undefined && { pageCrashedAt: store.pageCrashedAt }),
                 network: recentNetwork,
                 console: recentConsole,
                 totalNetwork,
                 totalConsole,
+                ...(dropped > 0 && { droppedConsole: dropped }),
+                ...(requestsDropped > 0 && { droppedNetwork: requestsDropped }),
+                ...(bodiesEvicted > 0 && { evictedNetworkBodies: bodiesEvicted }),
                 hasMoreNetwork: networkBounds.start > 0,
                 hasMoreConsole: consoleBounds.start > 0,
             });
@@ -348,7 +374,7 @@ export function createCommandRegistry(store, emulation) {
                 return Promise.resolve({ item: withBodyNotCaptured(request) });
             }
             if (params.itemType === 'console') {
-                const message = findConsoleMessageOrThrow(store.consoleMessages, params.id);
+                const message = findConsoleMessageOrThrow(store.consoleMessages, params.id, store.consoleDropped);
                 return Promise.resolve({ item: message });
             }
             return Promise.reject(new Error(`Unknown itemType: ${String(params.itemType)}. Expected 'network' or 'console'.`));
@@ -363,15 +389,18 @@ export function createCommandRegistry(store, emulation) {
                 target: {
                     url: store.targetInfo?.url ?? '',
                     title: store.targetInfo?.title ?? '',
-                    ...(await pageAppearance(cdp)),
+                    ...(store.pageCrashedAt === undefined
+                        ? await pageAppearance(cdp)
+                        : { crashedAt: store.pageCrashedAt }),
                 },
                 activeTelemetry: store.activeTelemetry,
-                activity: filterDefined({
+                activity: {
                     networkRequestsCaptured: store.networkRequests.length,
                     consoleMessagesCaptured: store.consoleMessages.length,
-                    lastNetworkRequestAt: lastNetworkRequest?.timestamp,
-                    lastConsoleMessageAt: lastConsoleMessage?.timestamp,
-                }),
+                    ...(lastNetworkRequest && { lastNetworkRequestAt: lastNetworkRequest.timestamp }),
+                    ...(lastConsoleMessage && { lastConsoleMessageAt: lastConsoleMessage.timestamp }),
+                    ...networkEvictionActivity(store),
+                },
                 navigationId: store.getCurrentNavigationId?.() ?? 0,
             };
             return result;
@@ -401,10 +430,15 @@ export function createCommandRegistry(store, emulation) {
             });
         },
         cdp_call: async (cdp, params) => {
-            const result = await withBusyPageRecovery(cdp, cdp.send(params.method, params.params ?? {}).catch((error) => {
+            const send = params.isolated
+                ? sendForBdgScript(cdp, params.method, params.params ?? {})
+                : cdp.send(params.method, params.params ?? {});
+            const result = await withBusyPageRecovery(cdp, send.catch((error) => {
                 throw callerError(params.method, error) ?? error;
             }));
-            const detectionResult = patternDetector.trackCommand(params.method);
+            const detectionResult = params.isolated
+                ? { shouldShow: false, pattern: undefined }
+                : patternDetector.trackCommand(params.method);
             let hint;
             if (detectionResult.shouldShow && detectionResult.pattern) {
                 hint = {
@@ -475,7 +509,7 @@ export function createCommandRegistry(store, emulation) {
             return { emulated, ...(await pageAppearance(cdp)) };
         },
         dom_form_discover: async (cdp) => {
-            const response = await withBusyPageRecovery(cdp, cdp.send('Runtime.evaluate', {
+            const response = await withBusyPageRecovery(cdp, evaluateInBdgWorld(cdp, {
                 expression: FORM_DISCOVERY_SCRIPT,
                 returnByValue: true,
             }));

package/dist/daemon/session/interactions.d.ts

@@ -51,7 +51,8 @@ export type InteractionRunner = <T extends object>(cdp: CDPConnection, action: (
  * queued. After each one, the bound target (`window.__bdgTarget`) is removed
  * from the page (without waiting: during a pending navigation that takes until
  * the new page commits), and the dialogs it opened, what it changed on the
- * page (see {@link watchActionEffects}) and the network requests it
+ * page (see {@link watchActionEffects}; a console message logged meanwhile
+ * counts as an effect) and the network requests it
  * triggered (see {@link watchTriggeredRequests}) are added to its result,
  * and, when asked, what the page was still working on (see
  * {@link pendingChanges}). They are attributed by time: a dialog or request

package/dist/daemon/session/interactions.js

@@ -18,6 +18,15 @@ const log = createLogger('dom');
 function succeeded(result) {
     return !('success' in result) || result.success !== false;
 }
+/**
+ * Console messages the session has logged, dropped ones included.
+ *
+ * @param store - Session store
+ * @returns Count that only grows
+ */
+function consoleMessagesLogged(store) {
+    return store.consoleDropped + store.consoleMessages.length;
+}
 /**
  * Create the runner for a session's interactions.
  *
@@ -26,7 +35,8 @@ function succeeded(result) {
  * queued. After each one, the bound target (`window.__bdgTarget`) is removed
  * from the page (without waiting: during a pending navigation that takes until
  * the new page commits), and the dialogs it opened, what it changed on the
- * page (see {@link watchActionEffects}) and the network requests it
+ * page (see {@link watchActionEffects}; a console message logged meanwhile
+ * counts as an effect) and the network requests it
  * triggered (see {@link watchTriggeredRequests}) are added to its result,
  * and, when asked, what the page was still working on (see
  * {@link pendingChanges}). They are attributed by time: a dialog or request
@@ -41,6 +51,7 @@ export function createInteractionRunner(store) {
     return (cdp, action, options = {}) => {
         const run = queue.then(async () => {
             const firstDialog = store.dialogs.length;
+            const firstConsoleMessage = consoleMessagesLogged(store);
             const collectRequests = options.reportRequests === false ? undefined : watchTriggeredRequests(store);
             const effects = options.reportEffects === false ? undefined : watchActionEffects(cdp);
             try {
@@ -50,6 +61,7 @@ export function createInteractionRunner(store) {
                     return { ...result, ...(dialogs.length > 0 && { dialogs }) };
                 const collected = await effects?.collect({
                     dialogs: dialogs.length,
+                    consoleMessages: () => consoleMessagesLogged(store) - firstConsoleMessage,
                     detectNoEffect: options.detectNoEffect === true,
                     reportShown: options.reportShown === true,
                     detectUnsettled: options.detectUnsettled === true,

package/dist/daemon/session/matchedStylesReset.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `dom inspect` keeps slow matched-rules answers for a few seconds, but page
+ * state such as `:checked`, `:hover` or `:focus` changes without any CDP
+ * event. Every daemon command that may change the page drops them, before
+ * and after it runs. Hooking the commands rather than the CDP methods they
+ * send keeps `dom inspect`'s own page scripts from clearing its answers, and
+ * listing the read-only commands makes a new command reset by default.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { CommandName } from '../../ipc/index.js';
+/**
+ * Commands that leave the page as it is: they read it, or only the telemetry.
+ * Any command not listed (new ones included) resets by default.
+ */
+export declare const KEEPS_MATCHED_STYLES: ReadonlySet<CommandName>;
+/**
+ * Run a command, dropping the kept matched rules before and after it unless
+ * it leaves the page as it is.
+ *
+ * @param cdp - CDP connection
+ * @param name - Command name
+ * @param run - The command
+ * @returns Its result
+ */
+export declare function withMatchedStylesReset<T>(cdp: CDPConnection, name: CommandName, run: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=matchedStylesReset.d.ts.map

package/dist/daemon/session/matchedStylesReset.js

@@ -0,0 +1,46 @@
+/**
+ * `dom inspect` keeps slow matched-rules answers for a few seconds, but page
+ * state such as `:checked`, `:hover` or `:focus` changes without any CDP
+ * event. Every daemon command that may change the page drops them, before
+ * and after it runs. Hooking the commands rather than the CDP methods they
+ * send keeps `dom inspect`'s own page scripts from clearing its answers, and
+ * listing the read-only commands makes a new command reset by default.
+ */
+import { resetMatchedStyles } from '../../runtime/dom/inspectRules.js';
+/**
+ * Commands that leave the page as it is: they read it, or only the telemetry.
+ * Any command not listed (new ones included) resets by default.
+ */
+export const KEEPS_MATCHED_STYLES = new Set([
+    'session_peek',
+    'session_details',
+    'session_status',
+    'session_har_data',
+    'session_network_headers',
+    'dom_frames',
+    'dom_form_discover',
+    'dom_listeners',
+    'dom_layout',
+    'dom_audit',
+    'css_search',
+    'dom_inspect',
+]);
+/**
+ * Run a command, dropping the kept matched rules before and after it unless
+ * it leaves the page as it is.
+ *
+ * @param cdp - CDP connection
+ * @param name - Command name
+ * @param run - The command
+ * @returns Its result
+ */
+export function withMatchedStylesReset(cdp, name, run) {
+    if (KEEPS_MATCHED_STYLES.has(name))
+        return run();
+    const reset = () => resetMatchedStyles(cdp);
+    reset();
+    const result = run();
+    void result.then(reset, reset);
+    return result;
+}
+//# sourceMappingURL=matchedStylesReset.js.map

package/dist/daemon/session/plugins.js

@@ -1,10 +1,11 @@
+import { hideHeadlessUserAgent } from '../../runtime/page/userAgent.js';
 import { startConsoleCollection } from '../../telemetry/console.js';
 import { startDialogHandling } from '../../telemetry/dialogs.js';
 import { prepareDOMCollection } from '../../telemetry/dom.js';
 import { startNavigationTracking } from '../../telemetry/navigation.js';
 import { startNetworkCollection, startWebSocketCollection } from '../../telemetry/network.js';
+import { pageCrashedCommandError, startCrashTracking } from '../../telemetry/pageCrash.js';
 import { getErrorMessage } from '../../utils/errors.js';
-import { hideHeadlessUserAgent } from '../../runtime/page/userAgent.js';
 import { filterDefined } from '../../utils/objects.js';
 /** Delay before reading the title after a same-document navigation */
 const TITLE_REFRESH_DELAY_MS = 300;
@@ -103,6 +104,17 @@ export function createDefaultTelemetryPlugins() {
                 return () => undefined;
             },
         },
+        {
+            name: 'page-crash',
+            runAlways: true,
+            async start({ cdp, store }) {
+                return startCrashTracking(cdp, (crashedAt) => {
+                    store.pageCrashedAt = crashedAt;
+                    if (crashedAt !== undefined)
+                        cdp.rejectPending(pageCrashedCommandError(crashedAt));
+                });
+            },
+        },
         {
             name: 'navigation',
             runAlways: true,
@@ -125,6 +137,7 @@ export function createDefaultTelemetryPlugins() {
                     fetchAllBodies: config.includeAll ?? false,
                     getCurrentNavigationId: store.getCurrentNavigationId ?? undefined,
                     pendingRequests: store.pendingNetworkRequests,
+                    evictions: store.networkEvictions,
                     ...filterDefined({
                         maxBodySize: config.maxBodySize,
                     }),
@@ -143,7 +156,9 @@ export function createDefaultTelemetryPlugins() {
             name: 'console',
             telemetry: 'console',
             async start({ cdp, config, store }) {
-                return startConsoleCollection(cdp, store.consoleMessages, config.includeAll ?? false, store.getCurrentNavigationId ?? undefined);
+                return startConsoleCollection(cdp, store.consoleMessages, config.includeAll ?? false, store.getCurrentNavigationId ?? undefined, () => {
+                    store.consoleDropped++;
+                });
             },
         },
         {

package/dist/daemon/session/teardown.js

@@ -123,6 +123,6 @@ async function terminateChrome(chrome, log) {
         log.info(`Chrome (PID ${pid}) survived SIGKILL`);
         return;
     }
-    clearChromePid();
+    clearChromePid(pid);
 }
 //# sourceMappingURL=teardown.js.map

package/dist/daemon/session/triggeredRequests.d.ts

@@ -5,11 +5,6 @@
 import type { TelemetryStore } from './TelemetryStore.js';
 import type { TriggeredRequest } from '../../ipc/protocol/domTypes.js';
 import type { NetworkRequest } from '../../types.js';
-/**
- * Requests listed in a result (a click that loads a page triggers its whole
- * load); notable ones ({@link isNotableRequest}) are kept before assets
- */
-export declare const MAX_TRIGGERED_REQUESTS = 50;
 /** Requests started since the watch began: the first ones, and how many more there were */
 export interface CollectedRequests {
     triggeredRequests: TriggeredRequest[];

package/dist/daemon/session/triggeredRequests.js

@@ -2,15 +2,11 @@
  * Network requests an interaction triggered, read from the session's network
  * telemetry (no CDP listeners of its own).
  */
+import { MAX_TRIGGERED_REQUESTS } from '../../constants.js';
 import { isNotableRequest } from '../../telemetry/requestKinds.js';
 import { failureReason, getRequestState } from '../../telemetry/requestState.js';
 /** URLs that never reach the network (inline data, in-page objects) */
 const LOCAL_URL_PATTERN = /^(data|blob):/i;
-/**
- * Requests listed in a result (a click that loads a page triggers its whole
- * load); notable ones ({@link isNotableRequest}) are kept before assets
- */
-export const MAX_TRIGGERED_REQUESTS = 50;
 /**
  * Start attributing requests to an interaction.
  *
@@ -28,11 +24,12 @@ export function watchTriggeredRequests(store) {
     if (!store.activeTelemetry.includes('network'))
         return () => undefined;
     const startedAt = Date.now();
-    const firstFinished = store.networkRequests.length;
+    const firstFinished = requestsFinished(store);
     const firstWebSocket = store.websocketConnections.length;
     return () => {
+        const firstKept = Math.max(0, firstFinished - store.networkEvictions.requestsDropped);
         const started = [
-            ...store.networkRequests.slice(firstFinished).map((request) => ({ request })),
+            ...store.networkRequests.slice(firstKept).map((request) => ({ request })),
             ...[...store.pendingNetworkRequests.values()].map((pending) => ({
                 request: pending.request,
                 inFlight: true,
@@ -52,6 +49,15 @@ export function watchTriggeredRequests(store) {
         };
     };
 }
+/**
+ * Requests the session has finished, dropped ones included.
+ *
+ * @param store - Session store
+ * @returns Count that only grows
+ */
+function requestsFinished(store) {
+    return store.networkEvictions.requestsDropped + store.networkRequests.length;
+}
 /**
  * At most `limit` requests, notable ones first (pages, API calls, sockets,
  * failures), then assets, still in start order.