@mrrisega/dsh-remote 0.6.14 → 0.6.16

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,33 +100,6 @@ 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 = `
-/* ===== 首屏加载提示（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; }
@@ -453,88 +431,25 @@ html[data-dsh-ma-merged-e2ee] #dsh-e2ee-badge { display: none !important; }
 const SCRIPT = `(() => {
   "use strict";
 
-  /* ===== 首屏加载提示（0.6.14）=====
-     用户反馈：「普通用户加载进入镜像页面时等待时间较长，目前等待过程中一直在转圈」
-     —— 官方那个转圈不告诉用户任何事。这里在**页面解析的第一时间**就挂上一条人话提示，
-     并在官方 UI 就绪（或兜底超时）后自动移除。
+  /* ===== 【0.6.16 已删除】首屏加载提示层（0.6.14 引入，0.6.15 仍在）=====
+     为什么删掉（业主实测，2026-09-25）：「界面都已经加载完了，十几秒就把插件的接口加载好了，
+     但这个遮罩一直不消失」—— 截图里官方 UI 就在下面透出来，秒表走到 187 秒。
+
+     根因是**设计错误**，不是某个选择器写错：
+       · 那是个 position:fixed / inset:0 / z-index:2147483000 的**全屏层**（88% 不透明背景 +
+         backdrop-blur），视觉上盖住整个应用；
+       · 它唯一的退出条件是 maBootLooksReady() 这组**DOM 启发式**（官方 frame 的
+         data-*-collapsed / 类名前缀，或 textarea/[contenteditable]/[role=textbox]）。
+         官方改版、会话尚未挂载输入框、或前缀变化时两组信号全不命中 → 层就永远留着。
+       · 当时我给自己写的安慰是「pointer-events:none，万一移除失效也绝不挡住点击」——
+         可对用户来说，**盖住视线和进不去没有区别**：刷新也一样，每次都要等 4 分钟兜底。
+     结论（业主要求）：**直接删掉这个功能**。首屏反馈交给官方自己的转圈；
+     我们不再在用户页面上放任何会覆盖整屏的东西 —— 这类层一旦判断失误就是"永远进不去"，
+     代价远大于它带来的提示价值（何况限速放开后首屏本来就快了）。
+
+     护栏见 test/mobile-adapter-guards.test.mjs：适配层不得再引入全屏覆盖层。 */
+  void 0;
 
-     ⚠️ 必须放在所有主机判定（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 判定
@@ -1699,6 +1614,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;
@@ -1718,6 +1799,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/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();
+  }
+});

package/clients/dsh-remote/test/e2ee-bridge.test.mjs

@@ -105,9 +105,12 @@ const OFFICIAL_BODY = `<!doctype html>
 <body><div id="root"></div></body></html>`;
 
 const upstream = http.createServer((req, res) => {
-  let body = "";
-  req.on("data", (c) => { body += c; });
+  // ⚠️ 必须按 Buffer 攒再一次性 toString：`body += chunk` 会对**每个分片**单独 toString，
+  //    一个多字节 UTF-8 字符正好跨在 64KB 分片边界上就会被拆坏（0.6.15 加了大正文用例才暴露）。
+  const chunks = [];
+  req.on("data", (c) => chunks.push(c));
   req.on("end", () => {
+    const body = Buffer.concat(chunks).toString("utf8");
     // 官方 dsh web 特征 html(Phase-4:验证 e2ee 启用的桥端注入镜像 shim)
     if (req.url === "/official" || req.url.startsWith("/api/official")) {
       res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
@@ -115,7 +118,7 @@ const upstream = http.createServer((req, res) => {
       return;
     }
     res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
-    res.end(JSON.stringify({ method: req.method, url: req.url, ct: req.headers["content-type"] || "", auth: req.headers["x-dsh-test-auth"] || "", body }));
+    res.end(JSON.stringify({ method: req.method, url: req.url, ct: req.headers["content-type"] || "", auth: req.headers["x-dsh-test-auth"] || "", want: req.headers["x-dsh-e2ee-want"] || "", body }));
   });
 });
 let upstreamWss = null;
@@ -375,6 +378,73 @@ test("E2EE HTTP:信封请求解封→上游→封回往返一致;篡改密文
   assert.match(badText, /auth_failed|无法解密/);
 });
 
+test("★ 0.6.15 三层 base64 降为两层:声明过的客户端收到二进制明文,协商头不转发上游", async () => {
+  // 业主实测（dev-1014f947f8ab，Ubuntu 上的 dsh + Windows 访问，首屏要等几分钟）：
+  // 同一条响应被 base64 编了三层（1.333³≈2.37×）。第一层是"gzip 正文进 JSON"，
+  // 现在由客户端声明 x-dsh-e2ee-want: bin 换成二进制框架；老客户端不声明 → 形态不变。
+  const u = globalThis.__unlocked;
+  assert.ok(u, "需要先解锁");
+  const { client } = u;
+  const payload = "首屏聚合包内容-".repeat(4000); // ~ 100KB：足够看出编码层差异
+
+  // ① 新客户端：声明二进制明文
+  const plainBin = Buffer.from(JSON.stringify({
+    m: "POST",
+    p: "/api/echo?bin=1",
+    h: { "content-type": "application/json; charset=utf-8", "x-dsh-e2ee-want": "bin" },
+    b: Buffer.from(payload, "utf8").toString("base64")
+  }), "utf8");
+  const envBin = client.seal({ kind: "http", dir: "p2b", counter: 21, data: plainBin });
+  const resBin = await fetch(`${routerBase}/remote/${DEV_ON}/api/echo?bin=1`, {
+    method: "POST",
+    headers: { ...envelopeRequestHeaders(client.sessId, "http"), cookie: COOKIE },
+    body: JSON.stringify(envBin)
+  });
+  assert.equal(resBin.status, 200);
+  const envRespBin = JSON.parse(await resBin.text());
+  const openedBin = client.open({ kind: "http-resp", dir: "b2p", env: envRespBin, counter: envRespBin.c, reqNonceB64: envBin.n });
+  assert.equal(openedBin.data[0], 0x02, "★ 声明过的客户端必须收到二进制明文框架（首字节 0x02）");
+  const respBin = decodeHttpResponsePlain(openedBin.data);
+  const upBin = JSON.parse(respBin.bodyBuffer.toString("utf8"));
+  assert.equal(upBin.want, "", "★ 内部协商头绝不能转发给上游 dsh web（它不是业务头）");
+  assert.equal(upBin.body, payload, "正文必须逐字节还原");
+
+  // ② 老客户端（不声明）→ 仍是旧 JSON 形态，解码照样成功（兼容性）
+  const plainOld = Buffer.from(JSON.stringify({
+    m: "POST",
+    p: "/api/echo?bin=0",
+    h: { "content-type": "application/json; charset=utf-8" },
+    b: Buffer.from(payload, "utf8").toString("base64")
+  }), "utf8");
+  const envOld = client.seal({ kind: "http", dir: "p2b", counter: 22, data: plainOld });
+  const resOld = await fetch(`${routerBase}/remote/${DEV_ON}/api/echo?bin=0`, {
+    method: "POST",
+    headers: { ...envelopeRequestHeaders(client.sessId, "http"), cookie: COOKIE },
+    body: JSON.stringify(envOld)
+  });
+  const envRespOld = JSON.parse(await resOld.text());
+  const openedOld = client.open({ kind: "http-resp", dir: "b2p", env: envRespOld, counter: envRespOld.c, reqNonceB64: envOld.n });
+  assert.equal(openedOld.data[0], 0x7b, "老客户端必须仍收到旧 JSON 明文（首字节 '{'）");
+  const respOld = decodeHttpResponsePlain(openedOld.data);
+  assert.equal(JSON.parse(respOld.bodyBuffer.toString("utf8")).body, payload);
+  // 同一份正文：新形态必须明显更小（省掉的就是那一层 33%）
+  assert.ok(openedOld.data.length > openedBin.data.length * 1.25,
+    `旧明文形态必须明显更大（实测 ${openedOld.data.length} vs ${openedBin.data.length}）`);
+});
+
+test("★ 0.6.15 隧道帧不再给信封 JSON 套第三层 base64（bridge→中继 是计量那条腿）", async () => {
+  const { e2eeHttpResponseFrame } = await import("../dsh-bridge.mjs");
+  const env = { v: 2, k: "http-resp", s: "s".repeat(32), c: 1, n: "n".repeat(16), t: 0, d: "A".repeat(3 * 1024 * 1024) };
+  const frame = e2eeHttpResponseFrame(7, env.s, env);
+  assert.equal(frame.bodyBase64, false, "★ 不得再标记 bodyBase64（那一层纯属白花 33% 流量）");
+  assert.equal(frame.status, 200);
+  assert.match(frame.headers["x-dsh-e2ee"], /k=http-resp$/);
+  assert.deepEqual(JSON.parse(frame.body), env, "中继解出来必须与原信封逐字段一致");
+  const oldBody = Buffer.from(JSON.stringify(env)).toString("base64");
+  assert.ok(oldBody.length > frame.body.length * 1.3,
+    `旧写法会把这条帧撑大 33%（实测 ${oldBody.length} vs ${frame.body.length}）`);
+});
+
 test("E2EE WS 数据流:&e2ee=&w= 标记 → 桥剥除标记连上游,逐消息加解密 echo 一致", async () => {
   const u = globalThis.__unlocked;
   assert.ok(u, "需要先解锁");

package/clients/dsh-remote/test/e2ee-client.test.mjs

@@ -32,7 +32,9 @@ import {
   normalizeKdf,
   parseEnvelopeMarker,
   parseWsE2eeParams,
-  randomB64
+  randomB64,
+  stripPlainWantHeader,
+  wantsBinaryResponsePlain
 } from "../e2ee-client.mjs";
 
 // 固定口令/盐的 MK 期望值:由 enterprise e2ee.js deriveE2eeMasterKey 计算得到
@@ -213,6 +215,45 @@ function flipB64(b64) {
   return buf.toString("base64url");
 }
 
+test("★ 0.6.15 二进制明文框架:正文不再 base64(省掉三层里的第一层),且旧 JSON 形态仍能解", () => {
+  // 业主实测"打开慢几分钟"的直接原因之一：同一条响应被 base64 编了三层(1.333³≈2.37×)。
+  // 第一层就是"gzip 正文塞进 JSON 明文"。二进制框架把它去掉，且必须**两种形态都能解**
+  // （老客户端只发旧形态，新客户端声明后收新形态）。
+  const body = Buffer.from("首屏聚合包".repeat(500), "utf8");
+  const headers = { "content-type": "application/javascript", "content-encoding": "gzip" };
+
+  const bin = encodeHttpResponsePlain({ status: 200, headers, bodyBuffer: body, binary: true });
+  const legacy = encodeHttpResponsePlain({ status: 200, headers, bodyBuffer: body });
+  assert.equal(bin[0], 0x02, "二进制框架必须以 0x02 开头（JSON 明文以 `{`=0x7B 开头，不可能冲突）");
+  // 旧形态：正文 base64 后是 1.333 倍（这就是被省掉的那一层）
+  assert.ok(legacy.length > bin.length * 1.3,
+    `旧 JSON 形态必须明显更大（实测 ${legacy.length} vs ${bin.length}）`);
+  assert.ok(bin.length < body.length + 256, `二进制框架只应多出一点头（实测 ${bin.length} vs 正文 ${body.length}）`);
+
+  const back = decodeHttpResponsePlain(bin);
+  assert.equal(back.status, 200);
+  assert.equal(back.enc, "gzip");
+  assert.equal(back.headers["content-type"], "application/javascript");
+  assert.deepEqual(Buffer.from(back.bodyBuffer), body, "正文必须逐字节还原");
+  const backLegacy = decodeHttpResponsePlain(legacy);
+  assert.deepEqual(Buffer.from(backLegacy.bodyBuffer), body, "旧形态必须照样能解（老客户端不受影响）");
+
+  // 空正文 / 只有头的响应
+  const empty = decodeHttpResponsePlain(encodeHttpResponsePlain({ status: 204, headers: {}, bodyBuffer: Buffer.alloc(0), binary: true }));
+  assert.equal(empty.status, 204);
+  assert.equal(empty.bodyBuffer.length, 0);
+});
+
+test("★ 0.6.15 协商头:只有客户端声明才用二进制框架,且声明头绝不转发给上游", () => {
+  assert.equal(wantsBinaryResponsePlain({ "x-dsh-e2ee-want": "bin" }), true);
+  assert.equal(wantsBinaryResponsePlain({ "X-DSH-E2EE-WANT": "BIN" }), true, "头名/值大小写不敏感");
+  assert.equal(wantsBinaryResponsePlain({ "x-dsh-e2ee-want": "json" }), false);
+  assert.equal(wantsBinaryResponsePlain({ "content-type": "application/json" }), false, "老客户端不发这个头 → 保持旧形态");
+
+  const stripped = stripPlainWantHeader({ "Content-Type": "application/json", "X-Dsh-E2ee-Want": "bin", "x-t": "v" });
+  assert.deepEqual(stripped, { "Content-Type": "application/json", "x-t": "v" }, "内部协商头绝不能出现在转发给上游的头里");
+});
+
 test("http 响应信封:封包→开包,enc=gzip 被提取、实体头剥离,正文还原", () => {
   const s = makeSession();
   const body = Buffer.from(JSON.stringify({ ok: true }), "utf8");

package/clients/dsh-remote/test/e2ee-shim.test.mjs

@@ -230,7 +230,16 @@ test("信封逐字段一致:http/http-resp/w(文本·二进制)/ctrl(shim ↔ no
 test("请求信封明文编解码与信封标记头同构(node 交叉)", () => {
   const plainShim = shim.seEncodeHttpReqPlain({ method: "POST", path: "/api/echo?b=2", headers: { "content-type": "application/json", "x-t": "v" }, bodyBytes: new Uint8Array(Buffer.from("载荷", "utf8")) });
   const plainNode = encodeHttpRequestPlain({ method: "POST", path: "/api/echo?b=2", headers: { "content-type": "application/json", "x-t": "v" }, bodyB64: Buffer.from("载荷", "utf8").toString("base64") });
-  assert.deepEqual(Buffer.from(plainShim), Buffer.from(plainNode));
+  const decShim = decodeHttpRequestPlain(plainShim);
+  const decNode = decodeHttpRequestPlain(plainNode);
+  // ★ 0.6.15:shim **额外**声明「响应明文请用二进制框架」（省掉正文那一层 base64）。
+  //   这是本版唯一一处**有意为之**的差异：老客户端（native.html / 企业版内置那份）不发这个头，
+  //   桥端也就永远不给他们发二进制明文 —— 兼容性靠"客户端声明"而不是靠版本号猜。
+  assert.equal(decShim.headers["x-dsh-e2ee-want"], "bin", "镜像页 shim 必须声明二进制明文框架");
+  assert.equal(decNode.headers["x-dsh-e2ee-want"], undefined, "桥端自己的编码器不得替客户端声明（否则老客户端会收到看不懂的字节）");
+  delete decShim.headers["x-dsh-e2ee-want"];
+  assert.deepEqual(decShim, decNode, "除该声明头外，请求明文逐字段同构");
+  assert.deepEqual(Buffer.from(decShim.bodyB64, "base64"), Buffer.from("载荷", "utf8"));
   const sessId = newSessId();
   assert.deepEqual(shim.seEnvelopeHeaders(sessId), envelopeRequestHeaders(sessId, "http"));
 });