@browserbridge/bbx 1.6.3 → 1.7.0

package/package.json

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

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

@@ -9,11 +9,13 @@ import { fileURLToPath } from 'node:url';
 
 import {
   applyWindowsTcpTransportDefaults,
+  createTcpBridgeTransport,
   getProxyConfigPath,
   readProxyConfig,
   SUPPORTED_BROWSERS,
 } from '../../native-host/src/config.js';
 import { writeBridgeAuthToken } from '../../native-host/src/auth-token.js';
+import { pingExistingDaemon } from '../../native-host/src/daemon.js';
 import { restartBridgeDaemon } from '../../native-host/src/daemon-process.js';
 import { uninstallNativeManifest } from '../../native-host/src/install-manifest.js';
 import {
@@ -23,7 +25,6 @@ import {
   summarizeBatchResponseItem,
 } from '../../protocol/src/index.js';
 import { startBridgeMcpServer } from '../../mcp-server/src/server.js';
-import { BridgeClient } from './client.js';
 import { CLI_HELP_SECTIONS, SHORTCUT_COMMANDS } from './command-registry.js';
 import {
   interactiveCheckbox,
@@ -59,6 +60,7 @@ import {
   parseRemoteEndpoint,
   readRemoteConfig,
   removeRemoteDestination,
+  resolveProxyEnableSettings,
 } from './remotes.js';
 import { collectSetupStatus } from './setup-status.js';
 import { annotateBridgeSummary, summarizeBridgeResponse } from './subagent.js';
@@ -69,6 +71,32 @@ import { annotateBridgeSummary, summarizeBridgeResponse } from './subagent.js';
 const REQUEST_SOURCE = 'cli';
 const TEST_TIMEOUT_ENV = 'BBX_CLIENT_REQUEST_TIMEOUT_MS';
 const TEST_DETECTED_MCP_CLIENTS_ENV = 'BBX_TEST_DETECTED_MCP_CLIENTS';
+const REMOTE_ENV = 'BBX_REMOTE';
+
+/**
+ * Commands that only make sense against the local machine (setup, daemon
+ * lifecycle, and config management). The explicit --remote flag is rejected
+ * for these; the ambient BBX_REMOTE env var is ignored.
+ *
+ * @type {ReadonlySet<string>}
+ */
+const LOCAL_ONLY_COMMANDS = new Set([
+  'help',
+  '--help',
+  '-h',
+  '--version',
+  '-v',
+  'skill',
+  'install',
+  'uninstall',
+  'install-skill',
+  'install-mcp',
+  'mcp',
+  'proxy',
+  'remote',
+  'doctor',
+  'restart',
+]);
 
 /**
  * Read all of stdin as UTF-8 text. Resolves once stdin closes.
@@ -89,7 +117,18 @@ function readStdin() {
   });
 }
 
-const [, , command, ...rest] = process.argv;
+const remoteFlag = extractRemoteFlag(process.argv.slice(2));
+const [command, ...rest] = remoteFlag.rest;
+
+if (remoteFlag.explicit && command && LOCAL_ONLY_COMMANDS.has(command)) {
+  process.stderr.write(`The --remote flag is not supported with "${command}".\n`);
+  process.exit(1);
+}
+
+const remoteDestinationId =
+  command && LOCAL_ONLY_COMMANDS.has(command)
+    ? null
+    : (remoteFlag.remoteId ?? process.env[REMOTE_ENV] ?? null);
 
 if (!command || ['help', '--help', '-h'].includes(command)) {
   printUsage();
@@ -396,23 +435,60 @@ if (command === 'mcp') {
 }
 
 if (command === 'proxy') {
-  await handleProxyCommand(rest);
-  process.exit(0);
+  await runLocalCommand(() => handleProxyCommand(rest));
+  process.exit();
 }
 
 if (command === 'remote') {
-  await handleRemoteCommand(rest);
-  process.exit(0);
+  await runLocalCommand(() => handleRemoteCommand(rest));
+  process.exit();
 }
 
 const clientTimeoutMs = getClientTimeoutOverride();
 applyWindowsTcpTransportDefaults();
-const client = new BridgeClient(
-  clientTimeoutMs ? { defaultTimeoutMs: clientTimeoutMs } : undefined
-);
+const client = await createCliClient();
 
 await main();
 
+/**
+ * Run a local (pre-main) command, converting thrown errors into a friendly
+ * one-line message instead of an unhandled stack trace.
+ *
+ * @param {() => Promise<void>} run
+ * @returns {Promise<void>}
+ */
+async function runLocalCommand(run) {
+  try {
+    await run();
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Create the bridge client for this invocation, honoring the --remote flag
+ * and BBX_REMOTE env var. Exits with a friendly error when the destination
+ * is not configured.
+ *
+ * @returns {Promise<import('./client.js').BridgeClient>}
+ */
+async function createCliClient() {
+  try {
+    return await createBridgeClientForDestination(
+      remoteDestinationId,
+      clientTimeoutMs ? { defaultTimeoutMs: clientTimeoutMs } : {}
+    );
+  } catch (error) {
+    printJson({
+      ok: false,
+      summary: `ERROR: ${error instanceof Error ? error.message : String(error)}`,
+      evidence: null,
+    });
+    process.exit(1);
+  }
+}
+
 async function main() {
   try {
     if (command === 'status') {
@@ -859,7 +935,12 @@ async function handleProxyCommand(args) {
   const [subcommand, ...restArgs] = args;
   if (subcommand === 'enable') {
     const options = parseProxyEnableArgs(restArgs);
-    const token = options.token ?? randomUUID();
+    const existing = readProxyConfig();
+    const { port, bindHost, token, tokenSource } = resolveProxyEnableSettings(
+      existing,
+      options,
+      randomUUID
+    );
     await writeBridgeAuthToken(token);
     const configPath = getProxyConfigPath();
     await fs.promises.mkdir(path.dirname(configPath), { recursive: true });
@@ -868,8 +949,8 @@ async function handleProxyCommand(args) {
       `${JSON.stringify(
         {
           enabled: true,
-          port: options.port,
-          bindHost: options.bindHost,
+          port,
+          bindHost,
           token,
         },
         null,
@@ -878,14 +959,22 @@ async function handleProxyCommand(args) {
       { encoding: 'utf8', mode: 0o600 }
     );
     const result = await restartBridgeDaemon();
-    const exampleHost = getProxyExampleHost(options.bindHost);
-    process.stdout.write(
-      [
-        `Browser Bridge proxy enabled on ${options.bindHost}:${options.port}.`,
-        '',
-        `Token: ${token}`,
-        `Config: ${configPath}`,
-        `Daemon: ${result.previouslyRunning ? 'restarted' : 'started'} (pid ${result.pid})`,
+    const exampleHost = getProxyExampleHost(bindHost);
+    const tokenNote =
+      tokenSource === 'existing'
+        ? ' (unchanged — already-configured clients keep working; pass --rotate-token to generate a new secret)'
+        : tokenSource === 'generated' && existing
+          ? ' (rotated — update every configured client with `bbx remote add`)'
+          : '';
+    const lines = [
+      `Browser Bridge proxy enabled on ${bindHost}:${port}.`,
+      '',
+      `Token: ${token}${tokenNote}`,
+      `Config: ${configPath}`,
+      `Daemon: ${result.previouslyRunning ? 'restarted' : 'started'} (pid ${result.pid})`,
+    ];
+    if (tokenSource !== 'existing') {
+      lines.push(
         '',
         'On your dev machine, add this remote:',
         '',
@@ -893,10 +982,11 @@ async function handleProxyCommand(args) {
         '',
         'Example:',
         '',
-        `bbx remote add remote-bbx ${exampleHost}:${options.port} --token ${token}`,
-        '',
-      ].join('\n')
-    );
+        `bbx remote add remote-bbx ${exampleHost}:${port} --token ${token}`
+      );
+    }
+    lines.push('');
+    process.stdout.write(lines.join('\n'));
     return;
   }
 
@@ -916,10 +1006,12 @@ async function handleProxyCommand(args) {
       process.stdout.write('Browser Bridge proxy is disabled.\n');
       return;
     }
+    const reachable = await pingExistingDaemon(createTcpBridgeTransport(config.port, '127.0.0.1'));
     process.stdout.write(
       [
         `Browser Bridge proxy is enabled on ${config.bindHost}:${config.port}.`,
         `Config: ${getProxyConfigPath()}`,
+        `Daemon: ${reachable ? 'reachable' : 'not reachable'} on 127.0.0.1:${config.port}`,
         '',
       ].join('\n')
     );
@@ -930,12 +1022,15 @@ async function handleProxyCommand(args) {
 }
 
 /**
+ * Parse `bbx proxy enable` flags. Values stay undefined when not passed so an
+ * existing proxy config can be reused instead of silently reset to defaults.
+ *
  * @param {string[]} args
- * @returns {{ port: number, bindHost: string, token?: string }}
+ * @returns {import('./remotes.js').ProxyEnableOptions}
  */
 function parseProxyEnableArgs(args) {
-  /** @type {{ port: number, bindHost: string, token?: string }} */
-  const options = { port: 9223, bindHost: '0.0.0.0' };
+  /** @type {import('./remotes.js').ProxyEnableOptions} */
+  const options = {};
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === '--port') {
@@ -956,9 +1051,16 @@ function parseProxyEnableArgs(args) {
       }
       continue;
     }
+    if (arg === '--rotate-token') {
+      options.rotateToken = true;
+      continue;
+    }
     throw new Error(`Unknown proxy enable option "${arg}".`);
   }
-  if (options.port < 1 || options.port > 65535) {
+  if (options.token && options.rotateToken) {
+    throw new Error('Use either --token or --rotate-token, not both.');
+  }
+  if (options.port !== undefined && (options.port < 1 || options.port > 65535)) {
     throw new Error('port must be an integer between 1 and 65535.');
   }
   return options;
@@ -1049,10 +1151,23 @@ async function handleRemoteCommand(args) {
     try {
       await remoteClient.connect();
       const response = await remoteClient.request({ method: 'health.ping' });
+      if (response.ok) {
+        const health = /** @type {{ extensionConnected?: boolean }} */ (response.result);
+        process.stdout.write(
+          `Remote destination "${name}" is reachable (extension ${
+            health.extensionConnected === true ? 'connected' : 'not connected'
+          }).\n`
+        );
+      } else {
+        process.exitCode = 1;
+        process.stdout.write(`Remote destination "${name}" failed: ${response.error.message}\n`);
+      }
+    } catch (error) {
+      process.exitCode = 1;
       process.stdout.write(
-        response.ok
-          ? `Remote destination "${name}" is reachable.\n`
-          : `Remote destination "${name}" failed: ${response.error.message}\n`
+        `Remote destination "${name}" is not reachable: ${
+          error instanceof Error ? error.message : String(error)
+        }\n`
       );
     } finally {
       await remoteClient.close();
@@ -1214,7 +1329,7 @@ function printCallResponse(response) {
 }
 
 function printUsage() {
-  const blocks = ['Usage: bbx <command> [args]'];
+  const blocks = ['Usage: bbx [--remote <name>] <command> [args]'];
   for (const section of CLI_HELP_SECTIONS) {
     blocks.push('', `${section.title}:`);
     blocks.push(...section.lines.map((line) => `  ${line}`));
@@ -1297,6 +1412,28 @@ async function parseCallCommand(args) {
   throw new Error('Usage: call [--tab <tabId>] <method> [paramsJson]');
 }
 
+/**
+ * Extract the global --remote flag from anywhere in the argument list.
+ * Exits with a usage error when the flag is present without a value.
+ *
+ * @param {string[]} args
+ * @returns {{ remoteId: string | null, explicit: boolean, rest: string[] }}
+ */
+function extractRemoteFlag(args) {
+  const rest = [...args];
+  const index = rest.indexOf('--remote');
+  if (index === -1) {
+    return { remoteId: null, explicit: false, rest };
+  }
+  const remoteId = rest[index + 1];
+  if (!remoteId || remoteId.startsWith('--')) {
+    process.stderr.write('--remote requires a destination name (see `bbx remote list`).\n');
+    process.exit(1);
+  }
+  rest.splice(index, 2);
+  return { remoteId, explicit: true, rest };
+}
+
 /**
  * @param {string[]} args
  * @returns {{ tabId: number | null, rest: string[] }}

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

@@ -257,10 +257,13 @@ export const CLI_HELP_SECTIONS = Object.freeze([
       'bbx status                                                         Check bridge connection',
       'bbx doctor                                                         Diagnose install, daemon, extension, and access readiness',
       'bbx restart                                                        Restart the local Browser Bridge daemon',
-      'bbx proxy enable [--port 9223] [--bind-host 0.0.0.0]              Enable opt-in TCP proxy mode and print a token',
+      'bbx proxy enable [--port 9223] [--bind-host 0.0.0.0] [--rotate-token]  Enable opt-in TCP proxy mode (idempotent: re-running keeps settings and token)',
       'bbx proxy disable                                                  Disable proxy mode and restart the daemon',
+      'bbx proxy status                                                   Show proxy config and daemon reachability',
       'bbx remote add <name> <host:port> --token <token>                  Add a remote Browser Bridge destination (example: remote-bbx 192.168.56.20:9223)',
       'bbx remote list                                                    List remote destinations',
+      'bbx remote test <name>                                             Ping a remote destination',
+      'bbx remote remove <name>                                           Remove a remote destination',
       'bbx access-request                                                 Request Browser Bridge access for the focused window',
       'bbx logs                                                           Recent bridge logs',
       'bbx tabs                                                           List available tabs',
@@ -277,6 +280,7 @@ export const CLI_HELP_SECTIONS = Object.freeze([
       'bbx call [--tab <tabId>] <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 '[{method,params,tabId?},...]'                           Parallel method calls",
+      'Every bridge command accepts --remote <name> (or BBX_REMOTE env) to target a remote destination from `bbx remote list`.',
       'Advanced bridge params stay available through `bbx call`, even when shortcuts expose only the common case.',
       'For open-ended investigation, start with `bbx batch` on `page.get_state`, `dom.query`, and `page.get_text` before any screenshot or CDP call.',
       '',

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

@@ -179,6 +179,34 @@ export async function listBridgeDestinations() {
   ];
 }
 
+/**
+ * @typedef {{ port?: number, bindHost?: string, token?: string, rotateToken?: boolean }} ProxyEnableOptions
+ */
+
+/**
+ * Merge `bbx proxy enable` options with an existing proxy config so re-running
+ * the command is idempotent: the port, bind host, and shared secret are
+ * preserved unless explicitly overridden. The token only changes when passed
+ * via --token or regenerated via --rotate-token, so already-configured remote
+ * clients keep working across repeated enables.
+ *
+ * @param {{ port: number, bindHost: string, token?: string } | null} existing
+ * @param {ProxyEnableOptions} options
+ * @param {() => string} generateToken
+ * @returns {{ port: number, bindHost: string, token: string, tokenSource: 'explicit' | 'existing' | 'generated' }}
+ */
+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';
+  if (options.token) {
+    return { port, bindHost, token: options.token, tokenSource: 'explicit' };
+  }
+  if (!options.rotateToken && existing?.token) {
+    return { port, bindHost, token: existing.token, tokenSource: 'existing' };
+  }
+  return { port, bindHost, token: generateToken(), tokenSource: 'generated' };
+}
+
 /**
  * @param {string | null | undefined} destinationId
  * @param {{ defaultTimeoutMs?: number }} [options={}]

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

@@ -132,6 +132,67 @@ 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]
@@ -140,7 +201,8 @@ export function summarizeToolError(error) {
 export async function withToolClient(callback, options = {}) {
   try {
     if (!options.destinationId) {
-      return await withBridgeClient(callback);
+      const result = await withBridgeClient(callback);
+      return shouldTryRemoteFallback(result) ? await tryRemoteFallback(callback, result) : result;
     }
     const client = await createBridgeClientForDestination(options.destinationId);
     await client.connect();

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

@@ -67,10 +67,31 @@ export {
 const HOME_DIR = os.homedir();
 
 /**
+ * @param {{ destinationId?: string }} [args]
  * @returns {Promise<ToolResult>}
  */
-export async function handleStatusTool() {
+export async function handleStatusTool(args = {}) {
   try {
+    const requestedDestinationId =
+      typeof args.destinationId === 'string' ? args.destinationId : null;
+    if (requestedDestinationId && requestedDestinationId !== 'local') {
+      const destination = (await getBridgeDestinations()).find(
+        (entry) => entry.id === requestedDestinationId
+      );
+      const result = await callRemoteHealth(requestedDestinationId);
+      return createToolResult(
+        result.reachable
+          ? `Browser Bridge destination "${requestedDestinationId}" is reachable.`
+          : `Browser Bridge destination "${requestedDestinationId}" is not reachable.`,
+        {
+          ok: result.reachable === true,
+          destination: destination ?? { id: requestedDestinationId, local: false },
+          ...result,
+        },
+        result.reachable !== true
+      );
+    }
+
     const report = await getDoctorReport();
     const destinations = await Promise.all(
       (await getBridgeDestinations()).map(async (destination) => {
@@ -147,7 +168,7 @@ export async function handleSetupTool(args) {
 }
 
 /**
- * @param {{ limit?: number, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * @param {{ limit?: number, budgetPreset?: 'quick' | 'normal' | 'deep', destinationId?: string }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleLogTool(args) {
@@ -163,6 +184,7 @@ export async function handleLogTool(args) {
     },
     {
       tokenBudget: getToolTokenBudget(normalizedArgs),
+      destinationId: typeof args.destinationId === 'string' ? args.destinationId : null,
     }
   );
 }

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

@@ -149,6 +149,7 @@ export function createBridgeMcpServer() {
           .enum(['quick', 'normal', 'deep'])
           .optional()
           .describe(BUDGET_PRESET_DESCRIPTION),
+        destinationId: z.string().optional().describe(DESTINATION_ID_DESCRIPTION),
       },
     },
     handleLogTool
@@ -704,7 +705,9 @@ export function createBridgeMcpServer() {
       title: 'Request Browser Bridge Access',
       description:
         'Request window access for Browser Bridge. Surfaces an Enable prompt in the extension popup or side panel. Use once per window; if access is already pending, ask the user to enable that window instead of requesting again.',
-      inputSchema: {},
+      inputSchema: {
+        destinationId: z.string().optional().describe(DESTINATION_ID_DESCRIPTION),
+      },
     },
     handleAccessTool
   );

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

@@ -638,6 +638,7 @@ export class BridgeDaemon {
           extensionConnected: false,
           socketPath: this.socketPath,
           transport: formatBridgeTransport(this.transport),
+          proxy: this.getProxyStatusPayload(),
           connectedExtensions: [],
           daemon_supported_versions: SUPPORTED_VERSIONS,
           ...getVersionNegotiationPayload(request.meta?.protocol_version),
@@ -878,6 +879,24 @@ export class BridgeDaemon {
     socket.__accessEnabled = accessEnabled;
   }
 
+  /**
+   * Structured remote-exposure status for health payloads. The proxy counts
+   * as enabled only when the daemon listens on a TCP address other than
+   * loopback, i.e. agents on other machines can reach it.
+   *
+   * @returns {{ enabled: boolean, endpoint: string | null }}
+   */
+  getProxyStatusPayload() {
+    if (this.transport.type !== 'tcp') {
+      return { enabled: false, endpoint: null };
+    }
+    const bindHost = this.transport.bindHost ?? this.transport.host;
+    const isLoopback = bindHost === '127.0.0.1' || bindHost === '::1' || bindHost === 'localhost';
+    return isLoopback
+      ? { enabled: false, endpoint: null }
+      : { enabled: true, endpoint: `${bindHost}:${this.transport.port}` };
+  }
+
   /**
    * @param {ClientSocket} socket
    * @param {DaemonMessage} message
@@ -930,6 +949,7 @@ export class BridgeDaemon {
                 .../** @type {Record<string, unknown>} */ (responseMessage.result),
                 daemonVersion: DAEMON_VERSION,
                 daemon_supported_versions: SUPPORTED_VERSIONS,
+                proxy: this.getProxyStatusPayload(),
               },
               {
                 ...responseMessage.meta,

package/skills/browser-bridge/SKILL.md

@@ -34,6 +34,8 @@ bbx tab-activate <tabId>    # bring a tab to the foreground
 bbx skill                   # live runtime presets + limits
 ```
 
+Use the globally installed `bbx` command or `node packages/agent-client/src/cli.js ...` for live readiness checks from this repository. Avoid `rtk npm exec -- bbx status` as a health signal: that path can restart/replace the daemon and report `Extension: disconnected` before Chrome reconnects. If it happens, wait a few seconds and verify with `bbx status`.
+
 ### Inspect & Find
 
 ```bash
@@ -89,6 +91,19 @@ bbx screenshot <ref> [outPath]       # capture partial element screenshot
 bbx call screenshot.capture_full_page '{}' # raw base64; avoid unless document context matters
 ```
 
+### Remote Destinations
+
+Every bridge command accepts `--remote <name>` (or `BBX_REMOTE=<name>` env) to target a browser on another machine registered with `bbx remote add`:
+
+```bash
+bbx remote list                      # configured remote destinations
+bbx remote test <name>               # ping a remote through the proxy
+bbx tabs --remote <name>             # any bridge command works with --remote
+bbx dom-query "#app" --remote <name>
+```
+
+In MCP mode, pass `destinationId` on any browser tool call instead; `browser_status` lists all destinations with reachability. Only use remotes the user has configured; local remains the default.
+
 ## Access Flow
 
 Browser Bridge access is window-scoped. The user turns it on once for the current browser window in the popup or side panel.