@mrrisega/dsh-remote 0.6.13 → 0.6.15

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

@@ -36,6 +36,11 @@
  *          left+top 陈旧锚点,默认回到右下;再兜底一次“卡左上角”检测(合成鼠标事件走它自己
  *          的拖拽收尾,state/localStorage 由它自洽)。
  *        仅对 ≤820 且锚点命中 left+top 干预;透明区点击/滚动仍穿透,与桌面语义一致。
+ *     6)【0.6.15】**手机图片上传兼容**:官方只把 image/png|jpeg|webp|gif 当图片(本地编码随 prompt
+ *        发给模型),其余一律当普通文件后台上传 —— 模型于是"看不到图"。而手机最容易产出非白名单
+ *        类型(iPhone「高效」= image/heic;部分 Android 图库给空 type)。适配层在**捕获阶段**拦下
+ *        官方隐藏 input[type=file] 的 change,把这类文件**无损改 MIME**(扩展名可判时)或
+ *        canvas 转 JPEG 后重新派发;任何失败都原样重发,绝不丢文件。详见脚本内长注释。
  *
  * 宿主特征门(防误注入其它 html):
  *   - 注入前:content-type 必须 text/html 且含 </head> 且原文含官方标记
@@ -95,7 +100,34 @@ const RUNTIME_HOST_RE =
   /(data-sidebar-collapsed|data-details-collapsed|data-rightbar-collapsed|data-shell-overlay)|(pI_x6G_frame|hHd-Xa_root|hHd-Xa_toggle)/;
 
 const STYLE = `
-/* ===== dsh-remote mobile adapter (bridge 注入;仅 ≤820px 生效,桌面宽屏无任何规则) ===== */
+/* ===== 首屏加载提示（0.6.14）=====
+   为什么要有它：镜像页首屏要拉 dsh web 的全部客户端插件（实测 ~14 MB，一个不可拆分的
+   /plugins/?? 聚合请求），免费档限速下几十秒起步。此前页面上**只有官方那个转圈**，
+   用户无法区分"在加载"和"卡死了"，只能反复刷新 —— 反而更慢。
+   这里给一句人话提示 + 分阶段的补充说明，加载完成（或超时兜底）即自动移除。
+   ⚠️ 刻意**不**放进 @media (max-width:820px)：Windows/桌面浏览器打开镜像页同样要等。
+   ⚠️ pointer-events:none + 半透明：万一移除逻辑失效，也绝不挡住任何点击。 */
+.dsh-ma-boot {
+  position: fixed; inset: 0; z-index: 2147483000;
+  display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 14px;
+  background: color-mix(in srgb, var(--dsw-alias-bg-base, #0f1115) 88%, transparent);
+  backdrop-filter: blur(2px);
+  pointer-events: none;
+  font-family: inherit; text-align: center; padding: 24px;
+  transition: opacity .3s ease;
+}
+.dsh-ma-boot[data-fading="1"] { opacity: 0; }
+.dsh-ma-boot-spin {
+  width: 34px; height: 34px; border-radius: 50%;
+  border: 3px solid color-mix(in srgb, currentColor 22%, transparent);
+  border-top-color: currentColor;
+  animation: dsh-ma-boot-spin 1s linear infinite;
+}
+@keyframes dsh-ma-boot-spin { to { transform: rotate(360deg); } }
+.dsh-ma-boot-title { font-size: 15px; font-weight: 600; }
+.dsh-ma-boot-sub { font-size: 13px; line-height: 1.6; opacity: .75; max-width: 22em; }
+.dsh-ma-boot-elapsed { font-size: 12px; opacity: .55; font-variant-numeric: tabular-nums; }
+
 @media (max-width: 820px) {
   html, body { max-width: 100%; overflow-x: hidden; }
   html { -webkit-text-size-adjust: 100%; text-size-adjust: 100%; }
@@ -426,6 +458,89 @@ html[data-dsh-ma-merged-e2ee] #dsh-e2ee-badge { display: none !important; }
 const SCRIPT = `(() => {
   "use strict";
 
+  /* ===== 首屏加载提示（0.6.14）=====
+     用户反馈：「普通用户加载进入镜像页面时等待时间较长，目前等待过程中一直在转圈」
+     —— 官方那个转圈不告诉用户任何事。这里在**页面解析的第一时间**就挂上一条人话提示，
+     并在官方 UI 就绪（或兜底超时）后自动移除。
+
+     ⚠️ 必须放在所有主机判定（HOSTISH / NARROW）之前：首屏慢的正是这些判定等不到的时候。
+     ⚠️ 只做提示，不做任何拦截：pointer-events:none，也没有遮罩语义。 */
+  var maBootTip = null, maBootTimers = [], maBootStart = Date.now(), maBootElapsedTimer = 0, maBootWatchTimer = 0;
+  function maBootSet(cls, text) {
+    try { var n = maBootTip && maBootTip.querySelector(cls); if (n) n.textContent = text; } catch (e) { /* 忽略 */ }
+  }
+  function maBootShow() {
+    try {
+      if (maBootTip) return;
+      if (!document.body) return; // 解析太早（body 还没出来）→ 交给 DOMContentLoaded 再挂
+      maBootTip = document.createElement("div");
+      maBootTip.className = "dsh-ma-boot";
+      maBootTip.setAttribute("role", "status");
+      maBootTip.setAttribute("aria-live", "polite");
+      maBootTip.innerHTML =
+        '<div class="dsh-ma-boot-spin" aria-hidden="true"></div>' +
+        '<div class="dsh-ma-boot-title">正在加载远程桌面…</div>' +
+        '<div class="dsh-ma-boot-sub">首次打开需要下载较完整的前端资源，请稍候</div>' +
+        '<div class="dsh-ma-boot-elapsed">已等待 0 秒</div>';
+      document.body.appendChild(maBootTip);
+      // 秒表：让"到底等了多久"可见（用户据此判断是慢还是死了）
+      maBootElapsedTimer = setInterval(function () {
+        try {
+          var s = Math.floor((Date.now() - maBootStart) / 1000);
+          var n = maBootTip && maBootTip.querySelector(".dsh-ma-boot-elapsed");
+          if (n) n.textContent = "已等待 " + s + " 秒";
+        } catch (e) { /* 忽略 */ }
+      }, 1000);
+      maBootTimers.push(setTimeout(function () {
+        maBootSet(".dsh-ma-boot-sub", "网络较慢时可能需要一两分钟；加载完成后会自动进入，不用重复刷新");
+      }, 8000));
+      maBootTimers.push(setTimeout(function () {
+        maBootSet(".dsh-ma-boot-sub", "还在加载…如果长时间停在这里，可以下拉刷新重试（重复刷新不会更快）");
+      }, 30 * 1000));
+    } catch (e) { /* 提示失败绝不影响主功能 */ }
+  }
+  function maBootHide() {
+    try {
+      for (var i = 0; i < maBootTimers.length; i++) clearTimeout(maBootTimers[i]);
+      maBootTimers = [];
+      if (maBootElapsedTimer) { clearInterval(maBootElapsedTimer); maBootElapsedTimer = 0; }
+      if (maBootWatchTimer) { try { clearInterval(maBootWatchTimer); } catch (e) { /* 忽略 */ } maBootWatchTimer = 0; }
+      var tip = maBootTip;
+      maBootTip = null;
+      if (tip && tip.parentNode) {
+        try { tip.setAttribute("data-fading", "1"); } catch (e) { /* 忽略 */ }
+        setTimeout(function () { try { if (tip.parentNode) tip.parentNode.removeChild(tip); } catch (e) { /* 忽略 */ } }, 300);
+      }
+    } catch (e) { /* 忽略 */ }
+  }
+  /** 官方 UI 是否已经可用了（= 提示可以撤了）。 */
+  function maBootLooksReady() {
+    try {
+      // ① 适配层认出来的官方 frame（与下方 boot() 同一组选择器）
+      if (document.querySelector(".pI_x6G_frame, [data-sidebar-collapsed], [data-details-collapsed], [data-rightbar-collapsed]")) return true;
+      // ② 出现输入框/会话区也算"进来了"（官方改版首选信号失灵时的兜底）
+      return Boolean(document.querySelector('textarea, [contenteditable="true"], [role="textbox"]'));
+    } catch (e) { return false; }
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", maBootShow);
+  } else {
+    maBootShow();
+  }
+  // 轮询撤下：1s 一次，成本可忽略（只是两次 querySelector）；一旦撤下就自我停止。
+  // 上限与"4 分钟兜底"对齐，避免页面异常时留下常驻定时器。
+  maBootWatchTimer = setInterval(function () {
+    if (maBootLooksReady()) { maBootHide(); return; }
+    if (!maBootTip) { try { clearInterval(maBootWatchTimer); } catch (e) { /* 忽略 */ } maBootWatchTimer = 0; }
+  }, 1000);
+  maBootTimers.push(setTimeout(function () { maBootHide(); }, 240 * 1000));
+  // 页面卸载/进 bfcache 时收干净（测试与真机都靠这条不留悬挂定时器）
+  try {
+    var maBootBye = function () { maBootHide(); };
+    window.addEventListener("pagehide", maBootBye);
+    window.addEventListener("unload", maBootBye);
+  } catch (e) { /* 忽略 */ }
+
   /* —— 主机门解除(2026-09):镜像页(如 n.risegao.cn)经设备流认证回连同一台 127.0.0.1:3080,
      桥已把 Host 回环化并剥 Origin(不扩大信任面)。官方客户端以 transport.ownsHost 判定
      「自有主机」,非回环域名下不置 true 会把设置页置为 memory(不可用)镜像 →
@@ -1589,6 +1704,172 @@ const SCRIPT = `(() => {
       try { if (typeof requestAnimationFrame === "function") { requestAnimationFrame(run); return; } } catch (eRaf) { /* 退化 */ }
       setTimeout(run, 0);
     };
+    /* ===== 手机图片上传兼容（0.6.15）=====
+       业主反馈：「手机端无法识别图片」——现象是选了照片发出去，模型看不到图 / 当成普通文件。
+
+       根因（官方 dsh web 客户端逻辑,dsh-client-ui-conversation 的 createDrafts）:
+         · 只有 file.type ∈ {image/png, image/jpeg, image/webp, image/gif} 才走**图片**通道
+           （本地编码后随 prompt 发出，模型真的"能看"）；
+         · 其余一律当**普通文件**：走 Web Worker 后台上传，模型只拿到一个文件引用。
+       而手机恰恰最容易产出"非白名单"的图片：
+         · iPhone 默认「高效」格式拍出来是 image/heic（不在白名单）；
+         · 部分 Android 图库 / 文件提供器给出的是**空 type**（""）；
+         · 从"文件"入口选的还可能是 heif / bmp / tiff / avif。
+
+       做法（全在浏览器里完成，不动官方代码、不动 host）：
+         1) 在**捕获阶段**监听 change（比 React 根容器的监听更早）:官方隐藏 input[type=file]
+            被选中后,若里面有"是图片但不在白名单"的文件,就先拦下这次事件,
+            用 canvas 把它转成 JPEG，再**替换 input.files 并重新派发一次 change** ——
+            这样官方按图片通道收下，模型就能"看见"了；
+         2) 任何一步失败（浏览器解不了 HEIC / canvas 不可用 / DataTransfer 不可用…）
+            一律**把原始文件原样重新派发**，绝不比现状更差（宁可当普通文件，也不能丢文件）；
+         3) 官方认得的类型一个字节都不碰（零行为）。 */
+    var MA_IMG_OK = { "image/png": 1, "image/jpeg": 1, "image/webp": 1, "image/gif": 1 };
+    var MA_IMG_EXT_RE = /\\.(png|jpe?g|webp|gif|heic|heif|bmp|tiff?|avif)$/i;
+    var MA_MAX_DIM = 4096;              // 与官方 imageLimits.maxImageDimension 对齐，避免超限被拒
+    var MA_CONVERT_TIMEOUT = 8000;      // 解码卡住就放弃（原样放行）
+    var MA_REENTRY = "__dshMaImageDone"; // 标记"这次 change 是我们自己派发的"
+
+    function maIsImageFile(f) {
+      var t = String((f && f.type) || "").toLowerCase();
+      if (t) return t.indexOf("image/") === 0;
+      return MA_IMG_EXT_RE.test(String((f && f.name) || ""));
+    }
+    /** 需要转码吗：是图片、但不在官方白名单里。 */
+    function maNeedsConvert(f) {
+      var t = String((f && f.type) || "").toLowerCase();
+      if (MA_IMG_OK[t]) return false;
+      return maIsImageFile(f);
+    }
+    /** 扩展名 → 白名单里的 MIME（拿不到返回空）。 */
+    function maMimeFromName(name) {
+      var m = /\.([A-Za-z0-9]+)$/.exec(String(name || ""));
+      if (!m) return "";
+      var e = m[1].toLowerCase();
+      if (e === "png") return "image/png";
+      if (e === "jpg" || e === "jpeg") return "image/jpeg";
+      if (e === "webp") return "image/webp";
+      if (e === "gif") return "image/gif";
+      return "";
+    }
+    /**
+     * 只改 type、不重编码（**无损**）。
+     * 为什么需要：Android 图库/文件提供器很常见地给出 type:""，而文件本身其实是标准 PNG/JPEG ——
+     * 这时把字节丢进 canvas 重编码纯属浪费（还可能丢透明通道），改个 MIME 就够了。
+     */
+    function maRelabel(file, mime) {
+      try {
+        return new File([file], String(file.name || "image"), { type: mime, lastModified: file.lastModified || Date.now() });
+      } catch (e) {
+        try { var b = file.slice(0, file.size, mime); b.name = file.name; return b; } catch (e2) { return null; }
+      }
+    }
+    /** 单个文件的归一化：优先无损改 MIME，实在不行才 canvas 转 JPEG。 */
+    async function maNormalizeImage(file) {
+      var mime = maMimeFromName(file && file.name);
+      if (mime && String(file.type || "") !== mime) {
+        var relabeled = maRelabel(file, mime);
+        if (relabeled) return relabeled;
+      }
+      return await maToJpeg(file);
+    }
+    function maToJpeg(file) {
+      return new Promise(function (resolve) {
+        var url = "";
+        try { url = URL.createObjectURL(file); } catch (e0) { resolve(null); return; }
+        var settled = false;
+        var finish = function (out) {
+          if (settled) return;
+          settled = true;
+          try { URL.revokeObjectURL(url); } catch (e1) { /* 忽略 */ }
+          resolve(out);
+        };
+        var timer = setTimeout(function () { finish(null); }, MA_CONVERT_TIMEOUT);
+        var img;
+        try { img = new Image(); } catch (e2) { clearTimeout(timer); finish(null); return; }
+        img.onload = function () {
+          clearTimeout(timer);
+          try {
+            var w = img.naturalWidth || img.width || 0;
+            var h = img.naturalHeight || img.height || 0;
+            if (!w || !h) return finish(null);
+            var scale = Math.min(1, MA_MAX_DIM / Math.max(w, h));
+            var cw = Math.max(1, Math.round(w * scale));
+            var ch = Math.max(1, Math.round(h * scale));
+            var cv = document.createElement("canvas");
+            cv.width = cw; cv.height = ch;
+            var ctx = cv.getContext("2d");
+            if (!ctx) return finish(null);
+            ctx.drawImage(img, 0, 0, cw, ch);
+            cv.toBlob(function (blob) {
+              if (!blob) return finish(null);
+              var base = String(file.name || "photo").replace(/\\.[^./\\\\]+$/, "") || "photo";
+              try {
+                finish(new File([blob], base + ".jpg", { type: "image/jpeg", lastModified: Date.now() }));
+              } catch (e3) {
+                // 极老的浏览器没有 File 构造器 → 用 type 改写过的 Blob 兜底（官方只看 type/name）
+                try { blob.name = base + ".jpg"; finish(blob); } catch (e4) { finish(null); }
+              }
+            }, "image/jpeg", 0.92);
+          } catch (e5) { finish(null); }
+        };
+        img.onerror = function () { clearTimeout(timer); finish(null); };
+        try { img.src = url; } catch (e6) { clearTimeout(timer); finish(null); }
+      });
+    }
+    /** 把 files 塞回 input（DataTransfer 缺失/只读 → 返回 false，调用方走"原样重发"）。 */
+    function maSetInputFiles(input, files) {
+      try {
+        var dt = new DataTransfer();
+        for (var i = 0; i < files.length; i++) dt.items.add(files[i]);
+        if (!dt.files || dt.files.length !== files.length) return false;
+        input.files = dt.files;
+        return true;
+      } catch (e) { return false; }
+    }
+    /** 重新派发一次 change（带重入标记，避免我们自己的监听再拦一次）。 */
+    function maRedispatch(input) {
+      try {
+        input[MA_REENTRY] = true;
+        input.dispatchEvent(new Event("change", { bubbles: true }));
+      } catch (e) { /* 忽略 */ } finally {
+        setTimeout(function () { try { input[MA_REENTRY] = false; } catch (e2) { /* 忽略 */ } }, 0);
+      }
+    }
+    async function maOnFilePicked(input) {
+      var list = input && input.files ? Array.prototype.slice.call(input.files) : [];
+      if (!list.length) return;
+      var need = list.filter(maNeedsConvert);
+      if (!need.length) return; // 官方认得的类型 → 零行为
+      var out = [];
+      for (var i = 0; i < list.length; i++) {
+        if (!maNeedsConvert(list[i])) { out.push(list[i]); continue; }
+        var conv = await maNormalizeImage(list[i]);
+        if (conv) out.push(conv);
+        else out.push(list[i]); // 转不了就按原文件走（与现状一致，绝不丢）
+      }
+      if (maSetInputFiles(input, out)) maRedispatch(input);
+      else maRedispatch(input); // 塞不回去 → 原样重发（文件不丢）
+    }
+    function maInstallImageCompat() {
+      try {
+        document.addEventListener("change", function (e) {
+          var t = e.target;
+          if (!t || String(t.tagName || "").toUpperCase() !== "INPUT") return;
+          if (String(t.type || "").toLowerCase() !== "file") return;
+          if (t[MA_REENTRY]) return; // 我们自己派发的那次 → 放行
+          var files = t.files ? Array.prototype.slice.call(t.files) : [];
+          if (!files.length) return;
+          var any = false;
+          for (var i = 0; i < files.length; i++) { if (maNeedsConvert(files[i])) { any = true; break; } }
+          if (!any) return; // 无需转码 → 完全不拦（官方照旧处理）
+          // 拦下这一次：官方若先看到原文件，会立刻按"普通文件"起后台上传（那就白改了）
+          try { e.stopPropagation(); } catch (eS) { /* 忽略 */ }
+          maOnFilePicked(t).catch(function () { maRedispatch(t); });
+        }, true); // ★ 捕获阶段：必须早于 React 根容器的 change 监听
+      } catch (e) { /* 适配层绝不把页面拖挂 */ }
+    }
+
     /* 挂上"叫醒"的两条路。做成可重入(先清旧的再建新的),这样 bfcache 恢复后能重新武装。 */
     const maArm = () => {
       maTorn = false;
@@ -1608,6 +1889,7 @@ const SCRIPT = `(() => {
       try { maInterval = setInterval(pump, 1000); } catch (eInt) { maInterval = 0; }
     };
     maArm();
+    maInstallImageCompat(); // 手机图片上传兼容（见上方长注释）：装了就一直有效，与 pump 无关
     /* 清理:页面卸载时断开观察者与兜底表(bfcache/长驻页面都不留悬挂回调)。
        pagehide 覆盖 bfcache 场景,unload 兜底更老的浏览器。 */
     const maTeardown = () => {

package/clients/dsh-remote/test/boot-tip.test.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * 镜像页首屏加载提示的契约与行为测试（0.6.14）。
+ *
+ * 用户反馈：「普通用户加载进入镜像页面时等待时间较长，目前等待过程中一直在转圈。
+ *          建议给普通用户增加一个友好的提示（例如提示"正在排队中"）。」
+ *
+ * 首屏为什么慢：镜像页要拉 dsh web 的全部客户端插件（实测 ~14 MB 的一个**不可拆分**聚合请求），
+ * 免费档限速下几十秒起步。官方那个转圈不告诉用户任何事，用户只能反复刷新 —— 反而更慢。
+ *
+ * 这里守四件事：
+ *   ① 提示必须在**页面解析的第一时间**出现（早于所有主机判定 —— 首屏慢的正是判定等不到的时候）；
+ *   ② 分阶段补充说明（8s / 30s）与秒表，让"到底等了多久"可见；
+ *   ③ 官方 UI 就绪后自动撤下；且有 4 分钟兜底 + pagehide/unload 清理，绝不留悬挂定时器；
+ *   ④ 只做提示、不做拦截（pointer-events:none），提示失效也绝不挡住用户操作。
+ *
+ * 用法: node --test test/boot-tip.test.mjs
+ */
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import vm from "node:vm";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SRC = readFileSync(path.join(HERE, "..", "mobile-adapter.mjs"), "utf8");
+const STYLE = SRC.slice(SRC.indexOf("const STYLE = `") + "const STYLE = `".length, SRC.indexOf("`;\n\n/**", SRC.indexOf("const STYLE = `")));
+const SCRIPT_START = SRC.indexOf("const SCRIPT = `(() => {") + "const SCRIPT = `".length;
+const SCRIPT = SRC.slice(SCRIPT_START, SRC.indexOf("`;\n\n/**", SCRIPT_START));
+/**
+ * 只取「首屏提示」这一段来跑行为。
+ * 为什么不像别的用例那样跑整个适配层：整段要一整套 DOM 桩（抽屉/遮罩/设置面板…），
+ * 而这里要验的是**提示的生命周期**，隔离出来既稳又准（改动范围也正好是这一段）。
+ */
+const BOOT = SCRIPT.slice(SCRIPT.indexOf("var maBootTip"), SCRIPT.indexOf("/* —— 主机门解除"));
+
+/** 极简 DOM 桩：只支撑"提示出现/撤下"这条路径。 */
+function makeDom({ body = true, ready = false, frame = false } = {}) {
+  const nodes = [];
+  const el = (tag) => {
+    const n = {
+      tagName: String(tag).toUpperCase(), className: "", _text: "", children: [], attrs: {}, parentNode: null,
+      set innerHTML(v) { this._html = v; }, get innerHTML() { return this._html || ""; },
+      set textContent(v) { this._text = String(v); }, get textContent() { return this._text; },
+      setAttribute(k, v) { this.attrs[k] = String(v); },
+      appendChild(c) { c.parentNode = this; this.children.push(c); return c; },
+      removeChild(c) { this.children = this.children.filter((x) => x !== c); c.parentNode = null; return c; },
+      querySelector(sel) {
+        const cls = String(sel).replace(/^\./, "");
+        const hit = (x) => (x.className || "").split(/\s+/).includes(cls);
+        const walk = (x) => { for (const c of x.children) { if (hit(c)) return c; const d = walk(c); if (d) return d; } return null; };
+        return walk(this);
+      }
+    };
+    return n;
+  };
+  const doc = {
+    readyState: ready ? "complete" : "loading",
+    listeners: {},
+    createElement: el,
+    querySelector(sel) {
+      if (sel === ".dsh-ma-boot") return nodes.find((n) => (n.className || "").includes("dsh-ma-boot")) || null;
+      if (frame && /frame|textarea|contenteditable|textbox|sidebar-collapsed/.test(sel)) return el("div");
+      return null;
+    },
+    addEventListener(type, fn) { (this.listeners[type] = this.listeners[type] || []).push(fn); },
+    dispatch(type) { (this.listeners[type] || []).forEach((fn) => fn({})); }
+  };
+  if (body) { doc.body = el("body"); doc.body.className = ""; }
+  else { doc.body = null; doc.bodyHolder = el("body"); }
+  return { doc, nodes, el, attachBody() { doc.body = doc.bodyHolder; } };
+}
+
+function run(env) {
+  const timers = [];
+  const intervals = [];
+  const win = {
+    listeners: {},
+    addEventListener(type, fn) { (this.listeners[type] = this.listeners[type] || []).push(fn); },
+    dispatch(type) { (this.listeners[type] || []).forEach((fn) => fn({})); },
+    innerWidth: 390, innerHeight: 844,
+    location: { href: "https://example.test/remote/dev-x/", origin: "https://example.test" },
+    MutationObserver: class { observe() {} disconnect() {} },
+    requestAnimationFrame: (fn) => { timers.push({ fn, ms: 0 }); return timers.length; },
+    cancelAnimationFrame() {}, matchMedia: () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
+  };
+  const ctx = {
+    window: win,
+    document: env.doc,
+    location: win.location,
+    navigator: { userAgent: "node-test", language: "zh-CN" },
+    console: { warn() {}, log() {}, error() {} },
+    setTimeout: (fn, ms) => { timers.push({ fn, ms }); return timers.length; },
+    clearTimeout: () => {},
+    setInterval: (fn, ms) => { intervals.push({ fn, ms }); return intervals.length; },
+    clearInterval: () => {},
+    Date, Math, JSON, Object, Array, String, Number, Boolean, Error, RegExp, Promise, Map, Set
+  };
+  vm.createContext(ctx);
+  vm.runInContext(BOOT, ctx, { timeout: 5000 });
+  return { win, timers, intervals };
+}
+
+test("样式：提示层不挡点击（pointer-events:none）、覆盖所有宽度、有转圈与秒表样式", () => {
+  assert.match(STYLE, /\.dsh-ma-boot\s*\{[\s\S]*?pointer-events:\s*none/, "提示层绝不能拦截点击");
+  assert.ok(!/@media \(max-width: 820px\) \{\s*\.dsh-ma-boot/.test(STYLE), "提示不受窄屏限定（Windows/桌面浏览器同样要等）");
+  assert.match(STYLE, /\.dsh-ma-boot-spin/, "要有加载动画");
+  assert.match(STYLE, /\.dsh-ma-boot-elapsed/, "要有秒表");
+});
+
+test("★ 行为：页面还在解析（readyState=loading）也要立刻挂出提示", () => {
+  const env = makeDom({ ready: false, frame: false });
+  const { win, timers } = run(env);
+  // 提示挂载挂在 DOMContentLoaded 上（此时 body 可能还没出来）
+  assert.ok((env.doc.listeners.DOMContentLoaded || []).length > 0, "必须监听 DOMContentLoaded 再挂提示");
+  env.doc.dispatch("DOMContentLoaded");
+  const tip = env.doc.body.children.find((c) => (c.className || "").includes("dsh-ma-boot"));
+  assert.ok(tip, "解析阶段就要出现提示（这正是首屏最慢的时候）");
+  assert.match(tip.innerHTML, /正在加载远程桌面/);
+  assert.match(tip.innerHTML, /首次打开需要下载/, "要说明为什么慢");
+  assert.ok(timers.some((t) => t.ms === 8000) && timers.some((t) => t.ms === 30000), "要有 8s/30s 两段补充说明");
+  assert.ok(timers.some((t) => t.ms === 240000), "要有 4 分钟兜底撤下");
+  assert.ok((win.listeners.pagehide || []).length > 0, "pagehide 要清理（不留悬挂定时器）");
+});
+
+test("★ 行为：官方 UI 就绪后自动撤下提示", () => {
+  const env = makeDom({ ready: true, frame: true }); // ready=complete → 立即挂；frame=true → 已就绪
+  const { intervals } = run(env);
+  const tip = env.doc.body.children.find((c) => (c.className || "").includes("dsh-ma-boot"));
+  assert.ok(tip, "先挂上");
+  assert.ok(intervals.length >= 2, "要有秒表 + 就绪轮询两个定时器");
+  // 两个 interval 都是 1000ms（秒表 / 就绪轮询），顺序不保证 —— 全部推一次，模拟"1 秒过去"
+  intervals.forEach((t) => t.fn());
+  assert.equal(tip.attrs["data-fading"], "1", "官方 UI 就绪后应进入淡出");
+});
+
+test("行为：脚本在 <head> 里先跑（readyState=loading，body 还没出来）也绝不能抛，body 就位后补挂", () => {
+  // 真实时序就是这条：适配层被内联在 <head>，执行时 body 可能还不存在
+  const env = makeDom({ body: false, ready: false });
+  assert.doesNotThrow(() => run(env), "body 缺失时绝不能抛（适配层其他逻辑还要跑）");
+  env.attachBody();
+  env.doc.dispatch("DOMContentLoaded");
+  const tip = env.doc.body.children.find((c) => (c.className || "").includes("dsh-ma-boot"));
+  assert.ok(tip, "body 就位后补挂提示");
+  assert.match(tip.innerHTML, /正在加载远程桌面/);
+});
+
+test("源码契约：提示必须早于主机判定（HOSTISH/NARROW），否则首屏最慢那段没有提示", () => {
+  // ⚠️ 基准要用 **HOSTISH 的定义**（const HOSTISH =），不能用 indexOf("HOSTISH")：
+  //    提示那段自己的注释里就提到了 HOSTISH，拿注释当基准会把顺序判反（第一版就这么红的）。
+  const iTip = SCRIPT.indexOf("var maBootTip");
+  const iHost = SCRIPT.indexOf("const HOSTISH");
+  assert.ok(iTip > 0 && iHost > 0, "找不到提示段或主机判定");
+  assert.ok(iTip < iHost, "提示段必须在主机判定之前");
+  assert.ok(BOOT.includes("pointer-events: none") || STYLE.includes("pointer-events: none"), "必须写明不拦截点击");
+  assert.ok(!/dsh-ma-boot[\s\S]{0,400}?pointer-events:\s*auto/.test(STYLE), "提示层不得改成可点击拦截");
+});

package/clients/dsh-remote/test/dsh-events.test.mjs

@@ -1996,3 +1996,92 @@ test("一元：本地校验（空 text / 缺 sessionId / 坏 mode…）直接类
     await dispose();
   }
 });
+
+// ═══════════════════ 2026-09-25 事故：完成推送静默消失（业主实测）═══════════════════
+//
+// 现场：任务跑完了，微信**一条推送都没有**，bridge 日志里也**没有任何报错**。
+// 活体探针（以微信通道同款方式订阅本机 dsh web）显示：
+//   · 新起的订阅器 163ms 就发现并 follow 了正在跑的会话 —— 机制本身是好的；
+//   · 而当时在跑的 bridge 进程到 3080 只有 2 条 WS（mux + control）、**没有 follow 流**，
+//     可它明明有一个正在跑长任务的会话。
+// 根因就在下面这条：周期性发现被"当前一条 follow 都没有"这个条件**关掉了自己**——
+// 丢一次 status:true 边沿就永久失去发现能力，而 turn/end 只在 follow 流上才有。
+
+test("★ 事故锁：一条 follow 都没有时，周期性发现**仍然要跑**（丢一次边沿不能永久失聪）", async () => {
+  const api = await startFakeDsh({ listItems: [] }); // 连上时没有任何会话在跑
+  const sub = createEventSubscriber({
+    upstream: api.base,
+    cookie: () => api.cookie,
+    discoverIntervalMs: 40,
+    reconnect: { minMs: 15, maxMs: 40, factor: 1, jitter: 0 },
+  });
+  try {
+    await start(sub);
+    await api.waitForListCalls(1);
+    assert.deepEqual(sub.sessions(), [], "前置条件：此刻不 follow 任何会话");
+
+    // 之后某个会话开始跑，但**故意不发任何 status 边沿事件**（模拟边沿丢失/早于我们订阅）
+    const opened = [];
+    sub.on("follow-opened", (info) => opened.push(info));
+    api.setListItems([{ sessionId: "session-late", running: true }]);
+
+    // ⚠️ 用**有界**等待（`once` 会永久挂住）——回归时必须是"红"，不能是"卡死"。
+    try {
+      await waitFor(() => opened.length > 0, { label: "周期性发现把在跑的会话 follow 起来" });
+    } catch (e) {
+      assert.fail(`★ 一条 follow 都没有时，周期性发现也必须继续跑（否则丢一次边沿就永久失聪）：${e.message}`);
+    }
+    assert.equal(opened[0].sessionId, "session-late");
+    assert.deepEqual(sub.sessions(), ["session-late"]);
+  } finally {
+    sub.close();
+    await api.close();
+  }
+});
+
+test("★ 一次 follow 失败不该把这条会话**永久**钉死：下一轮 running 边沿必须重试", async () => {
+  const faults = [];
+  let failNext = true;
+  const api = await startFakeDsh({
+    onOpen(server, conn, stream) {
+      if (stream.endpoint !== "session/follow") return;
+      // 第一轮一律 agent-busy（真机上子代理/繁忙会话就是这个码）；之后放行
+      if (failNext) {
+        server.fail(conn, stream.streamId, {
+          code: "session/agent-busy",
+          message: "session is busy",
+          details: {},
+        });
+      }
+    },
+  });
+  const sub = createEventSubscriber({
+    upstream: api.base,
+    cookie: () => api.cookie,
+    followSettleMs: 20,
+    reconnect: { minMs: 15, maxMs: 40, factor: 1, jitter: 0 },
+  });
+  try {
+    sub.on("fault", (f) => faults.push(f));
+    await start(sub);
+
+    api.pushEmit("api-session/status", ["session-busy-then-ok", true]);
+    await waitFor(() => faults.some((f) => f.code === "session/agent-busy"), { label: "第一次 follow 被拒" });
+    assert.deepEqual(sub.sessions(), [], "第一次失败：没有 follow 流");
+
+    // 新一轮 running（用户又跑了一轮）→ 必须重新订阅，而不是被 #followBlocked 永久挡住
+    const opened = [];
+    sub.on("follow-opened", (info) => opened.push(info));
+    failNext = false;
+    api.pushEmit("api-session/status", ["session-busy-then-ok", true]);
+    try {
+      await waitFor(() => opened.length > 0, { label: "新一轮 running 触发重新订阅" });
+    } catch (e) {
+      assert.fail(`★ 一次 follow 失败不得把会话永久钉死（这一整轮的 turn/end 都会丢）：${e.message}`);
+    }
+    assert.equal(opened[0].sessionId, "session-busy-then-ok");
+  } finally {
+    sub.close();
+    await api.close();
+  }
+});