browser-debugger-cli 0.13.0 → 0.15.0

package/dist/commands/optionBehaviors.js

@@ -65,8 +65,9 @@ const OPTION_BEHAVIORS = {
     },
     'get:--full': {
         default: 'Semantic output shows the element text up to 500 characters (whitespace collapsed; close buttons such as "×" and aria-hidden icons left out)',
-        whenEnabled: 'Shows all of the element text; cannot be combined with --raw or --node-id',
-        tokenImpact: 'A page-sized container can add thousands of tokens; target the element you need',
+        whenEnabled: 'Shows all of the element text; with --raw (or --node-id) prints the whole outer HTML instead of its first 20000 characters, and JSON outerHTML is whole too (else cut to 20000 with truncatedFrom, the original length)',
+        automaticBehavior: 'Without --full, --raw output cuts each element\'s HTML at 20000 characters and ends it with "… N more chars (use --full)"',
+        tokenImpact: 'A page-sized container can add thousands of tokens; dom get body --raw --full on Wikipedia is about 3.4 MB. Target the element you need',
     },
     'get:--all': {
         default: 'Returns first matching element only',
@@ -78,30 +79,42 @@ const OPTION_BEHAVIORS = {
         automaticBehavior: 'Past the last match exits 81; a numeric index argument (a cached query index) past the indexed matches, or from an earlier page, exits 87 (re-run dom query)',
     },
     'query:--limit': {
-        default: 'dom query and dom a11y query list the first 50 matches and say how many more there are; --json returns 1000 (dom query) or all of them (dom a11y query)',
+        default: 'dom query and dom a11y query list the first 50 matches and say how many more there are; --json lists the first 100 with count (all matches) and omitted (the rest)',
         whenEnabled: 'Lists that many matches (0 = all), in human and JSON output; count is always the total, JSON omitted the rest',
         automaticBehavior: 'Matches are cached for index-based access (bdg dom click 55 works even when 50 are listed): all of them for dom a11y query, the first 1000 (or --limit, if higher) for dom query, which describes only those, so a page with 50000 matches answers in under a second; an element the page and frame trees both report is listed once. Indices work with click, fill, hover, pressKey, scroll, submit, layout, get and listeners, also for elements of a cross-origin iframe of the same site (a consent dialog), whose scripts then run in that frame',
-        tokenImpact: 'About one line per match; a page can have hundreds of links',
+        tokenImpact: 'About one line per match (piped JSON about 160 bytes per dom query match, 230 per a11y match); a page can have thousands of links: on Wikipedia "United States" --limit 0 --json is 1.0 MB (dom query a) and 1.3 MB (dom a11y query role:link), the default 16 KB and 23 KB',
+    },
+    'tree:--limit': {
+        default: 'dom a11y tree lists the first 50 meaningful nodes depth-first, in human and JSON output; JSON count is the whole tree = nodes listed + omitted (cut by --limit/--depth) + skipped (never listed)',
+        whenEnabled: 'Lists that many nodes; 0 = all listed nodes (text boxes and empty wrappers are always skipped)',
+        automaticBehavior: 'Ignored nodes, text boxes, blank text, text repeating its parent name and nameless layout wrappers (generic, none, presentation, layout tables) are never listed (JSON skipped counts them); their children move up a level. For the raw tree with every node use bdg cdp Accessibility.getFullAXTree --json. JSON nodes carry depth (0 = root) instead of childIds; nodes outside the root (frame content) follow the root tree',
+        tokenImpact: 'About 140 bytes per piped JSON node (7 KB by default); the whole tree of a long page is megabytes (Wikipedia "United States": 51k nodes, 20k listed, 2.6 MB with --limit 0 --json), so prefer --depth or dom a11y query "role:<role>"',
+    },
+    'tree:--depth': {
+        default: 'dom a11y tree lists every level (up to --limit nodes)',
+        whenEnabled: 'Lists nodes down to that level (0 = root only); deeper nodes are counted in omitted',
+        tokenImpact: 'An outline of a page (landmarks, headings) in a few levels',
     },
     'eval:--frame': {
         default: "Evaluates in the page's main frame",
         whenEnabled: "Evaluates in one iframe's main world (its own globals), including cross-origin (out-of-process) iframes; output gains a frame field (its URL)",
         automaticBehavior: 'The value is matched as: a 0-based index (bdg dom frames order: document order of the <iframe> elements, nested ones depth-first, main page not counted), else an exact name/id attribute, else a case-insensitive part of the name, id or URL. Several matches fail with 81 listing them; none fails with 83 listing all frames. Frames are looked up on every call (a reloaded iframe is found again). An index that names another frame than in the last bdg dom frames listing (iframes added, removed or moved, or the page navigated) fails with 87 STALE_CACHE: re-run bdg dom frames or pick the frame by name.',
     },
-    'console:-H': {
-        default: 'Shows messages from current page load only (most recent navigation)',
-        whenEnabled: 'Shows messages from ALL page loads during the session',
-        automaticBehavior: 'Page navigations create new "navigation contexts" - default filters to latest context',
+    'eval:--full': {
+        default: 'Human output prints the first 20000 characters of the value followed by "… N more chars (use --full)". In JSON a string result is cut to 20000 characters with truncatedFrom (the original length); an array result lists its first 100 elements with count (all of them) and omitted; an object or array whose JSON is still over 20000 characters becomes the first 20000 characters of its JSON text (a string; arrays keep count) with truncatedFrom (the length of the JSON text of the copy, which holds at most 1000 entries per list or object): a string result with truncatedFrom while type is object is such a JSON-text start',
+        whenEnabled: 'Prints the whole value, byte for byte; objects and arrays are copied with every entry (without --full at most 1000 per list or object)',
+        tokenImpact: 'dom eval document.documentElement.outerHTML on Wikipedia is about 3.6 MB with --full; on a page with 20000 elements, [...document.querySelectorAll("*")].map(e => e.outerHTML) --json is 3 MB with --full and 23 KB without; select what you need in the expression instead',
+    },
+    'console:--full': {
+        default: 'Message texts are cut: human output (summary, --list, --follow) at 200 characters followed by "… N more chars (use --full)"; JSON text at 10000 characters with truncatedFrom (the original length)',
+        whenEnabled: 'Message texts are printed whole, in human and JSON output',
+        tokenImpact: 'A page that logs a large payload or throws a long error can add megabytes; bdg details console <n> shows one message whole',
     },
     'console:--history': {
         default: 'Shows messages from current page load only (most recent navigation)',
         whenEnabled: 'Shows messages from ALL page loads during the session',
         automaticBehavior: 'Page navigations create new "navigation contexts" - default filters to latest context',
     },
-    'console:-l': {
-        default: 'Smart summary with errors deduplicated and warnings grouped: the newest 50 distinct errors and warnings, with a note for the earlier ones. The session keeps the newest 10000 messages; dropped ones are counted (dropped in JSON)',
-        whenEnabled: 'Lists all messages chronologically without deduplication',
-    },
     'console:--list': {
         default: 'Smart summary with errors deduplicated and warnings grouped: the newest 50 distinct errors and warnings, with a note for the earlier ones. The session keeps the newest 10000 messages; dropped ones are counted (dropped in JSON)',
         whenEnabled: 'Lists all messages chronologically without deduplication',
@@ -253,6 +266,7 @@ const OPTION_BEHAVIORS = {
     },
     'inspect:--no-hints': {
         default: "Hints at the element's own author declarations that have no effect (flex/grid properties without flex or grid, item properties without a flex or grid parent, offsets on static elements, sizes on inline ones, var() of an unset custom property, form controls in the browser's font), within a 1 s budget; hints none when nothing was found",
+        automaticBehavior: "After a hint read times out, later inspects on the same page skip the hints without waiting (hints skipped: this page's stylesheets are slow to read) until a read is fast again, a stylesheet changes or it navigates; --rules and --why still wait up to 5 s. Matched rules that took over 300 ms are reused for up to 5 s, until a command that may change the page or a stylesheet or DOM change",
         whenEnabled: 'Skips the hints and does not read the matched rules',
     },
     'scroll:--down': {
@@ -293,56 +307,57 @@ const OPTION_BEHAVIORS = {
         whenEnabled: 'Quick scan: field names, types, and required status only',
         tokenImpact: 'Reduces output ~50% for initial discovery',
     },
+    'peek:--full': {
+        default: 'Console message texts are cut: human output at 200 characters (compact output also at 2 lines) followed by "… N more chars (use --full)"; JSON text at 10000 characters with truncatedFrom (the original length)',
+        whenEnabled: 'Console message texts are printed whole, in human and JSON output',
+        tokenImpact: 'A page that logs a large payload can add megabytes per peek',
+    },
     'peek:--type': {
         whenEnabled: 'Filters network requests by CDP resource type. Case-insensitive, comma-separated. Valid: Document, Stylesheet, Image, Media, Font, Script, XHR, Fetch, WebSocket, etc.',
     },
-    'peek:-f': {
-        default: 'Shows snapshot of current data',
-        whenEnabled: 'Continuous monitoring (like tail -f): refreshes every second, or every --interval ms (100-60000). Replaces the deprecated bdg tail',
-        automaticBehavior: FOLLOW_BEHAVIOR,
-    },
     'peek:--follow': {
         default: 'Shows snapshot of current data',
         whenEnabled: 'Continuous monitoring (like tail -f): refreshes every second, or every --interval ms (100-60000). Replaces the deprecated bdg tail',
         automaticBehavior: FOLLOW_BEHAVIOR,
     },
-    'console:-f': {
+    'console:--follow': {
         default: 'Prints the messages logged so far and exits',
         whenEnabled: 'Streams new messages as they come (the last --last at start)',
         automaticBehavior: FOLLOW_BEHAVIOR,
     },
-    'list:-f': {
+    'list:--follow': {
         default: 'Lists the requests captured so far and exits',
         whenEnabled: 'Streams requests as they finish',
         automaticBehavior: FOLLOW_BEHAVIOR,
     },
-    'peek:-v': {
+    'har:--include-sensitive': {
+        default: 'The HAR is sanitized: values become "[redacted]" for Authorization, Proxy-Authorization, Authentication, Cookie and Set-Cookie headers, X-*key/token/secret/auth headers and headers with an api-key/apikey/token/secret/jwt/subscription-key/session(-id) segment (www-authenticate is kept); every cookie value; query and fragment parameters named like credentials (plus code, sig, key) in the request URL, queryString, redirectURL and Location/Referer headers ("%5Bredacted%5D" in URLs); and password/token/secret/key/session/signature fields of JSON (primitives at any depth under such a name), form-urlencoded (also sniffed when the Content-Type says otherwise) and multipart request bodies. A JSON body too deep to walk becomes "[redacted]" whole. Header, cookie and parameter names, cookie attributes, headersSize and bodySize stay; log.comment and JSON sanitized: true say so',
+        whenEnabled: 'Writes every captured value (JSON sanitized: false); human output warns that the file holds credentials',
+        automaticBehavior: 'Matching is by name, so it over-redacts: harmless values under credential-looking names (tokenCount: 5, sessionLength) are replaced too, and credentials under other names are kept. Unlike Chrome DevTools, which drops these headers and empties cookies, names are kept so the HAR still shows a request was authenticated. Response bodies and WebSocket messages are not redacted. HAR files are written readable by their owner only (0600). network headers and network getCookies always show real values',
+    },
+    'peek:--verbose': {
         default: 'Compact output (truncated URLs, no resource types)',
         whenEnabled: 'Verbose output with full URLs and resource types',
     },
-    'start:--headless': {
+    'bdg:--headless': {
         default: 'A window when there is a display: on macOS unless over SSH (SSH_CONNECTION, SSH_TTY) or CI is set; on Linux when DISPLAY or WAYLAND_DISPLAY is set. Servers, containers and CI run headless',
         whenEnabled: 'Chrome runs without a window (pass it when running unattended on a Mac)',
     },
-    'start:--no-headless': {
+    'bdg:--no-headless': {
         default: 'A window when there is a display: on macOS unless over SSH (SSH_CONNECTION, SSH_TTY) or CI is set; on Linux when DISPLAY or WAYLAND_DISPLAY is set',
         whenEnabled: 'Chrome shows its window even without a detected display (it fails without one)',
     },
-    'start:--all': {
+    'bdg:--all': {
         default: 'Tracking/analytics requests and console noise are filtered; bodies of binary responses (images, fonts) are not captured',
         whenEnabled: 'Everything is captured, including binary response bodies (base64, flagged by responseBodyBase64, within --max-body-size)',
         tokenImpact: 'details network --json and HAR exports can grow considerably on media-heavy pages',
     },
-    'peek:--verbose': {
-        default: 'Compact output (truncated URLs, no resource types)',
-        whenEnabled: 'Verbose output with full URLs and resource types',
-    },
     'bdg:--session': {
         default: 'The default session in ~/.bdg (or $BDG_SESSION_DIR); BDG_SESSION=<name> selects a named session like the flag',
         whenEnabled: 'Uses the named session in ~/.bdg/sessions/<name>/ (or $BDG_SESSION_DIR/sessions/<name>/) with its own daemon, Chrome, profile and port; every command (status, stop, cleanup, ...) acts on that session only',
         automaticBehavior: 'Accepted before or after any subcommand; --session wins over BDG_SESSION. Names are case-insensitive (lower-cased: ALPHA is alpha). Without --port a named session takes the first free port above 9222 not claimed by another running session, and keeps it in port.txt. Names: 1-40 letters, digits, "-" or "_", starting with a letter or digit (exit 81 otherwise, also when the socket path would be too long). Hints and suggestions in its output carry --session <name>',
     },
-    'cleanup:-f': {
+    'cleanup:--force': {
         default: 'Refuses to run while a session is active; removes files left by a crashed session',
         whenEnabled: 'Kills the running daemon and its Chrome first (use when a session is stuck)',
     },
@@ -377,36 +392,39 @@ const OPTION_BEHAVIORS = {
         default: 'Chrome launched by bdg is always closed on stop; an attached Chrome (--chrome-ws-url) is left running',
         whenEnabled: 'No additional effect; kept for compatibility',
     },
-    'status:-v': {
-        default: 'Basic session status (daemon running, session active, URL)',
-        whenEnabled: 'Includes Chrome diagnostics and CDP connection details',
-    },
     'status:--verbose': {
         default: 'Basic session status (daemon running, session active, URL)',
         whenEnabled: 'Includes Chrome diagnostics and CDP connection details',
     },
 };
 /**
- * Build behavior registry key from command and flag.
+ * Build behavior registry key from command and option: the command's own
+ * name (`bdg` for the root) and the option's long flag, or its short flag
+ * when it has no long one.
  *
  * @param commandName - Command name (e.g., "screenshot")
- * @param flags - Option flags string (e.g., "--no-resize")
+ * @param option - Commander option
  * @returns Registry key
  */
-function buildKey(commandName, flags) {
-    const firstFlag = flags.split(',')[0] ?? flags;
-    const flagName = firstFlag.trim().split(' ')[0] ?? firstFlag.trim();
-    return `${commandName}:${flagName}`;
+export function behaviorKey(commandName, option) {
+    return `${commandName}:${option.long ?? option.short ?? option.flags}`;
+}
+/**
+ * Every key in the behavior registry.
+ *
+ * @returns Registry keys
+ */
+export function listBehaviorKeys() {
+    return Object.keys(OPTION_BEHAVIORS);
 }
 /**
  * Look up behavioral metadata for an option.
  *
  * @param commandName - Name of the command containing the option
- * @param flags - Option flags string from Commander
+ * @param option - Commander option
  * @returns Behavioral metadata if registered, undefined otherwise
  */
-export function getOptionBehavior(commandName, flags) {
-    const key = buildKey(commandName, flags);
-    return OPTION_BEHAVIORS[key];
+export function getOptionBehavior(commandName, option) {
+    return OPTION_BEHAVIORS[behaviorKey(commandName, option)];
 }
 //# sourceMappingURL=optionBehaviors.js.map

package/dist/commands/peek.js

@@ -8,6 +8,7 @@ import { fetchPreviewOutput, createErrorResult, } from './shared/dataFetcher.js'
 import { followFetchFailure, setupFollowMode, } from './shared/followMode.js';
 import { handleValidationError } from './shared/handleValidationError.js';
 import { MAX_LAST_ITEMS, positiveIntRule, resourceTypeRule } from './shared/validation.js';
+import { MAX_CONSOLE_JSON_TEXT_LENGTH, MAX_CONSOLE_TEXT_LENGTH } from '../constants.js';
 import { CommandError } from '../errors/index.js';
 import { intervalWithoutFollowError } from '../errors/messages.js';
 import { filterByResourceType } from '../telemetry/filters.js';
@@ -137,6 +138,7 @@ function previewDisplayOptions(options, lastN) {
         last: lastN,
         verbose: options.verbose,
         follow: options.follow,
+        full: options.full,
     };
 }
 /**
@@ -162,6 +164,7 @@ export function registerPeekCommand(program) {
         .option('--interval <ms>', 'Refresh interval of --follow in ms, 100-60000 (default: 1000)')
         .option('--last <count>', 'Show last N items, 0 for all', '10')
         .option('--type <types>', 'Filter network requests by resource type (comma-separated: Document,XHR,Fetch,etc.)')
+        .option('--full', `Print console message texts whole (default: the first ${MAX_CONSOLE_TEXT_LENGTH} characters, ${MAX_CONSOLE_JSON_TEXT_LENGTH} in JSON)`, false)
         .action(async (options) => {
         showBothSectionsWhenBothRequested(options);
         if (options.network && !options.json) {

package/dist/commands/shared/CommandRunner.js

@@ -2,7 +2,7 @@ import { getQuickIPCRequestTimeout } from '../../constants.js';
 import { CommandError, isDaemonConnectionError } from '../../errors/index.js';
 import { daemonNotRunningError, unknownError, genericError, commandTimedOutError, sessionNotRespondingError, sessionEndedDuringCommandError, } from '../../errors/messages.js';
 import { IPCEarlyCloseError, IPCTimeoutError } from '../../ipc/transport/IPCError.js';
-import { OutputBuilder, buildSuccessResponse } from '../../ui/OutputBuilder.js';
+import { OutputBuilder, buildSuccessResponse, stringifyEnvelope } from '../../ui/OutputBuilder.js';
 import { escapeControlChars } from '../../ui/formatting.js';
 import { noActiveSessionMessage, startSessionSuggestion } from '../../ui/messages/sessionCommand.js';
 import { getErrorExitCode, getErrorMessage } from '../../utils/errors.js';
@@ -36,7 +36,7 @@ export function noActiveSessionError() {
 export async function runJsonCommand(fn) {
     try {
         const data = await fn();
-        console.log(JSON.stringify(buildSuccessResponse(data), null, 2));
+        console.log(stringifyEnvelope(buildSuccessResponse(data)));
         process.exit(EXIT_CODES.SUCCESS);
     }
     catch (caught) {
@@ -49,10 +49,10 @@ export async function runJsonCommand(fn) {
         const suggestion = error instanceof CommandError && typeof error.metadata['suggestion'] === 'string'
             ? error.metadata['suggestion']
             : undefined;
-        console.log(JSON.stringify(OutputBuilder.buildJsonError(getErrorMessage(error), {
+        console.log(stringifyEnvelope(OutputBuilder.buildJsonError(getErrorMessage(error), {
             exitCode,
             ...(suggestion && { suggestion }),
-        }), null, 2));
+        })));
         process.exit(exitCode);
     }
 }
@@ -112,10 +112,10 @@ export async function runCommand(handler, options, formatter) {
         if (!result.success) {
             const exitCode = result.exitCode ?? EXIT_CODES.UNHANDLED_EXCEPTION;
             if (options.json) {
-                console.log(JSON.stringify(OutputBuilder.buildJsonError(result.error ?? 'Unknown error', {
+                console.log(stringifyEnvelope(OutputBuilder.buildJsonError(result.error ?? 'Unknown error', {
                     ...result.errorContext,
                     exitCode,
-                }), null, 2));
+                })));
             }
             else {
                 console.error(result.error ? genericError(result.error) : unknownError());
@@ -133,14 +133,14 @@ export async function runCommand(handler, options, formatter) {
             console.error(escapeControlChars(result.hint));
         }
         if (options.json) {
-            console.log(JSON.stringify(buildSuccessResponse(result.data), null, 2));
+            console.log(stringifyEnvelope(buildSuccessResponse(result.data)));
         }
         else if (formatter) {
             const formattedOutput = formatter(result.data);
             console.log(escapeControlChars(formattedOutput));
         }
         else {
-            console.log(JSON.stringify(buildSuccessResponse(result.data), null, 2));
+            console.log(stringifyEnvelope(buildSuccessResponse(result.data)));
         }
         process.exit(EXIT_CODES.SUCCESS);
     }
@@ -152,10 +152,10 @@ export async function runCommand(handler, options, formatter) {
                 : caught;
         if (error instanceof CommandError) {
             if (options.json) {
-                console.log(JSON.stringify(OutputBuilder.buildJsonError(error.message, {
+                console.log(stringifyEnvelope(OutputBuilder.buildJsonError(error.message, {
                     ...error.metadata,
                     exitCode: error.exitCode,
-                }), null, 2));
+                })));
             }
             else {
                 console.error(genericError(error.message));
@@ -168,10 +168,10 @@ export async function runCommand(handler, options, formatter) {
         const errorMessage = getErrorMessage(error);
         if (isDaemonConnectionError(error)) {
             if (options.json) {
-                console.log(JSON.stringify(OutputBuilder.buildJsonError(noActiveSessionMessage(), {
+                console.log(stringifyEnvelope(OutputBuilder.buildJsonError(noActiveSessionMessage(), {
                     suggestion: startSessionSuggestion(),
                     exitCode: EXIT_CODES.RESOURCE_NOT_FOUND,
-                }), null, 2));
+                })));
             }
             else {
                 console.error(daemonNotRunningError());
@@ -180,7 +180,7 @@ export async function runCommand(handler, options, formatter) {
         }
         const exitCode = getErrorExitCode(error, EXIT_CODES.UNHANDLED_EXCEPTION);
         if (options.json) {
-            console.log(JSON.stringify(OutputBuilder.buildJsonError(errorMessage, { exitCode }), null, 2));
+            console.log(stringifyEnvelope(OutputBuilder.buildJsonError(errorMessage, { exitCode })));
         }
         else {
             console.error(genericError(errorMessage));

package/dist/commands/shared/daemonErrorHandler.js

@@ -3,7 +3,7 @@
  */
 import { sessionUnavailableSuggestion } from '../../errors/messages.js';
 import { genericError } from '../../errors/messages.js';
-import { OutputBuilder } from '../../ui/OutputBuilder.js';
+import { OutputBuilder, stringifyEnvelope } from '../../ui/OutputBuilder.js';
 import { connectionLostRetryMessage, connectionLostStopHintMessage, followedSessionEndedMessage, } from '../../ui/messages/preview.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
 /** Follow-mode state: whether a session ever answered, and whether its loss was reported */
@@ -42,7 +42,7 @@ export function handleDaemonConnectionError(error, options) {
                 exitCode,
                 ...(suggestion && { suggestion }),
             });
-            console.log(follow ? JSON.stringify(envelope) : JSON.stringify(envelope, null, 2));
+            console.log(follow ? JSON.stringify(envelope) : stringifyEnvelope(envelope));
         }
         else {
             console.error(genericError(message));

package/dist/commands/shared/dataFetcher.d.ts

@@ -3,6 +3,7 @@
  */
 import type { PeekSection } from '../../ipc/protocol/commands.js';
 import type { BdgOutput, ConsoleMessage, NetworkRequest } from '../../types.js';
+import type { NetworkEvictionCounts } from '../../ui/messages/networkMessages.js';
 export type FetchSuccess<T> = {
     success: true;
     data: T;
@@ -47,12 +48,13 @@ export declare function fetchPreviewData(query?: PreviewQuery): Promise<FetchRes
  * Fetch all captured network requests from daemon.
  *
  * @param withHeaders - Include request/response headers (needed by header filters)
- * @returns Requests, and when the page crashed (while it is not loaded
- *   again), or a fetch error
+ * @returns Requests, when the page crashed (while it is not loaded again)
+ *   and what the session let go at its capture limits, or a fetch error
  */
 export declare function fetchNetworkRequests(withHeaders?: boolean): Promise<FetchResult<{
     requests: NetworkRequest[];
     pageCrashedAt: number | undefined;
+    evictions: NetworkEvictionCounts;
 }>>;
 /**
  * Fetch all console messages from daemon.

package/dist/commands/shared/dataFetcher.js

@@ -90,16 +90,24 @@ export async function fetchPreviewData(query = {}) {
  * Fetch all captured network requests from daemon.
  *
  * @param withHeaders - Include request/response headers (needed by header filters)
- * @returns Requests, and when the page crashed (while it is not loaded
- *   again), or a fetch error
+ * @returns Requests, when the page crashed (while it is not loaded again)
+ *   and what the session let go at its capture limits, or a fetch error
  */
 export async function fetchNetworkRequests(withHeaders = false) {
     const result = await fetchPreviewData({ lastN: 0, only: 'network', withHeaders });
     if (!result.success)
         return result;
+    const { totals, pageCrashedAt } = result.data.output;
     return {
         success: true,
-        data: { requests: result.data.network, pageCrashedAt: result.data.output.pageCrashedAt },
+        data: {
+            requests: result.data.network,
+            pageCrashedAt,
+            evictions: {
+                requestsDropped: totals?.networkDropped ?? 0,
+                bodiesEvicted: totals?.networkBodiesEvicted ?? 0,
+            },
+        },
     };
 }
 /**

package/dist/commands/shared/handleValidationError.js

@@ -1,6 +1,6 @@
 import { CommandError } from '../../errors/index.js';
 import { genericError } from '../../errors/messages.js';
-import { OutputBuilder } from '../../ui/OutputBuilder.js';
+import { OutputBuilder, stringifyEnvelope } from '../../ui/OutputBuilder.js';
 import { escapeControlChars } from '../../ui/formatting.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
 /**
@@ -24,7 +24,7 @@ export function handleValidationError(error, json) {
             if (error.metadata.suggestion) {
                 errorOptions.suggestion = error.metadata.suggestion;
             }
-            console.log(JSON.stringify(OutputBuilder.buildJsonError(error.message, errorOptions), null, 2));
+            console.log(stringifyEnvelope(OutputBuilder.buildJsonError(error.message, errorOptions)));
         }
         else {
             console.error(genericError(error.message));
@@ -38,7 +38,7 @@ export function handleValidationError(error, json) {
         const envelope = OutputBuilder.buildJsonError(message, {
             exitCode: EXIT_CODES.INVALID_ARGUMENTS,
         });
-        console.log(JSON.stringify(envelope, null, 2));
+        console.log(stringifyEnvelope(envelope));
     }
     else {
         console.error(genericError(message));

package/dist/commands/shared/optionTypes.d.ts

@@ -143,12 +143,12 @@ export type DetailsCommandOptions = BaseOptions & {
 };
 /** Options for DOM query command */
 export type DomQueryCommandOptions = BaseOptions & {
-    /** Matches listed (0 = all); default 50, or 1000 with --json */
+    /** Matches listed (0 = all); default 50, or 100 with --json */
     limit?: number;
 };
 /** Options for DOM get command */
 export type DomGetCommandOptions = BaseOptions & RawOptions & SelectionOptions & {
-    /** All of the element's text instead of its first 500 characters (semantic output) */
+    /** All of the element's text (semantic output) or HTML (`--raw`), instead of its start */
     full?: boolean;
     /** Which match of the selector (0-based); `--nth` is its alias */
     index?: number;
@@ -159,6 +159,8 @@ export type DomScreenshotCommandOptions = BaseOptions & ScreenshotOptions;
 export interface DomEvalCommandOptions extends BaseOptions {
     /** Iframe to evaluate in: index, name/id attribute, or part of the name, id or URL */
     frame?: string;
+    /** The whole value instead of its first 20000 characters */
+    full?: boolean;
 }
 /** Options for DOM frames command */
 export type DomFramesCommandOptions = BaseOptions;
@@ -276,7 +278,12 @@ export interface WaitCommandOptions extends BaseOptions {
     timeout: number;
 }
 /** Options for A11y tree command */
-export type A11yTreeCommandOptions = BaseOptions;
+export interface A11yTreeCommandOptions extends BaseOptions {
+    /** Nodes to list (0 = all); default 50, also with --json */
+    limit?: number;
+    /** Levels below the root to list (0 = root only) */
+    depth?: number;
+}
 /** Options for A11y query command */
 export interface A11yQueryCommandOptions extends BaseOptions {
     /** Matches to list (0 = all) */
@@ -293,6 +300,7 @@ export type NetworkCookiesCommandOptions = BaseOptions & {
 /** Options for network HAR command */
 export type NetworkHarCommandOptions = BaseOptions & {
     outputFile?: string;
+    includeSensitive?: boolean;
 };
 /** Options for network headers command */
 export type NetworkHeadersCommandOptions = BaseOptions & {
@@ -354,6 +362,8 @@ export interface ConsoleCommandOptions extends BaseOptions {
     history?: boolean;
     /** Filter by message level (error, warning, info, debug) */
     level?: ConsoleLevel;
+    /** Message texts whole instead of cut */
+    full?: boolean;
 }
 /**
  * Options for preview display.
@@ -380,6 +390,8 @@ export interface PeekCommandOptions extends BaseOptions, PreviewDisplayOptions {
     type?: string;
     /** Refresh interval of --follow in ms (string from CLI, default: 1000) */
     interval?: string;
+    /** Console message texts whole instead of cut */
+    full?: boolean;
 }
 /**
  * Options for tail command.

package/dist/commands/shared/outputFile.d.ts

@@ -26,8 +26,9 @@ export declare function assertFilePath(filePath: string, extension?: string): vo
  * @param filePath - Path the user gave
  * @param data - File contents
  * @param extension - Extension of the file kind, for examples in errors
+ * @param mode - File permissions of a text file (default: 0666 less the umask)
  * @returns Absolute path written
  * @throws CommandError naming the path when it cannot be written
  */
-export declare function writeOutputFile(filePath: string, data: string | Buffer, extension?: string): Promise<string>;
+export declare function writeOutputFile(filePath: string, data: string | Buffer, extension?: string, mode?: number): Promise<string>;
 //# sourceMappingURL=outputFile.d.ts.map

package/dist/commands/shared/outputFile.js

@@ -62,18 +62,21 @@ export function assertFilePath(filePath, extension) {
  * @param filePath - Path the user gave
  * @param data - File contents
  * @param extension - Extension of the file kind, for examples in errors
+ * @param mode - File permissions of a text file (default: 0666 less the umask)
  * @returns Absolute path written
  * @throws CommandError naming the path when it cannot be written
  */
-export async function writeOutputFile(filePath, data, extension) {
+export async function writeOutputFile(filePath, data, extension, mode) {
     assertFilePath(filePath, extension);
     const absolutePath = path.resolve(filePath);
     try {
         makeDirectory(path.dirname(absolutePath));
-        if (typeof data === 'string')
-            await AtomicFileWriter.writeAsync(absolutePath, data);
-        else
+        if (typeof data === 'string') {
+            await AtomicFileWriter.writeAsync(absolutePath, data, mode === undefined ? {} : { mode });
+        }
+        else {
             await AtomicFileWriter.writeBufferAsync(absolutePath, data);
+        }
     }
     catch (error) {
         throw outputPathError(filePath, error, extension);

package/dist/commands/shared/startHelpers.js

@@ -14,7 +14,7 @@ import { IPCErrorCode, } from '../../ipc/index.js';
 import { IPCTimeoutError } from '../../ipc/transport/index.js';
 import { isConnectionError } from '../../ipc/utils/errors.js';
 import { getSessionName } from '../../session/paths.js';
-import { OutputBuilder, buildSuccessResponse } from '../../ui/OutputBuilder.js';
+import { OutputBuilder, buildSuccessResponse, stringifyEnvelope } from '../../ui/OutputBuilder.js';
 import { escapeControlChars, joinLines } from '../../ui/formatting.js';
 import { createLogger } from '../../ui/logging/index.js';
 import { daemonStillExitingHint, daemonStillExitingSuggestion, startNotices, } from '../../ui/messages/session.js';
@@ -318,7 +318,7 @@ function reportStartOutcome(outcome, options) {
                 exitCode: outcome.exitCode,
                 ...outcome.details,
             });
-            console.log(JSON.stringify(envelope, null, 2));
+            console.log(stringifyEnvelope(envelope));
         }
         else {
             console.error(escapeControlChars(outcome.human));
@@ -340,7 +340,7 @@ function reportStartOutcome(outcome, options) {
             daemonPid: data.daemonPid,
             ...(autoStopAt && { autoStopAt: autoStopAt.toISOString() }),
         };
-        console.log(JSON.stringify(buildSuccessResponse(result), null, 2));
+        console.log(stringifyEnvelope(buildSuccessResponse(result)));
     }
     else {
         const page = {

package/dist/commands/status.js

@@ -1,5 +1,5 @@
 import { runCommand } from './shared/CommandRunner.js';
-import { isDaemonConnectionError } from '../errors/index.js';
+import { CommandError, isDaemonConnectionError } from '../errors/index.js';
 import { invalidResponseError, sessionNotRespondingError } from '../errors/messages.js';
 import { getStatus } from '../ipc/client.js';
 import { IPCTimeoutError } from '../ipc/transport/IPCError.js';
@@ -134,6 +134,8 @@ export function registerStatusCommand(program) {
                 return { success: true, data: withSessionName(jsonOutput) };
             }
             catch (error) {
+                if (error instanceof CommandError)
+                    throw error;
                 const errorMessage = getErrorMessage(error);
                 if (error instanceof IPCTimeoutError) {
                     const err = sessionNotRespondingError(error.timeoutMs / 1000);

package/dist/commands/stop.js

@@ -1,5 +1,6 @@
 import { runCommand } from './shared/CommandRunner.js';
 import { jsonOption } from './shared/commonOptions.js';
+import { CommandError } from '../errors/index.js';
 import { stopSession } from '../ipc/client.js';
 import { IPCErrorCode } from '../ipc/index.js';
 import { IPCTimeoutError } from '../ipc/transport/index.js';
@@ -97,7 +98,7 @@ export function registerStopCommand(program) {
                 }
             }
             catch (error) {
-                if (error instanceof IPCTimeoutError)
+                if (error instanceof IPCTimeoutError || error instanceof CommandError)
                     throw error;
                 const errorMessage = getErrorMessage(error);
                 if (isDaemonNotRunningError(errorMessage)) {

package/dist/connection/chromeIdentity.d.ts

@@ -49,12 +49,18 @@ export declare function waitForDevToolsEndpoint(logs: StartupLogs, isRunning: ()
  * Check that the Chrome answering on 127.0.0.1:<port> is the one just
  * launched, so bdg never drives another session's browser.
  *
+ * A Chrome that announced 127.0.0.1:<port> but does not answer yet (a slow
+ * start, its `/json/version` request timing out) is asked again until the
+ * deadline; only an answer from something else is a port conflict. A Chrome
+ * that fell back to [::1] is asked once: 127.0.0.1 is held by something else.
+ *
  * @param options - Chrome's log positions from before the launch, requested
  *   port (free on 127.0.0.1 and ::1 right before the launch), Chrome's PID and
- *   longest wait for its announcement
+ *   longest wait for its announcement and its answer
  * @throws ChromeLaunchError: CHROME_DIED_AFTER_LAUNCH if Chrome exits first;
  *   PORT_IN_USE if another browser or process answers on the port;
- *   CHROME_LAUNCH_FAILED if Chrome announced nothing and nothing answers
+ *   CHROME_LAUNCH_FAILED if Chrome announced nothing and nothing answers, or
+ *   announced the port but did not answer on it in time
  */
 export declare function verifyLaunchedChrome(options: {
     logs: StartupLogs;