Skip to content

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

9.9 KB
Raw Blame
// WeCom intelligent robot: one long-lived WebSocket, a { cmd, headers: {
// req_id }, body } protocol — aibot_subscribe authenticates, ping heartbeats,
// aibot_msg_callback carries inbound messages answered through
// aibot_respond_msg with the callback's req_id, later messages use
// aibot_send_msg. Template-card buttons come back as aibot_event_callback.
// Encrypted images download with their per-link AES-256 key. Markdown.
// Wire details ported from @wecom/aibot-node-sdk (MIT, see NOTICE).
import { createDecipheriv } from 'node:crypto'
import { chunkMarkdown } from '../format.js'

const WSS = 'wss://openws.work.weixin.qq.com'
const TEXT_LIMIT = 4000

const wsBase = env => String(env.config?.gateway ?? env.config?.api ?? WSS).replace(/\/+$/, '')

export default {
  id: 'wecom',

  // The subscription itself is the credential check: a bad bot id or secret
  // fails the aibot_subscribe response.
  async check(fields, env) {
    const botId = String(fields.botId ?? '').trim()
    const secret = String(fields.secret ?? '').trim()
    if (env.WebSocket === undefined) throw new Error('This dsh runs on a Node without WebSocket')
    return await new Promise((resolve, reject) => {
      let socket
      const finish = (error, account) => {
        clearTimeout(timer)
        try { socket?.close(1000, 'check') } catch { /* not open */ }
        if (error === undefined) resolve({ account })
        else reject(error)
      }
      const timer = setTimeout(() => finish(new Error('WeCom did not answer the subscription')), 10_000)
      try { socket = new env.WebSocket(`${wsBase(env)}/wss`) } catch (error) {
        finish(new Error(`WeCom could not open a socket: ${error?.message ?? error}`))
        return
      }
      socket.addEventListener('open', () => {
        socket.send(JSON.stringify({ cmd: 'aibot_subscribe', headers: { req_id: 'check-1' }, body: { secret, bot_id: botId } }))
      })
      socket.addEventListener('message', (event) => {
        let packet
        try { packet = JSON.parse(String(event.data)) } catch { return }
        if (packet.errcode === undefined) return
        if (packet.errcode === 0) finish(undefined, { id: botId, name: botId })
        else finish(new Error(String(packet.errmsg ?? `WeCom answered ${packet.errcode}`)))
      })
      socket.addEventListener('error', () => finish(new Error('WeCom refused the socket')))
      socket.addEventListener('close', () => {})
    })
  },

  connect(fields, env, handlers) {
    const botId = String(fields.botId ?? '').trim()
    const secret = String(fields.secret ?? '').trim()
    let stopped = false
    let socket
    let generation = 0
    let reconnectTimer
    let pingTimer
    let reqCounter = 0
    // Passive replies reuse the last callback req_id per chat.
    const lastReqId = new Map()
    const pending = new Map() // req_id → {resolve, reject}

    const nextReqId = () => `r${++reqCounter}`
    const sendFrame = (packet) => { if (socket?.readyState === 1) socket.send(JSON.stringify(packet)) }
    const request = (cmd, body, reqId) => {
      const req_id = reqId ?? nextReqId()
      sendFrame({ cmd, headers: { req_id }, body })
      if (cmd === 'aibot_send_msg') {
        return new Promise((resolve, reject) => {
          pending.set(req_id, { resolve, reject })
          setTimeout(() => {
            if (pending.delete(req_id)) reject(new Error('WeCom did not answer the send'))
          }, 15_000).unref?.()
        })
      }
    }

    const onCallback = async (headers, body) => {
      const key = String(body.chattype === 'single' ? body.from?.userid ?? '' : body.chatid ?? '')
      lastReqId.set(key, String(headers?.req_id ?? ''))
      const direct = body.chattype === 'single'
      // Groups only count when the bot was @-ed: the text keeps the mention.
      const text = String(body.text?.content ?? '').trim()
      const images = []
      if (body.msgtype === 'image' && body.image?.url !== undefined) {
        const bytes = await downloadImage(body.image, env).catch(() => undefined)
        if (bytes !== undefined) images.push({ mediaType: 'image/jpeg', data: Buffer.from(bytes).toString('base64') })
      }
      // Reply frames go out with the callback's req_id; a failed reply is
      // logged but the message itself still lands in the core.
      await handlers.onMessage({
        chat: { key, kind: direct ? 'direct' : 'group', title: '' },
        sender: { id: String(body.from?.userid ?? ''), name: String(body.from?.name ?? body.from?.userid ?? '') },
        text, images, files: [],
        mentioned: body.chattype !== 'single' && body.mention_robot === true,
        messageId: String(body.msgid ?? ''),
      })
    }

    const onEvent = async (headers, body) => {
      if (body.event?.event_type !== 'template_card_event' && body.event_type !== 'template_card_event') return
      const card = body.event?.template_card_event ?? body.template_card_event ?? {}
      const key = String(body.chattype === 'single' ? body.from?.userid ?? '' : body.chatid ?? card.chatid ?? '')
      await handlers.onAction({
        chat: { key, kind: body.chattype === 'single' ? 'direct' : 'group', title: '' },
        sender: { id: String(body.from?.userid ?? card.userid ?? ''), name: '' },
        data: String(card.event_key ?? card.key ?? ''),
        messageId: String(body.msgid ?? ''),
      })
    }

    const open = () => {
      const gen = generation
      try { socket = new env.WebSocket(`${wsBase(env)}/wss`) } catch (error) {
        handlers.onStatus({ state: 'error', error: `WeCom could not open a socket: ${error?.message ?? error}` })
        return
      }
      socket.addEventListener('open', () => {
        sendFrame({ cmd: 'aibot_subscribe', headers: { req_id: nextReqId() }, body: { secret, bot_id: botId } })
      })
      socket.addEventListener('message', (event) => {
        if (stopped || generation !== gen) return
        let packet
        try { packet = JSON.parse(String(event.data)) } catch { return }
        if (packet.errcode !== undefined) {
          if (packet.errcode !== 0) {
            handlers.onStatus({ state: 'error', error: String(packet.errmsg ?? `WeCom answered ${packet.errcode}`) })
            const held = pending.get(packet.headers?.req_id)
            if (held !== undefined) {
              pending.delete(packet.headers?.req_id)
              held.reject(Object.assign(new Error(String(packet.errmsg ?? 'WeCom refused')), { permanent: true }))
            }
            return
          }
          if (packet.headers?.req_id !== undefined && pending.has(packet.headers.req_id)) {
            const held = pending.get(packet.headers.req_id)
            pending.delete(packet.headers.req_id)
            held.resolve(packet.body)
          }
          handlers.onStatus({ state: 'ready', account: { id: botId, name: botId } })
          return
        }
        if (packet.cmd === 'aibot_msg_callback') {
          void onCallback(packet.headers, packet.body ?? {}).catch(error => env.log?.warn?.('ds-bot im: wecom message failed: %s', error?.message ?? error))
        } else if (packet.cmd === 'aibot_event_callback') {
          void onEvent(packet.headers, packet.body ?? {}).catch(error => env.log?.warn?.('ds-bot im: wecom event failed: %s', error?.message ?? error))
        }
      })
      socket.addEventListener('close', () => {
        clearTimeout(pingTimer)
        if (stopped || generation !== gen) return
        handlers.onStatus({ state: 'connecting' })
        reconnectTimer = setTimeout(() => { if (!stopped) open() }, 2000)
        reconnectTimer.unref?.()
      })
      socket.addEventListener('error', () => {})
      pingTimer = setInterval(() => { if (!stopped && socket?.readyState === 1) sendFrame({ cmd: 'ping', headers: { req_id: nextReqId() } }) }, 30_000)
      pingTimer.unref?.()
    }

    handlers.onStatus({ state: 'connecting' })
    open()

    return {
      send: async (chat, { text, buttons }) => {
        const chunks = chunkMarkdown(String(text ?? ''), TEXT_LIMIT)
        let messageId
        for (const [index, chunk] of chunks.entries()) {
          const body = { msgtype: 'markdown', markdown: { content: chunk } }
          // Buttons ride a template card on the last chunk.
          if (index === chunks.length - 1 && buttons?.length > 0) {
            body.msgtype = 'template_card'
            body.template_card = {
              card_type: 'text_notice',
              main_title: { title: chunk.slice(0, 100) },
              card_action: { type: 2, url: 'https://work.weixin.qq.com' },
              button_selection: { question_key: 'choice', option_list: buttons.slice(0, 10).map(b => ({ id: b.data, text: b.label.slice(0, 30) })) },
            }
          }
          const reqId = lastReqId.get(chat.key)
          if (reqId !== undefined) {
            sendFrame({ cmd: 'aibot_respond_msg', headers: { req_id: reqId }, body })
            messageId = undefined
          } else {
            const result = await request('aibot_send_msg', { ...body, chatid: chat.kind === 'group' ? chat.key : undefined, userid: chat.kind === 'direct' ? chat.key : undefined })
            messageId = String(result?.msgid ?? messageId ?? '')
          }
        }
        return { messageId }
      },
      stop: () => {
        stopped = true
        generation += 1
        clearTimeout(reconnectTimer)
        clearTimeout(pingTimer)
        for (const held of pending.values()) held.reject(new Error('stopped'))
        pending.clear()
        try { socket?.close(1000, 'stop') } catch { /* not open */ }
      },
    }
  },
}

// Images download from their CDN URL and decrypt with the per-link AES-256
// key (base64).
async function downloadImage(image, env) {
  const response = await env.fetch(String(image.url))
  if (!response.ok) return undefined
  const encrypted = Buffer.from(await response.arrayBuffer())
  const key = Buffer.from(String(image.aeskey ?? ''), 'base64')
  if (key.length !== 32) return undefined
  const decipher = createDecipheriv('aes-256-cbc', key, key.subarray(0, 16))
  return Buffer.concat([decipher.update(encrypted), decipher.final()])
}