dsh-sessions-manager 3.6.2 → 3.7.0

package/src/client/logic.js

@@ -177,3 +177,288 @@ export function toastDurationFor(text, kind) {
   const scaled = kind === 'err' ? Math.round(readingMs * 1.25) : readingMs
   return Math.min(TOAST_MAX_MS, Math.max(TOAST_MIN_MS, scaled))
 }
+
+// —— T2（3.7.0）：排队移动终局通知的文案与投递计划（纯函数，可 node --test）——
+// host 把每次后台终局（成功/放弃）落成通知经 sidebar-state 带出；client 用本地
+// 已见集合过滤后弹一次 toast，并 ack 已展示项。投递策略全部收敛在这里，
+// index.jsx 只做接线。
+
+export function pathTail(p) {
+  const parts = String(p == null ? '' : p).split(/[\\/]+/).filter(Boolean)
+  return parts.length ? parts[parts.length - 1] : ''
+}
+
+export function moveNoticeText(n) {
+  const id = shortId(n && n.sessionId)
+  if (n && n.kind === 'moved') {
+    const where = pathTail(n.targetPath)
+    return `排队中的移动已完成：${id}${where ? ` → 「${where}」` : ''}`
+  }
+  const reason = String((n && n.reason) || '').split('\n')[0].slice(0, 120)
+  return `排队中的移动多次失败已放弃：${id}${reason ? `（${reason}）` : ''}，可在 设置 → 会话管理 → 待移动队列 重新发起移动`
+}
+
+/**
+ * 一次侧栏拉取里的通知投递计划。
+ * @param raw      sidebar-state 的 moveNotices 数组（可能缺失/畸形——一律宽容）
+ * @param seenIds  本浏览器已展示过的通知 id 集合（多 tab 即时去重）
+ * @param max      单次最多展示几条真实通知，超出并入省略句
+ * @returns {{ text: string|null, kind: 'ok'|'err', ackIds: string[] }}
+ *          ackIds 只含**已展示**项——未展示的留在服务端，下一拍继续（TTL 兜底）。
+ */
+export function noticeToastPlan(raw, seenIds, max = 2) {
+  const list = (Array.isArray(raw) ? raw : [])
+    .filter((n) => n && typeof n.id === 'string' && typeof n.sessionId === 'string' && (n.kind === 'moved' || n.kind === 'abandoned') && !seenIds.has(String(n.id)))
+    .sort((a, b) => (a.at || 0) - (b.at || 0))
+  if (!list.length) return { text: null, kind: 'ok', ackIds: [] }
+  const shown = list.slice(Math.max(0, list.length - Math.max(1, max)))
+  const parts = shown.map(moveNoticeText)
+  if (list.length > shown.length) parts.push(`另有 ${list.length - shown.length} 条排队移动的结果，见 设置 → 会话管理 → 待移动队列`)
+  return {
+    text: parts.join('；'),
+    kind: shown.some((n) => n.kind === 'abandoned') ? 'err' : 'ok',
+    ackIds: shown.map((n) => String(n.id)),
+  }
+}
+
+// —— T3（3.7.0）：分支聚拢 ——
+// 把「同一父会话派生出的普通分支会话」归组，收拢到组锚（真实父行或合成头）
+// 之下。子代理已由 foldSubagents 先行摘除，本函数只处理非子代理的分支血缘。
+// 判定全部收敛为纯函数，供列表管线在 foldSubagents 之后调用；UI 接线不在此处。
+
+// 组内时间键：createdAt（>0）优先；缺失/非正回退 updatedAt——它是 host 后加的
+// 字段，老快照或尚未同步的行可能根本没有，必须宽容；两者都不可用按 0，交给
+// sessionId 决胜。
+export function branchTimeKey(item) {
+  const c = Number(item && item.createdAt)
+  if (Number.isFinite(c) && c > 0) return c
+  const u = Number(item && item.updatedAt)
+  if (Number.isFinite(u) && u > 0) return u
+  return 0
+}
+
+// 组内升序比较：时间差优先，决胜恒为 sessionId 字典序——即使宿主哪天给所有行
+// 都补上 createdAt，排序仍全序稳定、可复现。同毫秒/同零值也靠决胜定序。
+export function ascBranchTime(a, b) {
+  const ta = String((a && a.sessionId) ?? '')
+  const tb = String((b && b.sessionId) ?? '')
+  return branchTimeKey(a) - branchTimeKey(b) || ta.localeCompare(tb)
+}
+
+// 分支血缘边：lineage[id] 存在、origin 非 subagent、parentSession 非空且不
+// 自指，才返回父 id；否则 null（该行不是分支，不参与聚拢）。
+// 子代理即便漏进输入（上游本该是 foldSubagents 之后的 topList）也被 origin
+// 挡下——链上链下两层都锁，绝不入组。
+function branchParentOf(id, table) {
+  const info = table[id]
+  if (!info || typeof info !== 'object') return null
+  if (info.origin === 'subagent') return null
+  const p = info.parentSession ? String(info.parentSession) : null
+  if (!p || p === id) return null
+  return p
+}
+
+/**
+ * 分支聚拢：把普通分支会话（lineage 有 parentSession、非子代理、不自指）移入
+ * 组锚的分支组。
+ *
+ * 输入契约：items 应为 foldSubagents 之后的 topList（子代理已摘除）；lineage
+ * 形状 {id:{origin,parentSession,delegationDepth,empty}}。任何畸形输入（items
+ * 或 lineage 为 null、数组含洞/非对象行、lineage 非对象）都不得抛错——认不出
+ * 血缘的行一律原样留在顶层。
+ *
+ * 组锚解析（memo 化）：沿 parentSession 上溯，锚 = 链上第一个「在 items 中且
+ * 自身非分支」的行；父在 items 但也是分支 → 继续上溯（整条链拍平进同一组）；
+ * 父不在 items → 合成锚 = 链尾那个缺失父 id。visited Set + 步数上限防环；成
+ * 环的整条链不聚拢（行不丢，原地保 chip）；自指不算分支。
+ *
+ * 真实锚父行在 topList 中的位置纹丝不动；成员行从 topList 移出进 branchGroupsOf。
+ * 仅当锚是合成的（缺失父）才产出头行 {syntheticRoot:rootId, sessionId:'dsm-src:'+rootId}，
+ * 插入位置 = 组内最早成员（ascBranchTime 排序后的第一个）在原列表中的下标；
+ * 成员 ≥1 就出合成头（单孤儿与多孤儿统一规则）。组内恒按 ascBranchTime 升序
+ * （与调用方主排序方向无关）。
+ *
+ * 守恒不变量：topList 中非合成行数 + foldedCount === items.length（行不丢）。
+ *
+ * @param items 任意（应为 foldSubagents 之后的 topList 数组；畸形宽容）
+ * @param lineage 任意（血缘表 {id:{origin,parentSession,...}}；畸形宽容）
+ * @returns {{ topList: any[], branchGroupsOf: Map<string, any[]>, foldedCount: number, groupCount: number }}
+ *   topList 真实锚原位保留（或插入合成头行），branchGroupsOf 为 rootId → 升序
+ *   成员数组，foldedCount 为移出顶层的成员行数，groupCount 为组数。
+ */
+export function foldBranches(items, lineage) {
+  const list = Array.isArray(items) ? items : []
+  const table = lineage && typeof lineage === 'object' ? lineage : {}
+
+  const byId = new Map()
+  for (const it of list) {
+    if (it == null || it.sessionId == null) continue
+    byId.set(String(it.sessionId), it)
+  }
+
+  // 1) 组锚解析：向上走 parent 链。防环 = 访问集 + 步数上限（链上每个 id 至多
+  //    出现一次，上限只是兜底）；结果按起点 id memo。
+  const maxWalk = Object.keys(table).length + list.length + 2
+  const anchorMemo = new Map()
+  function resolveAnchor(id) {
+    if (anchorMemo.has(id)) return anchorMemo.get(id)
+    const seen = new Set([id])
+    let cur = id
+    let steps = 0
+    let anchor = null // null = 环 / 起点不是分支，整链不聚
+    while (true) {
+      const p = branchParentOf(cur, table)
+      if (!p) {
+        // cur 不是分支：起点若不是分支则不聚；否则停在祖先上，cur 即锚
+        // （循环不变量：除首轮外 cur 恒为分支，此分支只在起点命中）。
+        anchor = steps === 0 ? null : cur
+        break
+      }
+      if (seen.has(p)) break // 成环：anchor 保持 null
+      seen.add(p)
+      steps++
+      if (byId.has(p)) {
+        if (!branchParentOf(p, table)) {
+          anchor = p // p 在列表且自身非分支 → 真实锚
+          break
+        }
+        cur = p // p 在列表但也是分支 → 继续上溯（链拍平）
+        if (steps > maxWalk) break // 环：保持 null
+        continue
+      }
+      // p 不在列表：还是分支 → 继续上溯找更高祖先；否则合成锚 = p
+      if (!branchParentOf(p, table)) {
+        anchor = p
+        break
+      }
+      cur = p
+      if (steps > maxWalk) break // 环：保持 null
+    }
+    anchorMemo.set(id, anchor)
+    return anchor
+  }
+
+  // 2) 收集分组。anchorOfRow 按行对象记录锚（重复 id 的畸形行也各算各的），
+  //    foldedCount 按行计数——保证守恒律在含洞/重复 id 的输入下仍成立。
+  const groupsOf = new Map()
+  const anchorOfRow = new Map()
+  let foldedCount = 0
+  for (const it of list) {
+    if (it == null || it.sessionId == null) continue
+    const id = String(it.sessionId)
+    if (!branchParentOf(id, table)) continue // 非分支 / 子代理 / 自指 → 不动
+    const anchor = resolveAnchor(id)
+    if (!anchor || anchor === id) continue // 环 / 自锚异常 → 保持顶层可见
+    if (!groupsOf.has(anchor)) groupsOf.set(anchor, [])
+    groupsOf.get(anchor).push(it)
+    anchorOfRow.set(it, anchor)
+    foldedCount++
+  }
+
+  // 3) 组内升序（与主排序方向无关）；合成锚的组记下最早成员（升序第一个），
+  //    合成头将在它原来的位置插一次。
+  const earliest = new Set()
+  for (const [anchor, members] of groupsOf) {
+    members.sort(ascBranchTime)
+    if (!byId.has(anchor)) earliest.add(members[0])
+  }
+
+  // 4) topList 重建：非成员行（含畸形行）原样保序；成员行移出，合成组在最早
+  //    成员的原位置放一次合成头行。
+  const topList = []
+  const emitted = new Set()
+  for (const it of list) {
+    const anchor = it == null ? undefined : anchorOfRow.get(it)
+    if (anchor === undefined) {
+      topList.push(it)
+      continue
+    }
+    if (!byId.has(anchor) && !emitted.has(anchor) && earliest.has(it)) {
+      emitted.add(anchor)
+      topList.push({ syntheticRoot: anchor, sessionId: 'dsm-src:' + anchor })
+    }
+  }
+
+  // 空组防御（正常路径每组成员 ≥1，不产出空组）。
+  for (const [anchor, members] of groupsOf) {
+    if (!members.length) groupsOf.delete(anchor)
+  }
+  return { topList, branchGroupsOf: groupsOf, foldedCount, groupCount: groupsOf.size }
+}
+
+// —— T4（3.7.0）：标签筛选 + 已存筛选 ——
+// 标签与已存筛选是纯用户元数据：host 已把每会话的 tagId 列表挂到 /sessions 的
+// item.tags 上，筛选谓词只认这个字段。UI 接线全部在 index.jsx；这里收敛可测的
+// 判定与文案。
+
+/**
+ * 标签筛选（v1 单选）：tagId 为空串 / null / undefined 时原样返回输入列表
+ * （同一数组，不做拷贝）；否则返回 tags 数组含该 id 的子集。
+ * 为什么只做单选：多标签 AND 需要「已选标签集」这份额外界面状态，收益不抵
+ * 复杂度和与已存筛选快照格式的纠缠；v1 明确不追多选 AND，管理页的「合并」
+ * 已能覆盖主要的归并诉求。
+ * 宽容性：list 非数组按空表；条目缺 tags / tags 非数组 / id 是数字都不得抛错，
+ * 统一按「不匹配」处理（id 比较走字符串化，防 host 与本地 id 类型漂移）。
+ * @param list any（应为 /sessions 返回的条目数组，条目带 tags:[tagId]）
+ * @param tagId string|null|undefined ''/null 表示不按标签筛选
+ * @returns any[]
+ */
+export function applyTagFilter(list, tagId) {
+  const items = Array.isArray(list) ? list : []
+  if (!tagId) return items
+  const want = String(tagId)
+  return items.filter((item) => {
+    const tags = item && item.tags
+    return Array.isArray(tags) && tags.some((t) => String(t) === want)
+  })
+}
+
+// 删除标签的确认文案。红线：必须明说「只删标签，不会删除会话」——本插件一切
+// 标签操作都是纯元数据，但用户在「删除」字样上默认会联想到丢会话，含糊一次
+// 就再也骗不回来（见 star/标签路由注释的同一纪律）。单测锁关键词（copy-guard
+// 的替身：文案生成收敛为纯函数，防回归锁在 client-logic 测试里）。
+export function tagDeleteConfirm(name) {
+  return `删除标签「${String(name == null ? '' : name) || '(未命名)'}」？只删标签，不会删除会话；打过这个标签的会话只是失去它。`
+}
+
+// 已存筛选快照的字段域：视图与排序必须落在已知枚举里，否则应用一个不存在的
+// 视图会把面板带进没有 tab 的状态。workspace 只验「非空字符串」——工作区可能
+// 已删，删了也允许恢复（筛选结果为 0 行，用户可理解）；tag 允许 ''（=全部）。
+const SAVED_VIEWS = ['all', 'active', 'archived', 'starred', 'empty', 'trash']
+const SAVED_SORTS = ['newest', 'oldest', 'title']
+
+/**
+ * 把面板当前筛选态抓成可持久化的快照（/filters/save 的 filters 载荷）。
+ * 载荷字段名固定 {view, workspace, sort, tag}；host 侧对本体不透明（opaque
+ * payload），跨版本兼容全靠这里 + filterShapeFromSaved 两端夹逼。
+ * 入参任何字段非法都先回落默认再落盘，保存的永远是干净快照。
+ */
+export function filterSnapshotOf({ filter = 'all', workspaceFilter = 'all', sortBy = 'newest', tagFilter = '' } = {}) {
+  return {
+    view: SAVED_VIEWS.includes(filter) ? filter : 'all',
+    workspace: typeof workspaceFilter === 'string' && workspaceFilter ? workspaceFilter : 'all',
+    sort: SAVED_SORTS.includes(sortBy) ? sortBy : 'newest',
+    tag: typeof tagFilter === 'string' ? tagFilter : '',
+  }
+}
+
+/**
+ * 把一条已存筛选（/filters/list 的 item）还原成面板筛选形状；任何非法字段
+ * 回落默认，并在 degraded 数组里标注该字段名——UI 据此提示「部分条件已失效，
+ * 已按默认处理」，绝不静默吞掉。脏数据宽容：item/filters 缺失、为数组、字段
+ * 类型不对，统统不抛错。
+ * @returns {{view:string, workspace:string, sort:string, tag:string, degraded:string[]}}
+ */
+export function filterShapeFromSaved(item) {
+  const f = item && item.filters && typeof item.filters === 'object' && !Array.isArray(item.filters) ? item.filters : {}
+  const degraded = []
+  let view = typeof f.view === 'string' && SAVED_VIEWS.includes(f.view) ? f.view : 'all'
+  if (view === 'all' && f.view !== 'all') degraded.push('view')
+  let workspace = typeof f.workspace === 'string' && f.workspace ? f.workspace : 'all'
+  if (workspace === 'all' && f.workspace !== 'all') degraded.push('workspace')
+  let sort = typeof f.sort === 'string' && SAVED_SORTS.includes(f.sort) ? f.sort : 'newest'
+  if (sort === 'newest' && f.sort !== 'newest') degraded.push('sort')
+  let tag = typeof f.tag === 'string' ? f.tag : ''
+  if (tag === '' && f.tag !== '') degraded.push('tag')
+  return { view, workspace, sort, tag, degraded }
+}

package/src/empty-scan-index.js

@@ -0,0 +1,118 @@
+// empty-scan-index.js — 空白会话精判结论的**磁盘**缓存（3.7.0 / T1 refine 解绑）。
+//
+// 背景：精判（对 ≤8KB 小日志按事件类型判空白）原先只在 sidebar-state 的请求路径里
+// 同步跑，进程内 Map 缓存重启即全冷——分支标签延迟审计的根因之一。T1 把精判挪进
+// 后台队列后，本模块让「已判定」跨重启复用：指纹未变的会话直接沿用结论，零解码。
+//
+// 纪律（全部沿用 title-persist-index / session-meta-cache 的既定红线）：
+//   1. 只有**真正解码成功**的结论才允许落盘；解码失败按「非空」兜底只进进程内，
+//      绝不固化成跨重启的判定（v3.6.1 #1 的教训：一次失败被永久记下）。
+//   2. rev: 指纹（实例内 opaque token）在 normalizeEntry 处硬性拦截，与
+//      title-persist-index.js 同一道防线。
+//   3. 任何文件损坏 → 当空索引，绝不阻塞侧栏数据；坏 db 的代价是重判，不是错数据。
+//
+// 条目形状 { empty: 0|1, fingerprint: "<mtime:size>" | "sz:<n>", updatedAt }
+
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+export const EMPTY_SCAN_SCHEMA_VERSION = 1
+
+const MAX_ENTRIES = 20000
+
+export function normalizeEntry(raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const empty = raw.empty === 1 || raw.empty === true ? 1 : raw.empty === 0 || raw.empty === false ? 0 : null
+  const fingerprint = typeof raw.fingerprint === 'string' && raw.fingerprint ? raw.fingerprint : null
+  const updatedAt = typeof raw.updatedAt === 'number' ? raw.updatedAt : 0
+  if (empty === null || !fingerprint || fingerprint.startsWith('rev:')) return null
+  return { empty, fingerprint, updatedAt }
+}
+
+export function normalizeEmptyScanIndex(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: EMPTY_SCAN_SCHEMA_VERSION, entries }
+}
+
+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 createEmptyScanStore({ dir, file }) {
+  let cache = null
+  let chain = Promise.resolve()
+  const path = file || join(dir, 'empty-scan.json')
+
+  async function readRaw() {
+    try {
+      return normalizeEmptyScanIndex(JSON.parse(await readFile(path, 'utf8')))
+    } catch (e) {
+      return normalizeEmptyScanIndex(null)
+    }
+  }
+
+  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), `.empty-scan-${process.pid}-${Date.now()}.tmp`)
+        await writeFile(tmp, JSON.stringify({ schemaVersion: EMPTY_SCAN_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), `.empty-scan-${process.pid}-${Date.now()}.tmp`)
+        await writeFile(tmp, JSON.stringify({ schemaVersion: EMPTY_SCAN_SCHEMA_VERSION, entries: store }), { encoding: 'utf8', mode: 0o600 })
+        await rename(tmp, path)
+      })
+      return true
+    },
+  }
+}