@roaming-ai/dsh-group-chat 0.2.0

package/src/host/materials/materials.ts

@@ -0,0 +1,193 @@
+/**
+ * 资料读取与路径解析：群组工作区目录 → 注入文件清单 + 目录浏览器 + @ 文件检索。
+ * 路径解析顺序：~ 展开到 home；绝对路径直用；相对路径先试各工作区根，
+ * 再试 dsh web 进程 cwd。目录浏览器、资料读取与文件检索共用同一套解析。
+ * 无独立笔记/文件清单：共享资料 = workspaceDir 根下一层文本文件。
+ * @module dsh-group-chat/host/materials
+ */
+
+import { homedir } from 'node:os'
+import { dirname, isAbsolute, join } from 'node:path'
+import {
+  DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES,
+  DEFAULT_FILE_SEARCH_MAX_ENTRIES,
+  DEFAULT_FILE_SEARCH_MAX_RESULTS,
+  WorkspaceFileSearch,
+} from '@deepseek-ai/dsh-file-reference-local'
+import type { BrowseResult, FileSearchResult, GroupRecord } from '../../core/types.ts'
+import type { HostState } from '../state.ts'
+
+// 群组工作区目录 → 注入文件清单：目录内文本文件（白名单扩展名、跳过隐藏项，
+// 最多 20 个），单文件 16k、总量 48k 截断由 materialBlock 执行。
+const TEXT_EXTS = new Set(['.md', '.markdown', '.txt', '.json', '.yml', '.yaml', '.csv', '.tsv', '.toml', '.ini', '.conf', '.env', '.properties', '.log', '.xml', '.html', '.css', '.ts', '.tsx', '.js', '.jsx', '.py', '.java', '.go', '.rs', '.c', '.h', '.cpp', '.sql', '.sh'])
+const MAX_WS_FILES = 20
+
+/** 资料面。 */
+export interface Materials {
+  /** 群组工作区目录 → 注入文件清单（dir 为解析后的展示路径）。 */
+  loadWorkspaceFiles: (g: GroupRecord) => Promise<{ dir: string, parts: { name: string, content: string, error?: string }[] }>
+  /** 文件清单 → system 提示词内的「共享资料」块（单文件 16k / 总量 48k 截断）。 */
+  materialBlock: (parts: { name: string, content: string, error?: string }[], dir: string) => string
+  /** 目录浏览：返回文件+目录条目（绝对路径由 Host 解析，客户端不拼路径）。 */
+  browse: (args: { path?: string } | undefined) => Promise<BrowseResult>
+  /** 群工作区 @ 文件检索（WorkspaceFileSearch，根 = 解析后的 workspaceDir）。 */
+  fileSearch: (args: { groupId?: string, query?: string } | undefined) => Promise<FileSearchResult>
+  /** 释放某群（或全部）文件检索索引。 */
+  disposeFileSearch: (groupId?: string) => void
+}
+
+/** 创建资料面。 */
+export function createMaterials(core: HostState): Materials {
+  const { ctx, fs } = core
+  const HOME = homedir()
+  let workspacePathsCache = { at: 0, paths: [] as string[] }
+  const workspacePaths = async (): Promise<string[]> => {
+    const now = Date.now()
+    if (now - workspacePathsCache.at < 5000) return workspacePathsCache.paths
+    try {
+      const list = await ctx.workspaceRegistry.list()
+      workspacePathsCache = { at: now, paths: list.map((w) => w.path).filter(Boolean) }
+    } catch {
+      workspacePathsCache = { at: now, paths: workspacePathsCache.paths }
+    }
+    return workspacePathsCache.paths
+  }
+
+  const candidatePaths = async (raw: unknown): Promise<string[]> => {
+    const p = String(raw || '').trim()
+    if (p === '' || p === '~') return [HOME]
+    if (p.startsWith('~/')) return [join(HOME, p.slice(2))]
+    if (isAbsolute(p)) return [p]
+    const roots = [...(await workspacePaths()), process.cwd()]
+    return roots.map((root) => join(root, p))
+  }
+
+  /** 逐候选 stat，返回第一个存在的目标；都不存在时返回首候选与全部尝试。 */
+  const resolveMaterialTarget = async (raw: unknown) => {
+    const candidates = await candidatePaths(raw)
+    let first: { target: import('@deepseek-ai/dsh-fs').FsTarget, path: string } | undefined
+    for (const c of candidates) {
+      const target = await fs.resolve(c)
+      if (first === undefined) first = { target, path: c }
+      const info = await fs.stat(target)
+      if (info !== undefined) return { target, path: c, info, tried: candidates }
+    }
+    return { target: first!.target, path: first!.path, info: undefined, tried: candidates }
+  }
+
+  const loadWorkspaceFiles = async (g: GroupRecord) => {
+    if (!g.workspaceDir) return { dir: '', parts: [] as { name: string, content: string, error?: string }[] }
+    const res = await resolveMaterialTarget(g.workspaceDir)
+    if (res.info === undefined) throw new Error('工作区目录不存在（尝试过：' + res.tried.join('；') + '）')
+    if (res.info.type !== 'directory') throw new Error('工作区目录不是目录：' + res.path)
+    const entries = await fs.listDir(res.target)
+    const parts: { name: string, content: string, error?: string }[] = []
+    for (const e of entries) {
+      if (parts.length >= MAX_WS_FILES) break
+      if (e.type !== 'file' || e.name.startsWith('.')) continue
+      const dot = e.name.lastIndexOf('.')
+      const ext = dot === -1 ? '' : e.name.slice(dot).toLowerCase()
+      if (!TEXT_EXTS.has(ext)) continue
+      try {
+        const text = await fs.readText(e.target)
+        parts.push({ name: e.name, content: text })
+      } catch (err) {
+        parts.push({ name: e.name, content: '', error: String((err && (err as Error).message) || err) })
+      }
+    }
+    return { dir: res.path, parts }
+  }
+
+  const materialBlock = (parts: { name: string, content: string, error?: string }[], dir: string): string => {
+    if (!parts.length) return ''
+    let total = 0
+    const lines: string[] = []
+    for (const p of parts) {
+      if (p.error) {
+        lines.push('### ' + p.name + '\n[读取失败] ' + p.error)
+        continue
+      }
+      let c = p.content || ''
+      if (c.length > 16000) c = c.slice(0, 16000) + '\n…(已截断)'
+      if (total + c.length > 48000) c = c.slice(0, Math.max(0, 48000 - total)) + '\n…(总量超限截断)'
+      total += c.length
+      lines.push('### ' + p.name + '\n' + c)
+    }
+    return '\n# 共享资料（来自群组工作区目录' + (dir ? ' ' + dir : '') + '，群内所有成员可见）\n' + lines.join('\n\n')
+  }
+
+  const browse = async (args: { path?: string } | undefined): Promise<BrowseResult> => {
+    try {
+      const raw = String((args && args.path) || '').trim()
+      const res = await resolveMaterialTarget(raw === '' ? HOME : raw)
+      if (res.info === undefined) return { ok: false, error: '路径不存在，尝试过：' + res.tried.join('；') }
+      let dirPath = res.path
+      let target = res.target
+      if (res.info.type !== 'directory') {
+        dirPath = dirname(dirPath)
+        target = await fs.resolve(dirPath)
+      }
+      const entries = await fs.listDir(target)
+      const sorted = [...entries].sort((a, b) => (a.type === 'directory' ? 0 : 1) - (b.type === 'directory' ? 0 : 1) || a.name.localeCompare(b.name))
+      return {
+        ok: true,
+        path: dirPath,
+        home: HOME,
+        parent: dirname(dirPath),
+        entries: sorted.map((e) => ({ name: e.name, type: e.type, path: fs.processPath(e.target), size: e.size, hidden: e.name.startsWith('.') })),
+      }
+    } catch (e) {
+      return { ok: false, error: String((e && (e as Error).message) || e) }
+    }
+  }
+
+  const FILE_SEARCH_CONFIG = {
+    maxResults: DEFAULT_FILE_SEARCH_MAX_RESULTS,
+    maxEntries: DEFAULT_FILE_SEARCH_MAX_ENTRIES,
+    excludedDirectories: [...DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES],
+  }
+  const searches = new Map<string, { root: string, search: WorkspaceFileSearch }>()
+
+  const disposeFileSearch = (groupId?: string): void => {
+    if (groupId) {
+      searches.get(groupId)?.search.dispose()
+      searches.delete(groupId)
+      return
+    }
+    for (const hit of searches.values()) hit.search.dispose()
+    searches.clear()
+  }
+
+  const searchFor = (groupId: string, root: string): WorkspaceFileSearch => {
+    const hit = searches.get(groupId)
+    if (hit && hit.root === root) return hit.search
+    hit?.search.dispose()
+    const search = new WorkspaceFileSearch(root, FILE_SEARCH_CONFIG)
+    searches.set(groupId, { root, search })
+    return search
+  }
+
+  const fileSearch = async (args: { groupId?: string, query?: string } | undefined): Promise<FileSearchResult> => {
+    const groupId = String((args && args.groupId) || '')
+    const g = core.groups.get(groupId)
+    if (!g) return { ok: false, error: '群组不存在' }
+    const raw = String(g.workspaceDir || '').trim()
+    if (!raw) return { ok: false, error: '未设置群工作区，无法检索文件' }
+    if (raw === '~' || raw === '/') return { ok: false, error: '工作区不能是 ~ 或 /，请设置具体目录' }
+    try {
+      const res = await resolveMaterialTarget(raw)
+      if (res.info === undefined) return { ok: false, error: '工作区目录不存在（尝试过：' + res.tried.join('；') + '）' }
+      if (res.info.type !== 'directory') return { ok: false, error: '工作区不是目录：' + res.path }
+      const listed = await searchFor(g.id, res.path).list(String((args && args.query) || ''), AbortSignal.timeout(8000))
+      return {
+        ok: true,
+        candidates: listed.map((c) => ({ path: c.path, isDir: c.kind === 'directory' })),
+      }
+    } catch (e) {
+      if (e instanceof Error && e.name === 'TimeoutError') return { ok: false, error: '文件检索超时' }
+      return { ok: false, error: String((e && (e as Error).message) || e) }
+    }
+  }
+
+  return { loadWorkspaceFiles, materialBlock, browse, fileSearch, disposeFileSearch }
+}

package/src/host/persistence/index.ts

@@ -0,0 +1,7 @@
+/**
+ * 持久化层统一导出
+ * @module dsh-group-chat/host/persistence
+ */
+
+export { createPersistence } from './persistence.ts'
+export type { Persistence } from './persistence.ts'

package/src/host/persistence/persistence.ts

@@ -0,0 +1,311 @@
+/**
+ * 持久化（PERSISTENCE.md v2.1）：事件驱动脏标记合并落盘 + 启动恢复。
+ * 锁失败/写失败时降级为内存态运行（console 告警）。
+ * @module dsh-group-chat/host/persistence
+ */
+
+import { existsSync } from 'node:fs'
+import { messageJson, roleJson } from '../../core/json.ts'
+import { asNumber, migrateTier } from '../../core/types.ts'
+import type { GroupRecord, MessageRecord, RoleRecord, SessionRecord } from '../../core/types.ts'
+import { emptyGroup, LedgerDocument, scanGroupIds, scanSessionIds, STORE_DIR, Store } from './store.ts'
+import type { HostState } from '../state.ts'
+
+/** 会话文件形态（hydrate 用）。 */
+interface SessionDocument {
+  name?: string
+  topic?: string
+  namePinned?: boolean
+  topicPinned?: boolean
+  createdAt?: number
+  messages?: Partial<MessageRecord>[]
+}
+
+/** 群组角色文件形态（hydrate 用）。 */
+interface RolesDocument {
+  roles?: Partial<RoleRecord>[]
+}
+
+/** 持久化面。 */
+export interface Persistence {
+  /** 事件驱动落盘；同一 tick 内多次变更合并为一次写。 */
+  schedulePersist: (targets?: { ledger?: boolean, session?: string | null, roles?: string | null, workspace?: string | null }) => void
+  /** 同步 flush：写全部脏文件（dispose 最终落盘用）。 */
+  flushNow: () => void
+  /** 删除群组/会话后摘除脏标记（对应文件已删/将删，flush 跳过）。 */
+  dropDirty: (targets: { session?: string | null, roles?: string | null, workspace?: string | null }) => void
+  /** dispose：同步最终 flush → 释放锁 → 摘除句柄。 */
+  release: () => void
+}
+
+/**
+ * 创建持久化面：构造即完成 store 初始化 + hydrate（v1 迁移 → 残留清理 →
+ * 清单 → 群组数据 → 会话文件；缺文件空重建；补建默认会话/群组立即落盘）。
+ */
+export function createPersistence(core: HostState): Persistence {
+  // ---- 持久化：锁失败/写失败时降级为内存态运行（console 告警） ----
+  try {
+    core.store = new Store(STORE_DIR)
+  } catch (e) {
+    console.error('[dsh-group-chat] 持久化不可用，本实例以内存态运行（重启后数据不保留）：', e)
+    core.store = null
+  }
+  const store = (): Store | null => core.store
+
+  // 脏标记按文件记；flush 失败者保留脏标记，下次触发自动重试
+  const dirtySessions = new Set<string>()
+  const dirtyRoles = new Set<string>()
+  const dirtyWorkspace = new Set<string>()
+  let ledgerDirty = false
+  let flushScheduled = false
+
+  const ledgerDocument = (): LedgerDocument & { savedAt: number } => ({
+    schema: 3,
+    savedAt: Date.now(),
+    groups: [...core.groups.values()].map((g) => ({ id: g.id, name: g.name, permissionTier: g.permissionTier })),
+    sessions: [...core.groups.values()].flatMap((g) => g.sessionIds.map((sid) => ({ id: sid, groupId: g.id }))),
+  })
+  const sessionDocument = (s: SessionRecord) => ({
+    schema: 1,
+    savedAt: Date.now(),
+    id: s.id,
+    name: s.name,
+    groupId: s.groupId,
+    topic: s.topic,
+    ...(s.namePinned ? { namePinned: true } : {}),
+    ...(s.topicPinned ? { topicPinned: true } : {}),
+    createdAt: s.createdAt,
+    messages: s.messageIds.map((mid) => core.messages.get(mid)).filter(Boolean).map((m) => messageJson(m)).filter(Boolean),
+  })
+  const rolesDocument = (g: GroupRecord) => ({ schema: 1, savedAt: Date.now(), roles: g.roleIds.map((rid) => core.roles.get(rid)).filter((r): r is RoleRecord => Boolean(r)).map((r) => roleJson(r)) })
+
+  /** 同步 flush：写全部脏文件；成功才清脏标记；每个实际发生 rename 的目录一次 fsync。 */
+  const flushNow = (): void => {
+    const s = store()
+    if (s === null) return
+    const fsyncDirs = new Set<string>()
+    for (const sid of [...dirtySessions]) {
+      const sess = core.sessions.get(sid)
+      if (!sess) {
+        dirtySessions.delete(sid)
+        continue
+      }
+      try {
+        s.atomicWrite(s.sessionFile(sess.groupId, sess.id), JSON.stringify(sessionDocument(sess)))
+        dirtySessions.delete(sid)
+        fsyncDirs.add(s.sessionsDir(sess.groupId))
+      } catch (e) {
+        console.error(`[dsh-group-chat] 会话 ${sid} 落盘失败（保留脏标记待重试）：`, e)
+      }
+    }
+    for (const gid of [...dirtyRoles]) {
+      const g = core.groups.get(gid)
+      if (!g) {
+        dirtyRoles.delete(gid)
+        continue
+      }
+      try {
+        s.atomicWrite(s.rolesFile(gid), JSON.stringify(rolesDocument(g)))
+        dirtyRoles.delete(gid)
+        fsyncDirs.add(s.groupDir(gid))
+      } catch (e) {
+        console.error(`[dsh-group-chat] 群组 ${gid} roles.json 落盘失败（保留脏标记待重试）：`, e)
+      }
+    }
+    for (const gid of [...dirtyWorkspace]) {
+      const g = core.groups.get(gid)
+      if (!g) {
+        dirtyWorkspace.delete(gid)
+        continue
+      }
+      try {
+        s.atomicWrite(s.workspaceFile(gid), (g.workspaceDir || '') + '\n')
+        dirtyWorkspace.delete(gid)
+        fsyncDirs.add(s.groupDir(gid))
+      } catch (e) {
+        console.error(`[dsh-group-chat] 群组 ${gid} workspaceDir 落盘失败（保留脏标记待重试）：`, e)
+      }
+    }
+    if (ledgerDirty) {
+      try {
+        s.atomicWrite(s.ledgerFile, JSON.stringify(ledgerDocument(), null, 2))
+        ledgerDirty = false
+        fsyncDirs.add(s.dir)
+      } catch (e) {
+        console.error('[dsh-group-chat] ledger.json 落盘失败（保留脏标记待重试）：', e)
+      }
+    }
+    for (const d of fsyncDirs) s.fsyncDir(d)
+  }
+
+  /** 事件驱动落盘；同一 tick 内多次变更合并为一次写。 */
+  const schedulePersist = ({ ledger = false, session = null, roles: roleGroup = null, workspace = null }: { ledger?: boolean, session?: string | null, roles?: string | null, workspace?: string | null } = {}): void => {
+    if (store() === null) return
+    if (ledger) ledgerDirty = true
+    if (session) dirtySessions.add(session)
+    if (roleGroup) dirtyRoles.add(roleGroup)
+    if (workspace) dirtyWorkspace.add(workspace)
+    if (flushScheduled) return
+    flushScheduled = true
+    void Promise.resolve().then(() => {
+      flushScheduled = false
+      flushNow()
+    })
+  }
+
+  const dropDirty = ({ session = null, roles: roleGroup = null, workspace = null }: { session?: string | null, roles?: string | null, workspace?: string | null }): void => {
+    if (session) dirtySessions.delete(session)
+    if (roleGroup) dirtyRoles.delete(roleGroup)
+    if (workspace) dirtyWorkspace.delete(workspace)
+  }
+
+  // ---- 启动恢复：v1 迁移 → 残留清理 → 清单 → 群组数据 → 会话文件；缺文件空重建 ----
+
+  const loadSession = (groupId: string, sid: string, noteMissing: boolean): void => {
+    if (core.sessions.has(sid)) return
+    const g = core.groups.get(groupId)
+    if (!g) return
+    const sess: SessionRecord = { id: sid, groupId, name: '会话', topic: '', messageIds: [], createdAt: Date.now() }
+    let doc: SessionDocument | null = null
+    const s = store()
+    if (s) {
+      const file = s.sessionFile(groupId, sid)
+      if (noteMissing && !existsSync(file)) console.error(`[dsh-group-chat] 会话 ${sid} 文件缺失，按空消息重建`)
+      doc = s.loadJson(file) as SessionDocument | null
+    }
+    if (doc) {
+      if (typeof doc.name === 'string' && doc.name) sess.name = doc.name
+      if (typeof doc.topic === 'string') sess.topic = doc.topic
+      if (doc.namePinned === true) sess.namePinned = true
+      if (doc.topicPinned === true) sess.topicPinned = true
+      if (typeof doc.createdAt === 'number') sess.createdAt = doc.createdAt
+      let fallbackSeq = 0
+      for (const m of (Array.isArray(doc.messages) ? doc.messages : [])) {
+        if (!m || typeof m.id !== 'string' || core.messages.has(m.id)) continue
+        fallbackSeq++
+        core.messages.set(m.id, {
+          id: m.id,
+          sessionId: sid,
+          seq: typeof m.seq === 'number' ? m.seq : fallbackSeq,
+          speaker: m.speaker ?? '',
+          text: String(m.text || ''),
+          reasoning: m.reasoning !== undefined ? String(m.reasoning) : undefined,
+          reasoningFull: m.reasoningFull !== undefined ? String(m.reasoningFull) : undefined,
+          thinkingSummary: m.thinkingSummary !== undefined ? String(m.thinkingSummary) : undefined,
+          model: m.model,
+          error: m.error,
+          toolCalls: Array.isArray(m.toolCalls) ? m.toolCalls : undefined,
+          ts: typeof m.ts === 'number' ? m.ts : Date.now(),
+        })
+        sess.messageIds.push(m.id)
+      }
+    }
+    core.sessions.set(sid, sess)
+    g.sessionIds.push(sid)
+  }
+
+  const loadGroupData = (g: GroupRecord): void => {
+    const s = store()
+    if (!s) return
+    g.workspaceDir = s.readWorkspace(g.id)
+    const doc = s.loadJson(s.rolesFile(g.id)) as RolesDocument | null
+    if (doc && Array.isArray(doc.roles)) {
+      for (const r of doc.roles) {
+        if (r && typeof r.id === 'string' && !core.roles.has(r.id)) {
+          core.roles.set(r.id, {
+            id: r.id,
+            groupId: g.id,
+            name: String(r.name || '成员'),
+            color: r.color || undefined,
+            persona: String(r.persona || ''),
+            provider: String(r.provider || ''),
+            model: String(r.model || ''),
+            temperature: asNumber(r.temperature),
+            reasoningEffort: typeof r.reasoningEffort === 'string' && r.reasoningEffort ? r.reasoningEffort : undefined,
+            enabled: r.enabled !== false,
+            thinking: r.thinking === true,
+          })
+          g.roleIds.push(r.id)
+        }
+      }
+    }
+  }
+
+  const hydrate = (): void => {
+    const s = store()
+    if (s) {
+      try {
+        s.migrateV1()
+      } catch (e) {
+        console.error('[dsh-group-chat] v1 数据迁移失败，下次启动重试：', e)
+      }
+      try {
+        s.cleanup()
+      } catch {}
+    }
+    const ledger = s ? (s.loadJson(s.ledgerFile) as LedgerDocument | null) : null
+    if (ledger && Array.isArray(ledger.groups)) {
+      for (const g of ledger.groups) {
+        if (g && typeof g.id === 'string' && !core.groups.has(g.id)) {
+          core.groups.set(g.id, { id: g.id, name: String(g.name || '群组'), workspaceDir: '', permissionTier: migrateTier(g.permissionTier, g.allowCommands), roleIds: [], sessionIds: [] })
+        }
+      }
+      for (const g of core.groups.values()) loadGroupData(g)
+      for (const item of (Array.isArray(ledger.sessions) ? ledger.sessions : [])) {
+        if (item && typeof item.id === 'string' && core.groups.has(item.groupId)) loadSession(item.groupId, item.id, true)
+      }
+    } else if (s) {
+      // ledger 缺失/损坏：扫描群组目录回收（群组名丢失，角色/工作区/会话从文件恢复）
+      for (const gid of scanGroupIds(STORE_DIR)) {
+        const g = emptyGroup(gid, '群组')
+        core.groups.set(g.id, g)
+        loadGroupData(g)
+        for (const sid of scanSessionIds(s, gid)) loadSession(gid, sid, false)
+      }
+    }
+    const autoSessions: string[] = []
+    for (const g of core.groups.values()) {
+      if (g.sessionIds.length === 0) {
+        const sess = core.newSession(g.id)
+        g.sessionIds.push(sess.id)
+        autoSessions.push(sess.id)
+      }
+    }
+    if (core.groups.size === 0) {
+      const g: GroupRecord = { id: core.nid('grp'), name: '默认群组', workspaceDir: '', permissionTier: 'view_only', roleIds: [], sessionIds: [] }
+      core.groups.set(g.id, g)
+      const sess = core.newSession(g.id, '会话 1')
+      g.sessionIds.push(sess.id)
+      autoSessions.push(sess.id)
+    }
+    let maxSeq = 0
+    for (const id of [...core.groups.keys(), ...core.roles.keys(), ...core.messages.keys()]) {
+      const m = /-(\d+)$/.exec(id)
+      if (m) maxSeq = Math.max(maxSeq, Number(m[1]))
+    }
+    core.idSeq = maxSeq + 1
+    // 补建的默认会话/群组立即落盘，保证 ledger 与会话文件引用一致
+    if (autoSessions.length > 0) {
+      schedulePersist({ ledger: true })
+      for (const sid of autoSessions) schedulePersist({ session: sid })
+    }
+  }
+  hydrate()
+
+  return {
+    schedulePersist,
+    flushNow,
+    dropDirty,
+    release(): void {
+      const s = store()
+      if (s === null) return
+      try {
+        flushNow()
+      } catch {}
+      try {
+        s.release()
+      } catch {}
+      core.store = null
+    },
+  }
+}