@dcrays/dcgchat-test 0.6.10 → 0.6.12

package/src/gateway/socket.ts

@@ -0,0 +1,256 @@
+import type { OpenClawConfig } from 'openclaw/plugin-sdk'
+import { getDcgchatRuntime, getOpenClawConfig } from '../utils/global.js'
+import { GatewayConnection, type GatewayConfig } from './index.js'
+import { dcgLogger } from '../utils/log.js'
+import { openclawConfigLooksUsable } from '../utils/resolveRegisterConfig.js'
+import { WS_HEARTBEAT_INTERVAL_MS, WS_RECONNECT_DELAY_MS } from '../utils/constant.js'
+
+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']
+  }
+}
+/** register 尚未写入全局缓存时，回退到 runtime.loadConfig（与 registerFull 内解析方式一致） */
+function resolveOpenClawConfigForPersistentGateway(): OpenClawConfig | null {
+  const cached = getOpenClawConfig()
+  if (openclawConfigLooksUsable(cached)) return cached
+  try {
+    const fresh = getDcgchatRuntime().config.loadConfig() as OpenClawConfig
+    return openclawConfigLooksUsable(fresh) ? fresh : null
+  } catch {
+    return null
+  }
+}
+
+function resolveConfigSafe(): GatewayConfig | null {
+  try {
+    const cfg = resolveOpenClawConfigForPersistentGateway()
+    if (!cfg) {
+      dcgLogger('Gateway 持久连接未启动: 无可用 OpenClaw 配置（plugins.register 未完成或 loadConfig 失败）', 'error')
+      return null
+    }
+    return resolveGatewayClientConfig(cfg)
+  } catch (e) {
+    dcgLogger(`Gateway 持久连接未启动: ${e}`, 'error')
+    return null
+  }
+}
+
+/** 任意 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
+/** register 可能被调用多次，只保留一个「延迟首次连接」定时器，避免同一时刻触发两次 connect */
+let startupConnectTimer: 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')
+    }
+  }, WS_HEARTBEAT_INTERVAL_MS)
+}
+
+function scheduleReconnect(): void {
+  if (socketStopped || reconnectTimer) return
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null
+    void connectPersistentGateway()
+  }, WS_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) return
+  if (persistentConn?.isConnected()) return
+  if (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 连接失败: ${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()
+  if (startupConnectTimer != null) return
+  startupConnectTimer = setTimeout(() => {
+    startupConnectTimer = null
+    void connectPersistentGateway()
+  }, 0)
+}
+
+export function isDcgchatGatewaySocketConnected(): boolean {
+  return persistentConn?.isConnected() ?? false
+}
+
+/** `gateway_start` 等场景下，持久连接可能仍在异步 connect；轮询至连通或超时 */
+const DEFAULT_WAIT_GATEWAY_MS = 120_000
+const DEFAULT_WAIT_GATEWAY_POLL_MS = 150
+
+export async function waitForDcgchatGatewaySocketConnected(opts?: {
+  timeoutMs?: number
+  intervalMs?: number
+  signal?: AbortSignal
+}): Promise<boolean> {
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_WAIT_GATEWAY_MS
+  const intervalMs = opts?.intervalMs ?? DEFAULT_WAIT_GATEWAY_POLL_MS
+  const deadline = Date.now() + timeoutMs
+  for (;;) {
+    if (opts?.signal?.aborted) return false
+    if (isDcgchatGatewaySocketConnected()) return true
+    if (Date.now() >= deadline) return isDcgchatGatewaySocketConnected()
+    await new Promise<void>((r) => setTimeout(r, intervalMs))
+  }
+}
+
+/**
+ * 在已连接时调用 Gateway RPC；`params` 完全由调用方传入，不做固定结构。
+ */
+export async function callGatewayMethod<T = unknown>(
+  method: string,
+  params: Record<string, unknown> = {},
+  opts?: { timeoutMs?: number }
+): Promise<T> {
+  const gw = persistentConn
+  if (!gw?.isConnected()) {
+    throw new Error('Gateway 未连接（等待重连或检查配置）')
+  }
+  return gw.callMethod<T>(method, params, opts)
+}
+
+/**
+ * 使用对象形式发送 RPC。
+ */
+export async function sendGatewayRpc<T = unknown>(
+  payload: GatewayRpcPayload,
+  opts?: { timeoutMs?: number }
+): Promise<T> {
+  return callGatewayMethod<T>(payload.method, payload.params ?? {}, opts)
+}

package/src/monitor.ts

@@ -0,0 +1,269 @@
+import type { OpenClawConfig, RuntimeEnv } from 'openclaw/plugin-sdk'
+import WebSocket from 'ws'
+import { resolveAccount } from './channel/index.js'
+import type { ResolvedDcgchatAccount } from './types.js'
+import { setWsConnection, getOpenClawConfig, compressFields } from './utils/global.js'
+import { dcgLogger } from './utils/log.js'
+import { isWsOpen } from './transport.js'
+import { handleParsedWsMessage } from './utils/wsMessageHandler.js'
+import { WS_HEARTBEAT_INTERVAL_MS, WS_RECONNECT_DELAY_MS } from './utils/constant.js'
+
+export type MonitorDcgchatOpts = {
+  config?: OpenClawConfig
+  runtime?: RuntimeEnv
+  abortSignal?: AbortSignal
+  accountId?: string
+  statusSink?: (patch: {
+    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
+  }) => void
+}
+
+function buildConnectUrl(account: ResolvedDcgchatAccount): string {
+  const { wsUrl, botToken, userId, domainId, appId } = account
+  const url = new URL(wsUrl)
+  if (botToken) url.searchParams.set('bot_token', botToken)
+  if (userId) url.searchParams.set('_userId', userId)
+  url.searchParams.set('_domainId', domainId || '1000')
+  url.searchParams.set('_appId', appId || '100')
+  return url.toString()
+}
+
+export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<void> {
+  const { abortSignal, accountId } = opts
+
+  const config = getOpenClawConfig()
+  if (!config) {
+    dcgLogger('no OpenClaw config available', 'error')
+    return
+  }
+
+  const account = resolveAccount(config, accountId ?? 'default')
+
+  if (!account.wsUrl) {
+    dcgLogger(` wsUrl not configured`, 'error')
+    return
+  }
+
+  let shouldReconnect = true
+  let ws: WebSocket | null = null
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null
+  let heartbeatLogCounter = 0
+  let lastReportedStatus: 'connecting' | 'connected' | 'disconnected' | 'error' | '' = ''
+
+  const isOpenclawBotHeartbeat = (raw: WebSocket.RawData, parsedMsg: { messageType?: string }): boolean => {
+    if (parsedMsg?.messageType === 'openclaw_bot_heartbeat') return true
+    if (typeof raw === 'object' && raw !== null && !Buffer.isBuffer(raw)) {
+      return (raw as { messageType?: string }).messageType === 'openclaw_bot_heartbeat'
+    }
+    return false
+  }
+
+  const stopHeartbeat = () => {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer)
+      heartbeatTimer = null
+    }
+  }
+
+  const reportChannelStatus = (status: 'connecting' | 'connected' | 'disconnected' | 'error', extra?: Record<string, unknown>) => {
+    if (lastReportedStatus === status) return
+    lastReportedStatus = status
+    if (!opts.statusSink) return
+
+    if (status === 'connecting') {
+      opts.statusSink({
+        running: true,
+        lastError: null,
+        lastDisconnect: null
+      })
+      return
+    }
+
+    if (status === 'connected') {
+      opts.statusSink({
+        running: true,
+        connected: true,
+        lastConnectedAt: Date.now(),
+        lastError: null,
+        lastDisconnect: null
+      })
+      return
+    }
+
+    if (status === 'disconnected') {
+      opts.statusSink({
+        connected: false,
+        lastDisconnect: {
+          at: Date.now(),
+          status: typeof extra?.code === 'number' ? extra.code : undefined,
+          error: typeof extra?.reason === 'string' ? extra.reason : undefined
+        }
+      })
+      return
+    }
+
+    opts.statusSink({
+      connected: false,
+      lastError: typeof extra?.error === 'string' ? extra.error : String(extra?.error ?? 'WebSocket error')
+    })
+  }
+
+  function onHeartbeat() {
+    if (isWsOpen()) {
+      const heartbeat = {
+        messageType: 'openclaw_bot_heartbeat',
+        _userId: Number(account.userId) || 0,
+        source: 'client',
+        content: {
+          bot_token: account.botToken,
+          status: '1'
+        }
+      }
+      ws?.send(JSON.stringify(heartbeat))
+    }
+  }
+  const startHeartbeat = () => {
+    stopHeartbeat()
+    heartbeatTimer = setInterval(() => {
+      onHeartbeat()
+    }, WS_HEARTBEAT_INTERVAL_MS)
+  }
+
+  /** 移除当前 ws 实例上的事件监听器，防止重连时在旧实例上累积监听器 */
+  let removeWsListeners: (() => void) | null = null
+
+  const connect = () => {
+    if (!shouldReconnect) return
+
+    // 清理旧 ws 实例上的监听器（若有）
+    if (removeWsListeners) {
+      removeWsListeners()
+      removeWsListeners = null
+    }
+
+    const start = Date.now()
+    const connectUrl = buildConnectUrl(account)
+    dcgLogger(`connecting to ${connectUrl}`)
+    ws = new WebSocket(connectUrl)
+
+    const currentWs = ws
+
+    const onOpen = () => {
+      dcgLogger(`socket connected, 用时： ${ Date.now() - start}ms`,)
+      setWsConnection(currentWs)
+      reportChannelStatus('connecting')
+      startHeartbeat()
+      onHeartbeat()
+    }
+
+    const onMessage = async (data: WebSocket.RawData) => {
+      let parsed: { messageType?: string; content: any }
+      try {
+        parsed = JSON.parse(data.toString())
+        if (parsed.messageType !== 'openclaw_bot_heartbeat') {
+          dcgLogger(`[后端=>插件]-[消息解析成功]: ${JSON.stringify(compressFields(parsed, ['title']))}`)
+        }
+      } catch {
+        dcgLogger(`[后端=>插件]-[消息解析失败]: invalid JSON received`, 'error')
+        return
+      }
+
+      const payloadStr = data.toString()
+      const heartbeat = isOpenclawBotHeartbeat(data, parsed)
+      if (heartbeat) {
+        heartbeatLogCounter += 1
+        if (heartbeatLogCounter % 10 === 0 || heartbeatLogCounter === 1) {
+          dcgLogger(`心跳链接, ${payloadStr}`)
+        }
+        reportChannelStatus('connected')
+        return
+      }
+
+      try {
+        parsed.content = JSON.parse(parsed.content)
+      } catch {
+        dcgLogger(`用户消息content字段解析失败: invalid JSON received`, 'error')
+        return
+      }
+      try {
+        await handleParsedWsMessage(parsed, payloadStr, account.accountId)
+      } catch (err) {
+        dcgLogger(`WS onMessage: handleParsedWsMessage failed: ${String(err)}`, 'error')
+      }
+    }
+
+    const onClose = (code: number, reason: Buffer) => {
+      stopHeartbeat()
+      // 移除当前 ws 上的所有监听器
+      currentWs.removeListener('message', onMessage)
+      currentWs.removeListener('close', onClose)
+      currentWs.removeListener('error', onError)
+      currentWs.removeListener('open', onOpen)
+      removeWsListeners = null
+      setWsConnection(null)
+      reportChannelStatus('disconnected', { code, reason: reason?.toString() || '' })
+      dcgLogger(`disconnected (code=${code}, reason=${reason?.toString() || ''})`, 'error')
+      if (shouldReconnect) {
+        dcgLogger(`reconnecting in ${WS_RECONNECT_DELAY_MS}ms...`)
+        setTimeout(connect, WS_RECONNECT_DELAY_MS)
+      }
+    }
+
+    const onError = (e: Error) => {
+      reportChannelStatus('error', { error: String(e) })
+      dcgLogger(`WebSocket error: ${String(e)}`, 'error')
+    }
+
+    currentWs.on('open', onOpen)
+    currentWs.on('message', onMessage)
+    currentWs.on('close', onClose)
+    currentWs.on('error', onError)
+
+    removeWsListeners = () => {
+      currentWs.removeListener('open', onOpen)
+      currentWs.removeListener('message', onMessage)
+      currentWs.removeListener('close', onClose)
+      currentWs.removeListener('error', onError)
+    }
+  }
+
+  connect()
+
+  await new Promise<void>((resolve) => {
+    if (abortSignal?.aborted) {
+      shouldReconnect = false
+      ws?.close()
+      resolve()
+      return
+    }
+    abortSignal?.addEventListener(
+      'abort',
+      () => {
+        dcgLogger(`socket stopping`)
+        stopHeartbeat()
+        shouldReconnect = false
+        ws?.close()
+        resolve()
+      },
+      { once: true }
+    )
+  })
+}

package/src/request/api.ts

@@ -0,0 +1,80 @@
+import { post } from './request.js'
+import type { IStsToken, IStsTokenReq } from '../types.js'
+import { getUserTokenCache, setUserTokenCache } from './userInfo.js'
+import { getParamsDefaults } from '../utils/params.js'
+import { dcgLogger } from '../utils/log.js'
+
+export const getStsToken = async (name: string, botToken: string, isPrivate: 1 | 0) => {
+  // 确保 userToken 已缓存（如果未缓存会自动获取并缓存）
+  await getUserToken(botToken)
+
+  try {
+    const response = await post<IStsTokenReq, IStsToken>('/user/getStsTokenByAsync', { sourceFileName: name, isPrivate }, { botToken })
+
+    if (!response || !response.data || !response.data.bucket) {
+      throw new Error(`获取 OSS 临时凭证失败: response=${JSON.stringify(response)}`)
+    }
+
+    return response.data
+  } catch (err) {
+    dcgLogger(`getStsToken error: ${String(err)}`, 'error')
+    throw new Error(`获取 OSS 临时凭证失败: ${String(err)}`)
+  }
+}
+export const generateSignUrl = async (file_url: string, botToken: string) => {
+  try {
+    // 确保 userToken 已缓存（如果未缓存会自动获取并缓存）
+    await getUserToken(botToken)
+
+    const response = await post<{ loudPlatform: number; fileName: string }, { filePath?: string }>('/user/generateSignUrl', { loudPlatform: 0, fileName: file_url }, { botToken })
+    if (response.code !== 0 || !response?.data || !response.data?.filePath) {
+      throw new Error(`生成 OSS 链接失败: response=${JSON.stringify(response)}`)
+    }
+    return response.data.filePath
+  } catch (error) {
+    dcgLogger(`generateSignUrl error: ${String(error)}`, 'error')
+    throw new Error(`生成 OSS 链接失败: ${String(error)}`)
+  }
+}
+
+/**
+ * 通过 botToken 查询 userToken
+ * @param botToken 机器人 token
+ * @returns userToken
+ */
+export const queryUserTokenByBotToken = async (botToken: string): Promise<string> => {
+  const p = getParamsDefaults()
+  const response = await post<{ botToken: string; _userId: number }, { token: string }>('/organization/queryUserTokenByBotTokenV2', {
+    botToken,
+    _userId: p.userId ?? 0
+  })
+
+  if (!response || !response.data || !response.data.token) {
+    dcgLogger('获取绑定的用户信息失败: token:' + botToken + '|' + JSON.stringify(response), 'error')
+    return ''
+  }
+
+  return response.data.token
+}
+
+/**
+ * 获取 userToken（优先从缓存获取，缓存未命中则调用 API）
+ * @param botToken 机器人 token
+ * @returns userToken
+ */
+export const getUserToken = async (botToken: string): Promise<string> => {
+  // 1. 尝试从缓存获取
+  const cachedToken = getUserTokenCache(botToken)
+  if (cachedToken) {
+    return cachedToken
+  }
+
+  // 2. 缓存未命中，调用 API 获取
+  dcgLogger(`[api] cache miss, fetching userToken for botToken=${botToken.slice(0, 10)}...`)
+  const userToken = await queryUserTokenByBotToken(botToken)
+
+  // 3. 缓存新获取的 token
+  setUserTokenCache(botToken, userToken)
+
+  return userToken
+}