dsh-mobile-plugin 0.1.85 → 0.1.86

package/lib/mobile/events.js

@@ -67,22 +67,39 @@ function stableEventId(payload, frame) {
 }
 
 /**
- * 写一条 SSE 记录。返回值与 `mobile/stream.js` 的同名函数一致：`ok:false` 表示该收尾，
- * `shed:true` 表示这条帧被主动丢掉（写缓冲超过软水位）。
+ * 这条连接上真正「还没发出去」的字节数。
+ *
+ * 只看 `res.writableLength` 是错的：它只算响应对象自己那一层，真正的积压在底下的套接字
+ * 写队列里（堆快照里那些 `{chunk, encoding, callback}`）。2026-10-18 复测证实：只看
+ * 前者时闸门从不触发，内存照涨。所以顺着 socket 一起看，取较大值。
+ */
+function bufferedBytesOf(res) {
+  const own = Number(res.writableLength) || 0;
+  const socket = res.socket || res.connection;
+  const queued = socket ? Number(socket.writableLength) || 0 : 0;
+  return Math.max(own, queued);
+}
+
+/**
+ * 写一条 SSE 记录。返回值与 `mobile/stream.js` 的同名函数一致：`ok:false` 该收尾，
+ * `shed:true` 这条被丢掉，`needDrain:true` 写进去了但底下已经写不动。
  *
  * 设备级流的帧全是「有东西变了」的信号，本来就幂等：丢掉一帧的代价是那一次刷新要等
  * 下一次变更或 60s 兜底轮询；而堆在写缓冲里的代价是宿主 OOM（2026-10-17 现场：466MB
  * 的 SSE 帧挂在 socket 写队列上，宿主撞 4GB 上限被杀）。所以软水位一律 shed。
  */
 function writeSse(res, payload, frame) {
-  const buffered = Number(res.writableLength) || 0;
+  const buffered = bufferedBytesOf(res);
   if (buffered > SSE_CLOSE_BUFFERED_BYTES) return { ok: false };
   if (buffered > SSE_SHED_BUFFERED_BYTES) return { ok: true, shed: true };
   const id = stableEventId(payload, frame);
   const fields = [`retry: ${SSE_RETRY_MS}`];
   if (id) fields.push(`id: ${id}`);
   fields.push(`data: ${JSON.stringify(payload)}`, '', '');
-  try { res.write(`${fields.join('\n')}\n`); return { ok: true }; } catch { return { ok: false }; }
+  try {
+    const accepted = res.write(`${fields.join('\n')}\n`);
+    return { ok: true, needDrain: accepted === false };
+  } catch { return { ok: false }; }
 }
 
 async function* mergeHostAndMux(ctx, signal) {
@@ -179,8 +196,12 @@ async function handleDeviceStream(ctx, req, res) {
       version: 1,
       payload: devicePayload,
     }, null);
-    if (result.ok && !result.shed) framesSent += 1;
-    return result.ok;
+    if (!result.ok) return false;
+    if (result.shed) return true;
+    framesSent += 1;
+    // 所有调用点都是同步回调（信号总线、心跳），没法在这里 await；写不动就如实回报，
+    // 由调用方 abort —— 这条流本来就是「断了重连、靠补发收敛」的语义。
+    return !result.needDrain;
   };
   /**
    * 自产的「清单变了」帧：镜像推送调度器每 500ms 比一次清单内容哈希，变了就在这里推给手机。
@@ -290,7 +311,7 @@ async function handleDeviceStream(ctx, req, res) {
       // Keep the existing device/event JSON envelope unchanged; SSE metadata is additive.
       const sent = writeSse(res, envelope, frame);
       if (sent.shed) continue;
-      if (!sent.ok) { clientGone = true; break; }
+      if (!sent.ok || sent.needDrain) { clientGone = true; break; }
       framesSent += 1;
     }
     if (!clientGone) loopEnded = true;

package/lib/mobile/history-derive.js

@@ -79,6 +79,26 @@ function normalizeResultDiffs(meta) {
   return out.length > 0 ? out : undefined;
 }
 
+/**
+ * tool/result 的可见内容：两种形状都认。
+ *
+ * - 当前形状：`message.content` 直接就是内容块数组，成败在 `message.isError`；
+ * - 旧形状：`message.content[0]` 是 `{ isError, content: [内容块] }` 信封。
+ *
+ * 曾经只认旧形状，于是真实结果里的图片（`{type:'image', attachment}`）被当成信封剥掉、
+ * 整张图丢失，结果级 isError 也读不到（失败的工具显示成成功）。
+ */
+function toolResultParts(msg) {
+  const direct = Array.isArray(msg.content) ? msg.content : [];
+  const envelope = direct.length === 1 && direct[0] && typeof direct[0] === 'object'
+    && typeof direct[0].type !== 'string' ? direct[0] : null;
+  if (!envelope) return { parts: direct, isError: msg.isError === true };
+  return {
+    parts: Array.isArray(envelope.content) ? envelope.content : [],
+    isError: envelope.isError === true || msg.isError === true,
+  };
+}
+
 /** 预扫描 tool/result 事件，构建 callId → {isError, code} 映射（对接桌面 toolRowModel 状态派生）。 */
 function buildToolResultMap(events) {
   const map = new Map();
@@ -88,10 +108,8 @@ function buildToolResultMap(events) {
     const msg = e.data.message;
     const src = msg.source;
     if (!src || typeof src.callId !== 'string') continue;
-    const content = Array.isArray(msg.content) ? msg.content[0] : null;
-    const isError = content && content.isError === true;
+    const { parts, isError } = toolResultParts(msg);
     const code = e.data.error && typeof e.data.error.code === 'string' ? e.data.error.code : undefined;
-    const parts = content && Array.isArray(content.content) ? content.content : content ? [content] : [];
      const output = parts.map((part) => {
        if (part && typeof part.text === 'string') return part.text;
        if (part && typeof part === 'object' && part.type === 'image') return '';

package/lib/mobile/local-images.js

@@ -18,6 +18,8 @@
  * - 三级体积预算（单图 / 单段文本 / 单次响应，见下方常量）：超预算的图保持字面 markdown，
  *   不截断、不缩水成半张图。
  * - 读不到、不是普通文件、读取失败：原样保留 —— 一条图片取不到不能让整段历史或整帧 SSE 挂掉。
+ * - 围栏代码块与行内代码里的图片语法一律不碰：那是**写法示例**，不是要画的图；换掉会把
+ *   三行代码变成几十万字符的 base64，App 的代码块会铺成很长很长的一块。
  */
 
 const fs = require('node:fs/promises');
@@ -126,17 +128,97 @@ async function dataUriFor(filePath) {
   return uri;
 }
 
+/**
+ * Markdown 里「必须保持字面」的区间：围栏代码块与行内代码。
+ *
+ * 代码块里的 `![](/tmp/a.png)` 是**写法示例**而不是要画的图。旧实现整段正则替换，
+ * 会把三行代码换成几十万字符的 base64——App 把这段按代码文本铺开，就成了很长很长
+ * 的一块（真机现象：图片语法那块刷出几十屏，要划很久）。围栏判定与 App 的
+ * `utils/markdown/parser.ts` 同口径（两边都 trim 后看 3 个以上 ` / ~）。
+ */
+function literalRanges(text) {
+  const ranges = [];
+  const lines = text.split('\n');
+  const lineStarts = [];
+  let offset = 0;
+  for (const line of lines) {
+    lineStarts.push(offset);
+    offset += line.length + 1;
+  }
+  let fence = null;
+  let fenceStart = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (fence) {
+      const close = /^(`{3,}|~{3,})[ \t]*$/.exec(line.trim());
+      if (close && close[1][0] === fence.char && close[1].length >= fence.length) {
+        ranges.push([fenceStart, lineStarts[index] + line.length]);
+        fence = null;
+      }
+      continue;
+    }
+    const open = /^(`{3,}|~{3,})/.exec(line.trim());
+    if (!open) continue;
+    fence = { char: open[1][0], length: open[1].length };
+    fenceStart = lineStarts[index];
+  }
+  // 没闭合的围栏按 App 的解析口径一直吃到文末。
+  if (fence) ranges.push([fenceStart, text.length]);
+
+  // 行内代码：同长度的反引号成对（`code`）。围栏内部的反引号已在上面标过。
+  let cursor = 0;
+  while (cursor < text.length) {
+    if (text[cursor] !== '`' || inRanges(cursor, ranges)) {
+      cursor += 1;
+      continue;
+    }
+    let ticks = 1;
+    while (text[cursor + ticks] === '`') ticks += 1;
+    let scan = cursor + ticks;
+    let closed = -1;
+    while (scan < text.length) {
+      if (text[scan] !== '`' || inRanges(scan, ranges)) {
+        scan += 1;
+        continue;
+      }
+      let run = 1;
+      while (text[scan + run] === '`') run += 1;
+      if (run === ticks) {
+        closed = scan + run;
+        break;
+      }
+      scan += run;
+    }
+    if (closed < 0) {
+      cursor += ticks;
+      continue;
+    }
+    ranges.push([cursor, closed]);
+    cursor = closed;
+  }
+  return ranges;
+}
+
+function inRanges(index, ranges) {
+  for (const [start, end] of ranges) {
+    if (index >= start && index < end) return true;
+  }
+  return false;
+}
+
 /**
  * 把一段文本里的本机图片语法换成 data URI。返回原字符串本身（`===`）表示一个字没动，
  * 调用方据此免掉不必要的对象拷贝。
  */
 async function inlineTextImages(text, budget) {
   if (typeof text !== 'string' || text.indexOf('![') < 0) return text;
-  const matches = [...text.matchAll(IMAGE_RE)];
+  const ranges = literalRanges(text);
+  const matches = [...text.matchAll(IMAGE_RE)].filter((m) => !inRanges(m.index, ranges));
   if (!matches.length) return text;
   const pool = budget || createTextImageBudget();
   let textBudget = MAX_TEXT_CHARS;
-  let out = text;
+  let out = '';
+  let cursor = 0;
   for (const m of matches) {
     if (textBudget <= 0 || pool.remaining <= 0) break;
     const filePath = localImagePathOf(m[2]);
@@ -145,9 +227,10 @@ async function inlineTextImages(text, budget) {
     if (!uri || uri.length > textBudget || uri.length > pool.remaining) continue;
     textBudget -= uri.length;
     pool.remaining -= uri.length;
-    out = out.replace(m[0], `![${m[1]}](${uri})`);
+    out += text.slice(cursor, m.index) + `![${m[1]}](${uri})`;
+    cursor = m.index + m[0].length;
   }
-  return out === text ? text : out;
+  return cursor === 0 ? text : out + text.slice(cursor);
 }
 
 module.exports = { inlineTextImages, createTextImageBudget, localImagePathOf };

package/lib/mobile/stream.js

@@ -44,6 +44,11 @@ const SSE_FLUSH_PADDING_BYTES = 2048;
  */
 const SSE_SHED_BUFFERED_BYTES = 4 * 1024 * 1024;
 const SSE_CLOSE_BUFFERED_BYTES = 16 * 1024 * 1024;
+/**
+ * 等一次 `drain` 的上限。超过这么久还没排空，说明对面不是慢、是真的不读了（手机切后台、
+ * 中转卡住），继续等只是把这条连接挂在那里，不如收尾让客户端重连。
+ */
+const SSE_DRAIN_TIMEOUT_MS = 20_000;
 const REPLAY_WINDOW = 3000; // 断线补偿回放的最大事件数
 
 /**
@@ -88,18 +93,58 @@ function stableEventId(payload, frame) {
   return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
 }
 
+/**
+ * 这条连接上真正「还没发出去」的字节数。
+ *
+ * `res.writableLength` 只算响应对象自己那一层缓冲，真正堆积的地方在它底下的套接字
+ * 写队列（堆快照里那些 `{chunk, encoding, callback}` 就是它）。第一版只看
+ * `res.writableLength`，它恒为 0，两道闸一次都没触发 —— 2026-10-18 复测：修完内存
+ * 仍从 410MB 涨到 1.4GB。所以要顺着 socket 一起看，取两者较大值。
+ */
+function bufferedBytesOf(res) {
+  const own = Number(res.writableLength) || 0;
+  const socket = res.socket || res.connection;
+  const queued = socket ? Number(socket.writableLength) || 0 : 0;
+  return Math.max(own, queued);
+}
+
+/**
+ * 等底层把缓冲吐出去（`drain`）。背压的正解：写不动就停手，而不是继续塞。
+ *
+ * @returns {Promise<boolean>} 真的 drain 了 → true；超时或流被中断 → false（该收尾）。
+ */
+function waitForDrain(res, signal, timeoutMs = SSE_DRAIN_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    if (signal && signal.aborted) return resolve(false);
+    let done = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (typeof res.off === 'function') res.off('drain', onDrain);
+      if (signal && typeof signal.removeEventListener === 'function') signal.removeEventListener('abort', onAbort);
+    };
+    const finish = (value) => { if (done) return; done = true; cleanup(); resolve(value); };
+    const onDrain = () => finish(true);
+    const onAbort = () => finish(false);
+    const timer = setTimeout(() => finish(false), timeoutMs);
+    if (typeof timer.unref === 'function') timer.unref();
+    if (typeof res.once === 'function') res.once('drain', onDrain);
+    if (signal && typeof signal.addEventListener === 'function') signal.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
 /**
  * 写一条 SSE 记录。
  *
- * @returns {{ok: boolean, shed?: boolean}} `ok:false` 表示这条流该收尾了（客户端已经
- *   走了，或者写缓冲超过硬水位）；`shed:true` 表示这条**增量**帧被主动丢掉、连接还
- *   活着（见 SSE_SHED_BUFFERED_BYTES）。
+ * @returns {{ok: boolean, shed?: boolean, needDrain?: boolean}}
+ *   `ok:false` → 这条流该收尾（客户端走了，或积压超过硬水位）；
+ *   `shed:true` → 这条**增量**帧被丢掉、连接还活着（超过软水位且没有 seq）；
+ *   `needDrain:true` → 写成功了，但底下已经写不动，调用方要先 await 一次 drain 再继续。
  *
- * 丢增量必须只丢没有 seq 的帧：有 seq 的帧是客户端水位的一部分，丢了不回放就在手机
- * 上留一个永久的洞，那比断流更糟。
+ * 丢增量只丢没有 seq 的帧：有 seq 的帧是客户端水位的一部分，丢了不回放就在手机上
+ * 留一个永久的洞，那比断流更糟。
  */
 function writeSse(res, payload, frame) {
-  const buffered = Number(res.writableLength) || 0;
+  const buffered = bufferedBytesOf(res);
   if (buffered > SSE_CLOSE_BUFFERED_BYTES) return { ok: false };
   const id = stableEventId(payload, frame);
   const hasSeq = Number.isFinite(payload && payload.seq);
@@ -108,7 +153,12 @@ function writeSse(res, payload, frame) {
   if (id) fields.push(`id: ${id}`);
   fields.push(`data: ${JSON.stringify(payload)}`);
   fields.push(`: ${' '.repeat(SSE_FLUSH_PADDING_BYTES)}`, '', '');
-  try { res.write(`${fields.join('\n')}\n`); return { ok: true }; } catch { return { ok: false }; }
+  try {
+    // `write()` 返回 false 才是背压的正信号：数据已经堆到高水位，继续写只会把内存
+    // 堆起来。以前把它当成功吞掉，正是这次 4GB OOM 的直接原因。
+    const accepted = res.write(`${fields.join('\n')}\n`);
+    return { ok: true, needDrain: accepted === false };
+  } catch { return { ok: false }; }
 }
 
 /**
@@ -200,6 +250,19 @@ async function handleStream(ctx, req, res) {
       // 这一条会话的 follow + 投影 + 任务三条流（见 mobile/host-bridge.js 的 muxFrames）。
       // 不带就是设备级视角，只会给工作区基线与全局投影 —— 这里反正只要单会话。
       const frames = ctx.apiProxy.events.mux({ rpcId: 'mobile-stream', payload: { sessionId } }, ac.signal);
+      // 写一帧并把三种结果统一收口：丢增量、需要等 drain、该收尾。
+      // 「需要等 drain」这一步是这次 OOM 的正解 —— 写不动就停手，等底层消化完再继续，
+      // 而不是把帧继续往内存里塞。
+      const push = async (payload, frameArg) => {
+        const sent = writeSse(res, payload, frameArg);
+        if (sent.shed) return 'shed';
+        if (!sent.ok) return 'closed';
+        if (sent.needDrain) {
+          const drained = await waitForDrain(res, ac.signal);
+          if (!drained) { logStream(sessionId, 'drain timeout', null); return 'closed'; }
+        }
+        return 'sent';
+      };
       for await (const frame of frames) {
         const p = frame.payload;
         if (!p || p.sessionId !== sessionId) continue;
@@ -211,29 +274,29 @@ async function handleStream(ctx, req, res) {
           const event = await resolveEventAttachments(ctx, sessionId, p.event);
           // 被 shed 的只可能是没有 seq 的增量（见 writeSse 的软水位闸）；它不推进水位，
           // 同一轮收尾的 assistant/message 会把完整正文补上。
-          const sent = writeSse(res, event, { ...frame, payload: { ...p, event } });
-          if (sent.shed) continue;
-          if (!sent.ok) { clientGone = true; break; }
+          const result = await push(event, { ...frame, payload: { ...p, event } });
+          if (result === 'shed') continue;
+          if (result === 'closed') { clientGone = true; break; }
           if (seq !== null) lastDeliveredSeq = seq;
         } else if (p.type === 'session/queue' || p.type === 'session/projection') {
           // 队列/投影整帧转发；不假定存在可重放的宿主 API。
-          const sent = writeSse(res, p, frame);
-          if (sent.shed) continue;
-          if (!sent.ok) { clientGone = true; break; }
+          const result = await push(p, frame);
+          if (result === 'shed') continue;
+          if (result === 'closed') { clientGone = true; break; }
         } else if (p.type === 'session/jobs') {
           // 后台任务整帧（桌面端会话头部任务面板的数据源）。宿主只在任务有变化时发，
           // 且**空数组也要转发** —— 那是「任务都结束了」的唯一信号，丢掉它就永远清不掉。
           const value = { type: 'session/jobs', sessionId, jobs: normalizeJobs(p.jobs) };
-          if (!writeSse(res, value, frame).ok) { clientGone = true; break; }
+          if (await push(value, frame) === 'closed') { clientGone = true; break; }
         } else if (p.type === 'question/requested') {
           // 问题是可回答的 mux server-request，而非 session/event；保留 rpcId 供回答关联。
           const value = { ...p, rpcId: frame.rpcId };
-          if (!writeSse(res, value, { ...frame, payload: value }).ok) { clientGone = true; break; }
+          if (await push(value, { ...frame, payload: value }) === 'closed') { clientGone = true; break; }
         } else if (p.type === 'question/resolved' || p.type === 'approval/requested' || p.type === 'approval/asked' || p.type === 'approval/decided' || p.type === 'approval/resolved') {
           // Approval frames are server requests/resolutions, not session/event frames;
           // forward the rpcId and approval identity so the mobile client can answer safely.
           const value = ANSWERABLE_APPROVAL_TYPES.has(p.type) && frame.rpcId ? { ...p, rpcId: frame.rpcId } : p;
-          if (!writeSse(res, value, { ...frame, payload: value }).ok) { clientGone = true; break; }
+          if (await push(value, { ...frame, payload: value }) === 'closed') { clientGone = true; break; }
         }
       }
       if (!clientGone) loopEnded = true;
@@ -289,7 +352,10 @@ async function replaySince(ctx, sessionId, sinceSeq, res, signal, onDelivered) {
       // Keep replay data identical to live SSE data: the client reducer consumes
       // the event's own type (turn/start, assistant/message, etc.).
       const payload = { type: 'session/event', sessionId, event };
-      if (!writeSse(res, event, { payload }).ok) break;
+      const sent = writeSse(res, event, { payload });
+      if (!sent.ok) break;
+      // 回放是「一次性灌几千条」，最容易把写队列撑爆：写不动就在这里等，别一口气塞完。
+      if (sent.needDrain && !(await waitForDrain(res, signal))) break;
       if (Number.isFinite(event.seq)) onDelivered(event.seq);
     }
     return { gap, oldestSeq };

package/lib/session-cleanup.cjs

@@ -16,6 +16,9 @@
  *    （pruneOrphanedArchivedSessionsOnce）。理由写在那个函数上：桌面端的会话列表是
  *    连上宿主时拉的一份快照 + 之后的事件增量，进程里擦集合等于把已经删掉、却还留在
  *    快照里的行放回正常列表。
+ *  - **Windows 上目录删不掉 ≠ 会话没删掉**：宿主对它打开过的会话一直握着 `session.lock`
+ *    的写句柄，日志 unlink 成功后那个名字要等句柄关闭才消失（delete-pending），rmdir
+ *    于是报 ENOTEMPTY。判据改成「目录里还有没有规范名日志」：没有就是删成了。
  */
 'use strict'
 
@@ -90,6 +93,9 @@ async function readHeader(file) {
   } finally {
     stream.destroy()
     source.destroy()
+    // Windows 上句柄没真的关掉之前，这个目录项删不掉（delete-pending → rmdir 报 ENOTEMPTY）。
+    // 删会话目录就紧跟在读 header 之后，所以先等 close 再往下走。
+    if (!source.closed) await new Promise(resolve => source.once('close', resolve))
   }
   return undefined
 }
@@ -116,12 +122,16 @@ async function deleteSessionData(sessionIds) {
   for (const file of sessionFiles(root)) {
     const header = await readHeader(file)
     if (!header || !ids.has(header.id)) continue
+    const directory = path.dirname(file)
     try {
-      fs.rmSync(path.dirname(file), { recursive: true, force: true })
-      removed.push(header.id)
+      fs.rmSync(directory, { recursive: true, force: true })
     } catch (error) {
-      throw new Error(`删除会话 ${header.id} 失败：${error.message}`)
+      // Windows：宿主握着 session.lock，日志 unlink 成功了但名字还在（delete-pending），
+      // rmdir 报 ENOTEMPTY。日志都没了，这条会话对宿主就等于已经删掉，按删成记账、继续清
+      // 下一条；日志还在才算真失败（别把没删掉的说成删掉了）。
+      if (sessionFiles(directory).length > 0) throw new Error(`删除会话 ${header.id} 失败：${error.message}`)
     }
+    removed.push(header.id)
   }
   const cacheRoot = path.join(dshHome(), 'storages', 'session_projcache', 'sessions')
   for (const id of ids) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.85",
+  "version": "0.1.86",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (0.2.0-rc.2 compatible, peers resolved by the host)",
   "license": "MIT",
   "type": "module",