@peng272/dsh-wechat-ilink 0.0.0-stage → 0.7.0

package/lib/ilink.js

@@ -0,0 +1,164 @@
+/**
+ * iLink (Tencent ClawBot) protocol layer: HTTP client and QR login.
+ *
+ * Endpoints:
+ *   POST /ilink/bot/getupdates        long poll, carries the `get_updates_buf` cursor
+ *   POST /ilink/bot/sendmessage       send, requires a `context_token`
+ *   POST /ilink/bot/get_bot_qrcode    start a QR login
+ *   GET  /ilink/bot/get_qrcode_status poll that login
+ */
+import { randomUUID } from 'node:crypto'
+import { encodeQr, qrToPng, qrToTerminal } from './qr.js'
+
+export const DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com'
+/** Long-poll window the gateway honours; the client timeout sits above it. */
+export const LONG_POLL_MS = 35000
+
+export class ILinkClient {
+  constructor({ baseUrl, channelVersion, botAgent, appId } = {}) {
+    this.baseUrl = String(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')
+    this.channelVersion = channelVersion || '1.0.0'
+    this.botAgent = botAgent || 'DSH-ClawBot/0.1.0'
+    this.appId = appId || 'bot'
+  }
+
+  headers(token) {
+    const h = {
+      'Content-Type': 'application/json',
+      AuthorizationType: 'ilink_bot_token',
+      'X-WECHAT-UIN': Buffer.from(String(Math.floor(Math.random() * 4294967295))).toString('base64'),
+    }
+    const t = String(token || '').trim()
+    if (t) h.Authorization = `Bearer ${t}`
+    return h
+  }
+
+  baseInfo() {
+    return { channel_version: this.channelVersion, bot_agent: this.botAgent, app_id: this.appId }
+  }
+
+  async post(endpoint, body, { token, timeoutMs, signal } = {}) {
+    const ctrl = new AbortController()
+    const timer = timeoutMs ? setTimeout(() => ctrl.abort(), timeoutMs) : null
+    const onAbort = () => ctrl.abort()
+    if (signal) signal.addEventListener('abort', onAbort, { once: true })
+    try {
+      const res = await fetch(`${this.baseUrl}/${String(endpoint).replace(/^\/+/, '')}`, {
+        method: 'POST',
+        headers: this.headers(token),
+        body: JSON.stringify(body),
+        signal: ctrl.signal,
+      })
+      const text = await res.text()
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${text.slice(0, 300)}`)
+      return text ? JSON.parse(text) : {}
+    } finally {
+      if (timer) clearTimeout(timer)
+      if (signal) signal.removeEventListener('abort', onAbort)
+    }
+  }
+
+  async get(url, headers, timeoutMs) {
+    const ctrl = new AbortController()
+    const timer = timeoutMs ? setTimeout(() => ctrl.abort(), timeoutMs) : null
+    try {
+      const res = await fetch(url, { headers, signal: ctrl.signal })
+      const text = await res.text()
+      if (!res.ok) throw new Error(`HTTP ${res.status}`)
+      return JSON.parse(text)
+    } finally {
+      if (timer) clearTimeout(timer)
+    }
+  }
+
+  /** A long-poll timeout returning the same cursor and no messages is normal. */
+  async getUpdates(token, cursor, signal) {
+    return this.post(
+      'ilink/bot/getupdates',
+      { get_updates_buf: cursor || '', base_info: this.baseInfo() },
+      { token, timeoutMs: LONG_POLL_MS + 10000, signal },
+    )
+  }
+
+  /** Send one text message. The gateway requires `context_token`. */
+  async sendText(token, toUserId, text, contextToken, signal) {
+    if (!contextToken) throw new Error('context_token is required for send')
+    return this.post(
+      'ilink/bot/sendmessage',
+      {
+        msg: {
+          from_user_id: '',
+          to_user_id: toUserId,
+          client_id: randomUUID(),
+          message_type: 2,
+          message_state: 2,
+          context_token: contextToken,
+          item_list: [{ type: 1, text_item: { text } }],
+        },
+        base_info: this.baseInfo(),
+      },
+      { token, timeoutMs: 20000, signal },
+    )
+  }
+
+  async requestQrCode() {
+    return this.post('ilink/bot/get_bot_qrcode?bot_type=3', { local_token_list: [] }, { timeoutMs: 20000 })
+  }
+
+  async pollQrStatus(qrcode) {
+    const url = `${this.baseUrl}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`
+    return this.get(url, { 'iLink-App-ClientVersion': '1' }, 40000)
+  }
+}
+
+/**
+ * QR login: start a ticket, then poll it to resolution.
+ *
+ * The gateway returns only the login URL (`qrcode_img_content`), not an image.
+ * Rendering is therefore the client's job — see `./qr.js`.
+ */
+export class QrLoginManager {
+  constructor({ client, store }) {
+    this.client = client
+    this.store = store
+    this.ticket = null
+  }
+
+  async start() {
+    const qr = await this.client.requestQrCode()
+    if (!qr || !qr.qrcode) throw new Error('get_bot_qrcode returned no qrcode')
+    this.ticket = { id: qr.qrcode, url: typeof qr.qrcode_img_content === 'string' ? qr.qrcode_img_content : '' }
+    return this.ticket
+  }
+
+  /**
+   * Poll once.
+   * @returns {Promise<{status:'wait'|'scaned'|'confirmed'|'expired', accountId?:string, userId?:string, baseUrl?:string}>}
+   */
+  async poll({ ticketId } = {}) {
+    const id = ticketId ?? this.ticket?.id
+    if (!id) throw new Error('no login ticket; call start() first')
+    const status = await this.client.pollQrStatus(id)
+    const state = String(status?.status ?? '')
+    if (state === 'confirmed') {
+      const token = String(status.bot_token || '').trim()
+      if (!token) throw new Error('confirmed but no bot_token')
+      const baseUrl = status.base_url || DEFAULT_BASE_URL
+      // Account identity is derived from the token's own prefix, which is the
+      // stable bot account id the gateway uses.
+      const accountId = token.split(':')[0] || 'default'
+      this.store.registerAccountId(accountId)
+      this.store.save(accountId, { token, baseUrl })
+      return { status: 'confirmed', accountId, baseUrl }
+    }
+    if (state === 'scaned' || state === 'scanned') return { status: 'scaned' }
+    if (state === 'expired' || state === 'verify_code_blocked') return { status: 'expired' }
+    return { status: 'wait' }
+  }
+}
+
+/** Render a login URL into a PNG buffer. */
+export function renderQrPng(url, { scale = 8, margin = 4 } = {}) {
+  const qr = encodeQr(url, { ecc: 'M' })
+  return { png: qrToPng(qr.modules, { scale, margin }), art: qrToTerminal(qr.modules, { margin: 2 }), meta: qr }
+}

package/lib/index.js

@@ -0,0 +1,406 @@
+/**
+ * WeChat ClawBot (Tencent iLink) channel for DeepSeek Harness.
+ *
+ * Talk to DSH from WeChat: an outbound long poll receives messages, each message
+ * drives one DSH session, and the reply goes back to the chat.
+ *
+ * STABLE RUNTIME IDENTITIES (do not rename — they are what an existing install
+ * is keyed on):
+ *   Cordis plugin `name` (the log tag)   wechat-clawbot
+ *   Bundle row `id`                      wechat-clawbot
+ *   Default `sessionId`                  wechat-clawbot
+ *   State directory                      <DSH_HOME>/clawbot/
+ *   CLI binary                           dsh-wechat-ilink
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { randomUUID } from 'node:crypto'
+
+import { AccountStore, resolveStateDir } from './accounts.js'
+import { ILinkClient, QrLoginManager, DEFAULT_BASE_URL, renderQrPng } from './ilink.js'
+import { Logger, resolveConfig, isSenderAllowed, SingleInstanceLock, redactToken } from './support.js'
+import { Config } from './schema.js'
+
+export const name = 'wechat-clawbot'
+
+/** Plugin version, mirrored from package.json (a literal keeps the bundle JSON-free). */
+export const PLUGIN_VERSION = '0.7.0'
+
+/**
+ * Services this plugin requires before it activates.
+ *
+ * Deliberately empty: the conversation is driven through a `dsh --profile
+ * headless` child process, so this plugin needs no in-process DSH service and
+ * therefore cannot be blocked from activating by one that is missing.
+ */
+export const inject = []
+
+/** Re-exported so DSH validates the bundle row's `config` automatically. */
+export { Config }
+
+const CHANNEL_VERSION = '2.4.9'
+const BOT_AGENT = 'DSH-ClawBot/0.1.0'
+
+/** Split a long reply into chat-sized chunks. */
+function chunkText(text, maxChars) {
+  const limit = Number.isFinite(maxChars) && maxChars > 0 ? maxChars : 2000
+  const chunks = []
+  let rest = String(text ?? '')
+  while (rest.length > limit) {
+    let cut = rest.lastIndexOf('\n', limit)
+    if (cut < limit * 0.5) cut = limit
+    chunks.push(rest.slice(0, cut))
+    rest = rest.slice(cut).replace(/^\n+/, '')
+  }
+  if (rest.length > 0) chunks.push(rest)
+  return chunks
+}
+
+/** Token bucket for outbound sends; the gateway throttles aggressively. */
+class RateLimiter {
+  constructor(rate, burst) {
+    this.rate = Number(rate) > 0 ? Number(rate) : 0
+    this.burst = Number(burst) > 0 ? Number(burst) : 1
+    this.tokens = this.burst
+    this.last = Date.now()
+  }
+
+  async take(signal) {
+    if (this.rate <= 0) return
+    for (;;) {
+      if (signal?.aborted) throw new Error('aborted')
+      const now = Date.now()
+      this.tokens = Math.min(this.burst, this.tokens + ((now - this.last) / 1000) * this.rate)
+      this.last = now
+      if (this.tokens >= 1) {
+        this.tokens -= 1
+        return
+      }
+      const waitMs = Math.ceil(((1 - this.tokens) / this.rate) * 1000)
+      await new Promise((r) => setTimeout(r, Math.min(Math.max(waitMs, 20), 1000)))
+    }
+  }
+}
+
+/**
+ * Derive the argv prefix that re-launches DSH.
+ *
+ * This process IS DSH (Electron running as node), so `process.execPath` plus the
+ * `cli.js` entry from argv is exactly the pair the `dsh` shim uses.
+ */
+function resolveDshPrefix(config) {
+  if (Array.isArray(config.dshArgv) && config.dshArgv.length > 0) return config.dshArgv.map(String)
+  const exe = process.execPath
+  const cli = Array.isArray(process.argv) ? process.argv.find((a) => typeof a === 'string' && a.endsWith('cli.js')) : undefined
+  if (exe && cli) return [exe, '--expose-internals', cli]
+  return null
+}
+
+/** Parse the NDJSON emitted by `dsh --profile headless --json`. */
+export function parseHeadlessJson(stdout) {
+  let sessionId
+  let text = ''
+  let reason
+  for (const line of String(stdout ?? '').split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    let event
+    try {
+      event = JSON.parse(trimmed)
+    } catch {
+      continue
+    }
+    if (event.type === 'session' && typeof event.sessionId === 'string') sessionId = event.sessionId
+    else if (event.type === 'final' && typeof event.text === 'string') text = event.text
+    else if (event.type === 'status' && event.phase === 'turn_end' && event.reason) reason = event.reason
+  }
+  return {
+    sessionId,
+    text,
+    reason: reason ? reason.kind : 'incomplete',
+    error: reason?.error?.message,
+  }
+}
+
+/**
+ * Cordis plugin entry.
+ *
+ * @param ctx the plugin's Cordis context.
+ * @param rawConfig validated config from the bundle row.
+ */
+export function apply(ctx, rawConfig) {
+  const config = resolveConfig(rawConfig)
+  const stateDir = config.stateDir || resolveStateDir()
+  const logFile = path.join(stateDir, 'channel.log')
+  // A plugin inside DSH has no readable stderr, so every line also lands in a
+  // durable file next to the credentials. This is the only way a live failure
+  // can be diagnosed after the fact.
+  const logger = new Logger(config.logLevel, 'wechat-clawbot', (line) => process.stderr.write(line + '\n'), logFile)
+  const log = (level, message) => logger[level]?.(message)
+
+  log('info', `=== wechat-clawbot v${PLUGIN_VERSION} loading (state dir=${stateDir}) ===`)
+
+  if (config.enabled !== true) {
+    log('info', 'disabled by config (enabled: false); not connecting')
+    return
+  }
+
+  const store = new AccountStore(stateDir)
+  const client = new ILinkClient({
+    baseUrl: config.baseUrl || DEFAULT_BASE_URL,
+    channelVersion: CHANNEL_VERSION,
+    botAgent: BOT_AGENT,
+    appId: 'bot',
+  })
+  const login = new QrLoginManager({ client, store })
+  const abort = new AbortController()
+  let stopped = false
+
+  // Two pollers on one bot steal each other's messages, silently. Refuse to be
+  // the second one.
+  const lock = new SingleInstanceLock(stateDir, log)
+  if (!lock.acquire()) return
+
+  ctx.effect(
+    () => () => {
+      stopped = true
+      abort.abort()
+      lock.release()
+    },
+    'wechat-clawbot lifecycle',
+  )
+
+  // ---- account ----
+  let accountId = store.listAccountIds()[0]
+  let account = accountId ? store.load(accountId) : null
+  let boundUserId = account?.userId || ''
+
+  const persistBoundUser = (userId) => {
+    if (!userId || boundUserId === userId) return
+    boundUserId = userId
+    if (accountId) store.save(accountId, { userId })
+    log('info', `bound WeChat user recorded: ${userId}`)
+  }
+
+  // ---- outbound ----
+  const limiter = new RateLimiter(config.outgoingMaxPerSec ?? 0.5, config.outgoingBurst ?? 1)
+  let lastContextToken = ''
+
+  async function sendText(toUserId, text) {
+    if (!lastContextToken) {
+      log('error', `no context_token yet for ${toUserId}; they must send a message first`)
+      return false
+    }
+    for (const chunk of chunkText(text, config.maxMessageChars)) {
+      await limiter.take(abort.signal)
+      try {
+        const res = await client.sendText(account.token, toUserId, chunk, lastContextToken, abort.signal)
+        const ret = Number(res?.ret)
+        if (Number.isFinite(ret) && ret !== 0) {
+          log('error', `sendmessage declined ret=${ret} errcode=${res?.errcode} errmsg=${res?.errmsg}`)
+          return false
+        }
+      } catch (error) {
+        log('error', `send failed: ${error?.message ?? error}`)
+        return false
+      }
+    }
+    return true
+  }
+
+  // ---- session driving ----
+  const dshPrefix = resolveDshPrefix(config)
+  const workspace = config.cwd || process.cwd()
+  let sessionId = config.sessionId?.trim() || 'wechat-clawbot'
+  let chain = Promise.resolve()
+
+  function runHeadless(prompt) {
+    if (!dshPrefix) return Promise.resolve({ text: '', reason: 'no-dsh-prefix' })
+    const argv = [...dshPrefix, '--profile', 'headless', '--json', '--session-id', sessionId, prompt]
+    return new Promise((resolve) => {
+      let child
+      try {
+        child = spawn(argv[0], argv.slice(1), { cwd: workspace, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] })
+      } catch (error) {
+        resolve({ text: '', reason: `spawn: ${error?.message ?? error}` })
+        return
+      }
+      let stdout = ''
+      let stderr = ''
+      let settled = false
+      const finish = (r) => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        resolve(r)
+      }
+      const timer = setTimeout(() => {
+        log('error', `turn exceeded turnTimeoutMs=${config.turnTimeoutMs}; terminating`)
+        try {
+          child.kill()
+        } catch {
+          /* ignore */
+        }
+        finish({ text: '', reason: 'timeout' })
+      }, config.turnTimeoutMs)
+      child.stdout.on('data', (d) => {
+        stdout += d.toString('utf8')
+      })
+      child.stderr.on('data', (d) => {
+        stderr += d.toString('utf8')
+      })
+      child.on('error', (error) => finish({ text: '', reason: `error: ${error?.message ?? error}` }))
+      child.on('close', (code) => {
+        const parsed = parseHeadlessJson(stdout)
+        if (parsed.reason === 'incomplete' && stderr.trim()) {
+          log('error', `headless exited code=${code}: ${stderr.trim().slice(0, 400)}`)
+        }
+        finish(parsed)
+      })
+    })
+  }
+
+  // ---- inbound ----
+  function extractText(msg) {
+    const items = Array.isArray(msg?.item_list) ? msg.item_list : []
+    const parts = []
+    for (const item of items) {
+      if (item?.type === 1 && typeof item.text_item?.text === 'string') parts.push(item.text_item.text)
+      else if (item?.type === 3 && typeof item.voice_item?.text === 'string') parts.push(item.voice_item.text)
+    }
+    return parts.join('\n').trim()
+  }
+
+  async function handleInbound(msg) {
+    const from = String(msg?.from_user_id || '').trim()
+    if (!from) return
+
+    const token = String(msg?.context_token || '').trim()
+    if (token) lastContextToken = token
+
+    // A sender is allowed when explicitly listed, otherwise only the account
+    // that scanned the QR may drive the agent.
+    if (!isSenderAllowed(config, from, boundUserId)) {
+      log('error', `sender not allowed, ignored: ${from} (bind with the CLI, or add to allowedUserIds)`)
+      return
+    }
+    persistBoundUser(from)
+
+    const text = extractText(msg)
+    if (!text) {
+      log('debug', `non-text message from ${from} ignored`)
+      return
+    }
+    log('info', `inbound from ${from} (${text.length} chars)`)
+
+    if (config.progressNotice) await sendText(from, '🤔 收到，正在处理…').catch(() => {})
+
+    chain = chain
+      .catch(() => {})
+      .then(async () => {
+        const result = await runHeadless(text)
+        if (result.sessionId) sessionId = result.sessionId
+        if (result.text) await sendText(from, result.text)
+        else log('error', `no reply text (reason=${result.reason}${result.error ? ` error=${result.error}` : ''})`)
+      })
+  }
+
+  // ---- poll ----
+  async function pollLoop() {
+    let backoffMs = 1000
+    let cursor = accountId ? store.loadSyncBuf(accountId) : ''
+    log('info', `polling as ${accountId} (token ${redactToken(account.token)}, cursor ${cursor.length} chars)`)
+    while (!stopped) {
+      try {
+        const res = await client.getUpdates(account.token, cursor, abort.signal)
+        backoffMs = 1000
+
+        if (Number(res?.errcode) === -14) {
+          log('error', 'session expired (errcode -14) — re-login required')
+          await new Promise((r) => setTimeout(r, 30000))
+          continue
+        }
+
+        const next = res?.get_updates_buf
+        if (typeof next === 'string' && next.length > 0 && next !== cursor) {
+          cursor = next
+          if (accountId) store.saveSyncBuf(accountId, cursor)
+        }
+
+        for (const msg of Array.isArray(res?.msgs) ? res.msgs : []) {
+          handleInbound(msg).catch((error) => log('error', `inbound handling failed: ${error?.message ?? error}`))
+        }
+      } catch (error) {
+        if (stopped || /aborted/i.test(String(error?.message))) return
+        log('error', `poll error: ${error?.message ?? error}`)
+        await new Promise((r) => setTimeout(r, backoffMs))
+        backoffMs = Math.min(backoffMs * 2, 30000)
+      }
+    }
+  }
+
+  // ---- QR binding when nothing is bound ----
+  async function bindViaQr() {
+    log('info', 'no bound account — requesting a login QR code')
+    const ticket = await login.start()
+    log('info', `login URL: ${ticket.url}`)
+    try {
+      const { png, art } = renderQrPng(ticket.url)
+      const qrPath = path.join(stateDir, 'login-qr.png')
+      fs.mkdirSync(stateDir, { recursive: true })
+      fs.writeFileSync(qrPath, png)
+      log('info', `QR image written to ${qrPath}`)
+      for (const line of art.split('\n')) log('info', `QR ${line}`)
+    } catch (error) {
+      log('error', `QR rendering failed (use the URL above): ${error?.message ?? error}`)
+    }
+    const deadline = Date.now() + 10 * 60 * 1000
+    while (!stopped && Date.now() < deadline) {
+      const outcome = await login.poll({ ticketId: ticket.id })
+      if (outcome.status === 'confirmed') {
+        accountId = outcome.accountId
+        account = store.load(accountId)
+        log('info', `bound account ${accountId}; credentials stored under ${stateDir}`)
+        return true
+      }
+      if (outcome.status === 'expired') throw new Error('QR code expired')
+      await new Promise((r) => setTimeout(r, 2000))
+    }
+    throw new Error('QR binding timed out')
+  }
+
+  // ---- start ----
+  ;(async () => {
+    if (!dshPrefix) {
+      log('error', 'cannot derive the dsh argv prefix (process.execPath / cli.js); set config.dshArgv explicitly')
+    } else {
+      log('debug', `dsh prefix: ${dshPrefix.join(' ')}`)
+    }
+    if (!config.typing) log('debug', 'typing indicator disabled by config')
+    else log('info', 'NOTE: the typing indicator is not implemented in 0.7.0 (config accepted, ignored)')
+    if (config.acceptImages) log('info', 'NOTE: inbound images are not implemented in 0.7.0 (config accepted, ignored)')
+
+    try {
+      if (!account?.token) {
+        const ok = await bindViaQr()
+        if (!ok) return
+      }
+      log('info', `wechat-clawbot ready (session=${sessionId}, state dir=${store.dir})`)
+
+      if (config.selfTestOnStart) {
+        setTimeout(() => {
+          log('info', 'running startup self-test turn…')
+          runHeadless('Reply with exactly: SELFTEST_OK')
+            .then((r) => log(r.text.includes('SELFTEST_OK') ? 'info' : 'error', `self-test: reason=${r.reason} text=${JSON.stringify(r.text.slice(0, 120))}`))
+            .catch((error) => log('error', `self-test threw: ${error?.message ?? error}`))
+        }, config.selfTestDelayMs)
+      }
+
+      await pollLoop()
+    } catch (error) {
+      log('error', `channel failed to start: ${error?.message ?? error}`)
+      lock.release()
+    }
+  })()
+}