@btraut/browser-bridge 0.14.0 → 0.15.0

package/extension/dist/background.js

@@ -181,6 +181,14 @@ var readSitePermissionsMode = async () => {
     );
   });
 };
+var writeSitePermissionsMode = async (mode) => {
+  return await new Promise((resolve) => {
+    chrome.storage.local.set(
+      { [SITE_PERMISSIONS_MODE_KEY]: mode },
+      () => resolve()
+    );
+  });
+};
 var readPermissionPromptWaitMs = async () => {
   return await new Promise((resolve) => {
     chrome.storage.local.get(
@@ -212,6 +220,9 @@ var writeDebuggerCapabilityEnabled = async (enabled) => {
     );
   });
 };
+var getAllowlistedSites = async () => {
+  return await readAllowlistRaw();
+};
 var isSiteAllowed = async (siteKey) => {
   const key = normalizeSiteKey(siteKey);
   const allowlist = await readAllowlistRaw();
@@ -238,6 +249,15 @@ var touchSiteLastUsed = async (siteKey, now = /* @__PURE__ */ new Date()) => {
   allowlist[key] = { ...existing, lastUsedAt: now.toISOString() };
   await writeAllowlistRaw(allowlist);
 };
+var revokeSite = async (siteKey) => {
+  const key = normalizeSiteKey(siteKey);
+  const allowlist = await readAllowlistRaw();
+  if (!allowlist[key]) {
+    return;
+  }
+  delete allowlist[key];
+  await writeAllowlistRaw(allowlist);
+};
 
 // packages/extension/src/permission-prompt.ts
 var PERMISSION_PROMPT_PORT_NAME = "permission_prompt";
@@ -423,6 +443,281 @@ var PermissionPromptController = class {
   }
 };
 
+// packages/extension/src/permissions-request.ts
+var PERMISSIONS_REQUEST_PORT_NAME = "permissions_request_prompt";
+var defaultMakeRequestId2 = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `perm-change-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+};
+var defaultOpenWindow2 = async (url) => {
+  return await new Promise((resolve, reject) => {
+    chrome.windows.create(
+      {
+        type: "popup",
+        url,
+        focused: true,
+        width: 500,
+        height: 470
+      },
+      (win) => {
+        const err = chrome.runtime.lastError;
+        if (err) {
+          reject(new Error(err.message));
+          return;
+        }
+        const windowId = win?.id;
+        if (typeof windowId !== "number") {
+          reject(new Error("Prompt window id missing."));
+          return;
+        }
+        resolve(windowId);
+      }
+    );
+  });
+};
+var defaultCloseWindow2 = async (windowId) => {
+  return await new Promise((resolve) => {
+    chrome.windows.remove(windowId, () => resolve());
+  });
+};
+var delay2 = async (ms) => {
+  return await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+var normalizeSite = (site) => site.trim().toLowerCase();
+var describeChange = (state) => {
+  switch (state.kind) {
+    case "allow_site":
+      return `Allow Browser Bridge actions on ${state.site ?? "this site"}.`;
+    case "revoke_site":
+      return `Revoke Browser Bridge actions on ${state.site ?? "this site"}.`;
+    case "set_mode":
+      return state.mode === "bypass" ? "Switch Browser Bridge to bypass mode." : "Switch Browser Bridge to granular mode.";
+  }
+};
+var buildWarning = (kind, mode) => {
+  if (kind === "set_mode" && mode === "bypass") {
+    return "Bypass mode lets the agent act on any website without asking first.";
+  }
+  return void 0;
+};
+var PermissionsRequestController = class {
+  constructor(deps) {
+    this.stateByRequestId = /* @__PURE__ */ new Map();
+    this.stateByWindowId = /* @__PURE__ */ new Map();
+    this.deps = {
+      openWindow: deps?.openWindow ?? defaultOpenWindow2,
+      closeWindow: deps?.closeWindow ?? defaultCloseWindow2,
+      getDefaultWaitMs: deps?.getDefaultWaitMs ?? readPermissionPromptWaitMs,
+      makeRequestId: deps?.makeRequestId ?? defaultMakeRequestId2,
+      now: deps?.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()),
+      allowSite: deps?.allowSite ?? allowSiteAlways,
+      revokeSite: deps?.revokeSite ?? revokeSite,
+      setMode: deps?.setMode ?? writeSitePermissionsMode
+    };
+  }
+  async requestChange(request) {
+    const state = await this.createState(request);
+    const waitMs = typeof request.timeoutMs === "number" && request.timeoutMs > 0 ? request.timeoutMs : await this.deps.getDefaultWaitMs();
+    const decision = await this.waitForDecisionOrTimeout(state, waitMs);
+    if (!decision) {
+      return {
+        request_id: state.requestId,
+        kind: state.kind,
+        status: "timed_out",
+        requested_at: state.requestedAt,
+        ...state.site ? { site: state.site } : {},
+        ...state.mode ? { mode: state.mode } : {},
+        ...state.source ? { source: state.source } : {},
+        ...state.warning ? { warning: state.warning } : {},
+        message: "Permission change request timed out waiting for approval."
+      };
+    }
+    return {
+      request_id: state.requestId,
+      kind: state.kind,
+      status: decision === "approve" ? "approved" : "denied",
+      requested_at: state.requestedAt,
+      ...state.site ? { site: state.site } : {},
+      ...state.mode ? { mode: state.mode } : {},
+      ...state.source ? { source: state.source } : {},
+      ...state.warning ? { warning: state.warning } : {},
+      message: decision === "approve" ? describeChange(state) : "Permission change request was denied."
+    };
+  }
+  listPendingRequests() {
+    return [...this.stateByRequestId.values()].filter((state) => state.decided === null).map((state) => ({
+      request_id: state.requestId,
+      kind: state.kind,
+      status: "pending",
+      requested_at: state.requestedAt,
+      ...state.site ? { site: state.site } : {},
+      ...state.mode ? { mode: state.mode } : {},
+      ...state.source ? { source: state.source } : {},
+      ...state.warning ? { warning: state.warning } : {}
+    })).sort((a, b) => a.requested_at.localeCompare(b.requested_at));
+  }
+  handleConnect(port) {
+    if (!port || typeof port !== "object") {
+      return;
+    }
+    const p = port;
+    if (p.name !== PERMISSIONS_REQUEST_PORT_NAME) {
+      return;
+    }
+    const onMessage = p.onMessage;
+    if (!onMessage || typeof onMessage.addListener !== "function") {
+      return;
+    }
+    onMessage.addListener((message) => {
+      void this.handlePortMessage(message).catch((error) => {
+        console.error(
+          "PermissionsRequestController handlePortMessage failed:",
+          error
+        );
+      });
+    });
+  }
+  handleWindowRemoved(windowId) {
+    const state = this.stateByWindowId.get(windowId);
+    if (!state) {
+      return;
+    }
+    this.cleanupState(state);
+  }
+  async createState(request) {
+    const requestId = this.deps.makeRequestId();
+    const requestedAt = this.deps.now();
+    const kind = request.kind;
+    const warning = buildWarning(kind, request.mode);
+    const state = {
+      requestId,
+      kind,
+      requestedAt,
+      site: request.site ? normalizeSite(request.site) : void 0,
+      mode: request.mode,
+      source: request.source,
+      warning,
+      windowId: null,
+      decided: null,
+      waiters: /* @__PURE__ */ new Set()
+    };
+    this.stateByRequestId.set(requestId, state);
+    const url = this.buildPromptUrl(state);
+    const windowId = await this.deps.openWindow(url);
+    state.windowId = windowId;
+    this.stateByWindowId.set(windowId, state);
+    if (state.decided) {
+      await this.deps.closeWindow(windowId);
+      this.cleanupState(state);
+    }
+    return state;
+  }
+  buildPromptUrl(state) {
+    const base = chrome.runtime.getURL("permissions-request.html");
+    const url = new URL(base);
+    url.searchParams.set("requestId", state.requestId);
+    url.searchParams.set("kind", state.kind);
+    url.searchParams.set("requestedAt", state.requestedAt);
+    if (state.site) {
+      url.searchParams.set("site", state.site);
+    }
+    if (state.mode) {
+      url.searchParams.set("mode", state.mode);
+    }
+    if (state.source) {
+      url.searchParams.set("source", state.source);
+    }
+    if (state.warning) {
+      url.searchParams.set("warning", state.warning);
+    }
+    if (state.kind === "set_mode" && state.mode === "bypass") {
+      url.searchParams.set("requireAcknowledge", "1");
+    }
+    return url.toString();
+  }
+  async waitForDecisionOrTimeout(state, waitMs) {
+    if (state.decided) {
+      return state.decided;
+    }
+    let waiter = null;
+    const decisionPromise = new Promise((resolve) => {
+      waiter = resolve;
+      state.waiters.add(resolve);
+    });
+    const winner = await Promise.race([
+      decisionPromise,
+      delay2(waitMs).then(() => null)
+    ]);
+    if (winner === null && waiter) {
+      state.waiters.delete(waiter);
+    }
+    return winner;
+  }
+  async handlePortMessage(message) {
+    if (!message || typeof message !== "object") {
+      return;
+    }
+    const m = message;
+    if (m.type !== "decision") {
+      return;
+    }
+    const requestId = m.requestId;
+    const decision = m.decision;
+    if (typeof requestId !== "string" || requestId.length === 0) {
+      return;
+    }
+    if (decision !== "approve" && decision !== "deny") {
+      return;
+    }
+    const state = this.stateByRequestId.get(requestId);
+    if (!state) {
+      return;
+    }
+    state.decided = decision;
+    if (decision === "approve") {
+      await this.applyApprovedChange(state);
+    }
+    for (const waiter of state.waiters) {
+      waiter(decision);
+    }
+    state.waiters.clear();
+    if (typeof state.windowId === "number") {
+      await this.deps.closeWindow(state.windowId);
+      this.cleanupState(state);
+    }
+  }
+  async applyApprovedChange(state) {
+    if (state.kind === "allow_site") {
+      if (!state.site) {
+        throw new Error("allow_site request is missing site.");
+      }
+      await this.deps.allowSite(state.site);
+      return;
+    }
+    if (state.kind === "revoke_site") {
+      if (!state.site) {
+        throw new Error("revoke_site request is missing site.");
+      }
+      await this.deps.revokeSite(state.site);
+      return;
+    }
+    if (!state.mode) {
+      throw new Error("set_mode request is missing mode.");
+    }
+    await this.deps.setMode(state.mode);
+  }
+  cleanupState(state) {
+    this.stateByRequestId.delete(state.requestId);
+    if (typeof state.windowId === "number") {
+      this.stateByWindowId.delete(state.windowId);
+    }
+  }
+};
+
 // packages/extension/src/restricted-url.ts
 var RESTRICTED_URL_PREFIXES = [
   "chrome://",
@@ -840,6 +1135,9 @@ var TRANSIENT_TAB_CHANNEL_ERROR_PATTERNS = [
   "the message port closed before a response was received",
   "extension port is moved into back/forward cache"
 ];
+var CONTENT_SCRIPT_RECOVERY_ERROR_PATTERNS = [
+  "receiving end does not exist"
+];
 var TAB_CHANNEL_RETRY_DELAYS_MS = [120, 200, 320, 500, 750, 1e3, 1200];
 var normalizePathname = (pathname) => {
   if (pathname.length === 0) {
@@ -859,6 +1157,25 @@ var isTransientTabChannelError = (message) => {
     (pattern) => normalized.includes(pattern)
   );
 };
+var canInjectContentScriptForUrl = (url) => {
+  if (typeof url !== "string" || url.trim().length === 0) {
+    return false;
+  }
+  const normalized = url.toLowerCase();
+  if (normalized.startsWith("chrome://") || normalized.startsWith("chrome-extension://") || normalized.startsWith("devtools://") || normalized.startsWith("edge://") || normalized.startsWith("about:") || normalized.startsWith("file://")) {
+    return false;
+  }
+  return normalized.startsWith("http://") || normalized.startsWith("https://");
+};
+var shouldReinjectContentScript = (message, tabUrl) => {
+  if (typeof message !== "string") {
+    return false;
+  }
+  const normalized = message.toLowerCase();
+  return CONTENT_SCRIPT_RECOVERY_ERROR_PATTERNS.some(
+    (pattern) => normalized.includes(pattern)
+  ) && canInjectContentScriptForUrl(tabUrl);
+};
 var shouldRetryTabChannelFailure = (action, error) => {
   if (!error || typeof error !== "object") {
     return false;
@@ -1224,7 +1541,13 @@ var BASE_NEGOTIATED_CAPABILITIES = Object.freeze({
   "drive.tab_activate": true,
   "drive.tab_close": true,
   "drive.set_debugger_capability": true,
-  "drive.ping": true
+  "drive.ping": true,
+  "permissions.list": true,
+  "permissions.get_mode": true,
+  "permissions.list_pending_requests": true,
+  "permissions.request_allow_site": true,
+  "permissions.request_revoke_site": true,
+  "permissions.request_set_mode": true
 });
 var DEBUGGER_CAPABILITY_ACTIONS = [
   "debugger.attach",
@@ -1297,6 +1620,28 @@ var delayMs = async (ms) => {
     self.setTimeout(resolve, ms);
   });
 };
+var ensureTabContentScript = async (tabId) => {
+  try {
+    const tab = await getTab(tabId);
+    const url = typeof tab.url === "string" ? tab.url : void 0;
+    if (!canInjectContentScriptForUrl(url)) {
+      return false;
+    }
+    await wrapChromeVoid(
+      (callback) => chrome.scripting.executeScript(
+        {
+          target: { tabId },
+          files: ["dist/content.js"]
+        },
+        () => callback()
+      )
+    );
+    return true;
+  } catch (error) {
+    console.debug("Failed to re-inject content script.", { tabId, error });
+    return false;
+  }
+};
 var CAPTURE_VISIBLE_TAB_MIN_INTERVAL_MS = 400;
 var CAPTURE_VISIBLE_TAB_MAX_RETRIES = 3;
 var CAPTURE_VISIBLE_TAB_RETRY_BASE_DELAY_MS = 500;
@@ -1752,11 +2097,18 @@ var sendToTab = async (tabId, action, params, options) => {
       });
     });
   };
+  let attemptedContentRecovery = false;
   for (let attempt = 1; ; attempt += 1) {
     const result = await attemptSend();
     if (result.ok) {
       return result;
     }
+    if (!attemptedContentRecovery && shouldReinjectContentScript(
+      result.error.message,
+      (await getTab(tabId).catch(() => void 0))?.url
+    )) {
+      attemptedContentRecovery = await ensureTabContentScript(tabId);
+    }
     if (!shouldRetryTabChannelFailure(action, result.error)) {
       return result;
     }
@@ -1909,15 +2261,15 @@ var DriveSocket = class {
     if (this.reconnectTimer !== null) {
       return;
     }
-    const delay2 = this.reconnectDelayMs;
-    this.connection.markBackoff(delay2);
+    const delay3 = this.reconnectDelayMs;
+    this.connection.markBackoff(delay3);
     this.reconnectTimer = self.setTimeout(() => {
       this.reconnectTimer = null;
       this.connection.markConnecting();
       void this.connect().catch((error) => {
         this.recordConnectionFailure("reconnect", error);
       });
-    }, delay2);
+    }, delay3);
     this.reconnectDelayMs = Math.min(
       this.maxReconnectDelayMs,
       this.reconnectDelayMs * 2
@@ -2132,11 +2484,11 @@ var DriveSocket = class {
     this.refreshCapabilities();
   }
   async handleRequest(message) {
-    let driveMessage = null;
+    let requestMessage = null;
     let gatedSiteKey = null;
     let touchGatedSiteOnSuccess = false;
     const respondOk = (result) => {
-      if (!driveMessage) {
+      if (!requestMessage) {
         return;
       }
       if (touchGatedSiteOnSuccess && gatedSiteKey) {
@@ -2145,20 +2497,20 @@ var DriveSocket = class {
         });
       }
       const response = {
-        id: driveMessage.id,
-        action: driveMessage.action,
+        id: requestMessage.id,
+        action: requestMessage.action,
         status: "ok",
         result
       };
       this.sendMessage(response);
     };
     const respondError = (error) => {
-      if (!driveMessage) {
+      if (!requestMessage) {
         return;
       }
       const response = {
-        id: driveMessage.id,
-        action: driveMessage.action,
+        id: requestMessage.id,
+        action: requestMessage.action,
         status: "error",
         error: sanitizeDriveErrorInfo(error)
       };
@@ -2168,16 +2520,111 @@ var DriveSocket = class {
       if (!message || typeof message !== "object" || typeof message.id !== "string" || typeof message.action !== "string") {
         return;
       }
-      if (message.action.startsWith("debugger.")) {
+      const action = message.action;
+      if (action.startsWith("debugger.")) {
         await this.handleDebuggerRequest(message);
         return;
       }
-      if (!message.action.startsWith("drive.")) {
+      requestMessage = message;
+      if (action.startsWith("permissions.")) {
+        const params = message.params ?? {};
+        const rawTimeoutMs = params.timeout_ms;
+        const timeoutMs = typeof rawTimeoutMs === "number" && Number.isFinite(rawTimeoutMs) && rawTimeoutMs > 0 ? Math.floor(rawTimeoutMs) : void 0;
+        const rawSource = params.source;
+        const source = rawSource === "cli" || rawSource === "mcp" || rawSource === "api" ? rawSource : void 0;
+        switch (action) {
+          case "permissions.list": {
+            const allowlist = await getAllowlistedSites();
+            const sites = Object.entries(allowlist).map(([site, entry]) => ({
+              site,
+              created_at: entry.createdAt,
+              last_used_at: entry.lastUsedAt
+            })).sort((a, b) => a.site.localeCompare(b.site));
+            respondOk({ sites });
+            return;
+          }
+          case "permissions.get_mode": {
+            respondOk({
+              mode: await readSitePermissionsMode()
+            });
+            return;
+          }
+          case "permissions.list_pending_requests": {
+            respondOk({
+              requests: permissionsRequests.listPendingRequests()
+            });
+            return;
+          }
+          case "permissions.request_allow_site": {
+            const site = params.site;
+            if (typeof site !== "string" || site.trim().length === 0) {
+              respondError({
+                code: "INVALID_ARGUMENT",
+                message: "site must be a non-empty string.",
+                retryable: false,
+                details: { field: "site" }
+              });
+              return;
+            }
+            respondOk(
+              await permissionsRequests.requestChange({
+                kind: "allow_site",
+                site,
+                timeoutMs,
+                source
+              })
+            );
+            return;
+          }
+          case "permissions.request_revoke_site": {
+            const site = params.site;
+            if (typeof site !== "string" || site.trim().length === 0) {
+              respondError({
+                code: "INVALID_ARGUMENT",
+                message: "site must be a non-empty string.",
+                retryable: false,
+                details: { field: "site" }
+              });
+              return;
+            }
+            respondOk(
+              await permissionsRequests.requestChange({
+                kind: "revoke_site",
+                site,
+                timeoutMs,
+                source
+              })
+            );
+            return;
+          }
+          case "permissions.request_set_mode": {
+            const mode = params.mode;
+            if (mode !== "granular" && mode !== "bypass") {
+              respondError({
+                code: "INVALID_ARGUMENT",
+                message: "mode must be granular or bypass.",
+                retryable: false,
+                details: { field: "mode" }
+              });
+              return;
+            }
+            respondOk(
+              await permissionsRequests.requestChange({
+                kind: "set_mode",
+                mode,
+                timeoutMs,
+                source
+              })
+            );
+            return;
+          }
+        }
+      }
+      if (!action.startsWith("drive.")) {
         return;
       }
-      driveMessage = message;
       const gated = await gateDriveAction({
-        action: message.action,
+        action,
         params: message.params ?? {},
         getDefaultTabId,
         getTab,
@@ -2433,8 +2880,8 @@ var DriveSocket = class {
         }
         case "drive.handle_dialog": {
           const params = message.params ?? {};
-          const action = params.action;
-          if (action !== "accept" && action !== "dismiss") {
+          const action2 = params.action;
+          if (action2 !== "accept" && action2 !== "dismiss") {
             respondError({
               code: "INVALID_ARGUMENT",
               message: "action must be accept or dismiss.",
@@ -2467,7 +2914,7 @@ var DriveSocket = class {
               tabId,
               "Page.handleJavaScriptDialog",
               {
-                accept: action === "accept",
+                accept: action2 === "accept",
                 ...promptText ? { promptText } : {}
               },
               DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
@@ -3869,11 +4316,14 @@ var DebuggerTimeoutError = class extends Error {
 };
 var socket = new DriveSocket();
 var permissionPrompts = new PermissionPromptController();
+var permissionsRequests = new PermissionsRequestController();
 chrome.runtime.onConnect.addListener((port) => {
   permissionPrompts.handleConnect(port);
+  permissionsRequests.handleConnect(port);
 });
 chrome.windows.onRemoved.addListener((windowId) => {
   permissionPrompts.handleWindowRemoved(windowId);
+  permissionsRequests.handleWindowRemoved(windowId);
 });
 chrome.windows.onFocusChanged.addListener((windowId) => {
   if (windowId === chrome.windows.WINDOW_ID_NONE) {