dsh-mobile-plugin 0.5.5 → 0.5.8

package/lib/http/routing.js

@@ -58,7 +58,21 @@ const remoteRelayRequest = (req) => Boolean(
 // Rejecting cross-site fetches and pinning each route to one method closes
 // that: a control-plane call now has to be a same-origin top-level/`same-origin`
 // request, and it has to use the documented verb.
-const crossSiteRequest = (req) => {
+//
+// 只读页面（面板页）是唯一的例外，而且只放开「人点开的一页」这一种形态：社区桌面壳
+// 会把自己接住的链接原地打开，从自定义协议页跳到 `http://127.0.0.1:<端口>/api/relay/panel`
+// 时 Chromium 一定给 `sec-fetch-site: cross-site`（自定义协议与 http 不同源），
+// 按攻击挡掉，用户看到的就是整屏一句 403 JSON。判据换成 Fetch 元数据里的
+// `mode: navigate` + `dest: document`：别的网页最多能把用户带到这一页（只读 HTML），
+// 页面里偷偷发的 fetch/XHR 仍然 403。
+const documentNavigation = (req) => {
+  const headers = req?.headers && typeof req.headers === 'object' ? req.headers : {}
+  return String(headers['sec-fetch-mode'] || '').toLowerCase() === 'navigate'
+    && String(headers['sec-fetch-dest'] || '').toLowerCase() === 'document'
+}
+
+const crossSiteRequest = (req, allowDocumentNavigation = false) => {
+  if (allowDocumentNavigation === true && documentNavigation(req)) return false
   if (String(req.headers['sec-fetch-site'] || '').toLowerCase() === 'cross-site') return true
   const origin = req.headers.origin
   if (typeof origin !== 'string' || !origin) return false
@@ -103,9 +117,12 @@ const trustedLocalUi = (req) => {
 
 // `method` 可以是单个方法名，也可以是方法名数组（同一个路径上挂 GET+POST，
 // 例如 /api/relay/desktop-view 既读快照又收回传）。单方法时的 405 文案保持不变。
-const localOnly = (method, handler) => async (req, res) => {
+//
+// `options.allowDocumentNavigation` 只给那几条「本来就是给人点开看」的只读页面用，
+// 其余路由不传，跨站照旧一律拒。
+const localOnly = (method, handler, options = {}) => async (req, res) => {
   if (remoteRelayRequest(req)) return sendJson(res, 403, { ok: false, error: { code: 'local_only', message: '控制面仅允许本机访问' } })
-  if (crossSiteRequest(req)) return sendJson(res, 403, { ok: false, error: { code: 'cross_site', message: '控制面拒绝跨站请求' } })
+  if (crossSiteRequest(req, options.allowDocumentNavigation === true)) return sendJson(res, 403, { ok: false, error: { code: 'cross_site', message: '控制面拒绝跨站请求' } })
   const allowed = Array.isArray(method) ? method : [method]
   const actual = String(req.method || 'GET').toUpperCase()
   if (!allowed.includes(actual)) {

package/lib/mobile/history-derive.js

@@ -37,6 +37,7 @@ function collectTurnImages(entries, lookbackEntries) {
   return byTurn;
 }
 const {
+  reasoningText,
   reasoningStepSummary,
   toolStepSummary,
   toolStepState,
@@ -516,7 +517,8 @@ function deriveMessages(events, sessionId, lookbackEvents) {
     content.forEach((raw, index) => {
       if (!raw || typeof raw !== 'object') return;
       if (raw.type === 'reasoning') {
-        const text = typeof raw.text === 'string' ? raw.text : '';
+        // 签名块先剥掉再判空：只剩签名的那一段等于没有推理，不算一步（桌面那边是整行不显示）。
+        const text = reasoningText(raw.text);
         // 空推理块（只有零宽字符那种）不算一步：App 点开一条什么都没有的行没有意义。
         if (text.trim() === '') return;
         list.push({

package/lib/mobile/live-steps.js

@@ -23,7 +23,7 @@ const MAX_SESSIONS = 4;
 const TEXT_MAX = 200_000;
 
 const { liveStepTurnOf } = require('./session-cache.js');
-const { reasoningStepSummary, toolStepSummary } = require('./step-index.js');
+const { reasoningText, reasoningStepSummary, toolStepSummary } = require('./step-index.js');
 
 function bucketOf(ctx) {
   return liveStepTurnOf(ctx);
@@ -328,8 +328,9 @@ function liveStepOf(ctx, sessionId, query) {
   if (query && query.kind === 'think') {
     const index = Number.isSafeInteger(query.index) ? query.index : null;
     if (index === null) return null;
-    const text = turn.thoughts.get(index);
-    if (typeof text !== 'string' || text === '') return null;
+    // 签名块在展示前剥掉（与桌面同口径）；剥完没有正文，这一段思考就当还没有内容。
+    const text = reasoningText(turn.thoughts.get(index));
+    if (text === '') return null;
     return { kind: 'think', text, live: true, state: turn.ended ? 'ok' : 'running' };
   }
   const callId = query && typeof query.callId === 'string' ? query.callId : '';

package/lib/mobile/session-file.js

@@ -21,6 +21,7 @@ const path = require('node:path');
 const { pipeline } = require('node:stream/promises');
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { signedPath } = require('../shared/e2ee-request');
+const { FILE_CHUNK_BYTES, writeChunk } = require('../shared/e2ee-chunks.js');
 const { unwrap } = require('./envelope.js');
 const { callSessions } = require('./rpc.js');
 const { cwdOf } = require('./session-cwd.js');
@@ -244,13 +245,13 @@ async function writeEncryptedFile(req, res, target, opened) {
         const block = pending.subarray(0, FILE_CHUNK_BYTES);
         pending = pending.subarray(FILE_CHUNK_BYTES);
         seq += 1;
-        writeBlock(res, e2ee, opened.keys.down, block, e2ee.fileAad(path0, requestNonce, seq));
+        writeChunk(res, opened.keys.down, block, e2ee.fileAad(path0, requestNonce, seq));
       }
     }
     // 尾块（可能不足一块）；空文件也给一块，否则 App 拿不到「这是个空文件」的确认。
     if (!closed) {
       seq += 1;
-      writeBlock(res, e2ee, opened.keys.down, pending, e2ee.fileAad(path0, requestNonce, seq));
+      writeChunk(res, opened.keys.down, pending, e2ee.fileAad(path0, requestNonce, seq));
     }
     if (!closed) res.end();
   } catch {
@@ -258,29 +259,15 @@ async function writeEncryptedFile(req, res, target, opened) {
   }
 }
 
-/** 写一块：`[4 字节长度][nonce][密文+tag]`，长度写的是后两段之外的密文长度。 */
-function writeBlock(res, e2ee, key, block, aad) {
-  const sealed = e2ee.seal(key, block, aad);
-  const buf = Buffer.from(sealed);
-  const cipherLen = buf.length - e2ee.NONCE_BYTES;
-  const head = Buffer.alloc(4);
-  head.writeUInt32BE(cipherLen, 0);
-  res.write(Buffer.concat([head, buf]));
-}
-
-/** 交付文件的分块大小。64KB：一块一次 AEAD，太小会让每块的 16+12 字节固定开销占比变高。 */
-const FILE_CHUNK_BYTES = 64 * 1024;
-
 /** 一块除明文字节之外还带多少：`[4 字节长度][12 字节 nonce][16 字节 tag]`。 */
 const FILE_BLOCK_OVERHEAD = 4 + 12 + 16;
 
 /**
  * 一份文件按块加密之后在网上会有多少字节。
  *
- * 块数 = `floor(size / FILE_CHUNK_BYTES)` 个满块 + **永远存在的那一块尾块**（空文件也要一块）。
- * 这个数在写之前就得用（响应头的 `content-length`），所以它必须与 `writeEncryptedFile` 的
- * 写法逐字对得上 —— 后果不对称：算少了对端读不满、算多了对端一直等，两种都是「文件打不开」。
- * 守卫拿几个跨块边界的长度钉住它。
+ * 块数 = `floor(size / FILE_CHUNK_BYTES)` 个满块 + **永远存在的那一块尾块**（空文件也要一块）：
+ * 这个数在写之前就得用（响应头的 `content-length`），所以它必须与写块那份逐字对得上 —— 后果
+ * 不对称：算少了对端读不满、算多了对端一直等，两种都是「文件打不开」。
  */
 function encryptedLengthOf(size) {
   const plain = Math.max(0, Number(size) || 0);

package/lib/mobile/session-log.js

@@ -14,11 +14,21 @@
  *
  * 与桌面客户端保持同一口径：`includeDescendants` 缺省即 true —— 导出的是「当前会话
  * + 子会话 + 附件」的整棵会话树，而不是单个会话。
+ *
+ * **封过包的请求回分块信封，明文请求照旧回 zip**（2026-10-30）。判据是 `req.__dshE2ee`：
+ * 它由移动端守卫在解封请求时挂上，只有带 `X-Dsh-Proto: 2` 的请求才有 —— 也就是说这一档
+ * 只对新 App 生效，老 App 一个字都不用改。为什么要加这一档：守卫对「v2 凭据 + 明文请求」
+ * 一律回 `e2ee-required`，而这条导出一直是绕开传输内核直发的明文请求，于是它在按 v2 配对的
+ * 手机上从来就没走到下载这一步。封了包之后，**响应也得跟着封** —— 会话树里是整段对话与附件，
+ * 明文 zip 等于把这条链路唯一的加密出口又打开一次。分块格式与 `session-file.js` 共用一套
+ * （`[4 字节长度][nonce][密文+tag]`，AAD 绑路径 / 请求 nonce / 块序号），App 那边用同一个
+ * 原生解密口读，两处口径因此只有一份。
  */
 
 const { Readable } = require('node:stream');
 const { pipeline } = require('node:stream/promises');
 const { sendJson } = require('../shared/http-util.js');
+const { chunksHeaders, pipeEncrypted } = require('../shared/e2ee-chunks.js');
 
 /**
  * 与桌面 sessionLogZipFilename 同口径的下载文件名。
@@ -82,8 +92,19 @@ async function handleSessionLog(ctx, req, res) {
   };
   const length = upstream.headers.get('content-length');
   if (length) headers['content-length'] = length;
-  res.writeHead(200, headers);
 
+  const opened = req && req.__dshE2ee;
+  if (opened && opened.keys && opened.req && upstream.body) {
+    // 真类型单独给一条头：解密之后按它认「这是一份 zip」。
+    res.writeHead(200, chunksHeaders({
+      'content-disposition': headers['content-disposition'],
+      'x-dsh-content-type': headers['content-type'],
+    }));
+    await pipeEncrypted(req, res, Readable.fromWeb(upstream.body));
+    return;
+  }
+
+  res.writeHead(200, headers);
   if (!upstream.body) return res.end();
   try {
     // 边收边写，不在插件进程里整包缓冲：会话树的附件可能很大，缓冲等于把宿主的

package/lib/mobile/session-send.js

@@ -13,7 +13,9 @@
  * 未知命令或网关未组合时回退普通消息，与桌面 miss 落入默认 sink 的行为一致。
  */
 
+const { Readable } = require('node:stream');
 const { sendJson, readJsonBody } = require('../shared/http-util');
+const { chunksHeaders, pipeEncrypted } = require('../shared/e2ee-chunks.js');
 const { inlineUploadedImageBlocks } = require('./uploads.js');
 const { unwrap } = require('./envelope.js');
 const { callSessions, mobilePromptRpcId } = require('./rpc.js');
@@ -290,6 +292,19 @@ async function handleSessionAttachment(ctx, req, res) {
   // `dims: true` = 只要原始宽高，不要字节。老会话里宿主没存附件的宽高，正文下发时就带不上，
   // 手机侧只能按 240 方盒先占位、等字节到了再变高（那一行一变高，屏幕上就是「跳」）。这一档
   // 让手机在挂载那一帧就能按真比例占好：回给它的只有两格数字，整张图的 base64 不出这台电脑。
+  // `raw: true` = 要原始字节，不要 base64（2026-10-30）。宿主给的仍是 base64，这里解成
+  // Buffer 后按分块信封流出去：手机那边落盘的是密文，靠原生解盘口边解边写，整张图的
+  // base64 不进 JS 堆 —— 一张两兆的截图在手机上原本要摊着两兆七的字符串加一份解析副本。
+  // **不封包不许走这一档**：那就成了明文传输，正好把这条路本来的意义抹掉，如实回 400。
+  if (body.raw === true) {
+    const opened = req && req.__dshE2ee;
+    if (!opened || !opened.keys || !opened.req) {
+      return sendJson(res, 400, { ok: false, error: { code: 'e2ee-required', message: '这条会话是加密的，请用信封重发' } });
+    }
+    res.writeHead(200, chunksHeaders({ 'x-dsh-content-type': mediaType }));
+    await pipeEncrypted(req, res, Readable.from([Buffer.from(data, 'base64')]));
+    return;
+  }
   if (body.dims === true) {
     const size = imageSizeOf(Buffer.from(data, 'base64'));
     if (!size || !(size.width > 0) || !(size.height > 0)) {

package/lib/mobile/session-step.js

@@ -20,7 +20,7 @@ const { sendJson } = require('../shared/http-util');
 const { unwrap } = require('./envelope.js');
 const { callSessions } = require('./rpc.js');
 const { liveStepOf } = require('./live-steps.js');
-const { textOfParts } = require('./step-index.js');
+const { reasoningText, textOfParts } = require('./step-index.js');
 
 /** 详情单段文本的上限（参数 / 输出 / 思考全文各自适用）。 */
 const DETAIL_MAX_CHARS = 200_000;
@@ -106,7 +106,9 @@ async function historyStep(ctx, { sessionId, kind, callId, seq, index, resultSeq
     const message = target && target.data && target.data.message;
     const content = message && Array.isArray(message.content) ? message.content : [];
     const block = content[index];
-    const text = block && block.type === 'reasoning' && typeof block.text === 'string' ? block.text : '';
+    // 签名块（`<signature>…</signature>`）先剥掉再判断有没有正文：宿主数据里那段还在，
+    // 桌面的剥法是渲染层的，这里不跟着剥就会把一整段签名原文摊给用户看。
+    const text = block && block.type === 'reasoning' ? reasoningText(block.text) : '';
     if (!text) return null;
     const capped = capText(text);
     return { kind: 'think', state: 'ok', text: capped.text, ...(capped.truncated ? { truncated: true } : {}) };

package/lib/mobile/step-index.js

@@ -24,9 +24,34 @@ function clampSummary(text, max = STEP_SUMMARY_MAX) {
   return `${value.slice(0, max - 1)}…`;
 }
 
+/**
+ * 推理正文里模型带的签名块（`<signature>…</signature>`）在展示前剥掉。
+ *
+ * 桌面从 0.2.1-rc.5 起在渲染层做同一件事，但宿主存的会话数据里那段还在 —— 手机不从数据里
+ * 剥一遍，清单摘要那第一行就是一串 base64、展开详情整段噪声。流式期间只写到半截签名
+ * （`<sig`）时返回空串，不让它先闪一下再消失；剥完什么都不剩的块等于没有推理，调用方按空处理。
+ */
+function reasoningText(text) {
+  const value = typeof text === 'string' ? text : '';
+  if (value[0] !== '<') return value;
+  const opening = '<signature>';
+  if (opening.startsWith(value)) return '';
+  if (!value.startsWith(opening)) return value;
+  const closing = '</signature>';
+  const end = value.indexOf(closing, opening.length);
+  if (end === -1) return '';
+  let start = end + closing.length;
+  while (start < value.length) {
+    if (value[start] === '\n') start += 1;
+    else if (value[start] === '\r' && value[start + 1] === '\n') start += 2;
+    else break;
+  }
+  return value.slice(start);
+}
+
 /** 推理正文的一行摘要。 */
 function reasoningStepSummary(text) {
-  return clampSummary(firstLine(text));
+  return clampSummary(firstLine(reasoningText(text)));
 }
 
 /** 参数 JSON → 对象；解析不了就返回空对象（畸形参数不该让清单少一条）。 */
@@ -100,6 +125,7 @@ module.exports = {
   STEP_SUMMARY_MAX,
   firstLine,
   clampSummary,
+  reasoningText,
   reasoningStepSummary,
   parseArgs,
   toolStepSummary,

package/lib/relay/lan-network.cjs

@@ -352,15 +352,21 @@ function manualCandidate(value) {
 }
 
 /**
- * 候选 = 用户填的那条（有的话）在前 + 其余照旧。按 url 去重，**不删**任何一条 NIC 候选：
- * 穿透域名不通时手机还得能顺着网卡地址摸回这台机器。值不合法时原样返回 NIC 候选，
- * 不让一条坏配置把整份候选清空（那正是彻底失联的形状）。
+ * 候选 = 网卡那几条照旧 + 用户填的那条**排在最后**当兜底。按 url 去重，**不删**任何一条
+ * NIC 候选：穿透域名不通时手机还得能顺着网卡地址摸回这台机器。值不合法时原样返回 NIC
+ * 候选，不让一条坏配置把整份候选清空（那正是彻底失联的形状）。
+ *
+ * **为什么排在最后而不是最前**（2026-10-30 改）：这两类地址的快慢本来不可比 —— 同一个
+ * WiFi 里内网是几毫秒，穿透要绕公网，起步就是几十到几百毫秒。排在最前等于让手机按「先
+ * 回话的赢」这条规矩永远选中穿透域名，家里明明有内网地址却一次都不去试；现场表现就是
+ * 「以前在局域网下直连地址会自动变成内网 IP，现在不会了」。顺序是这条上唯一的表达方式，
+ * 所以内网那条必须排前面，穿透域名只当离开这个网络之后的兜底。
  */
 function withManualCandidate(list, value) {
   const manual = manualCandidate(value)
   const rest = Array.isArray(list) ? list : []
   if (!manual) return rest
-  return [manual, ...rest.filter(item => item && item.url !== manual.url)]
+  return [...rest.filter(item => item && item.url !== manual.url), manual]
 }
 
 /**
@@ -393,8 +399,8 @@ function orderCandidates(list, preferred) {
 /**
  * 报给手机的直连候选 —— 二维码、配对响应与 `/connection-info` 三处**只许走这一份**。
  *
- * 两步顺序不能反：先让「手机优先用这条」调网卡候选的顺序，再把用户手填的地址盖到最前
- * （那条是用户在手机上手打的，`preferredLanAddress` 只是面板上对网卡地址的选择，压不过它）。
+ * 两步顺序不能反：先让「手机优先用这条」调网卡候选的顺序，再把用户手填的地址**缀到末尾**
+ * 当兜底（`preferredLanAddress` 调的是同一批网卡地址之间的次序，手填的那条不属于这一批）。
  * 三处各写一遍的结果就是「画面上说这条、手机去试另一条」。
  */
 function phoneCandidates(list, options = {}) {

package/lib/routes/control-plane.js

@@ -87,7 +87,7 @@ function createWebAccessWindow({ now = Date.now, monotonicNow = () => performanc
 }
 
 function createWebAccessLocalOnly({ localOnly, trustedLocalUi, webAccessWindow, sendJson }) {
-  return (method, handler) => localOnly(method, async (req, res) => {
+  return (method, handler, options) => localOnly(method, async (req, res) => {
     const route = String(req?.url || '').split('?', 1)[0];
     if (WEB_ACCESS_ROUTES.has(route) && !trustedLocalUi(req) && !webAccessWindow.isOpen()) {
       return sendJson(res, 423, {
@@ -96,7 +96,7 @@ function createWebAccessLocalOnly({ localOnly, trustedLocalUi, webAccessWindow,
       });
     }
     return handler(req, res);
-  });
+  }, options);
 }
 
 /**
@@ -445,9 +445,12 @@ function registerControlPlaneRoutes(deps) {
     process.stderr.write(`[dsh-mobile-plugin] panel unavailable (${diagnosis.reason}) ${PANEL_FILE}: ${diagnosis.message}\n`);
     return sendJson(res, 500, { ok: false, error: { code: 'panel_missing', reason: diagnosis.reason, message: diagnosis.message, path: PANEL_FILE } });
   };
-  registerRoute({ kind: 'exact', path: '/api/relay/panel', handler: localOnly('GET', async (_req, res) => servePanel(res)) })
-  registerRoute({ kind: 'exact', path: '/api/relay/panel/setup', handler: localOnly('GET', async (_req, res) => servePanel(res)) })
-  registerRoute({ kind: 'exact', path: '/api/relay/panel/settings', handler: localOnly('GET', async (_req, res) => servePanel(res)) })
+  // 三条面板页是「人点开的一页」：社区桌面壳会把自己接住的链接原地打开，从自定义协议
+  // 页跳过来必带 `sec-fetch-site: cross-site`，不放开这一种形态，用户看到的就是整屏
+  // 一句 403 JSON（见 `lib/http/routing.js` 的 `documentNavigation`）。
+  registerRoute({ kind: 'exact', path: '/api/relay/panel', handler: localOnly('GET', async (_req, res) => servePanel(res), { allowDocumentNavigation: true }) })
+  registerRoute({ kind: 'exact', path: '/api/relay/panel/setup', handler: localOnly('GET', async (_req, res) => servePanel(res), { allowDocumentNavigation: true }) })
+  registerRoute({ kind: 'exact', path: '/api/relay/panel/settings', handler: localOnly('GET', async (_req, res) => servePanel(res), { allowDocumentNavigation: true }) })
   // 桌面端工作区视图（侧栏展开态）的回传/读取。桌面端只把展开态记在浏览器
   // localStorage 里，宿主进程读不到，只能由页面内的客户端半边（lib/client.js）
   // 每 2s 变了就 POST 到这里；App 再经 /api/mobile/v1/desktop-view 取走。

package/lib/routes/mobile-api.js

@@ -189,8 +189,8 @@ function registerMobileRoutes(deps) {
     const port = typeof lanPortInUse === 'function' ? lanPortInUse() : state.lanPort
     // 用户在面板上选过的「手机优先用这条」（设置项 `preferredLanAddress`）在这里同样兑现：
     // 手机是按顺序挨个试的，所以只挪顺序、不删候选。选的那条不在了就退回宿主排序。
-    // 手填的直连地址再盖到最前面：那是用户明确指定的那条，`preferredLanAddress` 只调网卡候选
-    // 的顺序，不该把它压到后面。
+    // 手填的直连地址（穿透域名）缀在**最后**当兜底：它绕公网、比内网慢一个数量级，排在前面
+    // 就等于让手机永远选中它、家里那条内网地址一次都不试（见 `withManualCandidate` 的注释）。
     const candidates = state.lanEnabled
       ? withManualCandidate(orderCandidates(safeLanCandidates(port), state.preferredLanAddress), state.manualLanUrl)
       : []

package/lib/shared/e2ee-chunks.js

@@ -0,0 +1,83 @@
+'use strict';
+
+/**
+ * 分块信封的写出口（协议 v2，§8.3(6)）—— 会话文件、会话日志 ZIP、会话图片附件共用这一份。
+ *
+ * 块形状：`[4 字节大端长度][12 字节 nonce][密文 + 16 字节 tag]`，长度字段写的是「密文 + tag」
+ * 这一段（不含 nonce 与长度字段本身）。AAD 绑这条请求的路径、请求 nonce 与块序号 —— 块序号
+ * 让中转既不能把别的文件的字节搬进来，也不能重排或截断而不被察觉。
+ *
+ * 为什么要一个共用模块：这是跨端**逐字对齐**的那一层，手机那边是同一个原生解盘口在读
+ * （`DSHCipher.openFile`）。三条下载各写一遍，等于给自己留三个漂移点，而漂了不会有报错，
+ * 只会换来「文件打不开」。
+ */
+
+const e2ee = require('./e2ee');
+const { signedPath } = require('./e2ee-request');
+
+/** 一块的明文字节数。与 App 侧 `FILE_CHUNK_BYTES` 同值。 */
+const FILE_CHUNK_BYTES = 64 * 1024;
+
+/** 分块信封的 content-type：App 靠它判「这份字节要解，别当普通文件存」。 */
+const E2EE_CHUNKS_TYPE = 'application/x-dsh-e2ee-chunks';
+
+/**
+ * 分块信封的响应头。
+ *
+ * **不给 content-length**：这一份是边收边加密的流，总长要等上游收完才知道；而 App 那条原生
+ * 下载器只认 EOF、不靠长度判完成（要看长度的是 blob-util 那条老路，已经不用了）。
+ */
+function chunksHeaders(extra = {}) {
+  return {
+    'content-type': E2EE_CHUNKS_TYPE,
+    'cache-control': 'no-store',
+    'x-dsh-proto': '2',
+    ...extra,
+  };
+}
+
+/** 写一块：`[4 字节长度][nonce][密文+tag]`。 */
+function writeChunk(res, key, block, aad) {
+  const sealed = Buffer.from(e2ee.seal(key, block, aad));
+  const head = Buffer.alloc(4);
+  head.writeUInt32BE(sealed.length - e2ee.NONCE_BYTES, 0);
+  res.write(Buffer.concat([head, sealed]));
+}
+
+/**
+ * 把一个可读流按块加密写进 `res`（调用方已经把状态码与头写完了）。
+ *
+ * 块边界要自己攒（`pending` 不到一块就等下一段）。**空内容也要写一块**，否则 App 分不清
+ * 「这份是空的」与「一个字节都没收到」。出错时只能断开连接 —— 头已经发出去了，改不了状态码。
+ */
+async function pipeEncrypted(req, res, source) {
+  const opened = req && req.__dshE2ee;
+  if (!opened || !opened.keys || !opened.req) throw new Error('这条请求没有信封');
+  const path = signedPath(req);
+  const requestNonce = opened.req.nonce;
+  let seq = 0;
+  let pending = Buffer.alloc(0);
+  let closed = false;
+  res.on('close', () => { closed = true; });
+  try {
+    for await (const chunk of source) {
+      if (closed) break;
+      pending = pending.length ? Buffer.concat([pending, chunk]) : Buffer.from(chunk);
+      while (pending.length >= FILE_CHUNK_BYTES) {
+        const block = pending.subarray(0, FILE_CHUNK_BYTES);
+        pending = pending.subarray(FILE_CHUNK_BYTES);
+        seq += 1;
+        writeChunk(res, opened.keys.down, block, e2ee.fileAad(path, requestNonce, seq));
+      }
+    }
+    if (!closed) {
+      seq += 1;
+      writeChunk(res, opened.keys.down, pending, e2ee.fileAad(path, requestNonce, seq));
+      res.end();
+    }
+  } catch {
+    try { res.destroy(); } catch { /* 连接已关闭 */ }
+  }
+}
+
+module.exports = { FILE_CHUNK_BYTES, E2EE_CHUNKS_TYPE, chunksHeaders, writeChunk, pipeEncrypted };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.5.5",
+  "version": "0.5.8",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (dsh 0.2.x, peers resolved by the host)",
   "license": "MIT",
   "icon": "./icon.png",