@btraut/browser-bridge 0.1.0

package/extension/dist/background.js

@@ -0,0 +1,1137 @@
+// packages/extension/src/background.ts
+var DEFAULT_CORE_PORT = 3210;
+var CORE_PORT_KEY = "corePort";
+var CORE_WS_PATH = "/drive";
+var DEBUGGER_PROTOCOL_VERSION = "1.3";
+var DEBUGGER_IDLE_TIMEOUT_KEY = "debuggerIdleTimeoutMs";
+var DEFAULT_DEBUGGER_IDLE_TIMEOUT_MS = 15e3;
+var DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS = 1e4;
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var makeEventId = /* @__PURE__ */ (() => {
+  let counter = 0;
+  return () => `evt-${Date.now()}-${counter += 1}`;
+})();
+var lastActiveAtByTab = /* @__PURE__ */ new Map();
+var ensureLastActiveAt = (tabId) => {
+  const existing = lastActiveAtByTab.get(tabId);
+  if (existing) {
+    return existing;
+  }
+  const timestamp = nowIso();
+  lastActiveAtByTab.set(tabId, timestamp);
+  return timestamp;
+};
+var markTabActive = (tabId) => {
+  const timestamp = nowIso();
+  lastActiveAtByTab.set(tabId, timestamp);
+  return timestamp;
+};
+var wrapChromeCallback = (invoker) => new Promise((resolve, reject) => {
+  invoker((value) => {
+    const error = chrome.runtime.lastError;
+    if (error) {
+      reject(new Error(error.message));
+      return;
+    }
+    resolve(value);
+  });
+});
+var wrapChromeVoid = (invoker) => {
+  return new Promise((resolve, reject) => {
+    invoker(() => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve();
+    });
+  });
+};
+var readCorePort = async () => {
+  return await new Promise((resolve) => {
+    chrome.storage.local.get(
+      [CORE_PORT_KEY],
+      (result) => {
+        const raw = result?.[CORE_PORT_KEY];
+        if (typeof raw === "number" && Number.isFinite(raw)) {
+          resolve(raw);
+          return;
+        }
+        if (typeof raw === "string") {
+          const parsed = Number(raw);
+          if (Number.isFinite(parsed)) {
+            resolve(parsed);
+            return;
+          }
+        }
+        resolve(DEFAULT_CORE_PORT);
+      }
+    );
+  });
+};
+var readDebuggerIdleTimeoutMs = async () => {
+  return await new Promise((resolve) => {
+    chrome.storage.local.get(
+      [DEBUGGER_IDLE_TIMEOUT_KEY],
+      (result) => {
+        const raw = result?.[DEBUGGER_IDLE_TIMEOUT_KEY];
+        if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+          resolve(raw);
+          return;
+        }
+        if (typeof raw === "string") {
+          const parsed = Number(raw);
+          if (Number.isFinite(parsed) && parsed > 0) {
+            resolve(parsed);
+            return;
+          }
+        }
+        resolve(DEFAULT_DEBUGGER_IDLE_TIMEOUT_MS);
+      }
+    );
+  });
+};
+var RESTRICTED_URL_PREFIXES = [
+  "chrome://",
+  "chrome-extension://",
+  "chrome-devtools://",
+  "devtools://",
+  "edge://",
+  "brave://",
+  "view-source:"
+];
+var isRestrictedUrl = (url) => {
+  if (!url || typeof url !== "string") {
+    return false;
+  }
+  const lowered = url.toLowerCase();
+  if (RESTRICTED_URL_PREFIXES.some((prefix) => lowered.startsWith(prefix))) {
+    return true;
+  }
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname === "chromewebstore.google.com") {
+      return true;
+    }
+    if (parsed.hostname === "chrome.google.com") {
+      return parsed.pathname.startsWith("/webstore");
+    }
+  } catch (error) {
+    console.debug("Ignoring invalid URL in restriction check.", error);
+  }
+  return false;
+};
+var mapDebuggerErrorMessage = (message, fallbackCode = "INSPECT_UNAVAILABLE") => {
+  const normalized = message.toLowerCase();
+  if (normalized.includes("already attached") || normalized.includes("another debugger") || normalized.includes("attached to this target")) {
+    return {
+      code: "DEBUGGER_IN_USE",
+      message: "Debugger already attached. Close DevTools on the target tab and retry.",
+      retryable: true,
+      details: {
+        reason: "debugger_in_use",
+        hint: "Close DevTools on the target tab and retry.",
+        original_message: message
+      }
+    };
+  }
+  if (normalized.includes("no tab") || normalized.includes("no target") || normalized.includes("tab id")) {
+    return {
+      code: "TAB_NOT_FOUND",
+      message,
+      retryable: false
+    };
+  }
+  if (normalized.includes("not allowed") || normalized.includes("permission") || normalized.includes("denied")) {
+    return {
+      code: "ATTACH_DENIED",
+      message,
+      retryable: false
+    };
+  }
+  if (normalized.includes("cannot access") || normalized.includes("not supported") || normalized.includes("disallowed")) {
+    return {
+      code: "NOT_SUPPORTED",
+      message,
+      retryable: false
+    };
+  }
+  return {
+    code: fallbackCode,
+    message,
+    retryable: false
+  };
+};
+var buildTabInfo = (tab) => {
+  const tabId = tab.id;
+  const windowId = tab.windowId;
+  if (typeof tabId !== "number" || typeof windowId !== "number") {
+    return null;
+  }
+  return {
+    tab_id: tabId,
+    window_id: windowId,
+    url: typeof tab.url === "string" ? tab.url : void 0,
+    title: typeof tab.title === "string" ? tab.title : void 0,
+    active: typeof tab.active === "boolean" ? tab.active : void 0,
+    last_active_at: ensureLastActiveAt(tabId)
+  };
+};
+var queryTabs = async () => {
+  const tabs = await wrapChromeCallback(
+    (callback) => chrome.tabs.query({}, callback)
+  );
+  const result = [];
+  for (const tab of tabs) {
+    const info = buildTabInfo(tab);
+    if (info) {
+      result.push(info);
+    }
+  }
+  return result;
+};
+var getTab = async (tabId) => {
+  return await wrapChromeCallback(
+    (callback) => chrome.tabs.get(tabId, callback)
+  );
+};
+var getActiveTabId = async () => {
+  const tabs = await wrapChromeCallback(
+    (callback) => chrome.tabs.query({ active: true, lastFocusedWindow: true }, callback)
+  );
+  const first = tabs[0];
+  if (first && typeof first.id === "number") {
+    return first.id;
+  }
+  throw new Error("No active tab found.");
+};
+var sendToTab = async (tabId, action, params) => {
+  return await new Promise((resolve) => {
+    const message = { action, params };
+    chrome.tabs.sendMessage(tabId, message, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        resolve({
+          ok: false,
+          error: {
+            code: "EVALUATION_FAILED",
+            message: error.message,
+            retryable: false
+          }
+        });
+        return;
+      }
+      if (!response || typeof response !== "object") {
+        resolve({
+          ok: false,
+          error: {
+            code: "EVALUATION_FAILED",
+            message: "Empty response from content script.",
+            retryable: false
+          }
+        });
+        return;
+      }
+      resolve(response);
+    });
+  });
+};
+var waitForDomContentLoaded = async (tabId, timeoutMs) => {
+  return await new Promise((resolve, reject) => {
+    let timeout;
+    const cleanup = () => {
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
+      chrome.webNavigation.onDOMContentLoaded.removeListener(listener);
+    };
+    const listener = (details) => {
+      if (details.tabId !== tabId || details.frameId !== 0) {
+        return;
+      }
+      cleanup();
+      resolve();
+    };
+    chrome.webNavigation.onDOMContentLoaded.addListener(listener);
+    timeout = self.setTimeout(() => {
+      cleanup();
+      reject(new Error("Timed out waiting for domcontentloaded."));
+    }, timeoutMs);
+  });
+};
+var getWsUrl = async () => {
+  const port = await readCorePort();
+  return `ws://127.0.0.1:${port}${CORE_WS_PATH}`;
+};
+var DriveSocket = class {
+  constructor() {
+    this.socket = null;
+    this.reconnectTimer = null;
+    this.reconnectDelayMs = 1e3;
+    this.maxReconnectDelayMs = 1e4;
+    this.keepAliveTimer = null;
+    this.keepAliveIntervalMs = 3e4;
+    this.debuggerSessions = /* @__PURE__ */ new Map();
+    this.debuggerIdleTimeoutMs = null;
+  }
+  start() {
+    void this.connect().catch((error) => {
+      console.error("DriveSocket connect failed:", error);
+    });
+  }
+  stop() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.stopKeepAlive();
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+  }
+  sendTabReport() {
+    void this.emitTabReport().catch((error) => {
+      console.error("DriveSocket emitTabReport failed:", error);
+    });
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer !== null) {
+      return;
+    }
+    const delay = this.reconnectDelayMs;
+    this.reconnectTimer = self.setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.connect().catch((error) => {
+        console.error("DriveSocket reconnect failed:", error);
+      });
+    }, delay);
+    this.reconnectDelayMs = Math.min(
+      this.maxReconnectDelayMs,
+      this.reconnectDelayMs * 2
+    );
+  }
+  async connect() {
+    const url = await getWsUrl();
+    try {
+      const socket2 = new WebSocket(url);
+      this.socket = socket2;
+      socket2.addEventListener("open", () => {
+        this.reconnectDelayMs = 1e3;
+        this.startKeepAlive();
+        void this.sendHello().catch((error) => {
+          console.error("DriveSocket hello failed:", error);
+        });
+      });
+      socket2.addEventListener("message", (event) => {
+        this.handleMessage(event.data);
+      });
+      socket2.addEventListener("close", () => {
+        this.socket = null;
+        this.stopKeepAlive();
+        this.scheduleReconnect();
+      });
+      socket2.addEventListener("error", () => {
+        this.socket = null;
+        this.stopKeepAlive();
+        this.scheduleReconnect();
+      });
+    } catch (error) {
+      console.debug("DriveSocket connect failed, scheduling reconnect.", error);
+      this.scheduleReconnect();
+    }
+  }
+  async sendHello() {
+    const manifest = chrome.runtime.getManifest();
+    let tabs = [];
+    try {
+      tabs = await queryTabs();
+    } catch (error) {
+      console.debug("DriveSocket sendHello failed to read tabs.", error);
+      tabs = [];
+    }
+    const params = {
+      version: manifest.version,
+      tabs
+    };
+    this.sendEvent("drive.hello", params);
+  }
+  async emitTabReport() {
+    try {
+      const tabs = await queryTabs();
+      this.sendEvent("drive.tab_report", { tabs });
+    } catch (error) {
+      console.debug("DriveSocket emitTabReport failed.", error);
+    }
+  }
+  sendEvent(action, params) {
+    const message = {
+      id: makeEventId(),
+      action,
+      status: "event",
+      params
+    };
+    this.sendMessage(message);
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.keepAliveTimer = self.setInterval(() => {
+      if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      this.sendEvent("drive.keepalive", {});
+    }, this.keepAliveIntervalMs);
+  }
+  stopKeepAlive() {
+    if (this.keepAliveTimer !== null) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = null;
+    }
+  }
+  sendDebuggerEvent(params) {
+    const message = {
+      id: makeEventId(),
+      action: "debugger.event",
+      status: "event",
+      params
+    };
+    this.sendMessage(message);
+  }
+  sendMessage(message) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    this.socket.send(JSON.stringify(message));
+  }
+  handleMessage(raw) {
+    if (typeof raw !== "string") {
+      return;
+    }
+    let message = null;
+    try {
+      message = JSON.parse(raw);
+    } catch (error) {
+      console.debug("DriveSocket received invalid JSON message.", error);
+      return;
+    }
+    if (!message || typeof message !== "object") {
+      return;
+    }
+    if (message.status === "request") {
+      void this.handleRequest(message).catch((error) => {
+        console.error("DriveSocket handleRequest failed:", error);
+      });
+    }
+  }
+  async handleRequest(message) {
+    let driveMessage = null;
+    const respondOk = (result) => {
+      if (!driveMessage) {
+        return;
+      }
+      const response = {
+        id: driveMessage.id,
+        action: driveMessage.action,
+        status: "ok",
+        result
+      };
+      this.sendMessage(response);
+    };
+    const respondError = (error) => {
+      if (!driveMessage) {
+        return;
+      }
+      const response = {
+        id: driveMessage.id,
+        action: driveMessage.action,
+        status: "error",
+        error
+      };
+      this.sendMessage(response);
+    };
+    try {
+      if (!message || typeof message !== "object" || typeof message.id !== "string" || typeof message.action !== "string") {
+        return;
+      }
+      if (message.action.startsWith("debugger.")) {
+        await this.handleDebuggerRequest(message);
+        return;
+      }
+      if (!message.action.startsWith("drive.")) {
+        return;
+      }
+      driveMessage = message;
+      switch (message.action) {
+        case "drive.ping": {
+          respondOk({ ok: true });
+          return;
+        }
+        case "drive.navigate": {
+          const params = message.params ?? {};
+          const url = params.url;
+          if (typeof url !== "string" || url.length === 0) {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "url must be a non-empty string.",
+              retryable: false
+            });
+            return;
+          }
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getActiveTabId();
+          }
+          const waitMode = params.wait === "none" || params.wait === "domcontentloaded" ? params.wait : "domcontentloaded";
+          await wrapChromeVoid(
+            (callback) => chrome.tabs.update(tabId, { url }, () => callback())
+          );
+          markTabActive(tabId);
+          if (waitMode === "domcontentloaded") {
+            try {
+              await waitForDomContentLoaded(tabId, 3e4);
+            } catch (error) {
+              respondError({
+                code: "TIMEOUT",
+                message: error instanceof Error ? error.message : "Timed out waiting.",
+                retryable: true
+              });
+              return;
+            }
+          }
+          respondOk({ ok: true });
+          return;
+        }
+        case "drive.go_back":
+        case "drive.back":
+        case "drive.go_forward":
+        case "drive.forward": {
+          const params = message.params ?? {};
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getActiveTabId();
+          }
+          try {
+            const isBack = message.action === "drive.go_back" || message.action === "drive.back";
+            await wrapChromeVoid((callback) => {
+              if (isBack) {
+                chrome.tabs.goBack(tabId, () => callback());
+              } else {
+                chrome.tabs.goForward(tabId, () => callback());
+              }
+            });
+          } catch (error) {
+            respondError({
+              code: "FAILED_PRECONDITION",
+              message: error instanceof Error ? error.message : "No history entry.",
+              retryable: false
+            });
+            return;
+          }
+          markTabActive(tabId);
+          try {
+            await waitForDomContentLoaded(tabId, 3e4);
+          } catch (error) {
+            respondError({
+              code: "TIMEOUT",
+              message: error instanceof Error ? error.message : "Timed out waiting.",
+              retryable: true
+            });
+            return;
+          }
+          respondOk({ ok: true });
+          return;
+        }
+        case "drive.tab_list": {
+          const tabs = await queryTabs();
+          const result = { tabs };
+          respondOk(result);
+          return;
+        }
+        case "drive.tab_activate": {
+          const tabId = message.params?.tab_id;
+          if (typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number.",
+              retryable: false
+            });
+            return;
+          }
+          const tab = await getTab(tabId);
+          await wrapChromeVoid(
+            (callback) => chrome.tabs.update(tabId, { active: true }, () => callback())
+          );
+          const windowId = tab.windowId;
+          if (typeof windowId === "number") {
+            await wrapChromeVoid(
+              (callback) => chrome.windows.update(
+                windowId,
+                { focused: true },
+                () => callback()
+              )
+            );
+          }
+          markTabActive(tabId);
+          respondOk({ ok: true });
+          this.sendTabReport();
+          return;
+        }
+        case "drive.tab_close": {
+          const tabId = message.params?.tab_id;
+          if (typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number.",
+              retryable: false
+            });
+            return;
+          }
+          await wrapChromeVoid(
+            (callback) => chrome.tabs.remove(tabId, () => callback())
+          );
+          lastActiveAtByTab.delete(tabId);
+          respondOk({ ok: true });
+          this.sendTabReport();
+          return;
+        }
+        case "drive.handle_dialog": {
+          const params = message.params ?? {};
+          const action = params.action;
+          if (action !== "accept" && action !== "dismiss") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "action must be accept or dismiss.",
+              retryable: false
+            });
+            return;
+          }
+          const promptText = params.promptText;
+          if (promptText !== void 0 && typeof promptText !== "string") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "promptText must be a string when provided.",
+              retryable: false
+            });
+            return;
+          }
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getActiveTabId();
+          }
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          try {
+            await this.sendDebuggerCommand(
+              tabId,
+              "Page.handleJavaScriptDialog",
+              {
+                accept: action === "accept",
+                ...promptText ? { promptText } : {}
+              },
+              DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+            );
+            this.touchDebuggerSession(tabId);
+            respondOk({ ok: true });
+          } catch (error2) {
+            const info = mapDebuggerErrorMessage(
+              error2 instanceof Error ? error2.message : "Dialog handling failed."
+            );
+            respondError(info);
+          }
+          return;
+        }
+        case "drive.click":
+        case "drive.hover":
+        case "drive.select":
+        case "drive.type":
+        case "drive.fill_form":
+        case "drive.drag":
+        case "drive.key":
+        case "drive.key_press":
+        case "drive.scroll":
+        case "drive.wait_for": {
+          const params = message.params ?? {};
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getActiveTabId();
+          }
+          const result = await sendToTab(
+            tabId,
+            message.action,
+            params
+          );
+          if (result.ok) {
+            respondOk(result.result ?? { ok: true });
+          } else {
+            respondError(result.error);
+          }
+          return;
+        }
+        default:
+          respondError({
+            code: "NOT_IMPLEMENTED",
+            message: `${message.action} not implemented in extension yet.`,
+            retryable: false
+          });
+      }
+    } catch (error) {
+      const messageText = error instanceof Error ? error.message : "Unknown error";
+      respondError({
+        code: "EVALUATION_FAILED",
+        message: messageText,
+        retryable: false
+      });
+    }
+  }
+  async handleDebuggerRequest(message) {
+    const respondAck = (result) => {
+      this.sendMessage({
+        id: message.id,
+        action: message.action,
+        status: "ack",
+        result
+      });
+    };
+    const respondError = (error) => {
+      this.sendMessage({
+        id: message.id,
+        action: message.action,
+        status: "error",
+        error
+      });
+    };
+    try {
+      switch (message.action) {
+        case "debugger.attach": {
+          const params = message.params ?? {};
+          const tabId = params.tab_id;
+          if (typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number.",
+              retryable: false
+            });
+            return;
+          }
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          respondAck({ ok: true });
+          return;
+        }
+        case "debugger.detach": {
+          const params = message.params ?? {};
+          const tabId = params.tab_id;
+          if (typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number.",
+              retryable: false
+            });
+            return;
+          }
+          const error = await this.detachDebugger(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          respondAck({ ok: true });
+          return;
+        }
+        case "debugger.command": {
+          const params = message.params ?? {};
+          const tabId = params.tab_id;
+          if (typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number.",
+              retryable: false
+            });
+            return;
+          }
+          if (typeof params.method !== "string" || params.method.length === 0) {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "method must be a non-empty string.",
+              retryable: false
+            });
+            return;
+          }
+          const session = this.debuggerSessions.get(tabId);
+          if (session?.attachPromise) {
+            try {
+              await session.attachPromise;
+            } catch (error) {
+              const info = mapDebuggerErrorMessage(
+                error instanceof Error ? error.message : "Debugger attach failed."
+              );
+              this.clearDebuggerSession(tabId);
+              respondError(info);
+              return;
+            }
+          }
+          const attachedSession = this.debuggerSessions.get(tabId);
+          if (!attachedSession?.attached) {
+            respondError({
+              code: "FAILED_PRECONDITION",
+              message: "Debugger is not attached to the requested tab.",
+              retryable: false
+            });
+            return;
+          }
+          try {
+            const result = await this.sendDebuggerCommand(
+              tabId,
+              params.method,
+              params.params,
+              DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+            );
+            this.touchDebuggerSession(tabId);
+            respondAck(result);
+          } catch (error) {
+            if (error instanceof DebuggerTimeoutError) {
+              respondError({
+                code: "TIMEOUT",
+                message: error.message,
+                retryable: true
+              });
+              return;
+            }
+            const info = mapDebuggerErrorMessage(
+              error instanceof Error ? error.message : "Debugger command failed."
+            );
+            respondError(info);
+          }
+          return;
+        }
+        default:
+          respondError({
+            code: "NOT_IMPLEMENTED",
+            message: `${message.action} not implemented in extension yet.`,
+            retryable: false
+          });
+      }
+    } catch (error) {
+      const messageText = error instanceof Error ? error.message : "Unexpected debugger error.";
+      respondError({
+        code: "INSPECT_UNAVAILABLE",
+        message: messageText,
+        retryable: false
+      });
+    }
+  }
+  async handleDebuggerEvent(source, method, params) {
+    const tabId = source.tabId;
+    if (typeof tabId !== "number") {
+      return;
+    }
+    this.touchDebuggerSession(tabId);
+    this.sendDebuggerEvent({
+      tab_id: tabId,
+      method,
+      params,
+      timestamp: nowIso()
+    });
+  }
+  async handleDebuggerDetach(source, reason) {
+    const tabId = source.tabId;
+    if (typeof tabId !== "number") {
+      return;
+    }
+    this.clearDebuggerSession(tabId);
+    this.sendDebuggerEvent({
+      tab_id: tabId,
+      method: "Debugger.detached",
+      params: { reason: reason ?? "unknown" },
+      timestamp: nowIso()
+    });
+  }
+  async ensureDebuggerAttached(tabId) {
+    const existing = this.debuggerSessions.get(tabId);
+    if (existing?.attached) {
+      this.touchDebuggerSession(tabId);
+      return null;
+    }
+    if (existing?.attachPromise) {
+      try {
+        await existing.attachPromise;
+      } catch (error) {
+        const info = mapDebuggerErrorMessage(
+          error instanceof Error ? error.message : "Debugger attach failed."
+        );
+        this.clearDebuggerSession(tabId);
+        return info;
+      }
+      if (existing.attached) {
+        this.touchDebuggerSession(tabId);
+        return null;
+      }
+    }
+    const preflightError = await this.checkDebuggerTarget(tabId);
+    if (preflightError) {
+      return preflightError;
+    }
+    const session = {
+      attached: false,
+      lastActivityAt: nowIso()
+    };
+    this.debuggerSessions.set(tabId, session);
+    session.attachPromise = wrapChromeVoid(
+      (callback) => chrome.debugger.attach(
+        { tabId },
+        DEBUGGER_PROTOCOL_VERSION,
+        () => callback()
+      )
+    );
+    try {
+      await session.attachPromise;
+      session.attached = true;
+      session.attachPromise = void 0;
+      const initError = await this.initializeDebuggerDomains(tabId);
+      if (initError) {
+        await this.detachDebugger(tabId);
+        return initError;
+      }
+      session.initialized = true;
+      this.touchDebuggerSession(tabId);
+      return null;
+    } catch (error) {
+      const info = mapDebuggerErrorMessage(
+        error instanceof Error ? error.message : "Debugger attach failed."
+      );
+      this.clearDebuggerSession(tabId);
+      return info;
+    }
+  }
+  async initializeDebuggerDomains(tabId) {
+    const methods = [
+      ["Page.enable", void 0],
+      ["Runtime.enable", void 0],
+      ["Log.enable", void 0],
+      ["Network.enable", void 0]
+    ];
+    try {
+      for (const [method, params] of methods) {
+        await this.sendDebuggerCommand(
+          tabId,
+          method,
+          params,
+          DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+        );
+      }
+      return null;
+    } catch (error) {
+      return mapDebuggerErrorMessage(
+        error instanceof Error ? error.message : "Debugger initialization failed."
+      );
+    }
+  }
+  async checkDebuggerTarget(tabId) {
+    try {
+      const tab = await getTab(tabId);
+      const url = typeof tab.url === "string" ? tab.url : void 0;
+      if (isRestrictedUrl(url)) {
+        return {
+          code: "NOT_SUPPORTED",
+          message: "Debugger cannot attach to restricted pages.",
+          retryable: false,
+          details: { url }
+        };
+      }
+    } catch (error) {
+      return mapDebuggerErrorMessage(
+        error instanceof Error ? error.message : "Failed to locate tab.",
+        "TAB_NOT_FOUND"
+      );
+    }
+    return null;
+  }
+  async detachDebugger(tabId) {
+    const session = this.debuggerSessions.get(tabId);
+    if (!session) {
+      return null;
+    }
+    if (session.attachPromise) {
+      try {
+        await session.attachPromise;
+      } catch (error) {
+        console.debug("Debugger attach promise failed before detach.", error);
+        this.clearDebuggerSession(tabId);
+        return null;
+      }
+    }
+    if (!session.attached) {
+      this.clearDebuggerSession(tabId);
+      return null;
+    }
+    try {
+      await wrapChromeVoid(
+        (callback) => chrome.debugger.detach({ tabId }, () => callback())
+      );
+    } catch (error) {
+      return mapDebuggerErrorMessage(
+        error instanceof Error ? error.message : "Debugger detach failed."
+      );
+    } finally {
+      this.clearDebuggerSession(tabId);
+    }
+    return null;
+  }
+  async sendDebuggerCommand(tabId, method, params, timeoutMs) {
+    return await new Promise((resolve, reject) => {
+      let finished = false;
+      const timeout = self.setTimeout(() => {
+        finished = true;
+        reject(new DebuggerTimeoutError(timeoutMs));
+      }, timeoutMs);
+      chrome.debugger.sendCommand(
+        { tabId },
+        method,
+        params ?? {},
+        (result) => {
+          if (finished) {
+            return;
+          }
+          finished = true;
+          clearTimeout(timeout);
+          const error = chrome.runtime.lastError;
+          if (error) {
+            reject(new Error(error.message));
+            return;
+          }
+          resolve(result);
+        }
+      );
+    });
+  }
+  touchDebuggerSession(tabId) {
+    const session = this.debuggerSessions.get(tabId);
+    if (!session) {
+      return;
+    }
+    session.lastActivityAt = nowIso();
+    void this.refreshDebuggerIdleTimer(tabId).catch((error) => {
+      console.error("DriveSocket refreshDebuggerIdleTimer failed:", error);
+    });
+  }
+  async refreshDebuggerIdleTimer(tabId) {
+    const session = this.debuggerSessions.get(tabId);
+    if (!session) {
+      return;
+    }
+    if (session.idleTimer) {
+      clearTimeout(session.idleTimer);
+    }
+    const timeoutMs = await this.getDebuggerIdleTimeoutMs();
+    session.idleTimer = self.setTimeout(() => {
+      void this.detachDebugger(tabId).catch((error) => {
+        console.error("DriveSocket detachDebugger failed:", error);
+      });
+    }, timeoutMs);
+  }
+  clearDebuggerSession(tabId) {
+    const session = this.debuggerSessions.get(tabId);
+    if (!session) {
+      return;
+    }
+    if (session.idleTimer) {
+      clearTimeout(session.idleTimer);
+    }
+    this.debuggerSessions.delete(tabId);
+  }
+  async getDebuggerIdleTimeoutMs() {
+    if (this.debuggerIdleTimeoutMs !== null) {
+      return this.debuggerIdleTimeoutMs;
+    }
+    const timeout = await readDebuggerIdleTimeoutMs();
+    this.debuggerIdleTimeoutMs = timeout;
+    return timeout;
+  }
+};
+var DebuggerTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Debugger command timed out after ${timeoutMs}ms.`);
+    this.name = "DebuggerTimeoutError";
+  }
+};
+var socket = new DriveSocket();
+chrome.tabs.onActivated.addListener((activeInfo) => {
+  markTabActive(activeInfo.tabId);
+  socket.sendTabReport();
+});
+chrome.tabs.onCreated.addListener((tab) => {
+  if (typeof tab.id === "number") {
+    ensureLastActiveAt(tab.id);
+  }
+  socket.sendTabReport();
+});
+chrome.tabs.onUpdated.addListener(
+  (tabId, changeInfo, tab) => {
+    const shouldReport = Boolean(changeInfo.url) || Boolean(changeInfo.title) || changeInfo.status === "complete";
+    if (!shouldReport) {
+      return;
+    }
+    if (tab && tab.active) {
+      markTabActive(tabId);
+    }
+    socket.sendTabReport();
+  }
+);
+chrome.tabs.onRemoved.addListener((tabId) => {
+  lastActiveAtByTab.delete(tabId);
+  socket.sendTabReport();
+});
+chrome.debugger.onEvent.addListener(
+  (source, method, params) => {
+    void socket.handleDebuggerEvent(source, method, params).catch((error) => {
+      console.error("DriveSocket handleDebuggerEvent failed:", error);
+    });
+  }
+);
+chrome.debugger.onDetach.addListener(
+  (source, reason) => {
+    void socket.handleDebuggerDetach(source, reason).catch((error) => {
+      console.error("DriveSocket handleDebuggerDetach failed:", error);
+    });
+  }
+);
+socket.start();
+//# sourceMappingURL=background.js.map