@dcrays/dcgchat-test 0.4.17 → 0.4.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/dcgchat-test",
-  "version": "0.4.17",
+  "version": "0.4.19",
   "type": "module",
   "description": "OpenClaw channel plugin for 书灵墨宝 (WebSocket)",
   "main": "index.ts",

package/src/bot.ts

@@ -17,7 +17,7 @@ import { dcgLogger } from './utils/log.js'
 import { channelInfo, systemCommand, interruptCommand, ENV, ignoreToolCommand } from './utils/constant.js'
 import { sendGatewayRpc } from './gateway/socket.js'
 import { clearParamsMessage, getEffectiveMsgParams, setParamsMessage } from './utils/params.js'
-import { getChildSessionKeysTrackedForRequester, resetSubagentStateForRequesterSession, waitUntilSubagentsIdle } from './tool.js'
+import { getDescendantSessionKeysForRequester, resetSubagentStateForRequesterSession, waitUntilSubagentsIdle } from './tool.js'
 
 type MediaInfo = {
   path: string
@@ -30,7 +30,7 @@ type TFileInfo = { name: string; url: string }
 
 const mediaMaxBytes = 300 * 1024 * 1024
 
-/** 当前会话最近一次 agent run 的 runId（供 chat.abort 精确打断；无则仅传 sessionKey 仍会中止该会话全部活动运行） */
+/** 当前会话最近一次 agent run 的 runId（供观测；/stop 时对子会话与主会话使用不传 runId 的 chat.abort 以终止该键下全部活跃 run） */
 const activeRunIdBySessionKey = new Map<string, string>()
 
 /**
@@ -174,7 +174,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     sessionId: conversationId,
     messageId: msg.content.message_id,
     domainId: msg.content.domain_id,
-    appId: msg.content.app_id,
+    appId: config.channels?.["dcgchat-test"]?.appId || 100,
     botId: msg.content.bot_id ?? '',
     agentId: msg.content.agent_id ?? '',
     sessionKey: dcgSessionKey,
@@ -327,12 +327,25 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         const ctxForAbort = priorOutboundCtx.messageId?.trim() || priorOutboundCtx.sessionId?.trim() ? priorOutboundCtx : outboundCtx
         sendFinal(ctxForAbort.messageId?.trim() ? ctxForAbort : { ...ctxForAbort, messageId: `${Date.now()}` }, 'abort')
         sessionStreamSuppressed.add(dcgSessionKey)
+        // 网关侧彻底中止：子 agent 使用独立 sessionKey，仅 abort 主会话不会停子 run；自深到浅 abort 后代，再 abort 主会话；不传 runId 以终止该键下全部活跃 chat run
+        const descendantKeys = getDescendantSessionKeysForRequester(dcgSessionKey)
+        const abortSubKeys = [...descendantKeys].reverse()
+        if (abortSubKeys.length > 0) {
+          dcgLogger(`interrupt: chat.abort ${abortSubKeys.length} subagent session(s) (nested incl.)`)
+        }
+        for (const subKey of abortSubKeys) {
+          try {
+            await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey: subKey } })
+          } catch (e) {
+            dcgLogger(`chat.abort subagent ${subKey}: ${String(e)}`, 'error')
+          }
+        }
         try {
-          const runId = activeRunIdBySessionKey.get(dcgSessionKey)
-          await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey: dcgSessionKey, runId } })
+          await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey: dcgSessionKey } })
         } catch (e) {
-          dcgLogger(`chat.abort ${dcgSessionKey}: ${String(e)}`, 'error')
+          dcgLogger(`chat.abort main ${dcgSessionKey}: ${String(e)}`, 'error')
         }
+        activeRunIdBySessionKey.delete(dcgSessionKey)
         streamChunkIdxBySessionKey.delete(dcgSessionKey)
         clearSentMediaKeys(msg.content.message_id)
         resetSubagentStateForRequesterSession(dcgSessionKey)

package/src/channel.ts

@@ -14,6 +14,7 @@ import { isWsOpen, mergeDefaultParams, mergeSessionParams, sendFinal, wsSendRaw
 import { dcgLogger, setLogger } from './utils/log.js'
 import { getOutboundMsgParams, getParamsMessage } from './utils/params.js'
 import { startDcgchatGatewaySocket } from './gateway/socket.js'
+import { getCronJobsPath, readCronJob } from './cron.js'
 
 function dcgchatChannelCfg(): DcgchatConfig {
   return (getOpenClawConfig()?.channels?.["dcgchat-test"] as DcgchatConfig | undefined) ?? {}
@@ -61,6 +62,8 @@ export type DcgchatMediaSendOptions = {
   sessionKey: string
   mediaUrl?: string
   text?: string
+  /** 定时任务等场景须与 `getCronMessageId` 一致，避免沿用 map 里上一条用户消息的 messageId */
+  messageId?: string
 }
 
 function normalizeSessionTarget(rawTo: string): string {
@@ -69,6 +72,29 @@ function normalizeSessionTarget(rawTo: string): string {
   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() ?? ''
@@ -76,21 +102,32 @@ function outboundChatId(rawTo: string | undefined, normalizedTo: string): string
 }
 
 export async function sendDcgchatMedia(opts: DcgchatMediaSendOptions): Promise<void> {
-  const sessionKey = normalizeSessionTarget(opts.sessionKey ?? '')
-  const msgCtx = getOutboundMsgParams(sessionKey)
+  let sessionKey = normalizeSessionTarget(opts.sessionKey ?? '')
+  sessionKey = resolveIsolatedCronSessionToJobSessionKey(sessionKey)
+  const baseCtx = getOutboundMsgParams(sessionKey)
+  const msgCtx = opts.messageId?.trim() ? { ...baseCtx, messageId: opts.messageId.trim() } : baseCtx
   if (!isWsOpen()) {
-    dcgLogger(`outbound media skipped -> ws not open: ${opts.mediaUrl ?? ''}`)
+    dcgLogger(`outbound media skipped -> ws not isWsOpen failed open: ${opts.mediaUrl ?? ''}`)
     return
   }
 
   const mediaUrl = opts.mediaUrl
-  const dedupeId = msgCtx.messageId
-  if (mediaUrl && dedupeId && hasSentMediaKey(dedupeId, mediaUrl)) {
-    dcgLogger(`dcgchat: sendMedia skipped (duplicate in session): ${mediaUrl}`)
-    return
+
+  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 { sessionId, agentId } = getInfoBySessionKey(sessionKey)
+  if (!msgCtx.sessionId) {
+    msgCtx.sessionId = sessionId
   }
-  if (mediaUrl && dedupeId) {
-    addSentMediaKey(dedupeId, mediaUrl)
+  if (!mediaUrl || !msgCtx.sessionId) {
+    dcgLogger(`dcgchat: sendMedia skipped (duplicate in session): ${mediaUrl} sessionId=${msgCtx.sessionId} sessionKey=${sessionKey}`)
+    return
   }
 
   const fileName = mediaUrl?.split(/[\\/]/).pop() || ''
@@ -98,16 +135,19 @@ export async function sendDcgchatMedia(opts: DcgchatMediaSendOptions): Promise<v
   try {
     const botToken = msgCtx.botToken ?? getOpenClawConfig()?.channels?.["dcgchat-test"]?.botToken ?? ''
     const url = opts.mediaUrl ? await ossUpload(opts.mediaUrl, botToken, 1) : ''
+    if (!msgCtx.agentId) {
+      msgCtx.agentId = agentId
+    }
     wsSendRaw(msgCtx, {
       response: opts.text ?? '',
-      message_tags: { source: 'file' },
+      is_finish: `${msgCtx?.messageId}`?.length === 13 ? -1 : 0,
       files: [{ url, name: fileName }]
     })
     dcgLogger(`dcgchat: sendMedia session=${sessionKey}, file=${fileName}`)
   } catch (error) {
     wsSendRaw(msgCtx, {
       response: opts.text ?? '',
-      message_tags: { source: 'file' },
+      is_finish: `${msgCtx?.messageId}`?.length === 13 ? -1 : 0,
       files: [{ url: opts.mediaUrl ?? '', name: fileName }]
     })
     dcgLogger(`dcgchat: error sendMedia session=${sessionKey}: ${String(error)}`, 'error')
@@ -283,8 +323,9 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
       }
     },
     sendMedia: async (ctx) => {
-      const isCron = ctx.to.indexOf('dcg-cron:') >= 0
-      const to = normalizeSessionTarget(ctx.to)
+      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
       const cronMsgId = getCronMessageId(to)
@@ -301,7 +342,11 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
       }
 
       dcgLogger(`channel sendMedia to ${ctx.to}`)
-      await sendDcgchatMedia({ sessionKey: to || '', mediaUrl: ctx.mediaUrl || '' })
+      await sendDcgchatMedia({
+        sessionKey: to || '',
+        mediaUrl: ctx.mediaUrl || '',
+        ...(isCron ? { messageId } : {})
+      })
       return {
         channel: "dcgchat-test",
         messageId,

package/src/cron.ts

@@ -135,7 +135,7 @@ export const onRunCronJob = async (jobId: string, messageId: string) => {
   )
   sendMessageToGateway(JSON.stringify({ method: 'cron.run', params: { id: jobId, mode: 'force' } }))
 }
-export const finishedDcgchatCron = async (jobId: string, summary: string) => {
+export const finishedDcgchatCron = async (jobId: string, summary: string, hasFileOutput?: boolean) => {
   const id = jobId?.trim()
   if (!id) {
     dcgLogger('finishedDcgchatCron: empty jobId', 'error')
@@ -159,7 +159,11 @@ export const finishedDcgchatCron = async (jobId: string, summary: string) => {
     messageId: messageId || `${Date.now()}`,
     real_mobook: !sessionId ? 1 : ''
   })
-  wsSendRaw(merged, { response: summary, message_tags: { source: 'cron' }, is_finish: -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)

package/src/cronToolCall.ts

@@ -135,10 +135,11 @@ function injectBestEffort(params: Record<string, unknown>, sk: string): Record<s
   // job.delivery
   const job = newParams.job as Record<string, unknown> | undefined
   if (job?.delivery && typeof job.delivery === 'object') {
-    ;(job.delivery as CronDelivery).bestEffort = true
-    ;(newParams.delivery as CronDelivery).to = `dcg-cron:${sk}`
-    ;(newParams.delivery as CronDelivery).accountId = agentId
-    ;(newParams.delivery as CronDelivery).channel = "dcgchat-test"
+    const jd = job.delivery as CronDelivery
+    jd.bestEffort = true
+    jd.to = `dcg-cron:${sk}`
+    jd.accountId = agentId
+    jd.channel = "dcgchat-test"
     newParams.sessionKey = sk
     return newParams
   }
@@ -154,14 +155,14 @@ export function cronToolCall(event: { toolName: any; params: any; toolCallId: an
     const delivery = extractDelivery(params)
     if (!delivery) {
       dcgLogger(`[${LOG_TAG}] cron call (${toolCallId}) has no delivery config, skip.`)
-      return params
+      return undefined
     }
     if (!needsBestEffort(delivery)) {
       dcgLogger(
         `[${LOG_TAG}] cron call (${toolCallId}) delivery does not need bestEffort ` +
           `(mode=${String(delivery.mode)}, channel=${String(delivery.channel)}, bestEffort=${String(delivery.bestEffort)}), skip.`
       )
-      return params
+      return undefined
     }
 
     // ★ 核心：注入 bestEffort: true
@@ -179,9 +180,9 @@ export function cronToolCall(event: { toolName: any; params: any; toolCallId: an
         params.command.replace('--json', '') + `  --session-key ${sk}  --channel ${"dcgchat-test"}  --to dcg-cron:${sk} --json`
       return { params: newParams }
     } else {
-      return params
+      return undefined
     }
   }
 
-  return params
+  return undefined
 }

package/src/tool.ts

@@ -180,6 +180,29 @@ export function getChildSessionKeysTrackedForRequester(requesterSessionKey: stri
   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，避免永久挂起。
  */
@@ -302,6 +325,16 @@ function resolveHookSessionKey(
   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 : ''
@@ -328,7 +361,10 @@ export function monitoringToolMessage(api: OpenClawPluginApi) {
       trackSubagentLifecycle(item.event, event, args)
       const sk = resolveHookSessionKey(item.event, args ?? {})
       if (sk) {
-        if (isSessionActiveForTool(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)}`)

package/src/transport.ts

@@ -1,4 +1,4 @@
-import { getWsConnection } from './utils/global.js'
+import { clearSentMediaKeys, getWsConnection } from './utils/global.js'
 import { dcgLogger } from './utils/log.js'
 import type { IMsgParams } from './types.js'
 import { getEffectiveMsgParams, getParamsDefaults } from './utils/params.js'
@@ -170,6 +170,7 @@ export function sendChunk(text: string, ctx: IMsgParams, chunkIdx: number): bool
 
 export function sendFinal(ctx: IMsgParams, tag: string): boolean {
   dcgLogger(` message handling complete state: to=${ctx.sessionId} final tag:${tag}`)
+  clearSentMediaKeys(ctx.sessionId)
   return wsSend(ctx, { response: '', state: 'final' })
 }
 

package/src/utils/gatewayMsgHanlder.ts

@@ -35,8 +35,13 @@ export function handleGatewayEventMessage(msg: { event?: string; payload?: Recor
       if (p?.action === 'removed') {
         sendDcgchatCron(p?.jobId as string)
       }
-      if (p?.action === 'finished') {
-        finishedDcgchatCron(p?.jobId as string, p?.summary as string)
+      if (p?.action === 'finished' && p?.status === 'ok') {
+        const hasFileOutput = p.delivered === true && p.deliveryStatus === 'delivered'
+        let summary = p?.summary as string
+        if (summary.indexOf('HEARTBEAT_OK') >= 0 && summary !== 'HEARTBEAT_OK') {
+          summary = summary.replace('HEARTBEAT_OK', '')
+        }
+        finishedDcgchatCron(p?.jobId as string, summary, hasFileOutput)
       }
     }
   } catch (error) {

package/src/utils/global.ts

@@ -82,11 +82,11 @@ const getMediaKey = (url: string) => url.split(/[\\/]/).pop() ?? url
 /** 已发送媒体去重：外层 messageId → 内层该会话下已发送的媒体 key（文件名） */
 const sentMediaKeysBySession = new Map<string, Set<string>>()
 
-function getSessionMediaSet(messageId: string): Set<string> {
-  let set = sentMediaKeysBySession.get(messageId)
+function getSessionMediaSet(sessionId: string): Set<string> {
+  let set = sentMediaKeysBySession.get(sessionId)
   if (!set) {
     set = new Set<string>()
-    sentMediaKeysBySession.set(messageId, set)
+    sentMediaKeysBySession.set(sessionId, set)
   }
   return set
 }
@@ -95,14 +95,14 @@ export function addSentMediaKey(messageId: string, url: string) {
   getSessionMediaSet(messageId).add(getMediaKey(url))
 }
 
-export function hasSentMediaKey(messageId: string, url: string): boolean {
-  return sentMediaKeysBySession.get(messageId)?.has(getMediaKey(url)) ?? false
+export function hasSentMediaKey(sessionId: string, url: string): boolean {
+  return sentMediaKeysBySession.get(sessionId)?.has(getMediaKey(url)) ?? false
 }
 
 /** 不传 messageId 时清空全部会话；传入则只清空该会话 */
-export function clearSentMediaKeys(messageId?: string) {
-  if (messageId) {
-    sentMediaKeysBySession.delete(messageId)
+export function clearSentMediaKeys(sessionId?: string) {
+  if (sessionId) {
+    sentMediaKeysBySession.delete(sessionId)
   } else {
     sentMediaKeysBySession.clear()
   }