dsh-mobile-plugin 0.5.4 → 0.5.5

package/lib/mobile/file-read.js

@@ -23,7 +23,7 @@ const { pipeline } = require('node:stream/promises');
 
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { allowedRoots, inAllowedZone } = require('./allowed-zone.js');
-const { writeEncryptedFile, SESSION_FILE_MAX_BYTES } = require('./session-file.js');
+const { writeEncryptedFile, SESSION_FILE_MAX_BYTES, encryptedLengthOf } = require('./session-file.js');
 
 /**
  * 扩展名 → 内容类型。与 `session-file.js` 那张表逐条相同：两条路给同一个文件必须给出同一个
@@ -137,14 +137,19 @@ async function handleFileRead(ctx, req, res) {
     'cache-control': 'no-store',
   };
 
-  // 协议 v2：与 `/session/file` 逐字节同形（`x-dsh-content-type` 带明文类型、chunked，
-  // 真实类型单独给一份让 App 解密后决定怎么预览）。
+  // 协议 v2：与 `/session/file` 逐字节同形（`x-dsh-content-type` 带明文类型、**带
+  // `content-length` 而不发分块**，真实类型单独给一份让 App 解密后决定怎么预览）。
+  // 长度是算出来的（`encryptedLengthOf`），为什么要给见那条路由的注释：Android 原生下载器
+  // 按「实收字节数 == content-length」判完整，分块响应会被它判成 `Download interrupted.`。
   const opened = req && req.__dshE2ee;
   if (opened && opened.keys && opened.req) {
     res.writeHead(200, {
       ...header,
       'content-type': 'application/x-dsh-e2ee-chunks',
-      'transfer-encoding': 'chunked',
+      'content-length': String(encryptedLengthOf(info.size)),
+      // 原文件的字节数：中转有时会把 `content-length` 吞掉（改成分块），而客户端要靠它
+      // 判「这份到底收全没有」—— 分块信封自己的认证判不出「正好在块边界被截断」那种。
+      'x-dsh-file-size': String(info.size),
       'x-dsh-proto': '2',
       'x-dsh-content-type': header['content-type'],
     });

package/lib/mobile/session-file.js

@@ -178,15 +178,22 @@ async function handleSessionFile(ctx, req, res) {
   // 协议 v2：分块信封（§8.3(6)）。
   //
   // 套一次性 AEAD 意味着宿主得先把整份读进内存 —— 单文件上限 512MB，那条路不能走。
-  // 所以改成固定分块流式写：宿主仍然边读边发，内存占用还是一块的大小；App 那边今天本来
-  // 就是整份读进 arrayBuffer（上限 200MB），按长度字段切块、逐块解即可，不需要流式解密栈。
+  // 所以改成固定分块流式写：宿主仍然边读边发，内存占用还是一块的大小；App 那边按长度字段
+  // 切块、逐块解即可，不需要流式解密栈。
   const opened = req && req.__dshE2ee;
   if (opened && opened.keys && opened.req) {
     res.writeHead(200, {
       ...header,
       'content-type': 'application/x-dsh-e2ee-chunks',
-      // 这份字节不是原文，`content-length` 得等写完才知道，改用 chunked。
-      'transfer-encoding': 'chunked',
+      // **给长度，不发分块**（2026-10-30）：加密后这份响应有多长是算得出来的（见
+      // `encryptedLengthOf`），而不给长度的代价很具体 —— 客户端只能「流到哪儿算哪儿」地判
+      // 收没收完，Android 那个原生下载器更是按「实收字节数 == content-length」判，
+      // 分块响应在它那儿一律判成 `Download interrupted.`，手机上就是「点开文件说网络断了」。
+      // 长度顺带还是这份分块信封自己的完整性凭据：被截断的字节数一定对不上。
+      'content-length': String(encryptedLengthOf(info.size)),
+      // 原文件的字节数：中转有时会把 `content-length` 吞掉（改成分块），而客户端要靠它
+      // 判「这份到底收全没有」—— 分块信封自己的认证判不出「正好在块边界被截断」那种。
+      'x-dsh-file-size': String(info.size),
       'x-dsh-proto': '2',
       // 真实类型单独给：App 解密之后要拿它决定怎么预览。
       'x-dsh-content-type': header['content-type'],
@@ -264,4 +271,26 @@ function writeBlock(res, e2ee, key, block, aad) {
 /** 交付文件的分块大小。64KB：一块一次 AEAD，太小会让每块的 16+12 字节固定开销占比变高。 */
 const FILE_CHUNK_BYTES = 64 * 1024;
 
-module.exports = { handleSessionFile, SESSION_FILE_MAX_BYTES, FILE_CHUNK_BYTES, writeEncryptedFile };
+/** 一块除明文字节之外还带多少：`[4 字节长度][12 字节 nonce][16 字节 tag]`。 */
+const FILE_BLOCK_OVERHEAD = 4 + 12 + 16;
+
+/**
+ * 一份文件按块加密之后在网上会有多少字节。
+ *
+ * 块数 = `floor(size / FILE_CHUNK_BYTES)` 个满块 + **永远存在的那一块尾块**（空文件也要一块）。
+ * 这个数在写之前就得用（响应头的 `content-length`），所以它必须与 `writeEncryptedFile` 的
+ * 写法逐字对得上 —— 后果不对称：算少了对端读不满、算多了对端一直等，两种都是「文件打不开」。
+ * 守卫拿几个跨块边界的长度钉住它。
+ */
+function encryptedLengthOf(size) {
+  const plain = Math.max(0, Number(size) || 0);
+  return plain + (Math.floor(plain / FILE_CHUNK_BYTES) + 1) * FILE_BLOCK_OVERHEAD;
+}
+
+module.exports = {
+  handleSessionFile,
+  SESSION_FILE_MAX_BYTES,
+  FILE_CHUNK_BYTES,
+  writeEncryptedFile,
+  encryptedLengthOf,
+};

package/lib/relay/lan-proxy.js

@@ -328,7 +328,12 @@ function createLanProxy(opts) {
       (ures) => {
         const out = {};
         for (const [k, v] of Object.entries(ures.headers)) {
-          if (!HOP_BY_HOP.has(k)) out[k] = v;
+          // `content-length` 照原样转出去（**它不是逐跳头**，见 `HOP_BY_HOP` 上面那条说明）：
+          // 丢了它，每一发响应都退化成 chunked，客户端拿不到长度 —— 小到进度条、大到
+          // 「这份文件收完了没有」都无从判断。中转那条路早就这么处理了
+          //（`dsh-mobile-server` 的 `headers.rs` 里那个 `forwardable_response_header`），
+          // 两条路对同一个宿主必须给同一份头，否则同一个文件在 Wi-Fi 下和在外面表现不一样。
+          if (!HOP_BY_HOP.has(k) || k === 'content-length') out[k] = v;
         }
         res.writeHead(ures.statusCode, out);
         // SSE 的第一段（`: connected` 与响应头）要立刻到手机，别等内核攒够一个段。

package/lib/routes/mobile-api.js

@@ -30,7 +30,6 @@ const workspaces = require('../mobile/workspaces.js');
 const directoryListing = require('../mobile/directory-listing.js');
 const archiveClean = require('../mobile/archive-clean.js');
 const sessionLog = require('../mobile/session-log.js');
-const debugTrace = require('../mobile/debug-trace.js');
 const hostSettings = require('../mobile/host-settings.js');
 const channels = require('../mobile/channels.js');
 const deepSeekAccount = require('../mobile/deepseek-account.js');
@@ -333,10 +332,6 @@ function registerMobileRoutes(deps) {
   // 的 127.0.0.1 上手机直连不到 —— 所以由插件代取（mobile/session-log.js），App 侧
   // 再落盘。
   route('/api/mobile/v1/session-log', sessionLog.handleSessionLog)
-  // 手机端调试轨迹（开发包专用，见 mobile/debug-trace.js）：App 录滑动过程，边录边把 JSONL
-  // 打到这里，插件写进 <DSH_HOME>/mobile-debug/<capture>.jsonl，维护者在电脑上直接读。
-  // 只追加、轨迹名走白名单、单份 8MB 封顶 —— 不是「任意文件写入」。
-  route('/api/mobile/v1/debug/trace', debugTrace.handleDebugTrace)
   // 宿主设置与模型提供方（宿主 settings.describe / llm.providers 的移动端只读代理）。
   // 桌面端「设置」里有默认模型、提供方配置、凭据是否已设；手机端此前完全没有这一块，
   // 只能看到 App 自己的偏好项。两个宿主接口本身已脱敏（secrets 只给 path 与 set），

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "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",

package/lib/mobile/debug-trace.js

@@ -1,180 +0,0 @@
-'use strict';
-
-/**
- * 手机端调试轨迹的落盘口（`POST /api/mobile/v1/debug/trace`）。
- *
- * 为什么要有它：滑动手感出问题时，现场在手机上（偏移轨迹、每一行的实际高度、图片什么时候
- * 才到），而能看这些东西的人在这台电脑上。让人把几万行日志抄进聊天不现实，所以 App 边录边把
- * 一行行 JSONL 打到这里，插件落进 `<DSH_HOME>/mobile-debug/<capture>.jsonl`，维护者在这台
- * 电脑上直接读文件。
- *
- * 三条边界，别放宽：
- *  - **不是任意文件写入**：文件名只由 `capture` 生成，且只认 `[A-Za-z0-9._-]`。构造一个别的
- *    capture 只会在这一个目录里多一份空文件，碰不到用户的任何东西；
- *  - **只追加**：一次请求往 `<capture>.jsonl` 末尾续一段，从不覆盖、从不删别的文件；
- *  - **封顶**：一份轨迹 8MB 之后停写（回 `capped: true`，App 收到就停手），目录里最多留 10 份，
- *    第 11 份进来时删掉最旧那份。录音不会把盘写满。
- *
- * 与 `session/file`、`session/attachment` 那些读口方向相反：这条只写、写的位置固定，回给手机
- * 的只有文件名与字节数，不回路径。
- */
-
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const path = require('node:path');
-
-const { dshHome } = require('../shared/paths');
-const { sendJson, readJsonBody } = require('../shared/http-util');
-
-/** 一份轨迹的字节上限。真到这一步说明录得太久，该停了。 */
-const MAX_CAPTURE_BYTES = 8 * 1024 * 1024;
-/** 目录里最多留几份（按 mtime，新的来、旧的走）。 */
-const MAX_CAPTURES = 10;
-/** 一次请求最多带多少行；App 那边按 40KB 切批，正常远小于这个数。 */
-const MAX_LINES_PER_BATCH = 4000;
-/** 一次请求最多多少字节（`readJsonBody` 本身还有 344KB 的封顶，这里再收一道）。 */
-const MAX_BATCH_BYTES = 512 * 1024;
-/** 轨迹名（也就是文件名）：只认这几类字符，别的一律 400。 */
-const CAPTURE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
-
-/** 轨迹目录。按调用时解析，测试可注入 `DSH_HOME`。 */
-function traceDir() {
-  return path.join(dshHome(), 'mobile-debug');
-}
-
-/** 某一份轨迹的落盘路径（`capture` 已经过白名单校验）。 */
-function capturePath(capture) {
-  return path.join(traceDir(), `${capture}.jsonl`);
-}
-
-/**
- * 目录里留最近 `MAX_CAPTURES` 份。
- *
- * 按 mtime 而不是文件名：轨迹名由 App 带时间戳生成，但同一秒的两份、或者用户手改过的名字都
- * 不该让清理算错。读不动 stat 的（正在被删）直接跳过，清理失败不该让这次上传失败。
- */
-async function pruneCaptures() {
-  let names;
-  try {
-    names = await fsp.readdir(traceDir());
-  } catch {
-    return;
-  }
-  const files = [];
-  for (const name of names) {
-    if (!name.endsWith('.jsonl')) continue;
-    const full = path.join(traceDir(), name);
-    try {
-      const info = await fsp.stat(full);
-      if (info.isFile()) files.push({ name, full, mtime: info.mtimeMs });
-    } catch { /* 刚被删掉 / 读不动：跳过 */ }
-  }
-  if (files.length <= MAX_CAPTURES) return;
-  files.sort((a, b) => a.mtime - b.mtime);
-  for (const file of files.slice(0, files.length - MAX_CAPTURES)) {
-    try {
-      await fsp.unlink(file.full);
-    } catch { /* 删不掉就留着，下次再说 */ }
-  }
-}
-
-/**
- * 续写一段轨迹。
- *
- * `lines` 是已经序列化好的 JSON 行（App 侧拼的），这里只做「拼成一段文本 + 追加」。一行都
- * 不合法的批次按空处理：回 ok、写 0 字节，别让手机那头因为一次形状不对就整段录不上。
- */
-async function handleDebugTrace(_ctx, req, res) {
-  const body = await readJsonBody(req);
-  const capture = body && typeof body.capture === 'string' ? body.capture : '';
-  if (!CAPTURE_RE.test(capture)) {
-    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { capture }，且只认字母数字与 ._-' } });
-  }
-  const raw = body && Array.isArray(body.lines) ? body.lines : null;
-  if (!raw) {
-    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { lines: string[] }' } });
-  }
-  if (raw.length > MAX_LINES_PER_BATCH) {
-    return sendJson(res, 413, { ok: false, error: { code: 'too-many-lines', message: `一次最多 ${MAX_LINES_PER_BATCH} 行` } });
-  }
-  const lines = raw.filter((line) => typeof line === 'string' && line.length > 0);
-  if (lines.length === 0) {
-    return sendJson(res, 200, { ok: true, file: `${capture}.jsonl`, bytes: 0, lines: 0, capped: false });
-  }
-  const text = `${lines.join('\n')}\n`;
-  const bytes = Buffer.byteLength(text, 'utf8');
-  if (bytes > MAX_BATCH_BYTES) {
-    return sendJson(res, 413, { ok: false, error: { code: 'too-large', message: `一次最多 ${MAX_BATCH_BYTES} 字节` } });
-  }
-
-  const file = capturePath(capture);
-  try {
-    await fsp.mkdir(traceDir(), { recursive: true });
-  } catch (error) {
-    return sendJson(res, 500, { ok: false, error: { code: 'io', message: `建目录失败：${error && error.message ? error.message : ''}` } });
-  }
-
-  let existing = 0;
-  let created = false;
-  try {
-    existing = (await fsp.stat(file)).size;
-  } catch {
-    created = true;
-  }
-
-  if (existing >= MAX_CAPTURE_BYTES) {
-    // 已经写满：回 capped 让 App 停手。文件留着，人要看的正是前面那一段。
-    return sendJson(res, 200, { ok: true, file: `${capture}.jsonl`, bytes: existing, lines: 0, capped: true });
-  }
-  // 快写满时**按整行留**：切在字节中间会让最后一行变成半截 JSON，读的人只会看到一行坏数据。
-  const room = MAX_CAPTURE_BYTES - existing;
-  let payload = text;
-  if (bytes > room) {
-    const kept = [];
-    let used = 0;
-    for (const line of lines) {
-      const size = Buffer.byteLength(line, 'utf8') + 1;
-      if (used + size > room) break;
-      kept.push(line);
-      used += size;
-    }
-    payload = kept.length > 0 ? `${kept.join('\n')}\n` : '';
-  }
-  try {
-    await fsp.appendFile(file, payload);
-  } catch (error) {
-    return sendJson(res, 500, { ok: false, error: { code: 'io', message: `写盘失败：${error && error.message ? error.message : ''}` } });
-  }
-  // 清理放在写完之后：这一份刚建出来的文件按 mtime 是最新的，留下来的正是它。
-  if (created) await pruneCaptures();
-  let total = existing;
-  try {
-    total = (await fsp.stat(file)).size;
-  } catch { /* 写成功但 stat 失败：回一个估计值，不影响 App */ }
-  sendJson(res, 200, {
-    ok: true,
-    file: `${capture}.jsonl`,
-    bytes: total,
-    lines: payload === text ? lines.length : (payload ? payload.split('\n').length - 1 : 0),
-    // 「这一段被切了」或「已经顶到上限」都算满：App 收到就停手，别继续往一条死路上发。
-    capped: payload !== text || total >= MAX_CAPTURE_BYTES,
-  });
-}
-
-/** 同步读一份轨迹（维护者在电脑上直接看文件；这里只给测试与将来的面板用）。 */
-function readCapture(capture) {
-  if (!CAPTURE_RE.test(capture)) return null;
-  try {
-    return fs.readFileSync(capturePath(capture), 'utf8');
-  } catch {
-    return null;
-  }
-}
-
-module.exports = {
-  handleDebugTrace,
-  readCapture,
-  traceDir,
-  MAX_CAPTURE_BYTES,
-  MAX_CAPTURES,
-};