@dcrays/dcgchat-test 0.6.12 → 0.7.0

package/src/channel/index.ts

@@ -1,329 +0,0 @@
-import type { ChannelPlugin, OpenClawConfig } from 'openclaw/plugin-sdk'
-import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/account-id'
-import type { ResolvedDcgchatAccount, DcgchatConfig } from '../types.js'
-import { getCronMessageId, getDcgchatRuntime, getOpenClawConfig, takeApartSessionKey } from '../utils/global.js'
-import { mergeDefaultParams, wsSendRaw } from '../transport.js'
-import { CHANNEL_ID } from '../utils/constant.js'
-import { dcgLogger, setLogger } from '../utils/log.js'
-import { getOutboundMsgParams } from '../utils/params.js'
-import { isSessionActiveForTool } from '../tool.js'
-import { startDcgchatGatewaySocket } from '../gateway/socket.js'
-import { dispatchChannelOutboundSendMedia } from './outboundMedia.js'
-import { outboundChatId, normalizeSessionTarget } from './outboundTarget.js'
-import { ChannelOutboundContext } from 'openclaw/plugin-sdk/channel-runtime'
-
-export type { DcgchatMediaSendOptions } from './outboundMedia.js'
-export { normalizeOutboundMediaPaths, sendDcgchatMedia } from './outboundMedia.js'
-
-function dcgchatChannelCfg(): DcgchatConfig {
-  return (getOpenClawConfig()?.channels?.[CHANNEL_ID] 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 function resolveAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedDcgchatAccount {
-  const id = accountId ?? DEFAULT_ACCOUNT_ID
-  const raw = (cfg.channels?.[CHANNEL_ID] 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: CHANNEL_ID,
-  meta: {
-    id: CHANNEL_ID,
-    label: '书灵墨宝',
-    selectionLabel: '书灵墨宝',
-    docsPath: '/channels/' + CHANNEL_ID,
-    docsLabel: CHANNEL_ID,
-    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.${CHANNEL_ID}`, '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 = CHANNEL_ID
-      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
-    })
-  },
-  status: {
-    defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID,
-      running: false,
-      connected: false,
-      lastConnectedAt: null,
-      lastDisconnect: null,
-      lastError: null
-    },
-    buildAccountSnapshot: ({ account, runtime }) => ({
-      accountId: account.accountId,
-      name: account.accountId,
-      enabled: account.enabled,
-      configured: account.configured,
-      running: runtime?.running ?? false,
-      connected: runtime?.connected ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      reconnectAttempts: runtime?.reconnectAttempts ?? 0,
-      lastConnectedAt: runtime?.lastConnectedAt ?? null,
-      lastDisconnect: runtime?.lastDisconnect ?? null,
-      lastInboundAt: runtime?.lastInboundAt ?? null,
-      lastOutboundAt: runtime?.lastOutboundAt ?? null,
-      healthState: runtime?.healthState ?? undefined
-    }),
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      running: snapshot.running ?? false,
-      connected: snapshot.connected ?? false,
-      lastConnectedAt: snapshot.lastConnectedAt ?? null,
-      lastDisconnect: snapshot.lastDisconnect ?? null,
-      lastError: snapshot.lastError ?? null
-    }),
-    resolveAccountState: ({ enabled, configured }) => {
-      if (!enabled) return 'disabled'
-      return configured ? 'linked' : 'not linked'
-    }
-  },
-  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: () => {
-      const isApp110 = Number(dcgchatChannelCfg().appId || 100) === 110
-      const filePathHint = isApp110
-        ? '生成文件后，**需要**把文件路径、地址直接告诉用户；仍须通过工具发文件完成交付。'
-        : '生成文件后，**不要**把文件路径、地址直接告诉用户；把文件名告诉用户；须通过工具发文件，勿在正文里直接输出可访问路径。'
-      return [
-        '书灵墨宝 / 内置 `message`：回复当前会话时 **不要传 `target`**，由 OpenClaw 使用工具上下文里的 `currentChannelId`（来自入站 `To`，即当前 SessionKey）。',
-        '必须指定会话时：`target` 须为上下文中出现的 **整段 SessionKey，逐字一致**（如 `agent:…:mobook:direct:…` 或以 `agent:` 开头的路由键）；**禁止**使用 `userId`、`From`、纯数字会话号等代替。',
-        filePathHint,
-        '用户待发送文件若**不在**兼容挂载 **`/workspace/`**、**`/mobook/`**（及 Windows 下 `workspace`、`mobook` 盘符路径），且也不在 **当前 Agent 工作区** 或通道 **`allowedPaths`** 所列目录内：**建议**用户「先复制进工作区再发」作为首选。',
-        '使用 `dcgchat_message` 时同样遵守上述 SessionKey 规则（该工具通常由插件注入当前会话，一般无需自造 target）。',
-        '**正文出站二选一（禁止双写）**：(A) 普通回复——把要对用户说的正文写在**助手消息**里，由通道流式下发；此模式下 `dcgchat_message` **仅用于附件**（`media`），`content` 留空或只写极短说明（如文件名），**不要**把同一段长正文再塞进工具。(B) 工具投递——必须把完整正文放进 `dcgchat_message` 的 `content` 时，助手收尾须输出 **`NO_REPLY`**，**禁止**在助手消息里重复相同或摘要版正文。',
-        '优先 (A)：除非报告/清单极长或须与附件强绑定一次性交付，否则不要走 (B)。同一轮内**禁止**既流式输出助手正文、又用 `dcgchat_message.content` 发送相同或高度重叠的文本。',
-        '**发送附件不需要、也不依赖 inline buttons**（inline buttons 仅用于 Telegram 等通道的交互回调按钮）。发文件请用 `dcgchat_message` 的 `media: [{ file: \"绝对路径\" }]`，或内置 `message` 的 `filePath`/`media`；**禁止**以「未开启 inline buttons」为由拒绝发文件或让用户去开该配置。',
-        '所有对话、思考、输出：**必须使用中文**；不允许直接输出英文原文；用户输入英文，你必须翻译成中文回答。'
-      ]
-    }
-  },
-  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) => {
-      let messageId = ''
-      const sessionKey = normalizeSessionTarget(ctx.to)
-      dcgLogger(`dcgchat: channel sendText to=${ctx.text} sessionKey=${sessionKey}`)
-      const isCron = ctx.to.indexOf('dcg-cron:') >= 0
-      const content: Record<string, unknown> = { response: ctx.text }
-      // 入站 handler 已将本轮标为 running；若已 sendFinal(end) 则应为 finished。
-      // 否则网关/Core 晚到的正文会仍用「当前 params map」里的 messageId，错挂到后一条用户消息上。
-      if (isSessionActiveForTool(sessionKey)) {
-        const outboundCtx = getOutboundMsgParams(sessionKey)
-        messageId = outboundCtx?.messageId || `${Date.now()}`
-        wsSendRaw({ ...outboundCtx, messageId }, content)
-      } else if (isCron) {
-        const { sessionId, agentId } = takeApartSessionKey(sessionKey)
-        messageId = getCronMessageId(sessionKey) || `${Date.now()}`
-        const baseCtx = mergeDefaultParams({
-          sessionId: `${sessionId}`,
-          agentId: agentId,
-          messageId: messageId
-        })
-        content.is_finish = -1
-        wsSendRaw(baseCtx, content)
-      } else {
-        dcgLogger(`dcgchat: channel sendText dropped (session not active): to=${sessionKey}`)
-      }
-      return {
-        channel: CHANNEL_ID,
-        messageId: `${messageId}`,
-        chatId: outboundChatId(ctx.to, sessionKey)
-      }
-    },
-    sendMedia: async (ctx: ChannelOutboundContext) => {
-      const meta = await dispatchChannelOutboundSendMedia(ctx)
-      return {
-        channel: CHANNEL_ID,
-        messageId: meta.messageId,
-        chatId: meta.chatId
-      }
-    }
-  },
-  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()
-      const statusSink = (
-        patch: Partial<{
-          connected: boolean
-          running: boolean
-          lastConnectedAt: number | null
-          lastDisconnect:
-            | string
-            | {
-                at: number
-                status?: number
-                error?: string
-                loggedOut?: boolean
-              }
-            | null
-          lastError: string | null
-          lastStartAt: number | null
-          lastStopAt: number | null
-          lastInboundAt: number | null
-          lastOutboundAt: number | null
-          reconnectAttempts: number
-          healthState: string
-        }>
-      ) => {
-        ctx.setStatus({
-          ...ctx.getStatus(),
-          accountId: ctx.accountId,
-          ...patch
-        })
-      }
-      return monitorDcgchatProvider({
-        config: ctx.cfg,
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        accountId: ctx.accountId,
-        statusSink
-      })
-    }
-  }
-}

package/src/channel/outboundMedia.ts

@@ -1,144 +0,0 @@
-import { getCronMessageId, takeApartSessionKey, setCronMessageId } from '../utils/global.js'
-import { dcgLogger } from '../utils/log.js'
-import { getOutboundMsgParams, getParamsMessage } from '../utils/params.js'
-import { isWsOpen, wsSendRaw } from '../transport.js'
-import { normalizeSessionTarget, outboundChatId } from './outboundTarget.js'
-import { uploadMediaUrls } from './uploadMediaUrl.js'
-
-/**
- * 仅从 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('[') && t.endsWith(']')) {
-      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)
-  return [...new Set(acc.filter(Boolean))]
-}
-
-export type DcgchatMediaSendOptions = {
-  /** 与 setParamsMessage / map 一致，用于 getOutboundMsgParams */
-  sessionKey: string
-  mediaUrls?: string[]
-  text?: string
-  /** 定时任务等场景须与 `getCronMessageId` 一致，避免沿用 map 里上一条用户消息的 messageId */
-  messageId?: string
-}
-
-const SHULING_MSG_ID_LENGTH = 13
-
-export async function sendDcgchatMedia(opts: DcgchatMediaSendOptions, tags?: Record<string, string | boolean>): Promise<void> {
-  const sessionKey = opts.sessionKey?.trim()
-  /** 定时自动执行未走 onRunCronJob，须与 finishedDcgchatCron 共用同一 messageId，否则附件与气泡错位 */
-  if (!opts.messageId?.trim() && !getCronMessageId(sessionKey)) {
-    setCronMessageId(sessionKey, `${Date.now()}`)
-  }
-
-  const messageId = (opts.messageId || getCronMessageId(sessionKey))?.trim()
-  const baseCtx = getOutboundMsgParams(sessionKey)
-  const msgCtx = { ...baseCtx, messageId }
-  if (!isWsOpen()) {
-    dcgLogger(`dcgchat: outbound media skipped -> ws not isWsOpen failed open: ${opts.mediaUrls ?? ''}`)
-    return
-  }
-
-  const { sessionId, agentId } = takeApartSessionKey(sessionKey)
-  if (!msgCtx.sessionId) {
-    msgCtx.sessionId = sessionId
-  }
-  if (!msgCtx.agentId) {
-    msgCtx.agentId = agentId
-  }
-
-  const expanded = normalizeOutboundMediaPaths(opts.mediaUrls)
-  if (expanded.length === 0) {
-    dcgLogger(`dcgchat: sendMedia skipped (no resolvable path): ${JSON.stringify(opts.mediaUrls)} sessionKey=${sessionKey}`, 'error')
-    return
-  }
-  try {
-    const urls = await uploadMediaUrls(expanded, msgCtx, sessionKey)
-    const notMessageId = !msgCtx?.messageId || String(msgCtx?.messageId).length === SHULING_MSG_ID_LENGTH
-    wsSendRaw(msgCtx, {
-      response: opts.text ?? '',
-      message_tags: notMessageId ? { mark: 'empty_text_file', ...tags } : tags,
-      is_finish: notMessageId ? -1 : 0,
-      files: urls.map((url) => ({ url: url.url ?? '', name: url.fileName }))
-    })
-    dcgLogger(`dcgchat: sendMedia session=${sessionKey}, file=${urls.map((url) => url.fileName).join(', ')}`)
-  } catch (error) {
-    dcgLogger(`dcgchat: error sendMedia session=${sessionKey}: ${String(error)}`, 'error')
-  }
-}
-
-export type ChannelOutboundSendMediaCtx = {
-  to: string
-  mediaUrls?: unknown
-  mediaUrl?: string
-  text?: string
-}
-
-/**
- * Plugin `outbound.sendMedia`：解析 cron / 会话、归一化路径并逐条投递。
- */
-interface ChannelOutboundSendMediaResult {
-  messageId: string
-  chatId: string
-}
-export async function dispatchChannelOutboundSendMedia(ctx: ChannelOutboundSendMediaCtx): Promise<ChannelOutboundSendMediaResult> {
-  const sessionKey = normalizeSessionTarget(ctx.to)
-  const isCron = ctx.to.indexOf('dcg-cron:') >= 0
-  const outboundCtx = getOutboundMsgParams(sessionKey)
-  const msgCtx = getParamsMessage(sessionKey) ?? outboundCtx
-  if (isCron && !getCronMessageId(sessionKey)) {
-    setCronMessageId(sessionKey, `${Date.now()}`)
-  }
-  const cronMsgId = getCronMessageId(sessionKey)
-  const messageId = (isCron ? cronMsgId : msgCtx?.messageId) || `${Date.now()}`
-  const { sessionId } = takeApartSessionKey(sessionKey)
-  if (!sessionId) {
-    dcgLogger(`dcgchat: channel sendMedia to ${ctx.to} -> sessionId not found`, 'error')
-    return {
-      messageId,
-      chatId: outboundChatId(ctx.to, sessionKey || '')
-    }
-  }
-
-  dcgLogger(`dcgchat: channel sendMedia to ${ctx.to}`)
-
-  const rawMedia = ctx.mediaUrls ?? ctx.mediaUrl
-  const mediaUrls = normalizeOutboundMediaPaths(rawMedia)
-  await sendDcgchatMedia({ sessionKey, mediaUrls, messageId, text: ctx.text })
-  return {
-    messageId,
-    chatId: outboundChatId(ctx.to, sessionKey || '')
-  }
-}

package/src/channel/outboundTarget.ts

@@ -1,62 +0,0 @@
-import { getParamsMessage } from '../utils/params.js'
-
-export function normalizeSessionTarget(rawTo: string): string {
-  const cleaned = rawTo.replace('dcg-cron:', '').trim()
-  if (!cleaned) return ''
-  return getParamsMessage(cleaned)?.sessionKey?.trim() || cleaned
-}
-
-const cronSessionKeyMap = new Set<string>()
-const cronSessionKeysByJobId = new Map<string, Set<string>>()
-
-function normalizeCronSessionKey(value: unknown): string {
-  if (typeof value !== 'string') return ''
-  return value.replace('dcg-cron:', '').trim()
-}
-
-export function setCronSessionKeyMap(sessionKey: string) {
-  const key = normalizeCronSessionKey(sessionKey)
-  if (key) cronSessionKeyMap.add(key)
-}
-
-export function setCronSessionKeyMapsForJob(jobId: unknown, sessionKeys: unknown[]): string[] {
-  const keys = [...new Set(sessionKeys.map(normalizeCronSessionKey).filter(Boolean))]
-  for (const key of keys) {
-    cronSessionKeyMap.add(key)
-  }
-  const id = typeof jobId === 'string' ? jobId.trim() : ''
-  if (id && keys.length > 0) {
-    const bucket = cronSessionKeysByJobId.get(id) ?? new Set<string>()
-    for (const key of keys) bucket.add(key)
-    cronSessionKeysByJobId.set(id, bucket)
-  }
-  return keys
-}
-export function hasCronSessionKeyMap(sessionKey: string): boolean {
-  const key = normalizeCronSessionKey(sessionKey)
-  return !!key && cronSessionKeyMap.has(key)
-}
-export function deleteCronSessionKeyMap(sessionKey: string) {
-  const key = normalizeCronSessionKey(sessionKey)
-  if (!key) return
-  cronSessionKeyMap.delete(key)
-  for (const [jobId, keys] of cronSessionKeysByJobId.entries()) {
-    keys.delete(key)
-    if (keys.size === 0) cronSessionKeysByJobId.delete(jobId)
-  }
-}
-
-export function deleteCronSessionKeyMapsForJob(jobId: unknown): string[] {
-  const id = typeof jobId === 'string' ? jobId.trim() : ''
-  if (!id) return []
-  const keys = [...(cronSessionKeysByJobId.get(id) ?? [])]
-  for (const key of keys) cronSessionKeyMap.delete(key)
-  cronSessionKeysByJobId.delete(id)
-  return keys
-}
-
-/** 出站返回的 chatId：含 `dcg-cron:` 时保留原始 `to`，便于下游识别定时投递 */
-export function outboundChatId(rawTo: string | undefined, normalizedTo: string): string {
-  const raw = rawTo?.trim() ?? ''
-  return raw.indexOf('dcg-cron:') >= 0 ? raw : normalizedTo
-}

package/src/channel/uploadMediaUrl.ts

@@ -1,76 +0,0 @@
-import fs from 'node:fs'
-import { basename } from 'node:path'
-import { ossUpload } from '../request/oss.js'
-import { CHANNEL_ID } from '../utils/constant.js'
-import { addSentMediaKey, getOpenClawConfig, hasSentMediaKey, resolveOutboundMediaDedupeKey } from '../utils/global.js'
-import { dcgLogger } from '../utils/log.js'
-import { IMsgParams } from '../types.js'
-
-export type UploadedMediaUrl = {
-  url: string
-  fileName: string
-}
-
-/**
- * 上传本地文件到 OSS，返回上传成功的文件访问地址与原始文件名。
- */
-export async function uploadMediaUrls(
-  mediaUrls: string[] | undefined,
-  msgCtx: IMsgParams,
-  sessionKey: string
-): Promise<UploadedMediaUrl[]> {
-  if (!mediaUrls || mediaUrls.length === 0) {
-    return []
-  }
-  const botToken = msgCtx.botToken ?? getOpenClawConfig()?.channels?.[CHANNEL_ID]?.botToken ?? ''
-  const urls: UploadedMediaUrl[] = []
-
-  for (const mediaUrl of mediaUrls) {
-    const filePath = mediaUrl?.trim()
-    if (!filePath) {
-      dcgLogger('dcgchat: uploadMediaUrls skipped (empty path)', 'error')
-      continue
-    }
-
-    let mediaStat: fs.Stats
-    try {
-      mediaStat = fs.statSync(filePath)
-    } catch (err) {
-      dcgLogger(`dcgchat: uploadMediaUrls skipped (cannot stat path): ${filePath} ${String(err)}`, 'error')
-      continue
-    }
-
-    if (!mediaStat.isFile()) {
-      const kind = mediaStat.isDirectory() ? 'directory' : 'non-regular'
-      dcgLogger(`dcgchat: uploadMediaUrls skipped (not a regular file, ${kind}): ${filePath}`, 'error')
-      continue
-    }
-    if (mediaUrl && msgCtx.sessionId) {
-      const mediaDedupeBucket = resolveOutboundMediaDedupeKey(msgCtx.messageId, msgCtx.sessionId, sessionKey)
-      if (!mediaDedupeBucket) {
-        dcgLogger(`dcgchat: sendMedia skipped (no media dedupe bucket): ${mediaUrl} sessionKey=${sessionKey}`, 'error')
-        continue
-      }
-      if (hasSentMediaKey(mediaDedupeBucket, mediaUrl)) {
-        dcgLogger(
-          `dcgchat: sendMedia skipped (hasSentMediaKey): ${mediaUrl} dedupeBucket=${mediaDedupeBucket} sessionKey=${sessionKey}`
-        )
-        continue
-      }
-      addSentMediaKey(mediaDedupeBucket, mediaUrl)
-    }
-
-    try {
-      const url = await ossUpload(filePath, botToken, 1)
-      if (!url) {
-        dcgLogger(`dcgchat: uploadMediaUrls failed (empty OSS url): ${filePath}`, 'error')
-        continue
-      }
-      urls.push({ url, fileName: basename(filePath) })
-    } catch (err) {
-      dcgLogger(`dcgchat: uploadMediaUrls failed: ${filePath} ${String(err)}`, 'error')
-    }
-  }
-
-  return urls
-}