npm - @btraut/browser-bridge - Versions diffs - 0.8.0 → 0.9.0 - Mend

@btraut/browser-bridge 0.8.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/CHANGELOG.md +24 -0
package/README.md +41 -4
package/dist/api.js +3926 -3239
package/dist/api.js.map +4 -4
package/dist/index.js +1027 -142
package/dist/index.js.map +4 -4
package/extension/dist/background.js +232 -38
package/extension/dist/background.js.map +2 -2
package/extension/dist/content.js +6 -2
package/extension/dist/content.js.map +2 -2
package/extension/dist/options-ui.js +59 -1
package/extension/dist/options-ui.js.map +2 -2
package/extension/manifest.json +1 -1
package/package.json +1 -1
package/skills/browser-bridge/skill.json +1 -1

package/extension/dist/background.js CHANGED Viewed

@@ -418,8 +418,19 @@ var DEBUGGER_PROTOCOL_VERSION = "1.3";
 var DEBUGGER_IDLE_TIMEOUT_KEY = "debuggerIdleTimeoutMs";
 var DEFAULT_DEBUGGER_IDLE_TIMEOUT_MS = 15e3;
 var DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS = 1e4;
+var DEFAULT_SEND_TO_TAB_TIMEOUT_MS = 1e4;
+var HISTORY_DISPATCH_TIMEOUT_MS = 2e3;
+var HISTORY_NAVIGATION_SIGNAL_TIMEOUT_MS = 8e3;
+var HISTORY_POST_NAV_DOM_GRACE_TIMEOUT_MS = 2e3;
 var AGENT_TAB_ID_KEY = "agentTabId";
 var AGENT_TAB_GROUP_TITLE = "\u{1F309} Browser Bridge";
+var AGENT_TAB_FAVICON_ASSET_PATH = "assets/icons/icon-32.png";
+var getAgentTabBootstrapUrl = () => {
+  const faviconUrl = typeof chrome.runtime?.getURL === "function" ? chrome.runtime.getURL(AGENT_TAB_FAVICON_ASSET_PATH) : AGENT_TAB_FAVICON_ASSET_PATH;
+  return `data:text/html;charset=UTF-8,${encodeURIComponent(
+    `<!doctype html><html><head><meta charset="utf-8"><title>${AGENT_TAB_GROUP_TITLE}</title><link rel="icon" type="image/png" href="${faviconUrl}"></head><body></body></html>`
+  )}`;
+};
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
 var makeEventId = /* @__PURE__ */ (() => {
   let counter = 0;
@@ -471,6 +482,80 @@ var delayMs = async (ms) => {
     self.setTimeout(resolve, ms);
   });
 };
+var CAPTURE_VISIBLE_TAB_MIN_INTERVAL_MS = 400;
+var CAPTURE_VISIBLE_TAB_MAX_RETRIES = 3;
+var CAPTURE_VISIBLE_TAB_RETRY_BASE_DELAY_MS = 500;
+var captureVisibleTabQueue = Promise.resolve();
+var captureVisibleTabLastCallAt = 0;
+var isCaptureVisibleTabRateLimitedMessage = (message) => {
+  const normalized = message.toLowerCase();
+  const hasCaptureSignal = normalized.includes("capturevisibletab") || normalized.includes("max_capture_visible_tab_calls_per_second");
+  const hasRateSignal = normalized.includes("too often") || normalized.includes("rate limit") || normalized.includes("rate-limit");
+  return hasCaptureSignal && hasRateSignal;
+};
+var isCaptureVisibleTabRateLimitedError = (error) => {
+  return error instanceof Error && isCaptureVisibleTabRateLimitedMessage(error.message);
+};
+var randomJitterMs = (maxMs) => {
+  return Math.floor(Math.random() * Math.max(1, maxMs));
+};
+var runCaptureVisibleTabOperation = async (operation) => {
+  const previous = captureVisibleTabQueue;
+  let releaseQueue;
+  captureVisibleTabQueue = new Promise((resolve) => {
+    releaseQueue = resolve;
+  });
+  await previous.catch(() => void 0);
+  try {
+    return await operation();
+  } finally {
+    releaseQueue?.();
+  }
+};
+var captureVisibleTabWithThrottle = async (windowId) => {
+  return await runCaptureVisibleTabOperation(async () => {
+    for (let attempt = 0; attempt <= CAPTURE_VISIBLE_TAB_MAX_RETRIES; attempt += 1) {
+      const waitMs = captureVisibleTabLastCallAt + CAPTURE_VISIBLE_TAB_MIN_INTERVAL_MS - Date.now();
+      if (waitMs > 0) {
+        await delayMs(waitMs);
+      }
+      try {
+        const dataUrl = await wrapChromeCallback(
+          (callback) => chrome.tabs.captureVisibleTab(windowId, { format: "png" }, callback)
+        );
+        captureVisibleTabLastCallAt = Date.now();
+        return dataUrl;
+      } catch (error) {
+        captureVisibleTabLastCallAt = Date.now();
+        if (!isCaptureVisibleTabRateLimitedError(error) || attempt >= CAPTURE_VISIBLE_TAB_MAX_RETRIES) {
+          throw error;
+        }
+        const backoffMs = CAPTURE_VISIBLE_TAB_RETRY_BASE_DELAY_MS * (attempt + 1) + randomJitterMs(120);
+        await delayMs(backoffMs);
+      }
+    }
+    throw new Error("captureVisibleTab failed unexpectedly.");
+  });
+};
+var mapScreenshotCaptureError = (error, fallbackMessage) => {
+  const message = error instanceof Error && error.message ? error.message : fallbackMessage;
+  if (isCaptureVisibleTabRateLimitedError(error)) {
+    return {
+      code: "RATE_LIMITED",
+      message: "Screenshot capture hit Chrome capture rate limits. Please retry shortly.",
+      retryable: true,
+      details: {
+        reason: "capture_visible_tab_rate_limited",
+        original_message: message
+      }
+    };
+  }
+  return {
+    code: "ARTIFACT_IO_ERROR",
+    message,
+    retryable: false
+  };
+};
 var parseDataUrl = (dataUrl) => {
   const match = /^data:([^;]+);base64,(.*)$/s.exec(dataUrl);
   if (!match) {
@@ -722,7 +807,10 @@ var ensureAgentTabGroup = async (tabId, windowId) => {
 };
 var createAgentWindow = async () => {
   const created = await wrapChromeCallback(
-    (callback) => chrome.windows.create({ url: "about:blank", focused: true }, callback)
+    (callback) => chrome.windows.create(
+      { url: getAgentTabBootstrapUrl(), focused: true },
+      callback
+    )
   );
   const windowId = created.id;
   if (typeof windowId !== "number") {
@@ -809,14 +897,42 @@ var getDefaultTabId = async () => {
     return await getActiveTabId();
   }
 };
-var sendToTab = async (tabId, action, params) => {
+var sendToTab = async (tabId, action, params, options) => {
+  const timeoutMs = typeof options?.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? Math.max(1, Math.floor(options.timeoutMs)) : DEFAULT_SEND_TO_TAB_TIMEOUT_MS;
   const attemptSend = async () => {
     return await new Promise((resolve) => {
       const message = { action, params };
+      let settled = false;
+      const finish = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (timeout !== void 0) {
+          clearTimeout(timeout);
+        }
+        resolve(result);
+      };
+      let timeout;
+      timeout = self.setTimeout(() => {
+        finish({
+          ok: false,
+          error: {
+            code: "TIMEOUT",
+            message: `Timed out waiting for content response after ${timeoutMs}ms.`,
+            retryable: true,
+            details: {
+              action,
+              tab_id: tabId,
+              timeout_ms: timeoutMs
+            }
+          }
+        });
+      }, timeoutMs);
       chrome.tabs.sendMessage(tabId, message, (response) => {
         const error = chrome.runtime.lastError;
         if (error) {
-          resolve({
+          finish({
             ok: false,
             error: {
               code: "EVALUATION_FAILED",
@@ -827,7 +943,7 @@ var sendToTab = async (tabId, action, params) => {
           return;
         }
         if (!response || typeof response !== "object") {
-          resolve({
+          finish({
             ok: false,
             error: {
               code: "EVALUATION_FAILED",
@@ -837,7 +953,7 @@ var sendToTab = async (tabId, action, params) => {
           });
           return;
         }
-        resolve(response);
+        finish(response);
       });
     });
   };
@@ -863,6 +979,67 @@ var sendToTab = async (tabId, action, params) => {
     }
   };
 };
+var waitForHistoryNavigationSignal = async (tabId, timeoutMs) => {
+  return await new Promise((resolve, reject) => {
+    let timeout;
+    const cleanup = () => {
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
+      chrome.webNavigation.onCommitted.removeListener(onCommitted);
+      chrome.webNavigation.onHistoryStateUpdated.removeListener(
+        onHistoryStateUpdated
+      );
+      chrome.webNavigation.onReferenceFragmentUpdated.removeListener(
+        onReferenceFragmentUpdated
+      );
+      chrome.tabs.onUpdated.removeListener(onTabUpdated);
+    };
+    const resolveSignal = () => {
+      cleanup();
+      resolve();
+    };
+    const onCommitted = (details) => {
+      if (details.tabId !== tabId || details.frameId !== 0) {
+        return;
+      }
+      resolveSignal();
+    };
+    const onHistoryStateUpdated = (details) => {
+      if (details.tabId !== tabId || details.frameId !== 0) {
+        return;
+      }
+      resolveSignal();
+    };
+    const onReferenceFragmentUpdated = (details) => {
+      if (details.tabId !== tabId || details.frameId !== 0) {
+        return;
+      }
+      resolveSignal();
+    };
+    const onTabUpdated = (updatedTabId, changeInfo) => {
+      if (updatedTabId !== tabId) {
+        return;
+      }
+      if (typeof changeInfo.url !== "string" || changeInfo.url.length === 0) {
+        return;
+      }
+      resolveSignal();
+    };
+    chrome.webNavigation.onCommitted.addListener(onCommitted);
+    chrome.webNavigation.onHistoryStateUpdated.addListener(
+      onHistoryStateUpdated
+    );
+    chrome.webNavigation.onReferenceFragmentUpdated.addListener(
+      onReferenceFragmentUpdated
+    );
+    chrome.tabs.onUpdated.addListener(onTabUpdated);
+    timeout = self.setTimeout(() => {
+      cleanup();
+      reject(new Error("Timed out waiting for history navigation signal."));
+    }, timeoutMs);
+  });
+};
 var waitForDomContentLoaded = async (tabId, timeoutMs) => {
   return await new Promise((resolve, reject) => {
     let timeout;
@@ -1313,21 +1490,37 @@ var DriveSocket = class {
           if (tabId === void 0) {
             tabId = await getDefaultTabId();
           }
-          const result = await sendToTab(tabId, message.action);
-          if (!result.ok) {
+          const navigationSignal = waitForHistoryNavigationSignal(
+            tabId,
+            HISTORY_NAVIGATION_SIGNAL_TIMEOUT_MS
+          );
+          const result = await sendToTab(
+            tabId,
+            message.action,
+            void 0,
+            {
+              timeoutMs: HISTORY_DISPATCH_TIMEOUT_MS
+            }
+          );
+          if (!result.ok && result.error.code !== "TIMEOUT") {
             respondError(result.error);
             return;
           }
           markTabActive(tabId);
           try {
-            await waitForDomContentLoaded(tabId, 3e4);
-          } catch (error) {
-            respondError({
-              code: "TIMEOUT",
-              message: error instanceof Error ? error.message : "Timed out waiting.",
-              retryable: true
-            });
-            return;
+            await navigationSignal;
+            try {
+              await waitForDomContentLoaded(
+                tabId,
+                HISTORY_POST_NAV_DOM_GRACE_TIMEOUT_MS
+              );
+            } catch {
+            }
+          } catch {
+            if (!result.ok) {
+              respondError(result.error);
+              return;
+            }
           }
           respondOk({ ok: true });
           return;
@@ -1901,10 +2094,14 @@ var DriveSocket = class {
           if (tabId === void 0) {
             tabId = await getDefaultTabId();
           }
+          const timeoutMs = message.action === "drive.wait_for" && typeof params.timeout_ms === "number" && Number.isFinite(params.timeout_ms) ? Math.max(1, Math.floor(params.timeout_ms) + 1e3) : void 0;
           const result = await sendToTab(
             tabId,
             message.action,
-            params
+            params,
+            {
+              timeoutMs
+            }
           );
           if (result.ok) {
             respondOk(result.result ?? { ok: true });
@@ -1959,13 +2156,7 @@ var DriveSocket = class {
             return;
           }
           const captureVisible = async () => {
-            return await wrapChromeCallback(
-              (callback) => chrome.tabs.captureVisibleTab(
-                windowId,
-                { format: "png" },
-                callback
-              )
-            );
+            return await captureVisibleTabWithThrottle(windowId);
           };
           const scrollTo = async (top, left) => {
             const result = await sendToTab(tabId, "drive.scroll", {
@@ -2111,11 +2302,12 @@ var DriveSocket = class {
               );
               respondOk(rendered);
             } catch (error) {
-              respondError({
-                code: "ARTIFACT_IO_ERROR",
-                message: error instanceof Error ? error.message : "Failed to capture screenshot.",
-                retryable: false
-              });
+              respondError(
+                mapScreenshotCaptureError(
+                  error,
+                  "Failed to capture screenshot."
+                )
+              );
             }
             return;
           }
@@ -2247,11 +2439,12 @@ var DriveSocket = class {
               );
               respondOk(await canvasToResult(cropCanvas));
             } catch (error) {
-              respondError({
-                code: "ARTIFACT_IO_ERROR",
-                message: error instanceof Error ? error.message : "Failed to capture element screenshot.",
-                retryable: false
-              });
+              respondError(
+                mapScreenshotCaptureError(
+                  error,
+                  "Failed to capture element screenshot."
+                )
+              );
             } finally {
               try {
                 await scrollTo(metaInfo.scrollY, metaInfo.scrollX);
@@ -2265,11 +2458,12 @@ var DriveSocket = class {
             const canvas = await captureFullPageCanvas(metaInfo);
             respondOk(await canvasToResult(canvas));
           } catch (error) {
-            respondError({
-              code: "ARTIFACT_IO_ERROR",
-              message: error instanceof Error ? error.message : "Failed to capture full page screenshot.",
-              retryable: false
-            });
+            respondError(
+              mapScreenshotCaptureError(
+                error,
+                "Failed to capture full page screenshot."
+              )
+            );
           }
           return;
         }