@dcrays/dcgchat-test 0.6.2 → 0.6.3

package/src/cron/params.ts

@@ -1,166 +0,0 @@
-import { PluginHookAfterToolCallEvent } from 'openclaw/plugin-sdk/plugin-runtime'
-import { dcgLogger } from '../utils/log.js'
-import { CHANNEL_ID } from '../utils/constant.js'
-import { sendGatewayRpc } from '../gateway/socket.js'
-import { sendEventMessage } from '../transport.js'
-
-// 为处理的jobId列表
-const processedJobIds = new Set<string>()
-// 定时任务执行时间处理
-export async function cronAddHandler(jobId: string) {
-  const hasSessionKey = await checkCronSessionKey(jobId, true)
-  if (!hasSessionKey) {
-    processedJobIds.add(jobId)
-  }
-}
-// 删除处理的jobId
-export function removeProcessedJobId(jobId: string) {
-  processedJobIds.delete(jobId)
-}
-
-export async function getSessionKeyByJobId(jobId: string) {
-  const cronData = (await sendGatewayRpc({ method: 'cron.get', params: { id: jobId } })) as Record<string, any>
-  return cronData?.sessionKey || cronData.delivery?.to?.replace('dcg-cron:', '').trim()
-}
-
-/**
- * 检查定时任务中是否含有sessionKey或deliveryTo，数据完整直接返回true，否则返回false 两者有一个补充数据更新
- * @param jobId
- * @returns
- */
-export async function checkCronSessionKey(jobId: string, isSend?: boolean) {
-  const cronData = (await sendGatewayRpc({ method: 'cron.get', params: { id: jobId } })) as Record<string, any>
-  if (!cronData) {
-    dcgLogger(`getJobIdBySessionKey failed for jobId: ${jobId}`, 'error')
-    return
-  }
-  const sessionKey = cronData?.sessionKey
-  const deliveryTo = cronData.delivery?.to?.replace('dcg-cron:', '').trim()
-  if (!sessionKey && !deliveryTo) {
-    dcgLogger(`checkCronSessionKey failed for jobId: ${jobId}`, 'error')
-    processedJobIds.add(jobId)
-    return false
-  }
-  if (sessionKey && deliveryTo) {
-    if (isSend) {
-      const params = {
-        event_type: 'cron',
-        operation_type: 'install',
-        data: cronData
-      }
-      sendEventMessage(params)
-    }
-    return true
-  }
-  return (await supplementSessionKey(jobId)) !== null
-}
-
-// 判断after_tool_call中是否含有jobId
-export function getJobIdInAfterToolCall(event: PluginHookAfterToolCallEvent) {
-  if (event.toolName !== 'cron') return null
-  if (String(event.params.action ?? '').toLowerCase() !== 'add') return
-  if (event.error) return
-
-  const result = event.result as { details?: { id?: unknown } }
-  const jobId = result.details?.id
-
-  if (typeof jobId === 'string') {
-    return jobId
-  }
-  const evtStr = JSON.stringify(event)
-  // 便利processedJobIds，找到包含在evtStr的jobId
-  for (const id of processedJobIds) {
-    if (evtStr.includes(id)) {
-      return id
-    }
-  }
-  return null
-}
-
-// 添加jobId -> sessionKey 映射
-export async function cronAfterToolCallHandler(event: PluginHookAfterToolCallEvent, sessionKey: string) {
-  const jobId = getJobIdInAfterToolCall(event)
-  if (!jobId) return dcgLogger(`getJobIdInAfterToolCall failed for event not has jobId: ${JSON.stringify(event)}`, 'error')
-  jobIdToSessionKeyMap.set(jobId, sessionKey)
-  sessionKeyToJobIdMap.set(sessionKey, jobId)
-  const hasCompleteSessionKey = await checkCronSessionKey(jobId)
-  if (hasCompleteSessionKey) {
-    removeProcessedJobId(jobId)
-    return
-  }
-  if (processedJobIds.has(jobId)) {
-    await supplementSessionKey(jobId)
-  }
-}
-
-// jobId -> sessionKey 映射
-const jobIdToSessionKeyMap = new Map<string, string>()
-const sessionKeyToJobIdMap = new Map<string, string>()
-// 获取jobId -> sessionKey 映射
-function getJobIdToSessionKeyMap(jobId: string) {
-  return jobIdToSessionKeyMap.get(jobId)
-}
-// 删除jobId -> sessionKey 映射
-export function removeJobIdToSessionKeyMap(jobId: string) {
-  const sessionKey = jobIdToSessionKeyMap.get(jobId)
-  jobIdToSessionKeyMap.delete(jobId)
-  if (sessionKey) sessionKeyToJobIdMap.delete(sessionKey)
-}
-// 补充定时任务数据
-export async function supplementSessionKey(jobId: string) {
-  const sk = getJobIdToSessionKeyMap(jobId)
-  if (!sk) {
-    dcgLogger(`getJobIdToSessionKeyMap failed for jobId: ${jobId}`, 'error')
-    return null
-  }
-  const cronData = (await sendGatewayRpc({ method: 'cron.get', params: { id: jobId } })) as Record<string, any>
-  if (!cronData) {
-    dcgLogger(`getJobIdToSessionKeyMap failed for jobId: ${jobId}`, 'error')
-    return null
-  }
-  const patch = structuredClone(cronData)
-  patch.sessionKey = sk
-  if (!patch?.delivery) {
-    patch.delivery = {}
-  }
-  patch.delivery.to = `dcg-cron:${sk}`
-  patch.delivery.channel = CHANNEL_ID
-  delete patch.id
-  delete patch.createdAtMs
-  delete patch.updatedAtMs
-  try {
-    await sendGatewayRpc({ method: 'cron.update', params: { id: jobId, patch } })
-    removeProcessedJobId(jobId)
-    removeJobIdToSessionKeyMap(jobId)
-    return true
-  } catch (e) {
-    dcgLogger(`supplementSessionKey failed for jobId: ${jobId}: ${String(e)}`, 'error')
-    return null
-  }
-}
-
-export function isCronAddAction(params: unknown): boolean {
-  const record = params !== null && typeof params === 'object' && !Array.isArray(params) ? (params as Record<string, unknown>) : null
-  const action = typeof record?.action === 'string' ? record.action.trim().toLowerCase() : ''
-  return action === 'add' || action === 'create'
-}
-
-export function isCronCreateExecCommand(command: unknown): boolean {
-  if (typeof command !== 'string') return false
-  return /(?:^|\s)cron\s+(?:create|add)(?:\s|$)/i.test(command.trim())
-}
-
-export function isCreateCronTool(event: { toolName: any; params: any; toolCallId: any }) {
-  const { toolName, params } = event
-
-  if (toolName === 'cron') {
-    return isCronAddAction(params)
-  }
-
-  if (toolName === 'exec') {
-    const record = params !== null && typeof params === 'object' && !Array.isArray(params) ? (params as Record<string, unknown>) : null
-    return isCronCreateExecCommand(record?.command)
-  }
-
-  return false
-}

package/src/cron/toolGuard.ts

@@ -1,285 +0,0 @@
-import { CHANNEL_ID } from '../utils/constant.js'
-import type { CronJobLike } from './types.js'
-/**
- * cron-delivery-guard — 定时任务投递守护插件
- *
- * 核心机制：通过 before_tool_call 钩子拦截 cron 工具调用，
- * 对 DCG 创建的 cron 统一注入会话、执行、payload 和 delivery 业务字段，
- * 并在模型生成不完整或冲突配置时强制规范化。
- *
- * 背景：
- * - 创建前尽量让 OpenClaw 收到完整合法的 cron 配置
- */
-
-import { dcgLogger } from '../utils/log.js'
-import { isCronAddAction, isCronCreateExecCommand } from './params.js'
-
-const LOG_TAG = 'cron-delivery-guard'
-const DCG_CRON_TZ = 'Asia/Shanghai'
-const CRON_PAYLOAD_TIMEOUT_SECONDS = 600
-const DEFAULT_CRON_MESSAGE = '请按定时任务要求提醒用户。'
-
-function trimCronString(value: unknown): string {
-  return typeof value === 'string' ? value.trim() : ''
-}
-
-export function formatterSessionKey(sessionKey: string): { agentId: string; sessionId: string } {
-  const parts = sessionKey.split(':').filter((part) => part.length > 0)
-  const normalized = parts.map((part) => part.toLowerCase())
-  if (parts.length >= 6 && normalized[0] === 'agent' && normalized[2] === 'mobook' && normalized[3] === 'direct') {
-    return {
-      agentId: parts[4] ?? '',
-      sessionId: parts[5] ?? ''
-    }
-  }
-  if (parts.length >= 2) {
-    return {
-      agentId: parts[parts.length - 2] ?? '',
-      sessionId: parts[parts.length - 1] ?? ''
-    }
-  }
-  return { agentId: '', sessionId: '' }
-}
-
-function resolveCronMessage(job: CronJobLike): string {
-  const payload = job.payload
-  return (
-    trimCronString(payload?.message) ||
-    trimCronString(payload?.text) ||
-    trimCronString(job.message) ||
-    trimCronString(job.text) ||
-    trimCronString(job.description) ||
-    trimCronString(job.name) ||
-    DEFAULT_CRON_MESSAGE
-  )
-}
-
-function buildDcgCronJob(job: CronJobLike, sessionKey: string): CronJobLike {
-  const sk = sessionKey.trim()
-  const { agentId } = formatterSessionKey(sk)
-  const delivery: Record<string, unknown> = {
-    ...(job.delivery ?? {}),
-    mode: 'announce',
-    channel: CHANNEL_ID,
-    to: `dcg-cron:${sk}`,
-    bestEffort: true
-  }
-  if (agentId) delivery.accountId = agentId
-
-  const sourcePayload = job.payload ?? {}
-  const payload: Record<string, unknown> = {
-    kind: 'agentTurn',
-    message: resolveCronMessage(job),
-    timeoutSeconds: CRON_PAYLOAD_TIMEOUT_SECONDS
-  }
-  for (const field of ['model', 'fallbacks', 'thinking', 'allowUnsafeExternalContent', 'lightContext', 'toolsAllow']) {
-    if (sourcePayload[field] !== undefined) payload[field] = sourcePayload[field]
-  }
-
-  return {
-    ...job,
-    sessionKey: sk,
-    delivery,
-    schedule: job.schedule?.kind === 'cron' ? { ...job.schedule, tz: DCG_CRON_TZ } : job.schedule,
-    payload
-  }
-}
-
-/** `--every` / `--at` 由 CLI 自行处理时区语义，不再追加 `--tz`（避免与 `--at` 等冲突） */
-function cronExecCmdSkipsInjectedTz(cmd: string): boolean {
-  return /--every(?:\s|=|$)/.test(cmd) || /(^|\s)--at(?:\s|=|$)/.test(cmd)
-}
-
-/** 移除 CLI 中“带值”的选项，例如 `--tz Asia/Shanghai` 或 `--tz=Asia/Shanghai` */
-function removeCliValueOption(command: string, option: string): string {
-  const escaped = option.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  const value = `(?:"[^"]*"|'[^']*'|\\S+)`
-  return command.replace(new RegExp(`(^|\\s)${escaped}(?:=${value}|\\s+${value})`, 'g'), '$1')
-}
-
-/** 移除 CLI 中“无值”的开关型选项，例如 `--announce` 或 `--json` */
-function removeCliFlag(command: string, option: string): string {
-  const escaped = option.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  return command.replace(new RegExp(`(^|\\s)${escaped}(?=\\s|$)`, 'g'), '$1')
-}
-
-/**
- * 规范化 `exec` 工具中的 `cron create/add` 命令字符串。
- *
- * 背景：模型可能通过自由文本的 `exec` 工具创建 cron，写出来的命令参数可能：
- * 1. 缺少 DCG 必须的字段（如 --to、--channel、--best-effort-deliver）；
- * 2. 与 DCG 要求冲突（如 --session default、--channel last）；
- * 3. 使用旧参数名（如 --system-event）。
- *
- * 本函数先“清洗”掉这些不确定/冲突的参数，再“强制注入”一套 DCG 统一的参数，
- * 保证最终命令在会话隔离、投递路由、超时、输出格式等方面一致。
- */
-function normalizeCronExecCommand(command: string, sessionKey: string): string {
-  // 1. 预处理：判断是否需要跳过 --tz 注入，并解析当前 agentId
-  const skipTz = cronExecCmdSkipsInjectedTz(command)
-  const { agentId } = formatterSessionKey(sessionKey)
-
-  // 兼容旧命令：将 --system-event 替换为 --message
-  let next = command.replace(/(^|\s)--system-event(?=\s|=)/g, '$1--message')
-
-  // 2. 清洗：移除所有 DCG 会强制接管的有值选项，避免与后续注入的值冲突
-  for (const option of ['--tz', '--timeout-seconds', '--session-key', '--session', '--wake', '--channel', '--to', '--account']) {
-    next = removeCliValueOption(next, option)
-  }
-
-  // 3. 清洗：移除所有 DCG 会强制接管的无值开关，避免重复或冲突
-  for (const option of ['--announce', '--deliver', '--no-deliver', '--best-effort-deliver', '--no-best-effort-deliver', '--json']) {
-    next = removeCliFlag(next, option)
-  }
-
-  // 4. 组装 DCG 强制要求的一套参数
-  const required = [
-    // 仅当命令不含 --every/--at 时才注入默认时区，避免时区语义冲突
-    skipTz ? '' : `--tz ${DCG_CRON_TZ}`,
-    // 控制 payload 执行超时
-    `--timeout-seconds ${CRON_PAYLOAD_TIMEOUT_SECONDS}`,
-    // 把 sessionKey 带给 cron payload，用于后续路由和修复
-    `--session-key ${sessionKey}`,
-    // 要求 cron 创建完成后发送announce消息，便于 DCG 拦截处理
-    '--announce',
-    // 固定投递到 DCG 监控的频道
-    `--channel ${CHANNEL_ID}`,
-    // 投递目标指向 DCG 专用队列，带上 sessionKey 以便路由
-    `--to dcg-cron:${sessionKey}`,
-    // 带上 agentId，便于多租户/多 agent 场景定位来源
-    agentId ? `--account ${agentId}` : '',
-    // 投递失败时尽量重试，不直接丢弃任务
-    '--best-effort-deliver',
-    // 输出 JSON，方便下游解析
-    '--json'
-  ].filter(Boolean)
-
-  // 5. 保留模型原始命令中未被清洗的部分，追加 DCG 强制参数，并压缩多余空格
-  return `${next.trim()} ${required.join(' ')}`.replace(/\s+/g, ' ')
-}
-
-// ---- 辅助函数 ----
-
-/** 与 OpenClaw cron tool 的 CRON_RECOVERABLE_OBJECT_KEYS 保持一致。 */
-const CRON_RECOVERABLE_JOB_KEYS = [
-  'name',
-  'schedule',
-  'payload',
-  'delivery',
-  'enabled',
-  'description',
-  'deleteAfterRun',
-  'agentId',
-  'sessionKey',
-  'failureAlert',
-  'message',
-  'text',
-  'model',
-  'fallbacks',
-  'toolsAllow',
-  'thinking',
-  'timeoutSeconds',
-  'lightContext',
-  'allowUnsafeExternalContent'
-] as const
-
-/**
- * 将任意值安全地收窄为普通对象类型。
- *
- * 主要用于处理来自模型/上游的 `params`：它可能是 `null`、数组、字符串等，
- * 本函数先排除这些非法形态，再返回 `Record<string, unknown>`，
- * 让调用方可以安全地访问 `.action` 等字段。
- */
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value !== null && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : null
-}
-
-/**
- * OpenClaw cron tool 的正式创建 action 是 `add`。
- * `create` 只是 `openclaw cron create` CLI 的 alias，不是 tool action。
- */
-function isCronAddParams(params: Record<string, unknown>): boolean {
-  const action = typeof params.action === 'string' ? params.action.trim().toLowerCase() : ''
-  return action === 'add'
-}
-
-/**
- * 模型偶尔会把 job 字段错误地放到 params 顶层。
- * OpenClaw 执行 cron.add 前也会按同一组字段恢复 params.job；这里提前恢复，
- * 这样 before_tool_call 可以在真正执行前应用完整的 DCG 规范。
- */
-function recoverFlatCronJob(params: Record<string, unknown>): Record<string, unknown> | null {
-  const recovered: Record<string, unknown> = {}
-  for (const key of CRON_RECOVERABLE_JOB_KEYS) {
-    if (params[key] !== undefined) recovered[key] = params[key]
-  }
-
-  // 与 OpenClaw 保持一致：至少存在 schedule、payload 或可推断 payload 的文本字段。
-  const hasJobContent =
-    recovered.schedule !== undefined ||
-    recovered.payload !== undefined ||
-    recovered.message !== undefined ||
-    recovered.text !== undefined
-
-  return hasJobContent ? recovered : null
-}
-
-/**
- * 规范化 cron.add 参数。
- *
- * 正式结构是 `{ action: "add", job: CronJobCreate }`，因此只修改 params.job。
- * 如果 job 缺失，则使用 OpenClaw 自身支持的 flat 参数兼容规则恢复 job。
- * update/remove/run 等 action 有各自的 patch/jobId 结构，不应在这里处理。
- */
-function patchCronAddParams(params: Record<string, unknown>, sk: string): Record<string, unknown> | null {
-  const newParams = structuredClone(params) as Record<string, unknown>
-  const explicitJob = asRecord(newParams.job)
-  const job = explicitJob && Object.keys(explicitJob).length > 0 ? explicitJob : recoverFlatCronJob(newParams)
-  if (!job) return null
-
-  // buildDcgCronJob 保留 job 的其他合法字段，只强制覆盖 DCG 业务字段。
-  newParams.job = buildDcgCronJob(job as CronJobLike, sk)
-  return newParams
-}
-
-export function cronToolCall(event: { toolName: any; params: any; toolCallId: any }, sk: string) {
-  const { toolName, params, toolCallId } = event
-  const isCronTool = toolName === 'cron' && isCronAddAction(params)
-  // 仅处理 cron 工具
-  if (isCronTool) {
-    const paramsRecord = asRecord(params)
-    if (!paramsRecord || !isCronAddParams(paramsRecord)) {
-      return undefined
-    }
-
-    const newParams = patchCronAddParams(paramsRecord, sk)
-
-    dcgLogger(`[${LOG_TAG}] cronToolCall params  (${toolCallId}) ==> ${JSON.stringify(params)}`)
-    dcgLogger(`[${LOG_TAG}] cronToolCall newParams (${toolCallId})  ==> ${JSON.stringify(newParams)}`)
-
-    if (!newParams) {
-      dcgLogger(`[${LOG_TAG}] cronToolCall (${toolCallId}) could not resolve cron.add job, skip.`)
-      return undefined
-    }
-
-    return { params: newParams }
-  } else if (toolName === 'exec') {
-    const cmd = params.command
-    if (typeof cmd !== 'string') {
-      return undefined
-    }
-
-    // 保留原有逻辑（非 openclaw cron 命令的 cron create/add，或其他 exec）
-    if (isCronCreateExecCommand(cmd)) {
-      const newParams = structuredClone(params) as Record<string, unknown>
-      newParams.command = normalizeCronExecCommand(cmd, sk)
-
-      dcgLogger(`cron exec create or add params: ${JSON.stringify(newParams)}`)
-
-      return { params: newParams }
-    }
-    return undefined
-  }
-
-  return undefined
-}

package/src/cron/types.ts

@@ -1,15 +0,0 @@
-/**
- * Cron 领域内创建前规范化与创建后修复共用的最小任务结构。
- * 保留索引签名，以兼容 OpenClaw 后续增加的合法 job 字段。
- */
-export interface CronJobLike {
-  sessionKey?: string
-  sessionTarget?: string
-  wakeMode?: string
-  name?: string
-  description?: string
-  delivery?: Record<string, unknown>
-  schedule?: Record<string, unknown>
-  payload?: Record<string, unknown>
-  [key: string]: unknown
-}