dsh-mini-remote 0.1.8 → 0.1.9

package/lib/page.js

@@ -19,7 +19,9 @@ let template = null
 export function renderPage({ defaultMode = 'minimal', needsToken = false, build = '', maxUpload = 0 } = {}) {
   if (template === null) template = readFileSync(PAGE_PATH, 'utf8')
   return template
-    .replace('__DEFAULT_MODE__', defaultMode === 'chat' ? 'chat' : 'minimal')
+    // 三种显示模式都认（单帧/聊天/完整）；不认识的值一律回落单帧——回落要卡在这一处，
+    // 各处自己挑认哪几个，迟早出现「存得进去、刷新就变回去」的对不上。
+    .replace('__DEFAULT_MODE__', ['chat', 'full'].includes(defaultMode) ? defaultMode : 'minimal')
     .replace('__NEEDS_TOKEN__', needsToken ? 'true' : 'false')
     // 立绘地址带上构建指纹（页面自己拼 ?v=__BUILD__），换了图浏览器就不会一直
     // 拿缓存里那张。只留字母数字，别让它有机会往 HTML 里塞东西。

package/lib/permissions.js

@@ -57,6 +57,7 @@ export const PRESET_LABELS = {
   'read-only': '仅可查看',
   'workspace-write': '工作区内修改',
   'danger-full-access': '完全权限',
+  'auto': '自动审查',
 }
 
 /**

package/lib/server.js

@@ -12,7 +12,7 @@
  *   - 只需要服务端→手机单向推送；手机发指令用普通 POST 即可
  */
 import { createServer } from 'node:http'
-import { timingSafeEqual } from 'node:crypto'
+import { randomBytes, timingSafeEqual } from 'node:crypto'
 import { renderPage, readArt, readImage, readSw } from './page.js'
 
 const COOKIE = 'dsh_mini_token'
@@ -170,17 +170,73 @@ export const miniControl = {
  * @param {(id:string)=>{ok:boolean, error?:string, sessionId?:string}} opts.onUnqueue
  * @param {() => (string|undefined)[]} [opts.imageRoots] 正文里相对路径图的额外候选根
  *        （由插件递进「当前已注册工作区的目录」，见 extraImageRoots 那段）
- * @returns {Promise<{port:number, addresses:string[], failed:{address:string,message:string}[], close:()=>Promise<void>, broadcast:(event:string, data:unknown)=>void}>}
+ * @returns {Promise<{port:number, addresses:string[], failed:{address:string,message:string}[], close:()=>Promise<void>, broadcast:(event:string, data:unknown)=>void, broadcastTrajectory:(payload:object)=>void, broadcastTrajectoryLive:(payload:object)=>void}>}
  */
 export async function createMiniServer({ store, config, token, bindAddresses, tunnelHost, onInstruction, onCommands, onCommand, onStop, onUnqueue, onUpload, onSessionOpened, log, tree, browse, build, imageRoots }) {
   /** @type {Set<import('node:http').ServerResponse>} */
   const clients = new Set()
 
+  /**
+   * 这条连接到底是谁——**订阅要按连接记，就得先有身份**。
+   *
+   * SSE 那边只有一个 `res`，一次普通的 POST 认不出「我是哪条流」。所以由客户端自己
+   * 生成一个随机串，两处都带上：连流时 `?clientId=…`，之后每一次开关订阅也带它。
+   * 客户端没报的（比如现在这版手机页面）服务端也给它编一个，只为日志里能对上号——
+   * 那种连接**订不了轨迹**，也就不会为这份体积付钱。
+   */
+  const clientsById = new Map()
+  /**
+   * 想要执行轨迹推送的那几条连接。
+   *
+   * 为什么必须按连接分流：轨迹的体积是回答正文的 **90.7 倍**（单轮最高约 946KB，
+   * 单条输出最大 49,930 字符），而现在的 `state` 是「每条广播都发整份快照」。
+   * 把它塞进那条路会把手机压垮，所以它走单独的增量帧，并且**只有声明要「完整」模式的
+   * 那几台**才推。声明有两条路：
+   *   ① 连上来时带 `?full=1`——断线重连之后自动重新对齐，不用先握手一次；
+   *   ② 连上之后 `POST /mini/api/trajectory/subscribe`——切模式时用，不必重连。
+   */
+  const trajectorySubscribers = new Set()
+  let clientSeq = 0
+
+  /**
+   * 「这一代服务」的编号。进程重启、服务重起都会换一个。
+   *
+   * 客户端拿它认出「对面换人了」：那种时候帧序号会从头开始，手里的轨迹该整个重拉一次。
+   * 光看 seq 是不够的——重启后 seq 也是从 1 开始，看着就像什么都没发生。
+   */
+  const EPOCH = randomBytes(4).toString('hex')
+
   // 导航栏的数据比普通状态更适合做 stale-while-revalidate：工作区和会话不会因为
   // 用户打开一次菜单就必须重新清点。第一次没有缓存时仍然等待真实结果；之后先回上次
   // 整理好的列表，再在后台刷新。手动点刷新时由请求方显式 force，保持原来的语义。
   const NAV_CACHE_TTL_MS = 30_000
   let navWorkspaceCache = { value: null, at: 0, inflight: null }
+  const SUBAGENT_CACHE_TTL_MS = 5_000
+  const subagentCaches = new Map()
+  function invalidateNavigation() {
+    navWorkspaceCache = { value: null, at: 0, inflight: null }
+  }
+
+  function invalidateSubagents(sessionId) {
+    if (sessionId) subagentCaches.delete(sessionId)
+    else subagentCaches.clear()
+  }
+
+  async function loadSubagents(sessionId) {
+    if (!sessionId) return nav.subagents(sessionId)
+    const hit = subagentCaches.get(sessionId)
+    if (hit && Date.now() - hit.at < SUBAGENT_CACHE_TTL_MS) return hit.value
+    if (hit?.inflight) return hit.inflight
+    const inflight = Promise.resolve(nav.subagents(sessionId, { includeMetrics: false, scheduleMetrics: true })).then((value) => {
+      subagentCaches.set(sessionId, { value, at: Date.now(), inflight: null })
+      return value
+    }).finally(() => {
+      const current = subagentCaches.get(sessionId)
+      if (current?.inflight === inflight) current.inflight = null
+    })
+    subagentCaches.set(sessionId, { value: hit?.value ?? null, at: hit?.at ?? 0, inflight })
+    return hit?.value ?? inflight
+  }
 
   async function loadWorkspaces(runningIds, force = false) {
     const now = Date.now()
@@ -280,6 +336,58 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     }
   }
 
+  /**
+   * 只发给「要轨迹」的那几台连接。**别人一个字节都不收**。
+   *
+   * 帧里只有这一批的变化（新条目 + 改动），不是整份：整份单轮最高约 946KB，而
+   * 一次工具调用也就是一条几 KB 的条目。`seq` 让客户端认出漏帧，`epoch` 认出重启。
+   */
+  function broadcastTrajectory(payload) {
+    if (!trajectorySubscribers.size) return
+    const frame = `event: trajectory\ndata: ${JSON.stringify({ epoch: EPOCH, ...payload })}\n\n`
+    for (const res of trajectorySubscribers) {
+      try {
+        res.write(frame)
+      } catch {
+        trajectorySubscribers.delete(res)
+        clients.delete(res)
+      }
+    }
+  }
+
+  /**
+   * 轨迹的活片段（2026-10-04 用户解禁「流式不做」，只给完整模式看）：模型正在想的
+   * 那一句，随打字顺出来。和上面那条增量帧走**同一批连接**（就是完整模式那几条），
+   * 但**不占它的 seq/epoch**——它是「还没落定」的影子，落定的字由增量帧接管。
+   */
+  function broadcastTrajectoryLive(payload) {
+    if (!trajectorySubscribers.size) return
+    const frame = `event: trajectory-live\ndata: ${JSON.stringify(payload)}\n\n`
+    for (const res of trajectorySubscribers) {
+      try {
+        res.write(frame)
+      } catch {
+        trajectorySubscribers.delete(res)
+        clients.delete(res)
+      }
+    }
+  }
+
+  /**
+   * 按身份名开/关轨迹推送。
+   * @returns 点到的连接数。**0 = 那条连接已经不在了**，客户端据此重连一次
+   *          （不然会出现「以为订上了，其实一条都收不到」这种最难查的静默状态）。
+   */
+  function setTrajectorySubscription(clientId, on) {
+    const group = clientsById.get(clientId)
+    if (!group) return 0
+    for (const res of group) {
+      if (on) trajectorySubscribers.add(res)
+      else trajectorySubscribers.delete(res)
+    }
+    return group.size
+  }
+
   // ---- 手机上答题 ------------------------------------------------------
   //
   // **这两样必须放在这一层**（和 `clients`、`broadcast` 同一层，全程只建一次）。
@@ -737,6 +845,15 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       })
       res.write(': connected\n\n')
       clients.add(res)
+      // 这条连接的身份 + 它要不要轨迹。身份是客户端自己报的随机串（见 clientsById），
+      // 没报就编一个：编出来的那种订不了轨迹，也就不用替这份体积付钱。
+      const askedClientId = String(url.searchParams.get('clientId') ?? '').slice(0, 64)
+      const clientId = askedClientId || `anon${++clientSeq}`
+      let sameId = clientsById.get(clientId)
+      if (!sameId) clientsById.set(clientId, (sameId = new Set()))
+      sameId.add(res)
+      // `?full=1` = 「我这一端是完整模式」：连上就订上，重连之后自动重新对齐。
+      if (url.searchParams.get('full') === '1') trajectorySubscribers.add(res)
       // 留痕：手机连没连上、一共有几台，就看这一句。2026-09-27 测自言自语的这天
       // 正是卡在这儿——「她怎么没说话」和「手机压根没连上」当时根本分不开。
       // 还要看**是谁**连的、**活了多久**：2026-09-27 日志里一分钟几十次成对出现，
@@ -773,6 +890,12 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         said = true
         clearInterval(beat)
         clients.delete(res)
+        trajectorySubscribers.delete(res)
+        const group = clientsById.get(clientId)
+        if (group) {
+          group.delete(res)
+          if (!group.size) clientsById.delete(clientId)
+        }
         console.log(`[dsh-mini-remote] 手机断开了，还剩 ${clients.size} 台`
           + `（${who}，活了 ${Date.now() - openedAt} ms）`)
       }
@@ -789,6 +912,58 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       return
     }
 
+    /**
+     * 执行轨迹：手机「完整」模式要的那一组一组过程。
+     *
+     * **它不在 `state` 快照里**，这是这次改动最要紧的一条：实测轨迹正文是回答正文的
+     * 90.7 倍（单轮最高约 946KB），而快照是**每条广播都发整份**的——塞进去等于把
+     * 每一次工具调用都变成一次几百 KB 的推送（公网隧道下尤其不可接受）。
+     * 所以全量快照照旧，轨迹走增量帧（`event: trajectory`），这份接口只负责
+     * 「重连 / 切到完整模式 / 换个会话时，一次把当前这一段补齐」。
+     *
+     * `turn=N` 只给那一轮：手机切回来时想对齐的是**当前正在跑的那一轮**，不必把
+     * 前面一百多条条目再拖一遍。
+     *
+     * 和 /state 同一条口径：没读过这个会话的记录就先读一次（`onSessionOpened`），
+     * 读完会广播 state；手机据此再拉一次，那时 `loading` 就不是 true 了。
+     */
+    if (req.method === 'GET' && path === '/mini/api/trajectory') {
+      const asked = url.searchParams.get('sessionId')
+      const sessionId = asked || store.targetSessionId()
+      if (!sessionId) {
+        sendJson(res, 200, {
+          ok: true, sessionId: null, epoch: EPOCH, seq: 0, turn: null,
+          turns: [], truncated: false, note: null, loading: false,
+        })
+        return
+      }
+      let onlyTurn = null
+      if (url.searchParams.has('turn')) {
+        onlyTurn = Number(url.searchParams.get('turn'))
+        if (!Number.isFinite(onlyTurn)) {
+          sendJson(res, 400, { ok: false, error: 'turn 要是一个数字。' })
+          return
+        }
+      }
+      onSessionOpened?.(sessionId)
+      const view = store.trajectoryOf(sessionId)
+      const turns = onlyTurn === null
+        ? view.turns
+        : view.turns.filter((g) => g.turn === onlyTurn)
+      sendJson(res, 200, {
+        ok: true,
+        sessionId,
+        epoch: EPOCH,
+        seq: view.seq,
+        turn: onlyTurn,
+        turns,
+        truncated: view.truncated,
+        note: view.note ?? null,
+        loading: view.loading === true,
+      })
+      return
+    }
+
     // 构建指纹。重启期间旧进程还在应答，这个接口用来确认「跑的是不是新代码」。
     //
     // `canCreateSession` 是**运行时**事实，不是配置推断：它问的是「这一刻 DSH 真的
@@ -803,7 +978,38 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         // 探测本身不该把接口带崩：问不到就当没有。
         canCreateSession = false
       }
-      sendJson(res, 200, { ok: true, build: build ?? 'unknown', canCreateSession })
+      // 版本号问**正在跑的这只 Host**（见 index.js 的 dshVersion）。
+      // 早先这里是读磁盘上的 package.json，桌面端读不到，一直报 unknown。
+      const version = (await nav.dshVersion?.()) || 'unknown'
+      sendJson(res, 200, { ok: true, build: build ?? 'unknown', dshVersion: version, canCreateSession })
+      return
+    }
+
+    // 插件列表：手机端「插件」页面用。分三块——
+    //   bundles  ：npm 包（官方可装的 + 用户装的第三方）
+    //   cards    ：官方那几张**设置卡片**（终端 / Agent 循环 / 子智能体 / 网页搜索）。
+    //             它们不是包，是注册了设置页的官方插件，宿主这边只能照 DSH 客户端
+    //              源码列一张表 + 按「宿主 served 了那个命名空间没」筛选。
+    //   entries/presets：**内置插件**（Cordis Loader 的实时条目表），也就是
+    //             「全局插件」和「会话插件」两块。2026-10-04 用户指出：内置插件
+    //             不能拿 npm 包充数（那只有几个），DSH 是「一切皆插件，无特权核心」。
+    // 三块各带各的错：一块读不到不该把另两块也弄没。
+    if (req.method === 'GET' && path === '/mini/api/plugins') {
+      const [list, inv, official] = await Promise.all([
+        nav.pluginList?.() ?? { ok: false, reason: 'unavailable' },
+        nav.pluginInventory?.() ?? { ok: false, reason: 'unavailable' },
+        nav.officialPlugins?.() ?? { ok: false, reason: 'unavailable' },
+      ])
+      sendJson(res, 200, {
+        ok: list.ok !== false || inv.ok !== false,
+        bundles: list.bundles ?? [],
+        bundlesError: list.ok === false ? String(list.reason || '读不到') : '',
+        official: official.cards ?? [],
+        officialError: official.ok === false ? String(official.reason || '读不到') : '',
+        entries: inv.entries ?? [],
+        presets: inv.presets ?? [],
+        builtinError: inv.ok === false ? String(inv.reason || '读不到') : '',
+      })
       return
     }
 
@@ -824,7 +1030,7 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     // 失败一律 200 + ok:false：这是"这道能力现在没有"或"这台电脑没开这条路"，
     // 不是请求本身有错——用 4xx 会让页面上的重试逻辑把它当网络故障。
     if (req.method === 'GET' && path === '/mini/api/subagents') {
-      const result = await nav.subagents(store.snapshot().boundSessionId)
+      const result = await loadSubagents(store.snapshot().boundSessionId)
       sendJson(res, 200, result)
       return
     }
@@ -837,6 +1043,25 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       return
     }
 
+    // ---- 繁忙时的发送行为 ------------------------------------------------
+    // 智能体跑着的时候，你发的那句话是排队等这一轮跑完（queue），还是当场插进去
+    // 让它调整方向（steer）。**PC 上的「设置 → 通用 → 繁忙时的发送行为」就是它**，
+    // 两端共用宿主那一份用户设置文档（用户 2026-10-05 拍板）。
+    //
+    // 读不到就如实说 unavailable，手机那边整条不显示——**不摆一个假的开关**。
+    if (req.method === 'GET' && path === '/mini/api/busy-enter') {
+      const result = await nav.busyEnterSetting()
+      sendJson(res, result.ok ? 200 : 503, result)
+      return
+    }
+
+    if (req.method === 'POST' && path === '/mini/api/busy-enter') {
+      const body = await readBody(req)
+      const result = await nav.setBusyEnter(body?.value)
+      sendJson(res, result.ok ? 200 : 400, result)
+      return
+    }
+
     // ---- 斜杠指令列表 ----------------------------------------------------
     // 手机在输入框里打 `/` 时要显示的那一份。**名单来自 DSH 自己的指令账本**，
     // 所以电脑上新装一个带指令的插件，手机上刷新就有了，不用改这个插件。
@@ -869,6 +1094,13 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       return
     }
 
+    // Agent 模式清单（2026-10-04）：手机新建会话时挑模式用。拿不到能力时如实回
+    // unavailable——手机那边会直接建默认模式，**不摆没得选的选择题**。
+    if (path === '/mini/api/agent-presets' && req.method === 'GET') {
+      sendJson(res, 200, await nav.agentPresets?.() ?? { ok: false, reason: 'unavailable' })
+      return
+    }
+
     const wsSessions = /^\/mini\/api\/workspaces\/([^/]+)\/sessions$/.exec(path)
     if (req.method === 'GET' && wsSessions) {
       const asked = Number(url.searchParams.get('limit'))
@@ -1194,6 +1426,26 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         return
       }
 
+      if (path === '/mini/api/trajectory/subscribe') {
+        // 开/关轨迹推送（见 trajectorySubscribers）。**只点到 clientId 名下那条连接**，
+        // 别的连接一个字节都不受影响——单帧/聊天模式的手机不该为这份体积付钱。
+        const clientId = typeof body.clientId === 'string' ? body.clientId.trim() : ''
+        if (!clientId) {
+          sendJson(res, 400, { ok: false, error: 'clientId 不能空——订阅是按连接记的。' })
+          return
+        }
+        const on = body.on !== false
+        const hit = setTrajectorySubscription(clientId, on)
+        if (!hit) {
+          // 认不出这条连接：多半是那条流已经断了（或者连流时没报 clientId）。
+          // **如实说没订上**，别让手机以为订上了却一条都收不到——那是最难查的一种静默失败。
+          sendJson(res, 404, { ok: false, error: '这条连接已经不在了，重新连一次流。' })
+          return
+        }
+        sendJson(res, 200, { ok: true, clientId, subscribed: on, connections: hit, epoch: EPOCH })
+        return
+      }
+
       // 在一个已有的工作区里新建会话，建完立刻把手机绑过去。
       //
       // 为什么排在这么靠后、而不是跟上面那条 GET 挨着：这两条都要读请求体，
@@ -1203,7 +1455,11 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
       // 建完顺手 bind + 广播：手机发一次请求就完成了「建 + 切过去」，
       // 不用再补一次 bind，也就不会出现「建好了但没切过去」这种半截状态。
       if (req.method === 'POST' && wsSessions) {
-        const created = await nav.createSession(decodeURIComponent(wsSessions[1]))
+        // agentPreset（2026-10-04，手机上也能选模式）：选了才带，没选让 DSH 用默认。
+        const preset = typeof body.agentPreset === 'string' && body.agentPreset.trim()
+          ? body.agentPreset.trim()
+          : undefined
+        const created = await nav.createSession(decodeURIComponent(wsSessions[1]), preset)
         if (!created.ok) {
           const known = {
             'no-controller': [503, '这台电脑上的 DSH 没提供新建会话的能力。'],
@@ -1216,7 +1472,7 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
         }
         store.bind(created.sessionId)
         // 新会话会改变工作区的数量；下次打开导航栏必须重新整理一次。
-        navWorkspaceCache = { value: null, at: 0, inflight: null }
+        invalidateNavigation()
         const snap = store.snapshot()
         broadcast('state', snap)
         sendJson(res, 200, {
@@ -1412,6 +1668,12 @@ export async function createMiniServer({ store, config, token, bindAddresses, tu
     /** 想绑但失败的地址，交给调用方决定怎么提示。 */
     failed,
     broadcast,
+    /** 执行轨迹的增量帧：只发给声明了「完整」模式的那几条连接（见 broadcastTrajectory）。 */
+    broadcastTrajectory,
+    /** 轨迹的活片段帧：同一批连接，不占 seq/epoch（见 broadcastTrajectoryLive）。 */
+    broadcastTrajectoryLive,
+    invalidateNavigation,
+    invalidateSubagents,
     close: async () => {
       for (const res of clients) {
         try { res.end() } catch { /* 已经断了 */ }

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()
+    },
+  }
+}