@browserbridge/bbx 1.12.0 → 1.12.2

package/PRIVACY.md

@@ -82,6 +82,7 @@ You should review the privacy and retention practices of any connected agent, ID
 Browser Bridge keeps data only as long as needed for the current local session and feature behavior.
 
 - Window enablement state is stored in session storage and cleared when disabled or when the browser session ends.
+- To warn about access enabled elsewhere, the daemon shares enabled-window IDs, bounded titles, enablement timestamps, browser names, and session profile labels with connected local Browser Bridge extensions. The side panel uses this in-memory metadata for its other-enabled-windows counter. It does not include page contents or disabled-window details, and disconnecting an extension removes its entry.
 - Action log entries are stored for the current browser session only.
 - Incidental action/log URLs remove credentials and fragments and redact query values; sensitive structured fields and local path prefixes are reduced before persistence.
 - Console and fetch/XHR network buffers are bounded in memory and cleared when disabled or when the page state is reset.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbridge/bbx",
-  "version": "1.12.0",
+  "version": "1.12.2",
   "private": false,
   "keywords": [
     "agent-tools",

package/packages/agent-client/src/cli-args.js

@@ -6,7 +6,8 @@ import { methodNeedsTab, parseIntArg, parseJsonObject } from './cli-helpers.js';
 /** @typedef {import('./types.js').BridgeMethod} BridgeMethod */
 /** @typedef {import('../../protocol/src/defaults.js').BudgetPresetName} BudgetPresetName */
 
-const CALL_USAGE = 'Usage: call [--tab <tabId>] [--preset quick|normal|deep] <method> [paramsJson]';
+const CALL_USAGE =
+  'Usage: call [--extension <connectionId>] [--browser <name>] [--profile <label>] [--tab <tabId>] [--preset quick|normal|deep] <method> [paramsJson]';
 
 /**
  * Read all of stdin as UTF-8 text. Resolves once stdin closes.
@@ -149,10 +150,27 @@ export function extractPresetFlag(args) {
 
 /**
  * @param {string[]} args
- * @returns {Promise<{ tabId: number | null, method: BridgeMethod, params: Record<string, unknown> }>}
+ * @returns {Promise<import('../../protocol/src/types.js').BrowserTarget & { tabId: number | null, method: BridgeMethod, params: Record<string, unknown> }>}
  */
 export async function parseCallCommand(args) {
-  const presetParsed = extractPresetFlag(args);
+  const remaining = [...args];
+  /** @type {import('../../protocol/src/types.js').BrowserTarget} */
+  const target = {};
+  /** @type {Array<[string, keyof import('../../protocol/src/types.js').BrowserTarget]>} */
+  const selectors = [
+    ['--extension', 'extensionId'],
+    ['--browser', 'targetBrowser'],
+    ['--profile', 'targetProfile'],
+  ];
+  for (const [flag, field] of selectors) {
+    const index = remaining.indexOf(flag);
+    if (index === -1) continue;
+    const value = remaining[index + 1];
+    if (!value?.trim() || value.startsWith('--')) throw new Error(`${flag} requires a value.`);
+    target[field] = value;
+    remaining.splice(index, 2);
+  }
+  const presetParsed = extractPresetFlag(remaining);
   const parsed = extractTabFlag(presetParsed.rest);
   const [first, second, ...extra] = parsed.rest;
   if (!first) {
@@ -173,6 +191,7 @@ export async function parseCallCommand(args) {
       rawParams = await readStdin();
     }
     return {
+      ...target,
       method,
       tabId: methodNeedsTab(method) ? parsed.tabId : null,
       params: applyMethodBudgetPreset(method, parseJsonObject(rawParams), presetParsed.preset),

package/packages/agent-client/src/cli-batch.js

@@ -33,7 +33,7 @@ import { requestBridge } from './runtime.js';
  */
 
 /**
- * @typedef {{ method: BridgeMethod, params: Record<string, unknown>, tabId: number | null }} PreparedBatchCall
+ * @typedef {import('../../protocol/src/types.js').BrowserTarget & { method: BridgeMethod, params: Record<string, unknown>, tabId: number | null }} PreparedBatchCall
  */
 
 /**
@@ -107,10 +107,11 @@ export async function runBatchCalls(client, input, source, options = {}) {
   const validPrepared = /** @type {Array<{ value: PreparedBatchCall }>} */ (prepared);
   if (!client.connected) await client.connect();
   return mapWithConcurrency(validPrepared, MAX_BATCH_CONCURRENCY, async (item) => {
-    const { method, params, tabId } = item.value;
+    const { method, params, tabId, ...target } = item.value;
     const startTime = Date.now();
     try {
       const response = await requestBridge(client, method, params, {
+        ...target,
         tabId,
         source,
       });
@@ -150,6 +151,16 @@ function prepareBatchCall(call, preset) {
     };
   }
   const method = /** @type {BridgeMethod} */ (batchCall.method);
+  /** @type {import('../../protocol/src/types.js').BrowserTarget} */
+  const target = {};
+  for (const field of /** @type {const} */ (['extensionId', 'targetBrowser', 'targetProfile'])) {
+    const value = batchCall[field];
+    if (value === undefined) continue;
+    if (typeof value !== 'string' || !value.trim()) {
+      return { error: invalidBatchItem(method, `${field} must be a non-empty string.`) };
+    }
+    target[field] = value;
+  }
   if (method === 'sensitive.read') {
     return {
       error: invalidBatchItem(
@@ -182,7 +193,7 @@ function prepareBatchCall(call, preset) {
     batchCall.tabId > 0
       ? batchCall.tabId
       : null;
-  return { value: { method, params: mergedParams, tabId } };
+  return { value: { ...target, method, params: mergedParams, tabId } };
 }
 
 /**

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

@@ -393,8 +393,9 @@ async function main() {
     }
 
     if (command === 'call') {
-      const { tabId, method, params } = await parseCallCommand(rest);
+      const { tabId, method, params, ...target } = await parseCallCommand(rest);
       const response = await requestBridge(client, method, params, {
+        ...target,
         tabId,
         source: REQUEST_SOURCE,
       });
@@ -413,8 +414,9 @@ async function main() {
     }
 
     if (command.includes('.') && METHODS.includes(/** @type {BridgeMethod} */ (command))) {
-      const { tabId, method, params } = await parseCallCommand([command, ...rest]);
+      const { tabId, method, params, ...target } = await parseCallCommand([command, ...rest]);
       const response = await requestBridge(client, method, params, {
+        ...target,
         tabId,
         source: REQUEST_SOURCE,
       });

package/packages/agent-client/src/command-registry.js

@@ -294,7 +294,7 @@ export const CLI_HELP_SECTIONS = Object.freeze([
   {
     title: 'Generic RPC',
     lines: [
-      'bbx call [--tab <tabId>] [--preset quick|normal|deep] <method> [paramsJson|-]  Call any bridge method (- reads JSON from stdin)',
+      'bbx call [--extension <connectionId>] [--browser <name>] [--profile <label>] [--tab <tabId>] [--preset quick|normal|deep] <method> [paramsJson|-]  Call any bridge method (- reads JSON from stdin)',
       'bbx <method> [--tab <tabId>] [paramsJson|-]                        Direct alias for exact bridge methods such as page.get_state',
       "bbx batch [--preset quick|normal|deep] '[{method,params,tabId?},...]'  Up to 20 parallel read-only calls",
       '--preset fills budget gaps (maxNodes, maxDepth, textBudget, limit) from the shared quick|normal|deep presets; explicit params always win.',

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

@@ -107,7 +107,7 @@ export async function ensureClientConnected(client) {
  * @param {BridgeClient} client
  * @param {BridgeMethod} method
  * @param {Record<string, unknown>} [params={}]
- * @param {{ tabId?: number | null, source?: BridgeRequestSource, mcpEra?: import('./types.js').McpProtocolEra, tokenBudget?: number | null, automaticRetry?: 'mcp_second_attempt' }} [options]
+ * @param {import('../../protocol/src/types.js').BrowserTarget & { tabId?: number | null, source?: BridgeRequestSource, mcpEra?: import('./types.js').McpProtocolEra, tokenBudget?: number | null, automaticRetry?: 'mcp_second_attempt' }} [options]
  * @returns {Promise<BridgeResponse>}
  */
 export async function requestBridge(client, method, params = {}, options = {}) {
@@ -128,12 +128,17 @@ export async function requestBridge(client, method, params = {}, options = {}) {
     method,
     params,
     tabId: methodNeedsTab(method) ? (options.tabId ?? null) : null,
-    meta: withRequestMeta(
-      options.source,
-      options.mcpEra,
-      options.tokenBudget,
-      options.automaticRetry
-    ),
+    meta: {
+      ...withRequestMeta(
+        options.source,
+        options.mcpEra,
+        options.tokenBudget,
+        options.automaticRetry
+      ),
+      ...(options.extensionId !== undefined ? { target_extension: options.extensionId } : {}),
+      ...(options.targetBrowser !== undefined ? { target_browser: options.targetBrowser } : {}),
+      ...(options.targetProfile !== undefined ? { target_profile: options.targetProfile } : {}),
+    },
     ...(timeoutMs === undefined ? {} : { timeoutMs }),
   });
 }

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

@@ -7,7 +7,8 @@
  */
 const SHARED_INSTRUCTIONS = Object.freeze([
   '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.',
+  'Start with browser_call method health.ping. Its access status describes only the routed profile, not every window. Use connectedExtensions or unscoped tabs.list to discover profiles and existing tabs. Reuse the selected extensionId, destinationId when remote, and tabId on every follow-up call, including each browser_batch item. tabId alone does not select a profile. Never disable unrelated windows to fix routing. If a connection disappears, rediscover it instead of switching profiles or using guessed IDs.',
+  "If the selected profile has window access disabled, call browser_call method access.request once with its extensionId, ask the user to click Enable in that profile's Browser Bridge popup or side panel, then retry once with the same target. Restricted pages and ambiguous_browser_target are routing problems, not evidence that every window needs enabling.",
   'Use structured reads first through browser_call: page.get_state, dom.query, page.get_text, page.extract_content, styles.get_computed, or layout.get_box_model. Prefer semantic extraction for articles and documentation. Use browser_batch only for parallel reads; run mutations sequentially and keep limits tight before widening.',
   'Reuse elementRef values returned by DOM reads. 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.',

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

@@ -5,6 +5,7 @@ import {
   createToolResult,
   getBridgeDestinations,
   getToolTokenBudget,
+  hasMcpBrowserTarget,
   requestBridgeWithRetry,
   summarizeToolError,
   withMcpRequestClient,
@@ -19,7 +20,7 @@ import {
  */
 export async function handleTabsTool(args) {
   if (args.action === 'list') {
-    if (typeof args.destinationId === 'string') {
+    if (typeof args.destinationId === 'string' || hasMcpBrowserTarget()) {
       return callBridgeTool('tabs.list', {}, { destinationId: args.destinationId });
     }
     const destinations = await getBridgeDestinations();
@@ -51,10 +52,14 @@ export async function handleTabsTool(args) {
               tabs: [],
             };
           }
-          const result = /** @type {{ tabs?: Array<Record<string, unknown>> }} */ (response.result);
+          const result =
+            /** @type {{ tabs?: Array<Record<string, unknown>>, profiles?: unknown[], partial?: boolean }} */ (
+              response.result
+            );
           return {
             destinationId: destination.id,
-            ok: true,
+            ok: result.partial !== true,
+            ...(result.profiles ? { profiles: result.profiles } : {}),
             tabs: (result.tabs ?? []).map((tab) => ({ destinationId: destination.id, ...tab })),
           };
         } catch (error) {
@@ -78,7 +83,7 @@ export async function handleTabsTool(args) {
         tabs,
         destinations: results,
       },
-      failures.length === results.length
+      failures.length === results.length && tabs.length === 0
     );
   }
   if (args.action === 'create') {

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

@@ -347,7 +347,7 @@ export async function handleSensitiveReadTool(args) {
 }
 
 /**
- * @param {{ calls?: Array<{ method?: string, params?: Record<string, unknown>, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }> }} args
+ * @param {{ calls?: Array<import('../../protocol/src/types.js').BrowserTarget & { method?: string, params?: Record<string, unknown>, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }> }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleBatchTool(args) {
@@ -393,6 +393,9 @@ export async function handleBatchTool(args) {
       response = await withMcpRequestClient(
         (client) =>
           requestBridgeWithRetry(client, method, params, {
+            ...(call.extensionId ? { extensionId: call.extensionId } : {}),
+            ...(call.targetBrowser ? { targetBrowser: call.targetBrowser } : {}),
+            ...(call.targetProfile ? { targetProfile: call.targetProfile } : {}),
             tabId,
             source: REQUEST_SOURCE,
             tokenBudget,
@@ -405,15 +408,25 @@ export async function handleBatchTool(args) {
     if (callError || !response) {
       return {
         destinationId,
+        ...(call.extensionId ? { extensionId: call.extensionId } : {}),
         ...summarizeThrownBatchError(method, tabId, callError, Date.now() - startTime),
       };
     }
+    const discovery = method === 'tabs.list' ? summarizeToolResponse(response, method) : null;
     return {
       destinationId,
+      ...(call.extensionId ? { extensionId: call.extensionId } : {}),
       ...summarizeBatchResponseItem(
         { method, tabId, response, durationMs: Date.now() - startTime },
         { compact: true }
       ),
+      ...(discovery
+        ? {
+            summary: discovery.content[0].text,
+            evidence: discovery.structuredContent.evidence,
+            ...(discovery.structuredContent.outputTruncated ? { outputTruncated: true } : {}),
+          }
+        : {}),
     };
   });
 

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

@@ -5,6 +5,8 @@ import { randomUUID } from 'node:crypto';
 
 import {
   BridgeError,
+  createSuccess,
+  createFailure,
   bridgeMethodNeedsTab,
   DEFAULT_CONSOLE_LIMIT,
   DEFAULT_LOG_TAIL_LIMIT,
@@ -51,6 +53,33 @@ const MCP_CLIENT_ID = `mcp_${randomUUID()}`;
 const MCP_AGENT_SESSION = process.env.BBX_SESSION?.trim() || MCP_CLIENT_ID;
 /** @type {AsyncLocalStorage<{ era: import('../../protocol/src/types.js').McpProtocolEra, signal?: AbortSignal }>} */
 const MCP_REQUEST_ERA = new AsyncLocalStorage();
+/** @type {AsyncLocalStorage<import('../../protocol/src/types.js').BrowserTarget>} */
+const MCP_REQUEST_TARGET = new AsyncLocalStorage();
+
+/**
+ * Scope routing to one tool invocation, including selector resolution and retries.
+ * @template T
+ * @param {unknown} args
+ * @param {() => T} callback
+ * @returns {T}
+ */
+export function runWithMcpRequestTarget(args, callback) {
+  const record =
+    args && typeof args === 'object' ? /** @type {Record<string, unknown>} */ (args) : {};
+  const target = {
+    ...(MCP_REQUEST_TARGET.getStore() ?? {}),
+    ...(typeof record.extensionId === 'string' ? { extensionId: record.extensionId } : {}),
+    ...(typeof record.targetBrowser === 'string' ? { targetBrowser: record.targetBrowser } : {}),
+    ...(typeof record.targetProfile === 'string' ? { targetProfile: record.targetProfile } : {}),
+  };
+  return MCP_REQUEST_TARGET.run(target, callback);
+}
+
+/** @returns {boolean} */
+export function hasMcpBrowserTarget() {
+  const target = MCP_REQUEST_TARGET.getStore();
+  return Boolean(target?.extensionId || target?.targetBrowser || target?.targetProfile);
+}
 
 /**
  * @template T
@@ -275,6 +304,16 @@ export function summarizeToolResponse(response, method, params = {}) {
   const summary = annotateBridgeSummary(summarizeBridgeResponse(response, method), response);
   const summaryRecord = /** @type {Record<string, unknown>} */ (summary);
   if (response.ok) {
+    if (
+      method === 'tabs.list' &&
+      response.result &&
+      typeof response.result === 'object' &&
+      'partial' in response.result &&
+      response.result.partial === true
+    ) {
+      summary.summary +=
+        ' Some browser profiles could not be listed; inspect evidence.profiles before assuming a tab is absent.';
+    }
     const evidence = getRequestAwareEvidence(response.result, method, params, summary.evidence);
     summary.evidence = evidence.value;
     if (evidence.metadata) summaryRecord.evidenceMeta = evidence.metadata;
@@ -505,6 +544,35 @@ function getRequestAwareEvidence(rawResult, method, params, fallback) {
     rawResult && typeof rawResult === 'object' && !Array.isArray(rawResult)
       ? /** @type {Record<string, unknown>} */ (rawResult)
       : {};
+  if (method === 'tabs.list' && Array.isArray(result.tabs)) {
+    const tabs = /** @type {unknown[]} */ (result.tabs)
+      .filter((tab) => tab && typeof tab === 'object' && !Array.isArray(tab))
+      .map((tab) => /** @type {Record<string, unknown>} */ (tab))
+      .sort(
+        (left, right) =>
+          Number(right.working === true || right.active === true) -
+          Number(left.working === true || left.active === true)
+      )
+      .map((tab) => ({
+        ...(typeof tab.extensionId === 'string' ? { extensionId: tab.extensionId } : {}),
+        tabId: tab.tabId,
+        windowId: tab.windowId,
+        active: tab.active,
+        ...(tab.working === true ? { working: true } : {}),
+        ...(tab.browserName !== undefined ? { browserName: tab.browserName } : {}),
+        ...(tab.profileLabel !== undefined ? { profileLabel: tab.profileLabel } : {}),
+        title: typeof tab.title === 'string' ? tab.title.slice(0, 200) : tab.title,
+        origin: tab.origin,
+        ...(typeof tab.url === 'string'
+          ? { url: tab.url.slice(0, 512), ...(tab.url.length > 512 ? { urlTruncated: true } : {}) }
+          : {}),
+      }));
+    const metadata = Object.fromEntries(Object.entries(result).filter(([key]) => key !== 'tabs'));
+    return boundToolValue(
+      { tabCount: tabs.length, ...metadata, tabs },
+      { maxEntries: 2000, maxCharacters: 30_000, maxStringLength: 1000 }
+    );
+  }
   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);
@@ -757,14 +825,24 @@ export async function waitForClientReconnect(client, timeoutMs = RECONNECT_WAIT_
  * @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, mcpEra?: import('../../protocol/src/types.js').McpProtocolEra, tokenBudget?: number | null, automaticRetry?: 'mcp_second_attempt' }} options
+ * @param {import('../../protocol/src/types.js').BrowserTarget & { tabId?: number | null, source?: import('../../protocol/src/types.js').BridgeRequestSource, mcpEra?: import('../../protocol/src/types.js').McpProtocolEra, tokenBudget?: number | null, automaticRetry?: 'mcp_second_attempt', skipProfileDiscovery?: boolean }} options
  * @returns {Promise<BridgeResponse>}
  */
 export async function requestBridgeWithRetry(client, method, params, options) {
   const requestOptions = {
+    ...(MCP_REQUEST_TARGET.getStore() ?? {}),
     ...options,
     mcpEra: options.mcpEra ?? MCP_REQUEST_ERA.getStore()?.era,
   };
+  if (
+    method === 'tabs.list' &&
+    !options.skipProfileDiscovery &&
+    !requestOptions.extensionId &&
+    !requestOptions.targetBrowser &&
+    !requestOptions.targetProfile
+  ) {
+    return listBrowserProfileTabs(client, params, requestOptions);
+  }
   /** @param {typeof requestOptions} attemptOptions */
   const attempt = (attemptOptions) =>
     awaitMcpOperation(async () => {
@@ -811,6 +889,102 @@ export async function requestBridgeWithRetry(client, method, params, options) {
   return response;
 }
 
+/**
+ * Discover only enabled profiles. Reading tabs never chooses a working tab.
+ * @param {import('../../agent-client/src/client.js').BridgeClient} client
+ * @param {Record<string, unknown>} params
+ * @param {Parameters<typeof requestBridgeWithRetry>[3]} options
+ * @returns {Promise<BridgeResponse>}
+ */
+async function listBrowserProfileTabs(client, params, options) {
+  const health = await requestBridgeWithRetry(client, 'health.ping', {}, options);
+  if (!health.ok) return health;
+  const result =
+    health.result && typeof health.result === 'object'
+      ? /** @type {Record<string, unknown>} */ (health.result)
+      : {};
+  const profiles = Array.isArray(result.connectedExtensions)
+    ? /** @type {unknown[]} */ (result.connectedExtensions)
+        .filter((value) => value && typeof value === 'object' && !Array.isArray(value))
+        .map((value) => /** @type {Record<string, unknown>} */ (value))
+        .filter((value) => typeof value.extensionId === 'string' && value.accessEnabled === true)
+        .map((value) => /** @type {Record<string, unknown> & { extensionId: string }} */ (value))
+    : [];
+  // Older daemons and a disabled single profile keep the usual access response.
+  if (
+    profiles.length === 0 &&
+    (!Array.isArray(result.connectedExtensions) || result.connectedExtensions.length <= 1)
+  ) {
+    return requestBridgeWithRetry(client, 'tabs.list', params, {
+      ...options,
+      skipProfileDiscovery: true,
+    });
+  }
+  if (profiles.length === 0) {
+    return createFailure(
+      health.id,
+      'ACCESS_DENIED',
+      'No connected profile has an enabled window. Select an extensionId from connectedExtensions and request access only for that profile.',
+      {
+        reason: 'no_enabled_browser_profiles',
+        connectedExtensions: result.connectedExtensions,
+      },
+      { method: 'tabs.list' }
+    );
+  }
+  const results = [];
+  for (const profile of profiles) {
+    /** @type {BridgeResponse} */
+    let response;
+    try {
+      response = await requestBridgeWithRetry(client, 'tabs.list', params, {
+        ...options,
+        extensionId: profile.extensionId,
+      });
+    } catch (error) {
+      throwIfMcpRequestCancelled();
+      response = createFailure(
+        health.id,
+        error instanceof BridgeError ? error.code : 'INTERNAL_ERROR',
+        error instanceof Error ? error.message : String(error),
+        null,
+        { method: 'tabs.list' }
+      );
+    }
+    const listed =
+      response.ok && response.result && typeof response.result === 'object'
+        ? /** @type {Record<string, unknown>} */ (response.result)
+        : {};
+    results.push({
+      extensionId: profile.extensionId,
+      browserName: profile.browserName ?? null,
+      profileLabel: profile.profileLabel ?? null,
+      ok: response.ok,
+      ...(response.ok ? {} : { error: response.error }),
+      tabs: Array.isArray(listed.tabs)
+        ? /** @type {unknown[]} */ (listed.tabs)
+            .filter((tab) => tab && typeof tab === 'object' && !Array.isArray(tab))
+            .map((tab) => ({
+              .../** @type {Record<string, unknown>} */ (tab),
+              extensionId: profile.extensionId,
+              browserName: profile.browserName ?? null,
+              profileLabel: profile.profileLabel ?? null,
+            }))
+        : [],
+    });
+  }
+  return createSuccess(
+    health.id,
+    {
+      tabs: results.flatMap((profile) => profile.tabs),
+      profiles: results.map(({ tabs, ...profile }) => ({ ...profile, tabCount: tabs.length })),
+      connectedExtensions: result.connectedExtensions,
+      partial: results.some((profile) => !profile.ok),
+    },
+    { method: 'tabs.list' }
+  );
+}
+
 /**
  * @param {BridgeMethod} method
  * @param {Record<string, unknown>} [params={}]

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

@@ -16,6 +16,7 @@ import {
   summarizeToolResponse,
   withToolClient,
   REQUEST_SOURCE,
+  hasMcpBrowserTarget,
 } from './handlers-utils.js';
 
 export {
@@ -81,6 +82,9 @@ const HOME_DIR = os.homedir();
  */
 export async function handleStatusTool(args = {}) {
   try {
+    if (hasMcpBrowserTarget()) {
+      return callBridgeTool('health.ping', {}, { destinationId: args.destinationId });
+    }
     const requestedDestinationId =
       typeof args.destinationId === 'string' ? args.destinationId : null;
     if (requestedDestinationId && requestedDestinationId !== 'local') {
@@ -172,7 +176,7 @@ async function callRemoteHealth(destinationId) {
  */
 export async function handleSkillTool(args = {}) {
   try {
-    if (typeof args.destinationId === 'string') {
+    if (typeof args.destinationId === 'string' || hasMcpBrowserTarget()) {
       return callBridgeTool('skill.get_runtime_context', {}, { destinationId: args.destinationId });
     }
     const ctx = createRuntimeContext();

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

@@ -54,13 +54,44 @@ import {
 import { applyWindowsTcpTransportDefaults } from '../../native-host/src/config.js';
 import { getMcpServerInstructions } from './guidance.js';
 import { isToolEnabledForEra, LOADABLE_TOOLSET_TOOLS } from './toolset.js';
+import { runWithMcpRequestTarget } from './handlers-utils.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 =
-  'Target a specific tab instead of the active tab in the enabled window.';
+  'Tab ID within the selected browser profile. With multiple profiles, also pass extensionId from tabs.list or health.ping.';
 export const DESTINATION_ID_DESCRIPTION =
   'Optional Browser Bridge destination ID from browser_status/browser_tabs; omit for local.';
 
+const BROWSER_TARGET_SCHEMA = {
+  extensionId: z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .optional()
+    .describe(
+      'Exact browser connection ID from health.ping connectedExtensions or tabs.list. Reuse with tabId on every call; IDs are scoped to destinationId and change on reconnect.'
+    ),
+  targetBrowser: z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .optional()
+    .describe(
+      'Browser name from health.ping connectedExtensions. Prefer extensionId when names are ambiguous.'
+    ),
+  targetProfile: z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .optional()
+    .describe(
+      'Profile label from health.ping connectedExtensions. Prefer extensionId when labels are missing or duplicated.'
+    ),
+};
+
 const MCP_SERVER_VERSION = loadPackageVersion();
 
 /**
@@ -173,9 +204,24 @@ export function createBridgeMcpServer(options = {}) {
   const registerTool = (name, config, handler) => {
     const wrappedHandler = /** @type {typeof handler} */ (
       (args, context) =>
-        runWithMcpRequestEra(era, () => handler(args, context), context.mcpReq.signal)
+        runWithMcpRequestEra(
+          era,
+          () => runWithMcpRequestTarget(args, () => handler(args, context)),
+          context.mcpReq.signal
+        )
     );
-    const registration = server.registerTool(name, config, wrappedHandler);
+    const routedConfig =
+      name === 'browser_setup' || name === 'browser_toolset'
+        ? config
+        : {
+            ...config,
+            // Added optional routing fields are consumed by the wrapper; handlers keep
+            // their original, SDK-checked argument contracts.
+            inputSchema: /** @type {InputSchema} */ (
+              /** @type {unknown} */ (config.inputSchema.extend(BROWSER_TARGET_SCHEMA))
+            ),
+          };
+    const registration = server.registerTool(name, routedConfig, wrappedHandler);
     registrations.set(name, registration);
     if (!isToolEnabledForEra(name, era)) {
       registration.disable();
@@ -257,7 +303,7 @@ export function createBridgeMcpServer(options = {}) {
     {
       title: 'Browser Tabs',
       description:
-        'List, create, close, or activate browser tabs. List without destinationId aggregates configured destinations; other actions default to local. Only create a page when the user explicitly requests it.',
+        "List, create, close, or activate browser tabs. Unscoped list discovers tabs across enabled browser profiles and configured destinations. Reuse each tab's extensionId, destinationId, and tabId for subsequent calls. Other actions default to local. Only create a page when the user explicitly requests it.",
       inputSchema: z.object({
         action: z
           .enum(['list', 'create', 'close', 'activate'])
@@ -1051,6 +1097,7 @@ export function createBridgeMcpServer(options = {}) {
                 .describe('Method params for this call'),
               tabId: z.number().int().positive().optional().describe(TAB_ID_DESCRIPTION),
               destinationId: z.string().optional().describe(DESTINATION_ID_DESCRIPTION),
+              ...BROWSER_TARGET_SCHEMA,
               budgetPreset: z
                 .enum(['quick', 'normal', 'deep'])
                 .optional()