@dcrays/dcgchat-test 0.6.12 → 0.6.13

package/src/gateway/socket.ts

@@ -1,256 +0,0 @@
-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

@@ -1,269 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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
-}