browser-debugger-cli 0.15.0 → 0.16.0

package/dist/telemetry/har/sanitizeBody.js

@@ -1,9 +1,18 @@
 /**
- * Credential redaction in request bodies and `name=value` lists, for
- * sanitized HAR exports (see sanitize.ts).
+ * Credential redaction in request and response bodies, WebSocket text
+ * messages and `name=value` lists, for sanitized HAR exports (see sanitize.ts).
  *
  * Matching is by field name only, so it over-redacts: any primitive whose
  * name looks like a credential (`tokenCount: 5`) is replaced too.
+ *
+ * JSON is never parsed and re-serialized: a single linear scan replaces the
+ * credential values in place, so everything else (64-bit numbers, formatting,
+ * duplicate keys, a BOM or `)]}'` prefix) stays byte for byte, and truncated
+ * JSON, socket.io and SockJS packets, server-sent events, NDJSON and JSON
+ * encoded in string values are covered too. JWTs are redacted under any name.
+ *
+ * Only JSON syntax is understood: single-quoted strings, unquoted keys,
+ * JSONP and `name:value` header lines (STOMP `passcode:`) are not.
  */
 import { SENSITIVE_NAME_SOURCE } from '../../runtime/dom/elementInfo.js';
 import { createLogger } from '../../ui/logging/index.js';
@@ -13,11 +22,41 @@ const log = createLogger('network');
 export const REDACTED = '[redacted]';
 /**
  * Field names holding credentials: password-like names (shared with form
- * masking), tokens, secrets, keys, sessions, signatures and credentials
+ * masking), tokens, secrets, keys, sessions, signatures, credentials, bearer,
+ * cookie, CSRF and refresh values, `auth` and `sid` as whole words, OAuth,
+ * authorization codes and PKCE verifiers
+ */
+const SENSITIVE_FIELD = new RegExp(`${SENSITIVE_NAME_SOURCE}|token|secret|api[-_]?key|authoriz|credential|jwt|private[-_]?key|access[-_]?key|session|signature|bearer|cookie|csrf|xsrf|refresh|oauth|(^|[^a-z])(auth|sid)([^a-z]|$)|auth[-_]?code|code[-_]?verifier`, 'i');
+/**
+ * A body that is a form whatever its Content-Type: `k=v&k=v`, no whitespace,
+ * not JSON (Rails-style names such as `user[password]` included)
  */
-const SENSITIVE_FIELD = new RegExp(`${SENSITIVE_NAME_SOURCE}|token|secret|api[-_]?key|authoriz|credential|jwt|private[-_]?key|access[-_]?key|session|signature`, 'i');
-/** A body that is a form whatever its Content-Type: `k=v&k=v`, no whitespace, not JSON */
-const FORM_BODY = /^[^\s=&{["]+=[^\s&]*(?:&[^\s=&]+=[^\s&]*)*$/;
+const FORM_BODY = /^(?!\[)[^\s=&{"]+=[^\s&]*(?:&[^\s=&]+=[^\s&]*)*$/;
+/**
+ * Text that holds JSON whatever its Content-Type: after an optional BOM,
+ * XSSI guard (`)]}'`) and whitespace, an object or array (also after a
+ * socket.io packet type such as `42`, `451-` or `42/chat,`, an Engine.io v3
+ * length prefix such as `45:`, or a SockJS `a`/`c` frame type) or a
+ * server-sent event field
+ */
+const JSON_LIKE_START = /^\uFEFF?(?:\)\]\}',?)?\s*(?:(?:\d+:)?(?:\d*-?(?:\/[^,]*,)?|[ac])[[{]|(?:data|event|id|retry):)/;
+/** Content-Types whose bodies are scanned as JSON whatever they start with */
+const JSON_MIME = /json|event-stream/i;
+/**
+ * Content-Types (without parameters) of base64 bodies decoded to look for
+ * credentials: none, generic binary, JSON, form and server-sent events
+ */
+const DECODABLE_MIME = /^(?:application\/octet-stream|binary\/octet-stream|application\/x-www-form-urlencoded|text\/event-stream)?$|json/i;
+/** A bare value (number, `true`, `false`, `null`) or word, up to the next delimiter */
+const BARE = /[^\s,:[\]{}"]+/y;
+/** Character code of `.`, the JWT segment separator */
+const DOT = 0x2e;
+/** Levels of JSON encoded in string values that are decoded */
+const MAX_ENCODED_DEPTH = 3;
+/** {@link REDACTED} as a JSON string */
+const REDACTED_STRING = JSON.stringify(REDACTED);
+/** Strict UTF-8 decoder that keeps a BOM */
+const UTF8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
 /**
  * Whether a body field, form field or query parameter name looks like it
  * holds a credential.
@@ -26,7 +65,53 @@ const FORM_BODY = /^[^\s=&{["]+=[^\s&]*(?:&[^\s=&]+=[^\s&]*)*$/;
  * @returns True for password, token, secret, key, session and signature names
  */
 export function isSensitiveField(name) {
-    return SENSITIVE_FIELD.test(name);
+    return SENSITIVE_FIELD.test(name.replace(/([a-z])([A-Z])/g, '$1_$2'));
+}
+/**
+ * Run a redaction, replacing the whole text when it fails, so that a body
+ * the sanitizer cannot handle is never exported as captured.
+ *
+ * @param text - Body or message text
+ * @param redact - Redaction of the text
+ * @param whole - Text written when the redaction throws
+ * @returns Redacted text, or `whole`
+ */
+export function redactOrReplaceWhole(text, redact, whole = REDACTED) {
+    try {
+        return redact(text);
+    }
+    catch (error) {
+        log.debug(`Body replaced whole, sanitizing failed: ${getErrorMessage(error)}`);
+        return whole;
+    }
+}
+/**
+ * Replace every whole JWT (`eyJ` and three base64url segments, not part of a
+ * longer word) in text. Scanned by hand: a regular expression overflows the
+ * stack on a word of millions of characters.
+ *
+ * @param text - Text
+ * @param replacement - Text written instead of each JWT
+ * @returns Text with JWTs replaced; the text unchanged when it has none
+ */
+export function redactJwts(text, replacement) {
+    if (!text.includes('eyJ'))
+        return text;
+    const parts = [];
+    let copied = 0;
+    let at = text.indexOf('eyJ');
+    while (at !== -1) {
+        const end = isJwtBoundary(text, at - 1) ? jwtEnd(text, at) : undefined;
+        if (end !== undefined && isJwtBoundary(text, end)) {
+            parts.push(text.slice(copied, at), replacement);
+            copied = end;
+        }
+        at = text.indexOf('eyJ', Math.max(at + 3, copied));
+    }
+    if (parts.length === 0)
+        return text;
+    parts.push(text.slice(copied));
+    return parts.join('');
 }
 /**
  * Redact credential values in an `&`-separated `name=value` list (a form body,
@@ -42,28 +127,61 @@ export function redactPairs(text, isSensitive, replacement) {
         .split('&')
         .map((pair) => {
         const eq = pair.indexOf('=');
-        if (eq === -1 || !isSensitive(decodeName(pair.slice(0, eq))))
+        if (eq === -1)
             return pair;
-        return `${pair.slice(0, eq)}=${replacement}`;
+        if (isSensitive(decodeName(pair.slice(0, eq))))
+            return `${pair.slice(0, eq)}=${replacement}`;
+        const value = pair.slice(eq + 1);
+        const redacted = redactJwts(value, replacement);
+        return redacted === value ? pair : `${pair.slice(0, eq + 1)}${redacted}`;
     })
         .join('&');
 }
 /**
- * Redact credential fields of a request body: multipart parts, form fields
- * (by Content-Type or shape) and JSON fields at any depth.
+ * Redact credential fields of a body or WebSocket text message: multipart
+ * parts, form fields (by Content-Type or shape) and JSON fields at any depth.
  *
  * @param text - Body text
- * @param mimeType - Content-Type of the body
+ * @param mimeType - Content-Type of the body (empty for a WebSocket message)
  * @returns Body with credential values replaced; the text unchanged when
- *   there were none
+ *   there were none or it is neither JSON, a form nor multipart
  */
-export function redactRequestBody(text, mimeType) {
+export function redactBody(text, mimeType) {
     if (/multipart\/form-data/i.test(mimeType))
         return redactMultipart(text, mimeType);
-    if (/x-www-form-urlencoded/i.test(mimeType) || FORM_BODY.test(text)) {
+    if (/x-www-form-urlencoded/i.test(mimeType))
+        return redactPairs(text, isSensitiveField, REDACTED);
+    if (JSON_LIKE_START.test(text))
+        return redactJsonText(text, 0);
+    if (FORM_BODY.test(text))
         return redactPairs(text, isSensitiveField, REDACTED);
+    if (JSON_MIME.test(mimeType))
+        return redactJsonText(text, 0);
+    return redactJwts(text, REDACTED);
+}
+/**
+ * Redact credential fields of a base64 body or binary WebSocket message that
+ * may be text: one with no, a generic binary, a JSON, a form or an
+ * event-stream Content-Type that decodes as UTF-8.
+ *
+ * @param base64 - Body as base64
+ * @param mimeType - Content-Type of the body
+ * @returns The redacted body re-encoded, or the input unchanged when it was
+ *   not decodable text or held no credentials
+ */
+export function redactBase64Body(base64, mimeType) {
+    if (!DECODABLE_MIME.test(mimeType.split(';')[0]?.trim() ?? ''))
+        return base64;
+    let decoded;
+    try {
+        decoded = UTF8.decode(Buffer.from(base64, 'base64'));
+    }
+    catch (error) {
+        log.debug(`Base64 body is not UTF-8: ${getErrorMessage(error)}`);
+        return base64;
     }
-    return redactJsonBody(text);
+    const redacted = redactBody(decoded, mimeType);
+    return redacted === decoded ? base64 : Buffer.from(redacted, 'utf8').toString('base64');
 }
 /**
  * Decode a form or query name.
@@ -97,10 +215,11 @@ function redactMultipart(text, mimeType) {
     return text.split(delimiter).map(redactPart).join(delimiter);
 }
 /**
- * Redact the value of one multipart part if its name holds a credential.
+ * Redact the value of one multipart part if its name holds a credential, or
+ * the JWTs in it.
  *
  * @param part - Text between two boundary delimiters
- * @returns The part, or the part with its value replaced
+ * @returns The part, or the part with its value or JWTs replaced
  */
 function redactPart(part) {
     const headerEnd = part.indexOf('\r\n\r\n');
@@ -108,61 +227,315 @@ function redactPart(part) {
         return part;
     const name = /;\s*name="([^"]*)"/i.exec(part.slice(0, headerEnd))?.[1];
     if (name === undefined || !isSensitiveField(name))
-        return part;
+        return redactJwts(part, REDACTED);
     const valueEnd = part.endsWith('\r\n') ? part.length - 2 : part.length;
     return `${part.slice(0, headerEnd + 4)}${REDACTED}${part.slice(valueEnd)}`;
 }
 /**
- * Redact credential fields of a JSON body.
+ * Replace the values under credential names in JSON-like text, in one linear
+ * pass. Every string, number and boolean under such a key is replaced, at
+ * any depth (objects and arrays keep their structure), and so is a JWT under
+ * any key; `null` and all other text stay byte for byte. A string ends at
+ * its closing quote or at the end of its line (JSON strings hold no raw line
+ * breaks), so a stray quote hides nothing past its line.
  *
- * @param text - Body text
- * @returns Re-serialized JSON when a field was redacted, the text unchanged
- *   when none was or it is not JSON, and {@link REDACTED} for JSON too deep
- *   to walk
+ * @param text - Text holding JSON, possibly truncated or framed
+ * @param depth - Levels of string encoding around the text
+ * @returns Text with credential values replaced by `"[redacted]"`; the text
+ *   unchanged when there were none
  */
-function redactJsonBody(text) {
-    if (!/^\s*[[{]/.test(text))
+function redactJsonText(text, depth) {
+    const scan = {
+        text,
+        parts: [],
+        copied: 0,
+        containers: [false],
+        key: undefined,
+        lineEnd: -1,
+        depth,
+    };
+    let index = 0;
+    while (index < text.length)
+        index = scanToken(scan, index);
+    if (scan.parts.length === 0)
         return text;
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
+    scan.parts.push(text.slice(scan.copied));
+    return scan.parts.join('');
+}
+/**
+ * Read the token at an index: a string, a bracket, a comma or a bare value;
+ * whitespace and colons are skipped.
+ *
+ * @param scan - Scan state
+ * @param index - Index of the token's first character
+ * @returns Index after the token
+ */
+function scanToken(scan, index) {
+    const char = scan.text[index];
+    if (char === '"')
+        return scanString(scan, index);
+    if (char === '{' || char === '[') {
+        scan.containers.push(takeValue(scan));
     }
-    catch (error) {
-        log.debug(`Request body not JSON: ${getErrorMessage(error)}`);
-        return error instanceof SyntaxError ? text : REDACTED;
+    else if (char === '}' || char === ']') {
+        if (scan.containers.length > 1)
+            scan.containers.pop();
+        scan.key = undefined;
+    }
+    else if (char === ',') {
+        scan.key = undefined;
+    }
+    else {
+        return scanBare(scan, index);
+    }
+    return index + 1;
+}
+/**
+ * Read a string: a key (followed by `:`) sets whether the next value is
+ * sensitive; a value under a credential name is replaced, JSON encoded in a
+ * value is redacted and encoded again, and JWTs in other values are replaced.
+ *
+ * @param scan - Scan state
+ * @param start - Index of the opening quote
+ * @returns Index after the string
+ */
+function scanString(scan, start) {
+    const end = stringEnd(scan, start);
+    if (isFollowedByColon(scan.text, end)) {
+        scan.key = isSensitiveField(keyName(scan.text, start, end));
+    }
+    else if (takeValue(scan)) {
+        replaceValue(scan, start, end, REDACTED_STRING);
+    }
+    else {
+        const encoded = redactEncodedJson(scan, start, end);
+        if (encoded === undefined)
+            redactStringJwts(scan, start, end);
+        else
+            replaceValue(scan, start, end, encoded);
+    }
+    return end;
+}
+/**
+ * Replace the whole JWTs in a string value, keeping the text around them.
+ *
+ * @param scan - Scan state
+ * @param start - Index of the opening quote
+ * @param end - Index after the string
+ */
+function redactStringJwts(scan, start, end) {
+    const contentEnd = end - 1 > start && scan.text[end - 1] === '"' ? end - 1 : end;
+    const content = scan.text.slice(start + 1, contentEnd);
+    const redacted = redactJwts(content, REDACTED);
+    if (redacted !== content)
+        replaceValue(scan, start + 1, contentEnd, redacted);
+}
+/**
+ * Read a bare value or word up to the next delimiter; a number, `true`,
+ * `false` or any bare text right after a credential key is replaced. Other
+ * words are not values.
+ *
+ * @param scan - Scan state
+ * @param index - Index of the character
+ * @returns Index after the bare text, or after a whitespace or colon character
+ */
+function scanBare(scan, index) {
+    BARE.lastIndex = index;
+    const bare = BARE.exec(scan.text)?.[0];
+    if (bare === undefined)
+        return index + 1;
+    const end = index + bare.length;
+    const isLiteral = /^[-\d]/.test(bare) || bare === 'true' || bare === 'false' || bare === 'null';
+    if (!isLiteral && scan.key !== true)
+        return end;
+    if (takeValue(scan) && bare !== 'null')
+        replaceValue(scan, index, end, REDACTED_STRING);
+    return end;
+}
+/**
+ * Whether the value being read is under a credential name; consumes the key.
+ *
+ * @param scan - Scan state
+ * @returns True when its key or an enclosing object or array names a credential
+ */
+function takeValue(scan) {
+    const sensitive = scan.key === true || scan.containers[scan.containers.length - 1] === true;
+    scan.key = undefined;
+    return sensitive;
+}
+/**
+ * Write a replacement instead of the text between two indices.
+ *
+ * @param scan - Scan state
+ * @param start - Index of the value's first character
+ * @param end - Index after the value
+ * @param replacement - Text written instead
+ */
+function replaceValue(scan, start, end, replacement) {
+    scan.parts.push(scan.text.slice(scan.copied, start), replacement);
+    scan.copied = end;
+}
+/**
+ * Whether the character at an index cannot be part of a JWT's word: outside
+ * the text, or not a base64url character, `.` or `-`.
+ *
+ * @param text - Text
+ * @param index - Index (may be -1 or the text length)
+ * @returns True at a word boundary
+ */
+function isJwtBoundary(text, index) {
+    if (index < 0 || index >= text.length)
+        return true;
+    const code = text.charCodeAt(index);
+    return !isBase64UrlCode(code) && code !== DOT;
+}
+/**
+ * End of a JWT starting at an index: `eyJ` and at least 5 more base64url
+ * characters, a dot, at least 5, a dot, and any number.
+ *
+ * @param text - Text
+ * @param start - Index of `eyJ`
+ * @returns Index after the third segment, or undefined when it is no JWT
+ */
+function jwtEnd(text, start) {
+    const first = segmentEnd(text, start + 3);
+    if (first - start < 8 || text[first] !== '.')
+        return undefined;
+    const second = segmentEnd(text, first + 1);
+    if (second - first - 1 < 5 || text[second] !== '.')
+        return undefined;
+    return segmentEnd(text, second + 1);
+}
+/**
+ * End of a run of base64url characters.
+ *
+ * @param text - Text
+ * @param from - Index to start at
+ * @returns Index of the first other character, or the text length
+ */
+function segmentEnd(text, from) {
+    let index = from;
+    while (index < text.length && isBase64UrlCode(text.charCodeAt(index)))
+        index++;
+    return index;
+}
+/**
+ * Whether a character code is a base64url character: `A-Z`, `a-z`, `0-9`,
+ * `_` or `-`.
+ *
+ * @param code - UTF-16 code unit
+ * @returns True for a base64url character
+ */
+function isBase64UrlCode(code) {
+    return ((code >= 0x30 && code <= 0x39) ||
+        (code >= 0x41 && code <= 0x5a) ||
+        (code >= 0x61 && code <= 0x7a) ||
+        code === 0x5f ||
+        code === 0x2d);
+}
+/**
+ * Redact JSON encoded in a string value (a JSON payload, GraphQL variables,
+ * a SockJS or socket.io message): decoded text that looks like JSON
+ * ({@link JSON_LIKE_START}), up to {@link MAX_ENCODED_DEPTH} levels.
+ *
+ * @param scan - Scan state
+ * @param start - Index of the opening quote
+ * @param end - Index after the string
+ * @returns The string encoded again with credentials redacted; undefined when
+ *   it holds no JSON or no credentials, so it stays byte for byte
+ */
+function redactEncodedJson(scan, start, end) {
+    if (scan.depth >= MAX_ENCODED_DEPTH || end - start < 2 || scan.text[end - 1] !== '"') {
+        return undefined;
     }
+    if (!/[[{]/.test(scan.text.slice(start + 1, end - 1)))
+        return undefined;
+    let decoded;
     try {
-        const hits = { count: 0 };
-        const redacted = redactJson(parsed, false, hits);
-        return hits.count > 0 ? JSON.stringify(redacted) : text;
+        decoded = JSON.parse(scan.text.slice(start, end));
     }
     catch (error) {
-        log.debug(`Request body redacted whole: ${getErrorMessage(error)}`);
-        return REDACTED;
+        log.debug(`String value not decodable: ${getErrorMessage(error)}`);
+        return undefined;
+    }
+    if (!JSON_LIKE_START.test(decoded))
+        return undefined;
+    const redacted = redactJsonText(decoded, scan.depth + 1);
+    return redacted === decoded ? undefined : JSON.stringify(redacted);
+}
+/**
+ * End of a JSON string: its closing quote, or the end of its line. Each quote
+ * looks back only over the backslashes since the previous quote, and the
+ * line end is cached, so the search stays linear.
+ *
+ * @param scan - Scan state
+ * @param start - Index of the opening quote
+ * @returns Index after the closing quote, or of the line break (`\r\n` or
+ *   `\n`) or text end when the line has none
+ */
+function stringEnd(scan, start) {
+    const { text } = scan;
+    let from = start + 1;
+    for (;;) {
+        const quote = text.indexOf('"', from);
+        const lineEnd = nextLineEnd(scan, from);
+        if (quote === -1 || lineEnd < quote) {
+            return lineEnd > from && text[lineEnd - 1] === '\r' ? lineEnd - 1 : lineEnd;
+        }
+        let backslashes = 0;
+        while (text[quote - 1 - backslashes] === '\\' && quote - 1 - backslashes > start) {
+            backslashes++;
+        }
+        if (backslashes % 2 === 0)
+            return quote + 1;
+        from = quote + 1;
     }
 }
 /**
- * Copy of parsed JSON with the primitives under credential names replaced.
- * Objects and arrays keep their structure; every string, number and boolean
- * inside a credential-named field is replaced, at any depth.
+ * Index of the next `\n` at or after an index, or the text length.
  *
- * @param value - Parsed JSON value
- * @param sensitive - Whether an enclosing field name holds a credential
- * @param hits - Counter of replaced values
- * @returns Redacted copy
+ * @param scan - Scan state, whose cached line end is updated
+ * @param from - Index to look from
+ * @returns Index of the line break
  */
-function redactJson(value, sensitive, hits) {
-    if (Array.isArray(value))
-        return value.map((item) => redactJson(item, sensitive, hits));
-    if (value !== null && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).map(([key, field]) => [
-            key,
-            redactJson(field, sensitive || isSensitiveField(key), hits),
-        ]));
+function nextLineEnd(scan, from) {
+    if (scan.lineEnd < from) {
+        const lineEnd = scan.text.indexOf('\n', from);
+        scan.lineEnd = lineEnd === -1 ? scan.text.length : lineEnd;
+    }
+    return scan.lineEnd;
+}
+/**
+ * Whether the next character after whitespace is a colon.
+ *
+ * @param text - Text
+ * @param index - Index to look from
+ * @returns True when a key ends at the index
+ */
+function isFollowedByColon(text, index) {
+    let next = index;
+    while (next < text.length && ' \t\n\r'.includes(text.charAt(next)))
+        next++;
+    return text[next] === ':';
+}
+/**
+ * Name of a key, with JSON escapes decoded.
+ *
+ * @param text - Text
+ * @param start - Index of the opening quote
+ * @param end - Index after the closing quote
+ * @returns Decoded name, or the raw name when its escapes are not valid
+ */
+function keyName(text, start, end) {
+    const raw = text.slice(start + 1, end - 1);
+    if (!raw.includes('\\'))
+        return raw;
+    try {
+        return JSON.parse(text.slice(start, end));
+    }
+    catch (error) {
+        log.debug(`Key not decodable: ${getErrorMessage(error)}`);
+        return raw;
     }
-    if (!sensitive || !['string', 'number', 'boolean'].includes(typeof value))
-        return value;
-    hits.count++;
-    return REDACTED;
 }
 //# sourceMappingURL=sanitizeBody.js.map

package/dist/telemetry/har/types.d.ts

@@ -115,6 +115,8 @@ export interface WebSocketMessage {
     opcode: number;
     /** Message payload (base64 for binary messages) */
     data: string;
+    /** Original payload length in characters, when bdg cut `data` at capture */
+    _truncatedFrom?: number;
 }
 /**
  * Request object containing detailed info about the request.

package/dist/telemetry/network.d.ts

@@ -30,7 +30,7 @@ export interface NetworkCollectionOptions {
     maxBodySize?: number;
     /** Finished requests kept at most; past it the oldest are dropped (default {@link MAX_NETWORK_REQUESTS}) */
     maxRequests?: number;
-    /** Total size of stored response bodies; past it the oldest are evicted (default {@link MAX_TOTAL_BODY_BYTES}) */
+    /** Total size of stored request and response bodies; past it the oldest are evicted (default {@link MAX_TOTAL_BODY_BYTES}) */
     maxTotalBodyBytes?: number;
     /** Counters of dropped requests and evicted bodies; otherwise the collector keeps private ones */
     evictions?: NetworkEvictions | undefined;
@@ -52,9 +52,9 @@ export interface NetworkCollectionOptions {
  * - The newest 10,000 finished requests are kept: past that the oldest finished
  *   ones are dropped (counted in `evictions.requestsDropped`); requests in flight
  *   are tracked separately and never dropped mid-flight
- * - Stored response bodies total at most 100MB: past that the oldest bodies are
- *   replaced by a placeholder (counted in `evictions.bodiesEvicted`), their
- *   request metadata stays
+ * - Stored request (post data) and response bodies total at most 100MB: past
+ *   that the oldest bodies are replaced by a placeholder (counted in
+ *   `evictions.bodiesEvicted`), their request metadata stays
  * - Response bodies are automatically skipped for images, fonts, CSS, and source maps (see DEFAULT_SKIP_BODY_PATTERNS)
  * - Response bodies larger than 5MB are skipped with a placeholder message
  * - By default, common tracking/analytics domains are filtered out (use includeAll to disable)

package/dist/telemetry/network.js

@@ -3,6 +3,7 @@ import { TypedCDPConnection } from '../connection/typed-cdp.js';
 import { MAX_NETWORK_REQUESTS, MAX_RESPONSE_SIZE, MAX_TOTAL_BODY_BYTES, CHROME_NETWORK_BUFFER_TOTAL, CHROME_NETWORK_BUFFER_PER_RESOURCE, CHROME_POST_DATA_LIMIT, } from '../constants.js';
 import { attachChildTargets } from './attachedTargets.js';
 import { createLogger } from '../ui/logging/index.js';
+import { bodyFetchFailedReason, bodyGoneReason } from '../ui/messages/networkMessages.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { filterDefined } from '../utils/objects.js';
 import { shouldExcludeDomain, shouldExcludeUrl, shouldFetchBodyWithReason } from './filters.js';
@@ -21,10 +22,38 @@ function shouldFilterRequest(url, includeAll, networkInclude, networkExclude) {
     }
     return false;
 }
+/** Statuses whose responses never have a body (RFC 9110) */
+const BODYLESS_STATUSES = new Set([204, 205, 304]);
+/**
+ * Whether HTTP rules out a body for this response (HEAD, 1xx, 204, 205,
+ * 304), so a failed body fetch means nothing was missed.
+ *
+ * @param request - Finished request
+ * @returns True when the response has no body by definition
+ */
+function responseHasNoBody(request) {
+    const status = request.status ?? 0;
+    return (request.method === 'HEAD' || (status >= 100 && status < 200) || BODYLESS_STATUSES.has(status));
+}
+/** Chrome's errors for a body it no longer has (evicted from its buffer, or never kept) */
+const BODY_GONE_ERROR = /No (resource|data found for resource) with given identifier/;
+/**
+ * Why a body fetch Chrome refused left no body.
+ *
+ * @param error - Rejection of `Network.getResponseBody`
+ * @returns Reason for `bodyNotCaptured`
+ */
+function bodyFetchErrorReason(error) {
+    const message = getErrorMessage(error);
+    return BODY_GONE_ERROR.test(message) ? bodyGoneReason() : bodyFetchFailedReason(message);
+}
 /**
  * Fetch response body for a request with cancellation support: a body that
  * arrives after its fetch was cancelled (removed from `pendingFetches`: the
- * collector stopped, or the request was dropped) is discarded.
+ * collector stopped, or the request was dropped) is discarded. A fetch Chrome
+ * refuses leaves a skipped-body placeholder with the reason (unless the fetch
+ * was cancelled, a body is already stored, or the response has no body by
+ * definition).
  *
  * @param cdp - CDP connection instance
  * @param requestId - Request ID to fetch body for
@@ -45,6 +74,11 @@ function fetchResponseBody(cdp, requestId, request, pendingFetches, retention, s
     })
         .catch((error) => {
         log.debug(`Failed to fetch response body for request ${requestId}: ${getErrorMessage(error)}`);
+        if (!pendingFetches.has(requestId))
+            return;
+        if (request.responseBody !== undefined || responseHasNoBody(request))
+            return;
+        request.responseBody = skippedBodyPlaceholder(bodyFetchErrorReason(error));
     })
         .finally(() => {
         pendingFetches.delete(requestId);
@@ -256,9 +290,9 @@ async function collectChildTargetNetwork(cdp) {
  * - The newest 10,000 finished requests are kept: past that the oldest finished
  *   ones are dropped (counted in `evictions.requestsDropped`); requests in flight
  *   are tracked separately and never dropped mid-flight
- * - Stored response bodies total at most 100MB: past that the oldest bodies are
- *   replaced by a placeholder (counted in `evictions.bodiesEvicted`), their
- *   request metadata stays
+ * - Stored request (post data) and response bodies total at most 100MB: past
+ *   that the oldest bodies are replaced by a placeholder (counted in
+ *   `evictions.bodiesEvicted`), their request metadata stays
  * - Response bodies are automatically skipped for images, fonts, CSS, and source maps (see DEFAULT_SKIP_BODY_PATTERNS)
  * - Response bodies larger than 5MB are skipped with a placeholder message
  * - By default, common tracking/analytics domains are filtered out (use includeAll to disable)