@dcrays/dcgchat-test 0.6.0 → 0.6.2

package/src/agent.ts

@@ -0,0 +1,592 @@
+import axios from 'axios'
+import fs from 'fs'
+import fsPromise from 'fs/promises'
+import path from 'path'
+import type { OpenClawConfig } from 'openclaw/plugin-sdk'
+import { getDcgchatRuntime, getOpenClawConfig, getWorkspaceDir, getWsConnection, setOpenClawConfig } from './utils/global.js'
+import { dcgLogger } from './utils/log.js'
+import { isWsOpen } from './transport.js'
+import { sendGatewayRpc } from './gateway/socket.js'
+import { extractZipBufferToDirectory } from './utils/zipExtract.js'
+import { retryWithBackoff, ENV } from './utils/constant.js'
+
+interface AgentEventMessage {
+  url?: string
+  clone_code?: string
+  clone_codes?: string[]
+  code_list?: string[]
+  remove_files?: string[]
+  name?: string
+  description?: string
+  status?: string
+  [key: string]: unknown
+}
+
+function sendEvent(msgContent: AgentEventMessage) {
+  const ws = getWsConnection()
+  if (isWsOpen()) {
+    ws?.send(
+      JSON.stringify({
+        messageType: 'openclaw_bot_event',
+        source: 'client',
+        content: msgContent
+      })
+    )
+    dcgLogger(`agent安装: ${JSON.stringify(msgContent)}`)
+  }
+}
+
+/**
+ * 异步版本，避免阻塞事件循环
+ * workspace-${clone_code}/agent 存在，则复制到 agents/${clone_code}/agent
+ * @param clone_code
+ * @returns
+ */
+async function copyAgentsFilesAsync(clone_code: string) {
+  const workspacePath = getWorkspaceDir()
+
+  if (!workspacePath) return
+  const workspaceDir = path.join(workspacePath, '../', `workspace-${clone_code}`)
+  const agentDir = path.join(workspacePath, '../', `agents/${clone_code}`)
+  const sourceAgent = path.join(workspaceDir, 'agent')
+
+  dcgLogger(`copyAgentsFilesAsync agentDir=${agentDir} sourceAgent=${sourceAgent}`)
+
+  try {
+    const stat = await fsPromise.stat(sourceAgent).catch(() => null)
+    if (!stat || !stat.isDirectory()) return
+
+    await fsPromise.mkdir(agentDir, { recursive: true })
+
+    const dest = path.join(agentDir, 'agent')
+
+    await fsPromise.rm(dest, { recursive: true, force: true }).catch((e) => dcgLogger(`agent workspace cleanup failed: ${String(e)}`))
+
+    await fsPromise.cp(sourceAgent, dest, { recursive: true })
+
+    dcgLogger(`copyAgentsFilesAsync success ${sourceAgent} ==> ${dest}`)
+  } catch (err: unknown) {
+    dcgLogger(`copyAgentsFilesAsync failed: ${String(err)}`, 'error')
+  }
+}
+
+/**
+ * Gateway 已写盘后，把 Runtime 当前配置同步到插件全局，避免 getOpenClawConfig() 仍是 register 时的旧快照。
+ * 专家会话若在缓存里没有 agents.list 条目，OpenClaw 会把 workspace 解析成 defaults.workspace/<id>，
+ * 与插件实际的 sibling `workspace-<id>` 不一致，必须先刷新或通过 agents.update 纠正。
+ */
+export function refreshCachedOpenClawConfigFromRuntime(): void {
+  try {
+    const cfg = getDcgchatRuntime().config.loadConfig()
+    setOpenClawConfig(structuredClone(cfg) as OpenClawConfig)
+    dcgLogger('refreshCachedOpenClawConfigFromRuntime: ok')
+  } catch (err: unknown) {
+    dcgLogger(`refreshCachedOpenClawConfigFromRuntime failed: ${String(err)}`, 'error')
+  }
+}
+
+function findAgentEntry(cfg: OpenClawConfig | null, agentId: string) {
+  const needle = agentId.trim().toLowerCase()
+  return cfg?.agents?.list?.find((a) => (a?.id ?? '').trim().toLowerCase() === needle)
+}
+
+function workspacePathMatches(expected: string, configured?: string): boolean {
+  const w = configured?.trim()
+  if (!w) return false
+  return path.resolve(w) === expected
+}
+
+/**
+ * 确保网关配置里该专家的 workspace 指向 sibling `workspace-<id>`（与 agents.create / 解压目录一致）。
+ * 在首次会话消息早于插件缓存刷新、或 workspace 字段缺失/错误时修复路径。
+ */
+export async function ensureExpertAgentWorkspaceBinding(agentId: string): Promise<void> {
+  const id = typeof agentId === 'string' ? agentId.trim() : ''
+  if (!id || id === 'main') return
+
+  refreshCachedOpenClawConfigFromRuntime()
+
+  const wsRoot = getWorkspaceDir()
+  if (!wsRoot) return
+
+  const expectedWorkspace = path.resolve(path.join(wsRoot, '..', `workspace-${id}`))
+  try {
+    await fsPromise.access(expectedWorkspace)
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err)
+    dcgLogger(`ensureExpertAgentWorkspaceBinding workspace access failed: ${errMsg}`, 'error')
+    return
+  }
+
+  let cfg = getOpenClawConfig()
+  let entry = findAgentEntry(cfg, id)
+
+  if (entry && workspacePathMatches(expectedWorkspace, entry.workspace)) return
+
+  if (entry && !workspacePathMatches(expectedWorkspace, entry.workspace)) {
+    try {
+      await sendGatewayRpc({
+        method: 'agents.update',
+        params: { agentId: id, workspace: expectedWorkspace }
+      })
+      refreshCachedOpenClawConfigFromRuntime()
+    } catch (err: unknown) {
+      dcgLogger(`ensureExpertAgentWorkspaceBinding agents.update failed after retries: ${String(err)}`, 'error')
+    }
+    return
+  }
+
+  try {
+    await sendGatewayRpc({
+      method: 'agents.create',
+      params: { name: id, workspace: expectedWorkspace }
+    })
+    refreshCachedOpenClawConfigFromRuntime()
+  } catch (err: unknown) {
+    const msg = String(err)
+    if (/already exists/i.test(msg)) {
+      refreshCachedOpenClawConfigFromRuntime()
+      cfg = getOpenClawConfig()
+      entry = findAgentEntry(cfg, id)
+      if (entry && !workspacePathMatches(expectedWorkspace, entry.workspace)) {
+        try {
+          await sendGatewayRpc({
+            method: 'agents.update',
+            params: { agentId: id, workspace: expectedWorkspace }
+          })
+          refreshCachedOpenClawConfigFromRuntime()
+        } catch (e2: unknown) {
+          dcgLogger(`ensureExpertAgentWorkspaceBinding repair workspace: ${String(e2)}`, 'error')
+        }
+      }
+    } else {
+      dcgLogger(`ensureExpertAgentWorkspaceBinding agents.create: ${msg}`, 'error')
+    }
+  }
+}
+
+async function onCreateAgent(params: AgentEventMessage) {
+  const { clone_code, name } = params
+  if (!clone_code) {
+    dcgLogger('onCreateAgent: clone_code is missing', 'error')
+    return
+  }
+  let createOk = false
+  try {
+    const workspacePath = getWorkspaceDir()
+    if (!workspacePath) return
+    const workspaceDir = path.join(workspacePath, '../', `workspace-${clone_code}`)
+
+    dcgLogger(`onCreateAgent workspaceDir ==> ${workspaceDir}`);
+    // 如果尝试创建一个已存在的 agent，会报错。 agents.create failed: Error: agent "reviser-expert-11-2-37-16" already exists
+    await sendGatewayRpc({ method: 'agents.create', params: { name: clone_code, workspace: workspaceDir } })
+    
+    createOk = true
+  } catch (err: unknown) {
+    dcgLogger(`agents.create failed: ${String(err)}`, 'error')
+  }
+  // Update config.name to the user-supplied display name (may contain CJK, spaces, etc.)
+  try {
+    await sendGatewayRpc({ method: 'agents.update', params: { name: name, agentId: clone_code } })
+  } catch (err: unknown) {
+    dcgLogger(`agents.update failed: ${String(err)}`, 'error')
+  }
+  if (createOk) {
+    refreshCachedOpenClawConfigFromRuntime()
+  }
+
+  await copyAgentsFilesAsync(clone_code)
+  sendEvent({ ...params, status: 'ok' })
+}
+
+// 校验Agent id 对应的文件目录是否存在
+export function isAgentInstalled(agentId: string): boolean {
+  const workspacePath = getWorkspaceDir()
+  if (!workspacePath) return false
+  const agentWorkspaceDir = path.join(workspacePath, '../', `workspace-${agentId}`)
+  return fs.existsSync(agentWorkspaceDir)
+}
+export async function onRemoveAgent(msgContent: AgentEventMessage) {
+  const { clone_code } = msgContent
+  if (!clone_code) {
+    dcgLogger('onRemoveAgent: clone_code is missing', 'error')
+    return
+  }
+  clearAgentDownloadUrl(clone_code)
+  await removeAgentDownloadUrlMeta(clone_code)
+  await sendGatewayRpc({ method: 'agents.delete', params: { agentId: clone_code } })
+}
+export async function onUpdateAgent(msgContent: AgentEventMessage) {
+  const { code_list, url, remove_files } = msgContent
+  const list = (code_list || []).filter((item): item is string => typeof item === 'string' && Boolean(item.trim()))
+  const removeFiles = (remove_files || []).filter((item): item is string => typeof item === 'string' && Boolean(item.trim()))
+  if (!list?.length) {
+    dcgLogger('onUpdateAgent: clone_codes is missing', 'error')
+    return
+  }
+  if (!url) {
+    dcgLogger('onUpdateAgent: url is missing', 'error')
+    sendEvent({ ...msgContent, status: 'fail' })
+    return
+  }
+  const workspacePath = getWorkspaceDir()
+  const tempDir = path.join(workspacePath, '../', `-temp-${Date.now()}`)
+  try {
+    const response = await axios({ method: 'get', url, responseType: 'arraybuffer' })
+    const zipBuffer = Buffer.from(response.data)
+    dcgLogger(`onUpdateAgent download ok: ${zipBuffer.length} bytes`)
+
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+    fs.mkdirSync(tempDir, { recursive: true })
+
+    await extractZipBufferToDirectory(zipBuffer, tempDir)
+    const results = await Promise.all(
+      list.map(async (clone_code) => {
+        const workspaceDir = path.join(workspacePath, '../', `workspace-${clone_code}`)
+        let installSucceeded = false
+        markAgentInstallStarted(clone_code)
+        try {
+          if (!fs.existsSync(workspaceDir)) {
+            dcgLogger(`onUpdateAgent file not found : ${clone_code}`)
+            return true
+          }
+          const overwriteFilesRecursively = (src: string, dest: string) => {
+            const entries = fs.readdirSync(src, { withFileTypes: true })
+            for (const entry of entries) {
+              const srcPath = path.join(src, entry.name)
+              const destPath = path.join(dest, entry.name)
+              if (entry.isDirectory()) {
+                if (!fs.existsSync(destPath)) {
+                  fs.mkdirSync(destPath, { recursive: true })
+                }
+                overwriteFilesRecursively(srcPath, destPath)
+              } else {
+                if (fs.existsSync(destPath)) {
+                  fs.rmSync(destPath, { force: true })
+                }
+                fs.copyFileSync(srcPath, destPath)
+              }
+            }
+          }
+          overwriteFilesRecursively(tempDir, workspaceDir)
+          removeFiles.forEach((file) => {
+            const filePath = path.join(workspaceDir, file)
+            if (fs.existsSync(filePath)) {
+              fs.rmSync(filePath, { recursive: true, force: true })
+            }
+          })
+          await sendGatewayRpc({ method: 'agents.update', params: { agentId: clone_code } })
+          installSucceeded = true
+          return true
+        } catch (error: unknown) {
+          const errMsg = error instanceof Error ? error.message : String(error)
+          dcgLogger(`onUpdateAgent error: clone_code=${clone_code}, workspaceDir=${workspaceDir}, error=${errMsg}`, 'error')
+          return false
+        } finally {
+          markAgentInstallFinished(clone_code, installSucceeded)
+        }
+      })
+    )
+    sendEvent({ ...msgContent, status: results.every(Boolean) ? 'ok' : 'fail' })
+  } catch (err: unknown) {
+    dcgLogger(`onUpdateAgent download failed: ${String(err)}`, 'error')
+    sendEvent({ ...msgContent, status: 'fail' })
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+export async function createAgent(msgContent: AgentEventMessage) {
+  const { url, clone_code, name, description } = msgContent
+
+  dcgLogger(`createAgent start: msgContent==> ${JSON.stringify(msgContent)}`)
+
+  if (!url || !clone_code) {
+    dcgLogger(`createAgent failed empty url&clone_code: ${JSON.stringify(msgContent)}`, 'error')
+    sendEvent({ ...msgContent, status: 'fail' })
+    return
+  }
+  // 缓存下载 URL，供消息处理流程中检测到 agent 缺失时重试下载
+  cacheAgentDownloadUrl(clone_code, url, name, description)
+
+  const workspacePath = getWorkspaceDir()
+  const workspaceDir = path.join(workspacePath, '../', `workspace-${clone_code}`)
+
+  dcgLogger(`createAgent workspaceDir ==> ${workspaceDir}`)
+
+  // 如果目标目录已存在，先删除（避免残留文件干扰新安装）
+  if (fs.existsSync(workspaceDir)) {
+    fs.rmSync(workspaceDir, { recursive: true, force: true })
+    dcgLogger(`createAgent removing existing dir: ${workspaceDir}`)
+  }
+
+  markAgentInstallStarted(clone_code)
+  let installSucceeded = false
+  try {
+    // 通过 retryWithBackoff 最多尝试 3 次下载+安装
+    const bytes = await retryWithBackoff(
+      () => downloadAndSetupAgent(url, clone_code, name, description),
+      3
+    )
+    dcgLogger(`createAgent download ok: ${bytes} bytes`)
+    dcgLogger(`createAgent ok: ${clone_code}`)
+    installSucceeded = true
+  } catch (error) {
+    dcgLogger(`createAgent error: ${error}`, 'error')
+    sendEvent({ ...msgContent, status: 'fail' })
+  } finally {
+    markAgentInstallFinished(clone_code, installSucceeded)
+  }
+}
+
+/** 正以 clone_code 安装中的专家 workspace（解压 + 网关注册整段流程） */
+const installingAgentCloneCodes = new Set<string>()
+const installCompleteWaitersByCloneCode = new Map<string, Array<(success: boolean) => void>>()
+
+function markAgentInstallStarted(cloneCode: string): void {
+  const id = typeof cloneCode === 'string' ? cloneCode.trim() : ''
+  if (!id) return
+  installingAgentCloneCodes.add(id)
+}
+
+function notifyInstallWaiters(cloneCode: string, success: boolean): void {
+  const waiters = installCompleteWaitersByCloneCode.get(cloneCode)
+  if (waiters) {
+    for (const r of waiters) {
+      r(success)
+    }
+    installCompleteWaitersByCloneCode.delete(cloneCode)
+  }
+}
+
+function markAgentInstallFinished(cloneCode: string, success: boolean): void {
+  const id = typeof cloneCode === 'string' ? cloneCode.trim() : ''
+  if (!id) return
+  installingAgentCloneCodes.delete(id)
+  notifyInstallWaiters(id, success)
+}
+
+export function isAgentInstalling(cloneCode: string): boolean {
+  const id = typeof cloneCode === 'string' ? cloneCode.trim() : ''
+  if (!id) return false
+  return installingAgentCloneCodes.has(id)
+}
+
+/** 等待当前安装流程结束；若未在安装中则立即返回是否已安装成功 */
+export function waitForAgentInstall(cloneCode: string): Promise<boolean> {
+  const id = typeof cloneCode === 'string' ? cloneCode.trim() : ''
+  if (!id) return Promise.resolve(false)
+  if (!installingAgentCloneCodes.has(id)) {
+    return Promise.resolve(isAgentInstalled(id))
+  }
+  return new Promise((resolve) => {
+    let list = installCompleteWaitersByCloneCode.get(id)
+    if (!list) {
+      list = []
+      installCompleteWaitersByCloneCode.set(id, list)
+    }
+    list.push(resolve)
+  })
+}
+
+/* ── Agent 下载 URL 缓存与消息触发重试 ── */
+// createAgent 收到 WebSocket 事件时缓存 url/cloneCode，消息处理流程检测到
+// agent 文件缺失时通过 retryDownloadAgent 利用缓存的 URL 重试一次下载。
+// agentRetryFailed 保证每个 cloneCode 在消息流程中只重试一次，避免无限重试。
+
+const agentDownloadUrls = new Map<string, { url: string; name?: string; description?: string }>()
+const agentRetryFailed = new Set<string>()
+
+function cacheAgentDownloadUrl(
+  cloneCode: string,
+  url: string,
+  name?: string,
+  description?: string
+): void {
+  agentDownloadUrls.set(cloneCode, { url, name, description })
+}
+
+function clearAgentDownloadUrl(cloneCode: string): void {
+  agentDownloadUrls.delete(cloneCode)
+  agentRetryFailed.delete(cloneCode)
+}
+
+/* ── 在 .mobook-agents-donwload-url-cache.json 文件中缓存 Agents 下载的 url，用于重新加载 */
+const AGENTS_DONWNLOAD_URL_CACHE_FILE = '.mobook-agents-donwload-url-cache.json'
+
+interface AgentMeta {
+  url: string
+  name?: string
+  description?: string
+}
+
+interface AgentsCache {
+  version: number
+  agents: Record<string, Record<string, AgentMeta>>
+}
+
+let _agentsCache: AgentsCache | null = null
+
+function getAgentsDownloadUrlCachePath(): string | null {
+  const workspacePath = getWorkspaceDir()
+  if (!workspacePath) return null
+  return path.join(workspacePath, AGENTS_DONWNLOAD_URL_CACHE_FILE)
+}
+
+async function loadAgentsDownloadUrlCache(): Promise<AgentsCache> {
+  if (_agentsCache) return _agentsCache
+
+  const cachePath = getAgentsDownloadUrlCachePath()
+  if (!cachePath) return { version: 1, agents: {} }
+
+  try {
+    const raw = await fsPromise.readFile(cachePath, 'utf-8')
+    const parsed = JSON.parse(raw) as AgentsCache
+    if (typeof parsed.version === 'number' && parsed.agents && typeof parsed.agents === 'object') {
+      _agentsCache = parsed
+      return parsed
+    }
+  } catch(error) {
+    dcgLogger(`loadAgentsCache error: ${JSON.stringify(error)}`);
+  }
+
+  /* 文件不存在或解析失败，返回空缓存 */
+  return { version: 1, agents: {} }
+}
+
+async function saveAgentsDownloadUrl(cache: AgentsCache): Promise<void> {
+  const cachePath = getAgentsDownloadUrlCachePath()
+
+  dcgLogger(`saveAgentsCache cachePath: ${cachePath}`)
+  if (!cachePath) return
+
+  try {
+    // 先写 .tmp 再 rename，避免写入中断导致文件损坏
+    const tempPath = `${cachePath}.tmp`
+    await fsPromise.writeFile(tempPath, JSON.stringify(cache, null, 2), 'utf-8')
+    await fsPromise.rename(tempPath, cachePath)
+    _agentsCache = cache
+  } catch (err) {
+    dcgLogger(`saveAgentsCache failed: ${String(err)}`, 'error')
+  }
+}
+
+async function writeAgentsDownloadUrlMeta(cloneCode: string, meta: AgentMeta): Promise<void> {
+  const cache = await loadAgentsDownloadUrlCache()
+  if (!cache.agents[ENV]) {
+    cache.agents[ENV] = {}
+  }
+  cache.agents[ENV][cloneCode] = meta
+  await saveAgentsDownloadUrl(cache)
+}
+
+async function readAgentDownloadUrlMeta(cloneCode: string): Promise<AgentMeta | null> {
+  const cache = await loadAgentsDownloadUrlCache()
+  return cache.agents[ENV]?.[cloneCode] ?? null
+}
+
+async function removeAgentDownloadUrlMeta(cloneCode: string): Promise<void> {
+  const cache = await loadAgentsDownloadUrlCache()
+  const envAgents = cache.agents[ENV]
+  if (!envAgents || !envAgents[cloneCode]) return
+  delete envAgents[cloneCode]
+  if (Object.keys(envAgents).length === 0) {
+    delete cache.agents[ENV]
+  }
+  await saveAgentsDownloadUrl(cache)
+}
+
+/**
+ * 核心下载+安装逻辑：单次 axios 请求，下载 zip、解压、调用 onCreateAgent 注册。
+ * 失败时自动清理目录并抛出异常，供上层 retryWithBackoff 捕获重试。
+ * @returns 下载的字节数
+ */
+async function downloadAndSetupAgent(
+  url: string,
+  cloneCode: string,
+  name?: string,
+  description?: string
+): Promise<number> {
+  const workspacePath = getWorkspaceDir()
+  const workspaceDir = path.join(workspacePath, '../', `workspace-${cloneCode}`)
+
+  // 每次调用时先清理残留目录，保证重试时环境干净
+  if (fs.existsSync(workspaceDir)) {
+    fs.rmSync(workspaceDir, { recursive: true, force: true })
+  }
+
+  try {
+    // 下载 agent file stream
+    const response = await axios({ method: 'get', url, responseType: 'arraybuffer' })
+
+    fs.mkdirSync(workspaceDir, { recursive: true })
+    await extractZipBufferToDirectory(Buffer.from(response.data), workspaceDir)
+
+    await onCreateAgent({ url, clone_code: cloneCode, name, description })
+    await writeAgentsDownloadUrlMeta(cloneCode, { url, name, description })
+    return response.data?.length ?? 0
+  } catch (error) {
+    dcgLogger(`downloadAndSetupAgent  error: ${error}`);
+    const resolvedCleanDir = path.resolve(workspaceDir)
+    if (fs.existsSync(resolvedCleanDir) && resolvedCleanDir !== '/') {
+      fs.rmSync(resolvedCleanDir, { recursive: true, force: true })
+    }
+    throw error
+  }
+}
+
+/**
+ * 在消息处理流程中，对之前下载失败的 agent 尝试一次重新下载。
+ * 依赖 createAgent 缓存的 URL，每个 cloneCode 在生命周期内只尝试一次。
+ * @returns 下载并注册成功返回 true；失败或已重试过返回 false
+ */
+export async function retryDownloadAgent(cloneCode: string): Promise<boolean> {
+
+  // console.log("retryDownloadAgent cloneCode ==>",cloneCode );
+
+  const id = typeof cloneCode === 'string' ? cloneCode.trim() : ''
+  if (!id) return false
+
+  let cached = agentDownloadUrls.get(id)
+
+  // 内存未命中 → 尝试从 workspace 缓存文件中恢复
+  if (!cached) {
+    const meta = await readAgentDownloadUrlMeta(id)
+    if (meta) {
+      cached = meta
+      agentDownloadUrls.set(id, cached)
+      dcgLogger(`retryDownloadAgent: recovered url from cache meta file for ${id}`)
+    }
+  }
+
+  if (!cached) {
+    dcgLogger(`retryDownloadAgent: no cached url for ${id}`)
+    return false
+  }
+
+  if (agentRetryFailed.has(id)) {
+    dcgLogger(`retryDownloadAgent: already retried and failed for ${id}`)
+    return false
+  }
+
+  dcgLogger(`retryDownloadAgent: retrying ${id}`)
+
+  try {
+
+    // 重新下载之前，先发送 "agents.delete" rpc， 避免下载成功之后, 发送 'agents.create'  rpc 报错
+    await sendGatewayRpc({ method: 'agents.delete', params: { agentId: cloneCode } })
+
+    // 重新下载文件
+    await downloadAndSetupAgent(cached.url, id, cached.name, cached.description)
+
+    dcgLogger(`retryDownloadAgent ok: ${id}`)
+    agentRetryFailed.delete(id)
+    return true
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error)
+    dcgLogger(`retryDownloadAgent error: ${id}, error=${errMsg}`, 'error')
+    agentRetryFailed.add(id)
+    return false
+  }
+}