@dcrays/dcgchat-test 0.2.34 → 0.3.0

package/index.ts

@@ -4,6 +4,7 @@ import { dcgchatPlugin } from './src/channel.js'
 import { setDcgchatRuntime, setWorkspaceDir } from './src/utils/global.js'
 import { monitoringToolMessage } from './src/tool.js'
 import { setOpenClawConfig } from './src/utils/global.js'
+import { startDcgchatGatewaySocket } from './src/gateway/socket.js'
 
 const plugin = {
   id: "dcgchat-test",
@@ -15,6 +16,7 @@ const plugin = {
 
     monitoringToolMessage(api)
     setOpenClawConfig(api.config)
+    startDcgchatGatewaySocket()
     api.registerChannel({ plugin: dcgchatPlugin })
     setWorkspaceDir(api.config?.agents?.defaults?.workspace)
     api.registerTool((ctx) => {

package/package.json

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

package/src/bot.ts

@@ -3,13 +3,21 @@ import path from 'node:path'
 import type { ReplyPayload } from 'openclaw/plugin-sdk'
 import { createReplyPrefixContext } from 'openclaw/plugin-sdk'
 import type { InboundMessage } from './types.js'
-import { clearSentMediaKeys, getDcgchatRuntime, getOpenClawConfig, getWorkspaceDir, setMsgStatus } from './utils/global.js'
+import {
+  clearSentMediaKeys,
+  getDcgchatRuntime,
+  getOpenClawConfig,
+  getWorkspaceDir,
+  setMsgParamsSessionKey,
+  setMsgStatus
+} from './utils/global.js'
 import { resolveAccount, sendDcgchatMedia } from './channel.js'
 import { generateSignUrl } from './request/api.js'
 import { extractMobookFiles } from './utils/searchFile.js'
 import { createMsgContext, sendChunk, sendFinal, sendText as sendTextMsg, sendError, sendText } from './transport.js'
 import { dcgLogger } from './utils/log.js'
 import { channelInfo, systemCommand, interruptCommand, ENV } from './utils/constant.js'
+import { sendMessageToGateway } from './gateway/socket.js'
 
 type MediaInfo = {
   path: string
@@ -23,16 +31,16 @@ type TFileInfo = { name: string; url: string }
 const mediaMaxBytes = 300 * 1024 * 1024
 
 /** Active LLM generation abort controllers, keyed by conversationId */
-const activeGenerations = new Map<string, AbortController>()
+// const activeGenerations = new Map<string, AbortController>()
 
-/** Abort an in-progress LLM generation for a given conversationId */
-export function abortMobookappGeneration(conversationId: string): void {
-  const ctrl = activeGenerations.get(conversationId)
-  if (ctrl) {
-    ctrl.abort()
-    activeGenerations.delete(conversationId)
-  }
-}
+// /** Abort an in-progress LLM generation for a given conversationId */
+// export function abortMobookappGeneration(conversationId: string): void {
+//   const ctrl = activeGenerations.get(conversationId)
+//   if (ctrl) {
+//     ctrl.abort()
+//     activeGenerations.delete(conversationId)
+//   }
+// }
 
 /**
  * Extract agentId from conversation_id formatted as "agentId::suffix".
@@ -154,6 +162,8 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     const core = getDcgchatRuntime()
 
     const conversationId = msg.content.session_id?.trim()
+    const agentId = msg.content.agent_id?.trim()
+    const realMobook = msg.content.real_mobook?.toString().trim()
 
     const route = core.channel.routing.resolveAgentRoute({
       cfg: config,
@@ -165,20 +175,20 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     // If conversation_id encodes an agentId prefix ("agentId::suffix"), override the route.
     const embeddedAgentId = extractAgentIdFromConversationId(conversationId)
     const effectiveAgentId = embeddedAgentId ?? route.agentId
-    const effectiveSessionKey = embeddedAgentId
-      ? `agent:${embeddedAgentId}:mobook:direct:${conversationId}`.toLowerCase()
-      : route.sessionKey
+    const effectiveSessionKey =
+      realMobook === '1' ? route.sessionKey : `agent:main:mobook:direct:${agentId}:${conversationId}`.toLowerCase()
+    setMsgParamsSessionKey(effectiveSessionKey)
 
     const agentEntry =
       effectiveAgentId && effectiveAgentId !== 'main' ? config.agents?.list?.find((a) => a.id === effectiveAgentId) : undefined
     const agentDisplayName = agentEntry?.name ?? (effectiveAgentId && effectiveAgentId !== 'main' ? effectiveAgentId : undefined)
 
     // Abort any existing generation for this conversation, then start a new one
-    const existingCtrl = activeGenerations.get(conversationId)
-    if (existingCtrl) existingCtrl.abort()
-    const genCtrl = new AbortController()
-    const genSignal = genCtrl.signal
-    activeGenerations.set(conversationId, genCtrl)
+    // const existingCtrl = activeGenerations.get(conversationId)
+    // if (existingCtrl) existingCtrl.abort()
+    // const genCtrl = new AbortController()
+    // const genSignal = genCtrl.signal
+    // activeGenerations.set(conversationId, genCtrl)
 
     // 处理用户上传的文件
     const files = msg.content.files ?? []
@@ -254,7 +264,6 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       }
     })
 
-    let wasAborted = false
     try {
       if (systemCommand.includes(text?.trim())) {
         dcgLogger(`dispatching /new`)
@@ -269,8 +278,14 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         })
       } else if (interruptCommand.includes(text?.trim())) {
         dcgLogger(`interrupt command: ${text}`)
-        abortMobookappGeneration(conversationId)
-        safeSendFinal()
+        // abortMobookappGeneration(conversationId)
+        sendMessageToGateway(
+          JSON.stringify({
+            method: 'chat.abort',
+            params: { sessionKey: effectiveSessionKey }
+          })
+        )
+        sendFinal(msgCtx)
         return
       } else {
         dcgLogger(`dispatching to agent (session=${route.sessionKey})`)
@@ -280,7 +295,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
           dispatcher,
           replyOptions: {
             ...replyOptions,
-            abortSignal: genSignal,
+            // abortSignal: genSignal,
             onModelSelected: prefixContext.onModelSelected,
             onPartialReply: async (payload: ReplyPayload) => {
               // Accumulate full text
@@ -311,19 +326,19 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         })
       }
     } catch (err: unknown) {
-      if (genSignal.aborted) {
-        wasAborted = true
-        dcgLogger(` generation aborted for conversationId=${conversationId}`)
-      } else if (err instanceof Error && err.name === 'AbortError') {
-        wasAborted = true
-        dcgLogger(` generation aborted for conversationId=${conversationId}`)
-      } else {
-        dcgLogger(` dispatchReplyFromConfig error: ${String(err)}`, 'error')
-      }
+      // if (genSignal.aborted) {
+      //   wasAborted = true
+      //   dcgLogger(` generation aborted for conversationId=${conversationId}`)
+      // } else if (err instanceof Error && err.name === 'AbortError') {
+      //   wasAborted = true
+      //   dcgLogger(` generation aborted for conversationId=${conversationId}`)
+      // } else {
+      //   dcgLogger(` dispatchReplyFromConfig error: ${String(err)}`, 'error')
+      // }
     } finally {
-      if (activeGenerations.get(conversationId) === genCtrl) {
-        activeGenerations.delete(conversationId)
-      }
+      // if (activeGenerations.get(conversationId) === genCtrl) {
+      //   activeGenerations.delete(conversationId)
+      // }
     }
     try {
       markRunComplete()

package/src/channel.ts

@@ -31,7 +31,7 @@ export async function sendDcgchatMedia(opts: DcgchatMediaSendOptions): Promise<v
   const fileName = mediaUrl?.split(/[\\/]/).pop() || ''
 
   try {
-    const url = opts.mediaUrl ? await ossUpload(opts.mediaUrl, msgCtx.botToken) : ''
+    const url = opts.mediaUrl ? await ossUpload(opts.mediaUrl, msgCtx.botToken, 1) : ''
     wsSendRaw(msgCtx, {
       response: opts.text ?? '',
       files: [{ url, name: fileName }]

package/src/cron.ts

@@ -0,0 +1,125 @@
+import path from 'node:path'
+import fs from 'node:fs'
+import crypto from 'node:crypto'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+import type { IMsgParams } from './types.js'
+import { DcgchatMsgContext, sendEventMessage } from './transport.js'
+import { getMsgParams, getWorkspaceDir } from './utils/global.js'
+import { ossUpload } from './request/oss.js'
+import { dcgLogger } from './utils/log.js'
+import { sendMessageToGateway } from './gateway/socket.js'
+
+export function getCronJobsPath(): string {
+  const workspaceDir = getWorkspaceDir()
+  const cronDir = workspaceDir.replace('workspace', 'cron')
+  return path.join(cronDir, 'jobs.json')
+}
+
+function msgParamsToCtx(p: IMsgParams): DcgchatMsgContext | null {
+  if (!p?.token) return null
+  return {
+    userId: p.userId,
+    botToken: p.token,
+    domainId: p.domainId,
+    appId: p.appId,
+    botId: p.botId,
+    agentId: p.agentId,
+    sessionId: p.sessionId,
+    messageId: p.messageId
+  }
+}
+
+const CRON_UPLOAD_DEBOUNCE_MS = 30_000
+
+/** 待合并的上传上下文（短时间内多次调用只保留最后一次） */
+let pendingCronUploadCtx: DcgchatMsgContext | null = null
+let cronUploadFlushTimer: ReturnType<typeof setTimeout> | null = null
+
+async function runCronJobsUpload(msgCtx: DcgchatMsgContext): Promise<void> {
+  const jobPath = getCronJobsPath()
+  if (fs.existsSync(jobPath)) {
+    try {
+      const url = await ossUpload(jobPath, msgCtx.botToken, 0)
+      dcgLogger(`定时任务创建成功: ${url}`)
+      sendEventMessage(msgCtx, url)
+    } catch (error) {
+      dcgLogger(`${jobPath} upload failed: ${error}`, 'error')
+    }
+  } else {
+    dcgLogger(`${jobPath} not found`, 'error')
+  }
+}
+
+function flushCronUploadQueue(): void {
+  cronUploadFlushTimer = null
+  const ctx = pendingCronUploadCtx
+  pendingCronUploadCtx = null
+  if (!ctx) return
+  void runCronJobsUpload(ctx)
+}
+
+/**
+ * 将 jobs.json 同步到 OSS 并推送事件。30s 内多次调用合并为一次上传；定时触发后清空待处理项，避免重复执行。
+ * @param msgCtx 可选；省略时使用当前 getMsgParams() 快照
+ */
+export function sendDcgchatCron(): void {
+  const ctx = msgParamsToCtx(getMsgParams() as IMsgParams)
+  if (!ctx) {
+    dcgLogger('sendDcgchatCron: no message context (missing token / params)', 'error')
+    return
+  }
+  pendingCronUploadCtx = ctx
+  if (cronUploadFlushTimer !== null) {
+    clearTimeout(cronUploadFlushTimer)
+  }
+  cronUploadFlushTimer = setTimeout(flushCronUploadQueue, 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) => {
+  const id = jobId?.trim()
+  if (!id) {
+    dcgLogger('onRemoveCronJob: empty jobId', 'error')
+    return
+  }
+  sendMessageToGateway(JSON.stringify({ method: 'cron.update', jobId }))
+}
+export const updateCronJobSessionKey = async (jobId: string) => {
+  const id = jobId?.trim()
+  if (!id) {
+    dcgLogger('onRemoveCronJob: empty jobId', 'error')
+    return
+  }
+  const params = getMsgParams()
+  sendMessageToGateway(JSON.stringify({ method: 'cron.update', params: { id: jobId, patch: { sessionKey: params.sessionKey } } }))
+}

package/src/gateway/index.ts

@@ -0,0 +1,458 @@
+// Gateway connection handler - connects to local OpenClaw gateway
+import { WebSocket } from 'ws'
+import crypto from 'crypto'
+import { deriveDeviceIdFromPublicKey, publicKeyRawBase64UrlFromPem, buildDeviceAuthPayloadV3, signDevicePayload } from './security.js'
+import { dcgLogger } from '../utils/log.js'
+import { sendDcgchatCron, updateCronJobSessionKey } from '../cron.js'
+
+export interface GatewayEvent {
+  type: string
+  payload?: Record<string, unknown>
+  seq?: number
+}
+
+export interface GatewayHelloOk {
+  server: {
+    connId: string
+  }
+  features: {
+    methods: string[]
+    events: string[]
+  }
+  policy?: {
+    tickIntervalMs?: number
+  }
+  auth?: {
+    deviceToken?: string
+    role?: string
+    scopes?: string[]
+  }
+}
+
+export interface GatewayResponse {
+  type: 'res'
+  id: string
+  ok: boolean
+  /** 多数 RPC 成功时的返回值 */
+  result?: unknown
+  /** connect 及部分响应使用 payload（见 docs/gateway/protocol.md） */
+  payload?: unknown
+  error?: {
+    code: string
+    message: string
+    details?: Record<string, unknown>
+  }
+}
+
+export interface GatewayEventFrame {
+  type: 'event'
+  event: string
+  payload?: Record<string, unknown>
+  seq?: number
+}
+
+export interface GatewayHelloOkFrame {
+  type: 'hello-ok'
+  server: {
+    connId: string
+  }
+  features: {
+    methods: string[]
+    events: string[]
+  }
+  policy?: {
+    tickIntervalMs?: number
+  }
+}
+
+// Union of all possible gateway messages
+export type GatewayMessage = GatewayEventFrame | GatewayResponse | GatewayHelloOkFrame
+
+export interface GatewayConfig {
+  url: string
+  token: string
+  role: string
+  scopes: string[]
+  reconnectInterval?: number
+  maxReconnectAttempts?: number
+}
+
+/**
+ * Gateway connection handler
+ */
+export class GatewayConnection {
+  private ws: WebSocket | null = null
+  private config: Required<GatewayConfig>
+  private deviceId: string
+  private privateKeyPem: string
+  private publicKeyB64Url: string
+  private connected: boolean = false
+  private connId: string | null = null
+  /** 服务端 connect.challenge 提供的 nonce，须与签名载荷一致 */
+  private connectChallengeNonce: string | null = null
+  private connectSent: boolean = false
+  private messageHandlers: Map<string, (response: GatewayResponse) => void> = new Map()
+  private eventHandlers: Set<(event: GatewayEvent) => void> = new Set()
+
+  constructor(config: GatewayConfig) {
+    this.config = {
+      url: config.url,
+      token: config.token,
+      role: config.role || 'operator',
+      scopes: config.scopes || ['operator.admin'],
+      reconnectInterval: config.reconnectInterval || 5000,
+      maxReconnectAttempts: config.maxReconnectAttempts || 10
+    }
+
+    const identity = this.loadOrCreateDeviceIdentity()
+    // 必须与公钥指纹一致（deriveDeviceIdFromPublicKey），不可用随机 UUID
+    this.deviceId = identity.deviceId
+    this.privateKeyPem = identity.privateKeyPem
+    this.publicKeyB64Url = identity.publicKeyB64Url
+  }
+
+  private loadOrCreateDeviceIdentity() {
+    const fs = require('fs')
+    const path = require('path')
+    const stateDir = path.join(process.cwd(), '.state')
+    const deviceFile = path.join(stateDir, 'device.json')
+
+    // Try to load existing identity
+    if (fs.existsSync(deviceFile)) {
+      const stored = JSON.parse(fs.readFileSync(deviceFile, 'utf8'))
+      if (stored.deviceId && stored.publicKeyPem && stored.privateKeyPem) {
+        const derivedId = deriveDeviceIdFromPublicKey(stored.publicKeyPem)
+        const deviceId = derivedId !== stored.deviceId ? derivedId : stored.deviceId
+        if (derivedId !== stored.deviceId) {
+          try {
+            fs.writeFileSync(deviceFile, JSON.stringify({ ...stored, deviceId: derivedId }, null, 2))
+          } catch {
+            /* keep in-memory fixed id only */
+          }
+        }
+        return {
+          deviceId,
+          publicKeyPem: stored.publicKeyPem,
+          privateKeyPem: stored.privateKeyPem,
+          publicKeyB64Url: publicKeyRawBase64UrlFromPem(stored.publicKeyPem)
+        }
+      }
+    }
+
+    // Create new identity
+    const keyPair = crypto.generateKeyPairSync('ed25519')
+    const publicKeyPem = keyPair.publicKey.export({ type: 'spki', format: 'pem' }).toString()
+    const privateKeyPem = keyPair.privateKey.export({ type: 'pkcs8', format: 'pem' }).toString()
+    const deviceId = deriveDeviceIdFromPublicKey(publicKeyPem)
+    const publicKeyB64Url = publicKeyRawBase64UrlFromPem(publicKeyPem)
+
+    // Ensure directory exists
+    if (!fs.existsSync(stateDir)) {
+      fs.mkdirSync(stateDir, { recursive: true })
+    }
+
+    // Save identity
+    fs.writeFileSync(
+      deviceFile,
+      JSON.stringify(
+        {
+          version: 1,
+          deviceId,
+          publicKeyPem,
+          privateKeyPem,
+          createdAtMs: Date.now()
+        },
+        null,
+        2
+      )
+    )
+    fs.chmodSync(deviceFile, 0o600)
+
+    return { deviceId, publicKeyPem, privateKeyPem, publicKeyB64Url }
+  }
+
+  /**
+   * Connect to the gateway
+   */
+  async connect(): Promise<GatewayHelloOk> {
+    return new Promise((resolve, reject) => {
+      this.connectChallengeNonce = null
+      this.connectSent = false
+      this.ws = new WebSocket(this.config.url)
+
+      let handshakeSettled = false
+      const finishHandshake = (fn: () => void) => {
+        if (handshakeSettled) return
+        handshakeSettled = true
+        clearTimeout(timeout)
+        fn()
+      }
+
+      const timeout = setTimeout(() => {
+        finishHandshake(() => reject(new Error('Gateway connection timeout')))
+      }, 15000)
+
+      this.ws.on('open', () => {
+        dcgLogger('Gateway connection opened（等待 connect.challenge）')
+      })
+
+      this.ws.on('message', (data) => {
+        try {
+          const msg = JSON.parse(data.toString())
+          this.handleMessage(
+            msg,
+            (hello) => finishHandshake(() => resolve(hello)),
+            (err) => finishHandshake(() => reject(err)),
+            timeout
+          )
+        } catch (err) {
+          dcgLogger(`[Gateway] 解析消息失败: ${err}`, 'error')
+        }
+      })
+
+      this.ws.on('close', () => {
+        this.connected = false
+        finishHandshake(() => reject(new Error('Gateway 在握手完成前关闭了连接')))
+      })
+
+      this.ws.on('error', (err) => {
+        console.log('🚀 ~ GatewayConnection ~ connect ~ err:', err)
+        finishHandshake(() => reject(err))
+      })
+    })
+  }
+
+  /**
+   * Send initial connect request
+   */
+  private sendConnect(): void {
+    if (this.connectSent) return
+    const nonce = this.connectChallengeNonce?.trim() ?? ''
+    if (!nonce) return
+
+    this.connectSent = true
+    const signedAtMs = Date.now()
+    const platform = process.platform
+
+    const payload = buildDeviceAuthPayloadV3({
+      deviceId: this.deviceId,
+      clientId: 'gateway-client',
+      clientMode: 'backend',
+      role: this.config.role,
+      scopes: this.config.scopes,
+      signedAtMs,
+      token: this.config.token,
+      nonce,
+      platform,
+      deviceFamily: ''
+    })
+
+    const signature = signDevicePayload(this.privateKeyPem, payload)
+
+    this.ws?.send(
+      JSON.stringify({
+        type: 'req',
+        id: '1',
+        method: 'connect',
+        params: {
+          minProtocol: 3,
+          maxProtocol: 3,
+          client: {
+            id: 'gateway-client',
+            version: '1.0.0',
+            platform,
+            mode: 'backend'
+          },
+          auth: { token: this.config.token },
+          role: this.config.role,
+          scopes: this.config.scopes,
+          device: {
+            id: this.deviceId,
+            publicKey: this.publicKeyB64Url,
+            signature,
+            signedAt: signedAtMs,
+            nonce
+          }
+        }
+      })
+    )
+  }
+
+  /**
+   * Handle incoming messages
+   */
+  private mapHelloPayloadToHelloOk(payload: Record<string, unknown>): GatewayHelloOk {
+    const serverRaw = payload.server as Record<string, unknown> | undefined
+    const featuresRaw = payload.features as Record<string, unknown> | undefined
+    return {
+      server: { connId: typeof serverRaw?.connId === 'string' ? serverRaw.connId : '' },
+      features: {
+        methods: Array.isArray(featuresRaw?.methods) ? (featuresRaw.methods as string[]) : [],
+        events: Array.isArray(featuresRaw?.events) ? (featuresRaw.events as string[]) : []
+      },
+      policy: payload.policy as GatewayHelloOk['policy'],
+      auth: payload.auth as GatewayHelloOk['auth']
+    }
+  }
+
+  private handleMessage(
+    msg: Record<string, any>,
+    resolveHello: (helloOk: GatewayHelloOk) => void,
+    rejectHello: (err: Error) => void,
+    timeout: NodeJS.Timeout
+  ): void {
+    const msgType = msg.type as string | undefined
+
+    if (msg.type === 'event' && msg.event === 'connect.challenge') {
+      const payload = msg.payload as Record<string, unknown> | undefined
+      const nonce = typeof payload?.nonce === 'string' ? payload.nonce.trim() : ''
+      if (!nonce) {
+        rejectHello(new Error('connect.challenge 缺少 nonce'))
+        return
+      }
+      this.connectChallengeNonce = nonce
+      this.sendConnect()
+      return
+    }
+
+    // 协议 v3：握手成功为 type:"res" + payload.type:"hello-ok"（见 openclaw docs/gateway/protocol.md）
+    if (msg.type === 'res' && !this.connected) {
+      const ok = msg.ok === true
+      const inner = msg.payload as Record<string, unknown> | undefined
+      if (ok && inner && inner.type === 'hello-ok') {
+        this.connected = true
+        const serverRaw = inner.server as Record<string, unknown> | undefined
+        this.connId = typeof serverRaw?.connId === 'string' ? serverRaw.connId : null
+        clearTimeout(timeout)
+        dcgLogger(`[Gateway] 已连接 connId=${this.connId ?? '(none)'}`)
+        resolveHello(this.mapHelloPayloadToHelloOk(inner))
+        return
+      }
+      if (msg.ok === false) {
+        const errObj = msg.error as Record<string, unknown> | undefined
+        const message = (typeof errObj?.message === 'string' && errObj.message) || 'Gateway connect 被拒绝'
+        clearTimeout(timeout)
+        rejectHello(new Error(message))
+        return
+      }
+    }
+
+    // 旧式或其它实现：顶层 hello-ok
+    if (msgType === 'hello-ok' || (!msgType && msg.server)) {
+      this.connected = true
+      this.connId = ((msg.server as Record<string, unknown>)?.connId as string) || null
+      clearTimeout(timeout)
+      dcgLogger(`[Gateway] 已连接 connId=${this.connId ?? '(none)'}`)
+      resolveHello(msg as unknown as GatewayHelloOk)
+      return
+    }
+    if (msg.type === 'res') {
+      const handler = this.messageHandlers.get(msg.id as string)
+      if (handler) {
+        this.messageHandlers.delete(msg.id as string)
+        handler(msg as unknown as GatewayResponse)
+      }
+      return
+    }
+
+    if (msg.type === 'event') {
+      if (msg.event === 'cron') {
+        dcgLogger(`[Gateway] 收到事件: ${JSON.stringify(msg)}`)
+        if (msg.payload?.action === 'added') {
+          updateCronJobSessionKey(msg.payload?.jobId as string)
+        }
+        if (msg.payload?.action === 'updated') {
+          sendDcgchatCron()
+        }
+      }
+      const event: GatewayEvent = {
+        type: msg.event as string,
+        payload: msg.payload as Record<string, unknown> | undefined,
+        seq: msg.seq as number | undefined
+      }
+      this.eventHandlers.forEach((h) => h(event))
+    }
+  }
+
+  /**
+   * Call a gateway method
+   */
+  async callMethod<T = unknown>(method: string, params: Record<string, unknown> = {}): Promise<T> {
+    const id = crypto.randomUUID()
+
+    return new Promise((resolve, reject) => {
+      if (!this.connected || !this.ws) {
+        reject(new Error('Not connected to gateway'))
+        return
+      }
+
+      const timeout = setTimeout(() => {
+        this.messageHandlers.delete(id)
+        reject(new Error('Method call timeout'))
+      }, 30000)
+
+      this.messageHandlers.set(id, (response) => {
+        clearTimeout(timeout)
+        if (response.ok) {
+          const body = response.result !== undefined ? response.result : (response as GatewayResponse).payload
+          resolve(body as T)
+        } else {
+          reject(new Error(response.error?.message || 'Method call failed'))
+        }
+      })
+
+      this.ws.send(
+        JSON.stringify({
+          type: 'req',
+          id,
+          method,
+          params
+        })
+      )
+    })
+  }
+
+  /**
+   * Register event handler
+   */
+  onEvent(handler: (event: GatewayEvent) => void): () => void {
+    this.eventHandlers.add(handler)
+    return () => this.eventHandlers.delete(handler)
+  }
+
+  /**
+   * Close connection
+   */
+  close(): void {
+    this.ws?.close(1000, 'Plugin stopped')
+    this.connected = false
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.connected
+  }
+
+  /**
+   * Get connection ID
+   */
+  getConnId(): string | null {
+    return this.connId
+  }
+
+  /**
+   * Get the WebSocket instance (for external use)
+   */
+  getWebSocket(): WebSocket | null {
+    return this.ws
+  }
+
+  /**
+   * Ping the gateway
+   */
+  ping(): void {
+    this.ws?.ping()
+  }
+}

package/src/gateway/security.ts

@@ -0,0 +1,101 @@
+// Security utilities for the tunnel plugin
+import crypto from 'crypto'
+import fs from 'fs'
+import jwt from 'jsonwebtoken'
+import { z } from 'zod'
+
+// ED25519 SubjectPublicKeyInfo prefix (must match openclaw gateway `ED25519_SPKI_PREFIX`)
+const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex')
+
+/**
+ * Raw 32-byte Ed25519 public key bytes from PEM (same rules as openclaw `derivePublicKeyRaw`).
+ */
+export function derivePublicKeyRawFromPem(publicKeyPem: string): Buffer {
+  const spki = crypto.createPublicKey(publicKeyPem).export({ type: 'spki', format: 'der' }) as Buffer
+  if (
+    spki.length === ED25519_SPKI_PREFIX.length + 32 &&
+    spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)
+  ) {
+    return spki.subarray(ED25519_SPKI_PREFIX.length)
+  }
+  return spki
+}
+
+/**
+ * Base64url encode (no padding)
+ */
+export function base64UrlEncode(buffer: Buffer): string {
+  return buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+/** Wire-format device public key (base64url of raw 32 bytes), matches gateway expectations. */
+export function publicKeyRawBase64UrlFromPem(publicKeyPem: string): string {
+  return base64UrlEncode(derivePublicKeyRawFromPem(publicKeyPem))
+}
+
+/**
+ * Derive device ID from ED25519 public key
+ * Device ID = sha256(rawPublicKey)
+ */
+export function deriveDeviceIdFromPublicKey(publicKeyPem: string): string {
+  const rawPublicKey = derivePublicKeyRawFromPem(publicKeyPem)
+  return crypto.createHash('sha256').update(rawPublicKey).digest('hex')
+}
+
+/**
+ * Sign device payload
+ */
+export function signDevicePayload(privateKeyPem: string, payload: string, encoding: 'base64' | 'base64url' = 'base64url'): string {
+  const key = crypto.createPrivateKey(privateKeyPem)
+  const sig = crypto.sign(null, Buffer.from(payload, 'utf8'), key)
+  return encoding === 'base64url' ? base64UrlEncode(sig) : sig.toString('base64')
+}
+function normalizeTrimmedMetadata(value: unknown): string {
+  if (typeof value !== 'string') return ''
+  const trimmed = value.trim()
+  return trimmed ? trimmed : ''
+}
+
+function toLowerAscii(input: string): string {
+  return input.replace(/[A-Z]/g, (char) => String.fromCharCode(char.charCodeAt(0) + 32))
+}
+
+function normalizeDeviceMetadataForAuth(value: unknown): string {
+  const trimmed = normalizeTrimmedMetadata(value)
+  if (!trimmed) return ''
+  return toLowerAscii(trimmed)
+}
+
+/**
+ * Device authentication payload v3（与 openclaw `buildDeviceAuthPayloadV3` 一致）
+ */
+export function buildDeviceAuthPayloadV3(params: {
+  deviceId: string
+  clientId: string
+  clientMode: string
+  role: string
+  scopes: string[]
+  signedAtMs: number
+  token: string
+  nonce: string
+  platform?: string
+  deviceFamily?: string
+}): string {
+  const scopes = params.scopes.join(',')
+  const token = params.token ?? ''
+  const platform = normalizeDeviceMetadataForAuth(params.platform ?? '')
+  const deviceFamily = normalizeDeviceMetadataForAuth(params.deviceFamily ?? '')
+  return [
+    'v3',
+    params.deviceId,
+    params.clientId,
+    params.clientMode,
+    params.role,
+    scopes,
+    String(params.signedAtMs),
+    token,
+    params.nonce,
+    platform,
+    deviceFamily
+  ].join('|')
+}

package/src/gateway/socket.ts

@@ -0,0 +1,271 @@
+import type { OpenClawConfig } from 'openclaw/plugin-sdk'
+import { getOpenClawConfig } from '../utils/global.js'
+import { GatewayConnection, type GatewayConfig } from './index.js'
+import { dcgLogger } from '../utils/log.js'
+
+/** 与 gateway-methods 中 registerGatewayMethod 名称一致（供引用） */
+export const DCGCHAT_GATEWAY_METHODS = ['dcgchat.cron.status', 'dcgchat.cron.add', 'dcgchat.cron.list', 'dcgchat.cron.remove'] as const
+
+const PING_INTERVAL_MS = 30_000
+const RECONNECT_DELAY_MS = 5_000
+
+type OpenClawGatewaySection = {
+  port?: number
+  bind?: string
+  tls?: { enabled?: boolean }
+  auth?: { mode?: string; token?: string }
+  remote?: { url?: string }
+}
+
+function getGatewaySection(cfg: OpenClawConfig): OpenClawGatewaySection | undefined {
+  return (cfg as OpenClawConfig & { gateway?: OpenClawGatewaySection }).gateway
+}
+
+/**
+ * 从 OpenClaw 配置解析本地/远程 Gateway WebSocket 与 token。
+ * 可用环境变量覆盖：OPENCLAW_GATEWAY_URL、OPENCLAW_GATEWAY_TOKEN。
+ */
+export function resolveGatewayClientConfig(cfg: OpenClawConfig | null): GatewayConfig {
+  if (!cfg) {
+    throw new Error('OpenClaw 配置未初始化（需先完成插件 register）')
+  }
+  const g = getGatewaySection(cfg)
+  const token = process.env.OPENCLAW_GATEWAY_TOKEN || g?.auth?.token || ''
+  if (!token) {
+    throw new Error('缺少 Gateway token：请在 openclaw.json 的 gateway.auth.token 设置，或设置环境变量 OPENCLAW_GATEWAY_TOKEN')
+  }
+
+  const scheme = g?.tls?.enabled === true ? 'wss' : 'ws'
+  const url = process.env.OPENCLAW_GATEWAY_URL || g?.remote?.url || `${scheme}://127.0.0.1:${g?.port ?? 18789}`
+
+  return {
+    url,
+    token,
+    role: 'operator',
+    scopes: ['operator.admin']
+  }
+}
+
+function resolveConfigSafe(): GatewayConfig | null {
+  try {
+    return resolveGatewayClientConfig(getOpenClawConfig())
+  } catch (e) {
+    dcgLogger(`Gateway 持久连接未启动: ${e}`, 'error')
+    return null
+  }
+}
+
+/**
+ * 解析要调用的 Gateway 方法。
+ * - 纯文本：整段为 method，params 为空
+ * - JSON：`{ "method": "dcgchat.cron.list", "params": { "includeDisabled": true } }`
+ */
+export function parseGatewayRpcMessage(message: string): { method: string; params: Record<string, unknown> } {
+  const trimmed = message.trim()
+  if (!trimmed) {
+    throw new Error('message 为空')
+  }
+  if (!trimmed.startsWith('{')) {
+    return { method: trimmed, params: {} }
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(trimmed)
+  } catch {
+    throw new Error('message 不是合法 JSON')
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('message JSON 必须是对象')
+  }
+  const o = parsed as Record<string, unknown>
+  if (typeof o.method !== 'string' || !o.method.trim()) {
+    throw new Error('message JSON 须包含非空字符串字段 method')
+  }
+  if (o.params != null && (typeof o.params !== 'object' || Array.isArray(o.params))) {
+    throw new Error('message JSON 的 params 必须是对象')
+  }
+  return {
+    method: o.method.trim(),
+    params: (o.params as Record<string, unknown>) || {}
+  }
+}
+
+/** 任意 method + params，由调用方决定载荷 */
+export type GatewayRpcPayload = {
+  method: string
+  params?: Record<string, unknown>
+}
+
+let persistentConn: GatewayConnection | null = null
+let pingTimer: ReturnType<typeof setInterval> | null = null
+let reconnectTimer: ReturnType<typeof setTimeout> | null = null
+let connectInFlight = false
+let socketStopped = true
+/** 用于忽略「已被替换的旧连接」上的 close/error */
+let socketGeneration = 0
+
+function clearPingTimer(): void {
+  if (pingTimer) {
+    clearInterval(pingTimer)
+    pingTimer = null
+  }
+}
+
+function clearReconnectTimer(): void {
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer)
+    reconnectTimer = null
+  }
+}
+
+function startPingTimer(gw: GatewayConnection): void {
+  clearPingTimer()
+  pingTimer = setInterval(() => {
+    if (!gw.isConnected()) return
+    try {
+      gw.ping()
+    } catch (e) {
+      dcgLogger(`Gateway ping 失败: ${e}`, 'error')
+    }
+  }, PING_INTERVAL_MS)
+}
+
+function scheduleReconnect(): void {
+  if (socketStopped || reconnectTimer) return
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null
+    void connectPersistentGateway()
+  }, RECONNECT_DELAY_MS)
+}
+
+function attachSocketLifecycle(gw: GatewayConnection, generation: number): void {
+  const ws = gw.getWebSocket()
+  if (!ws) return
+
+  const onDown = () => {
+    if (generation !== socketGeneration) return
+    clearPingTimer()
+    if (persistentConn === gw) {
+      persistentConn = null
+    }
+    dcgLogger('Gateway WebSocket 已断开，将在 5s 后重连', 'error')
+    if (!socketStopped) {
+      scheduleReconnect()
+    }
+  }
+
+  ws.once('close', onDown)
+  ws.once('error', onDown)
+}
+
+async function connectPersistentGateway(): Promise<void> {
+  if (socketStopped || connectInFlight) return
+
+  const cfg = resolveConfigSafe()
+  if (!cfg) return
+
+  connectInFlight = true
+  try {
+    socketGeneration += 1
+    const generation = socketGeneration
+
+    if (persistentConn) {
+      try {
+        persistentConn.close()
+      } catch {
+        /* ignore */
+      }
+      persistentConn = null
+    }
+
+    const gw = new GatewayConnection(cfg)
+    await gw.connect()
+    if (socketStopped) {
+      try {
+        gw.close()
+      } catch {
+        /* ignore */
+      }
+      return
+    }
+    if (generation !== socketGeneration) {
+      try {
+        gw.close()
+      } catch {
+        /* ignore */
+      }
+      return
+    }
+    persistentConn = gw
+    attachSocketLifecycle(gw, generation)
+    startPingTimer(gw)
+    dcgLogger(`Gateway 持久连接成功 connId=${gw.getConnId() ?? '?'}`)
+  } catch (e) {
+    dcgLogger(`Gateway 连接失败11: ${e}`, 'error')
+    persistentConn = null
+    clearPingTimer()
+    if (!socketStopped) {
+      scheduleReconnect()
+    }
+  } finally {
+    connectInFlight = false
+  }
+}
+
+/**
+ * 插件 register 后调用：建立到 OpenClaw Gateway 的长连接，30s 一次 WebSocket ping，断线每 5s 重连。
+ */
+export function startDcgchatGatewaySocket(): void {
+  socketStopped = false
+  clearReconnectTimer()
+  setTimeout(() => {
+    void connectPersistentGateway()
+  }, 10000)
+}
+
+/**
+ * 停止长连接与重连（例如测试或显式下线）。
+ */
+export function stopDcgchatGatewaySocket(): void {
+  socketStopped = true
+  clearReconnectTimer()
+  clearPingTimer()
+  if (persistentConn) {
+    try {
+      persistentConn.close()
+    } catch {
+      /* ignore */
+    }
+    persistentConn = null
+  }
+}
+
+export function isDcgchatGatewaySocketConnected(): boolean {
+  return persistentConn?.isConnected() ?? false
+}
+
+/**
+ * 在已连接时调用 Gateway RPC；`params` 完全由调用方传入，不做固定结构。
+ */
+export async function callGatewayMethod<T = unknown>(method: string, params: Record<string, unknown> = {}): Promise<T> {
+  const gw = persistentConn
+  if (!gw?.isConnected()) {
+    throw new Error('Gateway 未连接（等待重连或检查配置）')
+  }
+  return gw.callMethod<T>(method, params)
+}
+
+/**
+ * 使用对象形式发送 RPC（推荐）。
+ */
+export async function sendGatewayRpc<T = unknown>(payload: GatewayRpcPayload): Promise<T> {
+  return callGatewayMethod<T>(payload.method, payload.params ?? {})
+}
+
+/**
+ * 兼容：字符串方法名，或 JSON 字符串 `{ method, params? }`。
+ */
+export async function sendMessageToGateway(message: string): Promise<unknown> {
+  const { method, params } = parseGatewayRpcMessage(message)
+  return callGatewayMethod(method, params)
+}

package/src/monitor.ts

@@ -8,6 +8,7 @@ import { setMsgParams, setMsgStatus } from './utils/global.js'
 import { installSkill, uninstallSkill } from './skill.js'
 import { dcgLogger } from './utils/log.js'
 import { ignoreToolCommand } from './utils/constant.js'
+import { onDisabledCronJob, onEnabledCronJob, onRemoveCronJob, onRunCronJob } from './cron.js'
 
 export type MonitorDcgchatOpts = {
   config?: ClawdbotConfig
@@ -145,19 +146,18 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
 
         await handleDcgchatMessage(msg, account.accountId)
       } else if (parsed.messageType == 'openclaw_bot_event') {
-        const { event_type, operation_type, skill_url, skill_code, skill_id, bot_token, websocket_trace_id } = parsed.content
-          ? parsed.content
-          : ({} as Record<string, any>)
-        const content = {
-          event_type,
-          operation_type,
-          skill_url,
-          skill_code,
-          skill_id,
-          bot_token,
-          websocket_trace_id
-        }
+        const { event_type, operation_type } = parsed.content ? parsed.content : ({} as Record<string, any>)
         if (event_type === 'skill') {
+          const { skill_url, skill_code, skill_id, bot_token, websocket_trace_id } = parsed.content
+          const content = {
+            event_type,
+            operation_type,
+            skill_url,
+            skill_code,
+            skill_id,
+            bot_token,
+            websocket_trace_id
+          }
           if (operation_type === 'install' || operation_type === 'enable' || operation_type === 'update') {
             installSkill({ path: skill_url, code: skill_code }, content)
           } else if (operation_type === 'remove' || operation_type === 'disable') {
@@ -165,6 +165,17 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
           } else {
             dcgLogger(`openclaw_bot_event unknown event_type: ${event_type}, ${data.toString()}`)
           }
+        } else if (event_type === 'cron') {
+          const { job_id } = parsed.content
+          if (operation_type === 'remove') {
+            await onRemoveCronJob(job_id)
+          } else if (operation_type === 'enable') {
+            await onEnabledCronJob(job_id)
+          } else if (operation_type === 'disable') {
+            await onDisabledCronJob(job_id)
+          } else if (operation_type === 'exec') {
+            await onRunCronJob(job_id)
+          }
         } else {
           dcgLogger(`openclaw_bot_event unknown operation_type: ${operation_type}, ${data.toString()}`)
         }

package/src/request/api.ts

@@ -3,18 +3,11 @@ import type { IStsToken, IStsTokenReq } from '../types.js'
 import { getUserTokenCache, setUserTokenCache } from './userInfo.js'
 import { dcgLogger } from '../utils/log.js'
 
-export const getStsToken = async (name: string, botToken: string) => {
+export const getStsToken = async (name: string, botToken: string, isPrivate: 1 | 0) => {
   // 确保 userToken 已缓存（如果未缓存会自动获取并缓存）
   await getUserToken(botToken)
 
-  const response = await post<IStsTokenReq, IStsToken>(
-    '/user/getStsToken',
-    {
-      sourceFileName: name,
-      isPrivate: 1
-    },
-    { botToken }
-  )
+  const response = await post<IStsTokenReq, IStsToken>('/user/getStsToken', { sourceFileName: name, isPrivate }, { botToken })
 
   if (!response || !response.data || !response.data.bucket) {
     throw new Error('获取 OSS 临时凭证失败')
@@ -27,11 +20,7 @@ export const generateSignUrl = async (file_url: string, botToken: string) => {
     // 确保 userToken 已缓存（如果未缓存会自动获取并缓存）
     await getUserToken(botToken)
 
-    const response = await post<any>(
-      '/user/generateSignUrl',
-      { loudPlatform: 0, fileName: file_url },
-      { botToken }
-    )
+    const response = await post<any>('/user/generateSignUrl', { loudPlatform: 0, fileName: file_url }, { botToken })
     if (response.code === 0 && response.data) {
       // @ts-ignore
       return response.data?.filePath
@@ -48,10 +37,7 @@ export const generateSignUrl = async (file_url: string, botToken: string) => {
  * @returns userToken
  */
 export const queryUserTokenByBotToken = async (botToken: string): Promise<string> => {
-  const response = await post<{ botToken: string }, { token: string }>(
-    '/organization/queryUserTokenByBotToken',
-    { botToken }
-  )
+  const response = await post<{ botToken: string }, { token: string }>('/organization/queryUserTokenByBotToken', { botToken })
 
   if (!response || !response.data || !response.data.token) {
     dcgLogger('获取绑定的用户信息失败', 'error')

package/src/request/oss.ts

@@ -22,11 +22,11 @@ async function toUploadContent(
   return { content: buf, fileName: input.name }
 }
 
-export const ossUpload = async (file: File | string | Buffer, botToken: string) => {
+export const ossUpload = async (file: File | string | Buffer, botToken: string, isPrivate: 0 | 1 = 1) => {
   await getUserToken(botToken)
 
   const { content, fileName } = await toUploadContent(file)
-  const data = await getStsToken(fileName, botToken)
+  const data = await getStsToken(fileName, botToken, isPrivate)
 
   const options: OSS.Options = {
     // 从STS服务获取的临时访问密钥（AccessKey ID和AccessKey Secret）。
@@ -50,8 +50,9 @@ export const ossUpload = async (file: File | string | Buffer, botToken: string)
     if (objectResult?.res?.status !== 200) {
       dcgLogger(`OSS 上传失败, ${objectResult?.res?.status}`)
     }
-    dcgLogger(JSON.stringify(objectResult))
-    return objectResult.name || objectResult.url
+    dcgLogger(`OSS 上传成功, ${objectResult.name || objectResult.url}`)
+    // const url = `${data.protocol || 'http'}://${data.bucket}.${data.endPoint}/${data.uploadDir}${data.ossFileKey}`
+    return isPrivate === 1 ? objectResult.name || objectResult.url : objectResult.url
   } catch (error) {
     dcgLogger(`OSS 上传失败: ${error}`, 'error')
   }

package/src/tool.ts

@@ -80,12 +80,12 @@ function sendToolCallMessage(text: string, toolCallId: string, isCover: number)
 
 export function monitoringToolMessage(api: OpenClawPluginApi) {
   for (const item of eventList) {
-    api.on(item.event as PluginHookName, (event: any) => {
+    api.on(item.event as PluginHookName, (event: any, args: any) => {
       const status = getMsgStatus()
       if (status === 'running') {
-        dcgLogger(`工具调用结果： ~ event:${item.event}`)
         if (['after_tool_call', 'before_tool_call'].includes(item.event)) {
           const { result: _result, ...rest } = event
+          dcgLogger(`工具调用结果： ~ event:${item.event} ~ params:${JSON.stringify(rest)}`)
           const text = JSON.stringify({
             type: item.event,
             specialIdentification: 'dcgchat_tool_call_special_identification',
@@ -95,7 +95,9 @@ export function monitoringToolMessage(api: OpenClawPluginApi) {
           })
           sendToolCallMessage(text, event.toolCallId || event.runId || Date.now().toString(), item.event === 'after_tool_call' ? 1 : 0)
         } else if (item.event) {
+          dcgLogger(`工具调用结果： ~ event:${item.event}`)
           if (item.event === 'llm_output') {
+            dcgLogger(`llm_output工具调用结果： ~ event:${JSON.stringify(event)}`)
             if (event.lastAssistant?.errorMessage === '429-账户额度耗尽') {
               const params = getMsgParams()
               const message = '您的积分已消耗完，您可以通过充值积分来继续使用'

package/src/transport.ts

@@ -106,3 +106,26 @@ export function sendText(ctx: DcgchatMsgContext, text: string, event?: Record<st
 export function sendError(ctx: DcgchatMsgContext, errorMsg: string): boolean {
   return wsSend(ctx, { response: `[错误] ${errorMsg}`, state: 'final' })
 }
+export function sendEventMessage(ctx: DcgchatMsgContext, url: string) {
+  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?: {
@@ -123,4 +124,5 @@ export interface IMsgParams {
   appId: string
   botId: string
   agentId: string
+  sessionKey: string
 }

package/src/utils/global.ts

@@ -76,6 +76,9 @@ export function setMsgParams(params: any) {
 export function getMsgParams() {
   return msgParams
 }
+export function setMsgParamsSessionKey(sessionKey: string) {
+  if (sessionKey) msgParams.sessionKey = sessionKey
+}
 
 let msgStatus: 'running' | 'finished' | '' = ''
 export function setMsgStatus(status: 'running' | 'finished' | '') {