@xopcai/xopc 0.0.251 → 0.0.252

package/dist/browser-ext/dist/background.js

@@ -1,9 +1,3 @@
-const XOPC_EXT_PORT = 19820;
-const XOPC_EXT_HOST = "127.0.0.1";
-const XOPC_EXT_WS_URL = `ws://${XOPC_EXT_HOST}:${XOPC_EXT_PORT}/browser-ext`;
-const WS_RECONNECT_BASE_DELAY = 2e3;
-const WS_RECONNECT_MAX_DELAY = 5e3;
-
 const LOG_COLORS = {
   debug: "color: #888",
   info: "color: #3b82f6",
@@ -28,32 +22,100 @@ function createLogger(prefix) {
   };
 }
 
-async function sendContentMessage(tabId, message) {
+const log$2 = createLogger("CDP");
+const attached = /* @__PURE__ */ new Set();
+function isDebuggableUrl(url) {
+  if (!url) return true;
+  return url.startsWith("http://") || url.startsWith("https://") || url === "about:blank" || url.startsWith("data:");
+}
+async function ensureAttached(tabId) {
   try {
-    await chrome.tabs.sendMessage(tabId, message);
-  } catch {
+    const tab = await chrome.tabs.get(tabId);
+    if (!isDebuggableUrl(tab.url)) {
+      attached.delete(tabId);
+      throw new Error(`Cannot debug tab ${tabId}: URL is ${tab.url ?? "unknown"}`);
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("Cannot debug tab")) throw e;
+    attached.delete(tabId);
+    throw new Error(`Tab ${tabId} no longer exists`);
+  }
+  if (attached.has(tabId)) {
+    try {
+      await chrome.debugger.sendCommand({ tabId }, "Runtime.evaluate", {
+        expression: "1",
+        returnByValue: true
+      });
+      return;
+    } catch {
+      attached.delete(tabId);
+    }
+  }
+  const MAX_RETRIES = 3;
+  const RETRY_DELAY = 500;
+  let lastError = "";
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      try {
+        await chrome.debugger.detach({ tabId });
+      } catch {
+      }
+      await chrome.debugger.attach({ tabId }, "1.3");
+      attached.add(tabId);
+      await chrome.debugger.sendCommand({ tabId }, "Runtime.enable", {});
+      await chrome.debugger.sendCommand({ tabId }, "Page.enable", {});
+      log$2.debug("Attached to tab", { tabId, attempt });
+      return;
+    } catch (e) {
+      lastError = e instanceof Error ? e.message : String(e);
+      if (attempt < MAX_RETRIES) {
+        await new Promise((r) => setTimeout(r, RETRY_DELAY));
+      }
+    }
   }
+  throw new Error(`Failed to attach debugger to tab ${tabId}: ${lastError}`);
 }
-async function showOverlayOnTab(tabId, status) {
-  await sendContentMessage(tabId, { type: "content/show-overlay", status });
+async function sendCommand(tabId, method, params) {
+  await ensureAttached(tabId);
+  return chrome.debugger.sendCommand({ tabId }, method, params ?? {});
 }
-async function hideOverlayOnTab(tabId) {
-  await sendContentMessage(tabId, { type: "content/hide-overlay" });
+async function evaluate(tabId, expression) {
+  const result = await sendCommand(tabId, "Runtime.evaluate", {
+    expression,
+    returnByValue: true,
+    awaitPromise: true,
+    userGesture: true
+  });
+  if (result.exceptionDetails) {
+    throw new Error(`JS evaluation failed: ${result.exceptionDetails.text ?? "unknown error"}`);
+  }
+  return result.result?.value;
 }
-async function showClickRippleOnTab(tabId, x, y) {
-  await sendContentMessage(tabId, { type: "content/show-click-ripple", x, y });
+async function captureScreenshot(tabId, options) {
+  const result = await sendCommand(tabId, "Page.captureScreenshot", {
+    format: options?.format,
+    quality: options?.quality
+  });
+  return result.data;
 }
-async function showHoverHighlightOnTab(tabId, selector) {
-  await sendContentMessage(tabId, { type: "content/show-hover-highlight", selector });
+async function dispatchInput(tabId, type, params) {
+  await sendCommand(tabId, `Input.${type}`, params);
 }
-async function showInputFlashOnTab(tabId, selector) {
-  await sendContentMessage(tabId, { type: "content/show-input-flash", selector });
+chrome.debugger.onDetach.addListener((source) => {
+  if (source.tabId) attached.delete(source.tabId);
+});
+
+async function sendContentMessage(tabId, message) {
+  try {
+    await chrome.tabs.sendMessage(tabId, message);
+  } catch {
+  }
 }
-async function showScrollIndicatorOnTab(tabId, direction) {
-  await sendContentMessage(tabId, { type: "content/show-scroll-indicator", direction });
+async function hideOverlayOnTab(tabId) {
+  await sendContentMessage(tabId, { type: "content/hide-overlay" });
 }
 
-const log$2 = createLogger("SessionManager");
+const log$1 = createLogger("SessionManager");
 const XOPC_TAB_GROUP_TITLE = "xopc";
 const automationSessions = /* @__PURE__ */ new Map();
 const WINDOW_IDLE_TIMEOUT = 12e4;
@@ -75,7 +137,7 @@ function resetWindowIdleTimer(workspace = DEFAULT_WORKSPACE) {
     } catch {
     }
     automationSessions.delete(workspace);
-    log$2.info("Automation tab group cleared due to idle timeout", { workspace });
+    log$1.info("Automation tab group cleared due to idle timeout", { workspace });
   }, WINDOW_IDLE_TIMEOUT);
 }
 async function waitForTabLoad(tabId, timeoutMs = 3e4) {
@@ -153,7 +215,7 @@ async function getOrCreateAutomationWindow(workspace = DEFAULT_WORKSPACE) {
   };
   automationSessions.set(workspace, session);
   resetWindowIdleTimer(workspace);
-  log$2.info("Created automation tab group", { workspace, windowId, groupId, tabId: tab.id });
+  log$1.info("Created automation tab group", { workspace, windowId, groupId, tabId: tab.id });
   return session;
 }
 async function getActiveTabId(workspace = DEFAULT_WORKSPACE) {
@@ -197,7 +259,7 @@ async function closeSession(workspace = DEFAULT_WORKSPACE) {
     });
   }
   automationSessions.delete(workspace);
-  log$2.info("Closed automation session", { workspace });
+  log$1.info("Closed automation session", { workspace });
 }
 async function closeAllSessions() {
   for (const workspace of [...automationSessions.keys()]) {
@@ -205,719 +267,296 @@ async function closeAllSessions() {
   }
 }
 
-async function handleOpen(cmd) {
-  const url = cmd.args?.url;
-  if (!url) return { id: cmd.id, ok: false, error: "Missing required arg: url" };
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  await showOverlayOnTab(tabId, "operating");
+const observations = /* @__PURE__ */ new Map();
+async function executeBrowserCommand(command) {
+  const startedAt = Date.now();
   try {
-    await chrome.tabs.update(tabId, { url });
-    await waitForTabLoad(tabId, cmd.timeout ?? 3e4);
-    resetWindowIdleTimer();
-    const tab = await chrome.tabs.get(tabId);
-    await hideOverlayOnTab(tabId);
-    if (tab.groupId != null) {
-      await chrome.tabGroups.update(tab.groupId, { collapsed: false }).catch(() => {
-      });
-    }
-    await chrome.tabs.update(tabId, { active: true }).catch(() => {
-    });
+    const result = await execute(command.input, command.timeoutMs, command.visualFallback, startedAt);
+    return { id: command.id, result };
+  } catch (error) {
     return {
-      id: cmd.id,
-      ok: true,
-      data: { url: tab.url, title: tab.title, tabId }
-    };
-  } catch (e) {
-    await hideOverlayOnTab(tabId);
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleNavigate(cmd) {
-  return handleOpen(cmd);
-}
-async function handleReload(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  await showOverlayOnTab(tabId, "operating");
-  try {
-    await chrome.tabs.reload(tabId);
-    await waitForTabLoad(tabId, cmd.timeout ?? 3e4);
-    resetWindowIdleTimer();
-    const tab = await chrome.tabs.get(tabId);
-    await hideOverlayOnTab(tabId);
-    return { id: cmd.id, ok: true, data: { url: tab.url, title: tab.title } };
-  } catch (e) {
-    await hideOverlayOnTab(tabId);
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleBack(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  try {
-    await chrome.tabs.goBack(tabId);
-    await waitForTabLoad(tabId, cmd.timeout ?? 1e4);
-    const tab = await chrome.tabs.get(tabId);
-    return { id: cmd.id, ok: true, data: { url: tab.url, title: tab.title } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleForward(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  try {
-    await chrome.tabs.goForward(tabId);
-    await waitForTabLoad(tabId, cmd.timeout ?? 1e4);
-    const tab = await chrome.tabs.get(tabId);
-    return { id: cmd.id, ok: true, data: { url: tab.url, title: tab.title } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleGetUrl(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  try {
-    const tab = await chrome.tabs.get(tabId);
-    return { id: cmd.id, ok: true, data: { url: tab.url } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleGetTitle(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  try {
-    const tab = await chrome.tabs.get(tabId);
-    return { id: cmd.id, ok: true, data: { title: tab.title } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-
-const log$1 = createLogger("CDP");
-const attached = /* @__PURE__ */ new Set();
-function isDebuggableUrl(url) {
-  if (!url) return true;
-  return url.startsWith("http://") || url.startsWith("https://") || url === "about:blank" || url.startsWith("data:");
-}
-async function ensureAttached(tabId) {
-  try {
-    const tab = await chrome.tabs.get(tabId);
-    if (!isDebuggableUrl(tab.url)) {
-      attached.delete(tabId);
-      throw new Error(`Cannot debug tab ${tabId}: URL is ${tab.url ?? "unknown"}`);
-    }
-  } catch (e) {
-    if (e instanceof Error && e.message.startsWith("Cannot debug tab")) throw e;
-    attached.delete(tabId);
-    throw new Error(`Tab ${tabId} no longer exists`);
-  }
-  if (attached.has(tabId)) {
-    try {
-      await chrome.debugger.sendCommand({ tabId }, "Runtime.evaluate", {
-        expression: "1",
-        returnByValue: true
-      });
-      return;
-    } catch {
-      attached.delete(tabId);
-    }
-  }
-  const MAX_RETRIES = 3;
-  const RETRY_DELAY = 500;
-  let lastError = "";
-  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      try {
-        await chrome.debugger.detach({ tabId });
-      } catch {
-      }
-      await chrome.debugger.attach({ tabId }, "1.3");
-      attached.add(tabId);
-      await chrome.debugger.sendCommand({ tabId }, "Runtime.enable", {});
-      await chrome.debugger.sendCommand({ tabId }, "Page.enable", {});
-      log$1.debug("Attached to tab", { tabId, attempt });
-      return;
-    } catch (e) {
-      lastError = e instanceof Error ? e.message : String(e);
-      if (attempt < MAX_RETRIES) {
-        await new Promise((r) => setTimeout(r, RETRY_DELAY));
+      id: command.id,
+      result: {
+        ok: false,
+        error: {
+          code: /timeout/i.test(String(error)) ? "TIMEOUT" : "DRIVER_UNAVAILABLE",
+          message: error instanceof Error ? error.message : String(error)
+        }
       }
-    }
-  }
-  throw new Error(`Failed to attach debugger to tab ${tabId}: ${lastError}`);
-}
-async function sendCommand(tabId, method, params) {
-  await ensureAttached(tabId);
-  return chrome.debugger.sendCommand({ tabId }, method, params ?? {});
-}
-async function evaluate(tabId, expression) {
-  const result = await sendCommand(tabId, "Runtime.evaluate", {
-    expression,
-    returnByValue: true,
-    awaitPromise: true,
-    userGesture: true
-  });
-  if (result.exceptionDetails) {
-    throw new Error(`JS evaluation failed: ${result.exceptionDetails.text ?? "unknown error"}`);
+    };
   }
-  return result.result?.value;
 }
-async function captureScreenshot(tabId, options) {
-  if (options?.fullPage) {
-    const metrics = await sendCommand(tabId, "Page.getLayoutMetrics", {});
-    if (metrics.contentSize) {
-      await sendCommand(tabId, "Emulation.setDeviceMetricsOverride", {
-        width: Math.ceil(metrics.contentSize.width),
-        height: Math.ceil(metrics.contentSize.height),
-        deviceScaleFactor: 1,
-        mobile: false
-      });
+async function execute(input, timeoutMs, visualFallback, startedAt) {
+  const sessionId = input.sessionId;
+  if (!sessionId) return fail("INVALID_INPUT", "Extension actions require a session id.");
+  if (input.action === "close") {
+    await closeSession(sessionId);
+    observations.delete(sessionId);
+    return success("close", "read", startedAt);
+  }
+  if (input.action === "observe") {
+    const mode = input.visual === "always" ? "always" : input.visual === "never" || !visualFallback ? "never" : "auto";
+    const observation2 = await observe(sessionId, mode);
+    return success("observe", "read", startedAt, observation2);
+  }
+  if (input.action === "navigate") {
+    const tabId2 = await getActiveTabId(sessionId);
+    await chrome.tabs.update(tabId2, { url: input.url });
+    await waitForTabLoad(tabId2, timeoutMs);
+    resetWindowIdleTimer(sessionId);
+    const observation2 = await observe(sessionId, visualFallback ? "auto" : "never");
+    return verified(input, observation2, startedAt, "read");
+  }
+  if (input.action === "tabs") return tabs(sessionId, input, startedAt, timeoutMs);
+  if (input.action === "sequence") return fail("INVALID_INPUT", "Sequences are expanded by the browser runtime.");
+  const current = observations.get(sessionId);
+  if (!current || current.revision !== input.revision) {
+    return fail("STALE_OBSERVATION", "The page changed. Observe it again.", await observe(sessionId, "never"));
+  }
+  const tabId = await getActiveTabId(sessionId);
+  const ref = "ref" in input ? input.ref : void 0;
+  if (ref && !current.nodes.some((node) => node.ref === ref)) {
+    return fail("TARGET_NOT_FOUND", `Target ${ref} was not found.`);
+  }
+  if (input.action === "click") {
+    const point = await evaluateRef(tabId, input.ref, `(element) => {
+      const rect = element.getBoundingClientRect();
+      return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+    }`);
+    if (!point) return fail("TARGET_NOT_FOUND", `Target ${input.ref} was not found.`);
+    const coordinates = point;
+    await dispatchInput(tabId, "dispatchMouseEvent", { type: "mousePressed", ...coordinates, button: "left", clickCount: 1 });
+    await dispatchInput(tabId, "dispatchMouseEvent", { type: "mouseReleased", ...coordinates, button: "left", clickCount: 1 });
+  } else if (input.action === "fill") {
+    const changed = await evaluateRef(tabId, input.ref, `(element, value) => {
+      element.focus();
+      const prototype = element instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+      const setter = Object.getOwnPropertyDescriptor(prototype, 'value')?.set;
+      setter?.call(element, value);
+      element.dispatchEvent(new Event('input', { bubbles: true }));
+      element.dispatchEvent(new Event('change', { bubbles: true }));
+      return true;
+    }`, input.value);
+    if (!changed) return fail("TARGET_NOT_FOUND", `Target ${input.ref} was not found.`);
+    if (input.submit) await pressKey(tabId, "Enter");
+  } else if (input.action === "select") {
+    const changed = await evaluateRef(tabId, input.ref, `(element, value) => {
+      element.value = value;
+      element.dispatchEvent(new Event('input', { bubbles: true }));
+      element.dispatchEvent(new Event('change', { bubbles: true }));
+      return true;
+    }`, input.value);
+    if (!changed) return fail("TARGET_NOT_FOUND", `Target ${input.ref} was not found.`);
+  } else if (input.action === "press") {
+    if (input.ref) await evaluateRef(tabId, input.ref, "(element) => { element.focus(); return true; }");
+    await pressKey(tabId, input.key);
+  } else if (input.action === "scroll") {
+    if (input.ref) {
+      await evaluateRef(tabId, input.ref, "(element, deltaY) => { element.scrollBy({ top: deltaY }); return true; }", input.deltaY);
+    } else {
+      await dispatchInput(tabId, "dispatchMouseEvent", { type: "mouseWheel", x: 640, y: 360, deltaX: 0, deltaY: input.deltaY });
     }
-  }
-  const result = await sendCommand(tabId, "Page.captureScreenshot", {
-    format: options?.format,
-    quality: options?.quality
-  });
-  if (options?.fullPage) {
-    await sendCommand(tabId, "Emulation.clearDeviceMetricsOverride", {});
-  }
-  return result.data;
-}
-async function dispatchInput(tabId, type, params) {
-  await sendCommand(tabId, `Input.${type}`, params);
-}
-chrome.debugger.onDetach.addListener((source) => {
-  if (source.tabId) attached.delete(source.tabId);
-});
-
-async function handleMouseMove(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const x = cmd.args?.x ?? 0;
-  const y = cmd.args?.y ?? 0;
-  try {
-    await dispatchInput(tabId, "dispatchMouseEvent", {
-      type: "mouseMoved",
-      x,
-      y
-    });
-    return { id: cmd.id, ok: true, data: { x, y } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleMouseClick(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const x = cmd.args?.x ?? 0;
-  const y = cmd.args?.y ?? 0;
-  const button = cmd.args?.button ?? "left";
-  const clickCount = cmd.args?.clickCount ?? 1;
-  try {
-    await dispatchInput(tabId, "dispatchMouseEvent", {
-      type: "mousePressed",
-      x,
-      y,
-      button,
-      clickCount
-    });
-    await dispatchInput(tabId, "dispatchMouseEvent", {
-      type: "mouseReleased",
-      x,
-      y,
-      button,
-      clickCount
-    });
-    await showClickRippleOnTab(tabId, x, y);
-    return { id: cmd.id, ok: true, data: { x, y, button } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleMouseWheel(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const x = cmd.args?.x ?? 0;
-  const y = cmd.args?.y ?? 0;
-  const deltaX = cmd.args?.deltaX ?? 0;
-  const deltaY = cmd.args?.deltaY ?? 0;
-  try {
-    await dispatchInput(tabId, "dispatchMouseEvent", {
-      type: "mouseWheel",
-      x,
-      y,
-      deltaX,
-      deltaY
-    });
-    return { id: cmd.id, ok: true, data: { deltaX, deltaY } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleKeyboardPress(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const key = cmd.args?.key;
-  if (!key) return { id: cmd.id, ok: false, error: "Missing required arg: key" };
-  try {
-    await dispatchInput(tabId, "dispatchKeyEvent", {
-      type: "keyDown",
-      key,
-      windowsVirtualKeyCode: key.length === 1 ? key.charCodeAt(0) : 0
-    });
-    await dispatchInput(tabId, "dispatchKeyEvent", {
-      type: "keyUp",
-      key,
-      windowsVirtualKeyCode: key.length === 1 ? key.charCodeAt(0) : 0
+  } else if (input.action === "wait") {
+    await wait(tabId, input, timeoutMs);
+  } else if (input.action === "upload") {
+    const document = await sendCommand(tabId, "DOM.getDocument", { depth: 1 });
+    const query = await sendCommand(tabId, "DOM.querySelectorAll", {
+      nodeId: document.root.nodeId,
+      selector: `[data-xopc-ref="${input.ref}"]`
     });
-    return { id: cmd.id, ok: true, data: { key } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleKeyboardType(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const text = cmd.args?.text;
-  if (!text) return { id: cmd.id, ok: false, error: "Missing required arg: text" };
-  try {
-    for (const char of text) {
-      await dispatchInput(tabId, "dispatchKeyEvent", {
-        type: "char",
-        text: char
-      });
-    }
-    return { id: cmd.id, ok: true, data: { text } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleType(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const selector = cmd.args?.selector;
-  const text = cmd.args?.text;
-  if (!text) return { id: cmd.id, ok: false, error: "Missing required arg: text" };
-  try {
-    if (selector) {
-      await evaluate(tabId, `document.querySelector('${selector}')?.focus()`);
-      await showInputFlashOnTab(tabId, selector);
-    }
-    await sendCommand(tabId, "Input.insertText", { text });
-    if (cmd.args?.pressEnter) {
-      await dispatchInput(tabId, "dispatchKeyEvent", {
-        type: "keyDown",
-        key: "Enter",
-        code: "Enter",
-        windowsVirtualKeyCode: 13
-      });
-      await dispatchInput(tabId, "dispatchKeyEvent", {
-        type: "keyUp",
-        key: "Enter",
-        code: "Enter",
-        windowsVirtualKeyCode: 13
-      });
-    }
-    return { id: cmd.id, ok: true, data: { text, selector } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-
-async function handleClick(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const selector = cmd.args?.selector;
-  const text = cmd.args?.text;
-  try {
-    let x, y;
-    if (selector) {
-      await showHoverHighlightOnTab(tabId, selector);
-      const box = await evaluate(tabId, `(() => {
-        const el = document.querySelector('${selector}');
-        if (!el) return null;
-        const r = el.getBoundingClientRect();
-        return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
-      })()`);
-      if (!box || typeof box !== "object") {
-        return { id: cmd.id, ok: false, error: `Element not found: ${selector}` };
-      }
-      const coords = box;
-      x = coords.x;
-      y = coords.y;
-    } else if (text) {
-      const box = await evaluate(tabId, `(() => {
-        const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
-        while (walker.nextNode()) {
-          if (walker.currentNode.textContent?.trim().includes('${text.replace(/'/g, "\\'")}')) {
-            const el = walker.currentNode.parentElement;
-            if (el) { const r = el.getBoundingClientRect(); return { x: r.x + r.width / 2, y: r.y + r.height / 2 }; }
-          }
-        }
-        return null;
-      })()`);
-      if (!box || typeof box !== "object") {
-        return { id: cmd.id, ok: false, error: `Element with text not found: ${text}` };
+    if (query.nodeIds.length !== 1) return fail("TARGET_NOT_FOUND", `Target ${input.ref} was not uniquely found.`);
+    await sendCommand(tabId, "DOM.setFileInputFiles", { nodeId: query.nodeIds[0], files: input.paths });
+  }
+  await new Promise((resolve) => setTimeout(resolve, 200));
+  const observation = await observe(sessionId, visualFallback ? "auto" : "never");
+  return verified(input, observation, startedAt, "draft");
+}
+async function observe(sessionId, visual) {
+  const tabId = await getActiveTabId(sessionId);
+  const tab = await chrome.tabs.get(tabId);
+  const raw = await evaluate(tabId, `(() => {
+    const selector = 'a[href],button,input:not([type="hidden"]),textarea,select,summary,[contenteditable="true"],[role="button"],[role="link"],[role="checkbox"],[role="radio"],[role="combobox"],[role="menuitem"],[role="option"],[role="tab"],[tabindex]:not([tabindex="-1"])';
+    globalThis.__xopcRefCounter = globalThis.__xopcRefCounter || 0;
+    const nodes = [];
+    const seenRefs = new Set();
+    for (const element of Array.from(document.querySelectorAll(selector)).slice(0, 1500)) {
+      const rect = element.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) continue;
+      const style = getComputedStyle(element);
+      if (style.visibility === 'hidden' || style.display === 'none') continue;
+      let ref = element.getAttribute('data-xopc-ref');
+      if (!/^xopc-ed+$/.test(ref || '') || seenRefs.has(ref)) {
+        ref = 'xopc-e' + (++globalThis.__xopcRefCounter);
+        element.setAttribute('data-xopc-ref', ref);
       }
-      const coords = box;
-      x = coords.x;
-      y = coords.y;
-    } else if (cmd.args?.x !== void 0 && cmd.args?.y !== void 0) {
-      x = cmd.args.x;
-      y = cmd.args.y;
-    } else {
-      return { id: cmd.id, ok: false, error: "Click requires selector, text, or x/y coordinates" };
+      seenRefs.add(ref);
+      const tag = element.tagName.toLowerCase();
+      const role = element.getAttribute('role') || (tag === 'a' ? 'link' : tag === 'button' || tag === 'summary' ? 'button' : tag === 'select' ? 'combobox' : tag === 'input' && element.type === 'checkbox' ? 'checkbox' : tag === 'input' && element.type === 'radio' ? 'radio' : 'textbox');
+      const label = element.labels?.[0]?.innerText || '';
+      const name = (element.getAttribute('aria-label') || label || element.getAttribute('alt') || element.getAttribute('placeholder') || element.innerText || element.getAttribute('title') || '').trim().replace(/\\s+/g, ' ').slice(0, 240);
+      const states = [];
+      const autocomplete = (element.getAttribute('autocomplete') || '').toLowerCase();
+      const sensitive = element.type === 'password' || /^(cc-|one-time-code$|transaction-)/.test(autocomplete);
+      if (element.disabled) states.push('disabled');
+      if (element.checked) states.push('checked');
+      if (document.activeElement === element) states.push('focused');
+      if (element.getAttribute('aria-expanded') === 'true') states.push('expanded');
+      if (sensitive) states.push('sensitive');
+      if ((tag === 'button' || tag === 'input') && element.type === 'submit') states.push('submit');
+      nodes.push({ ref, role, name, value: !sensitive && 'value' in element ? String(element.value || '').slice(0, 500) : undefined, states, bounds: { x: rect.x, y: rect.y, width: rect.width, height: rect.height } });
+      if (nodes.length >= 500) break;
     }
-    await dispatchInput(tabId, "dispatchMouseEvent", { type: "mousePressed", x, y, button: "left", clickCount: 1 });
-    await dispatchInput(tabId, "dispatchMouseEvent", { type: "mouseReleased", x, y, button: "left", clickCount: 1 });
-    await showClickRippleOnTab(tabId, x, y);
-    return { id: cmd.id, ok: true, data: { x, y, selector, text } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleScroll(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const deltaY = cmd.args?.deltaY ?? (cmd.args?.direction === "up" ? -300 : 300);
-  try {
-    await dispatchInput(tabId, "dispatchMouseEvent", {
-      type: "mouseWheel",
-      x: 640,
-      y: 360,
-      deltaX: 0,
-      deltaY
-    });
-    await showScrollIndicatorOnTab(tabId, deltaY > 0 ? "down" : "up");
-    return { id: cmd.id, ok: true, data: { deltaY } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleEvaluate(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const expression = cmd.args?.expression;
-  if (!expression) return { id: cmd.id, ok: false, error: "Missing required arg: expression" };
-  try {
-    const result = await evaluate(tabId, expression);
-    return { id: cmd.id, ok: true, data: { result } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
+    return { marker: location.href + '|' + performance.timeOrigin, nodes, hasVisualSurface: !!document.querySelector('canvas,embed[type="application/pdf"],object[type="application/pdf"]') };
+  })()`);
+  const prior = observations.get(sessionId);
+  const state = prior?.documentMarker === raw.marker ? { ...prior, revision: prior.revision + 1, nodes: raw.nodes } : { documentMarker: raw.marker, documentId: crypto.randomUUID(), revision: 1, nodes: raw.nodes };
+  const changes = diff(prior?.documentMarker === raw.marker ? prior.nodes : [], raw.nodes);
+  observations.set(sessionId, state);
+  const capture = visual === "always" || visual === "auto" && (raw.nodes.length === 0 || raw.hasVisualSurface);
+  const image = capture ? await captureScreenshot(tabId, { format: "jpeg", quality: 70}) : void 0;
+  return {
+    sessionId,
+    tabId: String(tabId),
+    revision: state.revision,
+    documentId: state.documentId,
+    url: tab.url ?? "",
+    title: tab.title ?? "",
+    focused: raw.nodes.find((node) => node.states.includes("focused"))?.ref,
+    nodes: raw.nodes,
+    changes,
+    visual: image ? { mimeType: "image/jpeg", data: image } : void 0
+  };
 }
-async function handleWait(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const selector = cmd.args?.selector;
-  const timeout = cmd.timeout ?? 1e4;
-  if (!selector) {
-    const ms = cmd.args?.ms ?? 1e3;
-    await new Promise((r) => setTimeout(r, ms));
-    return { id: cmd.id, ok: true, data: { waited: ms } };
-  }
-  try {
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      const found = await evaluate(tabId, `!!document.querySelector('${selector}')`);
-      if (found) return { id: cmd.id, ok: true, data: { selector, elapsed: Date.now() - start } };
-      await new Promise((r) => setTimeout(r, 200));
+async function tabs(sessionId, input, startedAt, timeoutMs) {
+  const session = await getOrCreateAutomationWindow(sessionId);
+  if (input.operation === "create") {
+    const created = await addTabToAutomationGroup(input.url ?? "about:blank", sessionId);
+    session.activeTabId = created.tabId;
+    if (input.url) await waitForTabLoad(created.tabId, timeoutMs);
+  } else if (input.operation === "activate") {
+    const tabId = Number(input.tabId);
+    if (!Number.isInteger(tabId) || !session.tabIds.includes(tabId)) return fail("TARGET_NOT_FOUND", `Tab ${input.tabId ?? ""} was not found.`);
+    session.activeTabId = tabId;
+    await chrome.tabs.update(tabId, { active: true });
+  } else if (input.operation === "close") {
+    const tabId = Number(input.tabId);
+    if (!Number.isInteger(tabId) || !session.tabIds.includes(tabId)) return fail("TARGET_NOT_FOUND", `Tab ${input.tabId ?? ""} was not found.`);
+    await chrome.tabs.remove(tabId);
+    session.tabIds = session.tabIds.filter((id) => id !== tabId);
+    session.activeTabId = session.tabIds[0] ?? null;
+  }
+  const currentTabs = await chrome.tabs.query({ groupId: session.groupId });
+  return {
+    ok: true,
+    receipt: {
+      action: "tabs",
+      risk: "read",
+      durationMs: Date.now() - startedAt,
+      verified: true,
+      tabs: currentTabs.map((tab) => ({ id: String(tab.id), url: tab.url ?? "", title: tab.title ?? "", active: tab.id === session.activeTabId }))
     }
-    return { id: cmd.id, ok: false, error: `Timeout waiting for selector: ${selector}` };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleQuerySelector(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const selector = cmd.args?.selector;
-  if (!selector) return { id: cmd.id, ok: false, error: "Missing required arg: selector" };
-  try {
-    const result = await evaluate(tabId, `(() => {
-      const el = document.querySelector('${selector}');
-      if (!el) return null;
-      const r = el.getBoundingClientRect();
-      return { tag: el.tagName.toLowerCase(), text: el.textContent?.slice(0, 200), rect: { x: r.x, y: r.y, width: r.width, height: r.height } };
-    })()`);
-    return { id: cmd.id, ok: true, data: result };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-
-async function handleState(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  try {
-    const tab = await chrome.tabs.get(tabId);
-    return {
-      id: cmd.id,
-      ok: true,
-      data: { url: tab.url, title: tab.title, tabId, status: tab.status }
-    };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleSnapshot(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  try {
-    const accessibility = await sendCommand(tabId, "Accessibility.getFullAXTree", {});
-    const nodes = accessibility.nodes?.slice(0, 200).map((n) => ({
-      role: n.role?.value,
-      name: n.name?.value
-    })).filter((n) => n.role && n.name) ?? [];
-    const tab = await chrome.tabs.get(tabId);
-    return {
-      id: cmd.id,
-      ok: true,
-      data: { url: tab.url, title: tab.title, nodes, nodeCount: nodes.length }
-    };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleScreenshot(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const fullPage = cmd.args?.fullPage ?? cmd.args?.full_page ?? false;
-  try {
-    const base64 = await captureScreenshot(tabId, {
-      format: "png",
-      fullPage
-    });
-    return { id: cmd.id, ok: true, data: { base64, format: "png", fullPage } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleGetViewportSize(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  try {
-    const size = await evaluate(tabId, `({ width: window.innerWidth, height: window.innerHeight })`);
-    return { id: cmd.id, ok: true, data: size };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleSetViewportSize(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const width = cmd.args?.width ?? 1280;
-  const height = cmd.args?.height ?? 720;
-  try {
-    await sendCommand(tabId, "Emulation.setDeviceMetricsOverride", {
-      width,
-      height,
-      deviceScaleFactor: 1,
-      mobile: false
-    });
-    return { id: cmd.id, ok: true, data: { width, height } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleClose(cmd) {
-  try {
-    await closeSession();
-    return { id: cmd.id, ok: true, data: { closed: true } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleNewTab(cmd) {
-  try {
-    const url = cmd.args?.url ?? "about:blank";
-    const { tabId } = await addTabToAutomationGroup(url);
-    return { id: cmd.id, ok: true, data: { tabId, url } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
+  };
 }
-async function handleListTabs(cmd) {
-  try {
-    const sess = automationSessions.get(DEFAULT_WORKSPACE);
-    if (!sess) {
-      return { id: cmd.id, ok: true, data: { tabs: [] } };
+async function wait(tabId, input, defaultTimeout) {
+  const timeout = input.timeoutMs ?? defaultTimeout;
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    if (input.condition === "page_idle") {
+      const tab = await chrome.tabs.get(tabId);
+      if (tab.status === "complete") return;
+    } else if (input.condition === "text") {
+      const found = await evaluate(tabId, `document.body?.innerText.includes(${JSON.stringify(input.value ?? "")})`);
+      if (found) return;
+    } else if (input.ref) {
+      const visible = await evaluateRef(tabId, input.ref, `(element) => {
+        const rect = element.getBoundingClientRect();
+        const style = getComputedStyle(element);
+        return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none';
+      }`);
+      if (input.condition === "visible" && visible || input.condition === "hidden" && !visible) return;
     }
-    const tabs = await chrome.tabs.query({ groupId: sess.groupId });
-    return {
-      id: cmd.id,
-      ok: true,
-      data: {
-        tabs: tabs.map((t) => ({ id: t.id, url: t.url, title: t.title, active: t.active }))
-      }
-    };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleGetCookies(cmd) {
-  const url = cmd.args?.url;
-  try {
-    const cookies = await chrome.cookies.getAll(url ? { url } : {});
-    return { id: cmd.id, ok: true, data: { cookies: cookies.slice(0, 100) } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-async function handleDialog(cmd) {
-  const tabId = cmd.tabId ?? await getActiveTabId();
-  const accept = cmd.args?.accept ?? true;
-  const promptText = cmd.args?.text;
-  try {
-    await sendCommand(tabId, "Page.handleJavaScriptDialog", {
-      accept,
-      promptText
-    });
-    return { id: cmd.id, ok: true, data: { accept, promptText } };
-  } catch (e) {
-    return { id: cmd.id, ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Timed out waiting for ${input.condition}`);
+}
+async function evaluateRef(tabId, ref, functionBody, value) {
+  const expression = `(() => {
+    const matches = document.querySelectorAll('[data-xopc-ref="' + ${JSON.stringify(ref)} + '"]');
+    if (matches.length !== 1) return null;
+    const element = matches[0];
+    return (${functionBody})(element, ${JSON.stringify(value)});
+  })()`;
+  return evaluate(tabId, expression);
+}
+async function pressKey(tabId, key) {
+  await dispatchInput(tabId, "dispatchKeyEvent", { type: "keyDown", key });
+  await dispatchInput(tabId, "dispatchKeyEvent", { type: "keyUp", key });
+}
+function verified(input, observation, startedAt, risk) {
+  const expectation = "expect" in input ? input.expect : void 0;
+  const pageText = observation.nodes.map((node) => `${node.name}
+${node.value ?? ""}`).join("\n");
+  const failure = expectation?.urlIncludes && !observation.url.includes(expectation.urlIncludes) ? `URL does not include ${expectation.urlIncludes}` : expectation?.titleIncludes && !observation.title.includes(expectation.titleIncludes) ? `Title does not include ${expectation.titleIncludes}` : expectation?.textIncludes && !pageText.includes(expectation.textIncludes) ? `Page does not include ${expectation.textIncludes}` : null;
+  return failure ? fail("EXPECTATION_FAILED", failure, observation) : success(input.action, risk, startedAt, observation);
+}
+function success(action, risk, startedAt, observation) {
+  return { ok: true, receipt: { action, risk, durationMs: Date.now() - startedAt, verified: true, observation } };
+}
+function fail(code, message, observation) {
+  return { ok: false, error: { code, message, observation } };
+}
+function diff(previous, next) {
+  const before = new Map(previous.map((node) => [node.ref, node]));
+  const after = new Map(next.map((node) => [node.ref, node]));
+  return {
+    added: next.filter((node) => !before.has(node.ref)),
+    changed: next.filter((node) => before.has(node.ref) && JSON.stringify(before.get(node.ref)) !== JSON.stringify(node)),
+    removed: previous.filter((node) => !after.has(node.ref)).map((node) => node.ref)
+  };
 }
 
+const XOPC_EXT_PORT = 19820;
+const XOPC_EXT_HOST = "127.0.0.1";
+const XOPC_EXT_WS_URL = `ws://${XOPC_EXT_HOST}:${XOPC_EXT_PORT}/browser-ext`;
+const WS_RECONNECT_BASE_DELAY = 2e3;
+const WS_RECONNECT_MAX_DELAY = 5e3;
+
 const log = createLogger("Background");
 let ws = null;
 let reconnectTimer = null;
 let reconnectDelay = WS_RECONNECT_BASE_DELAY;
 let intentionalClose = false;
-async function dispatchCommand(cmd) {
-  const start = Date.now();
-  try {
-    let result;
-    switch (cmd.action) {
-      // Navigation
-      case "open":
-        result = await handleOpen(cmd);
-        break;
-      case "navigate":
-        result = await handleNavigate(cmd);
-        break;
-      case "reload":
-        result = await handleReload(cmd);
-        break;
-      case "back":
-        result = await handleBack(cmd);
-        break;
-      case "forward":
-        result = await handleForward(cmd);
-        break;
-      case "get_url":
-        result = await handleGetUrl(cmd);
-        break;
-      case "get_title":
-        result = await handleGetTitle(cmd);
-        break;
-      // Page
-      case "state":
-        result = await handleState(cmd);
-        break;
-      case "snapshot":
-        result = await handleSnapshot(cmd);
-        break;
-      case "screenshot":
-        result = await handleScreenshot(cmd);
-        break;
-      case "get_viewport_size":
-        result = await handleGetViewportSize(cmd);
-        break;
-      case "set_viewport_size":
-        result = await handleSetViewportSize(cmd);
-        break;
-      case "close":
-        result = await handleClose(cmd);
-        break;
-      case "new_tab":
-        result = await handleNewTab(cmd);
-        break;
-      case "list_tabs":
-        result = await handleListTabs(cmd);
-        break;
-      case "get_cookies":
-        result = await handleGetCookies(cmd);
-        break;
-      case "dialog":
-        result = await handleDialog(cmd);
-        break;
-      // Elements
-      case "click":
-        result = await handleClick(cmd);
-        break;
-      case "scroll":
-        result = await handleScroll(cmd);
-        break;
-      case "evaluate":
-        result = await handleEvaluate(cmd);
-        break;
-      case "wait":
-        result = await handleWait(cmd);
-        break;
-      case "query_selector":
-        result = await handleQuerySelector(cmd);
-        break;
-      // Input
-      case "mouse_move":
-        result = await handleMouseMove(cmd);
-        break;
-      case "mouse_click":
-        result = await handleMouseClick(cmd);
-        break;
-      case "mouse_wheel":
-        result = await handleMouseWheel(cmd);
-        break;
-      case "keys":
-        result = await handleKeyboardPress(cmd);
-        break;
-      case "keyboard_type":
-        result = await handleKeyboardType(cmd);
-        break;
-      case "type":
-        result = await handleType(cmd);
-        break;
-      // Ping
-      case "ping":
-        result = {
-          id: cmd.id,
-          ok: true,
-          data: {
-            pong: true,
-            extensionVersion: chrome.runtime.getManifest().version,
-            timestamp: Date.now()
-          }
-        };
-        break;
-      default:
-        result = { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
-    }
-    result.durationMs = Date.now() - start;
-    return result;
-  } catch (e) {
-    return {
-      id: cmd.id,
-      ok: false,
-      error: e instanceof Error ? e.message : String(e),
-      durationMs: Date.now() - start
-    };
-  }
-}
 function connect() {
-  if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
-    return;
-  }
+  if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) return;
   intentionalClose = false;
-  log.info("Connecting to xopc daemon...", { url: XOPC_EXT_WS_URL });
   ws = new WebSocket(XOPC_EXT_WS_URL);
   ws.onopen = () => {
-    log.info("Connected to xopc daemon");
     reconnectDelay = WS_RECONNECT_BASE_DELAY;
     sendStatus();
+    log.info("Connected to xopc daemon");
   };
   ws.onmessage = async (event) => {
     try {
-      const cmd = JSON.parse(event.data);
-      log.debug("Received command", { action: cmd.action, id: cmd.id });
-      const result = await dispatchCommand(cmd);
+      const command = JSON.parse(String(event.data));
+      const result = await executeBrowserCommand(command);
       ws?.send(JSON.stringify(result));
-    } catch (e) {
-      log.error("Failed to process message", {
-        error: e instanceof Error ? e.message : String(e)
-      });
+    } catch (error) {
+      log.error("Failed to process browser command", { error: error instanceof Error ? error.message : String(error) });
     }
   };
   ws.onclose = () => {
     ws = null;
-    if (!intentionalClose) {
-      log.warn("Disconnected, reconnecting...", { delay: reconnectDelay });
-      scheduleReconnect();
-    }
+    if (!intentionalClose) scheduleReconnect();
   };
-  ws.onerror = () => {
+}
+function sendStatus() {
+  if (ws?.readyState !== WebSocket.OPEN) return;
+  const status = {
+    type: "status",
+    connected: true,
+    sessionCount: automationSessions.size
   };
+  ws.send(JSON.stringify(status));
 }
 function scheduleReconnect() {
   if (reconnectTimer) clearTimeout(reconnectTimer);
@@ -929,76 +568,27 @@ function scheduleReconnect() {
 }
 function disconnect() {
   intentionalClose = true;
-  if (reconnectTimer) {
-    clearTimeout(reconnectTimer);
-    reconnectTimer = null;
-  }
-  if (ws) {
-    ws.close();
-    ws = null;
-  }
-}
-async function sendStatus() {
-  if (!ws || ws.readyState !== WebSocket.OPEN) return;
-  try {
-    const sess = automationSessions.get(DEFAULT_WORKSPACE);
-    let activeTabId;
-    let activeUrl;
-    if (sess?.activeTabId != null) {
-      const tab = await chrome.tabs.get(sess.activeTabId).catch(() => null);
-      if (tab) {
-        activeTabId = tab.id;
-        activeUrl = tab.url;
-      }
-    }
-    const status = {
-      type: "status",
-      connected: true,
-      tabCount: sess ? sess.tabIds.length : 0,
-      activeTabId,
-      activeUrl
-    };
-    ws.send(JSON.stringify(status));
-  } catch {
-  }
+  if (reconnectTimer) clearTimeout(reconnectTimer);
+  reconnectTimer = null;
+  ws?.close();
+  ws = null;
 }
-chrome.runtime.onMessage.addListener(
-  (message, _sender, sendResponse) => {
-    switch (message.type) {
-      case "popup/get-status":
-        sendResponse({
-          connected: ws?.readyState === WebSocket.OPEN,
-          url: XOPC_EXT_WS_URL
-        });
-        break;
-      case "popup/connect":
-        connect();
-        sendResponse({ ok: true });
-        break;
-      case "popup/disconnect":
-        disconnect();
-        sendResponse({ ok: true });
-        break;
-      case "content/heartbeat":
-        sendResponse({ ok: true });
-        break;
-      default:
-        sendResponse({ ok: false, error: `Unknown message: ${message.type}` });
-    }
-    return true;
-  }
-);
-chrome.runtime.onInstalled.addListener(() => {
-  log.info("Extension installed/updated");
-  connect();
-});
-chrome.runtime.onStartup.addListener(() => {
-  log.info("Browser started");
-  connect();
+chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+  if (message.type === "popup/get-status") sendResponse({ connected: ws?.readyState === WebSocket.OPEN, url: XOPC_EXT_WS_URL });
+  else if (message.type === "popup/connect") {
+    connect();
+    sendResponse({ ok: true });
+  } else if (message.type === "popup/disconnect") {
+    disconnect();
+    sendResponse({ ok: true });
+  } else if (message.type === "content/heartbeat") sendResponse({ ok: true });
+  else sendResponse({ ok: false, error: `Unknown message: ${message.type}` });
+  return true;
 });
+chrome.runtime.onInstalled.addListener(connect);
+chrome.runtime.onStartup.addListener(connect);
 connect();
 self.addEventListener("beforeunload", () => {
   disconnect();
   void closeAllSessions();
 });
-log.info("xopc Browser Bridge service worker loaded");