@youtyan/browser-pilot 0.7.1

package/extension/background.js

@@ -0,0 +1,2332 @@
+// apps/extension/src/background/tab-utils.ts
+function waitForTabLoad(tabId, timeoutMs = 15000) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      chrome.tabs.onUpdated.removeListener(listener);
+      reject(new Error("Page load timeout"));
+    }, timeoutMs);
+    function listener(updatedTabId, changeInfo) {
+      if (updatedTabId === tabId && changeInfo.status === "complete") {
+        clearTimeout(timeout);
+        chrome.tabs.onUpdated.removeListener(listener);
+        setTimeout(resolve, 500);
+      }
+    }
+    chrome.tabs.onUpdated.addListener(listener);
+  });
+}
+function reinjectContentScripts() {
+  chrome.tabs.query({}, (tabs) => {
+    for (const tab of tabs) {
+      if (tab.id && tab.url && (tab.url.startsWith("http://") || tab.url.startsWith("https://"))) {
+        chrome.scripting.executeScript({
+          target: { tabId: tab.id },
+          files: ["content.js"]
+        }).catch(() => {});
+      }
+    }
+  });
+}
+
+// apps/extension/src/background/download.ts
+function waitForDownload(timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let downloadId = null;
+    const timeout = setTimeout(() => {
+      chrome.downloads.onCreated.removeListener(onCreated);
+      chrome.downloads.onChanged.removeListener(onChanged);
+      reject(new Error(`Download timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+    function cleanup() {
+      clearTimeout(timeout);
+      chrome.downloads.onCreated.removeListener(onCreated);
+      chrome.downloads.onChanged.removeListener(onChanged);
+    }
+    function onCreated(item) {
+      downloadId = item.id;
+    }
+    function onChanged(delta) {
+      if (downloadId === null && delta.state) {
+        downloadId = delta.id;
+      }
+      if (delta.id !== downloadId)
+        return;
+      if (delta.state?.current === "complete") {
+        cleanup();
+        chrome.downloads.search({ id: downloadId }, (results) => {
+          const item = results[0];
+          resolve({
+            data: {
+              completed: true,
+              id: item?.id,
+              filename: item?.filename,
+              fileSize: item?.fileSize,
+              mime: item?.mime,
+              url: item?.url
+            }
+          });
+        });
+      } else if (delta.state?.current === "interrupted") {
+        cleanup();
+        chrome.downloads.search({ id: downloadId }, (results) => {
+          const item = results[0];
+          reject(new Error(`Download interrupted: ${item?.error ?? "unknown"}`));
+        });
+      }
+    }
+    chrome.downloads.onCreated.addListener(onCreated);
+    chrome.downloads.onChanged.addListener(onChanged);
+  });
+}
+
+// apps/extension/src/background/event-buffer.ts
+class EventBuffer {
+  maxSize;
+  buffer = [];
+  dropped = 0;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  push(item) {
+    if (this.buffer.length >= this.maxSize) {
+      this.buffer.shift();
+      this.dropped++;
+    }
+    this.buffer.push(item);
+  }
+  drain(filter) {
+    const dropped = this.dropped;
+    const items = filter ? this.buffer.filter(filter) : [...this.buffer];
+    this.buffer = [];
+    this.dropped = 0;
+    return { items, dropped };
+  }
+  peek(filter) {
+    return filter ? this.buffer.filter(filter) : [...this.buffer];
+  }
+  peekWithDropped(filter) {
+    const items = filter ? this.buffer.filter(filter) : [...this.buffer];
+    return { items, dropped: this.dropped };
+  }
+  clear() {
+    this.buffer = [];
+    this.dropped = 0;
+  }
+}
+
+// apps/extension/src/background/debugger.ts
+var screencastFrameHandler = null;
+function setScreencastFrameHandler(handler) {
+  screencastFrameHandler = handler;
+}
+var BUFFER_MAX = 1000;
+var PENDING_REQUEST_TTL_MS = 60000;
+var DETAIL_RETAIN_MAX = 500;
+var EXTRA_INFO_MAX = 200;
+var NAVIGATION_HISTORY_MAX = 3;
+var tabStates = new Map;
+var navigationCounter = 0;
+function getState(tabId) {
+  return tabStates.get(tabId);
+}
+function createState(tabId) {
+  const state = {
+    consoleBuffer: new EventBuffer(BUFFER_MAX),
+    networkBuffer: new EventBuffer(BUFFER_MAX),
+    exceptionBuffer: new EventBuffer(BUFFER_MAX),
+    pendingRequests: new Map,
+    completedRequests: new Map,
+    pendingExtraInfo: new Map,
+    mainFrameId: null,
+    currentNavigation: null,
+    navigationHistory: [],
+    orphanCleanupTimer: null,
+    nextMsgId: 1,
+    scriptMetaCache: new Map,
+    staleSourceMapUrls: [],
+    traceState: null,
+    cssEnabled: false,
+    attachedAt: Date.now()
+  };
+  tabStates.set(tabId, state);
+  return state;
+}
+function rotateNavigation(state, tabId, url, type) {
+  if (state.currentNavigation) {
+    const snapshot = {
+      navigation: state.currentNavigation,
+      requests: state.networkBuffer.peek().map((r) => ({
+        url: r.url,
+        method: r.method,
+        status: r.status,
+        navigationId: r.navigationId
+      })),
+      consoleEntries: state.consoleBuffer.peek().map((m) => ({
+        msgId: m.msgId,
+        level: m.level,
+        text: m.text
+      }))
+    };
+    state.navigationHistory.push(snapshot);
+    if (state.navigationHistory.length > NAVIGATION_HISTORY_MAX)
+      state.navigationHistory.shift();
+  }
+  state.currentNavigation = {
+    navigationId: `nav-${tabId}-${++navigationCounter}`,
+    url,
+    timestamp: Date.now(),
+    type
+  };
+  if (type === "full") {
+    state.scriptMetaCache.clear();
+    state.staleSourceMapUrls = [];
+  }
+}
+function evictOldestExtraInfo(state) {
+  if (state.pendingExtraInfo.size > EXTRA_INFO_MAX) {
+    const firstKey = state.pendingExtraInfo.keys().next().value;
+    if (firstKey)
+      state.pendingExtraInfo.delete(firstKey);
+  }
+}
+function removeState(tabId) {
+  tabStates.delete(tabId);
+}
+function estimateBodySafe(encodedDataLength, responseHeaders) {
+  const MAX_INLINE_SIZE = 1048576;
+  const rawCL = responseHeaders?.["content-length"] ? parseInt(responseHeaders["content-length"], 10) : undefined;
+  const contentLength = rawCL != null && !Number.isNaN(rawCL) ? rawCL : undefined;
+  const encoding = responseHeaders?.["content-encoding"];
+  let estimatedSize = encodedDataLength;
+  if (encoding && encoding !== "identity") {
+    estimatedSize = contentLength ?? encodedDataLength * 10;
+  } else if (contentLength) {
+    estimatedSize = contentLength;
+  }
+  return { safe: estimatedSize <= MAX_INLINE_SIZE, estimatedSize };
+}
+async function freezeRequestDetail(tabId, req, encodedDataLength) {
+  const { safe } = estimateBodySafe(encodedDataLength, req.responseHeaders);
+  let requestBody = null;
+  let responseBody = null;
+  let base64Encoded = false;
+  let bodyTruncated = false;
+  if (req.postDataLength) {
+    try {
+      const result = await chrome.debugger.sendCommand({ tabId }, "Network.getRequestPostData", { requestId: req.requestId });
+      requestBody = result.postData ?? null;
+    } catch {}
+  }
+  if (safe) {
+    try {
+      const result = await chrome.debugger.sendCommand({ tabId }, "Network.getResponseBody", { requestId: req.requestId });
+      const body = result;
+      responseBody = body.body ?? null;
+      base64Encoded = body.base64Encoded ?? false;
+    } catch {
+      bodyTruncated = true;
+    }
+  } else {
+    bodyTruncated = true;
+  }
+  req.frozen = { requestBody, responseBody, base64Encoded, bodyTruncated };
+}
+async function attachDebugger(tabId) {
+  if (tabStates.has(tabId))
+    return;
+  await chrome.debugger.attach({ tabId }, "1.3");
+  createState(tabId);
+  try {
+    await chrome.debugger.sendCommand({ tabId }, "Runtime.enable");
+    await chrome.debugger.sendCommand({ tabId }, "Network.enable", {
+      maxPostDataSize: 65536,
+      maxTotalBufferSize: 10485760,
+      maxResourceBufferSize: 5242880
+    });
+    await chrome.debugger.sendCommand({ tabId }, "Performance.enable");
+    await chrome.debugger.sendCommand({ tabId }, "Page.enable");
+    await chrome.debugger.sendCommand({ tabId }, "Debugger.enable");
+    await chrome.debugger.sendCommand({ tabId }, "Debugger.setSkipAllPauses", { skip: true });
+    await chrome.debugger.sendCommand({ tabId }, "Accessibility.enable");
+    const state = tabStates.get(tabId);
+    const frameTreeResult = await chrome.debugger.sendCommand({ tabId }, "Page.getFrameTree");
+    const frameTree = frameTreeResult.frameTree;
+    state.mainFrameId = frameTree.frame.id;
+    state.currentNavigation = {
+      navigationId: `nav-${tabId}-${++navigationCounter}`,
+      url: frameTree.frame.url,
+      timestamp: Date.now(),
+      type: "full"
+    };
+    state.orphanCleanupTimer = setInterval(() => {
+      const cutoff = Date.now() - 30000;
+      for (const [id, info] of state.pendingExtraInfo) {
+        if (info.timestamp < cutoff)
+          state.pendingExtraInfo.delete(id);
+      }
+    }, 1e4);
+  } catch (e) {
+    try {
+      await chrome.debugger.detach({ tabId });
+    } catch {}
+    removeState(tabId);
+    throw e;
+  }
+}
+async function detachDebugger(tabId) {
+  if (!tabStates.has(tabId))
+    return;
+  const state = getState(tabId);
+  if (state?.orphanCleanupTimer) {
+    clearInterval(state.orphanCleanupTimer);
+  }
+  try {
+    await chrome.debugger.detach({ tabId });
+  } catch {}
+  removeState(tabId);
+}
+function onEvent(source, method, params) {
+  try {
+    const tabId = source.tabId;
+    if (tabId == null)
+      return;
+    const p = params;
+    if (method === "Page.screencastFrame" && p) {
+      if (screencastFrameHandler)
+        screencastFrameHandler(tabId, p);
+      return;
+    }
+    const state = getState(tabId);
+    if (!state)
+      return;
+    if (method === "Tracing.dataCollected" && p) {
+      if (state.traceState?.recording) {
+        const value = p.value;
+        if (Array.isArray(value)) {
+          state.traceState.events.push(...value);
+        }
+      }
+      return;
+    }
+    if (method === "Tracing.tracingComplete") {
+      if (state.traceState?.resolve) {
+        state.traceState.resolve(state.traceState.events);
+        state.traceState = null;
+      }
+      return;
+    }
+    if (method === "Page.frameNavigated" && p) {
+      const frame = p.frame;
+      if (frame && !frame.parentId) {
+        state.mainFrameId = frame.id;
+        rotateNavigation(state, tabId, frame.url, "full");
+      }
+      return;
+    }
+    if (method === "Page.navigatedWithinDocument" && p) {
+      const frameId = p.frameId;
+      const url = p.url;
+      if (frameId && url && frameId === state.mainFrameId) {
+        rotateNavigation(state, tabId, url, "same-document");
+      }
+      return;
+    }
+    if (method === "Debugger.scriptParsed" && p) {
+      const scriptUrl = p.url;
+      const scriptId = p.scriptId;
+      if (!scriptUrl)
+        return;
+      const existingForUrl = [...state.scriptMetaCache.values()].find((m) => m.url === scriptUrl && m.scriptId !== scriptId);
+      if (existingForUrl) {
+        state.scriptMetaCache.delete(existingForUrl.scriptId);
+        state.staleSourceMapUrls.push(scriptUrl);
+      }
+      state.scriptMetaCache.set(scriptId, {
+        scriptId,
+        url: scriptUrl,
+        sourceMapURL: p.sourceMapURL ?? null,
+        startLine: p.startLine ?? 0,
+        startColumn: p.startColumn ?? 0
+      });
+      return;
+    }
+    if (method === "Runtime.consoleAPICalled" && p) {
+      const rawArgs = p.args ?? [];
+      const text = rawArgs.map((a) => {
+        if (a.type === "object" && a.preview?.properties) {
+          const entries = a.preview.properties.map((prop) => `${prop.name}: ${prop.value}`).join(", ");
+          return `{${entries}}`;
+        }
+        return a.description ?? String(a.value ?? "");
+      }).join(" ");
+      const consoleArgs = rawArgs.map((a) => ({
+        type: a.type,
+        subtype: a.subtype,
+        value: a.value,
+        description: a.description,
+        objectId: a.objectId
+      }));
+      const rawStack = p.stackTrace?.callFrames;
+      state.consoleBuffer.push({
+        msgId: state.nextMsgId++,
+        level: p.type ?? "log",
+        text,
+        url: rawStack?.[0]?.url,
+        lineNumber: rawStack?.[0]?.lineNumber,
+        columnNumber: rawStack?.[0]?.columnNumber,
+        scriptId: rawStack?.[0]?.scriptId,
+        timestamp: Date.now(),
+        navigationId: state.currentNavigation?.navigationId,
+        args: consoleArgs,
+        stackTrace: rawStack
+      });
+    }
+    if (method === "Runtime.exceptionThrown" && p) {
+      const exDetails = p.exceptionDetails;
+      if (exDetails) {
+        const description = exDetails.exception?.description ?? exDetails.text ?? "Unknown exception";
+        state.exceptionBuffer.push({
+          exceptionId: exDetails.exceptionId ?? 0,
+          text: description,
+          timestamp: Date.now(),
+          navigationId: state.currentNavigation?.navigationId,
+          revoked: false,
+          stackTrace: exDetails.stackTrace?.callFrames
+        });
+      }
+    }
+    if (method === "Runtime.exceptionRevoked" && p) {
+      const exceptionId = p.exceptionId;
+      const reason = p.reason ?? undefined;
+      if (exceptionId != null) {
+        for (const ex of state.exceptionBuffer.peek()) {
+          if (ex.exceptionId === exceptionId) {
+            ex.revoked = true;
+            ex.revokeReason = reason;
+            break;
+          }
+        }
+      }
+    }
+    if (method === "Network.requestWillBeSent" && p) {
+      const request = p.request;
+      if (!request)
+        return;
+      const requestId = p.requestId;
+      const redirectResponse = p.redirectResponse;
+      const existingPending = state.pendingRequests.get(requestId);
+      let redirectHops;
+      if (redirectResponse && existingPending) {
+        const hop = {
+          url: existingPending.url,
+          method: existingPending.method,
+          status: redirectResponse.status,
+          startTime: existingPending.startTime,
+          endTime: Date.now()
+        };
+        redirectHops = [...existingPending.redirectHops ?? [], hop];
+      }
+      if (redirectResponse) {
+        state.pendingExtraInfo.delete(requestId);
+      }
+      const req = {
+        requestId,
+        url: request.url,
+        method: request.method,
+        type: p.type,
+        startTime: Date.now(),
+        navigationId: state.currentNavigation?.navigationId
+      };
+      if (redirectHops)
+        req.redirectHops = redirectHops;
+      const initiator = p.initiator;
+      if (initiator?.type) {
+        let iUrl = initiator.url;
+        let iLine = initiator.lineNumber;
+        if (!iUrl && initiator.stack?.callFrames?.[0]) {
+          const frame = initiator.stack.callFrames[0];
+          iUrl = frame.url || undefined;
+          iLine = frame.lineNumber;
+        }
+        req.initiator = {
+          type: initiator.type,
+          ...iUrl && { url: iUrl },
+          ...iLine != null && { lineNumber: iLine }
+        };
+      }
+      const reqData = request;
+      if (reqData.hasPostData) {
+        req.postDataLength = reqData.postDataLength ?? 1;
+      }
+      const headers = reqData.headers;
+      if (headers)
+        req.requestHeaders = headers;
+      const buffered = state.pendingExtraInfo.get(req.requestId);
+      if (buffered) {
+        if (buffered.requestHeaders)
+          req.requestHeaders = buffered.requestHeaders;
+        if (buffered.associatedCookies)
+          req.associatedCookies = buffered.associatedCookies;
+        if (buffered.responseHeaders)
+          req.responseHeaders = buffered.responseHeaders;
+        state.pendingExtraInfo.delete(req.requestId);
+      }
+      state.pendingRequests.set(req.requestId, req);
+    }
+    if (method === "Network.responseReceived" && p) {
+      const id = p.requestId;
+      const pending = state.pendingRequests.get(id);
+      if (pending) {
+        const response = p.response;
+        if (response) {
+          pending.status = response.status;
+          pending.statusText = response.statusText;
+          pending.mimeType = response.mimeType;
+        }
+        const timing = response.timing;
+        if (timing) {
+          pending.timing = {
+            dnsStart: timing.dnsStart ?? -1,
+            dnsEnd: timing.dnsEnd ?? -1,
+            connectStart: timing.connectStart ?? -1,
+            connectEnd: timing.connectEnd ?? -1,
+            sslStart: timing.sslStart ?? -1,
+            sslEnd: timing.sslEnd ?? -1,
+            sendStart: timing.sendStart ?? -1,
+            sendEnd: timing.sendEnd ?? -1,
+            receiveHeadersStart: timing.receiveHeadersStart ?? -1,
+            receiveHeadersEnd: timing.receiveHeadersEnd ?? -1
+          };
+        }
+        pending.type = pending.type ?? p.type;
+      }
+    }
+    if (method === "Network.loadingFinished" && p) {
+      const id = p.requestId;
+      const pending = state.pendingRequests.get(id);
+      if (pending) {
+        pending.endTime = Date.now();
+        pending.size = p.encodedDataLength ?? undefined;
+        freezeRequestDetail(tabId, pending, p.encodedDataLength ?? 0).catch(() => {});
+        state.networkBuffer.push(pending);
+        state.pendingRequests.delete(id);
+        state.completedRequests.set(id, pending);
+        if (state.completedRequests.size > DETAIL_RETAIN_MAX) {
+          const firstKey = state.completedRequests.keys().next().value;
+          if (firstKey)
+            state.completedRequests.delete(firstKey);
+        }
+      }
+    }
+    if (method === "Network.loadingFailed" && p) {
+      const id = p.requestId;
+      const pending = state.pendingRequests.get(id);
+      if (pending) {
+        pending.error = p.errorText ?? "Failed";
+        pending.endTime = Date.now();
+        state.networkBuffer.push(pending);
+        state.pendingRequests.delete(id);
+        state.completedRequests.set(id, pending);
+        if (state.completedRequests.size > DETAIL_RETAIN_MAX) {
+          const firstKey = state.completedRequests.keys().next().value;
+          if (firstKey)
+            state.completedRequests.delete(firstKey);
+        }
+      }
+    }
+    if (method.startsWith("Network.")) {
+      const now = Date.now();
+      for (const [id, req] of state.pendingRequests) {
+        if (now - req.startTime > PENDING_REQUEST_TTL_MS) {
+          req.error = "stale (no completion event)";
+          req.endTime = now;
+          state.networkBuffer.push(req);
+          state.pendingRequests.delete(id);
+          state.completedRequests.set(id, req);
+          if (state.completedRequests.size > DETAIL_RETAIN_MAX) {
+            const firstKey = state.completedRequests.keys().next().value;
+            if (firstKey)
+              state.completedRequests.delete(firstKey);
+          }
+        }
+      }
+    }
+    if (method === "Network.requestWillBeSentExtraInfo" && p) {
+      const id = p.requestId;
+      const headers = p.headers;
+      const cookies = p.associatedCookies;
+      const parsedCookies = cookies?.map((c) => ({
+        name: c.cookie.name,
+        value: c.cookie.value,
+        domain: c.cookie.domain,
+        path: c.cookie.path,
+        httpOnly: c.cookie.httpOnly,
+        secure: c.cookie.secure,
+        blocked: (c.blockedReasons?.length ?? 0) > 0,
+        blockedReasons: c.blockedReasons?.length ? c.blockedReasons : undefined
+      }));
+      const pending = state.pendingRequests.get(id);
+      if (pending) {
+        if (headers)
+          pending.requestHeaders = headers;
+        if (parsedCookies)
+          pending.associatedCookies = parsedCookies;
+      } else {
+        const existing = state.pendingExtraInfo.get(id) ?? { timestamp: Date.now() };
+        if (headers)
+          existing.requestHeaders = headers;
+        if (parsedCookies)
+          existing.associatedCookies = parsedCookies;
+        state.pendingExtraInfo.set(id, existing);
+        evictOldestExtraInfo(state);
+      }
+    }
+    if (method === "Network.responseReceivedExtraInfo" && p) {
+      const id = p.requestId;
+      const headers = p.headers;
+      const completed = state.completedRequests.get(id);
+      if (completed) {
+        if (headers && !completed.responseHeaders)
+          completed.responseHeaders = headers;
+      } else {
+        const pending = state.pendingRequests.get(id);
+        if (pending) {
+          if (headers)
+            pending.responseHeaders = headers;
+        } else {
+          const existing = state.pendingExtraInfo.get(id) ?? { timestamp: Date.now() };
+          if (headers)
+            existing.responseHeaders = headers;
+          state.pendingExtraInfo.set(id, existing);
+          evictOldestExtraInfo(state);
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[Debugger] Error processing CDP event:", method, e);
+  }
+}
+function initDebuggerListeners() {
+  if (typeof chrome === "undefined" || !chrome.debugger)
+    return;
+  chrome.debugger.onEvent.addListener(onEvent);
+  chrome.debugger.onDetach.addListener((source) => {
+    if (source.tabId != null) {
+      const state = getState(source.tabId);
+      if (state?.orphanCleanupTimer)
+        clearInterval(state.orphanCleanupTimer);
+      removeState(source.tabId);
+    }
+  });
+}
+function getConsoleMessages(tabId, filter) {
+  const state = getState(tabId);
+  if (!state)
+    return { items: [], dropped: 0 };
+  const predicate = filter ? (msg) => {
+    if (filter.level && msg.level !== filter.level)
+      return false;
+    if (filter.textPattern && !msg.text.includes(filter.textPattern))
+      return false;
+    return true;
+  } : undefined;
+  return state.consoleBuffer.peekWithDropped(predicate);
+}
+function getRuntimeExceptions(tabId) {
+  const state = getState(tabId);
+  if (!state)
+    return { items: [], dropped: 0 };
+  return state.exceptionBuffer.peekWithDropped();
+}
+function getNetworkCaptureStatus(tabId) {
+  const state = getState(tabId);
+  if (!state)
+    return { attached: false, pendingCount: 0, captureStartedAt: null };
+  return {
+    attached: true,
+    pendingCount: state.pendingRequests.size,
+    captureStartedAt: state.attachedAt
+  };
+}
+function getNetworkRequests(tabId, filter, options) {
+  const state = getState(tabId);
+  if (!state)
+    return { items: [], dropped: 0 };
+  const predicate = filter ? (req) => {
+    if (filter.urlPattern && !req.url.includes(filter.urlPattern))
+      return false;
+    if (filter.method && req.method !== filter.method.toUpperCase())
+      return false;
+    if (filter.statusCode != null && req.status !== filter.statusCode)
+      return false;
+    return true;
+  } : undefined;
+  const result = state.networkBuffer.peekWithDropped(predicate);
+  if (options?.includePending) {
+    const pendingItems = [...state.pendingRequests.values()];
+    const filtered = predicate ? pendingItems.filter(predicate) : pendingItems;
+    result.items = [...result.items, ...filtered].sort((a, b) => a.startTime - b.startTime);
+  }
+  return result;
+}
+async function getPerformanceMetrics(tabId) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const result = await chrome.debugger.sendCommand({ tabId }, "Performance.getMetrics");
+  const metrics = {};
+  for (const m of result.metrics) {
+    metrics[m.name] = m.value;
+  }
+  return metrics;
+}
+async function getAccessibilityTree(tabId) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const result = await chrome.debugger.sendCommand({ tabId }, "Accessibility.getFullAXTree");
+  return result;
+}
+async function getNetworkRequestDetail(tabId, requestId) {
+  const state = getState(tabId);
+  if (!state)
+    return { request: null, requestBody: null, responseBody: null, base64Encoded: false, bodyUnavailable: true };
+  const req = state.completedRequests.get(requestId) ?? state.pendingRequests.get(requestId) ?? null;
+  if (!req)
+    return { request: null, requestBody: null, responseBody: null, base64Encoded: false, bodyUnavailable: true };
+  if (req.frozen) {
+    return {
+      request: req,
+      requestBody: req.frozen.requestBody,
+      responseBody: req.frozen.responseBody,
+      base64Encoded: req.frozen.base64Encoded,
+      bodyUnavailable: req.frozen.bodyTruncated
+    };
+  }
+  let requestBody = null;
+  let responseBody = null;
+  let base64Encoded = false;
+  let bodyUnavailable = false;
+  if (req.postDataLength) {
+    try {
+      const result = await chrome.debugger.sendCommand({ tabId }, "Network.getRequestPostData", { requestId });
+      requestBody = result.postData ?? null;
+    } catch {}
+  }
+  try {
+    const result = await chrome.debugger.sendCommand({ tabId }, "Network.getResponseBody", { requestId });
+    const body = result;
+    responseBody = body.body ?? null;
+    base64Encoded = body.base64Encoded ?? false;
+  } catch {
+    bodyUnavailable = true;
+  }
+  return { request: req, requestBody, responseBody, base64Encoded, bodyUnavailable };
+}
+function clearNetworkBuffer(tabId) {
+  const state = getState(tabId);
+  if (!state)
+    return;
+  state.networkBuffer.clear();
+  state.completedRequests.clear();
+  state.pendingRequests.clear();
+  state.pendingExtraInfo.clear();
+}
+function clearExceptionBuffer(tabId) {
+  const state = getState(tabId);
+  if (!state)
+    return;
+  state.exceptionBuffer.clear();
+}
+function getScriptMetaCache(tabId) {
+  const state = getState(tabId);
+  if (!state)
+    return { scripts: [], staleSourceMapUrls: [], topFrameUrl: null };
+  const staleUrls = [...state.staleSourceMapUrls];
+  state.staleSourceMapUrls = [];
+  return {
+    scripts: Array.from(state.scriptMetaCache.values()),
+    staleSourceMapUrls: staleUrls,
+    topFrameUrl: state.currentNavigation?.url ?? null
+  };
+}
+function getSentCookies(tabId, requestId) {
+  const state = getState(tabId);
+  if (!state)
+    return [];
+  if (requestId) {
+    const req = state.completedRequests.get(requestId) ?? state.pendingRequests.get(requestId);
+    if (!req?.associatedCookies)
+      return [];
+    return req.associatedCookies.map((c) => ({ ...c, requestId: req.requestId, url: req.url }));
+  }
+  const seen = new Map;
+  const result = [];
+  for (const req of state.completedRequests.values()) {
+    if (!req.associatedCookies)
+      continue;
+    for (const c of req.associatedCookies) {
+      const key = `${c.name}|${c.domain}|${c.path}`;
+      if (!seen.has(key)) {
+        const entry = { ...c, requestId: req.requestId, url: req.url };
+        seen.set(key, entry);
+        result.push(entry);
+      }
+    }
+  }
+  return result;
+}
+async function findElementsByAccessibility(tabId, filters) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const result = await chrome.debugger.sendCommand({ tabId }, "Accessibility.getFullAXTree");
+  const nodes = result.nodes ?? [];
+  const results = [];
+  for (const node of nodes) {
+    if (node.ignored)
+      continue;
+    if (!node.backendDOMNodeId)
+      continue;
+    const role = node.role?.value ?? "";
+    const name = node.name?.value ?? "";
+    const desc = node.description?.value;
+    if (filters.role && role.toLowerCase() !== filters.role.toLowerCase())
+      continue;
+    if (filters.name && !name.toLowerCase().includes(filters.name.toLowerCase()))
+      continue;
+    if (filters.description && desc && !desc.toLowerCase().includes(filters.description.toLowerCase()))
+      continue;
+    if (!filters.role && ["generic", "none", "InlineTextBox", "StaticText"].includes(role))
+      continue;
+    const props = {};
+    if (node.properties) {
+      for (const p of node.properties) {
+        props[p.name] = p.value?.value;
+      }
+    }
+    results.push({
+      backendDOMNodeId: node.backendDOMNodeId,
+      role,
+      name,
+      description: desc,
+      value: node.value?.value,
+      properties: props
+    });
+  }
+  return results;
+}
+async function getPartialAccessibilityTree(tabId, backendNodeId) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const result = await chrome.debugger.sendCommand({ tabId }, "Accessibility.getPartialAXTree", {
+    backendNodeId,
+    fetchRelatives: true
+  });
+  return result.nodes ?? [];
+}
+async function queryAccessibilitySubtree(tabId, backendNodeId) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const result = await chrome.debugger.sendCommand({ tabId }, "Accessibility.queryAXTree", {
+    backendNodeId
+  });
+  return result.nodes ?? [];
+}
+async function resolveSelector(tabId, selector) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const docResult = await chrome.debugger.sendCommand({ tabId }, "DOM.getDocument", { depth: 0 });
+  const rootNodeId = docResult.root.nodeId;
+  const queryResult = await chrome.debugger.sendCommand({ tabId }, "DOM.querySelector", {
+    nodeId: rootNodeId,
+    selector
+  });
+  const nodeId = queryResult.nodeId;
+  if (!nodeId)
+    throw new Error(`No element matches selector: ${selector}`);
+  const descResult = await chrome.debugger.sendCommand({ tabId }, "DOM.describeNode", { nodeId });
+  const backendNodeId = descResult.node.backendNodeId;
+  return backendNodeId;
+}
+async function resolveSelectorToNodeId(tabId, selector) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const docResult = await chrome.debugger.sendCommand({ tabId }, "DOM.getDocument", { depth: 0 });
+  const rootNodeId = docResult.root.nodeId;
+  const queryResult = await chrome.debugger.sendCommand({ tabId }, "DOM.querySelector", {
+    nodeId: rootNodeId,
+    selector
+  });
+  const nodeId = queryResult.nodeId;
+  if (!nodeId)
+    throw new Error(`No element matches selector: ${selector}`);
+  return nodeId;
+}
+async function ensureCssDomain(tabId) {
+  const state = tabStates.get(tabId);
+  if (!state)
+    throw new Error("Debugger not attached to tab " + tabId);
+  if (state.cssEnabled)
+    return;
+  await chrome.debugger.sendCommand({ tabId }, "DOM.enable");
+  await chrome.debugger.sendCommand({ tabId }, "CSS.enable");
+  state.cssEnabled = true;
+}
+var DEFAULT_INSPECT_PROPERTIES = [
+  "display",
+  "position",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "width",
+  "height",
+  "min-width",
+  "min-height",
+  "max-width",
+  "max-height",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "box-sizing",
+  "overflow",
+  "overflow-x",
+  "overflow-y",
+  "transform",
+  "rotate",
+  "scale",
+  "translate",
+  "z-index",
+  "contain",
+  "visibility",
+  "opacity",
+  "filter",
+  "backdrop-filter",
+  "perspective",
+  "will-change",
+  "isolation",
+  "clip-path",
+  "mix-blend-mode",
+  "flex-grow",
+  "flex-shrink",
+  "flex-basis",
+  "align-self",
+  "justify-self",
+  "order",
+  "grid-column-start",
+  "grid-column-end",
+  "grid-row-start",
+  "grid-row-end",
+  "grid-template-columns",
+  "grid-template-rows",
+  "grid-auto-columns",
+  "grid-auto-rows",
+  "gap",
+  "row-gap",
+  "column-gap",
+  "vertical-align",
+  "line-height",
+  "white-space",
+  "pointer-events"
+];
+var ANCESTOR_EXTRA_PROPERTIES = [
+  "flex-direction",
+  "flex-wrap",
+  "align-items",
+  "justify-content",
+  "grid-template-columns",
+  "grid-template-rows",
+  "grid-auto-flow",
+  "gap",
+  "row-gap",
+  "column-gap"
+];
+function parseCdpAttributes(attrs) {
+  const result = {};
+  for (let i = 0;i < attrs.length; i += 2) {
+    result[attrs[i]] = attrs[i + 1] ?? "";
+  }
+  return result;
+}
+async function cssInspect(tabId, options) {
+  await attachDebugger(tabId);
+  await ensureCssDomain(tabId);
+  const props = new Set(options.properties ?? DEFAULT_INSPECT_PROPERTIES);
+  const ancestorDepth = options.ancestorDepth ?? 5;
+  let nodeId;
+  if (options.selector) {
+    nodeId = await resolveSelectorToNodeId(tabId, options.selector);
+  } else if (options.backendNodeId != null) {
+    const objectId = await resolveBackendNode(tabId, options.backendNodeId);
+    const reqResult = await chrome.debugger.sendCommand({ tabId }, "DOM.requestNode", {
+      objectId
+    });
+    nodeId = reqResult.nodeId;
+    if (!nodeId)
+      throw new Error("Could not resolve backendNodeId to nodeId");
+  } else {
+    throw new Error("selector or backendNodeId is required");
+  }
+  const descResult = await chrome.debugger.sendCommand({ tabId }, "DOM.describeNode", { nodeId });
+  const nodeDesc = descResult.node;
+  const attrs = parseCdpAttributes(nodeDesc.attributes ?? []);
+  const target = {
+    tagName: nodeDesc.localName,
+    id: attrs.id ?? "",
+    classList: (attrs.class ?? "").split(/\s+/).filter(Boolean),
+    nodeId
+  };
+  let boxModel = null;
+  try {
+    const boxResult = await chrome.debugger.sendCommand({ tabId }, "DOM.getBoxModel", { nodeId });
+    const model = boxResult.model;
+    boxModel = {
+      content: model.content,
+      padding: model.padding,
+      border: model.border,
+      margin: model.margin,
+      width: model.width,
+      height: model.height
+    };
+  } catch {}
+  const computedResult = await chrome.debugger.sendCommand({ tabId }, "CSS.getComputedStyleForNode", { nodeId });
+  const allComputed = computedResult.computedStyle;
+  const computedStyle = options.includeComputed ? allComputed : allComputed.filter((p) => props.has(p.name));
+  const matchedResult = await chrome.debugger.sendCommand({ tabId }, "CSS.getMatchedStylesForNode", { nodeId });
+  const matched = matchedResult;
+  const inlineStyle = (matched.inlineStyle?.cssProperties ?? []).filter((p) => p.value && !p.disabled).map((p) => ({ name: p.name, value: p.value, important: p.important ?? false }));
+  const matchedRules = [];
+  for (const entry of matched.matchedCSSRules ?? []) {
+    const rule = entry.rule;
+    if (rule.origin === "user-agent")
+      continue;
+    matchedRules.push({
+      selector: rule.selectorList.text,
+      origin: rule.origin,
+      styleSheetId: rule.styleSheetId ?? "",
+      sourceLine: rule.style.range?.startLine ?? 0,
+      declarations: rule.style.cssProperties.filter((p) => p.value && !p.disabled).map((p) => ({
+        name: p.name,
+        value: p.value,
+        important: p.important ?? false
+      }))
+    });
+  }
+  const ancestorChain = [];
+  const ancestorProps = new Set([...props, ...ANCESTOR_EXTRA_PROPERTIES]);
+  const resolveResult = await chrome.debugger.sendCommand({ tabId }, "DOM.resolveNode", { nodeId });
+  let currentObjectId = resolveResult.object?.objectId;
+  for (let level = 0;level < ancestorDepth && currentObjectId; level++) {
+    try {
+      const parentResult = await chrome.debugger.sendCommand({ tabId }, "Runtime.callFunctionOn", {
+        objectId: currentObjectId,
+        functionDeclaration: `function() { return this.parentElement; }`,
+        returnByValue: false
+      });
+      const parentObj = parentResult.result;
+      if (!parentObj.objectId || parentObj.subtype === "null")
+        break;
+      const reqNodeResult = await chrome.debugger.sendCommand({ tabId }, "DOM.requestNode", {
+        objectId: parentObj.objectId
+      });
+      const parentNodeId = reqNodeResult.nodeId;
+      if (!parentNodeId)
+        break;
+      const parentDesc = await chrome.debugger.sendCommand({ tabId }, "DOM.describeNode", { nodeId: parentNodeId });
+      const pNode = parentDesc.node;
+      if (!pNode.localName)
+        break;
+      const pAttrs = parseCdpAttributes(pNode.attributes ?? []);
+      const pComputed = await chrome.debugger.sendCommand({ tabId }, "CSS.getComputedStyleForNode", { nodeId: parentNodeId });
+      const pAllComputed = pComputed.computedStyle;
+      const pFiltered = pAllComputed.filter((p) => ancestorProps.has(p.name));
+      ancestorChain.push({
+        level,
+        tagName: pNode.localName,
+        id: pAttrs.id ?? "",
+        classList: (pAttrs.class ?? "").split(/\s+/).filter(Boolean),
+        computed: pFiltered
+      });
+      currentObjectId = parentObj.objectId;
+    } catch {
+      break;
+    }
+  }
+  const result = { target, boxModel, computedStyle, inlineStyle, matchedRules, ancestorChain };
+  if (options.includeMeasured) {
+    const targetObjectId = resolveResult.object?.objectId;
+    if (targetObjectId) {
+      const measureResult = await chrome.debugger.sendCommand({ tabId }, "Runtime.callFunctionOn", {
+        objectId: targetObjectId,
+        functionDeclaration: `function() {
+          const measure = (el) => {
+            const r = el.getBoundingClientRect();
+            return {
+              rect: { x: r.x, y: r.y, width: r.width, height: r.height },
+              scrollWidth: el.scrollWidth,
+              scrollHeight: el.scrollHeight,
+              clientWidth: el.clientWidth,
+              clientHeight: el.clientHeight,
+            };
+          };
+          const target = measure(this);
+          const ancestors = [];
+          let el = this.parentElement;
+          let level = 0;
+          const maxLevel = ${options.ancestorDepth ?? 8};
+          while (el && level < maxLevel) {
+            ancestors.push({ level, ...measure(el) });
+            el = el.parentElement;
+            level++;
+          }
+          return JSON.stringify({ target, ancestors });
+        }`,
+        returnByValue: true
+      });
+      const measured = JSON.parse(measureResult.result.value);
+      result.measuredLayout = measured;
+    }
+  }
+  return result;
+}
+async function resolveBackendNode(tabId, backendNodeId) {
+  const result = await chrome.debugger.sendCommand({ tabId }, "DOM.resolveNode", {
+    backendNodeId
+  });
+  const objectId = result.object.objectId;
+  if (!objectId)
+    throw new Error("Could not resolve backendNodeId to objectId");
+  return objectId;
+}
+async function getElementCenter(tabId, objectId) {
+  const result = await chrome.debugger.sendCommand({ tabId }, "Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() {
+      const rect = this.getBoundingClientRect();
+      return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+    }`,
+    returnByValue: true
+  });
+  const pos = result.result.value;
+  return pos;
+}
+var NAV_DETECT_INTERVAL = 50;
+var NAV_DETECT_TIMEOUT = 1500;
+var SPA_SETTLE_MS = 200;
+var SCROLL_SETTLE_MS = 50;
+async function waitForNavigationChange(tabId, beforeNavId, beforeUrl, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, NAV_DETECT_INTERVAL));
+    const state = getState(tabId);
+    if (!state)
+      break;
+    const cur = state.currentNavigation;
+    if (!cur)
+      continue;
+    if (cur.navigationId !== beforeNavId || cur.url !== beforeUrl) {
+      return { navigated: true, navigationType: cur.type, url: cur.url };
+    }
+  }
+  return { navigated: false, navigationType: "none" };
+}
+async function waitForTabLoadSafe(tabId, timeoutMs) {
+  try {
+    const tab = await chrome.tabs.get(tabId);
+    if (tab.status === "complete") {
+      await new Promise((r) => setTimeout(r, 500));
+      return;
+    }
+  } catch {
+    return;
+  }
+  await waitForTabLoad(tabId, timeoutMs);
+}
+function captureNavigationState(tabId) {
+  const state = getState(tabId);
+  return {
+    navigationId: state?.currentNavigation?.navigationId,
+    url: state?.currentNavigation?.url
+  };
+}
+async function waitForPostDispatchNavigation(tabId, before) {
+  let navResult = await waitForNavigationChange(tabId, before.navigationId, before.url, NAV_DETECT_TIMEOUT);
+  if (!navResult.navigated) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      if (before.url && tab.url !== before.url) {
+        navResult = await waitForNavigationChange(tabId, before.navigationId, before.url, NAV_DETECT_TIMEOUT);
+        if (!navResult.navigated) {
+          navResult = { navigated: true, navigationType: "full", url: tab.url };
+        }
+      }
+    } catch {}
+  }
+  if (navResult.navigated && navResult.navigationType === "full") {
+    try {
+      await waitForTabLoadSafe(tabId, 1e4);
+    } catch {}
+  } else if (navResult.navigated && navResult.navigationType === "same-document") {
+    await new Promise((r) => setTimeout(r, SPA_SETTLE_MS));
+  }
+  let title;
+  if (navResult.navigated) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      title = tab.title;
+    } catch {}
+  }
+  return {
+    navigated: navResult.navigated,
+    navigationType: navResult.navigationType,
+    url: navResult.url,
+    title
+  };
+}
+async function clickByBackendNodeId(tabId, backendNodeId, options) {
+  const state = getState(tabId);
+  if (!state)
+    throw new Error("Debugger not attached to tab " + tabId);
+  const objectId = await resolveBackendNode(tabId, backendNodeId);
+  await chrome.debugger.sendCommand({ tabId }, "Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() { this.scrollIntoView({ block: "center", inline: "center", behavior: "instant" }); }`,
+    returnByValue: true
+  });
+  await new Promise((r) => setTimeout(r, SCROLL_SETTLE_MS));
+  const { x, y } = await getElementCenter(tabId, objectId);
+  const beforeNavId = state.currentNavigation?.navigationId;
+  const beforeUrl = state.currentNavigation?.url;
+  await chrome.debugger.sendCommand({ tabId }, "Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x,
+    y
+  });
+  await chrome.debugger.sendCommand({ tabId }, "Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x,
+    y,
+    button: "left",
+    clickCount: 1
+  });
+  await chrome.debugger.sendCommand({ tabId }, "Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x,
+    y,
+    button: "left",
+    clickCount: 1
+  });
+  if (!options?.waitForNavigation) {
+    return { clicked: true, navigated: false, navigationType: "none" };
+  }
+  let navResult = await waitForNavigationChange(tabId, beforeNavId, beforeUrl, NAV_DETECT_TIMEOUT);
+  if (!navResult.navigated) {
+    let urlAlreadyChanged = false;
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      urlAlreadyChanged = !!beforeUrl && tab.url !== beforeUrl;
+    } catch {}
+    if (!urlAlreadyChanged) {
+      try {
+        await chrome.debugger.sendCommand({ tabId }, "Runtime.callFunctionOn", {
+          objectId,
+          functionDeclaration: `function() { this.click(); }`,
+          returnByValue: true
+        });
+        navResult = await waitForNavigationChange(tabId, beforeNavId, beforeUrl, NAV_DETECT_TIMEOUT);
+      } catch {}
+    } else {
+      navResult = await waitForNavigationChange(tabId, beforeNavId, beforeUrl, NAV_DETECT_TIMEOUT);
+    }
+  }
+  if (navResult.navigated && navResult.navigationType === "full") {
+    try {
+      await waitForTabLoadSafe(tabId, 1e4);
+    } catch {}
+  } else if (navResult.navigated && navResult.navigationType === "same-document") {
+    await new Promise((r) => setTimeout(r, SPA_SETTLE_MS));
+  }
+  const finalState = getState(tabId);
+  const finalUrl = navResult.url ?? finalState?.currentNavigation?.url;
+  let finalTitle;
+  if (navResult.navigated) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      finalTitle = tab.title;
+    } catch {}
+  }
+  return {
+    clicked: true,
+    navigated: navResult.navigated,
+    navigationType: navResult.navigationType,
+    url: finalUrl,
+    title: finalTitle
+  };
+}
+async function verifyValueByObjectId(tabId, objectId, expectedValue, info) {
+  const readResult = await chrome.debugger.sendCommand({ tabId }, "Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() {
+      if (this.isContentEditable) return this.innerText.replace(/\\n{2,}/g, "\\n").trim();
+      return this.value ?? "";
+    }`,
+    returnByValue: true
+  });
+  const actualValue = String(readResult.result.value ?? "");
+  const normalizedExpected = info.contentEditable ? expectedValue.trim() : expectedValue;
+  const verified = actualValue === normalizedExpected;
+  return {
+    set: true,
+    verified,
+    verifyExpected: normalizedExpected.slice(0, 200),
+    verifyActual: actualValue.slice(0, 200)
+  };
+}
+async function setValueByBackendNodeId(tabId, backendNodeId, value, verify) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const objectId = await resolveBackendNode(tabId, backendNodeId);
+  const typeResult = await chrome.debugger.sendCommand({ tabId }, "Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() { return { tagName: this.tagName?.toLowerCase(), type: this.type?.toLowerCase(), contentEditable: this.isContentEditable }; }`,
+    returnByValue: true
+  });
+  const info = typeResult.result.value;
+  if (info.tagName === "select") {
+    await chrome.debugger.sendCommand({ tabId }, "Runtime.callFunctionOn", {
+      objectId,
+      functionDeclaration: `function(v) {
+        this.value = v;
+        this.dispatchEvent(new Event('input', { bubbles: true }));
+        this.dispatchEvent(new Event('change', { bubbles: true }));
+      }`,
+      arguments: [{ value }]
+    });
+    if (verify) {
+      return verifyValueByObjectId(tabId, objectId, value, info);
+    }
+    return { set: true };
+  }
+  if (info.tagName === "input" && info.type === "file") {
+    await chrome.debugger.sendCommand({ tabId }, "DOM.setFileInputFiles", {
+      backendNodeId,
+      files: [value]
+    });
+    if (verify) {
+      return { set: true, verified: false, verifyExpected: value.slice(0, 200), verifyActual: "(file input: verification not supported)" };
+    }
+    return { set: true };
+  }
+  const { x, y } = await getElementCenter(tabId, objectId);
+  await chrome.debugger.sendCommand({ tabId }, "Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x,
+    y,
+    button: "left",
+    clickCount: 1
+  });
+  await chrome.debugger.sendCommand({ tabId }, "Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x,
+    y,
+    button: "left",
+    clickCount: 1
+  });
+  await chrome.debugger.sendCommand({ tabId }, "Input.dispatchKeyEvent", {
+    type: "keyDown",
+    key: "a",
+    code: "KeyA",
+    commands: ["selectAll"]
+  });
+  await chrome.debugger.sendCommand({ tabId }, "Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: "a",
+    code: "KeyA"
+  });
+  await chrome.debugger.sendCommand({ tabId }, "Input.insertText", { text: value });
+  if (verify) {
+    return verifyValueByObjectId(tabId, objectId, value, info);
+  }
+  return { set: true };
+}
+async function getAttributesByBackendNodeId(tabId, backendNodeId) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const result = await chrome.debugger.sendCommand({ tabId }, "DOM.describeNode", {
+    backendNodeId
+  });
+  const node = result.node;
+  const attrs = {};
+  if (node.attributes) {
+    for (let i = 0;i < node.attributes.length; i += 2) {
+      attrs[node.attributes[i]] = node.attributes[i + 1] ?? "";
+    }
+  }
+  return attrs;
+}
+async function getDetachedDomNodes(tabId) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  try {
+    const result = await chrome.debugger.sendCommand({ tabId }, "DOM.getDetachedDomNodes");
+    const detachedNodes = result.detachedNodes ?? [];
+    return detachedNodes.map((entry) => ({
+      nodeName: entry.treeNode?.nodeName ?? "UNKNOWN",
+      backendNodeId: entry.treeNode?.backendNodeId ?? 0,
+      retainedNodeCount: entry.retainedNodeIds?.length ?? 0
+    }));
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("wasn't found") || msg.includes("not found") || msg.includes("not supported")) {
+      return null;
+    }
+    throw new Error(`Failed to get detached DOM nodes: ${msg}`);
+  }
+}
+async function getEventListenersForNode(tabId, backendNodeId) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  let objectId;
+  try {
+    const resolveResult = await chrome.debugger.sendCommand({ tabId }, "DOM.resolveNode", { backendNodeId });
+    objectId = resolveResult?.object?.objectId;
+    if (!objectId)
+      return { supported: true, listeners: null };
+    const listenersResult = await chrome.debugger.sendCommand({ tabId }, "DOMDebugger.getEventListeners", { objectId });
+    return {
+      supported: true,
+      listeners: (listenersResult?.listeners ?? []).map((l) => ({
+        type: l.type ?? "unknown",
+        scriptId: l.scriptId ?? "0",
+        lineNumber: l.lineNumber ?? 0
+      }))
+    };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("wasn't found") || msg.includes("not found") || msg.includes("not supported")) {
+      return { supported: false, listeners: null };
+    }
+    return { supported: true, listeners: null };
+  } finally {
+    if (objectId) {
+      try {
+        await chrome.debugger.sendCommand({ tabId }, "Runtime.releaseObject", { objectId });
+      } catch {}
+    }
+  }
+}
+var MAX_EXPAND_DEPTH = 3;
+var MAX_PROPERTIES_PER_OBJECT = 20;
+async function startTrace(tabId, reload) {
+  if (!tabStates.has(tabId))
+    throw new Error("Debugger not attached to tab " + tabId);
+  const state = getState(tabId);
+  if (state.traceState?.recording)
+    throw new Error("Trace already recording");
+  state.traceState = { recording: true, events: [], resolve: null };
+  await chrome.debugger.sendCommand({ tabId }, "Tracing.start", {
+    categories: "-*,devtools.timeline,v8.execute,disabled-by-default-devtools.timeline,disabled-by-default-devtools.timeline.frame,toplevel,blink.console,blink.user_timing,latencyInfo,disabled-by-default-v8.cpu_profiler",
+    options: "sampling-frequency=10000"
+  });
+  if (reload) {
+    await chrome.debugger.sendCommand({ tabId }, "Page.reload");
+  }
+  return { started: true };
+}
+function stopTrace(tabId) {
+  const state = getState(tabId);
+  if (!state?.traceState?.recording)
+    throw new Error("No trace recording");
+  return new Promise((resolve) => {
+    state.traceState.resolve = resolve;
+    chrome.debugger.sendCommand({ tabId }, "Tracing.end");
+  });
+}
+async function expandProperties(tabId, objectId, depth) {
+  const result = await chrome.debugger.sendCommand({ tabId }, "Runtime.getProperties", {
+    objectId,
+    ownProperties: true,
+    generatePreview: true
+  });
+  const allProps = result.result;
+  const rawProps = allProps.length > MAX_PROPERTIES_PER_OBJECT ? allProps.slice(0, MAX_PROPERTIES_PER_OBJECT) : allProps;
+  const properties = [];
+  for (const p of rawProps) {
+    const prop = {
+      name: p.name,
+      value: p.value?.description ?? String(p.value?.value ?? ""),
+      type: p.value?.type ?? "unknown"
+    };
+    if (p.value?.objectId && p.value.type === "object" && depth < MAX_EXPAND_DEPTH) {
+      try {
+        prop.properties = await expandProperties(tabId, p.value.objectId, depth + 1);
+      } catch {
+        prop.value = "(object expired)";
+      }
+    }
+    properties.push(prop);
+  }
+  if (allProps.length > MAX_PROPERTIES_PER_OBJECT) {
+    properties.push({ name: "...", value: `(${allProps.length - MAX_PROPERTIES_PER_OBJECT} more)`, type: "truncated" });
+  }
+  return properties;
+}
+async function getConsoleMessageDetail(tabId, msgId) {
+  const state = getState(tabId);
+  if (!state)
+    return null;
+  const items = state.consoleBuffer.peek();
+  const msg = items.find((m) => m.msgId === msgId);
+  if (!msg)
+    return null;
+  const expandedArgs = [];
+  for (const arg of msg.args) {
+    if (arg.objectId) {
+      try {
+        const properties = await expandProperties(tabId, arg.objectId, 1);
+        expandedArgs.push({
+          type: arg.type,
+          description: arg.description,
+          properties
+        });
+      } catch {
+        expandedArgs.push({ type: arg.type, description: arg.description, value: "(object expired)" });
+      }
+    } else {
+      expandedArgs.push({ type: arg.type, value: arg.value, description: arg.description });
+    }
+  }
+  return {
+    msgId: msg.msgId,
+    level: msg.level,
+    text: msg.text,
+    expandedArgs,
+    stackTrace: msg.stackTrace
+  };
+}
+
+// apps/extension/src/background/recording.ts
+var activeScreencast = null;
+var sendFrameFn = null;
+function setSendFrameCallback(fn) {
+  sendFrameFn = fn;
+}
+function getActiveScreencast() {
+  return activeScreencast;
+}
+async function startRecording(tabId, sessionId, fps, quality, maxDurationSec) {
+  if (activeScreencast) {
+    return activeScreencast;
+  }
+  await attachDebugger(tabId);
+  await chrome.debugger.sendCommand({ tabId }, "Page.enable");
+  await chrome.debugger.sendCommand({ tabId }, "Page.startScreencast", {
+    format: "jpeg",
+    quality,
+    maxWidth: 1280,
+    maxHeight: 720,
+    everyNthFrame: Math.max(1, Math.round(60 / fps))
+  });
+  activeScreencast = {
+    tabId,
+    sessionId,
+    startedAt: Date.now(),
+    frameCount: 0,
+    fps,
+    quality,
+    maxDurationSec,
+    autoStopTimer: setTimeout(() => {
+      console.log("[Recording] Auto-stop: max duration reached");
+      stopRecording().catch(console.error);
+    }, maxDurationSec * 1000)
+  };
+  return activeScreencast;
+}
+async function stopRecording() {
+  if (!activeScreencast)
+    return null;
+  const { tabId, sessionId, frameCount, startedAt, autoStopTimer } = activeScreencast;
+  if (autoStopTimer)
+    clearTimeout(autoStopTimer);
+  activeScreencast = null;
+  try {
+    await chrome.debugger.sendCommand({ tabId }, "Page.stopScreencast");
+  } catch (e) {
+    console.warn("[Recording] Failed to stop screencast:", e);
+  }
+  return {
+    sessionId,
+    frameCount,
+    durationSec: Math.round((Date.now() - startedAt) / 1000)
+  };
+}
+function handleScreencastFrame(tabId, params) {
+  if (!activeScreencast || activeScreencast.tabId !== tabId)
+    return;
+  const frameSessionId = params.sessionId;
+  chrome.debugger.sendCommand({ tabId }, "Page.screencastFrameAck", { sessionId: frameSessionId }).catch(() => {});
+  activeScreencast.frameCount++;
+  if (sendFrameFn) {
+    const metadata = params.metadata;
+    sendFrameFn({
+      type: "frame",
+      sessionId: activeScreencast.sessionId,
+      index: activeScreencast.frameCount,
+      data: params.data,
+      timestamp: metadata?.timestamp ?? Date.now() / 1000
+    });
+  }
+}
+function onTabRemoved(tabId) {
+  if (activeScreencast?.tabId === tabId) {
+    console.log("[Recording] Tab closed, stopping recording");
+    if (activeScreencast.autoStopTimer)
+      clearTimeout(activeScreencast.autoStopTimer);
+    activeScreencast = null;
+  }
+}
+function onWsDisconnect() {
+  if (activeScreencast) {
+    console.log("[Recording] WebSocket disconnected, stopping recording");
+    stopRecording().catch(console.error);
+  }
+}
+
+// apps/extension/src/background/handle-request.ts
+var captureQueue = Promise.resolve();
+var lastCaptureTime = 0;
+function throttledCaptureVisibleTab(windowId, options) {
+  const result = captureQueue.then(async () => {
+    const now = Date.now();
+    const elapsed = now - lastCaptureTime;
+    const minInterval = 600;
+    if (elapsed < minInterval) {
+      await new Promise((r) => setTimeout(r, minInterval - elapsed));
+    }
+    lastCaptureTime = Date.now();
+    return chrome.tabs.captureVisibleTab(windowId, options);
+  });
+  captureQueue = result.then(() => {}, () => {});
+  return result;
+}
+async function handleRequest(req) {
+  if (req.action === "list_tabs") {
+    const tabs = await chrome.tabs.query({});
+    return {
+      data: tabs.filter((t) => t.url && (t.url.startsWith("http://") || t.url.startsWith("https://"))).map((t) => ({ id: t.id, url: t.url ?? "", title: t.title ?? "" }))
+    };
+  }
+  if (req.action === "create_tab") {
+    const url = req.params?.url;
+    if (!url)
+      throw new Error("url is required");
+    if (!/^https?:\/\//i.test(url))
+      throw new Error("Only http/https URLs allowed");
+    const tab = await chrome.tabs.create({ url, active: false });
+    if (!tab.id)
+      throw new Error("Failed to get tab ID");
+    await waitForTabLoad(tab.id);
+    const updated = await chrome.tabs.get(tab.id);
+    return {
+      data: { id: tab.id, url: updated.url ?? url, title: updated.title ?? "" }
+    };
+  }
+  if (req.action === "close_tab") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await chrome.tabs.remove(tabId2);
+    return { data: { closed: true, tabId: tabId2 } };
+  }
+  if (req.action === "attach_debugger") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await attachDebugger(tabId2);
+    return { data: { attached: true, tabId: tabId2 } };
+  }
+  if (req.action === "detach_debugger") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await detachDebugger(tabId2);
+    return { data: { detached: true, tabId: tabId2 } };
+  }
+  if (req.action === "dispatch_mouse_event") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const events = req.params?.events;
+    if (!events || events.length === 0)
+      throw new Error("events array is required");
+    const delayMs = req.params?.delayMs ?? 0;
+    const waitForNavigation = req.params?.waitForNavigation === true;
+    await attachDebugger(tabId2);
+    const navBefore = waitForNavigation ? captureNavigationState(tabId2) : undefined;
+    const tab = await chrome.tabs.get(tabId2);
+    await chrome.tabs.update(tabId2, { active: true });
+    await chrome.windows.update(tab.windowId, { focused: true });
+    for (let i = 0;i < events.length; i++) {
+      await chrome.debugger.sendCommand({ tabId: tabId2 }, "Input.dispatchMouseEvent", events[i]);
+      if (delayMs > 0 && i < events.length - 1) {
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+    }
+    if (!waitForNavigation || !navBefore) {
+      return { data: { dispatched: true, count: events.length } };
+    }
+    const navResult = await waitForPostDispatchNavigation(tabId2, navBefore);
+    return {
+      data: {
+        dispatched: true,
+        count: events.length,
+        navigated: navResult.navigated,
+        navigationType: navResult.navigationType,
+        url: navResult.url,
+        title: navResult.title
+      }
+    };
+  }
+  if (req.action === "get_console_messages") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const filter = {
+      level: req.params?.level,
+      textPattern: req.params?.textPattern
+    };
+    const result = getConsoleMessages(tabId2, filter);
+    return { data: { messages: result.items, total: result.items.length, dropped: result.dropped } };
+  }
+  if (req.action === "get_runtime_exceptions") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const result = getRuntimeExceptions(tabId2);
+    return { data: { exceptions: result.items, total: result.items.length, dropped: result.dropped } };
+  }
+  if (req.action === "get_console_message_detail") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const msgId = req.params?.msgId;
+    if (msgId == null)
+      throw new Error("msgId is required");
+    const detail = await getConsoleMessageDetail(tabId2, msgId);
+    return { data: detail };
+  }
+  if (req.action === "get_network_requests") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await attachDebugger(tabId2);
+    const filter = {
+      urlPattern: req.params?.urlPattern,
+      method: req.params?.method,
+      statusCode: req.params?.statusCode
+    };
+    const includePending = req.params?.includePending === true;
+    const result = getNetworkRequests(tabId2, filter, { includePending });
+    const captureStatus = getNetworkCaptureStatus(tabId2);
+    return { data: { requests: result.items, total: result.items.length, dropped: result.dropped, captureStatus } };
+  }
+  if (req.action === "clear_network") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    clearNetworkBuffer(tabId2);
+    return { data: { cleared: true } };
+  }
+  if (req.action === "clear_exceptions") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    clearExceptionBuffer(tabId2);
+    return { data: { cleared: true } };
+  }
+  if (req.action === "get_network_request_detail") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await attachDebugger(tabId2);
+    const requestId = req.params?.requestId;
+    if (!requestId)
+      throw new Error("requestId is required");
+    const detail = await getNetworkRequestDetail(tabId2, requestId);
+    return { data: detail };
+  }
+  if (req.action === "get_storage") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const type = req.params?.type;
+    if (!type || !["cookies", "localStorage", "sessionStorage"].includes(type)) {
+      throw new Error("type must be one of: cookies, localStorage, sessionStorage");
+    }
+    const namePattern = req.params?.namePattern;
+    await attachDebugger(tabId2);
+    if (type === "cookies") {
+      let urls = req.params?.urls;
+      if (!urls || urls.length === 0) {
+        const tab = await chrome.tabs.get(tabId2);
+        urls = tab.url ? [tab.url] : [];
+      }
+      const result2 = await chrome.debugger.sendCommand({ tabId: tabId2 }, "Network.getCookies", { urls });
+      let cookies = result2.cookies ?? [];
+      if (namePattern) {
+        cookies = cookies.filter((c) => c.name.includes(namePattern));
+      }
+      return { data: { cookies } };
+    }
+    const storageType = type === "sessionStorage" ? "sessionStorage" : "localStorage";
+    const expression = `(() => {
+      const s = ${storageType};
+      const entries = {};
+      for (let i = 0; i < s.length; i++) {
+        const key = s.key(i);
+        if (key !== null) entries[key] = s.getItem(key) ?? "";
+      }
+      return { entries, count: s.length };
+    })()`;
+    const evalResult = await chrome.debugger.sendCommand({ tabId: tabId2 }, "Runtime.evaluate", { expression, returnByValue: true, awaitPromise: false });
+    const result = evalResult.result?.value;
+    if (!result)
+      throw new Error(`Failed to read ${storageType}`);
+    if (namePattern) {
+      const filtered = {};
+      let count = 0;
+      for (const [k, v] of Object.entries(result.entries)) {
+        if (k.includes(namePattern)) {
+          filtered[k] = v;
+          count++;
+        }
+      }
+      return { data: { entries: filtered, count } };
+    }
+    return { data: result };
+  }
+  if (req.action === "get_sent_cookies") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const requestId = req.params?.requestId;
+    return { data: { cookies: getSentCookies(tabId2, requestId) } };
+  }
+  if (req.action === "set_cookie") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await attachDebugger(tabId2);
+    const cookieParams = {};
+    for (const key of ["name", "value", "url", "domain", "path", "sameSite"]) {
+      if (req.params?.[key] != null)
+        cookieParams[key] = req.params[key];
+    }
+    for (const key of ["secure", "httpOnly"]) {
+      if (req.params?.[key] != null)
+        cookieParams[key] = req.params[key];
+    }
+    if (req.params?.expires != null)
+      cookieParams.expires = req.params.expires;
+    const result = await chrome.debugger.sendCommand({ tabId: tabId2 }, "Network.setCookie", cookieParams);
+    const success = result.success ?? false;
+    return { data: { success } };
+  }
+  if (req.action === "delete_cookie") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await attachDebugger(tabId2);
+    const deleteParams = {
+      name: req.params?.name
+    };
+    if (req.params?.url != null)
+      deleteParams.url = req.params.url;
+    if (req.params?.domain != null)
+      deleteParams.domain = req.params.domain;
+    if (req.params?.path != null)
+      deleteParams.path = req.params.path;
+    await chrome.debugger.sendCommand({ tabId: tabId2 }, "Network.deleteCookies", deleteParams);
+    return { data: {} };
+  }
+  if (req.action === "get_performance_metrics") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const metrics = await getPerformanceMetrics(tabId2);
+    return { data: { metrics } };
+  }
+  if (req.action === "start_trace") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const reload = req.params?.reload;
+    const result = await startTrace(tabId2, reload);
+    return { data: result };
+  }
+  if (req.action === "stop_trace") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const events = await stopTrace(tabId2);
+    return { data: { events, total: events.length } };
+  }
+  if (req.action === "get_accessibility_tree") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const tree = await getAccessibilityTree(tabId2);
+    return { data: tree };
+  }
+  if (req.action === "get_partial_accessibility_tree") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    let backendNodeId = req.params?.backendNodeId;
+    const selector = req.params?.selector;
+    if (!backendNodeId && selector) {
+      await attachDebugger(tabId2);
+      backendNodeId = await resolveSelector(tabId2, selector);
+    }
+    if (backendNodeId == null)
+      throw new Error("backendNodeId or selector is required");
+    await attachDebugger(tabId2);
+    const nodes = await getPartialAccessibilityTree(tabId2, backendNodeId);
+    return { data: { nodes, total: nodes.length } };
+  }
+  if (req.action === "query_ax_tree") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    let backendNodeId = req.params?.backendNodeId;
+    const selector = req.params?.selector;
+    if (!backendNodeId && selector) {
+      await attachDebugger(tabId2);
+      backendNodeId = await resolveSelector(tabId2, selector);
+    }
+    if (backendNodeId == null)
+      throw new Error("backendNodeId or selector is required");
+    await attachDebugger(tabId2);
+    const nodes = await queryAccessibilitySubtree(tabId2, backendNodeId);
+    return { data: { nodes, total: nodes.length } };
+  }
+  if (req.action === "find_elements_accessibility") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await attachDebugger(tabId2);
+    const filters = {
+      role: req.params?.role,
+      name: req.params?.name,
+      description: req.params?.description
+    };
+    const results = await findElementsByAccessibility(tabId2, filters);
+    return { data: { elements: results, total: results.length } };
+  }
+  if (req.action === "click_by_backend_node_id") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const backendNodeId = req.params?.backendNodeId;
+    if (backendNodeId == null)
+      throw new Error("backendNodeId is required");
+    const waitForNavigation = req.params?.waitForNavigation === true;
+    await attachDebugger(tabId2);
+    const result = await clickByBackendNodeId(tabId2, backendNodeId, { waitForNavigation });
+    return { data: result };
+  }
+  if (req.action === "set_value_by_backend_node_id") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const backendNodeId = req.params?.backendNodeId;
+    if (backendNodeId == null)
+      throw new Error("backendNodeId is required");
+    const value = req.params?.value;
+    if (value == null)
+      throw new Error("value is required");
+    const verify = req.params?.verify === true;
+    await attachDebugger(tabId2);
+    const result = await setValueByBackendNodeId(tabId2, backendNodeId, value, verify || undefined);
+    return { data: result };
+  }
+  if (req.action === "get_attributes_by_backend_node_id") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const backendNodeId = req.params?.backendNodeId;
+    if (backendNodeId == null)
+      throw new Error("backendNodeId is required");
+    await attachDebugger(tabId2);
+    const result = await getAttributesByBackendNodeId(tabId2, backendNodeId);
+    return { data: { attributes: result } };
+  }
+  if (req.action === "get_script_meta_cache") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const result = getScriptMetaCache(tabId2);
+    return { data: result };
+  }
+  if (req.action === "get_detached_dom_nodes") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const result = await getDetachedDomNodes(tabId2);
+    return { data: { detachedNodes: result } };
+  }
+  if (req.action === "get_event_listeners_for_node") {
+    const tabId2 = req.params?.tabId;
+    const backendNodeId = req.params?.backendNodeId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    if (backendNodeId == null)
+      throw new Error("backendNodeId is required");
+    const result = await getEventListenersForNode(tabId2, backendNodeId);
+    return { data: result };
+  }
+  if (req.action === "css_inspect") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const selector = req.params?.selector;
+    const backendNodeId = req.params?.backendNodeId;
+    if (!selector && backendNodeId == null)
+      throw new Error("selector or backendNodeId is required");
+    const result = await cssInspect(tabId2, {
+      selector,
+      backendNodeId,
+      properties: req.params?.properties,
+      ancestorDepth: req.params?.ancestorDepth,
+      includeComputed: req.params?.includeComputed,
+      includeMeasured: req.params?.includeMeasured
+    });
+    return { data: result };
+  }
+  if (req.action === "evaluate") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const expression = req.params?.expression;
+    if (!expression)
+      throw new Error("expression is required");
+    await attachDebugger(tabId2);
+    try {
+      const result = await chrome.debugger.sendCommand({ tabId: tabId2 }, "Runtime.evaluate", {
+        expression,
+        returnByValue: true,
+        awaitPromise: true
+      });
+      const evalResult = result;
+      if (evalResult.exceptionDetails) {
+        const errMsg = evalResult.exceptionDetails.exception?.description ?? evalResult.exceptionDetails.text ?? "Evaluation failed";
+        return { data: { result: `Error: ${errMsg}` } };
+      }
+      const value = evalResult.result?.value ?? null;
+      return { data: { result: value } };
+    } catch (e) {
+      const msg2 = e instanceof Error ? e.message : String(e);
+      return { data: { result: `Error: ${msg2}` } };
+    }
+  }
+  if (req.action === "upload_file") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const filePath = req.params?.filePath;
+    if (!filePath)
+      throw new Error("filePath is required");
+    const selector = req.params?.selector ?? 'input[type="file"]';
+    await attachDebugger(tabId2);
+    try {
+      const doc = await chrome.debugger.sendCommand({ tabId: tabId2 }, "DOM.getDocument");
+      const queryResult = await chrome.debugger.sendCommand({ tabId: tabId2 }, "DOM.querySelector", { nodeId: doc.root.nodeId, selector });
+      if (!queryResult.nodeId) {
+        throw new Error(`File input not found: "${selector}"`);
+      }
+      await chrome.debugger.sendCommand({ tabId: tabId2 }, "DOM.setFileInputFiles", { files: [filePath], nodeId: queryResult.nodeId });
+      await chrome.debugger.sendCommand({ tabId: tabId2 }, "Runtime.evaluate", {
+        expression: `(() => {
+            const el = document.querySelector(${JSON.stringify(selector)});
+            if (el) {
+              el.dispatchEvent(new Event('input', { bubbles: true }));
+              el.dispatchEvent(new Event('change', { bubbles: true }));
+            }
+          })()`,
+        returnByValue: true
+      });
+      return { data: { uploaded: true, selector, filePath } };
+    } catch (e) {
+      const msg2 = e instanceof Error ? e.message : String(e);
+      throw new Error(`upload_file failed: ${msg2}`);
+    }
+  }
+  if (req.action === "start_recording") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const sessionId = req.params?.sessionId;
+    if (!sessionId)
+      throw new Error("sessionId is required");
+    const fps = req.params?.fps ?? 15;
+    const quality = req.params?.quality ?? 80;
+    const maxDurationSec = req.params?.maxDurationSec ?? 300;
+    await chrome.tabs.update(tabId2, { active: true });
+    const existing = getActiveScreencast();
+    const state = await startRecording(tabId2, sessionId, fps, quality, maxDurationSec);
+    return {
+      data: {
+        sessionId: state.sessionId,
+        tabId: state.tabId,
+        startedAt: state.startedAt,
+        alreadyRecording: existing !== null
+      }
+    };
+  }
+  if (req.action === "stop_recording") {
+    const result = await stopRecording();
+    if (!result)
+      throw new Error("No active recording");
+    return { data: result };
+  }
+  if (req.action === "recording_status") {
+    const state = getActiveScreencast();
+    if (!state) {
+      return { data: { recording: false } };
+    }
+    return {
+      data: {
+        recording: true,
+        sessionId: state.sessionId,
+        tabId: state.tabId,
+        frameCount: state.frameCount,
+        durationSec: Math.round((Date.now() - state.startedAt) / 1000)
+      }
+    };
+  }
+  if (req.action === "screenshot") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    const tab = await chrome.tabs.get(tabId2);
+    await chrome.tabs.update(tabId2, { active: true });
+    await chrome.windows.update(tab.windowId, { focused: true });
+    const quality = req.params?.quality ?? 70;
+    const format = req.params?.format === "png" ? "png" : "jpeg";
+    let screenshot2;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      try {
+        screenshot2 = await throttledCaptureVisibleTab(tab.windowId, {
+          format,
+          quality: format === "jpeg" ? quality : undefined
+        });
+        break;
+      } catch (e) {
+        if (attempt === 2)
+          throw new Error(`Failed to capture tab: ${e.message}`);
+      }
+    }
+    return { data: { captured: true }, screenshot: screenshot2 };
+  }
+  if (req.action === "print_to_pdf") {
+    const tabId2 = req.params?.tabId;
+    if (!tabId2)
+      throw new Error("tabId is required");
+    await attachDebugger(tabId2);
+    const cdpParams = {};
+    for (const key of [
+      "landscape",
+      "printBackground",
+      "scale",
+      "paperWidth",
+      "paperHeight",
+      "pageRanges",
+      "preferCSSPageSize"
+    ]) {
+      if (req.params?.[key] != null)
+        cdpParams[key] = req.params[key];
+    }
+    const result = await chrome.debugger.sendCommand({ tabId: tabId2 }, "Page.printToPDF", cdpParams);
+    return { data: { data: result?.data } };
+  }
+  if (req.action === "wait_for_download") {
+    const timeoutMs = req.params?.timeout ?? 30000;
+    return waitForDownload(timeoutMs);
+  }
+  const tabId = req.params?.tabId;
+  if (!tabId) {
+    throw new Error("tabId is required");
+  }
+  if (req.action === "go_back") {
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      func: () => window.history.back()
+    });
+    await waitForTabLoad(tabId);
+  } else if (req.action === "go_forward") {
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      func: () => window.history.forward()
+    });
+    await waitForTabLoad(tabId);
+  } else if (req.action === "reload") {
+    await chrome.tabs.reload(tabId);
+    await waitForTabLoad(tabId);
+  } else if (req.action === "get_page" && req.params?.url) {
+    const navUrl = req.params.url;
+    if (!/^https?:\/\//i.test(navUrl))
+      throw new Error("Only http/https URLs allowed");
+    await chrome.tabs.update(tabId, { url: navUrl });
+    await waitForTabLoad(tabId);
+  }
+  const NAV_ACTIONS = new Set(["go_back", "go_forward", "reload"]);
+  const contentAction = NAV_ACTIONS.has(req.action) ? "get_page" : req.action;
+  const msg = { action: contentAction, params: req.params };
+  let data;
+  try {
+    data = await chrome.tabs.sendMessage(tabId, msg);
+  } catch (e) {
+    const errMsg = e instanceof Error ? e.message : String(e);
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      files: ["content.js"]
+    });
+    const delay = errMsg.includes("message channel closed") ? 500 : 300;
+    await new Promise((r) => setTimeout(r, delay));
+    data = await chrome.tabs.sendMessage(tabId, msg);
+  }
+  let screenshot = null;
+  if (req.params?.include_screenshot === true) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      await chrome.tabs.update(tabId, { active: true });
+      await chrome.windows.update(tab.windowId, { focused: true });
+      screenshot = await throttledCaptureVisibleTab(tab.windowId, {
+        format: "jpeg",
+        quality: 70
+      });
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      console.warn("[MCP Bridge] Screenshot failed:", errMsg);
+    }
+  }
+  return { data, screenshot };
+}
+
+// apps/extension/src/background/connection.ts
+var ws = null;
+var reconnectTimer = null;
+async function connect() {
+  if (ws) {
+    ws.onclose = null;
+    ws.close();
+  }
+  const stored = await chrome.storage.local.get(["mcpToken", "mcpPort"]);
+  const token = stored.mcpToken;
+  const port = stored.mcpPort ?? 18888;
+  const protocols = token ? [token] : [];
+  ws = new WebSocket(`ws://127.0.0.1:${port}`, protocols);
+  ws.onopen = async () => {
+    console.log("[MCP Bridge] Connected to MCP server");
+    const stored2 = await chrome.storage.session.get("lastReloadId");
+    const lastReloadId = stored2.lastReloadId ?? null;
+    if (lastReloadId) {
+      await chrome.storage.session.remove("lastReloadId");
+    }
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        type: "hello",
+        extensionId: chrome.runtime.id,
+        lastReloadId,
+        timestamp: Date.now()
+      }));
+    }
+    if (reconnectTimer) {
+      clearInterval(reconnectTimer);
+      reconnectTimer = null;
+    }
+    setSendFrameCallback((data) => {
+      if (ws?.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(data));
+      }
+    });
+  };
+  ws.onmessage = async (event) => {
+    let req;
+    try {
+      req = JSON.parse(event.data);
+    } catch {
+      console.error("[MCP Bridge] Invalid JSON received");
+      return;
+    }
+    if (req.type === "reload") {
+      const reloadId = req.reloadId ?? null;
+      console.log(`[MCP Bridge] Reload requested (reloadId=${reloadId}), reloading extension...`);
+      chrome.storage.session.set({ lastReloadId: reloadId }).then(() => {
+        chrome.runtime.reload();
+      });
+      return;
+    }
+    if (!req.id || !req.action) {
+      console.error("[MCP Bridge] Missing id or action");
+      return;
+    }
+    try {
+      console.log("[MCP Bridge] Handling request:", req.action, req.params);
+      const result = await handleRequest(req);
+      console.log("[MCP Bridge] Request succeeded:", req.action);
+      if (ws?.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ id: req.id, status: "ok", ...result }));
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error("[MCP Bridge] Request failed:", req.action, msg);
+      if (ws?.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({
+          id: req.id,
+          status: "error",
+          error: msg,
+          message: msg
+        }));
+      }
+    }
+  };
+  ws.onclose = () => {
+    console.log("[MCP Bridge] Disconnected. Reconnecting...");
+    onWsDisconnect();
+    scheduleReconnect();
+  };
+  ws.onerror = () => ws?.close();
+}
+function scheduleReconnect() {
+  if (!reconnectTimer) {
+    reconnectTimer = setInterval(connect, 5000);
+  }
+}
+function isConnected() {
+  return ws !== null && ws.readyState === WebSocket.OPEN;
+}
+
+// apps/extension/src/background.ts
+initDebuggerListeners();
+setScreencastFrameHandler(handleScreencastFrame);
+chrome.alarms.create("keepalive", { periodInMinutes: 1 });
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === "keepalive") {
+    if (!isConnected()) {
+      connect();
+    }
+  }
+});
+reinjectContentScripts();
+chrome.storage.onChanged.addListener((changes, area) => {
+  if (area === "local" && (changes.mcpToken || changes.mcpPort)) {
+    console.log("[BP] Token changed, reconnecting...");
+    connect();
+  }
+});
+chrome.tabs.onRemoved.addListener(onTabRemoved);
+connect();