@opentabs-dev/browser-extension 0.0.51 → 0.0.53

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 pendingConfirmationInfo = /* @__PURE__ */ new Map();
 var confirmationTimeouts = /* @__PURE__ */ new Map();
 var clearedConfirmationIds = /* @__PURE__ */ new Set();
 var CONFIRMATION_BACKGROUND_TIMEOUT_BUFFER_MS = 2e3;
@@ -15,9 +109,34 @@ var updateConfirmationBadge = () => {
     });
   }
 };
+var syncConfirmationNotification = () => {
+  if (pendingConfirmationCount <= 0 || isSidePanelOpen()) {
+    chrome.notifications.clear(NOTIFICATION_ID).catch(() => {
+    });
+    return;
+  }
+  let message;
+  if (pendingConfirmationCount === 1 && pendingConfirmationInfo.size === 1) {
+    const info = pendingConfirmationInfo.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 timeoutMs = typeof params.timeoutMs === "number" ? params.timeoutMs : 0;
   const existingTimeoutId = confirmationTimeouts.get(id);
@@ -28,6 +147,7 @@ var notifyConfirmationRequest = (params) => {
     pendingConfirmationCount++;
     updateConfirmationBadge();
   }
+  pendingConfirmationInfo.set(id, { tool, domain });
   const effectiveTimeoutMs = timeoutMs > 0 ? timeoutMs : CONFIRMATION_FALLBACK_TIMEOUT_MS;
   const bgTimeoutId = setTimeout(() => {
     confirmationTimeouts.delete(id);
@@ -35,15 +155,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 +163,11 @@ var clearConfirmationBadge = (id) => {
       return;
     }
     clearedConfirmationIds.add(id);
-    chrome.notifications.clear(`opentabs-confirm-${id}`).catch(() => {
-    });
+    pendingConfirmationInfo.delete(id);
   }
   pendingConfirmationCount = Math.max(0, pendingConfirmationCount - 1);
   updateConfirmationBadge();
+  syncConfirmationNotification();
   if (id !== void 0 && !confirmationTimeouts.has(id)) {
     clearedConfirmationIds.delete(id);
   }
@@ -69,19 +181,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();
+  pendingConfirmationInfo.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(() => {
@@ -95,36 +208,6 @@ 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`;
-
 // dist/json-rpc-errors.js
 var JSONRPC_METHOD_NOT_FOUND = -32601;
 var JSONRPC_INVALID_PARAMS = -32602;
@@ -1185,6 +1268,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();
@@ -1281,15 +1378,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",
@@ -1309,16 +1411,40 @@ var sendTabSyncAll = async () => {
 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 () => {
+  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);
@@ -1335,6 +1461,7 @@ var notifyAffectedPlugins = async (affectedPlugins) => {
     if (previous === serialized)
       return;
     lastKnownState.set(plugin.name, serialized);
+    scheduleLastKnownStatePersist();
     sendTabStateNotification(plugin.name, newState);
   })));
 };
@@ -1382,6 +1509,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) => {
@@ -3309,6 +3476,106 @@ var handlePromptGet = async (params, id) => {
   }
 };
 
+// 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 ("error" in data) {
+    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 EMPTY_CACHE = {
+  plugins: [],
+  failedPlugins: [],
+  browserTools: [],
+  serverVersion: void 0
+};
+var cache = { ...EMPTY_CACHE };
+var persistTimer;
+var persistToSession = () => {
+  chrome.storage.session.set({ [SESSION_KEY]: cache }).catch(() => {
+  });
+};
+var schedulePersist = () => {
+  if (persistTimer !== void 0)
+    clearTimeout(persistTimer);
+  persistTimer = setTimeout(() => {
+    persistTimer = void 0;
+    persistToSession();
+  }, 500);
+};
+var getServerStateCache = () => cache;
+var updateServerStateCache = (partial) => {
+  cache = { ...cache, ...partial };
+  schedulePersist();
+};
+var clearServerStateCache = () => {
+  cache = { ...EMPTY_CACHE };
+  if (persistTimer !== void 0) {
+    clearTimeout(persistTimer);
+    persistTimer = void 0;
+  }
+  chrome.storage.session.remove(SESSION_KEY).catch(() => {
+  });
+};
+var loadServerStateCacheFromSession = async () => {
+  try {
+    const data = await chrome.storage.session.get(SESSION_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
+      };
+    }
+  } catch {
+  }
+};
+
 // dist/tool-dispatch.js
 var progressCallbacks = /* @__PURE__ */ new Map();
 var notifyDispatchProgress = (dispatchId) => {
@@ -3707,11 +3974,45 @@ var handleSyncFull = async (params) => {
       console.warn("[opentabs] Plugin injection failed during sync.full:", result.reason);
     }
   }
-  await sendTabSyncAll();
+  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 } : {}
+  });
   forwardToSidePanel({
     type: "sp:serverMessage",
     data: { jsonrpc: "2.0", method: "plugins.changed" }
   });
+  void sendTabSyncAll().then(() => {
+    startReadinessPoll();
+  });
 };
 var handlePluginUpdate = async (params) => {
   const validated = validatePluginPayload(params);
@@ -3723,6 +4024,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" }
@@ -3763,6 +4081,18 @@ var handlePluginUninstall = async (params, id) => {
     id
   });
 };
+var handleExtensionGetTabState = (_params, id) => {
+  const 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)],
@@ -3809,14 +4139,26 @@ var methodHandlers = /* @__PURE__ */ new Map([
   [
     "extension.forceReconnect",
     wrapAsync("extension.forceReconnect", (_params, id) => handleExtensionForceReconnect(id))
-  ]
+  ],
+  ["extension.getTabState", wrapSync("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") {
@@ -3888,7 +4230,10 @@ var handleWsState = (message, sendResponse) => {
     }
   });
   if (!nowConnected) {
+    stopReadinessPoll();
     clearTabStateCache();
+    clearServerStateCache();
+    rejectAllPendingServerRequests();
     clearAllConfirmationBadges();
   }
   sendResponse({ ok: true });
@@ -3897,16 +4242,78 @@ var handleWsMessage = (message, sendResponse) => {
   handleServerMessage(message.data);
   sendResponse({ ok: true });
 };
-var handleBgSend = (message, sendResponse) => {
-  sendToServer(message.data);
-  sendResponse({ ok: true });
-};
 var handleBgGetConnectionState = (_message, sendResponse) => {
   sendResponse({
     connected: wsConnected,
     disconnectReason: wsConnected ? void 0 : lastDisconnectReason
   });
 };
+var handleBgGetFullState = (_message, sendResponse) => {
+  (async () => {
+    let tabStates = getLastKnownStates();
+    let serverCache = getServerStateCache();
+    if (wsConnected && tabStates.size === 0 && serverCache.plugins.length === 0) {
+      await Promise.all([loadLastKnownStateFromSession(), loadServerStateCacheFromSession()]);
+      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
+    });
+  })().catch(() => {
+    sendResponse({
+      connected: wsConnected,
+      disconnectReason: wsConnected ? void 0 : lastDisconnectReason,
+      plugins: [],
+      failedPlugins: [],
+      browserTools: [],
+      serverVersion: void 0
+    });
+  });
+};
 var handlePluginLogs = (message, sendResponse) => {
   const entries = message.entries;
   if (wsConnected && Array.isArray(entries)) {
@@ -3975,6 +4382,117 @@ 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 updatedPlugins = cache2.plugins.map((p) => {
+    if (p.name !== plugin)
+      return p;
+    return {
+      ...p,
+      tools: p.tools.map((t) => t.name === tool ? { ...t, enabled } : t)
+    };
+  });
+  updateServerStateCache({ plugins: updatedPlugins });
+  sendServerRequest("config.setToolEnabled", { plugin, tool, enabled }).then((result) => {
+    sendResponse(result);
+  }).catch((err2) => {
+    const revertCache = getServerStateCache();
+    const revertPlugins = revertCache.plugins.map((p) => {
+      if (p.name !== plugin)
+        return p;
+      return {
+        ...p,
+        tools: p.tools.map((t) => t.name === tool ? { ...t, enabled: !enabled } : t)
+      };
+    });
+    updateServerStateCache({ plugins: revertPlugins });
+    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 originalPlugins = cache2.plugins;
+  const updatedPlugins = cache2.plugins.map((p) => {
+    if (p.name !== plugin)
+      return p;
+    return {
+      ...p,
+      tools: p.tools.map((t) => ({ ...t, enabled }))
+    };
+  });
+  updateServerStateCache({ plugins: updatedPlugins });
+  sendServerRequest("config.setAllToolsEnabled", { plugin, enabled }).then((result) => {
+    sendResponse(result);
+  }).catch((err2) => {
+    updateServerStateCache({ plugins: originalPlugins });
+    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 updatedBrowserTools = cache2.browserTools.map((bt) => bt.name === tool ? { ...bt, enabled } : bt);
+  updateServerStateCache({ browserTools: updatedBrowserTools });
+  sendServerRequest("config.setBrowserToolEnabled", { tool, enabled }).then((result) => {
+    sendResponse(result);
+  }).catch((err2) => {
+    const revertCache = getServerStateCache();
+    const revertBrowserTools = revertCache.browserTools.map((bt) => bt.name === tool ? { ...bt, enabled: !enabled } : bt);
+    updateServerStateCache({ browserTools: revertBrowserTools });
+    sendResponse({ error: err2 instanceof Error ? err2.message : String(err2) });
+  });
+};
+var handleBgSetAllBrowserToolsEnabled = (message, sendResponse) => {
+  const enabled = message.enabled;
+  const cache2 = getServerStateCache();
+  const originalBrowserTools = cache2.browserTools;
+  const updatedBrowserTools = cache2.browserTools.map((bt) => ({ ...bt, enabled }));
+  updateServerStateCache({ browserTools: updatedBrowserTools });
+  sendServerRequest("config.setAllBrowserToolsEnabled", { enabled }).then((result) => {
+    sendResponse(result);
+  }).catch((err2) => {
+    updateServerStateCache({ browserTools: originalBrowserTools });
+    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 +4502,16 @@ 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 +4522,16 @@ 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 +4553,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 +4582,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));