dsh-recall-plugin 1.5.0 → 1.6.0

package/lib/index.js

@@ -12,10 +12,11 @@
  * 文件拆分见 lib/ 下各模块头注释；本文件只做接线，不承载业务逻辑。
  */
 
-import { createConfig } from './config.js'
+import { createConfig, Config } from './config.js'
 import { createRuntime } from './store.js'
 import { createSnapshots } from './snapshots.js'
 import { createMaintenance } from './maintenance.js'
+import { installSettingsSection } from '@deepseek-ai/dsh-settings'
 
 export const name = 'dsh-recall-plugin'
 
@@ -23,8 +24,13 @@ export const name = 'dsh-recall-plugin'
 // webServer（Client 半的 HTTP API 通道）。其余服务按需 ctx.get。
 export const inject = ['shell', 'sessions', 'webServer']
 
-// config 由 cordis.patch.yml 的 insert 行 config 键下发，用户在 profile 层
-// 按 id: recall 重述该行即可覆盖默认值（见 config.js 头注释）
+// 入口配置 schema：cordis 加载器据此校验 insert 行 config 并填充默认值，
+// 非法配置在插件加载时响亮失败（官方「插件配置」文档要求）。
+export { Config }
+
+// config 由 cordis.patch.yml 的 insert 行 config 键下发（schema 默认值兜底），
+// 设置页「插件配置」卡片的用户覆盖经 settings namespace 热更新进 cfg
+// （见下方 installSettingsSection 接线）
 export function apply(ctx, config) {
   const webServer = ctx.webServer
 
@@ -34,6 +40,27 @@ export function apply(ctx, config) {
   const maint = createMaintenance(ctx, rt, snaps, cfg)
   const state = rt.state
 
+  // ---- settings namespace「dsh-recall」：设置页「插件配置」分区正规接入 ----
+  // installSettingsSection（dsh-settings 官方辅助）：settings 服务挂载后以
+  // 真 Config schema 注册 namespace、组合 base 取入口 config；服务卸载时
+  // 源回退入口 config。解析层 = schema 默认 → 组合 base → 用户文档（设置
+  // 卡片写入、dsh-settings 持久化），变更经 watch 热更新进运行中的 cfg
+  // （Object.assign 原地改，各域按调用时读取立即生效）。环境变量仍最高
+  // 优先（createConfig 内处理）。settings 服务未组装（非 web 部署）时
+  // 整段静默不运行，插件照常以入口配置工作。
+  let readSettings = () => config
+  function applyResolvedConfig(resolved) {
+    Object.assign(cfg, createConfig(resolved && typeof resolved === 'object' ? resolved : {}))
+  }
+  try {
+    installSettingsSection(ctx, 'dsh-recall', Config, config, {
+      setSource: (fn) => { readSettings = fn },
+      onChange: () => applyResolvedConfig(readSettings()),
+    })
+  } catch (error) {
+    rt.recordError('recall settings namespace skipped: ' + String(error))
+  }
+
   // 平台门控：win32 走 PowerShell 模板，linux/darwin 走 bash 模板
   // （ctx.shell 由 DSH 平台层单选挂载 pwsh/bash 执行器，见 dsh-shell README）。
   // 其余平台干净短路：init 返回 unsupported，Client 弹一次性提示；
@@ -51,6 +78,9 @@ export function apply(ctx, config) {
   // 也不是零成本（1 条 shell + 若干日志解压）。设置页打开、删除后刷新
   // 都会重拉，30s 缓存让二次打开即时；delete 与新快照落地时失效。
   let listCache = { at: 0, payload: null }
+  // 排除配置枚举缓存（30s）：exclude-get 首次要遍历工作区、逐文件 shell 读，
+  // 设置页反复打开时不该每次重算；exclude-set 成功写入后立即失效。
+  let excludeCache = { at: 0, payload: null }
 
   // 会话标题缓存（apply 级跨请求共享）：冷会话标题要 readSession 整日志
   // 解压 + 重放校验（大日志 10 秒级），绝不能挡列表首屏——list 只查
@@ -138,7 +168,9 @@ export function apply(ctx, config) {
       if (cwd) roots.add(cwd)
     }
     const byFile = new Map()
-    for (const root of roots) {
+    // 并行解析全部 root：冷启动时每个 root 首次 resolveStore 可能触发 shell
+    // 建目录/写 root.txt，串行会随工作区数量线性变慢；Promise.all 让它们并发。
+    await Promise.all(Array.from(roots).map(async (root) => {
       try {
         const store = await rt.resolveStore(root)
         if (store && !byFile.has(store.excludeFile)) byFile.set(store.excludeFile, { store, roots: [] })
@@ -146,7 +178,7 @@ export function apply(ctx, config) {
       } catch (error) {
         /* 单个根解析失败只影响它自己，不拖垮整个列表 */
       }
-    }
+    }))
     // 磁盘兜底：冷启动时会话注册表为空（惰性载入），但 home 容器目录可能
     // 早已存在（历史快照）。容器在 ⇒ 共享 exclude.txt 可编辑（哪怕从未
     // 写过、内容为空）；容器不在 ⇒ 全新安装，让设置页显示引导文案。
@@ -278,6 +310,21 @@ export function apply(ctx, config) {
     return run
   }
 
+  // 通用并发限制器：冷会话标题/消息文本补齐会 readSession 整日志解压，
+  // 首次大量冷数据时全量 Promise.all 会同时压垮磁盘/CPU。限制同时最多
+  // CONCURRENCY 个任务，剩余排队执行；这是纯内存调度，不依赖额外依赖。
+  async function runLimited(tasks, concurrency) {
+    const limit = concurrency > 0 ? concurrency : 4
+    let index = 0
+    const workers = Array.from({ length: Math.min(limit, tasks.length) }, async () => {
+      while (index < tasks.length) {
+        const task = tasks[index++]
+        await task()
+      }
+    })
+    await Promise.all(workers)
+  }
+
   // 收集全量快照记录（内存 + 磁盘 dump 并集），供树形管理的按工作区/
   // 会话批量删除使用。返回 Map<消息ID, {id, root, sessionId, time}>；
   // 磁盘条目缺 root 时按 store 的 root.txt/内存映射补全（与 manage list
@@ -392,7 +439,9 @@ export function apply(ctx, config) {
           homeFallback: store ? !store.home : false
         }
       }
-      return { ok: Boolean(root), root: root || null, notice }
+      // 顺带下发客户端行为开关（fillDraft 等）：Client 无须为读配置单开请求，
+      // init 是每会话必经的预热通道
+      return { ok: Boolean(root), root: root || null, notice, config: { refillDraft: cfg.refillDraft } }
     },
 
     'snapshot-info': async (args) => {
@@ -443,14 +492,19 @@ export function apply(ctx, config) {
       // 设置页「撤回设置」标签的配置读取。不支持平台照常短路：Client
       // 显示不可用提示而不是空白表单，与 init 的 notice 语义对齐。
       if (!supported) return { ok: false, unsupported: true }
+      // 30s 结果缓存：首次进入要并行 resolveStore + 逐文件 shell 读，
+      // 二次打开/切标签不应重复付出这份代价；exclude-set 写入后失效。
+      if (excludeCache.payload && Date.now() - excludeCache.at < 30000) return excludeCache.payload
       const byFile = await listExcludeFiles()
-      const files = []
-      for (const [path, info] of byFile) {
+      // 并行读取各 exclude 文件内容：每个文件一条 shell，串行会放大延迟
+      const files = await Promise.all(Array.from(byFile.entries()).map(async ([path, info]) => {
         let content = ''
         try { content = await snaps.readExclude(info.store) } catch (error) { content = '' }
-        files.push({ path, home: Boolean(info.store.home), roots: info.roots, content })
-      }
-      return { ok: true, files }
+        return { path, home: Boolean(info.store.home), roots: info.roots, content }
+      }))
+      const payload = { ok: true, files }
+      excludeCache = { at: Date.now(), payload }
+      return payload
     },
 
     'exclude-set': async (args) => {
@@ -463,6 +517,70 @@ export function apply(ctx, config) {
       const info = byFile.get(path)
       if (!info) return { ok: false, code: 'UNKNOWN_PATH', message: '未知的排除文件路径' }
       await snaps.writeExclude(info.store, content)
+      // 写入后立即失效：设置页保存后刷新必须看到最新内容
+      excludeCache.payload = null
+      return { ok: true }
+    },
+
+    // 设置页「插件配置」卡片读配置：resolved 全量值 + 用户已覆盖字段（来自
+    // settings.describe 的 user 层，字段在层里出现即用户覆盖）+ env 锁定
+    // 字段（环境变量优先级最高，设置改不动）+ 可写性（只读 provider 禁存）。
+    'config-get': async () => {
+      const envLocks = {
+        gcSnaps: Boolean(process.env && process.env.DSH_RECALL_GC_SNAPS),
+        gcHours: Boolean(process.env && process.env.DSH_RECALL_GC_HOURS),
+      }
+      let overridden = {}
+      let writable = false
+      try {
+        const settings = ctx.get('settings')
+        if (settings && typeof settings.describe === 'function') {
+          const list = settings.describe()
+          const ours = (Array.isArray(list) ? list : []).find((d) => d && d.ns === 'dsh-recall')
+          if (ours && ours.user && typeof ours.user === 'object') overridden = ours.user
+          writable = settings.writable !== false
+        }
+      } catch (error) { /* describe 不可用按「无覆盖」处理 */ }
+      return {
+        ok: true,
+        values: {
+          gcSnaps: cfg.gcSnaps,
+          gcHours: cfg.gcHours,
+          maxFileBytes: cfg.maxFileBytes,
+          baseExcludes: cfg.baseExcludes.slice(),
+          refillDraft: cfg.refillDraft,
+        },
+        overridden,
+        envLocks,
+        writable,
+      }
+    },
+
+    // 设置页「插件配置」卡片存配置：白名单字段 + 类型清洗后经 settings.update
+    // 写进用户层（schema 校验失败会在持久化前 reject，错误信息回显卡片），
+    // watch 链路把新值热更新进 cfg，无需重启。
+    'config-set': async (args) => {
+      const patch = args && args.patch && typeof args.patch === 'object' ? args.patch : {}
+      const clean = {}
+      if (patch.gcSnaps !== undefined) clean.gcSnaps = Number(patch.gcSnaps)
+      if (patch.gcHours !== undefined) clean.gcHours = Number(patch.gcHours)
+      if (patch.maxFileBytes !== undefined) clean.maxFileBytes = Number(patch.maxFileBytes)
+      if (patch.refillDraft !== undefined) clean.refillDraft = Boolean(patch.refillDraft)
+      if (patch.baseExcludes !== undefined) {
+        if (!Array.isArray(patch.baseExcludes)) return { ok: false, code: 'BAD_TYPE', message: 'baseExcludes 必须是字符串数组' }
+        clean.baseExcludes = patch.baseExcludes.filter((p) => typeof p === 'string' && p.trim())
+      }
+      if (!Object.keys(clean).length) return { ok: false, code: 'EMPTY_PATCH', message: '没有可写入的配置字段' }
+      let settings = null
+      try { settings = ctx.get('settings') } catch (error) { settings = null }
+      if (!settings || typeof settings.update !== 'function') {
+        return { ok: false, code: 'SETTINGS_UNAVAILABLE', message: '设置服务不可用：请在 profile 的 cordis.patch.yml 按 id: recall 覆盖配置' }
+      }
+      try {
+        await settings.update('dsh-recall', clean)
+      } catch (error) {
+        return { ok: false, code: 'SETTINGS_WRITE_FAILED', message: '配置写入失败：' + String(error && error.message ? error.message : error) }
+      }
       return { ok: true }
     },
 
@@ -542,10 +660,14 @@ export function apply(ctx, config) {
         // 重放校验，大日志 10 秒级——独立于列表让首屏即时。并发交给
         // sessionQuery 自带的 inspect 并发闸，这里全量并行发车。
         if (!supported) return { ok: false, unsupported: true }
-        const ids = Array.isArray(args && args.sessionIds) ? args.sessionIds.map(String).slice(0, 100) : []
+        const ids = Array.from(new Set(
+          (Array.isArray(args && args.sessionIds) ? args.sessionIds.map(String) : []).filter(Boolean)
+        )).slice(0, 100)
         const out = {}
-        await Promise.all(ids.map(async (sid) => {
-          if (!sid || out[sid] !== undefined) return
+        // 并发限 4：冷标题 readSession 是重 IO，全量并发会把首次设置页
+        // 的 shell/日志解压都挤在一起；限制后列表本身不受影响，标题渐进补齐。
+        await runLimited(ids.map((sid) => async () => {
+          if (out[sid] !== undefined) return
           let title = liveTitleFast(sid)
           if (title === null) {
             const query = ctx.get('sessionQuery')
@@ -558,7 +680,7 @@ export function apply(ctx, config) {
           }
           sessionTitles.set(sid, title)
           out[sid] = title
-        }))
+        }), 4)
         return { ok: true, titles: out }
       }
       if (op === 'messages') {
@@ -576,7 +698,7 @@ export function apply(ctx, config) {
           bySession.get(sid).push(mid)
         }
         const texts = {}
-        await Promise.all(Array.from(bySession.entries()).map(async ([sid, mids]) => {
+        await runLimited(Array.from(bySession.entries()).map(([sid, mids]) => async () => {
           // 该会话所有消息都已缓存（含 null）时，不必 readSession 冷读
           const allCached = mids.every((mid) => messageTexts.has(String(sid) + '\u0000' + String(mid)))
           let log = null
@@ -604,16 +726,31 @@ export function apply(ctx, config) {
             messageTexts.set(key, text)
             texts[mid] = text
           }
-        }))
+        }), 4)
         return { ok: true, messageTexts: texts }
       }
       if (op === 'usage') {
-        const root = await rt.resolveRoot(sessionId)
-        if (!root) return { ok: false, code: 'NO_ROOT', message: '无法解析当前工作区' }
-        const store = state.stores.get(root)
-        if (!store) return { ok: false, code: 'NO_STORE', message: '当前工作区尚未创建快照存储' }
-        const out = await rt.runShell(rt.scripts.diskUsageScript(store.dir), { stdoutMaxBytes: 4096 })
-        const bytes = parseInt(rt.scripts.stripBom(out).trim(), 10) || 0
+        let bytes = 0
+        if (sessionId) {
+          // 旧调用方（带会话上下文）：单工作区占用
+          const root = await rt.resolveRoot(sessionId)
+          if (!root) return { ok: false, code: 'NO_ROOT', message: '无法解析当前工作区' }
+          const store = state.stores.get(root)
+          if (!store) return { ok: false, code: 'NO_STORE', message: '当前工作区尚未创建快照存储' }
+          const out = await rt.runShell(rt.scripts.diskUsageScript(store.dir), { stdoutMaxBytes: 4096 })
+          bytes = parseInt(rt.scripts.stripBom(out).trim(), 10) || 0
+        } else {
+          // 新调用方（settings.plugin.item 卡片无会话上下文）：全部已知
+          // store 汇总。store 全集取内存缓存（启动预热填齐）；单个失败
+          // 不影响汇总，best-effort。
+          for (const store of state.stores.values()) {
+            if (!store || !store.dir) continue
+            try {
+              const out = await rt.runShell(rt.scripts.diskUsageScript(store.dir), { stdoutMaxBytes: 4096 })
+              bytes += parseInt(rt.scripts.stripBom(out).trim(), 10) || 0
+            } catch (error) { /* 单 store 失败跳过 */ }
+          }
+        }
         return { ok: true, bytes }
       }
       if (op === 'delete') {
@@ -676,7 +813,11 @@ export function apply(ctx, config) {
         return { ok: true }
       }
       if (op === 'gc') {
-        const done = await enqueue(() => maint.runGc(sessionId, true))
+        // 带会话上下文：只 gc 该会话的工作区；无上下文（设置卡片）：
+        // 全部已知 store 逐个 gc。两者都排进串行队列，与快照互斥。
+        const done = sessionId
+          ? await enqueue(() => maint.runGc(sessionId, true))
+          : await enqueue(() => maint.runGcAll())
         return { ok: true, gc: Boolean(done) }
       }
       return { ok: false, code: 'UNKNOWN_OP', message: '未知的管理操作: ' + op }
@@ -730,16 +871,37 @@ export function apply(ctx, config) {
   // 启动预热：所有已存在工作区解析存储、重建索引与孤儿快照，
   // 并清理旧版项目内 blobs 目录（home 可用时）。
   // 不触发维护（gc/清理）：开机预热应尽量轻，重活等第一条消息再按节流来。
-  for (const session of ctx.sessions.list()) {
-    const cwd = session && session.header && session.header.cwd
-    if (!cwd) continue
-    const sessionId = session.id
-    Promise.resolve(rt.resolveStore(cwd))
-      .then(() => rt.tryUpgradeToHome(cwd))
-      .then((store) => rt.ensureGit(cwd, store))
-      .then(() => snaps.loadIndex(cwd, sessionId))
-      .then(() => snaps.rebuildOrphans(cwd, sessionId))
-      .then(() => rt.cleanupLegacy(cwd))
-      .catch(() => {})
-  }
+  // 冷启动时 ctx.sessions.list() 常为空（惰性载入），必须叠加
+  // sessionQuery.listSessions() 冷元数据，否则设置页首次打开仍要现场建 store。
+  // apply 不是 async，这里用 IIFE 把冷元数据扫描包成异步任务。
+  ;(async () => {
+    const warmupRoots = new Map()
+    for (const session of ctx.sessions.list()) {
+      const cwd = session && session.header && session.header.cwd
+      if (cwd && !warmupRoots.has(cwd)) warmupRoots.set(cwd, session.id)
+    }
+    const querySvc = ctx.get('sessionQuery')
+    if (querySvc && typeof querySvc.listSessions === 'function') {
+      try {
+        const records = await querySvc.listSessions()
+        for (const record of records || []) {
+          // listSessions 记录形如 {header, live, persisted}，会话 id 在
+          // header.id——此前误用顶层 record.id（恒 undefined），预热重建
+          // 的孤儿快照 sessionId 记为空，树形管理里会落进「已删除会话」。
+          const id = record && record.header && record.header.id ? record.header.id : null
+          const cwd = record && record.header && record.header.cwd
+          if (cwd && !warmupRoots.has(cwd)) warmupRoots.set(cwd, id)
+        }
+      } catch (error) { /* 冷元数据不可用则退回 live 注册表 */ }
+    }
+    for (const [cwd, sessionId] of warmupRoots) {
+      Promise.resolve(rt.resolveStore(cwd))
+        .then(() => rt.tryUpgradeToHome(cwd))
+        .then((store) => rt.ensureGit(cwd, store))
+        .then(() => snaps.loadIndex(cwd, sessionId))
+        .then(() => snaps.rebuildOrphans(cwd, sessionId))
+        .then(() => rt.cleanupLegacy(cwd))
+        .catch(() => {})
+    }
+  })()
 }

package/lib/maintenance.js

@@ -11,13 +11,12 @@
  * 接线），因此 gc/清理与快照天然互斥，不存在 git 锁竞态。
  */
 
-// gc 节流阈值来自 config 域（用户可在 profile 的 cordis.patch.yml 覆盖，
-// 环境变量 DSH_RECALL_GC_SNAPS/GC_HOURS 仍最高优先，见 config.js）：
+// gc 节流阈值来自 config 域（设置页「插件配置」卡片可实时改写 cfg，
+// 因此这里按调用时取值而不是工厂创建时快照；环境变量
+// DSH_RECALL_GC_SNAPS/GC_HOURS 仍最高优先，见 config.js）：
 // 每 gcSnaps 条快照或距上次 gc gcHours 小时，先到先触发。默认「50 条或
 // 24 小时」——重活（gc）一天至多一次的量级，轻会话用户也不会等太久。
 export function createMaintenance(ctx, rt, snaps, config) {
-  const GC_SNAPS = config.gcSnaps
-  const GC_MS = config.gcHours * 3600000
   const sessions = ctx.sessions
   const state = rt.state
   // 平台选择的脚本模板（gc/purge 两套模板同名导出）
@@ -97,7 +96,7 @@ export function createMaintenance(ctx, rt, snaps, config) {
     const last = state.gcLastAt.get(store.git) || 0
     const count = (state.gcCount.get(store.git) || 0) + 1
     state.gcCount.set(store.git, count)
-    if (!force && count < GC_SNAPS && now - last < GC_MS) return false
+    if (!force && count < config.gcSnaps && now - last < config.gcHours * 3600000) return false
     state.gcCount.set(store.git, 0)
     try {
       await sweepDeletedSessions()
@@ -109,12 +108,38 @@ export function createMaintenance(ctx, rt, snaps, config) {
     return true
   }
 
+  // 全局 gc（设置卡片没有会话上下文）：清理扫描一次 + 逐 store gc。
+  // store 全集取内存缓存（启动预热与历次操作会填齐已知工作区）；逐个
+  // best-effort，单个失败记错误继续。调用方（manage 端点）把它排进同一条
+  // 串行队列，与快照天然互斥，无 git 锁竞态。
+  async function runGcAll() {
+    const stores = Array.from(new Set(Array.from(state.stores.values()).filter(Boolean)))
+    if (!stores.length || !state.gitExe) return false
+    try {
+      await sweepDeletedSessions()
+    } catch (error) {
+      rt.recordError('recall sweep failed: ' + String(error))
+    }
+    let done = 0
+    for (const store of stores) {
+      try {
+        await rt.runShell(S.gcScript(store, state.gitExe), { timeoutMs: 600000, stdoutMaxBytes: 4096 })
+        done++
+      } catch (error) {
+        rt.recordError('recall gc failed for ' + (store && store.git) + ': ' + String(error))
+      }
+      state.gcLastAt.set(store.git, Date.now())
+      state.gcCount.set(store.git, 0)
+    }
+    return true
+  }
+
   // 每条消息快照后串行调用（见 index.js 事件接线）
   async function maybeMaintain(sessionId) {
     await runGc(sessionId, false)
   }
 
-  // 模块收敛：只导出唯一被装配层消费的入口；sweepDeletedSessions /
-  // purgeSession 是 runGc 的内部步骤，不对外暴露面
-  return { maybeMaintain, runGc }
+  // 模块收敛：只导出被装配层消费的入口；sweepDeletedSessions /
+  // purgeSession 是 gc 的内部步骤，不对外暴露面
+  return { maybeMaintain, runGc, runGcAll }
 }