@roaming-ai/dsh-group-chat 0.2.0

package/src/host/tools/tools.ts

@@ -0,0 +1,194 @@
+/**
+ * 工具执行（TOOLS.md §2：沙箱 / §3：确认闸门）：read_file / list_dir /
+ * run_command 三件套；realpath 硬边界 + 分隔符比较；run_command 按群组
+ * 权限档位走逐条确认或直接执行。
+ * @module dsh-group-chat/host/tools
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process'
+import { closeSync, openSync, readSync, readdirSync, realpathSync, statSync } from 'node:fs'
+import { isAbsolute, join, sep } from 'node:path'
+import { CMD_CAPTURE_MAX_BYTES, CMD_OUTPUT_MAX_CHARS, READ_FILE_MAX_BYTES, RUN_CMD_TIMEOUT_MS, TOOL_SCHEMAS } from '../../core/tools.ts'
+import type { GroupRecord, RunState, ToolExecution } from '../../core/types.ts'
+import type { HostState } from '../state.ts'
+
+/** 工具面。 */
+export interface Tools {
+  /** 执行一次工具调用（args 解析 + 分发 + 计时；确认闸门在 run_command 内）。 */
+  executeTool: (g: GroupRecord, root: string, tc: { id: string, name: string, args: string }) => Promise<ToolExecution>
+  /** 工具 schema（view_only 档剔除 run_command）。 */
+  buildToolSchemas: (g: GroupRecord) => (typeof TOOL_SCHEMAS)[number][]
+  /** 置 pendingConfirm 后无限等待，confirmCommand/stop/dispose 唤醒。 */
+  requestConfirmation: (toolCallId: string, args: Record<string, unknown>) => Promise<boolean>
+  /** 唤醒确认等待（以拒绝放行；置空 pendingConfirm）。 */
+  wakeConfirm: () => void
+  /** kill 正在执行的命令子进程。 */
+  killChild: () => void
+}
+
+/** 创建工具面。 */
+export function createTools(core: HostState, touch: () => void): Tools {
+  const { run } = core
+
+  /** realpath 硬边界：目标必须在群组工作区内（带分隔符比较，防 /ws/foo 放行 /ws/foobar）。 */
+  const resolveInWorkspace = (root: string, rawPath: unknown): { ok: true, target: string } | { ok: false, error: string } => {
+    const p = rawPath === undefined || rawPath === null || String(rawPath).trim() === '' ? '.' : String(rawPath)
+    let target: string
+    try {
+      target = realpathSync(isAbsolute(p) ? p : join(root, p))
+    } catch {
+      return { ok: false, error: '路径不存在：' + p }
+    }
+    if (target !== root && !target.startsWith(root + sep)) {
+      return { ok: false, error: '路径超出群组工作区范围：' + p }
+    }
+    return { ok: true, target }
+  }
+
+  const toolReadFile = (root: string, args: Record<string, unknown>): { status: 'ok' | 'error', output: string } => {
+    const r = resolveInWorkspace(root, args.path)
+    if (!r.ok) return { status: 'error', output: r.error }
+    let fd: number | undefined
+    try {
+      const st = statSync(r.target)
+      if (!st.isFile()) return { status: 'error', output: '不是文件：' + String(args.path) }
+      fd = openSync(r.target, 'r')
+      const buf = Buffer.alloc(READ_FILE_MAX_BYTES + 1)
+      const n = readSync(fd, buf, 0, buf.length, 0)
+      let text = buf.subarray(0, Math.min(n, READ_FILE_MAX_BYTES)).toString('utf8')
+      if (n > READ_FILE_MAX_BYTES) text += '\n…(文件超过 100KB，已截断)'
+      return { status: 'ok', output: text || '（空文件）' }
+    } catch (e) {
+      return { status: 'error', output: '读取失败：' + String((e && (e as Error).message) || e) }
+    } finally {
+      if (fd !== undefined) {
+        try {
+          closeSync(fd)
+        } catch {}
+      }
+    }
+  }
+
+  const toolListDir = (root: string, args: Record<string, unknown>): { status: 'ok' | 'error', output: string } => {
+    const r = resolveInWorkspace(root, args.path)
+    if (!r.ok) return { status: 'error', output: r.error }
+    try {
+      const st = statSync(r.target)
+      if (!st.isDirectory()) return { status: 'error', output: '不是目录：' + String(args.path) }
+      const entries = readdirSync(r.target, { withFileTypes: true }).sort((a, b) => (a.isDirectory() ? 0 : 1) - (b.isDirectory() ? 0 : 1) || a.name.localeCompare(b.name))
+      const lines = entries.slice(0, 500).map((e) => {
+        if (e.isDirectory()) return e.name + '/'
+        try {
+          return e.name + ' (' + statSync(join(r.target, e.name)).size + ' B)'
+        } catch {
+          return e.name
+        }
+      })
+      if (entries.length > 500) lines.push('…(共 ' + entries.length + ' 项，仅显示前 500)')
+      const out = lines.join('\n') || '（空目录）'
+      return { status: 'ok', output: out.length > CMD_OUTPUT_MAX_CHARS ? out.slice(0, CMD_OUTPUT_MAX_CHARS) + '\n…(已截断)' : out }
+    } catch (e) {
+      return { status: 'error', output: '列出失败：' + String((e && (e as Error).message) || e) }
+    }
+  }
+
+  const runCommandTool = (root: string, command: string): Promise<{ status: 'ok' | 'error', output: string }> => new Promise((resolve) => {
+    let child: ChildProcess
+    try {
+      child = spawn('bash', ['-c', command], { cwd: root })
+    } catch (e) {
+      resolve({ status: 'error', output: '无法启动命令：' + String((e && (e as Error).message) || e) })
+      return
+    }
+    run.childProc = child
+    let out = ''
+    let dropped = 0
+    let timedOut = false
+    const onChunk = (chunk: Buffer) => {
+      if (out.length < CMD_CAPTURE_MAX_BYTES) out += chunk.toString('utf8')
+      else dropped += chunk.length
+    }
+    child.stdout?.on('data', onChunk)
+    child.stderr?.on('data', onChunk)
+    const timer = setTimeout(() => {
+      timedOut = true
+      try {
+        child.kill('SIGKILL')
+      } catch {}
+    }, RUN_CMD_TIMEOUT_MS)
+    const finish = (result: { status: 'ok' | 'error', output: string }) => {
+      clearTimeout(timer)
+      if (run.childProc === child) run.childProc = null
+      resolve(result)
+    }
+    child.on('error', (e) => finish({ status: 'error', output: '执行失败：' + String((e && e.message) || e) }))
+    child.on('close', (code) => {
+      let text = out.length > CMD_CAPTURE_MAX_BYTES ? out.slice(0, CMD_CAPTURE_MAX_BYTES) : out
+      if (dropped > 0) text += '\n[输出采集超限，已丢弃 ' + dropped + ' 字节]'
+      if (timedOut) text += '\n[执行超时（' + Math.round(RUN_CMD_TIMEOUT_MS / 1000) + 's），已强制终止]'
+      if (code !== 0 && code !== null && !timedOut) text += '\n[退出码 ' + code + ']'
+      if (text.length > CMD_OUTPUT_MAX_CHARS) text = text.slice(0, CMD_OUTPUT_MAX_CHARS) + '\n…(输出超长，已截断)'
+      finish({ status: code === 0 ? 'ok' : 'error', output: text || '（无输出）' })
+    })
+  })
+
+  /** run_command 确认闸门：置 pendingConfirm 后无限等待，confirmCommand/stop/dispose 唤醒。 */
+  const requestConfirmation = (toolCallId: string, args: Record<string, unknown>): Promise<boolean> => new Promise((resolve) => {
+    run.pendingConfirm = { toolCallId, tool: 'run_command', args: args as RunState['pendingConfirm'] extends null ? never : NonNullable<RunState['pendingConfirm']>['args'] }
+    run.confirmSignal = { resolve }
+    touch()
+  })
+
+  const wakeConfirm = (): void => {
+    const signal = run.confirmSignal
+    run.pendingConfirm = null
+    run.confirmSignal = null
+    if (signal) {
+      try {
+        signal.resolve(false)
+      } catch {}
+    }
+  }
+
+  const killChild = (): void => {
+    if (run.childProc) {
+      try {
+        run.childProc.kill('SIGKILL')
+      } catch {}
+    }
+  }
+
+  const executeTool = async (g: GroupRecord, root: string, tc: { id: string, name: string, args: string }): Promise<ToolExecution> => {
+    let args: Record<string, unknown> = {}
+    try {
+      const parsed = JSON.parse(tc.args)
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) args = parsed as Record<string, unknown>
+    } catch {}
+    const started = Date.now()
+    let res: { status: 'ok' | 'error' | 'denied', output: string }
+    if (tc.name === 'read_file') res = toolReadFile(root, args)
+    else if (tc.name === 'list_dir') res = toolListDir(root, args)
+    else if (tc.name === 'run_command') {
+      if (g.permissionTier === 'view_only') {
+        res = { status: 'error', output: '群组权限为「仅可查看」，该命令未被运行' }
+      } else if (g.permissionTier === 'workspace_write') {
+        const allowed = await requestConfirmation(tc.id, args)
+        if (run.stopping) res = { status: 'error', output: '对话已被用户停止，命令未执行' }
+        else if (!allowed) res = { status: 'denied', output: '用户拒绝了这次命令执行' }
+        else res = await runCommandTool(root, String(args.command || ''))
+      } else {
+        res = await runCommandTool(root, String(args.command || ''))
+      }
+    } else {
+      res = { status: 'error', output: '未知工具：' + tc.name }
+    }
+    return { status: res.status, output: res.output, args, durationMs: Date.now() - started }
+  }
+
+  const buildToolSchemas = (g: GroupRecord) => {
+    if (!g.workspaceDir) return []
+    return TOOL_SCHEMAS.filter((t) => t.name !== 'run_command' || g.permissionTier !== 'view_only')
+  }
+
+  return { executeTool, buildToolSchemas, requestConfirmation, wakeConfirm, killChild }
+}

package/src/index.ts

@@ -0,0 +1,99 @@
+/**
+ * dsh-group-chat — DSH 模型群聊（host 平面组合插件，host + client 双半）。
+ *
+ * Host 半职责：
+ *  - 群组 / 会话 / 角色 / 消息的状态机，会话级文件持久化于
+ *    ~/.dsh/storages/group-chat/（PERSISTENCE.md v2.1：每群组一目录，
+ *    sessions/session-<uuid>.json 一会话一文件；roles.json 与 workspaceDir
+ *    随群组目录；ledger.json 纯清单；原子写 tmp+fsync+rename（每目录一次
+ *    fsync）；单实例 .lock；损坏隔离重建；写失败保留脏标记；v1 自动迁移）
+ *    数据模型：Group 1..N Session，消息挂在会话上；角色与工作区目录挂在群组上
+ *  - 群组与会话的增删改；群组/会话检索由客户端在快照上过滤
+ *  - 角色发言经 `llm` 服务流式生成，按角色绑定的 provider/model 路由
+ *  - 群组工作区目录经 `fs` 服务读取（根下一层文本文件，最多 20 个），
+ *    以「共享资料」块注入每个角色的 system 提示词；无独立笔记/文件清单
+ *  - 经 `webServer` 暴露 HTTP API：
+ *      GET  /api/group-chat/state   全量快照
+ *      POST /api/group-chat/action   { kind: mutate|send|stop|confirmCommand|models|efforts|browse|fileSearch, ... }
+ *      GET  /api/group-chat/events   SSE，状态变化时推送节流后的全量快照
+ *
+ * 设置命名空间 `group-chat`（settings.yaml 持久化）：`enabled` 控制浏览器半
+ * 的侧边栏入口与主面板挂载；关闭时会中止正在进行的群聊。
+ *
+ * @module dsh-group-chat
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-host-webserver'
+import type { SettingsNamespace } from '@deepseek-ai/dsh-settings'
+// 类型合并：ctx.settings（宿主面）
+import type {} from '@deepseek-ai/dsh-settings'
+import z from 'schemastery'
+import { mountOnce } from './mount-once.ts'
+import { createGroupChatService, makeGroupChatRoutes } from './host/index.ts'
+
+export const name = 'group-chat'
+
+export const inject = ['llm', 'fs', 'webServer', 'workspaceRegistry']
+
+/** 设置命名空间；浏览器半拼写同一值，两边不共享代码。 */
+export const SETTINGS_NAMESPACE = 'group-chat' as SettingsNamespace
+
+export interface Config {
+  enabled?: boolean
+}
+
+/** 设置 schema：目前只有启停一个开关。 */
+export const Config: z<Config> = z.object({
+  enabled: z.boolean().default(true),
+})
+
+/**
+ * Host 半插件体：状态机服务 + HTTP 路由 + 设置接入。
+ * mountOnce 保证同名包每进程至多挂载一次（bundle 聚合与独立安装并存场景）。
+ */
+export const apply = mountOnce('dsh-group-chat', (ctx: Context, config?: Config): void => {
+  const service = createGroupChatService(ctx)
+
+  // ---------- HTTP 路由 ----------
+  ctx.effect(() => {
+    const disposers = makeGroupChatRoutes(service).map((route) => ctx.webServer.register(route))
+    return () => {
+      for (const dispose of disposers) dispose()
+    }
+  }, 'group-chat: host API routes')
+
+  // 插件卸载/热重载：唤醒确认等待 + kill 子进程 → 同步最终 flush → 释放锁
+  ctx.effect(() => () => {
+    service.dispose()
+  })
+
+  // ---------- 设置（enabled 持久化于 settings.yaml） ----------
+
+  let current = (): Config => config ?? {}
+  const sync = (): void => {
+    const enabled = current().enabled ?? true
+    if (!enabled) service.stopAll()
+  }
+  ctx.inject(['settings'], (settingsCtx) => {
+    try {
+      if (typeof settingsCtx.settings?.installSection === 'function') {
+        settingsCtx.settings.installSection(ctx, SETTINGS_NAMESPACE, Config, config ?? {}, {
+          setSource: (source: () => Config) => {
+            current = source
+          },
+          onChange: sync,
+        })
+      } else if (typeof settingsCtx.settings?.register === 'function') {
+        const scope = settingsCtx.settings.register(SETTINGS_NAMESPACE, Config, { base: config ?? {} })
+        current = () => scope?.get?.() ?? (config ?? {})
+        scope?.watch?.(() => {
+          sync()
+        })
+      }
+    } catch {
+      /* 设置面不可用时插件照常工作，始终视为启用 */
+    }
+  })
+  sync()
+})

package/src/mount-once.ts

@@ -0,0 +1,49 @@
+// Generated by sync-shared (dsh-web shared/host/mount-once.ts). Do not edit this copy; edit the shared source and re-run the sync.
+
+/**
+ * Host single-instance guard shared by the plugin family. The family bundle
+ * (dsh-web-all / dsh-skins) namespaces every child row id (web-ui-*), so
+ * the loader accepts a standalone install of the same package side by side;
+ * without this guard the second instance would still re-register the same
+ * webserver routes, tools, settings namespaces, and system-prompt sections
+ * and fail the boot. mountOnce makes the second host apply a no-op for the
+ * lifetime of the first instance (the browser half is already deduped by
+ * package name in the client module host).
+ *
+ * The registry rides a global symbol so two module instances of the same
+ * package (npm copy vs repository link) still share one verdict. cordis
+ * `ctx.effect` runs its callback immediately and treats the callback's
+ * return value as the fiber disposer, so the unmarker is returned, not run.
+ */
+
+const MOUNTED = Symbol.for('dsh-web.mounted-plugins')
+
+interface MountRegistry {
+  [MOUNTED]?: Set<string>
+}
+
+function mountedSet(): Set<string> {
+  const registry = globalThis as MountRegistry
+  return (registry[MOUNTED] ??= new Set())
+}
+
+/**
+ * Wrap a cordis plugin apply so the package runs at most once per process.
+ * The first mount registers normally and unmarks when its fiber disposes;
+ * any later mount of the same package name is a no-op.
+ * @param packageName - npm package identity shared by every install source.
+ * @param fn - the original plugin apply.
+ * @returns an apply of the same shape.
+ */
+export function mountOnce<T extends (...args: any[]) => unknown>(packageName: string, fn: T): T {
+  return ((...args: unknown[]) => {
+    const mounted = mountedSet()
+    if (mounted.has(packageName)) return
+    mounted.add(packageName)
+    const ctx = args[0] as { effect?: (effect: () => unknown) => unknown } | undefined
+    ctx?.effect?.(() => () => {
+      mounted.delete(packageName)
+    })
+    return fn(...args)
+  }) as T
+}

package/src/shared/file-mention-grammar.test.ts

@@ -0,0 +1,77 @@
+/**
+ * @file Tests for vendored @file token grammar.
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import { activeAtToken, formatFileMention } from './file-mention-grammar.ts'
+
+describe('activeAtToken', () => {
+  it('extracts plain @path at cursor', () => {
+    expect(activeAtToken('@fil', 4)).toEqual({ prefix: '@fil', query: 'fil', quoted: false })
+    expect(activeAtToken('@src/', 5)).toEqual({ prefix: '@src/', query: 'src/', quoted: false })
+    expect(activeAtToken('text @lib/index.ts', 18)).toEqual({ prefix: '@lib/index.ts', query: 'lib/index.ts', quoted: false })
+  })
+
+  it('extracts quoted @"path with spaces at cursor', () => {
+    expect(activeAtToken('@"My Documents', 14)).toEqual({ prefix: '@"My Documents', query: 'My Documents', quoted: true })
+    expect(activeAtToken('open @"src/my file.ts', 22)).toEqual({ prefix: '@"src/my file.ts', query: 'src/my file.ts', quoted: true })
+  })
+
+  it('returns undefined when @ is not at word boundary', () => {
+    expect(activeAtToken('user@example.com', 16)).toBeUndefined()
+    expect(activeAtToken('no@@', 4)).toBeUndefined()
+  })
+
+  it('returns undefined when cursor is not inside @token', () => {
+    expect(activeAtToken('@file extra', 11)).toBeUndefined()
+    expect(activeAtToken('before @file', 6)).toBeUndefined()
+  })
+
+  it('handles @ at line start', () => {
+    expect(activeAtToken('@', 1)).toEqual({ prefix: '@', query: '', quoted: false })
+    expect(activeAtToken('@"', 2)).toEqual({ prefix: '@"', query: '', quoted: true })
+  })
+
+  it('handles @ after whitespace', () => {
+    expect(activeAtToken('  @qu', 5)).toEqual({ prefix: '@qu', query: 'qu', quoted: false })
+    expect(activeAtToken('\t@"test', 7)).toEqual({ prefix: '@"test', query: 'test', quoted: true })
+  })
+})
+
+describe('formatFileMention', () => {
+  it('formats plain file without whitespace', () => {
+    expect(formatFileMention({ kind: 'file', path: 'README.md' }, false)).toBe('@README.md')
+    expect(formatFileMention({ kind: 'file', path: 'src/index.ts' }, false)).toBe('@src/index.ts')
+  })
+
+  it('formats plain directory with trailing slash', () => {
+    expect(formatFileMention({ kind: 'directory', path: 'src' }, false)).toBe('@src/')
+    expect(formatFileMention({ kind: 'directory', path: 'lib/utils' }, false)).toBe('@lib/utils/')
+  })
+
+  it('quotes file with whitespace and closes quote', () => {
+    expect(formatFileMention({ kind: 'file', path: 'My Document.txt' }, false)).toBe('@"My Document.txt"')
+    expect(formatFileMention({ kind: 'file', path: 'src/my file.ts' }, false)).toBe('@"src/my file.ts"')
+  })
+
+  it('quotes directory with whitespace but keeps quote open', () => {
+    expect(formatFileMention({ kind: 'directory', path: 'My Folder' }, false)).toBe('@"My Folder/')
+    expect(formatFileMention({ kind: 'directory', path: 'src/my lib' }, false)).toBe('@"src/my lib/')
+  })
+
+  it('preserves quote even when unnecessary', () => {
+    expect(formatFileMention({ kind: 'file', path: 'plain.txt' }, true)).toBe('@"plain.txt"')
+    expect(formatFileMention({ kind: 'directory', path: 'lib' }, true)).toBe('@"lib/')
+  })
+
+  it('rejects paths with control characters', () => {
+    expect(formatFileMention({ kind: 'file', path: 'file\x00.txt' }, false)).toBeUndefined()
+    expect(formatFileMention({ kind: 'file', path: 'file\n.txt' }, false)).toBeUndefined()
+  })
+
+  it('rejects paths with embedded quotes', () => {
+    expect(formatFileMention({ kind: 'file', path: 'file"name.txt' }, false)).toBeUndefined()
+    expect(formatFileMention({ kind: 'directory', path: 'dir"name' }, false)).toBeUndefined()
+  })
+})

package/src/shared/file-mention-grammar.ts

@@ -0,0 +1,82 @@
+/**
+ * Vendored @file token grammar from dsh-file-reference (browser-safe, zero Node API).
+ * 
+ * Sourced from @deepseek-ai/dsh-file-reference/lib/types/grammar.js
+ * Cannot import directly due to client bundle purity gate (dsh-client-bundle-purity).
+ * 
+ * @module dsh-group-chat/shared
+ */
+
+export interface AtToken {
+  /** Full matched prefix including @ and optional quotes */
+  prefix: string
+  /** Query fragment after @ (unquoted content) */
+  query: string
+  /** Whether the token uses quoted form @"..." */
+  quoted: boolean
+}
+
+export interface FileCandidate {
+  kind: 'file' | 'directory'
+  path: string
+}
+
+/**
+ * Extract active @token at cursor position.
+ * Matches @ at word boundary (line start or after whitespace).
+ * 
+ * @param line - Current line text
+ * @param cursor - Cursor offset in line
+ * @returns Token or undefined if no active @token at cursor
+ */
+export function activeAtToken(line: string, cursor: number): AtToken | undefined {
+  const before = line.slice(0, cursor)
+  
+  // Try quoted @"... first (more specific)
+  const quotedMatch = /(?:^|\s)@"([^"]*)$/.exec(before)
+  if (quotedMatch) {
+    const prefix = quotedMatch[0].trimStart()
+    return {
+      prefix,
+      query: quotedMatch[1],
+      quoted: true,
+    }
+  }
+
+  // Then try plain @...
+  const plainMatch = /(?:^|\s)@([^\s@]*)$/.exec(before)
+  if (plainMatch) {
+    const prefix = plainMatch[0].trimStart()
+    return {
+      prefix,
+      query: plainMatch[1],
+      quoted: false,
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Format file/directory candidate as @mention text.
+ * 
+ * @param candidate - File or directory to format
+ * @param preserveQuote - Keep quotes even when unnecessary (for drill-down continuity)
+ * @returns Formatted @path or undefined for invalid paths
+ */
+export function formatFileMention(candidate: FileCandidate, preserveQuote: boolean): string | undefined {
+  const { path } = candidate
+
+  // Reject control characters and embedded quotes
+  if (/[\x00-\x1F"]/.test(path)) return undefined
+
+  const needsQuote = /\s/.test(path)
+  const useQuote = needsQuote || preserveQuote
+
+  if (candidate.kind === 'file') {
+    return useQuote ? `@"${path}"` : `@${path}`
+  } else {
+    // Directory: trailing slash, quote stays open for drill-down
+    return useQuote ? `@"${path}/` : `@${path}/`
+  }
+}