@dcrays/dcgchat-test 0.6.10 → 0.6.12

package/src/utils/searchFile.ts

@@ -0,0 +1,228 @@
+import { dcgLogger } from './log.js'
+
+/**
+ * 从文本中提取 /mobook 目录下的文件
+ * @param {string} text
+ * @returns {string[]}
+ */
+const EXT_LIST = [
+  // 文档类
+  'doc',
+  'docx',
+  'xls',
+  'xlsx',
+  'ppt',
+  'pptx',
+  'pdf',
+  'txt',
+  'rtf',
+  'odt',
+
+  // 数据/开发
+  'json',
+  'xml',
+  'csv',
+  'yaml',
+  'yml',
+
+  // 前端/文本
+  'html',
+  'htm',
+  'md',
+  'markdown',
+  'css',
+  'js',
+  'ts',
+
+  // 图片
+  'png',
+  'jpg',
+  'jpeg',
+  'gif',
+  'bmp',
+  'webp',
+  'svg',
+  'ico',
+  'tiff',
+
+  // 音频
+  'mp3',
+  'wav',
+  'ogg',
+  'aac',
+  'flac',
+  'm4a',
+
+  // 视频
+  'mp4',
+  'avi',
+  'mov',
+  'wmv',
+  'flv',
+  'mkv',
+  'webm',
+
+  // 压缩包
+  'zip',
+  'rar',
+  '7z',
+  'tar',
+  'gz',
+  'bz2',
+  'xz',
+
+  // 可执行/程序
+  'exe',
+  'dmg',
+  'pkg',
+  'apk',
+  'ipa',
+
+  // 其他常见
+  'log',
+  'dat',
+  'bin'
+]
+/**
+ * 扩展名按长度降序，用于正则交替，避免 xls 抢先匹配 xlsx、htm 抢先匹配 html 等
+ */
+const EXT_SORTED_FOR_REGEX = [...EXT_LIST].sort((a, b) => b.length - a.length)
+
+/** 去除控制符、零宽字符等常见脏值 */
+function stripMobookNoise(s: string) {
+  return s.replace(/[\u0000-\u001F\u007F\u200B-\u200D\u200E\u200F\uFEFF]/g, '')
+}
+
+/**
+ * 从文本中扫描 `.../mobook/...` 或 `...\mobook\...` 片段，按最长后缀匹配合法扩展名（兜底）
+ */
+function collectMobookPathsAfterNeedle(text: string, lower: string, needle: string, result: Set<string>): void {
+  let from = 0
+  while (from < text.length) {
+    const i = lower.indexOf(needle, from)
+    if (i < 0) break
+    const start = i + needle.length
+    const tail = text.slice(start)
+    const seg = tail.match(/^([^\s\]\)'"}\u3002，,]+)/)
+    if (!seg) {
+      from = start + 1
+      continue
+    }
+    let raw = stripMobookNoise(seg[1]).trim()
+    if (!raw || raw.includes('\uFFFD')) {
+      from = start + 1
+      continue
+    }
+    const low = raw.toLowerCase()
+    let matchedExt: string | undefined
+    for (const ext of EXT_SORTED_FOR_REGEX) {
+      if (low.endsWith(`.${ext}`)) {
+        matchedExt = ext
+        break
+      }
+    }
+    if (!matchedExt) {
+      from = start + 1
+      continue
+    }
+    const base = raw.slice(0, -(matchedExt.length + 1))
+    const fileName = `${base}.${matchedExt}`
+    if (isValidFileName(fileName)) {
+      result.add(normalizePath(`/mobook/${fileName}`))
+    }
+    from = start + 1
+  }
+}
+
+function collectMobookPathsByScan(text: string, result: Set<string>): void {
+  const lower = text.toLowerCase()
+  collectMobookPathsAfterNeedle(text, lower, '/mobook/', result)
+  collectMobookPathsAfterNeedle(text, lower, '\\mobook\\', result)
+}
+
+export function extractMobookFiles(text = '') {
+  if (typeof text !== 'string' || !text.trim()) return []
+  // 全角冒号（中文输入常见）→ 半角，便于匹配 c：\mobook\
+  text = text.replace(/\uFF1A/g, ':')
+  const result = new Set<string>()
+  // ✅ 扩展名（必须长扩展名优先，见 EXT_SORTED_FOR_REGEX）
+  const EXT = `(${EXT_SORTED_FOR_REGEX.join('|')})`
+  // ✅ 文件名字符（增强：支持中文、符号）
+  const FILE_NAME = `[\\w\\u4e00-\\u9fa5：:《》()（）\\-\\s]+?`
+  try {
+    // 1️⃣ `xxx.xxx`
+    const backtickReg = new RegExp(`\`([^\\\`]+?\\.${EXT})\``, 'gi')
+    ;(text.match(backtickReg) || []).forEach((item) => {
+      const name = item.replace(/`/g, '').trim()
+      if (isValidFileName(name)) {
+        result.add(`/mobook/${name}`)
+      }
+    })
+    // 2️⃣ /mobook/xxx.xxx
+    const fullPathReg = new RegExp(`/mobook/${FILE_NAME}\\.${EXT}`, 'gi')
+    ;(text.match(fullPathReg) || []).forEach((p) => {
+      result.add(normalizePath(p))
+    })
+    // 2️⃣b Windows 实际保存路径：C:\mobook\xxx、c:/mobook/xxx、\mobook\xxx（模型常写反斜杠，原先无法识别）
+    const winMobookReg = new RegExp(`(?:[a-zA-Z]:)?[/\\\\]mobook[/\\\\]${FILE_NAME}\\.${EXT}`, 'gi')
+    ;(text.match(winMobookReg) || []).forEach((full) => {
+      const name = full.replace(/^(?:[a-zA-Z]:)?[/\\\\]mobook[/\\\\]/i, '').trim()
+      if (isValidFileName(name)) {
+        result.add(normalizePath(`/mobook/${name}`))
+      }
+    })
+    // 3️⃣ mobook下的 xxx.xxx
+    const inlineReg = new RegExp(`mobook下的\\s*(${FILE_NAME}\\.${EXT})`, 'gi')
+    ;(text.match(inlineReg) || []).forEach((item) => {
+      const match = item.match(new RegExp(`${FILE_NAME}\\.${EXT}`, 'i'))
+      if (match && isValidFileName(match[0])) {
+        result.add(`/mobook/${match[0].trim()}`)
+      }
+    })
+    // 🆕 4️⃣ **xxx.xxx**
+    const boldReg = new RegExp(`\\*\\*(${FILE_NAME}\\.${EXT})\\*\\*`, 'gi')
+    ;(text.match(boldReg) || []).forEach((item) => {
+      const name = item.replace(/\*\*/g, '').trim()
+      if (isValidFileName(name)) {
+        result.add(`/mobook/${name}`)
+      }
+    })
+    // 🆕 5️⃣ xxx.xxx (123字节)
+    const looseReg = new RegExp(`(${FILE_NAME}\\.${EXT})\\s*\\(`, 'gi')
+    ;(text.match(looseReg) || []).forEach((item) => {
+      const name = item.replace(/\s*\(.+$/, '').trim()
+      if (isValidFileName(name)) {
+        result.add(`/mobook/${name}`)
+      }
+    })
+    // 6️⃣ 兜底：绝对路径等 `.../mobook/<文件名>.<扩展名>` + 最长后缀匹配 + 去脏字符
+    collectMobookPathsByScan(text, result)
+  } catch (e) {
+    dcgLogger(`extractMobookFiles error:${e}`, 'error')
+  }
+  return [...result]
+}
+
+/**
+ * 校验文件名是否合法（避免脏数据）
+ */
+function isValidFileName(name: string) {
+  if (!name) return false
+  const cleaned = stripMobookNoise(name).trim()
+  if (!cleaned) return false
+  if (cleaned.includes('\uFFFD')) return false
+  // 过滤异常字符
+  if (/[\/\\<>:"|?*]/.test(cleaned)) return false
+  // 长度限制（防止异常长字符串）
+  if (cleaned.length > 200) return false
+  return true
+}
+
+/**
+ * 规范路径（去重用）
+ */
+function normalizePath(path: string) {
+  return path
+    .replace(/\/+/g, '/') // 多斜杠 → 单斜杠
+    .replace(/\/$/, '') // 去掉结尾 /
+}

package/src/utils/sessionState.ts

@@ -0,0 +1,137 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getWorkspaceDir, snapshotGlobalSessionState, restoreGlobalSessionState, type GlobalSessionStateSnapshot } from './global.js'
+import { snapshotParamsState, restoreParamsState, type ParamsStateSnapshot } from './params.js'
+import { dcgLogger } from './log.js'
+
+/** 子 agent 跟踪状态（由 tool.ts 侧维护）的可序列化快照 */
+export type SubagentTrackingSnapshot = {
+  activeSubagentRunIdsByRequester: Array<[string, string[]]>
+  requesterByChildSessionKey: Array<[string, string]>
+  runIdByChildSessionKey: Array<[string, string]>
+  requesterSessionKeyByRunId?: Array<[string, string]>
+  childSessionKeyByRunId?: Array<[string, string]>
+}
+
+/** 完整的会话相关内存状态快照 */
+export type SessionStateFile = {
+  version: number
+  savedAt: number
+  params: ParamsStateSnapshot
+  global: GlobalSessionStateSnapshot
+  subagent: SubagentTrackingSnapshot
+}
+
+const SESSION_STATE_FILE_VERSION = 1
+const SESSION_STATE_FILE_NAME = 'session-state.json'
+
+/**
+ * 将快照落地到 `${workspace}/../session-state.json`，与 cron 走同级约定，
+ * 避免运行时污染 workspace 文件树。workspace 未初始化时直接跳过。
+ */
+function getSessionStateFilePath(): string | null {
+  const ws = getWorkspaceDir()
+  if (!ws) return null
+  return path.join(path.dirname(ws), SESSION_STATE_FILE_NAME)
+}
+
+export function writeSessionStateFile(subagent: SubagentTrackingSnapshot): void {
+  const filePath = getSessionStateFilePath()
+  if (!filePath) {
+    dcgLogger('writeSessionStateFile: workspace dir not initialized, skip', 'error')
+    return
+  }
+  const global = snapshotGlobalSessionState()
+  const runningSessionKeys = new Set(global.msgStatusBySessionKey.map(([k]) => k))
+  if (runningSessionKeys.size === 0) {
+    removeSessionStateFile()
+    dcgLogger('session state skipped: no running sessions')
+    return
+  }
+  const payload: SessionStateFile = {
+    version: SESSION_STATE_FILE_VERSION,
+    savedAt: Date.now(),
+    params: snapshotParamsState(runningSessionKeys),
+    global,
+    subagent
+  }
+  try {
+    const dir = path.dirname(filePath)
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+    const tmp = `${filePath}.tmp`
+    fs.writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8')
+    fs.renameSync(tmp, filePath)
+    dcgLogger(`session state persisted: ${filePath}`)
+  } catch (e) {
+    dcgLogger(`writeSessionStateFile failed: ${String(e)}`, 'error')
+  }
+}
+
+export function readSessionStateFile(): SessionStateFile | null {
+  const filePath = getSessionStateFilePath()
+  if (!filePath || !fs.existsSync(filePath)) return null
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8')
+    const data = JSON.parse(raw) as SessionStateFile
+    if (!data || typeof data !== 'object') return null
+    if (data.version !== SESSION_STATE_FILE_VERSION) {
+      dcgLogger(`readSessionStateFile: version mismatch ${data.version} vs ${SESSION_STATE_FILE_VERSION}`, 'error')
+      return null
+    }
+    return data
+  } catch (e) {
+    dcgLogger(`readSessionStateFile failed: ${String(e)}`, 'error')
+    return null
+  }
+}
+
+/**
+ * 恢复 params/global 两个模块的内存状态。subagent 跟踪由 tool.ts 侧自行 restore（避免循环依赖）。
+ */
+export function restoreParamsAndGlobal(snap: SessionStateFile | null): void {
+  if (!snap) return
+  restoreParamsState(snap.params)
+  restoreGlobalSessionState(snap.global)
+}
+
+export function removeSessionStateFile(): void {
+  const filePath = getSessionStateFilePath()
+  if (!filePath) return
+  try {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath)
+  } catch (e) {
+    dcgLogger(`removeSessionStateFile failed: ${String(e)}`, 'error')
+  }
+}
+
+function addSessionKeyToSet(out: Set<string>, k: string | undefined) {
+  const t = k?.trim()
+  if (t) out.add(t)
+}
+
+/**
+ * 从持久化快照中收集所有与「会话」相关的 dcg sessionKey，供网关恢复后 `chat.send` 等用。
+ * （不含 `sentMediaKeys` 外层 key：那是 messageId，不是 sessionKey。）
+ */
+export function collectSessionKeysFromSnapshot(snap: SessionStateFile | null | undefined): string[] {
+  if (!snap) return []
+  const set = new Set<string>()
+  for (const [k, status] of snap.global?.msgStatusBySessionKey ?? []) {
+    if (status === 'running') addSessionKeyToSet(set, k)
+  }
+  return [...set]
+}
+
+/**
+ * 网关恢复时只恢复顶层会话，避免对旧子会话发送「继续执行」但本地不恢复 runId 映射，
+ * 导致后续子 agent 流式输出无法回到主消息。
+ */
+export function collectRootSessionKeysFromSnapshot(snap: SessionStateFile | null | undefined): string[] {
+  if (!snap) return []
+  const childKeys = new Set<string>()
+  for (const [child] of snap.subagent?.requesterByChildSessionKey ?? []) {
+    const k = child?.trim()
+    if (k) childKeys.add(k)
+  }
+  return collectSessionKeysFromSnapshot(snap).filter((k) => !childKeys.has(k))
+}

package/src/utils/sessionTermination.ts

@@ -0,0 +1,228 @@
+/**
+ * 会话终止 / 抢占 / 网关 abort 的集中实现，便于单独调整策略与观测。
+ * 与 inboundTurnState（generation / streamChunkIdx）、入站业务上下文分离，仅负责：本地 AbortController、流抑制标记、
+ * 入站串行队尾、activeRunId、以及 /stop control barrier 时的 chat.abort（子会话→主会话）。
+ */
+import { sendGatewayRpc } from '../gateway/socket.js'
+import { dcgLogger } from './log.js'
+import { bumpInboundGeneration, bumpStopSeq, clearInboundGenerationForSession, getStopSeq } from './inboundTurnState.js'
+import { getDescendantSessionKeysForRequester, resetSubagentStateForRequesterSession, cleanupSubagentStateForSession } from '../tool.js'
+import { clearParamsMessage } from './params.js'
+import { setMsgStatus } from './global.js'
+import { clearOutboundTextState } from './outboundAssistantText.js'
+
+// 缩短超时时间，避免长时间阻塞
+const GATEWAY_ABORT_TIMEOUT_MS = 5_000
+
+// --- 状态（仅本模块内修改，供 bot 通过下方 API 使用）---
+
+/** 当前会话最近一次 agent run 的 runId（网关 chat.abort 主会话时携带） */
+const activeRunIdBySessionKey = new Map<string, string>()
+
+/** dispatchReplyFromConfig 使用的 AbortSignal，用于真正掐断工具与模型 */
+const dispatchAbortBySessionKey = new Map<string, AbortController>()
+
+/** 打断后抑制 deliver / onPartialReply 继续下发 */
+const sessionStreamSuppressed = new Set<string>()
+
+/**
+ * 同 sessionKey 入站串行队尾；与 Core session lane 对齐，避免并发 dispatch 过早返回。
+ */
+const inboundTurnTailBySessionKey = new Map<string, Promise<void>>()
+
+/** 当前 session 正在执行的 /stop 终止屏障；普通消息必须等它结束后再进入新 turn。 */
+const stopBarrierBySessionKey = new Map<string, Promise<void>>()
+
+// --- activeRunId（供 bot 在 onAgentRunStart / 错误收尾时同步）---
+
+export function setActiveRunIdForSession(sessionKey: string, runId: string): void {
+  activeRunIdBySessionKey.set(sessionKey, runId)
+}
+
+export function clearActiveRunIdForSession(sessionKey: string): void {
+  activeRunIdBySessionKey.delete(sessionKey)
+}
+
+// --- 流抑制 ---
+
+export function isSessionStreamSuppressed(sessionKey: string): boolean {
+  return sessionStreamSuppressed.has(sessionKey)
+}
+
+export function clearSessionStreamSuppression(sessionKey: string): void {
+  sessionStreamSuppressed.delete(sessionKey)
+}
+
+export function markSessionStreamSuppressed(sessionKey: string): void {
+  sessionStreamSuppressed.add(sessionKey)
+}
+
+// --- 入站串行队列 ---
+
+/**
+ * /stop control path：掐断当前 in-process，等待网关 chat.abort（子会话→主会话）完成后再释放普通消息。
+ *
+ * 返回 started=false 表示已有同 session 的 stop barrier 在跑；调用方仍应给当前 /stop 消息立即 ack。
+ */
+export function requestStopInterruption(sessionKey: string): { started: boolean; barrier: Promise<void> } {
+  const key = sessionKey.trim()
+  if (!key) return { started: false, barrier: Promise.resolve() }
+
+  const existing = stopBarrierBySessionKey.get(key)
+  if (existing) {
+    dcgLogger(`stop barrier already running sessionKey=${key}`)
+    return { started: false, barrier: existing }
+  }
+
+  let barrier!: Promise<void>
+  barrier = Promise.resolve().then(async () => {
+    try {
+      const c = dispatchAbortBySessionKey.get(key)
+      if (c) {
+        c.abort()
+        dispatchAbortBySessionKey.delete(key)
+        dcgLogger(`stop barrier: aborted local controller sessionKey=${key}`)
+      }
+
+      markSessionStreamSuppressed(key)
+      const inboundGenAfterBump = bumpInboundGeneration(key)
+      const stopSeqAfterBump = bumpStopSeq(key)
+      dcgLogger(`stop barrier: bump inboundGen=${inboundGenAfterBump}, stopSeq=${stopSeqAfterBump}, sessionKey=${key}`)
+
+      const oldTail = inboundTurnTailBySessionKey.get(key)
+      if (oldTail) {
+        await Promise.race([oldTail.catch(() => {}), new Promise<void>((r) => setTimeout(r, 100))])
+        dcgLogger(`stop barrier: old tail done/timeout sessionKey=${key}`)
+      }
+
+      try {
+        await abortGatewayRunsForSession(key)
+      } catch (e) {
+        dcgLogger(`stop barrier: gateway abort: ${String(e)}`, 'error')
+      }
+
+      inboundTurnTailBySessionKey.set(key, Promise.resolve())
+      dcgLogger(`stop barrier: released inbound queue sessionKey=${key}`)
+    } finally {
+      if (stopBarrierBySessionKey.get(key) === barrier) {
+        stopBarrierBySessionKey.delete(key)
+      }
+    }
+  })
+
+  stopBarrierBySessionKey.set(key, barrier)
+  return { started: true, barrier }
+}
+
+/** 普通入站消息进入队列前调用，保证 /stop 的 gateway abort 已完成或超时。 */
+export async function waitForStopInterruption(sessionKey: string): Promise<void> {
+  const key = sessionKey.trim()
+  if (!key) return
+  for (;;) {
+    const barrier = stopBarrierBySessionKey.get(key)
+    if (!barrier) return
+    dcgLogger(`waiting stop barrier before inbound turn sessionKey=${key}`)
+    await barrier.catch((e) => dcgLogger(`stop barrier wait failed: ${String(e)}`, 'error'))
+  }
+}
+
+/** 将本轮入站处理挂到 sessionKey 队尾，保证同会话顺序执行 */
+export async function runInboundTurnSequenced(sessionKey: string, run: () => Promise<void>): Promise<void> {
+  const prev = inboundTurnTailBySessionKey.get(sessionKey) ?? Promise.resolve()
+
+  const next = prev.catch(() => {}).then(() => run())
+
+  inboundTurnTailBySessionKey.set(
+    sessionKey,
+    next.catch((e) => dcgLogger(`session turn failed: ${String(e)}`, 'error'))
+  )
+  await next
+}
+
+// --- 网关 abort ---
+
+/**
+ * 终止网关上仍可能活跃的 run（子会话自深到浅，再主会话）。
+ * 主会话始终 chat.abort；有 mainRunId 则按 run 掐断，无则仅用 sessionKey 扫尾。
+ */
+export async function abortGatewayRunsForSession(sessionKey: string): Promise<void> {
+  const prefix = 'interrupt'
+  const descendantKeys = getDescendantSessionKeysForRequester(sessionKey)
+  const abortSubKeys = [...descendantKeys].reverse()
+  const mainRunId = activeRunIdBySessionKey.get(sessionKey)
+
+  if (abortSubKeys.length > 0) {
+    dcgLogger(`${prefix}: chat.abort ${abortSubKeys.length} subagent session(s) (nested incl.)`)
+  }
+
+  const abortAllSequentially = async () => {
+    // 按“先子后主”顺序终止，降低主会话先结束导致子会话残留事件的概率。
+    for (const subKey of abortSubKeys) {
+      try {
+        await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey: subKey } })
+      } catch (e: unknown) {
+        dcgLogger(`${prefix}: chat.abort subagent ${subKey}: ${String(e)}`, 'error')
+      }
+    }
+    try {
+      await sendGatewayRpc({
+        method: 'chat.abort',
+        params: mainRunId ? { sessionKey, runId: mainRunId } : { sessionKey }
+      })
+    } catch (e: unknown) {
+      dcgLogger(`${prefix}: chat.abort main ${sessionKey}: ${String(e)}`, 'error')
+    }
+  }
+
+  try {
+    await Promise.race([
+      abortAllSequentially(),
+      new Promise<void>((_, reject) => setTimeout(() => reject(new Error('batch abort timeout')), GATEWAY_ABORT_TIMEOUT_MS))
+    ])
+  } catch (e) {
+    dcgLogger(`${prefix}: batch abort timeout: ${String(e)}`, 'error')
+  }
+
+  activeRunIdBySessionKey.delete(sessionKey)
+  resetSubagentStateForRequesterSession(sessionKey)
+}
+
+// --- 本地 dispatch AbortController ---
+
+/**
+ * 新一轮非 /stop 用户消息：本地中止上一轮 AbortController（若有）、清除流抑制，并安装本轮 AbortController。
+ * 不在此处发往网关 chat.abort；每轮流式由入站串行保证先后，网关 run 收尾由上一轮正常完结或用户 /stop 处理。
+ * 调用方须在之前或之后自行 `resetStreamChunkIdxForSession(sessionKey, 0)`（见 inboundTurnState）。
+ */
+export function beginDispatchAbortForInboundTurn(sessionKey: string): AbortController {
+  dispatchAbortBySessionKey.get(sessionKey)?.abort()
+  sessionStreamSuppressed.delete(sessionKey)
+  const ac = new AbortController()
+  dispatchAbortBySessionKey.set(sessionKey, ac)
+  return ac
+}
+
+/** try/finally 中：仅当仍是当前 controller 时从 map 移除 */
+export function releaseDispatchAbortIfCurrent(sessionKey: string, controller: AbortController | undefined): void {
+  if (controller && dispatchAbortBySessionKey.get(sessionKey) === controller) {
+    dispatchAbortBySessionKey.delete(sessionKey)
+  }
+}
+
+/**
+ * 会话完全终止时的资源清理：移除本模块及 tool 模块中与该会话相关的所有状态，
+ * 防止 Map/Set 内存泄漏。
+ */
+export function cleanupTerminatedSession(sessionKey: string): void {
+  if (!sessionKey) return
+  activeRunIdBySessionKey.delete(sessionKey)
+  dispatchAbortBySessionKey.delete(sessionKey)
+  sessionStreamSuppressed.delete(sessionKey)
+  inboundTurnTailBySessionKey.delete(sessionKey)
+  stopBarrierBySessionKey.delete(sessionKey)
+  clearInboundGenerationForSession(sessionKey)
+  clearParamsMessage(sessionKey)
+  setMsgStatus(sessionKey, '')
+  clearOutboundTextState(sessionKey)
+  cleanupSubagentStateForSession(sessionKey)
+}