@dcrays/dcgchat 0.4.29 → 0.5.0

package/src/skill.ts

@@ -1,151 +0,0 @@
-import axios from 'axios'
-/** @ts-ignore */
-import unzipper from 'unzipper'
-import { pipeline } from 'stream/promises'
-import fs from 'fs'
-import path from 'path'
-import { getWorkspaceDir } from './utils/global.js'
-import { getWsConnection } from './utils/global.js'
-import { dcgLogger } from './utils/log.js'
-import { isWsOpen } from './transport.js'
-import { sendMessageToGateway } from './gateway/socket.js'
-import { decodeZipEntryPath } from './utils/zipPath.js'
-
-type ISkillParams = {
-  path: string
-  code: string
-}
-
-function sendEvent(msgContent: Record<string, any>) {
-  const ws = getWsConnection()
-  if (isWsOpen()) {
-    ws?.send(
-      JSON.stringify({
-        messageType: 'openclaw_bot_event',
-        source: 'client',
-        content: msgContent
-      })
-    )
-    dcgLogger(`技能安装: ${JSON.stringify(msgContent)}`)
-  }
-}
-
-export async function installSkill(params: ISkillParams, msgContent: Record<string, any>) {
-  const { path: cdnUrl, code } = params
-  const workspacePath = getWorkspaceDir()
-
-  // 确保 skills 目录存在
-  const skillsDir = path.join(workspacePath, 'skills')
-  if (!fs.existsSync(skillsDir)) {
-    fs.mkdirSync(skillsDir, { recursive: true })
-  }
-  // 如果目标目录已存在，先删除
-  const skillDir = path.join(workspacePath, 'skills', code)
-  if (fs.existsSync(skillDir)) {
-    fs.rmSync(skillDir, { recursive: true, force: true })
-  }
-
-  try {
-    // 下载 zip 文件
-    const response = await axios({
-      method: 'get',
-      url: cdnUrl,
-      responseType: 'stream'
-    })
-    // 创建目标目录
-    fs.mkdirSync(skillDir, { recursive: true })
-    // 解压文件到目标目录，跳过顶层文件夹
-    await new Promise((resolve, reject) => {
-      const tasks: Promise<void>[] = []
-      let rootDir: string | null = null
-      let hasError = false
-
-      response.data
-        .pipe(unzipper.Parse())
-        .on('entry', (entry: any) => {
-          if (hasError) {
-            entry.autodrain()
-            return
-          }
-          try {
-            const flags = entry.props?.flags ?? 0
-            const entryPath = decodeZipEntryPath(entry.props?.pathBuffer, flags, entry.path)
-            const pathParts = entryPath.split('/')
-
-            // 检测根目录
-            if (!rootDir && pathParts.length > 1) {
-              rootDir = pathParts[0]
-            }
-            let newPath = entryPath
-            // 移除顶层文件夹
-            if (rootDir && entryPath.startsWith(rootDir + '/')) {
-              newPath = entryPath.slice(rootDir.length + 1)
-            }
-
-            if (!newPath) {
-              entry.autodrain()
-              return
-            }
-
-            const targetPath = path.join(skillDir, newPath)
-
-            if (entry.type === 'Directory') {
-              fs.mkdirSync(targetPath, { recursive: true })
-              entry.autodrain()
-            } else {
-              const parentDir = path.dirname(targetPath)
-              fs.mkdirSync(parentDir, { recursive: true })
-              const writeStream = fs.createWriteStream(targetPath)
-              const task = pipeline(entry, writeStream).catch((err) => {
-                hasError = true
-                throw new Error(`解压文件失败 ${entryPath}: ${err.message}`)
-              })
-              tasks.push(task)
-            }
-          } catch (err) {
-            hasError = true
-            entry.autodrain()
-            reject(new Error(`处理entry失败: ${err}`))
-          }
-        })
-        .on('close', async () => {
-          try {
-            await Promise.all(tasks)
-            resolve(null)
-          } catch (err) {
-            reject(err)
-          }
-        })
-        .on('error', (err: { message: any }) => {
-          hasError = true
-          reject(new Error(`解压流错误: ${err.message}`))
-        })
-    })
-    sendEvent({ ...msgContent, status: 'ok' })
-    sendMessageToGateway(JSON.stringify({ method: 'skills.status', params: {} }))
-  } catch (error) {
-    // 如果安装失败，清理目录
-    if (fs.existsSync(skillDir)) {
-      fs.rmSync(skillDir, { recursive: true, force: true })
-    }
-    sendEvent({ ...msgContent, status: 'fail' })
-  }
-}
-
-export function uninstallSkill(params: Omit<ISkillParams, 'path'>, msgContent: Record<string, any>) {
-  const { code } = params
-
-  const workspacePath = getWorkspaceDir()
-  if (!workspacePath) {
-    sendEvent({ ...msgContent, status: 'ok' })
-  }
-
-  const skillDir = path.join(workspacePath, 'skills', code)
-
-  if (fs.existsSync(skillDir)) {
-    fs.rmSync(skillDir, { recursive: true, force: true })
-    sendEvent({ ...msgContent, status: 'ok' })
-  } else {
-    sendEvent({ ...msgContent, status: 'ok' })
-  }
-}

package/src/tool.ts

@@ -1,422 +0,0 @@
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { getMsgStatus } from './utils/global.js'
-import { dcgLogger } from './utils/log.js'
-import { sendFinal, sendText, wsSendRaw } from './transport.js'
-import { getEffectiveMsgParams, deleteSessionKeyBySubAgentRunId, setSessionKeyBySubAgentRunId } from './utils/params.js'
-import { cronToolCall } from './cronToolCall.js'
-
-type PluginHookName =
-  | 'before_model_resolve'
-  | 'before_prompt_build'
-  | 'before_agent_start'
-  | 'llm_input'
-  | 'llm_output'
-  | 'agent_end'
-  | 'before_compaction'
-  | 'after_compaction'
-  | 'before_reset'
-  | 'message_received'
-  | 'message_sending'
-  | 'message_sent'
-  | 'before_tool_call'
-  | 'after_tool_call'
-  | 'tool_result_persist'
-  | 'before_message_write'
-  | 'session_start'
-  | 'session_end'
-  | 'subagent_spawning'
-  | 'subagent_delivery_target'
-  | 'subagent_spawned'
-  | 'subagent_ended'
-  | 'gateway_start'
-  | 'gateway_stop'
-
-// message_received 没有 sessionKey 前置到bot中执行
-const eventList = [
-  // { event: 'message_received', message: '' },
-  // {event: 'before_model_resolve', message: ''},
-  // {event: 'before_prompt_build', message: '正在查阅背景资料，构建思考逻辑'},
-  // {event: 'before_agent_start', message: '书灵墨宝已就位，准备开始执行任务'},
-  { event: 'subagent_spawning', message: '' },
-  { event: 'subagent_spawned', message: '' },
-  { event: 'subagent_delivery_target', message: '' },
-  // {event: 'llm_input', message: ''},
-  { event: 'llm_output', message: '' },
-  // {event: 'agent_end', message: '核心任务已处理完毕...'},
-  { event: 'subagent_ended', message: '' },
-  // {event: 'before_message_write', message: '正在将本次对话存入记忆库...'},
-  // {event: 'message_sending', message: ''},
-  // {event: 'message_send', message: ''},
-  { event: 'before_tool_call', message: '' },
-  { event: 'after_tool_call', message: '' }
-]
-
-/** 子 agent 的 sessionKey 往往未写入 params map，回落到主会话 outbound 参数避免 messageId 缺失 */
-function resolveOutboundParamsForSession(sk: string) {
-  const k = sk.trim()
-  let params = getEffectiveMsgParams(k)
-  if (params.messageId?.trim() || params.sessionId?.trim()) return params
-  const parent = requesterByChildSessionKey.get(k)
-  if (parent) {
-    const parentParams = getEffectiveMsgParams(parent)
-    if (parentParams.messageId?.trim() || parentParams.sessionId?.trim()) return parentParams
-  }
-  return params
-}
-
-/** 主会话已 running 时，子会话上的工具/事件也应下发（否则子 key 无 running 状态会整段丢消息） */
-export function isSessionActiveForTool(sk: string): boolean {
-  const k = sk.trim()
-  if (!k) return false
-  if (getMsgStatus(k) === 'running') return true
-  const parent = requesterByChildSessionKey.get(k)
-  return parent ? getMsgStatus(parent) === 'running' : false
-}
-
-function sendToolCallMessage(sk: string, text: string, toolCallId: string, isCover: number) {
-  const params = resolveOutboundParamsForSession(sk)
-  const content = { is_finish: -1, tool_call_id: toolCallId, is_cover: isCover, thinking_content: text, response: '' }
-  wsSendRaw(params, content, false)
-}
-
-/**
- * 深拷贝 params 并注入 bestEffort: true
- */
-interface CronDelivery {
-  mode?: string
-  channel?: string
-  to?: string
-  bestEffort?: boolean
-  [key: string]: unknown
-}
-
-// --- Subagent 活跃跟踪（按主会话 requesterSessionKey）---
-
-/** 主会话 sessionKey -> 仍活跃的子 agent runId */
-const activeSubagentRunIdsByRequester = new Map<string, Set<string>>()
-/** 子会话 childSessionKey -> 主会话 requesterSessionKey */
-const requesterByChildSessionKey = new Map<string, string>()
-/** 子会话 childSessionKey -> spawn 时的 runId（ended 事件可能不带 runId） */
-const runIdByChildSessionKey = new Map<string, string>()
-/** 主会话 -> 等待「子 agent 全部结束」的回调 */
-const subagentIdleWaiters = new Map<string, Set<() => void>>()
-
-function getOrCreateRunIdSet(requesterSessionKey: string): Set<string> {
-  let set = activeSubagentRunIdsByRequester.get(requesterSessionKey)
-  if (!set) {
-    set = new Set()
-    activeSubagentRunIdsByRequester.set(requesterSessionKey, set)
-  }
-  return set
-}
-
-function flushSubagentIdleWaiters(requesterSessionKey: string): void {
-  const set = activeSubagentRunIdsByRequester.get(requesterSessionKey)
-  if (set && set.size > 0) return
-  activeSubagentRunIdsByRequester.delete(requesterSessionKey)
-  const waiters = subagentIdleWaiters.get(requesterSessionKey)
-  if (!waiters?.size) return
-  subagentIdleWaiters.delete(requesterSessionKey)
-  for (const w of waiters) {
-    try {
-      w()
-    } catch (e) {
-      dcgLogger(`subagent idle waiter error: ${String(e)}`, 'error')
-    }
-  }
-}
-
-function registerSubagentSpawn(requesterSessionKey: string, runId: string, childSessionKey: string): void {
-  const req = requesterSessionKey.trim()
-  const rid = runId.trim()
-  const child = childSessionKey.trim()
-  if (!req || !rid || !child) {
-    dcgLogger(`subagent track spawn skipped: missing key req=${req} runId=${rid} child=${child}`)
-    return
-  }
-  getOrCreateRunIdSet(req).add(rid)
-  requesterByChildSessionKey.set(child, req)
-  runIdByChildSessionKey.set(child, rid)
-  dcgLogger(`subagent track spawn: requester=${req} runId=${rid} child=${child} active=${getOrCreateRunIdSet(req).size}`)
-}
-
-function registerSubagentEnd(
-  ctx: { requesterSessionKey?: string; sessionKey?: string },
-  targetSessionKey: string,
-  runId?: string
-): void {
-  const child = targetSessionKey.trim()
-  if (!child) return
-  const req = ctx.requesterSessionKey?.trim() || requesterByChildSessionKey.get(child) || ctx.sessionKey?.trim() || ''
-  const resolvedRunId = (runId?.trim() || runIdByChildSessionKey.get(child) || '').trim()
-  deleteSessionKeyBySubAgentRunId(resolvedRunId)
-  if (!req) {
-    dcgLogger(`subagent track end: no requester for child=${child} runId=${resolvedRunId}`)
-    requesterByChildSessionKey.delete(child)
-    runIdByChildSessionKey.delete(child)
-    return
-  }
-  const set = activeSubagentRunIdsByRequester.get(req)
-  if (set && resolvedRunId) {
-    set.delete(resolvedRunId)
-  }
-  requesterByChildSessionKey.delete(child)
-  runIdByChildSessionKey.delete(child)
-  dcgLogger(`subagent track end: requester=${req} runId=${resolvedRunId || 'n/a'} remaining=${set?.size ?? 0}`)
-  if (set && set.size === 0) {
-    activeSubagentRunIdsByRequester.delete(req)
-  }
-  flushSubagentIdleWaiters(req)
-}
-
-/** 当前跟踪到的、挂在该主会话下的子会话 sessionKey（供 /stop 时逐个 chat.abort） */
-export function getChildSessionKeysTrackedForRequester(requesterSessionKey: string): string[] {
-  const req = requesterSessionKey.trim()
-  if (!req) return []
-  const out: string[] = []
-  for (const [child, parent] of requesterByChildSessionKey.entries()) {
-    if (parent === req) out.push(child)
-  }
-  return out
-}
-
-/**
- * 自根 requester 起 BFS 收集所有已跟踪后代子会话（含嵌套）。网关 abort 时宜自深到浅，调用方对结果 `.reverse()` 后再逐个 chat.abort。
- */
-export function getDescendantSessionKeysForRequester(rootRequesterSessionKey: string): string[] {
-  const root = rootRequesterSessionKey.trim()
-  if (!root) return []
-  const ordered: string[] = []
-  const seen = new Set<string>()
-  let frontier = getChildSessionKeysTrackedForRequester(root)
-  while (frontier.length > 0) {
-    const next: string[] = []
-    for (const sk of frontier) {
-      const k = sk.trim()
-      if (!k || seen.has(k)) continue
-      seen.add(k)
-      ordered.push(k)
-      next.push(...getChildSessionKeysTrackedForRequester(k))
-    }
-    frontier = next
-  }
-  return ordered
-}
-
-/**
- * 打断后清空本地子 agent 跟踪（runId、父子映射、子 runId→sessionKey），并唤醒 waitUntilSubagentsIdle，避免永久挂起。
- */
-export function resetSubagentStateForRequesterSession(requesterSessionKey: string): void {
-  const req = requesterSessionKey.trim()
-  if (!req) return
-
-  const runIdSet = activeSubagentRunIdsByRequester.get(req)
-  if (runIdSet) {
-    for (const rid of runIdSet) {
-      deleteSessionKeyBySubAgentRunId(rid)
-    }
-  }
-
-  for (const [child, parent] of [...requesterByChildSessionKey.entries()]) {
-    if (parent === req) {
-      requesterByChildSessionKey.delete(child)
-      runIdByChildSessionKey.delete(child)
-    }
-  }
-
-  activeSubagentRunIdsByRequester.delete(req)
-
-  const waiters = subagentIdleWaiters.get(req)
-  if (!waiters?.size) return
-  subagentIdleWaiters.delete(req)
-  for (const w of waiters) {
-    try {
-      w()
-    } catch (e) {
-      dcgLogger(`subagent idle waiter error: ${String(e)}`, 'error')
-    }
-  }
-}
-
-/** 当前主会话下仍在跑的子 agent 数量（按 spawn 时 runId 去重） */
-export function getActiveSubagentCount(sessionKey: string): number {
-  const sk = sessionKey?.trim()
-  if (!sk) return 0
-  return activeSubagentRunIdsByRequester.get(sk)?.size ?? 0
-}
-
-/**
- * 等到指定主会话下已跟踪的子 agent 全部结束（spawn 失败等路径也会触发 subagent_ended，一般会配对清理）。
- * 注意：须在收到 `subagent_spawned` 之后才会计入；仅 spawning 未 spawned 的不会阻塞。
- */
-export function waitUntilSubagentsIdle(sessionKey: string, opts?: { timeoutMs?: number; signal?: AbortSignal }): Promise<void> {
-  const sk = sessionKey?.trim()
-  if (!sk) return Promise.resolve()
-
-  if (getActiveSubagentCount(sk) === 0) return Promise.resolve()
-
-  return new Promise<void>((resolve, reject) => {
-    let settled = false
-    const finish = (fn: () => void) => {
-      if (settled) return
-      settled = true
-      if (timeoutId) clearTimeout(timeoutId)
-      opts?.signal?.removeEventListener('abort', onAbort)
-      removeWaiter()
-      fn()
-    }
-
-    const removeWaiter = () => {
-      const bucket = subagentIdleWaiters.get(sk)
-      if (!bucket) return
-      bucket.delete(onIdle)
-      if (bucket.size === 0) subagentIdleWaiters.delete(sk)
-    }
-
-    const onIdle = () => finish(() => resolve())
-
-    const onAbort = () => {
-      const reason = opts?.signal?.reason
-      finish(() => reject(reason instanceof Error ? reason : new Error(String(reason ?? 'Aborted'))))
-    }
-
-    let timeoutId: ReturnType<typeof setTimeout> | undefined
-    if (opts?.timeoutMs != null && opts.timeoutMs > 0) {
-      timeoutId = setTimeout(
-        () => finish(() => reject(new Error(`waitUntilSubagentsIdle timeout ${opts.timeoutMs}ms`))),
-        opts.timeoutMs
-      )
-    }
-
-    if (opts?.signal) {
-      if (opts.signal.aborted) {
-        onAbort()
-        return
-      }
-      opts.signal.addEventListener('abort', onAbort, { once: true })
-    }
-
-    let set = subagentIdleWaiters.get(sk)
-    if (!set) {
-      set = new Set()
-      subagentIdleWaiters.set(sk, set)
-    }
-    set.add(onIdle)
-
-    if (getActiveSubagentCount(sk) === 0) {
-      onIdle()
-    }
-  })
-}
-
-function resolveHookSessionKey(
-  eventName: string,
-  args: { sessionKey?: string; requesterSessionKey?: string; runId?: string }
-): string {
-  if (
-    eventName === 'subagent_spawned' ||
-    eventName === 'subagent_ended' ||
-    eventName === 'subagent_spawning' ||
-    eventName === 'subagent_delivery_target'
-  ) {
-    if (args?.runId && args?.requesterSessionKey) setSessionKeyBySubAgentRunId(args?.runId, args?.requesterSessionKey)
-    return (args?.requesterSessionKey || args?.sessionKey || '').trim()
-  }
-  return (args?.sessionKey || '').trim()
-}
-
-/** 定时触发时会话往往非 running，但仍需跑 before_tool_call 以注入 sessionKey / delivery（见 cronToolCall） */
-function shouldRunBeforeToolCallWithoutRunningSession(event: { toolName?: string; params?: { command?: string } }): boolean {
-  if (event?.toolName === 'cron') return true
-  const cmd = event?.params?.command
-  if (event?.toolName === 'exec' && typeof cmd === 'string') {
-    return cmd.includes('cron create') || cmd.includes('cron add')
-  }
-  return false
-}
-
-function trackSubagentLifecycle(eventName: string, event: any, args: any): void {
-  if (eventName === 'subagent_spawned') {
-    const runId = typeof event?.runId === 'string' ? event.runId : ''
-    const childSessionKey = typeof event?.childSessionKey === 'string' ? event.childSessionKey : ''
-    const requester =
-      typeof args?.requesterSessionKey === 'string'
-        ? args.requesterSessionKey
-        : typeof args?.sessionKey === 'string'
-          ? args.sessionKey
-          : ''
-    registerSubagentSpawn(requester, runId, childSessionKey)
-    return
-  }
-  if (eventName === 'subagent_ended') {
-    const targetSessionKey = typeof event?.targetSessionKey === 'string' ? event.targetSessionKey : ''
-    const runId = typeof event?.runId === 'string' ? event.runId : undefined
-    registerSubagentEnd(args ?? {}, targetSessionKey, runId)
-  }
-}
-
-export function monitoringToolMessage(api: OpenClawPluginApi) {
-  for (const item of eventList) {
-    api.on(item.event as PluginHookName, (event: any, args: any) => {
-      trackSubagentLifecycle(item.event, event, args)
-      const sk = resolveHookSessionKey(item.event, args ?? {})
-      if (sk) {
-        const toolHooksOk =
-          isSessionActiveForTool(sk) || (item.event === 'before_tool_call' && shouldRunBeforeToolCallWithoutRunningSession(event))
-        if (toolHooksOk) {
-          if (['after_tool_call', 'before_tool_call'].includes(item.event)) {
-            const { result: _result, ...rest } = event
-            dcgLogger(`工具调用结果： ~ event:${item.event} ~ params:${JSON.stringify(rest)}`)
-
-            if (item.event === 'before_tool_call') {
-              const hookResult = cronToolCall(rest, sk)
-              const text = JSON.stringify({
-                type: item.event,
-                specialIdentification: 'dcgchat_tool_call_special_identification',
-                callId: event.toolCallId || event.runId || Date.now().toString(),
-                ...rest,
-                status: 'running'
-              })
-              sendToolCallMessage(sk, text, event.toolCallId || event.runId || Date.now().toString(), 0)
-              return hookResult
-            }
-            const text = JSON.stringify({
-              type: item.event,
-              specialIdentification: 'dcgchat_tool_call_special_identification',
-              callId: event.toolCallId || event.runId || Date.now().toString(),
-              ...rest,
-              status: item.event === 'after_tool_call' ? 'finished' : 'running'
-            })
-            sendToolCallMessage(
-              sk,
-              text,
-              event.toolCallId || event.runId || Date.now().toString(),
-              item.event === 'after_tool_call' ? 1 : 0
-            )
-          } else if (item.event) {
-            const msgCtx = resolveOutboundParamsForSession(sk)
-            if (item.event === 'llm_output') {
-              if (event.lastAssistant?.errorMessage === '1003-额度不足请充值') {
-                const message = '您的积分已消耗完，您可以通过充值积分来继续使用'
-                sendText(message, msgCtx, { message_tags: { insufficient_balance: 1 }, is_finish: -1 })
-                sendFinal(msgCtx, '积分不足')
-                return
-              }
-            }
-            const text = JSON.stringify({
-              type: item.event,
-              specialIdentification: 'dcgchat_tool_call_special_identification',
-              toolName: '',
-              callId: event.runId || Date.now().toString(),
-              params: item.message
-            })
-            sendToolCallMessage(sk, text, event.runId || Date.now().toString(), 0)
-            dcgLogger(`工具调用结果： ~ event:${item.event}`)
-          }
-        }
-      } else if (item.event !== 'before_tool_call') {
-        dcgLogger(`工具调用结果： ~ event:${item.event} ~ 没有sessionKey 为执行`)
-      }
-    })
-  }
-}