dsh-mini-remote 0.1.8 → 0.2.0

package/lib/session-meta-cache.js

@@ -0,0 +1,100 @@
+/**
+ * 导航用的会话元数据缓存。
+ *
+ * 这里只保存 sessionQuery.listSessions() 返回记录中的 header 和两个可用性标志，
+ * 不保存会话正文。用途是让 DSH 重启后导航可以先显示上次已知的工作区关系，
+ * 再由后台完整扫描校正。
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+const DEFAULT_TTL_MS = 30 * 24 * 60 * 60 * 1000
+const DEFAULT_MAX = 10_000
+
+function validRecord(row) {
+  return Boolean(
+    row && typeof row === 'object'
+      && row.header && typeof row.header.id === 'string' && row.header.id
+      && Number.isFinite(row.header.createdAt),
+  )
+}
+
+export function createSessionMetaCache({
+  file, ttl = DEFAULT_TTL_MS, max = DEFAULT_MAX, debounceMs = 500, now = Date.now,
+}) {
+  const rows = new Map()
+  try {
+    const raw = JSON.parse(readFileSync(file, 'utf8'))
+    const at = now()
+    for (const row of Array.isArray(raw) ? raw : Object.values(raw ?? {})) {
+      if (!validRecord(row) || typeof row.at !== 'number' || at - row.at > ttl) continue
+      rows.set(row.header.id, { ...row, 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([...rows.values()]))
+      renameSync(tmp, file)
+    } catch {
+      // 缓存写失败只影响下次冷启动，不影响当前导航。
+    }
+  }
+  function schedule() {
+    dirty = true
+    if (timer) return
+    timer = setTimeout(save, debounceMs)
+    timer.unref?.()
+  }
+
+  return {
+    all() {
+      const at = now()
+      return [...rows.values()]
+        .filter((row) => at - row.at <= ttl)
+        .map(({ at: _at, ...row }) => row)
+    },
+
+    replace(records) {
+      rows.clear()
+      const at = now()
+      for (const record of records ?? []) {
+        if (!validRecord(record)) continue
+        rows.set(record.header.id, {
+          header: record.header,
+          live: Boolean(record.live),
+          persisted: Boolean(record.persisted),
+          at,
+        })
+      }
+      while (rows.size > max) rows.delete(rows.keys().next().value)
+      schedule()
+    },
+
+    upsert(record) {
+      if (!validRecord(record)) return
+      rows.set(record.header.id, {
+        header: record.header,
+        live: Boolean(record.live),
+        persisted: Boolean(record.persisted),
+        at: now(),
+      })
+      while (rows.size > max) rows.delete(rows.keys().next().value)
+      schedule()
+    },
+
+    clear() {
+      rows.clear()
+      schedule()
+    },
+  }
+}

package/lib/store.js

@@ -6,6 +6,12 @@
  */
 import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs'
 import { join, dirname } from 'node:path'
+import {
+  applyTrajectoryPatch,
+  capTrajectory,
+  mergeTrajectory,
+  TRAJECTORY_MAX_ENTRIES,
+} from './trajectory.js'
 
 export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
   const state = {
@@ -21,6 +27,18 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
     historyBySession: {}, // sessionId -> [{ role, text, timestamp, sessionId }]
     /** 手机当前遥控的那个会话。 */
     boundSessionId: null,
+    /**
+     * 「进阶设置（电脑端界面）」的开关。**默认关**。
+     *
+     * 为什么默认关：打开它 = 把这个令牌的权限**从「我们那张手机页暴露的那点事」
+     * 扩到整个电脑端设置面**（模型配置、凭据页、插件装卸、会话记录……）。
+     * 那是能力的大幅扩张，不该在用户不知情的时候发生——所以要他自己开，
+     * 而且界面上会把后果写清楚。
+     *
+     * 关着的时候那条代理路由**根本不存在**（见 server.js 里的判断），
+     * 不是「前端藏起来、后端还开着」。
+     */
+    mirrorEnabled: false,
     /** 手机会话在线状态，用于决定要不要发外部推送。 */
     presence: 'foreground',
     lastSeen: 0,
@@ -41,6 +59,24 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
      * 所以刷新页面看到的是「当前这一句」，而不是上一次的残留。
      */
     thoughtBySession: {},
+    /**
+     * 执行轨迹（「完整」模式里那一块过程）：sessionId ->
+     * `{ entries, turns, currentTurn, patches, dropped, seq }`。**故意不落盘**。
+     *
+     * 为什么连它一起不落盘（照 liveBySession 的理由，但这里更硬）：实测轨迹正文是
+     * 回答正文的 90.7 倍（单轮最高约 946KB），而落盘那份是**每 500 毫秒重写整份 JSON**。
+     * 灌进去等于每半秒重写一遍几兆的文件。它本来就是「刚发生的过程」，重启后从会话记录里
+     * 重放即可（见 lib/index.js 读历史那一段），聊天记录才是要留的那份。
+     *
+     * - `entries`：扁平的条目数组，每条自带 turn/step；上限 TRAJECTORY_MAX_ENTRIES 条，从尾部留。
+     * - `turns`：轮号 -> { state, reason }，只留「还有条目的轮」和「当前这一轮」。
+     * - `patches`：没认领到的补丁（插件中途起来时，那次调用的 tool/call 没亲眼看见，
+     *   但结果看见了）。少了它，手机上的那一行会一直停在「正在跑」。
+     * - `seq`：这个会话的帧序号，客户端靠它认出「我漏了几帧」。
+     */
+    trajectoryBySession: {},
+    /** 当前父会话名下正在运行的子智能体：parentId -> childId -> true。只在内存中。 */
+    subagentRunningBySession: {},
   }
 
   /** 已知会话的元信息：sessionId -> { id, title, running, lastActivity, seq } */
@@ -99,6 +135,11 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
    * （`sessionQuery.readSession`），而 store 拿不到 ctx，所以由插件注入一个回调。
    * 回调返回 `{ entries, latest, pending }`；没读过这个会话时返回 null。
    *
+   * **同一份记录里还带着执行轨迹**（`trajectory` / `trajectoryDropped`）：轨迹和聊天记录
+   * 是同一批原始事件的两面，读一次日志顺手把两面都重放出来，别为它再读一遍盘。
+   * 轨迹那份**已经在插件那边按上限截过**（120 条）再放这儿，否则 20 个会话的缓存
+   * 会各压着几兆。
+   *
    * **为什么不把读出来的历史塞进 `state.historyBySession`**：那一份是要落盘的，
    * 而且是 500 毫秒写一次整个 JSON。几百条历史灌进去，等于每半秒重写一遍几百 KB
    * 的文件。所以完整历史只活在内存里，落盘的仍然是「插件亲眼看过的事件」。
@@ -190,6 +231,92 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
     return t ? { text: t.text, at: t.at } : null
   }
 
+  /**
+   * 「当前这一轮」的哨兵。用 Symbol 而不是 null：`turn` 本身可能是 null
+   * （事件里没带轮号），拿 null 当哨兵就分不清「还没轮到过」和「这一轮没有轮号」。
+   */
+  const NO_TURN = Symbol('no-turn')
+
+  /** 轨迹缓冲的那一格。第一次碰到才建，删会话时一起丢。 */
+  function trajectorySlot(sessionId) {
+    let buf = state.trajectoryBySession[sessionId]
+    if (!buf) {
+      buf = state.trajectoryBySession[sessionId] = {
+        entries: [],
+        turns: new Map(),
+        currentTurn: NO_TURN,
+        patches: new Map(),
+        dropped: 0,
+        seq: 0,
+      }
+    }
+    return buf
+  }
+
+  /**
+   * 轨迹缓冲也按会话数收着点：插件会看到**所有**主会话的事件，不设上限的话，
+   * 一个跑了几十上百个会话的晚上就是几十份几 MB 的条目压在内存里。
+   * 丢掉的是「没在看的那些会话」刚发生的那一段——老的都在会话记录里（重放那条路），
+   * 手机切过去照样能拉出来。
+   */
+  function trimTrajectory(keepId) {
+    const ids = Object.keys(state.trajectoryBySession)
+    if (ids.length <= maxSessions) return
+    ids.sort((a, b) => (sessions.get(b)?.seq ?? 0) - (sessions.get(a)?.seq ?? 0))
+    for (const id of ids.slice(maxSessions)) {
+      if (id === keepId) continue
+      delete state.trajectoryBySession[id]
+    }
+  }
+
+  /** 找那条条目（结果总是紧跟着它的调用回来，所以从后往前找）。 */
+  function trajectoryEntryOf(buf, id) {
+    for (let i = buf.entries.length - 1; i >= 0; i -= 1) {
+      if (buf.entries[i]?.id === id) return buf.entries[i]
+    }
+    return null
+  }
+
+  /**
+   * 轮状态表只留「还有条目的轮」+「当前这一轮」。
+   * 不留的话，一个长会话跑几百轮就攒几百个 key；而当前这一轮哪怕一条条目都还没有
+   * （turn/start 刚到）也得留——手机靠它把那一组先立起来。
+   */
+  function pruneTrajectoryTurns(buf) {
+    if (!buf.turns.size) return
+    const live = new Set(buf.entries.map((e) => e.turn))
+    for (const turn of [...buf.turns.keys()]) {
+      if (live.has(turn) || turn === buf.currentTurn) continue
+      buf.turns.delete(turn)
+    }
+  }
+
+  /** 内存那份轨迹按轮分组（形状和重放那份、和增量帧要的形状一样）。 */
+  function liveTrajectoryTurns(buf) {
+    const out = []
+    const byTurn = new Map()
+    for (const entry of buf.entries) {
+      let group = byTurn.get(entry.turn)
+      if (!group) {
+        const st = buf.turns.get(entry.turn)
+        group = {
+          turn: entry.turn,
+          state: st?.state ?? 'running',
+          reason: st?.reason ?? null,
+          entries: [],
+        }
+        byTurn.set(entry.turn, group)
+        out.push(group)
+      }
+      group.entries.push(entry)
+    }
+    for (const [turn, st] of buf.turns) {
+      if (byTurn.has(turn)) continue
+      out.push({ turn, state: st.state, reason: st.reason ?? null, entries: [] })
+    }
+    return out
+  }
+
   /**
    * 只保留最近碰过的若干会话的数据，免得这个 JSON 文件无限长大。
    * 被丢掉的会话切过去会显示「还没有回复」——**这比显示别人的回答强**。
@@ -203,6 +330,7 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       delete state.latestBySession[id]
       delete state.liveBySession[id]
       delete state.thoughtBySession[id]
+      delete state.trajectoryBySession[id]
     }
   }
 
@@ -237,6 +365,9 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
           }
         }
         if (raw.boundSessionId) state.boundSessionId = raw.boundSessionId
+        // 进阶模式：**只有明确是 true 才算开**。缺失、损坏、写成别的值一律当关——
+        // 这个开关关系到权限大小，读不出来时必须往「关」那边倒。
+        if (raw.mirrorEnabled === true) state.mirrorEnabled = true
       }
     } catch {
       // 首次运行没有文件，或文件损坏——都不该让插件起不来。
@@ -256,6 +387,7 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
           latestBySession: state.latestBySession,
           historyBySession: state.historyBySession,
           boundSessionId: state.boundSessionId,
+          mirrorEnabled: state.mirrorEnabled,
         }))
         renameSync(tmp, file)
       } catch {
@@ -291,6 +423,40 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       s.running = running
     },
 
+    /**
+     * 开/关「进阶设置（电脑端界面）」。**立即落盘**，不等那 500 毫秒的合并写。
+     *
+     * 为什么破例：这是个权限开关。用户开了之后马上就会去点那个入口，
+     * 万一这中间进程没了，重启后应当还是他最后选的那个状态——
+     * 合并写那 500 毫秒的窗口在这里不值得省。
+     */
+    setMirrorEnabled(enabled) {
+      state.mirrorEnabled = enabled === true
+      try {
+        mkdirSync(dirname(file), { recursive: true })
+        const tmp = `${file}.tmp`
+        writeFileSync(tmp, JSON.stringify({
+          latestBySession: state.latestBySession,
+          historyBySession: state.historyBySession,
+          boundSessionId: state.boundSessionId,
+          mirrorEnabled: state.mirrorEnabled,
+        }))
+        renameSync(tmp, file)
+      } catch {
+        // 落盘失败不影响本次运行——内存里那个值照常生效。
+      }
+      return state.mirrorEnabled
+    },
+
+    setSubagentRunning(parentSessionId, childSessionId, running) {
+      if (!parentSessionId || !childSessionId) return
+      const group = state.subagentRunningBySession[parentSessionId]
+        ?? (state.subagentRunningBySession[parentSessionId] = {})
+      if (running) group[childSessionId] = true
+      else delete group[childSessionId]
+      if (!Object.keys(group).length) delete state.subagentRunningBySession[parentSessionId]
+    },
+
     /** 最近活跃的会话——手机没绑定时默认遥控它。 */
     mostRecentSession,
 
@@ -318,7 +484,7 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
      * interrupted 是「这一轮被中止了，下面只是已经吐出来的那半句」。
      * 手机要把它标出来——不标的话，按了停止之后冒出来的半句话看着像模型答崩了。
      */
-    pushReply({ text, sessionId, reason, interrupted, timestamp }) {
+    pushReply({ text, sessionId, reason, interrupted, timestamp, turn }) {
       // 同上：事件带过来的 `time` 优先。合成时两边的钟不一样，同一条回复就会
       // 既从硬盘来一遍、又从手里这份来一遍，手机上显示两遍。
       const at = timestamp ?? Date.now()
@@ -329,12 +495,14 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       }
       pushHistory(sessionId, {
         role: 'assistant', text, timestamp: at, sessionId, interrupted: interrupted === true,
+        // 这条回复是第几轮的——完整模式把轨迹块插回对话原位要用（见 lib/history.js）。
+        turn: turn ?? null,
       })
       persist()
     },
 
     /** 用户（手机上或电脑上）发出了一条指令。 */
-    pushUser({ text, sessionId, id, timestamp }) {
+    pushUser({ text, sessionId, id, timestamp, turn }) {
       // id 要留着：排队中的指令靠它和 agent 收件箱里的那一条对上号，
       // 界面上才能标出「这条还在排队」、也才能撤掉它。
       //
@@ -344,6 +512,9 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       // 同一条指令显示两遍（2026-09-27 用户实机报的，实测两份差 1 毫秒）。
       pushHistory(sessionId, {
         role: 'user', text, timestamp: timestamp ?? Date.now(), sessionId, id,
+        // 第几轮的指令——完整模式把轨迹块插回对话原位要用。手机自己发的那条
+        // （onInstruction 那路）发出去时轮还没开，轮号留空即可。
+        turn: turn ?? null,
       })
       persist()
     },
@@ -358,7 +529,7 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
      * 时间戳同样用事件自己的 `time`：硬盘重放出来那份（lib/history.js 里的 notice）
      * 用的也是它，两边同一个钟才合成得成一条，而不是显示两遍。
      */
-    pushNotice({ sessionId, text, summary, senderSessionId, timestamp }) {
+    pushNotice({ sessionId, text, summary, senderSessionId, timestamp, turn }) {
       pushHistory(sessionId, {
         role: 'notice',
         text,
@@ -366,6 +537,7 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
         senderSessionId: senderSessionId ?? '',
         timestamp: timestamp ?? Date.now(),
         sessionId,
+        turn: turn ?? null,
       })
       persist()
     },
@@ -460,6 +632,101 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       return state.presence === 'foreground' && Date.now() - state.lastSeen < 60_000
     },
 
+    /**
+     * 实时轨迹来了一批变化：落进内存缓冲，并给出**这一批的增量帧**。
+     *
+     * 为什么是增量而不是整份：实测轨迹正文是回答正文的 90.7 倍（单轮最高约 946KB），
+     * 每来一次工具事件就把一整份重新发一遍（现在的 state 快照就是这么发的），
+     * 手机上会被压垮、隧道里流量也不可接受。所以这里只回「新加的那几条 + 改了的那几笔」。
+     *
+     * **不 persist()**：理由见 state.trajectoryBySession 那段。
+     *
+     * @returns {null|{turn:number|null, state:string|null, reason:string|null, seq:number,
+     *                 add:Array<object>, update:Array<object>}} null = 什么都没变，不必推
+     */
+    applyTrajectory(sessionId, change) {
+      if (!sessionId || !change) return null
+      const entries = Array.isArray(change.entries) ? change.entries : []
+      const updates = Array.isArray(change.updates) ? change.updates : []
+      const turnState = typeof change.state === 'string' && change.state ? change.state : null
+      if (!entries.length && !updates.length && !turnState) return null
+
+      const buf = trajectorySlot(sessionId)
+      for (const entry of entries) buf.entries.push(entry)
+      for (const patch of updates) {
+        if (!patch?.id) continue
+        const hit = trajectoryEntryOf(buf, patch.id)
+        if (hit) applyTrajectoryPatch(hit, patch)
+        // 没认领到就先存着（见 state.trajectoryBySession 里 patches 那条）：
+        // 插件可能是中途起来的——那次调用的 tool/call 没亲眼看见，结果却看见了。
+        // 直接丢掉的话，手机上那一行会一直停在「正在跑」。
+        else buf.patches.set(patch.id, { ...(buf.patches.get(patch.id) ?? {}), ...patch })
+      }
+      while (buf.patches.size > TRAJECTORY_MAX_ENTRIES) {
+        buf.patches.delete(buf.patches.keys().next().value)
+      }
+      if (turnState) {
+        buf.turns.set(change.turn, { state: turnState, reason: change.reason ?? null })
+        buf.currentTurn = change.turn
+      }
+      // 从尾部留：手机上看的是刚发生的过程，最早的先走。
+      if (buf.entries.length > TRAJECTORY_MAX_ENTRIES) {
+        const cut = buf.entries.length - TRAJECTORY_MAX_ENTRIES
+        buf.entries.splice(0, cut)
+        buf.dropped += cut
+      }
+      pruneTrajectoryTurns(buf)
+      trimTrajectory(sessionId)
+      buf.seq += 1
+
+      return {
+        turn: change.turn ?? null,
+        state: turnState,
+        reason: turnState ? (change.reason ?? null) : null,
+        seq: buf.seq,
+        add: entries,
+        update: updates,
+      }
+    },
+
+    /**
+     * 这个会话的轨迹视图：内存那份（刚发生的）+ 会话记录里重放出来的那份（更完整的），
+     * 按 id 合成一组一轮。上限 120 条、从尾部留；「这不是全部」由 truncated/note 说出去。
+     *
+     * 条目是**副本**：GET 接口会往上贴那些没认领到的补丁，不能回头污染重放缓存。
+     * 序列号 `seq` 和帧里那个是同一个（客户端据此认出「我漏了几帧」）。
+     */
+    trajectoryOf(sessionId) {
+      const buf = sessionId ? state.trajectoryBySession[sessionId] : null
+      const replay = sessionId && replaySource ? replaySource(sessionId) : null
+      const merged = mergeTrajectory(
+        buf ? liveTrajectoryTurns(buf) : [],
+        replay?.trajectory ?? null,
+      )
+      if (buf?.patches.size) {
+        for (const group of merged) {
+          for (const entry of group.entries ?? []) {
+            const patch = buf.patches.get(entry.id)
+            if (patch) applyTrajectoryPatch(entry, patch)
+          }
+        }
+      }
+      const capped = capTrajectory(merged, TRAJECTORY_MAX_ENTRIES)
+      const cut = capped.dropped > 0
+        || (buf?.dropped ?? 0) > 0
+        || (replay?.trajectoryDropped ?? 0) > 0
+      return {
+        sessionId: sessionId ?? null,
+        seq: buf?.seq ?? 0,
+        turns: capped.turns,
+        truncated: cut,
+        note: cut ? `轨迹只显示最近一段（读取上限：${TRAJECTORY_MAX_ENTRIES} 条）` : null,
+        // 读会话记录是后台动作：手机切到「完整」模式那一刻可能还没读完。
+        // 空了要说「正在读」，不能让人以为这个会话没有过程。
+        loading: replay?.pending === true && !buf,
+      }
+    },
+
     snapshot() {
       const target = targetSessionId()
       // 内存里记着的那一份（插件在场时看见的）
@@ -529,6 +796,9 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
          * 每次现读，不缓存：见 setQueueSource 的说明。
          */
         queued: target ? queueSource(target) : [],
+        subagentsRunning: Boolean(
+          target && Object.keys(state.subagentRunningBySession[target] ?? {}).length,
+        ),
         // 同毫秒时用 seq 兜底，顺序才是确定的
         sessions: [...sessions.values()].sort(
           (a, b) => (b.lastActivity - a.lastActivity) || (b.seq - a.seq),

package/lib/subagent-cache.js

@@ -0,0 +1,63 @@
+/** 子代理结构清单缓存：只存 id、父级、类型和名称，不存运行记录或正文。 */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+const TTL_MS = 7 * 24 * 60 * 60 * 1000
+
+export function createSubagentCache({ file, ttl = TTL_MS, debounceMs = 500, now = Date.now }) {
+  const rows = new Map()
+  try {
+    const raw = JSON.parse(readFileSync(file, 'utf8'))
+    const at = now()
+    for (const [parentId, row] of Object.entries(raw ?? {})) {
+      if (!row || typeof row.at !== 'number' || at - row.at > ttl || !Array.isArray(row.subagents)) continue
+      rows.set(parentId, { subagents: row.subagents, 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`
+      const raw = {}
+      for (const [parentId, row] of rows) raw[parentId] = row
+      writeFileSync(tmp, JSON.stringify(raw))
+      renameSync(tmp, file)
+    } catch {
+      // 缓存写失败不影响当前运行。
+    }
+  }
+  function schedule() {
+    dirty = true
+    if (timer) return
+    timer = setTimeout(save, debounceMs)
+    timer.unref?.()
+  }
+
+  return {
+    get(parentId) {
+      const row = rows.get(parentId)
+      if (!row) return null
+      if (now() - row.at > ttl) {
+        rows.delete(parentId)
+        return null
+      }
+      return row.subagents.map((item) => ({ ...item }))
+    },
+    set(parentId, subagents) {
+      if (!parentId || !Array.isArray(subagents)) return
+      rows.set(parentId, { subagents: subagents.map((item) => ({ ...item })), at: now() })
+      schedule()
+    },
+    delete(parentId) {
+      if (rows.delete(parentId)) schedule()
+    },
+  }
+}