@wenbin_wb/dsh-bridge 2.8.1 → 2.8.4

package/CHANGELOG.md

@@ -4,6 +4,41 @@
 
 ---
 
+## [v2.8.4] - 2026-08-26
+
+### 🗂️ 会话列表 Web 端 1:1 深度对齐与归档过滤修复
+- **🗂️ 严格按工作区账本对齐会话列表**：全面采用 DSH 官方工作区账本排序规则，自动过滤子代理派生会话、空白草稿与已归档会话，彻底解决磁盘历史孤立会话冗余列出的问题，保持 IM 端与 Web 端侧边栏 1:1 结构一致与编号精准对应。
+
+---
+
+## [v2.8.3] - 2026-08-26
+
+### 📱 微信与全平台 IM 文件收发链路全面修复与深度兼容
+- **📱 微信 iLink 官方媒体传输协议完全对齐**：
+  - 修复 `getuploadurl` 媒体类型映射，确保文件上传请求采用标准 `UploadMediaType.FILE = 3`，微信服务端正确识别文件类型与大小；
+  - 严格采用官方规范对 `CDNMedia.aes_key` 进行 `base64(hex_string)` 编码，彻底解决微信移动端/电脑端解密失败报「文件已过期/下载失败/0B」的深层问题；
+  - 精简规范 `file_item` 结构并对齐 `encrypt_type: 1`。
+- **🤖 QQ 机器人富媒体文件直传与显示修复**：
+  - 支持 `file_type: 4` 通用文件传输，适配 QQ OpenAPI v2 文件格式校验（解决此前类型不符导致的 850019 拦截）；
+  - 显式传递 `file_name`，彻底消除 QQ 聊天界面将文档显示为「未命名」的问题；
+  - 自动识别群聊与单聊端点路由（`/v2/users/{openid}/files` 与 `/v2/groups/{group_openid}/files`）。
+- **🌐 微信会话凭证（context_token）持久化机制**：
+  - 捕获微信入站消息时自动将实时安全会话凭证持久化落盘（`wechat-context-tokens.json`），并在服务启动与重启时自动载入，彻底避免凭证在重启后丢失；
+  - 完善 `ret: -2` / `prepare failed` 过期感知，当用户重新发消息时自动刷新续期。
+- **📢 多平台多端共享会话广播**：
+  - 优化同一工作区多端共享会话的广播逻辑，当任一客户端（飞书/QQ/Telegram/Web）触发生成文件时，各平台桥接器自动回退至已授权用户，实现产物文件多端同步直传。
+
+---
+
+## [v2.8.2] - 2026-08-26
+
+### 🚀 微信/IM 本地生成文件全域探测与直接推送
+- **📁 全域文件智能探测与提取**：全面支持从 PowerShell/Bash 终端脚本（`New-Item`、`Set-Content`、`Out-File`、`>`）、工具调用参数及回复文本中自动探测提取生成的文件，并结合会话工作区目录自动解析为绝对路径；
+- **🌐 微信官方 CDN 媒体上传链路修复**：严格对齐腾讯 iLink 官方 CDN `/upload` 路由子路径与 `encrypted_query_param` / `filekey` 鉴权参数，彻底解决此前上传失败的问题；
+- **💬 微信与各 IM 原生文件气泡推送**：任务结束自动将 txt/pdf/docx/xlsx/zip/png 等产物推送到聊天界面，支持直接下载查看与转发。
+
+---
+
 ## [v2.8.1] - 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 } 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）
@@ -155,6 +156,73 @@ export function textOfAssistantMessage(message) {
     .join('\n')
 }
 
+/**
+ * 尝试将任意路径（绝对或相对当前工作区）解析为真实存在的本地文件绝对路径
+ */
+export function resolveFilePath(rawPath, cwd = process.cwd()) {
+  if (typeof rawPath !== 'string') return null
+  let p = rawPath.trim()
+    .replace(/^["'`]|["'`]$/g, '')
+    .replace(/^file:\/\/\/?/, '')
+    .replace(/^[📁📄📦\s]+/, '')
+  if (!p) return null
+  // 排除 HTTP/HTTPS 网址
+  if (/^https?:\/\//i.test(p)) return null
+  const resolved = isAbsolute(p) ? normalize(p) : resolve(cwd, p)
+  try {
+    if (statSync(resolved).isFile()) {
+      return resolved
+    }
+  } catch {}
+  return null
+}
+
+/**
+ * 从模型助手回复正文或工具命令中提取所有真实存在于本地磁盘的文件绝对路径
+ */
+export function extractFilePathsFromText(text, cwd = process.cwd()) {
+  if (typeof text !== 'string' || !text.trim()) return []
+  const found = new Set()
+
+  // 1. Windows 绝对路径：C:\Users\...\file.ext 或 C:/Users/.../file.ext（支持中文、空格、特殊符号）
+  const winAbsRegex = /[A-Za-z]:[\\/][^\s"'`<>|*?()]+?\.[A-Za-z0-9_.-]+/g
+  let m
+  while ((m = winAbsRegex.exec(text)) !== null) {
+    const r = resolveFilePath(m[0], cwd)
+    if (r) found.add(r)
+  }
+
+  // 2. POSIX 绝对路径：/home/.../file.ext 或 /tmp/.../file.ext
+  const posixAbsRegex = /\/(?:[^\s"'`<>|*?()\/]+\/)+[^\s"'`<>|*?()\/]+\.[A-Za-z0-9_.-]+/g
+  while ((m = posixAbsRegex.exec(text)) !== null) {
+    const r = resolveFilePath(m[0], cwd)
+    if (r) found.add(r)
+  }
+
+  // 3. Markdown 文件链接：[name](file:///path/to/file) 或 [name](path/to/file)
+  const mdLinkRegex = /\[(?:[^\]]*)\]\((?:file:\/\/\/?)?([^)]+)\)/g
+  while ((m = mdLinkRegex.exec(text)) !== null) {
+    const r = resolveFilePath(m[1], cwd)
+    if (r) found.add(r)
+  }
+
+  // 4. 关键词或 Emoji 引用的文件路径：📁 file.txt, 保存到：file.txt, 产物文件: ...
+  const keywordRegex = /(?:📁|📄|📦|保存到[：:\s]*|生成文件[：:\s]*|文件路径[：:\s]*|产物[：:\s]*|输出文件[：:\s]*|写入文件[：:\s]*)[`"']?([^\r\n`"'\t<>|*?]+?\.[A-Za-z0-9_.-]+)[`"']?/g
+  while ((m = keywordRegex.exec(text)) !== null) {
+    const r = resolveFilePath(m[1], cwd)
+    if (r) found.add(r)
+  }
+
+  // 5. Shell 终端常用输出命令参数：-Path "...", > "...", Out-File "...", Set-Content "..."
+  const cmdRegex = /(?:-Path\s+|>\s*|Out-File\s+|Set-Content\s+|TargetFile["':\s]+|targetFile["':\s]+)[`"']?([^\r\n`"'\t<>|*?]+?\.[A-Za-z0-9_.-]+)[`"']?/gi
+  while ((m = cmdRegex.exec(text)) !== null) {
+    const r = resolveFilePath(m[1], cwd)
+    if (r) found.add(r)
+  }
+
+  return Array.from(found)
+}
+
 // ---------------------------------------------------------------------------
 // digest 摘要
 // ---------------------------------------------------------------------------
@@ -559,8 +627,11 @@ export class ConversationBridge {
       return 'routed'
     }
 
+    // 针对微信/IM客户端用户，注入上下文提示，指导 Agent 生成文件后输出明确完整路径以触发自动上传直发
+    const promptWithContext = `${fullText}\n\n<!-- [dsh-bridge 提示] 当前用户正通过【${this.platform.name}】与你对话。若用户要求生成、导出或发送文件，请将文件保存在本地磁盘并在回复中明确写出文件的完整路径（如 📁 <路径>），网关会自动把该文件上传并直接发送到用户的 ${this.platform.name} 聊天窗口。 -->`
+
     const messageValue = createUserMessage({
-      content: [{ type: 'text', text: fullText }],
+      content: [{ type: 'text', text: promptWithContext }],
       source: { kind: 'user' },
     })
     agent.followup(messageValue)
@@ -572,7 +643,7 @@ export class ConversationBridge {
 
   /** 向当前 peer 发送文本（自动分块 + typing 指示）。 */
   async sendText(text) {
-    const peer = this.peerId
+    const peer = this.peerId || this.config.allowFrom?.[0]
     if (!peer) return
     const chunks = splitForIM(text, this.config.maxMessageChars)
     if (chunks.length === 0) return
@@ -595,8 +666,9 @@ export class ConversationBridge {
 
   /** 发送 typing 状态（1=开始，2=停止）。子类可覆盖。 */
   async sendTyping(state) {
-    if (!this.platform?.sendTyping || this.peerId == null) return
-    return this.platform.sendTyping(this.peerId, state)
+    const peer = this.peerId || this.config.allowFrom?.[0]
+    if (!this.platform?.sendTyping || peer == null) return
+    return this.platform.sendTyping(peer, state)
   }
 
   // ---- 出站事件绑定 ----
@@ -630,7 +702,7 @@ export class ConversationBridge {
       }, this.config.digestIntervalSec * 1000)
       if (typeof state.heartbeat.unref === 'function') state.heartbeat.unref()
     }
-    const onEvent = (session, event) => {
+    const onEvent = async (session, event) => {
       const state = this._digestState.get(session.id) ?? { startedTurns: new Set(), createdFiles: new Set() }
       this._digestState.set(session.id, state)
 
@@ -651,17 +723,40 @@ export class ConversationBridge {
         startHeartbeat(session, state)
         return
       }
+      const getSessionCwd = (sess) => sess?.cwd || this.config.cwd || process.cwd()
+
       if (event.type === 'tool/call') {
-        const args = event.data?.parameters || event.data?.args || {}
-        const target = args.TargetFile || args.targetFile || args.target_file || args.path || args.filePath
-        if (target && typeof target === 'string') {
-          state.createdFiles.add(target)
+        const cwd = getSessionCwd(session)
+        let args = event.data?.parameters || event.data?.args || event.data?.arguments || {}
+        if (typeof args === 'string') {
+          try { args = JSON.parse(args) } catch {}
         }
+        if (typeof args === 'object' && args !== null) {
+          const possibleKeys = [
+            'TargetFile', 'targetFile', 'target_file', 'path', 'filePath', 'file',
+            'destination', 'out_file', 'output', 'ImageName', 'fileName', 'filename'
+          ]
+          for (const k of possibleKeys) {
+            const val = args[k]
+            if (val && typeof val === 'string') {
+              const clean = val.trim().replace(/^["'`]|["'`]$/g, '').replace(/^file:\/\/\/?/, '')
+              if (clean) state.createdFiles.add(clean)
+            }
+          }
+        }
+        const rawStr = JSON.stringify(event.data || {})
+        const fromRaw = extractFilePathsFromText(rawStr, cwd)
+        for (const f of fromRaw) state.createdFiles.add(f)
         return
       }
       if (event.type === 'assistant/message') {
         const text = textOfAssistantMessage(event.data.message)
-        if (text.trim()) void this.sendText(text)
+        if (text.trim()) {
+          const cwd = getSessionCwd(session)
+          const fromText = extractFilePathsFromText(text, cwd)
+          for (const f of fromText) state.createdFiles.add(f)
+          void this.sendText(text)
+        }
         return
       }
       if (event.type === 'turn/end') {
@@ -675,29 +770,40 @@ export class ConversationBridge {
         } else if (reason.kind === 'max-tokens') {
           void this.sendText(`⚠️ **达到模型单轮输出上限，本轮内容已截断**`)
         }
-        // 如果本轮生成/修改了产物文件，下发产物清单通知并尝试直接上传文件至聊天窗口
+
+        // 如果本轮生成/记录了产物文件，下发清单通知并尝试直接上传文件至聊天窗口
         if (state.createdFiles && state.createdFiles.size > 0) {
-          const files = Array.from(state.createdFiles)
-          const fileLines = files.map((f) => `- \`${f}\``).join('\n')
+          const rawFiles = Array.from(state.createdFiles)
+          const cwd = getSessionCwd(session)
+          const fileLines = rawFiles.map((f) => `- \`${f}\``).join('\n')
           void this.sendText(`📦 **本轮已生成产物文件**：\n${fileLines}`)
 
-          // 如果平台支持 sendMediaFile，自动尝试直接发送文件/图片到聊天窗口
-          if (typeof this.platform?.sendMediaFile === 'function' && this.peerId) {
-            for (const f of files) {
+          // 如果平台支持 sendMediaFile，自动尝试直接发送真实存在的文件/图片到聊天窗口（严格按绝对路径去重）
+          const targetPeer = this.peerId || this.config.allowFrom?.[0]
+          if (typeof this.platform?.sendMediaFile === 'function' && targetPeer) {
+            const uniqueFilesToSend = new Set()
+            for (const f of rawFiles) {
+              const resolved = resolveFilePath(f, cwd)
+              if (resolved) uniqueFilesToSend.add(resolved)
+            }
+            for (const resolved of uniqueFilesToSend) {
               try {
-                if (statSync(f).isFile()) {
-                  void this.platform.sendMediaFile(this.peerId, f)
+                this.logger?.info?.(`[dsh-bridge ${this.platform.id}] auto sendMediaFile to peer: ${resolved}`)
+                const res = await this.platform.sendMediaFile(targetPeer, resolved)
+                if (res && res.success === false) {
+                  this.logger?.warn?.(`[dsh-bridge ${this.platform.id}] auto sendMediaFile ${resolved} failed: %s`, res.error)
                 }
-              } catch {}
+              } catch (err) {
+                this.logger?.warn?.(`[dsh-bridge ${this.platform.id}] auto sendMediaFile ${resolved} failed: %s`, err?.message ?? err)
+              }
             }
           }
-
           state.createdFiles.clear()
         }
         return
       }
     }
-    const listener = (session, event) => onEvent(session, event)
+    const listener = (session, event) => { void onEvent(session, event) }
     const disposer = this.ctx.on('session/event', listener)
     this.disposers.push(() => {
       for (const state of digestState.values()) stopHeartbeat(state)
@@ -837,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}]。
@@ -1127,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('')
   }
@@ -1165,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()
@@ -1174,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)
@@ -1234,8 +1556,11 @@ export const conversationBridgeHelpers = {
   splitForIM,
   digestLine,
   textOfAssistantMessage,
+  resolveFilePath,
+  extractFilePathsFromText,
   sessionsInDisplayOrder,
   listSessions,
+  renderSessions,
   listWorkspaces,
   BRIDGE_MARK,
 }

package/lib/qq/gateway.js

@@ -548,18 +548,31 @@ export class QqGateway extends Service {
     if (!fs.existsSync(filePath)) return null
     const ext = path.extname(filePath).toLowerCase()
     const isImage = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp'].includes(ext)
-    const fileType = isImage ? 1 : 1
+    const isVideo = ['.mp4', '.mov', '.webm', '.avi'].includes(ext)
+    const isVoice = ['.silk', '.amr', '.wav', '.mp3'].includes(ext)
+    let fileType = 4 // 默认文件类型（txt, pdf, zip, docx, etc.）
+    if (isImage) fileType = 1
+    else if (isVideo) fileType = 2
+    else if (isVoice) fileType = 3
+
+    const scope = opts.scope || (peerId.startsWith('g_') || peerId.startsWith('group_') ? 'group' : 'user')
     try {
+      const fileName = path.basename(filePath)
       const buf = await fs.promises.readFile(filePath)
       const base64Data = buf.toString('base64')
-      const ep = this.endpoint(peerId, opts.scope, 'files')
+      const ep = this.endpoint(peerId, scope, 'files')
+      const body = {
+        file_type: fileType,
+        file_data: base64Data,
+        file_name: fileName,
+        srv_send_msg: true,
+      }
+      if (opts.msgId !== undefined) body.msg_id = opts.msgId
+      if (opts.eventId !== undefined) body.event_id = opts.eventId
+      if (opts.msgSeq !== undefined) body.msg_seq = opts.msgSeq
       const res = await this.api(ep, {
         method: 'POST',
-        body: {
-          file_type: fileType,
-          file_data: base64Data,
-          srv_send_msg: true,
-        },
+        body,
       })
       return res
     } catch (err) {

package/lib/wechat/gateway.js

@@ -57,10 +57,11 @@ const MESSAGE_DEDUP_TTL_SECONDS = 300
 /** 默认 CDN 白名单（SSRF 防护）。v0.2 媒体用到，先保留常量。 */
 const DEFAULT_CDN_ALLOWLIST = ['novac2c.cdn.weixin.qq.com']
 
-/** ret/errcode=-2 + "unknown error" 表示会话过期（而非限流）。 */
+/** ret/errcode=-2 + "unknown error" 或 "prepare failed" 表示会话/凭证过期（而非限流）。 */
 function isStaleSessionRet(ret, errcode, errmsg) {
   if (ret !== RATE_LIMIT_ERRCODE && errcode !== RATE_LIMIT_ERRCODE) return false
-  return String(errmsg ?? '').toLowerCase() === 'unknown error'
+  const msg = String(errmsg ?? '').toLowerCase()
+  return msg === 'unknown error' || msg === 'prepare failed' || msg.includes('expired') || msg.includes('token')
 }
 
 // ---------------------------------------------------------------------------
@@ -323,6 +324,15 @@ export class WechatGateway extends Service {
     this.stopPollingLocal = false
     this.statusValue = 'idle'
     this.contextTokens = new Map()
+    try {
+      const tokenFile = path.join(process.env.DSH_HOME || path.join(process.env.USERPROFILE || process.env.HOME || '.', '.dsh'), 'dsh-bridge', 'wechat-context-tokens.json')
+      if (fs.existsSync(tokenFile)) {
+        const data = JSON.parse(fs.readFileSync(tokenFile, 'utf8'))
+        for (const [k, v] of Object.entries(data)) {
+          if (v) this.contextTokens.set(k, String(v))
+        }
+      }
+    } catch {}
     this.dedup = new Map()
     this.typingTickets = new Map()
     this.rateLimitHits = []
@@ -507,13 +517,20 @@ export class WechatGateway extends Service {
    */
   async getUploadUrl({ to, mediaType, filekey, rawSize, rawFileMd5, fileSize, aesKeyHex }) {
     if (!this.configured) throw new Error('not configured')
+    // 映射 MessageItemType 到 UploadMediaType (IMAGE:1, VIDEO:2, FILE:3, VOICE:4)
+    let uploadMediaType = mediaType
+    if (mediaType === 2) uploadMediaType = 1 // IMAGE
+    else if (mediaType === 4) uploadMediaType = 3 // FILE
+    else if (mediaType === 3) uploadMediaType = 4 // VOICE
+    else if (mediaType === 5) uploadMediaType = 2 // VIDEO
+
     const resp = await postJson({
       baseUrl: this.c.baseUrl,
       endpoint: 'ilink/bot/getuploadurl',
       token: this.c.token,
       payload: {
         filekey,
-        media_type: mediaType,
+        media_type: uploadMediaType,
         to_user_id: to,
         rawsize: rawSize,
         rawfilemd5: rawFileMd5,
@@ -548,6 +565,7 @@ export class WechatGateway extends Service {
     mediaType,
     encryptedQueryParam,
     aesKeyBase64,
+    aesKeyHex,
     ciphertextSize,
     plaintextSize,
     filename,
@@ -557,15 +575,22 @@ export class WechatGateway extends Service {
     if (!this.configured) return { success: false, error: 'not configured' }
     const contextToken = this.contextTokens.get(to)
     const id = clientId ?? `dsh-bridge-wechat-${randomId()}`
-    
-    // 构建媒体项（根据类型不同字段略有差异）
+    const hexKey = aesKeyHex || (aesKeyBase64 ? Buffer.from(aesKeyBase64, 'base64').toString('hex') : '')
+
+    // 构建媒体项（全字段兼容各端微信客户端解析）
     let item
     if (mediaType === 2) { // 图片
       item = {
         type: 2,
         image_item: {
-          encrypt_query_param: encryptedQueryParam,
-          aeskey: aesKeyBase64,
+          media: {
+            encrypt_query_param: encryptedQueryParam,
+            aes_key: aesKeyBase64,
+            aeskey: hexKey,
+            encrypt_type: 1,
+          },
+          aeskey: hexKey,
+          aes_key: aesKeyBase64,
           filesize: ciphertextSize,
           rawsize: plaintextSize,
           rawfilemd5: rawFileMd5,
@@ -575,23 +600,27 @@ export class WechatGateway extends Service {
       item = {
         type: 4,
         file_item: {
-          encrypt_query_param: encryptedQueryParam,
-          aes_key: aesKeyBase64,
-          filesize: ciphertextSize,
-          rawsize: plaintextSize,
-          filename,
-          rawfilemd5: rawFileMd5,
+          file_name: filename,
+          len: String(plaintextSize),
+          media: {
+            encrypt_query_param: encryptedQueryParam,
+            aes_key: aesKeyBase64,
+            encrypt_type: 1,
+          },
         },
       }
     } else if (mediaType === 3) { // 语音
       item = {
         type: 3,
         voice_item: {
-          encrypt_query_param: encryptedQueryParam,
+          media: {
+            encrypt_query_param: encryptedQueryParam,
+            aes_key: aesKeyBase64,
+            aeskey: hexKey,
+            encrypt_type: 0,
+          },
+          aeskey: hexKey,
           aes_key: aesKeyBase64,
-          filesize: ciphertextSize,
-          rawsize: plaintextSize,
-          rawfilemd5: rawFileMd5,
           encode_type: 6, // silk
           sample_rate: 24000,
           bits_per_sample: 16,
@@ -601,7 +630,13 @@ export class WechatGateway extends Service {
       item = {
         type: 5,
         video_item: {
-          encrypt_query_param: encryptedQueryParam,
+          media: {
+            encrypt_query_param: encryptedQueryParam,
+            aes_key: aesKeyBase64,
+            aeskey: hexKey,
+            encrypt_type: 1,
+          },
+          aeskey: hexKey,
           aes_key: aesKeyBase64,
           filesize: ciphertextSize,
           rawsize: plaintextSize,
@@ -668,9 +703,11 @@ export class WechatGateway extends Service {
         aesKeyHex,
       })
 
+      const uploadUrl = uploadInfo.uploadFullUrl || `${this.c.cdnBaseUrl.replace(/\/+$/, '')}/upload?encrypted_query_param=${encodeURIComponent(uploadInfo.uploadParam)}&filekey=${encodeURIComponent(filekey)}`
+
       const encryptedParam = await uploadMedia({
         plaintext: buf,
-        uploadUrl: uploadInfo.uploadFullUrl || `${WEIXIN_CDN_BASE_URL}?upload_param=${encodeURIComponent(uploadInfo.uploadParam)}`,
+        uploadUrl,
         aesKey,
       })
 
@@ -679,6 +716,7 @@ export class WechatGateway extends Service {
         mediaType,
         encryptedQueryParam: encryptedParam,
         aesKeyBase64,
+        aesKeyHex,
         ciphertextSize: fileSize,
         plaintextSize: rawSize,
         filename,
@@ -848,7 +886,16 @@ export class WechatGateway extends Service {
     if (messageId) this.remember(messageId)
 
     const contextToken = String(message.context_token ?? '')
-    if (contextToken) this.contextTokens.set(sender, contextToken)
+    if (contextToken) {
+      this.contextTokens.set(sender, contextToken)
+      try {
+        const tokenFile = path.join(process.env.DSH_HOME || path.join(process.env.USERPROFILE || process.env.HOME || '.', '.dsh'), 'dsh-bridge', 'wechat-context-tokens.json')
+        let data = {}
+        try { if (fs.existsSync(tokenFile)) data = JSON.parse(fs.readFileSync(tokenFile, 'utf8')) } catch {}
+        data[sender] = contextToken
+        fs.writeFileSync(tokenFile, JSON.stringify(data, null, 2), 'utf8')
+      } catch {}
+    }
 
     try {
       this.ctx.emit('wechat/message', message)

package/lib/wechat/index.js

@@ -85,6 +85,10 @@ export class WechatService extends Platform {
     return this.gateway.sendMedia({ ...media, to: peerId, ...opts })
   }
 
+  async sendMediaFile(peerId, filePath, opts = {}) {
+    return this.gateway.sendMediaFile(peerId, filePath)
+  }
+
   /** 合并展示状态给浏览器 UI（保持 v1.x 字段结构，新增 id/name/capabilities）。 */
   getStatus() {
     const allowFrom = [...(this.node.config.allowFrom ?? [])]

package/lib/wechat/media.js

@@ -114,11 +114,11 @@ export function normalizeAesKey(input) {
 }
 
 /**
- * 生成用于 iLink API 的 aes_key 字段（上传时用）。
- * iLink 期望 base64(hex_string)，不是 base64(raw_bytes)。
+ * 生成用于 iLink API CDNMedia 的 aes_key 字段（上传时用）。
+ * iLink 协议规范：aes_key 必须先转 hex 字符串，再 base64 编码（base64(hex_string)）。
  */
 export function encodeAesKeyForApi(keyBytes) {
-  const hexStr = keyBytes.toString('hex')
+  const hexStr = Buffer.isBuffer(keyBytes) ? keyBytes.toString('hex') : Buffer.from(keyBytes).toString('hex')
   return Buffer.from(hexStr, 'ascii').toString('base64')
 }
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@wenbin_wb/dsh-bridge",
-  "version": "2.8.1",
+  "version": "2.8.4",
   "description": "手机扫码即可在移动端/公网继续用 DeepSeek Harness，人不在电脑前也能接着干。一键局域网二维码、Cloudflare 公网隧道、自建隧道与微信 / QQ / 飞书 / Telegram Bot（多工作区/会话持久化/媒体/卡片审批/流式输出），无需自己搭公网服务器。",
-  "releaseNotes": "【v2.8.1 微信/IM 消息分块保护与流式体验修复】\n• 🛡️ 修复微信/IM 平台单条消息分块字符数因异常配置被切成 20 字符碎片的问题\n• ⚙️ 增加消息分块字符数全局安全下限防御（自动纠偏并保底为平台标准容量）\n• 💬 恢复微信/各平台完整段落与 Markdown 代码块的原生一次性下发",
+  "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": {