@mrrisega/dsh-remote 0.6.13 → 0.6.15

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

@@ -76,6 +76,7 @@ import { promisify } from "node:util";
 import { gzip as gzipCb } from "node:zlib";
 // 移动端适配层(经隧道访问的官方 dsh web 窄屏注入;DSH_MOBILE_ADAPTER=0 可关闭,默认开启)
 import { maybeInjectMobileAdapter } from "./mobile-adapter.mjs";
+import { discoverUpstream, resolveUpstreamHint, FALLBACK_UPSTREAM } from "./upstream-discovery.mjs";
 // 镜像页 E2EE 加密 shim(Phase-4):text/html 注入;DSH_E2EE_SHIM=0 可关闭,叠加 e2ee.enabled 灰度门
 import { maybeInjectE2eeShim } from "./e2ee-shim.mjs";
 // E2EE(端到端加密)客户端基建(Phase-2):MK 派生/会话密钥/信封/握手/开关
@@ -88,6 +89,8 @@ import {
   encodeHttpResponsePlain,
   hasEnvelopeMarker,
   parseWsE2eeParams,
+  stripPlainWantHeader,
+  wantsBinaryResponsePlain,
   writeE2eeStateFile
 } from "./e2ee-client.mjs";
 // 微信机器人通道(编排层):绑定控制面 + 出站通知路由 + 入站长轮询。
@@ -114,7 +117,23 @@ const CONFIG_PATH = process.env.DSH_BRIDGE_CONFIG || DEFAULT_CONFIG;
 // 隧道模式(唯一):bridge 主动 WS 连 relay-router 的 /_bridge
 const TUNNEL_URL = (process.env.DSH_BRIDGE_TUNNEL_URL || "").replace(/\/+$/, "");
 const TUNNEL_HEARTBEAT_MS = Math.max(100, Number(process.env.DSH_BRIDGE_HEARTBEAT_MS) || 15_000);
-const UPSTREAM = process.env.DSH_BRIDGE_UPSTREAM || "http://127.0.0.1:3080";
+/**
+ * 上游 dsh web 的地址。
+ *
+ * ⚠️ 这里**不能**只信环境变量 + 写死 3080（2026-09-23 两起用户实测）：
+ *   ① `dsh web --port 8090` / `--port 0`（系统分配）→ 3080 没人听；
+ *   ② **DSH Desktop**（Electron 壳 `dsh-plugin-desktop`）默认 43120，被占用还会 +1。
+ * bridge 与 watcher 共用同一份发现实现（`upstream-discovery.mjs`）：
+ *   显式环境变量 > `<relayDir>/.dsh-upstream`（插件半用 ctx.webServer.port 落盘）> DSH_WEB_URL
+ *   > **动态发现**（本机 dsh 进程实际监听端口 + Desktop 端口区间，且每个候选都做身份校验）。
+ *
+ * 用 `let` 是因为：① 发现发生在启动之后（异步）；② 上游端口变了要能在**不重启 bridge** 的前提下跟上。
+ */
+const RELAY_DIR = path.dirname(CONFIG_PATH);
+let UPSTREAM = (() => {
+  const hint = resolveUpstreamHint({ relayDir: RELAY_DIR });
+  return hint.url || FALLBACK_UPSTREAM;
+})();
 // 微信机器人通道总开关:DSH_WECHAT=0 关闭(默认开启)。控制面只 bind 回环,且必须带 bridge_secret。
 const WECHAT_DISABLED = String(process.env.DSH_WECHAT || "") === "0";
 // 默认云端服务地址（dsh-remote setup 会显式传入；自建模式无需账号 API）
@@ -385,6 +404,37 @@ const STRIP_RES_HEADERS = new Set([
   "connection", "keep-alive", "upgrade"
 ]);
 
+
+/** 上游重新发现的冷却:失败请求可能连成片,不能每个都去 lsof/pgrep + 探端口。 */
+const UPSTREAM_REFRESH_COOLDOWN_MS = 15_000;
+let upstreamRefreshedAt = 0;
+let upstreamRefreshInflight = null;
+/**
+ * 重新解析上游地址(带身份校验;显式 DSH_BRIDGE_UPSTREAM 时是恒等操作)。
+ * 上游端口变了(Desktop 换端口 / dsh web 重启到别的端口)时,靠它自愈而不必重启 bridge。
+ */
+async function refreshUpstream(reason = "") {
+  if (upstreamRefreshInflight) return upstreamRefreshInflight;
+  const now = Date.now();
+  if (now - upstreamRefreshedAt < UPSTREAM_REFRESH_COOLDOWN_MS) return UPSTREAM;
+  upstreamRefreshedAt = now;
+  upstreamRefreshInflight = (async () => {
+    try {
+      const found = await discoverUpstream({ relayDir: RELAY_DIR });
+      if (found.url && found.url !== UPSTREAM) {
+        console.log(`[bridge] 上游地址切换: ${UPSTREAM} → ${found.url}（来源 ${found.source}${reason ? `,${reason}` : ""}）`);
+        UPSTREAM = found.url;
+      }
+      return UPSTREAM;
+    } catch {
+      return UPSTREAM;
+    } finally {
+      upstreamRefreshInflight = null;
+    }
+  })();
+  return upstreamRefreshInflight;
+}
+
 console.log(`[bridge] 设备 ${DEVICE_ID} → 隧道 ${TUNNEL_URL}/_bridge`);
 console.log(`[bridge] 上游 ${UPSTREAM}`);
 
@@ -752,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;
@@ -779,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) {
@@ -816,6 +891,9 @@ export async function handleHttpFrame(dchOrSend, frame) {
     send(reply);
     console.log(`[bridge] ${method} ${path} → ${reply.status} (${Date.now() - t0}ms, ${(reply.body.length * 3 / 4 / 1024).toFixed(0)}KB)`);
   } catch (e) {
+    // 上游不可达是「端口可能变了」的最强信号（Desktop 换端口 / dsh web 重启到别的端口）：
+    // 触发一次带冷却的重新发现，后续请求自动跟上，不必重启 bridge。
+    void refreshUpstream("上游请求失败");
     console.log(`[bridge] ${method} ${path} 上游错误: ${e.message}`);
     send({ id, type: "http", status: 502, headers: { "content-type": "application/json" }, body: Buffer.from(JSON.stringify({ error: String(e.message || e) })).toString("base64"), bodyBase64: true });
   }
@@ -877,6 +955,7 @@ export async function handleLegacyFrame(dchOrSend, frame) {
     send({ id, status: reply.status, headers: reply.headers, body: text });
     console.log(`[bridge] legacy ${method} ${path} → ${reply.status} (${Date.now() - t0}ms)`);
   } catch (e) {
+    void refreshUpstream("上游请求失败(legacy)");
     console.log(`[bridge] legacy ${method} ${path} 上游错误: ${e.message}`);
     send({ id, status: 502, headers: {}, body: JSON.stringify({ error: String(e.message || e) }) });
   }
@@ -1469,6 +1548,9 @@ function startWeChat() {
     const cfg = loadLocalConfig();
     wechatRuntime = createWeChatRuntime({
       relayDir,
+      // 上游地址在 runTunnel() 开头已完成动态发现（见 refreshUpstream），所以这里拿到的是真实端口。
+      // ⚠️ 这是**取值**而非引用：运行中若上游端口又变了（自愈重发现），微信通道要等 bridge 重启才跟上；
+      //    隧道转发那一侧不受影响（它每次都读最新的 UPSTREAM）。
       upstream: UPSTREAM,
       cookieOf: harnessCookieOf,
       secret: process.env.DSH_BRIDGE_SECRET || (typeof cfg.bridge_secret === "string" ? cfg.bridge_secret : ""),
@@ -1514,6 +1596,10 @@ function redactText(e) {
 }
 
 async function runTunnel() {
+  // 先动态确定上游再连隧道：上游端口不是 3080 时（DSH Desktop 默认 43120）这一步是关键 ——
+  // 否则 bridge 会连上中继、手机也能打开页面，但每个请求都打到一个没人听的端口。
+  await refreshUpstream("启动");
+  console.log(`[bridge] 上游地址已确定: ${UPSTREAM}`);
   const token = await resolveToken();
   if (!token) {
     console.error("[bridge] 隧道模式需要账号认证:请设 DSH_BRIDGE_TOKEN,或 DSH_BRIDGE_PHONE+DSH_BRIDGE_PASSWORD");
@@ -1535,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 解压失败");