@browserbridge/bbx 1.6.2 → 1.6.4

package/package.json

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

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

@@ -973,15 +973,20 @@ function getProxyExampleHost(bindHost) {
     return bindHost;
   }
 
-  for (const entries of Object.values(os.networkInterfaces())) {
+  /** @type {string | null} */
+  let firstIpv4 = null;
+  for (const [name, entries] of Object.entries(os.networkInterfaces())) {
     for (const entry of entries ?? []) {
       if (!entry.internal && entry.family === 'IPv4') {
-        return entry.address;
+        if (name.toLowerCase() === 'ethernet 0') {
+          return entry.address;
+        }
+        firstIpv4 ??= entry.address;
       }
     }
   }
 
-  return '<host>';
+  return firstIpv4 ?? '<host>';
 }
 
 /**

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) => {

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

@@ -235,6 +235,9 @@ export function applyWindowsTcpTransportDefaults(env = process.env) {
   if (env[BRIDGE_TCP_PORT_ENV] != null && env[BRIDGE_TCP_PORT_ENV] !== '') {
     return false;
   }
+  if (readProxyConfig(env)) {
+    return false;
+  }
   if (env[BRIDGE_HOME_ENV]) {
     return false;
   }