dsh-mini-remote 0.1.4 → 0.1.6

package/lib/page.js

@@ -4,13 +4,15 @@
  * 页面之所以放独立 .html 而不是塞进 JS 模板字符串：省掉满屏的反引号和 ${} 转义，
  * 编辑器也能正常高亮。对外仍然是一个文件。
  */
-import { readFileSync } from 'node:fs'
+import { readFileSync, statSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
+import { dirname, extname, isAbsolute, join } from 'node:path'
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const PAGE_PATH = join(HERE, 'page.html')
 const ART_DIR = join(HERE, 'art')
+// 插件就在仓库里，`lib/` 的上一级即项目根——正文里写相对路径（如 dsh-image-gen/a.png）时按它找。
+const PROJECT_ROOT = join(HERE, '..')
 
 let template = null
 
@@ -45,6 +47,45 @@ export function readArt(name) {
   }
 }
 
+/** 这条通道只发图片：扩展名决定 Content-Type，也决定放不放行。别的类型一概不发。 */
+const IMAGE_TYPES = {
+  '.webp': 'image/webp',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+}
+
+const IMAGE_MAX = 20 * 1024 * 1024
+
+/**
+ * 读正文里直接写了一张图的位置时要发的那张图（`![](dsh-image-gen/a.png)` 这种）。
+ *
+ * 和立绘不一样，这条路上**没有文件名白名单**——正文里写的可以是电脑上任何一张图。
+ * 卡的是两点：**只发图片类型**（不然这条通道就成了读文件的口子），以及**体积**。
+ * 路径原样按系统解析；相对路径先试项目根、再试 lib/art，都没有就当读不到。
+ *
+ * 2026-09-28 之前这里只认"把图拷进 lib/art 并写裸名字"一种写法，正文里写全路径就成了
+ * 破图标——用户第三次为此来问，这是那时的放宽。
+ */
+export function readImage(raw) {
+  if (typeof raw !== 'string') return null
+  const p = raw.trim()
+  if (!p || p.length > 4096 || p.includes('\0')) return null
+  const type = IMAGE_TYPES[extname(p).toLowerCase()]
+  if (!type) return null
+  const candidates = isAbsolute(p) ? [p] : [p, join(PROJECT_ROOT, p), join(ART_DIR, p)]
+  for (const file of candidates) {
+    try {
+      if (statSync(file).size > IMAGE_MAX) continue
+      return { buf: readFileSync(file), type }
+    } catch {
+      // 这个位置没有，试下一个。
+    }
+  }
+  return null
+}
+
 const SW_PATH = join(HERE, 'sw.js')
 
 let sw = null

package/lib/server.js

@@ -13,7 +13,7 @@
  */
 import { createServer } from 'node:http'
 import { timingSafeEqual } from 'node:crypto'
-import { renderPage, readArt, readSw } from './page.js'
+import { renderPage, readArt, readImage, readSw } from './page.js'
 
 const COOKIE = 'dsh_mini_token'
 
@@ -218,9 +218,23 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
   const waitingQuestions = new Map()
   let questionSeq = 0
 
-  /** 手机上有没有人在看。**这就是「手机还在不在」那条判据**，不倒计时。 */
+  /**
+   * 手机上有没有人在看。**这就是「手机还在不在」那条判据**，不倒计时。
+   *
+   * **不能只看此刻连着几个。** 手机这一端会来回断（锁屏、切网、页面重连），
+   * 2026-09-27 的日志里一分钟能连断几十次；审批恰好落在断开的那一瞬，就被判成
+   * "手机不在"，于是让给了电脑——用户看到的就是"手机上什么都没弹"（他报的正是这个）。
+   * 所以判据改成"此刻连着，**或者最近这段时间露过面**"，让抖动不再决定归属。
+   * 露面有两个信号：SSE 连着（clients），或者最近来过一次带凭据的请求（notePhoneSeen）。
+   * 窗口给 20 秒：够跨过抖动，又不至于让"真的锁屏很久"的手机一直霸着审批。
+   */
+  const PHONE_GRACE_MS = 20000
+  let phoneSeenAt = 0
+  function notePhoneSeen() {
+    phoneSeenAt = Date.now()
+  }
   function hasPhone() {
-    return clients.size > 0
+    return clients.size > 0 || (phoneSeenAt > 0 && Date.now() - phoneSeenAt < PHONE_GRACE_MS)
   }
 
   /**
@@ -243,7 +257,7 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       // 用户选的是「一直等，不还回电脑」——但那不等于「手机都没了还等」。
       // 手机一旦全断开（锁屏、关了页面、网断），立刻收摊还给电脑，否则会永远卡住。
       watch = setInterval(() => {
-        if (clients.size === 0) settle(null)
+        if (!hasPhone()) settle(null)
       }, 2000)
     })
   }
@@ -269,18 +283,90 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     }
   }
 
+  // ---- 手机上来拍板审批 --------------------------------------------------
+  //
+  // 和上面那一套是**同一个形状**（推一次、等、手机没了就还给电脑），所以刻意并排写、
+  // 守同样的规矩：清单和函数都留在这一层，不写进下面"每来一个请求执行一次"的地方
+  // （那种错 2026-09-27 犯过一次，见上面那段注释）。
+  // 唯一不同的是交回来的东西：提问交的是答案，审批交的是**结论**。
+  const waitingApprovals = new Map()
+  let approvalSeq = 0
+
+  /**
+   * 把一条命令确认推到手机上，等它拍板。
+   * @returns 'allowed-once' 或 'rejected'；手机没了返回 null，调用方据此还给电脑。
+   */
+  function askApproval(req, agentId, command) {
+    const id = 'a' + (++approvalSeq)
+    return new Promise((resolve) => {
+      let watch = null
+      const settle = (value) => {
+        if (!waitingApprovals.has(id)) return
+        waitingApprovals.delete(id)
+        if (watch) clearInterval(watch)
+        resolve(value)
+      }
+      // 推给手机的就是这几样：工具名 + 为什么来问我。**不带命令正文**——
+      // 正文要另外去取，而且那是用户自己的东西，不进日志也不进这条帧。
+      const view = {
+        id,
+        agentId,
+        toolName: typeof req?.toolName === 'string' && req.toolName ? req.toolName : '某个工具',
+        reason: typeof req?.reason === 'string' ? req.reason : '',
+        // 命令原文（取不到就是空串）。**只发给手机，不进日志。**
+        command: typeof command === 'string' ? command : '',
+      }
+      waitingApprovals.set(id, { settle, agentId, view })
+      broadcast('approval', view)
+      // 和提问同一条判据：**不倒计时，看手机还在不在**。全断开了就立刻收摊还给电脑。
+      watch = setInterval(() => {
+        if (!hasPhone()) settle(null)
+      }, 2000)
+    })
+  }
+
+  /** 把还在等的审批补发给**刚连上来的那一个**连接（同 replayQuestions 的理由）。 */
+  function replayApprovals(res) {
+    for (const [, entry] of waitingApprovals) {
+      try {
+        res.write(`event: approval\ndata: ${JSON.stringify(entry.view)}\n\n`)
+      } catch {
+        return
+      }
+    }
+  }
   // 把这两个能力放到插件够得着的固定位置（见文件上方 `miniControl` 的说明）。
   // 放在这里是因为它俩都已定义（函数声明本来也会提升），且不受下面那堆路由逻辑影响。
   miniControl.hasPhone = hasPhone
   miniControl.askPhone = askPhone
+  miniControl.askApproval = askApproval
 
+  /**
+   * 把 UA 和来源地址压成一句人看的：设备类型 + 地址。
+   *
+   * **为什么要它**：SSE 那两行日志原来只说"连上了/断开了"，一分钟几十次成对出现时，
+   * 分不清是手机在抖、还是电脑上另有一个 /mini 页面也在连（两个都开着就会这样）。
+   * 只取设备类型和地址，**不记 token，也不记整个 UA**——够定位就行，多余的不留。
+   */
+  function describeClient(ua, ip) {
+    const u = String(ua ?? '')
+    const kind = /iPhone|iPad/i.test(u) ? 'iOS'
+      : /Android/i.test(u) ? 'Android'
+      : /Windows/i.test(u) ? 'Windows'
+      : (u ? '其他' : '无 UA')
+    return kind + (ip ? '@' + String(ip).replace('::ffff:', '') : '')
+  }
   function isAuthorized(req, url) {
     const fromQuery = url.searchParams.get('token')
     const fromCookie = parseCookies(req.headers.cookie)[COOKIE]
     const fromHeader = req.headers['x-mini-token']
-    return tokenEquals(fromQuery, token)
+    const ok = tokenEquals(fromQuery, token)
       || tokenEquals(fromCookie, token)
       || tokenEquals(fromHeader, token)
+    // 手机每来一次请求都算"露过面"——这是「手机还在不在」的第二个信号。
+    // 只看 SSE 连接数会被抖动骗到（见 hasPhone 上面那段），请求时间戳稳得多。
+    if (ok) notePhoneSeen()
+    return ok
   }
 
   /** 这次请求到底有没有带凭据。没带只是没登录，不算试错。 */
@@ -379,6 +465,25 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         return
       }
       noteSuccess(req)
+      // 取图有两条路，都挂在这个前缀下：
+      //   ① /mini/art/<名字>.webp —— 立绘。名字受白名单限制，地址里带构建指纹，可以长缓存。
+      //   ② /mini/art/?p=<路径>   —— 正文里直接写了一张图在电脑上的位置（绝对路径，或相对
+      //      项目根）。只发图片类型，地址里没有指纹，所以不让浏览器缓存。
+      const wanted = url.searchParams.get('p')
+      if (wanted) {
+        const hit = readImage(wanted)
+        if (!hit) {
+          sendJson(res, 404, { error: 'not found' })
+          return
+        }
+        res.writeHead(200, {
+          'Content-Type': hit.type,
+          'Content-Length': hit.buf.length,
+          'Cache-Control': 'no-cache, no-transform',
+        })
+        res.end(hit.buf)
+        return
+      }
       const buf = readArt(path.slice('/mini/art/'.length))
       if (!buf) {
         sendJson(res, 404, { error: 'not found' })
@@ -451,7 +556,11 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       clients.add(res)
       // 留痕：手机连没连上、一共有几台，就看这一句。2026-09-27 测自言自语的这天
       // 正是卡在这儿——「她怎么没说话」和「手机压根没连上」当时根本分不开。
-      console.log(`[dsh-mini-remote] 手机连上了，现在连着 ${clients.size} 台`)
+      // 还要看**是谁**连的、**活了多久**：2026-09-27 日志里一分钟几十次成对出现，
+      // 当时分不清是手机自己抖，还是电脑上另开着一个 /mini 页面在连。
+      const who = describeClient(req.headers['user-agent'], req.socket?.remoteAddress)
+      const openedAt = Date.now()
+      console.log(`[dsh-mini-remote] 手机连上了，现在连着 ${clients.size} 台（${who}）`)
 
       const beat = setInterval(() => {
         try {
@@ -468,6 +577,7 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
 
       // 接着把还在等手机回答的题补给它——重连上来的那一下最容易错过（见 replayQuestions）。
       replayQuestions(res)
+      replayApprovals(res)
 
       // 顺带把这个会话的完整历史准备好：手机上「刷新一下就只剩重启之后的事」
       // 就是这么来的（手里那份只有插件在场时看见的）。读完会再广播一份快照。
@@ -480,7 +590,8 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         said = true
         clearInterval(beat)
         clients.delete(res)
-        console.log(`[dsh-mini-remote] 手机断开了，还剩 ${clients.size} 台`)
+        console.log(`[dsh-mini-remote] 手机断开了，还剩 ${clients.size} 台`
+          + `（${who}，活了 ${Date.now() - openedAt} ms）`)
       }
       req.on('close', cleanup)
       res.on('close', cleanup)
@@ -643,6 +754,17 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       // 现在问不到就如实给 null，怎么讲由界面决定，反正不编。
       const asked = nav.sessionModel ? await nav.sessionModel(boundSessionId) : { ok: false }
       const remembered = store.snapshot().sessions?.find((s) => s.id === boundSessionId) ?? null
+      /**
+       * 手机上要看「上下文用了多少」，这份是分子分母凑齐的一份。
+       *
+       * 第一来源是内存里那份：会话跑起来时每一步的 usage 都会刷新它，最鲜活。
+       * 内存里没有才问日志（`nav.sessionContext`）——**这一条是必须的**：窗口那条
+       * 事件一个会话只写一次，插件晚一步起来（重启过、或早就开着的会话）就永远
+       * 等不到它，光靠内存会一直空着，用户看到的就是「这个功能没了」
+       * （2026-09-28 用户报的）。日志里那份同样是 DSH 记下的事实，不是估的。
+       */
+      const context = remembered?.context
+        ?? (nav.sessionContext ? await nav.sessionContext(boundSessionId) : null)
       const current = asked.ok
         ? asked.model
         : (remembered && remembered.model
@@ -652,7 +774,14 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
                 reasoningEffort: remembered.reasoningEffort ?? null,
               }
             : null)
-      sendJson(res, 200, { ok: true, boundSessionId, current, ...result.catalog })
+      sendJson(res, 200, {
+        ok: true,
+        boundSessionId,
+        current,
+        // { used, window } 或 null。缺任一半就是 null，界面据此整段不显示——不编、不放占位符。
+        context,
+        ...result.catalog,
+      })
       return
     }
 
@@ -677,6 +806,28 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       return
     }
 
+    // ---- 手机上来拍板审批 ------------------------------------------------
+    // 交回来的东西和上面的答案不同：这里只要一个结论。措辞照 /mini/api/answer 那一支——
+    // 过期了如实说、格式不对就说格式不对，别装作收下了。
+    if (req.method === 'POST' && path === '/mini/api/approval') {
+      const body = await readBody(req)
+      const waiting = waitingApprovals.get(body?.id)
+      if (!waiting) {
+        console.log('[dsh-mini-remote] 手机上拍晚了：这条审批已经交回电脑（' + String(body?.id) + '），没接')
+        sendJson(res, 409, { ok: false, error: '这条审批已经结束了。' })
+        return
+      }
+      const decision = body?.decision === 'allow'
+        ? 'allowed-once'
+        : (body?.decision === 'deny' ? 'rejected' : null)
+      if (!decision) {
+        sendJson(res, 400, { ok: false, error: '审批的结论只有同意或拒绝两种。' })
+        return
+      }
+      waiting.settle(decision)
+      sendJson(res, 200, { ok: true })
+      return
+    }
     // ---- 目录浏览（挑工作区用）------------------------------------------
     // 只列目录，绝不列文件、绝不读内容。手机上要的是「挑一个文件夹」。
     if (req.method === 'GET' && path === '/mini/api/browse/roots') {

package/lib/title-cache.js

@@ -0,0 +1,122 @@
+/**
+ * 会话标题的落盘缓存。
+ *
+ * 为什么要有它：一批会话的标题要靠**加载整份会话日志**才折得出来（DSH 的
+ * readTitleSnapshots 就是逐个 load），本机 1419 个日志共 1.4 GB 全是 zstd 压缩，
+ * 冷读一条实测约 5 秒。lib/tree.js 里那份内存缓存只活到 DSH 这次运行结束——
+ * 重启就清零，那 1.4 GB 又得重付一遍。而标题这东西定下来基本不变，读过就该长期记住。
+ *
+ * 三条边界，一条都不能让插件起不来（这个插件的一贯做法是"少了哪样就关掉哪一块，
+ * 不整个倒下"）：
+ *   - 文件不在（第一次跑）：当空缓存；
+ *   - 文件坏了（半个 JSON、手改坏的）：当空缓存，下次写盘自然把它盖掉；
+ *   - 写盘写到一半被打断（断电、两个 DSH 实例并存）：先写临时文件再改名，
+ *     盘上要么是旧的那一份、要么是新的那一份，**永远不会是半截**。
+ *
+ * 存的是一个 sessionId → { title, at } 的平表：手机要的就是"这条会话叫什么"，
+ * 别的字段一概不留（会话本身的事实由 DSH 的清单负责，这里只补齐一个缺口）。
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+/**
+ * 标题记多久。
+ *
+ * 七天：够跨过绝大多数重启（用户不会天天重启 DSH），又不是"永远"——万一哪条会话
+ * 后来真的改了标题、而事件流又没让我们看见，过期之后还有机会从日志里重新读一次。
+ * 比内存缓存原来那 10 分钟长得多，因为**内存丢了还能重读，落盘丢了就是白读一遍**。
+ */
+export const TITLE_TTL_MS = 7 * 24 * 60 * 60 * 1000
+
+/**
+ * 盘上最多留多少条。本机 1419 个会话，留一倍余量；一条几十字节，满载也就一百多 KB。
+ * 超了按"最久没更新"淘汰——和内存那份同一套规矩，只是盘子更大。
+ */
+const MAX_ENTRIES = 3000
+
+/**
+ * 建一份标题的落盘缓存。读盘是**当场同步做一次**（小文件，不值得为它引入异步），
+ * 写盘合并到一次（`debounceMs` 之内反复 set 只写最后那一下）——
+ * 展开一个工作区可能一口气补上十几条标题，不合并就是十几次写盘。
+ */
+export function createTitleCache({
+  file, ttl = TITLE_TTL_MS, max = MAX_ENTRIES, debounceMs = 500, now = Date.now,
+}) {
+  /** sessionId -> { title, at }。顺序 = 最近更新的在后，淘汰时从最早的开始。 */
+  const rows = new Map()
+
+  /**
+   * 读盘。**任何异常都当"没有缓存"**：文件不在、不是 JSON、结构对不上、
+   * 单条字段坏掉——各自跳过，绝不让调用方拿到一个半死的东西。
+   */
+  try {
+    const raw = JSON.parse(readFileSync(file, 'utf8'))
+    if (raw && typeof raw === 'object') {
+      const at = now()
+      for (const [id, row] of Object.entries(raw)) {
+        if (!id || !row || typeof row.title !== 'string') continue
+        if (typeof row.at !== 'number' || at - row.at > ttl) continue
+        rows.set(id, { title: row.title, at: row.at })
+      }
+    }
+  } catch {
+    // 第一次跑没有这个文件；损坏了也走这条。两种情况都是"从空缓存重来"。
+  }
+
+  let timer = null
+  let dirty = false
+
+  function save() {
+    timer = null
+    if (!dirty) return
+    dirty = false
+    try {
+      mkdirSync(dirname(file), { recursive: true })
+      const tmp = `${file}.tmp`
+      writeFileSync(tmp, JSON.stringify(Object.fromEntries(rows)))
+      // 改名是原子的：中途死掉也只留下一个 .tmp，正主那份还是完整的。
+      renameSync(tmp, file)
+    } catch {
+      // 写不进去只影响"下次重启还得重读一遍"，不该影响这一次运行。
+    }
+  }
+
+  function schedule() {
+    dirty = true
+    if (timer) return
+    timer = setTimeout(save, debounceMs)
+    // 这个定时器不该拖着进程不让它退出（DSH 关停时也是）。
+    if (timer.unref) timer.unref()
+  }
+
+  return {
+    /** 盘上现有的全部条目（给内存缓存首次灌数据用）。过期的当没记过。 */
+    all: () => [...rows].filter(([, row]) => now() - row.at <= ttl),
+
+    /** 取一条。过期的当场丢掉——"没记过"和"记着是空标题"必须分得出来。 */
+    get(id) {
+      const row = rows.get(id)
+      if (!row) return null
+      if (now() - row.at > ttl) {
+        rows.delete(id)
+        return null
+      }
+      return row.title
+    },
+
+    /** 记一条。空标题也记（会话确实没有标题，没理由每次重读一遍）。 */
+    set(id, title) {
+      if (!id || typeof title !== 'string') return
+      rows.delete(id)
+      rows.set(id, { title, at: now() })
+      while (rows.size > max) rows.delete(rows.keys().next().value)
+      schedule()
+    },
+
+    /** 立刻写盘。平时走上面那个合并写；测试和收尾时用这个，省得干等。 */
+    flush() {
+      if (timer) clearTimeout(timer)
+      save()
+    },
+  }
+}