@wenbin_wb/dsh-bridge 2.8.3 → 2.8.4

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ---
 
+## [v2.8.4] - 2026-08-26
+
+### 🗂️ 会话列表 Web 端 1:1 深度对齐与归档过滤修复
+- **🗂️ 严格按工作区账本对齐会话列表**：全面采用 DSH 官方工作区账本排序规则，自动过滤子代理派生会话、空白草稿与已归档会话，彻底解决磁盘历史孤立会话冗余列出的问题，保持 IM 端与 Web 端侧边栏 1:1 结构一致与编号精准对应。
+
+---
+
 ## [v2.8.3] - 2026-08-26
 
 ### 📱 微信与全平台 IM 文件收发链路全面修复与深度兼容

package/lib/platform/conversation-bridge.js

@@ -19,9 +19,10 @@
 
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { randomUUID } from 'node:crypto'
-import { statSync } from 'node:fs'
+import { statSync, existsSync, readFileSync } from 'node:fs'
 import { stat } from 'node:fs/promises'
-import { resolve, normalize, basename, isAbsolute } from 'node:path'
+import { join, resolve, normalize, basename, isAbsolute } from 'node:path'
+import { homedir } from 'node:os'
 import { isSafeWorkspacePath } from '../security/path-validator.js'
 
 // 纯文本标记（用户偏好不用 emoji）
@@ -942,45 +943,261 @@ function foldTitle(events) {
   return null
 }
 
-// 列出会话：使用 DSH 官方 API（ctx.sessions + sessionPersistence），与 web 端一致。
-// 屏蔽已归档会话。返回 [{ id, createdAt, events?, seq?, cwd?, title? }]，按时间倒序。
-async function listSessions(node) {
-  // 归档会话 ID 集合
-  let archived = new Set()
-  try { archived = new Set(node.ctx.workspaceRegistry?.archivedSessionIds ?? []) } catch { /* ignore */ }
-  const live = [...(node.ctx.sessions?.list() ?? [])].filter((s) => !archived.has(s.id))
-  const liveIds = new Set(live.map((s) => s.id))
-  // 内存活跃会话（带完整 events/title）
-  const liveMapped = live.map((s) => {
+/** 获取所有已归档会话 ID 集合（支持 ctx.workspaceRegistry 内存服务 + workspace.json 文件存储双重兜底） */
+function getArchivedSessionIds(ctx) {
+  const archived = new Set()
+  // 1. 尝试从 ctx.workspaceRegistry 内存服务读取
+  try {
+    const list = ctx?.workspaceRegistry?.archivedSessionIds
+    if (Array.isArray(list)) {
+      for (const id of list) {
+        if (id) archived.add(String(id))
+      }
+      return archived
+    }
+  } catch { /* ignore */ }
+
+  // 2. 尝试从 DSH workspace 存储文件（$DSH_HOME/storages/workspace.json）读取兜底
+  if (!ctx?._mock) {
     try {
-      const title = foldTitle(s.events ?? [])
-      if (title) return { id: s.id, createdAt: s.header?.createdAt ?? 0, events: s.events, seq: s.seq, cwd: s.header?.cwd, title }
+      const home = process.env.DSH_HOME || join(homedir(), '.dsh')
+      const wsFile = join(home, 'storages', 'workspace.json')
+      if (existsSync(wsFile)) {
+        const data = JSON.parse(readFileSync(wsFile, 'utf8'))
+        const fileArchived = data?.global?.archivedSessionIds
+        if (Array.isArray(fileArchived)) {
+          for (const id of fileArchived) {
+            if (id) archived.add(String(id))
+          }
+        }
+      }
     } catch { /* ignore */ }
-    return { id: s.id, createdAt: s.header?.createdAt ?? 0, events: s.events, seq: s.seq, cwd: s.header?.cwd }
-  })
-  // 持久化会话（含 cwd，与 web 端过滤一致）
-  let cold = []
+  }
+
+  return archived
+}
+
+/** 读取 DSH 官方持久化会话缓存元数据（标题、是否空白、创建时间等） */
+function getSessionProjCache(ctx) {
+  if (ctx?._mock) return {}
   try {
-    const headers = await node.ctx.sessionPersistence?.list?.()
-    if (Array.isArray(headers)) {
-      const coldHeaders = headers.filter((h) => h && h.id && !liveIds.has(h.id) && h.cwd !== undefined && !archived.has(h.id))
-      // 分批加载以避免并发过载（每批 10 个）
-      const BATCH_SIZE = 10
-      for (let i = 0; i < coldHeaders.length; i += BATCH_SIZE) {
-        const batch = coldHeaders.slice(i, i + BATCH_SIZE)
-        const batchResults = await Promise.all(batch.map(async (h) => {
-          let title
+    const home = process.env.DSH_HOME || join(homedir(), '.dsh')
+    const cacheFile = join(home, 'storages', 'session_projcache.json')
+    if (existsSync(cacheFile)) {
+      const data = JSON.parse(readFileSync(cacheFile, 'utf8'))
+      return data?.tables?.sessions || {}
+    }
+  } catch { /* ignore */ }
+  return {}
+}
+
+/** 读取 DSH 官方注册的工作区列表及各自绑定的 sessionIds 列表 */
+async function getRegisteredWorkspaces(ctx) {
+  const workspaces = []
+
+  // 优先从内存服务获取
+  if (ctx?.workspaceRegistry) {
+    try {
+      const list = await ctx.workspaceRegistry.list?.()
+      if (Array.isArray(list)) {
+        for (const w of list) {
+          if (w && w.path) {
+            workspaces.push({
+              id: w.id || w.path,
+              path: w.path,
+              title: w.title || basename(w.path),
+              sessionIds: Array.isArray(w.sessionIds) ? [...w.sessionIds] : [],
+            })
+          }
+        }
+        return workspaces
+      }
+    } catch { /* ignore */ }
+  }
+
+  // 兜底从 workspace.json 存储文件读取
+  if (!ctx?._mock) {
+    try {
+      const home = process.env.DSH_HOME || join(homedir(), '.dsh')
+      const wsFile = join(home, 'storages', 'workspace.json')
+      if (existsSync(wsFile)) {
+        const data = JSON.parse(readFileSync(wsFile, 'utf8'))
+        const wsIds = data?.global?.workspaceIds || Object.keys(data?.tables?.workspaces || {})
+        const table = data?.tables?.workspaces || {}
+        for (const wId of wsIds) {
+          const ws = table[wId]
+          if (ws && ws.path) {
+            workspaces.push({
+              id: wId,
+              path: ws.path,
+              title: ws.title || basename(ws.path),
+              sessionIds: Array.isArray(ws.sessionIds) ? [...ws.sessionIds] : [],
+            })
+          }
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  return workspaces
+}
+
+function isSubagentSession(cacheRow, liveSession) {
+  if (liveSession?.origin === 'subagent' || liveSession?.header?.origin === 'subagent') return true
+  const subVal = cacheRow?.rows?.subagent?.val
+  if (subVal && typeof subVal === 'object' && Object.keys(subVal).length > 0) return true
+  return false
+}
+
+// 列出会话：严格对齐 DSH Web 端侧边栏会话树逻辑。
+// 1. 过滤已归档会话 (archivedSessionIds)
+// 2. 过滤未发起提问的空白会话 (blank: true)
+// 3. 过滤子代理内部会话 (subagent origin)
+// 4. 严格按工作区账本 (workspace.sessionIds) 组织
+async function listSessions(node) {
+  const archived = getArchivedSessionIds(node.ctx)
+  const projCache = getSessionProjCache(node.ctx)
+  const workspaces = await getRegisteredWorkspaces(node.ctx)
+
+  // 内存活跃会话（按 id 索引）
+  const liveList = [...(node.ctx.sessions?.list?.() ?? [])].filter(
+    (s) => s && s.id && !archived.has(s.id) && !s.archived && !s.header?.archived
+  )
+  const liveById = new Map(liveList.map((s) => [s.id, s]))
+
+  const accounted = new Set()
+  const result = []
+
+  // 1. 如果存在已注册的工作区，严格按工作区及其 sessionIds 账本组织（与 Web 端完全一致）
+  if (workspaces.length > 0) {
+    for (const ws of workspaces) {
+      const normWsPath = ws.path ? normalize(ws.path).toLowerCase() : ''
+
+      // 优先将当前工作区下新创建但在内存里的 live 会话追加到头部
+      for (const s of liveList) {
+        const sCwd = s.header?.cwd || s.cwd
+        if (sCwd && normalize(sCwd).toLowerCase() === normWsPath && !accounted.has(s.id)) {
+          if (isSubagentSession(projCache[s.id], s)) continue
+          accounted.add(s.id)
+          let title = s.title || (s.events ? foldTitle(s.events) : '')
+          if (!title) {
+            const cache = projCache[s.id]
+            title = cache?.rows?.title?.val || cache?.rows?.goal?.val
+          }
+          result.push({
+            id: s.id,
+            createdAt: s.header?.createdAt || Date.now(),
+            cwd: ws.path,
+            workspaceTitle: ws.title,
+            title: title || '新会话',
+            events: s.events,
+            seq: s.seq ?? 0,
+          })
+        }
+      }
+
+      // 按工作区账本存储的 sessionIds 顺序追加已记录会话
+      for (const sId of ws.sessionIds) {
+        if (archived.has(sId) || accounted.has(sId)) continue
+        accounted.add(sId)
+
+        const cache = projCache[sId]
+        const live = liveById.get(sId)
+        // 过滤空白草稿会话（非当前活动会话）
+        if (cache?.rows?.sessionListMetadata?.val?.blank === true && sId !== node.activeSessionId) {
+          continue
+        }
+        // 过滤子代理内部会话
+        if (isSubagentSession(cache, live)) {
+          continue
+        }
+
+        let title = cache?.rows?.title?.val || cache?.rows?.goal?.val
+        let createdAt = cache?.identity?.createdAt || 0
+        let cwd = ws.path
+
+        // 如果内存有该会话，提取最新数据
+        if (live) {
+          title = live.title || (live.events ? foldTitle(live.events) : '') || title
+          createdAt = live.header?.createdAt || createdAt
+        } else if (!title && node.ctx.sessionPersistence?.load) {
           try {
-            const insp = await node.ctx.sessionPersistence.load(h.id)
+            const insp = await node.ctx.sessionPersistence.load(sId)
             title = foldTitle(insp.events ?? []) ?? undefined
-          } catch { /* 标题提取失败则只用 id */ }
-          return { id: h.id, createdAt: h.createdAt ?? 0, events: undefined, seq: 0, cwd: h.cwd, title }
-        }))
-        cold.push(...batchResults)
+          } catch {}
+        }
+
+        result.push({
+          id: sId,
+          createdAt,
+          cwd,
+          workspaceTitle: ws.title,
+          title: title || '新会话',
+          events: live?.events,
+          seq: live?.seq ?? 0,
+        })
       }
     }
-  } catch { /* 持久化服务不可用时仅返回内存会话 */ }
-  return [...liveMapped, ...cold].sort((a, b) => b.createdAt - a.createdAt || b.seq - a.seq)
+
+    // 处理当前内存中处于活动状态但未绑定任何工作区的 live 会话
+    for (const s of liveList) {
+      if (accounted.has(s.id)) continue
+      if (isSubagentSession(projCache[s.id], s)) continue
+      accounted.add(s.id)
+      const title = s.title || (s.events ? foldTitle(s.events) : '') || '未分组会话'
+      result.push({
+        id: s.id,
+        createdAt: s.header?.createdAt || Date.now(),
+        cwd: s.header?.cwd || '(未指定)',
+        workspaceTitle: '未指定工作区',
+        title,
+        events: s.events,
+        seq: s.seq ?? 0,
+      })
+    }
+  } else {
+    // 2. 如果系统未注册任何工作区（如单目录/无工作区模式），降级读取内存及持久化会话
+    for (const s of liveList) {
+      accounted.add(s.id)
+      const title = s.title || (s.events ? foldTitle(s.events) : '') || '活跃会话'
+      result.push({
+        id: s.id,
+        createdAt: s.header?.createdAt || Date.now(),
+        cwd: s.header?.cwd || '(未指定)',
+        workspaceTitle: '未指定工作区',
+        title,
+        events: s.events,
+        seq: s.seq ?? 0,
+      })
+    }
+    if (node.ctx.sessionPersistence?.list) {
+      try {
+        const headers = await node.ctx.sessionPersistence.list()
+        if (Array.isArray(headers)) {
+          const coldHeaders = headers.filter((h) => h && h.id && !accounted.has(h.id) && !archived.has(h.id) && !h.archived)
+          for (const h of coldHeaders) {
+            accounted.add(h.id)
+            let title
+            try {
+              const insp = await node.ctx.sessionPersistence.load(h.id)
+              title = foldTitle(insp.events ?? []) ?? undefined
+            } catch {}
+            result.push({
+              id: h.id,
+              createdAt: h.createdAt ?? 0,
+              events: undefined,
+              seq: 0,
+              cwd: h.cwd || '(未指定)',
+              workspaceTitle: '未指定工作区',
+              title: title || '新会话',
+            })
+          }
+        }
+      } catch {}
+    }
+  }
+
+  return result
 }
 
 // 列出可用工作区：使用 DSH 官方 workspaceRegistry。返回 [{title, path}]。
@@ -1232,37 +1449,38 @@ async function renderSessions(node) {
   if (all.length === 0) {
     return `## 📋 会话列表\n\n> 暂无历史会话。发送 \`/new <提示词>\` 开始新会话。`
   }
-  // 按工作区（真实 cwd）分组；无 cwd 的归入 '(未指定)'
+  // 按工作区分组（保持 listSessions 中的工作区账本顺序）
   const groups = new Map()
   for (const s of all) {
     const key = s.cwd || '(未指定)'
-    if (!groups.has(key)) groups.set(key, [])
-    groups.get(key).push(s)
+    if (!groups.has(key)) {
+      groups.set(key, { title: s.workspaceTitle || getWorkspaceBasename(key), sessions: [] })
+    }
+    groups.get(key).sessions.push(s)
   }
-  const sortedGroups = [...groups.entries()].sort((a, b) => String(a[0]).localeCompare(String(b[0])))
   const parts = [
     `## 📋 会话列表 (共 ${all.length} 个)`,
     `> 切换会话：发送 \`/use 编号\` 或 \`/resume 编号\``,
     '',
   ]
   let idx = 0
-  for (const [cwd, sessions] of sortedGroups) {
-    const groupName = cwd === '(未指定)' ? '📁 未指定工作区' : `📁 **${getWorkspaceBasename(cwd)}**`
+  for (const [cwd, group] of groups) {
+    const groupName = cwd === '(未指定)' ? '📁 未指定工作区' : `📁 **${group.title || getWorkspaceBasename(cwd)}**`
     parts.push(groupName)
     parts.push('')
     parts.push('| 序号 | 会话标题 / 摘要 | 时间 | 状态 |')
     parts.push('| :--- | :--- | :--- | :--- |')
-    for (const session of sessions.slice(0, 20)) {
+    for (const session of group.sessions.slice(0, 20)) {
       idx += 1
       const isActive = session.id === node.activeSessionId
       const statusTag = isActive ? '`[当前]`' : '-'
       const rawTitle = session.title || (session.events ? sessionLabel(session) : '')
-      const safeTitle = (rawTitle || '新会话 (待输入)').replace(/\|/g, '｜').replace(/\r?\n/g, ' ')
+      const safeTitle = (rawTitle || '新会话').replace(/\|/g, '｜').replace(/\r?\n/g, ' ')
       const when = session.createdAt ? fmtTime(session.createdAt) : '-'
       parts.push(`| **#${idx}** | ${safeTitle} | ${when} | ${statusTag} |`)
     }
-    if (sessions.length > 20) {
-      parts.push(`*…该工作区共 ${sessions.length} 个会话，仅显示前 20 个*`)
+    if (group.sessions.length > 20) {
+      parts.push(`*…该工作区共 ${group.sessions.length} 个会话，仅显示前 20 个*`)
     }
     parts.push('')
   }
@@ -1270,7 +1488,7 @@ async function renderSessions(node) {
   return parts.join('\n').trim()
 }
 
-// 与 renderSessions 完全一致的显示顺序：按工作区字母序分组、组内保持 listSessions 顺序。
+// 与 renderSessions 完全一致的显示顺序：保持 listSessions 中的分组和顺序。
 // /use N 用这个数组索引，保证显示的编号 N 与切换的会话一一对应。
 function sessionsInDisplayOrder(all) {
   const groups = new Map()
@@ -1279,8 +1497,7 @@ function sessionsInDisplayOrder(all) {
     if (!groups.has(key)) groups.set(key, [])
     groups.get(key).push(s)
   }
-  const sortedGroups = [...groups.entries()].sort((a, b) => String(a[0]).localeCompare(String(b[0])))
-  return sortedGroups.flatMap(([, sessions]) => sessions)
+  return [...groups.values()].flatMap((sessions) => sessions)
 }
 
 // 时间戳 → 简洁可读时间 (MM-DD HH:mm 或 YYYY-MM-DD HH:mm)
@@ -1343,6 +1560,7 @@ export const conversationBridgeHelpers = {
   extractFilePathsFromText,
   sessionsInDisplayOrder,
   listSessions,
+  renderSessions,
   listWorkspaces,
   BRIDGE_MARK,
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@wenbin_wb/dsh-bridge",
-  "version": "2.8.3",
+  "version": "2.8.4",
   "description": "手机扫码即可在移动端/公网继续用 DeepSeek Harness，人不在电脑前也能接着干。一键局域网二维码、Cloudflare 公网隧道、自建隧道与微信 / QQ / 飞书 / Telegram Bot（多工作区/会话持久化/媒体/卡片审批/流式输出），无需自己搭公网服务器。",
-  "releaseNotes": "【v2.8.3 微信与全平台 IM 文件收发链路全面修复与深度兼容】\n• 📱 微信 iLink 官方媒体传输协议完全对齐：修复 getuploadurl 文件媒体类型枚举（media_type=3）与 AES 密钥规范编码（base64(hex)），彻底解决手机端「文件已过期/下载失败/0B」问题\n• 🤖 QQ 机器人富媒体文件直传修复：支持 file_type=4 通用文件传输并显式传递 file_name，彻底消除「未命名」卡片显示\n• 🌐 微信会话凭证（context_token）持久化机制：自动捕获并持久化落盘实时安全凭证，重启服务永不丢失会话上下文\n• 📢 多平台多端共享会话广播：同一会话在任一端（飞书/QQ/TG/Web）生成产物文件时，自动同步广播推送到所有已绑定的 IM 客户端",
+  "releaseNotes": "【v2.8.4 会话列表 Web 端 1:1 深度对齐与归档过滤修复】\n• 🗂️ 严格按工作区账本对齐会话列表：修复会话列表展示冗余，严格以 DSH 官方工作区账本为准，自动过滤子代理派生会话、空白草稿与已归档会话，与 Web 端侧边栏 1:1 保持一致",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -27,6 +27,7 @@
     "build:lark": "node scripts/bundle-lark.mjs",
     "build:banner": "node scripts/generate-banner.mjs",
     "prepack": "npm run build:lark && npm run build:client",
+    "release:github": "node scripts/create-github-release.mjs",
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {