@opentabs-dev/browser-extension 0.0.34

package/dist/background.js

@@ -0,0 +1,3780 @@
+// dist/confirmation-badge.js
+var pendingConfirmationCount = 0;
+var updateConfirmationBadge = () => {
+  if (pendingConfirmationCount > 0) {
+    chrome.action.setBadgeText({ text: String(pendingConfirmationCount) }).catch(() => {
+    });
+    chrome.action.setBadgeBackgroundColor({ color: "#ffdb33" }).catch(() => {
+    });
+  } else {
+    chrome.action.setBadgeText({ text: "" }).catch(() => {
+    });
+  }
+};
+var notifyConfirmationRequest = (params) => {
+  pendingConfirmationCount++;
+  updateConfirmationBadge();
+  const tool = typeof params.tool === "string" ? params.tool : "unknown tool";
+  const domain = typeof params.domain === "string" ? params.domain : "unknown domain";
+  chrome.notifications.create(`opentabs-confirm-${typeof params.id === "string" ? params.id : Date.now()}`, {
+    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(() => {
+  });
+};
+var clearConfirmationBadge = () => {
+  pendingConfirmationCount = Math.max(0, pendingConfirmationCount - 1);
+  updateConfirmationBadge();
+};
+var clearAllConfirmationBadges = () => {
+  pendingConfirmationCount = 0;
+  updateConfirmationBadge();
+};
+var initConfirmationBadge = () => {
+  chrome.notifications.onClicked.addListener((notificationId) => {
+    if (notificationId.startsWith("opentabs-confirm-")) {
+      chrome.windows.getCurrent().then((w) => {
+        if (w.id !== void 0) {
+          chrome.sidePanel.open({ windowId: w.id }).catch(() => {
+          });
+        }
+      }).catch(() => {
+      });
+      chrome.notifications.clear(notificationId).catch(() => {
+      });
+    }
+  });
+};
+
+// 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 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;
+var JSONRPC_INTERNAL_ERROR = -32603;
+var JSONRPC_NO_USABLE_TAB = -32001;
+var JSONRPC_ADAPTER_NOT_READY = -32002;
+
+// dist/messaging.js
+var sendToServer = (data) => {
+  const method = data.method ?? "unknown";
+  chrome.runtime.sendMessage({ type: "ws:send", data }).catch((err2) => {
+    console.warn(`[opentabs] sendToServer failed for "${method}":`, err2);
+  });
+};
+var forwardToSidePanel = (message) => {
+  const type = message.type;
+  chrome.runtime.sendMessage(message).catch((err2) => {
+    console.warn(`[opentabs] forwardToSidePanel failed for "${type}":`, err2);
+  });
+};
+var sendTabStateNotification = (pluginName, stateInfo) => {
+  const params = {
+    plugin: pluginName,
+    state: stateInfo.state,
+    tabId: stateInfo.tabId,
+    url: stateInfo.url
+  };
+  sendToServer({
+    jsonrpc: "2.0",
+    method: "tab.stateChanged",
+    params
+  });
+  forwardToSidePanel({
+    type: "sp:serverMessage",
+    data: {
+      jsonrpc: "2.0",
+      method: "tab.stateChanged",
+      params
+    }
+  });
+};
+
+// dist/sanitize-error.js
+var MAX_LENGTH = 500;
+var sanitizeErrorMessage = (message) => {
+  let sanitized = message.replace(/[a-z]:[/\\][^\s,;)}\]]+/gi, "[PATH]").replace(/\/[a-z0-9._-]+(?:\/[a-z0-9._-]+)+/gi, "[PATH]").replace(/https?:\/\/[^\s,;)}\]]+/gi, "[URL]").replace(/localhost:\d+/gi, "[LOCALHOST]").replace(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/g, "[IP]");
+  if (sanitized.length > MAX_LENGTH) {
+    sanitized = sanitized.slice(0, MAX_LENGTH - 3) + "...";
+  }
+  return sanitized;
+};
+
+// ../shared/dist/error.js
+var toErrorMessage = (err2) => err2 instanceof Error ? err2.message : String(err2);
+
+// ../shared/dist/index.js
+var BLOCKED_URL_SCHEMES = [
+  "javascript:",
+  "data:",
+  "file:",
+  "chrome:",
+  "chrome-extension:",
+  "blob:"
+];
+var isBlockedUrlScheme = (url) => {
+  try {
+    const parsed = new URL(url);
+    return BLOCKED_URL_SCHEMES.includes(parsed.protocol);
+  } catch {
+    return true;
+  }
+};
+
+// dist/browser-commands/helpers.js
+var requireTabId = (params, id) => {
+  const tabId = params.tabId;
+  if (typeof tabId !== "number") {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INVALID_PARAMS, message: "Missing or invalid tabId parameter" },
+      id
+    });
+    return null;
+  }
+  return tabId;
+};
+var requireSelector = (params, id) => {
+  const selector = params.selector;
+  if (typeof selector !== "string" || selector.length === 0) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INVALID_PARAMS, message: "Missing or invalid selector parameter" },
+      id
+    });
+    return null;
+  }
+  return selector;
+};
+var requireStringParam = (params, paramName, id) => {
+  const value = params[paramName];
+  if (typeof value !== "string" || value.length === 0) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INVALID_PARAMS, message: `Missing or invalid ${paramName} parameter` },
+      id
+    });
+    return null;
+  }
+  return value;
+};
+var requireUrl = (params, id) => {
+  const url = params.url;
+  if (typeof url !== "string") {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INVALID_PARAMS, message: "Missing or invalid url parameter" },
+      id
+    });
+    return null;
+  }
+  if (isBlockedUrlScheme(url)) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: {
+        code: JSONRPC_INVALID_PARAMS,
+        message: "URL scheme not allowed (javascript:, data:, file:, chrome:, blob: are blocked)"
+      },
+      id
+    });
+    return null;
+  }
+  return url;
+};
+var extractScriptResult = (results, id, fallbackMsg = "No result from script execution") => {
+  const result = results[0]?.result;
+  if (!result) {
+    sendToServer({ jsonrpc: "2.0", error: { code: JSONRPC_INTERNAL_ERROR, message: fallbackMsg }, id });
+    return null;
+  }
+  if (result.error) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INVALID_PARAMS, message: sanitizeErrorMessage(result.error) },
+      id
+    });
+    return null;
+  }
+  return result;
+};
+var sendErrorResult = (id, err2) => {
+  sendToServer({
+    jsonrpc: "2.0",
+    error: { code: JSONRPC_INTERNAL_ERROR, message: sanitizeErrorMessage(toErrorMessage(err2)) },
+    id
+  });
+};
+var sendValidationError = (id, message) => {
+  sendToServer({
+    jsonrpc: "2.0",
+    error: { code: JSONRPC_INVALID_PARAMS, message },
+    id
+  });
+};
+var sendSuccessResult = (id, result) => {
+  sendToServer({ jsonrpc: "2.0", result, id });
+};
+
+// dist/browser-commands/content-commands.js
+var handleBrowserGetTabContent = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = typeof params.selector === "string" ? params.selector : "body";
+    const maxLength = typeof params.maxLength === "number" ? params.maxLength : 5e4;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, max) => {
+        const el = document.querySelector(sel);
+        if (!el)
+          return { error: `Element not found: ${sel}` };
+        return {
+          title: document.title,
+          url: document.URL,
+          content: (el.innerText || "").trim().slice(0, max)
+        };
+      },
+      args: [selector, maxLength]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, { title: result.title, url: result.url, content: result.content });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserGetPageHtml = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = typeof params.selector === "string" ? params.selector : "html";
+    const maxLength = typeof params.maxLength === "number" ? params.maxLength : 2e5;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, max) => {
+        const el = document.querySelector(sel);
+        if (!el)
+          return { error: `Element not found: ${sel}` };
+        const html = el.outerHTML;
+        return {
+          title: document.title,
+          url: document.URL,
+          html: html.length > max ? html.slice(0, max) + "... (truncated)" : html
+        };
+      },
+      args: [selector, maxLength]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, { title: result.title, url: result.url, html: result.html });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserGetStorage = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const storageType = typeof params.storageType === "string" ? params.storageType : "local";
+    if (storageType !== "local" && storageType !== "session") {
+      sendValidationError(id, "storageType must be 'local' or 'session'");
+      return;
+    }
+    const key = typeof params.key === "string" ? params.key : void 0;
+    const MAX_VALUE_LENGTH = 1e4;
+    const MAX_RESPONSE_LENGTH = 5e5;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (type, k, maxVal, maxResp) => {
+        const storage = type === "session" ? window.sessionStorage : window.localStorage;
+        if (k !== null) {
+          const value = storage.getItem(k);
+          return {
+            mode: "single",
+            key: k,
+            value: value !== null && value.length > maxVal ? value.slice(0, maxVal) + "... (truncated)" : value
+          };
+        }
+        const entries = [];
+        let totalLength = 0;
+        const keys = Object.keys(storage);
+        for (const entryKey of keys) {
+          const raw = storage.getItem(entryKey);
+          if (raw === null)
+            continue;
+          const value = raw.length > maxVal ? raw.slice(0, maxVal) + "... (truncated)" : raw;
+          const entryLength = entryKey.length + value.length;
+          if (totalLength + entryLength > maxResp)
+            break;
+          entries.push({ key: entryKey, value });
+          totalLength += entryLength;
+        }
+        return { mode: "all", entries, count: keys.length };
+      },
+      args: [storageType, key ?? null, MAX_VALUE_LENGTH, MAX_RESPONSE_LENGTH]
+    });
+    const result = results[0]?.result;
+    if (!result) {
+      sendErrorResult(id, new Error("No result from script execution"));
+      return;
+    }
+    if (result.mode === "single") {
+      sendSuccessResult(id, { key: result.key, value: result.value });
+    } else {
+      sendSuccessResult(id, { entries: result.entries, count: result.count });
+    }
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserScreenshotTab = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const tab = await chrome.tabs.update(tabId, { active: true });
+    if (!tab) {
+      sendValidationError(id, `Tab ${tabId} not found`);
+      return;
+    }
+    await chrome.windows.update(tab.windowId, { focused: true });
+    await new Promise((resolve) => setTimeout(resolve, SCREENSHOT_RENDER_DELAY_MS));
+    const dataUrl = await chrome.tabs.captureVisibleTab(tab.windowId, { format: "png" });
+    const base64 = dataUrl.replace(/^data:image\/png;base64,/, "");
+    sendSuccessResult(id, { image: base64 });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/browser-commands/cookie-commands.js
+var handleBrowserGetCookies = async (params, id) => {
+  try {
+    const url = requireUrl(params, id);
+    if (url === null)
+      return;
+    const filter = { url };
+    const name = params.name;
+    if (typeof name === "string") {
+      filter.name = name;
+    }
+    const cookies = await chrome.cookies.getAll(filter);
+    sendSuccessResult(id, {
+      cookies: cookies.map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        secure: c.secure,
+        httpOnly: c.httpOnly,
+        sameSite: c.sameSite,
+        expirationDate: c.expirationDate
+      }))
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserSetCookie = async (params, id) => {
+  try {
+    const url = requireUrl(params, id);
+    if (url === null)
+      return;
+    const name = requireStringParam(params, "name", id);
+    if (name === null)
+      return;
+    const value = params.value;
+    if (typeof value !== "string") {
+      sendValidationError(id, "Missing or invalid value parameter");
+      return;
+    }
+    const details = { url, name, value };
+    if (typeof params.domain === "string")
+      details.domain = params.domain;
+    if (typeof params.path === "string")
+      details.path = params.path;
+    if (typeof params.secure === "boolean")
+      details.secure = params.secure;
+    if (typeof params.httpOnly === "boolean")
+      details.httpOnly = params.httpOnly;
+    if (typeof params.expirationDate === "number")
+      details.expirationDate = params.expirationDate;
+    const cookie = await chrome.cookies.set(details);
+    if (!cookie) {
+      sendErrorResult(id, new Error("Failed to set cookie"));
+      return;
+    }
+    sendSuccessResult(id, {
+      name: cookie.name,
+      value: cookie.value,
+      domain: cookie.domain,
+      path: cookie.path,
+      secure: cookie.secure,
+      httpOnly: cookie.httpOnly,
+      sameSite: cookie.sameSite,
+      expirationDate: cookie.expirationDate
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserDeleteCookies = async (params, id) => {
+  try {
+    const url = requireUrl(params, id);
+    if (url === null)
+      return;
+    const name = requireStringParam(params, "name", id);
+    if (name === null)
+      return;
+    await chrome.cookies.remove({ url, name });
+    sendSuccessResult(id, { deleted: true, name, url });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/log-collector.js
+var MAX_MESSAGE_LENGTH = 2e3;
+var DEFAULT_MAX_ENTRIES = 500;
+var formatArg = (arg) => {
+  if (typeof arg === "string")
+    return arg;
+  if (arg instanceof Error)
+    return `${arg.message}${arg.stack ? `
+${arg.stack}` : ""}`;
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+};
+var formatMessage = (args) => {
+  const raw = args.map(formatArg).join(" ");
+  return raw.length > MAX_MESSAGE_LENGTH ? raw.slice(0, MAX_MESSAGE_LENGTH) : raw;
+};
+var LogCollector = class {
+  buffer = [];
+  maxEntries;
+  source;
+  totalCaptured = 0;
+  constructor(source, maxEntries = DEFAULT_MAX_ENTRIES) {
+    this.source = source;
+    this.maxEntries = maxEntries;
+  }
+  capture(level, args) {
+    const entry = {
+      timestamp: Date.now(),
+      level,
+      source: this.source,
+      message: formatMessage(args)
+    };
+    if (this.buffer.length >= this.maxEntries) {
+      this.buffer.shift();
+    }
+    this.buffer.push(entry);
+    this.totalCaptured++;
+  }
+  getEntries(options) {
+    let entries = this.buffer;
+    if (options?.level) {
+      const level = options.level;
+      entries = entries.filter((e) => e.level === level);
+    }
+    if (options?.source) {
+      const source = options.source;
+      entries = entries.filter((e) => e.source === source);
+    }
+    if (options?.since !== void 0) {
+      const since = options.since;
+      entries = entries.filter((e) => e.timestamp >= since);
+    }
+    const result = [...entries].reverse();
+    if (options?.limit !== void 0 && options.limit > 0) {
+      return result.slice(0, options.limit);
+    }
+    return result;
+  }
+  clear() {
+    this.buffer.length = 0;
+  }
+  getStats() {
+    const oldest = this.buffer[0];
+    const newest = this.buffer[this.buffer.length - 1];
+    return {
+      totalCaptured: this.totalCaptured,
+      bufferSize: this.buffer.length,
+      oldestTimestamp: oldest?.timestamp ?? null,
+      newestTimestamp: newest?.timestamp ?? null
+    };
+  }
+};
+var installLogCollector = (source, maxEntries) => {
+  const collector = new LogCollector(source, maxEntries);
+  const levels = ["log", "warn", "error", "info"];
+  for (const level of levels) {
+    const original = console[level].bind(console);
+    console[level] = (...args) => {
+      collector.capture(level, args);
+      original(...args);
+    };
+  }
+  return collector;
+};
+
+// dist/background-log-state.js
+var bgLogCollector = installLogCollector("background");
+
+// dist/network-capture.js
+var MAX_BODY_LENGTH = 102400;
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-csrf-token",
+  "x-xsrf-token",
+  "proxy-authorization",
+  "x-api-key",
+  "x-auth-token",
+  "x-access-token",
+  "x-api-token",
+  "www-authenticate"
+]);
+var scrubHeaders = (headers) => {
+  if (!headers)
+    return void 0;
+  const scrubbed = {};
+  for (const [k, v] of Object.entries(headers)) {
+    const lower = k.toLowerCase();
+    if (!SENSITIVE_HEADERS.has(lower)) {
+      scrubbed[k] = v;
+    } else if (lower === "authorization" || lower === "proxy-authorization") {
+      const spaceIdx = v.indexOf(" ");
+      scrubbed[k] = spaceIdx > 0 ? `${v.slice(0, spaceIdx)} [REDACTED]` : "[REDACTED]";
+    } else {
+      scrubbed[k] = "[REDACTED]";
+    }
+  }
+  return scrubbed;
+};
+var captures = /* @__PURE__ */ new Map();
+var headersToRecord = (raw) => {
+  if (!raw)
+    return void 0;
+  if (typeof raw === "object" && !Array.isArray(raw)) {
+    return raw;
+  }
+  if (Array.isArray(raw)) {
+    const record = {};
+    for (const entry of raw) {
+      if (typeof entry.name === "string") {
+        record[entry.name] = entry.value !== void 0 ? entry.value : "";
+      }
+    }
+    return record;
+  }
+  return void 0;
+};
+var stringProp = (obj, key, fallback) => {
+  const propertyValue = obj[key];
+  return typeof propertyValue === "string" ? propertyValue : fallback;
+};
+var truncateBody = (body) => body.length > MAX_BODY_LENGTH ? body.slice(0, MAX_BODY_LENGTH) + "... (truncated)" : body;
+var evictOldestRequest = (state) => {
+  const shifted = state.requests.shift();
+  if (shifted) {
+    for (const [key, value] of state.requestIdToRequest) {
+      if (value === shifted) {
+        state.requestIdToRequest.delete(key);
+        break;
+      }
+    }
+  }
+};
+var BINARY_MIME_PREFIXES = ["image/", "font/", "video/", "audio/"];
+var BINARY_MIME_EXACT = /* @__PURE__ */ new Set(["application/octet-stream", "application/wasm"]);
+var isBinaryMime = (mimeType) => {
+  if (!mimeType)
+    return false;
+  const lower = mimeType.toLowerCase();
+  if (BINARY_MIME_EXACT.has(lower))
+    return true;
+  return BINARY_MIME_PREFIXES.some((prefix) => lower.startsWith(prefix));
+};
+chrome.debugger.onEvent.addListener((source, method, params) => {
+  const paramsRecord = params;
+  const tabId = source.tabId;
+  if (tabId === void 0)
+    return;
+  const state = captures.get(tabId);
+  if (!state)
+    return;
+  if (method === "Network.requestWillBeSent") {
+    const requestId = paramsRecord?.requestId;
+    const request = paramsRecord?.request;
+    if (!requestId || !request)
+      return;
+    const url = stringProp(request, "url", "");
+    if (state.urlFilter && !url.includes(state.urlFilter))
+      return;
+    const postData = typeof request.postData === "string" ? request.postData : void 0;
+    state.pendingRequests.set(requestId, {
+      url,
+      method: stringProp(request, "method", "GET"),
+      requestHeaders: headersToRecord(request.headers),
+      requestBody: postData ? truncateBody(postData) : void 0,
+      timestamp: Date.now()
+    });
+  } else if (method === "Network.responseReceived") {
+    const requestId = paramsRecord?.requestId;
+    const response = paramsRecord?.response;
+    if (!requestId || !response)
+      return;
+    const pending = state.pendingRequests.get(requestId);
+    if (!pending)
+      return;
+    const completed = {
+      url: pending.url ?? stringProp(response, "url", ""),
+      method: pending.method ?? "GET",
+      status: typeof response.status === "number" ? response.status : void 0,
+      statusText: typeof response.statusText === "string" ? response.statusText : void 0,
+      requestHeaders: pending.requestHeaders,
+      responseHeaders: headersToRecord(response.headers),
+      requestBody: pending.requestBody,
+      mimeType: typeof response.mimeType === "string" ? response.mimeType : void 0,
+      timestamp: pending.timestamp ?? Date.now()
+    };
+    state.pendingRequests.delete(requestId);
+    if (state.requests.length >= state.maxRequests) {
+      evictOldestRequest(state);
+    }
+    state.requests.push(completed);
+    state.requestIdToRequest.set(requestId, completed);
+  } else if (method === "Network.loadingFailed") {
+    const requestId = paramsRecord?.requestId;
+    if (!requestId)
+      return;
+    const pending = state.pendingRequests.get(requestId);
+    if (!pending)
+      return;
+    state.pendingRequests.delete(requestId);
+    state.requestIdToRequest.delete(requestId);
+    const errorText = typeof paramsRecord?.errorText === "string" ? paramsRecord.errorText : "Unknown error";
+    const completed = {
+      url: pending.url ?? "",
+      method: pending.method ?? "GET",
+      status: 0,
+      statusText: errorText,
+      requestHeaders: pending.requestHeaders,
+      requestBody: pending.requestBody,
+      timestamp: pending.timestamp ?? Date.now()
+    };
+    if (state.requests.length >= state.maxRequests) {
+      evictOldestRequest(state);
+    }
+    state.requests.push(completed);
+  } else if (method === "Network.loadingFinished") {
+    const requestId = paramsRecord?.requestId;
+    if (!requestId)
+      return;
+    const request = state.requestIdToRequest.get(requestId);
+    if (!request)
+      return;
+    state.requestIdToRequest.delete(requestId);
+    if (isBinaryMime(request.mimeType))
+      return;
+    chrome.debugger.sendCommand({ tabId }, "Network.getResponseBody", { requestId }, (result) => {
+      if (chrome.runtime.lastError || !result)
+        return;
+      const responseData = result;
+      if (typeof responseData.body !== "string")
+        return;
+      const body = responseData.base64Encoded ? new TextDecoder().decode(Uint8Array.from(atob(responseData.body), (c) => c.charCodeAt(0))) : responseData.body;
+      request.responseBody = truncateBody(body);
+    });
+  } else if (method === "Network.webSocketCreated") {
+    const url = paramsRecord?.url;
+    if (!url)
+      return;
+    if (state.urlFilter && !url.includes(state.urlFilter))
+      return;
+    const completed = {
+      url,
+      method: "GET",
+      status: 101,
+      statusText: "Switching Protocols",
+      requestHeaders: { Upgrade: "websocket", Connection: "Upgrade" },
+      timestamp: Date.now()
+    };
+    if (state.requests.length >= state.maxRequests) {
+      evictOldestRequest(state);
+    }
+    state.requests.push(completed);
+  } else if (method === "Runtime.consoleAPICalled") {
+    const type = paramsRecord?.type;
+    const args = paramsRecord?.args;
+    if (!type || !args)
+      return;
+    const messageParts = [];
+    for (const arg of args) {
+      if (arg.value !== void 0) {
+        messageParts.push(typeof arg.value === "string" ? arg.value : JSON.stringify(arg.value));
+      } else if (arg.description) {
+        messageParts.push(arg.description);
+      } else {
+        messageParts.push(arg.type ?? "undefined");
+      }
+    }
+    if (state.consoleLogs.length >= state.maxConsoleLogs) {
+      state.consoleLogs.shift();
+    }
+    state.consoleLogs.push({
+      level: type,
+      message: messageParts.join(" "),
+      timestamp: Date.now()
+    });
+  }
+});
+chrome.tabs.onRemoved.addListener((tabId) => {
+  if (captures.has(tabId)) {
+    void chrome.debugger.detach({ tabId }).catch(() => {
+    });
+    captures.delete(tabId);
+  }
+});
+var startCapture = async (tabId, maxRequests = 100, urlFilter, maxConsoleLogs = 500) => {
+  if (captures.has(tabId)) {
+    throw new Error(`Network capture already active for tab ${tabId}. Call stopCapture first.`);
+  }
+  try {
+    await chrome.debugger.attach({ tabId }, CDP_VERSION);
+  } catch (err2) {
+    throw new Error(`Failed to attach debugger to tab ${tabId}: ${toErrorMessage(err2)}. Another debugger (e.g., DevTools) may already be attached.`);
+  }
+  try {
+    await chrome.debugger.sendCommand({ tabId }, "Network.enable");
+    await chrome.debugger.sendCommand({ tabId }, "Runtime.enable");
+  } catch (err2) {
+    await chrome.debugger.detach({ tabId }).catch(() => {
+    });
+    throw err2;
+  }
+  captures.set(tabId, {
+    requests: [],
+    consoleLogs: [],
+    maxRequests,
+    maxConsoleLogs,
+    urlFilter,
+    pendingRequests: /* @__PURE__ */ new Map(),
+    requestIdToRequest: /* @__PURE__ */ new Map()
+  });
+};
+var stopCapture = (tabId) => {
+  const state = captures.get(tabId);
+  if (!state)
+    return;
+  void chrome.debugger.detach({ tabId }).catch(() => {
+  });
+  captures.delete(tabId);
+};
+var getRequests = (tabId, clear = false) => {
+  const state = captures.get(tabId);
+  if (!state)
+    return [];
+  const requests = state.requests.map((req) => ({
+    ...req,
+    requestHeaders: scrubHeaders(req.requestHeaders),
+    responseHeaders: scrubHeaders(req.responseHeaders)
+  }));
+  if (clear) {
+    state.requests = [];
+    state.requestIdToRequest.clear();
+  }
+  return requests;
+};
+var isCapturing = (tabId) => captures.has(tabId);
+var getConsoleLogs = (tabId, clear = false, level) => {
+  const state = captures.get(tabId);
+  if (!state)
+    return [];
+  let logs = [...state.consoleLogs];
+  if (level && level !== "all") {
+    logs = logs.filter((entry) => entry.level === level);
+  }
+  if (clear) {
+    state.consoleLogs = [];
+  }
+  return logs;
+};
+var clearConsoleLogs = (tabId) => {
+  const state = captures.get(tabId);
+  if (state) {
+    state.consoleLogs = [];
+  }
+};
+var getActiveCapturesSummary = () => Array.from(captures.entries()).map(([tabId, state]) => ({
+  tabId,
+  requestCount: state.requests.length,
+  isCapturing: true
+}));
+
+// dist/plugin-storage.js
+var metaCache = null;
+var writeMutex = Promise.resolve();
+var serialize = (fn) => {
+  const result = writeMutex.then(fn);
+  writeMutex = result.then(() => {
+  }, () => {
+  });
+  return result;
+};
+var storePluginsBatch = (metas) => serialize(async () => {
+  if (metas.length === 0)
+    return;
+  const index = await getAllPluginMeta();
+  for (const meta of metas) {
+    index[meta.name] = meta;
+  }
+  await chrome.storage.local.set({ [PLUGINS_META_KEY]: index });
+  metaCache = index;
+});
+var removePlugin = (pluginName) => serialize(async () => {
+  const index = await getAllPluginMeta();
+  if (!(pluginName in index))
+    return;
+  const { [pluginName]: _, ...rest } = index;
+  await chrome.storage.local.set({ [PLUGINS_META_KEY]: rest });
+  metaCache = rest;
+});
+var removePluginsBatch = (pluginNames) => serialize(async () => {
+  if (pluginNames.length === 0)
+    return;
+  const index = await getAllPluginMeta();
+  const removeSet = new Set(pluginNames);
+  const filtered = {};
+  for (const [name, meta] of Object.entries(index)) {
+    if (!removeSet.has(name)) {
+      filtered[name] = meta;
+    }
+  }
+  await chrome.storage.local.set({ [PLUGINS_META_KEY]: filtered });
+  metaCache = filtered;
+});
+var VALID_TRUST_TIERS = /* @__PURE__ */ new Set(["official", "community", "local"]);
+var isValidPluginMeta = (value) => {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return typeof obj.name === "string" && typeof obj.version === "string" && Array.isArray(obj.urlPatterns) && typeof obj.trustTier === "string" && VALID_TRUST_TIERS.has(obj.trustTier) && Array.isArray(obj.tools);
+};
+var getAllPluginMeta = async () => {
+  if (metaCache !== null) {
+    return { ...metaCache };
+  }
+  const data = await chrome.storage.local.get(PLUGINS_META_KEY);
+  const index = data[PLUGINS_META_KEY];
+  if (!index || typeof index !== "object") {
+    metaCache = {};
+    return {};
+  }
+  const validated = {};
+  for (const [key, value] of Object.entries(index)) {
+    if (isValidPluginMeta(value)) {
+      validated[key] = value;
+    } else {
+      console.warn(`[opentabs] Skipping corrupted plugin meta entry: ${key}`);
+    }
+  }
+  metaCache = validated;
+  return { ...validated };
+};
+var getPluginMeta = async (pluginName) => {
+  const index = await getAllPluginMeta();
+  return index[pluginName];
+};
+var invalidatePluginCache = () => {
+  metaCache = null;
+};
+
+// dist/tab-matching.js
+var urlMatchesPatterns = (url, patterns) => {
+  for (const pattern of patterns) {
+    if (matchPattern(url, pattern))
+      return true;
+  }
+  return false;
+};
+var matchPattern = (url, pattern) => {
+  const matchResult = pattern.match(/^(\*|https?|ftp):\/\/(.+?)(\/.*)$/);
+  if (!matchResult?.[1] || !matchResult[2] || !matchResult[3])
+    return false;
+  const [, scheme, hostWithPort, path] = matchResult;
+  let patternHost;
+  let patternPort;
+  const colonIdx = hostWithPort.lastIndexOf(":");
+  if (colonIdx > 0 && /^\d+$/.test(hostWithPort.slice(colonIdx + 1))) {
+    patternHost = hostWithPort.slice(0, colonIdx);
+    patternPort = hostWithPort.slice(colonIdx + 1);
+  } else {
+    patternHost = hostWithPort;
+    patternPort = "";
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (scheme !== "*" && parsed.protocol !== `${scheme}:`)
+    return false;
+  if (scheme === "*" && !["http:", "https:"].includes(parsed.protocol))
+    return false;
+  if (patternPort) {
+    if (parsed.port !== patternPort)
+      return false;
+  }
+  if (patternHost !== "*") {
+    if (patternHost.startsWith("*.")) {
+      const suffix = patternHost.slice(2);
+      if (parsed.hostname !== suffix && !parsed.hostname.endsWith(`.${suffix}`))
+        return false;
+    } else {
+      if (parsed.hostname !== patternHost)
+        return false;
+    }
+  }
+  if (path !== "/*") {
+    const pathRegex = new RegExp("^" + path.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$");
+    if (!pathRegex.test(parsed.pathname))
+      return false;
+  }
+  return true;
+};
+var findAllMatchingTabs = async (plugin) => {
+  const seen = /* @__PURE__ */ new Set();
+  const allMatches = [];
+  for (const pattern of plugin.urlPatterns) {
+    let tabs;
+    try {
+      tabs = await chrome.tabs.query({ url: pattern });
+    } catch {
+      continue;
+    }
+    for (const tab of tabs) {
+      if (tab.id !== void 0 && !seen.has(tab.id)) {
+        seen.add(tab.id);
+        allMatches.push(tab);
+      }
+    }
+  }
+  if (allMatches.length <= 1)
+    return allMatches;
+  let focusedWindowId;
+  try {
+    const focusedWindow = await chrome.windows.getLastFocused();
+    focusedWindowId = focusedWindow.id;
+  } catch {
+  }
+  const rank = (tab) => {
+    const inFocused = focusedWindowId !== void 0 && tab.windowId === focusedWindowId;
+    if (tab.active && inFocused)
+      return 3;
+    if (tab.active)
+      return 2;
+    if (inFocused)
+      return 1;
+    return 0;
+  };
+  return allMatches.slice().sort((a, b) => rank(b) - rank(a));
+};
+
+// dist/tab-state.js
+var lastKnownState = /* @__PURE__ */ new Map();
+var pluginLocks = /* @__PURE__ */ new Map();
+var withPluginLock = (pluginName, fn) => {
+  const prev = pluginLocks.get(pluginName) ?? Promise.resolve();
+  const next = prev.then(fn);
+  pluginLocks.set(pluginName, next.catch((err2) => {
+    console.warn("[opentabs] tab state operation failed for plugin", pluginName, ":", err2);
+  }));
+  return next;
+};
+var probeTabReadiness = async (tabId, pluginName) => {
+  let timerId;
+  try {
+    const results = await Promise.race([
+      chrome.scripting.executeScript({
+        target: { tabId },
+        world: "MAIN",
+        func: async (pName) => {
+          const ot = globalThis.__openTabs;
+          const adapter = ot?.adapters?.[pName];
+          if (!adapter || typeof adapter !== "object")
+            return false;
+          if (typeof adapter.isReady !== "function")
+            return false;
+          return await adapter.isReady();
+        },
+        args: [pluginName]
+      }),
+      new Promise((resolve) => {
+        timerId = setTimeout(() => resolve(null), IS_READY_TIMEOUT_MS);
+      })
+    ]);
+    if (results === null) {
+      console.warn(`[opentabs] isReady() timed out for plugin "${pluginName}" in tab ${tabId}`);
+      return false;
+    }
+    const readyResult = results[0];
+    return readyResult?.result === true;
+  } finally {
+    if (timerId !== void 0)
+      clearTimeout(timerId);
+  }
+};
+var computePluginTabState = async (plugin) => {
+  const tabs = await findAllMatchingTabs(plugin);
+  if (tabs.length === 0) {
+    return { state: "closed", tabId: null, url: null };
+  }
+  let firstUnavailable;
+  for (const tab of tabs) {
+    if (tab.id === void 0)
+      continue;
+    try {
+      const ready = await probeTabReadiness(tab.id, plugin.name);
+      if (ready) {
+        return { state: "ready", tabId: tab.id, url: tab.url ?? null };
+      }
+      firstUnavailable ??= tab;
+    } catch (err2) {
+      console.warn(`[opentabs] computePluginTabState failed for plugin ${plugin.name} in tab ${tab.id}:`, err2);
+      firstUnavailable ??= tab;
+    }
+  }
+  const fallbackTab = firstUnavailable ?? tabs[0];
+  return {
+    state: "unavailable",
+    tabId: fallbackTab?.id ?? null,
+    url: fallbackTab?.url ?? null
+  };
+};
+var sendTabSyncAll = async () => {
+  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 entries = [];
+  for (const result of settled) {
+    if (result.status === "fulfilled") {
+      entries.push(result.value);
+    } else {
+      console.warn("[opentabs] Tab state computation failed during syncAll:", result.reason);
+    }
+  }
+  if (entries.length === 0)
+    return;
+  const tabSyncPayload = Object.fromEntries(entries);
+  const pluginNamesInSync = /* @__PURE__ */ new Set();
+  await Promise.all(entries.map(([pluginName, stateInfo]) => {
+    pluginNamesInSync.add(pluginName);
+    return withPluginLock(pluginName, () => {
+      lastKnownState.set(pluginName, stateInfo.state);
+      return Promise.resolve();
+    });
+  }));
+  for (const key of lastKnownState.keys()) {
+    if (!pluginNamesInSync.has(key)) {
+      lastKnownState.delete(key);
+      pluginLocks.delete(key);
+    }
+  }
+  sendToServer({
+    jsonrpc: "2.0",
+    method: "tab.syncAll",
+    params: { tabs: tabSyncPayload }
+  });
+  for (const [pluginName, stateInfo] of entries) {
+    forwardToSidePanel({
+      type: "sp:serverMessage",
+      data: {
+        jsonrpc: "2.0",
+        method: "tab.stateChanged",
+        params: { plugin: pluginName, state: stateInfo.state, tabId: stateInfo.tabId, url: stateInfo.url }
+      }
+    });
+  }
+};
+var clearTabStateCache = () => {
+  lastKnownState.clear();
+  pluginLocks.clear();
+};
+var clearPluginTabState = (pluginName) => {
+  lastKnownState.delete(pluginName);
+  pluginLocks.delete(pluginName);
+};
+var updateLastKnownState = (pluginName, state) => withPluginLock(pluginName, () => {
+  lastKnownState.set(pluginName, state);
+  return Promise.resolve();
+});
+var getLastKnownStates = () => lastKnownState;
+var notifyAffectedPlugins = async (affectedPlugins) => {
+  await Promise.all(affectedPlugins.map((plugin) => withPluginLock(plugin.name, async () => {
+    const newState = await computePluginTabState(plugin);
+    const previous = lastKnownState.get(plugin.name);
+    if (previous === newState.state)
+      return;
+    lastKnownState.set(plugin.name, newState.state);
+    sendTabStateNotification(plugin.name, newState);
+  })));
+};
+var checkTabRemoved = async (_removedTabId) => {
+  const index = await getAllPluginMeta();
+  const plugins = Object.values(index);
+  if (plugins.length === 0)
+    return;
+  await notifyAffectedPlugins(plugins);
+};
+var checkTabChanged = async (changedTabId, changeInfo) => {
+  const index = await getAllPluginMeta();
+  const plugins = Object.values(index);
+  if (plugins.length === 0)
+    return;
+  let affectedPlugins;
+  if (changeInfo.url) {
+    const changedUrl = changeInfo.url;
+    affectedPlugins = plugins.filter((p) => urlMatchesPatterns(changedUrl, p.urlPatterns) || lastKnownState.has(p.name) && lastKnownState.get(p.name) !== "closed");
+  } else if (changeInfo.status === "complete") {
+    let tabUrl;
+    try {
+      const tab = await chrome.tabs.get(changedTabId);
+      tabUrl = tab.url;
+    } catch {
+      return;
+    }
+    if (!tabUrl)
+      return;
+    affectedPlugins = plugins.filter((p) => urlMatchesPatterns(tabUrl, p.urlPatterns) || lastKnownState.has(p.name) && lastKnownState.get(p.name) !== "closed");
+  } else {
+    return;
+  }
+  if (affectedPlugins.length === 0)
+    return;
+  await notifyAffectedPlugins(affectedPlugins);
+};
+
+// dist/browser-commands/extension-commands.js
+var handleExtensionGetState = async (id) => {
+  try {
+    const sessionData = await chrome.storage.session.get(WS_CONNECTED_KEY).catch(() => ({}));
+    const wsConnected2 = typeof sessionData[WS_CONNECTED_KEY] === "boolean" ? sessionData[WS_CONNECTED_KEY] : false;
+    const localData = await chrome.storage.local.get(SERVER_PORT_KEY).catch(() => ({}));
+    const port = typeof localData[SERVER_PORT_KEY] === "number" && localData[SERVER_PORT_KEY] > 0 ? localData[SERVER_PORT_KEY] : DEFAULT_SERVER_PORT;
+    const mcpServerUrl = buildWsUrl(port);
+    const pluginIndex = await getAllPluginMeta();
+    const lastKnownStates = getLastKnownStates();
+    const plugins = Object.values(pluginIndex).map((meta) => ({
+      name: meta.name,
+      version: meta.version,
+      displayName: meta.displayName,
+      urlPatterns: meta.urlPatterns,
+      toolCount: meta.tools.length,
+      tabState: lastKnownStates.get(meta.name) ?? "closed"
+    }));
+    const networkCaptures = getActiveCapturesSummary();
+    let offscreenExists = false;
+    try {
+      const contexts = await chrome.runtime.getContexts({
+        contextTypes: ["OFFSCREEN_DOCUMENT"]
+      });
+      offscreenExists = contexts.length > 0;
+    } catch {
+    }
+    sendSuccessResult(id, {
+      connection: { wsConnected: wsConnected2, mcpServerUrl },
+      plugins,
+      networkCaptures,
+      offscreen: { exists: offscreenExists }
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleExtensionGetLogs = async (params, id) => {
+  try {
+    const filterOptions = {};
+    if (typeof params.level === "string" && params.level !== "all") {
+      filterOptions.level = params.level;
+    }
+    if (typeof params.source === "string" && params.source !== "all") {
+      filterOptions.source = params.source;
+    }
+    if (typeof params.limit === "number") {
+      filterOptions.limit = params.limit;
+    }
+    if (typeof params.since === "number") {
+      filterOptions.since = params.since;
+    }
+    const bgEntries = bgLogCollector.getEntries(filterOptions);
+    const bgStats = bgLogCollector.getStats();
+    let offscreenEntries = [];
+    let offscreenStats = {
+      totalCaptured: 0,
+      bufferSize: 0,
+      oldestTimestamp: null,
+      newestTimestamp: null
+    };
+    try {
+      const raw = await chrome.runtime.sendMessage({
+        type: "offscreen:getLogs",
+        options: Object.keys(filterOptions).length > 0 ? filterOptions : void 0
+      });
+      const response = raw;
+      if (response && Array.isArray(response.entries)) {
+        offscreenEntries = response.entries;
+      }
+      if (response?.stats) {
+        offscreenStats = response.stats;
+      }
+    } catch {
+    }
+    const merged = [...bgEntries, ...offscreenEntries].sort((a, b) => b.timestamp - a.timestamp);
+    const limit = filterOptions.limit ?? DEFAULT_LOG_LIMIT;
+    const entries = merged.slice(0, limit);
+    sendSuccessResult(id, {
+      entries,
+      stats: {
+        totalBackground: bgStats.totalCaptured,
+        totalOffscreen: offscreenStats.totalCaptured,
+        bufferSize: bgStats.bufferSize + offscreenStats.bufferSize
+      }
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleExtensionGetSidePanel = async (id) => {
+  try {
+    const sidePanelResult = await Promise.race([
+      chrome.runtime.sendMessage({ type: "sp:getState" }).then((raw) => raw),
+      new Promise((resolve) => setTimeout(() => resolve(null), SIDE_PANEL_TIMEOUT_MS))
+    ]);
+    if (!sidePanelResult || typeof sidePanelResult !== "object") {
+      sendSuccessResult(id, { open: false });
+      return;
+    }
+    const response = sidePanelResult;
+    sendSuccessResult(id, { open: true, state: response.state, html: response.html });
+  } catch {
+    sendSuccessResult(id, { open: false });
+  }
+};
+var handleExtensionCheckAdapter = async (params, id) => {
+  try {
+    const pluginName = requireStringParam(params, "plugin", id);
+    if (pluginName === null)
+      return;
+    const meta = await getPluginMeta(pluginName);
+    if (!meta) {
+      sendValidationError(id, `Plugin not found: "${pluginName}"`);
+      return;
+    }
+    const matchingTabs = await findAllMatchingTabs(meta);
+    const tabResults = await Promise.allSettled(matchingTabs.map(async (tab) => {
+      const tabId = tab.id;
+      if (tabId === void 0)
+        return null;
+      const inspectResults = await chrome.scripting.executeScript({
+        target: { tabId },
+        world: "MAIN",
+        func: (pName) => {
+          const ot = globalThis.__openTabs;
+          const adapter = ot?.adapters?.[pName];
+          if (!adapter || typeof adapter !== "object") {
+            return { adapterPresent: false };
+          }
+          const toolNames = [];
+          if (Array.isArray(adapter.tools)) {
+            for (const tool of adapter.tools) {
+              if (tool && typeof tool === "object" && typeof tool.name === "string") {
+                toolNames.push(tool.name);
+              }
+            }
+          }
+          return {
+            adapterPresent: true,
+            adapterHash: typeof adapter.__hash === "string" ? adapter.__hash : null,
+            toolCount: toolNames.length,
+            toolNames
+          };
+        },
+        args: [pluginName]
+      });
+      const inspectResult = inspectResults[0]?.result;
+      if (!inspectResult) {
+        return {
+          tabId,
+          tabUrl: tab.url ?? "",
+          adapterPresent: false,
+          adapterHash: null,
+          hashMatch: false,
+          isReady: false,
+          toolCount: 0,
+          toolNames: []
+        };
+      }
+      if (!inspectResult.adapterPresent) {
+        return {
+          tabId,
+          tabUrl: tab.url ?? "",
+          adapterPresent: false,
+          adapterHash: null,
+          hashMatch: false,
+          isReady: false,
+          toolCount: 0,
+          toolNames: []
+        };
+      }
+      let isReady = false;
+      try {
+        const readyResults = await Promise.race([
+          chrome.scripting.executeScript({
+            target: { tabId },
+            world: "MAIN",
+            func: async (pName) => {
+              const ot = globalThis.__openTabs;
+              const adapter = ot?.adapters?.[pName];
+              if (!adapter || typeof adapter.isReady !== "function")
+                return false;
+              return await adapter.isReady();
+            },
+            args: [pluginName]
+          }),
+          new Promise((resolve) => setTimeout(() => resolve(null), IS_READY_TIMEOUT_MS))
+        ]);
+        if (readyResults !== null) {
+          const readyResult = readyResults[0];
+          isReady = readyResult?.result === true;
+        }
+      } catch {
+      }
+      return {
+        tabId,
+        tabUrl: tab.url ?? "",
+        adapterPresent: true,
+        adapterHash: inspectResult.adapterHash ?? null,
+        hashMatch: meta.adapterHash ? inspectResult.adapterHash === meta.adapterHash : false,
+        isReady,
+        toolCount: inspectResult.toolCount ?? 0,
+        toolNames: inspectResult.toolNames ?? []
+      };
+    }));
+    const matchingTabResults = [];
+    for (const result of tabResults) {
+      if (result.status === "fulfilled" && result.value !== null) {
+        matchingTabResults.push(result.value);
+      }
+    }
+    sendSuccessResult(id, {
+      plugin: pluginName,
+      expectedHash: meta.adapterHash ?? null,
+      matchingTabs: matchingTabResults
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleExtensionForceReconnect = async (id) => {
+  try {
+    sendSuccessResult(id, { reconnecting: true });
+    await new Promise((resolve) => setTimeout(resolve, WS_FLUSH_DELAY_MS));
+    await chrome.runtime.sendMessage({
+      type: "bg:forceReconnect"
+    });
+  } catch (err2) {
+    console.warn("[opentabs] extension.forceReconnect failed:", err2);
+  }
+};
+var handleBrowserExecuteScript = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const execFile = requireStringParam(params, "execFile", id);
+    if (execFile === null)
+      return;
+    if (!/^__exec-[a-f0-9-]+\.js$/.test(execFile)) {
+      sendValidationError(id, "Invalid execFile format");
+      return;
+    }
+    let timeoutId;
+    const injectPromise = (async () => {
+      await chrome.scripting.executeScript({
+        target: { tabId },
+        world: "MAIN",
+        files: [`adapters/${execFile}`]
+      });
+      let elapsed = 0;
+      while (elapsed <= EXEC_MAX_ASYNC_WAIT_MS) {
+        const results = await chrome.scripting.executeScript({
+          target: { tabId },
+          world: "MAIN",
+          func: (truncLimit) => {
+            const ot = globalThis.__openTabs;
+            if (!ot)
+              return { pending: false, result: { error: "__openTabs not found" } };
+            const result2 = ot.__lastExecResult;
+            const isAsync = ot.__lastExecAsync === true;
+            if (result2 && ("value" in result2 || "error" in result2)) {
+              const captured = { ...result2 };
+              if (captured.value === void 0)
+                captured.value = null;
+              if (captured.value !== null && typeof captured.value === "object") {
+                try {
+                  const json = JSON.stringify(captured.value);
+                  captured.value = json.length > truncLimit ? json.slice(0, truncLimit) + "... (truncated)" : JSON.parse(json);
+                } catch {
+                  captured.value = String(captured.value);
+                }
+              }
+              delete ot.__lastExecResult;
+              delete ot.__lastExecAsync;
+              return { pending: false, result: captured };
+            }
+            if (isAsync)
+              return { pending: true };
+            return { pending: false, result: { error: "No result captured" } };
+          },
+          args: [EXEC_RESULT_TRUNCATION_LIMIT]
+        });
+        const first = results[0];
+        const data = first?.result;
+        if (data && !data.pending) {
+          return { value: data.result };
+        }
+        await new Promise((resolve) => setTimeout(resolve, EXEC_POLL_INTERVAL_MS));
+        elapsed += EXEC_POLL_INTERVAL_MS;
+      }
+      await chrome.scripting.executeScript({
+        target: { tabId },
+        world: "MAIN",
+        func: () => {
+          const ot = globalThis.__openTabs;
+          if (ot) {
+            delete ot.__lastExecResult;
+            delete ot.__lastExecAsync;
+          }
+        }
+      }).catch(() => {
+      });
+      return { value: { error: `Async code did not resolve within ${EXEC_MAX_ASYNC_WAIT_MS}ms` } };
+    })();
+    const timeoutPromise = new Promise((_resolve, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error(`Script execution timed out after ${SCRIPT_TIMEOUT_MS}ms`));
+      }, SCRIPT_TIMEOUT_MS);
+    });
+    let result;
+    try {
+      result = await Promise.race([injectPromise, timeoutPromise]);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    sendSuccessResult(id, result);
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/browser-commands/resource-commands.js
+var TEXT_MIME_PREFIXES = ["text/"];
+var TEXT_MIME_EXACT = /* @__PURE__ */ new Set([
+  "application/javascript",
+  "application/json",
+  "application/xml",
+  "application/xhtml+xml",
+  "application/x-javascript",
+  "application/ecmascript"
+]);
+var isTextMimeType = (mimeType) => {
+  if (TEXT_MIME_PREFIXES.some((prefix) => mimeType.startsWith(prefix)))
+    return true;
+  return TEXT_MIME_EXACT.has(mimeType);
+};
+var findFrameForResource = (tree, targetUrl) => {
+  for (const r of tree.resources) {
+    if (r.url === targetUrl) {
+      return { frameId: tree.frame.id, mimeType: r.mimeType };
+    }
+  }
+  if (tree.childFrames) {
+    for (const child of tree.childFrames) {
+      const found = findFrameForResource(child, targetUrl);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+};
+var withDebugger = async (tabId, fn) => {
+  const alreadyAttached = isCapturing(tabId);
+  if (!alreadyAttached) {
+    try {
+      await chrome.debugger.attach({ tabId }, CDP_VERSION);
+    } catch (err2) {
+      const msg = toErrorMessage(err2);
+      throw new Error(msg.includes("Another debugger") ? "Failed to attach debugger \u2014 another debugger (e.g., DevTools) is already attached. Close DevTools or enable network capture first (browser_enable_network_capture) so this tool can reuse the existing debugger session." : `Failed to attach debugger: ${sanitizeErrorMessage(msg)}`);
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    if (!alreadyAttached) {
+      await chrome.debugger.detach({ tabId }).catch(() => {
+      });
+    }
+  }
+};
+var handleBrowserListResources = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const typeFilter = typeof params.type === "string" ? params.type : void 0;
+    await withDebugger(tabId, async () => {
+      await chrome.debugger.sendCommand({ tabId }, "Page.enable");
+      const treeResult = await chrome.debugger.sendCommand({ tabId }, "Page.getResourceTree");
+      const frames = [];
+      const resources = [];
+      const walk = (node) => {
+        frames.push({ url: node.frame.url, securityOrigin: node.frame.securityOrigin });
+        for (const r of node.resources) {
+          if (typeFilter && r.type !== typeFilter)
+            continue;
+          resources.push({
+            url: r.url,
+            type: r.type,
+            mimeType: r.mimeType,
+            contentLength: r.contentLength ?? -1
+          });
+        }
+        if (node.childFrames) {
+          for (const child of node.childFrames)
+            walk(child);
+        }
+      };
+      walk(treeResult.frameTree);
+      resources.sort((a, b) => a.type.localeCompare(b.type) || a.url.localeCompare(b.url));
+      sendSuccessResult(id, { frames, resources });
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserGetResourceContent = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const url = requireStringParam(params, "url", id);
+    if (url === null)
+      return;
+    const maxLength = typeof params.maxLength === "number" ? params.maxLength : 5e5;
+    await withDebugger(tabId, async () => {
+      await chrome.debugger.sendCommand({ tabId }, "Page.enable");
+      const treeResult = await chrome.debugger.sendCommand({ tabId }, "Page.getResourceTree");
+      const match = findFrameForResource(treeResult.frameTree, url);
+      if (!match) {
+        sendValidationError(id, `Resource not found in page: ${url}. Use browser_list_resources to find valid resource URLs.`);
+        return;
+      }
+      const contentResult = await chrome.debugger.sendCommand({ tabId }, "Page.getResourceContent", {
+        frameId: match.frameId,
+        url
+      });
+      let content = contentResult.content;
+      let base64Encoded = contentResult.base64Encoded;
+      if (base64Encoded && isTextMimeType(match.mimeType)) {
+        try {
+          content = new TextDecoder().decode(Uint8Array.from(atob(content), (c) => c.charCodeAt(0)));
+          base64Encoded = false;
+        } catch {
+        }
+      }
+      let truncated = false;
+      if (!base64Encoded && content.length > maxLength) {
+        content = content.slice(0, maxLength) + "... (truncated)";
+        truncated = true;
+      }
+      sendSuccessResult(id, { url, content, base64Encoded, mimeType: match.mimeType, truncated });
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/browser-commands/interaction-commands.js
+var handleBrowserClickElement = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = requireSelector(params, id);
+    if (selector === null)
+      return;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, maxPreview) => {
+        const el = document.querySelector(sel);
+        if (!el)
+          return { error: `Element not found: ${sel}` };
+        el.click();
+        return {
+          clicked: true,
+          tagName: el.tagName.toLowerCase(),
+          text: (el.textContent || "").trim().slice(0, maxPreview)
+        };
+      },
+      args: [selector, TEXT_PREVIEW_MAX_LENGTH]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, { clicked: result.clicked, tagName: result.tagName, text: result.text });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserTypeText = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = requireSelector(params, id);
+    if (selector === null)
+      return;
+    const text = requireStringParam(params, "text", id);
+    if (text === null)
+      return;
+    const clear = typeof params.clear === "boolean" ? params.clear : true;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, txt, clr) => {
+        const el = document.querySelector(sel);
+        if (!el)
+          return { error: `Element not found: ${sel}` };
+        const tag = el.tagName.toLowerCase();
+        const isEditable = tag === "input" || tag === "textarea" || el.isContentEditable;
+        if (!isEditable)
+          return { error: `Element is not a text input (found <${tag}>)` };
+        if (tag === "input" || tag === "textarea") {
+          const input = el;
+          input.focus();
+          input.value = clr ? txt : input.value + txt;
+          input.dispatchEvent(new Event("input", { bubbles: true }));
+          input.dispatchEvent(new Event("change", { bubbles: true }));
+          return { typed: true, tagName: tag, value: input.value };
+        }
+        const htmlEl = el;
+        htmlEl.focus();
+        if (clr)
+          htmlEl.textContent = "";
+        const selection = window.getSelection();
+        if (selection) {
+          if (selection.rangeCount === 0) {
+            const range2 = document.createRange();
+            range2.selectNodeContents(htmlEl);
+            range2.collapse(false);
+            selection.removeAllRanges();
+            selection.addRange(range2);
+          }
+          const range = selection.getRangeAt(0);
+          range.deleteContents();
+          range.insertNode(document.createTextNode(txt));
+          range.collapse(false);
+          selection.removeAllRanges();
+          selection.addRange(range);
+        }
+        htmlEl.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: txt }));
+        return { typed: true, tagName: tag, value: htmlEl.textContent || "" };
+      },
+      args: [selector, text, clear]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, { typed: result.typed, tagName: result.tagName, value: result.value });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserSelectOption = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = requireSelector(params, id);
+    if (selector === null)
+      return;
+    const value = typeof params.value === "string" ? params.value : void 0;
+    const label = typeof params.label === "string" ? params.label : void 0;
+    if (value === void 0 && label === void 0) {
+      sendValidationError(id, "At least one of value or label must be provided");
+      return;
+    }
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, val, lbl) => {
+        const el = document.querySelector(sel);
+        if (!el)
+          return { error: `Element not found: ${sel}` };
+        if (el.tagName.toLowerCase() !== "select")
+          return { error: `Element is not a <select>: ${sel}` };
+        const select = el;
+        const options = Array.from(select.options);
+        let matchedIndex = -1;
+        for (let i = 0; i < options.length; i++) {
+          const opt = options[i];
+          if (!opt)
+            continue;
+          const isMatch = val !== null ? opt.value === val : (opt.textContent || "").trim() === lbl;
+          if (isMatch) {
+            matchedIndex = i;
+            break;
+          }
+        }
+        if (matchedIndex === -1) {
+          const criterion = val !== null ? `value="${val}"` : `label="${String(lbl)}"`;
+          return { error: `Option not found: ${criterion}` };
+        }
+        select.selectedIndex = matchedIndex;
+        select.dispatchEvent(new Event("change", { bubbles: true }));
+        const selectedOpt = options[matchedIndex];
+        return {
+          selected: true,
+          value: selectedOpt ? selectedOpt.value : "",
+          label: selectedOpt ? (selectedOpt.textContent || "").trim() : ""
+        };
+      },
+      args: [selector, value ?? null, label ?? null]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, { selected: result.selected, value: result.value, label: result.label });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserWaitForElement = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = requireSelector(params, id);
+    if (selector === null)
+      return;
+    const timeout = typeof params.timeout === "number" ? params.timeout : DEFAULT_WAIT_TIMEOUT_MS;
+    const visible = typeof params.visible === "boolean" ? params.visible : false;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, tmo, vis, maxPreview, pollMs) => new Promise((resolve) => {
+        let elapsed = 0;
+        const poll = setInterval(() => {
+          const el = document.querySelector(sel);
+          if (el) {
+            const htmlEl = el;
+            const isVisible = !vis || htmlEl.offsetParent !== null && getComputedStyle(htmlEl).display !== "none";
+            if (isVisible) {
+              clearInterval(poll);
+              resolve({
+                found: true,
+                tagName: el.tagName.toLowerCase(),
+                text: (el.textContent || "").trim().slice(0, maxPreview)
+              });
+              return;
+            }
+          }
+          elapsed += pollMs;
+          if (elapsed >= tmo) {
+            clearInterval(poll);
+            resolve({ error: `Timeout waiting for element: ${sel} (${tmo}ms)` });
+          }
+        }, pollMs);
+      }),
+      args: [selector, timeout, visible, TEXT_PREVIEW_MAX_LENGTH, POLL_INTERVAL_MS]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, { found: result.found, tagName: result.tagName, text: result.text });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserQueryElements = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = requireSelector(params, id);
+    if (selector === null)
+      return;
+    const limit = typeof params.limit === "number" ? params.limit : DEFAULT_QUERY_LIMIT;
+    const attributes = Array.isArray(params.attributes) ? params.attributes.filter((a) => typeof a === "string") : ["id", "class", "href", "src", "type", "name", "value", "placeholder"];
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, lim, attrs, maxPreview) => {
+        const all = document.querySelectorAll(sel);
+        const elements = Array.from(all).slice(0, lim).map((el) => ({
+          tagName: el.tagName.toLowerCase(),
+          text: (el.textContent || "").trim().slice(0, maxPreview),
+          attributes: Object.fromEntries(attrs.filter((a) => el.hasAttribute(a)).map((a) => [a, el.getAttribute(a)]))
+        }));
+        return { count: all.length, elements };
+      },
+      args: [selector, limit, attributes, TEXT_PREVIEW_MAX_LENGTH]
+    });
+    const result = extractScriptResult(results, id, "No result from query");
+    if (!result)
+      return;
+    sendSuccessResult(id, { count: result.count, elements: result.elements });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserHoverElement = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = requireSelector(params, id);
+    if (selector === null)
+      return;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, maxPreview) => {
+        const el = document.querySelector(sel);
+        if (!el)
+          return { error: `Element not found: ${sel}` };
+        const rect = el.getBoundingClientRect();
+        const clientX = rect.left + rect.width / 2;
+        const clientY = rect.top + rect.height / 2;
+        const pointerOpts = {
+          clientX,
+          clientY,
+          pointerId: 1,
+          pointerType: "mouse"
+        };
+        const mouseOpts = { clientX, clientY };
+        el.dispatchEvent(new PointerEvent("pointerenter", { bubbles: false, ...pointerOpts }));
+        el.dispatchEvent(new PointerEvent("pointerover", { bubbles: true, ...pointerOpts }));
+        el.dispatchEvent(new MouseEvent("mouseenter", { bubbles: false, ...mouseOpts }));
+        el.dispatchEvent(new MouseEvent("mouseover", { bubbles: true, ...mouseOpts }));
+        el.dispatchEvent(new PointerEvent("pointermove", { bubbles: true, ...pointerOpts }));
+        el.dispatchEvent(new MouseEvent("mousemove", { bubbles: true, ...mouseOpts }));
+        return {
+          hovered: true,
+          tagName: el.tagName.toLowerCase(),
+          text: (el.textContent || "").trim().slice(0, maxPreview),
+          bounds: { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
+        };
+      },
+      args: [selector, TEXT_PREVIEW_MAX_LENGTH]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, {
+      hovered: result.hovered,
+      tagName: result.tagName,
+      text: result.text,
+      bounds: result.bounds
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserHandleDialog = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const action = requireStringParam(params, "action", id);
+    if (action === null)
+      return;
+    if (action !== "accept" && action !== "dismiss") {
+      sendValidationError(id, "action must be 'accept' or 'dismiss'");
+      return;
+    }
+    const accept = action === "accept";
+    const promptText = typeof params.promptText === "string" ? params.promptText : void 0;
+    await withDebugger(tabId, async () => {
+      await chrome.debugger.sendCommand({ tabId }, "Page.enable");
+      try {
+        await chrome.debugger.sendCommand({ tabId }, "Page.handleJavaScriptDialog", {
+          accept,
+          ...promptText !== void 0 ? { promptText } : {}
+        });
+        sendSuccessResult(id, { handled: true, action });
+      } catch (err2) {
+        const msg = toErrorMessage(err2);
+        const isNoDialog = msg.includes("No dialog is showing") || msg.includes("no dialog");
+        sendErrorResult(id, isNoDialog ? new Error("No JavaScript dialog is currently open on this tab") : err2);
+      }
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/browser-commands/key-press-command.js
+var handleBrowserPressKey = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const key = requireStringParam(params, "key", id);
+    if (key === null)
+      return;
+    const selector = typeof params.selector === "string" && params.selector.length > 0 ? params.selector : null;
+    const modifiers = typeof params.modifiers === "object" && params.modifiers !== null ? params.modifiers : {};
+    const shiftKey = modifiers.shift === true;
+    const ctrlKey = modifiers.ctrl === true;
+    const altKey = modifiers.alt === true;
+    const metaKey = modifiers.meta === true;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (k, sel, shift, ctrl, alt, meta) => {
+        let target = null;
+        if (sel) {
+          target = document.querySelector(sel);
+          if (!target)
+            return { error: `Element not found: ${sel}` };
+          target.focus();
+        } else {
+          target = document.activeElement ?? document.body;
+        }
+        const deriveCode = (k2) => {
+          if (k2.length === 1) {
+            const upper = k2.toUpperCase();
+            if (upper >= "A" && upper <= "Z")
+              return `Key${upper}`;
+            if (k2 >= "0" && k2 <= "9")
+              return `Digit${k2}`;
+            if (k2 === " ")
+              return "Space";
+            return k2;
+          }
+          return k2;
+        };
+        const KEY_CODES = {
+          Enter: 13,
+          Escape: 27,
+          Tab: 9,
+          Backspace: 8,
+          Delete: 46,
+          ArrowUp: 38,
+          ArrowDown: 40,
+          ArrowLeft: 37,
+          ArrowRight: 39,
+          Home: 36,
+          End: 35,
+          PageUp: 33,
+          PageDown: 34,
+          " ": 32
+        };
+        const getKeyCode = (k2) => {
+          if (KEY_CODES[k2] !== void 0)
+            return KEY_CODES[k2];
+          if (k2.length === 1)
+            return k2.toUpperCase().charCodeAt(0);
+          return 0;
+        };
+        const code = deriveCode(k);
+        const keyCode = getKeyCode(k);
+        const isPrintable = k.length === 1;
+        const eventInit = {
+          key: k,
+          code,
+          keyCode,
+          which: keyCode,
+          bubbles: true,
+          cancelable: true,
+          shiftKey: shift,
+          ctrlKey: ctrl,
+          metaKey: meta,
+          altKey: alt
+        };
+        target.dispatchEvent(new KeyboardEvent("keydown", eventInit));
+        if (isPrintable) {
+          target.dispatchEvent(new KeyboardEvent("keypress", eventInit));
+        }
+        target.dispatchEvent(new KeyboardEvent("keyup", eventInit));
+        if (isPrintable) {
+          const tag = target.tagName.toLowerCase();
+          const isEditable = tag === "input" || tag === "textarea" || target.isContentEditable;
+          if (isEditable) {
+            if (tag === "input" || tag === "textarea") {
+              const input = target;
+              const start = input.selectionStart ?? input.value.length;
+              const end = input.selectionEnd ?? start;
+              input.value = input.value.slice(0, start) + k + input.value.slice(end);
+              input.selectionStart = input.selectionEnd = start + 1;
+            } else {
+              const selection = window.getSelection();
+              if (selection && selection.rangeCount > 0) {
+                const range = selection.getRangeAt(0);
+                range.deleteContents();
+                range.insertNode(document.createTextNode(k));
+                range.collapse(false);
+                selection.removeAllRanges();
+                selection.addRange(range);
+              }
+            }
+            target.dispatchEvent(new InputEvent("input", {
+              bubbles: true,
+              cancelable: true,
+              inputType: "insertText",
+              data: k
+            }));
+          }
+        }
+        return {
+          pressed: true,
+          key: k,
+          target: {
+            tagName: target.tagName.toLowerCase(),
+            id: target.id || void 0
+          }
+        };
+      },
+      args: [key, selector, shiftKey, ctrlKey, altKey, metaKey]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, { pressed: result.pressed, key: result.key, target: result.target });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/browser-commands/scroll-command.js
+var handleBrowserScroll = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const selector = typeof params.selector === "string" && params.selector.length > 0 ? params.selector : null;
+    const direction = typeof params.direction === "string" ? params.direction : null;
+    if (direction !== null && direction !== "up" && direction !== "down" && direction !== "left" && direction !== "right") {
+      sendValidationError(id, `Invalid direction: "${direction}". Must be one of: up, down, left, right`);
+      return;
+    }
+    const distance = typeof params.distance === "number" ? params.distance : null;
+    const position = typeof params.position === "object" && params.position !== null ? params.position : null;
+    const container = typeof params.container === "string" && params.container.length > 0 ? params.container : null;
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (sel, dir, dist, pos, ctr, maxPreview) => {
+        let scrollEl = null;
+        if (ctr) {
+          scrollEl = document.querySelector(ctr);
+          if (!scrollEl)
+            return { error: `Container not found: ${ctr}` };
+        }
+        const getMetrics = () => {
+          if (scrollEl) {
+            return {
+              scrollPosition: { x: scrollEl.scrollLeft, y: scrollEl.scrollTop },
+              scrollSize: { width: scrollEl.scrollWidth, height: scrollEl.scrollHeight },
+              viewportSize: { width: scrollEl.clientWidth, height: scrollEl.clientHeight }
+            };
+          }
+          return {
+            scrollPosition: { x: window.scrollX, y: window.scrollY },
+            scrollSize: {
+              width: document.documentElement.scrollWidth,
+              height: document.documentElement.scrollHeight
+            },
+            viewportSize: { width: window.innerWidth, height: window.innerHeight }
+          };
+        };
+        if (sel) {
+          const el = document.querySelector(sel);
+          if (!el)
+            return { error: `Element not found: ${sel}` };
+          el.scrollIntoView({ behavior: "instant", block: "center" });
+          const text = (el.textContent || "").trim().slice(0, maxPreview);
+          return {
+            scrolledTo: { tagName: el.tagName.toLowerCase(), text },
+            ...getMetrics()
+          };
+        }
+        if (dir) {
+          const metrics = getMetrics();
+          const defaultVertical = metrics.viewportSize.height;
+          const defaultHorizontal = metrics.viewportSize.width;
+          let dx = 0;
+          let dy = 0;
+          if (dir === "down")
+            dy = dist ?? defaultVertical;
+          else if (dir === "up")
+            dy = -(dist ?? defaultVertical);
+          else if (dir === "right")
+            dx = dist ?? defaultHorizontal;
+          else if (dir === "left")
+            dx = -(dist ?? defaultHorizontal);
+          if (scrollEl) {
+            scrollEl.scrollBy({ left: dx, top: dy, behavior: "instant" });
+          } else {
+            window.scrollBy({ left: dx, top: dy, behavior: "instant" });
+          }
+          return getMetrics();
+        }
+        if (pos) {
+          const opts = { behavior: "instant" };
+          if (pos.x !== void 0)
+            opts.left = pos.x;
+          if (pos.y !== void 0)
+            opts.top = pos.y;
+          if (scrollEl) {
+            scrollEl.scrollTo(opts);
+          } else {
+            window.scrollTo(opts);
+          }
+          return getMetrics();
+        }
+        return getMetrics();
+      },
+      args: [
+        selector,
+        direction,
+        distance,
+        position ? {
+          x: position.x,
+          y: position.y
+        } : null,
+        container,
+        TEXT_PREVIEW_MAX_LENGTH
+      ]
+    });
+    const result = extractScriptResult(results, id);
+    if (!result)
+      return;
+    sendSuccessResult(id, {
+      ...result.scrolledTo !== void 0 ? { scrolledTo: result.scrolledTo } : {},
+      scrollPosition: result.scrollPosition,
+      scrollSize: result.scrollSize,
+      viewportSize: result.viewportSize
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/browser-commands/network-commands.js
+var handleBrowserEnableNetworkCapture = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const maxRequests = typeof params.maxRequests === "number" ? params.maxRequests : 100;
+    const urlFilter = typeof params.urlFilter === "string" ? params.urlFilter : void 0;
+    const maxConsoleLogs = typeof params.maxConsoleLogs === "number" ? params.maxConsoleLogs : 500;
+    await startCapture(tabId, maxRequests, urlFilter, maxConsoleLogs);
+    sendSuccessResult(id, { enabled: true, tabId });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserGetNetworkRequests = (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const clear = typeof params.clear === "boolean" ? params.clear : false;
+    const requests = getRequests(tabId, clear);
+    sendSuccessResult(id, { requests });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserDisableNetworkCapture = (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    stopCapture(tabId);
+    sendSuccessResult(id, { disabled: true, tabId });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserGetConsoleLogs = (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const clear = typeof params.clear === "boolean" ? params.clear : false;
+    const level = typeof params.level === "string" ? params.level : void 0;
+    const logs = getConsoleLogs(tabId, clear, level);
+    sendSuccessResult(id, { logs });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserClearConsoleLogs = (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    clearConsoleLogs(tabId);
+    sendSuccessResult(id, { cleared: true });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/browser-commands/tab-commands.js
+var handleBrowserListTabs = async (id) => {
+  try {
+    const tabs = await chrome.tabs.query({});
+    const result = tabs.map((tab) => ({
+      id: tab.id,
+      title: tab.title ?? "",
+      url: tab.url ?? "",
+      active: tab.active,
+      windowId: tab.windowId
+    }));
+    sendSuccessResult(id, result);
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserOpenTab = async (params, id) => {
+  try {
+    const url = requireUrl(params, id);
+    if (url === null)
+      return;
+    const tab = await chrome.tabs.create({ url });
+    sendSuccessResult(id, { id: tab.id, title: tab.title ?? "", url: tab.url ?? url, windowId: tab.windowId });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserCloseTab = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    await chrome.tabs.remove(tabId);
+    sendSuccessResult(id, { ok: true });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserNavigateTab = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const url = requireUrl(params, id);
+    if (url === null)
+      return;
+    const tab = await chrome.tabs.update(tabId, { url });
+    sendSuccessResult(id, { id: tab?.id ?? tabId, title: tab?.title ?? "", url: tab?.url ?? url });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserFocusTab = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const tab = await chrome.tabs.update(tabId, { active: true });
+    if (!tab) {
+      sendValidationError(id, `Tab ${tabId} not found`);
+      return;
+    }
+    await chrome.windows.update(tab.windowId, { focused: true });
+    sendSuccessResult(id, { id: tab.id, title: tab.title ?? "", url: tab.url ?? "", active: true });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+var handleBrowserGetTabInfo = async (params, id) => {
+  try {
+    const tabId = requireTabId(params, id);
+    if (tabId === null)
+      return;
+    const tab = await chrome.tabs.get(tabId);
+    sendSuccessResult(id, {
+      id: tab.id,
+      title: tab.title ?? "",
+      url: tab.url ?? "",
+      status: tab.status ?? "",
+      active: tab.active,
+      windowId: tab.windowId,
+      favIconUrl: tab.favIconUrl ?? "",
+      incognito: tab.incognito
+    });
+  } catch (err2) {
+    sendErrorResult(id, err2);
+  }
+};
+
+// dist/iife-injection.js
+var RESERVED_NAMES = /* @__PURE__ */ new Set(["system", "browser", "opentabs", "extension", "config", "plugin", "tool", "mcp"]);
+var isSafePluginName = (name) => isValidPluginName(name) && !RESERVED_NAMES.has(name);
+var isAdapterPresent = async (tabId, pluginName) => {
+  try {
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (pName) => {
+        const ot = globalThis.__openTabs;
+        return ot?.adapters?.[pName] !== void 0;
+      },
+      args: [pluginName]
+    });
+    const first = results[0];
+    return first?.result === true;
+  } catch (err2) {
+    console.warn(`[opentabs] isAdapterPresent failed for tab ${String(tabId)}, plugin ${pluginName}:`, err2);
+    return false;
+  }
+};
+var verifyAdapterVersion = async (tabId, pluginName, expectedVersion) => {
+  try {
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (pName) => {
+        const ot = globalThis.__openTabs;
+        return ot?.adapters?.[pName]?.version;
+      },
+      args: [pluginName]
+    });
+    const first = results[0];
+    const version = first?.result;
+    if (version !== expectedVersion) {
+      console.warn(`[opentabs] Adapter version mismatch for ${pluginName}: expected ${expectedVersion}, got ${String(version)}`);
+      return false;
+    }
+    return true;
+  } catch {
+    console.warn(`[opentabs] Failed to verify adapter version for ${pluginName}`);
+    return false;
+  }
+};
+var readAdapterHash = async (tabId, pluginName) => {
+  try {
+    const results = await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (pName) => {
+        const ot = globalThis.__openTabs;
+        return ot?.adapters?.[pName]?.__adapterHash;
+      },
+      args: [pluginName]
+    });
+    const first = results[0];
+    return typeof first?.result === "string" ? first.result : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var verifyAdapterHash = async (tabId, pluginName, expectedHash) => {
+  const hash = await readAdapterHash(tabId, pluginName);
+  return hash === expectedHash;
+};
+var injectLogRelay = async (tabId) => {
+  const nonce = crypto.randomUUID();
+  try {
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "ISOLATED",
+      func: (n) => {
+        const guard = "__opentabs_log_relay";
+        const win = window;
+        if (win[guard]) {
+          const nonceSet = win.__opentabs_log_nonces;
+          if (nonceSet)
+            nonceSet.add(n);
+          return;
+        }
+        win[guard] = true;
+        const nonces = /* @__PURE__ */ new Set([n]);
+        win.__opentabs_log_nonces = nonces;
+        window.addEventListener("message", (event) => {
+          if (event.source !== window)
+            return;
+          const data = event.data;
+          if (!data || data.type !== "opentabs:plugin-logs")
+            return;
+          if (typeof data.nonce !== "string" || !nonces.has(data.nonce))
+            return;
+          const plugin = data.plugin;
+          const entries = data.entries;
+          if (typeof plugin !== "string" || !Array.isArray(entries) || entries.length === 0)
+            return;
+          chrome.runtime.sendMessage({ type: "plugin:logs", plugin, entries }).catch(() => {
+          });
+        });
+      },
+      args: [nonce]
+    });
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (n) => {
+        const ot = globalThis.__openTabs ?? {};
+        globalThis.__openTabs = ot;
+        ot._logNonce = n;
+      },
+      args: [nonce]
+    });
+  } catch (err2) {
+    console.warn(`[opentabs] injectLogRelay failed for tab ${String(tabId)}:`, err2);
+  }
+};
+var injectAdapterFile = async (tabId, pluginName, version, adapterHash, adapterFilePath) => {
+  await injectLogRelay(tabId);
+  const adapterFile = adapterFilePath ?? `adapters/${pluginName}.js`;
+  try {
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      files: [adapterFile]
+    });
+  } catch (err2) {
+    throw new Error(`Failed to inject adapter file '${adapterFile}' into tab ${String(tabId)}: ${toErrorMessage(err2)}`);
+  }
+  if (version) {
+    await verifyAdapterVersion(tabId, pluginName, version);
+  }
+  if (adapterHash) {
+    const hashMatched = await verifyAdapterHash(tabId, pluginName, adapterHash);
+    if (!hashMatched) {
+      await new Promise((resolve) => setTimeout(resolve, INJECTION_RETRY_DELAY_MS));
+      try {
+        await chrome.scripting.executeScript({
+          target: { tabId },
+          world: "MAIN",
+          files: [adapterFile]
+        });
+      } catch (err2) {
+        throw new Error(`Failed to re-inject adapter file '${adapterFile}' into tab ${String(tabId)}: ${toErrorMessage(err2)}`);
+      }
+      if (version) {
+        await verifyAdapterVersion(tabId, pluginName, version);
+      }
+      const retryMatched = await verifyAdapterHash(tabId, pluginName, adapterHash);
+      if (!retryMatched) {
+        const actualHash = await readAdapterHash(tabId, pluginName);
+        throw new Error(`Adapter hash mismatch for ${pluginName} after retry: expected ${adapterHash}, got ${String(actualHash)}`);
+      }
+    }
+  }
+};
+var queryMatchingTabIds = async (urlPatterns) => {
+  const tabIds = /* @__PURE__ */ new Set();
+  for (const pattern of urlPatterns) {
+    try {
+      const tabs = await chrome.tabs.query({ url: pattern });
+      for (const tab of tabs) {
+        if (tab.id !== void 0) {
+          tabIds.add(tab.id);
+        }
+      }
+    } catch (err2) {
+      console.warn(`[opentabs] chrome.tabs.query failed for pattern ${pattern}:`, err2);
+    }
+  }
+  return Array.from(tabIds);
+};
+var prepareForReinjection = async (tabId) => {
+  await chrome.scripting.executeScript({
+    target: { tabId },
+    world: "MAIN",
+    func: () => {
+      const ot = globalThis.__openTabs;
+      if (!ot)
+        return;
+      const adapters = ot.adapters;
+      if (!adapters)
+        return;
+      const newAdapters = {};
+      for (const key of Object.keys(adapters)) {
+        newAdapters[key] = adapters[key];
+      }
+      const newOt = {};
+      for (const key of Object.keys(ot)) {
+        if (key === "adapters")
+          continue;
+        const desc = Object.getOwnPropertyDescriptor(ot, key);
+        if (desc)
+          Object.defineProperty(newOt, key, desc);
+      }
+      newOt.adapters = newAdapters;
+      globalThis.__openTabs = newOt;
+    },
+    args: []
+  }).catch((err2) => {
+    console.warn(`[opentabs] prepareForReinjection failed:`, err2);
+  });
+};
+var injectPluginIntoMatchingTabs = async (pluginName, urlPatterns, forceReinject = false, version, adapterHash, adapterFile) => {
+  if (!isSafePluginName(pluginName)) {
+    console.warn(`[opentabs] Skipping injection for unsafe plugin name: ${pluginName}`);
+    return [];
+  }
+  const tabIds = await queryMatchingTabIds(urlPatterns);
+  const results = await Promise.allSettled(tabIds.map(async (tabId) => {
+    if (!forceReinject && await isAdapterPresent(tabId, pluginName)) {
+      return tabId;
+    }
+    if (forceReinject) {
+      await prepareForReinjection(tabId);
+    }
+    await injectAdapterFile(tabId, pluginName, version, adapterHash, adapterFile);
+    return tabId;
+  }));
+  const injectedTabIds = [];
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      injectedTabIds.push(result.value);
+    }
+  }
+  return injectedTabIds;
+};
+var injectPluginsIntoTab = async (tabId, tabUrl) => {
+  const index = await getAllPluginMeta();
+  const plugins = Object.values(index);
+  if (plugins.length === 0)
+    return;
+  const matching = plugins.filter((p) => isSafePluginName(p.name) && urlMatchesPatterns(tabUrl, p.urlPatterns));
+  if (matching.length === 0)
+    return;
+  const presenceResults = await Promise.allSettled(matching.map(async (plugin) => ({
+    plugin,
+    present: await isAdapterPresent(tabId, plugin.name)
+  })));
+  const needsInjection = presenceResults.filter((r) => r.status === "fulfilled" && !r.value.present).map((r) => r.value.plugin);
+  if (needsInjection.length === 0)
+    return;
+  await Promise.allSettled(needsInjection.map(async (plugin) => {
+    try {
+      await injectAdapterFile(tabId, plugin.name, plugin.version, plugin.adapterHash, plugin.adapterFile);
+    } catch (err2) {
+      console.warn(`[opentabs] Injection failed for tab ${String(tabId)}, plugin ${plugin.name}:`, err2);
+    }
+  }));
+};
+var cleanupAdaptersInMatchingTabs = async (pluginName, urlPatterns) => {
+  if (!isSafePluginName(pluginName)) {
+    console.warn(`[opentabs] Skipping cleanup for unsafe plugin name: ${pluginName}`);
+    return;
+  }
+  const tabIds = await queryMatchingTabIds(urlPatterns);
+  await Promise.allSettled(tabIds.map(async (tabId) => {
+    try {
+      await chrome.scripting.executeScript({
+        target: { tabId },
+        world: "MAIN",
+        func: (pName) => {
+          const ot = globalThis.__openTabs;
+          const adapters = ot?.adapters;
+          if (!adapters)
+            return;
+          const adapter = adapters[pName];
+          if (adapter) {
+            if (typeof adapter.teardown === "function") {
+              try {
+                adapter.teardown();
+              } catch (e) {
+                console.warn("[opentabs] teardown error:", e);
+              }
+            }
+            if (!Reflect.deleteProperty(adapters, pName)) {
+              const newAdapters = {};
+              for (const key of Object.keys(adapters)) {
+                if (key !== pName) {
+                  const desc = Object.getOwnPropertyDescriptor(adapters, key);
+                  if (desc)
+                    Object.defineProperty(newAdapters, key, desc);
+                }
+              }
+              delete globalThis.__openTabs;
+              globalThis.__openTabs = Object.assign({}, ot, {
+                adapters: newAdapters
+              });
+            }
+          }
+        },
+        args: [pluginName]
+      });
+    } catch (err2) {
+      console.warn(`[opentabs] Cleanup failed for tab ${String(tabId)}, plugin ${pluginName}:`, err2);
+    }
+  }));
+};
+var reinjectStoredPlugins = async () => {
+  const index = await getAllPluginMeta();
+  const plugins = Object.values(index);
+  if (plugins.length === 0)
+    return;
+  const results = await Promise.allSettled(plugins.map((plugin) => injectPluginIntoMatchingTabs(plugin.name, plugin.urlPatterns, false, plugin.version, plugin.adapterHash, plugin.adapterFile)));
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result && result.status === "rejected") {
+      const plugin = plugins[i];
+      console.warn(`[opentabs] Failed to reinject stored plugin ${plugin?.name ?? "unknown"}:`, result.reason);
+    }
+  }
+};
+
+// dist/rate-limiter.js
+var METHOD_LIMITS = /* @__PURE__ */ new Map([
+  // Expensive operations — tight limits
+  ["browser.screenshotTab", { maxRequests: 2, windowMs: 1e3 }],
+  ["browser.enableNetworkCapture", { maxRequests: 2, windowMs: 1e3 }],
+  ["browser.executeScript", { maxRequests: 15, windowMs: 1e3 }],
+  // Tool dispatch — allow bursts of sequential/concurrent tool calls from agents
+  ["tool.dispatch", { maxRequests: 30, windowMs: 1e3 }]
+]);
+var DEFAULT_LIMIT = { maxRequests: 20, windowMs: 1e3 };
+var EXEMPT_METHODS = /* @__PURE__ */ new Set(["extension.reload", "sync.full", "plugin.update", "plugin.uninstall"]);
+var methodTimestamps = /* @__PURE__ */ new Map();
+var checkRateLimit = (method, now = Date.now()) => {
+  if (EXEMPT_METHODS.has(method))
+    return true;
+  const config = METHOD_LIMITS.get(method) ?? DEFAULT_LIMIT;
+  const cutoff = now - config.windowMs;
+  const timestamps = (methodTimestamps.get(method) ?? []).filter((t) => t > cutoff);
+  if (timestamps.length >= config.maxRequests) {
+    methodTimestamps.set(method, timestamps);
+    return false;
+  }
+  timestamps.push(now);
+  methodTimestamps.set(method, timestamps);
+  return true;
+};
+
+// dist/dispatch-helpers.js
+var isAdapterNotReady = (result) => result.type === "error" && result.code === JSONRPC_ADAPTER_NOT_READY;
+var resolvePlugin = async (pluginName, id) => {
+  const plugin = await getPluginMeta(pluginName);
+  if (!plugin) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INTERNAL_ERROR, message: `Plugin "${pluginName}" not found` },
+      id
+    });
+    return null;
+  }
+  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);
+  if (matchingTabs.length === 0) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_NO_USABLE_TAB, message: `No matching tab for plugin "${pluginName}" (state: closed)` },
+      id
+    });
+    return;
+  }
+  let firstError;
+  for (const tab of matchingTabs) {
+    if (tab.id === void 0)
+      continue;
+    try {
+      const currentTab = await chrome.tabs.get(tab.id);
+      if (!currentTab.url || !urlMatchesPatterns(currentTab.url, plugin.urlPatterns)) {
+        firstError ??= { code: JSONRPC_NO_USABLE_TAB, message: "Tab navigated away from matching URL" };
+        continue;
+      }
+    } catch {
+      firstError ??= { code: JSONRPC_NO_USABLE_TAB, message: `Tab closed before ${operationName}` };
+      continue;
+    }
+    try {
+      const result = await executeOnTab(tab.id);
+      if (result.type === "success") {
+        sendToServer({ jsonrpc: "2.0", result: { output: result.output }, id });
+        return;
+      }
+      if (isAdapterNotReady(result) && matchingTabs.length > 1) {
+        firstError ??= { code: result.code, message: sanitizeErrorMessage(result.message) };
+        continue;
+      }
+      sendToServer({
+        jsonrpc: "2.0",
+        error: { code: result.code, message: sanitizeErrorMessage(result.message), data: result.data },
+        id
+      });
+      return;
+    } catch (err2) {
+      const msg = toErrorMessage(err2);
+      const isTabGone = msg.includes("No tab with id") || msg.includes("Cannot access");
+      if (isTabGone && matchingTabs.length > 1) {
+        firstError ??= { code: JSONRPC_NO_USABLE_TAB, message: `Tab closed before ${operationName}` };
+        continue;
+      }
+      sendToServer({
+        jsonrpc: "2.0",
+        error: {
+          code: isTabGone ? JSONRPC_NO_USABLE_TAB : JSONRPC_INTERNAL_ERROR,
+          message: isTabGone ? `Tab closed before ${operationName}` : `Script execution failed: ${sanitizeErrorMessage(msg)}`
+        },
+        id
+      });
+      return;
+    }
+  }
+  if (firstError) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: firstError.code, message: firstError.message, data: firstError.data },
+      id
+    });
+  } else {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_NO_USABLE_TAB, message: "No usable tab found (all matching tabs have undefined IDs)" },
+      id
+    });
+  }
+};
+
+// 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 plugin = await resolvePlugin(pluginName, id);
+  if (!plugin)
+    return;
+  await dispatchWithTabFallback({
+    id,
+    pluginName,
+    plugin,
+    operationName: "resource read",
+    executeOnTab: (tabId) => executeResourceReadOnTab(tabId, pluginName, resourceUri)
+  });
+};
+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 plugin = await resolvePlugin(pluginName, id);
+  if (!plugin)
+    return;
+  await dispatchWithTabFallback({
+    id,
+    pluginName,
+    plugin,
+    operationName: "prompt get",
+    executeOnTab: (tabId) => executePromptGetOnTab(tabId, pluginName, promptName, promptArgs)
+  });
+};
+
+// dist/tool-dispatch.js
+var progressCallbacks = /* @__PURE__ */ new Map();
+var notifyDispatchProgress = (dispatchId) => {
+  const cb = progressCallbacks.get(dispatchId);
+  if (cb)
+    cb();
+};
+var getPluginLink = (plugin) => {
+  if (plugin.trustTier === "local" && plugin.sourcePath) {
+    return plugin.sourcePath;
+  }
+  if (plugin.trustTier === "official") {
+    return `https://npmjs.com/package/@opentabs-dev/plugin-${plugin.name}`;
+  }
+  return `https://npmjs.com/package/opentabs-plugin-${plugin.name}`;
+};
+var injectToolInvocationLog = async (tabId, pluginName, toolName, link) => {
+  try {
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      func: (pName, tName, lnk) => {
+        console.warn(`[opentabs] ${pName}.${tName} invoked \u2014 ${lnk}`);
+      },
+      args: [pluginName, toolName, link]
+    });
+  } catch {
+  }
+};
+var injectProgressListener = async (tabId, dispatchId) => {
+  try {
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "ISOLATED",
+      func: (dId) => {
+        const eventName = `opentabs:progress:${dId}`;
+        const handler = (e) => {
+          const detail = e.detail;
+          if (!detail)
+            return;
+          void chrome.runtime.sendMessage({
+            type: "tool:progress",
+            dispatchId: detail.dispatchId,
+            progress: detail.progress,
+            total: detail.total,
+            message: detail.message
+          });
+        };
+        document.addEventListener(eventName, handler);
+        const cleanupKey = `__opentabs_progress_cleanup_${dId}`;
+        const doc = document;
+        doc[cleanupKey] = () => {
+          document.removeEventListener(eventName, handler);
+          doc[cleanupKey] = void 0;
+        };
+      },
+      args: [dispatchId]
+    });
+  } catch {
+  }
+};
+var removeProgressListener = (tabId, dispatchId) => {
+  chrome.scripting.executeScript({
+    target: { tabId },
+    world: "ISOLATED",
+    func: (dId) => {
+      const cleanupKey = `__opentabs_progress_cleanup_${dId}`;
+      const cleanup = document[cleanupKey];
+      if (cleanup)
+        cleanup();
+    },
+    args: [dispatchId]
+  }).catch(() => {
+  });
+};
+var executeToolOnTab = async (tabId, pluginName, toolName, input, dispatchId) => {
+  let timeoutId;
+  const startTs = Date.now();
+  const scriptPromise = chrome.scripting.executeScript({
+    target: { tabId },
+    world: "MAIN",
+    func: async (pName, tName, tInput, dId) => {
+      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` };
+      }
+      if (!Array.isArray(adapter.tools)) {
+        return { type: "error", code: -32002, message: `Adapter "${pName}" has no tools array` };
+      }
+      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)`
+        };
+      }
+      const tool = adapter.tools.find((t) => t.name === tName);
+      if (!tool || typeof tool.handle !== "function") {
+        return { type: "error", code: -32603, message: `Tool "${tName}" not found in adapter "${pName}"` };
+      }
+      const context = {
+        reportProgress(opts) {
+          try {
+            document.dispatchEvent(new CustomEvent(`opentabs:progress:${dId}`, {
+              detail: {
+                dispatchId: dId,
+                progress: opts.progress ?? 0,
+                total: opts.total ?? 0,
+                message: opts.message
+              }
+            }));
+          } catch {
+          }
+        }
+      };
+      try {
+        const output = await tool.handle(tInput, context);
+        return { type: "success", output };
+      } catch (err2) {
+        const caughtError = err2;
+        if (typeof caughtError.code !== "string") {
+          return {
+            type: "error",
+            code: -32603,
+            message: caughtError.message ?? "Tool execution failed"
+          };
+        }
+        const data = { code: caughtError.code };
+        if (typeof caughtError.retryable === "boolean")
+          data.retryable = caughtError.retryable;
+        if (typeof caughtError.retryAfterMs === "number")
+          data.retryAfterMs = caughtError.retryAfterMs;
+        if (typeof caughtError.category === "string")
+          data.category = caughtError.category;
+        return {
+          type: "error",
+          code: -32603,
+          message: caughtError.message ?? "Tool execution failed",
+          data
+        };
+      }
+    },
+    args: [pluginName, toolName, input, dispatchId]
+  });
+  let timeoutReject;
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timeoutReject = reject;
+    timeoutId = setTimeout(() => {
+      reject(new Error(`Script execution timed out after ${SCRIPT_TIMEOUT_MS}ms`));
+    }, SCRIPT_TIMEOUT_MS);
+  });
+  progressCallbacks.set(dispatchId, () => {
+    clearTimeout(timeoutId);
+    const elapsed = Date.now() - startTs;
+    const remainingMax = MAX_SCRIPT_TIMEOUT_MS - elapsed;
+    if (remainingMax <= 0) {
+      timeoutReject?.(new Error(`Script execution exceeded absolute max timeout of ${MAX_SCRIPT_TIMEOUT_MS}ms`));
+      return;
+    }
+    const nextTimeout = Math.min(SCRIPT_TIMEOUT_MS, remainingMax);
+    timeoutId = setTimeout(() => {
+      timeoutReject?.(new Error(`Script execution timed out after ${SCRIPT_TIMEOUT_MS}ms`));
+    }, nextTimeout);
+  });
+  let results;
+  try {
+    results = await Promise.race([scriptPromise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+    progressCallbacks.delete(dispatchId);
+  }
+  const firstResult = results[0];
+  const result = firstResult?.result;
+  if (!result || typeof result !== "object" || !("type" in result)) {
+    return { type: "error", code: JSONRPC_INTERNAL_ERROR, message: "No result from tool execution" };
+  }
+  return result;
+};
+var handleToolDispatch = async (params, id) => {
+  const dispatchId = typeof params.dispatchId === "string" ? params.dispatchId : String(id);
+  const pluginName = requireStringParam(params, "plugin", id);
+  if (!pluginName)
+    return;
+  const toolName = requireStringParam(params, "tool", id);
+  if (!toolName)
+    return;
+  const rawInput = params.input;
+  if (rawInput !== void 0 && rawInput !== null && (typeof rawInput !== "object" || Array.isArray(rawInput))) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INVALID_PARAMS, message: 'Invalid "input" param (expected object)' },
+      id
+    });
+    return;
+  }
+  const input = rawInput ?? {};
+  let inputJson;
+  try {
+    inputJson = JSON.stringify(input);
+  } catch (err2) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: {
+        code: JSONRPC_INVALID_PARAMS,
+        message: `Failed to serialize tool input: ${toErrorMessage(err2)}`
+      },
+      id
+    });
+    return;
+  }
+  if (inputJson.length > MAX_INPUT_SIZE) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: {
+        code: JSONRPC_INVALID_PARAMS,
+        message: `Tool input too large: ${(inputJson.length / 1024 / 1024).toFixed(1)}MB (limit: 10MB)`
+      },
+      id
+    });
+    return;
+  }
+  const plugin = await resolvePlugin(pluginName, id);
+  if (!plugin)
+    return;
+  const link = getPluginLink(plugin);
+  await dispatchWithTabFallback({
+    id,
+    pluginName,
+    plugin,
+    operationName: "tool execution",
+    executeOnTab: async (tabId) => {
+      await injectToolInvocationLog(tabId, pluginName, toolName, link);
+      await injectProgressListener(tabId, dispatchId);
+      try {
+        return await executeToolOnTab(tabId, pluginName, toolName, input, dispatchId);
+      } finally {
+        removeProgressListener(tabId, dispatchId);
+      }
+    }
+  });
+};
+
+// dist/message-router.js
+var wrapAsync = (method, fn) => (params, id) => {
+  if (id !== void 0) {
+    fn(params, id).catch((err2) => console.warn(`[opentabs] ${method} handler failed:`, err2));
+  }
+};
+var wrapSync = (method, fn) => (params, id) => {
+  if (id !== void 0) {
+    try {
+      fn(params, id);
+    } catch (err2) {
+      console.warn(`[opentabs] ${method} handler failed:`, err2);
+    }
+  }
+};
+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",
+  "confirmation.request"
+]);
+var toPluginMeta = (p) => ({
+  name: p.name,
+  version: p.version,
+  displayName: p.displayName,
+  urlPatterns: p.urlPatterns,
+  trustTier: p.trustTier,
+  sourcePath: p.sourcePath,
+  adapterHash: p.adapterHash,
+  adapterFile: p.adapterFile,
+  iconSvg: p.iconSvg,
+  iconInactiveSvg: p.iconInactiveSvg,
+  tools: p.tools
+});
+var validatePluginPayload = (raw) => {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    console.warn("[opentabs] Rejecting plugin payload: not an object");
+    return null;
+  }
+  const obj = raw;
+  if (typeof obj.name !== "string" || obj.name.length === 0) {
+    console.warn('[opentabs] Rejecting plugin payload: missing or invalid "name"');
+    return null;
+  }
+  if (/[/\\]|\.\./.test(obj.name) || !isValidPluginName(obj.name)) {
+    console.warn(`[opentabs] Rejecting plugin payload: unsafe name "${obj.name}"`);
+    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
+  })) : [];
+  return {
+    name: obj.name,
+    version: typeof obj.version === "string" ? obj.version : "0.0.0",
+    displayName: typeof obj.displayName === "string" ? obj.displayName : obj.name,
+    urlPatterns,
+    trustTier: obj.trustTier === "official" || obj.trustTier === "community" || obj.trustTier === "local" ? obj.trustTier : "local",
+    sourcePath: typeof obj.sourcePath === "string" ? obj.sourcePath : void 0,
+    adapterHash: typeof obj.adapterHash === "string" ? obj.adapterHash : void 0,
+    adapterFile: typeof obj.adapterFile === "string" ? obj.adapterFile : void 0,
+    iconSvg: typeof obj.iconSvg === "string" ? obj.iconSvg : void 0,
+    iconInactiveSvg: typeof obj.iconInactiveSvg === "string" ? obj.iconInactiveSvg : void 0,
+    tools
+  };
+};
+var handleExtensionReload = (_params, id) => {
+  if (id !== void 0) {
+    sendToServer({ jsonrpc: "2.0", result: { reloading: true }, id });
+  }
+  void chrome.storage.session.set({ [WS_CONNECTED_KEY]: false }).catch(() => {
+  }).then(() => {
+    setTimeout(() => {
+      chrome.runtime.reload();
+    }, RELOAD_FLUSH_DELAY_MS);
+  });
+};
+var handleSyncFull = async (params) => {
+  const rawPlugins = params.plugins;
+  if (!Array.isArray(rawPlugins))
+    return;
+  const validated = [];
+  for (const raw of rawPlugins) {
+    const result = validatePluginPayload(raw);
+    if (result)
+      validated.push(result);
+  }
+  const deduped = /* @__PURE__ */ new Map();
+  for (const p of validated) {
+    if (deduped.has(p.name)) {
+      console.warn(`[opentabs] Duplicate plugin in sync.full: ${p.name} \u2014 using last occurrence`);
+    }
+    deduped.set(p.name, p);
+  }
+  const uniquePlugins = Array.from(deduped.values());
+  const syncedNames = new Set(uniquePlugins.map((p) => p.name));
+  const existingMeta = await getAllPluginMeta();
+  const removedNames = Object.keys(existingMeta).filter((name) => !syncedNames.has(name));
+  if (removedNames.length > 0) {
+    await Promise.allSettled(removedNames.map((name) => {
+      const meta = existingMeta[name];
+      if (meta)
+        return cleanupAdaptersInMatchingTabs(name, meta.urlPatterns);
+      return Promise.resolve();
+    }));
+    await removePluginsBatch(removedNames);
+    for (const name of removedNames)
+      clearPluginTabState(name);
+  }
+  const metas = uniquePlugins.map(toPluginMeta);
+  await storePluginsBatch(metas);
+  const injectionResults = await Promise.allSettled(metas.map((meta) => injectPluginIntoMatchingTabs(meta.name, meta.urlPatterns, true, meta.version, meta.adapterHash, meta.adapterFile)));
+  for (const result of injectionResults) {
+    if (result.status === "rejected") {
+      console.warn("[opentabs] Plugin injection failed during sync.full:", result.reason);
+    }
+  }
+  await sendTabSyncAll();
+  forwardToSidePanel({
+    type: "sp:serverMessage",
+    data: { jsonrpc: "2.0", method: "plugins.changed" }
+  });
+};
+var handlePluginUpdate = async (params) => {
+  const validated = validatePluginPayload(params);
+  if (!validated)
+    return;
+  const meta = toPluginMeta(validated);
+  await storePluginsBatch([meta]);
+  await injectPluginIntoMatchingTabs(meta.name, meta.urlPatterns, true, meta.version, meta.adapterHash, meta.adapterFile);
+  const newState = await computePluginTabState(meta);
+  await updateLastKnownState(meta.name, newState.state);
+  sendTabStateNotification(meta.name, newState);
+  forwardToSidePanel({
+    type: "sp:serverMessage",
+    data: { jsonrpc: "2.0", method: "plugins.changed" }
+  });
+};
+var handlePluginUninstall = async (params, id) => {
+  const pluginName = params.name;
+  if (typeof pluginName !== "string" || pluginName.length === 0) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INVALID_PARAMS, message: "Missing plugin name" },
+      id
+    });
+    return;
+  }
+  if (!isValidPluginName(pluginName)) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_INVALID_PARAMS, message: `Invalid plugin name format: "${pluginName}"` },
+      id
+    });
+    return;
+  }
+  const meta = await getAllPluginMeta();
+  const pluginMeta = meta[pluginName];
+  if (pluginMeta) {
+    try {
+      await cleanupAdaptersInMatchingTabs(pluginName, pluginMeta.urlPatterns);
+    } catch (err2) {
+      console.warn(`[opentabs] Failed to clean up adapters for ${pluginName}:`, err2);
+    }
+  }
+  await removePlugin(pluginName);
+  clearPluginTabState(pluginName);
+  sendToServer({
+    jsonrpc: "2.0",
+    result: { success: true },
+    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)],
+  ["browser.navigateTab", wrapAsync("browser.navigateTab", handleBrowserNavigateTab)],
+  ["browser.focusTab", wrapAsync("browser.focusTab", handleBrowserFocusTab)],
+  ["browser.getTabInfo", wrapAsync("browser.getTabInfo", handleBrowserGetTabInfo)],
+  ["browser.screenshotTab", wrapAsync("browser.screenshotTab", handleBrowserScreenshotTab)],
+  ["browser.getTabContent", wrapAsync("browser.getTabContent", handleBrowserGetTabContent)],
+  ["browser.getPageHtml", wrapAsync("browser.getPageHtml", handleBrowserGetPageHtml)],
+  ["browser.getStorage", wrapAsync("browser.getStorage", handleBrowserGetStorage)],
+  ["browser.clickElement", wrapAsync("browser.clickElement", handleBrowserClickElement)],
+  ["browser.typeText", wrapAsync("browser.typeText", handleBrowserTypeText)],
+  ["browser.selectOption", wrapAsync("browser.selectOption", handleBrowserSelectOption)],
+  ["browser.waitForElement", wrapAsync("browser.waitForElement", handleBrowserWaitForElement)],
+  ["browser.queryElements", wrapAsync("browser.queryElements", handleBrowserQueryElements)],
+  ["browser.getCookies", wrapAsync("browser.getCookies", handleBrowserGetCookies)],
+  ["browser.setCookie", wrapAsync("browser.setCookie", handleBrowserSetCookie)],
+  ["browser.deleteCookies", wrapAsync("browser.deleteCookies", handleBrowserDeleteCookies)],
+  ["browser.enableNetworkCapture", wrapAsync("browser.enableNetworkCapture", handleBrowserEnableNetworkCapture)],
+  ["browser.getNetworkRequests", wrapSync("browser.getNetworkRequests", handleBrowserGetNetworkRequests)],
+  ["browser.disableNetworkCapture", wrapSync("browser.disableNetworkCapture", handleBrowserDisableNetworkCapture)],
+  ["browser.getConsoleLogs", wrapSync("browser.getConsoleLogs", handleBrowserGetConsoleLogs)],
+  ["browser.clearConsoleLogs", wrapSync("browser.clearConsoleLogs", handleBrowserClearConsoleLogs)],
+  ["browser.executeScript", wrapAsync("browser.executeScript", handleBrowserExecuteScript)],
+  ["browser.listResources", wrapAsync("browser.listResources", handleBrowserListResources)],
+  ["browser.getResourceContent", wrapAsync("browser.getResourceContent", handleBrowserGetResourceContent)],
+  ["browser.pressKey", wrapAsync("browser.pressKey", handleBrowserPressKey)],
+  ["browser.scroll", wrapAsync("browser.scroll", handleBrowserScroll)],
+  ["browser.hoverElement", wrapAsync("browser.hoverElement", handleBrowserHoverElement)],
+  ["browser.handleDialog", wrapAsync("browser.handleDialog", handleBrowserHandleDialog)],
+  ["extension.getState", wrapAsync("extension.getState", (_params, id) => handleExtensionGetState(id))],
+  ["extension.getLogs", wrapAsync("extension.getLogs", handleExtensionGetLogs)],
+  ["extension.getSidePanel", wrapAsync("extension.getSidePanel", (_params, id) => handleExtensionGetSidePanel(id))],
+  ["extension.checkAdapter", wrapAsync("extension.checkAdapter", handleExtensionCheckAdapter)],
+  [
+    "extension.forceReconnect",
+    wrapAsync("extension.forceReconnect", (_params, id) => handleExtensionForceReconnect(id))
+  ]
+]);
+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)) {
+    forwardToSidePanel({ type: "sp:serverMessage", data: message });
+  }
+  if (method === "confirmation.request") {
+    notifyConfirmationRequest(params);
+  }
+  if (!method)
+    return;
+  const handler = methodHandlers.get(method);
+  if (handler) {
+    if (!checkRateLimit(method)) {
+      console.warn(`[opentabs] Rate limited: ${method}`);
+      if (id !== void 0) {
+        sendToServer({
+          jsonrpc: "2.0",
+          error: { code: JSONRPC_INTERNAL_ERROR, message: `Rate limited: ${method}` },
+          id
+        });
+      }
+      return;
+    }
+    handler(params, id);
+    return;
+  }
+  if (id !== void 0) {
+    sendToServer({
+      jsonrpc: "2.0",
+      error: { code: JSONRPC_METHOD_NOT_FOUND, message: `Method not found: ${method}` },
+      id
+    });
+  }
+};
+var methodHandlerNames = Array.from(methodHandlers.keys());
+
+// dist/background-message-handlers.js
+var wsConnected = false;
+var lastDisconnectReason;
+var restoreWsConnectedState = () => {
+  chrome.storage.session.get(WS_CONNECTED_KEY).then((data) => {
+    if (typeof data[WS_CONNECTED_KEY] === "boolean") {
+      wsConnected = data[WS_CONNECTED_KEY];
+    }
+  }).catch(() => {
+  });
+};
+var persistWsConnected = (connected) => {
+  wsConnected = connected;
+  chrome.storage.session.set({ [WS_CONNECTED_KEY]: connected }).catch(() => {
+  });
+};
+var handleOffscreenGetUrl = (_message, sendResponse) => {
+  (async () => {
+    const stored = await chrome.storage.local.get(SERVER_PORT_KEY).catch(() => ({}));
+    const port = typeof stored[SERVER_PORT_KEY] === "number" && stored[SERVER_PORT_KEY] > 0 ? stored[SERVER_PORT_KEY] : void 0;
+    const url = port ? buildWsUrl(port) : void 0;
+    sendResponse({ url });
+  })().catch(() => {
+    sendResponse({ url: void 0 });
+  });
+};
+var handleWsState = (message, sendResponse) => {
+  const wasConnected = wsConnected;
+  const nowConnected = message.connected;
+  persistWsConnected(nowConnected);
+  lastDisconnectReason = nowConnected ? void 0 : message.disconnectReason;
+  forwardToSidePanel({
+    type: "sp:connectionState",
+    data: {
+      connected: nowConnected,
+      disconnectReason: lastDisconnectReason
+    }
+  });
+  if (!nowConnected && wasConnected) {
+    clearTabStateCache();
+    clearAllConfirmationBadges();
+  }
+  sendResponse({ ok: true });
+};
+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 handlePluginLogs = (message, sendResponse) => {
+  const entries = message.entries;
+  if (wsConnected && Array.isArray(entries)) {
+    const plugin = message.plugin;
+    for (const entry of entries) {
+      if (typeof entry !== "object" || entry === null)
+        continue;
+      const e = entry;
+      sendToServer({
+        jsonrpc: "2.0",
+        method: "plugin.log",
+        params: {
+          plugin,
+          level: e.level,
+          message: e.message,
+          data: e.data,
+          ts: e.ts
+        }
+      });
+    }
+  }
+  sendResponse({ ok: true });
+};
+var handleToolProgress = (message, sendResponse) => {
+  const dispatchId = message.dispatchId;
+  const progress = message.progress;
+  const total = message.total;
+  if (wsConnected && typeof dispatchId === "string" && typeof progress === "number" && typeof total === "number") {
+    sendToServer({
+      jsonrpc: "2.0",
+      method: "tool.progress",
+      params: {
+        dispatchId,
+        progress,
+        total,
+        message: typeof message.message === "string" ? message.message : void 0
+      }
+    });
+  }
+  if (typeof dispatchId === "string") {
+    notifyDispatchProgress(dispatchId);
+  }
+  sendResponse({ ok: true });
+};
+var handleSpConfirmationResponse = (message, sendResponse) => {
+  if (wsConnected) {
+    sendToServer({
+      jsonrpc: "2.0",
+      method: "confirmation.response",
+      params: message.data
+    });
+  }
+  clearConfirmationBadge();
+  sendResponse({ ok: true });
+};
+var handleSpConfirmationTimeout = (_message, sendResponse) => {
+  clearConfirmationBadge();
+  sendResponse({ ok: true });
+};
+var handlePortChanged = (message, sendResponse) => {
+  chrome.runtime.sendMessage(message).catch(() => {
+  });
+  sendResponse({ ok: true });
+};
+var backgroundHandlers = /* @__PURE__ */ new Map([
+  ["offscreen:getUrl", handleOffscreenGetUrl],
+  ["ws:state", handleWsState],
+  ["ws:message", handleWsMessage],
+  ["bg:send", handleBgSend],
+  ["bg:getConnectionState", handleBgGetConnectionState],
+  ["plugin:logs", handlePluginLogs],
+  ["tool:progress", handleToolProgress],
+  ["sp:confirmationResponse", handleSpConfirmationResponse],
+  ["sp:confirmationTimeout", handleSpConfirmationTimeout],
+  ["port-changed", handlePortChanged]
+]);
+var EXTENSION_ONLY_TYPES = /* @__PURE__ */ new Set([
+  "offscreen:getUrl",
+  "ws:state",
+  "ws:message",
+  "bg:send",
+  "bg:getConnectionState",
+  "offscreen:getLogs"
+]);
+var initBackgroundMessageHandlers = () => {
+  chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+    if (EXTENSION_ONLY_TYPES.has(message.type) && sender.id !== chrome.runtime.id) {
+      console.warn(`[opentabs] Rejected ${message.type} from unauthorized sender:`, sender.id ?? sender.url);
+      return false;
+    }
+    const handler = backgroundHandlers.get(message.type);
+    if (handler) {
+      handler(message, sendResponse);
+      return true;
+    }
+    return false;
+  });
+};
+var backgroundHandlerNames = [...backgroundHandlers.keys()];
+
+// dist/side-panel-toggle.js
+var openWindows = /* @__PURE__ */ new Set();
+var initSidePanelToggle = () => {
+  chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: false }).catch(() => {
+  });
+  const canToggle = "onOpened" in chrome.sidePanel;
+  if (canToggle) {
+    chrome.sidePanel.onOpened.addListener(({ windowId }) => {
+      openWindows.add(windowId);
+    });
+    chrome.sidePanel.onClosed.addListener(({ windowId }) => {
+      openWindows.delete(windowId);
+    });
+  }
+  chrome.action.onClicked.addListener(({ windowId }) => {
+    if (canToggle && openWindows.has(windowId)) {
+      chrome.sidePanel.close({ windowId }).catch(() => {
+      });
+    } else {
+      chrome.sidePanel.open({ windowId }).catch(() => {
+      });
+    }
+  });
+};
+
+// dist/background.js
+initSidePanelToggle();
+restoreWsConnectedState();
+var creatingOffscreen = null;
+var ensureOffscreenDocument = async () => {
+  if (creatingOffscreen)
+    return creatingOffscreen;
+  creatingOffscreen = (async () => {
+    try {
+      await chrome.offscreen.createDocument({
+        url: "offscreen/offscreen.html",
+        reasons: [chrome.offscreen.Reason.WORKERS],
+        justification: "Maintain persistent WebSocket connection to MCP server"
+      });
+    } catch {
+    }
+  })();
+  await creatingOffscreen;
+  creatingOffscreen = null;
+};
+var setupKeepaliveAlarm = async () => {
+  const existing = await chrome.alarms.get(KEEPALIVE_ALARM);
+  if (!existing) {
+    await chrome.alarms.create(KEEPALIVE_ALARM, {
+      periodInMinutes: KEEPALIVE_INTERVAL_MINUTES
+    });
+  }
+};
+chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
+  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));
+  }
+});
+chrome.tabs.onRemoved.addListener((tabId) => {
+  checkTabRemoved(tabId).catch((err2) => console.warn("[opentabs] tab state check failed:", err2));
+});
+chrome.tabs.onReplaced.addListener((addedTabId, removedTabId) => {
+  checkTabRemoved(removedTabId).catch((err2) => console.warn("[opentabs] tab state check failed for replaced tab:", err2));
+  chrome.tabs.get(addedTabId).then(async (tab) => {
+    if (tab.url) {
+      await injectPluginsIntoTab(addedTabId, tab.url);
+    }
+    await checkTabChanged(addedTabId, { status: "complete" });
+  }).catch((err2) => console.warn("[opentabs] tab replacement handling failed:", err2));
+});
+initBackgroundMessageHandlers();
+chrome.alarms.onAlarm.addListener(() => {
+  ensureOffscreenDocument().catch((err2) => console.warn("[opentabs] offscreen creation failed:", err2));
+});
+chrome.runtime.onInstalled.addListener(() => {
+  void (async () => {
+    await ensureOffscreenDocument();
+    await setupKeepaliveAlarm();
+    await reinjectStoredPlugins();
+  })();
+});
+chrome.runtime.onStartup.addListener(() => {
+  void (async () => {
+    await ensureOffscreenDocument();
+    await setupKeepaliveAlarm();
+    await reinjectStoredPlugins();
+  })();
+});
+ensureOffscreenDocument().catch((err2) => console.warn("[opentabs] offscreen creation failed:", err2));
+setupKeepaliveAlarm().catch((err2) => console.warn("[opentabs] keepalive alarm failed:", err2));
+reinjectStoredPlugins().catch((err2) => console.warn("[opentabs] plugin reinjection failed:", err2));
+initConfirmationBadge();
+chrome.storage.onChanged.addListener((changes, area) => {
+  if (area !== "local")
+    return;
+  const portChange = changes[SERVER_PORT_KEY];
+  if (typeof portChange?.newValue === "number" && portChange.newValue > 0) {
+    const newUrl = buildWsUrl(portChange.newValue);
+    chrome.runtime.sendMessage({ type: "ws:setUrl", url: newUrl }).catch(() => {
+    });
+  }
+  if (changes[PLUGINS_META_KEY]) {
+    invalidatePluginCache();
+  }
+});