@glittering0717/ai-browser 1.3.0 → 2.0.0

package/src/main/window_open_shim_source.js

@@ -0,0 +1,117 @@
+// window_open_shim_source.js — 注入页面主 world 的 window.open 兼容垫片源码
+//
+// 背景：站点惯用法（超星专技平台等大量老站）是
+//     var w = window.open("", "_blank"); // 先开一个新页面
+//     w.location = res.url;              // 再把真实地址赋给它
+// 主进程的 setWindowOpenHandler 对 window.open 一律 deny（改为自建 tab），
+// deny 之后 window.open 返回 null，页面再赋 w.location 直接抛 TypeError ——
+// 用户看到的就是一个光秃秃的 about:blank 标签，站点逻辑静默断裂。
+// （实测：pxsxzj.xidian.edu.cn「进入学习」，2026-10-19。）
+//
+// ⚠️ 第二层根因（同一天发现，比第一层更隐蔽）：光让 window.open 返回一个
+// 非 null 的对象还不够。真实 Window 的 location 是 [LegacyUnforgeable] +
+// [PutForwards=href]，所以 `w.location = url` 等价于 `w.location.href = url`，
+// 会导航。第一版垫片把 location 写成普通数据属性（location: loc），站点
+// 这一赋值只是把字符串塞进属性、覆盖掉 loc 对象，**静默不导航**——垫片
+// 注入了、window.open 也返回了对象、站点不报错，标签页却永远停在
+// about:blank。现在的实现用 Object.defineProperty 装一个带 setter 的
+// 访问器来复刻 PutForwards 语义。
+//
+// 为什么必须走 CDP 注入而不是 preload：tab 的 BrowserView 是
+// contextIsolation:true，preload 里写的 window.open 只作用于 isolated
+// world 的 window，页面脚本看到的仍是原生 window.open（第一版就是这么
+// 失败的——隔离测试里 window.open() 返回 falsy）。Page.addScriptToEvaluate
+// OnNewDocument 注入的脚本跑在主 world，才能真正替换掉页面可见的那个。
+//
+// 通信：垫片本体没有 ipcRenderer，经 preload 用 contextBridge 暴露的
+// __ai_browser__.windowOpenBridge(op, token, url, name)（单一入口，
+// fire-and-forget）把事件送到主进程；主进程建 tab / 导航 / 关 tab。
+// ⚠️ 入口 arity 固定 4：contextBridge 两岸参数数量不一致时调用会抛错
+// （实测少传一个 → 抛错被 catch 吞掉 → window.open 静默返回 null，
+// 站点看到的就是"弹窗被拦截"的老症状）。垫片所有调用必须传满 4 个参数。
+export const WINDOW_OPEN_SHIM_SOURCE = `(function () {
+  if (window.__aiWindowOpenShimV2) return;
+  window.__aiWindowOpenShimV2 = true;
+  var seq = 0;
+
+  function send(op, token, url, name) {
+    var b = window.__ai_browser__;
+    if (!b || typeof b.windowOpenBridge !== 'function') return false;
+    try { b.windowOpenBridge(op, token, url === undefined ? '' : url, name === undefined ? '' : name); return true; } catch (e) { return false; }
+  }
+
+  // 相对地址按发起页面的 baseURI 解析（真实 window 的 location 也这么做）。
+  function abs(v) {
+    var s = String(v);
+    try { return new URL(s, document.baseURI).href; } catch (e) { return s; }
+  }
+
+  window.open = function (url, name, _features) {
+    var target = (url === undefined || url === null) ? '' : String(url);
+    var token = 'wo' + (++seq) + '_' + Date.now();
+    var ok = send('open', token, target, name || '');
+    if (!ok) {
+      // 没有桥：退回原生语义（deny → null），至少不像成功那样骗站点。
+      return null;
+    }
+    var currentHref = target ? abs(target) : 'about:blank';
+    var closed = false;
+
+    function navigate(v) {
+      currentHref = abs(v);
+      send('nav', token, currentHref, '');
+    }
+
+    var loc = {
+      get href() { return currentHref; },
+      set href(v) { navigate(v); },
+      assign: function (v) { navigate(v); },
+      replace: function (v) { navigate(v); },
+      reload: function () {},
+      toString: function () { return currentHref; }
+    };
+
+    var doc = {
+      write: function () {}, writeln: function () {},
+      open: function () {}, close: function () {},
+      get location() { return loc; },
+      set location(v) { navigate(v); },
+      get URL() { return currentHref; }
+    };
+
+    var win = {
+      close: function () {
+        if (closed) return;
+        closed = true;
+        send('close', token, '', '');
+      },
+      focus: function () {},
+      blur: function () {},
+      get closed() { return closed; },
+      name: name || '',
+      opener: null,
+      document: doc
+    };
+
+    // ⚠️ 关键：真实 Window 的 location 是 [LegacyUnforgeable] +
+    // [PutForwards=href] 的访问器——w.location = url 会被转发到 href
+    // 上变成导航。如果这里写成普通数据属性（location: loc），站点的
+    // w.location = res.url 就只是把字符串写进属性、覆盖掉 loc，
+    // **静默不导航**，标签页永远停在 about:blank（这正是本 bug 的根因：
+    // 垫片注入是成功的，window.open 也返回了对象，站点不报错，
+    // 但赋值被吞掉）。所以必须用带 setter 的访问器，并设成不可配置
+    // 以贴近 unforgeable 语义。
+    try {
+      Object.defineProperty(win, 'location', {
+        get: function () { return loc; },
+        set: function (v) { navigate(v); },
+        enumerable: true,
+        configurable: false
+      });
+    } catch (e) {
+      win.location = loc;
+    }
+
+    return win;
+  };
+})();`;

package/src/preload/bridge.cjs

@@ -20,7 +20,19 @@ function sendEvent(event, data) {
 
 contextBridge.exposeInMainWorld("__ai_browser__", {
   sendTree: function(tree) { ipcRenderer.send("ai:tree", tree); },
-  sendDiff: function(changes) { ipcRenderer.send("ai:diff", changes); }
+  sendDiff: function(changes) { ipcRenderer.send("ai:diff", changes); },
+  // window.open 垫片的桥（主 world 侧脚本见 main/window_open_shim_source.js）。
+  // contextIsolation 下 preload 改不了页面的 window.open（那是 isolated
+  // world 的 window），所以垫片本体由 CDP 注入进主 world，只把这一个
+  // 出口经 contextBridge 暴露给它。
+  // ⚠️ arity 必须固定为 4：contextBridge 两岸参数数量不一致时调用会抛错
+  // （实测：垫片少传一个参数 → 抛错被 catch 吞掉 → window.open 静默返回
+  // null，站点拿到的还是"弹窗被拦"的老症状）。垫片侧所有调用都传满 4 个。
+  windowOpenBridge: function(op, token, url, name) {
+    if (op === 'open') ipcRenderer.send('ai:window_open', { token: token, url: url, name: name || '' });
+    else if (op === 'nav') ipcRenderer.send('ai:window_open_nav', { token: token, url: url });
+    else if (op === 'close') ipcRenderer.send('ai:window_open_close', { token: token });
+  }
 });
 
 // Extract tree request — echo back the request id so the main process can
@@ -34,10 +46,16 @@ ipcRenderer.on("ai:extract", function(_event, params) {
     ipcRenderer.send("ai:tree", { tree: tree, context: ctx, id: id });
   } catch(e) {
     console.error("[bridge] extractTree crash:", e.message, e.stack);
-    // Return empty fallback
+    // 兜底必须**声明自己是兜底**。
+    // 旧实现只把异常文本塞进一个节点的 label 就当树返回了：调用方看到一张
+    // "只有一个节点、没有可操作元素"的页面，无从判断是"页面本来就空"还是
+    // "我们没读成"。2026-10-19 实测在 about:blank 上就踩到了（document.cookie
+    // 在 opaque origin 抛 SecurityError），而那一刻 page_coverage 也只能给
+    // null —— 又一个"失败"和"没内容"长得一样的例子。
+    // 现在 read_ok/read_error 显式写进 context，main 侧会保留它。
     ipcRenderer.send("ai:tree", {
       tree: { id: "root", role: "generic", label: "[error: " + e.message + "]", states: ["visible"], actions: [], bounds: { x: 0, y: 0, width: 0, height: 0 } },
-      context: { modals: [], forms: [], session: {}, auth_wall: null, stats: {} },
+      context: { modals: [], forms: [], session: {}, auth_wall: null, stats: {}, read_ok: false, read_error: String(e && e.message || e) },
       id: id
     });
   }
@@ -55,7 +73,7 @@ ipcRenderer.on("ai:context", function(_event, params) {
   } catch(e) {
     ipcRenderer.send("ai:tree", {
       tree: null,
-      context: { modals: [], forms: [], session: {}, auth_wall: null, stats: {} },
+      context: { modals: [], forms: [], session: {}, auth_wall: null, stats: {}, read_ok: false, read_error: String(e && e.message || e) },
       id: id
     });
   }

package/src/preload/extractor.cjs

@@ -18,6 +18,25 @@ var frameProbe = require("../shared/frame_probe.cjs");
 // （旧元素沿用自身 data-ai-id，新元素却可能生成出同名的号），所以它只增不减。
 var AI_ID_SEQ = 0;
 
+// document.cookie 在 **opaque origin** 上会**抛 SecurityError**，不是返回空串。
+// 哪些页面是 opaque origin：about:blank、sandbox 属性的 iframe、data: 文档、
+// 导航失败后 Chromium 留下的空白页。
+//
+// 2026-10-19 实测事故：`ui.new_tab` 给一个打不开的域名，标签页停在 about:blank，
+// 于是 extractPageContext 在这里抛 SecurityError，**整个抽取器崩掉**，
+// bridge 的兜底把异常文本塞进一个节点当树返回 —— 调用方看到的是"页面只有
+// 一个节点"，而不是"读数失败"。一个可选字段（cookie 只用于登录态启发式）
+// 炸掉了整条读路径，这是纯粹的自伤。
+function readCookieSafely() {
+  try {
+    return document.cookie || "";
+  } catch (e) {
+    // 拿不到就当没有：登录态判定本来就把"没有 cookie 证据"当作未登录倾向，
+    // 这个降级方向是安全的（宁可说"需要确认登录"，不可谎报已登录）。
+    return "";
+  }
+}
+
 // ---- 必填 / 已判错（P2-2）----------------------------------------------
 // 这两条判定同时服务两处输出：语义树的 node.states 与 context.fields[].required。
 // 两个地方必须给同一个答案 —— 树里说"可选"而 context 说"必填"，比只给一处更糟。
@@ -522,9 +541,22 @@ function extractTree() {
     return null;
   }
 
-  function extractLabel(el) {
+  // label 的来源。**只有 kind === "text" 的字才在页面的 innerText 里**，
+  // 其余（aria-label / alt / title / placeholder）都是可访问名，不是渲染出来的文字。
+  //
+  // 为什么必须区分：coverage 的分母是 innerText，分子是树里 label 的字数。
+  // 把可访问名算进分子，等于拿两把尺子量 —— 实测 /basic.html：
+  // `<input placeholder="随便填">` 让分子 46 大于分母 43，明明只读到 43 字却报 100%。
+  // 这类节点在真实站点上极其常见（每个图标按钮都挂 aria-label），
+  // 所以这不是零点几个百分比的噪声，而是系统性虚高。
+  // 节点上只在"不是渲染文字"时才写 label_kind，正常节点不加字段（省 token）。
+  function extractLabel(el, meta) {
+    var setKind = function (kind, value) {
+      if (meta) meta.kind = kind;
+      return value;
+    };
     var ariaLabel = el.getAttribute("aria-label");
-    if (ariaLabel) return ariaLabel;
+    if (ariaLabel) return setKind("aria", ariaLabel);
     // 图片的可访问名是 alt（HTML-AAM 规定），此前完全没读。
     //
     // 实测（B站动态正文）：插入的表情是 `<img alt="[doge_金箍]">`，正文里看得见、
@@ -532,7 +564,7 @@ function extractTree() {
     // 同理，带 alt 的图标按钮（img 包在 <button> 里）也变成了无名节点。
     // 空 alt（alt="" 表示装饰性图片）继续往下走，不制造假名字。
     var alt = el.getAttribute("alt");
-    if (alt && String(alt).trim()) return String(alt).trim();
+    if (alt && String(alt).trim()) return setKind("alt", String(alt).trim());
     // input[type=submit|button|reset] 的可访问名是 value（同理，标准规定）。
     // 没有这条，提交按钮在树里是"无名可点节点"，只能靠坐标点。
     var tagName = String(el.tagName || "").toUpperCase();
@@ -540,17 +572,45 @@ function extractTree() {
       var itype = String(el.getAttribute("type") || "").toLowerCase();
       if (itype === "submit" || itype === "button" || itype === "reset") {
         var iv = el.getAttribute("value");
-        if (iv && String(iv).trim()) return String(iv).trim();
+        if (iv && String(iv).trim()) return setKind("value", String(iv).trim());
       }
     }
     var title = el.getAttribute("title");
-    if (title) return title;
-    var text = (el.textContent || "").trim();
-    if (text.length > 60) text = text.slice(0, 60);
-    if (text) return text;
+    if (title) return setKind("title", title);
+    var text = renderedText(el).trim();
+    // 截断必须**留痕**。原来这里是裸 `text.slice(0, 60)`：一段 500 字的正文在树里
+    // 变成 60 字，而且看不出被砍过 —— agent 会把它当成"这一段就这么点字"。
+    // 实测 /long.html：60 段全在树里，覆盖率只有 70%，原因就是每段被裁到 60；
+    // 而回执上没有任何一处说"我裁过"。抄 frame_read_source 的 clip() 口径，补一个省略号。
+    if (text.length > 60) text = text.slice(0, 59) + "\u2026";
+    if (text) return setKind("text", text);
     var placeholder = el.getAttribute("placeholder");
-    if (placeholder) return placeholder;
-    return "";
+    if (placeholder) return setKind("placeholder", placeholder);
+    return setKind("none", "");
+  }
+
+  // 元素上**看得见**的文字。
+  //
+  // 为什么不用裸 textContent：它把**不渲染的东西**也算进去，而 label 是
+  // 直接给 agent 当"这个元素写着什么"读的。2026-10-19 用受控页面实测了两类泄漏：
+  //   1. `<div style="display:none">…说明文字…</div>` 整段进了父节点的 label，
+  //      agent 会把一段用户根本看不见的说明当成页面正文；
+  //   2. `<canvas>` 页面的容器 label 里装的是 `<script>` 的 JS 源码
+  //      （"绘图工具 const c = document.getElementById('cv')…"）。
+  // 更根本的是**口径**问题：文字覆盖率的分母（stats.text_chars）用的是
+  // innerText，分子来自 label；label 用 textContent 就等于"分子分母两把尺子"，
+  // 那这个比例算出来没有意义。
+  //
+  // innerText 是浏览器算出来的"渲染后可见文字"：display:none / visibility:hidden /
+  // <script> / <style> 天然排除，换行也按渲染结果归一。
+  //
+  // 但要留 textContent 兜底：`<option>`、`<title>` 这类元素 innerText 可能为空，
+  // 而它们的文字是有效的可访问名。宁可多读，不可让按钮变无声。
+  function renderedText(el) {
+    var t = "";
+    try { t = el.innerText; } catch (e) { t = ""; }
+    if (t && t.trim()) return t;
+    try { return el.textContent || ""; } catch (e) { return ""; }
   }
 
   function extractBounds(el) {
@@ -647,7 +707,9 @@ function extractTree() {
         var ifrRect = el.getBoundingClientRect ? el.getBoundingClientRect() : { width: 0, height: 0 };
         opaqueFrames.push({
           id: el.id || null,
-          src: el.getAttribute("src") || null,
+          // 绝对地址（el.src 会被解析成绝对 URL）。相对地址对调用方没用：
+          // 树里写着 /mooc2-ans/xxx，agent 拿它去 navigate 只会失败。
+          src: (el.src || '').trim() || el.getAttribute("src") || null,
           width: Math.round(ifrRect.width || 0),
           height: Math.round(ifrRect.height || 0)
         });
@@ -660,7 +722,8 @@ function extractTree() {
         // opaque: 内容在另一个渲染进程。同源读取（getBoundingClientRect 之外
         // 的任何 DOM 访问）都到不了；读取要走 CDP Accessibility（ax:true）。
         opaque: true,
-        src: el.getAttribute("src") || null
+        // 绝对地址：树里出现的 iframe 必须能被直接打开（ui.new_tab）。
+        src: (el.src || '').trim() || el.getAttribute("src") || null
       };
     }
     if (!isSemantic(el)) {
@@ -679,7 +742,8 @@ function extractTree() {
       return null;
     }
 
-    var label = extractLabel(el);
+    var labelMeta = {};
+    var label = extractLabel(el, labelMeta);
     var role = inferRole(el);
     var actions = extractActions(el, role);
     var bounds = extractBounds(el);
@@ -753,6 +817,10 @@ function extractTree() {
       actions: actions,
       bounds: bounds
     };
+    // 只有当 label **不是**页面上渲染出来的文字时才写这一位。coverage 分子靠它
+    // 把 aria-label / alt / title / placeholder 排除掉（它们不在 innerText 里）。
+    // 正常节点不写，省 token。
+    if (labelMeta.kind && labelMeta.kind !== "text") node.label_kind = labelMeta.kind;
     // Attach current value for input/textarea/contenteditable.
     // 截断走共享契约（src/shared/value_contract.cjs）：按 Unicode code point
     // 计数，截断时带 value_truncated / value_full_length / value_fetch_ref，
@@ -885,13 +953,13 @@ function extractTree() {
           var oRect = ifr.getBoundingClientRect ? ifr.getBoundingClientRect() : { width: 0, height: 0 };
           opaqueFrames.push({
             id: ifr.id || null,
-            src: ifr.getAttribute("src") || null,
+            src: (ifr.src || '').trim() || ifr.getAttribute("src") || null,
             width: Math.round(oRect.width || 0),
             height: Math.round(oRect.height || 0)
           });
         } catch (e3) { /* 尺寸拿不到也留下存在性线索 */ }
       }
-      extraIframes.push({ id: "iframe-empty-" + counter++, role: "iframe", label: ifr.title || ifr.name || "iframe", opaque: true, src: ifr.getAttribute("src") || null });
+      extraIframes.push({ id: "iframe-empty-" + counter++, role: "iframe", label: ifr.title || ifr.name || "iframe", opaque: true, src: (ifr.src || '').trim() || ifr.getAttribute("src") || null });
     }
   }
   if (extraIframes.length && root) {
@@ -1386,7 +1454,7 @@ function extractPageContext() {
     url: document.URL,
     hasPasswordInput: hasPwdInput,
     hasAvatar: hasAvatar,
-    cookieString: document.cookie,
+    cookieString: readCookieSafely(),
   });
 
   return {
@@ -1423,7 +1491,83 @@ function extractPageContext() {
       inputs: document.querySelectorAll("input:not([type=hidden])").length,
       buttons: document.querySelectorAll("button").length,
       links: document.querySelectorAll("a[href]").length,
-      iframes: document.querySelectorAll("iframe").length
+      // 没有 href 的锚点（onclick / JS 驱动）。它们仍然是可点目标，而 a[href]
+      // 数不到 —— 超星泛雅的章节条目就是这一类。只报 links 会让人以为这页
+      // 一个链接都没有（实测该页 links=2、links_without_href=6）。
+      links_without_href: (function() {
+        try { return document.querySelectorAll("a:not([href])").length; } catch(e) { return 0; }
+      })(),
+      iframes: document.querySelectorAll("iframe").length,
+      // 页面**看得见的文字**总量 —— 文字覆盖率的分母（见 shared/doc_coverage.js）。
+      // 用 innerText 而不是 textContent：前者是浏览器算出来的"渲染后可见文字"，
+      // display:none / 折叠 / visibility:hidden 都不算。
+      // 只数**非空白字符**：innerText 会把结构分隔符也吐出来（表格里的 \t、
+      // 段落间的 \n），而分子（label）没有这些。实测一张 8×4 表格因此虚低到 68%，
+      // 实际每个单元格都在。两边同一把尺子，这个数字才有意义。
+      text_chars: (function() {
+        try {
+          var t = document.body && document.body.innerText;
+          if (!t) return 0;
+          var m = String(t).match(/[^\s\u00a0]/g);
+          return m ? m.length : 0;
+        } catch(e) { return 0; }
+      })(),
+      // 同源子帧里的可见文字。**必须单独算、并进分母**：抽取器会走进同源
+      // iframe（见 winOf 的注释），所以树里有它们的文字，但
+      // `document.body.innerText` 不会下钻到 iframe（iframe 是替换元素）。
+      // 2026-10-19 实测：主文档 21 字 + 同源子帧 330 字，分子 83、分母 20，
+      // 比例 4.15 被钳到 100% —— 一个 24% 的页面被报成"全读到了"。
+      // 比例大于 1 从来不是"读得特别好"，是**分母漏了一块**。
+      same_origin_chars: (function() {
+        var total = 0;
+        try {
+          var frames = document.querySelectorAll("iframe");
+          for (var i = 0; i < frames.length; i++) {
+            var doc = null;
+            try { doc = frames[i].contentDocument; } catch(e) { doc = null; }
+            if (!doc || !doc.body) continue;   // 跨进程帧拿不到 contentDocument
+            try {
+              var t = doc.body.innerText;
+              // 与 text_chars 同一把尺子：只数非空白字符
+              if (t) { var m = String(t).match(/[^\s\u00a0]/g); total += m ? m.length : 0; }
+            } catch(e) {}
+          }
+        } catch(e) {}
+        return total;
+      })(),
+      // canvas 数量。innerText 永远看不见画在画布上的字，所以这类页面的
+      // 文字覆盖率**不可度量** —— 报 100% 是彻头彻尾的谎报（实测：一个只画
+      // 了 12 行字的 canvas 页，分母 4 字、报 100%）。有它才能说"量不了"。
+      canvases: (function() {
+        try { return document.querySelectorAll("canvas").length; } catch(e) { return 0; }
+      })(),
+      // open shadow root 里的文字。
+      //
+      // 为什么必须算：抽取器会下探 shadowRoot（见 childrenOf 的注释），所以
+      // **树里有 shadow 内容**；但 `body.innerText` 不穿过 shadow 边界 ——
+      // 分母里没有。实测一个 shadow 页：树里 35 字、分母只有 8 字 → 比例 4.4
+      // → over_measured，看起来像"分子在重复计数"，实际是分母漏了一个表面。
+      //
+      // 这里用 textContent 而不是 innerText，原因很实在：拿不到某个 shadow root
+      // 的"渲染后文本"（host.innerText 不含 shadow 内容，逐个元素算 innerText
+      // 要遍历整棵影子树并触发布局）。所以这是**已知偏保守**的一侧：shadow 里
+      // 被 display:none 藏掉的文字也会被算进分母，让覆盖率略微偏低。
+      // 偏低的方向是安全的 —— 它只会让"读不全"更容易被发现，不会掩盖。
+      shadow_chars: (function() {
+        var total = 0;
+        try {
+          var all = document.querySelectorAll("*");
+          for (var i = 0; i < all.length; i++) {
+            var sr = all[i].shadowRoot;
+            if (!sr) continue;
+            try {
+              var t = sr.textContent;
+              if (t) total += String(t).replace(/[\s\u00a0]+/g, "").length;
+            } catch(e) {}
+          }
+        } catch(e) {}
+        return total;
+      })()
     }
   };
 }