@browserbridge/bbx 1.7.3 → 1.7.5

package/packages/agent-client/src/mcp-config.js

@@ -4,6 +4,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
+import { atomicWriteFile } from './atomic-write.js';
+
 /** @typedef {import('./types.js').McpClientName} McpClientName */
 
 /** @type {McpClientName[]} */
@@ -491,6 +493,8 @@ async function installJsonMcpConfig(clientName, configPath, stdout) {
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
       existing = parsed;
+    } else {
+      throw new Error('MCP config root must be a JSON object.');
     }
   } catch (error) {
     if (!isMissingFileError(error)) {
@@ -519,8 +523,9 @@ async function installJsonMcpConfig(clientName, configPath, stdout) {
     },
   };
 
-  await fs.promises.mkdir(path.dirname(configPath), { recursive: true });
-  await fs.promises.writeFile(configPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+  await atomicWriteFile(configPath, `${JSON.stringify(merged, null, 2)}\n`, {
+    encoding: 'utf8',
+  });
   stdout.write(`Wrote ${configPath}\n`);
 }
 
@@ -533,13 +538,14 @@ async function installCodexMcpConfig(configPath, stdout) {
   let raw = '';
   try {
     raw = await fs.promises.readFile(configPath, 'utf8');
-  } catch {
-    raw = '';
+  } catch (error) {
+    if (!isMissingFileError(error)) {
+      throw error;
+    }
   }
 
   const updated = upsertCodexServerBlock(raw);
-  await fs.promises.mkdir(path.dirname(configPath), { recursive: true });
-  await fs.promises.writeFile(configPath, updated, 'utf8');
+  await atomicWriteFile(configPath, updated, { encoding: 'utf8' });
   stdout.write(`Wrote ${configPath}\n`);
 }
 
@@ -558,10 +564,15 @@ async function removeJsonMcpConfig(clientName, configPath, stdout) {
     if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
       existing = parsed;
     } else {
+      throw new Error('MCP config root must be a JSON object.');
+    }
+  } catch (error) {
+    if (isMissingFileError(error)) {
       return false;
     }
-  } catch {
-    return false;
+    throw new Error(
+      `Cannot remove Browser Bridge from ${configPath}: existing MCP config is not readable valid JSON.`
+    );
   }
 
   const shape = getMcpConfigShapeForPath(clientName, configPath);
@@ -584,8 +595,9 @@ async function removeJsonMcpConfig(clientName, configPath, stdout) {
     merged[topKey] = updatedBlock;
   }
 
-  await fs.promises.mkdir(path.dirname(configPath), { recursive: true });
-  await fs.promises.writeFile(configPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+  await atomicWriteFile(configPath, `${JSON.stringify(merged, null, 2)}\n`, {
+    encoding: 'utf8',
+  });
   stdout.write(`Removed ${configPath}\n`);
   return true;
 }
@@ -599,8 +611,11 @@ async function removeCodexMcpConfig(configPath, stdout) {
   let raw = '';
   try {
     raw = await fs.promises.readFile(configPath, 'utf8');
-  } catch {
-    return false;
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return false;
+    }
+    throw error;
   }
 
   if (!hasCodexServerBlock(raw)) {
@@ -608,8 +623,7 @@ async function removeCodexMcpConfig(configPath, stdout) {
   }
 
   const updated = removeCodexServerBlock(raw);
-  await fs.promises.mkdir(path.dirname(configPath), { recursive: true });
-  await fs.promises.writeFile(configPath, updated, 'utf8');
+  await atomicWriteFile(configPath, updated, { encoding: 'utf8' });
   stdout.write(`Removed ${configPath}\n`);
   return true;
 }

package/packages/agent-client/src/remotes.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 
 import { createTcpBridgeTransport, getBridgeDir } from '../../native-host/src/config.js';
 import { normalizeBridgeAuthToken } from '../../native-host/src/auth-token.js';
+import { atomicWriteFile } from './atomic-write.js';
 import { BridgeClient } from './client.js';
 
 const REMOTES_FILENAME = 'remotes.json';
@@ -121,15 +122,13 @@ export async function readRemoteConfig(options = {}) {
 
 /**
  * @param {RemoteConfig} config
- * @param {{ configPath?: string, writeFile?: typeof fs.promises.writeFile, mkdir?: typeof fs.promises.mkdir }} [options={}]
+ * @param {{ configPath?: string }} [options={}]
  * @returns {Promise<void>}
  */
 export async function writeRemoteConfig(config, options = {}) {
   const configPath = options.configPath ?? getRemoteConfigPath();
-  const writeFile = options.writeFile ?? fs.promises.writeFile.bind(fs.promises);
-  const mkdir = options.mkdir ?? fs.promises.mkdir.bind(fs.promises);
-  await mkdir(path.dirname(configPath), { recursive: true });
-  await writeFile(configPath, `${JSON.stringify({ remotes: config.remotes }, null, 2)}\n`, {
+  const remotes = config.remotes.map(validateRemoteDestination);
+  await atomicWriteFile(configPath, `${JSON.stringify({ remotes }, null, 2)}\n`, {
     encoding: 'utf8',
     mode: 0o600,
   });
@@ -140,15 +139,16 @@ export async function writeRemoteConfig(config, options = {}) {
  * @returns {Promise<RemoteDestination>}
  */
 export async function addRemoteDestination(remote) {
+  const validated = validateRemoteDestination(remote);
   const config = await readRemoteConfig();
-  const existing = config.remotes.findIndex((entry) => entry.id === remote.id);
+  const existing = config.remotes.findIndex((entry) => entry.id === validated.id);
   if (existing === -1) {
-    config.remotes.push(remote);
+    config.remotes.push(validated);
   } else {
-    config.remotes[existing] = remote;
+    config.remotes[existing] = validated;
   }
   await writeRemoteConfig(config);
-  return remote;
+  return validated;
 }
 
 /**
@@ -180,7 +180,7 @@ export async function listBridgeDestinations() {
 }
 
 /**
- * @typedef {{ port?: number, bindHost?: string, token?: string, rotateToken?: boolean }} ProxyEnableOptions
+ * @typedef {{ port?: number, bindHost?: string, token?: string, rotateToken?: boolean, unsafePlaintext?: boolean }} ProxyEnableOptions
  */
 
 /**
@@ -197,14 +197,92 @@ export async function listBridgeDestinations() {
  */
 export function resolveProxyEnableSettings(existing, options, generateToken) {
   const port = options.port ?? existing?.port ?? DEFAULT_REMOTE_PORT;
-  const bindHost = options.bindHost ?? existing?.bindHost ?? '0.0.0.0';
+  const bindHost = options.bindHost ?? existing?.bindHost ?? '127.0.0.1';
   if (options.token) {
-    return { port, bindHost, token: options.token, tokenSource: 'explicit' };
+    return {
+      port,
+      bindHost,
+      token: validateAuthToken(options.token),
+      tokenSource: 'explicit',
+    };
   }
-  if (!options.rotateToken && existing?.token) {
-    return { port, bindHost, token: existing.token, tokenSource: 'existing' };
+  const existingToken = normalizeBridgeAuthToken(existing?.token);
+  if (!options.rotateToken && existingToken) {
+    return { port, bindHost, token: existingToken, tokenSource: 'existing' };
   }
-  return { port, bindHost, token: generateToken(), tokenSource: 'generated' };
+  return {
+    port,
+    bindHost,
+    token: validateAuthToken(generateToken()),
+    tokenSource: 'generated',
+  };
+}
+
+/**
+ * Require an explicit acknowledgement before creating or changing a raw TCP
+ * listener that is reachable beyond the local machine. A stored non-loopback
+ * host may be reused without breaking an existing installation.
+ *
+ * @param {{ bindHost: string } | null} existing
+ * @param {ProxyEnableOptions} options
+ * @param {string} bindHost
+ * @returns {void}
+ */
+export function assertProxyBindSafety(existing, options, bindHost) {
+  if (
+    isLoopbackHost(bindHost) ||
+    options.unsafePlaintext === true ||
+    (options.bindHost === undefined && existing?.bindHost === bindHost)
+  ) {
+    return;
+  }
+  throw new Error(
+    'Refusing to bind Browser Bridge raw TCP to a non-loopback host without --unsafe-plaintext. This transport is unencrypted; keep the default 127.0.0.1 bind and use an SSH tunnel instead.'
+  );
+}
+
+/**
+ * @param {string} host
+ * @returns {boolean}
+ */
+export function isLoopbackHost(host) {
+  const normalized = host
+    .trim()
+    .toLowerCase()
+    .replace(/^\[|\]$/gu, '');
+  const ipv4Parts = normalized.split('.').map(Number);
+  const isIpv4Loopback =
+    ipv4Parts.length === 4 &&
+    ipv4Parts[0] === 127 &&
+    ipv4Parts.every((part) => Number.isInteger(part) && part >= 0 && part <= 255);
+  return (
+    normalized === 'localhost' ||
+    normalized === '::1' ||
+    normalized === '0:0:0:0:0:0:0:1' ||
+    isIpv4Loopback
+  );
+}
+
+/**
+ * @param {RemoteDestination} remote
+ * @returns {RemoteDestination}
+ */
+function validateRemoteDestination(remote) {
+  const id = normalizeDestinationId(remote.id);
+  const { host, port } = parseRemoteEndpoint(`${remote.host}:${remote.port}`);
+  return { id, host, port, token: validateAuthToken(remote.token) };
+}
+
+/**
+ * @param {unknown} token
+ * @returns {string}
+ */
+function validateAuthToken(token) {
+  const normalized = normalizeBridgeAuthToken(token);
+  if (!normalized) {
+    throw new Error('Bridge auth token must be a UUID or 32-256 URL-safe characters.');
+  }
+  return normalized;
 }
 
 /**

package/packages/agent-client/src/runtime.js

@@ -19,6 +19,7 @@ import {
 } from '../../native-host/src/daemon-process.js';
 import { resolveDefaultExtensionId } from '../../native-host/src/install-manifest.js';
 import {
+  BridgeError,
   CLIENT_REQUEST_TIMEOUT_MARGIN_MS,
   DEFAULT_CLIENT_REQUEST_TIMEOUT_MS,
   getBridgeOperationTimeoutMs,
@@ -102,12 +103,14 @@ export async function resolveRef(client, refOrSelector, tabId = null, source) {
   );
 
   if (!response.ok) {
-    throw new Error(response.error.message);
+    throw new BridgeError(response.error.code, response.error.message, response.error.details);
   }
 
   const result = /** @type {{ nodes: Array<{ elementRef: string }> }} */ (response.result);
   if (!result.nodes || result.nodes.length === 0) {
-    throw new Error(`No element found for selector "${refOrSelector}".`);
+    throw new BridgeError('INVALID_REQUEST', `No element found for selector "${refOrSelector}".`, {
+      selector: refOrSelector,
+    });
   }
   return result.nodes[0].elementRef;
 }
@@ -350,7 +353,7 @@ export async function checkNativeHostManifestHealth(browserManifests) {
  */
 export async function checkUnwritableBridgePaths() {
   // The root-owned-files scenario comes from sudo installs, which do not exist
-  // on Windows — and fs.access(W_OK) there only reflects the read-only file
+  // on Windows - and fs.access(W_OK) there only reflects the read-only file
   // attribute, so it would produce false positives.
   if (os.platform() === 'win32') {
     return [];

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

@@ -4,11 +4,13 @@
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
+import { tryStartMcpProcessControl } from './lifecycle.js';
 import { startBridgeMcpServer } from './server.js';
 
 /**
  * @typedef {{
  *   start?: () => Promise<void>,
+ *   startControl?: typeof tryStartMcpProcessControl,
  *   argv?: string[],
  *   stdout?: { write: (chunk: string) => unknown },
  *   stderr?: { write: (chunk: string) => unknown },
@@ -33,6 +35,7 @@ const MCP_USAGE = [
 export async function runBridgeMcpCli(options = {}) {
   const {
     start = startBridgeMcpServer,
+    startControl = tryStartMcpProcessControl,
     argv = process.argv.slice(2),
     stdout = process.stdout,
     stderr = process.stderr,
@@ -45,7 +48,13 @@ export async function runBridgeMcpCli(options = {}) {
   }
 
   try {
-    await start();
+    const control = await startControl();
+    try {
+      await start();
+    } catch (error) {
+      await control?.dispose();
+      throw error;
+    }
     return 0;
   } catch (error) {
     const message = error instanceof Error ? error.stack || error.message : String(error);

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

@@ -10,7 +10,7 @@ export const MCP_SERVER_INSTRUCTIONS = [
   'In permission-ask hosts, use browser_call as the default Browser Bridge MCP tool so the user can approve one BBX tool instead of separate browser_status, browser_page, browser_dom, browser_input, and other tools.',
   'Prefer Browser Bridge MCP tools over shelling out to bbx. Use bbx only for explicit CLI setup, doctor, logs, or raw debugging requests.',
   'Start with browser_call method health.ping. If window access is disabled, call browser_call method access.request once, ask the user to click Enable in the Browser Bridge popup or side panel, then retry once.',
-  'Use structured reads first through browser_call: page.get_state, dom.query, page.get_text, styles.get_computed, or layout.get_box_model. Use browser_batch for parallel reads and keep limits tight before widening.',
+  'Use structured reads first through browser_call: page.get_state, dom.query, page.get_text, styles.get_computed, or layout.get_box_model. Use browser_batch only for parallel reads; run mutations sequentially and keep limits tight before widening.',
   'Reuse elementRef values returned by DOM tools. Use attribute allowlists for focused DOM reads.',
   'Escalate to screenshot.capture_element, screenshot.capture_region, dom.get_accessibility_tree, page.evaluate, viewport.resize, or CDP only when structured reads cannot answer the question.',
   'Use patch.apply_styles or patch.apply_dom for temporary experiments, and rollback patches before finishing unless the user asks to keep them.',
@@ -103,7 +103,7 @@ function createGuidePrompt() {
       '2. In permission-ask hosts, use `browser_call` as the default tool so the user can approve one BBX MCP tool instead of separate tools for status, page, DOM, input, and patches.',
       '3. Start with `browser_call` method `health.ping`. If access is disabled, call `browser_call` method `access.request` once, ask the user to click Enable, then retry once.',
       '4. Start with structured reads via `browser_call`: `page.get_state`, `dom.query`, `dom.find_by_text`, `dom.find_by_role`, and `styles.get_computed`. Use `browser_batch` for parallel reads.',
-      '5. `browser_call` accepts explicit method limits, not `budgetPreset`; keep limits tight and widen only when results are truncated.',
+      '5. `browser_call` accepts `budgetPreset`; explicit method limits override preset values. Keep limits tight and widen only when results are truncated.',
       '6. Reuse `elementRef` values returned by DOM tools instead of rescanning.',
       '7. Escalate to screenshots, accessibility tree, `page.evaluate`, viewport resize, or CDP only when structured reads cannot answer.',
       '8. Use `patch.apply_styles` or `patch.apply_dom` for temporary experiments and rollback before finishing unless the user asks to keep patches.',

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

@@ -1,12 +1,12 @@
 // @ts-check
 
+import { BridgeError } from '../../protocol/src/index.js';
 import {
   createToolResult,
   getToolTokenBudget,
   REQUEST_SOURCE,
   requestBridgeWithRetry,
   resolveToolRef,
-  resolveRef,
   summarizeToolError,
   summarizeToolResponse,
   withToolClient,
@@ -110,7 +110,7 @@ export async function handleCaptureTool(args) {
       const response = await requestBridgeWithRetry(client, entry.method, entry.params(args, ref), {
         tabId: requestedTabId,
         source: REQUEST_SOURCE,
-        tokenBudget: getToolTokenBudget(args),
+        tokenBudget: entry.method.startsWith('screenshot.') ? null : getToolTokenBudget(args),
       });
       if (!response.ok) {
         return summarizeToolResponse(response, entry.method);
@@ -128,15 +128,15 @@ export async function handleCaptureTool(args) {
  * @param {BridgeMethod} method
  * @returns {ToolResult}
  */
-function createScreenshotResult(response, method) {
+export function createScreenshotResult(response, method) {
   const result = toRecord(response.result);
   if (typeof result.image !== 'string') {
-    return summarizeToolError(`${method} returned no image data.`);
+    return summarizeToolError(new Error(`${method} returned no image data.`));
   }
 
   const image = normalizeBase64Image(result.image);
   if (!image) {
-    return summarizeToolError(`${method} returned invalid base64 image data.`);
+    return summarizeToolError(new Error(`${method} returned invalid base64 image data.`));
   }
 
   const rect = boundedRect(result.rect);
@@ -269,6 +269,7 @@ export const INPUT_ACTION_METHODS = {
   click: 'input.click',
   focus: 'input.focus',
   type: 'input.type',
+  fill: 'input.fill',
   press_key: 'input.press_key',
   cdp_press_key: 'cdp.dispatch_key_event',
   set_checked: 'input.set_checked',
@@ -279,13 +280,30 @@ export const INPUT_ACTION_METHODS = {
 };
 
 /**
- * @param {{ action: string, elementRef?: string, selector?: string, button?: string, clickCount?: number, text?: string, clear?: boolean, submit?: boolean, key?: string, code?: string, modifiers?: string[], checked?: boolean, values?: string[], labels?: string[], indexes?: number[], duration?: number, sourceElementRef?: string, sourceSelector?: string, destinationElementRef?: string, destinationSelector?: string, offsetX?: number, offsetY?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * Keep selector-based actions atomic instead of resolving a ref in a separate
+ * bridge request that can race with a page rerender.
+ *
+ * @param {unknown} elementRef
+ * @param {unknown} selector
+ * @returns {import('../../protocol/src/types.js').InputTarget | null}
+ */
+function createInputTarget(elementRef, selector) {
+  if (typeof elementRef === 'string' && elementRef) return { elementRef };
+  if (typeof selector === 'string' && selector) return { selector };
+  return null;
+}
+
+/**
+ * @param {{ action: string, elementRef?: string, selector?: string, button?: string, clickCount?: number, text?: string, value?: string, mode?: 'auto' | 'setter' | 'keystrokes', clear?: boolean, submit?: boolean, key?: string, code?: string, modifiers?: string[], checked?: boolean, values?: string[], labels?: string[], indexes?: number[], duration?: number, sourceElementRef?: string, sourceSelector?: string, destinationElementRef?: string, destinationSelector?: string, offsetX?: number, offsetY?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleInputTool(args) {
   if (args.action === 'type' && !hasText(args.text)) {
     return summarizeToolError('text is required for input.type.');
   }
+  if (args.action === 'fill' && typeof args.value !== 'string') {
+    return summarizeToolError('value is required for input.fill.');
+  }
   if ((args.action === 'press_key' || args.action === 'cdp_press_key') && !hasText(args.key)) {
     return summarizeToolError('key is required for key input actions.');
   }
@@ -301,9 +319,13 @@ export async function handleInputTool(args) {
   return withToolClient(
     async (client) => {
       const requestedTabId = typeof args.tabId === 'number' ? args.tabId : null;
-      const elementTarget = async () => ({
-        elementRef: await resolveToolRef(client, args, requestedTabId),
-      });
+      const elementTarget = () => {
+        const target = createInputTarget(args.elementRef, args.selector);
+        if (!target) {
+          throw new BridgeError('INVALID_REQUEST', 'Provide either elementRef or selector.');
+        }
+        return target;
+      };
 
       switch (args.action) {
         case 'click': {
@@ -311,7 +333,7 @@ export async function handleInputTool(args) {
             client,
             'input.click',
             {
-              target: await elementTarget(),
+              target: elementTarget(),
               button: args.button,
               clickCount: args.clickCount,
               modifiers: args.modifiers,
@@ -329,7 +351,7 @@ export async function handleInputTool(args) {
             client,
             'input.focus',
             {
-              target: await elementTarget(),
+              target: elementTarget(),
             },
             {
               tabId: requestedTabId,
@@ -344,7 +366,7 @@ export async function handleInputTool(args) {
             client,
             'input.type',
             {
-              target: await elementTarget(),
+              target: elementTarget(),
               text: args.text,
               clear: args.clear,
               submit: args.submit,
@@ -358,8 +380,25 @@ export async function handleInputTool(args) {
           );
           return summarizeToolResponse(response, 'input.type');
         }
+        case 'fill': {
+          const response = await requestBridgeWithRetry(
+            client,
+            'input.fill',
+            {
+              target: elementTarget(),
+              value: args.value,
+              mode: args.mode,
+            },
+            {
+              tabId: requestedTabId,
+              source: REQUEST_SOURCE,
+              tokenBudget: getToolTokenBudget(args),
+            }
+          );
+          return summarizeToolResponse(response, 'input.fill');
+        }
         case 'press_key': {
-          const target = args.elementRef || args.selector ? await elementTarget() : undefined;
+          const target = args.elementRef || args.selector ? elementTarget() : undefined;
           const response = await requestBridgeWithRetry(
             client,
             'input.press_key',
@@ -398,7 +437,7 @@ export async function handleInputTool(args) {
             client,
             'input.set_checked',
             {
-              target: await elementTarget(),
+              target: elementTarget(),
               checked: args.checked,
             },
             {
@@ -414,7 +453,7 @@ export async function handleInputTool(args) {
             client,
             'input.select_option',
             {
-              target: await elementTarget(),
+              target: elementTarget(),
               values: args.values,
               labels: args.labels,
               indexes: args.indexes,
@@ -432,7 +471,7 @@ export async function handleInputTool(args) {
             client,
             'input.hover',
             {
-              target: await elementTarget(),
+              target: elementTarget(),
               duration: args.duration,
               modifiers: args.modifiers,
             },
@@ -445,21 +484,12 @@ export async function handleInputTool(args) {
           return summarizeToolResponse(response, 'input.hover');
         }
         case 'drag': {
-          const source = {
-            elementRef:
-              args.sourceElementRef ||
-              (args.sourceSelector
-                ? await resolveRef(client, args.sourceSelector, requestedTabId, REQUEST_SOURCE)
-                : ''),
-          };
-          const destination = {
-            elementRef:
-              args.destinationElementRef ||
-              (args.destinationSelector
-                ? await resolveRef(client, args.destinationSelector, requestedTabId, REQUEST_SOURCE)
-                : ''),
-          };
-          if (!source.elementRef || !destination.elementRef) {
+          const source = createInputTarget(args.sourceElementRef, args.sourceSelector);
+          const destination = createInputTarget(
+            args.destinationElementRef,
+            args.destinationSelector
+          );
+          if (!source || !destination) {
             return summarizeToolError(
               'sourceElementRef/sourceSelector and destinationElementRef/destinationSelector are required for drag.'
             );
@@ -486,7 +516,7 @@ export async function handleInputTool(args) {
             client,
             'input.scroll_into_view',
             {
-              target: await elementTarget(),
+              target: elementTarget(),
             },
             {
               tabId: requestedTabId,

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

@@ -104,7 +104,8 @@ export async function handleDomTool(args) {
     return summarizeToolError('role is required for dom.find_by_role.');
   }
   if (args.action === 'query' || args.action === 'accessibility_tree') {
-    const inferred = inferBudgetFromSelector(args);
+    const inferred =
+      args.action === 'accessibility_tree' ? 'normal' : inferBudgetFromSelector(args);
     const withBudget = inferred ? { ...args, budgetPreset: args.budgetPreset ?? inferred } : args;
     return dispatchToolAction(DOM_ACTIONS, applyTreeBudgetPreset(withBudget), 'DOM');
   }
@@ -183,7 +184,6 @@ export const PATCH_ACTIONS = {
         addClass: 'add_class',
         removeClass: 'remove_class',
         setTextContent: 'set_text',
-        setProperty: 'set_attribute',
       };
       const normalizedOperation = opMap[operation] || operation;
       const value =

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

@@ -6,6 +6,7 @@ import {
   createToolResult,
   getBridgeDestinations,
   getToolTokenBudget,
+  requestBridgeWithRetry,
   summarizeToolError,
 } from './handlers-utils.js';
 
@@ -27,15 +28,23 @@ export async function handleTabsTool(args) {
     }
     const results = await Promise.all(
       destinations.map(async (destination) => {
-        const client = await createBridgeClientForDestination(
-          destination.local ? null : destination.id
-        );
+        /** @type {import('../../agent-client/src/client.js').BridgeClient | null} */
+        let client = null;
         try {
+          client = await createBridgeClientForDestination(
+            destination.local ? null : destination.id
+          );
           await client.connect();
-          const response = await client.request({
-            method: 'tabs.list',
-            meta: { source: 'mcp' },
-          });
+          const response = await requestBridgeWithRetry(
+            client,
+            'tabs.list',
+            {},
+            {
+              tabId: null,
+              source: 'mcp',
+              tokenBudget: null,
+            }
+          );
           if (!response.ok) {
             return {
               destinationId: destination.id,
@@ -58,7 +67,9 @@ export async function handleTabsTool(args) {
             tabs: [],
           };
         } finally {
-          await client.close();
+          if (client) {
+            await client.close().catch(() => {});
+          }
         }
       })
     );
@@ -73,7 +84,7 @@ export async function handleTabsTool(args) {
         tabs,
         destinations: results,
       },
-      false
+      failures.length === results.length
     );
   }
   if (args.action === 'create') {
@@ -96,6 +107,16 @@ export async function handleTabsTool(args) {
       { destinationId: args.destinationId ?? null }
     );
   }
+  if (args.action === 'activate') {
+    if (typeof args.tabId !== 'number') {
+      return summarizeToolError('tabId is required for tabs.activate.');
+    }
+    return callBridgeTool(
+      'tabs.activate',
+      { tabId: args.tabId },
+      { destinationId: args.destinationId ?? null }
+    );
+  }
   return summarizeToolError(`Unsupported tabs action "${args.action}".`);
 }