@vforsh/argus 0.1.19 → 0.1.20

package/dist/extension/dist/background/service-worker.js

@@ -0,0 +1,2004 @@
+// src/background/debugger-manager.ts
+var FRAME_TREE_SYNC_DELAY_MS = 150;
+var DebuggerManager = class {
+  attached = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Set();
+  detachHandlers = /* @__PURE__ */ new Set();
+  frameTreeSyncTimers = /* @__PURE__ */ new Map();
+  constructor() {
+    chrome.debugger.onEvent.addListener((debuggee, method, params) => {
+      this.handleCdpEvent(debuggee, method, params);
+    });
+    chrome.debugger.onDetach.addListener((debuggee, reason) => {
+      if (debuggee.tabId) {
+        this.handleDetach(debuggee.tabId, debuggee.sessionId ?? null, reason);
+      }
+    });
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => {
+      this.eventHandlers.delete(handler);
+    };
+  }
+  onDetach(handler) {
+    this.detachHandlers.add(handler);
+    return () => {
+      this.detachHandlers.delete(handler);
+    };
+  }
+  emitEvent(tabId, method, params, sessionId) {
+    for (const handler of this.eventHandlers) {
+      handler(tabId, method, params, { sessionId });
+    }
+  }
+  emitDetach(tabId, reason) {
+    for (const handler of this.detachHandlers) {
+      handler(tabId, reason);
+    }
+  }
+  async attach(tabId) {
+    if (this.attached.has(tabId)) {
+      return this.attached.get(tabId);
+    }
+    const debuggee = { tabId };
+    await chrome.debugger.attach(debuggee, "1.3");
+    const tab = await chrome.tabs.get(tabId);
+    const target = {
+      tabId,
+      debuggeeId: debuggee,
+      url: tab.url ?? "",
+      title: tab.title ?? "",
+      faviconUrl: tab.favIconUrl,
+      attachedAt: Date.now(),
+      enabledDomains: /* @__PURE__ */ new Set(),
+      childSessions: /* @__PURE__ */ new Map(),
+      frames: /* @__PURE__ */ new Map(),
+      topFrameId: null
+    };
+    this.attached.set(tabId, target);
+    await this.configureAutoAttach(tabId);
+    await this.refreshFrameTree(tabId, null);
+    return target;
+  }
+  async detach(tabId) {
+    const target = this.attached.get(tabId);
+    if (!target) return;
+    try {
+      await chrome.debugger.detach(target.debuggeeId);
+    } catch {
+    }
+    this.attached.delete(tabId);
+  }
+  async sendCommand(tabId, method, params, sessionId) {
+    const target = this.getRequiredTarget(tabId);
+    const debuggee = this.toDebuggee(target, sessionId);
+    const result = await chrome.debugger.sendCommand(debuggee, method, params);
+    return result;
+  }
+  async enableDomain(tabId, domain, sessionId) {
+    const enabledDomains = this.getRequiredEnabledDomains(tabId, sessionId);
+    if (enabledDomains.has(domain)) {
+      return;
+    }
+    await this.sendCommand(tabId, `${domain}.enable`, void 0, sessionId);
+    enabledDomains.add(domain);
+  }
+  isAttached(tabId) {
+    return this.attached.has(tabId);
+  }
+  listAttached() {
+    return [...this.attached.values()];
+  }
+  getTarget(tabId) {
+    return this.attached.get(tabId);
+  }
+  getFrames(tabId) {
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return [];
+    }
+    return [...target.frames.values()];
+  }
+  /**
+   * Read cookies from the attached tab's cookie store so extension-mode auth export can keep
+   * sibling subdomain session cookies such as `auth.example.com`.
+   */
+  async getCookies(tabId, query = {}) {
+    this.getRequiredTarget(tabId);
+    const storeId = await this.findCookieStoreId(tabId);
+    const cookies = await chrome.cookies.getAll({
+      domain: query.domain,
+      storeId: storeId ?? void 0,
+      url: query.domain ? void 0 : query.url
+    });
+    return cookies.map((cookie) => ({
+      name: cookie.name,
+      value: cookie.value,
+      domain: cookie.domain,
+      path: cookie.path,
+      secure: cookie.secure,
+      httpOnly: cookie.httpOnly,
+      session: cookie.session,
+      expires: typeof cookie.expirationDate === "number" ? cookie.expirationDate : null,
+      sameSite: cookie.sameSite ?? null
+    }));
+  }
+  async configureAutoAttach(tabId, sessionId) {
+    await this.sendCommand(
+      tabId,
+      "Target.setAutoAttach",
+      {
+        autoAttach: true,
+        waitForDebuggerOnStart: false,
+        flatten: true,
+        filter: [{ type: "iframe", exclude: false }]
+      },
+      sessionId
+    );
+  }
+  getEnabledDomains(tabId, sessionId) {
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return null;
+    }
+    if (!sessionId) {
+      return target.enabledDomains;
+    }
+    return target.childSessions.get(sessionId)?.enabledDomains ?? null;
+  }
+  getRequiredTarget(tabId) {
+    const target = this.attached.get(tabId);
+    if (!target) {
+      throw new Error(`Tab ${tabId} is not attached`);
+    }
+    return target;
+  }
+  getRequiredEnabledDomains(tabId, sessionId) {
+    const enabledDomains = this.getEnabledDomains(tabId, sessionId);
+    if (!enabledDomains) {
+      throw new Error(`Tab ${tabId} is not attached`);
+    }
+    return enabledDomains;
+  }
+  toDebuggee(target, sessionId) {
+    if (!sessionId) {
+      return target.debuggeeId;
+    }
+    return { tabId: target.tabId, sessionId };
+  }
+  async findCookieStoreId(tabId) {
+    const stores = await chrome.cookies.getAllCookieStores();
+    const store = stores.find((candidate) => candidate.tabIds.includes(tabId));
+    return store?.id ?? null;
+  }
+  handleCdpEvent(debuggee, method, params) {
+    const tabId = debuggee.tabId;
+    if (!tabId || !this.attached.has(tabId)) return;
+    const sessionId = debuggee.sessionId ?? null;
+    if (method === "Target.attachedToTarget" && params) {
+      void this.handleAttachedToTarget(tabId, params);
+      return;
+    }
+    if (method === "Target.detachedFromTarget" && params) {
+      this.handleDetachedFromTarget(tabId, params);
+      return;
+    }
+    this.updateStateFromEvent(tabId, sessionId, method, params);
+    this.emitEvent(tabId, method, params ?? {}, sessionId);
+    this.scheduleFrameTreeSyncIfNeeded(tabId, sessionId, method, params);
+  }
+  async handleAttachedToTarget(tabId, params) {
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return;
+    }
+    const record = params;
+    if (!record.sessionId) {
+      return;
+    }
+    target.childSessions.set(record.sessionId, {
+      sessionId: record.sessionId,
+      targetId: record.targetInfo?.targetId ?? record.sessionId,
+      type: record.targetInfo?.type ?? "unknown",
+      url: record.targetInfo?.url ?? "",
+      title: record.targetInfo?.title ?? "",
+      attachedAt: Date.now(),
+      enabledDomains: /* @__PURE__ */ new Set()
+    });
+    try {
+      await this.configureAutoAttach(tabId, record.sessionId);
+      await this.enableChildSessionDomains(tabId, record.sessionId);
+      await this.refreshFrameTree(tabId, record.sessionId);
+    } catch (error) {
+      console.warn("[DebuggerManager] Failed to bootstrap child target:", error);
+    }
+  }
+  async enableChildSessionDomains(tabId, sessionId) {
+    for (const domain of ["Runtime", "Page", "Network"]) {
+      await this.enableDomain(tabId, domain, sessionId);
+    }
+  }
+  handleDetachedFromTarget(tabId, params) {
+    const record = params;
+    if (!record.sessionId) {
+      return;
+    }
+    this.clearFrameTreeSync(record.sessionId, tabId);
+    this.dropChildSession(tabId, record.sessionId);
+  }
+  async refreshFrameTree(tabId, sessionId) {
+    const result = await this.sendCommand(tabId, "Page.getFrameTree", void 0, sessionId);
+    this.replaceFrameTreeSnapshot(tabId, sessionId, result.frameTree);
+  }
+  /**
+   * Each `Page.getFrameTree` result is a full snapshot for that session, so merge the refreshed
+   * nodes and then prune frames from the same session that no longer exist after reload.
+   */
+  replaceFrameTreeSnapshot(tabId, sessionId, node) {
+    if (!node?.frame?.id) {
+      return;
+    }
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return;
+    }
+    const nextFrameIds = /* @__PURE__ */ new Set();
+    this.mergeFrameTree(tabId, sessionId, node, nextFrameIds);
+    this.pruneMissingSessionFrames(tabId, sessionId, nextFrameIds);
+  }
+  mergeFrameTree(tabId, sessionId, node, nextFrameIds) {
+    if (!node?.frame?.id) {
+      return;
+    }
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return;
+    }
+    const frameId = node.frame.id;
+    nextFrameIds.add(frameId);
+    target.frames.set(frameId, this.toFrameRecord(node.frame, sessionId));
+    if (!node.frame.parentId && !sessionId) {
+      target.topFrameId = frameId;
+    }
+    this.emitEvent(
+      tabId,
+      "Page.frameNavigated",
+      {
+        frame: {
+          id: frameId,
+          parentId: node.frame.parentId ?? null,
+          url: node.frame.url ?? "",
+          name: node.frame.name ?? null
+        }
+      },
+      sessionId
+    );
+    for (const child of node.childFrames ?? []) {
+      this.mergeFrameTree(tabId, sessionId, child, nextFrameIds);
+    }
+  }
+  pruneMissingSessionFrames(tabId, sessionId, nextFrameIds) {
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return;
+    }
+    for (const [frameId, frame] of target.frames.entries()) {
+      if (frame.sessionId !== sessionId || nextFrameIds.has(frameId)) {
+        continue;
+      }
+      target.frames.delete(frameId);
+      this.emitEvent(tabId, "Page.frameDetached", { frameId }, sessionId);
+    }
+  }
+  updateStateFromEvent(tabId, sessionId, method, params) {
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return;
+    }
+    if (method === "Page.frameNavigated" && params) {
+      const frame = params.frame;
+      if (!frame?.id) {
+        return;
+      }
+      target.frames.set(frame.id, this.toFrameRecord(frame, sessionId));
+      if (!frame.parentId && !sessionId && frame.url) {
+        target.url = frame.url;
+        target.topFrameId = frame.id;
+      }
+      return;
+    }
+    if (method === "Page.frameAttached" && params) {
+      const frame = params;
+      if (!frame.frameId) {
+        return;
+      }
+      const existing = target.frames.get(frame.frameId);
+      target.frames.set(frame.frameId, {
+        frameId: frame.frameId,
+        parentFrameId: frame.parentFrameId ?? target.topFrameId,
+        url: existing?.url ?? "",
+        title: existing?.title ?? null,
+        sessionId: existing?.sessionId ?? sessionId
+      });
+      return;
+    }
+    if (method === "Page.frameDetached" && params) {
+      const frame = params;
+      if (!frame.frameId) {
+        return;
+      }
+      target.frames.delete(frame.frameId);
+    }
+  }
+  /**
+   * Chrome's frame attach/detach events during reload are not always complete. When the root frame
+   * for a session navigates, refresh that session's full frame tree shortly afterward and treat it
+   * as authoritative so stale iframe records do not linger in extension state.
+   */
+  scheduleFrameTreeSyncIfNeeded(tabId, sessionId, method, params) {
+    if (!shouldSyncFrameTreeSnapshot(method, params)) {
+      return;
+    }
+    const key = getFrameTreeSyncKey(tabId, sessionId);
+    if (this.frameTreeSyncTimers.has(key)) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.frameTreeSyncTimers.delete(key);
+      void this.refreshFrameTree(tabId, sessionId).catch((error) => {
+        console.warn("[DebuggerManager] Failed to refresh frame tree after navigation:", error);
+      });
+    }, FRAME_TREE_SYNC_DELAY_MS);
+    this.frameTreeSyncTimers.set(key, timer);
+  }
+  clearFrameTreeSync(sessionId, tabId) {
+    const key = getFrameTreeSyncKey(tabId, sessionId);
+    const timer = this.frameTreeSyncTimers.get(key);
+    if (!timer) {
+      return;
+    }
+    clearTimeout(timer);
+    this.frameTreeSyncTimers.delete(key);
+  }
+  clearAllFrameTreeSync(tabId) {
+    for (const [key, timer] of this.frameTreeSyncTimers.entries()) {
+      if (!key.startsWith(`${tabId}:`)) {
+        continue;
+      }
+      clearTimeout(timer);
+      this.frameTreeSyncTimers.delete(key);
+    }
+  }
+  toFrameRecord(frame, sessionId) {
+    return {
+      frameId: frame.id,
+      parentFrameId: frame.parentId ?? null,
+      url: frame.url ?? "",
+      title: frame.name ?? null,
+      sessionId
+    };
+  }
+  handleDetach(tabId, sessionId, reason) {
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return;
+    }
+    this.clearFrameTreeSync(sessionId, tabId);
+    if (sessionId) {
+      this.dropChildSession(tabId, sessionId);
+      return;
+    }
+    this.clearAllFrameTreeSync(tabId);
+    this.attached.delete(tabId);
+    this.emitDetach(tabId, reason);
+  }
+  dropChildSession(tabId, sessionId) {
+    const target = this.attached.get(tabId);
+    if (!target) {
+      return;
+    }
+    target.childSessions.delete(sessionId);
+    for (const [frameId, frame] of target.frames.entries()) {
+      if (frame.sessionId !== sessionId) {
+        continue;
+      }
+      target.frames.delete(frameId);
+      this.emitEvent(tabId, "Page.frameDetached", { frameId }, sessionId);
+    }
+  }
+};
+function shouldSyncFrameTreeSnapshot(method, params) {
+  if (method !== "Page.frameNavigated" || !params) {
+    return false;
+  }
+  const frame = params.frame;
+  return frame?.parentId == null;
+}
+function getFrameTreeSyncKey(tabId, sessionId) {
+  return `${tabId}:${sessionId ?? "root"}`;
+}
+
+// src/background/bridge-client.ts
+var BridgeClient = class {
+  port = null;
+  hostName;
+  messageHandlers = /* @__PURE__ */ new Set();
+  connectHandler = null;
+  disconnectHandler = null;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  reconnectDelay = 1e3;
+  autoReconnect;
+  reconnectEnabled = true;
+  constructor(hostName = "com.vforsh.argus.bridge", options = {}) {
+    this.hostName = hostName;
+    this.autoReconnect = options.autoReconnect ?? true;
+  }
+  /**
+   * Set handler for incoming messages from the host.
+   */
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+  }
+  /**
+   * Set handler for successful connection.
+   */
+  onConnect(handler) {
+    this.connectHandler = handler;
+  }
+  /**
+   * Set handler for disconnection.
+   */
+  onDisconnect(handler) {
+    this.disconnectHandler = handler;
+  }
+  /**
+   * Connect to the Native Messaging host.
+   */
+  connect() {
+    if (this.port) {
+      return true;
+    }
+    this.reconnectEnabled = true;
+    try {
+      this.port = chrome.runtime.connectNative(this.hostName);
+      this.port.onMessage.addListener((message) => {
+        this.reconnectAttempts = 0;
+        for (const handler of this.messageHandlers) {
+          handler(message);
+        }
+      });
+      this.port.onDisconnect.addListener(() => {
+        const error = chrome.runtime.lastError;
+        console.log("[BridgeClient] Disconnected:", error?.message ?? "unknown reason");
+        this.port = null;
+        if (this.disconnectHandler) {
+          this.disconnectHandler();
+        }
+        this.scheduleReconnect();
+      });
+      console.log("[BridgeClient] Connected to", this.hostName);
+      this.reconnectAttempts = 0;
+      if (this.connectHandler) {
+        this.connectHandler();
+      }
+      return true;
+    } catch (err) {
+      console.error("[BridgeClient] Failed to connect:", err);
+      this.scheduleReconnect();
+      return false;
+    }
+  }
+  /**
+   * Disconnect from the Native Messaging host.
+   */
+  disconnect() {
+    this.reconnectEnabled = false;
+    if (this.port) {
+      this.port.disconnect();
+      this.port = null;
+    }
+  }
+  /**
+   * Send a message to the Native Messaging host.
+   */
+  send(message) {
+    if (!this.port) {
+      console.warn("[BridgeClient] Cannot send, not connected");
+      return false;
+    }
+    try {
+      this.port.postMessage(message);
+      return true;
+    } catch (err) {
+      console.error("[BridgeClient] Send failed:", err);
+      return false;
+    }
+  }
+  /**
+   * Check if connected to the host.
+   */
+  isConnected() {
+    return this.port !== null;
+  }
+  /**
+   * Schedule a reconnection attempt with exponential backoff.
+   */
+  scheduleReconnect() {
+    if (!this.autoReconnect || !this.reconnectEnabled) {
+      return;
+    }
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.log("[BridgeClient] Max reconnection attempts reached");
+      return;
+    }
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts++;
+    console.log(`[BridgeClient] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    setTimeout(() => {
+      this.connect();
+    }, delay);
+  }
+};
+
+// src/background/tab-list.ts
+var listBrowserTabs = async (debuggerManager2, filter, options = {}) => {
+  const chromeTabs = await chrome.tabs.query({});
+  const attachedTargets = debuggerManager2.listAttached();
+  const attachedTabIds = new Set(attachedTargets.map((target) => target.tabId));
+  let tabs = chromeTabs.filter((tab) => tab.id !== void 0 && tab.url !== void 0).filter((tab) => !tab.url.startsWith("chrome://") && !tab.url.startsWith("chrome-extension://")).map((tab) => ({
+    tabId: tab.id,
+    url: tab.url,
+    title: tab.title ?? "",
+    faviconUrl: tab.favIconUrl,
+    attached: attachedTabIds.has(tab.id),
+    watcherId: options.getWatcherIdForTab?.(tab.id) ?? void 0
+  }));
+  if (filter?.url) {
+    const urlFilter = filter.url.toLowerCase();
+    tabs = tabs.filter((tab) => tab.url.toLowerCase().includes(urlFilter));
+  }
+  if (filter?.title) {
+    const titleFilter = filter.title.toLowerCase();
+    tabs = tabs.filter((tab) => tab.title.toLowerCase().includes(titleFilter));
+  }
+  tabs.sort((left, right) => Number(right.attached) - Number(left.attached));
+  return tabs;
+};
+
+// src/background/cdp-proxy.ts
+var CdpProxy = class {
+  debuggerManager;
+  bridgeClient;
+  removeDebuggerEventForwarding = null;
+  removeDebuggerDetachForwarding = null;
+  constructor(debuggerManager2, bridgeClient) {
+    this.debuggerManager = debuggerManager2;
+    this.bridgeClient = bridgeClient;
+    this.setupEventForwarding();
+    this.setupMessageHandling();
+  }
+  /**
+   * Forward CDP events from debugger to bridge.
+   */
+  setupEventForwarding() {
+    this.removeDebuggerEventForwarding = this.debuggerManager.onEvent((tabId, method, params, meta) => {
+      this.bridgeClient.send({
+        type: "cdp_event",
+        tabId,
+        method,
+        params,
+        sessionId: meta?.sessionId ?? void 0
+      });
+    });
+    this.removeDebuggerDetachForwarding = this.debuggerManager.onDetach((tabId, reason) => {
+      this.bridgeClient.send({
+        type: "tab_detached",
+        tabId,
+        reason
+      });
+    });
+  }
+  dispose() {
+    this.removeDebuggerEventForwarding?.();
+    this.removeDebuggerEventForwarding = null;
+    this.removeDebuggerDetachForwarding?.();
+    this.removeDebuggerDetachForwarding = null;
+  }
+  /**
+   * Handle messages from the bridge.
+   */
+  setupMessageHandling() {
+    this.bridgeClient.onMessage((message) => {
+      this.handleMessage(message);
+    });
+  }
+  /**
+   * Process a message from the bridge.
+   */
+  async handleMessage(message) {
+    switch (message.type) {
+      case "attach_tab":
+        await this.handleAttachTab(message);
+        break;
+      case "detach_tab":
+        await this.handleDetachTab(message);
+        break;
+      case "cdp_command":
+        await this.handleCdpCommand(message);
+        break;
+      case "cookie_query":
+        await this.handleCookieQuery(message);
+        break;
+      case "enable_domain":
+        await this.handleEnableDomain(message);
+        break;
+      case "host_info":
+      case "host_ready":
+      case "target_info":
+        break;
+      default:
+        console.warn("[CdpProxy] Unknown message type:", message.type);
+    }
+  }
+  /**
+   * Attach to a tab.
+   */
+  async handleAttachTab(message) {
+    try {
+      const target = await this.debuggerManager.attach(message.tabId);
+      this.bridgeClient.send({
+        type: "tab_attached",
+        tabId: target.tabId,
+        url: target.url,
+        title: target.title,
+        faviconUrl: target.faviconUrl,
+        topFrameId: target.topFrameId,
+        frames: this.debuggerManager.getFrames(target.tabId)
+      });
+    } catch (err) {
+      console.error("[CdpProxy] Failed to attach:", err);
+      this.bridgeClient.send({
+        type: "tab_detached",
+        tabId: message.tabId,
+        reason: err instanceof Error ? err.message : "attach_failed"
+      });
+    }
+  }
+  /**
+   * Detach from a tab.
+   */
+  async handleDetachTab(message) {
+    await this.debuggerManager.detach(message.tabId);
+  }
+  /**
+   * Execute a CDP command.
+   */
+  async handleCdpCommand(message) {
+    try {
+      const result = await this.debuggerManager.sendCommand(message.tabId, message.method, message.params, message.sessionId);
+      this.bridgeClient.send({
+        type: "cdp_response",
+        requestId: message.requestId,
+        result
+      });
+    } catch (err) {
+      this.bridgeClient.send({
+        type: "cdp_response",
+        requestId: message.requestId,
+        error: {
+          message: err instanceof Error ? err.message : "Unknown error"
+        }
+      });
+    }
+  }
+  /**
+   * Query browser cookies from the attached tab's cookie store.
+   */
+  async handleCookieQuery(message) {
+    try {
+      const cookies = await this.debuggerManager.getCookies(message.tabId, {
+        domain: message.domain,
+        url: message.url
+      });
+      this.bridgeClient.send({
+        type: "cookie_query_response",
+        requestId: message.requestId,
+        cookies
+      });
+    } catch (err) {
+      this.bridgeClient.send({
+        type: "cookie_query_response",
+        requestId: message.requestId,
+        error: {
+          message: err instanceof Error ? err.message : "Unknown error"
+        }
+      });
+    }
+  }
+  /**
+   * Enable a CDP domain for a tab.
+   */
+  async handleEnableDomain(message) {
+    try {
+      await this.debuggerManager.enableDomain(message.tabId, message.domain);
+    } catch (err) {
+      console.error("[CdpProxy] Failed to enable domain:", err);
+    }
+  }
+  /**
+   * Manually attach to a tab (called from popup).
+   */
+  async attachTab(tabId) {
+    await this.handleAttachTab({ type: "attach_tab", tabId });
+  }
+  /**
+   * Manually detach from a tab (called from popup).
+   */
+  async detachTab(tabId) {
+    this.bridgeClient.send({
+      type: "tab_detached",
+      tabId,
+      reason: "user_requested"
+    });
+    await this.debuggerManager.detach(tabId);
+  }
+  /**
+   * Get list of tabs for popup UI.
+   */
+  async getTabsForPopup() {
+    return await listBrowserTabs(this.debuggerManager);
+  }
+};
+
+// src/background/native-hosts.ts
+var BRIDGE_HOST_NAME = "com.vforsh.argus.bridge";
+var CONTROL_HOST_NAME = "com.vforsh.argus.control";
+
+// src/background/tab-bridge-session.ts
+var TabBridgeSession = class {
+  tabId;
+  bridgeClient;
+  cdpProxy;
+  events;
+  watcherInfo = null;
+  targetInfo = null;
+  desiredWatcherId;
+  lastMessageAt = null;
+  ready = false;
+  readyWaiters = [];
+  watcherInfoWaiters = [];
+  disposed = false;
+  constructor(tabId, debuggerManager2, events = {}, options = {}) {
+    this.tabId = tabId;
+    this.events = events;
+    this.desiredWatcherId = options.watcherId;
+    this.bridgeClient = new BridgeClient(BRIDGE_HOST_NAME, { autoReconnect: false });
+    this.cdpProxy = new CdpProxy(debuggerManager2, this.bridgeClient);
+    this.bridgeClient.onMessage((message) => {
+      this.handleMessage(message);
+    });
+    this.bridgeClient.onDisconnect(() => {
+      if (this.disposed) {
+        return;
+      }
+      this.events.onDisconnect?.();
+    });
+  }
+  async connectAndAttach() {
+    this.assertOpen();
+    const connected = this.bridgeClient.connect();
+    if (!connected) {
+      throw new Error(`Failed to connect native host for tab ${this.tabId}`);
+    }
+    const sent = this.bridgeClient.send({
+      type: "init_tab_watcher",
+      watcherId: this.desiredWatcherId
+    });
+    if (!sent) {
+      throw new Error(`Failed to initialize watcher for tab ${this.tabId}`);
+    }
+    await this.waitUntilReady();
+    await this.waitForWatcherInfo();
+    await this.cdpProxy.attachTab(this.tabId);
+  }
+  async waitUntilReady(timeoutMs = 3e3) {
+    this.assertOpen();
+    if (this.ready) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.readyWaiters = this.readyWaiters.filter((waiter) => waiter !== onReady);
+        reject(new Error(`Native host session for tab ${this.tabId} did not become ready`));
+      }, timeoutMs);
+      const onReady = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      this.readyWaiters.push(onReady);
+    });
+  }
+  async detach() {
+    if (this.disposed) {
+      return;
+    }
+    try {
+      await this.cdpProxy.detachTab(this.tabId);
+    } finally {
+      this.dispose();
+    }
+  }
+  selectTarget(frameId) {
+    this.assertOpen();
+    const sent = this.bridgeClient.send({
+      type: "target_selected",
+      tabId: this.tabId,
+      frameId
+    });
+    if (!sent) {
+      throw new Error(`Failed to select target for tab ${this.tabId}`);
+    }
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.cdpProxy.dispose();
+    this.bridgeClient.disconnect();
+  }
+  isConnected() {
+    return this.bridgeClient.isConnected();
+  }
+  getWatcherInfo() {
+    return this.watcherInfo;
+  }
+  getTargetInfo() {
+    return this.targetInfo;
+  }
+  getLastMessageAt() {
+    return this.lastMessageAt;
+  }
+  async waitForWatcherInfo(timeoutMs = 3e3) {
+    this.assertOpen();
+    if (this.watcherInfo) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.watcherInfoWaiters = this.watcherInfoWaiters.filter((waiter) => waiter !== onWatcherInfo);
+        reject(new Error(`Native host session for tab ${this.tabId} did not report watcher info`));
+      }, timeoutMs);
+      const onWatcherInfo = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      this.watcherInfoWaiters.push(onWatcherInfo);
+    });
+  }
+  handleMessage(message) {
+    this.lastMessageAt = Date.now();
+    switch (message.type) {
+      case "host_info":
+        this.watcherInfo = {
+          watcherId: message.watcherId,
+          watcherHost: message.watcherHost,
+          watcherPort: message.watcherPort,
+          pid: message.pid
+        };
+        this.events.onWatcherInfo?.(this.watcherInfo);
+        this.resolveWatcherInfoWaiters();
+        return;
+      case "host_ready":
+        this.resolveReadyWaiters();
+        return;
+      case "target_info":
+        this.targetInfo = {
+          targetId: message.targetId,
+          title: message.title,
+          url: message.url,
+          attachedAt: message.attachedAt,
+          targetReady: message.targetReady ?? null
+        };
+        this.events.onTargetInfo?.(this.targetInfo);
+    }
+  }
+  resolveReadyWaiters() {
+    this.ready = true;
+    const waiters = this.readyWaiters;
+    this.readyWaiters = [];
+    for (const waiter of waiters) {
+      waiter();
+    }
+  }
+  resolveWatcherInfoWaiters() {
+    const waiters = this.watcherInfoWaiters;
+    this.watcherInfoWaiters = [];
+    for (const waiter of waiters) {
+      waiter();
+    }
+  }
+  assertOpen() {
+    if (this.disposed) {
+      throw new Error(`Native host session for tab ${this.tabId} is already closed`);
+    }
+  }
+};
+
+// src/background/control-bridge-session.ts
+var ControlBridgeSession = class {
+  bridgeClient;
+  debuggerManager;
+  events;
+  watcherInfo = null;
+  lastMessageAt = null;
+  disposed = false;
+  constructor(debuggerManager2, events = {}) {
+    this.debuggerManager = debuggerManager2;
+    this.events = events;
+    this.bridgeClient = new BridgeClient(CONTROL_HOST_NAME, { autoReconnect: true });
+    this.bridgeClient.onMessage((message) => {
+      void this.handleMessage(message);
+    });
+    this.bridgeClient.onDisconnect(() => {
+      if (this.disposed) {
+        return;
+      }
+      this.events.onDisconnect?.();
+    });
+  }
+  connect() {
+    this.assertOpen();
+    return this.bridgeClient.connect();
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.bridgeClient.disconnect();
+  }
+  isConnected() {
+    return this.bridgeClient.isConnected();
+  }
+  getWatcherInfo() {
+    return this.watcherInfo;
+  }
+  getLastMessageAt() {
+    return this.lastMessageAt;
+  }
+  async handleMessage(message) {
+    this.lastMessageAt = Date.now();
+    switch (message.type) {
+      case "host_info":
+        this.watcherInfo = {
+          watcherId: message.watcherId,
+          watcherHost: message.watcherHost,
+          watcherPort: message.watcherPort,
+          pid: message.pid
+        };
+        this.events.onWatcherInfo?.(this.watcherInfo);
+        return;
+      case "attach_tab_watcher":
+        await this.handleTabAction(message.requestId, () => this.events.onAttachTabWatcher?.(message.tabId, { watcherId: message.watcherId }));
+        return;
+      case "detach_tab_watcher":
+        await this.handleTabAction(message.requestId, () => this.events.onDetachTabWatcher?.(message.tabId));
+        return;
+      case "list_tabs":
+        await this.handleListTabs(message.requestId, message.filter);
+        return;
+      case "control_status":
+        this.handleControlStatus(message.requestId);
+        return;
+      case "host_ready":
+        return;
+    }
+  }
+  async handleTabAction(requestId, action) {
+    try {
+      const result = await action() ?? { ok: false, error: "Extension control action is not available" };
+      if (!result.ok) {
+        this.bridgeClient.send({ type: "tab_action_response", requestId, ok: false, error: { message: result.error } });
+        return;
+      }
+      this.bridgeClient.send({ type: "tab_action_response", requestId, ok: true, tab: result.tab, watcherId: result.watcherId });
+    } catch (error) {
+      this.bridgeClient.send({
+        type: "tab_action_response",
+        requestId,
+        ok: false,
+        error: { message: error instanceof Error ? error.message : String(error) }
+      });
+    }
+  }
+  async handleListTabs(requestId, filter) {
+    const tabs = await listBrowserTabs(this.debuggerManager, filter, {
+      getWatcherIdForTab: this.events.getWatcherIdForTab
+    });
+    this.bridgeClient.send({
+      type: "list_tabs_response",
+      requestId,
+      tabs
+    });
+  }
+  handleControlStatus(requestId) {
+    this.bridgeClient.send({
+      type: "control_status_response",
+      requestId,
+      diagnostics: this.events.getDiagnostics?.() ?? this.buildFallbackDiagnostics()
+    });
+  }
+  buildFallbackDiagnostics() {
+    return {
+      extensionId: null,
+      extensionVersion: null,
+      control: {
+        connected: this.isConnected(),
+        watcherId: this.watcherInfo?.watcherId ?? null,
+        watcherHost: this.watcherInfo?.watcherHost ?? null,
+        watcherPort: this.watcherInfo?.watcherPort ?? null,
+        pid: this.watcherInfo?.pid ?? null,
+        lastMessageAt: this.lastMessageAt
+      },
+      tabWatchers: [],
+      recentEvents: []
+    };
+  }
+  assertOpen() {
+    if (this.disposed) {
+      throw new Error("Native host control session is already closed");
+    }
+  }
+};
+
+// src/background/target-selection-history.ts
+var DEFAULT_STORAGE_KEY = "targetSelectionHistory";
+var DEFAULT_MAX_ENTRIES = 20;
+var normalizeSelectionPageKey = (pageUrl) => {
+  try {
+    const parsed = new URL(pageUrl);
+    return `${parsed.origin}${parsed.pathname || "/"}`;
+  } catch {
+    return pageUrl.split("#", 1)[0] || pageUrl;
+  }
+};
+var matchRememberedIframeTarget = (entry, targets) => {
+  if (entry.target.type !== "iframe") {
+    return null;
+  }
+  const rememberedIframe = entry.target;
+  const iframeTargets = getIframeTargets(targets);
+  if (rememberedIframe.url) {
+    return pickSingleTargetMatch(iframeTargets, (target) => target.url === rememberedIframe.url);
+  }
+  if (!rememberedIframe.title) {
+    return null;
+  }
+  return pickSingleTargetMatch(iframeTargets, (target) => normalizeTargetTitle(target.title) === rememberedIframe.title);
+};
+var TargetSelectionHistoryStore = class {
+  persistence;
+  maxEntries;
+  entries = [];
+  loadPromise = null;
+  saveChain = Promise.resolve();
+  constructor(persistence = createChromeStoragePersistence(), options = {}) {
+    this.persistence = persistence;
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  async getByPageUrl(pageUrl) {
+    await this.ensureLoaded();
+    const pageKey = normalizeSelectionPageKey(pageUrl);
+    return this.entries.find((entry) => entry.pageKey === pageKey) ?? null;
+  }
+  async remember(pageUrl, target) {
+    await this.ensureLoaded();
+    const entry = buildRememberedSelection(pageUrl, target);
+    this.entries = [entry, ...this.entries.filter((candidate) => candidate.pageKey !== entry.pageKey)].slice(0, this.maxEntries);
+    await this.persist();
+    return entry;
+  }
+  async ensureLoaded() {
+    if (!this.loadPromise) {
+      this.loadPromise = this.persistence.load().then((entries) => {
+        this.entries = sanitizeRememberedSelections(entries).slice(0, this.maxEntries);
+      }).catch((error) => {
+        console.error("[TargetSelectionHistoryStore] Failed to load history:", error);
+        this.entries = [];
+      });
+    }
+    await this.loadPromise;
+  }
+  async persist() {
+    this.saveChain = this.saveChain.catch(() => void 0).then(() => this.persistence.save(this.entries)).catch((error) => {
+      console.error("[TargetSelectionHistoryStore] Failed to save history:", error);
+    });
+    await this.saveChain;
+  }
+};
+var createChromeStoragePersistence = (storageArea = chrome.storage.local, storageKey = DEFAULT_STORAGE_KEY) => ({
+  load: async () => {
+    const stored = await readStorageValue(storageArea, storageKey);
+    return sanitizeRememberedSelections(Array.isArray(stored) ? stored : []);
+  },
+  save: async (entries) => {
+    await writeStorageValue(storageArea, { [storageKey]: entries });
+  }
+});
+var buildRememberedSelection = (pageUrl, target) => {
+  const base = {
+    pageKey: normalizeSelectionPageKey(pageUrl),
+    pageUrl,
+    updatedAt: Date.now()
+  };
+  if (target.type === "page") {
+    return {
+      ...base,
+      target: { type: "page" }
+    };
+  }
+  return {
+    ...base,
+    target: {
+      type: "iframe",
+      url: normalizeTargetUrl(target.url),
+      title: normalizeTargetTitle(target.title)
+    }
+  };
+};
+var pickSingleTargetMatch = (targets, predicate) => {
+  const matches = targets.filter(predicate);
+  return matches.length === 1 ? matches[0] : null;
+};
+var getIframeTargets = (targets) => {
+  return targets.filter((target) => {
+    return target.type === "iframe" && typeof target.frameId === "string" && target.frameId.length > 0;
+  });
+};
+var sanitizeRememberedSelections = (entries) => {
+  return entries.map(sanitizeRememberedSelection).filter((entry) => entry !== null).sort(sortByUpdatedAtDesc);
+};
+var sanitizeRememberedSelection = (entry) => {
+  const candidate = entry;
+  if (typeof candidate?.pageUrl !== "string" || candidate.pageUrl.length === 0) {
+    return null;
+  }
+  const base = {
+    pageKey: typeof candidate.pageKey === "string" && candidate.pageKey.length > 0 ? candidate.pageKey : normalizeSelectionPageKey(candidate.pageUrl),
+    pageUrl: candidate.pageUrl,
+    updatedAt: typeof candidate.updatedAt === "number" ? candidate.updatedAt : 0
+  };
+  if (candidate.target?.type === "page") {
+    return {
+      ...base,
+      target: { type: "page" }
+    };
+  }
+  if (candidate.target?.type !== "iframe") {
+    return null;
+  }
+  return {
+    ...base,
+    target: {
+      type: "iframe",
+      url: normalizeTargetUrl(typeof candidate.target.url === "string" ? candidate.target.url : null),
+      title: normalizeTargetTitle(typeof candidate.target.title === "string" ? candidate.target.title : null)
+    }
+  };
+};
+function normalizeTargetUrl(url) {
+  return normalizeOptionalText(url);
+}
+function normalizeTargetTitle(title) {
+  return normalizeOptionalText(title);
+}
+function normalizeOptionalText(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+var sortByUpdatedAtDesc = (left, right) => right.updatedAt - left.updatedAt;
+var readStorageValue = async (storageArea, key) => {
+  return await new Promise((resolve, reject) => {
+    storageArea.get(key, (items) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(items[key]);
+    });
+  });
+};
+var writeStorageValue = async (storageArea, items) => {
+  await new Promise((resolve, reject) => {
+    storageArea.set(items, () => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve();
+    });
+  });
+};
+
+// src/background/target-visibility-history.ts
+var DEFAULT_STORAGE_KEY2 = "hiddenTargetHistory";
+var DEFAULT_MAX_PAGE_ENTRIES = 20;
+var TargetVisibilityHistoryStore = class {
+  persistence;
+  maxPageEntries;
+  entries = [];
+  loadPromise = null;
+  saveChain = Promise.resolve();
+  constructor(persistence = createChromeStoragePersistence2(), options = {}) {
+    this.persistence = persistence;
+    this.maxPageEntries = options.maxPageEntries ?? DEFAULT_MAX_PAGE_ENTRIES;
+  }
+  async getHiddenTargets(pageUrl) {
+    await this.ensureLoaded();
+    return [...this.findEntry(pageUrl)?.targets ?? []];
+  }
+  async hide(pageUrl, target) {
+    await this.ensureLoaded();
+    const hiddenTarget = toHiddenTarget(target);
+    if (!hiddenTarget) {
+      return null;
+    }
+    const pageKey = normalizeSelectionPageKey(pageUrl);
+    const existing = this.findEntry(pageUrl);
+    const targets = uniqueHiddenTargets([hiddenTarget, ...existing?.targets ?? []]);
+    const entry = { pageKey, pageUrl, updatedAt: Date.now(), targets };
+    this.upsertEntry(entry);
+    await this.persist();
+    return entry;
+  }
+  async show(pageUrl, target) {
+    await this.ensureLoaded();
+    const hiddenTarget = toHiddenTarget(target);
+    if (!hiddenTarget) {
+      return;
+    }
+    const existing = this.findEntry(pageUrl);
+    if (!existing) {
+      return;
+    }
+    const targets = existing.targets.filter((candidate) => !isSameHiddenTarget(candidate, hiddenTarget));
+    if (targets.length === 0) {
+      this.entries = this.entries.filter((entry) => entry.pageKey !== existing.pageKey);
+      await this.persist();
+      return;
+    }
+    this.entries = this.entries.map((entry) => entry.pageKey === existing.pageKey ? { ...entry, targets, updatedAt: Date.now() } : entry);
+    await this.persist();
+  }
+  async isHidden(pageUrl, target) {
+    const hiddenTargets = await this.getHiddenTargets(pageUrl);
+    return hiddenTargets.some((hiddenTarget) => matchesHiddenTarget(hiddenTarget, target));
+  }
+  findEntry(pageUrl) {
+    const pageKey = normalizeSelectionPageKey(pageUrl);
+    return this.entries.find((entry) => entry.pageKey === pageKey) ?? null;
+  }
+  upsertEntry(entry) {
+    this.entries = [entry, ...this.entries.filter((candidate) => candidate.pageKey !== entry.pageKey)].slice(0, this.maxPageEntries);
+  }
+  async ensureLoaded() {
+    if (!this.loadPromise) {
+      this.loadPromise = this.persistence.load().then((entries) => {
+        this.entries = sanitizeHiddenTargetEntries(entries).slice(0, this.maxPageEntries);
+      }).catch((error) => {
+        console.error("[TargetVisibilityHistoryStore] Failed to load history:", error);
+        this.entries = [];
+      });
+    }
+    await this.loadPromise;
+  }
+  async persist() {
+    this.saveChain = this.saveChain.catch(() => void 0).then(() => this.persistence.save(this.entries)).catch((error) => {
+      console.error("[TargetVisibilityHistoryStore] Failed to save history:", error);
+    });
+    await this.saveChain;
+  }
+};
+var createChromeStoragePersistence2 = (storageArea = chrome.storage.local, storageKey = DEFAULT_STORAGE_KEY2) => ({
+  load: async () => {
+    const stored = await readStorageValue2(storageArea, storageKey);
+    return sanitizeHiddenTargetEntries(Array.isArray(stored) ? stored : []);
+  },
+  save: async (entries) => {
+    await writeStorageValue2(storageArea, { [storageKey]: entries });
+  }
+});
+function matchesHiddenTarget(hiddenTarget, target) {
+  if (target.type !== "iframe") {
+    return false;
+  }
+  const candidate = toHiddenTarget(target);
+  return candidate ? isSameHiddenTarget(hiddenTarget, candidate) : false;
+}
+function toHiddenTarget(target) {
+  if (target.type !== "iframe") {
+    return null;
+  }
+  const url = normalizeOptionalText2(target.url);
+  const title = normalizeOptionalText2(target.title);
+  if (!url && !title) {
+    return null;
+  }
+  return { type: "iframe", url, title };
+}
+function uniqueHiddenTargets(targets) {
+  const unique = [];
+  for (const target of targets) {
+    if (!unique.some((candidate) => isSameHiddenTarget(candidate, target))) {
+      unique.push(target);
+    }
+  }
+  return unique;
+}
+function isSameHiddenTarget(left, right) {
+  if (left.url || right.url) {
+    return left.url === right.url;
+  }
+  return left.title === right.title;
+}
+function sanitizeHiddenTargetEntries(entries) {
+  return entries.map(sanitizeHiddenTargetEntry).filter((entry) => entry !== null).sort(sortByUpdatedAtDesc2);
+}
+function sanitizeHiddenTargetEntry(entry) {
+  const candidate = entry;
+  if (typeof candidate?.pageUrl !== "string" || candidate.pageUrl.length === 0 || !Array.isArray(candidate.targets)) {
+    return null;
+  }
+  const targets = uniqueHiddenTargets(candidate.targets.map(sanitizeHiddenTarget).filter((target) => target !== null));
+  if (targets.length === 0) {
+    return null;
+  }
+  return {
+    pageKey: typeof candidate.pageKey === "string" && candidate.pageKey.length > 0 ? candidate.pageKey : normalizeSelectionPageKey(candidate.pageUrl),
+    pageUrl: candidate.pageUrl,
+    updatedAt: typeof candidate.updatedAt === "number" ? candidate.updatedAt : 0,
+    targets
+  };
+}
+function sanitizeHiddenTarget(target) {
+  const candidate = target;
+  if (candidate?.type !== "iframe") {
+    return null;
+  }
+  const url = normalizeOptionalText2(typeof candidate.url === "string" ? candidate.url : null);
+  const title = normalizeOptionalText2(typeof candidate.title === "string" ? candidate.title : null);
+  if (!url && !title) {
+    return null;
+  }
+  return { type: "iframe", url, title };
+}
+function normalizeOptionalText2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+var sortByUpdatedAtDesc2 = (left, right) => right.updatedAt - left.updatedAt;
+var readStorageValue2 = async (storageArea, key) => {
+  return await new Promise((resolve, reject) => {
+    storageArea.get(key, (items) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(items[key]);
+    });
+  });
+};
+var writeStorageValue2 = async (storageArea, items) => {
+  await new Promise((resolve, reject) => {
+    storageArea.set(items, () => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve();
+    });
+  });
+};
+
+// src/background/action-badge.ts
+var badgeSyncChain = Promise.resolve();
+function syncActionBadge(debuggerManager2) {
+  badgeSyncChain = badgeSyncChain.catch(() => void 0).then(async () => {
+    const attachedCount = debuggerManager2.listAttached().length;
+    await applyBadgeState(attachedCount);
+  }).catch((error) => {
+    console.error("[ServiceWorker] Failed to sync action badge:", error);
+  });
+  return badgeSyncChain;
+}
+async function applyBadgeState(attachedCount) {
+  const badgeText = attachedCount > 0 ? String(attachedCount) : "";
+  const tabs = await chrome.tabs.query({});
+  await Promise.all(
+    tabs.filter((tab) => tab.id !== void 0).map((tab) => chrome.action.setBadgeText({ tabId: tab.id, text: badgeText }))
+  );
+  await chrome.action.setBadgeText({ text: badgeText });
+  if (attachedCount > 0) {
+    await chrome.action.setBadgeBackgroundColor({ color: "#4CAF50" });
+  }
+}
+
+// src/background/popup-targets.ts
+function parseWatcherTargetId(targetId) {
+  if (targetId.startsWith("tab:")) {
+    const tabId = Number.parseInt(targetId.slice(4), 10);
+    return Number.isFinite(tabId) ? { tabId, frameId: null } : null;
+  }
+  if (targetId.startsWith("frame:")) {
+    const [, tabIdRaw, ...frameIdParts] = targetId.split(":");
+    const tabId = Number.parseInt(tabIdRaw ?? "", 10);
+    const frameId = frameIdParts.join(":");
+    return Number.isFinite(tabId) && frameId ? { tabId, frameId } : null;
+  }
+  return null;
+}
+function getPopupTargets(debuggerManager2, tabId) {
+  const frames = debuggerManager2.getFrames(tabId);
+  const topFrameId = debuggerManager2.getTarget(tabId)?.topFrameId ?? null;
+  const topFrame = frames.find((frame) => frame.frameId === topFrameId) ?? frames.find((frame) => frame.parentFrameId == null);
+  if (!topFrame) {
+    return [];
+  }
+  return [
+    {
+      type: "page",
+      frameId: null,
+      parentFrameId: null,
+      title: topFrame.title || "Page",
+      url: topFrame.url
+    },
+    ...frames.filter((frame) => frame.frameId !== topFrame.frameId).map((frame) => ({
+      type: "iframe",
+      frameId: frame.frameId,
+      parentFrameId: frame.parentFrameId === topFrame.frameId ? null : frame.parentFrameId,
+      title: frame.title || frame.url || `iframe ${frame.frameId.slice(0, 8)}`,
+      url: frame.url
+    }))
+  ];
+}
+function getPopupTarget(debuggerManager2, tabId, frameId) {
+  return getPopupTargets(debuggerManager2, tabId).find((target) => (target.frameId ?? null) === frameId) ?? null;
+}
+function getRequiredIframeTarget(debuggerManager2, tabId, frameId) {
+  const target = getPopupTarget(debuggerManager2, tabId, frameId);
+  if (!target || target.type !== "iframe" || !target.frameId) {
+    throw new Error(`Unknown iframe target for tab ${tabId}`);
+  }
+  return target;
+}
+function getPageUrlForTab(debuggerManager2, tabId) {
+  return getPopupTarget(debuggerManager2, tabId, null)?.url ?? debuggerManager2.getTarget(tabId)?.url ?? null;
+}
+function toSelectionTarget(target) {
+  return {
+    type: target.type,
+    frameId: target.frameId,
+    title: target.title,
+    url: target.url
+  };
+}
+
+// src/background/watcher-status.ts
+function buildWatcherStatus(debuggerManager2, tabId, session) {
+  const watcherInfo = session.getWatcherInfo();
+  const targetInfo = session.getTargetInfo();
+  const parsedTarget = targetInfo ? parseWatcherTargetId(targetInfo.targetId) : null;
+  if (!watcherInfo && !targetInfo) {
+    return createWatcherStatus(debuggerManager2, tabId, session, null, null);
+  }
+  return createWatcherStatus(
+    debuggerManager2,
+    tabId,
+    session,
+    watcherInfo ?? null,
+    targetInfo && parsedTarget ? {
+      type: parsedTarget.frameId ? "iframe" : "page",
+      title: targetInfo.title,
+      url: targetInfo.url,
+      targetId: targetInfo.targetId,
+      frameId: parsedTarget.frameId,
+      attachedAt: targetInfo.attachedAt,
+      targetReady: targetInfo.targetReady
+    } : null
+  );
+}
+function createWatcherStatus(debuggerManager2, tabId, session, watcherInfo, currentTarget) {
+  const readiness = buildWatcherReadiness(debuggerManager2, tabId, session, watcherInfo, currentTarget);
+  return {
+    tabId,
+    bridgeConnected: readiness.nativeHostConnected,
+    nativeHostConnected: readiness.nativeHostConnected,
+    watcherReady: readiness.watcherReady,
+    targetReady: readiness.targetReady,
+    targetState: readiness.targetState,
+    watcherId: watcherInfo?.watcherId ?? null,
+    watcherHost: watcherInfo?.watcherHost ?? null,
+    watcherPort: watcherInfo?.watcherPort ?? null,
+    nativeHostPid: watcherInfo?.pid ?? null,
+    lastMessageAt: session.getLastMessageAt(),
+    currentTarget
+  };
+}
+function buildWatcherReadiness(debuggerManager2, tabId, session, watcherInfo, currentTarget) {
+  const nativeHostConnected = session.isConnected();
+  const watcherReady = nativeHostConnected && Boolean(watcherInfo?.watcherId && watcherInfo.watcherHost && watcherInfo.watcherPort != null);
+  const targetReady = currentTarget?.targetReady ?? getTargetReadiness(debuggerManager2, tabId, currentTarget);
+  return {
+    nativeHostConnected,
+    watcherReady,
+    targetReady,
+    targetState: targetReady == null ? "not-selected" : targetReady ? "ready" : "rebinding"
+  };
+}
+function getTargetReadiness(debuggerManager2, tabId, target) {
+  if (!target) {
+    return null;
+  }
+  if (!target.frameId) {
+    return debuggerManager2.isAttached(tabId);
+  }
+  const frame = debuggerManager2.getFrames(tabId).find((candidate) => candidate.frameId === target.frameId);
+  return Boolean(frame?.sessionId);
+}
+
+// src/background/service-worker.ts
+var debuggerManager = new DebuggerManager();
+var controlBridgeSession = new ControlBridgeSession(debuggerManager, {
+  onWatcherInfo: (info) => {
+    recordEvent("info", "bridge", `Control watcher ready: ${info.watcherId} (pid ${info.pid})`);
+  },
+  onAttachTabWatcher: attachTabFromControl,
+  onDetachTabWatcher: detachTabFromControl,
+  getWatcherIdForTab,
+  getDiagnostics: buildControlDiagnostics,
+  onDisconnect: () => {
+    recordEvent("error", "bridge", "Control native host disconnected");
+  }
+});
+var bridgeSessions = /* @__PURE__ */ new Map();
+var selectedFrameByTabId = /* @__PURE__ */ new Map();
+var pendingRememberedTargetByTabId = /* @__PURE__ */ new Map();
+var targetSelectionHistory = new TargetSelectionHistoryStore();
+var targetVisibilityHistory = new TargetVisibilityHistoryStore();
+var recentEvents = [];
+var MAX_RECENT_EVENTS = 8;
+var REMEMBERED_TARGET_RETRY_EVENTS = /* @__PURE__ */ new Set(["Page.frameAttached", "Page.frameDetached", "Page.frameNavigated"]);
+function recordEvent(level, source, message) {
+  recentEvents.unshift({
+    ts: Date.now(),
+    level,
+    source,
+    message
+  });
+  if (recentEvents.length > MAX_RECENT_EVENTS) {
+    recentEvents.length = MAX_RECENT_EVENTS;
+  }
+}
+debuggerManager.onDetach((tabId, reason) => {
+  clearTabState(tabId);
+  recordEvent("error", "debugger", `Tab ${tabId} detached: ${reason}`);
+  void syncActionBadge(debuggerManager);
+});
+debuggerManager.onEvent((tabId, method) => {
+  if (!shouldReplayRememberedTarget(tabId, method)) {
+    return;
+  }
+  void replayRememberedTargetSelection(tabId);
+});
+chrome.runtime.onMessage.addListener(
+  (message, _sender, sendResponse) => {
+    void handlePopupMessage(message, sendResponse);
+    return true;
+  }
+);
+chrome.runtime.onStartup.addListener(() => {
+  ensureControlBridgeSession();
+});
+chrome.runtime.onInstalled.addListener(() => {
+  ensureControlBridgeSession();
+});
+async function handlePopupMessage(message, sendResponse) {
+  ensureControlBridgeSession();
+  pruneStaleBridgeSessions();
+  const response = await buildPopupResponse(message);
+  await syncActionBadge(debuggerManager);
+  sendResponse(response);
+}
+function ensureControlBridgeSession() {
+  if (controlBridgeSession.isConnected()) {
+    return;
+  }
+  controlBridgeSession.connect();
+}
+ensureControlBridgeSession();
+async function attachTabFromControl(tabId, options = {}) {
+  try {
+    const session = await attachBridgeSession(tabId, options);
+    setSelectedFrame(tabId, null);
+    await prepareRememberedTargetSelection(tabId);
+    recordEvent("info", "bridge", `Control attached tab ${tabId}`);
+    void syncActionBadge(debuggerManager);
+    const tab = await getTabInfo(tabId);
+    if (!tab) {
+      return { ok: false, error: `Tab ${tabId} is no longer available` };
+    }
+    return { ok: true, tab, watcherId: session.getWatcherInfo()?.watcherId };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function detachTabFromControl(tabId) {
+  try {
+    await detachTab(tabId);
+    recordEvent("info", "bridge", `Control detached tab ${tabId}`);
+    void syncActionBadge(debuggerManager);
+    const tab = await getTabInfo(tabId);
+    if (!tab) {
+      return { ok: false, error: `Tab ${tabId} is no longer available` };
+    }
+    return { ok: true, tab };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function buildPopupResponse(message) {
+  try {
+    switch (message.action) {
+      case "getTargets":
+        return { success: true, tabs: await getTabsWithTargets() };
+      case "attach": {
+        const tabId = requireTabId(message);
+        await attachBridgeSession(tabId);
+        setSelectedFrame(tabId, null);
+        await prepareRememberedTargetSelection(tabId);
+        recordEvent("info", "popup", `Attached tab ${tabId}`);
+        return { success: true };
+      }
+      case "detach": {
+        const tabId = requireTabId(message);
+        await detachTab(tabId);
+        recordEvent("info", "popup", `Detached tab ${tabId}`);
+        return { success: true };
+      }
+      case "focusTab": {
+        const tabId = requireTabId(message);
+        await focusTab(tabId);
+        recordEvent("info", "popup", `Focused tab ${tabId}`);
+        return { success: true };
+      }
+      case "selectTarget": {
+        const tabId = requireTabId(message);
+        const session = bridgeSessions.get(tabId);
+        if (!session) {
+          return { success: false, error: `No watcher bridge for tab ${tabId}` };
+        }
+        const frameId = message.frameId ?? null;
+        const target = getPopupTarget(debuggerManager, tabId, frameId);
+        if (!target) {
+          return { success: false, error: `Unknown target for tab ${tabId}` };
+        }
+        session.selectTarget(frameId);
+        clearPendingRememberedTarget(tabId);
+        setSelectedFrame(tabId, frameId);
+        await rememberTargetSelection(tabId, target);
+        recordEvent("info", "popup", `Selected ${frameId ? `iframe ${frameId}` : "page"} on tab ${tabId}`);
+        return { success: true };
+      }
+      case "hideTarget": {
+        const tabId = requireTabId(message);
+        const target = getRequiredIframeTarget(debuggerManager, tabId, message.frameId ?? null);
+        await hideTarget(tabId, target);
+        recordEvent("info", "popup", `Hid iframe ${target.frameId} on tab ${tabId}`);
+        return { success: true };
+      }
+      case "showTarget": {
+        const tabId = requireTabId(message);
+        const target = getRequiredIframeTarget(debuggerManager, tabId, message.frameId ?? null);
+        await showTarget(tabId, target);
+        recordEvent("info", "popup", `Restored iframe ${target.frameId} on tab ${tabId}`);
+        return { success: true };
+      }
+      case "getStatus":
+        return {
+          success: true,
+          status: buildPopupStatusPayload()
+        };
+      default:
+        return { success: false, error: `Unknown action: ${message.action}` };
+    }
+  } catch (err) {
+    recordEvent("error", "popup", err instanceof Error ? err.message : "Unknown popup error");
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+function requireTabId(message) {
+  if (message.tabId !== void 0) {
+    return message.tabId;
+  }
+  throw new Error("No tabId provided");
+}
+async function attachBridgeSession(tabId, options = {}) {
+  const existing = bridgeSessions.get(tabId);
+  if (existing) {
+    await connectBridgeSession(tabId, existing);
+    return existing;
+  }
+  const session = new TabBridgeSession(
+    tabId,
+    debuggerManager,
+    {
+      onWatcherInfo: (info) => {
+        recordEvent("info", "bridge", `Watcher ready for tab ${tabId}: ${info.watcherId} (pid ${info.pid})`);
+      },
+      onTargetInfo: (info) => {
+        syncSelectedFrameFromWatcher(info.targetId);
+      },
+      onDisconnect: () => {
+        recordEvent("error", "bridge", `Native host disconnected for tab ${tabId}`);
+        void debuggerManager.detach(tabId).catch(() => {
+        });
+        clearTabState(tabId);
+        void syncActionBadge(debuggerManager);
+      }
+    },
+    options
+  );
+  bridgeSessions.set(tabId, session);
+  await connectBridgeSession(tabId, session);
+  return session;
+}
+async function detachTab(tabId) {
+  const session = bridgeSessions.get(tabId);
+  if (session) {
+    await session.detach();
+  } else {
+    await debuggerManager.detach(tabId);
+  }
+  clearTabState(tabId);
+}
+async function focusTab(tabId) {
+  const tab = await chrome.tabs.get(tabId);
+  await chrome.tabs.update(tabId, { active: true });
+  await chrome.windows.update(tab.windowId, { focused: true });
+}
+async function connectBridgeSession(tabId, session) {
+  try {
+    await session.connectAndAttach();
+  } catch (error) {
+    destroyBridgeSession(tabId);
+    throw error;
+  }
+}
+function clearTabState(tabId) {
+  selectedFrameByTabId.delete(tabId);
+  clearPendingRememberedTarget(tabId);
+  destroyBridgeSession(tabId);
+}
+function pruneStaleBridgeSessions() {
+  for (const [tabId, session] of bridgeSessions.entries()) {
+    if (debuggerManager.isAttached(tabId)) {
+      continue;
+    }
+    if (!session.getTargetInfo()) {
+      continue;
+    }
+    clearTabState(tabId);
+    recordEvent("error", "bridge", `Pruned stale watcher state for tab ${tabId}`);
+  }
+}
+function destroyBridgeSession(tabId) {
+  const session = bridgeSessions.get(tabId);
+  if (!session) {
+    return;
+  }
+  bridgeSessions.delete(tabId);
+  session.dispose();
+}
+function buildPopupStatusPayload() {
+  return {
+    bridgeConnected: [...bridgeSessions.values()].some((session) => session.isConnected()),
+    attachedTabs: debuggerManager.listAttached().map((target) => ({
+      tabId: target.tabId,
+      url: target.url,
+      title: target.title
+    })),
+    watchers: getWatcherStatuses(),
+    recentEvents
+  };
+}
+function buildControlDiagnostics() {
+  const controlInfo = controlBridgeSession.getWatcherInfo();
+  return {
+    extensionId: chrome.runtime.id ?? null,
+    extensionVersion: chrome.runtime.getManifest().version ?? null,
+    control: {
+      connected: controlBridgeSession.isConnected(),
+      watcherId: controlInfo?.watcherId ?? null,
+      watcherHost: controlInfo?.watcherHost ?? null,
+      watcherPort: controlInfo?.watcherPort ?? null,
+      pid: controlInfo?.pid ?? null,
+      lastMessageAt: controlBridgeSession.getLastMessageAt()
+    },
+    tabWatchers: [...bridgeSessions.entries()].map(([tabId, session]) => buildTabBridgeStatus(tabId, session)),
+    recentEvents
+  };
+}
+function buildTabBridgeStatus(tabId, session) {
+  const watcher = session.getWatcherInfo();
+  const target = session.getTargetInfo();
+  return {
+    tabId,
+    connected: session.isConnected(),
+    watcherId: watcher?.watcherId ?? null,
+    watcherHost: watcher?.watcherHost ?? null,
+    watcherPort: watcher?.watcherPort ?? null,
+    pid: watcher?.pid ?? null,
+    targetId: target?.targetId ?? null,
+    targetTitle: target?.title ?? null,
+    targetUrl: target?.url ?? null,
+    targetReady: target?.targetReady ?? null,
+    lastMessageAt: session.getLastMessageAt()
+  };
+}
+async function getTabInfo(tabId) {
+  const tabs = await listBrowserTabs(debuggerManager, void 0, {
+    getWatcherIdForTab
+  });
+  return tabs.find((tab) => tab.tabId === tabId) ?? null;
+}
+function getWatcherIdForTab(tabId) {
+  return bridgeSessions.get(tabId)?.getWatcherInfo()?.watcherId ?? null;
+}
+function getWatcherStatuses() {
+  return [...bridgeSessions.entries()].map(([tabId, session]) => buildWatcherStatus(debuggerManager, tabId, session)).filter((status) => status !== null);
+}
+async function getTabsWithTargets() {
+  const tabs = await listBrowserTabs(debuggerManager);
+  return await Promise.all(
+    tabs.map(async (tab) => {
+      const session = bridgeSessions.get(tab.tabId);
+      const { visibleTargets, hiddenTargets } = await getPopupTargetVisibility(tab.tabId, tab.attached);
+      return {
+        ...tab,
+        targets: visibleTargets,
+        hiddenTargets,
+        selectedFrameId: getSelectedFrameId(tab.tabId),
+        watcher: session ? buildWatcherStatus(debuggerManager, tab.tabId, session) : null
+      };
+    })
+  );
+}
+async function getPopupTargetVisibility(tabId, attached) {
+  const targets = attached ? getPopupTargets(debuggerManager, tabId) : [];
+  const pageUrl = getPageUrlForTab(debuggerManager, tabId);
+  if (!pageUrl) {
+    return { visibleTargets: targets, hiddenTargets: [] };
+  }
+  const hiddenTargets = await filterHiddenTargets(pageUrl, targets);
+  if (hiddenTargets.length === 0) {
+    return { visibleTargets: targets, hiddenTargets };
+  }
+  return {
+    visibleTargets: targets.filter((target) => !hiddenTargets.includes(target)),
+    hiddenTargets
+  };
+}
+function syncSelectedFrameFromWatcher(targetId) {
+  const target = parseWatcherTargetId(targetId);
+  if (!target) {
+    return;
+  }
+  setSelectedFrame(target.tabId, target.frameId);
+}
+function getSelectedFrameId(tabId) {
+  if (!selectedFrameByTabId.has(tabId)) {
+    return void 0;
+  }
+  return selectedFrameByTabId.get(tabId) ?? null;
+}
+async function rememberTargetSelection(tabId, target) {
+  const pageUrl = getPageUrlForTab(debuggerManager, tabId);
+  if (!pageUrl) {
+    return;
+  }
+  await targetSelectionHistory.remember(pageUrl, toSelectionTarget(target));
+}
+async function hideTarget(tabId, target) {
+  const pageUrl = getPageUrlForTab(debuggerManager, tabId);
+  if (!pageUrl) {
+    return;
+  }
+  await targetVisibilityHistory.hide(pageUrl, toSelectionTarget(target));
+  if (getSelectedFrameId(tabId) !== target.frameId) {
+    return;
+  }
+  const session = bridgeSessions.get(tabId);
+  session?.selectTarget(null);
+  setSelectedFrame(tabId, null);
+  const pageTarget = getPopupTarget(debuggerManager, tabId, null);
+  if (pageTarget) {
+    await rememberTargetSelection(tabId, pageTarget);
+  }
+}
+async function showTarget(tabId, target) {
+  const pageUrl = getPageUrlForTab(debuggerManager, tabId);
+  if (!pageUrl) {
+    return;
+  }
+  await targetVisibilityHistory.show(pageUrl, toSelectionTarget(target));
+}
+async function filterHiddenTargets(pageUrl, targets) {
+  const hiddenTargets = await targetVisibilityHistory.getHiddenTargets(pageUrl);
+  if (hiddenTargets.length === 0) {
+    return [];
+  }
+  return targets.filter((target) => hiddenTargets.some((hiddenTarget) => matchesHiddenTarget(hiddenTarget, toSelectionTarget(target))));
+}
+async function prepareRememberedTargetSelection(tabId) {
+  const pageUrl = getPageUrlForTab(debuggerManager, tabId);
+  if (!pageUrl) {
+    clearPendingRememberedTarget(tabId);
+    return;
+  }
+  const remembered = await targetSelectionHistory.getByPageUrl(pageUrl);
+  if (!remembered || remembered.target.type === "page") {
+    clearPendingRememberedTarget(tabId);
+    return;
+  }
+  setPendingRememberedTarget(tabId, remembered);
+  await replayRememberedTargetSelection(tabId);
+}
+async function replayRememberedTargetSelection(tabId) {
+  const remembered = pendingRememberedTargetByTabId.get(tabId);
+  const session = bridgeSessions.get(tabId);
+  if (!remembered || !session) {
+    return;
+  }
+  const target = matchRememberedIframeTarget(
+    remembered,
+    getPopupTargets(debuggerManager, tabId).map((candidate) => toSelectionTarget(candidate))
+  );
+  if (!target?.frameId) {
+    return;
+  }
+  try {
+    session.selectTarget(target.frameId);
+    setSelectedFrame(tabId, target.frameId);
+    clearPendingRememberedTarget(tabId);
+    recordEvent("info", "bridge", `Restored iframe ${target.frameId} on tab ${tabId}`);
+  } catch (error) {
+    console.warn(`[ServiceWorker] Failed to restore remembered iframe for tab ${tabId}:`, error);
+  }
+}
+function shouldReplayRememberedTarget(tabId, method) {
+  return pendingRememberedTargetByTabId.has(tabId) && REMEMBERED_TARGET_RETRY_EVENTS.has(method);
+}
+function setSelectedFrame(tabId, frameId) {
+  selectedFrameByTabId.set(tabId, frameId);
+}
+function setPendingRememberedTarget(tabId, remembered) {
+  pendingRememberedTargetByTabId.set(tabId, remembered);
+}
+function clearPendingRememberedTarget(tabId) {
+  pendingRememberedTargetByTabId.delete(tabId);
+}
+console.log("[ServiceWorker] Argus CDP Bridge extension loaded");
+void syncActionBadge(debuggerManager);
+export {
+  bridgeSessions,
+  debuggerManager
+};
+//# sourceMappingURL=service-worker.js.map