@browserbridge/bbx 1.11.0 → 1.11.1

package/SECURITY.md

@@ -52,8 +52,15 @@ Out of scope:
 
 - By default the daemon listens on a user-owned Unix socket (mode `0700` directory) or,
   on Windows, a named pipe / localhost TCP.
-- Any TCP listener requires a random 256-bit auth token stored with mode `0600`;
-  registration without it is rejected and the comparison is constant-time.
+- Any TCP listener requires random 256-bit credentials stored with mode `0600`.
+  Agents and the Chrome native host use distinct credentials, so a remote agent
+  token cannot register an extension-role socket. Registration without the
+  role-appropriate credential is rejected and comparison is constant-time.
+- Setup mutation is accepted only from the local socket or authenticated native
+  host. A TCP agent remains non-local even when its peer address is loopback,
+  preventing SSH port forwarding from turning remote access into local control.
+- Daemon connections, registration time, malformed input, pending requests, and
+  per-client pending requests are bounded to limit resource exhaustion.
 - Proxy mode (LAN exposure) is opt-in via `bbx proxy enable` and always provisions a
   token; an invalid `bindHost` in the config rejects the config rather than widening
   the bind address.
@@ -62,3 +69,8 @@ Out of scope:
 - Ordinary Web Storage reads return key/presence metadata only. The separate
   `sensitive.read` method requires one exact key, is excluded from batches and
   automatic retries, and returns a value whole or fails atomically.
+- Fetch/XHR and console capture run in the inspected page's main JavaScript
+  world. Results are therefore marked `integrity: "untrusted"`, copied through
+  strict bounded schemas, and never treated as daemon or extension authority.
+- Request interception rules are bounded per tab; patterns, bodies, and headers
+  have protocol-level size limits and URL matchers are compiled once per rule.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbridge/bbx",
-  "version": "1.11.0",
+  "version": "1.11.1",
   "private": false,
   "keywords": [
     "agent-tools",
@@ -80,7 +80,7 @@
   },
   "devDependencies": {
     "@modelcontextprotocol/client": "^2.0.0",
-    "@types/chrome": "^0.2.5",
+    "@types/chrome": "^0.2.6",
     "@types/node": "^26.2.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/packages/native-host/bin/postinstall.js

@@ -17,15 +17,17 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(__dirname, '../../..');
 
 /**
- * npm exec may run package lifecycle hooks while resolving the local bin. Keep
- * transient `npm exec -- bbx ...` invocations from rewriting host setup or
- * replacing a working daemon.
+ * Host setup is appropriate for a global CLI install, not when this package is
+ * an ordinary project dependency. npm exec is also always non-mutating. The
+ * explicit force switch is reserved for controlled packaging/tests.
  *
  * @param {NodeJS.ProcessEnv} [env=process.env]
  * @returns {boolean}
  */
-function shouldSkipPostinstall(env = process.env) {
-  return env.npm_command === 'exec';
+export function shouldSkipPostinstall(env = process.env) {
+  const globalInstall = env.npm_config_global === 'true' || env.npm_config_global === '1';
+  const explicitlyEnabled = env.BBX_POSTINSTALL_FORCE === '1';
+  return env.npm_command === 'exec' || (!globalInstall && !explicitlyEnabled);
 }
 
 /**

package/packages/native-host/src/auth-token.js

@@ -9,6 +9,7 @@ import { getBridgeDir } from './config.js';
 export const BRIDGE_AUTH_TOKEN_ENV = 'BBX_AUTH_TOKEN';
 export const BRIDGE_AUTH_TOKEN_FILE_ENV = 'BBX_AUTH_TOKEN_FILE';
 const TOKEN_FILENAME = 'daemon.auth';
+const EXTENSION_TOKEN_FILENAME = 'daemon.extension.auth';
 const TOKEN_BYTES = 32;
 const TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,256}$/u;
 const UUID_TOKEN_PATTERN =
@@ -22,6 +23,17 @@ export function getBridgeAuthTokenPath(env = process.env) {
   return path.join(getBridgeDir(env), TOKEN_FILENAME);
 }
 
+/**
+ * Private credential used only by the Chrome native host when registering the
+ * extension role. Remote agent configurations never receive this token.
+ *
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {string}
+ */
+export function getBridgeExtensionAuthTokenPath(env = process.env) {
+  return path.join(getBridgeDir(env), EXTENSION_TOKEN_FILENAME);
+}
+
 /**
  * @param {unknown} value
  * @returns {string | null}
@@ -91,6 +103,25 @@ export async function readBridgeAuthToken(options = {}) {
   }
   const tokenPath = options.tokenPath ?? getBridgeAuthTokenPath();
   const readFile = options.readFile ?? fs.promises.readFile.bind(fs.promises);
+  return readStoredBridgeAuthToken(tokenPath, readFile);
+}
+
+/**
+ * @param {{ tokenPath?: string, readFile?: typeof fs.promises.readFile }} [options={}]
+ * @returns {Promise<string | null>}
+ */
+export async function readBridgeExtensionAuthToken(options = {}) {
+  const tokenPath = options.tokenPath ?? getBridgeExtensionAuthTokenPath();
+  const readFile = options.readFile ?? fs.promises.readFile.bind(fs.promises);
+  return readStoredBridgeAuthToken(tokenPath, readFile);
+}
+
+/**
+ * @param {string} tokenPath
+ * @param {typeof fs.promises.readFile} readFile
+ * @returns {Promise<string | null>}
+ */
+async function readStoredBridgeAuthToken(tokenPath, readFile) {
   try {
     return normalizeBridgeAuthToken(await readFile(tokenPath, 'utf8'));
   } catch (error) {
@@ -136,12 +167,43 @@ export async function writeBridgeAuthToken(token, options = {}) {
  */
 export async function ensureBridgeAuthToken(options = {}) {
   const tokenPath = options.tokenPath ?? getBridgeAuthTokenPath();
+  return ensureStoredBridgeAuthToken(tokenPath, options);
+}
+
+/**
+ * @param {{
+ *   tokenPath?: string,
+ *   readFile?: typeof fs.promises.readFile,
+ *   writeFile?: typeof fs.promises.writeFile,
+ *   mkdir?: typeof fs.promises.mkdir,
+ *   chmod?: typeof fs.promises.chmod,
+ *   randomBytesFn?: typeof randomBytes
+ * }} [options={}]
+ * @returns {Promise<string>}
+ */
+export async function ensureBridgeExtensionAuthToken(options = {}) {
+  const tokenPath = options.tokenPath ?? getBridgeExtensionAuthTokenPath();
+  return ensureStoredBridgeAuthToken(tokenPath, options);
+}
+
+/**
+ * @param {string} tokenPath
+ * @param {{
+ *   readFile?: typeof fs.promises.readFile,
+ *   writeFile?: typeof fs.promises.writeFile,
+ *   mkdir?: typeof fs.promises.mkdir,
+ *   chmod?: typeof fs.promises.chmod,
+ *   randomBytesFn?: typeof randomBytes
+ * }} options
+ * @returns {Promise<string>}
+ */
+async function ensureStoredBridgeAuthToken(tokenPath, options) {
   const readFile = options.readFile ?? fs.promises.readFile.bind(fs.promises);
   const writeFile = options.writeFile ?? fs.promises.writeFile.bind(fs.promises);
   const mkdir = options.mkdir ?? fs.promises.mkdir.bind(fs.promises);
   const chmod = options.chmod ?? fs.promises.chmod.bind(fs.promises);
   const randomBytesFn = options.randomBytesFn ?? randomBytes;
-  const existing = await readBridgeAuthToken({ tokenPath, readFile });
+  const existing = await readStoredBridgeAuthToken(tokenPath, readFile);
   if (existing) {
     return existing;
   }

package/packages/native-host/src/daemon.js

@@ -44,7 +44,12 @@ import {
   getSocketPath,
 } from './config.js';
 import { ArtifactStore } from './artifact-store.js';
-import { bridgeAuthTokensEqual, ensureBridgeAuthToken, readBridgeAuthToken } from './auth-token.js';
+import {
+  bridgeAuthTokensEqual,
+  ensureBridgeAuthToken,
+  ensureBridgeExtensionAuthToken,
+  readBridgeAuthToken,
+} from './auth-token.js';
 import { normalizeDaemonLogger } from './daemon-logger.js';
 import { DomBaselineOwnerRegistry, isValidBaselineId } from './dom-baseline-owners.js';
 import { writeJsonLine } from './framing.js';
@@ -59,7 +64,7 @@ setProtocolPackageVersion(DAEMON_VERSION);
 /** @typedef {import('./config.js').BridgeTransport} BridgeTransport */
 /** @typedef {import('./daemon-logger.js').DaemonLoggerLike} DaemonLoggerLike */
 /** @typedef {'agent' | 'extension'} SocketRole */
-/** @typedef {import('node:net').Socket & { readonly __role?: SocketRole, __clientId?: string, __extensionId?: string, __browserName?: string, __profileLabel?: string, __browserExtensionId?: string, __accessEnabled?: boolean, __lastActiveAt?: number }} ClientSocket */
+/** @typedef {import('node:net').Socket & { readonly __role?: SocketRole, __localControl?: boolean, __registrationTimeoutId?: NodeJS.Timeout, __invalidLineCount?: number, __clientId?: string, __extensionId?: string, __browserName?: string, __profileLabel?: string, __browserExtensionId?: string, __accessEnabled?: boolean, __lastActiveAt?: number }} ClientSocket */
 /** @typedef {{ socket: ClientSocket, timeoutId: NodeJS.Timeout, source?: string, mcpEra?: string, method?: string, protocolVersion?: string, baselineId?: string | null, automaticMcpRetry?: boolean, targets: Set<ClientSocket>, lastErrorResponse?: import('../../protocol/src/types.js').BridgeResponse }} PendingEntry */
 /**
  * @typedef {{
@@ -123,6 +128,13 @@ const DIAGNOSTIC_METHODS = new Set([
   'setup.get_status',
   'setup.install',
 ]);
+export const DAEMON_REGISTRATION_TIMEOUT_MS = 5_000;
+export const MAX_DAEMON_CONNECTIONS = 64;
+export const MAX_DAEMON_PENDING_REQUESTS = 128;
+export const MAX_DAEMON_PENDING_REQUESTS_PER_CLIENT = 16;
+export const MAX_DAEMON_INVALID_LINES = 3;
+const MAX_CLIENT_ID_LENGTH = 128;
+const MAX_ROUTING_LABEL_LENGTH = 128;
 
 /**
  * @param {unknown} value
@@ -134,6 +146,42 @@ function asHealthRecord(value) {
     : null;
 }
 
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function normalizeRoutingLabel(value) {
+  if (typeof value !== 'string' || value.length === 0 || value.length > MAX_ROUTING_LABEL_LENGTH) {
+    return undefined;
+  }
+  return hasAsciiControlCharacters(value) ? undefined : value;
+}
+
+/** @param {string} value @returns {boolean} */
+function hasAsciiControlCharacters(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | null}
+ */
+function normalizeClientId(value) {
+  if (value == null || value === '') return randomUUID();
+  if (
+    typeof value !== 'string' ||
+    value.length > MAX_CLIENT_ID_LENGTH ||
+    !/^[A-Za-z0-9_.:-]+$/u.test(value)
+  ) {
+    return null;
+  }
+  return value;
+}
+
 /**
  * @param {unknown} value
  * @returns {number | undefined}
@@ -383,6 +431,7 @@ export class BridgeDaemon {
    *   setupInstaller?: (params: Record<string, unknown>) => Promise<SetupInstallResult>,
    *   logger?: DaemonLoggerLike | Pick<Console, 'log' | 'error'>,
    *   authToken?: string | null,
+   *   extensionAuthToken?: string | null,
    *   artifactStore?: ArtifactStore
    * }} [options={}]
    */
@@ -394,6 +443,7 @@ export class BridgeDaemon {
     setupInstaller = installSetupTarget,
     logger = undefined,
     authToken = undefined,
+    extensionAuthToken = undefined,
     artifactStore = new ArtifactStore(getArtifactStorePath()),
   } = {}) {
     this.transport = socketPath ? createSocketBridgeTransport(socketPath) : transport;
@@ -437,6 +487,8 @@ export class BridgeDaemon {
     this.requestStartTimes = new Map();
     /** @type {string | null | undefined} */
     this.authToken = authToken;
+    /** @type {string | null | undefined} */
+    this.extensionAuthToken = extensionAuthToken;
     this.artifactStore = artifactStore;
     this.artifactStoreInitialized = false;
     this.domBaselines = new DomBaselineOwnerRegistry({
@@ -580,26 +632,32 @@ export class BridgeDaemon {
       return;
     }
 
-    if (this.isAuthRequired() && !bridgeAuthTokensEqual(message.authToken, this.authToken)) {
-      this.logger.error('socket registration rejected', { role: message.role ?? null });
+    if (message.role !== 'extension' && message.role !== 'agent') {
       void writeJsonLine(socket, {
         type: 'registration_failed',
         error: {
-          code: ERROR_CODES.ACCESS_DENIED,
-          message: 'Bridge daemon authentication failed.',
+          code: ERROR_CODES.INVALID_REQUEST,
+          message: 'Socket role must be "agent" or "extension".',
         },
-      }).finally(() => socket.destroy());
+      });
       return;
     }
 
-    if (message.role !== 'extension' && message.role !== 'agent') {
+    const expectedToken =
+      message.role === 'extension'
+        ? this.extensionAuthToken
+        : this.isAuthRequired()
+          ? this.authToken
+          : null;
+    if (expectedToken && !bridgeAuthTokensEqual(message.authToken, expectedToken)) {
+      this.logger.error('socket registration rejected', { role: message.role ?? null });
       void writeJsonLine(socket, {
         type: 'registration_failed',
         error: {
-          code: ERROR_CODES.INVALID_REQUEST,
-          message: 'Socket role must be "agent" or "extension".',
+          code: ERROR_CODES.ACCESS_DENIED,
+          message: 'Bridge daemon authentication failed.',
         },
-      });
+      }).finally(() => socket.destroy());
       return;
     }
 
@@ -609,13 +667,16 @@ export class BridgeDaemon {
       configurable: false,
       writable: false,
     });
+    if (socket.__registrationTimeoutId) {
+      clearTimeout(socket.__registrationTimeoutId);
+      socket.__registrationTimeoutId = undefined;
+    }
     if (message.role === 'extension') {
+      socket.__localControl = true;
       const extensionId = randomUUID();
       socket.__extensionId = extensionId;
-      socket.__browserName =
-        typeof message.browserName === 'string' ? message.browserName : undefined;
-      socket.__profileLabel =
-        typeof message.profileLabel === 'string' ? message.profileLabel : undefined;
+      socket.__browserName = normalizeRoutingLabel(message.browserName);
+      socket.__profileLabel = normalizeRoutingLabel(message.profileLabel);
       socket.__browserExtensionId = normalizeBrowserExtensionId(message.browserExtensionId);
       socket.__lastActiveAt = Date.now();
       this.extensionSockets.set(extensionId, socket);
@@ -630,7 +691,18 @@ export class BridgeDaemon {
     }
 
     if (message.role === 'agent') {
-      const clientId = message.clientId || randomUUID();
+      socket.__localControl = this.transport.type === 'socket';
+      const clientId = normalizeClientId(message.clientId);
+      if (!clientId) {
+        void writeJsonLine(socket, {
+          type: 'registration_failed',
+          error: {
+            code: ERROR_CODES.INVALID_REQUEST,
+            message: 'Agent clientId is invalid.',
+          },
+        }).finally(() => socket.destroy());
+        return;
+      }
       this.agentSockets.set(clientId, socket);
       socket.__clientId = clientId;
       this.logger.info('agent registered', { clientId });
@@ -649,6 +721,10 @@ export class BridgeDaemon {
     if (this.authToken === undefined) {
       this.authToken = this.transport.type === 'tcp' ? await ensureBridgeAuthToken() : null;
     }
+    if (this.extensionAuthToken === undefined) {
+      this.extensionAuthToken =
+        this.transport.type === 'tcp' ? await ensureBridgeExtensionAuthToken() : null;
+    }
 
     if (this.transport.type === 'socket' && !isWindowsNamedPipePath(this.socketPath)) {
       const socketDir = path.dirname(this.socketPath);
@@ -677,6 +753,14 @@ export class BridgeDaemon {
 
     this.server = net.createServer((socket) => {
       const typedSocket = /** @type {ClientSocket} */ (socket);
+      typedSocket.__invalidLineCount = 0;
+      typedSocket.__registrationTimeoutId = setTimeout(() => {
+        if (!typedSocket.__role) {
+          this.logger.warn('unregistered socket timed out');
+          typedSocket.destroy();
+        }
+      }, DAEMON_REGISTRATION_TIMEOUT_MS);
+      typedSocket.__registrationTimeoutId.unref?.();
       typedSocket.on('error', (err) => {
         this.logger.error('socket error', { message: err.message });
       });
@@ -694,10 +778,18 @@ export class BridgeDaemon {
           onProtocolError: (error) => {
             this.logger.error('socket protocol error', { message: error.message });
           },
+          onInvalidLine: () => {
+            typedSocket.__invalidLineCount = (typedSocket.__invalidLineCount ?? 0) + 1;
+            if (typedSocket.__invalidLineCount >= MAX_DAEMON_INVALID_LINES) {
+              this.logger.warn('socket sent too many malformed JSON lines');
+              typedSocket.destroy();
+            }
+          },
         }
       );
       typedSocket.on('close', () => this.handleSocketClose(typedSocket));
     });
+    this.server.maxConnections = MAX_DAEMON_CONNECTIONS;
 
     const server = this.server;
     await new Promise((resolve, reject) => {
@@ -1076,7 +1168,7 @@ export class BridgeDaemon {
     }
 
     if (request.method === 'setup.install') {
-      if (socket.__role === 'agent' && !this.isLocalSocket(socket)) {
+      if (!socket.__localControl) {
         const response = createFailure(
           request.id,
           ERROR_CODES.ACCESS_DENIED,
@@ -1115,6 +1207,26 @@ export class BridgeDaemon {
       typeof request.meta?.target_profile === 'string' ? request.meta.target_profile : null;
     const hasExplicitTarget = Boolean(targetBrowser || targetProfile);
 
+    const ownerPendingCount = this.pendingRequestsByOwnerSocket.get(socket)?.size ?? 0;
+    if (
+      this.pendingRequests.size >= MAX_DAEMON_PENDING_REQUESTS ||
+      ownerPendingCount >= MAX_DAEMON_PENDING_REQUESTS_PER_CLIENT
+    ) {
+      const response = createFailure(
+        request.id,
+        ERROR_CODES.INVALID_REQUEST,
+        'Daemon pending-request limit reached. Wait for existing requests to finish.',
+        {
+          maxPendingRequests: MAX_DAEMON_PENDING_REQUESTS,
+          maxPendingRequestsPerClient: MAX_DAEMON_PENDING_REQUESTS_PER_CLIENT,
+        },
+        { method: request.method }
+      );
+      await writeJsonLine(socket, { type: 'agent.response', response });
+      this.recordDaemonRequestOutcome(request, false);
+      return;
+    }
+
     const baselineId =
       typeof request.params.baselineId === 'string' ? request.params.baselineId : null;
     const usesBaselineOwner =
@@ -1222,23 +1334,6 @@ export class BridgeDaemon {
     }
   }
 
-  /**
-   * @param {ClientSocket} socket
-   * @returns {boolean}
-   */
-  isLocalSocket(socket) {
-    if (this.transport.type === 'socket') {
-      return true;
-    }
-    const address = socket.remoteAddress ?? '';
-    return (
-      address === '127.0.0.1' ||
-      address === '::1' ||
-      address === 'localhost' ||
-      address === '::ffff:127.0.0.1'
-    );
-  }
-
   /**
    * Select from a snapshot so routing neither mutates nor observes mutations to
    * the live extension map while candidates are ordered.
@@ -1348,13 +1443,15 @@ export class BridgeDaemon {
    */
   handleExtensionIdentity(socket, message) {
     let changed = false;
-    if (typeof message.browserName === 'string') {
-      changed = changed || socket.__browserName !== message.browserName;
-      socket.__browserName = message.browserName;
+    const browserName = normalizeRoutingLabel(message.browserName);
+    if (browserName) {
+      changed = changed || socket.__browserName !== browserName;
+      socket.__browserName = browserName;
     }
-    if (typeof message.profileLabel === 'string') {
-      changed = changed || socket.__profileLabel !== message.profileLabel;
-      socket.__profileLabel = message.profileLabel;
+    const profileLabel = normalizeRoutingLabel(message.profileLabel);
+    if (profileLabel) {
+      changed = changed || socket.__profileLabel !== profileLabel;
+      socket.__profileLabel = profileLabel;
     }
     if (typeof message.browserExtensionId === 'string') {
       const browserExtensionId = normalizeBrowserExtensionId(message.browserExtensionId);
@@ -1457,12 +1554,11 @@ export class BridgeDaemon {
 
   /**
    * @param {ClientSocket} socket
-   * @param {DaemonMessage} message
+   * @param {DaemonMessage} _message
    * @returns {void}
    */
-  handleExtensionActivity(socket, message) {
-    socket.__lastActiveAt =
-      typeof message.at === 'number' && Number.isFinite(message.at) ? message.at : Date.now();
+  handleExtensionActivity(socket, _message) {
+    socket.__lastActiveAt = Date.now();
   }
 
   /**
@@ -1623,6 +1719,10 @@ export class BridgeDaemon {
    * @returns {void}
    */
   handleSocketClose(socket) {
+    if (socket.__registrationTimeoutId) {
+      clearTimeout(socket.__registrationTimeoutId);
+      socket.__registrationTimeoutId = undefined;
+    }
     if (socket.__extensionId) {
       this.artifactStore.deleteByExtension(socket.__extensionId);
       this.domBaselines.clearForSocket(socket);

package/packages/native-host/src/install-manifest.js

@@ -184,7 +184,8 @@ export function getDefaultExtensionId(env = process.env) {
 
 /**
  * Build the allowed_origins list.
- * If an extension ID was provided, ensures its origin is present.
+ * If an extension ID was provided, it is the complete allowlist so stale
+ * origins from an earlier installation do not retain native-host access.
  * Otherwise falls back to existing origins or a placeholder.
  *
  * @param {{allowed_origins?: string[]} | null} existingManifest
@@ -199,14 +200,7 @@ export function getAllowedOrigins(existingManifest, extensionId) {
 
   if (extensionId) {
     const origin = `chrome-extension://${extensionId}/`;
-    const merged = new Set(existing);
-    merged.add(origin);
-    for (const item of [...merged]) {
-      if (item.includes('__REPLACE_WITH_EXTENSION_ID__')) {
-        merged.delete(item);
-      }
-    }
-    return [...merged];
+    return [origin];
   }
 
   if (existing.length > 0) return existing;

package/packages/native-host/src/native-host.js

@@ -8,7 +8,7 @@ import {
   parseJsonLines,
   sanitizeIncidentalText,
 } from '../../protocol/src/index.js';
-import { readBridgeAuthToken } from './auth-token.js';
+import { readBridgeExtensionAuthToken } from './auth-token.js';
 import { createSocketBridgeTransport, getBridgeTransport } from './config.js';
 import { spawnBridgeDaemonProcess } from './daemon-process.js';
 import { createNativeMessageReader, createNativeMessageWriter, writeJsonLine } from './framing.js';
@@ -163,11 +163,11 @@ export async function runNativeHost({
   socket.once('close', cleanupStdinEndListener);
   socket.once('end', cleanupStdinEndListener);
   socket.once('error', cleanupStdinEndListener);
-  const authToken = resolvedTransport.type === 'tcp' ? await readBridgeAuthToken() : null;
+  const authToken = await readBridgeExtensionAuthToken();
   await writeJsonLine(socket, {
     type: 'register',
     role: 'extension',
-    ...(authToken ? { authToken } : {}),
+    authToken,
   });
 
   parseJsonLines(

package/packages/protocol/src/defaults.js

@@ -45,6 +45,12 @@ export const MAX_BATCH_CALLS = 20;
 
 /** Maximum read-only batch calls executing concurrently. */
 export const MAX_BATCH_CONCURRENCY = 5;
+export const MAX_INTERCEPT_RULES_PER_TAB = 32;
+export const MAX_INTERCEPT_URL_PATTERN_LENGTH = 2_048;
+export const MAX_INTERCEPT_BODY_BYTES = 262_144;
+export const MAX_INTERCEPT_HEADERS = 64;
+export const MAX_INTERCEPT_HEADER_VALUE_BYTES = 8_192;
+export const MAX_INTERCEPT_HEADER_BYTES = 65_536;
 export const SCREENSHOT_AUTO_INLINE_BYTES = 262_144;
 export const SCREENSHOT_MAX_INLINE_BYTES = 524_288;
 export const ARTIFACT_CHUNK_BYTES = 196_608;

package/packages/protocol/src/protocol.js

@@ -26,6 +26,11 @@ import {
   MAX_EXTRACT_SETTLE_TIMEOUT_MS,
   MAX_ARTIFACT_BYTES,
   MAX_HAR_ENTRIES,
+  MAX_INTERCEPT_BODY_BYTES,
+  MAX_INTERCEPT_HEADER_BYTES,
+  MAX_INTERCEPT_HEADERS,
+  MAX_INTERCEPT_HEADER_VALUE_BYTES,
+  MAX_INTERCEPT_URL_PATTERN_LENGTH,
   MAX_SENSITIVE_VALUE_BYTES,
 } from './defaults.js';
 import { BridgeError, ERROR_CODES, getErrorRecovery } from './errors.js';
@@ -300,8 +305,16 @@ export function validateBridgeRequest(request) {
 
   const candidate = /** @type {Record<string, unknown>} */ (request);
 
-  if (typeof candidate.id !== 'string' || !candidate.id.trim()) {
-    throw new BridgeError(ERROR_CODES.INVALID_REQUEST, 'Request id must be a non-empty string.');
+  if (
+    typeof candidate.id !== 'string' ||
+    !candidate.id.trim() ||
+    candidate.id.length > 128 ||
+    hasAsciiControlCharacters(candidate.id)
+  ) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      'Request id must be a non-empty string of at most 128 characters without controls.'
+    );
   }
 
   if (
@@ -378,6 +391,15 @@ export function validateBridgeRequest(request) {
   };
 }
 
+/** @param {string} value @returns {boolean} */
+function hasAsciiControlCharacters(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+
 /**
  * @param {unknown} source
  * @param {unknown} value
@@ -1503,6 +1525,12 @@ export function normalizeNetworkInterceptAddParams(params = {}) {
   if (typeof params.urlPattern !== 'string' || !params.urlPattern) {
     throw new BridgeError(ERROR_CODES.INVALID_REQUEST, 'urlPattern is required.');
   }
+  if (params.urlPattern.length > MAX_INTERCEPT_URL_PATTERN_LENGTH) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `urlPattern must not exceed ${MAX_INTERCEPT_URL_PATTERN_LENGTH} characters.`
+    );
+  }
 
   const action = params.action ?? DEFAULT_NETWORK_INTERCEPT_ACTION;
   if (action !== 'fulfill' && action !== 'continue' && action !== 'block') {
@@ -1523,6 +1551,15 @@ export function normalizeNetworkInterceptAddParams(params = {}) {
   if (params.body !== undefined && typeof params.body !== 'string') {
     throw new BridgeError(ERROR_CODES.INVALID_REQUEST, 'body must be a string.');
   }
+  if (
+    typeof params.body === 'string' &&
+    new TextEncoder().encode(params.body).byteLength > MAX_INTERCEPT_BODY_BYTES
+  ) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `body must not exceed ${MAX_INTERCEPT_BODY_BYTES} UTF-8 bytes.`
+    );
+  }
 
   /** @type {Record<string, string> | undefined} */
   let headers;
@@ -1533,8 +1570,16 @@ export function normalizeNetworkInterceptAddParams(params = {}) {
         'headers must be an object containing string values.'
       );
     }
+    const entries = Object.entries(params.headers);
+    if (entries.length > MAX_INTERCEPT_HEADERS) {
+      throw new BridgeError(
+        ERROR_CODES.INVALID_REQUEST,
+        `headers must contain at most ${MAX_INTERCEPT_HEADERS} entries.`
+      );
+    }
     headers = {};
-    for (const [name, value] of Object.entries(params.headers)) {
+    let headerBytes = 0;
+    for (const [name, value] of entries) {
       if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) {
         throw new BridgeError(
           ERROR_CODES.INVALID_REQUEST,
@@ -1547,6 +1592,20 @@ export function normalizeNetworkInterceptAddParams(params = {}) {
           `Header ${name} must have a string value without newlines.`
         );
       }
+      const valueBytes = new TextEncoder().encode(value).byteLength;
+      if (valueBytes > MAX_INTERCEPT_HEADER_VALUE_BYTES) {
+        throw new BridgeError(
+          ERROR_CODES.INVALID_REQUEST,
+          `Header ${name} must not exceed ${MAX_INTERCEPT_HEADER_VALUE_BYTES} UTF-8 bytes.`
+        );
+      }
+      headerBytes += new TextEncoder().encode(name).byteLength + valueBytes;
+      if (headerBytes > MAX_INTERCEPT_HEADER_BYTES) {
+        throw new BridgeError(
+          ERROR_CODES.INVALID_REQUEST,
+          `headers must not exceed ${MAX_INTERCEPT_HEADER_BYTES} UTF-8 bytes in total.`
+        );
+      }
       headers[name] = value;
     }
   }

package/packages/protocol/src/types.ts

@@ -1053,6 +1053,8 @@ export interface NetworkResult {
   dropped: number;
   abandoned: number;
   source: NetworkSource;
+  provenance: 'page_main_world' | 'chrome_devtools_protocol';
+  integrity: 'untrusted' | 'browser_observed';
   capture: NetworkCaptureAction | null;
   armed: boolean;
   armedDuringCapture: boolean;