@youtyan/browser-pilot 0.7.1

package/extension/content.js

@@ -0,0 +1,2107 @@
+// apps/extension/src/content/element-utils.ts
+var INTERACTABLE_SELECTORS = "input,select,textarea,button,a,[role='button'],[role='link'],[role='tab'],[role='menuitem'],[contenteditable='true']";
+function isSensitiveInput(el) {
+  if (el.tagName !== "INPUT")
+    return false;
+  const type = el.getAttribute("type")?.toLowerCase();
+  return type === "password" || type === "hidden";
+}
+function isVisible(el) {
+  const rect = el.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0)
+    return false;
+  const style = getComputedStyle(el);
+  if (style.display === "none")
+    return false;
+  if (style.visibility === "hidden" || style.visibility === "collapse")
+    return false;
+  if (style.opacity === "0")
+    return false;
+  let parent = el.parentElement;
+  while (parent) {
+    const ps = getComputedStyle(parent);
+    if (ps.display === "none")
+      return false;
+    if (ps.visibility === "hidden" || ps.visibility === "collapse")
+      return false;
+    if (ps.opacity === "0")
+      return false;
+    parent = parent.parentElement;
+  }
+  return true;
+}
+function isInteractable(el) {
+  return el.matches(INTERACTABLE_SELECTORS);
+}
+function matchesText(el, query) {
+  const lower = query.toLowerCase();
+  const text = el.textContent?.trim().toLowerCase() ?? "";
+  if (text.includes(lower))
+    return true;
+  const ariaLabel = el.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.toLowerCase().includes(lower))
+    return true;
+  const title = el.getAttribute("title");
+  if (title && title.toLowerCase().includes(lower))
+    return true;
+  if (el.tagName.toLowerCase() === "a") {
+    const href = el.href;
+    if (href && href.toLowerCase().includes(lower))
+      return true;
+  } else if (el.getAttribute("role") === "link") {
+    const href = el.getAttribute("href");
+    if (href && href.toLowerCase().includes(lower))
+      return true;
+  }
+  return false;
+}
+function matchesFilters(el, params) {
+  if (params.tag && el.tagName.toLowerCase() !== params.tag.toLowerCase())
+    return false;
+  if (params.text) {
+    if (!matchesText(el, params.text))
+      return false;
+  }
+  if (params.role) {
+    const elRole = el.getAttribute("role") ?? "";
+    if (elRole.toLowerCase() !== params.role.toLowerCase())
+      return false;
+  }
+  if (params.attribute) {
+    const attrVal = el.getAttribute(params.attribute);
+    if (attrVal === null)
+      return false;
+    if (params.attributeValue) {
+      if (!attrVal.toLowerCase().includes(params.attributeValue.toLowerCase()))
+        return false;
+    }
+  }
+  if (params.visibleOnly !== false && !isVisible(el))
+    return false;
+  if (params.interactableOnly && !isInteractable(el))
+    return false;
+  return true;
+}
+function collectByNearText(nearText, maxDepth, params) {
+  const results = [];
+  const seen = new Set;
+  const lowerNear = nearText.toLowerCase();
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, {
+    acceptNode(node) {
+      return node.textContent?.toLowerCase().includes(lowerNear) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+    }
+  });
+  const textNodes = [];
+  for (let tNode = walker.nextNode();tNode !== null; tNode = walker.nextNode()) {
+    textNodes.push(tNode);
+  }
+  const implicitInteractable = !params.tag && !params.role && !params.selector;
+  for (const textNode of textNodes) {
+    let ancestor = textNode.parentElement;
+    for (let d = 0;d < maxDepth && ancestor && ancestor !== document.body; d++) {
+      ancestor = ancestor.parentElement;
+    }
+    if (!ancestor)
+      continue;
+    for (const desc of ancestor.querySelectorAll("*")) {
+      const htmlDesc = desc;
+      if (seen.has(htmlDesc))
+        continue;
+      const filterParams = {
+        ...params,
+        nearText: undefined,
+        interactableOnly: params.interactableOnly ?? implicitInteractable
+      };
+      if (matchesFilters(htmlDesc, filterParams)) {
+        seen.add(htmlDesc);
+        results.push(htmlDesc);
+      }
+    }
+  }
+  return results;
+}
+function findMatchingElements(params) {
+  if (!params)
+    return [];
+  if (params.nearText) {
+    const maxDepth = params.nearMaxDepth ?? 3;
+    return collectByNearText(params.nearText, maxDepth, params);
+  }
+  const hasRichFilters = params.tag || params.role || params.attribute || params.interactableOnly;
+  if (params.scanAll || hasRichFilters) {
+    let baseElements;
+    if (params.selector) {
+      try {
+        baseElements = document.querySelectorAll(params.selector);
+      } catch {
+        return [];
+      }
+    } else {
+      baseElements = document.querySelectorAll("*");
+    }
+    const candidates = [];
+    for (const el of baseElements) {
+      if (matchesFilters(el, params))
+        candidates.push(el);
+    }
+    return candidates;
+  }
+  const targets = [];
+  if (params.selector) {
+    const els = document.querySelectorAll(params.selector);
+    for (const el of els) {
+      const htmlEl = el;
+      if (!isVisible(htmlEl))
+        continue;
+      if (params.text) {
+        if (matchesText(htmlEl, params.text)) {
+          targets.push(htmlEl);
+        }
+      } else {
+        targets.push(htmlEl);
+      }
+    }
+  } else if (params.text) {
+    const clickableSelectors = ["button", "a", '[role="button"]', '[role="link"]', ".btn"];
+    for (const sel of clickableSelectors) {
+      const els = document.querySelectorAll(sel);
+      for (const el of els) {
+        const htmlEl = el;
+        if (!isVisible(htmlEl))
+          continue;
+        if (matchesText(htmlEl, params.text)) {
+          targets.push(htmlEl);
+        }
+      }
+      if (targets.length > 0)
+        break;
+    }
+  }
+  return targets;
+}
+
+// apps/extension/src/content/wait.ts
+var LOADING_SELECTORS = [
+  '[class*="loading"]',
+  '[class*="Loading"]',
+  ".spinner",
+  '[class*="spinner"]',
+  '[role="progressbar"]'
+];
+function hasVisibleLoading() {
+  return LOADING_SELECTORS.some((sel) => {
+    const els = document.querySelectorAll(sel);
+    return Array.from(els).some((el) => isVisible(el));
+  });
+}
+function waitForContent(timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    function check() {
+      if (!hasVisibleLoading() || Date.now() - start > timeoutMs) {
+        resolve();
+        return;
+      }
+      setTimeout(check, 100);
+    }
+    check();
+  });
+}
+
+// apps/extension/src/content/get-page.ts
+function getPage() {
+  const clone = document.body.cloneNode(true);
+  for (const hlEl of clone.querySelectorAll("[data-mcp-annotate]")) {
+    hlEl.remove();
+  }
+  const origInputs = document.body.querySelectorAll("input, textarea");
+  const cloneInputs = clone.querySelectorAll("input, textarea");
+  origInputs.forEach((orig, i) => {
+    const origEl = orig;
+    const cloneEl = cloneInputs[i];
+    if (!cloneEl) {
+      return;
+    }
+    if (isSensitiveInput(cloneEl)) {
+      cloneEl.removeAttribute("value");
+      return;
+    }
+    if (origEl.value) {
+      cloneEl.setAttribute("value", origEl.value);
+    }
+  });
+  const origSelects = document.body.querySelectorAll("select");
+  const cloneSelects = clone.querySelectorAll("select");
+  origSelects.forEach((orig, i) => {
+    const origEl = orig;
+    const cloneEl = cloneSelects[i];
+    if (cloneEl) {
+      const selectedIdx = origEl.selectedIndex;
+      const opts = cloneEl.querySelectorAll("option");
+      opts.forEach((opt, j) => {
+        if (j === selectedIdx)
+          opt.setAttribute("selected", "");
+        else
+          opt.removeAttribute("selected");
+      });
+    }
+  });
+  return {
+    html: clone.innerHTML,
+    url: window.location.href,
+    title: document.title
+  };
+}
+
+// apps/extension/src/content/diagnose.ts
+function diagnoseElement(params) {
+  const allMatches = findMatchingElementsUnfiltered(params);
+  if (allMatches.length === 0) {
+    const candidates = findCandidates(params);
+    return {
+      reason: "not_found",
+      ...candidates.length > 0 ? { candidates } : {}
+    };
+  }
+  const index = (params.nth ?? 1) - 1;
+  if (index < 0 || index >= allMatches.length) {
+    return {
+      reason: "not_found",
+      details: { element: `nth=${params.nth} but only ${allMatches.length} match(es)` }
+    };
+  }
+  const el = allMatches[index];
+  const visibilityIssue = diagnoseVisibility(el);
+  if (visibilityIssue) {
+    return {
+      reason: "invisible",
+      details: {
+        element: el.tagName.toLowerCase(),
+        ...visibilityIssue
+      }
+    };
+  }
+  const disabledIssue = diagnoseDisabled(el);
+  if (disabledIssue) {
+    return {
+      reason: "disabled",
+      details: disabledIssue
+    };
+  }
+  const coverageIssue = diagnoseCoverage(el);
+  if (coverageIssue) {
+    return {
+      reason: "covered",
+      details: coverageIssue
+    };
+  }
+  return { reason: "ok" };
+}
+function findMatchingElementsUnfiltered(params) {
+  if (params.nearText) {
+    const maxDepth = params.nearMaxDepth ?? 3;
+    return collectByNearTextUnfiltered(params.nearText, maxDepth, params);
+  }
+  const hasRichFilters = params.tag || params.role || params.attribute;
+  if (params.scanAll || hasRichFilters) {
+    let baseElements;
+    if (params.selector) {
+      try {
+        baseElements = document.querySelectorAll(params.selector);
+      } catch {
+        return [];
+      }
+    } else {
+      baseElements = document.querySelectorAll("*");
+    }
+    return applyNonVisibilityFilters(Array.from(baseElements), params);
+  }
+  if (params.selector) {
+    try {
+      const els = document.querySelectorAll(params.selector);
+      const filtered = applyNonVisibilityFilters(Array.from(els), params);
+      return filtered;
+    } catch {
+      return [];
+    }
+  }
+  if (params.text) {
+    const clickableSelectors = ["button", "a", '[role="button"]', '[role="link"]', ".btn"];
+    for (const sel of clickableSelectors) {
+      const els = document.querySelectorAll(sel);
+      const matches = [];
+      for (const el of els) {
+        const htmlEl = el;
+        if (matchesText(htmlEl, params.text))
+          matches.push(htmlEl);
+      }
+      if (matches.length > 0)
+        return matches;
+    }
+  }
+  return [];
+}
+function applyNonVisibilityFilters(elements, params) {
+  return elements.filter((el) => {
+    if (params.tag && el.tagName.toLowerCase() !== params.tag.toLowerCase())
+      return false;
+    if (params.text && !matchesText(el, params.text))
+      return false;
+    if (params.role) {
+      const elRole = el.getAttribute("role") ?? "";
+      if (elRole.toLowerCase() !== params.role.toLowerCase())
+        return false;
+    }
+    if (params.attribute) {
+      const attrVal = el.getAttribute(params.attribute);
+      if (attrVal === null)
+        return false;
+      if (params.attributeValue) {
+        if (!attrVal.toLowerCase().includes(params.attributeValue.toLowerCase()))
+          return false;
+      }
+    }
+    if (params.interactableOnly && !isInteractable(el))
+      return false;
+    return true;
+  });
+}
+function collectByNearTextUnfiltered(nearText, maxDepth, params) {
+  const results = [];
+  const seen = new Set;
+  const lowerNear = nearText.toLowerCase();
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, {
+    acceptNode(node) {
+      return node.textContent?.toLowerCase().includes(lowerNear) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+    }
+  });
+  const textNodes = [];
+  for (let tNode = walker.nextNode();tNode !== null; tNode = walker.nextNode()) {
+    textNodes.push(tNode);
+  }
+  for (const textNode of textNodes) {
+    let ancestor = textNode.parentElement;
+    for (let d = 0;d < maxDepth && ancestor && ancestor !== document.body; d++) {
+      ancestor = ancestor.parentElement;
+    }
+    if (!ancestor)
+      continue;
+    for (const desc of ancestor.querySelectorAll("*")) {
+      const htmlDesc = desc;
+      if (seen.has(htmlDesc))
+        continue;
+      const matchesFiltersNoVis = applyNonVisibilityFilters([htmlDesc], {
+        ...params,
+        nearText: undefined,
+        interactableOnly: params.interactableOnly ?? (!params.tag && !params.role && !params.selector)
+      });
+      if (matchesFiltersNoVis.length > 0) {
+        seen.add(htmlDesc);
+        results.push(htmlDesc);
+      }
+    }
+  }
+  return results;
+}
+function diagnoseVisibility(el) {
+  const rect = el.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0) {
+    return { visibility: "zero-size" };
+  }
+  const style = getComputedStyle(el);
+  if (style.display === "none")
+    return { visibility: "display:none" };
+  if (style.visibility === "hidden" || style.visibility === "collapse")
+    return { visibility: "visibility:hidden" };
+  if (style.opacity === "0")
+    return { visibility: "opacity:0" };
+  let parent = el.parentElement;
+  while (parent) {
+    const ps = getComputedStyle(parent);
+    if (ps.display === "none") {
+      return { visibility: "display:none", ancestor: describeElement(parent) };
+    }
+    if (ps.visibility === "hidden" || ps.visibility === "collapse") {
+      return { visibility: "visibility:hidden", ancestor: describeElement(parent) };
+    }
+    if (ps.opacity === "0") {
+      return { visibility: "opacity:0", ancestor: describeElement(parent) };
+    }
+    parent = parent.parentElement;
+  }
+  return null;
+}
+function diagnoseDisabled(el) {
+  if (el.disabled === true || el.getAttribute("disabled") !== null) {
+    return { disabledBy: "disabled" };
+  }
+  if (el.getAttribute("aria-disabled") === "true") {
+    return { disabledBy: "aria-disabled" };
+  }
+  const style = getComputedStyle(el);
+  if (style.pointerEvents === "none") {
+    return { disabledBy: "pointer-events:none" };
+  }
+  if (el.hasAttribute("inert") || el.closest("[inert]")) {
+    return { disabledBy: "inert" };
+  }
+  return null;
+}
+function diagnoseCoverage(el) {
+  const rect = el.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0)
+    return null;
+  const centerX = rect.left + rect.width / 2;
+  const centerY = rect.top + rect.height / 2;
+  const topEl = document.elementFromPoint(centerX, centerY);
+  if (!topEl)
+    return null;
+  if (topEl !== el && !el.contains(topEl)) {
+    return {
+      coveredBy: describeElement(topEl)
+    };
+  }
+  return null;
+}
+function findCandidates(params) {
+  const candidates = [];
+  const clickable = document.querySelectorAll("button, a, [role='button'], [role='link'], input[type='submit']");
+  if (params.text) {
+    const lower = params.text.toLowerCase();
+    for (const el of clickable) {
+      if (candidates.length >= 3)
+        break;
+      const htmlEl = el;
+      const text = htmlEl.textContent?.trim() ?? "";
+      const label = htmlEl.getAttribute("aria-label") ?? "";
+      const combined = `${text} ${label}`.toLowerCase();
+      const queryWords = lower.split(/\s+/).filter((w) => w.length >= 2);
+      const hasOverlap = queryWords.some((w) => combined.includes(w));
+      if (hasOverlap && (text || label)) {
+        candidates.push({
+          tag: htmlEl.tagName.toLowerCase(),
+          text: (text || label).slice(0, 50),
+          selector: generateSimpleSelector(htmlEl)
+        });
+      }
+    }
+  }
+  if (candidates.length === 0) {
+    for (const el of clickable) {
+      if (candidates.length >= 3)
+        break;
+      const htmlEl = el;
+      const text = htmlEl.textContent?.trim() ?? "";
+      if (text || htmlEl.getAttribute("aria-label")) {
+        candidates.push({
+          tag: htmlEl.tagName.toLowerCase(),
+          text: text.slice(0, 50) || htmlEl.getAttribute("aria-label")?.slice(0, 50) || "",
+          selector: generateSimpleSelector(htmlEl)
+        });
+      }
+    }
+  }
+  return candidates;
+}
+function describeElement(el) {
+  const tag = el.tagName.toLowerCase();
+  const id = el.id ? `#${el.id}` : "";
+  const cls = el.className && typeof el.className === "string" ? "." + el.className.trim().split(/\s+/).slice(0, 2).join(".") : "";
+  return `${tag}${id}${cls}`;
+}
+function generateSimpleSelector(el) {
+  if (el.id)
+    return `#${el.id}`;
+  const tag = el.tagName.toLowerCase();
+  const cls = el.className && typeof el.className === "string" ? "." + el.className.trim().split(/\s+/).slice(0, 2).join(".") : "";
+  return `${tag}${cls}`;
+}
+
+// apps/extension/src/content/click-element.ts
+function waitAfterClick(waitSelector, beforeCount, timeoutMs) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    function check() {
+      const hasLoading = hasVisibleLoading();
+      let ready;
+      if (waitSelector) {
+        try {
+          const afterCount = document.querySelectorAll(waitSelector).length;
+          ready = !hasLoading && afterCount !== beforeCount;
+        } catch {
+          ready = !hasLoading;
+        }
+      } else {
+        ready = !hasLoading;
+      }
+      if (ready || Date.now() - start > timeoutMs) {
+        resolve();
+        return;
+      }
+      setTimeout(check, 100);
+    }
+    setTimeout(check, 200);
+  });
+}
+function checkPostcondition(params, remainingMs) {
+  if (!params?.expectText && !params?.expectSelector && !params?.expectUrlContains) {
+    return Promise.resolve(null);
+  }
+  const effectiveTimeout = Math.max(remainingMs, 0);
+  return new Promise((resolve) => {
+    const start = Date.now();
+    function check() {
+      if (params.expectText) {
+        const bodyText = document.body?.innerText ?? "";
+        if (bodyText.includes(params.expectText)) {
+          resolve(null);
+          return;
+        }
+        if (Date.now() - start >= effectiveTimeout) {
+          resolve({ type: "text", expected: params.expectText, actual: bodyText.slice(0, 200) });
+          return;
+        }
+      } else if (params.expectSelector) {
+        try {
+          if (document.querySelector(params.expectSelector)) {
+            resolve(null);
+            return;
+          }
+        } catch {}
+        if (Date.now() - start >= effectiveTimeout) {
+          resolve({ type: "selector", expected: params.expectSelector, actual: "not found" });
+          return;
+        }
+      } else if (params.expectUrlContains) {
+        if (window.location.href.includes(params.expectUrlContains)) {
+          resolve(null);
+          return;
+        }
+        if (Date.now() - start >= effectiveTimeout) {
+          resolve({ type: "url", expected: params.expectUrlContains, actual: window.location.href });
+          return;
+        }
+      }
+      setTimeout(check, 100);
+    }
+    check();
+  });
+}
+async function clickElement(params) {
+  const targets = findMatchingElements(params);
+  if (targets.length === 0) {
+    const diag = diagnoseElement(params ?? {});
+    const diagnosis = diag.reason !== "ok" ? { reason: diag.reason, details: diag.details, candidates: diag.candidates } : undefined;
+    return { clicked: false, count: 0, ...diagnosis ? { diagnosis } : {} };
+  }
+  const timeout = params?.timeout ?? 5000;
+  if (params?.cdpClick) {
+    const index2 = (params?.nth ?? 1) - 1;
+    if (index2 < 0 || index2 >= targets.length) {
+      return { clicked: false, count: 0 };
+    }
+    const el = targets[index2];
+    el.scrollIntoView({ block: "center", inline: "center", behavior: "instant" });
+    await new Promise((r) => setTimeout(r, 50));
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 && rect.height === 0) {
+      return { clicked: false, count: 0 };
+    }
+    const x = Math.round(rect.left + rect.width / 2);
+    const y = Math.round(rect.top + rect.height / 2);
+    return { clicked: false, cdpTargets: [{ x, y }] };
+  }
+  function getBeforeCount() {
+    if (!params?.waitSelector)
+      return 0;
+    try {
+      return document.querySelectorAll(params.waitSelector).length;
+    } catch {
+      return 0;
+    }
+  }
+  if (params?.all) {
+    let clickedCount = 0;
+    const deadline = Date.now() + timeout;
+    for (const target of targets) {
+      const beforeCount2 = getBeforeCount();
+      target.click();
+      clickedCount++;
+      const perElementTimeout = Math.min(Math.max(deadline - Date.now(), 0), 2000);
+      await waitAfterClick(params?.waitSelector, beforeCount2, perElementTimeout);
+      if (Date.now() >= deadline)
+        break;
+    }
+    const remaining2 = deadline - Date.now();
+    const expectDetails2 = await checkPostcondition(params, remaining2);
+    if (expectDetails2) {
+      return { clicked: true, count: clickedCount, expectMet: false, expectDetails: expectDetails2 };
+    }
+    if (params?.expectText || params?.expectSelector || params?.expectUrlContains) {
+      return { clicked: true, count: clickedCount, expectMet: true };
+    }
+    return { clicked: true, count: clickedCount };
+  }
+  const index = (params?.nth ?? 1) - 1;
+  if (index < 0 || index >= targets.length) {
+    return { clicked: false, count: 0 };
+  }
+  const clickStart = Date.now();
+  const beforeCount = getBeforeCount();
+  targets[index].click();
+  await waitAfterClick(params?.waitSelector, beforeCount, timeout);
+  const remaining = timeout - (Date.now() - clickStart);
+  const expectDetails = await checkPostcondition(params, remaining);
+  if (expectDetails) {
+    return { clicked: true, count: 1, expectMet: false, expectDetails };
+  }
+  if (params?.expectText || params?.expectSelector || params?.expectUrlContains) {
+    return { clicked: true, count: 1, expectMet: true };
+  }
+  return { clicked: true, count: 1 };
+}
+
+// apps/extension/src/content/action-element.ts
+function actionElement(params) {
+  const actionType = params?.action;
+  if (!actionType) {
+    return { dispatched: false, action: "none", count: 0 };
+  }
+  if (actionType === "drag") {
+    return dispatchDrag(params);
+  }
+  const targets = findMatchingElements(params);
+  if (targets.length === 0) {
+    return { dispatched: false, action: actionType ?? "none", count: 0 };
+  }
+  const elementsToAct = params?.all ? targets : [targets[0]];
+  for (const el of elementsToAct) {
+    if (actionType === "hover") {
+      el.dispatchEvent(new MouseEvent("mouseenter", { bubbles: true, cancelable: true }));
+      el.dispatchEvent(new MouseEvent("mouseover", { bubbles: true, cancelable: true }));
+      el.dispatchEvent(new MouseEvent("mousemove", { bubbles: true, cancelable: true }));
+    } else if (actionType === "dblclick") {
+      el.dispatchEvent(new MouseEvent("dblclick", { bubbles: true, cancelable: true }));
+    } else if (actionType === "contextmenu") {
+      el.dispatchEvent(new MouseEvent("contextmenu", { bubbles: true, cancelable: true }));
+    } else if (actionType === "mousedown") {
+      el.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true }));
+    } else if (actionType === "mouseup") {
+      el.dispatchEvent(new MouseEvent("mouseup", { bubbles: true, cancelable: true }));
+    } else if (actionType === "focus") {
+      el.focus();
+      el.dispatchEvent(new FocusEvent("focus", { bubbles: true }));
+    } else if (actionType === "blur") {
+      el.blur();
+      el.dispatchEvent(new FocusEvent("blur", { bubbles: true }));
+    } else {
+      el.dispatchEvent(new Event(actionType, { bubbles: true, cancelable: true }));
+    }
+  }
+  return { dispatched: true, action: actionType, count: elementsToAct.length };
+}
+function dispatchDrag(params) {
+  const sources = findMatchingElements(params);
+  if (sources.length === 0) {
+    return { dispatched: false, action: "drag", count: 0 };
+  }
+  const source = sources[0];
+  const targetSelector = params?.targetSelector;
+  if (!targetSelector) {
+    return { dispatched: false, action: "drag", count: 0 };
+  }
+  const target = document.querySelector(targetSelector);
+  if (!target) {
+    return { dispatched: false, action: "drag", count: 0 };
+  }
+  const dt = new DataTransfer;
+  const sourceRect = source.getBoundingClientRect();
+  const targetRect = target.getBoundingClientRect();
+  const srcX = sourceRect.left + sourceRect.width / 2;
+  const srcY = sourceRect.top + sourceRect.height / 2;
+  const tgtX = targetRect.left + targetRect.width / 2;
+  const tgtY = targetRect.top + targetRect.height / 2;
+  source.dispatchEvent(new DragEvent("dragstart", {
+    bubbles: true,
+    cancelable: true,
+    dataTransfer: dt,
+    clientX: srcX,
+    clientY: srcY
+  }));
+  source.dispatchEvent(new DragEvent("drag", {
+    bubbles: true,
+    cancelable: true,
+    dataTransfer: dt,
+    clientX: srcX,
+    clientY: srcY
+  }));
+  target.dispatchEvent(new DragEvent("dragenter", {
+    bubbles: true,
+    cancelable: true,
+    dataTransfer: dt,
+    clientX: tgtX,
+    clientY: tgtY
+  }));
+  target.dispatchEvent(new DragEvent("dragover", {
+    bubbles: true,
+    cancelable: true,
+    dataTransfer: dt,
+    clientX: tgtX,
+    clientY: tgtY
+  }));
+  target.dispatchEvent(new DragEvent("drop", {
+    bubbles: true,
+    cancelable: true,
+    dataTransfer: dt,
+    clientX: tgtX,
+    clientY: tgtY
+  }));
+  source.dispatchEvent(new DragEvent("dragend", {
+    bubbles: true,
+    cancelable: true,
+    dataTransfer: dt,
+    clientX: tgtX,
+    clientY: tgtY
+  }));
+  return { dispatched: true, action: "drag", count: 1 };
+}
+
+// apps/extension/src/content/set-value.ts
+function setValue(params) {
+  if (!params?.selector || params.value === undefined) {
+    return { set: false };
+  }
+  const el = document.querySelector(params.selector);
+  if (!el) {
+    const diag = diagnoseElement({ selector: params.selector });
+    const diagnosis = diag.reason !== "ok" ? { reason: diag.reason, details: diag.details, candidates: diag.candidates } : undefined;
+    return { set: false, ...diagnosis ? { diagnosis } : {} };
+  }
+  if (el.isContentEditable) {
+    el.focus();
+    if (params.value === "") {
+      if (el.textContent) {
+        document.execCommand("selectAll", false);
+        document.execCommand("delete", false);
+      }
+      if (params?.verify) {
+        const actual = el.innerText ?? "";
+        if (actual !== "") {
+          return { set: true, verified: false, verifyExpected: "", verifyActual: actual.slice(0, 200) };
+        }
+        return { set: true, verified: true };
+      }
+      return { set: true };
+    }
+    if (params.value.includes(`
+`)) {
+      if (el.textContent) {
+        document.execCommand("selectAll", false);
+        document.execCommand("delete", false);
+      }
+      const dt = new DataTransfer;
+      dt.setData("text/plain", params.value);
+      const pasteEvent = new ClipboardEvent("paste", {
+        clipboardData: dt,
+        bubbles: true,
+        cancelable: true
+      });
+      el.dispatchEvent(pasteEvent);
+      if (!pasteEvent.defaultPrevented) {
+        const lines = params.value.split(`
+`);
+        for (let i = 0;i < lines.length; i++) {
+          if (i === 0) {
+            document.execCommand("insertText", false, lines[i]);
+          } else {
+            document.execCommand("insertLineBreak", false);
+            if (lines[i]) {
+              document.execCommand("insertText", false, lines[i]);
+            }
+          }
+        }
+      }
+    } else {
+      if (el.textContent) {
+        document.execCommand("selectAll", false);
+      }
+      document.execCommand("insertText", false, params.value);
+    }
+    if (params?.verify) {
+      const actual = (el.innerText ?? "").replace(/\n{2,}/g, `
+`).trim();
+      const expected = params.value.trim();
+      if (actual !== expected) {
+        return { set: true, verified: false, verifyExpected: params.value, verifyActual: actual.slice(0, 200) };
+      }
+      return { set: true, verified: true };
+    }
+    return { set: true };
+  }
+  const inputEl = el;
+  const nativeSetter = Object.getOwnPropertyDescriptor(inputEl instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : inputEl instanceof HTMLSelectElement ? HTMLSelectElement.prototype : HTMLInputElement.prototype, "value")?.set;
+  if (nativeSetter) {
+    nativeSetter.call(inputEl, params.value);
+  } else {
+    inputEl.value = params.value;
+  }
+  inputEl.dispatchEvent(new Event("input", { bubbles: true }));
+  inputEl.dispatchEvent(new Event("change", { bubbles: true }));
+  if (params?.verify) {
+    const actual = inputEl.value;
+    if (actual !== params.value) {
+      return { set: true, verified: false, verifyExpected: params.value, verifyActual: actual };
+    }
+    return { set: true, verified: true };
+  }
+  return { set: true };
+}
+
+// apps/extension/src/content/paste-file.ts
+function pasteFile(params) {
+  if (!params?.base64 || !params?.mimeType) {
+    return { pasted: false };
+  }
+  const binaryStr = atob(params.base64);
+  const bytes = new Uint8Array(binaryStr.length);
+  for (let i = 0;i < binaryStr.length; i++) {
+    bytes[i] = binaryStr.charCodeAt(i);
+  }
+  const blob = new Blob([bytes], { type: params.mimeType });
+  const file = new File([blob], params.fileName ?? "pasted-file", { type: params.mimeType });
+  const dt = new DataTransfer;
+  dt.items.add(file);
+  const target = params.selector ? document.querySelector(params.selector) : document.activeElement;
+  if (!target) {
+    return { pasted: false };
+  }
+  target.focus();
+  const event = new ClipboardEvent("paste", {
+    clipboardData: dt,
+    bubbles: true,
+    cancelable: true
+  });
+  target.dispatchEvent(event);
+  return { pasted: true };
+}
+
+// apps/extension/src/content/query-selector.ts
+function queryElements(params) {
+  if (!params?.selector) {
+    return { count: 0, elements: [] };
+  }
+  const limit = params.limit ?? 20;
+  let els;
+  try {
+    els = document.querySelectorAll(params.selector);
+  } catch {
+    return { count: 0, elements: [] };
+  }
+  const elements = [];
+  for (const el of els) {
+    if (elements.length >= limit)
+      break;
+    const htmlEl = el;
+    let outerHTML;
+    if (isSensitiveInput(htmlEl)) {
+      const clone = htmlEl.cloneNode(false);
+      clone.removeAttribute("value");
+      outerHTML = clone.outerHTML.slice(0, 200);
+    } else {
+      outerHTML = htmlEl.outerHTML.slice(0, 200);
+    }
+    elements.push({
+      tag: htmlEl.tagName.toLowerCase(),
+      text: (htmlEl.textContent?.trim() ?? "").slice(0, 100),
+      visible: isVisible(htmlEl),
+      outerHTML
+    });
+  }
+  return { count: els.length, elements };
+}
+
+// apps/extension/src/content/find-elements.ts
+var KEY_ATTRIBUTES = ["id", "name", "class", "type", "placeholder", "aria-label", "role", "data-testid", "value", "href"];
+function generateSelector(el) {
+  if (el.id) {
+    const sel = `#${CSS.escape(el.id)}`;
+    if (document.querySelectorAll(sel).length === 1)
+      return sel;
+  }
+  const testId = el.getAttribute("data-testid");
+  if (testId) {
+    const sel = `[data-testid="${CSS.escape(testId)}"]`;
+    if (document.querySelectorAll(sel).length === 1)
+      return sel;
+  }
+  const name = el.getAttribute("name");
+  if (name) {
+    const tag = el.tagName.toLowerCase();
+    const sel = `${tag}[name="${CSS.escape(name)}"]`;
+    if (document.querySelectorAll(sel).length === 1)
+      return sel;
+  }
+  const ariaLabel = el.getAttribute("aria-label");
+  if (ariaLabel) {
+    const tag = el.tagName.toLowerCase();
+    const sel = `${tag}[aria-label="${CSS.escape(ariaLabel)}"]`;
+    if (document.querySelectorAll(sel).length === 1)
+      return sel;
+  }
+  const placeholder = el.getAttribute("placeholder");
+  if (placeholder) {
+    const tag = el.tagName.toLowerCase();
+    const sel = `${tag}[placeholder="${CSS.escape(placeholder)}"]`;
+    if (document.querySelectorAll(sel).length === 1)
+      return sel;
+  }
+  const parts = [];
+  let current = el;
+  for (let depth = 0;depth < 3 && current && current !== document.body; depth++) {
+    const parent = current.parentElement;
+    if (!parent)
+      break;
+    const tag = current.tagName.toLowerCase();
+    const siblings = parent.querySelectorAll(`:scope > ${tag}`);
+    if (siblings.length === 1) {
+      parts.unshift(tag);
+    } else {
+      const idx = Array.from(siblings).indexOf(current) + 1;
+      parts.unshift(`${tag}:nth-of-type(${idx})`);
+    }
+    const candidate = parts.join(" > ");
+    if (document.querySelectorAll(candidate).length === 1)
+      return candidate;
+    current = parent;
+  }
+  return parts.join(" > ") || el.tagName.toLowerCase();
+}
+function getElementLabel(el) {
+  const ariaLabel = el.getAttribute("aria-label");
+  if (ariaLabel)
+    return ariaLabel;
+  const labelledBy = el.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    const labelEl = document.getElementById(labelledBy);
+    if (labelEl)
+      return labelEl.textContent?.trim() ?? "";
+  }
+  if (el.id) {
+    const label = document.querySelector(`label[for="${CSS.escape(el.id)}"]`);
+    if (label)
+      return label.textContent?.trim() ?? "";
+  }
+  const ancestorLabel = el.closest("label");
+  if (ancestorLabel) {
+    const clone = ancestorLabel.cloneNode(true);
+    for (const inp of clone.querySelectorAll("input, select, textarea"))
+      inp.remove();
+    const text = clone.textContent?.trim() ?? "";
+    if (text)
+      return text;
+  }
+  const ph = el.getAttribute("placeholder");
+  if (ph)
+    return ph;
+  return "";
+}
+function extractKeyAttributes(el) {
+  const attrs = {};
+  const sensitive = isSensitiveInput(el);
+  for (const key of KEY_ATTRIBUTES) {
+    if (sensitive && key === "value")
+      continue;
+    const val = el.getAttribute(key);
+    if (val !== null && val !== "")
+      attrs[key] = val.slice(0, 200);
+  }
+  return attrs;
+}
+function sanitizeOuterHTML(el) {
+  if (isSensitiveInput(el)) {
+    const clone = el.cloneNode(false);
+    clone.removeAttribute("value");
+    return clone.outerHTML.slice(0, 200);
+  }
+  return el.outerHTML.slice(0, 200);
+}
+function buildElementInfo(el) {
+  return {
+    generatedSelector: generateSelector(el),
+    tag: el.tagName.toLowerCase(),
+    text: (el.textContent?.trim() ?? "").slice(0, 100),
+    visible: isVisible(el),
+    attributes: extractKeyAttributes(el),
+    outerHTML: sanitizeOuterHTML(el),
+    label: getElementLabel(el)
+  };
+}
+function findElements(params) {
+  if (!params)
+    return { count: 0, elements: [] };
+  const limit = params.limit ?? 20;
+  const candidates = findMatchingElements({ ...params, scanAll: true });
+  return { count: candidates.length, elements: candidates.slice(0, limit).map(buildElementInfo) };
+}
+
+// apps/extension/src/content/wait-for.ts
+function getInterval(elapsed) {
+  if (elapsed < 2000)
+    return 100;
+  if (elapsed < 5000)
+    return 200;
+  return 500;
+}
+function waitFor(params) {
+  const selector = params?.selector;
+  if (!selector)
+    return Promise.resolve({ matched: false, timeElapsed: 0 });
+  const condition = params?.condition ?? "appear";
+  const timeoutMs = params?.timeout ?? 1e4;
+  const start = Date.now();
+  function getVisibleCount(sel) {
+    let els;
+    try {
+      els = document.querySelectorAll(sel);
+    } catch {
+      return { total: 0, visible: 0 };
+    }
+    let visible = 0;
+    for (const el of els) {
+      if (isVisible(el))
+        visible++;
+    }
+    return { total: els.length, visible };
+  }
+  const initial = getVisibleCount(selector);
+  let stableCount = 0;
+  const STABLE_THRESHOLD = 2;
+  return new Promise((resolve) => {
+    function check() {
+      const elapsed = Date.now() - start;
+      const current = getVisibleCount(selector);
+      if (elapsed > timeoutMs) {
+        resolve({ matched: false, timeElapsed: Date.now() - start });
+        return;
+      }
+      let met = false;
+      if (condition === "appear") {
+        met = current.visible > 0;
+      } else if (condition === "disappear") {
+        met = current.total === 0 || current.visible === 0;
+      } else if (condition === "count_change") {
+        const changed = current.visible !== initial.visible;
+        if (changed) {
+          stableCount++;
+          if (stableCount < STABLE_THRESHOLD) {
+            met = false;
+          } else {
+            met = true;
+          }
+        } else {
+          stableCount = 0;
+          met = false;
+        }
+      }
+      if (met) {
+        resolve({ matched: true, timeElapsed: Date.now() - start });
+        return;
+      }
+      setTimeout(check, getInterval(elapsed));
+    }
+    check();
+  });
+}
+
+// apps/extension/src/content/scroll.ts
+function scrollPage(params) {
+  if (params?.intoView) {
+    try {
+      const el = document.querySelector(params.intoView);
+      if (el) {
+        el.scrollIntoView({ behavior: "smooth", block: "center" });
+        return { scrolled: true, scrollX: window.scrollX, scrollY: window.scrollY };
+      }
+    } catch {}
+    return { scrolled: false, scrollX: window.scrollX, scrollY: window.scrollY };
+  }
+  if (params?.scrollTo === "top") {
+    window.scrollTo(0, 0);
+    return { scrolled: true, scrollX: 0, scrollY: 0 };
+  }
+  if (params?.scrollTo === "bottom") {
+    window.scrollTo(0, document.body.scrollHeight);
+    return { scrolled: true, scrollX: window.scrollX, scrollY: document.body.scrollHeight };
+  }
+  const amount = params?.amount ?? window.innerHeight;
+  const dir = params?.direction ?? "down";
+  const dx = dir === "left" ? -amount : dir === "right" ? amount : 0;
+  const dy = dir === "up" ? -amount : dir === "down" ? amount : 0;
+  const target = params?.selector ? document.querySelector(params.selector) : null;
+  if (target) {
+    target.scrollBy(dx, dy);
+  } else {
+    window.scrollBy(dx, dy);
+  }
+  return { scrolled: true, scrollX: window.scrollX, scrollY: window.scrollY };
+}
+
+// apps/extension/src/content/press-key.ts
+function pressKey(params) {
+  if (!params?.key)
+    return { dispatched: false, count: 0 };
+  const repeatCount = params.repeat ?? 1;
+  const mods = params.modifiers ?? [];
+  const target = params.selector ? document.querySelector(params.selector) : document.activeElement;
+  if (!target)
+    return { dispatched: false, count: 0 };
+  for (let i = 0;i < repeatCount; i++) {
+    const eventInit = {
+      key: params.key,
+      code: params.key,
+      bubbles: true,
+      cancelable: true,
+      ctrlKey: mods.includes("Control") || mods.includes("ctrlKey"),
+      shiftKey: mods.includes("Shift") || mods.includes("shiftKey"),
+      altKey: mods.includes("Alt") || mods.includes("altKey"),
+      metaKey: mods.includes("Meta") || mods.includes("metaKey")
+    };
+    target.dispatchEvent(new KeyboardEvent("keydown", eventInit));
+    target.dispatchEvent(new KeyboardEvent("keyup", eventInit));
+  }
+  return { dispatched: true, count: repeatCount };
+}
+
+// apps/extension/src/content/get-attributes.ts
+function getAttributes(params) {
+  if (!params?.selector)
+    return { count: 0, elements: [] };
+  const limit = params.limit ?? 20;
+  const attrNames = params.attributes;
+  let els;
+  try {
+    els = document.querySelectorAll(params.selector);
+  } catch {
+    return { count: 0, elements: [] };
+  }
+  const elements = [];
+  for (const el of els) {
+    if (elements.length >= limit)
+      break;
+    const htmlEl = el;
+    const sensitive = isSensitiveInput(htmlEl);
+    const attrs = {};
+    if (attrNames && attrNames.length > 0) {
+      for (const name of attrNames) {
+        if (sensitive && name === "value")
+          continue;
+        const val = htmlEl.getAttribute(name);
+        if (val !== null)
+          attrs[name] = val;
+      }
+    } else {
+      for (const attr of htmlEl.attributes) {
+        if (sensitive && attr.name === "value")
+          continue;
+        attrs[attr.name] = attr.value;
+      }
+    }
+    elements.push({ tag: htmlEl.tagName.toLowerCase(), attributes: attrs });
+  }
+  return { count: els.length, elements };
+}
+
+// apps/extension/src/content/get-bounds.ts
+function getBounds(params) {
+  const selector = params?.selector;
+  if (!selector)
+    return { bounds: [] };
+  const all = params?.all ?? false;
+  const els = all ? Array.from(document.querySelectorAll(selector)) : (() => {
+    const el = document.querySelector(selector);
+    return el ? [el] : [];
+  })();
+  const sX = window.scrollX;
+  const sY = window.scrollY;
+  const bounds = els.map((el, i) => {
+    const rect = el.getBoundingClientRect();
+    const vw = window.innerWidth;
+    const vh = window.innerHeight;
+    const visible = rect.bottom > 0 && rect.top < vh && rect.right > 0 && rect.left < vw && rect.width > 0 && rect.height > 0;
+    return {
+      index: i,
+      selector,
+      tag: el.tagName,
+      text: (el.textContent ?? "").trim().slice(0, 100),
+      x: Math.round(rect.x),
+      y: Math.round(rect.y),
+      width: Math.round(rect.width),
+      height: Math.round(rect.height),
+      scrollX: Math.round(sX),
+      scrollY: Math.round(sY),
+      pageX: Math.round(rect.x + sX),
+      pageY: Math.round(rect.y + sY),
+      visible
+    };
+  });
+  return { bounds };
+}
+
+// apps/extension/src/content/annotate.ts
+var annotationMap = new Map;
+var nextAnnotationId = 1;
+function applyAnnotations(params) {
+  const items = params?.annotations ?? [];
+  const results = [];
+  for (const item of items) {
+    const id = nextAnnotationId++;
+    let element;
+    switch (item.type) {
+      case "rect":
+        element = createRect(item);
+        break;
+      case "arrow":
+        element = createArrow(id, item);
+        break;
+      case "text":
+        element = createText(item);
+        break;
+      case "mosaic":
+        element = createMosaic(item);
+        break;
+      case "badge":
+        element = createBadge(item);
+        break;
+      default:
+        continue;
+    }
+    element.setAttribute("data-mcp-annotate", String(id));
+    document.body.appendChild(element);
+    annotationMap.set(id, { id, type: item.type, element });
+    results.push({ id, type: item.type });
+  }
+  return { annotations: results };
+}
+function clearAnnotations(params) {
+  const ids = params?.ids;
+  if (ids && ids.length > 0) {
+    let cleared = 0;
+    for (const id of ids) {
+      const entry = annotationMap.get(id);
+      if (entry) {
+        entry.element.remove();
+        annotationMap.delete(id);
+        cleared++;
+      }
+    }
+    return { cleared };
+  }
+  const count = annotationMap.size;
+  for (const entry of annotationMap.values()) {
+    entry.element.remove();
+  }
+  annotationMap.clear();
+  return { cleared: count };
+}
+function createRect(item) {
+  const div = document.createElement("div");
+  const color = item.color ?? "red";
+  const lineWidth = item.lineWidth ?? 3;
+  Object.assign(div.style, {
+    position: "absolute",
+    left: `${item.x ?? 0}px`,
+    top: `${item.y ?? 0}px`,
+    width: `${item.width ?? 0}px`,
+    height: `${item.height ?? 0}px`,
+    border: `${lineWidth}px solid ${color}`,
+    boxSizing: "border-box",
+    pointerEvents: "none",
+    zIndex: "2147483646"
+  });
+  return div;
+}
+function createArrow(id, item) {
+  const fromX = item.fromX ?? 0;
+  const fromY = item.fromY ?? 0;
+  const toX = item.toX ?? 0;
+  const toY = item.toY ?? 0;
+  const color = item.color ?? "red";
+  const lineWidth = item.lineWidth ?? 3;
+  const pad = 20;
+  const minX = Math.min(fromX, toX) - pad;
+  const minY = Math.min(fromY, toY) - pad;
+  const maxX = Math.max(fromX, toX) + pad;
+  const maxY = Math.max(fromY, toY) + pad;
+  const ns = "http://www.w3.org/2000/svg";
+  const svg = document.createElementNS(ns, "svg");
+  svg.setAttribute("xmlns", ns);
+  svg.style.position = "absolute";
+  svg.style.left = `${minX}px`;
+  svg.style.top = `${minY}px`;
+  svg.style.width = `${maxX - minX}px`;
+  svg.style.height = `${maxY - minY}px`;
+  svg.style.overflow = "visible";
+  svg.style.pointerEvents = "none";
+  svg.style.zIndex = "2147483646";
+  const defs = document.createElementNS(ns, "defs");
+  const marker = document.createElementNS(ns, "marker");
+  const markerId = `mcp-arrow-${id}`;
+  marker.setAttribute("id", markerId);
+  marker.setAttribute("markerWidth", "10");
+  marker.setAttribute("markerHeight", "7");
+  marker.setAttribute("refX", "10");
+  marker.setAttribute("refY", "3.5");
+  marker.setAttribute("orient", "auto");
+  const polygon = document.createElementNS(ns, "polygon");
+  polygon.setAttribute("points", "0 0, 10 3.5, 0 7");
+  polygon.setAttribute("fill", color);
+  marker.appendChild(polygon);
+  defs.appendChild(marker);
+  svg.appendChild(defs);
+  const line = document.createElementNS(ns, "line");
+  line.setAttribute("x1", String(fromX - minX));
+  line.setAttribute("y1", String(fromY - minY));
+  line.setAttribute("x2", String(toX - minX));
+  line.setAttribute("y2", String(toY - minY));
+  line.setAttribute("stroke", color);
+  line.setAttribute("stroke-width", String(lineWidth));
+  line.setAttribute("marker-end", `url(#${markerId})`);
+  svg.appendChild(line);
+  return svg;
+}
+function createText(item) {
+  const div = document.createElement("div");
+  const color = item.color ?? "white";
+  const fontSize = item.fontSize ?? 16;
+  const bg = item.backgroundColor ?? "rgba(0,0,0,0.8)";
+  Object.assign(div.style, {
+    position: "absolute",
+    left: `${item.x ?? 0}px`,
+    top: `${item.y ?? 0}px`,
+    color,
+    fontSize: `${fontSize}px`,
+    fontFamily: "Arial, Helvetica, sans-serif",
+    fontWeight: "bold",
+    backgroundColor: bg,
+    padding: "4px 8px",
+    borderRadius: "4px",
+    whiteSpace: "nowrap",
+    pointerEvents: "none",
+    zIndex: "2147483646",
+    lineHeight: "1.4"
+  });
+  div.textContent = item.text ?? "";
+  return div;
+}
+function createMosaic(item) {
+  const div = document.createElement("div");
+  const blur = item.blur ?? 10;
+  Object.assign(div.style, {
+    position: "absolute",
+    left: `${item.x ?? 0}px`,
+    top: `${item.y ?? 0}px`,
+    width: `${item.width ?? 0}px`,
+    height: `${item.height ?? 0}px`,
+    backdropFilter: `blur(${blur}px)`,
+    WebkitBackdropFilter: `blur(${blur}px)`,
+    pointerEvents: "none",
+    zIndex: "2147483646"
+  });
+  return div;
+}
+function createBadge(item) {
+  const div = document.createElement("div");
+  const color = item.color ?? "red";
+  Object.assign(div.style, {
+    position: "absolute",
+    left: `${(item.x ?? 0) - 12}px`,
+    top: `${(item.y ?? 0) - 12}px`,
+    width: "24px",
+    height: "24px",
+    borderRadius: "50%",
+    backgroundColor: color,
+    color: "white",
+    fontSize: "12px",
+    fontWeight: "bold",
+    fontFamily: "Arial, sans-serif",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    zIndex: "2147483646",
+    boxShadow: "0 2px 4px rgba(0,0,0,0.3)",
+    pointerEvents: "none"
+  });
+  div.textContent = String(item.number ?? 0);
+  return div;
+}
+
+// apps/extension/src/content/extract.ts
+var CURRENCY_RE = /^[\s]*[¥$€£₹₩₫₱₿][\s]*[\d,.]+|[\d,.]+[\s]*[¥$€£₹₩₫₱₿]|[\d,.]+\s*(USD|EUR|GBP|JPY|CNY|KRW|BRL|INR|kr|R\$)/i;
+var RATING_ATTR_RE = /^(data-)?rat(e|ing)|score|stars?$/i;
+var ALL_SEMANTIC_TYPES = ["title", "price", "url", "image", "rating", "description", "date", "author"];
+function extractData(params) {
+  const { multiple = true } = params;
+  let { fields } = params;
+  const autoInfer = !fields || Object.keys(fields).length === 0;
+  const effectiveRoot = autoInfer && !params.root ? "auto" : params.root;
+  const extractionMeta = {
+    mode: autoInfer ? "auto" : "explicit",
+    rootResolution: "explicit",
+    fieldResolution: autoInfer ? "inferred" : "explicit"
+  };
+  let roots;
+  if (effectiveRoot === "auto") {
+    const discoveryFields = autoInfer ? Object.fromEntries(ALL_SEMANTIC_TYPES.map((s) => [s, { semantic: s }])) : fields;
+    roots = discoverRepeatingRoots(discoveryFields);
+    if (roots.length > 0) {
+      extractionMeta.rootResolution = "discovered";
+      const first = roots[0];
+      const tag = first.tagName.toLowerCase();
+      const cls = first.className ? `.${first.className.trim().split(/\s+/).join(".")}` : "";
+      extractionMeta.discoveredRoot = `${tag}${cls}`;
+    }
+    if (roots.length === 0 && autoInfer) {
+      roots = [document.body];
+      extractionMeta.rootResolution = "body_fallback";
+    }
+  } else if (effectiveRoot) {
+    try {
+      const all = document.querySelectorAll(effectiveRoot);
+      roots = Array.from(all);
+    } catch {
+      return { items: [], total: 0, errors: [`Invalid root selector: "${effectiveRoot}"`] };
+    }
+  } else {
+    roots = [document.body];
+  }
+  if (!multiple && roots.length > 0) {
+    roots = [roots[0]];
+  }
+  if (autoInfer && roots.length > 0) {
+    const inferredFields = {};
+    const sample = roots[0];
+    for (const semantic of ALL_SEMANTIC_TYPES) {
+      const resolved = resolveSemanticField(sample, semantic, {});
+      if (resolved.value !== null && resolved.value !== false) {
+        inferredFields[semantic] = { semantic };
+      }
+    }
+    fields = inferredFields;
+    if (Object.keys(inferredFields).length === 0 && roots[0] !== document.body) {
+      roots = [document.body];
+      extractionMeta.rootResolution = "body_fallback";
+      const bodyFields = {};
+      for (const semantic of ALL_SEMANTIC_TYPES) {
+        const resolved = resolveSemanticField(document.body, semantic, {});
+        if (resolved.value !== null && resolved.value !== false) {
+          bodyFields[semantic] = { semantic };
+        }
+      }
+      fields = bodyFields;
+    }
+    const resolvedCount = Object.keys(fields).length;
+    extractionMeta.resolvedFieldCount = resolvedCount;
+    extractionMeta.fieldCoverage = resolvedCount / ALL_SEMANTIC_TYPES.length;
+  }
+  if (!fields || Object.keys(fields).length === 0) {
+    return { items: [], total: 0, extractionMeta };
+  }
+  const items = [];
+  const errors = [];
+  const meta = {};
+  let hasSemantic = false;
+  for (const spec of Object.values(fields)) {
+    if (spec.semantic)
+      hasSemantic = true;
+  }
+  for (let i = 0;i < roots.length; i++) {
+    const root = roots[i];
+    const item = {};
+    for (const [fieldName, spec] of Object.entries(fields)) {
+      let value;
+      if (spec.selector) {
+        value = extractField(root, spec);
+        if (i === 0) {
+          meta[fieldName] = { matchedBy: spec.semantic ? `selector (semantic:${spec.semantic} available)` : "selector", resolvedSelector: spec.selector };
+        }
+      } else if (spec.semantic) {
+        const resolved = resolveSemanticField(root, spec.semantic, spec);
+        value = resolved.value;
+        if (i === 0) {
+          meta[fieldName] = { matchedBy: `semantic:${spec.semantic}`, resolvedSelector: resolved.selector };
+        }
+      } else {
+        value = null;
+      }
+      item[fieldName] = value;
+      const isMissing = value === null || spec.type === "exists" && value === false;
+      if (spec.required && isMissing) {
+        const target = spec.selector ?? spec.semantic ?? "unknown";
+        errors.push(`Required field "${fieldName}" not found in root[${i}] (${target})`);
+      }
+    }
+    items.push(item);
+  }
+  return {
+    items,
+    total: items.length,
+    ...errors.length > 0 ? { errors } : {},
+    ...hasSemantic ? { meta } : {},
+    extractionMeta
+  };
+}
+function extractField(root, spec) {
+  const type = spec.type ?? "text";
+  let el;
+  try {
+    el = root.querySelector(spec.selector);
+  } catch {
+    return null;
+  }
+  if (!el) {
+    return type === "exists" ? false : null;
+  }
+  return extractValue(el, type, spec.attr);
+}
+function extractValue(el, type, attr) {
+  switch (type) {
+    case "text":
+      return (el.textContent ?? "").trim() || null;
+    case "attr":
+      if (!attr)
+        return null;
+      return el.getAttribute(attr);
+    case "html": {
+      const clone = el.cloneNode(true);
+      for (const input of clone.querySelectorAll("input")) {
+        if (isSensitiveInput(input)) {
+          input.removeAttribute("value");
+        }
+      }
+      return clone.innerHTML;
+    }
+    case "exists":
+      return true;
+    default:
+      return null;
+  }
+}
+function contentScopedQuery(root, selector) {
+  if (root !== document.body) {
+    return root.querySelector(selector);
+  }
+  for (const scope of ["main", "[role='main']", "article", "#content", "#dp-container", ".content"]) {
+    const container = root.querySelector(scope);
+    if (container) {
+      const el = container.querySelector(selector);
+      if (el)
+        return el;
+    }
+  }
+  return root.querySelector(selector);
+}
+function contentScopedQueryAll(root, selector) {
+  if (root !== document.body) {
+    return Array.from(root.querySelectorAll(selector));
+  }
+  for (const scope of ["main", "[role='main']", "article", "#content", "#dp-container", ".content"]) {
+    const container = root.querySelector(scope);
+    if (container) {
+      const els = Array.from(container.querySelectorAll(selector));
+      if (els.length > 0)
+        return els;
+    }
+  }
+  return Array.from(root.querySelectorAll(selector));
+}
+function resolveSemanticField(root, semantic, _spec) {
+  switch (semantic) {
+    case "title":
+      return resolveTitle(root);
+    case "price":
+      return resolvePrice(root);
+    case "url":
+      return resolveUrl(root);
+    case "image":
+      return resolveImage(root);
+    case "rating":
+      return resolveRating(root);
+    case "description":
+      return resolveDescription(root);
+    case "date":
+      return resolveByAttrOrClass(root, ["date", "time", "published", "created"], "time");
+    case "author":
+      return resolveByAttrOrClass(root, ["author", "byline", "writer"], undefined);
+    default:
+      return { value: null };
+  }
+}
+function isInsideTemplate(el) {
+  let parent = el.parentElement;
+  while (parent) {
+    if (parent.tagName === "TEMPLATE")
+      return true;
+    parent = parent.parentElement;
+  }
+  return false;
+}
+function isHiddenElement(el) {
+  const htmlEl = el;
+  if (htmlEl.offsetParent === null && htmlEl.tagName !== "BODY" && htmlEl.tagName !== "HTML") {
+    const style = getComputedStyle(htmlEl);
+    if (style.display === "none" || style.visibility === "hidden")
+      return true;
+    if (style.position !== "fixed" && style.position !== "sticky")
+      return true;
+  }
+  if (el.getAttribute("aria-hidden") === "true")
+    return true;
+  return false;
+}
+function querySelectorVisible(root, selector) {
+  const candidates = root.querySelectorAll(selector);
+  for (const el of candidates) {
+    if (isInsideTemplate(el))
+      continue;
+    if (isHiddenElement(el))
+      continue;
+    return el;
+  }
+  return null;
+}
+function isMeaningfulTitle(text) {
+  if (text.length <= 2)
+    return false;
+  if (/^\d+\.?$/.test(text))
+    return false;
+  if (/^[#\-\*•→►▶]+$/.test(text))
+    return false;
+  return true;
+}
+function resolveTitle(root) {
+  for (const sel of ["h1", "h2", "h3", "h4"]) {
+    const el = querySelectorVisible(root, sel);
+    if (el) {
+      const text = (el.textContent ?? "").trim();
+      if (isMeaningfulTitle(text))
+        return { value: text, selector: sel };
+    }
+  }
+  const itemprop = root.querySelector('[itemprop="name"]');
+  if (itemprop) {
+    const text = (itemprop.textContent ?? "").trim();
+    if (isMeaningfulTitle(text))
+      return { value: text, selector: '[itemprop="name"]' };
+  }
+  const links = root.querySelectorAll("a[href]");
+  for (const link of links) {
+    if (isInsideTemplate(link) || isHiddenElement(link))
+      continue;
+    const href = link.getAttribute("href") ?? "";
+    if (href.startsWith("vote?") || href.startsWith("javascript:") || href === "#")
+      continue;
+    const text = (link.textContent ?? "").trim();
+    if (isMeaningfulTitle(text) && text.length > 5) {
+      return { value: text, selector: "a[href]" };
+    }
+  }
+  for (const cls of ["title", "name", "heading"]) {
+    const el = root.querySelector(`[class*="${cls}"]`);
+    if (el) {
+      const text = (el.textContent ?? "").trim();
+      if (isMeaningfulTitle(text))
+        return { value: text, selector: `[class*="${cls}"]` };
+    }
+  }
+  return { value: null };
+}
+function resolvePrice(root) {
+  const itemprop = root.querySelector('[itemprop="price"]');
+  if (itemprop) {
+    const text = (itemprop.textContent ?? "").trim();
+    if (text)
+      return { value: text, selector: '[itemprop="price"]' };
+  }
+  for (const cls of ["price", "cost", "amount"]) {
+    const el = root.querySelector(`[class*="${cls}"]`);
+    if (el) {
+      const text = (el.textContent ?? "").trim();
+      if (text)
+        return { value: text, selector: `[class*="${cls}"]` };
+    }
+  }
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  for (let node = walker.nextNode();node; node = walker.nextNode()) {
+    const text = (node.textContent ?? "").trim();
+    if (text && CURRENCY_RE.test(text)) {
+      const parent = node.parentElement;
+      if (parent && parent !== root) {
+        return { value: text, selector: describeElement2(parent) };
+      }
+    }
+  }
+  return { value: null };
+}
+var SKIP_URL_RE = /^(vote\?|javascript:|#$|mailto:|tel:)/;
+function resolveUrl(root) {
+  const links = root.querySelectorAll("a[href]");
+  if (links.length === 0)
+    return { value: null };
+  let best = null;
+  for (const link of links) {
+    const href = link.getAttribute("href") ?? "";
+    if (SKIP_URL_RE.test(href))
+      continue;
+    const text = (link.textContent ?? "").trim();
+    let score = 0;
+    if (href.startsWith("http"))
+      score += 10;
+    score += Math.min(text.length, 50) / 5;
+    if (text.length > 3)
+      score += 5;
+    if (!best || score > best.score) {
+      best = { el: link, score };
+    }
+  }
+  if (best) {
+    return { value: best.el.getAttribute("href"), selector: "a[href]" };
+  }
+  return { value: null };
+}
+function resolveImage(root) {
+  const imgs = contentScopedQueryAll(root, "img[src]");
+  let bestWithAlt = null;
+  let bestWithoutAlt = null;
+  for (const img of imgs) {
+    const src = img.getAttribute("src");
+    if (!src)
+      continue;
+    if (src.startsWith("data:") && src.length < 200)
+      continue;
+    const w = parseInt(img.getAttribute("width") ?? "0", 10);
+    const h = parseInt(img.getAttribute("height") ?? "0", 10);
+    if (w > 0 && h > 0 && (w < 50 || h < 50))
+      continue;
+    if (src.includes("sprite") || src.includes("pixel") || src.includes("spacer"))
+      continue;
+    const hasAlt = !!img.getAttribute("alt");
+    if (hasAlt && !bestWithAlt) {
+      bestWithAlt = img;
+    } else if (!hasAlt && !bestWithoutAlt) {
+      bestWithoutAlt = img;
+    }
+  }
+  const chosen = bestWithAlt ?? bestWithoutAlt;
+  if (chosen) {
+    return { value: chosen.getAttribute("src"), selector: "img[src]" };
+  }
+  return { value: null };
+}
+function resolveRating(root) {
+  for (const el of root.querySelectorAll("*")) {
+    for (const attr of el.getAttributeNames()) {
+      if (RATING_ATTR_RE.test(attr)) {
+        const val = el.getAttribute(attr);
+        if (val && /[\d.]+/.test(val)) {
+          return { value: val, selector: `[${attr}]` };
+        }
+      }
+    }
+  }
+  const itemprop = root.querySelector('[itemprop="ratingValue"]');
+  if (itemprop) {
+    const text = (itemprop.textContent ?? "").trim();
+    if (text)
+      return { value: text, selector: '[itemprop="ratingValue"]' };
+  }
+  for (const cls of ["rating", "score", "stars"]) {
+    const el = root.querySelector(`[class*="${cls}"]`);
+    if (el) {
+      const text = (el.textContent ?? "").trim();
+      if (text)
+        return { value: text, selector: `[class*="${cls}"]` };
+    }
+  }
+  return { value: null };
+}
+function resolveDescription(root) {
+  const itemprop = contentScopedQuery(root, '[itemprop="description"]');
+  if (itemprop) {
+    const text = (itemprop.textContent ?? "").trim();
+    if (text)
+      return { value: text, selector: '[itemprop="description"]' };
+  }
+  const p = contentScopedQuery(root, "p");
+  if (p) {
+    const text = (p.textContent ?? "").trim();
+    if (text && text.length > 20)
+      return { value: text, selector: "p" };
+  }
+  for (const cls of ["description", "desc", "summary", "excerpt"]) {
+    const el = contentScopedQuery(root, `[class*="${cls}"]`);
+    if (el) {
+      const text = (el.textContent ?? "").trim();
+      if (text)
+        return { value: text, selector: `[class*="${cls}"]` };
+    }
+  }
+  return { value: null };
+}
+function resolveByAttrOrClass(root, keywords, tagHint) {
+  if (tagHint) {
+    const el = root.querySelector(tagHint);
+    if (el) {
+      const datetime = el.getAttribute("datetime");
+      if (datetime)
+        return { value: datetime, selector: tagHint };
+      const text = (el.textContent ?? "").trim();
+      if (text)
+        return { value: text, selector: tagHint };
+    }
+  }
+  for (const kw of keywords) {
+    const el = root.querySelector(`[itemprop="${kw}"]`);
+    if (el) {
+      const text = (el.textContent ?? "").trim();
+      if (text)
+        return { value: text, selector: `[itemprop="${kw}"]` };
+    }
+  }
+  for (const kw of keywords) {
+    const el = root.querySelector(`[class*="${kw}"]`);
+    if (el) {
+      const text = (el.textContent ?? "").trim();
+      if (text)
+        return { value: text, selector: `[class*="${kw}"]` };
+    }
+  }
+  return { value: null };
+}
+function describeElement2(el) {
+  const tag = el.tagName.toLowerCase();
+  const id = el.id ? `#${el.id}` : "";
+  const cls = el.className && typeof el.className === "string" ? "." + el.className.trim().split(/\s+/).slice(0, 2).join(".") : "";
+  return `${tag}${id}${cls}`;
+}
+var MIN_REPEATING = 2;
+function discoverRepeatingRoots(fields) {
+  const candidates = [];
+  const articles = document.querySelectorAll("article");
+  if (articles.length >= MIN_REPEATING) {
+    const articleScore = scoreCandidate(Array.from(articles), fields);
+    candidates.push({
+      elements: Array.from(articles),
+      score: articleScore > 0 ? articleScore * 2 : 0
+    });
+  }
+  for (const list of document.querySelectorAll("ul, ol")) {
+    const lis = Array.from(list.children).filter((c) => c.tagName === "LI");
+    if (lis.length >= MIN_REPEATING) {
+      candidates.push({
+        elements: lis,
+        score: scoreCandidate(lis, fields)
+      });
+    }
+  }
+  const scanned = new Set;
+  const containers = [document.body, ...Array.from(document.querySelectorAll("main, section, div, [role='main'], [role='list']"))];
+  for (const container of containers) {
+    if (scanned.has(container))
+      continue;
+    scanned.add(container);
+    const signatureGroups = new Map;
+    for (const child of container.children) {
+      const sig = elementSignature(child);
+      if (!sig)
+        continue;
+      if (!signatureGroups.has(sig))
+        signatureGroups.set(sig, []);
+      signatureGroups.get(sig).push(child);
+    }
+    for (const group of signatureGroups.values()) {
+      if (group.length >= MIN_REPEATING) {
+        candidates.push({
+          elements: group,
+          score: scoreCandidate(group, fields)
+        });
+      }
+    }
+  }
+  for (const table of document.querySelectorAll("table")) {
+    const trGroups = new Map;
+    for (const tr of table.querySelectorAll("tr")) {
+      const cls = tr.className && typeof tr.className === "string" ? tr.className.trim() : "";
+      if (!cls)
+        continue;
+      if (!trGroups.has(cls))
+        trGroups.set(cls, []);
+      trGroups.get(cls).push(tr);
+    }
+    for (const group of trGroups.values()) {
+      if (group.length >= MIN_REPEATING) {
+        candidates.push({
+          elements: group,
+          score: scoreCandidate(group, fields)
+        });
+      }
+    }
+  }
+  const customTagCounts = new Map;
+  for (const el of document.querySelectorAll("*")) {
+    const tag = el.tagName.toLowerCase();
+    if (tag.includes("-") && !tag.startsWith("x-") || tag.startsWith("shreddit-") || tag.startsWith("yt-")) {
+      if (!customTagCounts.has(tag))
+        customTagCounts.set(tag, []);
+      customTagCounts.get(tag).push(el);
+    }
+  }
+  for (const [, group] of customTagCounts) {
+    if (group.length >= MIN_REPEATING) {
+      candidates.push({
+        elements: group,
+        score: scoreCandidate(group, fields)
+      });
+    }
+  }
+  if (candidates.length === 0)
+    return [];
+  candidates.sort((a, b) => b.score - a.score);
+  return candidates[0].elements;
+}
+function scoreCandidate(elements, fields) {
+  const count = elements.length;
+  const semanticFields = Object.values(fields).filter((f) => f.semantic);
+  if (semanticFields.length === 0)
+    return count;
+  const sample = elements[0];
+  let filled = 0;
+  for (const spec of semanticFields) {
+    if (spec.semantic) {
+      const resolved = resolveSemanticField(sample, spec.semantic, spec);
+      if (resolved.value !== null && resolved.value !== false)
+        filled++;
+    }
+  }
+  const coverage = filled / semanticFields.length;
+  const sample0 = elements[0];
+  const inNav = !!sample0.closest("nav, header, footer, [role='navigation'], [role='banner'], [role='contentinfo']");
+  const navPenalty = inNav ? 0.3 : 1;
+  const inMain = !!sample0.closest("main, [role='main'], article, section, #content, .content");
+  const mainBonus = inMain ? 1.5 : 1;
+  if (coverage === 0)
+    return 0;
+  if (elements.length >= 3) {
+    const sampleTexts = elements.slice(0, Math.min(5, elements.length)).map((el) => (el.textContent ?? "").trim().slice(0, 50));
+    const allSame = sampleTexts.every((t) => t === sampleTexts[0]);
+    if (allSame)
+      return 0;
+  }
+  return (coverage * 10 + Math.min(count, 20)) * navPenalty * mainBonus;
+}
+function elementSignature(el) {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "script" || tag === "style" || tag === "link" || tag === "meta")
+    return null;
+  const cls = el.className && typeof el.className === "string" ? el.className.trim().split(/\s+/).sort().join(" ") : "";
+  return `${tag}:${cls}`;
+}
+
+// apps/extension/src/content.ts
+var CONTENT_SCRIPT_VERSION = 37;
+if (window.__mcp_listener) {
+  try {
+    chrome.runtime.onMessage.removeListener(window.__mcp_listener);
+  } catch {}
+}
+var mcpListener = (request, _sender, sendResponse) => {
+  if (!chrome.runtime?.id) {
+    return false;
+  }
+  if (!request || !request.action) {
+    sendResponse({ error: "Invalid request: missing action" });
+    return true;
+  }
+  handleAction(request.action, request.params).then((result) => sendResponse(result)).catch((e) => {
+    const msg = e instanceof Error ? e.message : String(e);
+    sendResponse({ error: msg });
+  });
+  return true;
+};
+window.__mcp_listener = mcpListener;
+window.__mcp_content_version = CONTENT_SCRIPT_VERSION;
+chrome.runtime.onMessage.addListener(mcpListener);
+for (const el of document.querySelectorAll("[data-mcp-annotate]")) {
+  el.remove();
+}
+async function handleAction(action, params) {
+  const SKIP_WAIT = new Set(["click_element", "wait_for", "get_bounds", "annotate", "clear_annotations", "diagnose_interaction"]);
+  if (!SKIP_WAIT.has(action)) {
+    await waitForContent();
+  }
+  switch (action) {
+    case "get_page":
+      return getPage();
+    case "click_element":
+      return clickElement(params);
+    case "action_element":
+      return actionElement(params);
+    case "set_value":
+      return setValue(params);
+    case "paste_file":
+      return pasteFile(params);
+    case "query_selector":
+      return queryElements(params);
+    case "find_elements":
+      return findElements(params);
+    case "wait_for":
+      return waitFor(params);
+    case "scroll":
+      return scrollPage(params);
+    case "press_key":
+      return pressKey(params);
+    case "get_attributes":
+      return getAttributes(params);
+    case "get_bounds":
+      return getBounds(params);
+    case "annotate":
+      return applyAnnotations(params);
+    case "clear_annotations":
+      return clearAnnotations(params);
+    case "extract_data": {
+      const fields = {};
+      if (params && typeof params === "object" && "fields" in params) {
+        const rawFields = params.fields;
+        if (rawFields && typeof rawFields === "object") {
+          for (const [k, v] of Object.entries(rawFields)) {
+            if (v && typeof v === "object") {
+              const spec = v;
+              fields[k] = {
+                ...spec.selector ? { selector: String(spec.selector) } : {},
+                ...spec.semantic ? { semantic: String(spec.semantic) } : {},
+                ...spec.type ? { type: String(spec.type) } : {},
+                ...spec.attr ? { attr: String(spec.attr) } : {},
+                ...spec.required ? { required: true } : {}
+              };
+            }
+          }
+        }
+      }
+      return extractData({
+        root: params?.selector,
+        multiple: params?.all !== false,
+        fields
+      });
+    }
+    case "diagnose_interaction": {
+      const diag = diagnoseElement(params ?? {});
+      return {
+        canInteract: diag.reason === "ok",
+        reason: diag.reason,
+        ...diag.details ? { details: diag.details } : {},
+        ...diag.candidates ? { candidates: diag.candidates } : {}
+      };
+    }
+    default:
+      return { error: `Unknown action: ${action}` };
+  }
+}