browser-debugger-cli 0.12.0 → 0.13.0

package/dist/daemon/session/Session.js

@@ -18,6 +18,7 @@ import { readPageLoadingState } from '../../runtime/page/loadingState.js';
 import { reapOrphanedChrome, removeSessionFiles } from '../../session/cleanup/staleSession.js';
 import { writeSessionMetadata } from '../../session/metadata.js';
 import { getSessionPort } from '../../session/port.js';
+import { pageCrashedCommandError } from '../../telemetry/pageCrash.js';
 import { createLogger } from '../../ui/logging/index.js';
 import { formatChromeNotice } from '../../ui/messages/chrome.js';
 import { delay } from '../../utils/async.js';
@@ -31,6 +32,26 @@ const log = createLogger('session');
 const CRASH_SETTLE_MS = 500;
 /** Ports tried when automatically chosen ports turn out to be taken */
 const PORT_ATTEMPTS = 3;
+/**
+ * Commands that still work after the page's renderer crashed: they read what
+ * the session collected, load the page again (`page reload`/`navigate`) or
+ * send raw CDP. Every other command needs the page and fails at once.
+ */
+const RUN_ON_CRASHED_PAGE = new Set([
+    'session_peek',
+    'session_details',
+    'session_status',
+    'session_har_data',
+    'session_network_headers',
+    'page_navigate',
+    'cdp_call',
+]);
+/**
+ * CDP methods `bdg cdp` may still send after a renderer crash: loading the
+ * page again, and domains the browser process answers. Others wait for the
+ * renderer, which never answers.
+ */
+const CRASH_SAFE_CDP = /^(Page\.(navigate|reload|getNavigationHistory|navigateToHistoryEntry)|Target\.|Browser\.|Inspector\.|Network\.(?!getResponseBody|getRequestPostData)|Storage\.|SystemInfo\.)/;
 /**
  * Whether a launch failed because another process holds the port.
  *
@@ -127,7 +148,10 @@ export class Session {
         }
     }
     /**
-     * Execute a registered command against this session.
+     * Execute a registered command against this session. After a renderer
+     * crash only {@link RUN_ON_CRASHED_PAGE} commands run (`bdg cdp` only for
+     * {@link CRASH_SAFE_CDP} methods); others fail with exit 107 instead of
+     * waiting for a page that cannot answer.
      *
      * @param name - Command name
      * @param params - Command parameters
@@ -137,6 +161,13 @@ export class Session {
         if (!this.cdp || !this.started || this.stopping) {
             return Promise.reject(new Error('No active session'));
         }
+        const crashedAt = this.store.pageCrashedAt;
+        const cdpMethod = name === 'cdp_call' ? params.method : undefined;
+        const needsPage = !RUN_ON_CRASHED_PAGE.has(name) ||
+            (cdpMethod !== undefined && !CRASH_SAFE_CDP.test(cdpMethod));
+        if (crashedAt !== undefined && needsPage) {
+            return Promise.reject(pageCrashedCommandError(crashedAt));
+        }
         return this.registry[name](this.cdp, params);
     }
     /**
@@ -223,7 +254,7 @@ export class Session {
             await this.releaseResources();
             if (!this.started)
                 return;
-            removeSessionFiles();
+            removeSessionFiles(process.pid);
             this.onEnded(reason);
         })();
         return this.stopping;

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

@@ -7,11 +7,18 @@ export declare class TelemetryStore {
     /** Requests still in flight, keyed by CDP requestId */
     readonly pendingNetworkRequests: Map<string, PendingRequest>;
     readonly consoleMessages: ConsoleMessage[];
+    /**
+     * Console messages dropped at the limit, oldest first: the index of
+     * `consoleMessages[i]` in the session is `consoleDropped + i`
+     */
+    consoleDropped: number;
     readonly navigationEvents: NavigationEvent[];
     readonly websocketConnections: WebSocketConnection[];
     /** JavaScript dialogs accepted during the session */
     readonly dialogs: DialogInfo[];
     activeTelemetry: TelemetryType[];
+    /** When the page's renderer crashed (epoch ms); undefined while the page is alive */
+    pageCrashedAt: number | undefined;
     getCurrentNavigationId: (() => number) | null;
     sessionStartTime: number;
     targetInfo: CDPTarget | null;
@@ -21,7 +28,7 @@ export declare class TelemetryStore {
     /**
      * Record an accepted dialog, and show it among the console messages when
      * console telemetry is collected (it is otherwise invisible: bdg accepts it
-     * before anyone could see it).
+     * before anyone could see it), dropping the oldest message at the limit.
      *
      * @param dialog - Dialog type and text
      */

package/dist/daemon/session/TelemetryStore.js

@@ -1,14 +1,22 @@
+import { MAX_CONSOLE_MESSAGES } from '../../constants.js';
 import { dialogConsoleText } from '../../ui/messages/commands.js';
 export class TelemetryStore {
     networkRequests = [];
     /** Requests still in flight, keyed by CDP requestId */
     pendingNetworkRequests = new Map();
     consoleMessages = [];
+    /**
+     * Console messages dropped at the limit, oldest first: the index of
+     * `consoleMessages[i]` in the session is `consoleDropped + i`
+     */
+    consoleDropped = 0;
     navigationEvents = [];
     websocketConnections = [];
     /** JavaScript dialogs accepted during the session */
     dialogs = [];
     activeTelemetry = [];
+    /** When the page's renderer crashed (epoch ms); undefined while the page is alive */
+    pageCrashedAt;
     getCurrentNavigationId = null;
     sessionStartTime = Date.now();
     targetInfo = null;
@@ -24,7 +32,7 @@ export class TelemetryStore {
     /**
      * Record an accepted dialog, and show it among the console messages when
      * console telemetry is collected (it is otherwise invisible: bdg accepts it
-     * before anyone could see it).
+     * before anyone could see it), dropping the oldest message at the limit.
      *
      * @param dialog - Dialog type and text
      */
@@ -32,6 +40,10 @@ export class TelemetryStore {
         this.dialogs.push(dialog);
         if (!this.activeTelemetry.includes('console'))
             return;
+        if (this.consoleMessages.length >= MAX_CONSOLE_MESSAGES) {
+            this.consoleMessages.shift();
+            this.consoleDropped++;
+        }
         this.consoleMessages.push({
             type: 'info',
             text: dialogConsoleText(dialog),

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 { 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';
@@ -187,24 +189,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 +318,7 @@ export function createCommandRegistry(store, emulation) {
             const allNetwork = allNetworkRequests(store);
             const totalNetwork = allNetwork.length;
             const totalConsole = store.consoleMessages.length;
+            const dropped = store.consoleDropped;
             const networkBounds = calculateSliceBounds(totalNetwork, lastN, offset);
             const consoleBounds = calculateSliceBounds(totalConsole, lastN, offset);
             const recentNetwork = params.only === 'console'
@@ -323,7 +330,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 +341,12 @@ 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 }),
                 hasMoreNetwork: networkBounds.start > 0,
                 hasMoreConsole: consoleBounds.start > 0,
             });
@@ -348,7 +357,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,7 +372,9 @@ 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({
@@ -401,10 +412,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 +491,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/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,
@@ -143,7 +155,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