@browserbridge/bbx 1.7.2 → 1.7.3

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

@@ -24,8 +24,12 @@ import {
 } from './handlers-utils.js';
 
 /** @typedef {import('../../protocol/src/types.js').BridgeMethod} BridgeMethod */
+/** @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 {Record<string, { method: BridgeMethod, params: (a: Record<string, unknown>) => Record<string, unknown> }>} */
 export const PAGE_ACTIONS = {
   state: { method: 'page.get_state', params: () => ({}) },
@@ -109,86 +113,111 @@ export async function handleBatchTool(args) {
   if (!Array.isArray(args.calls) || args.calls.length === 0) {
     return summarizeToolError('calls must be a non-empty array.');
   }
+  if (args.calls.length > MAX_BATCH_CALLS) {
+    return summarizeToolError(`calls must contain at most ${MAX_BATCH_CALLS} entries.`);
+  }
 
   const calls = args.calls;
-  return withToolClient(async (client) => {
-    const results = await Promise.all(
-      calls.map(async (call) => {
-        if (!call || typeof call !== 'object' || typeof call.method !== 'string') {
-          return {
-            method: '',
-            tabId: null,
-            ok: false,
-            summary: 'INVALID_REQUEST: Each batch call needs a method.',
-            evidence: null,
-            error: {
-              code: 'INVALID_REQUEST',
-              message: 'Each batch call needs a method.',
-            },
-            response: null,
-          };
-        }
+  /** @param {BridgeClient | null} client */
+  const executeBatch = async (client) => {
+    const results = await mapWithConcurrency(calls, MAX_BATCH_CONCURRENCY, async (call) => {
+      if (!call || typeof call !== 'object' || typeof call.method !== 'string') {
+        return {
+          method: '',
+          tabId: null,
+          ok: false,
+          summary: 'INVALID_REQUEST: Each batch call needs a method.',
+          evidence: null,
+          error: {
+            code: 'INVALID_REQUEST',
+            message: 'Each batch call needs a method.',
+          },
+          response: null,
+        };
+      }
 
-        if (!METHOD_SET.has(/** @type {BridgeMethod} */ (call.method))) {
-          return {
-            method: call.method,
-            tabId: null,
-            ok: false,
-            summary: `INVALID_REQUEST: Unknown bridge method "${call.method}".`,
-            evidence: null,
-            error: {
-              code: 'INVALID_REQUEST',
-              message: `Unknown bridge method "${call.method}".`,
-            },
-            response: null,
-          };
-        }
+      if (!METHOD_SET.has(/** @type {BridgeMethod} */ (call.method))) {
+        return {
+          method: call.method,
+          tabId: null,
+          ok: false,
+          summary: `INVALID_REQUEST: Unknown bridge method "${call.method}".`,
+          evidence: null,
+          error: {
+            code: 'INVALID_REQUEST',
+            message: `Unknown bridge method "${call.method}".`,
+          },
+          response: null,
+        };
+      }
 
-        const method = /** @type {BridgeMethod} */ (call.method);
-        const tabId = bridgeMethodNeedsTab(method)
-          ? typeof call.tabId === 'number'
-            ? call.tabId
-            : null
-          : null;
-        const tokenBudget = getToolTokenBudget(call);
-        const destinationId = typeof call.destinationId === 'string' ? call.destinationId : null;
+      if (call.method === 'setup.install') {
+        return {
+          method: call.method,
+          tabId: null,
+          ok: false,
+          summary: 'INVALID_REQUEST: Use browser_setup for setup changes.',
+          evidence: null,
+          error: {
+            code: 'INVALID_REQUEST',
+            message: 'Use browser_setup for setup changes.',
+          },
+          response: null,
+        };
+      }
 
-        const startTime = Date.now();
-        const callClient = destinationId
-          ? await createBridgeClientForDestination(destinationId)
-          : client;
-        try {
-          if (destinationId) {
-            await callClient.connect();
-          }
-          const response = await requestBridgeWithRetry(callClient, method, call.params || {}, {
-            tabId,
-            source: REQUEST_SOURCE,
-            tokenBudget,
-          });
-          return {
-            destinationId,
-            ...summarizeBatchResponseItem({
-              method,
-              tabId,
-              response,
-              durationMs: Date.now() - startTime,
-            }),
-          };
-        } catch (error) {
-          return summarizeBatchErrorItem({
+      const method = /** @type {BridgeMethod} */ (call.method);
+      const tabId = bridgeMethodNeedsTab(method)
+        ? typeof call.tabId === 'number'
+          ? call.tabId
+          : null
+        : null;
+      const tokenBudget = getToolTokenBudget(call);
+      const destinationId = typeof call.destinationId === 'string' ? call.destinationId : null;
+
+      const startTime = Date.now();
+      const callClient = destinationId
+        ? await createBridgeClientForDestination(destinationId)
+        : client;
+      if (!callClient) {
+        return summarizeBatchErrorItem({
+          method,
+          tabId,
+          error: new Error('A local bridge client is required for calls without destinationId.'),
+          durationMs: Date.now() - startTime,
+        });
+      }
+      try {
+        if (destinationId) {
+          await callClient.connect();
+        }
+        const response = await requestBridgeWithRetry(callClient, method, call.params || {}, {
+          tabId,
+          source: REQUEST_SOURCE,
+          tokenBudget,
+        });
+        return {
+          destinationId,
+          ...summarizeBatchResponseItem({
             method,
             tabId,
-            error,
+            response,
             durationMs: Date.now() - startTime,
-          });
-        } finally {
-          if (destinationId) {
-            await callClient.close();
-          }
+          }),
+        };
+      } catch (error) {
+        return summarizeBatchErrorItem({
+          method,
+          tabId,
+          error,
+          durationMs: Date.now() - startTime,
+        });
+      } finally {
+        if (destinationId) {
+          await callClient.close();
         }
-      })
-    );
+      }
+    });
 
     const failureCount = results.filter((result) => !result.ok).length;
     const summary =
@@ -203,7 +232,35 @@ export async function handleBatchTool(args) {
       },
       failureCount > 0
     );
-  });
+  };
+
+  return calls.every((call) => typeof call?.destinationId === 'string')
+    ? executeBatch(null)
+    : withToolClient(executeBatch);
+}
+
+/**
+ * @template T, R
+ * @param {T[]} values
+ * @param {number} concurrency
+ * @param {(value: T, index: number) => Promise<R>} callback
+ * @returns {Promise<R[]>}
+ */
+async function mapWithConcurrency(values, concurrency, callback) {
+  /** @type {R[]} */
+  const results = new Array(values.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < values.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await callback(values[index], index);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, values.length) }, async () => worker())
+  );
+  return results;
 }
 
 /**
@@ -214,6 +271,9 @@ export async function handleRawCallTool(args) {
   if (!METHOD_SET.has(/** @type {BridgeMethod} */ (args.method))) {
     return summarizeToolError(`Unknown bridge method "${args.method}".`);
   }
+  if (args.method === 'setup.install') {
+    return summarizeToolError('Use browser_setup for setup changes.');
+  }
 
   return withToolClient(
     async (client) => {

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

@@ -76,7 +76,10 @@ export function isRetrySafeBridgeMethod(method, params) {
 
 /**
  * @typedef {{
- *   content: Array<{ type: 'text', text: string }>,
+ *   content: [
+ *     { type: 'text', text: string },
+ *     ...Array<{ type: 'image', data: string, mimeType: string }>
+ *   ],
  *   structuredContent: Record<string, unknown>,
  *   isError?: boolean
  * }} ToolResult
@@ -86,11 +89,20 @@ export function isRetrySafeBridgeMethod(method, params) {
  * @param {string} summary
  * @param {Record<string, unknown>} [structuredContent={}]
  * @param {boolean} [isError=false]
+ * @param {Array<{ type: 'image', data: string, mimeType: string }>} [additionalContent=[]]
  * @returns {ToolResult}
  */
-export function createToolResult(summary, structuredContent = {}, isError = false) {
+export function createToolResult(
+  summary,
+  structuredContent = {},
+  isError = false,
+  additionalContent = []
+) {
   const toolResult = {
-    content: [{ type: /** @type {'text'} */ ('text'), text: summary }],
+    content: /** @type {ToolResult['content']} */ ([
+      { type: 'text', text: summary },
+      ...additionalContent,
+    ]),
     structuredContent,
     ...(isError ? { isError: true } : {}),
   };
@@ -132,67 +144,6 @@ export function summarizeToolError(error) {
   );
 }
 
-/**
- * @param {ToolResult} result
- * @returns {boolean}
- */
-function shouldTryRemoteFallback(result) {
-  if (!result.isError && result.structuredContent.ok !== false) {
-    return false;
-  }
-  const text = result.content[0]?.text ?? '';
-  return /\b(ACCESS_DENIED|DAEMON_OFFLINE|EXTENSION_DISCONNECTED|NATIVE_HOST_UNAVAILABLE|CONNECTION_LOST)\b|\b(ENOENT|ECONNREFUSED|ETIMEDOUT)\b|ERROR: connect\b/u.test(
-    text
-  );
-}
-
-/**
- * @param {ToolResult} result
- * @param {string} destinationId
- * @returns {ToolResult}
- */
-function annotateAutoDestination(result, destinationId) {
-  return {
-    ...result,
-    structuredContent: {
-      ...result.structuredContent,
-      destinationId,
-      autoSelectedDestinationId: destinationId,
-    },
-  };
-}
-
-/**
- * @param {(client: import('../../agent-client/src/client.js').BridgeClient) => Promise<ToolResult>} callback
- * @param {ToolResult} localResult
- * @returns {Promise<ToolResult>}
- */
-async function tryRemoteFallback(callback, localResult) {
-  const remotes = (await listBridgeDestinations()).filter((destination) => !destination.local);
-  if (remotes.length === 0) {
-    return localResult;
-  }
-
-  let lastFallbackResult = localResult;
-  for (const remote of remotes) {
-    const client = await createBridgeClientForDestination(remote.id);
-    try {
-      await client.connect();
-      const result = annotateAutoDestination(await callback(client), remote.id);
-      lastFallbackResult = result;
-      if (!shouldTryRemoteFallback(result)) {
-        return result;
-      }
-    } catch (error) {
-      lastFallbackResult = annotateAutoDestination(summarizeToolError(error), remote.id);
-    } finally {
-      await client.close();
-    }
-  }
-
-  return lastFallbackResult;
-}
-
 /**
  * @param {(client: import('../../agent-client/src/client.js').BridgeClient) => Promise<ToolResult>} callback
  * @param {{ destinationId?: string | null }} [options]
@@ -201,8 +152,7 @@ async function tryRemoteFallback(callback, localResult) {
 export async function withToolClient(callback, options = {}) {
   try {
     if (!options.destinationId) {
-      const result = await withBridgeClient(callback);
-      return shouldTryRemoteFallback(result) ? await tryRemoteFallback(callback, result) : result;
+      return await withBridgeClient(callback);
     }
     const client = await createBridgeClientForDestination(options.destinationId);
     await client.connect();

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

@@ -54,6 +54,8 @@ export {
 } from './handlers-capture.js';
 
 export {
+  MAX_BATCH_CALLS,
+  MAX_BATCH_CONCURRENCY,
   PAGE_ACTIONS,
   handlePageTool,
   handleBatchTool,

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

@@ -27,6 +27,7 @@ import {
   handleStylesLayoutTool,
   handleTabsTool,
   handleInvestigateTool,
+  MAX_BATCH_CALLS,
 } from './handlers.js';
 import {
   BUDGET_PRESETS,
@@ -40,7 +41,7 @@ import {
   getMethodsByMaxComplexity,
 } from '../../protocol/src/index.js';
 import { applyWindowsTcpTransportDefaults } from '../../native-host/src/config.js';
-import { MCP_SERVER_INSTRUCTIONS } from './guidance.js';
+import { MCP_SERVER_INSTRUCTIONS, registerBridgeMcpGuidance } from './guidance.js';
 
 export const BUDGET_PRESET_DESCRIPTION = `Budget preset: "quick", "normal", or "deep" (defaults: query ${BUDGET_PRESETS.normal.maxNodes} nodes / depth ${BUDGET_PRESETS.normal.maxDepth} / text ${BUDGET_PRESETS.normal.textBudget}). Numeric fields override the preset when both are provided.`;
 export const TAB_ID_DESCRIPTION =
@@ -105,6 +106,8 @@ export function createBridgeMcpServer() {
     }
   );
 
+  registerBridgeMcpGuidance(server);
+
   server.registerTool(
     'browser_status',
     {
@@ -661,6 +664,7 @@ export function createBridgeMcpServer() {
             })
           )
           .min(1)
+          .max(MAX_BATCH_CALLS)
           .describe('Calls to execute in parallel'),
       },
     },

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

@@ -249,11 +249,20 @@ export async function stopBridgeDaemon(options = {}) {
     resolvedTransport.type === 'socket' ? resolvedTransport.socketPath : '';
 
   const pidFromFile = await readPidFn(pidPath);
-  let previousPid = pidFromFile;
-  let previouslyRunning = previousPid !== null;
-
-  if (previousPid === null && (await safePingDaemon(resolvedTransport, pingDaemonFn))) {
-    previousPid = await findPidByTransportFn(resolvedTransport);
+  const reachable = await safePingDaemon(resolvedTransport, pingDaemonFn);
+  const endpointOwnerPid =
+    pidFromFile !== null || reachable ? await findPidByTransportFn(resolvedTransport) : null;
+  /** @type {number | null} */
+  let previousPid = null;
+  let previouslyRunning = false;
+
+  if (endpointOwnerPid !== null) {
+    previousPid = endpointOwnerPid;
+    previouslyRunning = true;
+  } else if (reachable) {
+    // TCP endpoints do not expose an owner pid. In that case daemon
+    // reachability is the evidence supporting the recorded pid.
+    previousPid = pidFromFile;
     previouslyRunning = true;
   }
 
@@ -275,9 +284,8 @@ export async function stopBridgeDaemon(options = {}) {
       sleepFn,
     });
     if (!stopped) {
-      // The pid file can be stale (e.g. a root-owned leftover from a sudo
-      // install that the daemon could not overwrite) while a daemon with a
-      // different pid owns the socket. Target the socket owner before giving up.
+      // Endpoint ownership may become discoverable after a recorded daemon pid
+      // fails to stop. Only target the verified owner before giving up.
       const socketOwnerPid = await findPidByTransportFn(resolvedTransport);
       if (socketOwnerPid !== null && socketOwnerPid !== previousPid) {
         try {