@opentabs-dev/browser-extension 0.0.52 → 0.0.54

package/dist/background.js

@@ -1,5 +1,99 @@
+// dist/constants.js
+var KEEPALIVE_ALARM = "opentabs-keepalive";
+var KEEPALIVE_INTERVAL_MINUTES = 0.5;
+var PLUGINS_META_KEY = "plugins_meta";
+var WS_CONNECTED_KEY = "wsConnected";
+var SIDE_PANEL_OPEN_WINDOWS_KEY = "sidePanelOpenWindows";
+var SCRIPT_TIMEOUT_MS = 25e3;
+var MAX_SCRIPT_TIMEOUT_MS = 295e3;
+var IS_READY_TIMEOUT_MS = 5e3;
+var READINESS_POLL_INTERVAL_MS = 3e4;
+var RELOAD_FLUSH_DELAY_MS = 100;
+var INJECTION_RETRY_DELAY_MS = 200;
+var SCREENSHOT_RENDER_DELAY_MS = 100;
+var WS_FLUSH_DELAY_MS = 50;
+var SERVER_PORT_KEY = "serverPort";
+var DEFAULT_SERVER_PORT = 9515;
+var TEXT_PREVIEW_MAX_LENGTH = 200;
+var DEFAULT_WAIT_TIMEOUT_MS = 1e4;
+var POLL_INTERVAL_MS = 100;
+var DEFAULT_QUERY_LIMIT = 100;
+var MAX_INPUT_SIZE = 10 * 1024 * 1024;
+var SIDE_PANEL_TIMEOUT_MS = 3e3;
+var CDP_VERSION = "1.3";
+var EXEC_MAX_ASYNC_WAIT_MS = 1e4;
+var EXEC_POLL_INTERVAL_MS = 50;
+var EXEC_RESULT_TRUNCATION_LIMIT = 5e4;
+var DEFAULT_LOG_LIMIT = 100;
+var VALID_PLUGIN_NAME = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var isValidPluginName = (name) => VALID_PLUGIN_NAME.test(name);
+var buildWsUrl = (port) => `ws://localhost:${port}/ws`;
+
+// dist/side-panel-toggle.js
+var openWindows = /* @__PURE__ */ new Set();
+var persistOpenWindows = () => {
+  chrome.storage.session.set({ [SIDE_PANEL_OPEN_WINDOWS_KEY]: Array.from(openWindows) }).catch(() => {
+  });
+};
+var restoreOpenWindows = () => {
+  chrome.storage.session.get(SIDE_PANEL_OPEN_WINDOWS_KEY).then((data) => {
+    const stored = data[SIDE_PANEL_OPEN_WINDOWS_KEY];
+    if (Array.isArray(stored)) {
+      for (const id of stored) {
+        if (typeof id === "number") {
+          openWindows.add(id);
+        }
+      }
+    }
+  }).catch(() => {
+  });
+};
+var isSidePanelOpen = () => openWindows.size > 0;
+var initSidePanelToggle = () => {
+  chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: false }).catch(() => {
+  });
+  const canToggle = "onOpened" in chrome.sidePanel;
+  if (canToggle) {
+    restoreOpenWindows();
+    chrome.sidePanel.onOpened.addListener(({ windowId }) => {
+      openWindows.add(windowId);
+      persistOpenWindows();
+    });
+    chrome.sidePanel.onClosed.addListener(({ windowId }) => {
+      openWindows.delete(windowId);
+      persistOpenWindows();
+    });
+    chrome.windows.onRemoved.addListener((windowId) => {
+      openWindows.delete(windowId);
+      persistOpenWindows();
+    });
+  }
+  chrome.action.onClicked.addListener(({ windowId }) => {
+    void (async () => {
+      if (canToggle && openWindows.has(windowId)) {
+        try {
+          await chrome.windows.get(windowId);
+        } catch {
+          openWindows.delete(windowId);
+          persistOpenWindows();
+          await chrome.sidePanel.open({ windowId }).catch(() => {
+          });
+          return;
+        }
+        chrome.sidePanel.close({ windowId }).catch(() => {
+        });
+      } else {
+        chrome.sidePanel.open({ windowId }).catch(() => {
+        });
+      }
+    })();
+  });
+};
+
 // dist/confirmation-badge.js
 var pendingConfirmationCount = 0;
+var NOTIFICATION_ID = "opentabs-confirmation";
+var pendingConfirmations = /* @__PURE__ */ new Map();
 var confirmationTimeouts = /* @__PURE__ */ new Map();
 var clearedConfirmationIds = /* @__PURE__ */ new Set();
 var CONFIRMATION_BACKGROUND_TIMEOUT_BUFFER_MS = 2e3;
@@ -15,11 +109,39 @@ var updateConfirmationBadge = () => {
     });
   }
 };
+var syncConfirmationNotification = () => {
+  if (pendingConfirmationCount <= 0 || isSidePanelOpen()) {
+    chrome.notifications.clear(NOTIFICATION_ID).catch(() => {
+    });
+    return;
+  }
+  let message;
+  if (pendingConfirmationCount === 1 && pendingConfirmations.size === 1) {
+    const info = pendingConfirmations.values().next().value;
+    message = info.domain ? `${info.tool} on ${info.domain}` : info.tool;
+  } else if (pendingConfirmationCount > 1) {
+    message = `${pendingConfirmationCount} tools awaiting approval`;
+  } else {
+    message = "1 tool awaiting approval";
+  }
+  chrome.notifications.create(NOTIFICATION_ID, {
+    type: "basic",
+    iconUrl: chrome.runtime.getURL("icons/icon-128.png"),
+    title: "OpenTabs \u2014 Approval Required",
+    message,
+    priority: 2,
+    requireInteraction: true
+  }).catch(() => {
+  });
+};
 var notifyConfirmationRequest = (params) => {
   const tool = typeof params.tool === "string" ? params.tool : "unknown tool";
-  const domain = typeof params.domain === "string" ? params.domain : "unknown domain";
+  const domain = typeof params.domain === "string" ? params.domain : null;
   const id = typeof params.id === "string" ? params.id : String(Date.now());
+  const tabId = typeof params.tabId === "number" ? params.tabId : void 0;
+  const paramsPreview = typeof params.paramsPreview === "string" ? params.paramsPreview : "";
   const timeoutMs = typeof params.timeoutMs === "number" ? params.timeoutMs : 0;
+  const receivedAt = Date.now();
   const existingTimeoutId = confirmationTimeouts.get(id);
   if (existingTimeoutId !== void 0) {
     clearTimeout(existingTimeoutId);
@@ -28,6 +150,7 @@ var notifyConfirmationRequest = (params) => {
     pendingConfirmationCount++;
     updateConfirmationBadge();
   }
+  pendingConfirmations.set(id, { id, tool, domain, tabId, paramsPreview, timeoutMs, receivedAt });
   const effectiveTimeoutMs = timeoutMs > 0 ? timeoutMs : CONFIRMATION_FALLBACK_TIMEOUT_MS;
   const bgTimeoutId = setTimeout(() => {
     confirmationTimeouts.delete(id);
@@ -35,15 +158,7 @@ var notifyConfirmationRequest = (params) => {
     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",
-    message: `${tool} on ${domain} \u2014 Click to open side panel`,
-    priority: 2,
-    requireInteraction: true
-  }).catch(() => {
-  });
+  syncConfirmationNotification();
 };
 var clearConfirmationBadge = (id) => {
   if (id !== void 0) {
@@ -51,11 +166,11 @@ var clearConfirmationBadge = (id) => {
       return;
     }
     clearedConfirmationIds.add(id);
-    chrome.notifications.clear(`opentabs-confirm-${id}`).catch(() => {
-    });
+    pendingConfirmations.delete(id);
   }
   pendingConfirmationCount = Math.max(0, pendingConfirmationCount - 1);
   updateConfirmationBadge();
+  syncConfirmationNotification();
   if (id !== void 0 && !confirmationTimeouts.has(id)) {
     clearedConfirmationIds.delete(id);
   }
@@ -69,19 +184,20 @@ var clearConfirmationBackgroundTimeout = (id) => {
   }
 };
 var clearAllConfirmationBadges = () => {
-  for (const [id, timeoutId] of confirmationTimeouts.entries()) {
+  for (const [, timeoutId] of confirmationTimeouts.entries()) {
     clearTimeout(timeoutId);
-    chrome.notifications.clear(`opentabs-confirm-${id}`).catch(() => {
-    });
   }
   confirmationTimeouts.clear();
   clearedConfirmationIds.clear();
+  pendingConfirmations.clear();
   pendingConfirmationCount = 0;
   updateConfirmationBadge();
+  chrome.notifications.clear(NOTIFICATION_ID).catch(() => {
+  });
 };
 var initConfirmationBadge = () => {
   chrome.notifications.onClicked.addListener((notificationId) => {
-    if (notificationId.startsWith("opentabs-confirm-")) {
+    if (notificationId === NOTIFICATION_ID) {
       chrome.windows.getCurrent().then((w) => {
         if (w.id !== void 0) {
           chrome.sidePanel.open({ windowId: w.id }).catch(() => {
@@ -94,36 +210,7 @@ var initConfirmationBadge = () => {
     }
   });
 };
-
-// dist/constants.js
-var KEEPALIVE_ALARM = "opentabs-keepalive";
-var KEEPALIVE_INTERVAL_MINUTES = 0.5;
-var PLUGINS_META_KEY = "plugins_meta";
-var WS_CONNECTED_KEY = "wsConnected";
-var SIDE_PANEL_OPEN_WINDOWS_KEY = "sidePanelOpenWindows";
-var SCRIPT_TIMEOUT_MS = 25e3;
-var MAX_SCRIPT_TIMEOUT_MS = 295e3;
-var IS_READY_TIMEOUT_MS = 5e3;
-var RELOAD_FLUSH_DELAY_MS = 100;
-var INJECTION_RETRY_DELAY_MS = 200;
-var SCREENSHOT_RENDER_DELAY_MS = 100;
-var WS_FLUSH_DELAY_MS = 50;
-var SERVER_PORT_KEY = "serverPort";
-var DEFAULT_SERVER_PORT = 9515;
-var TEXT_PREVIEW_MAX_LENGTH = 200;
-var DEFAULT_WAIT_TIMEOUT_MS = 1e4;
-var POLL_INTERVAL_MS = 100;
-var DEFAULT_QUERY_LIMIT = 100;
-var MAX_INPUT_SIZE = 10 * 1024 * 1024;
-var SIDE_PANEL_TIMEOUT_MS = 3e3;
-var CDP_VERSION = "1.3";
-var EXEC_MAX_ASYNC_WAIT_MS = 1e4;
-var EXEC_POLL_INTERVAL_MS = 50;
-var EXEC_RESULT_TRUNCATION_LIMIT = 5e4;
-var DEFAULT_LOG_LIMIT = 100;
-var VALID_PLUGIN_NAME = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-var isValidPluginName = (name) => VALID_PLUGIN_NAME.test(name);
-var buildWsUrl = (port) => `ws://localhost:${port}/ws`;
+var getPendingConfirmations = () => [...pendingConfirmations.values()];
 
 // dist/json-rpc-errors.js
 var JSONRPC_METHOD_NOT_FOUND = -32601;
@@ -1185,6 +1272,20 @@ var findAllMatchingTabs = async (plugin) => {
 // dist/tab-state.js
 var serializeTabState = (info) => JSON.stringify({ state: info.state, tabs: info.tabs });
 var lastKnownState = /* @__PURE__ */ new Map();
+var LAST_KNOWN_STATE_SESSION_KEY = "lastKnownState";
+var lastKnownStatePersistTimer;
+var persistLastKnownStateToSession = () => {
+  chrome.storage.session.set({ [LAST_KNOWN_STATE_SESSION_KEY]: Object.fromEntries(lastKnownState) }).catch(() => {
+  });
+};
+var scheduleLastKnownStatePersist = () => {
+  if (lastKnownStatePersistTimer !== void 0)
+    clearTimeout(lastKnownStatePersistTimer);
+  lastKnownStatePersistTimer = setTimeout(() => {
+    lastKnownStatePersistTimer = void 0;
+    persistLastKnownStateToSession();
+  }, 500);
+};
 var pluginLocks = /* @__PURE__ */ new Map();
 var withPluginLock = (pluginName, fn) => {
   const prev = pluginLocks.get(pluginName) ?? Promise.resolve();
@@ -1238,33 +1339,45 @@ var computePluginTabState = async (plugin) => {
   if (matchingTabs.length === 0) {
     return { state: "closed", tabs: [] };
   }
-  const tabInfos = [];
-  for (const tab of matchingTabs) {
-    if (tab.id === void 0)
-      continue;
+  const validTabs = matchingTabs.filter((tab) => tab.id !== void 0);
+  const results = await Promise.allSettled(validTabs.map(async (tab) => {
     let ready = false;
     try {
       ready = await probeTabReadiness(tab.id, plugin.name);
     } catch (err2) {
       console.warn(`[opentabs] computePluginTabState failed for plugin ${plugin.name} in tab ${tab.id}:`, err2);
     }
-    tabInfos.push({
+    return {
       tabId: tab.id,
       url: tab.url ?? "",
       title: tab.title ?? "",
       ready
-    });
+    };
+  }));
+  const tabInfos = [];
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      tabInfos.push(result.value);
+    }
   }
   const hasReady = tabInfos.some((t) => t.ready);
   const state = hasReady ? "ready" : "unavailable";
   return { state, tabs: tabInfos };
 };
 var sendTabSyncAll = async () => {
+  const syncAllStart = Date.now();
+  console.log("[opentabs:timing] sendTabSyncAll started");
   const index = await getAllPluginMeta();
   const plugins = Object.values(index);
   if (plugins.length === 0)
     return;
-  const settled = await Promise.allSettled(plugins.map(async (plugin) => [plugin.name, await computePluginTabState(plugin)]));
+  const settled = await Promise.allSettled(plugins.map(async (plugin) => {
+    const t0 = Date.now();
+    const result = [plugin.name, await computePluginTabState(plugin)];
+    console.log(`[opentabs:timing] computePluginTabState(${plugin.name}): ${Date.now() - t0}ms`);
+    return result;
+  }));
+  console.log(`[opentabs:timing] all probes done: +${Date.now() - syncAllStart}ms`);
   const entries = [];
   for (const result of settled) {
     if (result.status === "fulfilled") {
@@ -1281,15 +1394,20 @@ var sendTabSyncAll = async () => {
     pluginNamesInSync.add(pluginName);
     return withPluginLock(pluginName, () => {
       lastKnownState.set(pluginName, serializeTabState(stateInfo));
+      scheduleLastKnownStatePersist();
       return Promise.resolve();
     });
   }));
+  let removedStale = false;
   for (const key of lastKnownState.keys()) {
     if (!pluginNamesInSync.has(key)) {
       lastKnownState.delete(key);
       pluginLocks.delete(key);
+      removedStale = true;
     }
   }
+  if (removedStale)
+    scheduleLastKnownStatePersist();
   sendToServer({
     jsonrpc: "2.0",
     method: "tab.syncAll",
@@ -1306,23 +1424,56 @@ var sendTabSyncAll = async () => {
     });
   }
 };
+var flushLastKnownStateToSession = () => {
+  if (lastKnownStatePersistTimer !== void 0) {
+    clearTimeout(lastKnownStatePersistTimer);
+    lastKnownStatePersistTimer = void 0;
+  }
+  persistLastKnownStateToSession();
+};
 var clearTabStateCache = () => {
   lastKnownState.clear();
   pluginLocks.clear();
+  if (lastKnownStatePersistTimer !== void 0) {
+    clearTimeout(lastKnownStatePersistTimer);
+    lastKnownStatePersistTimer = void 0;
+  }
+  chrome.storage.session.remove(LAST_KNOWN_STATE_SESSION_KEY).catch(() => {
+  });
 };
 var clearPluginTabState = (pluginName) => {
+  const had = lastKnownState.has(pluginName);
   lastKnownState.delete(pluginName);
   pluginLocks.delete(pluginName);
+  if (had)
+    scheduleLastKnownStatePersist();
 };
 var updateLastKnownState = (pluginName, stateInfo) => withPluginLock(pluginName, () => {
   lastKnownState.set(pluginName, serializeTabState(stateInfo));
+  scheduleLastKnownStatePersist();
   return Promise.resolve();
 });
 var getLastKnownStates = () => lastKnownState;
+var loadLastKnownStateFromSession = async () => {
+  lastKnownState.clear();
+  try {
+    const data = await chrome.storage.session.get(LAST_KNOWN_STATE_SESSION_KEY);
+    const stored = data[LAST_KNOWN_STATE_SESSION_KEY];
+    if (stored && typeof stored === "object" && !Array.isArray(stored)) {
+      for (const [key, value] of Object.entries(stored)) {
+        if (typeof value === "string") {
+          lastKnownState.set(key, value);
+        }
+      }
+    }
+  } catch {
+  }
+};
 var getAggregateState = (serialized) => {
   try {
     const parsed = JSON.parse(serialized);
-    return parsed.state;
+    const validStates = /* @__PURE__ */ new Set(["closed", "unavailable", "ready"]);
+    return validStates.has(parsed.state) ? parsed.state : "closed";
   } catch {
     return "closed";
   }
@@ -1335,6 +1486,7 @@ var notifyAffectedPlugins = async (affectedPlugins) => {
     if (previous === serialized)
       return;
     lastKnownState.set(plugin.name, serialized);
+    scheduleLastKnownStatePersist();
     sendTabStateNotification(plugin.name, newState);
   })));
 };
@@ -1382,6 +1534,46 @@ var checkTabChanged = async (changedTabId, changeInfo) => {
     return;
   await notifyAffectedPlugins(affectedPlugins);
 };
+var readinessPollTimer;
+var readinessPollRunning = false;
+var runReadinessPoll = async () => {
+  if (readinessPollRunning)
+    return;
+  readinessPollRunning = true;
+  try {
+    const index = await getAllPluginMeta();
+    const plugins = Object.values(index);
+    if (plugins.length === 0)
+      return;
+    const activePlugins = plugins.filter((p) => {
+      const cached = lastKnownState.get(p.name);
+      return cached !== void 0 && getAggregateState(cached) !== "closed";
+    });
+    if (activePlugins.length === 0)
+      return;
+    await notifyAffectedPlugins(activePlugins);
+  } catch (err2) {
+    console.warn("[opentabs] readiness poll failed:", err2);
+  } finally {
+    readinessPollRunning = false;
+  }
+};
+var startReadinessPoll = () => {
+  if (readinessPollTimer !== void 0)
+    return;
+  readinessPollTimer = setInterval(() => {
+    runReadinessPoll().catch((err2) => {
+      console.warn("[opentabs] readiness poll tick failed:", err2);
+    });
+  }, READINESS_POLL_INTERVAL_MS);
+};
+var stopReadinessPoll = () => {
+  if (readinessPollTimer !== void 0) {
+    clearInterval(readinessPollTimer);
+    readinessPollTimer = void 0;
+  }
+  readinessPollRunning = false;
+};
 
 // dist/browser-commands/extension-commands.js
 var handleExtensionGetState = async (id) => {
@@ -1450,7 +1642,8 @@ var handleExtensionGetLogs = async (params, id) => {
     if (typeof params.since === "number") {
       filterOptions.since = params.since;
     }
-    const bgEntries = bgLogCollector.getEntries(filterOptions);
+    const { limit: _, ...sourceOptions } = filterOptions;
+    const bgEntries = bgLogCollector.getEntries(sourceOptions);
     const bgStats = bgLogCollector.getStats();
     let offscreenEntries = [];
     let offscreenStats = {
@@ -1462,7 +1655,7 @@ var handleExtensionGetLogs = async (params, id) => {
     try {
       const raw = await chrome.runtime.sendMessage({
         type: "offscreen:getLogs",
-        options: Object.keys(filterOptions).length > 0 ? filterOptions : void 0
+        options: Object.keys(sourceOptions).length > 0 ? sourceOptions : void 0
       });
       const response = raw;
       if (response && Array.isArray(response.entries)) {
@@ -2222,6 +2415,42 @@ var handleBrowserHandleDialog = async (params, id) => {
 };
 
 // dist/browser-commands/key-press-command.js
+var SHIFTED_PUNCTUATION_CODES = {
+  "!": "Digit1",
+  "@": "Digit2",
+  "#": "Digit3",
+  $: "Digit4",
+  "%": "Digit5",
+  "^": "Digit6",
+  "&": "Digit7",
+  "*": "Digit8",
+  "(": "Digit9",
+  ")": "Digit0",
+  _: "Minus",
+  "+": "Equal",
+  "{": "BracketLeft",
+  "}": "BracketRight",
+  "|": "Backslash",
+  ":": "Semicolon",
+  '"': "Quote",
+  "<": "Comma",
+  ">": "Period",
+  "?": "Slash",
+  "~": "Backquote"
+};
+var UNSHIFTED_PUNCTUATION_CODES = {
+  "-": "Minus",
+  "=": "Equal",
+  "[": "BracketLeft",
+  "]": "BracketRight",
+  "\\": "Backslash",
+  ";": "Semicolon",
+  "'": "Quote",
+  ",": "Comma",
+  ".": "Period",
+  "/": "Slash",
+  "`": "Backquote"
+};
 var handleBrowserPressKey = async (params, id) => {
   try {
     const tabId = requireTabId(params, id);
@@ -2239,7 +2468,7 @@ var handleBrowserPressKey = async (params, id) => {
     const results = await chrome.scripting.executeScript({
       target: { tabId },
       world: "MAIN",
-      func: (k, sel, shift, ctrl, alt, meta) => {
+      func: (k, sel, shift, ctrl, alt, meta, shiftedPunct, unshiftedPunct) => {
         let target = null;
         if (sel) {
           target = document.querySelector(sel);
@@ -2258,7 +2487,7 @@ var handleBrowserPressKey = async (params, id) => {
               return `Digit${k2}`;
             if (k2 === " ")
               return "Space";
-            return k2;
+            return shiftedPunct[k2] ?? unshiftedPunct[k2] ?? k2;
           }
           return k2;
         };
@@ -2343,7 +2572,7 @@ var handleBrowserPressKey = async (params, id) => {
           }
         };
       },
-      args: [key, selector, shiftKey, ctrlKey, altKey, metaKey]
+      args: [key, selector, shiftKey, ctrlKey, altKey, metaKey, SHIFTED_PUNCTUATION_CODES, UNSHIFTED_PUNCTUATION_CODES]
     });
     const result = extractScriptResult(results, id);
     if (!result)
@@ -2954,6 +3183,208 @@ var checkRateLimit = (method, now = Date.now()) => {
   return true;
 };
 
+// dist/server-request.js
+var REQUEST_TIMEOUT_MS = 3e4;
+var pendingRequests = /* @__PURE__ */ new Map();
+var nextId = 1;
+var sendServerRequest = (method, params = {}) => {
+  const id = nextId++;
+  const data = { jsonrpc: "2.0", method, params, id };
+  return new Promise((resolve, reject) => {
+    const timerId = setTimeout(() => {
+      if (pendingRequests.has(id)) {
+        pendingRequests.delete(id);
+        reject(new Error(`Request ${method} timed out after ${REQUEST_TIMEOUT_MS}ms`));
+      }
+    }, REQUEST_TIMEOUT_MS);
+    pendingRequests.set(id, { resolve, reject, timerId });
+    sendToServer(data);
+  });
+};
+var consumeServerResponse = (data) => {
+  if (data.method !== void 0)
+    return false;
+  const rawId = data.id;
+  if (rawId === void 0 || rawId === null)
+    return false;
+  const id = typeof rawId === "number" ? rawId : void 0;
+  if (id === void 0)
+    return false;
+  const pending = pendingRequests.get(id);
+  if (!pending)
+    return false;
+  pendingRequests.delete(id);
+  clearTimeout(pending.timerId);
+  if (data.error !== void 0 && data.error !== null) {
+    const err2 = data.error;
+    pending.reject(new Error(err2.message ?? "Unknown server error"));
+  } else {
+    pending.resolve(data.result);
+  }
+  return true;
+};
+var rejectAllPendingServerRequests = () => {
+  for (const [id, pending] of pendingRequests) {
+    pendingRequests.delete(id);
+    clearTimeout(pending.timerId);
+    pending.reject(new Error("Server disconnected"));
+  }
+};
+
+// dist/server-state-cache.js
+var SESSION_KEY = "serverStateCache";
+var CACHES_INITIALIZED_KEY = "cachesInitialized";
+var EMPTY_CACHE = {
+  plugins: [],
+  failedPlugins: [],
+  browserTools: [],
+  serverVersion: void 0
+};
+var cache = { ...EMPTY_CACHE };
+var pendingPluginToolUpdates = /* @__PURE__ */ new Map();
+var pendingBrowserToolUpdates = /* @__PURE__ */ new Map();
+var reapplyPendingOptimisticUpdates = () => {
+  if (pendingPluginToolUpdates.size > 0) {
+    cache = {
+      ...cache,
+      plugins: cache.plugins.map((plugin) => {
+        const toolOverrides = pendingPluginToolUpdates.get(plugin.name);
+        if (!toolOverrides)
+          return plugin;
+        return {
+          ...plugin,
+          tools: plugin.tools.map((tool) => {
+            const override = toolOverrides.get(tool.name);
+            return override !== void 0 ? { ...tool, enabled: override } : tool;
+          })
+        };
+      })
+    };
+  }
+  if (pendingBrowserToolUpdates.size > 0) {
+    cache = {
+      ...cache,
+      browserTools: cache.browserTools.map((bt) => {
+        const override = pendingBrowserToolUpdates.get(bt.name);
+        return override !== void 0 ? { ...bt, enabled: override } : bt;
+      })
+    };
+  }
+};
+var addPendingPluginToolUpdate = (plugin, tool, enabled) => {
+  let toolMap = pendingPluginToolUpdates.get(plugin);
+  if (!toolMap) {
+    toolMap = /* @__PURE__ */ new Map();
+    pendingPluginToolUpdates.set(plugin, toolMap);
+  }
+  toolMap.set(tool, enabled);
+};
+var removePendingPluginToolUpdate = (plugin, tool) => {
+  const toolMap = pendingPluginToolUpdates.get(plugin);
+  if (!toolMap)
+    return;
+  toolMap.delete(tool);
+  if (toolMap.size === 0)
+    pendingPluginToolUpdates.delete(plugin);
+};
+var addPendingPluginAllToolsUpdate = (plugin, toolNames, enabled) => {
+  let toolMap = pendingPluginToolUpdates.get(plugin);
+  if (!toolMap) {
+    toolMap = /* @__PURE__ */ new Map();
+    pendingPluginToolUpdates.set(plugin, toolMap);
+  }
+  for (const name of toolNames) {
+    toolMap.set(name, enabled);
+  }
+};
+var removePendingPluginAllToolsUpdate = (plugin, toolNames) => {
+  const toolMap = pendingPluginToolUpdates.get(plugin);
+  if (!toolMap)
+    return;
+  for (const name of toolNames) {
+    toolMap.delete(name);
+  }
+  if (toolMap.size === 0)
+    pendingPluginToolUpdates.delete(plugin);
+};
+var addPendingBrowserToolUpdate = (tool, enabled) => {
+  pendingBrowserToolUpdates.set(tool, enabled);
+};
+var removePendingBrowserToolUpdate = (tool) => {
+  pendingBrowserToolUpdates.delete(tool);
+};
+var addPendingAllBrowserToolsUpdate = (toolNames, enabled) => {
+  for (const name of toolNames) {
+    pendingBrowserToolUpdates.set(name, enabled);
+  }
+};
+var removePendingAllBrowserToolsUpdate = (toolNames) => {
+  for (const name of toolNames) {
+    pendingBrowserToolUpdates.delete(name);
+  }
+};
+var cachesInitialized = false;
+var persistTimer;
+var persistToSession = () => {
+  chrome.storage.session.set({ [SESSION_KEY]: cache, [CACHES_INITIALIZED_KEY]: cachesInitialized }).catch(() => {
+  });
+};
+var schedulePersist = () => {
+  if (persistTimer !== void 0)
+    clearTimeout(persistTimer);
+  persistTimer = setTimeout(() => {
+    persistTimer = void 0;
+    persistToSession();
+  }, 500);
+};
+var getServerStateCache = () => structuredClone(cache);
+var updateServerStateCache = (partial) => {
+  cache = { ...cache, ...partial };
+  reapplyPendingOptimisticUpdates();
+  schedulePersist();
+};
+var flushServerStateCacheToSession = () => {
+  if (persistTimer !== void 0) {
+    clearTimeout(persistTimer);
+    persistTimer = void 0;
+  }
+  persistToSession();
+};
+var clearServerStateCache = () => {
+  cache = { ...EMPTY_CACHE };
+  cachesInitialized = false;
+  pendingPluginToolUpdates.clear();
+  pendingBrowserToolUpdates.clear();
+  if (persistTimer !== void 0) {
+    clearTimeout(persistTimer);
+    persistTimer = void 0;
+  }
+  chrome.storage.session.remove([SESSION_KEY, CACHES_INITIALIZED_KEY]).catch(() => {
+  });
+};
+var loadServerStateCacheFromSession = async () => {
+  try {
+    const data = await chrome.storage.session.get([SESSION_KEY, CACHES_INITIALIZED_KEY]);
+    const stored = data[SESSION_KEY];
+    if (stored && typeof stored === "object") {
+      cache = {
+        plugins: Array.isArray(stored.plugins) ? stored.plugins : [],
+        failedPlugins: Array.isArray(stored.failedPlugins) ? stored.failedPlugins : [],
+        browserTools: Array.isArray(stored.browserTools) ? stored.browserTools : [],
+        serverVersion: typeof stored.serverVersion === "string" ? stored.serverVersion : void 0
+      };
+    }
+    if (typeof data[CACHES_INITIALIZED_KEY] === "boolean") {
+      cachesInitialized = data[CACHES_INITIALIZED_KEY];
+    }
+  } catch {
+  }
+};
+var getCachesInitialized = () => cachesInitialized;
+var setCachesInitialized = (value) => {
+  cachesInitialized = value;
+};
+
 // dist/dispatch-helpers.js
 var isAdapterNotReady = (result) => result.type === "error" && result.code === JSONRPC_ADAPTER_NOT_READY;
 var resolvePlugin = async (pluginName, id) => {
@@ -2968,26 +3399,6 @@ var resolvePlugin = async (pluginName, id) => {
   }
   return plugin;
 };
-var executeWithTimeout = async (scriptPromise, timeoutMs, fallbackMessage) => {
-  let timeoutId;
-  const timeoutPromise = new Promise((_resolve, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new Error(`Script execution timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-  });
-  let results;
-  try {
-    results = await Promise.race([scriptPromise, timeoutPromise]);
-  } finally {
-    clearTimeout(timeoutId);
-  }
-  const firstResult = results[0];
-  const result = firstResult?.result;
-  if (!result || typeof result !== "object" || !("type" in result)) {
-    return { type: "error", code: JSONRPC_INTERNAL_ERROR, message: fallbackMessage };
-  }
-  return result;
-};
 var dispatchWithTabFallback = async (config) => {
   const { id, pluginName, plugin, operationName, executeOnTab } = config;
   const matchingTabs = await findAllMatchingTabs(plugin);
@@ -3113,202 +3524,6 @@ var dispatchToTargetedTab = async (config) => {
   }
 };
 
-// dist/resource-prompt-dispatch.js
-var executeResourceReadOnTab = async (tabId, pluginName, resourceUri) => {
-  const scriptPromise = chrome.scripting.executeScript({
-    target: { tabId },
-    world: "MAIN",
-    func: async (pName, uri) => {
-      const ot = globalThis.__openTabs;
-      const adapter = ot?.adapters?.[pName];
-      if (!adapter || typeof adapter !== "object") {
-        return { type: "error", code: -32002, message: `Adapter "${pName}" not injected or not ready` };
-      }
-      if (!Object.isFrozen(adapter)) {
-        return {
-          type: "error",
-          code: -32002,
-          message: `Adapter "${pName}" failed integrity check (not frozen)`
-        };
-      }
-      if (typeof adapter.isReady !== "function") {
-        return { type: "error", code: -32002, message: `Adapter "${pName}" has no isReady function` };
-      }
-      let ready;
-      try {
-        ready = await adapter.isReady();
-      } catch {
-        return { type: "error", code: -32002, message: `Adapter "${pName}" isReady() threw an error` };
-      }
-      if (!ready) {
-        return {
-          type: "error",
-          code: -32002,
-          message: `Plugin "${pName}" is not ready (state: unavailable)`
-        };
-      }
-      if (!Array.isArray(adapter.resources)) {
-        return { type: "error", code: -32603, message: `Adapter "${pName}" has no resources array` };
-      }
-      const resource = adapter.resources.find((r) => r.uri === uri);
-      if (!resource || typeof resource.read !== "function") {
-        return { type: "error", code: -32603, message: `Resource "${uri}" not found in adapter "${pName}"` };
-      }
-      try {
-        const output = await resource.read(uri);
-        return { type: "success", output };
-      } catch (err2) {
-        const caughtError = err2;
-        return {
-          type: "error",
-          code: -32603,
-          message: caughtError.message ?? "Resource read failed"
-        };
-      }
-    },
-    args: [pluginName, resourceUri]
-  });
-  return executeWithTimeout(scriptPromise, SCRIPT_TIMEOUT_MS, "No result from resource read");
-};
-var executePromptGetOnTab = async (tabId, pluginName, promptName, promptArgs) => {
-  const scriptPromise = chrome.scripting.executeScript({
-    target: { tabId },
-    world: "MAIN",
-    func: async (pName, pPromptName, pArgs) => {
-      const ot = globalThis.__openTabs;
-      const adapter = ot?.adapters?.[pName];
-      if (!adapter || typeof adapter !== "object") {
-        return { type: "error", code: -32002, message: `Adapter "${pName}" not injected or not ready` };
-      }
-      if (!Object.isFrozen(adapter)) {
-        return {
-          type: "error",
-          code: -32002,
-          message: `Adapter "${pName}" failed integrity check (not frozen)`
-        };
-      }
-      if (typeof adapter.isReady !== "function") {
-        return { type: "error", code: -32002, message: `Adapter "${pName}" has no isReady function` };
-      }
-      let ready;
-      try {
-        ready = await adapter.isReady();
-      } catch {
-        return { type: "error", code: -32002, message: `Adapter "${pName}" isReady() threw an error` };
-      }
-      if (!ready) {
-        return {
-          type: "error",
-          code: -32002,
-          message: `Plugin "${pName}" is not ready (state: unavailable)`
-        };
-      }
-      if (!Array.isArray(adapter.prompts)) {
-        return { type: "error", code: -32603, message: `Adapter "${pName}" has no prompts array` };
-      }
-      const prompt = adapter.prompts.find((p) => p.name === pPromptName);
-      if (!prompt || typeof prompt.render !== "function") {
-        return {
-          type: "error",
-          code: -32603,
-          message: `Prompt "${pPromptName}" not found in adapter "${pName}"`
-        };
-      }
-      try {
-        const output = await prompt.render(pArgs);
-        return { type: "success", output };
-      } catch (err2) {
-        const caughtError = err2;
-        return {
-          type: "error",
-          code: -32603,
-          message: caughtError.message ?? "Prompt render failed"
-        };
-      }
-    },
-    args: [pluginName, promptName, promptArgs]
-  });
-  return executeWithTimeout(scriptPromise, SCRIPT_TIMEOUT_MS, "No result from prompt render");
-};
-var handleResourceRead = async (params, id) => {
-  const pluginName = requireStringParam(params, "plugin", id);
-  if (!pluginName)
-    return;
-  const resourceUri = requireStringParam(params, "uri", id);
-  if (!resourceUri)
-    return;
-  const rawTabId = params.tabId;
-  const targetTabId = typeof rawTabId === "number" && Number.isInteger(rawTabId) && rawTabId > 0 ? rawTabId : void 0;
-  const plugin = await resolvePlugin(pluginName, id);
-  if (!plugin)
-    return;
-  const executeOnTab = (tid) => executeResourceReadOnTab(tid, pluginName, resourceUri);
-  if (targetTabId !== void 0) {
-    await dispatchToTargetedTab({
-      id,
-      pluginName,
-      plugin,
-      tabId: targetTabId,
-      operationName: "resource read",
-      executeOnTab
-    });
-  } else {
-    await dispatchWithTabFallback({
-      id,
-      pluginName,
-      plugin,
-      operationName: "resource read",
-      executeOnTab
-    });
-  }
-};
-var handlePromptGet = async (params, id) => {
-  const pluginName = requireStringParam(params, "plugin", id);
-  if (!pluginName)
-    return;
-  const promptName = requireStringParam(params, "prompt", id);
-  if (!promptName)
-    return;
-  const rawArgs = params.arguments;
-  if (rawArgs !== void 0 && rawArgs !== null && (typeof rawArgs !== "object" || Array.isArray(rawArgs))) {
-    sendToServer({
-      jsonrpc: "2.0",
-      error: { code: JSONRPC_INVALID_PARAMS, message: 'Invalid "arguments" param (expected object)' },
-      id
-    });
-    return;
-  }
-  const rawObj = rawArgs ?? {};
-  const promptArgs = {};
-  for (const [key, val] of Object.entries(rawObj)) {
-    promptArgs[key] = String(val);
-  }
-  const rawTabId = params.tabId;
-  const targetTabId = typeof rawTabId === "number" && Number.isInteger(rawTabId) && rawTabId > 0 ? rawTabId : void 0;
-  const plugin = await resolvePlugin(pluginName, id);
-  if (!plugin)
-    return;
-  const executeOnTab = (tid) => executePromptGetOnTab(tid, pluginName, promptName, promptArgs);
-  if (targetTabId !== void 0) {
-    await dispatchToTargetedTab({
-      id,
-      pluginName,
-      plugin,
-      tabId: targetTabId,
-      operationName: "prompt get",
-      executeOnTab
-    });
-  } else {
-    await dispatchWithTabFallback({
-      id,
-      pluginName,
-      plugin,
-      operationName: "prompt get",
-      executeOnTab
-    });
-  }
-};
-
 // dist/tool-dispatch.js
 var progressCallbacks = /* @__PURE__ */ new Map();
 var notifyDispatchProgress = (dispatchId) => {
@@ -3505,7 +3720,7 @@ var executeToolOnTab = async (tabId, pluginName, toolName, input, dispatchId) =>
   return result;
 };
 var handleToolDispatch = async (params, id) => {
-  const dispatchId = typeof params.dispatchId === "string" ? params.dispatchId : String(id);
+  const dispatchId = typeof params.__opentabs_dispatchId === "string" ? params.__opentabs_dispatchId : String(id);
   const pluginName = requireStringParam(params, "plugin", id);
   if (!pluginName)
     return;
@@ -3601,7 +3816,6 @@ var wrapNotification = (method, fn) => (params) => {
   fn(params).catch((err2) => console.warn(`[opentabs] ${method} handler failed:`, err2));
 };
 var SIDE_PANEL_METHODS = /* @__PURE__ */ new Set([
-  "tab.stateChanged",
   "tool.invocationStart",
   "tool.invocationEnd",
   "plugins.changed",
@@ -3635,13 +3849,18 @@ var validatePluginPayload = (raw) => {
     return null;
   }
   const urlPatterns = Array.isArray(obj.urlPatterns) ? obj.urlPatterns.filter((p) => typeof p === "string") : [];
-  const tools = Array.isArray(obj.tools) ? obj.tools.filter((t) => typeof t === "object" && t !== null && typeof t.name === "string" && typeof t.description === "string" && typeof t.enabled === "boolean").map((t) => ({
-    name: t.name,
-    displayName: typeof t.displayName === "string" ? t.displayName : t.name,
-    description: t.description,
-    icon: typeof t.icon === "string" ? t.icon : "wrench",
-    enabled: t.enabled
-  })) : [];
+  const tools = Array.isArray(obj.tools) ? obj.tools.filter((t) => typeof t === "object" && t !== null && typeof t.name === "string" && typeof t.description === "string").map((t) => {
+    if (typeof t.enabled !== "boolean") {
+      console.warn(`[opentabs] Tool "${t.name}" in plugin "${obj.name}" is missing the "enabled" field \u2014 defaulting to enabled=true. This is a server-side bug.`);
+    }
+    return {
+      name: t.name,
+      displayName: typeof t.displayName === "string" ? t.displayName : t.name,
+      description: t.description,
+      icon: typeof t.icon === "string" ? t.icon : "wrench",
+      enabled: typeof t.enabled === "boolean" ? t.enabled : true
+    };
+  }) : [];
   return {
     name: obj.name,
     version: typeof obj.version === "string" ? obj.version : "0.0.0",
@@ -3668,6 +3887,8 @@ var handleExtensionReload = (_params, id) => {
   });
 };
 var handleSyncFull = async (params) => {
+  const syncStart = Date.now();
+  console.log("[opentabs:timing] handleSyncFull started");
   const rawPlugins = params.plugins;
   if (!Array.isArray(rawPlugins))
     return;
@@ -3701,17 +3922,58 @@ var handleSyncFull = async (params) => {
   }
   const metas = uniquePlugins.map(toPluginMeta);
   await storePluginsBatch(metas);
+  console.log(`[opentabs:timing] storePluginsBatch done: +${Date.now() - syncStart}ms`);
   const injectionResults = await Promise.allSettled(metas.map((meta) => injectPluginIntoMatchingTabs(meta.name, meta.urlPatterns, true, meta.adapterHash, meta.adapterFile, meta.adapterHash)));
   for (const result of injectionResults) {
     if (result.status === "rejected") {
       console.warn("[opentabs] Plugin injection failed during sync.full:", result.reason);
     }
   }
-  await sendTabSyncAll();
+  console.log(`[opentabs:timing] injection done: +${Date.now() - syncStart}ms`);
+  const rawPluginMap = /* @__PURE__ */ new Map();
+  for (const raw of rawPlugins) {
+    if (typeof raw === "object" && raw !== null && typeof raw.name === "string") {
+      rawPluginMap.set(raw.name, raw);
+    }
+  }
+  const cachePlugins = uniquePlugins.map((p) => {
+    const raw = rawPluginMap.get(p.name);
+    return {
+      name: p.name,
+      displayName: p.displayName,
+      version: p.version,
+      trustTier: p.trustTier,
+      source: raw?.source === "npm" || raw?.source === "local" ? raw.source : "local",
+      tabState: "closed",
+      urlPatterns: p.urlPatterns,
+      tools: p.tools,
+      iconSvg: p.iconSvg,
+      iconInactiveSvg: p.iconInactiveSvg,
+      ...typeof raw?.sdkVersion === "string" ? { sdkVersion: raw.sdkVersion } : {},
+      ...raw?.update && typeof raw.update === "object" ? { update: raw.update } : {}
+    };
+  });
+  const rawFailedPlugins = Array.isArray(params.failedPlugins) ? params.failedPlugins : void 0;
+  const rawBrowserTools = Array.isArray(params.browserTools) ? params.browserTools : void 0;
+  const rawServerVersion = typeof params.serverVersion === "string" ? params.serverVersion : void 0;
+  updateServerStateCache({
+    plugins: cachePlugins,
+    ...rawFailedPlugins ? { failedPlugins: rawFailedPlugins } : {},
+    ...rawBrowserTools ? { browserTools: rawBrowserTools } : {},
+    ...rawServerVersion !== void 0 ? { serverVersion: rawServerVersion } : {}
+  });
+  setCachesInitialized(true);
+  flushServerStateCacheToSession();
+  console.log(`[opentabs:timing] cache + flush done: +${Date.now() - syncStart}ms`);
   forwardToSidePanel({
     type: "sp:serverMessage",
     data: { jsonrpc: "2.0", method: "plugins.changed" }
   });
+  console.log(`[opentabs:timing] plugins.changed sent to side panel: +${Date.now() - syncStart}ms`);
+  void sendTabSyncAll().then(() => {
+    flushLastKnownStateToSession();
+    startReadinessPoll();
+  });
 };
 var handlePluginUpdate = async (params) => {
   const validated = validatePluginPayload(params);
@@ -3723,6 +3985,23 @@ var handlePluginUpdate = async (params) => {
   const newState = await computePluginTabState(meta);
   await updateLastKnownState(meta.name, newState);
   sendTabStateNotification(meta.name, newState);
+  const existingCache = getServerStateCache();
+  const updatedPlugin = {
+    name: validated.name,
+    displayName: validated.displayName,
+    version: validated.version,
+    trustTier: validated.trustTier,
+    source: params.source === "npm" || params.source === "local" ? params.source : "local",
+    tabState: newState.state,
+    urlPatterns: validated.urlPatterns,
+    tools: validated.tools,
+    iconSvg: validated.iconSvg,
+    iconInactiveSvg: validated.iconInactiveSvg,
+    ...typeof params.sdkVersion === "string" ? { sdkVersion: params.sdkVersion } : {},
+    ...params.update && typeof params.update === "object" ? { update: params.update } : {}
+  };
+  const otherPlugins = existingCache.plugins.filter((p) => p.name !== validated.name);
+  updateServerStateCache({ plugins: [...otherPlugins, updatedPlugin] });
   forwardToSidePanel({
     type: "sp:serverMessage",
     data: { jsonrpc: "2.0", method: "plugins.changed" }
@@ -3757,20 +4036,40 @@ var handlePluginUninstall = async (params, id) => {
   }
   await removePlugin(pluginName);
   clearPluginTabState(pluginName);
+  const existingCache = getServerStateCache();
+  updateServerStateCache({ plugins: existingCache.plugins.filter((p) => p.name !== pluginName) });
+  forwardToSidePanel({
+    type: "sp:serverMessage",
+    data: { jsonrpc: "2.0", method: "plugins.changed" }
+  });
   sendToServer({
     jsonrpc: "2.0",
     result: { success: true },
     id
   });
 };
+var handleExtensionGetTabState = async (_params, id) => {
+  let states = getLastKnownStates();
+  if (states.size === 0) {
+    await loadLastKnownStateFromSession();
+    states = getLastKnownStates();
+  }
+  const tabStates = {};
+  for (const [pluginName, serialized] of states) {
+    try {
+      tabStates[pluginName] = JSON.parse(serialized);
+    } catch {
+      tabStates[pluginName] = { state: "closed", tabs: [] };
+    }
+  }
+  sendToServer({ jsonrpc: "2.0", result: { tabStates }, id });
+};
 var methodHandlers = /* @__PURE__ */ new Map([
   ["extension.reload", handleExtensionReload],
   ["sync.full", wrapNotification("sync.full", handleSyncFull)],
   ["plugin.update", wrapNotification("plugin.update", handlePluginUpdate)],
   ["plugin.uninstall", wrapAsync("plugin.uninstall", handlePluginUninstall)],
   ["tool.dispatch", wrapAsync("tool.dispatch", handleToolDispatch)],
-  ["resource.read", wrapAsync("resource.read", handleResourceRead)],
-  ["prompt.get", wrapAsync("prompt.get", handlePromptGet)],
   ["browser.listTabs", wrapAsync("browser.listTabs", (_params, id) => handleBrowserListTabs(id))],
   ["browser.openTab", wrapAsync("browser.openTab", handleBrowserOpenTab)],
   ["browser.closeTab", wrapAsync("browser.closeTab", handleBrowserCloseTab)],
@@ -3809,14 +4108,26 @@ var methodHandlers = /* @__PURE__ */ new Map([
   [
     "extension.forceReconnect",
     wrapAsync("extension.forceReconnect", (_params, id) => handleExtensionForceReconnect(id))
-  ]
+  ],
+  ["extension.getTabState", wrapAsync("extension.getTabState", handleExtensionGetTabState)]
 ]);
 var handleServerMessage = (message) => {
   const method = message.method;
   const id = message.id;
   const params = message.params ?? {};
-  const isResponse = id !== void 0 && !method;
-  if (isResponse || method && SIDE_PANEL_METHODS.has(method)) {
+  if (!method && consumeServerResponse(message)) {
+    return;
+  }
+  if (method === "plugins.changed") {
+    const payload = params;
+    updateServerStateCache({
+      ...payload.plugins ? { plugins: payload.plugins } : {},
+      ...payload.failedPlugins ? { failedPlugins: payload.failedPlugins } : {},
+      ...payload.browserTools ? { browserTools: payload.browserTools } : {},
+      ...payload.serverVersion !== void 0 ? { serverVersion: payload.serverVersion } : {}
+    });
+  }
+  if (method && SIDE_PANEL_METHODS.has(method)) {
     forwardToSidePanel({ type: "sp:serverMessage", data: message });
   }
   if (method === "confirmation.request") {
@@ -3853,14 +4164,18 @@ var methodHandlerNames = Array.from(methodHandlers.keys());
 // dist/background-message-handlers.js
 var wsConnected = false;
 var lastDisconnectReason;
+var wsConnectedRestorePromise;
 var restoreWsConnectedState = () => {
-  chrome.storage.session.get(WS_CONNECTED_KEY).then((data) => {
+  if (wsConnectedRestorePromise !== void 0)
+    return;
+  wsConnectedRestorePromise = chrome.storage.session.get(WS_CONNECTED_KEY).then((data) => {
     if (typeof data[WS_CONNECTED_KEY] === "boolean") {
       wsConnected = data[WS_CONNECTED_KEY];
     }
   }).catch(() => {
   });
 };
+var waitForWsConnectedRestore = () => wsConnectedRestorePromise ?? Promise.resolve();
 var persistWsConnected = (connected) => {
   wsConnected = connected;
   chrome.storage.session.set({ [WS_CONNECTED_KEY]: connected }).catch(() => {
@@ -3888,23 +4203,92 @@ var handleWsState = (message, sendResponse) => {
     }
   });
   if (!nowConnected) {
+    stopReadinessPoll();
     clearTabStateCache();
+    clearServerStateCache();
+    rejectAllPendingServerRequests();
     clearAllConfirmationBadges();
   }
   sendResponse({ ok: true });
 };
 var handleWsMessage = (message, sendResponse) => {
-  handleServerMessage(message.data);
-  sendResponse({ ok: true });
-};
-var handleBgSend = (message, sendResponse) => {
-  sendToServer(message.data);
+  try {
+    handleServerMessage(message.data);
+  } catch (err2) {
+    console.error("[opentabs:background] handleServerMessage threw:", err2);
+  }
   sendResponse({ ok: true });
 };
-var handleBgGetConnectionState = (_message, sendResponse) => {
-  sendResponse({
-    connected: wsConnected,
-    disconnectReason: wsConnected ? void 0 : lastDisconnectReason
+var handleBgGetFullState = (_message, sendResponse) => {
+  (async () => {
+    await waitForWsConnectedRestore();
+    let tabStates = getLastKnownStates();
+    let serverCache = getServerStateCache();
+    if (wsConnected && tabStates.size === 0 && serverCache.plugins.length === 0) {
+      await loadServerStateCacheFromSession();
+      if (getCachesInitialized()) {
+        await loadLastKnownStateFromSession();
+        tabStates = getLastKnownStates();
+      }
+      serverCache = getServerStateCache();
+    }
+    const metaIndex = await getAllPluginMeta();
+    const serverPluginMap = /* @__PURE__ */ new Map();
+    for (const sp of serverCache.plugins) {
+      serverPluginMap.set(sp.name, sp);
+    }
+    const plugins = Object.values(metaIndex).map((meta) => {
+      const serverPlugin = serverPluginMap.get(meta.name);
+      let tabState = "closed";
+      const serialized = tabStates.get(meta.name);
+      if (serialized) {
+        try {
+          const parsed = JSON.parse(serialized);
+          tabState = parsed.state;
+        } catch {
+        }
+      }
+      const tools = meta.tools.map((metaTool) => {
+        const serverTool = serverPlugin?.tools.find((st) => st.name === metaTool.name);
+        return {
+          ...metaTool,
+          enabled: serverTool?.enabled ?? true
+        };
+      });
+      return {
+        name: meta.name,
+        displayName: meta.displayName,
+        version: meta.version,
+        trustTier: meta.trustTier,
+        urlPatterns: meta.urlPatterns,
+        iconSvg: meta.iconSvg,
+        iconInactiveSvg: meta.iconInactiveSvg,
+        tools,
+        tabState,
+        source: serverPlugin?.source ?? "local",
+        sdkVersion: serverPlugin?.sdkVersion,
+        update: serverPlugin?.update
+      };
+    });
+    sendResponse({
+      connected: wsConnected,
+      disconnectReason: wsConnected ? void 0 : lastDisconnectReason,
+      plugins,
+      failedPlugins: serverCache.failedPlugins,
+      browserTools: serverCache.browserTools,
+      serverVersion: serverCache.serverVersion,
+      pendingConfirmations: getPendingConfirmations()
+    });
+  })().catch(() => {
+    sendResponse({
+      connected: wsConnected,
+      disconnectReason: wsConnected ? void 0 : lastDisconnectReason,
+      plugins: [],
+      failedPlugins: [],
+      browserTools: [],
+      serverVersion: void 0,
+      pendingConfirmations: []
+    });
   });
 };
 var handlePluginLogs = (message, sendResponse) => {
@@ -3975,6 +4359,160 @@ var handleSpConfirmationTimeout = (message, sendResponse) => {
   clearConfirmationBadge(id);
   sendResponse({ ok: true });
 };
+var handleBgSetToolEnabled = (message, sendResponse) => {
+  const plugin = message.plugin;
+  const tool = message.tool;
+  const enabled = message.enabled;
+  const cache2 = getServerStateCache();
+  const pluginEntry = cache2.plugins.find((p) => p.name === plugin);
+  const originalEnabled = pluginEntry?.tools.find((t) => t.name === tool)?.enabled ?? !enabled;
+  const updatedPlugins = cache2.plugins.map((p) => {
+    if (p.name !== plugin)
+      return p;
+    return {
+      ...p,
+      tools: p.tools.map((t) => t.name === tool ? { ...t, enabled } : t)
+    };
+  });
+  addPendingPluginToolUpdate(plugin, tool, enabled);
+  updateServerStateCache({ plugins: updatedPlugins });
+  sendServerRequest("config.setToolEnabled", { plugin, tool, enabled }).then((result) => {
+    removePendingPluginToolUpdate(plugin, tool);
+    sendResponse(result);
+  }).catch((err2) => {
+    removePendingPluginToolUpdate(plugin, tool);
+    const currentCache = getServerStateCache();
+    const revertedPlugins = currentCache.plugins.map((p) => {
+      if (p.name !== plugin)
+        return p;
+      return {
+        ...p,
+        tools: p.tools.map((t) => t.name === tool ? { ...t, enabled: originalEnabled } : t)
+      };
+    });
+    updateServerStateCache({ plugins: revertedPlugins });
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
+var handleBgSetAllToolsEnabled = (message, sendResponse) => {
+  const plugin = message.plugin;
+  const enabled = message.enabled;
+  const cache2 = getServerStateCache();
+  const pluginEntry = cache2.plugins.find((p) => p.name === plugin);
+  const toolNames = pluginEntry ? pluginEntry.tools.map((t) => t.name) : [];
+  const originalToolStates = /* @__PURE__ */ new Map();
+  if (pluginEntry) {
+    for (const t of pluginEntry.tools) {
+      originalToolStates.set(t.name, t.enabled);
+    }
+  }
+  const updatedPlugins = cache2.plugins.map((p) => {
+    if (p.name !== plugin)
+      return p;
+    return {
+      ...p,
+      tools: p.tools.map((t) => ({ ...t, enabled }))
+    };
+  });
+  addPendingPluginAllToolsUpdate(plugin, toolNames, enabled);
+  updateServerStateCache({ plugins: updatedPlugins });
+  sendServerRequest("config.setAllToolsEnabled", { plugin, enabled }).then((result) => {
+    removePendingPluginAllToolsUpdate(plugin, toolNames);
+    sendResponse(result);
+  }).catch((err2) => {
+    removePendingPluginAllToolsUpdate(plugin, toolNames);
+    const currentCache = getServerStateCache();
+    const revertedPlugins = currentCache.plugins.map((p) => {
+      if (p.name !== plugin)
+        return p;
+      return {
+        ...p,
+        tools: p.tools.map((t) => ({
+          ...t,
+          enabled: originalToolStates.get(t.name) ?? t.enabled
+        }))
+      };
+    });
+    updateServerStateCache({ plugins: revertedPlugins });
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
+var handleBgSetBrowserToolEnabled = (message, sendResponse) => {
+  const tool = message.tool;
+  const enabled = message.enabled;
+  const cache2 = getServerStateCache();
+  const originalEnabled = cache2.browserTools.find((bt) => bt.name === tool)?.enabled ?? !enabled;
+  const updatedBrowserTools = cache2.browserTools.map((bt) => bt.name === tool ? { ...bt, enabled } : bt);
+  addPendingBrowserToolUpdate(tool, enabled);
+  updateServerStateCache({ browserTools: updatedBrowserTools });
+  sendServerRequest("config.setBrowserToolEnabled", { tool, enabled }).then((result) => {
+    removePendingBrowserToolUpdate(tool);
+    sendResponse(result);
+  }).catch((err2) => {
+    removePendingBrowserToolUpdate(tool);
+    const currentCache = getServerStateCache();
+    const revertedBrowserTools = currentCache.browserTools.map((bt) => bt.name === tool ? { ...bt, enabled: originalEnabled } : bt);
+    updateServerStateCache({ browserTools: revertedBrowserTools });
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
+var handleBgSetAllBrowserToolsEnabled = (message, sendResponse) => {
+  const enabled = message.enabled;
+  const cache2 = getServerStateCache();
+  const toolNames = cache2.browserTools.map((bt) => bt.name);
+  const originalToolStates = /* @__PURE__ */ new Map();
+  for (const bt of cache2.browserTools) {
+    originalToolStates.set(bt.name, bt.enabled);
+  }
+  const updatedBrowserTools = cache2.browserTools.map((bt) => ({ ...bt, enabled }));
+  addPendingAllBrowserToolsUpdate(toolNames, enabled);
+  updateServerStateCache({ browserTools: updatedBrowserTools });
+  sendServerRequest("config.setAllBrowserToolsEnabled", { enabled }).then((result) => {
+    removePendingAllBrowserToolsUpdate(toolNames);
+    sendResponse(result);
+  }).catch((err2) => {
+    removePendingAllBrowserToolsUpdate(toolNames);
+    const currentCache = getServerStateCache();
+    const revertedBrowserTools = currentCache.browserTools.map((bt) => ({
+      ...bt,
+      enabled: originalToolStates.get(bt.name) ?? bt.enabled
+    }));
+    updateServerStateCache({ browserTools: revertedBrowserTools });
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
+var handleBgSearchPlugins = (message, sendResponse) => {
+  const query = message.query;
+  sendServerRequest("plugin.search", { query }).then((result) => {
+    sendResponse(result);
+  }).catch((err2) => {
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
+var handleBgInstallPlugin = (message, sendResponse) => {
+  const name = message.name;
+  sendServerRequest("plugin.install", { name }).then((result) => {
+    sendResponse(result);
+  }).catch((err2) => {
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
+var handleBgRemovePlugin = (message, sendResponse) => {
+  const name = message.name;
+  sendServerRequest("plugin.remove", { name }).then((result) => {
+    sendResponse(result);
+  }).catch((err2) => {
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
+var handleBgUpdatePlugin = (message, sendResponse) => {
+  const name = message.name;
+  sendServerRequest("plugin.updateFromRegistry", { name }).then((result) => {
+    sendResponse(result);
+  }).catch((err2) => {
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
 var handlePortChanged = (message, sendResponse) => {
   chrome.runtime.sendMessage(message).catch(() => {
   });
@@ -3984,8 +4522,15 @@ var backgroundHandlers = /* @__PURE__ */ new Map([
   ["offscreen:getUrl", handleOffscreenGetUrl],
   ["ws:state", handleWsState],
   ["ws:message", handleWsMessage],
-  ["bg:send", handleBgSend],
-  ["bg:getConnectionState", handleBgGetConnectionState],
+  ["bg:getFullState", handleBgGetFullState],
+  ["bg:setToolEnabled", handleBgSetToolEnabled],
+  ["bg:setAllToolsEnabled", handleBgSetAllToolsEnabled],
+  ["bg:setBrowserToolEnabled", handleBgSetBrowserToolEnabled],
+  ["bg:setAllBrowserToolsEnabled", handleBgSetAllBrowserToolsEnabled],
+  ["bg:searchPlugins", handleBgSearchPlugins],
+  ["bg:installPlugin", handleBgInstallPlugin],
+  ["bg:removePlugin", handleBgRemovePlugin],
+  ["bg:updatePlugin", handleBgUpdatePlugin],
   ["plugin:logs", handlePluginLogs],
   ["tool:progress", handleToolProgress],
   ["sp:confirmationResponse", handleSpConfirmationResponse],
@@ -3996,8 +4541,15 @@ var EXTENSION_ONLY_TYPES = /* @__PURE__ */ new Set([
   "offscreen:getUrl",
   "ws:state",
   "ws:message",
-  "bg:send",
-  "bg:getConnectionState",
+  "bg:getFullState",
+  "bg:setToolEnabled",
+  "bg:setAllToolsEnabled",
+  "bg:setBrowserToolEnabled",
+  "bg:setAllBrowserToolsEnabled",
+  "bg:searchPlugins",
+  "bg:installPlugin",
+  "bg:removePlugin",
+  "bg:updatePlugin",
   "offscreen:getLogs",
   "sp:confirmationResponse",
   "sp:confirmationTimeout",
@@ -4019,66 +4571,6 @@ var initBackgroundMessageHandlers = () => {
 };
 var backgroundHandlerNames = [...backgroundHandlers.keys()];
 
-// dist/side-panel-toggle.js
-var openWindows = /* @__PURE__ */ new Set();
-var persistOpenWindows = () => {
-  chrome.storage.session.set({ [SIDE_PANEL_OPEN_WINDOWS_KEY]: Array.from(openWindows) }).catch(() => {
-  });
-};
-var restoreOpenWindows = () => {
-  chrome.storage.session.get(SIDE_PANEL_OPEN_WINDOWS_KEY).then((data) => {
-    const stored = data[SIDE_PANEL_OPEN_WINDOWS_KEY];
-    if (Array.isArray(stored)) {
-      for (const id of stored) {
-        if (typeof id === "number") {
-          openWindows.add(id);
-        }
-      }
-    }
-  }).catch(() => {
-  });
-};
-var initSidePanelToggle = () => {
-  chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: false }).catch(() => {
-  });
-  const canToggle = "onOpened" in chrome.sidePanel;
-  if (canToggle) {
-    restoreOpenWindows();
-    chrome.sidePanel.onOpened.addListener(({ windowId }) => {
-      openWindows.add(windowId);
-      persistOpenWindows();
-    });
-    chrome.sidePanel.onClosed.addListener(({ windowId }) => {
-      openWindows.delete(windowId);
-      persistOpenWindows();
-    });
-    chrome.windows.onRemoved.addListener((windowId) => {
-      openWindows.delete(windowId);
-      persistOpenWindows();
-    });
-  }
-  chrome.action.onClicked.addListener(({ windowId }) => {
-    void (async () => {
-      if (canToggle && openWindows.has(windowId)) {
-        try {
-          await chrome.windows.get(windowId);
-        } catch {
-          openWindows.delete(windowId);
-          persistOpenWindows();
-          await chrome.sidePanel.open({ windowId }).catch(() => {
-          });
-          return;
-        }
-        chrome.sidePanel.close({ windowId }).catch(() => {
-        });
-      } else {
-        chrome.sidePanel.open({ windowId }).catch(() => {
-        });
-      }
-    })();
-  });
-};
-
 // dist/background.js
 initSidePanelToggle();
 restoreWsConnectedState();
@@ -4108,7 +4600,9 @@ var setupKeepaliveAlarm = async () => {
   }
 };
 chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
-  if (changeInfo.status === "complete" && tab.url) {
+  if (changeInfo.status === "loading" && tab.url) {
+    injectPluginsIntoTab(tabId, tab.url).catch((err2) => console.warn("[opentabs] early tab injection failed:", err2));
+  } else if (changeInfo.status === "complete" && tab.url) {
     injectPluginsIntoTab(tabId, tab.url).then(() => checkTabChanged(tabId, changeInfo)).catch((err2) => console.warn("[opentabs] tab injection failed:", err2));
   } else if (changeInfo.url) {
     checkTabChanged(tabId, changeInfo).catch((err2) => console.warn("[opentabs] tab state check failed:", err2));