dsh-mobile-plugin 0.5.1 → 0.5.4

package/lib/mobile/session-mirror.js

@@ -8,7 +8,8 @@
  * `updatedAt:running:limit` 指纹判鲜，2 分钟 TTL，上限 256 条按插入序淘汰。
  */
 
-const { buildMessagesSnapshot, buildStatsSnapshot } = require('./session-snapshot.js');
+const { buildMessagesSnapshot } = require('./session-snapshot.js');
+const { buildStatsSnapshot } = require('./session-stats.js');
 const { mirrorHistoryStateOf } = require('./session-cache.js');
 
 const MIRROR_HISTORY_CACHE_MS = 120000;  // 2 min TTL, reduces redundant rebuilds

package/lib/mobile/session-send.js

@@ -25,6 +25,7 @@ const { promptErrorObject, MODEL_UNAVAILABLE_ERROR } = require('./history-derive
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
 const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/transport.js');
 const { recordSessionRead } = require('./session-last-turn.js');
+const { imageSizeOf } = require('./local-images.js');
 
 /**
  * `/send` 的请求体上限（**明文**字节，图片 base64）。
@@ -285,9 +286,20 @@ async function handleSessionAttachment(ctx, req, res) {
   // 让 App 那边把重试按钮的失败说清楚，而不是转圈到超时。
   if (!data) return sendJson(res, 404, { ok: false, error: { code: 'not-found', message: '附件已不可读' } });
   const attachment = (value && value.attachment) || {};
+  const mediaType = typeof attachment.mediaType === 'string' && attachment.mediaType ? attachment.mediaType : 'image/png';
+  // `dims: true` = 只要原始宽高，不要字节。老会话里宿主没存附件的宽高，正文下发时就带不上，
+  // 手机侧只能按 240 方盒先占位、等字节到了再变高（那一行一变高，屏幕上就是「跳」）。这一档
+  // 让手机在挂载那一帧就能按真比例占好：回给它的只有两格数字，整张图的 base64 不出这台电脑。
+  if (body.dims === true) {
+    const size = imageSizeOf(Buffer.from(data, 'base64'));
+    if (!size || !(size.width > 0) || !(size.height > 0)) {
+      return sendJson(res, 404, { ok: false, error: { code: 'no-dims', message: '这张图的文件头里量不出宽高' } });
+    }
+    return sendJson(res, 200, { ok: true, mediaType, width: size.width, height: size.height });
+  }
   sendJson(res, 200, {
     ok: true,
-    mediaType: typeof attachment.mediaType === 'string' && attachment.mediaType ? attachment.mediaType : 'image/png',
+    mediaType,
     data,
     ...(typeof attachment.name === 'string' ? { name: attachment.name } : {}),
   });

package/lib/mobile/session-snapshot.js

@@ -1,11 +1,12 @@
 'use strict';
 
 /**
- * 消息与统计快照：镜像推送与 /messages 分页共用的两条折叠路径。
+ * 消息快照：镜像推送与 /messages 分页共用的折叠路径。
  *
  * buildMessagesSnapshot（不解析 query）与 handleMessages（解析 beforeSeq/afterSeq/limit）
  * 共用消息折叠逻辑。普通会话走 sessions.history；子代理必须携带 durable parent address，
- * 改走 subagents.history，不能把 child sessionId 当普通会话读。
+ * 改走 subagents.history，不能把 child sessionId 当普通会话读。统计投影不在这里，
+ * 在 session-stats.js（两条路径的取数口径不同，别混回一份）。
  *
  * 上游历史接口不认 afterSeq（只认 beforeSeq/maxMessages），所以增量轮询在插件内用较大的
  * 窗口（Math.max(limit, 200)）拉最近若干事件后再按 seq 过滤；缺口超过窗口时会漏，此时
@@ -20,7 +21,7 @@ const { resolveEventAttachments } = require('./attachments.js');
 const { createTextImageBudget } = require('./local-images.js');
 const { entryWindowPayload } = require('./entry-window.js');
 
-const MESSAGES_DEFAULT_LIMIT = 50;  // /messages 默认条数
+const MESSAGES_DEFAULT_LIMIT = 50, TOOL_LOOKBACK_EVENTS = 120;  // 默认条数 / 倒着翻页时多看几条（只为认出这一轮的工具结果）
 
 function historyHttpStatus(error) {
   switch (error && error.code) {
@@ -55,58 +56,19 @@ function eventSeqOf(entry) {
 async function buildMessagesSnapshot(ctx, sessionId, limit = MESSAGES_DEFAULT_LIMIT) {
   const { value, error } = unwrap(await callSessions(ctx, 'history', { sessionId, maxMessages: limit }));
   if (error) return { ok: false, error };
-  const events = (value && value.events) || [];
+  const allEvents = (value && value.events) || [];
+  // 这一路是整窗快照，不带分页参数（宿主已按 maxMessages 截过）：多给了就只留尾部那一窗。
+  const events = allEvents.length > limit ? allEvents.slice(-limit) : allEvents;
   // 引用模式：图片只下发 attachmentId，不取字节（见 attachments.js）。正文里本机图片的
   // 内联仍走 budget，与之前一致。
   const budget = createTextImageBudget();
   const resolvedEvents = await Promise.all(events.map((entry) => resolveEventAttachments(ctx, sessionId, entry.event || entry, { budget, referencesOnly: true }).then((event) => entry.event ? { ...entry, event } : event)));
-  const messages = deriveMessages(resolvedEvents);
+  const messages = deriveMessages(resolvedEvents, sessionId);
   const lastSeq = events.length ? (eventSeqOf(events[events.length - 1]) ?? 0) : 0;
   const hasMore = !!(value && value.hasMore);
   return { ok: true, items: messages, lastSeq, hasMore };
 }
 
-/**
- * 镜像快照用的统计投影（与 handleStats 尾部投影读取保持一致）：取整帧 projections，
- * 并把 plan 归一化为 planMode，供 pushMirror 为活跃会话生成统计快照。
- */
-async function buildStatsSnapshot(ctx, sessionId) {
-  return statsProjections(ctx, sessionId);
-}
-
-/**
- * 统计投影快照（handleStats 与 buildStatsSnapshot 共用）。
- *
- * 0.2.0 把整帧投影从 history/page 的返回值里拆走了，「拉一条历史顺带取投影」这条路断了；
- * 改走 `apiProxy.sessions.projections({ request: { sessionId } })`，返回值是
- * `{ asOfSeq, values }`。顺带把 plan 归一化成 planMode（排队条与计划条读它）。
- * 历史轮询是每 15 秒一次的热路径，多背一次投影 RPC 划不来，所以统计单独走投影端点。
- */
-async function statsProjections(ctx, sessionId) {
-  // 显式给 signal：宿主部分方法内部直接读 signal.aborted，不做 undefined 兜底。
-  const controller = new AbortController();
-  let value;
-  let error;
-  try {
-    ({ value, error } = unwrap(await callSessions(ctx, 'projections', { sessionId }, 'mobile', controller.signal)));
-  } catch (thrown) {
-    // 投影读不出来不该变成一个从路由层逃出去的 rejection：handleStats 要回 400，
-    // pushMirror 那边更是一条都不能抛（抛了整帧快照就丢了）。收敛成正常错误态。
-    error = thrown && typeof thrown === 'object' && typeof thrown.code === 'string'
-      ? { code: thrown.code, message: typeof thrown.message === 'string' ? thrown.message : '读会话投影失败' }
-      : { code: 'host-call-failed', message: thrown && thrown.message ? String(thrown.message) : '读会话投影失败' };
-  }
-  if (error) return { ok: false, error };
-  const projections = value && value.values && typeof value.values === 'object' ? value.values : {};
-  const plan = projections.plan;
-  return {
-    ok: true,
-    projections: plan && typeof plan === 'object' && typeof plan.active === 'boolean'
-      ? { ...projections, planMode: { active: plan.active, ...(typeof plan.pending === 'boolean' ? { pending: plan.pending } : {}) } }
-      : projections,
-  };
-}
-
 /** GET /api/mobile/v1/session/messages?sessionId=…&beforeSeq=…&afterSeq=…&limit=…（token） */
 async function handleMessages(ctx, req, res) {
   const url = new URL(req.url, 'http://x');
@@ -135,7 +97,7 @@ async function handleMessages(ctx, req, res) {
     if (Number.isSafeInteger(parsed)) afterSeq = parsed;
   }
   const payload = { sessionId, maxMessages: limit };
-  if (beforeSeq !== null) payload.beforeSeq = beforeSeq;
+  if (beforeSeq !== null) { payload.beforeSeq = beforeSeq; payload.maxMessages = limit + TOOL_LOOKBACK_EVENTS; }
   // 上游历史接口都不支持 afterSeq（只认 beforeSeq/maxMessages），故在插件内用较大的窗口
   // 拉最近若干事件后再过滤 seq > afterSeq，覆盖常见轮询缺口；缺口超过窗口时要求客户端全量补齐。
   if (afterSeq !== null) payload.maxMessages = Math.max(limit, 200);
@@ -159,16 +121,37 @@ async function handleMessages(ctx, req, res) {
     error = normalizeHistoryError(thrown);
   }
   if (error) return sendJson(res, historyHttpStatus(error), { ok: false, error });
-  const events = (value && value.events) || [];
-  // 增量：只保留水位之后的事件；非 afterSeq 调用时 events 原样保留（行为与之前完全一致）。
-  const filtered = afterSeq !== null ? events.filter((entry) => (eventSeqOf(entry) ?? -1) > afterSeq) : events;
+  const allEvents = (value && value.events) || [];
+  const lookback = beforeSeq !== null && allEvents.length > limit ? allEvents.slice(0, -limit) : null;
+  const events = lookback ? allEvents.slice(-limit) : allEvents;
+  // 增量：游标之后的事件才是要发的行，但**折叠**仍按整窗做（见下）。
   // 一页历史共用一个内联图片预算：正文里的本机图片越多，越靠后的那些保持字面 markdown，
   // 而不是让单次响应无限膨胀（见 local-images.js 的三级预算）。
+  //
+  // 折叠要看**整窗**：压缩与 slash 命令行都是「一串事件攒出来的一行」（start → summary → end、
+  // run → done），按游标先把事件砍掉再折叠，剩下那半截就会漏成「没有摘要的压缩行」和
+  // 「没有名字的命令行」——真机现场就是屏幕上并排三行：`compact·执行中`、`上下文已压缩·
+  // 压缩摘要不可用`、`命令·Compacted 206 history items`。所以游标只用来筛**折叠出来的行**，
+  // 事件仍按整窗折叠；附件只为游标之后的事件解析（游标前那批只当上下文，不出行）。
   const budget = createTextImageBudget();
-  const resolvedEvents = await Promise.all(filtered.map((entry) => resolveEventAttachments(ctx, sessionId, entry.event || entry, { budget, referencesOnly: true }).then((event) => entry.event ? { ...entry, event } : event)));
-  const messages = deriveMessages(resolvedEvents);
+  const resolvedEvents = await Promise.all(events.map((entry) => {
+    const seq = eventSeqOf(entry);
+    const deliverable = afterSeq === null || !Number.isSafeInteger(seq) || seq > afterSeq;
+    const event = entry.event || entry;
+    if (!deliverable) return event;
+    return resolveEventAttachments(ctx, sessionId, event, { budget, referencesOnly: true })
+      .then((resolved) => (entry.event ? { ...entry, event: resolved } : resolved));
+  }));
+  const messages = deriveMessages(resolvedEvents, sessionId, lookback);
   const hasMore = !!(value && value.hasMore);
-  const items = wantThin ? thinEntryMessages(messages, { hasMore }) : messages;
+  const items = wantThin
+    ? thinEntryMessages(messages, { hasMore })
+    // 结构行（压缩 / 命令行）照发：它们由整段生命周期折出来，一次也就一两条，按 id 覆盖
+    // 正好把屏幕上已经歪掉的那一行修回来 —— 按游标筛掉就永远修不回来。
+    : (afterSeq === null
+      ? messages
+      : messages.filter((item) => item.kind === 'compaction' || item.kind === 'command'
+        || (Number.isSafeInteger(item.seq) && item.seq > afterSeq)));
   // 工具结果不产生消息行，但会把**缓存里已有的**工具卡从 running 补成最终态。补丁取自
   // 整个窗口（调用方游标可能已越过结果 seq）；已随消息块下发的只回状态（见 toolResultPatchesFor）。
   // 增量那一发（带 afterSeq）一律只回状态：调用方手上已有一份会话，整窗重发等于每 15 秒
@@ -193,4 +176,4 @@ async function handleMessages(ctx, req, res) {
   });
 }
 
-module.exports = { eventSeqOf, buildMessagesSnapshot, statsProjections, buildStatsSnapshot, handleMessages };
+module.exports = { eventSeqOf, buildMessagesSnapshot, handleMessages };

package/lib/mobile/session-stats.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * 会话统计投影：handleStats 与镜像推送共用的那一份取数口径。
+ *
+ * 0.2.0 把整帧投影从 history/page 的返回值里拆走了，「拉一条历史顺带取投影」这条路断了；
+ * 改走 `apiProxy.sessions.projections({ request: { sessionId } })`，返回值是
+ * `{ asOfSeq, values }`。顺带把 plan 归一化成 planMode（排队条与计划条读它）。
+ * 历史轮询是每 15 秒一次的热路径，多背一次投影 RPC 划不来，所以统计单独走投影端点。
+ */
+
+const { unwrap } = require('./envelope.js');
+const { callSessions } = require('./rpc.js');
+
+/**
+ * 镜像快照用的统计投影（与 handleStats 尾部投影读取保持一致）：取整帧 projections，
+ * 并把 plan 归一化为 planMode，供 pushMirror 为活跃会话生成统计快照。
+ */
+async function buildStatsSnapshot(ctx, sessionId) {
+  return statsProjections(ctx, sessionId);
+}
+
+/**
+ * 统计投影快照（handleStats 与 buildStatsSnapshot 共用）。
+ */
+async function statsProjections(ctx, sessionId) {
+  // 显式给 signal：宿主部分方法内部直接读 signal.aborted，不做 undefined 兜底。
+  const controller = new AbortController();
+  let value;
+  let error;
+  try {
+    ({ value, error } = unwrap(await callSessions(ctx, 'projections', { sessionId }, 'mobile', controller.signal)));
+  } catch (thrown) {
+    // 投影读不出来不该变成一个从路由层逃出去的 rejection：handleStats 要回 400，
+    // pushMirror 那边更是一条都不能抛（抛了整帧快照就丢了）。收敛成正常错误态。
+    error = thrown && typeof thrown === 'object' && typeof thrown.code === 'string'
+      ? { code: thrown.code, message: typeof thrown.message === 'string' ? thrown.message : '读会话投影失败' }
+      : { code: 'host-call-failed', message: thrown && thrown.message ? String(thrown.message) : '读会话投影失败' };
+  }
+  if (error) return { ok: false, error };
+  const projections = value && value.values && typeof value.values === 'object' ? value.values : {};
+  const plan = projections.plan;
+  return {
+    ok: true,
+    projections: plan && typeof plan === 'object' && typeof plan.active === 'boolean'
+      ? { ...projections, planMode: { active: plan.active, ...(typeof plan.pending === 'boolean' ? { pending: plan.pending } : {}) } }
+      : projections,
+  };
+}
+
+module.exports = { buildStatsSnapshot, statsProjections };

package/lib/mobile/sessions.js

@@ -6,7 +6,7 @@
  * 这个文件一度是一千九百多行的单体，HTTP 路由、宿主 RPC、缓存、事件派生全混在一起；现在
  * 按域拆开：envelope（信封拆解）、rpc（窄接口封装）、session-cache（按 ctx 隔离的状态表）、
  * attachments、completion、session-models、session-search、session-send、session-snapshot、
- * session-mirror、session-goal、session-presets、session-preview、session-list-shortcut。
+ * session-stats、session-mirror、session-goal、session-presets、session-preview、session-list-shortcut。
  *
  * 剩下的就是列表：GET /sessions（10 秒缓存 + fresh 绕过 + 完成态确认 + `?rev=` 条件刷新）、
  * 单会话摘要、正文水位探针、统计、新建会话、排队消息动作。本文件继续转出各子模块的导出，
@@ -32,7 +32,8 @@ const {
 const { resolveEventAttachments } = require('./attachments.js');
 const { updateCompletionStates, confirmCompletionFromHistory } = require('./completion.js');
 const { lastTurnOf } = require('./session-last-turn.js');
-const { eventSeqOf, buildMessagesSnapshot, buildStatsSnapshot, statsProjections, handleMessages } = require('./session-snapshot.js');
+const { eventSeqOf, buildMessagesSnapshot, handleMessages } = require('./session-snapshot.js');
+const { buildStatsSnapshot, statsProjections } = require('./session-stats.js');
 const { buildModelsSnapshot, handleModels, handleSelectModel } = require('./session-models.js');
 const { buildSingleSessionMirror, buildMirrorWarmSnapshots } = require('./session-mirror.js');
 const { promptOnce, handleSend, handleCommands, handleSessionRead, handleSessionAttachment, handleStop,

package/lib/mobile/tool-result-cache.js

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * 「这一页里只看到工具调用、看不到它的结果」时的补救：把结果记在进程里，供更早的页用。
+ *
+ * 为什么需要：历史是倒着分页取的（`beforeSeq`），一页的事件是 `[oldest, beforeSeq)`。而
+ * `tool/result` 事件的 seq 比「发起这次调用的 assistant 消息」**大** —— 边界正好切在两者
+ * 之间时，那一页只看得到调用，看不到结果，于是那条消息的工具图缺一块；等下一页（更新的一页，
+ * 本机早就拿到过）把结果带回来再补，手机侧那一行已经从「没图」的高度长到「有图」的高度，
+ * 而它在用户头顶上 —— 一变就把正看的内容推走（真机录制：同一条消息 589 ↔ 817 来回）。
+ *
+ * 做法：每次投影都把这一页看到的结果记下来；下一次投影更早的页时，把这些记下的结果一并喂给
+ * `deriveMessages`，图就跟着消息一起下发，行在挂载那一帧就是终高。
+ *
+ * 边界：只活在插件进程里、只按会话分桶、每桶按插入序淘汰 —— 进程重启就没了，那时手机重新
+ * 进对话本来也要重拉。
+ */
+
+/** 每条会话记住多少个调用：一次翻页窗口最多几百个，2000 足够覆盖一次通读。 */
+const MAX_CALLS_PER_SESSION = 2000;
+/** 同时记几条会话：手机一般只在一两条会话里翻历史。 */
+const MAX_SESSIONS = 8;
+
+/** sessionId → Map(callId → 结果)。Map 的插入序就是淘汰序。 */
+const stores = new Map();
+
+/**
+ * 记住这一页看到的结果（已存在的不覆盖：同一次调用的结果不会变，先记下的就是它）。
+ */
+function rememberToolResults(sessionId, results) {
+  if (!sessionId || !results || results.size === 0) return;
+  let bucket = stores.get(sessionId);
+  if (!bucket) {
+    bucket = new Map();
+    stores.set(sessionId, bucket);
+    // 新会话进来，把最旧的那条挤掉。
+    while (stores.size > MAX_SESSIONS) {
+      const oldest = stores.keys().next();
+      if (oldest.done) break;
+      stores.delete(oldest.value);
+    }
+  } else {
+    // 读到就挪到末尾（按使用序淘汰，而不是按写入序）。
+    stores.delete(sessionId);
+    stores.set(sessionId, bucket);
+  }
+  for (const [callId, result] of results) {
+    if (bucket.has(callId)) continue;
+    bucket.set(callId, result);
+    if (bucket.size > MAX_CALLS_PER_SESSION) {
+      const oldest = bucket.keys().next();
+      if (oldest.done) break;
+      bucket.delete(oldest.value);
+    }
+  }
+}
+
+/** 这条会话已经记下的结果（没有就是 empty Map）。调用方不要改它。 */
+function toolResultsFor(sessionId) {
+  return (sessionId && stores.get(sessionId)) || null;
+}
+
+/** 测试用：清掉一条（或全部）会话的记录。 */
+function clearToolResults(sessionId) {
+  if (sessionId) stores.delete(sessionId);
+  else stores.clear();
+}
+
+module.exports = {
+  rememberToolResults,
+  toolResultsFor,
+  clearToolResults,
+  MAX_CALLS_PER_SESSION,
+  MAX_SESSIONS,
+};