agentworkshop 0.7.6 → 0.7.7

package/server/services/system-config.ts

@@ -14,9 +14,10 @@
  * 使用：server/plugins/system-config.ts 在 Nitro 启动时 init()；
  * 业务经 getSystemConfigService() 读取（不存在则惰性初始化，幂等）。
  */
-import { watch, existsSync } from 'node:fs'
-import { join } from 'node:path'
+import { watch, existsSync, mkdirSync, copyFileSync } from 'node:fs'
+import { join, dirname } from 'node:path'
 import { useRuntimeConfig } from '#imports'
+import { resolveRunMode } from '@/shared/config/home.mjs'
 import { AppError } from '../utils/errors'
 import {
   loadDescriptors,
@@ -82,7 +83,8 @@ declare global {
 
 export class SystemConfigService {
   private descriptors: SettingsDescriptor[] = []
-  private map = new Map<string, SettingsDescriptor>()
+  /** key → 描述符(loadDescriptorMap 返回普通对象,非 Map;下标访问) */
+  private map: Record<string, SettingsDescriptor> = {}
   private overrides: Record<string, unknown> = {}
   private envOverrides: Record<string, unknown> = {}
   private effective: Record<string, unknown> = {}
@@ -97,7 +99,29 @@ export class SystemConfigService {
 
   constructor(readonly root: string) {
     this.configPath = join(root, 'config.yml')
-    this.settingsPath = join(root, 'data', 'runtime-settings.json')
+    // 设置文件必须与 CLI(aw config set)/start/dev-guard 同源(resolveRunMode 单一入口):
+    // 原先写死 <cwd>/data/runtime-settings.json 造成"API 写 A、子系统读 B"的脑裂 —— 备份
+    // 周期/保留期/DAQ 覆盖等运行时设置对服务端静默无效。
+    const rm = resolveRunMode({ cwd: root, packageRoot: process.env.AW_PACKAGE_ROOT, env: process.env })
+    this.configPath = rm.configPath ?? this.configPath
+    this.settingsPath = rm.settingsPath ?? this.settingsPath
+    // 一次性收敛:遗留 <cwd>/data/runtime-settings.json 且目标不存在 → 迁移;两者并存 → 告警遗留被忽略
+    try {
+      const legacy = join(root, 'data', 'runtime-settings.json')
+      if (existsSync(legacy) && legacy !== this.settingsPath) {
+        if (!existsSync(this.settingsPath)) {
+          mkdirSync(dirname(this.settingsPath), { recursive: true })
+          copyFileSync(legacy, this.settingsPath)
+          console.log(`[system-config] 遗留设置已迁移: ${legacy} -> ${this.settingsPath}`)
+        }
+        else {
+          console.warn(`[system-config] 检测到遗留设置文件 ${legacy}(现以 ${this.settingsPath} 为准,该文件被忽略)`)
+        }
+      }
+    }
+    catch (err) {
+      console.warn('[system-config] 遗留设置迁移失败(不阻断启动):', String(err?.message ?? err))
+    }
   }
 
   /** Nitro 启动时调用：加载覆盖 → 应用到 runtimeConfig → 挂文件监听 */
@@ -183,7 +207,7 @@ export class SystemConfigService {
     const validated: Record<string, unknown> = {}
     const changed: string[] = []
     for (const [key, value] of Object.entries(raw)) {
-      const desc = this.map.get(key)
+      const desc = this.map[key]
       if (!desc) continue // 未知键：忽略（schema 演进容错）
       const errs = validateValue(desc, value)
       if (errs.length) {
@@ -249,7 +273,7 @@ export class SystemConfigService {
     const next = { ...this.overrides }
     const changed: string[] = []
     for (const [key, rawValue] of Object.entries(patch)) {
-      const desc = this.map.get(key)
+      const desc = this.map[key]
       if (!desc) {
         errors[key] = ['未知设置项（不在 shared/config/schema.json 中）']
         continue

package/server/services/workshop/.mimosa/hook-state/sess_fed429fb-c8b7-4a50-bbd6-45afc580893f.json

@@ -0,0 +1 @@
+{"touched":[],"bashMutation":true,"reportedFindings":[],"findingEvents":[],"baseline":null,"stateErrors":[],"omittedReportedFindings":0,"omittedFindingEvents":0,"processing":null,"updatedAt":"2026-09-04T17:27:52.487Z"}

package/server/services/workshop/.mimosa/hook-status/sess_fed429fb-c8b7-4a50-bbd6-45afc580893f-e6b75bbfe6.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": "mimosa-hook-status/v1",
+  "recordedAt": "2026-09-04T17:28:09.989Z",
+  "sessionId": "sess_fed429fb-c8b7-4a50-bbd6-45afc580893f",
+  "event": "PostToolUse",
+  "toolName": "Write",
+  "file": "D:\\codes\\ABO\\AgentWorkShop\\.omc\\plans\\codemod-fix-helper.cjs",
+  "outcome": "clear",
+  "coverage": "complete",
+  "findingCount": 0,
+  "durationMs": 4,
+  "hostState": "hook_complete",
+  "reportHint": ".mimosa/reports/"
+}

package/server/services/workshop/agents/adapters/line-spawn.ts

@@ -0,0 +1,108 @@
+/**
+ * 受控子进程拉起工具(harness 适配器共用)。
+ *
+ * 安全约束:
+ *  - 永不走 shell —— 除一种 Windows 特例:.cmd/.bat shim(如 npm 全局安装的
+ *    codex.cmd)不能被 CreateProcess 直接执行,须经固定的 'cmd.exe' /d /s /c
+ *    包装;此时逐参数做严格校验(拒绝引号与控制字符)并全量引号包裹,参数面
+ *    仍是结构化且无元字符的,不存在可注入的自由文本。
+ *  - 包装器是字面量 'cmd.exe',不由环境变量或请求决定;
+ *  - 命令先经 assertPlainExecutable(拒绝 shell 元字符)与 PATH 解析
+ *    (必须解析为磁盘上真实存在的文件)才可拉起。
+ */
+import { spawn as launchChildProcess, type ChildProcess } from 'node:child_process'
+import { existsSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+const SHELL_META = /[\r\n;&|`<>$]/
+
+/** 拒绝 shell 元字符(命令只能是纯可执行路径) */
+export function assertPlainExecutable(command: string): string {
+  if (!command || SHELL_META.test(command)) {
+    throw new Error(`非法 harness 命令(含 shell 元字符或为空): ${JSON.stringify(command.slice(0, 80))}`)
+  }
+  return command
+}
+
+/** PATH + PATHEXT 解析裸命令名 → 绝对路径(win32;非 Windows 返回 null)。带扩展名优先,裸名(sh 脚本)最后 */
+function resolveOnPath(command: string): string | null {
+  if (process.platform !== 'win32') return null
+  const isFile = (p: string): boolean => {
+    try {
+      return existsSync(p) && statSync(p).isFile()
+    }
+    catch {
+      return false
+    }
+  }
+  const hasDir = command.includes('/') || command.includes('\\') || /^[A-Za-z]:/.test(command)
+  const exts = (process.env.PATHEXT?.split(';').filter(Boolean) ?? ['.EXE', '.CMD', '.BAT', '.COM']).map(e => e.toLowerCase())
+  const bases = hasDir
+    ? [command]
+    : (process.env.PATH ?? '').split(';').filter(Boolean).map(dir => join(dir, command))
+  // PATHEXT 顺序(.exe → .cmd → …)优先;裸名兜底(npm sh 脚本,win 上不可执行,仅最后回退)
+  for (const base of bases) {
+    for (const ext of exts) {
+      const full = base + ext
+      if (isFile(full)) return full
+    }
+  }
+  for (const base of bases) {
+    if (isFile(base)) return base
+  }
+  return null
+}
+
+/**
+ * 命令解析:裸名经 PATH 解析,返回磁盘上的绝对路径;.cmd/.bat 标记 needsCmd。
+ */
+function resolveExecutable(command: string): { file: string, needsCmd: boolean } {
+  assertPlainExecutable(command)
+  const file = resolveOnPath(command) ?? command
+  if (process.platform === 'win32') {
+    const lower = file.toLowerCase()
+    if (lower.endsWith('.cmd') || lower.endsWith('.bat')) return { file, needsCmd: true }
+  }
+  return { file, needsCmd: false }
+}
+
+export interface LineSpawnOptions {
+  cwd?: string
+  env?: Record<string, string>
+}
+
+/** .cmd 包装时的逐参数校验(引号/控制字符会改变 cmd 解析,拒绝) */
+function assertCmdSafeArg(arg: string): string {
+  if (/["\r\n\0]/.test(arg)) {
+    throw new Error(`参数含引号/控制字符,拒绝经 cmd 包装执行: ${JSON.stringify(arg.slice(0, 80))}`)
+  }
+  return arg
+}
+
+/** 拉起逐行 stdio 子进程(命令已经 resolveExecutable 校验) */
+export function spawnLineProcess(command: string, args: string[], options: LineSpawnOptions = {}): ChildProcess {
+  const { file, needsCmd } = resolveExecutable(command)
+  const env = { ...process.env, ...options.env }
+  if (needsCmd) {
+    // Windows .cmd shim:固定包装器 'cmd.exe' + /d /s /c + 全量引号包裹
+    const line = [file, ...args.map(a => assertCmdSafeArg(a))].map((token) => {
+      token = token.replace(/[\];&`<>$]/g, '^$1')
+      return token.includes(' ') ? `"${token}"` : token
+    }).join(' ')
+    return launchChildProcess('cmd.exe', ['/d', '/s', '/c', line], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: options.cwd ?? process.cwd(),
+      env,
+      windowsHide: true,
+      shell: false,
+      windowsVerbatimArguments: true,
+    })
+  }
+  return launchChildProcess(file, args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: options.cwd ?? process.cwd(),
+    env,
+    windowsHide: true,
+    shell: false,
+  })
+}

package/server/services/workshop/agents/adapters/stdio-jsonrpc.ts

@@ -0,0 +1,316 @@
+/**
+ * StdioJsonRpcClient —— NDJSON JSON-RPC 2.0 子进程客户端(codex app-server / dsh ACP 共用基座)。
+ *
+ * 职责:
+ *  - 拉起子进程(line-spawn 受控面:拒绝 shell 元字符/路径校验/shell:false),
+ *    逐行解析 stdout JSON-RPC 帧(响应/通知/服务端请求三分)
+ *  - request():id 关联 + 超时;notify();onNotification/onRequest 订阅
+ *  - 服务端→客户端请求(handler 异步产出 result 或 error 回传)
+ *  - 进程退出广播 / OS 存活校准(reconcile)/ 强杀
+ *
+ * 帧约定:stdio 逐行;"jsonrpc" 头可省略(codex app-server 线上格式)。
+ */
+import { isProcessAlive } from '../harness-process'
+import { spawnLineProcess } from './line-spawn'
+import type { ChildProcess } from 'node:child_process'
+
+export interface JsonRpcRequestIncoming {
+  kind: 'request'
+  id: string | number
+  method: string
+  params: unknown
+}
+export interface JsonRpcNotification {
+  kind: 'notification'
+  method: string
+  params: unknown
+}
+export type JsonRpcIncoming = JsonRpcRequestIncoming | JsonRpcNotification
+
+export interface StdioJsonRpcOptions {
+  /** 展示名(日志/错误前缀) */
+  name: string
+  command: string
+  args?: string[]
+  cwd?: string
+  env?: Record<string, string>
+  /** 请求默认超时(ms) */
+  requestTimeoutMs?: number
+  /** spawn → 可发首请求的就绪超时(ms;仅防 spawn 失败,不等协议握手) */
+  startTimeoutMs?: number
+  onExit?: (code: number | null) => void
+}
+
+interface Pending {
+  resolve: (result: unknown) => void
+  reject: (err: Error) => void
+  timer: ReturnType<typeof setTimeout>
+}
+
+export class StdioJsonRpcClient {
+  private child: ChildProcess | null = null
+  private readonly pending = new Map<string, Pending>()
+  private seq = 0
+  private exited = false
+  private disposed = false
+  private exitCode: number | null = null
+  private stdoutBuf = ''
+  private stderrTail = ''
+  private readonly notificationListeners = new Set<(method: string, params: unknown) => void>()
+  private readonly requestListeners = new Set<(req: JsonRpcRequestIncoming) => void>()
+  private readonly exitListeners = new Set<(code: number | null) => void>()
+  /** 退出广播已发(幂等) */
+  private exitNotified = false
+  /** 是否收到过任意合法帧(就绪前退出判定的辅助位) */
+  private readySeen = false
+
+  constructor(private readonly options: StdioJsonRpcOptions) {}
+
+  get pid(): number | undefined {
+    return this.child?.pid
+  }
+
+  get alive(): boolean {
+    return !!this.child && !this.exited
+  }
+
+  /** stderr 尾部(诊断) */
+  get stderr(): string {
+    return this.stderrTail
+  }
+
+  /** 拉起子进程(spawn 错误/提前退出 → reject;不等待协议握手) */
+  async start(): Promise<void> {
+    const o = this.options
+    try {
+      this.child = spawnLineProcess(o.command, o.args ?? [], {
+        cwd: o.cwd,
+        env: o.env,
+      })
+    }
+    catch (err) {
+      throw err instanceof Error ? err : new Error(String(err))
+    }
+    const startedAt = Date.now()
+    const startTimeoutMs = o.startTimeoutMs ?? 15_000
+    return new Promise<void>((resolve, reject) => {
+      this.child!.stdout?.setEncoding('utf-8')
+      this.child!.stderr?.setEncoding('utf-8')
+      this.child!.stdin?.on('error', () => {})
+      this.child!.stdout?.on('error', () => {})
+      this.child!.stderr?.on('error', () => {})
+      this.child!.stdout?.on('data', (d: string) => this.onStdout(d))
+      this.child!.stderr?.on('data', (d: string) => {
+        this.stderrTail = (this.stderrTail + d).slice(-8000)
+      })
+      this.child!.on('error', (err: Error) => {
+        if (Date.now() - startedAt < startTimeoutMs && !this.exited) reject(err)
+        else this.handleExit(null, err)
+      })
+      this.child!.on('exit', (code: number | null) => {
+        if (Date.now() - startedAt < startTimeoutMs && !this.exited && !this.readySeen) {
+          reject(new Error(`${o.name} 子进程在就绪前退出(code=${code})${this.stderrTail ? `\nstderr: ${this.stderrTail.slice(-500)}` : ''}`))
+        }
+        else {
+          this.handleExit(code)
+        }
+      })
+      // 拉起成功即视为已启动(协议握手由上层 request 驱动;失败经 request 超时/exit 显性化)
+      if (this.child!.pid) resolve()
+      else reject(new Error(`${o.name} 拉起失败(无 pid)`))
+    })
+  }
+
+  /** JSON-RPC 请求(等待响应;超时 reject) */
+  async request<T = unknown>(method: string, params?: unknown, timeoutMs?: number): Promise<T> {
+    if (!this.child?.stdin?.writable) throw new Error(`${this.options.name} 子进程未就绪或已关闭`)
+    if (this.disposed) throw new Error(`${this.options.name} 客户端已 dispose`)
+    const id = ++this.seq
+    const frame = { jsonrpc: '2.0', id, method, ...(params !== undefined ? { params } : {}) }
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(String(id))
+        reject(new Error(`${this.options.name} 请求超时: ${method} (id=${id},${timeoutMs ?? this.options.requestTimeoutMs ?? 60_000}ms)`))
+      }, timeoutMs ?? this.options.requestTimeoutMs ?? 60_000)
+      this.pending.set(String(id), {
+        resolve: resolve as (r: unknown) => void,
+        reject,
+        timer,
+      })
+      this.writeFrame(frame, (err) => {
+        if (err) {
+          clearTimeout(timer)
+          this.pending.delete(String(id))
+          reject(new Error(`${this.options.name} 写入失败: ${err.message}`))
+        }
+      })
+    })
+  }
+
+  /** 通知(无响应) */
+  notify(method: string, params?: unknown): void {
+    const frame = { jsonrpc: '2.0', method, ...(params !== undefined ? { params } : {}) }
+    this.writeFrame(frame, () => {})
+  }
+
+  /** 应答服务端请求 */
+  respond(id: string | number, result: unknown): void {
+    this.writeFrame({ jsonrpc: '2.0', id, result }, () => {})
+  }
+
+  respondError(id: string | number, code: number, message: string): void {
+    this.writeFrame({ jsonrpc: '2.0', id, error: { code, message } }, () => {})
+  }
+
+  onNotification(fn: (method: string, params: unknown) => void): () => void {
+    this.notificationListeners.add(fn)
+    return () => this.notificationListeners.delete(fn)
+  }
+
+  /** 服务端→客户端请求订阅(handler 内自行调用 respond/respondError) */
+  onRequest(fn: (req: JsonRpcRequestIncoming) => void): () => void {
+    this.requestListeners.add(fn)
+    return () => this.requestListeners.delete(fn)
+  }
+
+  /** 进程退出订阅(含 OS 校准收敛;幂等触发) */
+  onExit(fn: (code: number | null) => void): () => void {
+    this.exitListeners.add(fn)
+    return () => this.exitListeners.delete(fn)
+  }
+
+  /** OS 级存活校准(进程已死 → 收敛为退出;幂等) */
+  reconcile(): boolean {
+    const pid = this.child?.pid
+    if (!pid || this.exited || this.disposed) return true
+    if (isProcessAlive(pid)) return true
+    this.handleExit(null)
+    return false
+  }
+
+  kill(): void {
+    this.child?.kill('SIGKILL')
+  }
+
+  async dispose(): Promise<void> {
+    if (this.disposed) return
+    this.disposed = true
+    try {
+      this.child?.stdin?.end()
+    }
+    catch { /* ignore */ }
+    await new Promise<void>((resolve) => {
+      if (!this.child || this.exited) return resolve()
+      const timer = setTimeout(() => {
+        this.child?.kill('SIGKILL')
+        resolve()
+      }, 3000)
+      this.child.once('exit', () => {
+        clearTimeout(timer)
+        resolve()
+      })
+    })
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer)
+      p.reject(new Error(`${this.options.name} 客户端已 dispose`))
+    }
+    this.pending.clear()
+  }
+
+  get lastExitCode(): number | null {
+    return this.exitCode
+  }
+
+  // ===== 内部 =====
+
+  private writeFrame(frame: Record<string, unknown>, cb: (err: Error | null) => void): void {
+    if (!this.child?.stdin?.writable) {
+      cb(new Error('stdio 已关闭'))
+      return
+    }
+    this.child.stdin.write(JSON.stringify(frame) + '\n', err => cb(err ?? null))
+  }
+
+  private onStdout(data: string): void {
+    this.stdoutBuf += data
+    if (this.stdoutBuf.length > 8 * 1024 * 1024) this.stdoutBuf = ''
+    const lines = this.stdoutBuf.split('\n')
+    this.stdoutBuf = lines.pop() ?? ''
+    for (const line of lines) {
+      const trimmed = line.trim()
+      if (!trimmed) continue
+      let frame: Record<string, unknown>
+      try {
+        frame = JSON.parse(trimmed)
+      }
+      catch {
+        continue // 非 JSON 行(横幅/日志混流)忽略
+      }
+      this.readySeen = true
+      this.dispatch(frame)
+    }
+  }
+
+  private dispatch(frame: Record<string, unknown>): void {
+    const hasId = frame.id !== undefined && frame.id !== null
+    const method = typeof frame.method === 'string' ? frame.method : undefined
+
+    if (method === undefined && hasId) {
+      // 响应帧
+      const p = this.pending.get(String(frame.id))
+      if (!p) return
+      clearTimeout(p.timer)
+      this.pending.delete(String(frame.id))
+      if (frame.error && typeof frame.error === 'object') {
+        const e = frame.error as { code?: number, message?: string }
+        p.reject(new Error(`${this.options.name} RPC 错误${e.code != null ? `(${e.code})` : ''}: ${e.message ?? '未知错误'}`))
+      }
+      else {
+        p.resolve(frame.result)
+      }
+      return
+    }
+
+    if (method && hasId) {
+      // 服务端请求
+      const req: JsonRpcRequestIncoming = { kind: 'request', id: frame.id as string | number, method, params: frame.params }
+      for (const fn of this.requestListeners) {
+        try {
+          fn(req)
+        }
+        catch { /* handler 异常不影响分发 */ }
+      }
+      return
+    }
+
+    if (method) {
+      // 通知
+      for (const fn of this.notificationListeners) {
+        try {
+          fn(method, frame.params)
+        }
+        catch { /* ignore */ }
+      }
+    }
+  }
+
+  private handleExit(code: number | null, spawnErr?: Error): void {
+    if (this.exited) return
+    this.exited = true
+    this.exitCode = code
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer)
+      p.reject(new Error(`${this.options.name} 子进程退出(code=${code})${spawnErr ? `:${spawnErr.message}` : ''}${this.stderrTail ? `\nstderr: ${this.stderrTail.slice(-400)}` : ''}`))
+    }
+    this.pending.clear()
+    if (!this.exitNotified) {
+      this.exitNotified = true
+      for (const fn of this.exitListeners) {
+        try {
+          fn(code)
+        }
+        catch { /* ignore */ }
+      }
+    }
+  }
+}

package/server/services/workshop/agents/agent-interface.ts

@@ -261,4 +261,21 @@ export interface AgentInterface {
    * 实现方自守卫(仅回合间隙发起、异常不抛出);调用方 AgentRuntime 在信箱无排队消息时调用。
    */
   onTurnSettled?(): Promise<void>
+  /**
+   * 可选:harness 无关工具直调面(REST agent-tools / stdio MCP 桥回程)。
+   * 实现方走共享 host-tool-bridge 分发;未实现时上层回退 workspace 协作工具族。
+   */
+  dispatchHostTool?(toolName: string, args: Record<string, unknown>): Promise<{ text: string, isError?: boolean }>
+  /**
+   * 可选:HITL 应答传导(人类经 /api/workshop/hitl/respond 裁决引擎侧审批/权限请求)。
+   * outcome:confirmed=true 应答通过 / cancelled=true 人工放弃 / value=文本应答 /
+   * response=引擎原生选项(如 opencode once|always|reject)。未实现 → 上层 409。
+   */
+  respondHitl?(kind: string, id: string, outcome: {
+    confirmed?: boolean
+    cancelled?: boolean
+    value?: string
+    response?: string
+    comment?: string
+  }): Promise<void>
 }