dsh-sessions-manager 3.4.1 → 3.4.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-sessions-manager",
   "description": "DSH 设置面板会话管理器：归档 / 恢复 / 彻底删除 / 移动到其他工作区，带工作区标签与会话日期；统一「会话管理」面板。Session manager for the DeepSeek Harness settings panel — archive / restore / permanently delete / move sessions across workspaces, with workspace tags & session dates in one unified panel.",
-  "version": "3.4.1",
+  "version": "3.4.2",
   "type": "module",
   "main": "lib/index.js",
   "exports": {

package/src/index.js

@@ -16,7 +16,8 @@ import { renderSessionMarkdown } from './markdown.js'
 import { createStarIndex } from './star-index.js'
 import { aggregateStorage } from './storage-stats.js'
 import { createAutoArchiveStore, pickInactiveCandidates } from './auto-archive.js'
-import { createSessionMetaCache } from './session-meta-cache.js'
+import { createSessionMetaCache, fingerprintOf } from './session-meta-cache.js'
+import { createTitleIndexStore } from './title-persist-index.js'
 
 
 export const name = 'dsh-sessions-manager'
@@ -128,6 +129,44 @@ export function apply(ctx) {
   // 见 src/session-meta-cache.js 的说明：列表构建原本每条会话都要整本解压日志，
   // 这个缓存让「日志没变」的会话直接跳过解码。
   const metaCache = createSessionMetaCache()
+  // 持久标题索引（冷启动加速）：metaCache 是进程内的，重启即空——第一次列表
+  // 仍要全库解码。索引按同样的 (mtime, size) 指纹存解码结果，指纹没变的会话
+  // 重启后也直接复用。见 src/title-persist-index.js。
+  const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join(TRASH_DIR, 'title-index.json') })
+
+  // P4：对「内存缓存未命中」的会话查持久索引，指纹一致才可信。
+  // 返回 Map<id, meta>；调用方应把命中条目回填 metaCache 并从 missing 里剔除。
+  async function hydrateFromPersist(ids, statsById) {
+    const hits = new Map()
+    if (!ids || !ids.length) return hits
+    let store
+    try { store = await titleIndex.entries() } catch (e) { return hits }
+    for (const id of ids) {
+      const stat = statsById.get(id)
+      const entry = store && store[id]
+      if (!stat || !entry) continue
+      const fp = fingerprintOf(stat)
+      if (fp && entry.fingerprint === fp) {
+        hits.set(id, { title: entry.title, cwd: entry.cwd, createdAt: entry.createdAt })
+      }
+    }
+    return hits
+  }
+
+  // 把本批真正解码出的元数据异步回写持久索引（fire-and-forget：索引只是
+  // 加速器，写失败不影响响应，队列内部已串行化 + 原子替换）。
+  function persistDecoded(decoded, statsById) {
+    if (!decoded || !decoded.size) return
+    const batch = {}
+    const now = Date.now()
+    for (const [id, meta] of decoded) {
+      const fp = fingerprintOf(statsById.get(id))
+      if (!fp) continue
+      batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now }
+    }
+    if (!Object.keys(batch).length) return
+    titleIndex.merge(batch).catch(() => {})
+  }
 
   // 从投影快照里抽出元数据；快照缺失/异常时返回零值 meta（调用方决定兜底）。
   function metaFromSnapshot(o) {
@@ -239,6 +278,8 @@ export function apply(ctx) {
       } catch (e2) { /* keep what we have */ }
     }
     metaCache.set(key, statInfo, meta)
+    // 本条是「真解码」出来的：交给调用方回写持久标题索引（P4 冷启动加速）。
+    if (opts.collectDecoded && statInfo) opts.collectDecoded(key, meta)
     return buildItem(key, meta, usage, opts.exposeUsage)
   }
 
@@ -805,7 +846,13 @@ export function apply(ctx) {
     // 先按指纹把「缓存命中」与「需要解码」分开，只对后者做批量投影。
     const statsById = new Map(visibleIds.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]))
     const { cached, missing } = metaCache.partition(visibleIds, statsById)
-    const snapshotById = await projectTitles(missing)
+    // P4：missing 里先查持久标题索引（冷启动跳过整本解码），命中的回填内存缓存。
+    const persisted = await hydrateFromPersist(missing, statsById)
+    for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta)
+    const stillMissing = missing.filter((id) => !persisted.has(id))
+    const snapshotById = await projectTitles(stillMissing)
+    const decoded = new Map()
+    const collectDecoded = (id, meta) => { decoded.set(id, meta) }
     const CHUNK = 6
     for (let i = 0; i < visibleIds.length; i += CHUNK) {
       // Arrow wrapper on purpose: Array#map passes (value, index, array), and
@@ -813,9 +860,11 @@ export function apply(ctx) {
       const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map((id) => resolveOne(id, usage, {
         exposeUsage: !!(opts && opts.usage),
         preloaded: snapshotById.has(id) ? snapshotById.get(id) : undefined,
+        collectDecoded,
       })))
       for (const it of res2) items.push({ ...it, archived: currentArchived.has(it.sessionId) })
     }
+    persistDecoded(decoded, statsById)
     // Annotate stars; GC only when we have a trustworthy id baseline, so a
     // failing sp.list() can never wipe the whole index.
     let starredSet = new Set()
@@ -889,19 +938,27 @@ export function apply(ctx) {
       const usage = await collectUsage(headers)
       const statsById = new Map(ids.map((id) => [id, { mtimeMs: usage.mtimeById.get(id), size: usage.sizeById.get(id) }]))
       const { cached, missing } = metaCache.partition(ids, statsById)
-      const snapshotById = await projectTitles(missing)
+      // P4：与列表构建共用持久标题索引，冷启动零解码。
+      const persisted = await hydrateFromPersist(missing, statsById)
+      for (const [id, meta] of persisted) metaCache.set(id, statsById.get(id), meta)
+      const rest = missing.filter((id) => !persisted.has(id))
+      const snapshotById = await projectTitles(rest)
+      const decoded = new Map()
+      const collectDecoded = (id, meta) => { decoded.set(id, meta) }
       for (const id of ids) {
-        let meta = cached.get(id) || null
+        let meta = cached.get(id) || persisted.get(id) || null
         if (!meta) {
           const snapshot = snapshotById.has(id)
             ? snapshotById.get(id)
             : (typeof sq.readTitleSnapshot === 'function' ? await sq.readTitleSnapshot(id).catch(() => null) : null)
           const next = metaFromSnapshot(snapshot)
           metaCache.set(id, statsById.get(id), next)
+          if (statsById.get(id)) collectDecoded(id, next)
           meta = next
         }
         if (meta && meta.title) authorityTitleCache.set(id, String(meta.title))
       }
+      persistDecoded(decoded, statsById)
     }
     return {
       titles: Object.fromEntries(authorityTitleCache),
@@ -1226,6 +1283,8 @@ export function apply(ctx) {
           if (!sid) return json(res, { ok: false, error: 'missing sessionId' }, 400)
           const out = await purgeFromTrash(sid)
           metaCache.invalidate(sid)
+          // 彻底删除：持久标题索引里的条目一并清掉（issue #1 P4）。
+          titleIndex.remove([sid]).catch(() => {})
           json(res, out)
         } catch (e) {
           json(res, { ok: false, error: String((e && e.message) || e) }, 500)
@@ -1243,7 +1302,7 @@ export function apply(ctx) {
           if (!ids || ids.length === 0) return json(res, { ok: false, error: 'missing sessionIds' }, 400)
           const results = []
           for (const sid of ids) {
-            try { results.push({ sessionId: sid, ok: true, ...(await purgeFromTrash(sid)) }); metaCache.invalidate(sid) }
+            try { results.push({ sessionId: sid, ok: true, ...(await purgeFromTrash(sid)) }); metaCache.invalidate(sid); titleIndex.remove([sid]).catch(() => {}) }
             catch (e) { results.push({ sessionId: sid, ok: false, error: String((e && e.message) || e) }) }
           }
           json(res, { ok: true, purged: results.filter((r) => r.ok).length, results })
@@ -1440,7 +1499,10 @@ export function apply(ctx) {
 
     // Auto-archive settings. A plain read (no patch keys) doubles as the lazy
     // sweep trigger — that is how the once-a-day cleanup gets a chance to run
-    // without a background timer.
+    // without a background timer. The sweep runs in the background so opening
+    // the panel never waits on it (P5, issue #1): the sweep itself already
+    // reuses the metadata caches, and this keeps the settings read latency
+    // independent of library size.
     disposers.push(ctx.webServer.register({
       kind: 'exact',
       path: '/archived-sessions/auto-archive/settings',
@@ -1450,10 +1512,20 @@ export function apply(ctx) {
           const patch = {}
           if (body && Object.prototype.hasOwnProperty.call(body, 'inactiveDays')) patch.inactiveDays = body.inactiveDays
           if (body && Object.prototype.hasOwnProperty.call(body, 'skipStarred')) patch.skipStarred = body.skipStarred
-          const settings = Object.keys(patch).length
+          const isPatch = Object.keys(patch).length > 0
+          const settings = isPatch
             ? await autoArchive.update(patch)
             : (await autoArchive.read()).settings
-          const sweep = await autoArchiveSweep()
+          let sweep
+          if (isPatch) {
+            // 显式保存设置：保持「保存即生效」的同步 sweep（含刚启用时的首次归档）。
+            sweep = await autoArchiveSweep()
+          } else {
+            // 面板打开的纯读取：sweep 转后台执行，打开延迟与库大小解耦
+            //（P5，issue #1）。sweep 本身已复用元数据缓存 + 持久标题索引。
+            void autoArchiveSweep().catch(() => {})
+            sweep = { triggered: true }
+          }
           const store = await autoArchive.read()
           json(res, {
             ok: true,

package/src/title-persist-index.js

@@ -0,0 +1,137 @@
+// title-persist-index.js — 会话标题/元数据的**磁盘**小索引（P4，issue #1）。
+//
+// metaCache（session-meta-cache.js）解决的是「进程内重复解码」；本模块解决
+// 的是冷启动：插件重启后内存缓存为空，第一次列表构建仍要全库解码一次。
+// 把解码出的元数据连同文件指纹原子写进一个 JSON 索引，重启后列表只需
+// 一次索引读 + 指纹比对，指纹没变的会话零解码。
+//
+// 结构仿 trash 的原子写索引：{ schemaVersion, entries: { [sessionId]: entry } }
+// entry = { title, cwd, createdAt, fingerprint, updatedAt }
+//   fingerprint 即 session-meta-cache.js 的 fingerprintOf(stat) 产出
+//   （"<mtimeMs>:<size>"），比对一致即可信任条目内容。
+//
+// 写入时机由调用方决定（列表构建收尾批量回写、purge 时清理），本模块只
+// 提供：读取缓存、合并写入（串行化 + 原子替换）、按 id 删除。任何文件
+// 损坏都按空索引处理，绝不阻塞列表构建。
+//
+// 单实例假设：一个进程内只 apply 一个插件实例（生产即如此），实例间的
+// 内存副本不互相同步——跨「重启」以落盘内容为准（测试亦按此断言）。
+
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+export const TITLE_INDEX_SCHEMA_VERSION = 1
+
+const MAX_ENTRIES = 20000
+
+// 条目只保留可序列化且对列表有用的字段；指纹缺失的条目无法校验，直接丢弃——
+// 宁可下次重解码，也不能把无法失效的数据当真。
+export function normalizeEntry(raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const title = typeof raw.title === 'string' ? raw.title : null
+  const cwd = typeof raw.cwd === 'string' ? raw.cwd : null
+  const createdAt = typeof raw.createdAt === 'number' ? raw.createdAt : null
+  const fingerprint = typeof raw.fingerprint === 'string' && raw.fingerprint ? raw.fingerprint : null
+  const updatedAt = typeof raw.updatedAt === 'number' ? raw.updatedAt : 0
+  if (!fingerprint || (!title && !cwd)) return null
+  return { title, cwd, createdAt, fingerprint, updatedAt }
+}
+
+export function normalizeTitleIndex(raw) {
+  const entries = {}
+  if (raw && typeof raw === 'object' && raw.entries && typeof raw.entries === 'object') {
+    for (const [id, entry] of Object.entries(raw.entries)) {
+      if (typeof id !== 'string' || !id || id.length > 200) continue
+      const normalized = normalizeEntry(entry)
+      if (normalized) entries[id] = normalized
+    }
+  }
+  return { schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries }
+}
+
+// 纯合并：right 覆盖 left 同 id 条目；截断到 MAX_ENTRIES（保留 updatedAt 新的）。
+export function mergeEntries(left, right) {
+  const merged = { ...left }
+  for (const [id, entry] of Object.entries(right)) merged[id] = entry
+  const ids = Object.keys(merged)
+  if (ids.length > MAX_ENTRIES) {
+    ids.sort((a, b) => (merged[a].updatedAt || 0) - (merged[b].updatedAt || 0))
+    for (const id of ids.slice(0, ids.length - MAX_ENTRIES)) delete merged[id]
+  }
+  return merged
+}
+
+export function createTitleIndexStore({ dir, file }) {
+  let cache = null
+  let chain = Promise.resolve()
+  const path = file || join(dir, 'title-index.json')
+
+  async function readRaw() {
+    try {
+      return normalizeTitleIndex(JSON.parse(await readFile(path, 'utf8')))
+    } catch (e) {
+      return normalizeTitleIndex(null)
+    }
+  }
+
+  // 所有写操作串行化（仿 trash 的 mutate 队列），避免并发 merge 互相覆盖。
+  function enqueue(mutator) {
+    const operation = chain.then(async () => {
+      const store = cache || (cache = (await readRaw()).entries)
+      await mutator(store)
+      return store
+    })
+    chain = operation.catch(() => {})
+    return operation
+  }
+
+  return {
+    // 只读：内存优先，未加载过才落盘一次。绝不抛错。
+    async entries() {
+      if (cache) return cache
+      cache = (await readRaw()).entries
+      return cache
+    },
+    // 批量合并写入（原子替换）。失败静默：索引只是加速器，坏了下次重解码。
+    async merge(batch) {
+      const right = {}
+      for (const [id, entry] of Object.entries(batch || {})) {
+        const normalized = normalizeEntry(entry)
+        if (normalized) right[String(id)] = normalized
+      }
+      if (!Object.keys(right).length) return false
+      await enqueue(async (store) => {
+        const next = mergeEntries(store, right)
+        await mkdir(dirname(path), { recursive: true })
+        const tmp = join(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`)
+        await writeFile(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: next }), { encoding: 'utf8', mode: 0o600 })
+        await rename(tmp, path)
+        cache = next
+      })
+      return true
+    },
+    async remove(ids) {
+      const wanted = new Set((ids || []).map(String))
+      if (!wanted.size) return false
+      await enqueue(async (store) => {
+        let changed = false
+        for (const id of wanted) {
+          if (id in store) { delete store[id]; changed = true }
+        }
+        if (!changed) return
+        await mkdir(dirname(path), { recursive: true })
+        const tmp = join(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`)
+        await writeFile(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: store }), { encoding: 'utf8', mode: 0o600 })
+        await rename(tmp, path)
+      })
+      return true
+    },
+  }
+}
+
+// 判定持久条目能否当作当前日志的解码结果：指纹一致即可（与内存缓存同一标准）。
+export function persistEntryUsable(entry, stat) {
+  const normalized = normalizeEntry(entry)
+  if (!normalized || !stat) return null
+  return normalized.fingerprint === stat.fingerprint ? normalized : null
+}