@mrrisega/dsh-remote 0.6.14 → 0.6.15

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

@@ -89,6 +89,8 @@ import {
   encodeHttpResponsePlain,
   hasEnvelopeMarker,
   parseWsE2eeParams,
+  stripPlainWantHeader,
+  wantsBinaryResponsePlain,
   writeE2eeStateFile
 } from "./e2ee-client.mjs";
 // 微信机器人通道(编排层):绑定控制面 + 出站通知路由 + 入站长轮询。
@@ -800,6 +802,34 @@ async function doHttp(method, path, reqHeaders, body, isB64) {
   };
 }
 
+/**
+ * 构造 e2ee http 响应帧（**导出给用例**：第三层 base64 的去留必须有测试钉住）。
+ *
+ * 【0.6.15】这里曾经是 `body: Buffer.from(JSON.stringify(respEnv)).toString("base64")`
+ * + `bodyBase64: true` —— 也就是把整个信封 JSON 再 base64 一次。中继拿到它做的第一件事
+ * 就是解回 UTF-8 再写给手机，所以这一层**纯属白花 33% 流量**，而且正好落在按流量计量的
+ * bridge→中继 那条 WS 上（业主实测那条聚合包：12.69 MiB vs 直接发 UTF-8 的 9.5 MiB）。
+ * 中继对两种形态都支持（`frame.bodyBase64` 真假之分），所以直接发 UTF-8 明文即可。
+ *
+ * @param {string|number} id 帧 id
+ * @param {string} sessId E2EE 会话 id（只进标记头）
+ * @param {object} respEnv 已封好的响应信封
+ * @returns {{id:any,type:string,status:number,headers:object,body:string,bodyBase64:boolean}}
+ */
+export function e2eeHttpResponseFrame(id, sessId, respEnv) {
+  return {
+    id,
+    type: "http",
+    status: 200, // 外层一律 200,真实状态在信封明文 st 里(§4.3)
+    headers: {
+      "content-type": ENVELOPE_CONTENT_TYPE,
+      "x-dsh-e2ee": `v=2;s=${sessId};k=http-resp`
+    },
+    body: JSON.stringify(respEnv),
+    bodyBase64: false // ★ 第三层 base64 在这里被去掉（见上）
+  };
+}
+
 export async function handleHttpFrame(dchOrSend, frame) {
   const send = toSender(dchOrSend);
   const { id, method = "GET", path = "/", headers = {}, body, bodyBase64: isB64 } = frame;
@@ -827,22 +857,19 @@ export async function handleHttpFrame(dchOrSend, frame) {
       const session = e2ee.guardHttpRequest(String(env?.s || ""), env);
       const opened = session.open({ kind: "http", dir: "p2b", env, counter: env?.c ?? 0 });
       const req = decodeHttpRequestPlain(opened.data);
-      const reply = await doHttp(req.method, req.path, req.headers, req.bodyB64, true);
+      // 客户端是否声明"响应用二进制明文框架"（省掉正文那一层 base64，见 e2ee-client.mjs 长注释）。
+      // 老客户端（native.html 的 WC-CORE / 企业版内置那份）不声明 → 照旧走 JSON，零影响。
+      // ★ 这个头**无条件**摘掉再转发：它是端到端内部协商头，不是业务头，不该出现在上游请求里
+      //   （哪怕客户端给了个我们看不懂的值，也不能原样漏给 dsh web）。
+      const wantBinPlain = wantsBinaryResponsePlain(req.headers);
+      const upstreamHeaders = stripPlainWantHeader(req.headers);
+      const reply = await doHttp(req.method, req.path, upstreamHeaders, req.bodyB64, true);
       const bodyBuffer = Buffer.from(reply.body, "base64");
-      const plain = encodeHttpResponsePlain({ status: reply.status, headers: reply.headers, bodyBuffer });
+      const plain = encodeHttpResponsePlain({ status: reply.status, headers: reply.headers, bodyBuffer, binary: wantBinPlain });
       // 响应压缩已发生在 doHttp(明文侧,gzip 在加密前 §4.7);信封用 http-resp kind
       const respEnv = session.seal({ kind: "http-resp", dir: "b2p", counter: env?.c ?? 0, data: plain, reqNonceB64: String(env?.n || "") });
-      send({
-        id,
-        type: "http",
-        status: 200, // 外层一律 200,真实状态在信封明文 st 里(§4.3)
-        headers: {
-          "content-type": ENVELOPE_CONTENT_TYPE,
-          "x-dsh-e2ee": `v=2;s=${env.s};k=http-resp`
-        },
-        body: Buffer.from(JSON.stringify(respEnv)).toString("base64"),
-        bodyBase64: true
-      });
+      // ★ 0.6.15：**不再**把整个信封 JSON 再 base64 一次（第三层）。理由见 e2eeHttpResponseFrame。
+      send(e2eeHttpResponseFrame(id, env.s, respEnv));
       console.log(`[bridge] e2ee http ${req.method} ${req.path} → ${reply.status} (${Date.now() - t0}ms, 信封 ${(reply.body.length * 3 / 4 / 1024).toFixed(0)}KB)`);
       return;
     } catch (e) {
@@ -1594,7 +1621,31 @@ async function runTunnel() {
   }, 1000);
 }
 
+/**
+ * 给 stdout/stderr 的每一行加 ISO 时间戳。
+ *
+ * 【2026-09-25 事故】bridge 日志**没有任何时间戳**，于是排查
+ * 「任务跑完没收到微信推送」时完全无法把日志和事件对上时间：
+ * 不知道最后一条 `sendmessage 失败` 发生在用户的回话之前还是之后，
+ * 最后只能靠"数行数 ÷ 每分钟行数"去估时间（估出来的结论还差点搞反方向）。
+ * 加了时间戳之后，这类问题一眼可读。只影响本进程的输出（日志由 watcher 重定向到 .dsh-bridge.log）。
+ */
+function stampConsoleLines() {
+  for (const level of ["log", "info", "warn", "error"]) {
+    const original = console[level]?.bind(console);
+    if (typeof original !== "function") continue;
+    console[level] = (...args) => {
+      try {
+        original(`[${new Date().toISOString()}]`, ...args);
+      } catch {
+        original(...args);
+      }
+    };
+  }
+}
+
 async function main() {
+  stampConsoleLines();
   // 隧道模式是唯一模式(WebRTC/信令已废弃删除)
   if (!TUNNEL_URL) {
     console.error("[bridge] 缺少 DSH_BRIDGE_TUNNEL_URL:隧道模式是唯一模式(请设 relay-router 地址)");

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

@@ -951,6 +951,13 @@ class EventSubscriber extends EventEmitter {
           clearTimeout(entry.settleTimer);
           entry.settleTimer = null;
         }
+        // ★ 2026-09-25：一次 follow 失败不该把这条会话**永久**钉死。
+        //   旧行为是失败即 `#followBlocked.add()`，此后**本代**（直到 mux 重连）再也不订阅它 ——
+        //   而「这一轮又跑起来了」（status:true）恰恰是重新订阅的正当理由。
+        //   不清掉的话：一次 `session/agent-busy`/`session/not-found` 抖动 = 该会话这一整轮的
+        //   turn/end 全部丢失 = 完成推送静默消失（与上面定时任务那个自我关停是同一类事故）。
+        //   重试天然有界：一次 running 边沿最多触发一次重新订阅，不会打转。
+        this.#followBlocked.delete(sessionId);
         this.#ensureFollow(sessionId);
       } else {
         this.#running.delete(sessionId);
@@ -1092,8 +1099,21 @@ class EventSubscriber extends EventEmitter {
     const timer = setTimeout(() => {
       this.#discoverTimer = null;
       if (this.#closed || this.#state !== "ready") return;
-      // 没有 follow 流就没有可对账的东西；但**每代**至少发现过一次（连接时就做过了）。
-      if (this.#follows.size > 0) void this.discoverRunningSessions().catch(() => {});
+      // ★ 2026-09-25 事故修复：这里原本写成 `if (this.#follows.size > 0)`，注释是
+      //   「没有 follow 流就没有可对账的东西（每代至少发现过一次）」。
+      //   它漏掉了这条定时任务的**另一半职责：发现**。丢一次边沿事件（mux 重连、status:true
+      //   早于我们订阅、帧被丢）就会让 `#follows` 长期为 0，而这条任务又因为「0 个流」把自己关掉
+      //   → **从此再也不发现任何会话** → 该会话的 turn/end 永远收不到 → 完成推送**静默消失**。
+      //
+      //   真机现场（业主本人，2026-09-25）：任务跑完一条微信都没收到，bridge 日志里也
+      //   **没有任何报错**（因为确实什么都没发生）。活体探针（以微信通道同款方式订阅本机）显示：
+      //     · 新起的订阅器 **163ms** 就发现并 follow 了正在跑的会话 —— 机制本身是好的；
+      //     · 而当时在跑的 bridge 进程到 3080 只有 **2 条** WS（mux + control）、**没有 follow 流**，
+      //       可它明明有一个正在跑长任务的会话 —— 正是这里的自我关停把发现能力锁死了。
+      //
+      //   代价：一次 `session/list`（本机实测 291 个会话约 200ms）。每 120s 一次完全承受得起，
+      //   换来的是「丢了边沿也能在两分钟内自愈」。
+      void this.discoverRunningSessions().catch(() => {});
       this.#scheduleDiscovery();
     }, interval);
     timer.unref?.();

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

@@ -469,9 +469,12 @@ export function headerValueOf(headers, name) {
  * @returns {{method:string, path:string, headers:object, bodyB64:string, hasBody:boolean}}
  */
 export function decodeHttpRequestPlain(buf) {
+  // ⚠️ 不能写 `String(buf)`：手机端 shim 交出来的是 Uint8Array，String() 会得到 "123,34,..."，
+  //    结果永远是"不是 JSON"（0.6.15 对拍用例抓到的真问题）。
+  const raw = Buffer.isBuffer(buf) ? buf : (typeof buf === "string" ? Buffer.from(buf, "utf8") : Buffer.from(buf ?? []));
   let pt;
   try {
-    pt = JSON.parse(Buffer.isBuffer(buf) ? buf.toString("utf8") : String(buf));
+    pt = JSON.parse(raw.toString("utf8"));
   } catch {
     throw new E2eeError("bad_plain", "e2ee: http 请求明文不是 JSON");
   }
@@ -479,8 +482,8 @@ export function decodeHttpRequestPlain(buf) {
   const method = typeof pt.m === "string" && pt.m ? pt.m.toUpperCase() : "GET";
   const path = typeof pt.p === "string" && pt.p ? pt.p : "/";
   const headers = pt.h && typeof pt.h === "object" ? pt.h : {};
-  const b = typeof pt.b === "string" ? pt.b : "";
-  return { method, path, headers, bodyB64: b, hasBody: b !== "" };
+  const bodyB64 = typeof pt.b === "string" ? pt.b : "";
+  return { method, path, headers, bodyB64, hasBody: bodyB64 !== "" };
 }
 
 /** 编码请求信封明文(测试端/手机侧对称实现用;b 一律为 base64 正文)。 */
@@ -490,13 +493,60 @@ export function encodeHttpRequestPlain({ method = "GET", path = "/", headers = {
 }
 
 /**
- * 响应信封明文(§4.3):{ "st":status, "h":{头, 去 content-length/encoding}, "enc":"gzip|", "b":<b64> }
- * @returns {{status:number, headers:object, enc:string, bodyBuffer:Buffer}}
+ * 响应信封明文（§4.3）。
+ *
+ * 两种形态（**自动识别**，由首字节判别，解码方无需知道对方是哪个版本）：
+ *
+ *   ① 旧/兼容 JSON：`{ "st", "h", "enc", "b":<base64 正文> }` —— 首字节 `{`（0x7B）；
+ *   ② 新二进制框架（0.6.15）：`[0x02][4B 大端头长度][头 JSON][正文原始字节]` —— 首字节 0x02。
+ *
+ * ## 为什么要有 ②（这是"打开慢几分钟"的直接原因之一）
+ *
+ * 同一条响应在链路上被 base64 编码了**三层**（每层 +33%，叠起来 2.37 倍），其中第一层就是这里：
+ * gzip 后的正文塞进 JSON 只能 base64。以实测那条首屏聚合包（gzip 后 5.35 MiB）为例：
+ *
+ *   gzip 正文            5.35 MiB
+ *     ① base64 进 JSON     7.14 MiB   ← 本函数（旧形态）
+ *     ② AES-GCM 密文 base64url  9.52 MiB
+ *     ③ 信封 JSON base64   12.69 MiB  ← 隧道帧（bridge→中继，见 dsh-bridge.mjs）
+ *
+ * ②用"头 JSON + 正文原样跟在其后"的框架，**第一层 33% 直接消失**：明文 = 5.35 MiB + 几百字节头。
+ * 手机端下载量随之从 1.78× 降到 1.33×（9.52 → 7.14 MiB），中继那侧的计量也同步下降。
+ *
+ * ## 为什么是"客户端声明才用"
+ *
+ * 明文框架是**端到端**格式：老的手机客户端（`clients/dsh-web/native.html` 抽出的 WC-CORE、
+ * 企业版内置的那份）只认旧 JSON。所以改成**由客户端在请求里声明**（`x-dsh-e2ee-want: bin`），
+ * 桥端只对声明过的请求用新框架 —— 老客户端一个字都不用改，也不会收到看不懂的字节。
+ *
+ * @returns {{status:number, headers:object, enc:string, bodyBuffer:Buffer, bodyB64:string}}
+ *          `bodyBuffer` 是原始字节（新旧两种形态都填）；`bodyB64` 仅旧 JSON 形态填
+ *          （兼容既有调用方/对拍用例；二进制形态**不**额外做一次 base64，那正是要省掉的开销）。
  */
 export function decodeHttpResponsePlain(buf) {
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf ?? []);
+  if (b.length >= 5 && b[0] === PLAIN_BIN_MAGIC) {
+    const len = b.readUInt32BE(1);
+    if (len > 0 && 5 + len <= b.length) {
+      let head;
+      try {
+        head = JSON.parse(b.subarray(5, 5 + len).toString("utf8"));
+      } catch {
+        throw new E2eeError("bad_plain", "e2ee: http 响应明文头不是 JSON");
+      }
+      if (!head || typeof head !== "object") throw new E2eeError("bad_plain", "e2ee: http 响应明文缺失");
+      return {
+        status: Number(head.st) || 502,
+        headers: head.h && typeof head.h === "object" ? head.h : {},
+        enc: typeof head.enc === "string" ? head.enc : "",
+        bodyBuffer: b.subarray(5 + len), // 视图，零拷贝
+        bodyB64: ""
+      };
+    }
+  }
   let pt;
   try {
-    pt = JSON.parse(Buffer.isBuffer(buf) ? buf.toString("utf8") : String(buf));
+    pt = JSON.parse(b.toString("utf8"));
   } catch {
     throw new E2eeError("bad_plain", "e2ee: http 响应明文不是 JSON");
   }
@@ -512,11 +562,36 @@ export function decodeHttpResponsePlain(buf) {
       throw new E2eeError("bad_plain", "e2ee: http 响应 body base64 非法");
     }
   }
-  return { status, headers, enc, bodyBuffer };
+  return { status, headers, enc, bodyBuffer, bodyB64: typeof pt.b === "string" ? pt.b : "" };
+}
+
+/** 二进制明文框架的魔数（JSON 明文以 `{`=0x7B 开头，0x02 永不冲突）。 */
+export const PLAIN_BIN_MAGIC = 0x02;
+/** 客户端在**加密请求明文**里声明"我的响应明文请用二进制框架"的头（见上方长注释）。 */
+export const PLAIN_WANT_BIN_HEADER = "x-dsh-e2ee-want";
+export const PLAIN_WANT_BIN_VALUE = "bin";
+
+/** 请求头里是否声明了"响应用二进制明文框架"（大小写不敏感）。 */
+export function wantsBinaryResponsePlain(headers) {
+  const v = headerValueOf(headers, PLAIN_WANT_BIN_HEADER);
+  return String(v).toLowerCase().split(/[\s,]+/).includes(PLAIN_WANT_BIN_VALUE);
 }
 
-/** 编码响应信封明文(status/headers/原始正文;content-encoding 提取到 enc)。 */
-export function encodeHttpResponsePlain({ status = 200, headers = {}, bodyBuffer = Buffer.alloc(0) }) {
+/** 从请求头里摘掉那个"内部协商"头（它绝不能转发给上游 dsh web）。返回新的头对象（不改原对象）。 */
+export function stripPlainWantHeader(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers || {})) {
+    if (String(k).toLowerCase() === PLAIN_WANT_BIN_HEADER) continue;
+    out[k] = v;
+  }
+  return out;
+}
+
+/**
+ * 编码响应信封明文（status/headers/原始正文；content-encoding 提取到 enc）。
+ * @param {boolean} [o.binary] true = 用二进制框架（省掉正文那一层 base64；仅客户端声明时使用）
+ */
+export function encodeHttpResponsePlain({ status = 200, headers = {}, bodyBuffer = Buffer.alloc(0), binary = false }) {
   const h = {};
   let enc = "";
   for (const [k, v] of Object.entries(headers || {})) {
@@ -527,11 +602,20 @@ export function encodeHttpResponsePlain({ status = 200, headers = {}, bodyBuffer
     }
     h[k] = Array.isArray(v) ? v.join(", ") : String(v);
   }
+  const head = { st: Number(status) || 200, h, enc };
+  const body = Buffer.isBuffer(bodyBuffer) ? bodyBuffer : Buffer.alloc(0);
+  if (binary) {
+    const headBuf = Buffer.from(JSON.stringify(head), "utf8");
+    const out = Buffer.allocUnsafe(5 + headBuf.length + body.length);
+    out[0] = PLAIN_BIN_MAGIC;
+    out.writeUInt32BE(headBuf.length, 1);
+    headBuf.copy(out, 5);
+    body.copy(out, 5 + headBuf.length);
+    return out;
+  }
   return Buffer.from(JSON.stringify({
-    st: Number(status) || 200,
-    h,
-    enc,
-    b: Buffer.isBuffer(bodyBuffer) && bodyBuffer.length ? bodyBuffer.toString("base64") : ""
+    ...head,
+    b: body.length ? body.toString("base64") : ""
   }), "utf8");
 }
 

package/clients/dsh-remote/e2ee-shim-script.js

@@ -211,12 +211,39 @@
   };
 
   /* ---- http 明文载荷编解码(与 node encode/decodeHttp*Plain 同构) ---- */
+  /* 0.6.15:响应明文支持二进制框架(首字节 0x02)，省掉"gzip 正文 → base64"那一层(+33%)。
+     由**本客户端主动声明**(请求明文里的 x-dsh-e2ee-want: bin)，桥端只对声明过的请求用它 ——
+     老客户端/企业版内置的那份不认识这个头，也就永远收不到看不懂的字节。 */
+  var SE_PLAIN_BIN_MAGIC = 2;
+  var SE_WANT_BIN_HEADER = "x-dsh-e2ee-want";
   function seEncodeHttpReqPlain(opt) {
     var b = opt.bodyBytes && opt.bodyBytes.length ? seBytesToB64(opt.bodyBytes) : "";
-    return seUtf8(JSON.stringify({ m: String(opt.method || "GET").toUpperCase(), p: opt.path, h: opt.headers || {}, b: b }));
+    var src = opt.headers || {};
+    var h = {};
+    for (var k in src) { if (Object.prototype.hasOwnProperty.call(src, k)) h[k] = src[k]; }
+    h[SE_WANT_BIN_HEADER] = "bin"; // 只加在信封明文里（外层 HTTP 头不带它）
+    return seUtf8(JSON.stringify({ m: String(opt.method || "GET").toUpperCase(), p: opt.path, h: h, b: b }));
   }
   function seDecodeHttpRespPlain(buf) {
-    var text = buf instanceof Uint8Array ? seUtf8Decode(buf) : String(buf);
+    var u8 = buf instanceof Uint8Array ? buf : new Uint8Array(0);
+    // ① 二进制框架：[0x02][4B 大端头长度][头 JSON][正文原始字节]
+    if (u8.length >= 5 && u8[0] === SE_PLAIN_BIN_MAGIC) {
+      var headLen = ((u8[1] << 24) | (u8[2] << 16) | (u8[3] << 8) | u8[4]) >>> 0;
+      if (headLen > 0 && 5 + headLen <= u8.length) {
+        var head = null;
+        try { head = JSON.parse(seUtf8Decode(u8.subarray(5, 5 + headLen))); } catch (e) { throw seErr("bad_plain", "e2ee: http 响应明文头不是 JSON"); }
+        if (!head || typeof head !== "object") throw seErr("bad_plain", "e2ee: http 响应明文缺失");
+        return {
+          status: Number(head.st) || 502,
+          headers: head.h && typeof head.h === "object" ? head.h : {},
+          enc: typeof head.enc === "string" ? head.enc : "",
+          bodyBytes: u8.subarray(5 + headLen),
+          bodyB64: ""
+        };
+      }
+    }
+    // ② 兼容 JSON：{st,h,enc,b:<base64>}
+    var text = buf instanceof Uint8Array ? seUtf8Decode(buf) : String(buf || "");
     var pt = null;
     try { pt = JSON.parse(text); } catch (e) { throw seErr("bad_plain", "e2ee: http 响应明文不是 JSON"); }
     if (!pt || typeof pt !== "object") throw seErr("bad_plain", "e2ee: http 响应明文缺失");
@@ -224,6 +251,7 @@
       status: Number(pt.st) || 502,
       headers: pt.h && typeof pt.h === "object" ? pt.h : {},
       enc: typeof pt.enc === "string" ? pt.enc : "",
+      bodyBytes: typeof pt.b === "string" && pt.b ? seB64ToBytes(pt.b) : new Uint8Array(0),
       bodyB64: typeof pt.b === "string" ? pt.b : ""
     };
   }
@@ -455,7 +483,7 @@
       seNotifyFail("响应明文非法");
       return seErrorResponse("bad_plain", "⚠ 无法解密:响应明文非法");
     }
-    var bodyU8 = rp.bodyB64 ? seB64ToBytes(rp.bodyB64) : new Uint8Array(0);
+    var bodyU8 = rp.bodyBytes instanceof Uint8Array ? rp.bodyBytes : (rp.bodyB64 ? seB64ToBytes(rp.bodyB64) : new Uint8Array(0));
     if (rp.enc === "gzip" && bodyU8.length) {
       var un = await seGunzip(bodyU8);
       if (!un) return seErrorResponse("gunzip", "⚠ 无法解压:响应 gzip 解压失败");

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> 且原文含官方标记
@@ -1699,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;
@@ -1718,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/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();
+  }
+});