@mrrisega/dsh-remote 0.6.14 → 0.6.16

package/clients/dsh-remote/test/mobile-adapter-guards.test.mjs

@@ -32,6 +32,7 @@
  *   浏览器里的真实结果另在 headless Chromium + 官方 GUI 上验证过（见报告）。
  */
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
 import test from "node:test";
 import vm from "node:vm";
 import { injectMobileAdapter } from "../mobile-adapter.mjs";
@@ -349,7 +350,10 @@ function harness({
     MutationObserver: MutationObserverStub,
     ResizeObserver: class { observe() {} disconnect() {} },
     requestAnimationFrame: (fn) => setImmediate(fn),
-    setTimeout: (fn, ms) => setTimeout(fn, ms),
+    // unref：适配层自带 8s/30s/**4 分钟**的兜底计时器（首屏提示），不 unref 的话
+    // 测试进程会一直等到最后一个定时器到期才退出 —— 实测这个文件因此**空等 4 分钟**，
+    // 单次全量测试的 94% 时间都花在这里（2026-09-25 实测：240s vs 其余 20 个文件合计 30s）。
+    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); try { id.unref?.(); } catch { /* 忽略 */ } return id; },
     clearTimeout: (id) => clearTimeout(id),
     setInterval: (fn) => { intervals.push(fn); return intervals.length; },
     clearInterval: (id) => { if (id) intervals[id - 1] = null; },
@@ -830,3 +834,43 @@ test("自动收抽屉：桌面宽屏(>820)不收起", async () => {
   await waitTick();
   assert.equal(clicks(), 0, "宽屏没有离屏抽屉这回事 —— 窄屏门必须继续有效");
 });
+
+test("★ 迭代速度护栏：适配层测试的假定时器**必须 unref**（否则每个文件空等 4 分钟）", () => {
+  // 2026-09-25 实测：适配层会挂 8s / 30s / **4 分钟** 的首屏提示兜底计时器，
+  // 而两个适配层测试文件的假 setTimeout 直接转给 Node 的真定时器 → 测试全跑完后
+  // 进程还要等最后一个定时器到期才退出：单文件 **240 秒**，而其余 20 个文件合计只有 30 秒。
+  // 也就是说"每轮迭代全量测试 8.5 分钟"里 **94% 是纯空等**。
+  // 这条护栏把 unref 钉住 —— 它一丢，迭代速度立刻退回 8 分钟级。
+  const files = ["mobile-adapter-guards.test.mjs", "mobile-adapter-runtime.test.mjs", "mobile-adapter-image.test.mjs"];
+  for (const f of files) {
+    const src = readFileSync(new URL(`./${f}`, import.meta.url), "utf8");
+    assert.match(src, /id\.unref\?\.\(\)/, `${f} 的假 setTimeout 必须 unref（否则该文件会空等数分钟）`);
+  }
+});
+
+test("★ 护栏：解析期绝不许往页面塞东西（0.6.14 首屏提示层就是这么做、然后永久盖住 UI 的）", () => {
+  // 事故 3（2026-09-25，业主实测）：「界面都已经加载完了…但这个遮罩一直不消失」，
+  // 截图里官方 UI 就在 88% 不透明的全屏层下面透出来，秒表走到 187 秒 —— 刷新也一样。
+  //
+  // 根因是**设计错误**：那个提示层是 `position:fixed; inset:0; z-index:2147483000` 的全屏层，
+  // 退出条件却是 DOM 启发式（官方 data-* 属性 / 类名前缀 / textarea…）。官方一改版，
+  // 两组信号全不命中 → 层永远留着。当时我写的"pointer-events:none 所以不会挡点击"是自我安慰：
+  // **盖住视线和进不去对用户没区别**。
+  //
+  // 业主决定：直接删掉。这条护栏守两件事：
+  //   ① `dsh-ma-boot` 不许回来；
+  //   ② **解析期**（主机门之前）不许有任何 `appendChild` —— 页面还没确认是官方 dsh web，
+  //      更不该有任何覆盖层；所有注入节点都必须在 boot() 里、过了主机门之后才做。
+  const { js: script, css } = injected();
+  const gate = script.indexOf("/* —— 主机门解除");
+  assert.ok(gate > 0, "找不到主机门锚点（脚本结构变了，请同步更新本用例）");
+  const preGate = script.slice(script.indexOf('"use strict";'), gate);
+  assert.ok(!/appendChild/.test(preGate),
+    "★ 解析期不得往页面 appendChild 任何节点（首屏提示层就是在这里挂上去、然后永远不消失的）");
+  assert.ok(!/dsh-ma-boot/.test(script), "首屏提示层必须已彻底删除");
+
+  // 全屏 + 超高 z-index 的组合本身就是"一旦判断失误就永远进不去"，不许出现
+  assert.ok(!/z-index:\s*[0-9]{7,}/.test(css),
+    "不得出现 1000000 以上的 z-index（压过一切的全屏层 = 判断错一次就锁死用户）");
+  assert.ok(!/dsh-ma-boot/.test(css), "首屏提示层的样式必须已彻底删除");
+});

package/clients/dsh-remote/test/mobile-adapter-image.test.mjs

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+/**
+ * mobile-adapter **图片上传兼容**契约测试（假 DOM + vm 执行真实注入脚本）。
+ *
+ * 业主反馈（2026-09）：「手机端无法识别图片」——选了照片发出去，模型看不到图 / 被当成普通文件。
+ *
+ * 根因（官方 dsh web 客户端 `dsh-client-ui-conversation` 的 createDrafts）：
+ *   只有 `file.type ∈ {image/png,image/jpeg,image/webp,image/gif}` 才走**图片**通道
+ *   （本地编码随 prompt 发出 → 模型真能"看"）；其余一律当**普通文件**（后台上传 + 一个文件引用）。
+ * 手机恰恰最容易给出非白名单类型：iPhone「高效」格式 = `image/heic`；部分 Android = 空 type。
+ *
+ * 本用例拿 injectMobileAdapter() 注入的**真实脚本**在假 DOM 里跑，断言运行时行为：
+ *   ① HEIC → 转成 JPEG 后再交给官方（官方收到的是 image/jpeg，而不是 heic）；
+ *   ② 空 type + `.png` 扩展名 → **无损**改 MIME（不重编码）；
+ *   ③ 官方认得的类型 → 一根手指都不动（零行为）；
+ *   ④ 任何失败（解码失败 / DataTransfer 不可用）→ **原样重新派发**，文件绝不丢。
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import vm from "node:vm";
+import { injectMobileAdapter } from "../mobile-adapter.mjs";
+
+function adapterScript() {
+  const { html } = injectMobileAdapter("<!doctype html><html><head></head><body></body></html>");
+  const m = /<script id="[^"]*-js"[^>]*>([\s\S]*?)<\/script>/.exec(html);
+  assert.ok(m, "应能取出注入脚本");
+  return m[1];
+}
+
+// ── 极简假 DOM：只实现图片兼容这条路径真正用到的东西 ──────────────────────────
+class FakeFile {
+  constructor(parts, name, opts = {}) {
+    this._blob = { parts: parts.map((p) => String(p)) };
+    this.name = name;
+    this.type = opts.type || "";
+    this.size = this._blob.parts.join("").length;
+    this.lastModified = opts.lastModified || 1;
+  }
+  slice(_a, _b, mime) {
+    const f = new FakeBlob(this._blob.parts, mime || this.type);
+    f.name = this.name;
+    return f;
+  }
+}
+class FakeBlob {
+  constructor(parts, type) { this._parts = parts; this.type = type || ""; this.size = parts.join("").length; this.name = ""; }
+  slice(_a, _b, mime) { const b = new FakeBlob(this._parts, mime || this.type); b.name = this.name; return b; }
+}
+class FakeInput {
+  constructor() {
+    this.tagName = "INPUT";
+    this.type = "file";
+    this.files = [];
+    this._listeners = new Map();
+    this._attrs = {};
+  }
+  getAttribute(n) { return n in this._attrs ? this._attrs[n] : null; }
+  setAttribute(n, v) { this._attrs[n] = String(v); }
+  addEventListener(t, fn) { if (!this._listeners.has(t)) this._listeners.set(t, []); this._listeners.get(t).push(fn); }
+  removeEventListener() {}
+  // 真实 DOM 里 dispatchEvent 会再走一遍 document 捕获监听 —— 那次会被 MA_REENTRY 提前返回，
+  // 所以这里只跑本元素上的监听即可（语义等价）。
+  dispatchEvent(ev) {
+    ev.target = this;
+    for (const fn of this._listeners.get(ev.type) || []) fn(ev);
+    return true;
+  }
+}
+class FakeEvent {
+  constructor(type, init = {}) {
+    this.type = type;
+    this.bubbles = init.bubbles !== false;
+    this._stopped = false;
+    this._prevented = false;
+    this.target = null;
+  }
+  stopPropagation() { this._stopped = true; }
+  preventDefault() { this._prevented = true; }
+}
+
+/**
+ * 最小事件派发模型：document（捕获）→ target（冒泡）。
+ * capture 阶段 stopPropagation 后，**target 上的监听不再收到** —— 这正是 React 根容器监听
+ * （挂在 document 之下的容器上）会因此被拦住的机制，也是本方案能生效的前提。
+ */
+function fireChange(env, input) {
+  const ev = new FakeEvent("change", { bubbles: true });
+  ev.target = input;
+  for (const fn of env.docListeners.capture) fn(ev);
+  if (ev._stopped) return ev;
+  for (const fn of input._listeners.get("change") || []) fn(ev);
+  return ev;
+}
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function makeEnv({ decodeHeic = true, hasDataTransfer = true, frame = null } = {}) {
+  const docListeners = { capture: [], bubble: [] };
+  const input = new FakeInput();
+  const created = { canvases: 0, blobs: 0, objectUrls: 0, revoked: 0 };
+
+  const doc = {
+    documentElement: { outerHTML: "<html><head><title>DeepSeek Harness</title><script>window.__ModuleLoader__=1</script></head><body></body></html>" },
+    body: { appendChild() {}, querySelector: () => null, classList: { add() {}, remove() {} } },
+    readyState: "complete",
+    addEventListener(type, fn, opts) {
+      const capture = typeof opts === "object" ? !!opts.capture : opts === true;
+      (capture ? docListeners.capture : docListeners.bubble).push(fn);
+    },
+    removeEventListener() {},
+    querySelector: () => frame,
+    querySelectorAll: () => [],
+    getElementById: () => null,
+    createElement(tag) {
+      if (String(tag).toLowerCase() !== "canvas") return { style: {}, setAttribute() {}, appendChild() {}, classList: { add() {}, remove() {} } };
+      created.canvases += 1;
+      const cv = {
+        width: 0,
+        height: 0,
+        style: {},
+        getContext: () => ({ drawImage() {} }),
+        toBlob(cb, mime) {
+          created.blobs += 1;
+          cb(new FakeBlob(["jpeg-bytes"], mime || "image/jpeg"));
+        }
+      };
+      return cv;
+    },
+    createTextNode: (t) => ({ nodeValue: t })
+  };
+
+  class FakeImage {
+    constructor() { this.naturalWidth = 0; this.naturalHeight = 0; this.width = 0; this.height = 0; }
+    set src(v) {
+      this._src = v;
+      // HEIC 在部分浏览器上解不了；这里用开关模拟"解码成功/失败"
+      setTimeout(() => {
+        if (decodeHeic) { this.naturalWidth = 4032; this.naturalHeight = 3024; this.onload && this.onload(); }
+        else { this.onerror && this.onerror(); }
+      }, 0);
+    }
+    get src() { return this._src; }
+  }
+
+  const timers = new Set();
+  const win = {
+    innerWidth: 390,
+    innerHeight: 800,
+    devicePixelRatio: 2,
+    addEventListener() {},
+    removeEventListener() {},
+    getComputedStyle: () => ({ getPropertyValue: () => "" }),
+    requestAnimationFrame: (fn) => setTimeout(fn, 0),
+    // unref：适配层自带 8s/30s/4min 的兜底计时器（首屏提示、看门狗），不 unref 会把测试进程吊住。
+    // 用例里的 await wait(...) 用的是宿主定时器（未 unref），足够让这些 vm 内定时器在该跑的时候跑到。
+    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); try { id.unref?.(); } catch (e) { /* 忽略 */ } timers.add(id); return id; },
+    clearTimeout: (id) => { timers.delete(id); clearTimeout(id); },
+    MutationObserver: class { observe() {} disconnect() {} },
+    ResizeObserver: class { observe() {} disconnect() {} },
+    location: { href: "https://n.risegao.cn:13443/remote/dev-x/", host: "n.risegao.cn", pathname: "/remote/dev-x/", origin: "https://n.risegao.cn:13443" },
+    localStorage: { getItem: () => null, setItem() {}, removeItem() {} }
+  };
+
+  const ctx = vm.createContext({
+    window: win,
+    document: doc,
+    console,
+    setTimeout: win.setTimeout,
+    clearTimeout: win.clearTimeout,
+    setInterval: () => 0,
+    clearInterval() {},
+    MutationObserver: win.MutationObserver,
+    ResizeObserver: win.ResizeObserver,
+    requestAnimationFrame: win.requestAnimationFrame,
+    navigator: { userAgent: "iPhone Safari", maxTouchPoints: 5, platform: "iPhone" },
+    location: win.location,
+    localStorage: win.localStorage,
+    URL: {
+      createObjectURL() { created.objectUrls += 1; return "blob:fake/" + created.objectUrls; },
+      revokeObjectURL() { created.revoked += 1; }
+    },
+    Image: FakeImage,
+    File: FakeFile,
+    Blob: FakeBlob,
+    Event: FakeEvent,
+    Date, Math, JSON, Object, Array, String, Number, RegExp, Boolean, Promise, Error,
+    isNaN, parseInt, parseFloat
+  });
+  if (hasDataTransfer) {
+    ctx.DataTransfer = class {
+      constructor() { this.items = { _f: [], add(f) { this._f.push(f); } }; }
+      get files() { return this.items._f; }
+    };
+  }
+  ctx.globalThis = ctx;
+  return { ctx, input, docListeners, created };
+}
+
+function runAdapter(env) {
+  vm.runInContext(adapterScript(), env.ctx, { filename: "mobile-adapter.js" });
+}
+
+// ─────────────────────────── 用例 ───────────────────────────
+
+test("★ iPhone HEIC 照片 → 转成 JPEG 后再交给官方（否则会被当成普通文件，模型看不到）", async () => {
+  const env = makeEnv();
+  runAdapter(env);
+
+  // 官方监听（模拟 React 根容器/输入框上的 change 处理）
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const heic = new FakeFile(["heic-bytes"], "IMG_0001.HEIC", { type: "image/heic" });
+  env.input.files = [heic];
+  fireChange(env, env.input); // 第一次：被适配层拦下（官方收不到）
+  assert.equal(official.length, 0, "★ 必须先把这次事件拦下来，不能让官方按普通文件先收走");
+
+  await wait(30); // 等 canvas 转码完成 + 重新派发
+
+  assert.equal(official.length, 1, "转码完成后必须重新派发一次 change");
+  const got = official[0];
+  assert.equal(got.length, 1);
+  assert.equal(got[0].type, "image/jpeg", "★ 交给官方的必须是白名单里的 image/jpeg");
+  assert.equal(got[0].name, "IMG_0001.jpg", "文件名也要跟着换成 .jpg（面板/模型看到的名字才一致）");
+  assert.equal(env.created.canvases, 1, "HEIC 必须走 canvas 转码");
+});
+
+test("★ Android 空 type + .png → **无损**改 MIME（不重编码，不丢透明通道）", async () => {
+  // Android 图库经文件提供器给出的 file.type 常常是空串；字节本身是标准 PNG。
+  // 这种情况走 canvas 重编码纯属浪费（还会把透明通道压成黑底），只改 MIME 就够了。
+  const env = makeEnv();
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const png = new FakeFile(["png-bytes"], "screenshot.png", { type: "" });
+  env.input.files = [png];
+  fireChange(env, env.input);
+  await wait(30);
+
+  assert.equal(official.length, 1);
+  assert.equal(official[0][0].type, "image/png", "★ 空 type 的 PNG 必须被改写成 image/png");
+  assert.equal(env.created.canvases, 0, "★ 不得重编码（无损路径不该碰 canvas）");
+  assert.equal(env.created.blobs, 0);
+});
+
+test("★ 官方认得的类型（image/jpeg）→ 零行为：不拦、不转、不重派发", async () => {
+  const env = makeEnv();
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const jpg = new FakeFile(["jpg-bytes"], "photo.jpg", { type: "image/jpeg" });
+  env.input.files = [jpg];
+  fireChange(env, env.input);
+  await wait(20);
+
+  assert.equal(official.length, 1, "官方应当**当场**收到事件（我们没有拦）");
+  assert.equal(official[0][0], jpg, "原文件对象必须是同一个（一个字节都没动）");
+  assert.equal(env.created.canvases, 0);
+  assert.equal(env.created.objectUrls, 0);
+});
+
+test("★ 解码失败（浏览器读不了 HEIC）→ 原样重新派发，文件绝不丢", async () => {
+  const env = makeEnv({ decodeHeic: false });
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const heic = new FakeFile(["heic-bytes"], "IMG_2.HEIC", { type: "image/heic" });
+  env.input.files = [heic];
+  fireChange(env, env.input);
+  await wait(40);
+
+  assert.equal(official.length, 1, "转不了也必须把这次选择交回官方（否则用户会觉得「选了没反应」）");
+  assert.equal(official[0][0].name, "IMG_2.HEIC", "交回去的是**原文件**（宁可当普通文件，也不能丢）");
+});
+
+test("★ DataTransfer 不可用（老浏览器）→ 原样重新派发，不吞事件", async () => {
+  const env = makeEnv({ hasDataTransfer: false });
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const heic = new FakeFile(["heic-bytes"], "IMG_3.HEIC", { type: "image/heic" });
+  env.input.files = [heic];
+  fireChange(env, env.input);
+  await wait(40);
+
+  assert.equal(official.length, 1, "塞不回 input.files 时必须原样重发");
+  assert.equal(official[0][0].name, "IMG_3.HEIC");
+});
+
+test("★ 混合选择：只动需要动的那个，其余原样（顺序也不许乱）", async () => {
+  const env = makeEnv();
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const jpg = new FakeFile(["a"], "a.jpg", { type: "image/jpeg" });
+  const heic = new FakeFile(["b"], "b.heic", { type: "image/heic" });
+  const pdf = new FakeFile(["c"], "c.pdf", { type: "application/pdf" });
+  env.input.files = [jpg, heic, pdf];
+  fireChange(env, env.input);
+  await wait(40);
+
+  assert.equal(official.length, 1);
+  const got = official[0];
+  assert.equal(got.length, 3, "文件数量必须保持 3");
+  assert.equal(got[0], jpg, "官方认得的原样保留（同一对象）");
+  assert.equal(got[1].type, "image/jpeg", "HEIC 被转成 JPEG");
+  assert.equal(got[1].name, "b.jpg");
+  assert.equal(got[2], pdf, "非图片原样保留");
+});
+
+test("接线守卫：图片兼容必须真的被装上，且走**捕获阶段**（否则拦不住 React 根容器）", () => {
+  const src = adapterScript();
+  assert.match(src, /maInstallImageCompat\(\);/, "必须在主流程里调用（定义了不调用等于没做）");
+  const i = src.indexOf('document.addEventListener("change"');
+  assert.ok(i > 0, "找不到 change 监听");
+  const tail = src.slice(i, i + 2000);
+  assert.ok(/\},\s*true\s*\)\s*;/.test(tail),
+    "★ 必须注册在捕获阶段（第三个参数 true）：React 根容器的 change 监听在 document 之下，冒泡阶段拦不住它");
+  assert.match(src, /MA_REENTRY/, "必须有重入标记（否则自己派发的 change 会再被自己拦一次，死循环）");
+});

package/clients/dsh-remote/test/mobile-adapter-runtime.test.mjs

@@ -168,7 +168,9 @@ function harness({ collapsedAttr = undefined, detailsAttr = undefined, sidebarRe
     removeEventListener() {},
     getComputedStyle: () => ({ getPropertyValue: () => "" }),
     requestAnimationFrame: (fn) => { const id = setImmediate(fn); return id; },
-    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); timers.set(id, fn); return id; },
+    // unref：同上 —— 适配层的 4 分钟兜底计时器会让测试进程空等到期（本来 240s，只剩 0.2s）。
+    // 用例里的 `_pendingTimers` 仍会被 runAdapter() 主动跑一轮，行为不变。
+    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); try { id.unref?.(); } catch { /* 忽略 */ } timers.set(id, fn); return id; },
     clearTimeout: (id) => clearTimeout(id),
     MutationObserver: class { observe() {} disconnect() {} },
     ResizeObserver: class { observe() {} disconnect() {} },