dsh-sessions-manager 3.7.2 → 3.7.4

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.7.2",
+  "version": "3.7.4",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -58,14 +58,14 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-workspace": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session-persistence-jsonl": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session-query": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-storage-domain": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-host-webserver": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-workspace": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-session-persistence-jsonl": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-session-query": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-storage-domain": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-runtime": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings": ">=0.1.0-rc.6",
     "react": "^18.2.0"
   },
   "allowScripts": {

package/src/active-session.js

@@ -0,0 +1,87 @@
+// 活跃会话（host 侧）追踪。
+//
+// 背景：0.1.7 / 0.2.0 把「当前选中哪个会话」这件事完全放到了客户端——
+// uiWorkspace 持有 mainView 的会话引用，host 进程里根本不存在
+// activeSession / currentSession / sessions.active 任何一个访问器（实测三个
+// 探测全部落空）。而 host 又必须知道「这个会话是不是用户正在看的那个」：
+//   - 移动：活跃会话被写锁持有，动盘要排到 DSH 释放之后（409 / 排队）
+//   - 自动归档：正在看的会话不该被默默归档掉
+// host 自己证明不了，只能由能看到 UI 状态的客户端心跳上报。
+//
+// 设计取舍：
+//   * 按 clientId 分桶——浏览器端与 Desktop 端可能同时连着同一个 host，各自看
+//     的会话不同，只留一份会互相顶掉。
+//   * 只采信「新鲜」的心跳（TTL）。客户端面板关闭 / 标签页隐藏 / 进程退出后
+//     心跳停止，过期数据必须失效：宁可漏判（放行移动，移动路径本身有备份+
+//     回滚和写锁兜底），也不拿陈旧数据把用户早已切走的会话一直锁死。
+//   * 上报 null/空 = 该客户端当前没有活跃会话，删掉它的桶（而不是留旧值）。
+
+export const DEFAULT_ACTIVE_TTL_MS = 45 * 1000
+// 桶数量上限：clientId 由客户端生成，理论无限。超过就先清过期的，再清最旧的，
+// 防止异常客户端（每次刷新换 id）把 Map 撑大。
+export const MAX_ACTIVE_REPORTS = 32
+
+// 与 host 侧会话 id 校验同源（src/index.js isSafeSessionId）：会话 id 会参与
+// 日志路径拼接，含路径分隔符的脏数据必须挡在外面。
+function isUsableSessionId(value) {
+  return typeof value === 'string'
+    && value.length > 0
+    && value.length <= 200
+    && !/[\\/\0]/.test(value)
+    && value !== '.'
+    && value !== '..'
+}
+
+export function createActiveSessionTracker(options = {}) {
+  const ttl = Number.isFinite(options.ttlMs) ? Number(options.ttlMs) : DEFAULT_ACTIVE_TTL_MS
+  const now = typeof options.now === 'function' ? options.now : () => Date.now()
+  /** @type {Map<string, {id: string, at: number}>} */
+  const reports = new Map()
+
+  function trim(at) {
+    for (const [key, value] of reports) if (at - value.at > ttl) reports.delete(key)
+    while (reports.size > MAX_ACTIVE_REPORTS) {
+      const oldest = reports.keys().next().value
+      if (oldest === undefined) break
+      reports.delete(oldest)
+    }
+  }
+
+  /**
+   * Record one client's currently-open session.
+   * @param {string} clientId
+   * @param {string|null} sessionId - null clears this client's slot.
+   * @returns {boolean} whether it was accepted.
+   */
+  function report(clientId, sessionId, at = now()) {
+    const key = typeof clientId === 'string' && clientId ? clientId.slice(0, 64) : 'default'
+    if (sessionId === null || sessionId === undefined || sessionId === '') {
+      reports.delete(key)
+      return true
+    }
+    if (!isUsableSessionId(sessionId)) return false
+    reports.set(key, { id: String(sessionId), at })
+    trim(at)
+    return true
+  }
+
+  /**
+   * Freshly reported active session ids (any connected client).
+   * @returns {Set<string>}
+   */
+  function activeIds(at = now()) {
+    const out = new Set()
+    for (const [key, value] of reports) {
+      if (at - value.at > ttl) { reports.delete(key); continue }
+      out.add(value.id)
+    }
+    return out
+  }
+
+  return {
+    report,
+    activeIds,
+    get size() { return reports.size },
+    clear() { reports.clear() },
+  }
+}

package/src/auto-archive.js

@@ -62,6 +62,9 @@ export function normalizeAutoArchiveStore(raw) {
  * @param {number} [options.now] - Reference timestamp (tests inject it).
  * @param {boolean} [options.skipStarred=true] - Keep starred sessions.
  * @param {string|null} [options.activeSessionId] - Never archive the open one.
+ * @param {Array<string>} [options.activeSessionIds] - Same, for several clients
+ *   (browser + desktop can each hold their own open session). Takes precedence
+ *   over `activeSessionId` when given.
  * @returns {string[]} Session ids to archive.
  */
 export function pickInactiveCandidates(items, options = {}) {
@@ -70,7 +73,11 @@ export function pickInactiveCandidates(items, options = {}) {
   const now = Number.isFinite(options.now) ? options.now : Date.now()
   const cutoff = now - days * DAY_MS
   const skipStarred = options.skipStarred !== false
-  const activeId = options.activeSessionId != null ? String(options.activeSessionId) : null
+  const activeIds = new Set(
+    Array.isArray(options.activeSessionIds)
+      ? options.activeSessionIds.map((id) => String(id))
+      : options.activeSessionId != null ? [String(options.activeSessionId)] : [],
+  )
   const list = Array.isArray(items) ? items : []
 
   const out = []
@@ -81,7 +88,7 @@ export function pickInactiveCandidates(items, options = {}) {
     if (seen.has(id)) continue
     if (item.archived) continue
     if (skipStarred && item.starred) continue
-    if (activeId !== null && id === activeId) continue
+    if (activeIds.has(id)) continue
     const updatedAt = Number(item.updatedAt)
     // No usable timestamp → cannot prove it is idle → leave it alone.
     if (!Number.isFinite(updatedAt) || updatedAt <= 0) continue

package/src/client/index.jsx

@@ -244,15 +244,58 @@ async function postJSON(path, body) {
 
 // 打开一个会话（尤其是侧栏不渲染的子代理会话）。
 //
-// 只走官方公开契约（runtime 的 client api-catalog）：
-//   sessions.open(id)                 —— 选中会话为当前
-//   sessions.refreshSubagents(parent) —— 刷新某父会话的直接子代理目录
-//   sessions.openSubagent(address)    —— 用「直接父 + 子」地址打开目录里的子代理
-// 拿不到 sessions 服务（老 runtime）时返回 false，由调用方给出降级提示，绝不
-// 触碰任何私有内部状态。
+// 只走官方公开契约，按方法存在性分支、不写死核心版本：
+//   旧核心（≤0.1.6）  ctx.get('sessions') 自带
+//     sessions.open(id)                 —— 选中会话为当前
+//     sessions.refreshSubagents(parent) —— 刷新某父会话的直接子代理目录
+//     sessions.openSubagent(address)    —— 用「直接父 + 子」地址打开目录里的子代理
+//   新核心（0.1.7+ / 0.2.0+）sessions 退化为会话数据流服务（retain/release/
+//     readPage…，没有 open），切换会话的公开入口是 uiWorkspace.openSession(target)：
+//     target 为会话 id 字符串，或 {parentSessionId, childSessionId, mode} 子代理
+//     地址（与旧 openSubagent 契约同形，replaceMain 经 sessions.retain 原生支持；
+//     id 命中已加载目录的子代理时核心会自动解析地址）。核心侧栏点会话走的就是
+//     这条路径（dsh-workspace-kit 0.1.12 起同样从 ctx.sessions.open 迁移过来）。
+// 拿不到任何服务时返回 null，由调用方给出降级提示，绝不触碰私有内部状态。
 let dsmClientCtx = null
 function dsmSessionsService() {
-  try { return dsmClientCtx && typeof dsmClientCtx.get === 'function' ? dsmClientCtx.get('sessions') : null } catch (e) { return null }
+  try {
+    if (!dsmClientCtx || typeof dsmClientCtx.get !== 'function') return null
+    const native = dsmClientCtx.get('sessions')
+    if (native && (typeof native.open === 'function' || typeof native.openSubagent === 'function')) return native
+    const ui = dsmClientCtx.get('uiWorkspace')
+    if (!ui || typeof ui.openSession !== 'function') return native
+    let lastOpened = null
+    const bridge = {
+      open(id) {
+        if (id === null || id === undefined) return
+        const target = String(id)
+        // 地址未加载的子代理会在这里被核心拒绝（unknown session），调用方
+        // 依赖抛错落回 openSubagent 地址路径，因此不吞异常。
+        ui.openSession(target)
+        lastOpened = target
+      },
+      openSubagent(address) {
+        if (address === null || address === undefined) return
+        if (typeof address === 'object') {
+          // 逐字段原样透传（parentSessionId / childSessionId / mode），新核心
+          // 的 retain 直接以该地址解析历史路由。
+          ui.openSession(address)
+          lastOpened = String(address.childSessionId)
+        } else {
+          bridge.open(address)
+        }
+      },
+      // 新核心的子代理目录由投影自动维护，无需手动刷新。
+      refreshSubagents() {},
+    }
+    // dsmCurrentSessionId 走 list.getSnapshot().current 校验切换结果；桥接下
+    // 核心未公开等价快照，以自己最近一次成功提交的目标为准。
+    Object.defineProperty(bridge, 'list', {
+      configurable: true,
+      get() { return { getSnapshot: () => ({ current: lastOpened }) } },
+    })
+    return bridge
+  } catch (e) { return null }
 }
 function dsmCurrentSessionId(svc) {
   try {
@@ -293,6 +336,73 @@ async function dsmOpenSessionById(childId, directParentId) {
   return 'failed'
 }
 
+// ---- 活跃会话上报：host 判定「用户正在看哪个会话」的唯一来源 ----------------
+//
+// 0.1.7+ / 0.2.x 的 host 进程里没有 activeSession / currentSession /
+// sessions.active 任何一个访问器（实测三个探测全部落空），它根本无从判断用户在
+// 看哪个会话——但必须判断，否则两条保护形同虚设：
+//   * 移动：活跃会话被写锁持有，硬动盘要排队（409 / queued）
+//   * 自动归档：正在看的会话不该被默默归档掉
+// 能看到 UI 状态的是客户端，所以由它周期性上报；host 只在心跳新鲜期内采信
+// （见 src/active-session.js 的 TTL 说明：过期即失效，宁可漏判也不误判）。
+//
+// 探测顺序：uiWorkspace 的 selection 快照（持久化在 dsh.sessions.current，即
+// 启动时恢复的那个选中项，最权威）→ uiWorkspace 的 mainView 引用（mainReference）
+// → 旧核心 sessions.list.getSnapshot().current。
+// 前两者是客户端服务对象上的字段，全部 try/catch 包裹：上游改名/重构只会退化成
+// 「探测不到」（放行移动，移动路径本身有写锁 + 备份回滚兜底），不会抛错。
+const DSM_CLIENT_ID = (() => {
+  try {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') return crypto.randomUUID()
+  } catch (e) { /* 非安全上下文没有 randomUUID */ }
+  return `c${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`
+})()
+
+export function dsmActiveSessionId() {
+  try {
+    if (!dsmClientCtx || typeof dsmClientCtx.get !== 'function') return null
+    const ui = dsmClientCtx.get('uiWorkspace')
+    if (ui) {
+      const snap = ui.selection && typeof ui.selection.getSnapshot === 'function' ? ui.selection.getSnapshot() : null
+      if (snap && snap.sessionId != null) return String(snap.sessionId)
+      const ref = ui.mainReference
+      if (ref && ref.sessionId != null) return String(ref.sessionId)
+    }
+    const native = dsmClientCtx.get('sessions')
+    if (native && native.list && typeof native.list.getSnapshot === 'function') {
+      const snap = native.list.getSnapshot()
+      if (snap && snap.current != null) return String(snap.current)
+    }
+  } catch (e) { /* 服务不可用/字段不存在 */ }
+  return null
+}
+
+const DSM_ACTIVE_HEARTBEAT_MS = 15000
+const DSM_ACTIVE_MIN_REPORT_MS = 30000
+let dsmLastActiveReport = { id: null, at: 0 }
+
+/**
+ * 上报当前会话。心跳（force=false）在「值没变 + 距上次不足 30s」时跳过网络请求；
+ * force=true 用于移动前强制同步——用户在心跳间隔内刚切过会话时，host 手里还是旧值。
+ */
+async function reportActiveSession(force) {
+  const id = dsmActiveSessionId()
+  const now = Date.now()
+  if (!force && id === dsmLastActiveReport.id && now - dsmLastActiveReport.at < DSM_ACTIVE_MIN_REPORT_MS) return
+  dsmLastActiveReport = { id, at: now }
+  try {
+    await postJSON('/archived-sessions/active-session', { clientId: DSM_CLIENT_ID, sessionId: id })
+  } catch (e) { /* host 未就绪 / 路由缺失：静默，下个心跳再试 */ }
+}
+
+// 移动类请求：先同步一次活跃会话，再发真正的移动请求。否则 host 拿旧值放行，
+// 移动中的会话恰好是用户刚切过去的那个（写锁持有 → 只能排队，UI 上表现为「排队」
+// 而不是「已移动」——不算错，但用户点之前本可以选别的会话）。
+async function postActiveAware(path, body) {
+  await reportActiveSession(true).catch(() => null)
+  return postJSON(path, body)
+}
+
 // Left-nav icon swap: DSH's settings shell renders a shared fallback gear for
 // every custom section and settings.section has no per-section icon field.
 // Like dsh-better-sidebar, we mark our own row by matching its visible label
@@ -1277,7 +1387,7 @@ function SessionPanel({ workspacesSvc }) {
     if (!targetPath) { setError('请选择已有工作区或输入新的目标目录路径'); return }
     setBusy(it.sessionId)
     setError(null)
-    postJSON('/archived-sessions/move', { sessionId: it.sessionId, targetPath })
+    postActiveAware('/archived-sessions/move', { sessionId: it.sessionId, targetPath })
       .then((r) => {
         setBusy(null)
         setOpenMove(null)
@@ -1337,7 +1447,7 @@ function SessionPanel({ workspacesSvc }) {
     setBusy('__batch__')
     setError(null)
     setRetry(null)
-    postJSON('/archived-sessions/move-many', { sessionIds: ids, targetPath })
+    postActiveAware('/archived-sessions/move-many', { sessionIds: ids, targetPath })
       .then((r) => {
         setBusy(null)
         setBatchMoveOpen(false)
@@ -2713,7 +2823,7 @@ function installSidebarSessionMenuAug() {
           e.preventDefault()
           closeSub()
           closeMenu()
-          postJSON('/archived-sessions/move', { sessionId: info.id, targetPath: w.path })
+          postActiveAware('/archived-sessions/move', { sessionId: info.id, targetPath: w.path })
             .then((r) => {
               // 会话被 DSH 打开（活跃/未关闭）时服务端只登记排队：磁盘与工作区分组都没动。
               // 这条路径原先无条件报「移动成功」——2026-09-10 用户报的「说移动成功但还在
@@ -3458,7 +3568,7 @@ function installSidebarWorkspaceDrag() {
     clearVisuals()
     row.classList.add('dsm-drag-busy')
     try {
-      const result = await postJSON('/archived-sessions/move', { sessionId: item.sessionId, targetPath: target.path })
+      const result = await postActiveAware('/archived-sessions/move', { sessionId: item.sessionId, targetPath: target.path })
       // 会话被 DSH 打开时服务端只登记排队：磁盘与工作区分组都没动。这条路径绝不能
       // 本地改行 + 报成功——那会让用户以为移动已完成，而侧栏刷新后该行又跳回原工作区
       //（用户 2026-09-10 报的「说移动成功但还在原工作区」就是这个）。排队时只如实说明。
@@ -3524,6 +3634,20 @@ function installSidebarWorkspaceDrag() {
 export function apply(ctx) {
   dsmClientCtx = ctx
   dsmLoadCapabilities()
+  // 活跃会话心跳：页面隐藏时不发（用户没在看；host 侧 TTL 到期后自然失效，
+  // 于是「无法证明活跃」→ 放行移动，不会把会话永久锁死）。
+  const beat = () => {
+    if (typeof document !== 'undefined' && document.hidden) return
+    reportActiveSession(false).catch(() => {})
+  }
+  beat()
+  const beatTimer = setInterval(beat, DSM_ACTIVE_HEARTBEAT_MS)
+  const beatAc = typeof AbortController !== 'undefined' ? new AbortController() : null
+  if (beatAc && typeof document !== 'undefined' && document.addEventListener) {
+    // 标签页重新可见：立刻补一次（切回来后第一件事就可能是移动）。
+    document.addEventListener('visibilitychange', () => { if (!document.hidden) beat() }, { signal: beatAc.signal })
+  }
+  ctx.effect(() => () => { clearInterval(beatTimer); if (beatAc) beatAc.abort() })
   installSettingsNavIcons(ctx)
   installSidebarSessionMenuAug()
   // 侧栏增强的卸载清退挂到 cordis effect：插件停用/HMR 时 interval、

package/src/index.js

@@ -24,6 +24,7 @@ import { createAutoArchiveStore, pickInactiveCandidates } from './auto-archive.j
 import { createSessionMetaCache, fingerprintOf, persistFingerprintOf } from './session-meta-cache.js'
 import { createTitleIndexStore } from './title-persist-index.js'
 import { createEmptyScanStore } from './empty-scan-index.js'
+import { createActiveSessionTracker } from './active-session.js'
 import { createPersistenceAdapter } from './compat/persistence.js'
 import { detectCapabilities, requireCapability } from './compat/capabilities.js'
 import { pathOwnsSession } from './path-guard.js'
@@ -124,7 +125,12 @@ function requireSessionId(value) {
 // few known accessors for the active id; if none is available we return null
 // and callers should treat the session as movable (the move path is
 // crash-safe via backup+rollback and re-syncs the live object afterwards).
-function getActiveSessionId(context) {
+//
+// 这些访问器只在旧核心（≤0.1.6）里存在。0.1.7+ / 0.2.x 把「当前选中哪个会话」
+// 完全移到了客户端（uiWorkspace 持 mainView 引用），host 侧三个探测全部落空 →
+// 恒 null。所以真正的判定入口是下面的 getActiveSessionIds（客户端心跳优先），
+// 这个函数退化为旧核心的兜底探测。
+function legacyActiveSessionId(context) {
   try {
     const a = context.get('activeSession')
     if (a != null) return (a && a.id != null) ? a.id : (typeof a === 'string' ? a : null)
@@ -140,6 +146,15 @@ function getActiveSessionId(context) {
   return null
 }
 
+// 活跃会话判定：优先采信客户端心跳（0.1.7+ 唯一可信来源），没有心跳才退回旧核心
+// 访问器探测。心跳过期/没有客户端连接 → 空集合，调用方按「无法证明活跃」处理。
+function getActiveSessionIds(context, tracker) {
+  const reported = tracker ? tracker.activeIds() : null
+  if (reported && reported.size) return reported
+  const legacy = legacyActiveSessionId(context)
+  return legacy != null ? new Set([String(legacy)]) : new Set()
+}
+
 // foldTitle（v3.6.1 删除路径的兜底折叠）随 v3.6.2 #7 的「删除路径零解码」一并
 // 移除；标题折叠逻辑的权威实现现在是 runtime 投影（src/index.js projectTitlesStatus）。
 
@@ -162,6 +177,9 @@ export function apply(ctx) {
   // T1（3.7.0）：空白精判结论的持久层。只有**真解码成功**的判定落盘（unknown
   // 与失败兜底都不是结论），sz 指纹 + 14 天 TTL 双闸门防「同尺寸原地改写」。
   const emptyIndex = createEmptyScanStore({ dir: TRASH_DIR })
+  // 活跃会话（客户端心跳上报，见 src/active-session.js）：0.1.7+ host 侧无法
+  // 自行判断「用户正在看哪个会话」，靠客户端周期性上报。过期即失效。
+  const activeTracker = createActiveSessionTracker()
   const EMPTY_VERDICT_TTL_MS = 14 * 24 * 3600 * 1000
 
   // P4：对「内存缓存未命中」的会话查持久索引，指纹一致才可信。
@@ -960,8 +978,9 @@ export function apply(ctx) {
     // merely looked at. When the host exposes no active-session accessor we
     // can't prove activeness, so we allow the move; the relocation below is
     // crash-safe (backup + rollback) and re-syncs the live object.
-    const activeId = getActiveSessionId(ctx)
-    if (activeId != null && String(activeId) === String(sid)) {
+    const activeIds = getActiveSessionIds(ctx, activeTracker)
+    const activeId = activeIds.values().next().value != null ? activeIds.values().next().value : null
+    if (activeIds.has(String(sid)) || (activeId != null && String(activeId) === String(sid))) {
       const error = new Error('会话正被 DSH 打开，暂时无法移动；请重启 DSH 后再试。')
       error.status = 409
       error.code = 'DSM_SESSION_BUSY'
@@ -1559,7 +1578,7 @@ export function apply(ctx) {
     const candidates = pickInactiveCandidates(items, {
       inactiveDays: days,
       skipStarred: store.settings.skipStarred,
-      activeSessionId: getActiveSessionId(ctx),
+      activeSessionIds: [...getActiveSessionIds(ctx, activeTracker)],
       now,
     })
     let archived = 0
@@ -1906,6 +1925,25 @@ export function apply(ctx) {
       handler: async (req, res) => json(res, { ...capabilities, buildStamp: BUILD_STAMP }),
     }))
 
+    // 活跃会话心跳（客户端 → host）。0.1.7+ 起 host 无从得知 UI 当前选中了哪个
+    // 会话（见 src/active-session.js），只能由客户端上报；host 只在心跳新鲜期内
+    // 采信，用它拦住「移动正在看的会话」和「自动归档正在看的会话」。
+    // body: { clientId, sessionId|null }。sessionId 为空 = 该客户端当前无活跃会话。
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/active-session',
+      handler: async (req, res) => {
+        const body = await readJsonBody(req)
+        const clientId = body && typeof body.clientId === 'string' ? body.clientId : 'default'
+        const sid = body && typeof body.sessionId === 'string' && body.sessionId ? body.sessionId : null
+        const accepted = activeTracker.report(clientId, sid)
+        json(res, {
+          ok: accepted,
+          activeSessionIds: [...activeTracker.activeIds()],
+        })
+      },
+    }))
+
     disposers.push(ctx.webServer.register({
       kind: 'exact',
       path: '/archived-sessions/list',