@dcrays/dcgchat-test 0.2.34 → 0.3.1

package/src/transport.ts

@@ -1,19 +1,22 @@
 import { getWsConnection } from './utils/global.js'
 import { dcgLogger } from './utils/log.js'
+import type { IMsgParams } from './types.js'
+import { getEffectiveMsgParams, getParamsDefaults } from './utils/params.js'
 
-export type DcgchatMsgContext = {
-  userId: number
-  botToken: string
-  domainId?: string
-  appId?: string
-  botId?: string
-  agentId?: string
-  sessionId: string
-  messageId: string
+/** 用 sessionKey 从 map 取参，再合并 overrides（channel 出站、媒体等） */
+export function mergeSessionParams(sessionKey: string, overrides?: Partial<IMsgParams>): IMsgParams {
+  const base = getEffectiveMsgParams(sessionKey)
+  if (!overrides) return base
+  return { ...base, ...overrides }
+}
+export function mergeDefaultParams(overrides?: Partial<IMsgParams>): IMsgParams {
+  const base = getParamsDefaults()
+  if (!overrides) return base
+  return { ...base, ...overrides }
 }
 
-export function createMsgContext(msg: {
-  _userId: number
+export type InboundMsgForContext = {
+  _userId: number | string
   content: {
     bot_token: string
     domain_id?: string
@@ -23,86 +26,176 @@ export function createMsgContext(msg: {
     session_id: string
     message_id: string
   }
-}): DcgchatMsgContext {
+}
+
+export type OpenclawBotChatEnvelope = {
+  messageType: 'openclaw_bot_chat'
+  _userId: number | undefined
+  source: 'client'
+  content: Record<string, unknown>
+}
+
+function isInboundWire(arg: unknown): arg is InboundMsgForContext {
+  return Boolean(arg && typeof arg === 'object' && '_userId' in arg && 'content' in arg)
+}
+
+/** 下行 WebSocket 帧 → 内部上下文（字段缺省用 channel 配置补） */
+function inboundToCtx(msg: InboundMsgForContext, d: IMsgParams): IMsgParams {
+  const c = msg.content
   return {
-    userId: msg._userId,
-    botToken: msg.content.bot_token,
-    domainId: msg.content.domain_id,
-    appId: msg.content.app_id,
-    botId: msg.content.bot_id,
-    agentId: msg.content.agent_id,
-    sessionId: msg.content.session_id,
-    messageId: msg.content.message_id
+    userId: Number(msg._userId ?? d.userId),
+    botToken: c.bot_token ?? d.botToken,
+    domainId: String(c.domain_id ?? d.domainId),
+    appId: String(c.app_id ?? d.appId),
+    botId: c.bot_id,
+    agentId: c.agent_id,
+    sessionId: c.session_id,
+    messageId: c.message_id
   }
 }
 
-function buildContent(ctx: DcgchatMsgContext, extra: Record<string, unknown>) {
+/** 上行：与配置合并缺省后再 `...ctx` 覆盖（原 wsSendRaw） */
+function mergeOutboundWithDefaults(ctx: IMsgParams, d: IMsgParams): IMsgParams {
+  return {
+    userId: Number(ctx.userId ?? d.userId),
+    botToken: ctx.botToken ?? d.botToken,
+    domainId: String(ctx.domainId ?? d.domainId),
+    appId: String(ctx.appId ?? d.appId),
+    ...ctx
+  }
+}
+
+/**
+ * 组装完整 wire `content` 对象：先写会话/机器人基础字段（回落到 d），再合并调用方传入的 payload。
+ * `content` 在使用处构造（如 response、state、files），同名键可覆盖基础字段。
+ */
+export function buildWireContent(base: IMsgParams, d: IMsgParams, content: Record<string, unknown>): Record<string, unknown> {
+  const resolvedBotToken = base.botToken ?? d.botToken
+  const domain = base.domainId ?? d.domainId
+  const app = base.appId ?? d.appId
   return {
-    bot_token: ctx.botToken,
-    domain_id: ctx.domainId,
-    app_id: ctx.appId,
-    bot_id: ctx.botId,
-    agent_id: ctx.agentId,
-    session_id: ctx.sessionId,
-    message_id: ctx.messageId || Date.now().toString(),
-    ...extra
+    bot_token: base.botToken || resolvedBotToken,
+    domain_id: base.domainId || domain,
+    app_id: base.appId || app,
+    bot_id: base.botId,
+    agent_id: base.agentId,
+    session_id: base.sessionId,
+    message_id: base.messageId || Date.now().toString(),
+    ...content
   }
 }
 
-function buildEnvelope(ctx: DcgchatMsgContext, extra: Record<string, unknown>) {
+/** 上行：在已合并的 ctx 上套 openclaw_bot_chat 信封（messageType / _userId / source + content） */
+function buildOutboundOpenclawBotChatEnvelope(
+  ctx: IMsgParams,
+  content: Record<string, unknown>,
+  opts?: { mergeChannelDefaults?: boolean }
+): OpenclawBotChatEnvelope {
+  const d = getParamsDefaults()
+  const base = opts?.mergeChannelDefaults ? mergeOutboundWithDefaults(ctx, d) : ctx
   return {
-    messageType: 'openclaw_bot_chat' as const,
-    _userId: ctx.userId,
-    source: 'client' as const,
-    content: buildContent(ctx, extra)
+    messageType: 'openclaw_bot_chat',
+    _userId: base.userId,
+    source: 'client',
+    content: buildWireContent(base, d, content)
   }
 }
 
+/**
+ * 下行解析为 DcgchatMsgContext，或上行组装 openclaw_bot_chat 信封。
+ * 上行时 `content` 由调用方传入；基础参数来自 `ctx` 与 `getParamsDefaults()`（可选 mergeChannelDefaults，同原 wsSendRaw）。
+ */
+export function buildOpenclawBotChat(msg: InboundMsgForContext): IMsgParams
+export function buildOpenclawBotChat(
+  ctx: IMsgParams,
+  content: Record<string, unknown>,
+  opts?: { mergeChannelDefaults?: boolean }
+): OpenclawBotChatEnvelope
+export function buildOpenclawBotChat(
+  arg1: InboundMsgForContext | IMsgParams,
+  arg2?: Record<string, unknown>,
+  opts?: { mergeChannelDefaults?: boolean }
+): IMsgParams | OpenclawBotChatEnvelope {
+  const d = getParamsDefaults()
+
+  if (arg2 === undefined && isInboundWire(arg1)) {
+    return inboundToCtx(arg1, d)
+  }
+
+  const ctx = arg1 as IMsgParams
+  return buildOutboundOpenclawBotChatEnvelope(ctx, arg2 ?? {}, opts)
+}
+
 export function isWsOpen(): boolean {
   const isOpen = getWsConnection()?.readyState === WebSocket.OPEN
   if (!isOpen) {
-    dcgLogger(`socket not ready ${getWsConnection()?.readyState}`, 'error')
+    dcgLogger(`server socket not ready ${getWsConnection()?.readyState}`, 'error')
   }
   return isOpen
 }
 
 /**
- * Content is stringified separately (double-encoded) to match the
- * dcgchat wire protocol used by the chat stream path.
+ * 聊天流路径：content 单独 JSON.stringify（双重编码），符合 dcgchat 协议。
+ * `ctx` 须由调用方用 getEffectiveMsgParams(sessionKey) 等解析好；`content` 为完整业务 payload。
  */
-export function wsSend(ctx: DcgchatMsgContext, extra: Record<string, unknown>): boolean {
+export function wsSend(ctx: IMsgParams, content: Record<string, unknown>): boolean {
   const ws = getWsConnection()
   if (ws?.readyState !== WebSocket.OPEN) return false
-  const envelope = buildEnvelope(ctx, extra)
+  const envelope = buildOpenclawBotChat(ctx, content)
   ws.send(JSON.stringify({ ...envelope, content: JSON.stringify(envelope.content) }))
   return true
 }
 
 /**
- * Content stays as a nested object (single-encoded).
- * Matches the legacy wire format used by media and outbound-pipeline messages.
+ * 媒体 / channel 出站：content 保持嵌套对象（单次编码）。
+ * `ctx` 须由调用方解析（如需合并覆盖可先 mergeSessionParams）。
  */
-export function wsSendRaw(ctx: DcgchatMsgContext, extra: Record<string, unknown>): boolean {
+export function wsSendRaw(ctx: IMsgParams, content: Record<string, unknown>): boolean {
   const ws = getWsConnection()
   if (isWsOpen()) {
-    ws?.send(JSON.stringify(buildEnvelope(ctx, extra)))
+    ws?.send(JSON.stringify(buildOpenclawBotChat(ctx, content, { mergeChannelDefaults: true })))
   }
   return true
 }
 
-export function sendChunk(ctx: DcgchatMsgContext, text: string): boolean {
+export function sendChunk(text: string, ctx: IMsgParams): boolean {
   return wsSend(ctx, { response: text, state: 'chunk' })
 }
 
-export function sendFinal(ctx: DcgchatMsgContext): boolean {
+export function sendFinal(ctx: IMsgParams): boolean {
   dcgLogger(` message handling complete state: final`)
   return wsSend(ctx, { response: '', state: 'final' })
 }
 
-export function sendText(ctx: DcgchatMsgContext, text: string, event?: Record<string, unknown>): boolean {
+export function sendText(text: string, ctx: IMsgParams, event?: Record<string, unknown>): boolean {
   return wsSend(ctx, { response: text, ...event })
 }
 
-export function sendError(ctx: DcgchatMsgContext, errorMsg: string): boolean {
+export function sendError(errorMsg: string, ctx: IMsgParams): boolean {
   return wsSend(ctx, { response: `[错误] ${errorMsg}`, state: 'final' })
 }
+
+export function sendEventMessage(url: string, sessionKey: string) {
+  const ctx = getEffectiveMsgParams(sessionKey)
+  const ws = getWsConnection()
+  if (isWsOpen()) {
+    ws?.send(
+      JSON.stringify({
+        messageType: 'openclaw_bot_event',
+        source: 'client',
+        content: {
+          event_type: 'cron',
+          operation_type: 'install',
+          bot_token: ctx.botToken,
+          domain_id: ctx.domainId,
+          app_id: ctx.appId,
+          oss_url: url,
+          bot_id: ctx.botId,
+          agent_id: ctx.agentId,
+          session_id: ctx.sessionId,
+          message_id: ctx.messageId || Date.now().toString()
+        }
+      })
+    )
+  }
+}

package/src/types.ts

@@ -44,6 +44,7 @@ export type InboundMessage = {
     bot_id?: string
     agent_id?: string
     session_id: string
+    real_mobook: string | number
     message_id: string
     text: string
     files?: {
@@ -115,12 +116,15 @@ export interface IStsTokenReq {
 }
 
 export interface IMsgParams {
-  userId: number
-  token: string
-  sessionId: string
-  messageId: string
-  domainId: string
-  appId: string
-  botId: string
-  agentId: string
+  userId?: number
+  botToken?: string
+  sessionId?: string
+  messageId?: string
+  domainId?: string
+  appId?: string
+  botId?: string
+  agentId?: string
+  /** 与 OpenClaw 路由一致，用于 map 与异步链路（工具 / HTTP / cron）对齐当前会话 */
+  sessionKey?: string
+  real_mobook?: string | number
 }

package/src/utils/global.ts

@@ -24,7 +24,6 @@ export function getOpenClawConfig(): OpenClawConfig | null {
 
 import type { OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk'
 import { dcgLogger } from './log.js'
-import { IMsgParams } from '../types.js'
 import { channelInfo, ENV } from './constant.js'
 
 const path = require('path')
@@ -69,14 +68,6 @@ export function getDcgchatRuntime(): PluginRuntime {
   return runtime as PluginRuntime
 }
 
-let msgParams = {} as IMsgParams
-export function setMsgParams(params: any) {
-  msgParams = params
-}
-export function getMsgParams() {
-  return msgParams
-}
-
 let msgStatus: 'running' | 'finished' | '' = ''
 export function setMsgStatus(status: 'running' | 'finished' | '') {
   msgStatus = status

package/src/utils/params.ts

@@ -0,0 +1,65 @@
+import { channelInfo, ENV } from './constant.js'
+import { getOpenClawConfig } from './global.js'
+import type { DcgchatConfig, IMsgParams } from '../types.js'
+
+/**
+ * map key 是 session_key，value 为该会话下已 merge 后的消息参数。
+ */
+const paramsMessageMap = new Map<string, IMsgParams>()
+
+/** 最近一次 setParamsMessage 的 key，供不传参的 getEffectiveMsgParams() 使用 */
+let currentSessionKey: string | null = null
+
+/** 从 OpenClaw 配置读取当前 channel 的基础参数（唯一来源，供 transport / resolve 等复用） */
+export function getParamsDefaults(): IMsgParams {
+  const ch = (getOpenClawConfig()?.channels?.["dcgchat-test"] as DcgchatConfig | undefined) ?? {}
+  return {
+    userId: Number(ch.userId ?? 0),
+    botToken: ch.botToken ?? '',
+    sessionId: '',
+    messageId: '',
+    domainId: String(ch.domainId ?? '1000'),
+    appId: String(ch.appId ?? '100'),
+    botId: '',
+    agentId: '',
+    sessionKey: ''
+  }
+}
+
+export function resolveParamsMessage(params: Partial<IMsgParams>): IMsgParams {
+  const defaults = getParamsDefaults()
+  return {
+    userId: Number(params.userId ?? defaults.userId),
+    botToken: params.botToken ?? defaults.botToken,
+    sessionId: params.sessionId ?? defaults.sessionId,
+    messageId: params.messageId ?? defaults.messageId,
+    domainId: String(params.domainId ?? defaults.domainId),
+    appId: String(params.appId ?? defaults.appId),
+    botId: params.botId ?? defaults.botId,
+    agentId: params.agentId ?? defaults.agentId,
+    sessionKey: params.sessionKey ?? defaults.sessionKey
+  }
+}
+
+/**
+ * 统一取值入口：显式 sessionKey，或回落到当前会话；再与配置缺省 merge，保证字段完整。
+ */
+export function getEffectiveMsgParams(sessionKey?: string): IMsgParams {
+  const key = sessionKey ?? currentSessionKey
+  const stored = key ? paramsMessageMap.get(key) : undefined
+  return stored ? resolveParamsMessage(stored) : getParamsDefaults()
+}
+
+export function setParamsMessage(sessionKey: string, params: Partial<IMsgParams>) {
+  if (!sessionKey) return
+  currentSessionKey = sessionKey
+  paramsMessageMap.set(sessionKey, resolveParamsMessage({ ...params, sessionKey }))
+}
+
+export function getParamsMessage(sessionKey: string): IMsgParams | undefined {
+  return paramsMessageMap.get(sessionKey)
+}
+
+export function getCurrentSessionKey(): string | null {
+  return currentSessionKey
+}