@browserbridge/bbx 1.8.0 → 1.9.0

package/packages/agent-client/src/types.ts

@@ -4,6 +4,8 @@ import type {
   BridgeMethod,
   BridgeRequestSource,
   BridgeResponse,
+  RecoveryEventKind,
+  RecoveryTelemetrySummary,
   ScreenshotResult,
   SetupStatus,
 } from '../../protocol/src/types.js';
@@ -30,6 +32,26 @@ export type McpClientName =
 
 export type SupportedTarget = McpClientName;
 
+export type AutoUpdatePolicy = 'off' | 'compatible';
+
+export interface BrowserBridgeConfig {
+  autoUpdate: AutoUpdatePolicy;
+  [key: string]: unknown;
+}
+
+export interface NpmUpdateResult {
+  updated: boolean;
+  reason:
+    | 'updated'
+    | 'invalid_extension_version'
+    | 'invalid_installed_version'
+    | 'extension_not_newer'
+    | 'not_global_install'
+    | 'no_compatible_update';
+  previousVersion?: string;
+  version?: string;
+}
+
 export type Detector = () => boolean | Promise<boolean>;
 
 export interface InstallAgentOptions {
@@ -51,6 +73,8 @@ export interface SetupStatusOptions {
 
 export interface ProtocolHealthResult {
   extensionConnected?: boolean;
+  extensionVersion?: string;
+  daemonVersion?: string;
   supported_versions?: string[];
   extension_supported_versions?: string[];
   daemon_supported_versions?: string[];
@@ -91,6 +115,12 @@ export interface BridgeClientOptions {
   checkProtocolOnConnect?: boolean;
   restartDaemonOnVersionMismatch?: boolean;
   restartDaemonFn?: typeof restartBridgeDaemon;
+  updateNpmOnCompatibleVersion?: boolean;
+  exitProcessOnNpmUpdate?: boolean;
+  updateCompatibleNpmPackageFn?: (options: {
+    extensionVersion: string;
+    supportedVersions: readonly string[];
+  }) => Promise<NpmUpdateResult>;
   authToken?: string | null;
 }
 
@@ -182,6 +212,13 @@ export interface DoctorDaemonMetrics {
   requestsProcessed: number;
   requestsFailed: number;
   avgResponseTimeMs: number;
+  recovery: RecoveryTelemetrySummary | null;
+}
+
+export interface DoctorRecoveryDiagnostics {
+  daemon: RecoveryTelemetrySummary | null;
+  routedExtension: RecoveryTelemetrySummary | null;
+  activeLoops: RecoveryEventKind[];
 }
 
 export interface DoctorRecentEvent {
@@ -246,6 +283,7 @@ export interface DoctorReport {
   connections: DoctorConnectionDiagnostics;
   protocol: DoctorProtocolDiagnostics;
   debugger: DoctorDebuggerDiagnostics;
+  recovery: DoctorRecoveryDiagnostics;
   metrics: DoctorDaemonMetrics | null;
   recentEvents: DoctorRecentEvent[];
   recentCauses: DoctorRecentEvent['cause'][];

package/packages/mcp-server/src/handlers-capture.js

@@ -26,6 +26,8 @@ export const CAPTURE_ACTIONS = {
       elementRef: r,
       ...(a.format ? { format: a.format } : {}),
       ...(typeof a.quality === 'number' ? { quality: a.quality } : {}),
+      delivery: a.delivery ?? 'auto',
+      ...(typeof a.scale === 'number' ? { scale: a.scale } : {}),
     }),
   },
   region: {
@@ -35,6 +37,8 @@ export const CAPTURE_ACTIONS = {
       .../** @type {Record<string, unknown>} */ (a.rect || {}),
       ...(a.format ? { format: a.format } : {}),
       ...(typeof a.quality === 'number' ? { quality: a.quality } : {}),
+      delivery: a.delivery ?? 'auto',
+      ...(typeof a.scale === 'number' ? { scale: a.scale } : {}),
     }),
   },
   full_page: {
@@ -43,13 +47,15 @@ export const CAPTURE_ACTIONS = {
     params: (a) => ({
       ...(a.format ? { format: a.format } : {}),
       ...(typeof a.quality === 'number' ? { quality: a.quality } : {}),
+      delivery: a.delivery ?? 'auto',
+      ...(typeof a.scale === 'number' ? { scale: a.scale } : {}),
     }),
   },
   cdp_document: { ref: false, method: 'cdp.get_document', params: () => ({}) },
   cdp_dom_snapshot: {
     ref: false,
     method: 'cdp.get_dom_snapshot',
-    params: () => ({}),
+    params: (a) => ({ computedStyles: a.computedStyles }),
   },
   cdp_box_model: {
     ref: false,
@@ -93,7 +99,7 @@ function isValidCaptureRegion(rect) {
 }
 
 /**
- * @param {{ action: string, elementRef?: string, selector?: string, rect?: Record<string, unknown>, format?: 'png' | 'jpeg' | 'webp', quality?: number, nodeId?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * @param {{ action: string, elementRef?: string, selector?: string, rect?: Record<string, unknown>, format?: 'png' | 'jpeg' | 'webp', quality?: number, delivery?: 'auto' | 'inline' | 'artifact', scale?: number, nodeId?: number, computedStyles?: string[], tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleCaptureTool(args) {
@@ -141,6 +147,27 @@ export async function handleCaptureTool(args) {
  */
 export function createScreenshotResult(response, method) {
   const result = toRecord(response.result);
+  if (result.delivery === 'artifact') {
+    const artifact = toRecord(result.artifact);
+    if (typeof artifact.artifactId !== 'string' || typeof artifact.byteLength !== 'number') {
+      return summarizeToolError(new Error(`${method} returned invalid artifact metadata.`));
+    }
+    return createToolResult(
+      `Captured screenshot artifact (${artifact.byteLength} bytes, expires ${artifact.expiresAt ?? 'soon'}).`,
+      {
+        ok: true,
+        method,
+        delivery: 'artifact',
+        artifact,
+        mimeType: result.mimeType,
+        byteLength: result.byteLength,
+        dimensions: result.dimensions,
+        rect: boundedRect(result.rect),
+        complete: result.complete === true,
+        clipped: result.clipped === true,
+      }
+    );
+  }
   if (typeof result.image !== 'string') {
     return summarizeToolError(new Error(`${method} returned no image data.`));
   }

package/packages/mcp-server/src/handlers-dom.js

@@ -15,6 +15,32 @@ import {
 
 /** @type {Record<string, ToolAction>} */
 export const DOM_ACTIONS = {
+  baseline_create: {
+    ref: false,
+    method: 'dom.baseline.create',
+    params: (a) => ({
+      selector: a.selector,
+      maxNodes: a.maxNodes,
+      maxDepth: a.maxDepth,
+      textBudget: a.textBudget,
+      attributeAllowlist: a.attributeAllowlist,
+    }),
+  },
+  baseline_compare: {
+    ref: false,
+    method: 'dom.baseline.compare',
+    params: (a) => ({ baselineId: a.baselineId, maxChanges: a.maxChanges }),
+  },
+  baseline_describe: {
+    ref: false,
+    method: 'dom.baseline.describe',
+    params: (a) => ({ baselineId: a.baselineId }),
+  },
+  baseline_release: {
+    ref: false,
+    method: 'dom.baseline.release',
+    params: (a) => ({ baselineId: a.baselineId }),
+  },
   query: {
     ref: false,
     method: 'dom.query',
@@ -96,7 +122,7 @@ export const DOM_ACTIONS = {
 };
 
 /**
- * @param {{ action: string, selector?: string, elementRef?: string, withinRef?: string, maxNodes?: number, maxDepth?: number, compact?: boolean, interactiveOnly?: boolean, textBudget?: number, includeBbox?: boolean, attributeAllowlist?: string[], attributes?: string[], text?: string, exact?: boolean, maxResults?: number, role?: string, name?: string, state?: string, timeoutMs?: number, outer?: boolean, maxLength?: number, tabId?: number, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * @param {{ action: string, baselineId?: string, maxChanges?: number, selector?: string, elementRef?: string, withinRef?: string, maxNodes?: number, maxDepth?: number, compact?: boolean, interactiveOnly?: boolean, textBudget?: number, includeBbox?: boolean, attributeAllowlist?: string[], attributes?: string[], text?: string, exact?: boolean, maxResults?: number, role?: string, name?: string, state?: string, timeoutMs?: number, outer?: boolean, maxLength?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleDomTool(args) {
@@ -109,7 +135,17 @@ export async function handleDomTool(args) {
   if (args.action === 'find_role' && !hasText(args.role)) {
     return summarizeToolError('role is required for dom.find_by_role.');
   }
-  if (args.action === 'query' || args.action === 'accessibility_tree') {
+  if (
+    ['baseline_compare', 'baseline_describe', 'baseline_release'].includes(args.action) &&
+    !hasText(args.baselineId)
+  ) {
+    return summarizeToolError('baselineId is required for this DOM baseline action.');
+  }
+  if (
+    args.action === 'query' ||
+    args.action === 'accessibility_tree' ||
+    args.action === 'baseline_create'
+  ) {
     const inferred =
       args.action === 'accessibility_tree' ? 'normal' : inferBudgetFromSelector(args);
     const withBudget = inferred ? { ...args, budgetPreset: args.budgetPreset ?? inferred } : args;
@@ -118,6 +154,18 @@ export async function handleDomTool(args) {
   if (args.action === 'text') {
     return dispatchToolAction(DOM_ACTIONS, applyTextBudgetPreset(args), 'DOM');
   }
+  if (args.action === 'baseline_compare') {
+    const byPreset = { quick: 10, normal: 50, deep: 100 };
+    return dispatchToolAction(
+      DOM_ACTIONS,
+      {
+        ...args,
+        maxChanges:
+          args.maxChanges ?? (args.budgetPreset ? byPreset[args.budgetPreset] : undefined),
+      },
+      'DOM'
+    );
+  }
   if (args.action === 'html') {
     return dispatchToolAction(DOM_ACTIONS, applyHtmlBudgetPreset(args), 'DOM');
   }
@@ -189,11 +237,14 @@ export const PATCH_ACTIONS = {
         removeAttribute: 'remove_attribute',
         addClass: 'add_class',
         removeClass: 'remove_class',
+        toggleClass: 'toggle_class',
         setTextContent: 'set_text',
       };
       const normalizedOperation = opMap[operation] || operation;
       const value =
-        normalizedOperation === 'add_class' || normalizedOperation === 'remove_class'
+        normalizedOperation === 'add_class' ||
+        normalizedOperation === 'remove_class' ||
+        normalizedOperation === 'toggle_class'
           ? (a.value ?? a.name)
           : a.value;
       return {

package/packages/mcp-server/src/handlers-page.js

@@ -2,9 +2,13 @@
 
 import {
   DEFAULT_CONSOLE_LIMIT,
+  DEFAULT_HAR_LIMIT,
   DEFAULT_NETWORK_LIMIT,
   ERROR_CODES,
   getErrorRecovery,
+  isBatchSafeBridgeCall,
+  MAX_BATCH_CALLS,
+  MAX_BATCH_CONCURRENCY,
   METHOD_SET,
 } from '../../protocol/src/index.js';
 import { createBridgeClientForDestination } from '../../agent-client/src/remotes.js';
@@ -33,63 +37,6 @@ import { createScreenshotResult } from './handlers-capture.js';
 /** @typedef {import('../../agent-client/src/client.js').BridgeClient} BridgeClient */
 /** @typedef {import('./handlers-utils.js').ToolResult} ToolResult */
 
-export const MAX_BATCH_CALLS = 20;
-export const MAX_BATCH_CONCURRENCY = 5;
-
-/** @type {ReadonlySet<BridgeMethod>} */
-const BATCH_SAFE_METHODS = new Set([
-  'health.ping',
-  'daemon.metrics',
-  'tabs.list',
-  'skill.get_runtime_context',
-  'setup.get_status',
-  'log.tail',
-  'page.get_state',
-  'page.get_console',
-  'page.wait_for_load_state',
-  'page.get_storage',
-  'page.get_text',
-  'page.extract_content',
-  'page.get_network',
-  'dom.query',
-  'dom.describe',
-  'dom.get_text',
-  'dom.get_attributes',
-  'dom.wait_for',
-  'dom.find_by_text',
-  'dom.find_by_role',
-  'dom.get_html',
-  'dom.get_accessibility_tree',
-  'layout.get_box_model',
-  'layout.hit_test',
-  'styles.get_computed',
-  'styles.get_matched_rules',
-  'network.intercept.list',
-  'patch.list',
-  'performance.get_metrics',
-]);
-
-/**
- * @param {BridgeMethod} method
- * @param {Record<string, unknown>} params
- * @returns {boolean}
- */
-export function isBatchSafeBridgeCall(method, params) {
-  if (!BATCH_SAFE_METHODS.has(method)) return false;
-  if ((method === 'page.get_console' || method === 'page.get_network') && params.clear === true) {
-    return false;
-  }
-  if (
-    method === 'page.get_network' &&
-    params.source === 'cdp' &&
-    params.capture !== undefined &&
-    params.capture !== 'read'
-  ) {
-    return false;
-  }
-  return true;
-}
-
 /** @type {Record<string, { method: BridgeMethod, params: (a: Record<string, unknown>) => Record<string, unknown> }>} */
 export const PAGE_ACTIONS = {
   state: { method: 'page.get_state', params: () => ({}) },
@@ -152,11 +99,19 @@ export const PAGE_ACTIONS = {
       capture: a.capture,
     }),
   },
+  har: {
+    method: 'network.export_har',
+    params: (a) => ({
+      limit: a.limit,
+      urlPattern: a.urlPattern,
+      delivery: a.delivery,
+    }),
+  },
   performance: { method: 'performance.get_metrics', params: () => ({}) },
 };
 
 /**
- * @param {{ action: string, expression?: string, awaitPromise?: boolean, timeoutMs?: number, returnByValue?: boolean, level?: string, clear?: boolean, limit?: number, type?: string, keys?: string[], textBudget?: number, format?: 'text' | 'markdown', selector?: string, includeMetadata?: boolean, consistency?: 'best_effort' | 'settled', settleTimeoutMs?: number, urlPattern?: string, source?: 'fetch-xhr' | 'cdp', capture?: 'read' | 'start' | 'clear' | 'stop', dialogAction?: string, promptText?: string, expectedDialogId?: string, waitForLoad?: boolean, url?: string, urlMatch?: string, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * @param {{ action: string, expression?: string, awaitPromise?: boolean, timeoutMs?: number, returnByValue?: boolean, level?: string, clear?: boolean, limit?: number, type?: string, keys?: string[], textBudget?: number, format?: 'text' | 'markdown', selector?: string, includeMetadata?: boolean, consistency?: 'best_effort' | 'settled', settleTimeoutMs?: number, urlPattern?: string, source?: 'fetch-xhr' | 'cdp', capture?: 'read' | 'start' | 'clear' | 'stop', delivery?: 'auto' | 'inline' | 'artifact', dialogAction?: string, promptText?: string, expectedDialogId?: string, waitForLoad?: boolean, url?: string, urlMatch?: string, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handlePageTool(args) {
@@ -175,6 +130,12 @@ export async function handlePageTool(args) {
       normal: DEFAULT_NETWORK_LIMIT,
       deep: 100,
     });
+  } else if (args.action === 'har') {
+    normalizedArgs = applyLimitBudgetPreset(args, {
+      quick: 20,
+      normal: DEFAULT_HAR_LIMIT,
+      deep: 100,
+    });
   }
   const entry = PAGE_ACTIONS[normalizedArgs.action];
   if (!entry) return summarizeToolError(`Unsupported page action "${args.action}".`);
@@ -184,13 +145,53 @@ export async function handlePageTool(args) {
   ) {
     return summarizeToolError('expression is required for page evaluate.');
   }
-  return callBridgeTool(entry.method, entry.params(normalizedArgs), {
+  const params = entry.params(normalizedArgs);
+  if (entry.method === 'network.export_har') {
+    return withToolClient(
+      async (client) => {
+        const response = await requestBridgeWithRetry(client, entry.method, params, {
+          tabId: typeof normalizedArgs.tabId === 'number' ? normalizedArgs.tabId : null,
+          source: REQUEST_SOURCE,
+          tokenBudget: getToolTokenBudget(normalizedArgs),
+        });
+        return createHarExportResult(response);
+      },
+      { destinationId: normalizedArgs.destinationId ?? null }
+    );
+  }
+  return callBridgeTool(entry.method, params, {
     tabId: typeof normalizedArgs.tabId === 'number' ? normalizedArgs.tabId : null,
     tokenBudget: getToolTokenBudget(normalizedArgs),
     destinationId: normalizedArgs.destinationId ?? null,
   });
 }
 
+/**
+ * Deliberately read one exact storage value without retries, budgeting, or
+ * value-derived delivery metrics.
+ *
+ * @param {{ source: 'local_storage' | 'session_storage', key: string, tabId?: number, destinationId?: string }} args
+ * @returns {Promise<ToolResult>}
+ */
+export async function handleSensitiveReadTool(args) {
+  return withToolClient(
+    async (client) => {
+      const response = await requestBridgeWithRetry(
+        client,
+        'sensitive.read',
+        { source: args.source, key: args.key },
+        {
+          tabId: typeof args.tabId === 'number' ? args.tabId : null,
+          source: REQUEST_SOURCE,
+          tokenBudget: null,
+        }
+      );
+      return createSensitiveReadResult(response);
+    },
+    { destinationId: args.destinationId ?? null }
+  );
+}
+
 /**
  * @param {{ calls?: Array<{ method?: string, params?: Record<string, unknown>, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }> }} args
  * @returns {Promise<ToolResult>}
@@ -361,17 +362,136 @@ export async function handleRawCallTool(args) {
       const response = await requestBridgeWithRetry(client, method, params, {
         tabId: typeof args.tabId === 'number' ? args.tabId : null,
         source: REQUEST_SOURCE,
-        tokenBudget: method.startsWith('screenshot.') ? null : getToolTokenBudget(args),
+        tokenBudget:
+          method.startsWith('screenshot.') || method === 'sensitive.read'
+            ? null
+            : getToolTokenBudget(args),
       });
       if (response.ok && method.startsWith('screenshot.')) {
         return createScreenshotResult(response, method);
       }
+      if (method === 'network.export_har') {
+        return createHarExportResult(response);
+      }
+      if (method === 'sensitive.read') {
+        return createSensitiveReadResult(response);
+      }
       return summarizeToolResponse(response, method, params);
     },
     { destinationId: args.destinationId ?? null }
   );
 }
 
+/**
+ * Preserve the atomic HAR payload exactly. Generic evidence bounding must not
+ * turn a valid HAR document into a structurally invalid partial document.
+ *
+ * @param {import('../../protocol/src/types.js').BridgeResponse} response
+ * @returns {ToolResult}
+ */
+export function createHarExportResult(response) {
+  if (!response.ok) return summarizeToolResponse(response, 'network.export_har', {});
+  const result =
+    response.result && typeof response.result === 'object' && !Array.isArray(response.result)
+      ? /** @type {Record<string, unknown>} */ (response.result)
+      : {};
+  const numericFields = [
+    'byteLength',
+    'entryCount',
+    'totalEntries',
+    'dropped',
+    'abandoned',
+    'inflight',
+  ];
+  const captureState = result.captureState;
+  const validMetadata =
+    result.format === 'har' &&
+    result.harVersion === '1.2' &&
+    result.mimeType === 'application/json' &&
+    numericFields.every((field) => typeof result[field] === 'number') &&
+    (typeof result.startedAt === 'number' || result.startedAt === null) &&
+    (captureState === 'armed' ||
+      captureState === 'stop_failed' ||
+      captureState === 'stopped' ||
+      captureState === 'instrumented') &&
+    typeof result.truncated === 'boolean' &&
+    result.truncation !== null &&
+    typeof result.truncation === 'object';
+  if (!validMetadata) {
+    return summarizeToolError('network.export_har returned invalid HAR metadata.');
+  }
+
+  if (result.delivery === 'inline') {
+    const har =
+      result.har && typeof result.har === 'object' && !Array.isArray(result.har)
+        ? /** @type {Record<string, unknown>} */ (result.har)
+        : {};
+    const log =
+      har.log && typeof har.log === 'object' && !Array.isArray(har.log)
+        ? /** @type {Record<string, unknown>} */ (har.log)
+        : {};
+    if (log.version !== '1.2' || !Array.isArray(log.entries)) {
+      return summarizeToolError('network.export_har returned an invalid inline HAR document.');
+    }
+  } else if (result.delivery === 'artifact') {
+    const artifact =
+      result.artifact && typeof result.artifact === 'object' && !Array.isArray(result.artifact)
+        ? /** @type {Record<string, unknown>} */ (result.artifact)
+        : {};
+    if (
+      artifact.kind !== 'har' ||
+      artifact.mimeType !== 'application/json' ||
+      typeof artifact.artifactId !== 'string' ||
+      typeof artifact.byteLength !== 'number' ||
+      typeof artifact.sha256 !== 'string' ||
+      !/^[a-f0-9]{64}$/u.test(artifact.sha256) ||
+      typeof artifact.chunkSize !== 'number' ||
+      typeof artifact.chunkCount !== 'number' ||
+      typeof artifact.createdAt !== 'string' ||
+      typeof artifact.expiresAt !== 'string'
+    ) {
+      return summarizeToolError('network.export_har returned invalid artifact metadata.');
+    }
+  } else {
+    return summarizeToolError('network.export_har returned an invalid delivery mode.');
+  }
+
+  const summary = summarizeBridgeResponse(response, 'network.export_har');
+  return createToolResult(summary.summary, result);
+}
+
+/**
+ * @param {import('../../protocol/src/types.js').BridgeResponse} response
+ * @returns {ToolResult}
+ */
+function createSensitiveReadResult(response) {
+  if (!response.ok) return summarizeToolResponse(response, 'sensitive.read', {});
+  const result =
+    response.result && typeof response.result === 'object'
+      ? /** @type {Record<string, unknown>} */ (response.result)
+      : {};
+  if (
+    (result.source !== 'local_storage' && result.source !== 'session_storage') ||
+    typeof result.value !== 'string' ||
+    result.exact !== true
+  ) {
+    return summarizeToolError('sensitive.read returned an invalid exact-value response.');
+  }
+  return {
+    content: [
+      {
+        type: 'text',
+        text: 'Sensitive storage read succeeded. The exact value is available in structuredContent.value.',
+      },
+    ],
+    structuredContent: {
+      source: result.source,
+      value: result.value,
+      exact: true,
+    },
+  };
+}
+
 /**
  * @typedef {{ method: BridgeMethod, params: (args: Record<string, unknown>) => Record<string, unknown> }} InvestigateStep
  */

package/packages/mcp-server/src/handlers-utils.js

@@ -1,9 +1,12 @@
 // @ts-check
 
+import { randomUUID } from 'node:crypto';
+
 import {
   BridgeError,
   bridgeMethodNeedsTab,
   DEFAULT_CONSOLE_LIMIT,
+  DEFAULT_HAR_LIMIT,
   DEFAULT_LOG_TAIL_LIMIT,
   DEFAULT_MAX_HTML_LENGTH,
   DEFAULT_MAX_NODES,
@@ -33,6 +36,7 @@ import { annotateBridgeSummary, summarizeBridgeResponse } from '../../agent-clie
 /** @typedef {import('../../protocol/src/types.js').BridgeResponse} BridgeResponse */
 
 export const REQUEST_SOURCE = 'mcp';
+const MCP_CLIENT_ID = `mcp_${randomUUID()}`;
 
 /** @type {ReadonlySet<BridgeMethod>} */
 const RETRY_SAFE_METHODS = new Set([
@@ -47,6 +51,8 @@ const RETRY_SAFE_METHODS = new Set([
   'page.get_text',
   'page.extract_content',
   'dom.query',
+  'dom.baseline.compare',
+  'dom.baseline.describe',
   'dom.describe',
   'dom.get_text',
   'dom.get_attributes',
@@ -198,10 +204,14 @@ export function summarizeToolError(error) {
 export async function withToolClient(callback, options = {}) {
   try {
     if (!options.destinationId) {
-      return await withBridgeClient(callback, { checkProtocolOnConnect: false });
+      return await withBridgeClient(callback, {
+        checkProtocolOnConnect: false,
+        clientId: MCP_CLIENT_ID,
+      });
     }
     const client = await createBridgeClientForDestination(options.destinationId, {
       checkProtocolOnConnect: false,
+      clientId: MCP_CLIENT_ID,
     });
     await client.connect();
     try {
@@ -367,9 +377,21 @@ export function applyHtmlBudgetPreset(args) {
  */
 export function applyMethodBudgetPreset(method, params, budgetPreset) {
   const args = { ...params, budgetPreset };
+  /** @type {Record<string, unknown>} */
   let normalized = args;
-  if (method === 'dom.query' || method === 'dom.get_accessibility_tree') {
+  if (
+    method === 'dom.query' ||
+    method === 'dom.get_accessibility_tree' ||
+    method === 'dom.baseline.create'
+  ) {
     normalized = applyTreeBudgetPreset(args);
+  } else if (method === 'dom.baseline.compare') {
+    const preset = getBudgetPresetName(budgetPreset);
+    const defaults = { quick: 10, normal: 50, deep: 100 };
+    normalized = {
+      ...args,
+      maxChanges: params.maxChanges ?? (preset ? defaults[preset] : undefined),
+    };
   } else if (method === 'dom.get_text') {
     normalized = applyTextBudgetPreset(args);
   } else if (method === 'dom.get_html') {
@@ -388,6 +410,12 @@ export function applyMethodBudgetPreset(method, params, budgetPreset) {
       normal: DEFAULT_NETWORK_LIMIT,
       deep: 100,
     });
+  } else if (method === 'network.export_har') {
+    normalized = applyLimitBudgetPreset(args, {
+      quick: 20,
+      normal: DEFAULT_HAR_LIMIT,
+      deep: 100,
+    });
   } else if (method === 'log.tail') {
     normalized = applyLimitBudgetPreset(args, {
       quick: 10,
@@ -637,7 +665,7 @@ function compactDomNode(value) {
  * @param {import('../../agent-client/src/client.js').BridgeClient} client
  * @param {BridgeMethod} method
  * @param {Record<string, unknown>} params
- * @param {{ tabId?: number | null, source?: import('../../protocol/src/types.js').BridgeRequestSource, tokenBudget?: number | null }} options
+ * @param {{ tabId?: number | null, source?: import('../../protocol/src/types.js').BridgeRequestSource, tokenBudget?: number | null, automaticRetry?: 'mcp_second_attempt' }} options
  * @returns {Promise<BridgeResponse>}
  */
 export async function requestBridgeWithRetry(client, method, params, options) {
@@ -652,7 +680,10 @@ export async function requestBridgeWithRetry(client, method, params, options) {
       `[bbx-mcp] Retrying ${method} after ${delay}ms (${response.error.code})\n`
     );
     await new Promise((r) => setTimeout(r, delay));
-    return requestBridge(client, method, params, options);
+    return requestBridge(client, method, params, {
+      ...options,
+      automaticRetry: 'mcp_second_attempt',
+    });
   }
   return response;
 }

package/packages/mcp-server/src/handlers.js

@@ -54,15 +54,17 @@ export {
 } from './handlers-capture.js';
 
 export {
-  MAX_BATCH_CALLS,
-  MAX_BATCH_CONCURRENCY,
   PAGE_ACTIONS,
   handlePageTool,
+  handleSensitiveReadTool,
   handleBatchTool,
   handleRawCallTool,
+  createHarExportResult,
   handleInvestigateTool,
 } from './handlers-page.js';
 
+export { MAX_BATCH_CALLS, MAX_BATCH_CONCURRENCY } from '../../protocol/src/index.js';
+
 /** @typedef {import('./handlers-utils.js').ToolAction} ToolAction */
 /** @typedef {import('./handlers-utils.js').ToolResult} ToolResult */
 
@@ -97,8 +99,13 @@ export async function handleStatusTool(args = {}) {
     }
 
     const report = await getDoctorReport();
+    const configuredDestinations = await getBridgeDestinations();
+    const destinationsToInspect =
+      requestedDestinationId === 'local'
+        ? configuredDestinations.filter((destination) => destination.local)
+        : configuredDestinations;
     const destinations = await Promise.all(
-      (await getBridgeDestinations()).map(async (destination) => {
+      destinationsToInspect.map(async (destination) => {
         if (destination.local) {
           return {
             ...destination,