dsh-sessions-manager 3.5.3 → 3.6.0

package/src/lineage.js

@@ -0,0 +1,78 @@
+// Lineage classification for sidebar grouping (issue #6).
+//
+// All inputs come from the public list() snapshot — header + sizeBytes — so
+// classification costs zero log decoding, keeping the zero-decode listing
+// design intact. Three kinds:
+//   - subagent: official header.origin === 'subagent' (with parentSession and
+//     a delegationDepth recursion budget, both persisted by the backend)
+//   - fork branch: header.parentSession set without the subagent origin
+//   - empty: the log holds only the generation header
+//
+// The backend list snapshot carries NO eventCount, so the size test below is
+// only a cheap PRE-FILTER: since 0.1.3 it can no longer decide emptiness by
+// itself (bigger headers + a constant lifecycle-metadata frame push every
+// new log past the old baseline). The authoritative verdict comes from
+// refineEmptyLineage in index.js — an event-type scan (see below). Keep the
+// size test: it flags candidates cheaply and its false positives get
+// corrected by the precise pass.
+
+const EMPTY_BASE = 190
+
+export function isEmptyLogSize(sizeBytes, cwd) {
+  if (!Number.isFinite(sizeBytes) || sizeBytes < 0) return false
+  const cwdLen = typeof cwd === 'string' ? cwd.length : 0
+  return sizeBytes <= EMPTY_BASE + cwdLen
+}
+
+// ---- 0.1.3 空会话判定（事件类型法）---------------------------------------
+// 0.1.3 起日志结构变了：头部帧之后恒定跟一帧「生命周期元数据」
+// （permission/preset / sandbox/mode / approval/policy，实测约 150B 压缩），
+// 且头部新增 isSeeded / delegationDepth / agentPreset 等字段，压缩后整本
+// 约 300 + cwd.length 字节——上面的体积阈值（190 + cwd，alpha.2 基线）对
+// 新格式永远判不中，空白会话全部漏判。压缩体积对头部扩容/压缩器参数天生
+// 敏感，不再扩阈值，改为按事件类型判定：
+//   空会话 = 头部之外只出现生命周期元数据事件，没有任何内容事件。
+// 解码在宿主侧进行（index.js 的 refineEmptyLineage：只对压缩体积 ≤
+// EMPTY_DECODE_LIMIT 的候选调官方 inspectSession），这里只放纯函数与常量。
+//
+// 已知的生命周期事件（0.1.3-alpha.1 实测，会话创建时一次性写入）。'session'
+// 是头部行自身——inspectSession 若把头部当事件回传，它恒存在于每本日志，
+// 放行不削弱判定；任何未知类型都按内容处理（宁可漏判，不可错杀）。
+export const EMPTY_DECODE_LIMIT = 8192
+
+const LIFECYCLE_EVENT_TYPES = new Set([
+  'session',
+  'permission/preset',
+  'sandbox/mode',
+  'approval/policy',
+])
+
+/**
+ * @param {Array<string|undefined>} types 事件类型序列（不含头部也可，含头部
+ *        也可——'session' 在放行清单里）。0 条 = 头部之外无任何事件，视为空。
+ * @returns {boolean}
+ */
+export function isEmptyEventTypes(types) {
+  if (!Array.isArray(types)) return false
+  for (const t of types) {
+    if (typeof t !== 'string' || !LIFECYCLE_EVENT_TYPES.has(t)) return false
+  }
+  return true
+}
+
+// Returns a lineage record, or null when the session is an ordinary
+// top-level, non-empty session (the overwhelmingly common case — keeps the
+// sidebar-state payload small).
+export function classifyLineage(header, sizeBytes) {
+  if (!header || typeof header !== 'object') return null
+  const origin = header.origin === 'subagent' ? 'subagent' : null
+  const parentSession = typeof header.parentSession === 'string' && header.parentSession
+    ? header.parentSession
+    : null
+  const delegationDepth = Number.isSafeInteger(header.delegationDepth) && header.delegationDepth > 0
+    ? header.delegationDepth
+    : 0
+  const empty = isEmptyLogSize(sizeBytes, header.cwd)
+  if (!origin && !parentSession && !empty) return null
+  return { origin, parentSession, delegationDepth, empty }
+}

package/src/pending-moves.js

@@ -0,0 +1,126 @@
+// Deferred cross-workspace moves ("排队移动").
+//
+// 背景：0.1.5 起会话日志是**单写者**——agent-loop 在 resume 时会话时取写所有权
+// （日志旁的 session.lock 上一个 flock(2)），持有到 agent 卸载；插件既拿不到该
+// 句柄，也没有任何公共 API 能释放别人的所有权（dsh-session 服务只暴露
+// list/get/prepare/enter/fork/flush；`session/disposed` 只在持有它的 fiber 被
+// dispose 时发出）。在占用期硬搬目录会让在写者继续往旧 inode 写、并在旧路径
+// 重建空壳（2026-09-10 实测过），所以唯一安全的做法是**排队等它被释放**。
+//
+// 本模块只负责持久化队列本身（读写/去重/清理），执行时机由 index.js 决定：
+//   - 宿主释放该会话（session/disposed；0.1.5 无用户可见的关闭入口，绝大多数情况
+//     就是进程退出）→ 立刻尝试
+//   - 插件启动后（会话尚未被打开）→ 兜底尝试
+//   - 周期性轻量重试（队列为空时不启动定时器）
+// 写入沿用本仓库其他索引的模式：schemaVersion + 原子写（tmp → rename）。
+
+import { readFileSync } from 'node:fs'
+import { mkdir, rename, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const SCHEMA_VERSION = 1
+const DEFAULT_DIR = process.env.DSH_SESSIONS_MANAGER_PENDING_DIR
+  || process.env.DSH_SESSIONS_MANAGER_STAR_DIR
+  || join(homedir(), '.dsh', 'sessions-manager')
+const MAX_ITEMS = 50
+// 非"占用中"的失败（目标工作区消失、日志损坏…）留在队列里但计数；超过阈值就丢弃，
+// 避免一个永远失败的条目让每次重试都白跑。
+const MAX_ATTEMPTS = 5
+
+function isSafeId(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 200
+}
+
+function normalizeStore(raw) {
+  const items = []
+  const seen = new Set()
+  const source = raw && Array.isArray(raw.items) ? raw.items : []
+  for (const item of source) {
+    if (!item || !isSafeId(item.sessionId) || typeof item.targetPath !== 'string' || item.targetPath.length === 0) continue
+    if (seen.has(item.sessionId)) continue
+    seen.add(item.sessionId)
+    items.push({
+      sessionId: String(item.sessionId),
+      targetPath: String(item.targetPath),
+      queuedAt: Number.isFinite(item.queuedAt) ? Number(item.queuedAt) : Date.now(),
+      attempts: Number.isSafeInteger(item.attempts) && item.attempts >= 0 ? Number(item.attempts) : 0,
+    })
+    if (items.length >= MAX_ITEMS) break
+  }
+  return { schemaVersion: SCHEMA_VERSION, items }
+}
+
+/**
+ * @param {object} [options]
+ * @param {string} [options.dir] 队列所在目录（测试注入临时目录）
+ */
+export function createPendingMoveStore(options = {}) {
+  const dir = options.dir || DEFAULT_DIR
+  const indexPath = options.indexPath || join(dir, 'pending-moves.json')
+  let mutation = Promise.resolve()
+
+  async function read() {
+    try {
+      return normalizeStore(JSON.parse(readFileSync(indexPath, 'utf8')))
+    } catch (e) {
+      return normalizeStore(null)
+    }
+  }
+
+  async function write(store) {
+    await mkdir(dir, { recursive: true })
+    const tmp = join(dir, `.pending-moves-${process.pid}-${Date.now()}.tmp`)
+    await writeFile(tmp, JSON.stringify(normalizeStore(store), null, 2), { encoding: 'utf8', mode: 0o600 })
+    await rename(tmp, indexPath)
+  }
+
+  function mutate(mutator) {
+    const operation = mutation.then(async () => {
+      const store = await read()
+      const result = await mutator(store)
+      await write(store)
+      return result
+    })
+    mutation = operation.catch(() => {})
+    return operation
+  }
+
+  return {
+    indexPath,
+    dir,
+    list: async () => (await read()).items,
+    has: async (sessionId) => (await read()).items.some((item) => item.sessionId === String(sessionId)),
+    queue: (sessionId, targetPath) => mutate((store) => {
+      if (!isSafeId(sessionId) || typeof targetPath !== 'string' || targetPath.length === 0) return null
+      const existing = store.items.find((item) => item.sessionId === String(sessionId))
+      if (existing) {
+        existing.targetPath = String(targetPath)
+        existing.attempts = 0
+        return existing
+      }
+      const item = { sessionId: String(sessionId), targetPath: String(targetPath), queuedAt: Date.now(), attempts: 0 }
+      store.items.push(item)
+      if (store.items.length > MAX_ITEMS) store.items.splice(0, store.items.length - MAX_ITEMS)
+      return item
+    }),
+    remove: (sessionIds) => mutate((store) => {
+      const drop = new Set((Array.isArray(sessionIds) ? sessionIds : [sessionIds]).filter(isSafeId).map(String))
+      const before = store.items.length
+      store.items = store.items.filter((item) => !drop.has(item.sessionId))
+      return before - store.items.length
+    }),
+    bumpAttempts: (sessionId) => mutate((store) => {
+      const item = store.items.find((entry) => entry.sessionId === String(sessionId))
+      if (!item) return null
+      item.attempts += 1
+      if (item.attempts >= MAX_ATTEMPTS) {
+        store.items = store.items.filter((entry) => entry.sessionId !== item.sessionId)
+        return { dropped: true, attempts: item.attempts }
+      }
+      return { dropped: false, attempts: item.attempts }
+    }),
+  }
+}
+
+export { MAX_ITEMS, MAX_ATTEMPTS, SCHEMA_VERSION, normalizeStore }

package/src/state-temp-sweep.js

@@ -0,0 +1,42 @@
+// Stale atomic-write temp sweeper.
+//
+// 四个状态文件写入器都用「同目录 .<name>-<pid>-<ts>.tmp → rename 到正式文件」的
+// 原子写模式（star-index / auto-archive / title-persist-index / index.js 的回收站索引）。
+// 若进程在 writeFile 与 rename 之间被杀（反复重启 dsm web 时很常见），临时文件就留在
+// 目录里：实测 ~/.dsh/sessions-manager 累积了 153 个孤儿 .star-*.tmp（2026-09-10）。
+//
+// 启动时扫一遍这些目录，把「超过 maxAgeMs 没被动过」的临时文件清掉。用年龄而非 pid
+// 判定：pid 会回绕，而 1 小时的宽限期远大于任何正常写入窗口，不会碰到并发中的写入。
+
+import { readdir, rm, stat } from 'node:fs/promises'
+import { join } from 'node:path'
+
+const TEMP_NAME_RE = /^\..+-\d+-\d+\.tmp$/
+
+/**
+ * @param {string[]} dirs 需要清扫的目录（不存在时静默跳过）
+ * @param {object} [options]
+ * @param {number} [options.maxAgeMs] 只清理比这更旧的临时文件（默认 1 小时）
+ * @param {number} [options.now] 注入时钟，便于测试
+ * @returns {Promise<number>} 清理掉的临时文件数
+ */
+export async function sweepStaleStateTemps(dirs, options = {}) {
+  const maxAgeMs = Number.isSafeInteger(options.maxAgeMs) && options.maxAgeMs >= 0 ? options.maxAgeMs : 3600_000
+  const now = Number.isFinite(options.now) ? options.now : Date.now()
+  let removed = 0
+  for (const dir of Array.isArray(dirs) ? dirs : []) {
+    if (typeof dir !== 'string' || dir.length === 0) continue
+    let entries
+    try { entries = await readdir(dir) } catch (e) { continue }
+    for (const name of entries) {
+      if (!TEMP_NAME_RE.test(name)) continue
+      const path = join(dir, name)
+      let info
+      try { info = await stat(path) } catch (e) { continue }
+      if (!info.isFile()) continue
+      if (now - info.mtimeMs < maxAgeMs) continue
+      try { await rm(path, { force: true }); removed++ } catch (e) { /* 清不掉的下次再说 */ }
+    }
+  }
+  return removed
+}