agentworkshop 0.7.6 → 0.7.8

package/server/services/workshop/dcw/dcw-controller.ts

@@ -26,6 +26,7 @@ import { emitDcwWrite } from '@/server/services/workshop/plugins/host.mjs'
 import { clearActiveLineRun, getActiveLineRun, getAllActiveLineRuns, setActiveLineRun } from './line-run'
 import { getRecipeRollBackManager } from './recipe-rollback-manager'
 import { recordOps } from '../ops/ops'
+import { daqRuntimeSettings } from '../settings'
 
 /** 运维日志写下发防噪:同节点同值 10s 内的心跳重下发不重复入册 */
 const opsWriteMemo = new Map<string, { eng: number, at: number }>()
@@ -770,6 +771,9 @@ class DcwController {
     await tsdbReady
     const { getDaqNodeRepo } = await import('../daq/daq-node.repo')
     const { findDaqTemplate } = await import('../daq/daq-templates')
+    // 时间间隔参数(bucketMs):缺省与下限来自 daq.query.*(live 配置,热重载)
+    const { defaultBucketMs, minBucketMs } = daqRuntimeSettings().query
+    const bucketMs = opts.bucketMs == null ? defaultBucketMs : Math.max(minBucketMs, Math.min(3_600_000, Math.round(opts.bucketMs)))
     const nodeFilter = opts.nodeId ? opts.nodeId.split(',').map(x => x.trim()).filter(Boolean) : []
     const nodes = getDaqNodeRepo().all().filter((n) => {
       if (opts.paramKey && n.templateKey !== opts.paramKey) return false
@@ -785,7 +789,7 @@ class DcwController {
       nodeIds: nodes.map(n => n.id),
       fromMs: opts.fromMs,
       toMs: opts.toMs,
-      bucketMs: opts.bucketMs,
+      bucketMs,
       limit: opts.limit,
     })
     const channels: LineQueryResult['channels'] = []

package/server/services/workshop/dcw/dcw-line.repo.ts

@@ -6,27 +6,20 @@
  */
 
 import { randomUUID } from 'node:crypto'
-import fs from 'node:fs'
 import path from 'node:path'
 import { dcwLineColorFor, type LineInput, type LineView } from '../../../../shared/dcw-protocol'
 import { AppError, ErrorCodes } from '../../../utils/errors'
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 const DB_PATH = process.cwd().endsWith('server') ? 'data/dcw-lines.json' : path.join(process.cwd(), 'server', 'data', 'dcw-lines.json')
 
 function load(): LineView[] {
-  try {
-    const raw = fs.readFileSync(DB_PATH, 'utf-8')
-    const parsed = JSON.parse(raw)
-    return Array.isArray(parsed) ? parsed : []
-  }
-  catch {
-    return []
-  }
+  const parsed = loadJsonFile(DB_PATH, [])
+  return Array.isArray(parsed) ? parsed as LineView[] : []
 }
 
 function save(list: LineView[]): void {
-  fs.mkdirSync(path.dirname(DB_PATH), { recursive: true })
-  fs.writeFileSync(DB_PATH, JSON.stringify(list, null, 2), 'utf-8')
+  saveJsonFileAtomic(DB_PATH, list)
 }
 
 export class DcwLineRepo {

package/server/services/workshop/dcw/dcw-node.repo.ts

@@ -5,9 +5,9 @@
  */
 
 import { createLogger } from '../logger'
-import fs from 'node:fs'
 import path from 'node:path'
 import { DcwNode } from './dcw-node'
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 const log = createLogger('dcw.node-repo')
 
@@ -17,8 +17,7 @@ const DB_PATH = process.cwd().endsWith('server')
 
 function load(): DcwNode[] {
   try {
-    const raw = fs.readFileSync(DB_PATH, 'utf-8')
-    const parsed = JSON.parse(raw)
+    const parsed = loadJsonFile(DB_PATH, null)
     return Array.isArray(parsed) ? parsed.map(r => DcwNode.fromRow(r as Record<string, unknown>)) : []
   }
   catch {
@@ -72,8 +71,7 @@ class DcwNodeRepo {
       this.flushTimer = null
     }
     try {
-      fs.mkdirSync(path.dirname(DB_PATH), { recursive: true })
-      fs.writeFileSync(DB_PATH, JSON.stringify(this.list.map(n => n.toRow()), null, 2), 'utf-8')
+      saveJsonFileAtomic(DB_PATH, this.list.map(n => n.toRow()))
     }
     catch (err) {
       log.error('[dcw] 快照落盘失败:', err)

package/server/services/workshop/dcw/dcw-node.ts

@@ -194,7 +194,19 @@ export class DcwNode {
     if (row.lastReadError != null) node.lastReadError = String(row.lastReadError)
     if (row.lastAckAt != null) node.lastAckAt = String(row.lastAckAt)
     if (row.lastWriteAt != null) node.lastWriteAt = String(row.lastWriteAt)
-    if (row.state != null) node.state = String(row.state) as DcwNodeState
+    if (row.state != null) {
+      const restored = String(row.state)
+      // 持久化恢复消毒:'writing' 是进程内瞬态(写事务在飞)。若被快照带出后进程
+      // 硬杀重启,原样恢复会让该节点所有写永久 409(startAll 只复位 offline)。
+      // 归一为 error:写路径放行,同时显式提示"上次写入结果未知,需核销"。
+      if (restored === 'writing') {
+        node.state = 'error'
+        node.lastError = node.lastError || '进程中断于写入,状态已复位为 error(上次写入结果未知,请回读核销)'
+      }
+      else {
+        node.state = restored as DcwNodeState
+      }
+    }
     if (row.lastError != null) node.lastError = String(row.lastError)
     return node
   }

package/server/services/workshop/dcw/dcw-product.repo.ts

@@ -4,11 +4,11 @@
  */
 
 import { createLogger } from '../logger'
-import fs from 'node:fs'
 import path from 'node:path'
 import { randomUUID } from 'node:crypto'
 import type { ProductInput, ProductView } from '../../../../shared/dcw-protocol'
 import { AppError, ErrorCodes } from '../../../utils/errors'
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 const log = createLogger('dcw.product-repo')
 
@@ -18,7 +18,7 @@ const DB_PATH = process.cwd().endsWith('server')
 
 function load(): ProductView[] {
   try {
-    const parsed = JSON.parse(fs.readFileSync(DB_PATH, 'utf-8'))
+    const parsed = loadJsonFile(DB_PATH, null)
     return Array.isArray(parsed) ? parsed as ProductView[] : []
   }
   catch {
@@ -78,8 +78,7 @@ class DcwProductRepo {
 
   private flush(): void {
     try {
-      fs.mkdirSync(path.dirname(DB_PATH), { recursive: true })
-      fs.writeFileSync(DB_PATH, JSON.stringify(this.list, null, 2), 'utf-8')
+      saveJsonFileAtomic(DB_PATH, this.list)
     }
     catch (err) {
       log.error('[dcw-product] 落盘失败:', err)

package/server/services/workshop/dcw/dcw-recipe.repo.ts

@@ -5,8 +5,6 @@
  * 按批次时间窗归属产品;写历史追加式落盘(上限 3000 条,超出丢最旧)。
  */
 
-import { createLogger } from '../logger'
-import fs from 'node:fs'
 import path from 'node:path'
 import { randomUUID } from 'node:crypto'
 import type { RecipeDaqWindow, RecipeInput, RecipeParam, RecipeRunView, RecipeView } from '../../../../shared/dcw-protocol'
@@ -15,8 +13,7 @@ import { AppError, ErrorCodes } from '../../../utils/errors'
 import { getDcwProductRepo } from './dcw-product.repo'
 import { getDcwNodeRepo } from './dcw-node.repo'
 import { getDaqNodeRepo } from '../daq/daq-node.repo'
-
-const log = createLogger('dcw.recipe-repo')
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 const DATA_DIR = process.cwd().endsWith('server')
   ? 'data'
@@ -29,24 +26,11 @@ const RUNS_CAP = 200
 const WRITES_CAP = 3000
 
 function loadJson<T>(file: string, fallback: T): T {
-  try {
-    const raw = fs.readFileSync(file, 'utf-8')
-    const parsed = JSON.parse(raw)
-    return parsed ?? fallback
-  }
-  catch {
-    return fallback
-  }
+  return loadJsonFile(file, fallback) as T
 }
 
 function saveJson(file: string, data: unknown): void {
-  try {
-    fs.mkdirSync(path.dirname(file), { recursive: true })
-    fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8')
-  }
-  catch (err) {
-    log.error('[dcw-recipe] 落盘失败:', file, err)
-  }
+  saveJsonFileAtomic(file, data)
 }
 
 export interface DcwWriteHistoryEntry {

package/server/services/workshop/dcw/dcw-templates.ts

@@ -4,13 +4,13 @@
  */
 
 import { createLogger } from '../logger'
-import fs from 'node:fs'
 import path from 'node:path'
 import { randomUUID } from 'node:crypto'
 import { DCW_TEMPLATES, DCW_TEMPLATE_ICONS, dcwTemplateByKey, type DcwTemplateDef, type DcwTemplateIcon, type DcwTemplateInput } from '../../../../shared/dcw-protocol'
 
 // dcwTemplateByKey 用于内置判别
 import { AppError, ErrorCodes } from '../../../utils/errors'
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 const log = createLogger('dcw.templates')
 
@@ -20,8 +20,7 @@ const DB_PATH = process.cwd().endsWith('server')
 
 function load(): DcwTemplateDef[] {
   try {
-    const raw = fs.readFileSync(DB_PATH, 'utf-8')
-    const parsed = JSON.parse(raw)
+    const parsed = loadJsonFile(DB_PATH, null)
     return Array.isArray(parsed) ? parsed as DcwTemplateDef[] : []
   }
   catch {
@@ -113,8 +112,7 @@ class DcwTemplateRegistry {
 
   private flush(): void {
     try {
-      fs.mkdirSync(path.dirname(DB_PATH), { recursive: true })
-      fs.writeFileSync(DB_PATH, JSON.stringify(this.customs, null, 2), 'utf-8')
+      saveJsonFileAtomic(DB_PATH, this.customs)
     }
     catch (err) {
       log.error('[dcw] 模板落盘失败:', err)

package/server/services/workshop/dcw/drivers.ts

@@ -10,7 +10,7 @@
 import { createRequire } from 'node:module'
 import type { DcwDriverKind } from '../../../../shared/dcw-protocol'
 import { AppError } from '../../../utils/errors'
-import { classifyCommError, decodeRegisters, evictModbusConn, getModbusConn, getOpcUaConn, modbusKey, registerOffset, withModbusConn } from '../daq/drivers'
+import { classifyCommError, decodeRegisters, evictModbusConn, evictOpcUaConn, getModbusConn, getOpcUaConn, modbusKey, registerOffset, withModbusConn } from '../daq/drivers'
 
 const reqNative = createRequire(import.meta.url)
 
@@ -286,6 +286,20 @@ async function opcuaWrite(input: DcwWriteInput): Promise<DcwWriteResult> {
   if (!cfg.endpoint) throw new AppError(400, 'BAD_REQUEST', '缺少端点 endpoint(opc.tcp://…)')
   if (!cfg.nodeId) throw new AppError(400, 'BAD_REQUEST', '缺少节点 ID nodeId(ns=…;s=…)')
   const conn = await getOpcUaConn(cfg)
+  // 会话死亡自愈:连续 3 次故障驱逐重建(与数采采样路径同策略)。此前纯写控节点
+  // 会拿同一个死 session 反复失败,直到 10 分钟空闲 sweep 才可能重建。
+  try {
+    return await opcuaWriteOnce(conn, input)
+  }
+  catch (err) {
+    conn.errors++
+    if (conn.errors >= 3) void evictOpcUaConn(cfg)
+    throw err
+  }
+}
+
+async function opcuaWriteOnce(conn: { session: import('node-opcua').ClientSession, errors: number }, input: DcwWriteInput): Promise<DcwWriteResult> {
+  const cfg = input.driverConfig
   const opcua = reqNative('node-opcua') as typeof import('node-opcua')
   const node = opcua.coerceNodeId(String(cfg.nodeId))
   const writeResult = await conn.session.write({
@@ -480,6 +494,8 @@ export const mqttDcwDriver: DcwWriteDriver = {
           username: cfg.username ? String(cfg.username) : undefined,
           password: cfg.password ? String(cfg.password) : undefined,
           connectTimeout: 4000,
+          // 一次性连接:发布即断,绝不能让 mqtt.js 默认的 1s 无限重连在后台空转
+          reconnectPeriod: 0,
         })
         c.once('connect', () => resolve(c))
         c.once('error', (err) => {
@@ -490,19 +506,27 @@ export const mqttDcwDriver: DcwWriteDriver = {
           reject(new Error(err.message))
         })
       })
-      await new Promise<void>((resolve, reject) => {
-        client.publish(String(cfg.topic), payload, { qos: Math.min(2, Math.max(0, Number(cfg.qos ?? 1))) as 0 | 1 | 2 }, (err) => {
-          if (err)
-            reject(new Error(err.message))
-          else
-            resolve()
+      const qos = Math.min(2, Math.max(0, Number(cfg.qos ?? 1))) as 0 | 1 | 2
+      try {
+        await new Promise<void>((resolve, reject) => {
+          client.publish(String(cfg.topic), payload, { qos }, (err) => {
+            if (err)
+              reject(new Error(err.message))
+            else
+              resolve()
+          })
+          // 发布确认超时(QoS1 等 puback):8s 未确认按失败收敛,不悬挂工具调用
+          const timer = setTimeout(() => reject(new Error('发布确认超时(8s)')), 8000)
+          timer.unref?.()
         })
-        // 发布确认超时(QoS1 等 puback):8s 未确认按失败收敛,不悬挂工具调用
-        setTimeout(() => reject(new Error('发布确认超时(8s)')), 8000)
-      })
-      await new Promise<void>((resolve) => {
-        client.end(false, {}, resolve)
-      })
+      }
+      finally {
+        // 失败/超时路径同样关闭连接(此前只在成功后 end,超时会泄漏 client +
+        // broker session),已关闭的 client 重复 end 幂等安全
+        await new Promise<void>((resolve) => {
+          client.end(false, {}, resolve)
+        })
+      }
       return {
         ok: true,
         message: `已发布 ${input.eng} → ${String(cfg.topic)}(QoS ${Number(cfg.qos ?? 1)};MQTT 无回读,建议以同主题数采节点验证)`,

package/server/services/workshop/dcw/line-run.ts

@@ -11,8 +11,8 @@
  * 落盘(写放大),恢复时从最近一次结构变更的值继续。
  */
 
-import fs from 'node:fs'
 import path from 'node:path'
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 export interface ActiveLineRun {
   lineId: string
@@ -40,8 +40,7 @@ function restore(): void {
   if (g.__lineRunsLoaded) return
   g.__lineRunsLoaded = true
   try {
-    const raw = fs.readFileSync(PERSIST_PATH, 'utf-8')
-    const arr: unknown = JSON.parse(raw)
+    const arr: unknown = loadJsonFile(PERSIST_PATH, null)
     if (!Array.isArray(arr)) return
     for (const run of arr as ActiveLineRun[]) {
       if (run?.lineId && run.runId && run.recipeId) registry().set(run.lineId, run)
@@ -55,8 +54,7 @@ function restore(): void {
 /** 结构性变更落盘(开跑/停线;非热路径) */
 function persist(): void {
   try {
-    fs.mkdirSync(path.dirname(PERSIST_PATH), { recursive: true })
-    fs.writeFileSync(PERSIST_PATH, JSON.stringify(getAllActiveLineRuns(), null, 2), 'utf-8')
+    saveJsonFileAtomic(PERSIST_PATH, getAllActiveLineRuns())
   }
   catch {
     // 落盘失败不阻断主流程:内存窗口仍是权威;下次结构性变更再试

package/server/services/workshop/dcw/recipe-rollback.repo.ts

@@ -10,9 +10,9 @@
  */
 
 import { randomUUID } from 'node:crypto'
-import fs from 'node:fs'
 import path from 'node:path'
 import type { DcwJournalAnchor, OptimizationRecord } from '../../../../shared/dcw-protocol'
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 const DATA_DIR = process.cwd().endsWith('server')
   ? 'data'
@@ -27,13 +27,8 @@ interface RollbackDb {
 }
 
 function loadDb(): RollbackDb {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(ROLLBACK_PATH, 'utf-8')) as Partial<RollbackDb>
-    return { anchors: parsed.anchors ?? [], records: parsed.records ?? [] }
-  }
-  catch {
-    return { anchors: [], records: [] }
-  }
+  const parsed = loadJsonFile(ROLLBACK_PATH, { anchors: [], records: [] }) as Partial<RollbackDb>
+  return { anchors: parsed.anchors ?? [], records: parsed.records ?? [] }
 }
 
 export class RecipeRollBackRepo {
@@ -64,8 +59,7 @@ export class RecipeRollBackRepo {
 
   flushNow(): void {
     try {
-      fs.mkdirSync(path.dirname(ROLLBACK_PATH), { recursive: true })
-      fs.writeFileSync(ROLLBACK_PATH, JSON.stringify(this.db, null, 2), 'utf-8')
+      saveJsonFileAtomic(ROLLBACK_PATH, this.db)
     }
     catch (err) {
       console.error('[recipe-rollback] 落盘失败:', err)

package/server/services/workshop/json-store.mjs

@@ -0,0 +1,72 @@
+// ============================================================
+// JSON 文件存储原语 —— 全部 JSON 仓库共用(hardening:防数据丢失)。
+//
+// 背景(2026-09-05 QA 审计 P0-2):各仓库原先直接 writeFileSync 落盘 +
+// load 时 catch 后静默返回空库。一次写入中断(崩溃/断电/磁盘满)即产生
+// 截断文件,下次启动静默以空库运行,首次落盘用空数据覆盖原文件 ——
+// recipes/产线配置/回滚锚点永久丢失。
+//
+// 约定:
+//  - loadJsonFile:损坏时把坏文件保留为 <name>.corrupt-<ts>(现场可追责),
+//    再返回 fallback;ENOTDIR/ENOENT 等缺失场景静默 fallback。
+//  - saveJsonFileAtomic:先写同目录临时文件再 rename(同卷原子替换);
+//    rename 失败(Windows 杀软占用等)退回直写,保证可用性。
+// ============================================================
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+/**
+ * 读取 JSON 文件;缺失或损坏时返回 fallback。
+ * @param {string} filePath
+ * @param {unknown} fallback 缺省结构(如 { anchors: [], records: [] } 或 [])
+ * @returns
+ */
+export function loadJsonFile(filePath, fallback) {
+  let raw
+  try {
+    raw = readFileSync(filePath, 'utf-8')
+  }
+  catch {
+    return fallback
+  }
+  try {
+    return JSON.parse(raw)
+  }
+  catch (err) {
+    // 损坏现场保留:改名留档,绝不用空库静默顶替用户数据
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-')
+    const backupPath = `${filePath}.corrupt-${stamp}`
+    try {
+      renameSync(filePath, backupPath)
+      console.error(`[json-store] ⚠ ${filePath} 解析失败(${err.message}),坏文件已保留为 ${backupPath},本次以空数据启动`)
+    }
+    catch {
+      console.error(`[json-store] ⚠ ${filePath} 解析失败(${err.message}),且保留坏文件失败,本次以空数据启动`)
+    }
+    return fallback
+  }
+}
+
+/**
+ * 原子落盘:写临时文件 → rename 替换;失败退回直写。
+ * @param {string} filePath
+ * @param {unknown} data
+ */
+export function saveJsonFileAtomic(filePath, data) {
+  mkdirSync(dirname(filePath), { recursive: true })
+  const tmp = `${filePath}.tmp-${process.pid}`
+  try {
+    writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8')
+    try {
+      renameSync(tmp, filePath)
+      return
+    }
+    catch {
+      // rename 失败(目标被占用等):退回直写,可用性优先
+    }
+  }
+  catch (tmpErr) {
+    console.error(`[json-store] 临时文件写入失败(${tmpErr.message}),退回直写`)
+  }
+  writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8')
+}

package/server/services/workshop/plugins/host.mjs

@@ -169,7 +169,8 @@ async function loadAllPlugins(host, { config, paths }) {
   for (const { dir, scope } of entries) {
     const entry = join(dir, 'index.mjs')
     try {
-      const mod = await import(pathToUrl(entry))
+      // cache-busting:热重载时 ESM 按 URL 缓存,不带 query 永远拿到旧模块(插件改代码不生效)
+      const mod = await import(`${pathToUrl(entry)}?t=${Date.now()}`)
       const check = validatePluginModule(mod, entry)
       if (!check.ok) throw new Error(check.error)
       const def = check.def

package/server/services/workshop/runtime/agent-runtime.ts

@@ -406,6 +406,28 @@ export class AgentRuntime {
     }
   }
 
+  /**
+   * harness 无关工具直调面(REST agent-tools / stdio MCP 桥回程)。
+   * impl 未实现(老引擎/进程内 mock)返回 null,调用方回退协作工具族。
+   */
+  async dispatchHostTool(toolName: string, args: Record<string, unknown>): Promise<{ text: string, isError?: boolean } | null> {
+    if (!this.impl.dispatchHostTool) return null
+    return await this.impl.dispatchHostTool(toolName, args)
+  }
+
+  /** HITL 应答传导:impl 未实现返回 false(上层据此 409);异常上抛由 HTTP 层收口 */
+  async respondHitl(kind: string, id: string, outcome: {
+    confirmed?: boolean
+    cancelled?: boolean
+    value?: string
+    response?: string
+    comment?: string
+  }): Promise<boolean> {
+    if (!this.impl.respondHitl) return false
+    await this.impl.respondHitl(kind, id, outcome)
+    return true
+  }
+
   /** 暴露 TaskEngine(供 SchedulerLoop 收集快照与执行调度决策) */
   get taskEngine(): TaskEngine {
     return this.deps.taskEngine
@@ -571,6 +593,28 @@ export class AgentRuntime {
         sawRunError = true
         log.error(`[AgentRuntime:${this.agentId}] 回合异常:`, err)
       }
+      // 人类 requireReply 的平台兜底回执:实测部分引擎/模型不遵从 send_message_to_agent
+      // (回合只产 artifact 文本),请求方将收不到任何应答。平台把回合聚合文本代投回
+      // 时间线(in_reply_to 关联 + x-aw-relayed 标记),保证"要求回复"必有确定应答;
+      // 模型已自行回执时时间线会出现两条,属可接受的冗余(宁多勿丢)。
+      if (msg.metadata?.['x-aw-require-reply'] === 'true'
+        && typeof msg.metadata?.['x-aw-from-label'] === 'string'
+        && replyText.trim()) {
+        this.emitExternal({
+          kind: 'message',
+          message: {
+            messageId: randomUUID(),
+            contextId: this.channelId,
+            role: 'ROLE_AGENT',
+            parts: [{ text: replyText }],
+            metadata: {
+              'x-aw-in-reply-to': msg.messageId,
+              'x-aw-to-label': String(msg.metadata['x-aw-from-label']),
+              'x-aw-relayed': 'true',
+            },
+          },
+        })
+      }
       // 交付兜底(harness 回合结束 ≠ 任务完成):
       //  - 回合产出过实质 artifact(LLM 完成了工作但跳过 complete_task 工具)→ 隐式完成,
       //    交付物即回合规避的输出,平台代为收口(进度 100)。