@browserbridge/bbx 1.10.0 → 1.11.1

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,8 +64,8 @@ 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 {{ socket: ClientSocket, timeoutId: NodeJS.Timeout, source?: string, method?: string, protocolVersion?: string, baselineId?: string | null, automaticMcpRetry?: boolean, targets: Set<ClientSocket>, lastErrorResponse?: import('../../protocol/src/types.js').BridgeResponse }} PendingEntry */
+/** @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 {{
  *   installAgentFiles: typeof import('../../agent-client/src/install.js').installAgentFiles,
@@ -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 =
@@ -1165,6 +1277,7 @@ export class BridgeDaemon {
       method: request.method,
       protocolVersion: request.meta?.protocol_version,
       source: typeof request.meta?.source === 'string' ? request.meta.source : '',
+      mcpEra: typeof request.meta?.mcp_era === 'string' ? request.meta.mcp_era : '',
       baselineId,
       automaticMcpRetry: isAutomaticMcpRetry(request.meta),
       targets: new Set([target]),
@@ -1221,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.
@@ -1347,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);
@@ -1456,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();
   }
 
   /**
@@ -1603,6 +1700,7 @@ export class BridgeDaemon {
         ok: true,
         id: responseMessage.id,
         source: pending.source || null,
+        ...(pending.mcpEra ? { mcpEra: pending.mcpEra } : {}),
       });
       return;
     }
@@ -1621,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);
@@ -1702,6 +1804,7 @@ export class BridgeDaemon {
       ok: false,
       id: requestId,
       source: pending.source || null,
+      ...(pending.mcpEra ? { mcpEra: pending.mcpEra } : {}),
     });
 
     await writeJsonLine(pending.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 (
@@ -372,11 +385,30 @@ export function validateBridgeRequest(request) {
         typeof meta.protocol_version === 'string' ? meta.protocol_version : getProtocolVersion(),
       token_budget: typeof meta.token_budget === 'number' ? meta.token_budget : null,
       source: meta.source === 'cli' || meta.source === 'mcp' ? meta.source : undefined,
+      mcp_era: normalizeMcpEra(meta.source, meta.mcp_era),
       automatic_retry: normalizeAutomaticRetryMeta(meta.source, meta.automatic_retry),
     },
   };
 }
 
+/** @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
+ * @returns {import('./types.js').McpProtocolEra | undefined}
+ */
+function normalizeMcpEra(source, value) {
+  return source === 'mcp' && (value === 'legacy' || value === 'modern') ? value : undefined;
+}
+
 /**
  * @param {unknown} source
  * @param {unknown} value
@@ -1493,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') {
@@ -1513,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;
@@ -1523,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,
@@ -1537,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

@@ -1,4 +1,5 @@
 export type BridgeRequestSource = 'cli' | 'mcp';
+export type McpProtocolEra = 'legacy' | 'modern';
 
 export type AccessIntent = 'inspect' | 'interact' | 'capture' | 'navigate' | 'debugger' | 'general';
 
@@ -153,6 +154,7 @@ export interface BridgeMeta {
   image_approx_tokens?: number;
   image_bytes?: number;
   source?: BridgeRequestSource;
+  mcp_era?: McpProtocolEra;
   response_bytes?: number;
   approx_tokens?: number;
   cost_class?: CostClass;
@@ -1051,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;

package/skills/browser-bridge/SKILL.md

@@ -15,7 +15,7 @@ Skill name: `browser-bridge` (also known as `bbx`). In GitHub Copilot, invoke as
 When the runtime supports subagents, delegate bridge inspection to a smaller, lower-cost worker and return only concise findings to the parent.
 For open-ended investigation, start with structured reads (`page.get_state`, `dom.query`, `page.get_text`, `page.extract_content`, `styles.get_computed`, and `bbx batch` for CLI or `browser_batch` for MCP) and escalate to screenshots or debugger-backed methods only when structured evidence is insufficient. `browser_call` accepts one protocol method at a time; `batch` is not a valid `browser_call` method.
 When an unfamiliar method is needed, run `bbx protocol describe <method|group>` before guessing parameters. In MCP mode, call `browser_call` with method `protocol.describe` and params `{ "method": "dom.query" }` or `{ "group": "inspect" }`.
-MCP exposes common tools first. Load one specialized typed tool only when needed by calling `browser_toolset` with its exact name, for example `{ "tool": "browser_dom" }`; `browser_call` remains the universal fallback.
+MCP exposes a compact tool surface. If `browser_toolset` is available on a legacy connection, load one specialized typed tool only when needed, for example `{ "tool": "browser_dom" }`. Modern stateless connections use a fixed surface with `browser_skill` instead. `browser_call` remains the universal path in both eras.
 
 ## CLI