browser-debugger-cli 0.13.0 → 0.15.0

package/dist/daemon/session/Session.js

@@ -11,8 +11,10 @@ import { connectCDP, navigateToTarget } from './cdpSetup.js';
 import { externalChromePort, findPageTarget, setupChromeConnection, } from './chromeConnection.js';
 import { startTelemetryCollectors } from './collectors.js';
 import { createCommandRegistry } from './commandRegistry.js';
+import { withMatchedStylesReset } from './matchedStylesReset.js';
 import { teardownSession } from './teardown.js';
 import { CommandError } from '../../errors/index.js';
+import { unknownSessionCommandMessage } from '../../errors/messages.js';
 import { applySessionEmulation } from '../../runtime/page/emulation.js';
 import { readPageLoadingState } from '../../runtime/page/loadingState.js';
 import { reapOrphanedChrome, removeSessionFiles } from '../../session/cleanup/staleSession.js';
@@ -151,7 +153,8 @@ export class 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.
+     * waiting for a page that cannot answer. Commands that may change the page
+     * drop `dom inspect`'s kept matched rules ({@link withMatchedStylesReset}).
      *
      * @param name - Command name
      * @param params - Command parameters
@@ -168,7 +171,12 @@ export class Session {
         if (crashedAt !== undefined && needsPage) {
             return Promise.reject(pageCrashedCommandError(crashedAt));
         }
-        return this.registry[name](this.cdp, params);
+        if (!Object.hasOwn(this.registry, name)) {
+            return Promise.reject(new CommandError(unknownSessionCommandMessage(name), {}, EXIT_CODES.INVALID_ARGUMENTS));
+        }
+        const handler = this.registry[name];
+        const cdp = this.cdp;
+        return withMatchedStylesReset(cdp, name, () => handler(cdp, params));
     }
     /**
      * Summary of this session for start responses.

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

@@ -1,9 +1,16 @@
 import type { DialogInfo } from '../../ipc/protocol/domTypes.js';
 import type { NavigationEvent } from '../../telemetry/navigation.js';
 import type { PendingRequest } from '../../telemetry/network.js';
+import type { NetworkEvictions } from '../../telemetry/networkRetention.js';
 import type { CDPTarget, ConsoleMessage, NetworkRequest, TelemetryType, WebSocketConnection } from '../../types.js';
 export declare class TelemetryStore {
+    /**
+     * Finished requests, oldest first: the newest are kept, so the session's
+     * `networkEvictions.requestsDropped` oldest ones are gone
+     */
     readonly networkRequests: NetworkRequest[];
+    /** Requests dropped and response bodies evicted at the capture limits */
+    readonly networkEvictions: NetworkEvictions;
     /** Requests still in flight, keyed by CDP requestId */
     readonly pendingNetworkRequests: Map<string, PendingRequest>;
     readonly consoleMessages: ConsoleMessage[];

package/dist/daemon/session/TelemetryStore.js

@@ -1,7 +1,13 @@
 import { MAX_CONSOLE_MESSAGES } from '../../constants.js';
 import { dialogConsoleText } from '../../ui/messages/commands.js';
 export class TelemetryStore {
+    /**
+     * Finished requests, oldest first: the newest are kept, so the session's
+     * `networkEvictions.requestsDropped` oldest ones are gone
+     */
     networkRequests = [];
+    /** Requests dropped and response bodies evicted at the capture limits */
+    networkEvictions = { requestsDropped: 0, bodiesEvicted: 0 };
     /** Requests still in flight, keyed by CDP requestId */
     pendingNetworkRequests = new Map();
     consoleMessages = [];

package/dist/daemon/session/commandRegistry.js

@@ -21,7 +21,7 @@ import { evaluateInBdgWorld, sendForBdgScript } from '../../runtime/page/bdgWorl
 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';
@@ -140,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.
@@ -319,6 +333,7 @@ export function createCommandRegistry(store, emulation) {
             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'
@@ -347,6 +362,8 @@ export function createCommandRegistry(store, emulation) {
                 totalNetwork,
                 totalConsole,
                 ...(dropped > 0 && { droppedConsole: dropped }),
+                ...(requestsDropped > 0 && { droppedNetwork: requestsDropped }),
+                ...(bodiesEvicted > 0 && { evictedNetworkBodies: bodiesEvicted }),
                 hasMoreNetwork: networkBounds.start > 0,
                 hasMoreConsole: consoleBounds.start > 0,
             });
@@ -377,12 +394,13 @@ export function createCommandRegistry(store, emulation) {
                         : { 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;
@@ -434,8 +452,8 @@ export function createCommandRegistry(store, emulation) {
             return { result, ...(hint !== undefined && { hint }) };
         },
         dom_eval: async (cdp, params) => params.frame === undefined
-            ? evaluateScript(cdp, params.script)
-            : evaluateInFrame(cdp, pageWebSocketUrl(store), params.script, params.frame, listedFrameIds),
+            ? evaluateScript(cdp, params.script, { full: params.full ?? false })
+            : evaluateInFrame(cdp, pageWebSocketUrl(store), params.script, params.frame, listedFrameIds, params.full ?? false),
         dom_frames: async (cdp) => {
             const { frames, frameIds } = await listFrames(cdp, pageWebSocketUrl(store));
             listedFrameIds = frameIds;

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

@@ -137,6 +137,7 @@ export function createDefaultTelemetryPlugins() {
                     fetchAllBodies: config.includeAll ?? false,
                     getCurrentNavigationId: store.getCurrentNavigationId ?? undefined,
                     pendingRequests: store.pendingNetworkRequests,
+                    evictions: store.networkEvictions,
                     ...filterDefined({
                         maxBodySize: config.maxBodySize,
                     }),

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.