@btraut/browser-bridge 0.13.0 → 0.13.2

package/CHANGELOG.md

@@ -6,6 +6,23 @@ The format is based on "Keep a Changelog", and this project adheres to Semantic
 
 ## [Unreleased]
 
+## [0.13.2] - 2026-02-18
+
+### Changed
+
+- Maintenance patch release for `0.13.2`.
+
+### Fixed
+
+- MCP adapter readiness tests now model POST/GET health probing correctly, preventing false failures when daemon auto-start is enabled.
+
+## [0.13.1] - 2026-02-18
+
+### Fixed
+
+- Extension packaging now resolves `@btraut/browser-bridge-shared/dist/*` imports from workspace source during zip builds, so release packaging works from clean CI checkouts without prebuilt shared artifacts.
+- Core startup now handles shared-port collisions more clearly (POST/GET health compatibility probe + actionable occupied-port fallback), drive tab messaging retries transient post-navigation channel-closure races more aggressively, `drive.navigate` avoids false timeouts when URL commit succeeds without a DOM event, and diagnostics now surfaces inspect capability + shared-core metadata mismatch checks in one pass.
+
 ## [0.13.0] - 2026-02-18
 
 ### Changed

package/dist/api.js

@@ -41,6 +41,7 @@ var import_express2 = __toESM(require("express"));
 
 // packages/shared/src/core-readiness.ts
 var import_promises = require("node:timers/promises");
+var import_node_net = require("node:net");
 
 // packages/shared/src/logging.ts
 var import_node_fs2 = require("node:fs");
@@ -637,6 +638,27 @@ var DEFAULT_HEALTH_RETRY_MS = 250;
 var DEFAULT_HEALTH_ATTEMPTS = 20;
 var DEFAULT_HEALTH_TIMEOUT_MS = 2e3;
 var DEFAULT_HEALTH_BUDGET_MS = 15e3;
+var DEFAULT_PORT_REACHABILITY_TIMEOUT_MS = 300;
+var isPortReachableDefault = async (runtime) => {
+  return await new Promise((resolve3) => {
+    const socket = new import_node_net.Socket();
+    let settled = false;
+    const finish = (reachable) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve3(reachable);
+    };
+    socket.setTimeout(DEFAULT_PORT_REACHABILITY_TIMEOUT_MS);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", () => finish(false));
+    socket.connect(runtime.port, runtime.host);
+  });
+};
 var resolveTimeoutMs = (timeoutMs) => {
   const candidate = timeoutMs ?? (process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS, 10) : process.env.BROWSER_VISION_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_VISION_CORE_TIMEOUT_MS, 10) : void 0);
   if (candidate === void 0 || candidate === null) {
@@ -702,57 +724,71 @@ var createCoreReadinessController = (options = {}) => {
     baseUrl = `http://${runtime.host}:${runtime.port}`;
   };
   const checkHealth = async () => {
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), healthTimeoutMs);
+    for (const method of ["POST", "GET"]) {
       try {
-        let response;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), healthTimeoutMs);
         try {
-          response = await fetchImpl(`${baseUrl}/health`, {
-            method: "POST",
-            signal: controller.signal
-          });
-        } catch (error) {
-          if (controller.signal.aborted || error instanceof Error && error.name === "AbortError") {
-            logger.warn(`${logPrefix}.health.timeout`, {
+          let response;
+          try {
+            response = await fetchImpl(`${baseUrl}/health`, {
+              method,
+              signal: controller.signal
+            });
+          } catch (error) {
+            if (controller.signal.aborted || error instanceof Error && error.name === "AbortError") {
+              logger.warn(`${logPrefix}.health.timeout`, {
+                base_url: baseUrl,
+                method,
+                timeout_ms: healthTimeoutMs
+              });
+              continue;
+            }
+            logger.warn(`${logPrefix}.health.fetch_failed`, {
               base_url: baseUrl,
-              timeout_ms: healthTimeoutMs
+              method,
+              error
             });
-            return false;
+            throw error;
+          }
+          if (!response.ok) {
+            logger.warn(`${logPrefix}.health.non_ok`, {
+              base_url: baseUrl,
+              method,
+              status: response.status
+            });
+            continue;
+          }
+          const data = await response.json().catch(() => null);
+          const ok = Boolean(data?.ok);
+          if (ok) {
+            if (method === "GET") {
+              logger.info(`${logPrefix}.health.compat_probe`, {
+                base_url: baseUrl,
+                method
+              });
+            }
+            return true;
           }
-          logger.warn(`${logPrefix}.health.fetch_failed`, {
-            base_url: baseUrl,
-            error
-          });
-          throw error;
-        }
-        if (!response.ok) {
-          logger.warn(`${logPrefix}.health.non_ok`, {
-            base_url: baseUrl,
-            status: response.status
-          });
-          return false;
-        }
-        const data = await response.json().catch(() => null);
-        const ok = Boolean(data?.ok);
-        if (!ok) {
           logger.warn(`${logPrefix}.health.not_ready`, {
-            base_url: baseUrl
+            base_url: baseUrl,
+            method
           });
+        } finally {
+          clearTimeout(timeout);
         }
-        return ok;
-      } finally {
-        clearTimeout(timeout);
+      } catch (error) {
+        logger.warn(`${logPrefix}.health.error`, {
+          base_url: baseUrl,
+          method,
+          error
+        });
       }
-    } catch (error) {
-      logger.warn(`${logPrefix}.health.error`, {
-        base_url: baseUrl,
-        error
-      });
-      return false;
     }
+    return false;
   };
   const ensureCoreRunning = async () => {
+    const portReachabilityCheck = options.portReachabilityCheck ?? isPortReachableDefault;
     refreshRuntime();
     if (await checkHealth()) {
       logger.debug(`${logPrefix}.ensure_ready.already_running`, {
@@ -793,6 +829,21 @@ var createCoreReadinessController = (options = {}) => {
       health_budget_ms: healthBudgetMs,
       health_timeout_ms: healthTimeoutMs
     });
+    let portOccupied = false;
+    try {
+      portOccupied = await portReachabilityCheck(runtime);
+    } catch (error) {
+      logger.warn(`${logPrefix}.ensure_ready.port_probe_failed`, {
+        host: runtime.host,
+        port: runtime.port,
+        error
+      });
+    }
+    if (portOccupied) {
+      throw new Error(
+        `Core daemon failed to start on ${runtime.host}:${runtime.port}. A process is already listening on this port but did not pass Browser Bridge health checks. Retry with --no-daemon to reuse it, or enable isolated mode (BROWSER_BRIDGE_ISOLATED_MODE=1) for per-worktree ports.`
+      );
+    }
     throw new Error(
       `Core daemon failed to start on ${runtime.host}:${runtime.port}.`
     );
@@ -4703,6 +4754,13 @@ var endpointLabel = (endpoint) => {
   }
   return "unknown";
 };
+var readCapability = (capabilities, name) => {
+  if (!capabilities) {
+    return void 0;
+  }
+  const candidate = capabilities[name];
+  return typeof candidate === "boolean" ? candidate : void 0;
+};
 var hasEndpoint = (endpoint) => Boolean(
   endpoint && typeof endpoint.host === "string" && endpoint.host.length > 0 && typeof endpoint.port === "number" && Number.isFinite(endpoint.port)
 );
@@ -4781,6 +4839,23 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
       }
     });
   }
+  if (callerEndpoint?.metadataPath && coreEndpoint?.metadataPath) {
+    const matches = callerEndpoint.metadataPath === coreEndpoint.metadataPath;
+    checks.push({
+      name: "runtime.caller.metadata_path_match",
+      ok: matches,
+      message: matches ? "Caller metadata path matches the active core runtime metadata path." : "Caller metadata path differs from core runtime metadata path (shared core across worktrees).",
+      details: {
+        caller_metadata_path: callerEndpoint.metadataPath,
+        core_metadata_path: coreEndpoint.metadataPath
+      }
+    });
+    if (!matches) {
+      warnings.push(
+        "CLI is talking to a core process started from a different worktree metadata path. If daemon auto-start fails, retry with --no-daemon or enable isolated mode."
+      );
+    }
+  }
   if (extensionConnected && hasEndpoint(coreEndpoint) && hasEndpoint(extensionEndpoint)) {
     const matches = coreEndpoint.host === extensionEndpoint.host && coreEndpoint.port === extensionEndpoint.port;
     checks.push({
@@ -4798,6 +4873,49 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
       }
     });
   }
+  if (extensionConnected) {
+    const capabilityNegotiated = context.runtime?.extension?.capabilityNegotiated ?? false;
+    const capabilities = context.runtime?.extension?.capabilities;
+    const driveNavigateCapability = readCapability(
+      capabilities,
+      "drive.navigate"
+    );
+    const inspectAttachCapability = readCapability(
+      capabilities,
+      "debugger.attach"
+    );
+    const inspectCommandCapability = readCapability(
+      capabilities,
+      "debugger.command"
+    );
+    checks.push({
+      name: "runtime.extension.capability_negotiated",
+      ok: capabilityNegotiated,
+      message: capabilityNegotiated ? "Extension capability negotiation completed." : "Extension capability negotiation is incomplete; action availability may be stale."
+    });
+    checks.push({
+      name: "drive.capability",
+      ok: driveNavigateCapability !== false,
+      message: driveNavigateCapability === false ? "Drive actions are disabled by extension capability negotiation." : "Drive actions are available.",
+      details: driveNavigateCapability === void 0 ? { capability: "drive.navigate", state: "unknown" } : { capability: "drive.navigate", enabled: driveNavigateCapability }
+    });
+    const inspectEnabled = inspectAttachCapability === true && inspectCommandCapability === true;
+    checks.push({
+      name: "inspect.capability",
+      ok: capabilityNegotiated && inspectEnabled,
+      message: capabilityNegotiated && inspectEnabled ? "Inspect debugger capability is enabled." : capabilityNegotiated ? "Inspect debugger capability is disabled in extension options." : "Inspect capability is unknown until extension capability negotiation completes.",
+      details: {
+        required_capabilities: ["debugger.attach", "debugger.command"],
+        debugger_attach: inspectAttachCapability,
+        debugger_command: inspectCommandCapability
+      }
+    });
+    if (capabilityNegotiated && !inspectEnabled) {
+      warnings.push(
+        "Inspect commands require debugger capability. Enable debugger-based inspect in extension options to use inspect.* routes."
+      );
+    }
+  }
   const callerVersion = context.runtime?.caller?.process?.version;
   const extensionVersion = extensionConnected ? context.runtime?.extension?.version : void 0;
   if (callerVersion && extensionVersion) {