| import crypto from 'node:crypto' |
|
|
| export const WECHAT_DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com' |
| export const WECHAT_DEFAULT_BOT_TYPE = '3' |
|
|
| const ILINK_APP_ID = 'bot' |
| const CHANNEL_VERSION = '2.1.7' |
| const ILINK_APP_CLIENT_VERSION = buildClientVersion(CHANNEL_VERSION) |
| const QR_LOGIN_TTL_MS = 5 * 60_000 |
| const QR_STATUS_TIMEOUT_MS = 35_000 |
| const GET_UPDATES_TIMEOUT_MS = 35_000 |
| const API_TIMEOUT_MS = 15_000 |
|
|
| type QrLoginStatus = 'wait' | 'scaned' | 'confirmed' | 'expired' | 'scaned_but_redirect' |
|
|
| type ActiveLogin = { |
| sessionKey: string |
| qrcode: string |
| qrcodeUrl: string |
| startedAt: number |
| currentApiBaseUrl: string |
| } |
|
|
| type QrCodeResponse = { |
| qrcode: string |
| qrcode_img_content: string |
| } |
|
|
| type QrStatusResponse = { |
| status: QrLoginStatus |
| bot_token?: string |
| ilink_bot_id?: string |
| baseurl?: string |
| ilink_user_id?: string |
| redirect_host?: string |
| } |
|
|
| export type WechatQrStartResult = { |
| qrcodeUrl?: string |
| message: string |
| sessionKey: string |
| } |
|
|
| export type WechatQrPollResult = { |
| connected: boolean |
| status: QrLoginStatus | 'not_started' |
| message: string |
| botToken?: string |
| accountId?: string |
| baseUrl?: string |
| userId?: string |
| } |
|
|
| export type WechatMessageItem = { |
| type?: number |
| msg_id?: string |
| text_item?: { text?: string } |
| voice_item?: { text?: string } |
| media?: WechatCdnMedia |
| image_item?: { |
| media?: WechatCdnMedia |
| thumb_media?: WechatCdnMedia |
| aeskey?: string |
| url?: string |
| } |
| file_item?: { |
| media?: WechatCdnMedia |
| file_name?: string |
| len?: string |
| } |
| video_item?: { |
| media?: WechatCdnMedia |
| thumb_media?: WechatCdnMedia |
| } |
| ref_msg?: { |
| title?: string |
| message_item?: WechatMessageItem |
| } |
| } |
|
|
| export type WechatCdnMedia = { |
| encrypt_query_param?: string |
| aes_key?: string |
| full_url?: string |
| } |
|
|
| export type WechatMessage = { |
| seq?: number |
| message_id?: number |
| from_user_id?: string |
| to_user_id?: string |
| client_id?: string |
| create_time_ms?: number |
| session_id?: string |
| message_type?: number |
| message_state?: number |
| item_list?: WechatMessageItem[] |
| context_token?: string |
| } |
|
|
| export type WechatGetUpdatesResp = { |
| ret?: number |
| errcode?: number |
| errmsg?: string |
| msgs?: WechatMessage[] |
| get_updates_buf?: string |
| longpolling_timeout_ms?: number |
| } |
|
|
| const activeLogins = new Map<string, ActiveLogin>() |
|
|
| export function buildClientVersion(version: string): number { |
| const parts = version.split('.').map((p) => parseInt(p, 10)) |
| const major = parts[0] ?? 0 |
| const minor = parts[1] ?? 0 |
| const patch = parts[2] ?? 0 |
| return ((major & 0xff) << 16) | ((minor & 0xff) << 8) | (patch & 0xff) |
| } |
|
|
| export function extractWechatText(itemList?: WechatMessageItem[]): string { |
| if (!itemList?.length) return '' |
| for (const item of itemList) { |
| if (item.type === 1 && item.text_item?.text != null) { |
| const text = String(item.text_item.text) |
| const ref = item.ref_msg |
| if (!ref) return text |
| const parts: string[] = [] |
| if (ref.title) parts.push(ref.title) |
| if (ref.message_item) { |
| const refBody = extractWechatText([ref.message_item]) |
| if (refBody) parts.push(refBody) |
| } |
| return parts.length ? `[引用: ${parts.join(' | ')}]\n${text}` : text |
| } |
| if (item.type === 3 && item.voice_item?.text) { |
| return item.voice_item.text |
| } |
| } |
| return '' |
| } |
|
|
| export async function startWechatLoginWithQr(opts: { |
| force?: boolean |
| sessionKey?: string |
| botType?: string |
| } = {}): Promise<WechatQrStartResult> { |
| purgeExpiredLogins() |
|
|
| const sessionKey = opts.sessionKey || crypto.randomUUID() |
| const existing = activeLogins.get(sessionKey) |
| if (!opts.force && existing && isLoginFresh(existing)) { |
| return { |
| qrcodeUrl: existing.qrcodeUrl, |
| message: '二维码已就绪，请使用微信扫描。', |
| sessionKey, |
| } |
| } |
|
|
| const botType = opts.botType || WECHAT_DEFAULT_BOT_TYPE |
| const rawText = await apiGetFetch({ |
| baseUrl: WECHAT_DEFAULT_BASE_URL, |
| endpoint: `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`, |
| label: 'wechatQrStart', |
| }) |
| const qr = JSON.parse(rawText) as QrCodeResponse |
| if (!qr.qrcode || !qr.qrcode_img_content) { |
| throw new Error('WeChat QR response did not include a QR code URL') |
| } |
|
|
| activeLogins.set(sessionKey, { |
| sessionKey, |
| qrcode: qr.qrcode, |
| qrcodeUrl: qr.qrcode_img_content, |
| startedAt: Date.now(), |
| currentApiBaseUrl: WECHAT_DEFAULT_BASE_URL, |
| }) |
|
|
| return { |
| qrcodeUrl: qr.qrcode_img_content, |
| message: '使用微信扫描二维码完成绑定。', |
| sessionKey, |
| } |
| } |
|
|
| export async function pollWechatLoginWithQr(opts: { |
| sessionKey: string |
| }): Promise<WechatQrPollResult> { |
| purgeExpiredLogins() |
|
|
| const login = activeLogins.get(opts.sessionKey) |
| if (!login) { |
| return { |
| connected: false, |
| status: 'not_started', |
| message: '当前没有进行中的微信绑定，请重新生成二维码。', |
| } |
| } |
|
|
| const status = await pollQrStatus(login.currentApiBaseUrl, login.qrcode) |
| switch (status.status) { |
| case 'wait': |
| return { connected: false, status: 'wait', message: '等待扫码。' } |
| case 'scaned': |
| return { connected: false, status: 'scaned', message: '已扫码，请在微信中确认。' } |
| case 'scaned_but_redirect': |
| if (status.redirect_host) { |
| login.currentApiBaseUrl = `https://${status.redirect_host}` |
| } |
| return { connected: false, status: 'scaned_but_redirect', message: '已扫码，正在切换微信网关。' } |
| case 'expired': |
| activeLogins.delete(opts.sessionKey) |
| return { connected: false, status: 'expired', message: '二维码已过期，请重新生成。' } |
| case 'confirmed': |
| activeLogins.delete(opts.sessionKey) |
| if (!status.bot_token || !status.ilink_bot_id) { |
| return { connected: false, status: 'confirmed', message: '微信已确认，但服务端未返回完整凭据。' } |
| } |
| return { |
| connected: true, |
| status: 'confirmed', |
| message: '微信绑定成功。', |
| botToken: status.bot_token, |
| accountId: status.ilink_bot_id, |
| baseUrl: status.baseurl || login.currentApiBaseUrl || WECHAT_DEFAULT_BASE_URL, |
| userId: status.ilink_user_id, |
| } |
| } |
| } |
|
|
| export async function getWechatUpdates(params: { |
| baseUrl: string |
| token: string |
| getUpdatesBuf?: string |
| timeoutMs?: number |
| }): Promise<WechatGetUpdatesResp> { |
| try { |
| const rawText = await apiPostFetch({ |
| baseUrl: params.baseUrl, |
| endpoint: 'ilink/bot/getupdates', |
| body: JSON.stringify({ |
| get_updates_buf: params.getUpdatesBuf ?? '', |
| base_info: buildBaseInfo(), |
| }), |
| token: params.token, |
| timeoutMs: params.timeoutMs ?? GET_UPDATES_TIMEOUT_MS, |
| label: 'wechatGetUpdates', |
| }) |
| return JSON.parse(rawText) as WechatGetUpdatesResp |
| } catch (err) { |
| if (err instanceof Error && err.name === 'AbortError') { |
| return { ret: 0, msgs: [], get_updates_buf: params.getUpdatesBuf } |
| } |
| throw err |
| } |
| } |
|
|
| export async function sendWechatText(params: { |
| baseUrl: string |
| token: string |
| to: string |
| text: string |
| contextToken?: string |
| timeoutMs?: number |
| }): Promise<void> { |
| const body = { |
| msg: { |
| from_user_id: '', |
| to_user_id: params.to, |
| client_id: `claude-code-haha-wechat-${crypto.randomUUID()}`, |
| message_type: 2, |
| message_state: 2, |
| item_list: params.text ? [{ type: 1, text_item: { text: params.text } }] : undefined, |
| context_token: params.contextToken, |
| }, |
| base_info: buildBaseInfo(), |
| } |
|
|
| const rawText = await apiPostFetch({ |
| baseUrl: params.baseUrl, |
| endpoint: 'ilink/bot/sendmessage', |
| body: JSON.stringify(body), |
| token: params.token, |
| timeoutMs: params.timeoutMs ?? API_TIMEOUT_MS, |
| label: 'wechatSendMessage', |
| }) |
| assertWechatApiOk(rawText, 'wechatSendMessage') |
| } |
|
|
| export async function getWechatConfig(params: { |
| baseUrl: string |
| token: string |
| ilinkUserId: string |
| contextToken?: string |
| timeoutMs?: number |
| }): Promise<{ ret?: number; errmsg?: string; typing_ticket?: string }> { |
| const rawText = await apiPostFetch({ |
| baseUrl: params.baseUrl, |
| endpoint: 'ilink/bot/getconfig', |
| body: JSON.stringify({ |
| ilink_user_id: params.ilinkUserId, |
| context_token: params.contextToken, |
| base_info: buildBaseInfo(), |
| }), |
| token: params.token, |
| timeoutMs: params.timeoutMs ?? 10_000, |
| label: 'wechatGetConfig', |
| }) |
| return JSON.parse(rawText) as { ret?: number; errmsg?: string; typing_ticket?: string } |
| } |
|
|
| export async function sendWechatTyping(params: { |
| baseUrl: string |
| token: string |
| ilinkUserId: string |
| typingTicket: string |
| status: 'typing' | 'cancel' |
| timeoutMs?: number |
| }): Promise<void> { |
| const rawText = await apiPostFetch({ |
| baseUrl: params.baseUrl, |
| endpoint: 'ilink/bot/sendtyping', |
| body: JSON.stringify({ |
| ilink_user_id: params.ilinkUserId, |
| typing_ticket: params.typingTicket, |
| status: params.status === 'typing' ? 1 : 2, |
| base_info: buildBaseInfo(), |
| }), |
| token: params.token, |
| timeoutMs: params.timeoutMs ?? 10_000, |
| label: 'wechatSendTyping', |
| }) |
| assertWechatApiOk(rawText, 'wechatSendTyping') |
| } |
|
|
| async function pollQrStatus(apiBaseUrl: string, qrcode: string): Promise<QrStatusResponse> { |
| try { |
| const rawText = await apiGetFetch({ |
| baseUrl: apiBaseUrl, |
| endpoint: `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, |
| timeoutMs: QR_STATUS_TIMEOUT_MS, |
| label: 'wechatQrStatus', |
| }) |
| return JSON.parse(rawText) as QrStatusResponse |
| } catch (err) { |
| if (err instanceof Error && err.name === 'AbortError') return { status: 'wait' } |
| return { status: 'wait' } |
| } |
| } |
|
|
| async function apiGetFetch(params: { |
| baseUrl: string |
| endpoint: string |
| timeoutMs?: number |
| label: string |
| }): Promise<string> { |
| const url = new URL(params.endpoint, ensureTrailingSlash(params.baseUrl)) |
| const controller = params.timeoutMs ? new AbortController() : undefined |
| const timer = controller ? setTimeout(() => controller.abort(), params.timeoutMs) : undefined |
| try { |
| const res = await fetch(url.toString(), { |
| method: 'GET', |
| headers: buildCommonHeaders(), |
| ...(controller ? { signal: controller.signal } : {}), |
| }) |
| const rawText = await res.text() |
| if (!res.ok) throw new Error(`${params.label} ${res.status}: ${rawText}`) |
| return rawText |
| } finally { |
| if (timer) clearTimeout(timer) |
| } |
| } |
|
|
| async function apiPostFetch(params: { |
| baseUrl: string |
| endpoint: string |
| body: string |
| token?: string |
| timeoutMs: number |
| label: string |
| }): Promise<string> { |
| const url = new URL(params.endpoint, ensureTrailingSlash(params.baseUrl)) |
| const controller = new AbortController() |
| const timer = setTimeout(() => controller.abort(), params.timeoutMs) |
| try { |
| const res = await fetch(url.toString(), { |
| method: 'POST', |
| headers: buildHeaders({ token: params.token, body: params.body }), |
| body: params.body, |
| signal: controller.signal, |
| }) |
| const rawText = await res.text() |
| if (!res.ok) throw new Error(`${params.label} ${res.status}: ${rawText}`) |
| return rawText |
| } finally { |
| clearTimeout(timer) |
| } |
| } |
|
|
| function buildBaseInfo(): { channel_version: string } { |
| return { channel_version: CHANNEL_VERSION } |
| } |
|
|
| function buildCommonHeaders(): Record<string, string> { |
| return { |
| 'iLink-App-Id': ILINK_APP_ID, |
| 'iLink-App-ClientVersion': String(ILINK_APP_CLIENT_VERSION), |
| } |
| } |
|
|
| function buildHeaders(opts: { token?: string; body: string }): Record<string, string> { |
| const headers: Record<string, string> = { |
| 'Content-Type': 'application/json', |
| AuthorizationType: 'ilink_bot_token', |
| 'Content-Length': String(Buffer.byteLength(opts.body, 'utf-8')), |
| 'X-WECHAT-UIN': randomWechatUin(), |
| ...buildCommonHeaders(), |
| } |
| if (opts.token?.trim()) { |
| headers.Authorization = `Bearer ${opts.token.trim()}` |
| } |
| return headers |
| } |
|
|
| function ensureTrailingSlash(url: string): string { |
| return url.endsWith('/') ? url : `${url}/` |
| } |
|
|
| function randomWechatUin(): string { |
| const uint32 = crypto.randomBytes(4).readUInt32BE(0) |
| return Buffer.from(String(uint32), 'utf-8').toString('base64') |
| } |
|
|
| function assertWechatApiOk(rawText: string, label: string): void { |
| if (!rawText.trim()) return |
|
|
| let body: unknown |
| try { |
| body = JSON.parse(rawText) |
| } catch { |
| return |
| } |
|
|
| if (!body || typeof body !== 'object') return |
|
|
| const record = body as Record<string, unknown> |
| const code = typeof record.ret === 'number' |
| ? record.ret |
| : typeof record.errcode === 'number' |
| ? record.errcode |
| : 0 |
| if (code === 0) return |
|
|
| const message = typeof record.errmsg === 'string' ? record.errmsg : rawText |
| throw new Error(`${label} returned ${code}: ${message}`) |
| } |
|
|
| function isLoginFresh(login: ActiveLogin): boolean { |
| return Date.now() - login.startedAt < QR_LOGIN_TTL_MS |
| } |
|
|
| function purgeExpiredLogins(): void { |
| for (const [sessionKey, login] of activeLogins) { |
| if (!isLoginFresh(login)) activeLogins.delete(sessionKey) |
| } |
| } |
|
|
