dsh-mobile-plugin 0.5.19 → 0.5.21

package/lib/mobile/session-flags.js

@@ -24,22 +24,69 @@ const questions = require('./questions.js');
  * - `pinnedSessionIds`：已置顶的会话。摘要里没有置顶字段，不读这份快照就画不出置顶标记、
  *   也排不到工作区最前。
  *
- * 两个集合合并成一次 RPC：同源同一次快照，而会话列表每 10 秒重建一次。取不到时都回空 ——
- * 宁可多显示几行，也不能因为一次 RPC 抖动让整个列表变空。
+ * 两个集合合并成一次 RPC：同源同一次快照，而会话列表每 10 秒重建一次。
+ *
+ * 取不到时两个集合都回空，另外带一个 `known: false`。调用方据此分两种口径：
+ *
+ * - **列表**（`/sessions`）按空集合画：宁可多显示几行，也不能因为一次 RPC 抖动让整个侧栏变空。
+ * - **提醒**（`/monitor`）不许把「不知道」当成「没有归档」：那样一次抖动就会让已归档的会话
+ *   重新进监控视图，被当成刚跑完再响一遍。所以那条路由另外用一本账（[archivedSessionIds]），
+ *   记着最近一次真读到的归档集合，读不到就沿用它。
  */
 async function workspaceSessionFlags(ctx) {
   try {
     const resp = await ctx.apiProxy.workspace.list({ rpcId: 'mobile', method: 'workspace.list', payload: {} });
     const value = unwrap(resp).value;
-    const idSetOf = (field) => new Set(
-      value && Array.isArray(value[field]) ? value[field].filter(id => typeof id === 'string') : [],
-    );
-    return { archived: idSetOf('archivedSessionIds'), pinned: idSetOf('pinnedSessionIds') };
+    // 集合被人当成 Set 传过（宿主与本仓库两个来源形状不一样，dsh-devmap 专门归一化过），
+    // 所以数组与 Set 都收：只认 `Array.isArray` 会让那一类宿主上的归档过滤恒失效。
+    const idSetOf = (field) => {
+      const raw = value && value[field];
+      const list = Array.isArray(raw) ? raw : (raw instanceof Set ? [...raw] : null);
+      return list ? new Set(list.filter(id => typeof id === 'string')) : null;
+    };
+    const archived = idSetOf('archivedSessionIds');
+    // 判据只看归档那一格：置顶是画图用的，缺了顶多个图钉，不值得让它把归档判断一起拖死。
+    const pinned = idSetOf('pinnedSessionIds') ?? new Set();
+    if (!archived) return { archived: new Set(), pinned, known: false };
+    return { archived, pinned, known: true };
   } catch {
-    return { archived: new Set(), pinned: new Set() };
+    return { archived: new Set(), pinned: new Set(), known: false };
   }
 }
 
+/**
+ * `/monitor` 用的归档集合：**只认读到的**，读不到就沿用上一次读到的那一份。
+ *
+ * 为什么不跟列表一样 fail-open：这条视图的作用是决定「要不要在后台叫醒人」，而它的判据是
+ * 「这个会话还在不在清单里」。一次读不到就按空集合画，已归档的会话会重新进清单 —— 原生那边
+ * 刚因为它消失而清了基线，于是它成了「第一次见到」，只要那一轮结束在十分钟内就再响一遍
+ * （延迟多久取决于宿主的 RPC 超时，反复抖动就会反复响）。列表那边空一下只是多显示几行，
+ * 这边空一下是半夜多叮一声，两种代价不是一个量级。
+ *
+ * 也刻意**不**回 5xx：README 那条规矩是「一拍什么都没取到就退回完整清单」，而这条 RPC
+ * 在 0.2.0 宿主要现开 `workspace.follow` 取首帧（8 秒预算），失败率不低 —— 每失败一拍就
+ * 让整个后台提醒哑掉，代价比偶尔多滤错一条大得多。沿用旧账的最坏结果是「刚归档的会话还在
+ * 清单里挂一会儿」，而它挂着的那些拍，这条会话的 `completed` 还会按已读水位判，不会凭空响。
+ *
+ * 一本账都没有（进程刚起来就问不到）时退回空集合 —— 那时候原生手上也没有基线，
+ * 首拍见到什么都只建基线、不提醒，所以空集合不会凭空造出一次提醒。
+ */
+const archivedSessionIds = { ids: null };
+
+async function archivedSessionIdsForMonitor(ctx) {
+  const { archived, known } = await workspaceSessionFlags(ctx);
+  if (known) {
+    archivedSessionIds.ids = archived;
+    return archived;
+  }
+  return archivedSessionIds.ids ?? archived;
+}
+
+/** 仅供守卫重置进程内那本归档账。 */
+function resetArchivedSessionIdsForTest() {
+  archivedSessionIds.ids = null;
+}
+
 /**
  * 「这条会话是不是在等人回话」以及等的是什么。
  *
@@ -72,4 +119,10 @@ function pendingCardOf(sessionId, summary) {
   return approvals.pendingCardOf(sessionId) || questions.pendingCardOf(sessionId);
 }
 
-module.exports = { workspaceSessionFlags, pendingInteractionOf, pendingCardOf };
+module.exports = {
+  workspaceSessionFlags,
+  archivedSessionIdsForMonitor,
+  resetArchivedSessionIdsForTest,
+  pendingInteractionOf,
+  pendingCardOf,
+};

package/lib/mobile/session-send.js

@@ -283,25 +283,25 @@ async function handleSessionAttachment(ctx, req, res) {
     || typeof body.attachmentId !== 'string' || !body.attachmentId) {
     return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { sessionId, attachmentId }' } });
   }
-  // 直读宿主附件库（2026-10-31）：登记过的 id 直接从本地盘流给手机，省掉「等宿主把整张
-  // 读成 base64 再返回」那一段（宿主主线程忙时手机会一个字节都收不到）。前提与回退见
-  // `attachment-store.js` 的 `streamIfRemembered`：不满足就往下走原来的宿主接口。
+  // 直读宿主附件库（2026-10-31）：登记过的 id 直接从本地盘流给手机，省掉「等宿主把整张读成
+  // base64 再返回」那段（宿主主线程忙时手机一个字节都收不到）。回退见 `streamIfRemembered`。
   if (body.raw === true && await attachmentStore.streamIfRemembered(req, res, body.sessionId, body.attachmentId)) return;
-  const { value, error } = unwrap(await callSessions(ctx, 'attachment', { sessionId: body.sessionId, attachmentId: body.attachmentId }));
+  // 要递一份**和盘上字节对得上**的引用：宿主会逐字段比对类型 / 字节数 / 宽高，占位值会被
+  // 挡回 `Stored attachment metadata does not match its reference.`。拼不出来（对象不在）回 404。
+  const ref = attachmentStore.refFor(body.sessionId, body.attachmentId);
+  if (!ref) return sendJson(res, 404, { ok: false, error: { code: 'not-found', message: '附件已不可读' } });
+  const { value, error } = unwrap(await callSessions(ctx, 'attachment', { sessionId: body.sessionId, attachment: ref }));
   if (error) return sendJson(res, 400, { ok: false, error });
   const data = value && typeof value.data === 'string' ? value.data : '';
-  // 附件已被会话清理掉时宿主回的是空字节：这不是「稍后再试就好」，如实回 404，
-  // 让 App 那边把重试按钮的失败说清楚，而不是转圈到超时。
+  // 宿主回空字节＝附件已被会话清理掉：如实回 404，别让 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 不出这台电脑。
-  // `raw: true` = 要原始字节，不要 base64（2026-10-30）。宿主给的仍是 base64，这里解成
-  // Buffer 后按分块信封流出去：手机那边落盘的是密文，靠原生解盘口边解边写，整张图的
-  // base64 不进 JS 堆 —— 一张两兆的截图在手机上原本要摊着两兆七的字符串加一份解析副本。
-  // **不封包不许走这一档**：那就成了明文传输，正好把这条路本来的意义抹掉，如实回 400。
+  // `dims: true` = 只要原始宽高，不要字节：老会话里宿主没存宽高，手机得先按兜底盒占位、等字节
+  // 到了再变高（那一行一跳，上面整截就被推走）。回给它的只有两格数字，base64 不出这台电脑。
+  // `raw: true` = 要原始字节（2026-10-30）：宿主给的仍是 base64，这里解成 Buffer 后按分块信封
+  // 流出去，手机那边靠原生解盘口边解边写，整张图的 base64 不进 JS 堆。
+  // **不封包不许走这一档**：那就成了明文传输，如实回 400。
   if (body.raw === true) {
     const opened = req && req.__dshE2ee;
     if (!opened || !opened.keys || !opened.req) {

package/lib/mobile/stats-ledger.cjs

@@ -170,11 +170,25 @@ function addDays(day, delta) {
 /** 范围起点（含）；`all` 返回 null，表示不设下限。 */
 function startDayOf(range, now) {
   const today = dayKeyOf(now);
+  if (range === 'today') return today;
+  if (range === 'yesterday') return addDays(today, -1);
+  if (range === '3d') return addDays(today, -2);
   if (range === '7d') return addDays(today, -6);
   if (range === '30d') return addDays(today, -29);
   return null;
 }
 
+/**
+ * 范围终点（含）：只有「昨天」不看今天。
+ *
+ * 逐日补零、合计、`usageInRange` 都走它。单看昨天却把今天的量算进去，是这一档最容易错的
+ * 地方 —— 用户多半正是用着这台机器的时候打开统计页。
+ */
+function endDayOf(range, now) {
+  const today = dayKeyOf(now);
+  return range === 'yesterday' ? addDays(today, -1) : today;
+}
+
 /**
  * `YYYY-MM-DD` → 那天本地零点的毫秒数。
  *
@@ -501,18 +515,18 @@ function moneyOf(value) {
 }
 
 /**
- * 一条会话在 [startDay, today] 里的用量。
+ * 一条会话在 [startDay, endDay] 里的用量。
  *
  * `startDay` 为 null（`all`）时直接用记录里的累计值 —— 累计值是权威，而它那份按天用量
  * 只保留最近 `MAX_DAILY_DAYS` 天。
  */
-function usageInRange(record, startDay, today) {
+function usageInRange(record, startDay, endDay) {
   const billed = record.billed || emptyUsage();
   if (!startDay) return sanitizeUsage(billed);
   const usage = emptyUsage();
   const daily = record.daily || {};
   for (const [day, value] of Object.entries(daily)) {
-    if (day < startDay || day > today) continue;
+    if (day < startDay || day > endDay) continue;
     for (const key of USAGE_KEYS) usage[key] += num(value[key]);
   }
   return usage;
@@ -529,6 +543,7 @@ function usageInRange(record, startDay, today) {
 function summarize(ledger, range, now) {
   const today = dayKeyOf(now);
   const startDay = startDayOf(range, now);
+  const endDay = endDayOf(range, now);
   const allDays = Object.keys(ledger.days).sort();
   const firstDay = startDay || allDays[0] || today;
 
@@ -544,7 +559,7 @@ function summarize(ledger, range, now) {
       requests: num(source.requests),
       turns: num(source.turns),
     });
-    if (cursor >= today) break;
+    if (cursor >= endDay) break;
   }
 
   const kpi = {
@@ -589,7 +604,7 @@ function summarize(ledger, range, now) {
   let composition = null;
   let compositionSession = null;
   for (const [sessionId, record] of Object.entries(ledger.sessions)) {
-    const usage = usageInRange(record, startDay, today);
+    const usage = usageInRange(record, startDay, endDay);
     if (record.composition && num(record.lastAt) > num(compositionSession && compositionSession.lastAt)) {
       composition = {
         systemTokens: num(record.composition.systemTokens),
@@ -643,7 +658,7 @@ function summarize(ledger, range, now) {
   let costPricedRows = 0;
   for (const bucket of Object.values(ledger.models || {})) {
     if (!bucket || typeof bucket !== 'object') continue;
-    const usage = usageInRange(bucket, startDay, today);
+    const usage = usageInRange(bucket, startDay, endDay);
     const billedTokens = billedOf(usage);
     const turns = num(usage.turns);
     // 与卡片同一条规矩：范围内一个 token、一轮都没有的组合不上卡。

package/lib/mobile/stats.js

@@ -1,21 +1,25 @@
 'use strict';
 
 /**
- * GET /api/mobile/v1/stats/overview?range=7d|30d|all[&fresh=1]（token）
+ * GET /api/mobile/v1/stats/overview?range=today|yesterday|3d|7d|30d|all[&fresh=1]（token）
  *
  * 统计页的唯一接口：先采一轮（水位差记账），再把账本按范围折算成页面要的那份。
  *
  * 采集失败**不**让整页报错：账本里已有的数字照样是真的，宁可让用户看到一份偏旧的统计，
  * 也不要为了「这次没采上」把整页变成错误页。要重新采就用 `fresh=1`（下拉刷新那条）。
  *
- * 范围词只有三档，别的值一律按 `7d`：多一档就要在页面和这里各维护一份日历口径。
+ * 范围词是 App 与这里共用的一份词汇表（`app/src/types/stats.ts` 的 `StatsRange`）：
+ * 「今天 / 昨天」是单天窗口，`3d` / `7d` / `30d` 是含今天往前数的天窗，`all` 不设下限。
+ * 日历口径只有 `stats-ledger.cjs` 的 `startDayOf` / `endDayOf` 一份，App 不自己算。
+ * 认不出来的词一律按 `7d`（老 App 照旧发那三档）；**新范围词遇到老插件就会落到这一条**，
+ * 所以 App 拿回包里的 `range` 与请求的对不对得上当作「插件较旧」的判据（见 A2-60）。
  */
 
 const { sendJson } = require('../http/routing.js');
 const { collectStats, DEFAULT_BUDGET_MS } = require('./stats-collect.cjs');
 const ledger = require('./stats-ledger.cjs');
 
-const RANGES = new Set(['7d', '30d', 'all']);
+const RANGES = new Set(['today', 'yesterday', '3d', '7d', '30d', 'all']);
 
 function normalizeRange(value) {
   return typeof value === 'string' && RANGES.has(value) ? value : '7d';