@btraut/browser-bridge 0.13.0 → 0.13.1

package/extension/dist/background.js

@@ -1,56 +1,5 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// packages/shared/dist/contract-version.js
-var require_contract_version = __commonJS({
-  "packages/shared/dist/contract-version.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.resolveContractVersionMismatch = exports.DRIVE_WS_PROTOCOL_VERSION = exports.HTTP_CONTRACT_VERSION = exports.HTTP_CONTRACT_VERSION_HEADER = void 0;
-    exports.HTTP_CONTRACT_VERSION_HEADER = "x-browser-bridge-contract-version";
-    exports.HTTP_CONTRACT_VERSION = "2026-02-17.1";
-    exports.DRIVE_WS_PROTOCOL_VERSION = "2026-02-17.1";
-    var resolveContractVersionMismatch = (receivedVersion) => {
-      if (!receivedVersion || receivedVersion.trim().length === 0) {
-        return void 0;
-      }
-      if (receivedVersion === exports.HTTP_CONTRACT_VERSION) {
-        return void 0;
-      }
-      return {
-        expected: exports.HTTP_CONTRACT_VERSION,
-        received: receivedVersion
-      };
-    };
-    exports.resolveContractVersionMismatch = resolveContractVersionMismatch;
-  }
-});
-
-// packages/extension/src/background.ts
-var import_contract_version = __toESM(require_contract_version());
+// packages/shared/src/contract-version.ts
+var DRIVE_WS_PROTOCOL_VERSION = "2026-02-17.1";
 
 // packages/extension/src/error-sanitizer.ts
 var TRAILING_PUNCTUATION_RE = /[.,;:!?]+$/;
@@ -487,6 +436,54 @@ var PermissionPromptController = class {
   }
 };
 
+// packages/extension/src/drive-reliability.ts
+var TRANSIENT_TAB_CHANNEL_ERROR_PATTERNS = [
+  "receiving end does not exist",
+  "message channel closed before a response was received",
+  "the message port closed before a response was received",
+  "extension port is moved into back/forward cache"
+];
+var TAB_CHANNEL_RETRY_DELAYS_MS = [120, 200, 320, 500, 750, 1e3, 1200];
+var normalizePathname = (pathname) => {
+  if (pathname.length === 0) {
+    return "/";
+  }
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.slice(0, -1);
+  }
+  return pathname;
+};
+var isTransientTabChannelError = (message) => {
+  if (typeof message !== "string") {
+    return false;
+  }
+  const normalized = message.toLowerCase();
+  return TRANSIENT_TAB_CHANNEL_ERROR_PATTERNS.some(
+    (pattern) => normalized.includes(pattern)
+  );
+};
+var getTabChannelRetryDelayMs = (attempt) => {
+  if (!Number.isInteger(attempt) || attempt < 1) {
+    return void 0;
+  }
+  return TAB_CHANNEL_RETRY_DELAYS_MS[attempt - 1];
+};
+var isLikelyNavigationCommitted = (requestedUrl, tabUrl) => {
+  if (typeof requestedUrl !== "string" || typeof tabUrl !== "string") {
+    return false;
+  }
+  if (requestedUrl === tabUrl) {
+    return true;
+  }
+  try {
+    const requested = new URL(requestedUrl);
+    const actual = new URL(tabUrl);
+    return requested.origin === actual.origin && normalizePathname(requested.pathname) === normalizePathname(actual.pathname) && requested.search === actual.search;
+  } catch {
+    return requestedUrl === tabUrl;
+  }
+};
+
 // packages/extension/src/connection-state.ts
 var toIso = (ms) => new Date(ms).toISOString();
 var ConnectionStateTracker = class {
@@ -1166,12 +1163,18 @@ var sendToTab = async (tabId, action, params, options) => {
       chrome.tabs.sendMessage(tabId, message, (response) => {
         const error = chrome.runtime.lastError;
         if (error) {
+          const retryable = isTransientTabChannelError(error.message);
           finish({
             ok: false,
             error: {
               code: "EVALUATION_FAILED",
               message: error.message,
-              retryable: false
+              retryable,
+              ...retryable ? {
+                details: {
+                  reason: "transient_tab_channel_error"
+                }
+              } : {}
             }
           });
           return;
@@ -1191,27 +1194,20 @@ var sendToTab = async (tabId, action, params, options) => {
       });
     });
   };
-  const MAX_ATTEMPTS = 5;
-  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+  for (let attempt = 1; ; attempt += 1) {
     const result = await attemptSend();
     if (result.ok) {
       return result;
     }
-    const message = result.error?.message;
-    const isNoReceiver = typeof message === "string" && message.toLowerCase().includes("receiving end does not exist");
-    if (!isNoReceiver || attempt === MAX_ATTEMPTS) {
+    if (!isTransientTabChannelError(result.error?.message)) {
       return result;
     }
-    await delayMs(200);
-  }
-  return {
-    ok: false,
-    error: {
-      code: "INTERNAL",
-      message: "Failed to send message to content script.",
-      retryable: false
+    const retryDelayMs = getTabChannelRetryDelayMs(attempt);
+    if (retryDelayMs === void 0) {
+      return result;
     }
-  };
+    await delayMs(retryDelayMs);
+  }
 };
 var refreshAgentTabBranding = async (tabId) => {
   const result = await sendToTab(
@@ -1494,7 +1490,7 @@ var DriveSocket = class {
     }
     const params = {
       version: manifest.version,
-      protocol_version: import_contract_version.DRIVE_WS_PROTOCOL_VERSION,
+      protocol_version: DRIVE_WS_PROTOCOL_VERSION,
       capabilities: buildNegotiatedCapabilities(debuggerCapabilityEnabled),
       core_host: endpoint.host,
       core_port: endpoint.port,
@@ -1817,26 +1813,38 @@ var DriveSocket = class {
             tabId = await getDefaultTabId();
           }
           const waitMode = params.wait === "none" || params.wait === "domcontentloaded" ? params.wait : "domcontentloaded";
+          const domContentLoadedSignal = waitMode === "domcontentloaded" ? waitForDomContentLoaded(tabId, 3e4) : null;
+          const warnings = [];
           await wrapChromeVoid(
             (callback) => chrome.tabs.update(tabId, { url }, () => callback())
           );
           markTabActive(tabId);
-          if (waitMode === "domcontentloaded") {
+          if (domContentLoadedSignal) {
             try {
-              await waitForDomContentLoaded(tabId, 3e4);
+              await domContentLoadedSignal;
             } catch (error) {
-              respondError({
-                code: "TIMEOUT",
-                message: error instanceof Error ? error.message : "Timed out waiting.",
-                retryable: true
-              });
-              return;
+              const tab = await getTab(tabId).catch(() => void 0);
+              if (tab && isLikelyNavigationCommitted(url, tab.url ?? void 0)) {
+                warnings.push(
+                  "Timed out waiting for DOMContentLoaded, but the tab URL already updated to the requested target."
+                );
+              } else {
+                respondError({
+                  code: "TIMEOUT",
+                  message: error instanceof Error ? error.message : "Timed out waiting.",
+                  retryable: true
+                });
+                return;
+              }
             }
           }
           if (tabId === agentTabId) {
             void refreshAgentTabBranding(tabId);
           }
-          respondOk({ ok: true });
+          respondOk({
+            ok: true,
+            ...warnings.length > 0 ? { warnings } : {}
+          });
           return;
         }
         case "drive.go_back":
@@ -1882,14 +1890,18 @@ var DriveSocket = class {
             }
           } catch {
             if (!result.ok) {
-              respondError(result.error);
+              respondError({
+                ...result.error
+              });
               return;
             }
           }
           if (tabId === agentTabId) {
             void refreshAgentTabBranding(tabId);
           }
-          respondOk({ ok: true });
+          respondOk({
+            ok: true
+          });
           return;
         }
         case "drive.tab_list": {