@opentabs-dev/browser-extension 0.0.34 → 0.0.36

package/dist/background.js

@@ -1,5 +1,9 @@
 // dist/confirmation-badge.js
 var pendingConfirmationCount = 0;
+var confirmationTimeouts = /* @__PURE__ */ new Map();
+var clearedConfirmationIds = /* @__PURE__ */ new Set();
+var CONFIRMATION_BACKGROUND_TIMEOUT_BUFFER_MS = 2e3;
+var CONFIRMATION_FALLBACK_TIMEOUT_MS = 3e4;
 var updateConfirmationBadge = () => {
   if (pendingConfirmationCount > 0) {
     chrome.action.setBadgeText({ text: String(pendingConfirmationCount) }).catch(() => {
@@ -12,11 +16,26 @@ var updateConfirmationBadge = () => {
   }
 };
 var notifyConfirmationRequest = (params) => {
-  pendingConfirmationCount++;
-  updateConfirmationBadge();
   const tool = typeof params.tool === "string" ? params.tool : "unknown tool";
   const domain = typeof params.domain === "string" ? params.domain : "unknown domain";
-  chrome.notifications.create(`opentabs-confirm-${typeof params.id === "string" ? params.id : Date.now()}`, {
+  const id = typeof params.id === "string" ? params.id : String(Date.now());
+  const timeoutMs = typeof params.timeoutMs === "number" ? params.timeoutMs : 0;
+  const existingTimeoutId = confirmationTimeouts.get(id);
+  if (existingTimeoutId !== void 0) {
+    clearTimeout(existingTimeoutId);
+  } else {
+    clearedConfirmationIds.delete(id);
+    pendingConfirmationCount++;
+    updateConfirmationBadge();
+  }
+  const effectiveTimeoutMs = timeoutMs > 0 ? timeoutMs : CONFIRMATION_FALLBACK_TIMEOUT_MS;
+  const bgTimeoutId = setTimeout(() => {
+    confirmationTimeouts.delete(id);
+    clearConfirmationBadge(id);
+    clearedConfirmationIds.delete(id);
+  }, effectiveTimeoutMs + CONFIRMATION_BACKGROUND_TIMEOUT_BUFFER_MS);
+  confirmationTimeouts.set(id, bgTimeoutId);
+  chrome.notifications.create(`opentabs-confirm-${id}`, {
     type: "basic",
     iconUrl: chrome.runtime.getURL("icons/icon-128.png"),
     title: "OpenTabs: Approval Required",
@@ -26,11 +45,37 @@ var notifyConfirmationRequest = (params) => {
   }).catch(() => {
   });
 };
-var clearConfirmationBadge = () => {
+var clearConfirmationBadge = (id) => {
+  if (id !== void 0) {
+    if (clearedConfirmationIds.has(id)) {
+      return;
+    }
+    clearedConfirmationIds.add(id);
+    chrome.notifications.clear(`opentabs-confirm-${id}`).catch(() => {
+    });
+  }
   pendingConfirmationCount = Math.max(0, pendingConfirmationCount - 1);
   updateConfirmationBadge();
+  if (id !== void 0 && !confirmationTimeouts.has(id)) {
+    clearedConfirmationIds.delete(id);
+  }
+};
+var clearConfirmationBackgroundTimeout = (id) => {
+  const timeoutId = confirmationTimeouts.get(id);
+  if (timeoutId !== void 0) {
+    clearTimeout(timeoutId);
+    confirmationTimeouts.delete(id);
+    clearedConfirmationIds.delete(id);
+  }
 };
 var clearAllConfirmationBadges = () => {
+  for (const [id, timeoutId] of confirmationTimeouts.entries()) {
+    clearTimeout(timeoutId);
+    chrome.notifications.clear(`opentabs-confirm-${id}`).catch(() => {
+    });
+  }
+  confirmationTimeouts.clear();
+  clearedConfirmationIds.clear();
   pendingConfirmationCount = 0;
   updateConfirmationBadge();
 };
@@ -465,8 +510,8 @@ var handleBrowserDeleteCookies = async (params, id) => {
     const name = requireStringParam(params, "name", id);
     if (name === null)
       return;
-    await chrome.cookies.remove({ url, name });
-    sendSuccessResult(id, { deleted: true, name, url });
+    const result = await chrome.cookies.remove({ url, name });
+    sendSuccessResult(id, { deleted: result !== null, name, url });
   } catch (err2) {
     sendErrorResult(id, err2);
   }
@@ -565,6 +610,9 @@ var bgLogCollector = installLogCollector("background");
 
 // dist/network-capture.js
 var MAX_BODY_LENGTH = 102400;
+var PENDING_REQUEST_TTL_MS = 6e4;
+var PRUNE_INTERVAL_MS = 3e4;
+var WS_TTL_MS = 5 * 6e4;
 var SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
   "authorization",
   "cookie",
@@ -596,6 +644,7 @@ var scrubHeaders = (headers) => {
   return scrubbed;
 };
 var captures = /* @__PURE__ */ new Map();
+var pendingCaptures = /* @__PURE__ */ new Map();
 var headersToRecord = (raw) => {
   if (!raw)
     return void 0;
@@ -652,6 +701,23 @@ chrome.debugger.onEvent.addListener((source, method, params) => {
     const request = paramsRecord?.request;
     if (!requestId || !request)
       return;
+    const now = Date.now();
+    for (const [id, pending] of state.pendingRequests) {
+      if (pending.timestamp !== void 0 && now - pending.timestamp > PENDING_REQUEST_TTL_MS) {
+        state.pendingRequests.delete(id);
+      }
+    }
+    for (const [id, req] of state.requestIdToRequest) {
+      if (now - req.timestamp > PENDING_REQUEST_TTL_MS) {
+        state.requestIdToRequest.delete(id);
+      }
+    }
+    for (const [id, createdAt] of state.wsCreatedAt) {
+      if (now - createdAt > WS_TTL_MS) {
+        state.wsFramesByRequestId.delete(id);
+        state.wsCreatedAt.delete(id);
+      }
+    }
     const url = stringProp(request, "url", "");
     if (state.urlFilter && !url.includes(state.urlFilter))
       return;
@@ -727,15 +793,22 @@ chrome.debugger.onEvent.addListener((source, method, params) => {
       const responseData = result;
       if (typeof responseData.body !== "string")
         return;
+      if (!state.requests.includes(request))
+        return;
       const body = responseData.base64Encoded ? new TextDecoder().decode(Uint8Array.from(atob(responseData.body), (c) => c.charCodeAt(0))) : responseData.body;
       request.responseBody = truncateBody(body);
     });
   } else if (method === "Network.webSocketCreated") {
     const url = paramsRecord?.url;
+    const requestId = paramsRecord?.requestId;
     if (!url)
       return;
     if (state.urlFilter && !url.includes(state.urlFilter))
       return;
+    if (requestId) {
+      state.wsFramesByRequestId.set(requestId, url);
+      state.wsCreatedAt.set(requestId, Date.now());
+    }
     const completed = {
       url,
       method: "GET",
@@ -748,6 +821,28 @@ chrome.debugger.onEvent.addListener((source, method, params) => {
       evictOldestRequest(state);
     }
     state.requests.push(completed);
+  } else if (method === "Network.webSocketFrameSent" || method === "Network.webSocketFrameReceived") {
+    const requestId = paramsRecord?.requestId;
+    const response = paramsRecord?.response;
+    if (!requestId || !response)
+      return;
+    const url = state.wsFramesByRequestId.get(requestId);
+    if (!url)
+      return;
+    const opcode = typeof response.opcode === "number" ? response.opcode : 1;
+    const payloadData = typeof response.payloadData === "string" ? response.payloadData : "";
+    const direction = method === "Network.webSocketFrameSent" ? "sent" : "received";
+    const data = truncateBody(payloadData);
+    if (state.wsFrames.length >= state.maxWsFrames) {
+      state.wsFrames.shift();
+    }
+    state.wsFrames.push({ url, direction, data, opcode, timestamp: Date.now() });
+  } else if (method === "Network.webSocketClosed") {
+    const requestId = paramsRecord?.requestId;
+    if (requestId) {
+      state.wsFramesByRequestId.delete(requestId);
+      state.wsCreatedAt.delete(requestId);
+    }
   } else if (method === "Runtime.consoleAPICalled") {
     const type = paramsRecord?.type;
     const args = paramsRecord?.args;
@@ -774,43 +869,93 @@ chrome.debugger.onEvent.addListener((source, method, params) => {
   }
 });
 chrome.tabs.onRemoved.addListener((tabId) => {
-  if (captures.has(tabId)) {
+  const state = captures.get(tabId);
+  if (state) {
+    clearInterval(state.pruneIntervalId);
     void chrome.debugger.detach({ tabId }).catch(() => {
     });
     captures.delete(tabId);
   }
 });
-var startCapture = async (tabId, maxRequests = 100, urlFilter, maxConsoleLogs = 500) => {
+chrome.debugger.onDetach.addListener((source, _reason) => {
+  const tabId = source.tabId;
+  if (tabId !== void 0) {
+    const state = captures.get(tabId);
+    if (state)
+      clearInterval(state.pruneIntervalId);
+    captures.delete(tabId);
+  }
+});
+var startCapture = async (tabId, maxRequests = 100, urlFilter, maxConsoleLogs = 500, maxWsFrames = 200) => {
+  const inFlightCapture = pendingCaptures.get(tabId);
+  if (inFlightCapture) {
+    return inFlightCapture;
+  }
   if (captures.has(tabId)) {
     throw new Error(`Network capture already active for tab ${tabId}. Call stopCapture first.`);
   }
+  const capturePromise = (async () => {
+    try {
+      await chrome.debugger.attach({ tabId }, CDP_VERSION);
+    } catch (err2) {
+      throw new Error(`Failed to attach debugger to tab ${tabId}: ${toErrorMessage(err2)}. Another debugger (e.g., DevTools) may already be attached.`);
+    }
+    try {
+      await chrome.debugger.sendCommand({ tabId }, "Network.enable");
+      await chrome.debugger.sendCommand({ tabId }, "Runtime.enable");
+    } catch (err2) {
+      await chrome.debugger.detach({ tabId }).catch(() => {
+      });
+      throw err2;
+    }
+    const captureState = {
+      requests: [],
+      consoleLogs: [],
+      wsFrames: [],
+      maxRequests,
+      maxConsoleLogs,
+      maxWsFrames,
+      urlFilter,
+      pendingRequests: /* @__PURE__ */ new Map(),
+      requestIdToRequest: /* @__PURE__ */ new Map(),
+      wsFramesByRequestId: /* @__PURE__ */ new Map(),
+      wsCreatedAt: /* @__PURE__ */ new Map()
+    };
+    captureState.pruneIntervalId = setInterval(() => {
+      const now = Date.now();
+      for (const [id, pendingReq] of captureState.pendingRequests) {
+        if (pendingReq.timestamp !== void 0 && now - pendingReq.timestamp > PENDING_REQUEST_TTL_MS) {
+          captureState.pendingRequests.delete(id);
+        }
+      }
+      for (const [id, req] of captureState.requestIdToRequest) {
+        if (now - req.timestamp > PENDING_REQUEST_TTL_MS) {
+          captureState.requestIdToRequest.delete(id);
+        }
+      }
+      for (const [id, createdAt] of captureState.wsCreatedAt) {
+        if (now - createdAt > WS_TTL_MS) {
+          captureState.wsFramesByRequestId.delete(id);
+          captureState.wsCreatedAt.delete(id);
+        }
+      }
+    }, PRUNE_INTERVAL_MS);
+    captures.set(tabId, captureState);
+  })();
+  pendingCaptures.set(tabId, capturePromise);
   try {
-    await chrome.debugger.attach({ tabId }, CDP_VERSION);
-  } catch (err2) {
-    throw new Error(`Failed to attach debugger to tab ${tabId}: ${toErrorMessage(err2)}. Another debugger (e.g., DevTools) may already be attached.`);
+    await capturePromise;
+  } finally {
+    pendingCaptures.delete(tabId);
   }
-  try {
-    await chrome.debugger.sendCommand({ tabId }, "Network.enable");
-    await chrome.debugger.sendCommand({ tabId }, "Runtime.enable");
-  } catch (err2) {
-    await chrome.debugger.detach({ tabId }).catch(() => {
-    });
-    throw err2;
-  }
-  captures.set(tabId, {
-    requests: [],
-    consoleLogs: [],
-    maxRequests,
-    maxConsoleLogs,
-    urlFilter,
-    pendingRequests: /* @__PURE__ */ new Map(),
-    requestIdToRequest: /* @__PURE__ */ new Map()
-  });
 };
 var stopCapture = (tabId) => {
   const state = captures.get(tabId);
   if (!state)
     return;
+  clearInterval(state.pruneIntervalId);
+  state.wsFramesByRequestId.clear();
+  state.wsCreatedAt.clear();
   void chrome.debugger.detach({ tabId }).catch(() => {
   });
   captures.delete(tabId);
@@ -850,6 +995,16 @@ var clearConsoleLogs = (tabId) => {
     state.consoleLogs = [];
   }
 };
+var getWsFrames = (tabId, clear = false) => {
+  const state = captures.get(tabId);
+  if (!state)
+    return [];
+  const frames = [...state.wsFrames];
+  if (clear) {
+    state.wsFrames = [];
+  }
+  return frames;
+};
 var getActiveCapturesSummary = () => Array.from(captures.entries()).map(([tabId, state]) => ({
   tabId,
   requestCount: state.requests.length,
@@ -1031,11 +1186,17 @@ var lastKnownState = /* @__PURE__ */ new Map();
 var pluginLocks = /* @__PURE__ */ new Map();
 var withPluginLock = (pluginName, fn) => {
   const prev = pluginLocks.get(pluginName) ?? Promise.resolve();
-  const next = prev.then(fn);
-  pluginLocks.set(pluginName, next.catch((err2) => {
+  const operation = prev.then(fn);
+  const lock = operation.catch((err2) => {
     console.warn("[opentabs] tab state operation failed for plugin", pluginName, ":", err2);
-  }));
-  return next;
+  });
+  pluginLocks.set(pluginName, lock);
+  void lock.then(() => {
+    if (pluginLocks.get(pluginName) === lock) {
+      pluginLocks.set(pluginName, Promise.resolve());
+    }
+  });
+  return operation;
 };
 var probeTabReadiness = async (tabId, pluginName) => {
   let timerId;
@@ -1294,10 +1455,18 @@ var handleExtensionGetLogs = async (params, id) => {
 };
 var handleExtensionGetSidePanel = async (id) => {
   try {
-    const sidePanelResult = await Promise.race([
-      chrome.runtime.sendMessage({ type: "sp:getState" }).then((raw) => raw),
-      new Promise((resolve) => setTimeout(() => resolve(null), SIDE_PANEL_TIMEOUT_MS))
-    ]);
+    let timeoutId;
+    let sidePanelResult;
+    try {
+      sidePanelResult = await Promise.race([
+        chrome.runtime.sendMessage({ type: "sp:getState" }).then((raw) => raw),
+        new Promise((resolve) => {
+          timeoutId = setTimeout(() => resolve(null), SIDE_PANEL_TIMEOUT_MS);
+        })
+      ]);
+    } finally {
+      clearTimeout(timeoutId);
+    }
     if (!sidePanelResult || typeof sidePanelResult !== "object") {
       sendSuccessResult(id, { open: false });
       return;
@@ -1376,21 +1545,29 @@ var handleExtensionCheckAdapter = async (params, id) => {
       }
       let isReady = false;
       try {
-        const readyResults = await Promise.race([
-          chrome.scripting.executeScript({
-            target: { tabId },
-            world: "MAIN",
-            func: async (pName) => {
-              const ot = globalThis.__openTabs;
-              const adapter = ot?.adapters?.[pName];
-              if (!adapter || typeof adapter.isReady !== "function")
-                return false;
-              return await adapter.isReady();
-            },
-            args: [pluginName]
-          }),
-          new Promise((resolve) => setTimeout(() => resolve(null), IS_READY_TIMEOUT_MS))
-        ]);
+        let isReadyTimeoutId;
+        let readyResults;
+        try {
+          readyResults = await Promise.race([
+            chrome.scripting.executeScript({
+              target: { tabId },
+              world: "MAIN",
+              func: async (pName) => {
+                const ot = globalThis.__openTabs;
+                const adapter = ot?.adapters?.[pName];
+                if (!adapter || typeof adapter.isReady !== "function")
+                  return false;
+                return await adapter.isReady();
+              },
+              args: [pluginName]
+            }),
+            new Promise((resolve) => {
+              isReadyTimeoutId = setTimeout(() => resolve(null), IS_READY_TIMEOUT_MS);
+            })
+          ]);
+        } finally {
+          clearTimeout(isReadyTimeoutId);
+        }
         if (readyResults !== null) {
           const readyResult = readyResults[0];
           isReady = readyResult?.result === true;
@@ -1446,7 +1623,11 @@ var handleBrowserExecuteScript = async (params, id) => {
       sendValidationError(id, "Invalid execFile format");
       return;
     }
+    const execUuid = execFile.replace(/^__exec-/, "").replace(/\.js$/, "");
+    const resultKey = `__execResult_${execUuid}`;
+    const asyncKey = `__execAsync_${execUuid}`;
     let timeoutId;
+    const cancelled = { value: false };
     const injectPromise = (async () => {
       await chrome.scripting.executeScript({
         target: { tabId },
@@ -1455,15 +1636,17 @@ var handleBrowserExecuteScript = async (params, id) => {
       });
       let elapsed = 0;
       while (elapsed <= EXEC_MAX_ASYNC_WAIT_MS) {
+        if (cancelled.value)
+          return;
         const results = await chrome.scripting.executeScript({
           target: { tabId },
           world: "MAIN",
-          func: (truncLimit) => {
+          func: (truncLimit, rKey, aKey) => {
             const ot = globalThis.__openTabs;
             if (!ot)
               return { pending: false, result: { error: "__openTabs not found" } };
-            const result2 = ot.__lastExecResult;
-            const isAsync = ot.__lastExecAsync === true;
+            const result2 = ot[rKey];
+            const isAsync = ot[aKey] === true;
             if (result2 && ("value" in result2 || "error" in result2)) {
               const captured = { ...result2 };
               if (captured.value === void 0)
@@ -1476,15 +1659,15 @@ var handleBrowserExecuteScript = async (params, id) => {
                   captured.value = String(captured.value);
                 }
               }
-              delete ot.__lastExecResult;
-              delete ot.__lastExecAsync;
+              Reflect.deleteProperty(ot, rKey);
+              Reflect.deleteProperty(ot, aKey);
               return { pending: false, result: captured };
             }
             if (isAsync)
               return { pending: true };
             return { pending: false, result: { error: "No result captured" } };
           },
-          args: [EXEC_RESULT_TRUNCATION_LIMIT]
+          args: [EXEC_RESULT_TRUNCATION_LIMIT, resultKey, asyncKey]
         });
         const first = results[0];
         const data = first?.result;
@@ -1494,18 +1677,21 @@ var handleBrowserExecuteScript = async (params, id) => {
         await new Promise((resolve) => setTimeout(resolve, EXEC_POLL_INTERVAL_MS));
         elapsed += EXEC_POLL_INTERVAL_MS;
       }
-      await chrome.scripting.executeScript({
-        target: { tabId },
-        world: "MAIN",
-        func: () => {
-          const ot = globalThis.__openTabs;
-          if (ot) {
-            delete ot.__lastExecResult;
-            delete ot.__lastExecAsync;
-          }
-        }
-      }).catch(() => {
-      });
+      if (!cancelled.value) {
+        await chrome.scripting.executeScript({
+          target: { tabId },
+          world: "MAIN",
+          func: (rKey, aKey) => {
+            const ot = globalThis.__openTabs;
+            if (ot) {
+              Reflect.deleteProperty(ot, rKey);
+              Reflect.deleteProperty(ot, aKey);
+            }
+          },
+          args: [resultKey, asyncKey]
+        }).catch(() => {
+        });
+      }
       return { value: { error: `Async code did not resolve within ${EXEC_MAX_ASYNC_WAIT_MS}ms` } };
     })();
     const timeoutPromise = new Promise((_resolve, reject) => {
@@ -1518,6 +1704,7 @@ var handleBrowserExecuteScript = async (params, id) => {
       result = await Promise.race([injectPromise, timeoutPromise]);
     } finally {
       clearTimeout(timeoutId);
+      cancelled.value = true;
     }
     sendSuccessResult(id, result);
   } catch (err2) {
@@ -1824,24 +2011,30 @@ var handleBrowserWaitForElement = async (params, id) => {
       func: (sel, tmo, vis, maxPreview, pollMs) => new Promise((resolve) => {
         let elapsed = 0;
         const poll = setInterval(() => {
-          const el = document.querySelector(sel);
-          if (el) {
-            const htmlEl = el;
-            const isVisible = !vis || htmlEl.offsetParent !== null && getComputedStyle(htmlEl).display !== "none";
-            if (isVisible) {
+          try {
+            const el = document.querySelector(sel);
+            if (el) {
+              const htmlEl = el;
+              const style = getComputedStyle(htmlEl);
+              const isVisible = !vis || style.display !== "none" && style.visibility !== "hidden" && (htmlEl.offsetParent !== null || style.position === "fixed" || style.position === "sticky");
+              if (isVisible) {
+                clearInterval(poll);
+                resolve({
+                  found: true,
+                  tagName: el.tagName.toLowerCase(),
+                  text: (el.textContent || "").trim().slice(0, maxPreview)
+                });
+                return;
+              }
+            }
+            elapsed += pollMs;
+            if (elapsed >= tmo) {
               clearInterval(poll);
-              resolve({
-                found: true,
-                tagName: el.tagName.toLowerCase(),
-                text: (el.textContent || "").trim().slice(0, maxPreview)
-              });
-              return;
+              resolve({ error: `Timeout waiting for element: ${sel} (${tmo}ms)` });
             }
-          }
-          elapsed += pollMs;
-          if (elapsed >= tmo) {
+          } catch (err2) {
             clearInterval(poll);
-            resolve({ error: `Timeout waiting for element: ${sel} (${tmo}ms)` });
+            resolve({ error: `Error checking element: ${err2 instanceof Error ? err2.message : String(err2)}` });
           }
         }, pollMs);
       }),
@@ -2230,7 +2423,8 @@ var handleBrowserEnableNetworkCapture = async (params, id) => {
     const maxRequests = typeof params.maxRequests === "number" ? params.maxRequests : 100;
     const urlFilter = typeof params.urlFilter === "string" ? params.urlFilter : void 0;
     const maxConsoleLogs = typeof params.maxConsoleLogs === "number" ? params.maxConsoleLogs : 500;
-    await startCapture(tabId, maxRequests, urlFilter, maxConsoleLogs);
+    const maxWsFrames = typeof params.maxWsFrames === "number" ? params.maxWsFrames : 200;
+    await startCapture(tabId, maxRequests, urlFilter, maxConsoleLogs, maxWsFrames);
     sendSuccessResult(id, { enabled: true, tabId });
   } catch (err2) {
     sendErrorResult(id, err2);
@@ -2283,6 +2477,18 @@ var handleBrowserClearConsoleLogs = (params, id) => {
     sendErrorResult(id, err2);
   }
 };
+var handleBrowserGetWebSocketFrames = (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const clear = typeof params.clear === "boolean" ? params.clear : false;
+    const frames = getWsFrames(tabId, clear);
+    sendSuccessResult(id, { frames });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
 
 // dist/browser-commands/tab-commands.js
 var handleBrowserListTabs = async (id) => {
@@ -2331,7 +2537,7 @@ var handleBrowserNavigateTab = async (params, id) => {
     if (url === null)
       return;
     const tab = await chrome.tabs.update(tabId, { url });
-    sendSuccessResult(id, { id: tab?.id ?? tabId, title: tab?.title ?? "", url: tab?.url ?? url });
+    sendSuccessResult(id, { id: tab?.id ?? tabId, title: tab?.title ?? "", url });
   } catch (err2) {
     sendErrorResult(id, err2);
   }
@@ -2449,8 +2655,10 @@ var injectLogRelay = async (tabId) => {
         const win = window;
         if (win[guard]) {
           const nonceSet = win.__opentabs_log_nonces;
-          if (nonceSet)
+          if (nonceSet) {
+            nonceSet.clear();
             nonceSet.add(n);
+          }
           return;
         }
         win[guard] = true;
@@ -2702,6 +2910,9 @@ var checkRateLimit = (method, now = Date.now()) => {
   const config = METHOD_LIMITS.get(method) ?? DEFAULT_LIMIT;
   const cutoff = now - config.windowMs;
   const timestamps = (methodTimestamps.get(method) ?? []).filter((t) => t > cutoff);
+  if (timestamps.length === 0) {
+    methodTimestamps.delete(method);
+  }
   if (timestamps.length >= config.maxRequests) {
     methodTimestamps.set(method, timestamps);
     return false;
@@ -3455,6 +3666,7 @@ var methodHandlers = /* @__PURE__ */ new Map([
   ["browser.deleteCookies", wrapAsync("browser.deleteCookies", handleBrowserDeleteCookies)],
   ["browser.enableNetworkCapture", wrapAsync("browser.enableNetworkCapture", handleBrowserEnableNetworkCapture)],
   ["browser.getNetworkRequests", wrapSync("browser.getNetworkRequests", handleBrowserGetNetworkRequests)],
+  ["browser.getWebSocketFrames", wrapSync("browser.getWebSocketFrames", handleBrowserGetWebSocketFrames)],
   ["browser.disableNetworkCapture", wrapSync("browser.disableNetworkCapture", handleBrowserDisableNetworkCapture)],
   ["browser.getConsoleLogs", wrapSync("browser.getConsoleLogs", handleBrowserGetConsoleLogs)],
   ["browser.clearConsoleLogs", wrapSync("browser.clearConsoleLogs", handleBrowserClearConsoleLogs)],
@@ -3540,7 +3752,6 @@ var handleOffscreenGetUrl = (_message, sendResponse) => {
   });
 };
 var handleWsState = (message, sendResponse) => {
-  const wasConnected = wsConnected;
   const nowConnected = message.connected;
   persistWsConnected(nowConnected);
   lastDisconnectReason = nowConnected ? void 0 : message.disconnectReason;
@@ -3551,7 +3762,7 @@ var handleWsState = (message, sendResponse) => {
       disconnectReason: lastDisconnectReason
     }
   });
-  if (!nowConnected && wasConnected) {
+  if (!nowConnected) {
     clearTabStateCache();
     clearAllConfirmationBadges();
   }
@@ -3623,11 +3834,20 @@ var handleSpConfirmationResponse = (message, sendResponse) => {
       params: message.data
     });
   }
-  clearConfirmationBadge();
+  const data = message.data;
+  const id = typeof data?.id === "string" ? data.id : void 0;
+  if (id !== void 0) {
+    clearConfirmationBackgroundTimeout(id);
+  }
+  clearConfirmationBadge(id);
   sendResponse({ ok: true });
 };
-var handleSpConfirmationTimeout = (_message, sendResponse) => {
-  clearConfirmationBadge();
+var handleSpConfirmationTimeout = (message, sendResponse) => {
+  const id = typeof message.id === "string" ? message.id : void 0;
+  if (id !== void 0) {
+    clearConfirmationBackgroundTimeout(id);
+  }
+  clearConfirmationBadge(id);
   sendResponse({ ok: true });
 };
 var handlePortChanged = (message, sendResponse) => {
@@ -3653,7 +3873,10 @@ var EXTENSION_ONLY_TYPES = /* @__PURE__ */ new Set([
   "ws:message",
   "bg:send",
   "bg:getConnectionState",
-  "offscreen:getLogs"
+  "offscreen:getLogs",
+  "sp:confirmationResponse",
+  "sp:confirmationTimeout",
+  "port-changed"
 ]);
 var initBackgroundMessageHandlers = () => {
   chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
@@ -3684,15 +3907,28 @@ var initSidePanelToggle = () => {
     chrome.sidePanel.onClosed.addListener(({ windowId }) => {
       openWindows.delete(windowId);
     });
+    chrome.windows.onRemoved.addListener((windowId) => {
+      openWindows.delete(windowId);
+    });
   }
   chrome.action.onClicked.addListener(({ windowId }) => {
-    if (canToggle && openWindows.has(windowId)) {
-      chrome.sidePanel.close({ windowId }).catch(() => {
-      });
-    } else {
-      chrome.sidePanel.open({ windowId }).catch(() => {
-      });
-    }
+    void (async () => {
+      if (canToggle && openWindows.has(windowId)) {
+        try {
+          await chrome.windows.get(windowId);
+        } catch {
+          openWindows.delete(windowId);
+          await chrome.sidePanel.open({ windowId }).catch(() => {
+          });
+          return;
+        }
+        chrome.sidePanel.close({ windowId }).catch(() => {
+        });
+      } else {
+        chrome.sidePanel.open({ windowId }).catch(() => {
+        });
+      }
+    })();
   });
 };
 
@@ -3752,14 +3988,14 @@ chrome.runtime.onInstalled.addListener(() => {
     await ensureOffscreenDocument();
     await setupKeepaliveAlarm();
     await reinjectStoredPlugins();
-  })();
+  })().catch((err2) => console.warn("[opentabs] onInstalled failed:", err2));
 });
 chrome.runtime.onStartup.addListener(() => {
   void (async () => {
     await ensureOffscreenDocument();
     await setupKeepaliveAlarm();
     await reinjectStoredPlugins();
-  })();
+  })().catch((err2) => console.warn("[opentabs] onStartup failed:", err2));
 });
 ensureOffscreenDocument().catch((err2) => console.warn("[opentabs] offscreen creation failed:", err2));
 setupKeepaliveAlarm().catch((err2) => console.warn("[opentabs] keepalive alarm failed:", err2));
@@ -3769,7 +4005,7 @@ chrome.storage.onChanged.addListener((changes, area) => {
   if (area !== "local")
     return;
   const portChange = changes[SERVER_PORT_KEY];
-  if (typeof portChange?.newValue === "number" && portChange.newValue > 0) {
+  if (typeof portChange?.newValue === "number" && Number.isInteger(portChange.newValue) && portChange.newValue >= 1 && portChange.newValue <= 65535) {
     const newUrl = buildWsUrl(portChange.newValue);
     chrome.runtime.sendMessage({ type: "ws:setUrl", url: newUrl }).catch(() => {
     });