mcp-scraper 0.2.24 → 0.3.0

package/dist/bin/mcp-scraper-combined-stdio-server.cjs

@@ -1,10 +1,32 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // bin/mcp-scraper-combined-stdio-server.ts
-var import_node_fs6 = require("fs");
-var import_node_os6 = require("os");
-var import_node_path8 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_os7 = require("os");
+var import_node_path9 = require("path");
 var import_mcp3 = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
@@ -246,9 +268,9 @@ var HttpMcpToolExecutor = class {
 
 // src/mcp/browser-agent-mcp-server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_node_fs3 = require("fs");
-var import_node_os4 = require("os");
-var import_node_path5 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_os5 = require("os");
+var import_node_path6 = require("path");
 
 // src/lib/chrome-profiles.ts
 var import_promises = require("fs/promises");
@@ -470,18 +492,834 @@ async function syncImportedChromeProfile(name, options = {}) {
 
 // src/services/browser-agent/local-browser-agent-service.ts
 var import_node_crypto = require("crypto");
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+var import_playwright_extra = require("playwright-extra");
+var import_puppeteer_extra_plugin_stealth = __toESM(require("puppeteer-extra-plugin-stealth"), 1);
+
+// src/services/fanout/cdp-capture.ts
+var ANSWER_RE = /\/backend-api\/(f\/)?conversation$|\/chat_conversations\/[^/]+\/(completion|retry_completion)$|\/completion$/i;
+var FanoutCdpCapture = class {
+  client = null;
+  reqUrl = /* @__PURE__ */ new Map();
+  ctById = /* @__PURE__ */ new Map();
+  answerIds = /* @__PURE__ */ new Set();
+  bodies = [];
+  pending = [];
+  answerStreams = 0;
+  async attach(page) {
+    if (this.client) return;
+    const client = await page.context().newCDPSession(page);
+    this.client = client;
+    await client.send("Network.enable", { maxTotalBufferSize: 2e8, maxResourceBufferSize: 2e8 });
+    client.on("Network.requestWillBeSent", (e) => {
+      const id = e.requestId;
+      const req = e.request;
+      if (id) this.reqUrl.set(id, req?.url || "");
+    });
+    client.on("Network.responseReceived", (e) => {
+      const id = e.requestId;
+      const res = e.response;
+      const url = res?.url || this.reqUrl.get(id) || "";
+      const headers = res?.headers || {};
+      const ct = String(headers["content-type"] || headers["Content-Type"] || "");
+      if (id) this.ctById.set(id, ct);
+      if (id && (this.isAnswerUrl(url) || /event-stream/i.test(ct))) this.answerIds.add(id);
+    });
+    client.on("Network.loadingFinished", (e) => this.grab(e.requestId));
+  }
+  reset() {
+    this.bodies = [];
+    this.answerStreams = 0;
+    this.answerIds.clear();
+    this.pending = [];
+  }
+  answerStreamCount() {
+    return this.answerStreams;
+  }
+  async drain() {
+    await Promise.all(this.pending);
+  }
+  bestAnswerText() {
+    const eventStreams = this.bodies.filter((b) => /event-stream/i.test(b.ct));
+    const answerStreams = eventStreams.filter((b) => this.isAnswerUrl(b.url)).sort((a, b) => b.text.length - a.text.length);
+    if (answerStreams.length) return answerStreams.map((b) => b.text).join("\n");
+    const answerJson = this.bodies.filter((b) => this.isAnswerUrl(b.url)).sort((a, b) => b.text.length - a.text.length);
+    if (answerJson.length) return answerJson[0].text;
+    if (eventStreams.length) return eventStreams.sort((a, b) => b.text.length - a.text.length)[0].text;
+    return "";
+  }
+  async detach() {
+    try {
+      await this.client?.detach();
+    } catch {
+      this.client = null;
+    }
+    this.client = null;
+  }
+  isAnswerUrl(url) {
+    let path = "";
+    try {
+      path = new URL(url).pathname;
+    } catch {
+      path = String(url || "").split("?")[0];
+    }
+    return ANSWER_RE.test(path);
+  }
+  grab(requestId) {
+    if (!requestId || !this.client || !this.answerIds.has(requestId)) return;
+    const url = this.reqUrl.get(requestId) || "";
+    const ct = this.ctById.get(requestId) || "";
+    const client = this.client;
+    const p = client.send("Network.getResponseBody", { requestId }).then((r) => {
+      const text = r.base64Encoded ? Buffer.from(String(r.body), "base64").toString("utf8") : String(r.body || "");
+      if (text) {
+        this.bodies.push({ url, ct, text });
+        if (this.isAnswerUrl(url)) this.answerStreams++;
+      }
+    }).catch(() => void 0);
+    this.pending.push(p);
+  }
+};
+
+// src/services/fanout/parse-helpers.ts
+var INTERNAL = /chatgpt\.com|openai\.com|oaiusercontent|oaistatic|claude\.ai|anthropic\.com/i;
+var TRACK = /^(utm_|oai|fbclid|gclid|ref$|ref_|sa$|usg$|ved$|sca_esv$|sources$)/i;
+function domainOf(u) {
+  try {
+    return new URL(u).hostname.replace(/^www\./, "");
+  } catch {
+    return "";
+  }
+}
+function normUrl(u) {
+  try {
+    const x = new URL(u);
+    x.hash = "";
+    for (const k of [...x.searchParams.keys()]) {
+      if (TRACK.test(k)) x.searchParams.delete(k);
+    }
+    return x.toString().replace(/\/$/, "").toLowerCase();
+  } catch {
+    return String(u || "").toLowerCase();
+  }
+}
+function isExternal(u) {
+  const h = domainOf(u);
+  return Boolean(h) && !INTERNAL.test(h);
+}
+function unesc(s) {
+  try {
+    return JSON.parse('"' + s + '"');
+  } catch {
+    return String(s).replace(/\\(.)/g, "$1");
+  }
+}
+function stripCitationMarkers(s) {
+  return String(s || "").replace(/[-]/g, "").replace(/cite(?:turn\d+\w+?\d+)+/g, "").replace(/\s+/g, " ").trim();
+}
+function sliceBalanced(text, openIdx) {
+  const open = text[openIdx];
+  const close = open === "[" ? "]" : "}";
+  let depth = 0;
+  let inStr = false;
+  let esc2 = false;
+  for (let i = openIdx; i < text.length; i++) {
+    const ch = text[i];
+    if (inStr) {
+      if (esc2) esc2 = false;
+      else if (ch === "\\") esc2 = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') {
+      inStr = true;
+      continue;
+    }
+    if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0) return text.slice(openIdx, i + 1);
+    }
+  }
+  return null;
+}
+function findJsonValues(text, field) {
+  const out = [];
+  const re = new RegExp('"' + field + '"\\s*:\\s*(\\[|\\{)', "g");
+  let m;
+  while (m = re.exec(text)) {
+    const openIdx = m.index + m[0].length - 1;
+    const slice = sliceBalanced(text, openIdx);
+    if (slice) {
+      try {
+        out.push(JSON.parse(slice));
+      } catch {
+        continue;
+      }
+    }
+  }
+  return out;
+}
+function stringsInArrayBody(arrBody) {
+  const out = [];
+  const re = /"((?:[^"\\]|\\.){2,300}?)"/g;
+  let m;
+  while (m = re.exec(arrBody)) out.push(unesc(m[1]));
+  return out;
+}
+function cleanQuery(q) {
+  const t = (q || "").trim();
+  if (t.length < 2 || t.length > 300) return null;
+  return t;
+}
+
+// src/services/fanout/adapters/chatgpt.ts
+function roundOf(refId) {
+  const m = /^turn(\d+)/.exec(refId || "");
+  return m ? Number(m[1]) : null;
+}
+function normRef(r) {
+  if (typeof r === "string") {
+    const m = /turn(\d+)(search|news|ref|video|image|product)(\d+)/.exec(r);
+    return m ? `turn${m[1]}${m[2]}${m[3]}` : null;
+  }
+  if (r && typeof r === "object") {
+    const o = r;
+    if (o.turn_index != null) {
+      return `turn${o.turn_index}${o.ref_type || "search"}${o.ref_index != null ? o.ref_index : ""}`;
+    }
+  }
+  return null;
+}
+function refsInText(s) {
+  return (String(s || "").match(/turn\d+(?:search|news|ref|video|image|product)\d+/g) || []).map(normRef).filter((x) => Boolean(x));
+}
+function collectInto(arr, v) {
+  if (Array.isArray(v)) arr.push(...v);
+  else if (v && typeof v === "object") arr.push(v);
+}
+function reconstructFromSsePatches(raw) {
+  const contentReferences = [];
+  const searchResultGroups = [];
+  const citations = [];
+  const citedUrls = /* @__PURE__ */ new Set();
+  const state = { found: false };
+  const handleOp = (op) => {
+    if (!op || typeof op !== "object") return;
+    const o = op;
+    const v = o.v;
+    if (o.o === "patch" && Array.isArray(v)) {
+      state.found = true;
+      v.forEach(handleOp);
+      return;
+    }
+    const path = typeof o.p === "string" ? o.p : "";
+    if ((path === "" || path === "/message") && v && typeof v === "object") {
+      const root = v;
+      const msg = root.message || root;
+      const md = msg && msg.metadata;
+      if (md) {
+        collectInto(contentReferences, md.content_references);
+        collectInto(searchResultGroups, md.search_result_groups);
+        collectInto(citations, md.citations);
+        state.found = true;
+      }
+    }
+    if (!path) return;
+    if (/\/safe_urls$/.test(path) && Array.isArray(v)) {
+      for (const u of v) if (typeof u === "string") citedUrls.add(u);
+      state.found = true;
+    } else if (path.includes("content_references")) {
+      collectInto(contentReferences, v);
+      state.found = true;
+    } else if (path.includes("search_result_groups")) {
+      collectInto(searchResultGroups, v);
+      state.found = true;
+    } else if (path.includes("citations")) {
+      collectInto(citations, v);
+      state.found = true;
+    }
+  };
+  for (const line of raw.split("\n")) {
+    const s = (line.startsWith("data:") ? line.slice(5) : line).trim();
+    if (!s || s === "[DONE]" || s[0] !== "{" && s[0] !== "[") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(s);
+    } catch {
+      continue;
+    }
+    const ops = Array.isArray(parsed) ? parsed : [parsed];
+    ops.forEach(handleOp);
+  }
+  if (!state.found) return raw;
+  const citedRefs = [...citedUrls].map((url) => ({ type: "grouped_webpages", items: [{ url }] }));
+  const synthetic = JSON.stringify({
+    content_references: [...contentReferences, ...citedRefs],
+    search_result_groups: searchResultGroups,
+    citations
+  });
+  return raw + "\n" + synthetic;
+}
+var chatgptAdapter = {
+  platform: "ChatGPT",
+  matchesHost(hostname) {
+    return /(^|\.)chatgpt\.com$|(^|\.)openai\.com$/i.test(hostname);
+  },
+  parse(rawInput, prompt) {
+    const raw = reconstructFromSsePatches(rawInput);
+    const sources = /* @__PURE__ */ new Map();
+    const snippets = /* @__PURE__ */ new Map();
+    const queries = /* @__PURE__ */ new Set();
+    const unmapped = /* @__PURE__ */ new Set();
+    const meta = { model: "", finishType: "", title: "", rounds: 0 };
+    const ensure = (url) => {
+      if (!isExternal(url)) return null;
+      const k = normUrl(url);
+      let s = sources.get(k);
+      if (!s) {
+        s = { url, domain: domainOf(url), title: "", cited: false, timesCited: 0, firstOrder: Infinity, snippet: "", round: null };
+        sources.set(k, s);
+      }
+      return s;
+    };
+    const addSnippet = (url, title, text) => {
+      const clean = stripCitationMarkers(text);
+      if (!isExternal(url) || clean.length < 2) return;
+      snippets.set(normUrl(url), { url, domain: domainOf(url), title: title || domainOf(url), text: clean.slice(0, 400) });
+    };
+    for (const m of raw.matchAll(/"([a-z_]*(?:quer|search)[a-z_]*)"\s*:/gi)) unmapped.add(m[1]);
+    for (const m of raw.matchAll(/"search_model_queries"\s*:\s*\[([^\]]*)\]/g)) {
+      for (const q of stringsInArrayBody(m[1])) {
+        const c = cleanQuery(q);
+        if (c) queries.add(c);
+      }
+    }
+    for (const m of raw.matchAll(/"(?:search_queries|queries|search_query)"\s*:\s*\[([^\]]*)\]/g)) {
+      for (const q of stringsInArrayBody(m[1])) {
+        const c = cleanQuery(q);
+        if (c) queries.add(c);
+      }
+    }
+    for (const v of findJsonValues(raw, "search_result_groups")) {
+      if (!Array.isArray(v)) continue;
+      for (const g of v) {
+        const entries = g && typeof g === "object" && Array.isArray(g.entries) ? g.entries : [];
+        for (const e of entries) {
+          const url = typeof e.url === "string" ? e.url : "";
+          const s = ensure(url);
+          if (!s) continue;
+          if (!s.title && typeof e.title === "string") s.title = e.title.slice(0, 200);
+          const ref = normRef(e.ref_id);
+          if (ref && s.round == null) s.round = roundOf(ref);
+          if (typeof e.snippet === "string" && e.snippet) addSnippet(url, s.title, e.snippet);
+        }
+      }
+    }
+    for (const m of raw.matchAll(/"url"\s*:\s*"(https?:\/\/[^"\\]+)"(?:[\s\S]{0,120}?"(?:title|name)"\s*:\s*"((?:[^"\\]|\\.){0,200})")?/g)) {
+      const s = ensure(m[1]);
+      if (s && !s.title && m[2]) s.title = unesc(m[2]).slice(0, 200);
+    }
+    let spanTotal = 0;
+    for (const cr of findJsonValues(raw, "content_references")) {
+      if (!Array.isArray(cr)) continue;
+      for (const ref of cr) {
+        const type = typeof ref.type === "string" ? ref.type : "";
+        const isBundle = /sources_footnote|nav_list|alt_text/.test(type);
+        const refs = refsInText(typeof ref.matched_text === "string" ? ref.matched_text : "");
+        if (!isBundle) spanTotal++;
+        const ord = typeof ref.start_idx === "number" ? ref.start_idx : isBundle ? Infinity : spanTotal;
+        const items = Array.isArray(ref.items) ? ref.items : [];
+        items.forEach((it, idx) => {
+          const refForItem = refs.length === items.length ? refs[idx] : refs[0];
+          const urls = [it.url].concat((Array.isArray(it.supporting_websites) ? it.supporting_websites : []).map((s) => s?.url)).filter((u) => typeof u === "string");
+          for (const u of urls) {
+            const s = ensure(u);
+            if (!s) continue;
+            if (!isBundle) {
+              s.cited = true;
+              s.timesCited++;
+              if (ord < s.firstOrder) s.firstOrder = ord;
+            } else if (!s.cited) {
+              s.cited = true;
+            }
+            if (refForItem && s.round == null) s.round = roundOf(refForItem);
+          }
+          if (typeof it.url === "string" && typeof it.snippet === "string") addSnippet(it.url, typeof it.title === "string" ? it.title : "", it.snippet);
+        });
+      }
+    }
+    for (const v of findJsonValues(raw, "citations")) {
+      if (!Array.isArray(v)) continue;
+      v.forEach((c, i) => {
+        const md = c && typeof c === "object" ? c.metadata : null;
+        if (!md || typeof md.url !== "string") return;
+        const s = ensure(md.url);
+        if (!s) return;
+        s.cited = true;
+        s.timesCited++;
+        const ord = typeof c.start_ix === "number" ? c.start_ix : i;
+        if (ord < s.firstOrder) s.firstOrder = ord;
+        if (typeof md.text === "string") addSnippet(md.url, typeof md.title === "string" ? md.title : "", md.text);
+      });
+    }
+    for (const m of raw.matchAll(/"content_type"\s*:\s*"tether_quote"([\s\S]{0,4000}?)"text"\s*:\s*"((?:[^"\\]|\\.)*)"/g)) {
+      const url = (m[1].match(/"url"\s*:\s*"([^"]+)"/) || [])[1];
+      const title = (m[1].match(/"title"\s*:\s*"((?:[^"\\]|\\.)*)"/) || [])[1];
+      if (url) {
+        ensure(url);
+        addSnippet(url, title ? unesc(title) : "", unesc(m[2]));
+      }
+    }
+    const modelMatches = [...raw.matchAll(/"resolved_model_slug"\s*:\s*"([^"]+)"/g)];
+    const slugMatches = modelMatches.length ? modelMatches : [...raw.matchAll(/"model_slug"\s*:\s*"([^"]+)"/g)];
+    if (slugMatches.length) meta.model = slugMatches[slugMatches.length - 1][1];
+    const finish = raw.match(/"finish_details"\s*:\s*\{[^}]*"type"\s*:\s*"([^"]+)"/);
+    if (finish) meta.finishType = finish[1];
+    const searchRounds = (raw.match(/"recipient"\s*:\s*"(?:web|browser)"[\s\S]{0,400}?"content_type"\s*:\s*"code"[\s\S]{0,200}?search\(/g) || []).length;
+    const sourceRounds = /* @__PURE__ */ new Set();
+    for (const s of sources.values()) if (s.round != null) sourceRounds.add(s.round);
+    meta.rounds = Math.max(searchRounds, sourceRounds.size);
+    const ordered = [...sources.values()].sort((a, b) => a.cited === b.cited ? b.timesCited - a.timesCited || a.firstOrder - b.firstOrder : a.cited ? -1 : 1).map((s) => ({
+      url: s.url,
+      domain: s.domain,
+      title: s.title || s.domain,
+      cited: s.cited,
+      timesCited: s.timesCited,
+      snippet: snippets.get(normUrl(s.url))?.text || "",
+      round: s.round
+    }));
+    return {
+      subQueries: [...queries],
+      sources: ordered,
+      snippets: [...snippets.values()],
+      meta,
+      unmappedKeys: [...unmapped].slice(0, 50)
+    };
+  }
+};
+
+// src/services/fanout/adapters/claude.ts
+function isFavicon(u) {
+  return /\/s2\/favicons/i.test(u) || /favicon/i.test(u);
+}
+var claudeAdapter = {
+  platform: "Claude",
+  matchesHost(hostname) {
+    return /(^|\.)claude\.ai$/i.test(hostname);
+  },
+  parse(raw, prompt) {
+    const sources = /* @__PURE__ */ new Map();
+    const snippets = /* @__PURE__ */ new Map();
+    const queries = /* @__PURE__ */ new Set();
+    const unmapped = /* @__PURE__ */ new Set();
+    const meta = { model: "", finishType: "", title: "", rounds: 0 };
+    const ensure = (url) => {
+      if (!url || !isExternal(url) || isFavicon(url)) return null;
+      const k = normUrl(url);
+      let s = sources.get(k);
+      if (!s) {
+        s = { url, domain: domainOf(url), title: "", cited: false, timesCited: 0, snippet: "", round: null };
+        sources.set(k, s);
+      }
+      return s;
+    };
+    const toolInputs = /* @__PURE__ */ new Map();
+    const searchBlocks = /* @__PURE__ */ new Set();
+    const finalizeTool = (index) => {
+      const t = toolInputs.get(index);
+      if (!t || !/web_search|web_fetch|search|browse/i.test(t.name)) return;
+      try {
+        const input = JSON.parse(t.buf);
+        if (typeof input.query === "string") {
+          const q = cleanQuery(input.query);
+          if (q) queries.add(q);
+        }
+      } catch {
+        const m = t.buf.match(/"query"\s*:\s*"((?:[^"\\]|\\.)*)"/);
+        if (m) {
+          const q = cleanQuery(unesc(m[1]));
+          if (q) queries.add(q);
+        }
+      }
+    };
+    for (const line of raw.split("\n")) {
+      const s = (line.startsWith("data:") ? line.slice(5) : line).trim();
+      if (!s || s[0] !== "{" && s[0] !== "[") continue;
+      let ev;
+      try {
+        ev = JSON.parse(s);
+      } catch {
+        continue;
+      }
+      const type = ev.type;
+      if (type === "content_block_start") {
+        const cb = ev.content_block || {};
+        const index = typeof ev.index === "number" ? ev.index : -1;
+        if (cb.type === "tool_use" && index >= 0) {
+          const name = typeof cb.name === "string" ? cb.name : "";
+          toolInputs.set(index, { name, buf: "" });
+          if (/web_search|web_fetch|search|browse/i.test(name)) searchBlocks.add(index);
+        }
+      } else if (type === "content_block_delta") {
+        const d = ev.delta || {};
+        const index = typeof ev.index === "number" ? ev.index : -1;
+        if (d.type === "input_json_delta" && typeof d.partial_json === "string") {
+          const t = toolInputs.get(index);
+          if (t) t.buf += d.partial_json;
+        } else if (d.type === "citation_start_delta") {
+          const c = d.citation || {};
+          if (typeof c.url === "string") {
+            const src = ensure(c.url);
+            if (src) {
+              src.cited = true;
+              src.timesCited++;
+              if (!src.title && typeof c.title === "string") src.title = c.title.slice(0, 200);
+              if (typeof c.cited_text === "string" && c.cited_text) {
+                snippets.set(normUrl(c.url), { url: c.url, domain: domainOf(c.url), title: src.title, text: String(c.cited_text).slice(0, 400) });
+              }
+            }
+          }
+        }
+      } else if (type === "content_block_stop") {
+        const index = typeof ev.index === "number" ? ev.index : -1;
+        if (index >= 0) finalizeTool(index);
+      } else if (type === "message_delta" || type === "message_stop" || type === "message_start") {
+        const d = ev.delta || ev.message || {};
+        if (typeof d.stop_reason === "string" && !meta.finishType) meta.finishType = d.stop_reason;
+        if (typeof d.model === "string" && !meta.model) meta.model = d.model;
+      }
+    }
+    for (const index of searchBlocks) finalizeTool(index);
+    for (const m of raw.matchAll(/"title"\s*:\s*"((?:[^"\\]|\\.){1,200})"\s*,\s*"url"\s*:\s*"(https?:\/\/[^"\\]+)"/g)) {
+      const src = ensure(m[2]);
+      if (src && !src.title) src.title = unesc(m[1]).slice(0, 200);
+    }
+    for (const m of raw.matchAll(/"url"\s*:\s*"(https?:\/\/[^"\\]+)"/g)) ensure(m[1]);
+    for (const m of raw.matchAll(/\\"title\\"\s*:\s*\\"((?:[^"\\]|\\.){1,160}?)\\"[\s\S]{0,160}?\\"url\\"\s*:\s*\\"(https?:[^"\\]+)\\"/g)) {
+      const src = ensure(m[2]);
+      if (src && !src.title) src.title = unesc(unesc(m[1])).slice(0, 200);
+    }
+    for (const m of raw.matchAll(/\\"url\\"\s*:\s*\\"(https?:[^"\\]+)\\"/g)) ensure(m[1]);
+    if (!meta.model) {
+      const mm = raw.match(/"model"\s*:\s*"(claude[^"]+)"/);
+      if (mm) meta.model = mm[1];
+    }
+    meta.rounds = queries.size > 0 ? searchBlocks.size : 0;
+    for (const m of raw.matchAll(/"([a-z_]*(?:quer|search)[a-z_]*)"\s*:/gi)) unmapped.add(m[1]);
+    const ordered = [...sources.values()].sort((a, b) => a.cited === b.cited ? b.timesCited - a.timesCited : a.cited ? -1 : 1).map((s) => ({
+      url: s.url,
+      domain: s.domain,
+      title: s.title || s.domain,
+      cited: s.cited,
+      timesCited: s.timesCited,
+      snippet: snippets.get(normUrl(s.url))?.text || "",
+      round: s.round
+    }));
+    return {
+      subQueries: [...queries],
+      sources: ordered,
+      snippets: [...snippets.values()],
+      meta,
+      unmappedKeys: [...unmapped].slice(0, 50)
+    };
+  }
+};
+
+// src/services/fanout/adapters/index.ts
+var FANOUT_ADAPTERS = [chatgptAdapter, claudeAdapter];
+function adapterForHost(hostname) {
+  return FANOUT_ADAPTERS.find((a) => a.matchesHost(hostname)) ?? null;
+}
+
+// src/services/fanout/build.ts
+function buildFanoutResult(ctx) {
+  const { platform, parsed, ready, rawBytes } = ctx;
+  const browsedUrls = parsed.sources;
+  const citedUrls = browsedUrls.filter((s) => s.cited);
+  const browsedOnly = browsedUrls.filter((s) => !s.cited);
+  const prompt = ctx.prompt || parsed.meta.title || "";
+  const result = {
+    platform,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    prompt,
+    meta: parsed.meta,
+    subQueries: parsed.subQueries,
+    browsedUrls,
+    citedUrls,
+    browsedOnly,
+    snippets: parsed.snippets,
+    counts: {
+      subQueries: parsed.subQueries.length,
+      browsed: browsedUrls.length,
+      cited: citedUrls.length,
+      browsedOnly: browsedOnly.length
+    }
+  };
+  if (parsed.subQueries.length === 0 && browsedUrls.length === 0) {
+    result.debug = {
+      interceptorReady: ready,
+      rawBytes,
+      unmappedKeys: parsed.unmappedKeys,
+      note: ready ? "Capture hook is live but no fan-out was seen yet. Run a NEW prompt that triggers web search in this session, then call browser_capture_fanout again. Fan-out is only captured as it streams; past answers from before the session opened cannot be recovered." : "Capture hook not detected on this page. The session must be opened with MCP_SCRAPER_BROWSER_MODE=local and navigated to chatgpt.com or claude.ai after opening, so the hook installs before the site scripts run."
+    };
+  }
+  return result;
+}
+
+// src/services/fanout/classify.ts
+var SOCIAL = /(^|\.)(youtube\.com|youtu\.be|instagram\.com|tiktok\.com|facebook\.com|fb\.com|x\.com|twitter\.com|linkedin\.com|pinterest\.com|threads\.net|vimeo\.com)$/i;
+var ENCYCLOPEDIA = /(^|\.)(wikipedia\.org|wikimedia\.org|britannica\.com|merriam-webster\.com|dictionary\.com|fandom\.com|investopedia\.com)$/i;
+var REVIEW = /(^|\.)(yelp\.com|trustpilot\.com|g2\.com|capterra\.com|angi\.com|angieslist\.com|bbb\.org|consumeraffairs\.com|bestcompany\.com|sitejabber\.com|clutch\.co|bestpickreports\.com|homeguide\.com|porch\.com|ontoplist\.com|thumbtack\.com)$/i;
+var NEWS = /(^|\.)(reuters\.com|apnews\.com|nytimes\.com|wsj\.com|washingtonpost\.com|bloomberg\.com|cnbc\.com|forbes\.com|bbc\.com|theguardian\.com|cnn\.com|npr\.org|usatoday\.com|expressnews\.com|mysanantonio\.com|beaumontenterprise\.com)$/i;
+function classifyDomain(domain, firstPartyDomain) {
+  const d = domain.toLowerCase().replace(/^www\./, "");
+  if (firstPartyDomain) {
+    const fp = firstPartyDomain.toLowerCase().replace(/^www\./, "");
+    if (fp && (d === fp || d.endsWith("." + fp))) return "First-party/vendor";
+  }
+  if (/(^|\.)reddit\.com$/i.test(d)) return "Reddit";
+  if (SOCIAL.test(d)) return "Social/video";
+  if (ENCYCLOPEDIA.test(d)) return "Encyclopedia";
+  if (REVIEW.test(d)) return "Review site";
+  if (NEWS.test(d) || /(^|\.)news\./i.test(d)) return "News/media";
+  if (/^docs?\.|^developer\.|^developers\.|readthedocs|\.dev$/i.test(d)) return "Docs";
+  return "Blog";
+}
+function emptyCategoryCounts() {
+  return { "First-party/vendor": 0, "News/media": 0, Reddit: 0, "Social/video": 0, Encyclopedia: 0, "Review site": 0, Docs: 0, Blog: 0 };
+}
+function enrichFanout(result, opts = {}) {
+  const addSiteType = (s) => ({ ...s, siteType: classifyDomain(s.domain, opts.firstPartyDomain) });
+  const browsedUrls = result.browsedUrls.map(addSiteType);
+  const citedUrls = result.citedUrls.map(addSiteType);
+  const browsedOnly = result.browsedOnly.map(addSiteType);
+  const byCategory = emptyCategoryCounts();
+  const domainAgg = /* @__PURE__ */ new Map();
+  for (const s of browsedUrls) {
+    byCategory[s.siteType]++;
+    const cur = domainAgg.get(s.domain);
+    if (!cur) domainAgg.set(s.domain, { domain: s.domain, count: 1, cited: s.cited, timesCited: s.timesCited, siteType: s.siteType });
+    else {
+      cur.count++;
+      cur.cited = cur.cited || s.cited;
+      cur.timesCited += s.timesCited;
+    }
+  }
+  const topSites = [...domainAgg.values()].sort((a, b) => b.count - a.count || b.timesCited - a.timesCited);
+  const citationOrder = citedUrls.slice().sort((a, b) => b.timesCited - a.timesCited).map((s, i) => ({ rank: i + 1, domain: s.domain, url: s.url, timesCited: s.timesCited }));
+  return {
+    platform: result.platform,
+    capturedAt: result.capturedAt,
+    prompt: result.prompt,
+    meta: result.meta,
+    queries: result.subQueries,
+    browsedUrls,
+    citedUrls,
+    browsedOnly,
+    snippets: result.snippets,
+    counts: result.counts,
+    aggregates: { topSites, citationOrder, byCategory },
+    firstPartyDomain: opts.firstPartyDomain ? opts.firstPartyDomain.toLowerCase().replace(/^www\./, "") : null,
+    ...result.debug ? { debug: result.debug } : {}
+  };
+}
+
+// src/services/fanout/export.ts
 var import_node_fs2 = require("fs");
+var import_node_os3 = require("os");
 var import_node_path3 = require("path");
-var import_playwright = require("playwright");
+var import_papaparse = __toESM(require("papaparse"), 1);
+function outputBaseDir() {
+  return process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path3.join)((0, import_node_os3.homedir)(), "Downloads", "mcp-scraper");
+}
+function safe(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "capture";
+}
+function writeTable(path, rows, delimiter) {
+  (0, import_node_fs2.writeFileSync)(path, import_papaparse.default.unparse(rows.length ? rows : [{}], { delimiter }));
+}
+function exportFanout(enriched) {
+  const stamp = safe(enriched.capturedAt.replace(/[:.]/g, "-"));
+  const dir = (0, import_node_path3.join)(outputBaseDir(), "fanout", `${stamp}-${safe(enriched.platform)}`);
+  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const queryRows = enriched.queries.map((q, i) => ({ index: i + 1, query: q }));
+  const citationRows = enriched.aggregates.citationOrder.map((c) => {
+    const src = enriched.citedUrls.find((s) => s.url === c.url);
+    return { rank: c.rank, domain: c.domain, url: c.url, timesCited: c.timesCited, siteType: src?.siteType ?? "", title: src?.title ?? "" };
+  });
+  const sourceRows = enriched.browsedUrls.map((s) => ({ domain: s.domain, url: s.url, cited: s.cited, timesCited: s.timesCited, siteType: s.siteType, title: s.title, round: s.round ?? "" }));
+  const domainRows = enriched.aggregates.topSites.map((d) => ({ domain: d.domain, count: d.count, cited: d.cited, timesCited: d.timesCited, siteType: d.siteType }));
+  const paths = {
+    dir,
+    json: (0, import_node_path3.join)(dir, "fanout.json"),
+    queriesCsv: (0, import_node_path3.join)(dir, "queries.csv"),
+    queriesTsv: (0, import_node_path3.join)(dir, "queries.tsv"),
+    citationsCsv: (0, import_node_path3.join)(dir, "citations.csv"),
+    sourcesCsv: (0, import_node_path3.join)(dir, "sources.csv"),
+    domainsCsv: (0, import_node_path3.join)(dir, "domains.csv"),
+    report: (0, import_node_path3.join)(dir, "report.html")
+  };
+  (0, import_node_fs2.writeFileSync)(paths.json, JSON.stringify(enriched, null, 2));
+  writeTable(paths.queriesCsv, queryRows, ",");
+  writeTable(paths.queriesTsv, queryRows, "	");
+  writeTable(paths.citationsCsv, citationRows, ",");
+  writeTable(paths.sourcesCsv, sourceRows, ",");
+  writeTable(paths.domainsCsv, domainRows, ",");
+  (0, import_node_fs2.writeFileSync)(paths.report, renderReportHtml(enriched));
+  return paths;
+}
+function esc(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderReportHtml(enriched) {
+  const data = JSON.stringify(enriched).replace(/</g, "\\u003c");
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>AI Search Fan-Out \u2014 ${esc(enriched.platform)}</title>
+<style>
+:root{--bg:#0b0d12;--panel:#151922;--line:#252b38;--ink:#e8ecf3;--mut:#8b95a7;--acc:#5b9dff;--cite:#39d98a;--browse:#5a6677}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);font:14px/1.5 -apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif}
+.wrap{max-width:980px;margin:0 auto;padding:28px 20px 80px}
+h1{font-size:20px;margin:0 0 2px}.sub{color:var(--mut);margin:0 0 20px;font-size:13px}
+.stat{font-size:30px;font-weight:700}.stat small{font-size:13px;font-weight:400;color:var(--mut)}
+.cards{display:grid;grid-template-columns:repeat(4,1fr);gap:10px;margin:18px 0}
+.card{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:12px 14px}
+.card b{font-size:22px;display:block}.card span{color:var(--mut);font-size:12px}
+.bars{margin:8px 0 22px}.bar{display:flex;align-items:center;gap:8px;margin:4px 0}
+.bar .lab{width:150px;color:var(--mut);font-size:12px;text-align:right}.bar .track{flex:1;background:#10141c;border-radius:5px;overflow:hidden}
+.bar .fill{background:var(--acc);height:16px}.bar .n{width:34px;font-size:12px;color:var(--mut)}
+.tabs{display:flex;gap:8px;margin:22px 0 12px}.tab{background:var(--panel);border:1px solid var(--line);color:var(--ink);padding:7px 14px;border-radius:8px;cursor:pointer}
+.tab.on{background:var(--acc);border-color:var(--acc);color:#04101f;font-weight:600}
+.chips{display:flex;flex-wrap:wrap;gap:6px;margin-bottom:12px}
+.chip{background:var(--panel);border:1px solid var(--line);color:var(--mut);padding:4px 10px;border-radius:20px;cursor:pointer;font-size:12px}
+.chip.on{border-color:var(--acc);color:var(--ink)}.chip b{color:var(--ink)}
+.row{background:var(--panel);border:1px solid var(--line);border-radius:8px;padding:10px 12px;margin:6px 0;display:flex;gap:10px;align-items:flex-start}
+.row .idx{color:var(--mut);min-width:22px}.row .main{flex:1}
+.tag{font-size:11px;padding:2px 7px;border-radius:6px;border:1px solid var(--line);color:var(--mut);margin-right:5px}
+.dom{font-weight:600}.url{color:var(--mut);font-size:12px;word-break:break-all}
+.pill{font-size:11px;padding:2px 7px;border-radius:6px}.pill.cite{background:rgba(57,217,138,.15);color:var(--cite)}.pill.brow{background:rgba(90,102,119,.2);color:#aeb8c8}
+.copy{background:none;border:1px solid var(--line);color:var(--mut);border-radius:6px;cursor:pointer;font-size:11px;padding:2px 8px}
+.hide{display:none}
+</style>
+</head>
+<body><div class="wrap">
+<h1>AI Search Fan-Out</h1>
+<p class="sub" id="sub"></p>
+<div class="stat" id="stat"></div>
+<div class="cards" id="cards"></div>
+<div id="charts"></div>
+<div class="tabs"><button class="tab on" data-tab="q">Queries</button><button class="tab" data-tab="u">URLs</button></div>
+<div class="chips" id="chips"></div>
+<div id="list"></div>
+</div>
+<script>
+const D=${data};
+const el=(t,c,h)=>{const e=document.createElement(t);if(c)e.className=c;if(h!=null)e.innerHTML=h;return e};
+document.getElementById('sub').textContent=D.platform+' \xB7 '+(D.meta.model||'model n/a')+' \xB7 '+D.meta.rounds+' search round(s) \xB7 prompt: '+(D.prompt||'');
+document.getElementById('stat').innerHTML='Total Fan-Out: '+D.counts.subQueries+' <small>sub-queries \xB7 '+D.counts.browsed+' URLs researched \xB7 '+D.counts.cited+' cited</small>';
+const cards=[['Sub-queries',D.counts.subQueries],['Researched',D.counts.browsed],['Cited',D.counts.cited],['Browsed-only',D.counts.browsedOnly]];
+const cc=document.getElementById('cards');cards.forEach(([k,v])=>{const c=el('div','card');c.appendChild(el('b',null,v));c.appendChild(el('span',null,k));cc.appendChild(c)});
+function barChart(title,obj){const max=Math.max(1,...Object.values(obj));const box=el('div','bars');box.appendChild(el('div',null,'<b>'+title+'</b>'));Object.entries(obj).forEach(([k,v])=>{const r=el('div','bar');r.appendChild(el('div','lab',k));const t=el('div','track');const f=el('div','fill');f.style.width=(v/max*100)+'%';t.appendChild(f);r.appendChild(t);r.appendChild(el('div','n',v));box.appendChild(r)});return box}
+const charts=document.getElementById('charts');
+charts.appendChild(barChart('URL Categories',D.aggregates.byCategory));
+let tab='q',filter=null;
+const chips=document.getElementById('chips'),list=document.getElementById('list');
+function render(){
+  chips.innerHTML='';list.innerHTML='';
+  if(tab==='q'){
+    D.queries.forEach((q,i)=>{const r=el('div','row');r.appendChild(el('div','idx',i+1));const m=el('div','main');m.appendChild(el('div',null,esc(q)));r.appendChild(m);const b=el('button','copy','copy');b.onclick=()=>navigator.clipboard.writeText(q);r.appendChild(b);list.appendChild(r)});
+  } else {
+    const counts={};D.browsedUrls.forEach(s=>{counts[s.siteType]=(counts[s.siteType]||0)+1});
+    Object.entries(counts).forEach(([k,v])=>{const c=el('button','chip'+(filter===k?' on':''),k+' <b>'+v+'</b>');c.onclick=()=>{filter=filter===k?null:k;render()};chips.appendChild(c)});
+    D.browsedUrls.forEach(s=>{if(filter&&s.siteType!==filter)return;const r=el('div','row');const m=el('div','main');m.appendChild(el('div',null,'<span class="dom">'+esc(s.domain)+'</span> <span class="pill '+(s.cited?'cite':'brow')+'">'+(s.cited?'cited '+s.timesCited+'\xD7':'browsed')+'</span> <span class="tag">'+s.siteType+'</span>'));m.appendChild(el('div','url',esc(s.url)));r.appendChild(m);list.appendChild(r)});
+  }
+}
+function esc(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;')}
+document.querySelectorAll('.tab').forEach(t=>t.onclick=()=>{document.querySelectorAll('.tab').forEach(x=>x.classList.remove('on'));t.classList.add('on');tab=t.dataset.tab;filter=null;render()});
+render();
+</script>
+</body></html>`;
+}
+
+// src/services/fanout/run-capture.ts
+var COMPOSER_SELECTORS = [
+  "#prompt-textarea",
+  "div#prompt-textarea",
+  'textarea[data-testid="prompt-textarea"]',
+  'div.ProseMirror[contenteditable="true"]',
+  'div[contenteditable="true"]',
+  "textarea"
+];
+async function sendPrompt(page, text) {
+  for (const selector of COMPOSER_SELECTORS) {
+    const locator = page.locator(selector).first();
+    try {
+      await locator.waitFor({ state: "visible", timeout: 12e3 });
+    } catch {
+      continue;
+    }
+    await locator.click({ timeout: 4e3 }).catch(() => void 0);
+    await locator.focus().catch(() => void 0);
+    await page.keyboard.type(text, { delay: 12 });
+    await page.waitForTimeout(300).catch(() => void 0);
+    await page.keyboard.press("Enter");
+    return true;
+  }
+  return false;
+}
+async function waitForAnswer(page, cap, baseline, waitMs) {
+  const start = Date.now();
+  while (Date.now() - start < waitMs && cap.answerStreamCount() <= baseline) {
+    await page.waitForTimeout(400).catch(() => void 0);
+  }
+  await page.waitForTimeout(1e3).catch(() => void 0);
+}
+async function runFanoutCapture(page, input) {
+  const cap = new FanoutCdpCapture();
+  await cap.attach(page);
+  try {
+    const baseline = cap.answerStreamCount();
+    if (input.prompt) await sendPrompt(page, input.prompt).catch(() => false);
+    const waitMs = input.wait_ms ?? (input.prompt ? 9e4 : 8e3);
+    await waitForAnswer(page, cap, baseline, waitMs);
+    await cap.drain();
+    let hostname = "";
+    try {
+      hostname = new URL(page.url()).hostname;
+    } catch {
+      hostname = "";
+    }
+    const adapter = adapterForHost(hostname);
+    if (!adapter) {
+      throw new Error(`browser_capture_fanout supports chatgpt.com and claude.ai only; the session is on ${hostname || "an unknown page"}. Navigate there first with browser_goto.`);
+    }
+    const text = cap.bestAnswerText();
+    const parsed = adapter.parse(text, input.prompt || "");
+    const result = buildFanoutResult({ platform: adapter.platform, parsed, prompt: input.prompt || "", ready: true, rawBytes: text.length });
+    const enriched = enrichFanout(result, { firstPartyDomain: input.first_party_domain });
+    const exports2 = input.export ? exportFanout(enriched) : null;
+    return { result: enriched, exports: exports2 };
+  } finally {
+    await cap.detach().catch(() => void 0);
+  }
+}
+
+// src/services/browser-agent/local-browser-agent-service.ts
+import_playwright_extra.chromium.use((0, import_puppeteer_extra_plugin_stealth.default)());
 function directProfileDir() {
   return process.env.MCP_SCRAPER_BROWSER_PROFILE_DIR?.trim() || void 0;
 }
 function configuredProfileName(profile) {
-  return profile?.trim() || process.env.MCP_SCRAPER_BROWSER_PROFILE?.trim() || (directProfileDir() ? (0, import_node_path3.basename)(directProfileDir()) : "default");
+  return profile?.trim() || process.env.MCP_SCRAPER_BROWSER_PROFILE?.trim() || (directProfileDir() ? (0, import_node_path4.basename)(directProfileDir()) : "default");
 }
 function launchExecutablePath(profile) {
   const configured = process.env.MCP_SCRAPER_BROWSER_EXECUTABLE?.trim() || profile.browserExecutablePath || defaultChromeExecutablePath();
-  return configured && (0, import_node_fs2.existsSync)(configured) ? configured : void 0;
+  return configured && (0, import_node_fs3.existsSync)(configured) ? configured : void 0;
 }
 function ignoreDefaultArgsFor(executablePath) {
   if (!executablePath) return void 0;
@@ -754,6 +1592,17 @@ var LocalBrowserAgentService = class {
   list(includeClosed = false) {
     return Array.from(this.sessions.values()).filter((session) => includeClosed || session.status === "open").map(sessionSummary);
   }
+  async captureFanout(sessionId, input) {
+    const session = this.requireOpenSession(sessionId);
+    this.touch(session);
+    return runFanoutCapture(session.page, input);
+  }
+  async screenshotOnly(sessionId) {
+    const session = this.requireOpenSession(sessionId);
+    await this.waitForPage(session.page);
+    const img = await session.page.screenshot({ type: "png", fullPage: false });
+    return img.toString("base64");
+  }
   async resolveProfile(profile) {
     const directDir = directProfileDir();
     const requestedName = configuredProfileName(profile);
@@ -777,7 +1626,7 @@ var LocalBrowserAgentService = class {
     const existing = this.contexts.get(profile.userDataDir);
     if (existing) return existing;
     const executablePath = launchExecutablePath(profile);
-    const context = await import_playwright.chromium.launchPersistentContext(profile.userDataDir, {
+    const context = await import_playwright_extra.chromium.launchPersistentContext(profile.userDataDir, {
       headless: false,
       viewport: { width: 1440, height: 900 },
       acceptDownloads: true,
@@ -824,7 +1673,7 @@ var LocalBrowserAgentService = class {
 };
 
 // src/version.ts
-var PACKAGE_VERSION = "0.2.24";
+var PACKAGE_VERSION = "0.3.0";
 
 // src/mcp/browser-agent-tool-schemas.ts
 var import_zod = require("zod");
@@ -967,6 +1816,70 @@ var BrowserReplayAnnotateInputSchema = {
 var BrowserListInputSchema = {
   include_closed: import_zod.z.boolean().default(false).describe("Include closed sessions in the list.")
 };
+var BrowserCaptureFanoutInputSchema = {
+  session_id: import_zod.z.string().describe("The session id returned by browser_open or browser_list_sessions. The session must be a local-mode session on chatgpt.com or claude.ai that is logged in. Use only a returned session_id; do not construct one yourself."),
+  prompt: import_zod.z.string().optional().describe("Optional prompt to type into the chat composer and submit before capturing. Omit to passively capture the fan-out of a prompt the user just ran in the visible browser. The prompt must trigger web search for there to be a fan-out."),
+  wait_ms: import_zod.z.number().int().min(0).max(18e4).optional().describe("How long to wait for the answer stream to finish before parsing. Defaults to 90000 when a prompt is sent, 8000 for passive capture. Capture ends as soon as the answer stream finishes."),
+  first_party_domain: import_zod.z.string().optional().describe("The brand/site being researched, for example example.com. Sources on this domain are tagged First-party/vendor. Set this when the prompt is about a specific business."),
+  reset: import_zod.z.boolean().default(false).describe("Clear any previously buffered stream for this page before capturing. Use when re-running to avoid mixing turns."),
+  export: import_zod.z.boolean().default(false).describe("When true, write JSON, CSV, TSV exports (queries, citations, sources, domains) and a self-contained HTML report to MCP_SCRAPER_OUTPUT_DIR/fanout and return their paths.")
+};
+var FanoutSourceOutput = import_zod.z.object({
+  url: import_zod.z.string(),
+  domain: import_zod.z.string(),
+  title: import_zod.z.string(),
+  cited: import_zod.z.boolean(),
+  timesCited: import_zod.z.number().int().min(0),
+  snippet: import_zod.z.string(),
+  round: import_zod.z.number().int().nullable(),
+  siteType: import_zod.z.string().describe("URL category: First-party/vendor, News/media, Reddit, Social/video, Encyclopedia, Review site, Docs, or Blog.")
+});
+var BrowserCaptureFanoutOutputSchema = {
+  ...BrowserBaseOutput,
+  tool: import_zod.z.literal("browser_capture_fanout"),
+  platform: import_zod.z.enum(["ChatGPT", "Claude"]).describe("Which AI-search surface the fan-out was captured from."),
+  captured_at: import_zod.z.string(),
+  prompt: import_zod.z.string().describe("The user prompt that triggered the captured fan-out, when recoverable."),
+  meta: import_zod.z.object({
+    model: import_zod.z.string(),
+    finishType: import_zod.z.string(),
+    title: import_zod.z.string(),
+    rounds: import_zod.z.number().int().min(0)
+  }),
+  queries: import_zod.z.array(import_zod.z.string()).describe("Every web-search sub-query the model issued, in capture order. Classify these by funnel stage and type yourself from the text."),
+  browsed_urls: import_zod.z.array(FanoutSourceOutput).describe("Every researched URL (cited and browsed-only), cited first."),
+  cited_urls: import_zod.z.array(FanoutSourceOutput).describe("The subset of researched URLs actually cited in the final answer."),
+  browsed_only: import_zod.z.array(FanoutSourceOutput).describe("Researched URLs the model pulled but did not cite."),
+  snippets: import_zod.z.array(import_zod.z.object({ url: import_zod.z.string(), domain: import_zod.z.string(), title: import_zod.z.string(), text: import_zod.z.string() })),
+  counts: import_zod.z.object({
+    subQueries: import_zod.z.number().int().min(0),
+    browsed: import_zod.z.number().int().min(0),
+    cited: import_zod.z.number().int().min(0),
+    browsedOnly: import_zod.z.number().int().min(0)
+  }),
+  aggregates: import_zod.z.object({
+    topSites: import_zod.z.array(import_zod.z.object({ domain: import_zod.z.string(), count: import_zod.z.number().int(), cited: import_zod.z.boolean(), timesCited: import_zod.z.number().int(), siteType: import_zod.z.string() })),
+    citationOrder: import_zod.z.array(import_zod.z.object({ rank: import_zod.z.number().int(), domain: import_zod.z.string(), url: import_zod.z.string(), timesCited: import_zod.z.number().int() })),
+    byCategory: import_zod.z.record(import_zod.z.number().int())
+  }).describe("Objective aggregates: top sourced sites by frequency, citation order, and URL-category counts."),
+  first_party_domain: import_zod.z.string().nullable(),
+  exports: import_zod.z.object({
+    dir: import_zod.z.string(),
+    json: import_zod.z.string(),
+    queriesCsv: import_zod.z.string(),
+    queriesTsv: import_zod.z.string(),
+    citationsCsv: import_zod.z.string(),
+    sourcesCsv: import_zod.z.string(),
+    domainsCsv: import_zod.z.string(),
+    report: import_zod.z.string()
+  }).nullable().describe("Local file paths when export=true, otherwise null."),
+  debug: import_zod.z.object({
+    interceptorReady: import_zod.z.boolean(),
+    rawBytes: import_zod.z.number().int().min(0),
+    unmappedKeys: import_zod.z.array(import_zod.z.string()),
+    note: import_zod.z.string()
+  }).optional()
+};
 var BrowserOpenOutputSchema = {
   ok: import_zod.z.boolean(),
   tool: import_zod.z.literal("browser_open"),
@@ -1115,8 +2028,8 @@ var BrowserListSessionsOutputSchema = {
 // src/mcp/replay-annotator.ts
 var import_node_child_process = require("child_process");
 var import_promises3 = require("fs/promises");
-var import_node_os3 = require("os");
-var import_node_path4 = require("path");
+var import_node_os4 = require("os");
+var import_node_path5 = require("path");
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 function finiteNumber(value) {
@@ -1126,11 +2039,11 @@ function clamp(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
 function formatAssTime(seconds) {
-  const safe = Math.max(0, seconds);
-  const hours = Math.floor(safe / 3600);
-  const minutes = Math.floor(safe % 3600 / 60);
-  const wholeSeconds = Math.floor(safe % 60);
-  const centiseconds = Math.floor((safe - Math.floor(safe)) * 100);
+  const safe2 = Math.max(0, seconds);
+  const hours = Math.floor(safe2 / 3600);
+  const minutes = Math.floor(safe2 % 3600 / 60);
+  const wholeSeconds = Math.floor(safe2 % 60);
+  const centiseconds = Math.floor((safe2 - Math.floor(safe2)) * 100);
   return `${hours}:${String(minutes).padStart(2, "0")}:${String(wholeSeconds).padStart(2, "0")}.${String(centiseconds).padStart(2, "0")}`;
 }
 function cssHexToAssColor(color) {
@@ -1339,8 +2252,8 @@ function ffmpegFilterPath(path) {
 async function annotateReplayVideo(inputFilePath, outputFilePath, options) {
   if (!options.annotations.length) throw new Error("annotations must include at least one item");
   const size = await videoSize(inputFilePath);
-  const tmp = await (0, import_promises3.mkdtemp)((0, import_node_path4.join)((0, import_node_os3.tmpdir)(), "mcp-scraper-ass-"));
-  const assPath = (0, import_node_path4.join)(tmp, "annotations.ass");
+  const tmp = await (0, import_promises3.mkdtemp)((0, import_node_path5.join)((0, import_node_os4.tmpdir)(), "mcp-scraper-ass-"));
+  const assPath = (0, import_node_path5.join)(tmp, "annotations.ass");
   try {
     await (0, import_promises3.writeFile)(assPath, buildAssSubtitle(options, size), "utf8");
     await execFileAsync("ffmpeg", [
@@ -1408,8 +2321,8 @@ function actionResult(tool, sessionId, ok, data, nextRecommendedTool = "browser_
     nextRecommendedTool
   });
 }
-function outputBaseDir() {
-  return process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path5.join)((0, import_node_os4.homedir)(), "Downloads", "mcp-scraper");
+function outputBaseDir2() {
+  return process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path6.join)((0, import_node_os5.homedir)(), "Downloads", "mcp-scraper");
 }
 function safeFilePart(value) {
   return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 120) || "replay";
@@ -1418,7 +2331,7 @@ function replayFilePath(sessionId, replayId, filename) {
   const requested = filename?.trim();
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const name = requested ? safeFilePart(requested).replace(/\.mp4$/i, "") : `${stamp}-${safeFilePart(sessionId)}-${safeFilePart(replayId)}`;
-  return (0, import_node_path5.join)(outputBaseDir(), "browser-replays", `${name}.mp4`);
+  return (0, import_node_path6.join)(outputBaseDir2(), "browser-replays", `${name}.mp4`);
 }
 function annotatedReplayFilePath(sessionId, replayId, filename) {
   const requested = filename?.trim();
@@ -1478,8 +2391,8 @@ function registerBrowserAgentMcpTools(server2, opts) {
       }
       const bytes = Buffer.from(await res.arrayBuffer());
       const filePath = replayFilePath(sessionId, replayId, filename);
-      (0, import_node_fs3.mkdirSync)((0, import_node_path5.join)(outputBaseDir(), "browser-replays"), { recursive: true });
-      (0, import_node_fs3.writeFileSync)(filePath, bytes);
+      (0, import_node_fs4.mkdirSync)((0, import_node_path6.join)(outputBaseDir2(), "browser-replays"), { recursive: true });
+      (0, import_node_fs4.writeFileSync)(filePath, bytes);
       return {
         ok: true,
         data: {
@@ -2130,7 +3043,7 @@ function registerBrowserAgentMcpTools(server2, opts) {
       try {
         const sourcePath = String(downloaded.data.file_path);
         const outputPath = annotatedReplayFilePath(input.session_id, input.replay_id, input.filename);
-        (0, import_node_fs3.mkdirSync)((0, import_node_path5.join)(outputBaseDir(), "browser-replays"), { recursive: true });
+        (0, import_node_fs4.mkdirSync)((0, import_node_path6.join)(outputBaseDir2(), "browser-replays"), { recursive: true });
         const result = await annotateReplayVideo(sourcePath, outputPath, {
           annotations: input.annotations,
           sourceWidth: input.source_width,
@@ -2223,17 +3136,65 @@ function registerBrowserAgentMcpTools(server2, opts) {
       });
     }
   );
+  server2.registerTool(
+    "browser_capture_fanout",
+    {
+      title: "Capture AI Search Fan-Out",
+      description: "Capture the query fan-out behind a ChatGPT or Claude web-search answer for Answer Engine Optimization (AEO) analysis: the exact sub-queries the model issued, every researched URL split into cited vs browsed-only with citation frequency and snippet, each source tagged by site category, plus top sourced sites and citation order. This tool returns the raw, structured fan-out data; YOU then analyze it \u2014 classify each sub-query by funnel stage (Problem/Solution/Decision-aware, Retention) and type (BoFu, Branded, Comparison, How-to, operator), identify which brands the model researched, and surface AEO insights. Requires MCP_SCRAPER_BROWSER_MODE=local with the user's own logged-in Chrome profile (or a logged-in hosted profile); it reads the network stream the page receives and never leaves the machine. Open the session with browser_open and browser_goto to chatgpt.com or claude.ai first. Pass prompt to send and capture a new query, or omit it to capture a prompt the user just ran. Fan-out is only captured as it streams, so run the prompt with the session open.",
+      inputSchema: BrowserCaptureFanoutInputSchema,
+      outputSchema: BrowserCaptureFanoutOutputSchema,
+      annotations: annotations("Capture AI Search Fan-Out", true)
+    },
+    async (input) => {
+      const emit = (result, exports2) => structuredResult({
+        ok: true,
+        tool: "browser_capture_fanout",
+        session_id: input.session_id,
+        platform: result.platform,
+        captured_at: result.capturedAt,
+        prompt: result.prompt,
+        meta: result.meta,
+        queries: result.queries,
+        browsed_urls: result.browsedUrls,
+        cited_urls: result.citedUrls,
+        browsed_only: result.browsedOnly,
+        snippets: result.snippets,
+        counts: result.counts,
+        aggregates: result.aggregates,
+        first_party_domain: result.firstPartyDomain,
+        exports: exports2 ?? null,
+        ...result.debug ? { debug: result.debug } : {}
+      });
+      if (localBrowserModeEnabled()) {
+        try {
+          const { result, exports: exports2 } = await localBrowser.captureFanout(input.session_id, input);
+          return emit(result, exports2);
+        } catch (err) {
+          return errorResult("browser_capture_fanout", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
+      const res = await req("POST", `/agent/sessions/${input.session_id}/capture-fanout`, {
+        prompt: input.prompt,
+        wait_ms: input.wait_ms,
+        first_party_domain: input.first_party_domain,
+        export: false
+      });
+      if (!res.ok) return errorResult("browser_capture_fanout", res.data, input.session_id);
+      const hosted = res.data?.result ?? res.data;
+      return emit(hosted, res.data?.exports ?? null);
+    }
+  );
 }
 
 // src/mcp/paa-mcp-server.ts
 var import_mcp2 = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_node_fs5 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path8 = require("path");
 
 // src/mcp/mcp-response-formatter.ts
-var import_node_fs4 = require("fs");
-var import_node_os5 = require("os");
-var import_node_path6 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_os6 = require("os");
+var import_node_path7 = require("path");
 
 // src/errors.ts
 function sanitizeVendorName(message) {
@@ -2369,17 +3330,17 @@ function reportTitle(full) {
   const title = full.split("\n").find((line) => line.startsWith("# "));
   return title?.replace(/^#\s+/, "").trim() || "MCP Scraper Report";
 }
-function outputBaseDir2() {
-  return process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path6.join)((0, import_node_os5.homedir)(), "Downloads", "mcp-scraper");
+function outputBaseDir3() {
+  return process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path7.join)((0, import_node_os6.homedir)(), "Downloads", "mcp-scraper");
 }
 function saveFullReport(full) {
   if (!reportSavingEnabled || process.env.MCP_SCRAPER_SAVE_REPORTS === "false") return null;
-  const outDir = outputBaseDir2();
+  const outDir = outputBaseDir3();
   try {
-    (0, import_node_fs4.mkdirSync)(outDir, { recursive: true });
+    (0, import_node_fs5.mkdirSync)(outDir, { recursive: true });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const file = (0, import_node_path6.join)(outDir, `${stamp}-${slugifyReportName(reportTitle(full))}.md`);
-    (0, import_node_fs4.writeFileSync)(file, full, "utf8");
+    const file = (0, import_node_path7.join)(outDir, `${stamp}-${slugifyReportName(reportTitle(full))}.md`);
+    (0, import_node_fs5.writeFileSync)(file, full, "utf8");
     return file;
   } catch {
     return null;
@@ -2388,12 +3349,12 @@ function saveFullReport(full) {
 function persistScreenshotLocally(base64, url) {
   if (!reportSavingEnabled || process.env.MCP_SCRAPER_SAVE_REPORTS === "false") return null;
   try {
-    const dir = (0, import_node_path6.join)(outputBaseDir2(), "screenshots");
-    (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_node_path7.join)(outputBaseDir3(), "screenshots");
+    (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const slug = url.replace(/^https?:\/\//, "").replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").slice(0, 60);
-    const filePath = (0, import_node_path6.join)(dir, `${stamp}-${slug}.png`);
-    (0, import_node_fs4.writeFileSync)(filePath, Buffer.from(base64, "base64"));
+    const filePath = (0, import_node_path7.join)(dir, `${stamp}-${slug}.png`);
+    (0, import_node_fs5.writeFileSync)(filePath, Buffer.from(base64, "base64"));
     return filePath;
   } catch {
     return null;
@@ -4768,8 +5729,8 @@ function localPlanningToolAnnotations(title) {
 }
 function listSavedReports() {
   try {
-    const dir = outputBaseDir2();
-    return (0, import_node_fs5.readdirSync)(dir).filter((f) => f.endsWith(".md")).map((f) => ({ filename: f, mtimeMs: (0, import_node_fs5.statSync)((0, import_node_path7.join)(dir, f)).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, 100);
+    const dir = outputBaseDir3();
+    return (0, import_node_fs6.readdirSync)(dir).filter((f) => f.endsWith(".md")).map((f) => ({ filename: f, mtimeMs: (0, import_node_fs6.statSync)((0, import_node_path8.join)(dir, f)).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, 100);
   } catch {
     return [];
   }
@@ -4793,9 +5754,9 @@ function registerSavedReportResources(server2) {
     },
     async (uri, variables) => {
       const requested = Array.isArray(variables.filename) ? variables.filename[0] : variables.filename;
-      const filename = (0, import_node_path7.basename)(decodeURIComponent(String(requested ?? "")));
+      const filename = (0, import_node_path8.basename)(decodeURIComponent(String(requested ?? "")));
       if (!filename.endsWith(".md")) throw new Error("Only saved .md reports can be read");
-      const text = (0, import_node_fs5.readFileSync)((0, import_node_path7.join)(outputBaseDir2(), filename), "utf8");
+      const text = (0, import_node_fs6.readFileSync)((0, import_node_path8.join)(outputBaseDir3(), filename), "utf8");
       return { contents: [{ uri: uri.href, mimeType: "text/markdown", text }] };
     }
   );
@@ -5081,10 +6042,10 @@ if (!forceStdio && (interactiveTerminal || wantsHelp)) {
 }
 function readApiKeyFile() {
   const explicitPath = process.env.MCP_SCRAPER_KEY_PATH?.trim();
-  const paths = [explicitPath, (0, import_node_path8.join)((0, import_node_os6.homedir)(), ".mcp-scraper-key")].filter(Boolean);
+  const paths = [explicitPath, (0, import_node_path9.join)((0, import_node_os7.homedir)(), ".mcp-scraper-key")].filter(Boolean);
   for (const path of paths) {
     try {
-      const value = (0, import_node_fs6.readFileSync)(path, "utf8").trim();
+      const value = (0, import_node_fs7.readFileSync)(path, "utf8").trim();
       if (value) return value;
     } catch {
     }