@wenbin_wb/dsh-bridge 2.8.3 → 2.8.5

package/CHANGELOG.md

@@ -4,6 +4,22 @@
 
 ---
 
+## [v2.8.5] - 2026-08-27
+
+### 🎯 产物文件推送改为 AI 指令驱动 & 修复 IM 平台断开连接问题
+- **🎯 显式文件发送协议**：由 AI 通过 `[SEND_FILE: <路径>]` 显式驱动文件直传，杜绝修改代码时的文件误发风暴；
+- **🧹 聊天正文自动净化**：自动剔除聊天窗口中的文件发送指令，保持聊天气泡清爽；
+- **🔌 修复 IM 断开连接失效**：修复 QQ 等网关断开连接时 WebSocket 事件悬挂问题，断开后彻底阻断入站消息与出站回复。
+
+---
+
+## [v2.8.4] - 2026-08-26
+
+### 🗂️ 会话列表 Web 端 1:1 深度对齐与归档过滤修复
+- **🗂️ 严格按工作区账本对齐会话列表**：全面采用 DSH 官方工作区账本排序规则，自动过滤子代理派生会话、空白草稿与已归档会话，彻底解决磁盘历史孤立会话冗余列出的问题，保持 IM 端与 Web 端侧边栏 1:1 结构一致与编号精准对应。
+
+---
+
 ## [v2.8.3] - 2026-08-26
 
 ### 📱 微信与全平台 IM 文件收发链路全面修复与深度兼容

package/lib/feishu/gateway.js

@@ -205,6 +205,7 @@ export class FeishuGateway extends Service {
   // ---- 消息收发 ----
 
   async _handleMessageReceive(data) {
+    if (this._closing || this.status === 'offline') return
     if (!data?.message) return
     const { message, sender } = data
     const messageId = message.message_id

package/lib/feishu/node.js

@@ -107,6 +107,7 @@ export class FeishuConversationNode extends ConversationBridge {
   }
 
   async _handleInbound(event) {
+    if (this.gateway?._closing || this.gateway?.status === 'offline') return
     const { peerId, senderId, isGroup, text, messageId, messageType, contentObj } = event
     this._lastPeer = { peerId, senderId, isGroup }
 

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, extname, isAbsolute } from 'node:path'
+import { homedir } from 'node:os'
 import { isSafeWorkspacePath } from '../security/path-validator.js'
 
 // 纯文本标记（用户偏好不用 emoji）
@@ -177,49 +178,41 @@ export function resolveFilePath(rawPath, cwd = process.cwd()) {
 }
 
 /**
- * 从模型助手回复正文或工具命令中提取所有真实存在于本地磁盘的文件绝对路径
+ * 提取并过滤文本中的 [SEND_FILE: <path>] 显式发送指令
+ * 由 AI 根据用户意图显式决定何时向用户发送文件附件，杜绝底层盲目扫描与误发。
+ * @param {string} text - 原始助手回复文本
+ * @param {string} cwd - 会话当前工作目录
+ * @returns {{ cleanText: string, files: string[] }}
  */
-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)
+export function extractAndStripSendFileDirectives(text, cwd = process.cwd()) {
+  if (typeof text !== 'string' || !text.trim()) {
+    return { cleanText: text || '', files: [] }
   }
 
-  // 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)
-  }
+  const files = []
+  const directiveRegex = /\[(?:SEND_FILE|SEND-FILE|send_file|send-file|SEND_MEDIA|send_media):\s*[`"']?([^\]`"'\r\n]+?)[`"']?\s*\]/gi
 
-  // 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)
+  let m
+  const re = new RegExp(directiveRegex)
+  while ((m = re.exec(text)) !== null) {
+    const rawPath = m[1].trim()
+    const resolved = resolveFilePath(rawPath, cwd)
+    if (resolved && !files.includes(resolved)) {
+      files.push(resolved)
+    }
   }
 
-  // 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)
-  }
+  // 从聊天正文中彻底剔除控制指令（保持 IM 聊天气泡的干净整洁）
+  const cleanText = text.replace(directiveRegex, '').replace(/\n{3,}/g, '\n\n').trim()
 
-  // 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 { cleanText, files }
+}
 
-  return Array.from(found)
+/**
+ * 提取文本中的产物文件路径（基于显式指令）
+ */
+export function extractFilePathsFromText(text, cwd = process.cwd()) {
+  return extractAndStripSendFileDirectives(text, cwd).files
 }
 
 // ---------------------------------------------------------------------------
@@ -626,8 +619,8 @@ export class ConversationBridge {
       return 'routed'
     }
 
-    // 针对微信/IM客户端用户，注入上下文提示，指导 Agent 生成文件后输出明确完整路径以触发自动上传直发
-    const promptWithContext = `${fullText}\n\n<!-- [dsh-bridge 提示] 当前用户正通过【${this.platform.name}】与你对话。若用户要求生成、导出或发送文件，请将文件保存在本地磁盘并在回复中明确写出文件的完整路径（如 📁 <路径>），网关会自动把该文件上传并直接发送到用户的 ${this.platform.name} 聊天窗口。 -->`
+    // 针对微信/IM客户端用户，注入上下文提示，规范 Agent 仅在需要向用户发送文件附件时输出 [SEND_FILE: <文件绝对路径>]
+    const promptWithContext = `${fullText}\n\n<!-- [dsh-bridge 提示] 当前用户正通过【${this.platform.name}】与你对话。若用户明确要求发送、导出或传送文件/图片/报表/代码脚本产物，请在本地生成/准备好文件后，在回复正文中附带明确发送指令：\n[SEND_FILE: <本地文件绝对路径>]\n例如：[SEND_FILE: C:\\path\\to\\report.xlsx]\n网关会自动解析该指令并将该文件直传至用户的聊天窗口，且在聊天文本中自动隐藏该指令。在日常编写代码、回复普通文本或未请求发送文件时，请勿输出此指令。 -->`
 
     const messageValue = createUserMessage({
       content: [{ type: 'text', text: promptWithContext }],
@@ -642,6 +635,7 @@ export class ConversationBridge {
 
   /** 向当前 peer 发送文本（自动分块 + typing 指示）。 */
   async sendText(text) {
+    if (this.platform?.status === 'idle' || this.platform?.status === 'offline') return
     const peer = this.peerId || this.config.allowFrom?.[0]
     if (!peer) return
     const chunks = splitForIM(text, this.config.maxMessageChars)
@@ -710,6 +704,7 @@ export class ConversationBridge {
         stopHeartbeat(state)
       }
       if (session.id !== this.activeSessionId) return
+      if (this.platform?.status === 'idle' || this.platform?.status === 'offline') return
 
       if (event.type === 'turn/start') {
         const turn = event.data?.turn
@@ -725,36 +720,21 @@ export class ConversationBridge {
       const getSessionCwd = (sess) => sess?.cwd || this.config.cwd || process.cwd()
 
       if (event.type === 'tool/call') {
-        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)
+        // 工具执行仅在终端/状态中展示，文件直发由 AI 回复中的 [SEND_FILE: ...] 指令显式驱动，杜绝误判
         return
       }
       if (event.type === 'assistant/message') {
-        const text = textOfAssistantMessage(event.data.message)
-        if (text.trim()) {
+        const rawText = textOfAssistantMessage(event.data.message)
+        if (rawText.trim()) {
           const cwd = getSessionCwd(session)
-          const fromText = extractFilePathsFromText(text, cwd)
-          for (const f of fromText) state.createdFiles.add(f)
-          void this.sendText(text)
+          const { cleanText, files } = extractAndStripSendFileDirectives(rawText, cwd)
+          for (const f of files) {
+            state.createdFiles.add(f)
+          }
+          // 仅向聊天窗口发送过滤掉 [SEND_FILE: ...] 控制指令后的纯净正文
+          if (cleanText) {
+            void this.sendText(cleanText)
+          }
         }
         return
       }
@@ -770,20 +750,19 @@ export class ConversationBridge {
           void this.sendText(`⚠️ **达到模型单轮输出上限，本轮内容已截断**`)
         }
 
-        // 如果本轮生成/记录了产物文件，下发清单通知并尝试直接上传文件至聊天窗口
+        // 如果本轮 AI 显式指定了 [SEND_FILE: ...] 文件发送指令，直接上传并发送给用户
         if (state.createdFiles && state.createdFiles.size > 0) {
           const rawFiles = Array.from(state.createdFiles)
           const cwd = getSessionCwd(session)
-          const fileLines = rawFiles.map((f) => `- \`${f}\``).join('\n')
-          void this.sendText(`📦 **本轮已生成产物文件**：\n${fileLines}`)
-
-          // 如果平台支持 sendMediaFile，自动尝试直接发送真实存在的文件/图片到聊天窗口（严格按绝对路径去重）
           const targetPeer = this.peerId || this.config.allowFrom?.[0]
+
           if (typeof this.platform?.sendMediaFile === 'function' && targetPeer) {
-            const uniqueFilesToSend = new Set()
+            const uniqueFilesToSend = []
             for (const f of rawFiles) {
               const resolved = resolveFilePath(f, cwd)
-              if (resolved) uniqueFilesToSend.add(resolved)
+              if (resolved && !uniqueFilesToSend.includes(resolved)) {
+                uniqueFilesToSend.push(resolved)
+              }
             }
             for (const resolved of uniqueFilesToSend) {
               try {
@@ -942,45 +921,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 +1427,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 +1466,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 +1475,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)
@@ -1341,8 +1536,10 @@ export const conversationBridgeHelpers = {
   textOfAssistantMessage,
   resolveFilePath,
   extractFilePathsFromText,
+  extractAndStripSendFileDirectives,
   sessionsInDisplayOrder,
   listSessions,
+  renderSessions,
   listWorkspaces,
   BRIDGE_MARK,
 }

package/lib/qq/gateway.js

@@ -164,9 +164,16 @@ export class QqGateway extends Service {
   async stop() {
     this.stopRequested = true
     this.clearHeartbeat()
+    const finish = this._finishConnect
+    this._finishConnect = null
+    if (finish) {
+      try { finish(new Error('Stopped by user')) } catch {}
+    }
     const ws = this.ws
     this.ws = null
-    if (ws) { try { ws.removeAllListeners(); ws.close(); ws.terminate() } catch {} }
+    if (ws) {
+      try { ws.close(); ws.terminate() } catch {}
+    }
     const task = this.loopTask
     this.loopTask = null
     if (task) await task.catch(() => {})
@@ -227,11 +234,13 @@ export class QqGateway extends Service {
       try {
         this.setStatus('starting')
         const token = await this.refreshAccessToken()
+        if (this.stopRequested) break
         // 官方「获取带分片 WSS 接入点」接口，返回网关地址与建议分片数
         // 参考：https://bot.q.qq.com/wiki/develop/api-v2/dev-prepare/event-emit/websocket.html
         const gateway = this.config.gatewayUrl
           || ((await requestJson(`${API_BASE}/gateway/bot`, { token, timeoutMs: this.config.apiTimeoutMs })).url)
           || DEFAULT_GATEWAY
+        if (this.stopRequested) break
         await this.connect(gateway, token)
         backoffMs = this.config.reconnectDelayMs
       } catch (error) {
@@ -247,18 +256,32 @@ export class QqGateway extends Service {
 
   connect(url, token) {
     return new Promise((resolve, reject) => {
+      if (this.stopRequested) {
+        resolve()
+        return
+      }
       const ws = new WebSocket(url)
       this.ws = ws
       let settled = false
       const finish = (error) => {
         if (settled) return
         settled = true
+        this._finishConnect = null
         this.clearHeartbeat()
         if (this.ws === ws) this.ws = null
         error ? reject(error) : resolve()
       }
-      ws.on('open', () => this.logger?.info?.('[dsh-bridge qq] WebSocket connected to QQ Open Platform'))
+      this._finishConnect = finish
+
+      ws.on('open', () => {
+        if (this.stopRequested) {
+          finish()
+          return
+        }
+        this.logger?.info?.('[dsh-bridge qq] WebSocket connected to QQ Open Platform')
+      })
       ws.on('message', (raw) => {
+        if (this.stopRequested) return
         let payload
         try { payload = JSON.parse(String(raw)) } catch { return }
         void this.handlePayload(payload, token, ws).catch(finish)
@@ -269,6 +292,7 @@ export class QqGateway extends Service {
   }
 
   async handlePayload(payload, token, ws) {
+    if (this.stopRequested) return
     const op = Number(payload?.op)
     if (payload?.s != null) this.sequence = payload.s
     if (op === 10) {

package/lib/qq/node.js

@@ -360,6 +360,7 @@ export class QqConversationNode extends ConversationBridge {
   // ---- 入站 ----
 
   async _handleInbound(event) {
+    if (this.gateway?.stopRequested) return
     const sender = String(event.senderId ?? '').trim()
     if (!sender) return
 
@@ -449,6 +450,7 @@ export class QqConversationNode extends ConversationBridge {
   // ---- 互动事件 ----
 
   async _handleInteraction(event) {
+    if (this.gateway?.stopRequested) return
     const sender = String(event.senderId ?? '').trim()
     if (!sender) return
 

package/lib/telegram/gateway.js

@@ -365,8 +365,11 @@ export class TelegramGateway extends Service {
           consecutiveErrors = 0
           if (this.status !== 'online') this.setStatus('online')
 
+          if (this._stopPolling) break
+
           if (Array.isArray(updates) && updates.length > 0) {
             for (const update of updates) {
+              if (this._stopPolling) break
               if (this._seenUpdates.has(update.update_id)) continue
               this._seenUpdates.add(update.update_id)
               if (this._seenUpdates.size > 2000) {

package/lib/telegram/node.js

@@ -95,6 +95,7 @@ export class TelegramConversationNode extends ConversationBridge {
   }
 
   async _handleInbound(event) {
+    if (this.gateway?._stopPolling) return
     const { chatId, senderId, senderUsername, isGroup, text, messageId, raw } = event
     this._lastPeer = { chatId, senderId, senderUsername, isGroup }
     const authId = isGroup ? chatId : senderId

package/lib/wechat/gateway.js

@@ -845,8 +845,10 @@ export class WechatGateway extends Service {
         if (this.statusValue !== 'connected') {
           this.logger?.info?.('[dsh-bridge wechat] connected to iLink platform')
         }
+        if (this.stopPollingLocal) break
         this.setStatus('connected')
         for (const message of batch.messages) {
+          if (this.stopPollingLocal) break
           this.dispatchInbound(message)
         }
         if (this.c.pollIdleDelayMs > 0) await sleep(this.c.pollIdleDelayMs)

package/lib/wechat/node.js

@@ -67,6 +67,7 @@ export class WechatConversationNode extends ConversationBridge {
   // ---- 入站 ----
 
   async _handleInbound(message) {
+    if (this.ctx?.wechat?.stopPollingLocal) return
     const sender = String(message.from_user_id ?? '').trim()
     if (!sender) return
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@wenbin_wb/dsh-bridge",
-  "version": "2.8.3",
+  "version": "2.8.5",
   "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.5 产物文件推送改为 AI 指令驱动 & 修复 IM 平台断开连接问题】\n• 🎯 显式文件发送协议：由 AI 通过 [SEND_FILE: <路径>] 显式驱动文件直传，杜绝修改代码时的文件误发风暴\n• 🧹 聊天正文自动净化：自动剔除聊天窗口中的文件发送指令，保持聊天气泡清爽\n• 🔌 修复 IM 断开连接失效：修复 QQ 等网关断开连接时 WebSocket 事件悬挂问题，断开后彻底阻断入站消息与出站回复",
   "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": {