@dcrays/dcgchat-test 0.6.12 → 0.6.13

package/src/cron/toolGuard.ts

@@ -1,466 +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'
-
-const LOG_TAG = 'cron-delivery-guard'
-const DCG_CRON_TZ = 'Asia/Shanghai'
-const CRON_PAYLOAD_TIMEOUT_SECONDS = 600
-const DEFAULT_CRON_MESSAGE = '请按定时任务要求提醒用户。'
-
-type CronExecSegment = { cronIndex: number; segmentStartIndex: number; segmentEndIndex: number }
-
-/**
- * 定位 exec 命令中合法的 `cron create/add` 片段。
- * 仅接受段首 `cron create/add`，或 `openclaw cron create/add`，避免误匹配 `echo cron create` 等。
- */
-function findCronCreateExecSegment(tokens: ShellToken[]): CronExecSegment | null {
-  const cronIndex = tokens.findIndex(
-    (token, index) =>
-      !token.control &&
-      token.value.toLowerCase() === 'cron' &&
-      ['create', 'add'].includes(tokens[index + 1]?.value.toLowerCase() ?? '')
-  )
-  if (cronIndex < 0) return null
-
-  const prev = tokens[cronIndex - 1]
-  const atSegmentStart = cronIndex === 0 || prev?.control === true
-  const hasOpenclawPrefix = !prev?.control && prev?.value.toLowerCase() === 'openclaw'
-  if (!atSegmentStart && !hasOpenclawPrefix) return null
-
-  const segmentStartIndex = hasOpenclawPrefix ? cronIndex - 1 : cronIndex
-  let segmentEndIndex = cronIndex + 2
-  while (segmentEndIndex < tokens.length && !tokens[segmentEndIndex]?.control) segmentEndIndex += 1
-
-  return { cronIndex, segmentStartIndex, segmentEndIndex }
-}
-
-export function isCronCreateExecCommand(command: unknown): boolean {
-  if (typeof command !== 'string') return false
-  const tokens = tokenizeShell(command.trim())
-  return tokens !== null && findCronCreateExecSegment(tokens) !== null
-}
-
-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
-  )
-}
-
-export 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> = { ...sourcePayload }
-  const payloadKind = trimCronString(sourcePayload.kind)
-  const hasPayloadText = trimCronString(payload.message) || trimCronString(payload.text)
-  if (!hasPayloadText) {
-    if (payloadKind === 'systemEvent') {
-      payload.text = resolveCronMessage(job)
-    } else {
-      payload.message = resolveCronMessage(job)
-    }
-  }
-  if (!payloadKind) payload.kind = 'agentTurn'
-  if (payloadKind !== 'systemEvent') {
-    const configured = Number(payload.timeoutSeconds)
-    payload.timeoutSeconds =
-      Number.isFinite(configured) && configured >= CRON_PAYLOAD_TIMEOUT_SECONDS
-        ? configured
-        : 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,
-    sessionTarget: 'current',
-    wakeMode: 'now',
-    delivery,
-    schedule: job.schedule?.kind === 'cron' ? { ...job.schedule, tz: DCG_CRON_TZ } : job.schedule,
-    payload
-  }
-}
-
-export function quoteCliArg(value: string): string {
-  if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) return value
-  return `'${value.replace(/'/g, `'\\''`)}'`
-}
-
-type ShellToken = { start: number; end: number; value: string; control: boolean }
-
-/** 识别参数、引号/转义和常用控制运算符，同时保留原始字符串位置。 */
-function tokenizeShell(command: string): ShellToken[] | null {
-  const tokens: ShellToken[] = []
-  let i = 0
-  while (i < command.length) {
-    if (/[^\S\r\n]/.test(command[i] ?? '')) {
-      i += 1
-      continue
-    }
-    const start = i
-    const ch = command[i] ?? ''
-    if (';&|\r\n'.includes(ch)) {
-      const two = command.slice(i, i + 2)
-      const end = two === '&&' || two === '||' || two === '\r\n' ? i + 2 : i + 1
-      tokens.push({ start, end, value: command.slice(start, end), control: true })
-      i = end
-      continue
-    }
-
-    let value = ''
-    let quote: "'" | '"' | null = null
-    while (i < command.length) {
-      const current = command[i] ?? ''
-      if (!quote && (/\s/.test(current) || ';&|'.includes(current))) break
-      if (!quote && (current === "'" || current === '"')) {
-        quote = current
-        i += 1
-        continue
-      }
-      if (current === quote) {
-        quote = null
-        i += 1
-        continue
-      }
-      if (current === '\\' && quote !== "'") {
-        if (i + 1 >= command.length) return null
-        value += command[i + 1] ?? ''
-        i += 2
-        continue
-      }
-      value += current
-      i += 1
-    }
-    if (quote) return null
-    tokens.push({ start, end: i, value, control: false })
-  }
-  return tokens
-}
-
-const CRON_VALUE_OPTIONS = new Set([
-  '--tz', '--timeout-seconds', '--session', '--session-key', '--wake', '--channel', '--to', '--account'
-])
-const CRON_FLAG_OPTIONS = new Set([
-  '--announce', '--deliver', '--no-deliver', '--best-effort-deliver', '--no-best-effort-deliver', '--json'
-])
-
-/**
- * 规范化 `exec` 工具中的 `cron create/add` 命令字符串。
- *
- * 背景：模型可能通过自由文本的 `exec` 工具创建 cron，写出来的命令参数可能：
- * 1. 缺少 DCG 必须的投递字段（如 --to、--channel、--best-effort-deliver）；
- * 2. 与 DCG 投递要求冲突（如 --channel last）；
- *
- * 本函数先“清洗”掉这些不确定/冲突的投递参数，再注入一套 DCG 统一的投递参数，
- * 保证最终命令在投递路由、超时、输出格式等方面一致。
- */
-export function normalizeCronExecCommand(command: string, sessionKey: string): string {
-  const tokens = tokenizeShell(command)
-  if (!tokens) {
-    dcgLogger(`[${LOG_TAG}] cannot safely parse cron exec command, skip normalization.`, 'error')
-    return command
-  }
-
-  const segment = findCronCreateExecSegment(tokens)
-  if (!segment) return command
-
-  const { segmentStartIndex, segmentEndIndex } = segment
-  const segmentTokens = tokens.slice(segmentStartIndex, segmentEndIndex)
-  const segmentStart = segmentTokens[0]?.start ?? 0
-  const segmentEnd = tokens[segmentEndIndex]?.start ?? command.length
-  const removed: Array<{ start: number; end: number }> = []
-
-  for (let index = 0; index < segmentTokens.length; index += 1) {
-    const token = segmentTokens[index]
-    if (!token) continue
-    const equalAt = token.value.indexOf('=')
-    const option = equalAt >= 0 ? token.value.slice(0, equalAt) : token.value
-    if (CRON_FLAG_OPTIONS.has(option)) {
-      removed.push({ start: token.start, end: token.end })
-    } else if (CRON_VALUE_OPTIONS.has(option)) {
-      const nextToken = equalAt < 0 ? segmentTokens[index + 1] : undefined
-      removed.push({ start: token.start, end: nextToken?.end ?? token.end })
-      if (nextToken) index += 1
-    }
-  }
-
-  let cursor = segmentStart
-  let cleanedSegment = ''
-  for (const range of removed) {
-    cleanedSegment += command.slice(cursor, range.start)
-    cursor = range.end
-  }
-  cleanedSegment += command.slice(cursor, segmentEnd)
-
-  const remainingTokens = segmentTokens.filter(
-    (token) => !removed.some((range) => token.start >= range.start && token.end <= range.end)
-  )
-  const skipTz = remainingTokens.some(
-    (token) => token.value === '--every' || token.value.startsWith('--every=') || token.value === '--at' || token.value.startsWith('--at=')
-  )
-  const sk = sessionKey.trim()
-  const { agentId } = formatterSessionKey(sk)
-
-  // 4. 组装 DCG 要求的一套投递参数
-  const required = [
-    // 仅当命令不含 --every/--at 时才注入默认时区，避免时区语义冲突
-    skipTz ? '' : `--tz ${quoteCliArg(DCG_CRON_TZ)}`,
-    '--session current',
-    '--wake now',
-    // 控制 payload 执行超时
-    `--timeout-seconds ${CRON_PAYLOAD_TIMEOUT_SECONDS}`,
-    // 把 sessionKey 带给 cron payload，用于后续路由和修复
-    `--session-key ${quoteCliArg(sk)}`,
-    // 要求 cron 创建完成后发送announce消息，便于 DCG 拦截处理
-    '--announce',
-    // 固定投递到 DCG 监控的频道
-    `--channel ${quoteCliArg(CHANNEL_ID)}`,
-    // 投递目标指向 DCG 专用队列，带上 sessionKey 以便路由
-    `--to ${quoteCliArg(`dcg-cron:${sk}`)}`,
-    // 带上 agentId，便于多租户/多 agent 场景定位来源
-    agentId ? `--account ${quoteCliArg(agentId)}` : '',
-    // 投递失败时尽量重试，不直接丢弃任务
-    '--best-effort-deliver',
-    // 输出 JSON，方便下游解析
-    '--json'
-  ].filter(Boolean)
-
-  const normalizedSegment = `${cleanedSegment.trim()} ${required.join(' ')}`
-  const prefix = command.slice(0, segmentStart)
-  const suffix = command.slice(segmentEnd)
-  return `${prefix}${normalizedSegment}${suffix ? ` ${suffix.trimStart()}` : ''}`
-}
-
-// ---- 辅助函数 ----
-
-/** 与 OpenClaw cron tool 的 CRON_RECOVERABLE_OBJECT_KEYS 保持一致。 */
-const CRON_FLAT_PAYLOAD_KEYS = [
-  'message',
-  'text',
-  'model',
-  'fallbacks',
-  'toolsAllow',
-  'thinking',
-  'timeoutSeconds',
-  'lightContext',
-  'allowUnsafeExternalContent'
-] as const
-
-const CRON_FLAT_SCHEDULE_KEYS = [
-  'kind',
-  'at',
-  'atMs',
-  'every',
-  'everyMs',
-  'anchorMs',
-  'cron',
-  'expr',
-  'tz',
-  'stagger',
-  'staggerMs',
-  'exact'
-] as const
-
-const CRON_RECOVERABLE_JOB_KEYS = [
-  'name',
-  'schedule',
-  'sessionTarget',
-  'wakeMode',
-  'payload',
-  'delivery',
-  'enabled',
-  'description',
-  'deleteAfterRun',
-  'agentId',
-  'sessionKey',
-  'failureAlert',
-  'namePayload',
-  'scheduleKind',
-  'sessionTargetName',
-  ...CRON_FLAT_PAYLOAD_KEYS,
-  ...CRON_FLAT_SCHEDULE_KEYS
-] 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
-}
-
-function cloneParams(params: Record<string, unknown>): Record<string, unknown> | null {
-  try {
-    return structuredClone(params) as Record<string, unknown>
-  } catch (err) {
-    dcgLogger(`[${LOG_TAG}] structuredClone failed: ${String(err)}`, 'error')
-    return 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' || action === 'create'
-}
-
-/**
- * 模型偶尔会把 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 hasCronCreateSignal 保持一致。
-  const hasJobContent =
-    recovered.schedule !== undefined ||
-    recovered.at !== undefined ||
-    recovered.atMs !== undefined ||
-    recovered.everyMs !== undefined ||
-    recovered.cron !== undefined ||
-    recovered.expr !== undefined ||
-    recovered.payload !== undefined ||
-    recovered.message !== undefined ||
-    recovered.text !== undefined
-
-  return hasJobContent ? recovered : null
-}
-
-function resolveCronJob(params: Record<string, unknown>): Record<string, unknown> | null {
-  const explicitJob = asRecord(params.job)
-  const flatJob = recoverFlatCronJob(params)
-  const hasExplicitJob = explicitJob !== null && Object.keys(explicitJob).length > 0
-
-  if (hasExplicitJob && flatJob) {
-    return { ...flatJob, ...explicitJob }
-  }
-  if (hasExplicitJob) {
-    return explicitJob
-  }
-  return flatJob
-}
-
-/**
- * 规范化 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 = cloneParams(params)
-  if (!newParams) return null
-  const job = resolveCronJob(newParams)
-  if (!job) return null
-
-  // OpenClaw cron tool 的正式 action 是 add；create 只是 CLI alias。
-  newParams.action = 'add'
-  // buildDcgCronJob 保留 job 的其他合法字段，只强制覆盖 DCG 业务字段。
-  newParams.job = buildDcgCronJob(job as CronJobLike, sk)
-  return newParams
-}
-
-export function cronToolCall(event: { toolName: unknown; params: unknown; toolCallId?: unknown }, sk: string) {
-  const { toolName, params, toolCallId } = event
-  // 仅处理 cron 工具
-  if (toolName === 'cron') {
-    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 paramsRecord = asRecord(params)
-    if (!paramsRecord) return undefined
-    const cmd = paramsRecord.command
-    if (typeof cmd !== 'string') {
-      return undefined
-    }
-
-    // 保留原有逻辑（非 openclaw cron 命令的 cron create/add，或其他 exec）
-    if (isCronCreateExecCommand(cmd)) {
-      const newParams = cloneParams(paramsRecord)
-      if (!newParams) return undefined
-      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
-}