@browserbridge/bbx 1.8.0 → 1.10.0

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

@@ -1,5 +1,7 @@
 // @ts-check
 
+import { randomUUID } from 'node:crypto';
+
 import {
   BridgeError,
   bridgeMethodNeedsTab,
@@ -12,11 +14,21 @@ import {
   DEFAULT_TEXT_BUDGET,
   estimateJsonPayloadCost,
   getBudgetPreset,
+  getBudgetPresetName,
   getErrorRecovery,
-  isBudgetPresetName,
   summarizeBatchErrorItem,
   summarizeBatchResponseItem,
 } from '../../protocol/src/index.js';
+
+export {
+  applyHtmlBudgetPreset,
+  applyLimitBudgetPreset,
+  applyMethodBudgetPreset,
+  applyPageTextBudgetPreset,
+  applyTextBudgetPreset,
+  applyTreeBudgetPreset,
+  getBudgetPresetName,
+} from '../../protocol/src/index.js';
 import {
   getDoctorReport,
   requestBridge,
@@ -33,6 +45,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 +60,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',
@@ -62,6 +77,8 @@ const RETRY_SAFE_METHODS = new Set([
   'screenshot.capture_region',
   'screenshot.capture_element',
   'screenshot.capture_full_page',
+  'artifact.read',
+  'network.intercept.list',
   'performance.get_metrics',
   'cdp.get_document',
   'cdp.get_dom_snapshot',
@@ -198,10 +215,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 {
@@ -230,14 +251,6 @@ export async function resolveToolRef(client, input, tabId = null) {
   throw new BridgeError('INVALID_REQUEST', 'Provide either elementRef or selector.');
 }
 
-/**
- * @param {unknown} value
- * @returns {'quick' | 'normal' | 'deep' | null}
- */
-export function getBudgetPresetName(value) {
-  return isBudgetPresetName(value) ? value : null;
-}
-
 /**
  * @param {{ budgetPreset?: unknown, selector?: unknown, elementRef?: unknown }} args
  * @returns {'quick' | 'normal' | 'deep' | null}
@@ -261,144 +274,6 @@ export function getToolTokenBudget(args) {
   return presetName ? getBudgetPreset(presetName).tokenBudget : null;
 }
 
-/**
- * @template {{ budgetPreset?: unknown, maxNodes?: unknown, maxDepth?: unknown, textBudget?: unknown }} T
- * @param {T} args
- * @returns {T}
- */
-export function applyTreeBudgetPreset(args) {
-  const presetName = getBudgetPresetName(args.budgetPreset);
-  if (!presetName) {
-    return args;
-  }
-  const preset = getBudgetPreset(presetName);
-  return /** @type {T} */ ({
-    ...args,
-    maxNodes: args.maxNodes ?? preset.maxNodes,
-    maxDepth: args.maxDepth ?? preset.maxDepth,
-    textBudget: args.textBudget ?? preset.textBudget,
-  });
-}
-
-/**
- * @template {{ budgetPreset?: unknown, textBudget?: unknown }} T
- * @param {T} args
- * @returns {T}
- */
-export function applyTextBudgetPreset(args) {
-  const presetName = getBudgetPresetName(args.budgetPreset);
-  if (!presetName) {
-    return args;
-  }
-  const preset = getBudgetPreset(presetName);
-  return /** @type {T} */ ({
-    ...args,
-    textBudget: args.textBudget ?? preset.textBudget,
-  });
-}
-
-/**
- * @template {{ budgetPreset?: unknown, textBudget?: unknown }} T
- * @param {T} args
- * @returns {T}
- */
-export function applyPageTextBudgetPreset(args) {
-  const presetName = getBudgetPresetName(args.budgetPreset);
-  if (!presetName) {
-    return args;
-  }
-  const textBudgetByPreset = {
-    quick: 2000,
-    normal: DEFAULT_PAGE_TEXT_BUDGET,
-    deep: DEFAULT_PAGE_TEXT_BUDGET * 2,
-  };
-  return /** @type {T} */ ({
-    ...args,
-    textBudget: args.textBudget ?? textBudgetByPreset[presetName],
-  });
-}
-
-/**
- * @template {{ budgetPreset?: unknown, limit?: unknown }} T
- * @param {T} args
- * @param {{ quick: number, normal: number, deep: number }} defaults
- * @returns {T}
- */
-export function applyLimitBudgetPreset(args, defaults) {
-  const presetName = getBudgetPresetName(args.budgetPreset);
-  if (!presetName) {
-    return args;
-  }
-  return /** @type {T} */ ({
-    ...args,
-    limit: args.limit ?? defaults[presetName],
-  });
-}
-
-/**
- * @template {{ budgetPreset?: unknown, maxLength?: unknown }} T
- * @param {T} args
- * @returns {T}
- */
-export function applyHtmlBudgetPreset(args) {
-  const presetName = getBudgetPresetName(args.budgetPreset);
-  if (!presetName) {
-    return args;
-  }
-  const maxLengthByPreset = {
-    quick: 600,
-    normal: DEFAULT_MAX_HTML_LENGTH,
-    deep: 6000,
-  };
-  return /** @type {T} */ ({
-    ...args,
-    maxLength: args.maxLength ?? maxLengthByPreset[presetName],
-  });
-}
-
-/**
- * Apply a preset to method parameters before dispatch. Explicit method params
- * always win over preset defaults.
- *
- * @param {BridgeMethod} method
- * @param {Record<string, unknown>} params
- * @param {unknown} budgetPreset
- * @returns {Record<string, unknown>}
- */
-export function applyMethodBudgetPreset(method, params, budgetPreset) {
-  const args = { ...params, budgetPreset };
-  let normalized = args;
-  if (method === 'dom.query' || method === 'dom.get_accessibility_tree') {
-    normalized = applyTreeBudgetPreset(args);
-  } else if (method === 'dom.get_text') {
-    normalized = applyTextBudgetPreset(args);
-  } else if (method === 'dom.get_html') {
-    normalized = applyHtmlBudgetPreset(args);
-  } else if (method === 'page.get_text' || method === 'page.extract_content') {
-    normalized = applyPageTextBudgetPreset(args);
-  } else if (method === 'page.get_console') {
-    normalized = applyLimitBudgetPreset(args, {
-      quick: 10,
-      normal: DEFAULT_CONSOLE_LIMIT,
-      deep: 100,
-    });
-  } else if (method === 'page.get_network') {
-    normalized = applyLimitBudgetPreset(args, {
-      quick: 10,
-      normal: DEFAULT_NETWORK_LIMIT,
-      deep: 100,
-    });
-  } else if (method === 'log.tail') {
-    normalized = applyLimitBudgetPreset(args, {
-      quick: 10,
-      normal: DEFAULT_LOG_TAIL_LIMIT,
-      deep: 100,
-    });
-  }
-  const { budgetPreset: _budgetPreset, ...methodParams } = normalized;
-  return methodParams;
-}
-
 /**
  * @param {unknown} input
  * @param {{ maxEntries?: number, maxCharacters?: number, maxStringLength?: number }} [options]
@@ -558,6 +433,14 @@ function getRequestAwareEvidence(rawResult, method, params, fallback) {
       limit: { maxEntries },
     };
   }
+  if (method?.startsWith('network.intercept.')) {
+    const bounded = boundToolValue(result, { maxEntries: 100, maxCharacters: 10_000 });
+    return {
+      value: bounded.value,
+      truncated: bounded.truncated,
+      limit: { maxEntries: 100, maxCharacters: 10_000 },
+    };
+  }
   if (
     (method === 'page.get_console' || method === 'page.get_network' || method === 'log.tail') &&
     Array.isArray(result.entries)
@@ -633,15 +516,119 @@ function compactDomNode(value) {
   return compact;
 }
 
+/**
+ * Socket-level Node error codes that mean the daemon connection itself was
+ * lost, as opposed to an application-level bridge failure.
+ *
+ * @type {ReadonlySet<string>}
+ */
+const CONNECTION_LOSS_CODES = new Set([
+  'ENOTCONN',
+  'ECONNREFUSED',
+  'ECONNRESET',
+  'EPIPE',
+  'ERR_SOCKET_CLOSED',
+]);
+
+const RECONNECT_WAIT_TIMEOUT_MS = 5_000;
+const RECONNECT_POLL_INTERVAL_MS = 250;
+
+/**
+ * Detect thrown transport errors caused by a lost daemon connection. These
+ * never arrive as bridge failure responses because the socket died before (or
+ * while) the daemon could reply.
+ *
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+export function isConnectionLossError(error) {
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+  const code = /** @type {{ code?: unknown }} */ (error).code;
+  if (typeof code === 'string' && CONNECTION_LOSS_CODES.has(code)) {
+    return true;
+  }
+  const message = error instanceof Error ? error.message : '';
+  return /Bridge socket closed|BridgeClient is not connected/u.test(message);
+}
+
+/**
+ * Wait, bounded, for the client to regain its daemon connection.
+ *
+ * When the client's own auto-reconnect loop is active it owns reconnecting and
+ * emits `reconnected`; otherwise one manual connect is attempted per poll
+ * interval. Application state is never touched here - this only restores the
+ * transport.
+ *
+ * @param {import('../../agent-client/src/client.js').BridgeClient} client
+ * @param {number} [timeoutMs=RECONNECT_WAIT_TIMEOUT_MS]
+ * @returns {Promise<boolean>}
+ */
+export async function waitForClientReconnect(client, timeoutMs = RECONNECT_WAIT_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (!client.connected && Date.now() < deadline) {
+    if (client.autoReconnect) {
+      await new Promise((resolve) => {
+        const remaining = Math.max(0, deadline - Date.now());
+        /** @type {ReturnType<typeof setTimeout>} */
+        let timer;
+        const cleanup = () => {
+          clearTimeout(timer);
+          client.off('reconnected', onReconnected);
+          resolve(undefined);
+        };
+        const onReconnected = () => cleanup();
+        timer = setTimeout(cleanup, Math.min(RECONNECT_POLL_INTERVAL_MS, remaining));
+        client.on('reconnected', onReconnected);
+      });
+      continue;
+    }
+    try {
+      await client.connect();
+    } catch (error) {
+      if (error instanceof Error && /already connected/u.test(error.message)) {
+        break;
+      }
+      // Daemon still unreachable; keep waiting inside the bounded window.
+    }
+    if (!client.connected) {
+      const remaining = Math.max(0, deadline - Date.now());
+      await new Promise((resolve) =>
+        setTimeout(resolve, Math.min(RECONNECT_POLL_INTERVAL_MS, remaining))
+      );
+    }
+  }
+  return client.connected;
+}
+
 /**
  * @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) {
-  const response = await requestBridge(client, method, params, options);
+  /** @type {BridgeResponse} */
+  let response;
+  try {
+    response = await requestBridge(client, method, params, options);
+  } catch (error) {
+    if (!isConnectionLossError(error) || !isRetrySafeBridgeMethod(method, params)) {
+      throw error;
+    }
+    process.stderr.write(
+      `[bbx-mcp] ${method} lost its daemon connection; waiting up to ${RECONNECT_WAIT_TIMEOUT_MS}ms for reconnect before one retry.\n`
+    );
+    if (!(await waitForClientReconnect(client))) {
+      throw error;
+    }
+    return requestBridge(client, method, params, {
+      ...options,
+      automaticRetry: 'mcp_second_attempt',
+    });
+  }
   const recovery =
     !response.ok && response.error
       ? (response.error.recovery ?? getErrorRecovery(response.error.code))
@@ -652,7 +639,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

@@ -1,6 +1,7 @@
 // @ts-check
 
 import os from 'node:os';
+
 import { DEFAULT_LOG_TAIL_LIMIT, createRuntimeContext } from '../../protocol/src/index.js';
 import { collectSetupStatus } from '../../agent-client/src/setup-status.js';
 import {
@@ -54,15 +55,19 @@ export {
 } from './handlers-capture.js';
 
 export {
-  MAX_BATCH_CALLS,
-  MAX_BATCH_CONCURRENCY,
   PAGE_ACTIONS,
   handlePageTool,
+  handleArtifactTool,
+  handleInterceptTool,
+  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 +102,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,
@@ -187,7 +197,10 @@ export async function handleSetupTool(args) {
   const configuredMcp = status.mcpClients.filter((e) => e.configured).length;
   const installedSkills = status.skillTargets.filter((e) => e.installed).length;
   const summary = `Optional agent integration status: ${configuredMcp}/${status.mcpClients.length} MCP clients configured, ${installedSkills}/${status.skillTargets.length} skills installed.`;
-  return createToolResult(summary, { ok: true, status });
+  return createToolResult(summary, {
+    ok: true,
+    status,
+  });
 }
 
 /**