pikiloop 0.4.0

package/dist/channels/weixin/api.js

@@ -0,0 +1,520 @@
+/**
+ * WeChat official account API integration.
+ */
+import crypto from 'node:crypto';
+import QRCode from 'qrcode';
+import { VALIDATION_TIMEOUTS, WEIXIN_LIMITS } from '../../core/constants.js';
+export const WEIXIN_DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
+const WEIXIN_QR_LOGIN_TTL_MS = 5 * 60_000;
+const WEIXIN_DEFAULT_BOT_TYPE = '3';
+const WEIXIN_QR_CONTENT_CHECK_TIMEOUT_MS = 5_000;
+export const WeixinMessageType = {
+    NONE: 0,
+    USER: 1,
+    BOT: 2,
+};
+export const WeixinMessageItemType = {
+    NONE: 0,
+    TEXT: 1,
+    IMAGE: 2,
+    VOICE: 3,
+    FILE: 4,
+    VIDEO: 5,
+};
+export const WeixinMessageState = {
+    NEW: 0,
+    GENERATING: 1,
+    FINISH: 2,
+};
+export const WeixinTypingStatus = {
+    TYPING: 1,
+    CANCEL: 2,
+};
+const activeWeixinQrLogins = new Map();
+function randomWechatUin() {
+    const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), 'utf-8').toString('base64');
+}
+function withTimeoutSignal(timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return {
+        signal: controller.signal,
+        dispose: () => clearTimeout(timer),
+    };
+}
+/**
+ * Combine a timeout signal with an optional external "stop" signal so that
+ * either source can abort the in-flight request. Used by long-poll callers
+ * to cut over immediately when the channel is being torn down (config change,
+ * channel removal) without waiting out the long-poll timeout.
+ */
+function combineAbortSignals(timeoutMs, external) {
+    const timeout = withTimeoutSignal(timeoutMs);
+    if (!external)
+        return timeout;
+    if (external.aborted) {
+        timeout.dispose();
+        return { signal: external, dispose: () => { } };
+    }
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    timeout.signal.addEventListener('abort', onAbort, { once: true });
+    external.addEventListener('abort', onAbort, { once: true });
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            timeout.signal.removeEventListener('abort', onAbort);
+            external.removeEventListener('abort', onAbort);
+            timeout.dispose();
+        },
+    };
+}
+function buildWeixinHeaders(body, token) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Content-Length': String(Buffer.byteLength(body, 'utf-8')),
+        AuthorizationType: 'ilink_bot_token',
+        'X-WECHAT-UIN': randomWechatUin(),
+    };
+    if (token?.trim())
+        headers.Authorization = `Bearer ${token.trim()}`;
+    return headers;
+}
+function describeError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error ?? 'unknown error');
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+function normalizeFetchBaseUrl(baseUrl) {
+    const trimmed = String(baseUrl || '').trim();
+    return (trimmed || WEIXIN_DEFAULT_BASE_URL).replace(/\/+$/, '');
+}
+function isHttpUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function isImageDataUrl(value) {
+    return /^data:image\/[a-z0-9.+-]+;base64,/i.test(value);
+}
+function normalizeEncodedImageDataUrl(value) {
+    const trimmed = String(value || '').trim().replace(/\s+/g, '');
+    if (!trimmed)
+        return null;
+    if (isImageDataUrl(trimmed))
+        return trimmed;
+    if (trimmed.startsWith('iVBORw0KGgo'))
+        return `data:image/png;base64,${trimmed}`;
+    if (trimmed.startsWith('/9j/'))
+        return `data:image/jpeg;base64,${trimmed}`;
+    if (trimmed.startsWith('R0lGOD'))
+        return `data:image/gif;base64,${trimmed}`;
+    if (trimmed.startsWith('UklGR'))
+        return `data:image/webp;base64,${trimmed}`;
+    if (trimmed.startsWith('PHN2Zy') || trimmed.startsWith('PD94bWwg'))
+        return `data:image/svg+xml;base64,${trimmed}`;
+    return null;
+}
+async function probeRemoteContentType(url, timeoutMs) {
+    const headTimeout = withTimeoutSignal(timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method: 'HEAD',
+            signal: headTimeout.signal,
+        });
+        if (response.ok) {
+            const contentType = String(response.headers.get('content-type') || '').trim();
+            if (contentType)
+                return contentType;
+        }
+    }
+    catch { }
+    finally {
+        headTimeout.dispose();
+    }
+    const getTimeout = withTimeoutSignal(timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: { Range: 'bytes=0-0' },
+            signal: getTimeout.signal,
+        });
+        const contentType = String(response.headers.get('content-type') || '').trim();
+        void response.body?.cancel().catch(() => { });
+        return contentType;
+    }
+    catch {
+        return '';
+    }
+    finally {
+        getTimeout.dispose();
+    }
+}
+async function buildQrDataUrl(content) {
+    return QRCode.toDataURL(content, {
+        errorCorrectionLevel: 'M',
+        margin: 1,
+        width: 512,
+    });
+}
+export function normalizeWeixinBaseUrl(baseUrl) {
+    return normalizeFetchBaseUrl(baseUrl);
+}
+export async function resolveWeixinQrDisplayUrl(qrcodeImgContent) {
+    const trimmed = String(qrcodeImgContent || '').trim();
+    if (!trimmed)
+        throw new Error('Missing QR code image content.');
+    const embeddedImage = normalizeEncodedImageDataUrl(trimmed);
+    if (embeddedImage)
+        return embeddedImage;
+    if (isHttpUrl(trimmed)) {
+        const contentType = await probeRemoteContentType(trimmed, WEIXIN_QR_CONTENT_CHECK_TIMEOUT_MS);
+        if (/^image\//i.test(contentType))
+            return trimmed;
+        return buildQrDataUrl(trimmed);
+    }
+    return buildQrDataUrl(trimmed);
+}
+async function parseJsonResponse(response, label) {
+    const raw = await response.text();
+    if (!response.ok) {
+        throw new Error(`${label} failed: HTTP ${response.status} ${response.statusText || ''}`.trim());
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`${label} returned invalid JSON: ${describeError(error)}`);
+    }
+}
+async function weixinPostJson(params) {
+    const url = new URL(params.endpoint, `${normalizeFetchBaseUrl(params.baseUrl)}/`);
+    const body = JSON.stringify(params.body);
+    const combined = combineAbortSignals(params.timeoutMs, params.signal);
+    try {
+        const response = await fetch(url.toString(), {
+            method: 'POST',
+            headers: buildWeixinHeaders(body, params.token),
+            body,
+            signal: combined.signal,
+        });
+        return await parseJsonResponse(response, params.label);
+    }
+    finally {
+        combined.dispose();
+    }
+}
+async function weixinGetJson(params) {
+    const timeout = withTimeoutSignal(params.timeoutMs);
+    try {
+        const response = await fetch(params.url, {
+            method: 'GET',
+            headers: params.headers,
+            signal: timeout.signal,
+        });
+        return await parseJsonResponse(response, params.label);
+    }
+    finally {
+        timeout.dispose();
+    }
+}
+function purgeExpiredWeixinQrLogins() {
+    const now = Date.now();
+    for (const [sessionKey, login] of activeWeixinQrLogins) {
+        if (now - login.startedAt >= WEIXIN_QR_LOGIN_TTL_MS)
+            activeWeixinQrLogins.delete(sessionKey);
+    }
+}
+function buildSendMessageBody(toUserId, text, contextToken) {
+    return {
+        msg: {
+            from_user_id: '',
+            to_user_id: toUserId,
+            client_id: crypto.randomUUID(),
+            message_type: WeixinMessageType.BOT,
+            message_state: WeixinMessageState.FINISH,
+            item_list: text
+                ? [{ type: WeixinMessageItemType.TEXT, text_item: { text } }]
+                : undefined,
+            context_token: contextToken || undefined,
+        },
+        base_info: {},
+    };
+}
+export async function weixinGetUpdates(params) {
+    const timeoutMs = params.timeoutMs ?? WEIXIN_LIMITS.longPollTimeout;
+    try {
+        return await weixinPostJson({
+            baseUrl: params.baseUrl,
+            endpoint: 'ilink/bot/getupdates',
+            body: {
+                get_updates_buf: params.getUpdatesBuf ?? '',
+                base_info: {},
+            },
+            token: params.token,
+            timeoutMs,
+            label: 'weixin getupdates',
+            signal: params.signal,
+        });
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            return {
+                ret: 0,
+                msgs: [],
+                get_updates_buf: params.getUpdatesBuf ?? '',
+            };
+        }
+        throw error;
+    }
+}
+export async function weixinSendTextMessage(params) {
+    await weixinPostJson({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/sendmessage',
+        body: buildSendMessageBody(params.toUserId, params.text, params.contextToken),
+        token: params.token,
+        timeoutMs: params.timeoutMs ?? 15_000,
+        label: 'weixin sendmessage',
+    });
+}
+export async function weixinGetConfig(params) {
+    return weixinPostJson({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/getconfig',
+        body: {
+            ilink_user_id: params.userId,
+            context_token: params.contextToken || undefined,
+            base_info: {},
+        },
+        token: params.token,
+        timeoutMs: params.timeoutMs ?? 10_000,
+        label: 'weixin getconfig',
+    });
+}
+export async function weixinSendTyping(params) {
+    await weixinPostJson({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/sendtyping',
+        body: {
+            ilink_user_id: params.userId,
+            typing_ticket: params.typingTicket,
+            status: params.status ?? WeixinTypingStatus.TYPING,
+            base_info: {},
+        },
+        token: params.token,
+        timeoutMs: params.timeoutMs ?? 10_000,
+        label: 'weixin sendtyping',
+    });
+}
+export function extractWeixinTextBody(message) {
+    const items = message.item_list || [];
+    for (const item of items) {
+        if (item.type === WeixinMessageItemType.TEXT && item.text_item?.text) {
+            return String(item.text_item.text);
+        }
+        if (item.type === WeixinMessageItemType.VOICE && item.voice_item?.text) {
+            return String(item.voice_item.text);
+        }
+    }
+    return '';
+}
+export function markdownToWeixinPlainText(text) {
+    let result = String(text || '');
+    result = result.replace(/```[^\n]*\n?([\s\S]*?)```/g, (_, code) => code.trim());
+    result = result.replace(/!\[[^\]]*\]\([^)]*\)/g, '');
+    result = result.replace(/\[([^\]]+)\]\([^)]*\)/g, '$1');
+    result = result.replace(/^\|[\s:|-]+\|$/gm, '');
+    result = result.replace(/^\|(.+)\|$/gm, (_, inner) => inner.split('|').map(cell => cell.trim()).join('  '));
+    result = result.replace(/[*_~`>#-]/g, match => (match === '-' ? '-' : ''));
+    return result.replace(/\r\n?/g, '\n').trim();
+}
+function buildQrUrl(baseUrl, botType) {
+    return new URL(`ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`, `${normalizeFetchBaseUrl(baseUrl)}/`).toString();
+}
+function buildQrStatusUrl(baseUrl, qrcode) {
+    return new URL(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, `${normalizeFetchBaseUrl(baseUrl)}/`).toString();
+}
+async function fetchWeixinQrCode(baseUrl, botType) {
+    return weixinGetJson({
+        url: buildQrUrl(baseUrl, botType),
+        timeoutMs: VALIDATION_TIMEOUTS.weixinDefault,
+        label: 'weixin get_bot_qrcode',
+    });
+}
+async function fetchWeixinQrStatus(baseUrl, qrcode, timeoutMs) {
+    try {
+        return await weixinGetJson({
+            url: buildQrStatusUrl(baseUrl, qrcode),
+            timeoutMs,
+            label: 'weixin get_qrcode_status',
+            headers: {
+                'iLink-App-ClientVersion': '1',
+            },
+        });
+    }
+    catch (error) {
+        if (isAbortError(error))
+            return { status: 'wait' };
+        throw error;
+    }
+}
+export async function startWeixinQrLogin(params = {}) {
+    purgeExpiredWeixinQrLogins();
+    const sessionKey = String(params.sessionKey || crypto.randomUUID());
+    const baseUrl = normalizeFetchBaseUrl(params.baseUrl);
+    const existing = activeWeixinQrLogins.get(sessionKey);
+    if (existing) {
+        return {
+            ok: true,
+            sessionKey,
+            qrcodeUrl: existing.qrcodeUrl,
+            message: '二维码已生成，请使用微信扫描。',
+        };
+    }
+    try {
+        const qr = await fetchWeixinQrCode(baseUrl, params.botType || WEIXIN_DEFAULT_BOT_TYPE);
+        if (!qr.qrcode || !qr.qrcode_img_content) {
+            return {
+                ok: false,
+                sessionKey,
+                message: '微信未返回二维码数据。',
+                error: 'Missing QR code payload.',
+            };
+        }
+        const qrcodeUrl = await resolveWeixinQrDisplayUrl(qr.qrcode_img_content);
+        activeWeixinQrLogins.set(sessionKey, {
+            sessionKey,
+            qrcode: qr.qrcode,
+            qrcodeUrl,
+            startedAt: Date.now(),
+        });
+        return {
+            ok: true,
+            sessionKey,
+            qrcodeUrl,
+            message: '二维码已生成，请使用微信扫描。',
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            sessionKey,
+            message: '生成微信二维码失败。',
+            error: describeError(error),
+        };
+    }
+}
+export async function waitForWeixinQrLogin(params) {
+    purgeExpiredWeixinQrLogins();
+    const baseUrl = normalizeFetchBaseUrl(params.baseUrl);
+    const login = activeWeixinQrLogins.get(params.sessionKey);
+    if (!login) {
+        return {
+            ok: false,
+            connected: false,
+            status: 'error',
+            message: '当前没有进行中的微信扫码会话，请重新生成二维码。',
+            error: 'QR session not found.',
+        };
+    }
+    if (Date.now() - login.startedAt >= WEIXIN_QR_LOGIN_TTL_MS) {
+        activeWeixinQrLogins.delete(params.sessionKey);
+        return {
+            ok: false,
+            connected: false,
+            status: 'expired',
+            message: '二维码已过期，请重新生成。',
+            qrcodeUrl: login.qrcodeUrl,
+            error: 'QR session expired.',
+        };
+    }
+    try {
+        const status = await fetchWeixinQrStatus(baseUrl, login.qrcode, Math.max(1_000, params.timeoutMs ?? VALIDATION_TIMEOUTS.weixinQrPoll));
+        switch (status.status) {
+            case 'confirmed':
+                activeWeixinQrLogins.delete(params.sessionKey);
+                if (!status.bot_token || !status.ilink_bot_id) {
+                    return {
+                        ok: false,
+                        connected: false,
+                        status: 'error',
+                        message: '微信登录已确认，但返回数据不完整。',
+                        error: 'Missing bot token or account id.',
+                    };
+                }
+                return {
+                    ok: true,
+                    connected: true,
+                    status: 'confirmed',
+                    message: '微信连接成功。',
+                    botToken: status.bot_token,
+                    accountId: status.ilink_bot_id,
+                    userId: status.ilink_user_id,
+                    baseUrl: normalizeFetchBaseUrl(status.baseurl || baseUrl),
+                };
+            case 'expired': {
+                const refreshed = await fetchWeixinQrCode(baseUrl, params.botType || WEIXIN_DEFAULT_BOT_TYPE);
+                if (refreshed.qrcode && refreshed.qrcode_img_content) {
+                    const qrcodeUrl = await resolveWeixinQrDisplayUrl(refreshed.qrcode_img_content);
+                    activeWeixinQrLogins.set(params.sessionKey, {
+                        sessionKey: params.sessionKey,
+                        qrcode: refreshed.qrcode,
+                        qrcodeUrl,
+                        startedAt: Date.now(),
+                    });
+                    return {
+                        ok: true,
+                        connected: false,
+                        status: 'expired',
+                        message: '二维码已刷新，请重新扫码。',
+                        qrcodeUrl,
+                    };
+                }
+                return {
+                    ok: false,
+                    connected: false,
+                    status: 'expired',
+                    message: '二维码已过期，请重新生成。',
+                    qrcodeUrl: login.qrcodeUrl,
+                    error: 'Failed to refresh QR code.',
+                };
+            }
+            case 'scaned':
+                return {
+                    ok: true,
+                    connected: false,
+                    status: 'scaned',
+                    message: '已扫码，请在微信里确认。',
+                    qrcodeUrl: login.qrcodeUrl,
+                };
+            case 'wait':
+            default:
+                return {
+                    ok: true,
+                    connected: false,
+                    status: 'wait',
+                    message: '等待扫码中。',
+                    qrcodeUrl: login.qrcodeUrl,
+                };
+        }
+    }
+    catch (error) {
+        activeWeixinQrLogins.delete(params.sessionKey);
+        return {
+            ok: false,
+            connected: false,
+            status: 'error',
+            message: '微信扫码登录失败。',
+            error: describeError(error),
+        };
+    }
+}