@browserbridge/bbx 1.6.4 → 1.7.1

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

@@ -24,9 +24,10 @@ import {
   DEFAULT_DAEMON_PENDING_TIMEOUT_MS,
   DEFAULT_LOG_TAIL_LIMIT,
   ERROR_CODES,
+  getProtocolVersion,
+  getSupportedProtocolVersions,
   parseJsonLines,
-  PROTOCOL_VERSION,
-  SUPPORTED_VERSIONS,
+  setProtocolPackageVersion,
   validateBridgeRequest,
 } from '../../protocol/src/index.js';
 import {
@@ -45,6 +46,7 @@ import { normalizeDaemonLogger } from './daemon-logger.js';
 import { writeJsonLine } from './framing.js';
 
 const DAEMON_VERSION = loadDaemonVersion();
+setProtocolPackageVersion(DAEMON_VERSION);
 
 /** @typedef {import('../../protocol/src/types.js').BridgeRequest} BridgeRequest */
 /** @typedef {import('../../protocol/src/types.js').SetupInstallParams} SetupInstallParams */
@@ -89,14 +91,15 @@ function compareProtocolVersions(left, right) {
  * @returns {{ supported_versions: readonly string[], deprecated_since?: string, migration_hint?: string }}
  */
 function getVersionNegotiationPayload(requestedVersion) {
-  const latestSupported = SUPPORTED_VERSIONS[0];
-  if (!requestedVersion || !latestSupported || SUPPORTED_VERSIONS.includes(requestedVersion)) {
-    return { supported_versions: SUPPORTED_VERSIONS };
+  const supportedVersions = getSupportedProtocolVersions();
+  const latestSupported = supportedVersions[0];
+  if (!requestedVersion || !latestSupported || supportedVersions.includes(requestedVersion)) {
+    return { supported_versions: supportedVersions };
   }
 
   const localIsNewer = compareProtocolVersions(latestSupported, requestedVersion) > 0;
   return {
-    supported_versions: SUPPORTED_VERSIONS,
+    supported_versions: supportedVersions,
     ...(localIsNewer ? { deprecated_since: latestSupported } : {}),
     migration_hint: localIsNewer
       ? `Browser Bridge daemon is newer than the client protocol ${requestedVersion}. Restart or update the Browser Bridge CLI/npm package to ${latestSupported} or later.`
@@ -638,8 +641,9 @@ export class BridgeDaemon {
           extensionConnected: false,
           socketPath: this.socketPath,
           transport: formatBridgeTransport(this.transport),
+          proxy: this.getProxyStatusPayload(),
           connectedExtensions: [],
-          daemon_supported_versions: SUPPORTED_VERSIONS,
+          daemon_supported_versions: getSupportedProtocolVersions(),
           ...getVersionNegotiationPayload(request.meta?.protocol_version),
         });
         await writeJsonLine(socket, { type: 'agent.response', response });
@@ -878,6 +882,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
@@ -929,7 +951,8 @@ export class BridgeDaemon {
                 ...getVersionNegotiationPayload(pending.protocolVersion),
                 .../** @type {Record<string, unknown>} */ (responseMessage.result),
                 daemonVersion: DAEMON_VERSION,
-                daemon_supported_versions: SUPPORTED_VERSIONS,
+                daemon_supported_versions: getSupportedProtocolVersions(),
+                proxy: this.getProxyStatusPayload(),
               },
               {
                 ...responseMessage.meta,
@@ -1141,7 +1164,7 @@ export async function pingExistingDaemon(transport) {
             method: 'health.ping',
             tab_id: null,
             params: {},
-            meta: { protocol_version: PROTOCOL_VERSION, token_budget: null },
+            meta: { protocol_version: getProtocolVersion(), token_budget: null },
           },
         })}\n`
       );

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

@@ -125,7 +125,7 @@ export async function runNativeHost({
     socket = await connectWithBootstrap(resolvedTransport);
   } catch (error) {
     await writeNativeMessageQueued({
-      type: 'agent.response',
+      type: 'host.bridge_response',
       response: createFailure(
         'native_bootstrap',
         ERROR_CODES.NATIVE_HOST_UNAVAILABLE,

package/packages/protocol/src/protocol.js

@@ -82,10 +82,59 @@ import { BRIDGE_METHODS, METHOD_SET, createBridgeMethodGroups } from './registry
 /** @typedef {import('./types.js').WaitForLoadStateParams} WaitForLoadStateParams */
 /** @typedef {import('./types.js').WaitForParams} WaitForParams */
 
-export const PROTOCOL_VERSION = '1.0';
+/** @type {string | null} */
+let protocolPackageVersion = null;
+
+/**
+ * @param {string | null | undefined} packageVersion
+ * @returns {string}
+ */
+export function deriveProtocolVersion(packageVersion) {
+  const match = typeof packageVersion === 'string' ? /^(\d+)\.(\d+)/.exec(packageVersion) : null;
+  return match ? `${match[1]}.${match[2]}` : '0.0';
+}
+
+/**
+ * @returns {string | null}
+ */
+function getRuntimePackageVersion() {
+  const chromeRuntime = /** @type {{ runtime?: { getManifest?: () => { version?: unknown } } }} */ (
+    globalThis.chrome ?? {}
+  ).runtime;
+  const manifestVersion = chromeRuntime?.getManifest?.().version;
+  if (typeof manifestVersion === 'string') {
+    return manifestVersion;
+  }
+
+  const npmPackageVersion = globalThis.process?.env?.npm_package_version;
+  return typeof npmPackageVersion === 'string' ? npmPackageVersion : null;
+}
+
+/**
+ * @param {string | null | undefined} packageVersion
+ * @returns {void}
+ */
+export function setProtocolPackageVersion(packageVersion) {
+  protocolPackageVersion = typeof packageVersion === 'string' ? packageVersion : null;
+}
+
+/**
+ * @returns {string}
+ */
+export function getProtocolVersion() {
+  return deriveProtocolVersion(protocolPackageVersion ?? getRuntimePackageVersion());
+}
+
+/** Snapshot retained for older callers; new code should call getProtocolVersion(). */
+export const PROTOCOL_VERSION = getProtocolVersion();
 
 /** Versions this build can speak. Newest first. */
-export const SUPPORTED_VERSIONS = Object.freeze(['1.0']);
+export function getSupportedProtocolVersions() {
+  return Object.freeze([getProtocolVersion()]);
+}
+
+/** Snapshot retained for older callers; new code should call getSupportedProtocolVersions(). */
+export const SUPPORTED_VERSIONS = getSupportedProtocolVersions();
 
 /**
  * Clamp a numeric value between min and max, falling back to a default.
@@ -122,7 +171,7 @@ export function createRequest({ id, method, tabId = null, params = {}, meta = {}
     tab_id: tabId,
     params,
     meta: {
-      protocol_version: PROTOCOL_VERSION,
+      protocol_version: getProtocolVersion(),
       ...meta,
     },
   });
@@ -141,7 +190,7 @@ export function createSuccess(id, result, meta = {}) {
     result,
     error: null,
     meta: {
-      protocol_version: PROTOCOL_VERSION,
+      protocol_version: getProtocolVersion(),
       ...meta,
     },
   };
@@ -168,7 +217,7 @@ export function createFailure(id, code, message, details = null, meta = {}) {
       ...(recovery && { recovery }),
     },
     meta: {
-      protocol_version: PROTOCOL_VERSION,
+      protocol_version: getProtocolVersion(),
       ...meta,
     },
   };
@@ -238,7 +287,7 @@ export function validateBridgeRequest(request) {
     meta: {
       ...meta,
       protocol_version:
-        typeof meta.protocol_version === 'string' ? meta.protocol_version : PROTOCOL_VERSION,
+        typeof meta.protocol_version === 'string' ? meta.protocol_version : getProtocolVersion(),
       token_budget: typeof meta.token_budget === 'number' ? meta.token_budget : null,
       source: meta.source === 'cli' || meta.source === 'mcp' ? meta.source : undefined,
     },
@@ -842,7 +891,7 @@ export function createRuntimeContext() {
   const methodGroups = createBridgeMethodGroups();
 
   return {
-    v: PROTOCOL_VERSION,
+    v: getProtocolVersion(),
     budgets: {
       quick: {
         n: BUDGET_PRESETS.quick.maxNodes,

package/packages/protocol/src/summary.js

@@ -1,6 +1,11 @@
 // @ts-check
 
-import { estimateSerializedPayloadCost, getCostClass, serializeJsonPayload } from './index.js';
+import {
+  estimateSerializedPayloadCost,
+  getCostClass,
+  getProtocolVersion,
+  serializeJsonPayload,
+} from './index.js';
 
 /** @typedef {import('./types.js').BridgeResponse} BridgeResponse */
 /** @typedef {import('./types.js').BridgeMethod} SummaryMethod */
@@ -692,7 +697,7 @@ export function summarizeBatchErrorItem({ method, tabId, error, durationMs }) {
       message,
       details: null,
     },
-    meta: { protocol_version: '1.0' },
+    meta: { protocol_version: getProtocolVersion() },
   });
   const summary = annotateBridgeSummary(summarizeBridgeResponse(response, method), response);
   return {

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.

package/skills/browser-bridge/references/protocol.md

@@ -348,7 +348,7 @@ bbx call screenshot.capture_full_page '{}'
   "tab_id": 123,
   "method": "dom.query",
   "params": {},
-  "meta": { "protocol_version": "1.0", "token_budget": 1200 }
+  "meta": { "protocol_version": "<package major.minor>", "token_budget": 1200 }
 }
 ```