@dcrays/dcgchat 0.4.29 → 0.5.1

package/src/channel.ts

@@ -1,470 +0,0 @@
-import fs from 'node:fs'
-import type { ChannelPlugin, OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk'
-import { createPluginRuntimeStore, DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk'
-import type { ResolvedDcgchatAccount, DcgchatConfig } from './types.js'
-import { ossUpload } from './request/oss.js'
-import {
-  addSentMediaKey,
-  getCronMessageId,
-  getDcgchatRuntime,
-  getInfoBySessionKey,
-  getOpenClawConfig,
-  hasSentMediaKey,
-  setCronMessageId
-} from './utils/global.js'
-import { isWsOpen, mergeDefaultParams, mergeSessionParams, sendFinal, wsSendRaw } from './transport.js'
-import { dcgLogger, setLogger } from './utils/log.js'
-import { getOutboundMsgParams, getParamsMessage } from './utils/params.js'
-import { isSessionActiveForTool } from './tool.js'
-import { startDcgchatGatewaySocket } from './gateway/socket.js'
-import { getCronJobsPath, readCronJob } from './cron.js'
-
-function dcgchatChannelCfg(): DcgchatConfig {
-  return (getOpenClawConfig()?.channels?.["dcgchat"] as DcgchatConfig | undefined) ?? {}
-}
-
-/** `agent:<code>:mobook:direct:<agentId>:<sessionId>`（与 getSessionKey 非 real_mobook 分支一致） */
-function isMobookDirectSessionKey(s: string): boolean {
-  const parts = s.split(':').filter((p) => p.length > 0)
-  const low = parts.map((p) => p.toLowerCase())
-  return parts.length >= 6 && low[0] === 'agent' && low[2] === 'mobook' && low[3] === 'direct'
-}
-
-/** real_mobook 等线路下 Core 分配的 `agent:<agentId>:…` sessionKey */
-function isAgentPrefixedSessionKey(s: string): boolean {
-  const parts = s.split(':').filter((p) => p.length > 0)
-  return parts.length >= 3 && parts[0].toLowerCase() === 'agent'
-}
-
-/**
- * 供 `messaging.targetResolver.looksLikeId` 使用：与 OpenClaw `resolveMessagingTarget` 对齐，
- * 仅当 target「像合法会话路由键」时才走 id 类解析；纯数字不会命中，从而在系统层拒绝误填 userId。
- */
-function looksLikeDcgchatMessageToolTarget(raw: string): boolean {
-  let s = raw.trim()
-  if (!s) return false
-  const prefix = 'dcg-cron:'
-  if (s.startsWith(prefix)) {
-    s = s.slice(prefix.length).trim()
-    if (!s) return false
-  }
-  if (isMobookDirectSessionKey(s)) return true
-  if (isAgentPrefixedSessionKey(s)) return true
-  return false
-}
-
-function dcgchatMessageTargetLooksLikeId(raw: string, _normalized?: string): boolean {
-  if (dcgchatChannelCfg().strictMessageToolTarget === false) {
-    return Boolean(raw?.trim())
-  }
-  return looksLikeDcgchatMessageToolTarget(raw)
-}
-
-export type DcgchatMediaSendOptions = {
-  /** 与 setParamsMessage / map 一致，用于 getOutboundMsgParams */
-  sessionKey: string
-  mediaUrl?: string
-  text?: string
-  /** 定时任务等场景须与 `getCronMessageId` 一致，避免沿用 map 里上一条用户消息的 messageId */
-  messageId?: string
-}
-
-function normalizeSessionTarget(rawTo: string): string {
-  const cleaned = rawTo.replace('dcg-cron:', '').trim()
-  if (!cleaned) return ''
-  return getParamsMessage(cleaned)?.sessionKey?.trim() || cleaned
-}
-
-/**
- * OpenClaw 定时任务 `sessionTarget: isolated` 时，出站 `to` 常为 `agent:<code>:cron:<jobId>[:run:…]`，
- * 与 `paramsMessageMap` / `getCronMessageId` 使用的 jobs.json `sessionKey`（mobook 用户会话）不一致，导致发文件时 sessionId、messageId 错位或缺省。
- */
-function extractCronJobIdFromIsolatedSessionKey(sessionKey: string): string | null {
-  const parts = sessionKey.split(':').filter((p) => p.length > 0)
-  const i = parts.findIndex((p) => p.toLowerCase() === 'cron')
-  if (i < 0 || i + 1 >= parts.length) return null
-  return parts[i + 1] ?? null
-}
-
-function resolveIsolatedCronSessionToJobSessionKey(sessionKey: string): string {
-  const jobId = extractCronJobIdFromIsolatedSessionKey(sessionKey)
-  if (!jobId) return sessionKey
-  const job = readCronJob(getCronJobsPath(), jobId)
-  const sk = job && typeof job.sessionKey === 'string' ? job.sessionKey.trim() : ''
-  if (!sk) {
-    dcgLogger(`dcgchat: cron job ${jobId} has no sessionKey in jobs.json, keep outbound key=${sessionKey}`, 'error')
-    return sessionKey
-  }
-  return sk
-}
-
-/** 出站返回的 chatId：含 `dcg-cron:` 时保留原始 `to`，便于下游识别定时投递 */
-function outboundChatId(rawTo: string | undefined, normalizedTo: string): string {
-  const raw = rawTo?.trim() ?? ''
-  return raw.indexOf('dcg-cron:') >= 0 ? raw : normalizedTo
-}
-
-/**
- * 仅从 JSON / `{ file | path | url }` 等结构里取出路径字符串，不做改写（不拼 workspace、不 normalize）。
- */
-function collectOutboundMediaPaths(item: unknown, out: string[]): void {
-  if (item == null) return
-  if (typeof item === 'string') {
-    const t = item.trim()
-    if (!t) return
-    if (t.startsWith('[')) {
-      try {
-        const parsed = JSON.parse(t) as unknown
-        collectOutboundMediaPaths(parsed, out)
-        return
-      } catch {
-        /* 非 JSON，按普通路径处理 */
-      }
-    }
-    out.push(t)
-    return
-  }
-  if (Array.isArray(item)) {
-    for (const el of item) collectOutboundMediaPaths(el, out)
-    return
-  }
-  if (typeof item === 'object') {
-    const o = item as Record<string, unknown>
-    const raw = o.file ?? o.path ?? o.url
-    if (typeof raw === 'string' && raw.trim()) {
-      out.push(raw.trim())
-    }
-  }
-}
-
-/** 将出站 media 展平为路径字符串列表（去重保序；路径保持 Core 原样） */
-export function normalizeOutboundMediaPaths(raw: unknown): string[] {
-  const acc: string[] = []
-  collectOutboundMediaPaths(raw, acc)
-  const seen = new Set<string>()
-  const deduped: string[] = []
-  for (const p of acc) {
-    if (!p || seen.has(p)) continue
-    seen.add(p)
-    deduped.push(p)
-  }
-  return deduped
-}
-
-export async function sendDcgchatMedia(opts: DcgchatMediaSendOptions): Promise<void> {
-  const rawOpt = (opts.sessionKey ?? '').trim()
-  const strippedForCron = rawOpt.replace(/^dcg-cron:/i, '').trim()
-  const fromIsolatedCron = extractCronJobIdFromIsolatedSessionKey(strippedForCron) !== null
-  const fromDcgCronWrapper = rawOpt.toLowerCase().startsWith('dcg-cron:')
-
-  let sessionKey = normalizeSessionTarget(opts.sessionKey ?? '')
-  sessionKey = resolveIsolatedCronSessionToJobSessionKey(sessionKey)
-
-  /** 定时自动执行未走 onRunCronJob，须与 finishedDcgchatCron 共用同一 messageId，否则附件与气泡错位 */
-  if (!opts.messageId?.trim() && (fromIsolatedCron || fromDcgCronWrapper) && !getCronMessageId(sessionKey)) {
-    setCronMessageId(sessionKey, `${Date.now()}`)
-  }
-
-  const cronMid = getCronMessageId(sessionKey)
-  const baseCtx = getOutboundMsgParams(sessionKey)
-  const msgCtx = opts.messageId?.trim()
-    ? { ...baseCtx, messageId: opts.messageId.trim() }
-    : cronMid
-      ? { ...baseCtx, messageId: cronMid }
-      : baseCtx
-  if (!isWsOpen()) {
-    dcgLogger(`outbound media skipped -> ws not isWsOpen failed open: ${opts.mediaUrl ?? ''}`)
-    return
-  }
-
-  const expanded = normalizeOutboundMediaPaths(opts.mediaUrl)
-  if (expanded.length === 0) {
-    dcgLogger(
-      `dcgchat: sendMedia skipped (no resolvable path): ${typeof opts.mediaUrl === 'string' ? opts.mediaUrl : JSON.stringify(opts.mediaUrl)} sessionKey=${sessionKey}`,
-      'error'
-    )
-    return
-  }
-  if (expanded.length > 1) {
-    for (const single of expanded) {
-      await sendDcgchatMedia({ ...opts, mediaUrl: single })
-    }
-    return
-  }
-  const mediaUrl = expanded[0]
-
-  const { sessionId, agentId } = getInfoBySessionKey(sessionKey)
-  if (!msgCtx.sessionId) {
-    msgCtx.sessionId = sessionId
-  }
-  if (!msgCtx.agentId) {
-    msgCtx.agentId = agentId
-  }
-  if (!mediaUrl || !msgCtx.sessionId) {
-    dcgLogger(`dcgchat: sendMedia skipped (duplicate in session): ${mediaUrl} sessionId=${msgCtx.sessionId} sessionKey=${sessionKey}`)
-    return
-  }
-  // 判断文件存在
-  try {
-    if (!fs.existsSync(mediaUrl)) {
-      dcgLogger(`dcgchat: sendMedia skipped (file not found): ${mediaUrl} sessionKey=${sessionKey}`, 'error')
-      return
-    }
-  } catch (err) {
-    dcgLogger(`dcgchat: sendMedia skipped (cannot stat path): ${mediaUrl} ${String(err)} sessionKey=${sessionKey}`, 'error')
-  }
-
-  if (mediaUrl && msgCtx.sessionId) {
-    if (hasSentMediaKey(msgCtx.sessionId, mediaUrl)) {
-      dcgLogger(`dcgchat: sendMedia skipped (hasSentMediaKey): ${mediaUrl} sessionId=${msgCtx.sessionId} sessionKey=${sessionKey}`)
-      return
-    }
-    addSentMediaKey(msgCtx.sessionId, mediaUrl)
-  }
-  const fileName = mediaUrl?.split(/[\\/]/).pop() || ''
-  const notMessageId = `${msgCtx?.messageId}`?.length === 13 || !msgCtx?.messageId
-  try {
-    const botToken = msgCtx.botToken ?? getOpenClawConfig()?.channels?.["dcgchat"]?.botToken ?? ''
-    const url = mediaUrl ? await ossUpload(mediaUrl, botToken, 1) : ''
-    wsSendRaw(msgCtx, {
-      response: opts.text ?? '',
-      is_finish: notMessageId ? -1 : 0,
-      message_tags: notMessageId ? { mark: 'empty_text_file' } : {},
-      files: [{ url, name: fileName }]
-    })
-    dcgLogger(`dcgchat: sendMedia session=${sessionKey}, file=${fileName}`)
-  } catch (error) {
-    wsSendRaw(msgCtx, {
-      response: opts.text ?? '',
-      message_tags: notMessageId ? { mark: 'empty_text_file' } : {},
-      is_finish: notMessageId ? -1 : 0,
-      files: [{ url: opts.mediaUrl ?? '', name: fileName }]
-    })
-    dcgLogger(`dcgchat: error sendMedia session=${sessionKey}: ${String(error)}`, 'error')
-  }
-}
-
-export function resolveAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedDcgchatAccount {
-  const id = accountId ?? DEFAULT_ACCOUNT_ID
-  const raw = (cfg.channels?.["dcgchat"] as DcgchatConfig | undefined) ?? {}
-  return {
-    accountId: id,
-    enabled: raw.enabled !== false,
-    configured: Boolean(raw.wsUrl),
-    wsUrl: raw.wsUrl ?? '',
-    botToken: raw.botToken ?? '',
-    userId: raw.userId ?? '',
-    domainId: raw.domainId ?? '',
-    appId: raw.appId ?? ''
-  }
-}
-
-export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
-  id: "dcgchat",
-  meta: {
-    id: "dcgchat",
-    label: '书灵墨宝',
-    selectionLabel: '书灵墨宝',
-    docsPath: '/channels/dcgchat',
-    docsLabel: "dcgchat",
-    blurb: '连接 OpenClaw 与 书灵墨宝 产品',
-    order: 80
-  },
-  capabilities: {
-    chatTypes: ['direct'],
-    polls: false,
-    threads: true,
-    media: true,
-    nativeCommands: true,
-    reactions: true,
-    edit: false,
-    reply: true,
-    effects: true
-    // blockStreaming: true,
-  },
-  /** 当前构建的 channel id + 兼容旧配置键 `channels.dcgchat` */
-  reload: { configPrefixes: [`channels.${"dcgchat"}`, 'channels.dcgchat'] },
-  configSchema: {
-    schema: {
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        enabled: { type: 'boolean' },
-        wsUrl: { type: 'string' },
-        botToken: { type: 'string' },
-        userId: { type: 'string', description: 'WebSocket 连接参数 _userId，与 dcgchat_message 工具的 target（dcgSessionKey）无关' },
-        appId: { type: 'string' },
-        domainId: { type: 'string' },
-        capabilities: { type: 'array', items: { type: 'string' } },
-        strictMessageToolTarget: {
-          type: 'boolean',
-          description:
-            '默认 true：内置 message 工具的 target 须为 sessionKey 形态（如 agent:…:mobook:direct:… 或 agent: 前缀多段），禁止纯数字 WS userId。设为 false 关闭此校验。'
-        }
-      }
-    },
-    uiHints: {
-      userId: {
-        label: 'WS 连接 _userId',
-        help: '仅用于拼接网关 WebSocket URL 的查询参数，不是 Agent 发消息时的 target。发消息请使用 dcgSessionKey（与入站上下文 SessionKey 相同）。'
-      },
-      strictMessageToolTarget: {
-        label: '严格 message.target',
-        help: '开启后由通道目标解析层拒绝纯数字等非 sessionKey 的 target（推荐开启）；关闭则与旧版行为一致。'
-      }
-    }
-  },
-  config: {
-    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
-    resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-    setAccountEnabled: ({ cfg, enabled }) => {
-      const channelKey = "dcgchat"
-      const prev = (cfg.channels?.[channelKey as keyof NonNullable<typeof cfg.channels>] as Record<string, unknown> | undefined) ?? {}
-      return {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          [channelKey]: { ...prev, enabled }
-        }
-      }
-    },
-    isConfigured: (account) => account.configured,
-    describeAccount: (account) => ({
-      accountId: account.accountId,
-      enabled: account.enabled,
-      configured: account.configured,
-      wsUrl: account.wsUrl,
-      botToken: account.botToken ? '***' : '',
-      userId: account.userId,
-      domainId: account.domainId,
-      appId: account.appId
-    })
-  },
-  messaging: {
-    normalizeTarget: (raw) => raw || undefined,
-    targetResolver: {
-      looksLikeId: dcgchatMessageTargetLooksLikeId,
-      hint: '须为完整 dcgSessionKey（与 SessionKey 一致，形如 agent:…:mobook:direct:… 或 agent: 前缀路由键）；禁止填 WS userId 等纯数字。可在通道配置 strictMessageToolTarget=false 关闭校验。'
-    }
-  },
-  /**
-   * 与 Telegram 等通道一致：用入站路由键 `To`（即 SessionKey / OriginatingTo）作为 message 工具默认 `currentChannelId`。
-   * 显式 target 由 `messaging.targetResolver.looksLikeId` + OpenClaw `resolveMessagingTarget` 校验（见 strictMessageToolTarget）。
-   */
-  threading: {
-    buildToolContext: ({ context, hasRepliedRef }) => ({
-      currentChannelId: context.To?.trim() || undefined,
-      hasRepliedRef
-    })
-  },
-  agentPrompt: {
-    messageToolHints: () => [
-      '书灵墨宝 / 内置 `message`：回复当前会话时 **不要传 `target`**，由 OpenClaw 使用工具上下文里的 `currentChannelId`（来自入站 `To`，即当前 SessionKey）。',
-      '必须指定会话时：`target` 须为上下文中出现的 **整段 SessionKey，逐字一致**（如 `agent:…:mobook:direct:…` 或以 `agent:` 开头的路由键）；**禁止**使用 `userId`、`From`、纯数字会话号等代替。',
-      '生成文件后，**尽可能不要**把文件路径、地址直接告诉用户；把文件名告诉用户；须通过工具发文件，勿在正文里直接输出可访问路径。',
-      '使用 `dcgchat_message` 时同样遵守上述 SessionKey 规则（该工具通常由插件注入当前会话，一般无需自造 target）。'
-    ]
-  },
-  outbound: {
-    deliveryMode: 'direct',
-    resolveTarget: ({ to }) => {
-      if (!to) {
-        return { ok: false, error: new Error('target is empty') }
-      }
-      return { ok: true, to: to }
-    },
-    chunker: (text, limit) => getDcgchatRuntime().channel.text.chunkMarkdownText(text, limit),
-    textChunkLimit: 4000,
-    sendText: async (ctx) => {
-      dcgLogger(`channel sendText to ${ctx.to} `)
-      let messageId = ''
-      const to = normalizeSessionTarget(ctx.to)
-      if (isWsOpen()) {
-        const isCron = ctx.to.indexOf('dcg-cron:') >= 0
-        const outboundCtx = getOutboundMsgParams(to)
-        const content: Record<string, unknown> = { response: ctx.text }
-        if (!isCron) {
-          if (outboundCtx?.sessionId) {
-            // 入站 handler 已将本轮标为 running；若已 sendFinal(end) 则应为 finished。
-            // 否则网关/Core 晚到的正文会仍用「当前 params map」里的 messageId，错挂到后一条用户消息上。
-            if (!isSessionActiveForTool(to)) {
-              dcgLogger(`channel sendText dropped (session not active): to=${to}`)
-              return {
-                channel: "dcgchat",
-                messageId: '',
-                chatId: outboundChatId(ctx.to, to)
-              }
-            }
-            messageId = outboundCtx?.messageId || `${Date.now()}`
-            const newCtx = { ...outboundCtx, messageId }
-            wsSendRaw(newCtx, content)
-          }
-        }
-      }
-      return {
-        channel: "dcgchat",
-        messageId: `${messageId}`,
-        chatId: outboundChatId(ctx.to, to)
-      }
-    },
-    sendMedia: async (ctx) => {
-      const normalizedFromTo = normalizeSessionTarget(ctx.to)
-      const isCron = ctx.to.indexOf('dcg-cron:') >= 0 || extractCronJobIdFromIsolatedSessionKey(normalizedFromTo) !== null
-      const to = resolveIsolatedCronSessionToJobSessionKey(normalizedFromTo)
-      const outboundCtx = getOutboundMsgParams(to)
-      const msgCtx = getParamsMessage(to) ?? outboundCtx
-      if (isCron && !getCronMessageId(to)) {
-        setCronMessageId(to, `${Date.now()}`)
-      }
-      const cronMsgId = getCronMessageId(to)
-      const fallbackMessageId = `${Date.now()}`
-      const messageId = cronMsgId || (isCron ? fallbackMessageId : msgCtx?.messageId || fallbackMessageId)
-      const { sessionId } = getInfoBySessionKey(to)
-      if (!sessionId) {
-        dcgLogger(`channel sendMedia to ${ctx.to} -> sessionId not found`, 'error')
-        return {
-          channel: "dcgchat",
-          messageId,
-          chatId: outboundChatId(ctx.to, to || '')
-        }
-      }
-
-      dcgLogger(`channel sendMedia to ${ctx.to}`)
-
-      const ctxExt = ctx as { mediaUrls?: unknown; mediaUrl?: string }
-      const rawMedia = ctxExt.mediaUrls ?? ctxExt.mediaUrl
-      const paths = normalizeOutboundMediaPaths(rawMedia)
-      for (const mediaUrl of paths) {
-        await sendDcgchatMedia({
-          sessionKey: to || '',
-          mediaUrl,
-          ...(isCron ? { messageId } : {})
-        })
-      }
-      return {
-        channel: "dcgchat",
-        messageId,
-        chatId: outboundChatId(ctx.to, to || '')
-      }
-    }
-  },
-  gateway: {
-    startAccount: async (ctx) => {
-      const { monitorDcgchatProvider } = await import('./monitor.js')
-      const account = resolveAccount(ctx.cfg, ctx.accountId)
-      setLogger(ctx.runtime)
-      if (!account.wsUrl) {
-        dcgLogger(`dcgchat[${account.accountId}]: wsUrl not configured, skipping`, 'error')
-        return
-      }
-      startDcgchatGatewaySocket()
-      return monitorDcgchatProvider({
-        config: ctx.cfg,
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        accountId: ctx.accountId
-      })
-    }
-  }
-}

package/src/cron.ts

@@ -1,194 +0,0 @@
-import path from 'node:path'
-import fs from 'node:fs'
-import type { IMsgParams } from './types.js'
-import { isWsOpen, mergeDefaultParams, sendEventMessage, sendFinal, wsSendRaw } from './transport.js'
-import { getCronMessageId, getWorkspaceDir, getWsConnection, removeCronMessageId, setCronMessageId } from './utils/global.js'
-import { ossUpload } from './request/oss.js'
-import { dcgLogger } from './utils/log.js'
-import { sendMessageToGateway } from './gateway/socket.js'
-import { getEffectiveMsgParams, getParamsDefaults } from './utils/params.js'
-
-export function getCronJobsPath(): string {
-  const workspaceDir = getWorkspaceDir()
-  const cronDir = workspaceDir.replace('workspace', 'cron')
-  return path.join(cronDir, 'jobs.json')
-}
-
-type CronJobsFile = {
-  version?: number
-  jobs?: Array<{ id?: string; sessionKey?: string; name?: string }>
-}
-
-/**
- * 在 `jobPath` 指向的 jobs.json（通常为 getCronJobsPath()）中按 id 查找任务并返回其 sessionKey。
- */
-export function readCronJob(jobPath: string, jobId: string): Record<string, any> | null {
-  const id = jobId?.trim()
-  if (!id) return null
-  if (!fs.existsSync(jobPath)) {
-    dcgLogger(`readCronJobSessionKey: file not found ${jobPath}`, 'error')
-    return null
-  }
-  try {
-    const raw = fs.readFileSync(jobPath, 'utf8')
-    const data = JSON.parse(raw) as CronJobsFile
-    const job = (data.jobs ?? []).find((j) => j.id === id)
-    return job || null
-  } catch (e) {
-    dcgLogger(`readCronJobSessionKey: failed to read ${jobPath}: ${String(e)}`, 'error')
-    return null
-  }
-}
-
-const CRON_UPLOAD_DEBOUNCE_MS = 2400
-
-let cronUploadFlushTimer: ReturnType<typeof setTimeout> | null = null
-
-async function runCronJobsUpload(sessionKey: string): Promise<void> {
-  const jobPath = getCronJobsPath()
-  const botToken = getParamsDefaults().botToken
-  if (fs.existsSync(jobPath)) {
-    try {
-      const url = await ossUpload(jobPath, botToken ?? '', 0)
-      dcgLogger(`定时任务更新成功: ${url}`)
-      const sessionInfo = sessionKey?.split(':') || []
-      const sessionId = sessionInfo.at(-1) ?? ''
-      const agentId = sessionInfo.at(-2) ?? ''
-      const params = {
-        event_type: 'cron',
-        operation_type: 'install',
-        session_id: sessionId,
-        agent_id: agentId,
-        oss_url: url
-      }
-      sendEventMessage(params)
-    } catch (error) {
-      dcgLogger(`${jobPath} upload failed: ${error}`, 'error')
-    }
-  } else {
-    dcgLogger(`${jobPath} not found`, 'error')
-  }
-}
-
-/**
- * 将 jobs.json 同步到 OSS 并推送事件。30s 内多次调用合并为一次上传；定时触发后清空待处理项，避免重复执行。
- * @param msgCtx 可选；省略时使用当前会话 getEffectiveMsgParams(sessionKey) 快照
- */
-export function sendDcgchatCron(jobId: string): void {
-  const jobPath = getCronJobsPath()
-  const { sessionKey } = readCronJob(jobPath, jobId) || {}
-  dcgLogger(`sessionKey: ${sessionKey}, jobId: ${jobId}`)
-  if (cronUploadFlushTimer !== null) {
-    clearTimeout(cronUploadFlushTimer)
-  }
-  cronUploadFlushTimer = setTimeout(() => {
-    runCronJobsUpload(sessionKey)
-  }, CRON_UPLOAD_DEBOUNCE_MS)
-}
-
-/**
- * 通过 OpenClaw CLI 删除定时任务（走 Gateway，与内存状态一致）。
- * 文档：运行中请勿手改 jobs.json，应使用 `openclaw cron rm` 或工具 API。
- */
-export const onRemoveCronJob = async (jobId: string) => {
-  const id = jobId?.trim()
-  if (!id) {
-    dcgLogger('onRemoveCronJob: empty jobId', 'error')
-    return
-  }
-  sendMessageToGateway(JSON.stringify({ method: 'cron.remove', params: { id: jobId } }))
-}
-export const onDisabledCronJob = async (jobId: string) => {
-  const id = jobId?.trim()
-  if (!id) {
-    dcgLogger('onRemoveCronJob: empty jobId', 'error')
-    return
-  }
-  sendMessageToGateway(JSON.stringify({ method: 'cron.update', params: { id: jobId, patch: { enabled: false } } }))
-}
-export const onEnabledCronJob = async (jobId: string) => {
-  const id = jobId?.trim()
-  if (!id) {
-    dcgLogger('onRemoveCronJob: empty jobId', 'error')
-    return
-  }
-  sendMessageToGateway(JSON.stringify({ method: 'cron.update', params: { id: jobId, patch: { enabled: true } } }))
-}
-export const onRunCronJob = async (jobId: string, messageId: string) => {
-  const id = jobId?.trim()
-  if (!id) {
-    dcgLogger('onRemoveCronJob: empty jobId', 'error')
-    return
-  }
-  const jobPath = getCronJobsPath()
-  const { sessionKey } = readCronJob(jobPath, jobId) || {}
-  if (!sessionKey) {
-    dcgLogger(`finishedDcgchatCron: no sessionKey for job id=${id}`, 'error')
-    return
-  }
-  setCronMessageId(sessionKey, messageId)
-  sendMessageToGateway(
-    JSON.stringify({
-      method: 'cron.runs',
-      params: { scope: 'job', id: jobId, limit: 50, offset: 0, status: 'all', sortDir: 'desc' }
-    })
-  )
-  sendMessageToGateway(JSON.stringify({ method: 'cron.run', params: { id: jobId, mode: 'force' } }))
-}
-export const finishedDcgchatCron = async (jobId: string, summary: string, hasFileOutput?: boolean) => {
-  const id = jobId?.trim()
-  if (!id) {
-    dcgLogger('finishedDcgchatCron: empty jobId', 'error')
-    return
-  }
-  const jobPath = getCronJobsPath()
-  const { sessionKey, name } = readCronJob(jobPath, id) || {}
-  if (!sessionKey) {
-    dcgLogger(`finishedDcgchatCron: no sessionKey for job id=${id}`, 'error')
-    return
-  }
-  const messageId = getCronMessageId(sessionKey) || `${Date.now()}`
-  const sessionInfo = sessionKey.split(':')
-  const sessionId = sessionInfo.at(-1) ?? ''
-  const agentId = sessionInfo.at(-2) ?? ''
-  // if (outboundCtx?.sessionId) {
-
-  const merged = mergeDefaultParams({
-    agentId: agentId,
-    sessionId: `${sessionId}`,
-    messageId: messageId || `${Date.now()}`,
-    real_mobook: !sessionId ? 1 : ''
-  })
-  const message_tags = { source: 'cron' } as Record<string, string | boolean>
-  if (hasFileOutput) {
-    message_tags.hasFile = true
-  }
-  wsSendRaw(merged, { response: summary, message_tags, is_finish: -1 })
-  setTimeout(() => {
-    sendFinal(merged, 'cron send')
-  }, 200)
-  // }
-  const ws = getWsConnection()
-  const baseContent = getParamsDefaults()
-  if (isWsOpen()) {
-    ws?.send(
-      JSON.stringify({
-        messageType: 'openclaw_bot_event',
-        source: 'client',
-        content: {
-          event_type: 'notify',
-          operation_type: 'cron',
-          bot_token: baseContent.botToken,
-          app_id: baseContent.appId,
-          session_id: sessionId,
-          agent_id: agentId,
-          real_mobook: !sessionId ? 1 : '',
-          title: name
-        }
-      })
-    )
-  }
-  dcgLogger(`定时任务执行成功: ${id}`)
-  removeCronMessageId(sessionKey)
-  dcgLogger(`finishedDcgchatCron: job=${id} sessionKey=${sessionKey}`)
-}