Skip to content

A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.

8.8 KB
Raw Blame
// QQ open platform: an app access token from appId+secret, then a Discord-like
// gateway (hello, heartbeat, identify, resume, reconnect, invalid session) for
// C2C and group @ messages. Sends are passive replies carrying the inbound
// msg_id with an incrementing msg_seq; outside the reply window the platform
// refuses and the reason is permanent. No buttons — the core numbers choices.
// Wire details ported from @tencent-connect/qqbot-nodejs (MIT, see NOTICE).
import { chunkMarkdown } from '../format.js'

const API = 'https://api.sgroup.qq.com'
const TOKEN_API = 'https://bots.qq.com'
const TEXT_LIMIT = 2000
// GROUP_AND_C2C covers C2C_MESSAGE_CREATE and GROUP_AT_MESSAGE_CREATE.
const INTENTS = 1 << 25

const apiBase = env => String(env.config?.api ?? API).replace(/\/+$/, '')
const tokenBase = env => String(env.config?.token ?? TOKEN_API)

const getToken = async (fields, env) => {
  const response = await env.fetch(`${tokenBase(env)}/app/getAppAccessToken`, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ appId: String(fields.appId ?? '').trim(), clientSecret: String(fields.appSecret ?? '').trim() }),
  })
  const body = await response.json().catch(() => ({}))
  if (body.access_token === undefined) throw new Error(body.error_reason ?? body.error ?? 'QQ refused these credentials')
  return { token: body.access_token, expiresAt: Date.now() + Math.max(10, Number(body.expires_in ?? 7200) - 300) * 1000 }
}

export default {
  id: 'qq',

  async check(fields, env) {
    const { token } = await getToken(fields, env)
    const me = await api(env, token, '/users/@me', { method: 'GET' }).catch(() => ({}))
    return { account: { id: String(fields.appId).trim(), name: me?.username ? `@${me.username}` : String(fields.appId).trim() } }
  },

  connect(fields, env, handlers) {
    let stopped = false
    let socket
    let token
    let expiresAt = 0
    let refreshTimer
    let heartbeatTimer
    let heartbeatAcked = true
    let reconnectTimer
    let generation = 0
    let sequence
    let sessionId
    // Passive replies reuse the inbound msg_id with a msg_seq that climbs
    // per id — outside the window the platform refuses (permanent).
    const msgSeq = new Map()
    const lastMsgId = new Map()

    const send = packet => { if (socket?.readyState === 1) socket.send(JSON.stringify(packet)) }
    const heartbeat = () => send({ op: 1, d: sequence ?? null })
    const scheduleHeartbeat = (interval) => {
      clearTimeout(heartbeatTimer)
      heartbeatAcked = true
      const beat = () => {
        if (!heartbeatAcked) { socket?.close(4000, 'Heartbeat lost'); return }
        heartbeatAcked = false
        heartbeat()
        heartbeatTimer = setTimeout(beat, interval)
        heartbeatTimer.unref?.()
      }
      heartbeatTimer = setTimeout(beat, interval)
      heartbeatTimer.unref?.()
    }

    const refresh = () => {
      const wait = Math.max(5_000, expiresAt - Date.now() - 60_000)
      refreshTimer = setTimeout(async () => {
        if (stopped) return
        try {
          const next = await getToken(fields, env)
          token = next.token
          expiresAt = next.expiresAt
        } catch (error) {
          env.log?.warn?.('ds-bot im: qq token refresh failed: %s', error?.message ?? error)
        }
        refresh()
      }, wait)
      refreshTimer.unref?.()
    }

    const onDispatch = async (packet) => {
      if (packet.t === 'READY') {
        sessionId = packet.d?.session_id
        handlers.onStatus({ state: 'ready', account: { id: String(fields.appId).trim(), name: packet.d?.user?.username ? `@${packet.d.user.username}` : String(fields.appId).trim() } })
        return
      }
      if (packet.t === 'RESUMED') { handlers.onStatus({ state: 'ready' }); return }
      const c2c = packet.t === 'C2C_MESSAGE_CREATE'
      const group = packet.t === 'GROUP_AT_MESSAGE_CREATE'
      if (!c2c && !group) return
      const d = packet.d ?? {}
      const key = String(c2c ? d.author?.user_openid ?? d.channel_id ?? '' : d.group_openid ?? d.channel_id ?? '')
      lastMsgId.set(key, String(d.id ?? ''))
      const sender = c2c ? d.author?.user_openid : d.author?.member_openid ?? d.author?.id
      await handlers.onMessage({
        chat: { key, kind: c2c ? 'direct' : 'group', title: '' },
        sender: { id: String(sender ?? ''), name: String(sender ?? '') },
        text: String(d.content ?? '').trim(),
        images: [], files: [],
        mentioned: group, messageId: String(d.id ?? ''),
      })
    }

    const open = (resume) => {
      const gen = generation
      try {
        socket = new env.WebSocket(gatewayUrl)
      } catch (error) {
        handlers.onStatus({ state: 'error', error: `QQ could not open a socket: ${error?.message ?? error}` })
        return
      }
      socket.addEventListener('message', (event) => {
        if (stopped || generation !== gen) return
        let packet
        try { packet = JSON.parse(String(event.data)) } catch { return }
        if (Number.isSafeInteger(packet.s)) sequence = packet.s
        if (packet.op === 10) {
          scheduleHeartbeat(Number(packet.d?.heartbeat_interval) || 40_000)
          send(resume && sessionId
            ? { op: 6, d: { token: `QQBot ${token}`, session_id: sessionId, seq: sequence ?? null } }
            : { op: 2, d: { token: `QQBot ${token}`, intents: INTENTS, shard: [0, 1], properties: { os: process.platform, browser: 'ds-bot', device: 'ds-bot' } } })
          return
        }
        if (packet.op === 11) { heartbeatAcked = true; return }
        if (packet.op === 1) { heartbeat(); return }
        if (packet.op === 7) { socket.close(4000, 'Reconnect requested'); return }
        if (packet.op === 9) {
          if (packet.d !== true) { sessionId = undefined; sequence = undefined }
          socket.close(4000, 'Invalid session')
          return
        }
        if (packet.op === 0) void onDispatch(packet).catch(error => env.log?.warn?.('ds-bot im: qq event failed: %s', error?.message ?? error))
      })
      socket.addEventListener('close', () => {
        clearTimeout(heartbeatTimer)
        if (stopped || generation !== gen) return
        handlers.onStatus({ state: 'connecting' })
        reconnectTimer = setTimeout(() => { if (!stopped) open(sessionId !== undefined) }, 2000)
        reconnectTimer.unref?.()
      })
      socket.addEventListener('error', () => {})
    }

    let gatewayUrl
    handlers.onStatus({ state: 'connecting' })
    void (async () => {
      try {
        const got = await getToken(fields, env)
        token = got.token
        expiresAt = got.expiresAt
        const gateway = await api(env, token, '/gateway', { method: 'GET' })
        gatewayUrl = gateway?.url
      } catch (error) {
        handlers.onStatus({ state: 'error', error: error.message })
        return
      }
      if (stopped) return
      refresh()
      open(false)
    })()

    return {
      send: async (chat, { text }) => {
        const chunks = chunkMarkdown(String(text ?? ''), TEXT_LIMIT)
        const msgId = lastMsgId.get(chat.key)
        const base = chat.kind === 'direct' ? `/v2/users/${chat.key}/messages` : `/v2/groups/${chat.key}/messages`
        let messageId
        for (const chunk of chunks) {
          const seq = (msgSeq.get(msgId) ?? 0) + 1
          msgSeq.set(msgId, seq)
          const sent = await api(env, token, base, {
            method: 'POST',
            body: { content: chunk, msg_type: 0, ...(msgId ? { msg_id: msgId, msg_seq: seq } : {}) },
          })
          messageId = String(sent?.id ?? messageId ?? '')
        }
        return { messageId }
      },
      stop: () => {
        stopped = true
        generation += 1
        clearTimeout(heartbeatTimer)
        clearTimeout(reconnectTimer)
        clearTimeout(refreshTimer)
        try { socket?.close(1000, 'stop') } catch { /* not open */ }
      },
    }
  },
}

async function api(env, token, path, { method = 'GET', body } = {}) {
  const response = await env.fetch(`${apiBase(env)}${path}`, {
    method,
    headers: { authorization: `QQBot ${token}`, 'content-type': 'application/json' },
    body: body === undefined ? undefined : JSON.stringify(body),
  })
  const json = await response.json().catch(() => ({}))
  if (!response.ok || json.code !== undefined) {
    const reason = json.message ?? json.error ?? `QQ answered ${response.status}`
    const error = new Error(String(reason))
    error.status = response.status
    // A refusal outside the reply window or over quota is permanent; 4xx other
    // than auth problems too. 5xx and timeouts retry.
    error.permanent = response.status >= 400 && response.status < 500 && response.status !== 429
      || /reply.*window|quota|frequency|超过|过期/i.test(String(reason))
    if (response.status === 429) error.retryAfter = Number(response.headers.get('retry-after'))
    throw error
  }
  return json
}