@browserbridge/bbx 1.7.8 → 1.9.0

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,54 +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.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;
-  }
-  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: () => ({}) },
@@ -97,9 +53,22 @@ export const PAGE_ACTIONS = {
     method: 'page.get_console',
     params: (a) => ({ level: a.level, clear: a.clear, limit: a.limit }),
   },
+  handle_dialog: {
+    method: 'page.handle_dialog',
+    params: (a) => ({
+      action: a.dialogAction,
+      promptText: a.promptText,
+      expectedDialogId: a.expectedDialogId,
+    }),
+  },
   wait_for_load: {
     method: 'page.wait_for_load_state',
-    params: (a) => ({ timeoutMs: a.timeoutMs }),
+    params: (a) => ({
+      timeoutMs: a.timeoutMs,
+      waitForLoad: a.waitForLoad,
+      url: a.url,
+      urlMatch: a.urlMatch,
+    }),
   },
   storage: {
     method: 'page.get_storage',
@@ -109,24 +78,45 @@ export const PAGE_ACTIONS = {
     method: 'page.get_text',
     params: (a) => ({ textBudget: a.textBudget }),
   },
+  extract_content: {
+    method: 'page.extract_content',
+    params: (a) => ({
+      format: a.format,
+      selector: a.selector,
+      includeMetadata: a.includeMetadata,
+      consistency: a.consistency,
+      textBudget: a.textBudget,
+      settleTimeoutMs: a.settleTimeoutMs,
+    }),
+  },
   network: {
     method: 'page.get_network',
     params: (a) => ({
       clear: a.clear,
       limit: a.limit,
       urlPattern: a.urlPattern,
+      source: a.source,
+      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, urlPattern?: 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) {
   let normalizedArgs = args;
-  if (args.action === 'text') {
+  if (args.action === 'text' || args.action === 'extract_content') {
     normalizedArgs = applyPageTextBudgetPreset(args);
   } else if (args.action === 'console') {
     normalizedArgs = applyLimitBudgetPreset(args, {
@@ -140,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}".`);
@@ -149,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>}
@@ -201,7 +237,9 @@ export async function handleBatchTool(args) {
     /** @type {unknown} */
     let callError = null;
     try {
-      callClient = await createBridgeClientForDestination(destinationId);
+      callClient = await createBridgeClientForDestination(destinationId, {
+        checkProtocolOnConnect: false,
+      });
       await callClient.connect();
       const params = applyMethodBudgetPreset(method, call.params || {}, call.budgetPreset);
       response = await requestBridgeWithRetry(callClient, method, params, {
@@ -324,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([
@@ -45,7 +49,10 @@ const RETRY_SAFE_METHODS = new Set([
   'page.get_state',
   'page.get_storage',
   'page.get_text',
+  'page.extract_content',
   'dom.query',
+  'dom.baseline.compare',
+  'dom.baseline.describe',
   'dom.describe',
   'dom.get_text',
   'dom.get_attributes',
@@ -75,7 +82,13 @@ const RETRY_SAFE_METHODS = new Set([
  */
 export function isRetrySafeBridgeMethod(method, params) {
   if (method === 'page.get_console' || method === 'page.get_network') {
-    return params.clear !== true;
+    return (
+      params.clear !== true &&
+      (method !== 'page.get_network' ||
+        params.source !== 'cdp' ||
+        params.capture === undefined ||
+        params.capture === 'read')
+    );
   }
   return RETRY_SAFE_METHODS.has(method);
 }
@@ -136,6 +149,7 @@ export function summarizeToolResponse(response, method, params = {}) {
   if (response.ok) {
     const evidence = getRequestAwareEvidence(response.result, method, params, summary.evidence);
     summary.evidence = evidence.value;
+    if (evidence.metadata) summaryRecord.evidenceMeta = evidence.metadata;
     if (evidence.truncated) {
       summaryRecord.outputTruncated = true;
       summaryRecord.outputLimit = evidence.limit;
@@ -190,9 +204,15 @@ export function summarizeToolError(error) {
 export async function withToolClient(callback, options = {}) {
   try {
     if (!options.destinationId) {
-      return await withBridgeClient(callback);
+      return await withBridgeClient(callback, {
+        checkProtocolOnConnect: false,
+        clientId: MCP_CLIENT_ID,
+      });
     }
-    const client = await createBridgeClientForDestination(options.destinationId);
+    const client = await createBridgeClientForDestination(options.destinationId, {
+      checkProtocolOnConnect: false,
+      clientId: MCP_CLIENT_ID,
+    });
     await client.connect();
     try {
       return await callback(client);
@@ -357,14 +377,26 @@ 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') {
     normalized = applyHtmlBudgetPreset(args);
-  } else if (method === 'page.get_text') {
+  } else if (method === 'page.get_text' || method === 'page.extract_content') {
     normalized = applyPageTextBudgetPreset(args);
   } else if (method === 'page.get_console') {
     normalized = applyLimitBudgetPreset(args, {
@@ -378,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,
@@ -392,7 +430,7 @@ export function applyMethodBudgetPreset(method, params, budgetPreset) {
 /**
  * @param {unknown} input
  * @param {{ maxEntries?: number, maxCharacters?: number, maxStringLength?: number }} [options]
- * @returns {{ value: unknown, truncated: boolean, limit: Record<string, number> }}
+ * @returns {{ value: unknown, truncated: boolean, limit: Record<string, number>, metadata?: Record<string, unknown> }}
  */
 export function boundToolValue(input, options = {}) {
   const maxEntries = options.maxEntries ?? 500;
@@ -451,13 +489,27 @@ export function boundToolValue(input, options = {}) {
  * @param {string | undefined} method
  * @param {Record<string, unknown>} params
  * @param {unknown} fallback
- * @returns {{ value: unknown, truncated: boolean, limit: Record<string, number> }}
+ * @returns {{ value: unknown, truncated: boolean, limit: Record<string, number>, metadata?: Record<string, unknown> }}
  */
 function getRequestAwareEvidence(rawResult, method, params, fallback) {
   const result =
     rawResult && typeof rawResult === 'object' && !Array.isArray(rawResult)
       ? /** @type {Record<string, unknown>} */ (rawResult)
       : {};
+  if (method === 'page.extract_content' && typeof result.content === 'string') {
+    const requested = positiveInteger(params.textBudget) ?? DEFAULT_PAGE_TEXT_BUDGET;
+    const maxCharacters = Math.min(requested, 16_000);
+    const content = result.content.slice(0, maxCharacters);
+    return {
+      value: {
+        ...result,
+        content,
+        returnedChars: content.length,
+      },
+      truncated: result.content.length > maxCharacters,
+      limit: { maxCharacters },
+    };
+  }
   if (method === 'page.get_text' || method === 'dom.get_text') {
     const text = typeof result.text === 'string' ? result.text : result.value;
     if (typeof text === 'string') {
@@ -506,14 +558,30 @@ function getRequestAwareEvidence(rawResult, method, params, fallback) {
       const node =
         value && typeof value === 'object' ? /** @type {Record<string, unknown>} */ (value) : {};
       return {
+        nodeId: node.nodeId,
         role: node.role,
         name: node.name,
         ...(node.interactive === true ? { interactive: true } : {}),
+        ...(node.semanticInteractive === true ? { semanticInteractive: true } : {}),
+        ...(node.focusableAndEnabled === true ? { focusableAndEnabled: true } : {}),
         ...(node.value !== undefined ? { value: node.value } : {}),
+        childIds: Array.isArray(node.childIds) ? node.childIds : [],
       };
     });
     return {
       value: nodes,
+      metadata: {
+        rootIds: Array.isArray(result.rootIds) ? result.rootIds : [],
+        count: result.count,
+        total: result.total,
+        rawTotal: result.rawTotal,
+        source: result.source,
+        compact: result.compact,
+        interactiveOnly: result.interactiveOnly,
+        truncated: result.truncated,
+        truncation: result.truncation,
+        continuationHint: result.continuationHint,
+      },
       truncated: result.truncated === true || result.nodes.length > maxEntries,
       limit: { maxEntries },
     };
@@ -535,7 +603,27 @@ function getRequestAwareEvidence(rawResult, method, params, fallback) {
         : result.entries.slice(0, maxEntries);
     const bounded = boundToolValue(selected, { maxEntries: 500, maxCharacters: 20_000 });
     return {
-      value: bounded.value,
+      value:
+        method === 'page.get_network'
+          ? {
+              entries: bounded.value,
+              count: result.count,
+              total: result.total,
+              filteredTotal: result.filteredTotal,
+              dropped: result.dropped,
+              abandoned: result.abandoned,
+              source: result.source,
+              capture: result.capture,
+              armed: result.armed,
+              armedDuringCapture: result.armedDuringCapture,
+              captureState: result.captureState,
+              startedAt: result.startedAt,
+              inflight: result.inflight,
+              ownershipHeld: result.ownershipHeld,
+              truncated: result.truncated,
+              truncation: result.truncation,
+            }
+          : bounded.value,
       truncated: result.entries.length > maxEntries || bounded.truncated,
       limit: { maxEntries, maxCharacters: 20_000 },
     };
@@ -577,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) {
@@ -592,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,22 +54,24 @@ 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 */
 
 const HOME_DIR = os.homedir();
 
 /**
- * @param {{ destinationId?: string }} [args]
+ * @param {{ destinationId?: string, intent?: import('../../protocol/src/types.js').AccessIntent }} [args]
  * @returns {Promise<ToolResult>}
  */
 export async function handleStatusTool(args = {}) {
@@ -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,
@@ -155,7 +162,7 @@ async function callRemoteHealth(destinationId) {
 }
 
 /**
- * @param {{ destinationId?: string }} [args]
+ * @param {{ destinationId?: string, intent?: import('../../protocol/src/types.js').AccessIntent }} [args]
  * @returns {Promise<ToolResult>}
  */
 export async function handleSkillTool(args = {}) {
@@ -231,13 +238,13 @@ export async function handleHealthTool(args = {}) {
 }
 
 /**
- * @param {{ destinationId?: string }} [args]
+ * @param {{ destinationId?: string, intent?: import('../../protocol/src/types.js').AccessIntent }} [args]
  * @returns {Promise<ToolResult>}
  */
 export async function handleAccessTool(args = {}) {
   return callBridgeTool(
     'access.request',
-    {},
+    { intent: args.intent },
     {
       destinationId: typeof args.destinationId === 'string' ? args.destinationId : null,
     }