@wu529778790/open-im 1.10.9-beta.2 → 1.10.9-beta.21

package/dist/clawbot/client.js

@@ -0,0 +1,299 @@
+/**
+ * ClawBot Client - WeChat iLink Bot API long-polling client
+ *
+ * Uses the official iLink protocol: POST + JSON body + Bearer token auth.
+ * Receives messages via long-polling ilink/bot/getupdates and dispatches
+ * them to the event handler.
+ *
+ * Reference: @tencent-weixin/openclaw-weixin, cc-wechat, claude-code-wechat-channel
+ */
+import { randomBytes } from 'node:crypto';
+import { createLogger } from '../logger.js';
+import { jitteredDelay, isFatalReconnectError, SLOW_PROBE_MS } from '../shared/reconnect.js';
+import { cacheContextToken } from './message-sender.js';
+import { CLAWBOT_POLL_INTERVAL_MS } from '../constants.js';
+const log = createLogger('ClawBot');
+const RECONNECT_DELAYS_MS = [3000, 5000, 10000, 20000, 30000];
+const BASE_INFO = { channel_version: '0.1.0' };
+let pollController = null;
+let channelState = 'disconnected';
+let messageHandler = null;
+let stateChangeHandler = null;
+let reconnectTimer = null;
+let reconnectAttempt = 0;
+let fatal = false;
+let stopped = false;
+let apiUrl = 'https://ilinkai.weixin.qq.com';
+let apiToken = '';
+/** Opaque cursor for getupdates pagination (replaces numeric offset) */
+let getUpdatesBuf = '';
+export function getChannelState() {
+    return channelState;
+}
+export async function initClawbot(config, eventHandler, onStateChange) {
+    const pc = config.platforms?.clawbot;
+    if (!pc?.enabled) {
+        throw new Error('ClawBot platform not enabled');
+    }
+    if (!pc.apiToken) {
+        throw new Error('ClawBot apiToken required');
+    }
+    apiUrl = pc.apiUrl ?? 'https://ilinkai.weixin.qq.com';
+    apiToken = pc.apiToken;
+    messageHandler = eventHandler;
+    stateChangeHandler = onStateChange ?? null;
+    stopped = false;
+    reconnectAttempt = 0;
+    fatal = false;
+    getUpdatesBuf = '';
+    // Verify connectivity — non-fatal, reconnect loop will retry
+    try {
+        const res = await postApi('/ilink/bot/getupdates', {
+            get_updates_buf: '',
+            base_info: BASE_INFO,
+        });
+        if (!res.ok) {
+            throw new Error(`API check failed: ${res.error ?? 'unknown'}`);
+        }
+        log.info(`ClawBot API reachable at ${apiUrl}`);
+        fatal = false;
+        reconnectAttempt = 0;
+        if (res.updatesBuf)
+            getUpdatesBuf = res.updatesBuf;
+        updateState('connected');
+        startPolling();
+    }
+    catch (err) {
+        if (isFatalReconnectError(err)) {
+            fatal = true;
+            log.warn('ClawBot API auth/session error, will slow-probe:', err);
+        }
+        else {
+            log.warn('ClawBot API not reachable, will retry:', err);
+        }
+        updateState('connecting');
+        scheduleReconnect();
+    }
+    log.info('ClawBot client initialized');
+}
+function startPolling() {
+    if (stopped || pollController)
+        return;
+    pollController = new AbortController();
+    const signal = pollController.signal;
+    (async () => {
+        log.info('ClawBot long-polling started');
+        while (!stopped && !signal.aborted) {
+            try {
+                const res = await postApi('/ilink/bot/getupdates', {
+                    get_updates_buf: getUpdatesBuf,
+                    base_info: BASE_INFO,
+                }, signal);
+                if (signal.aborted)
+                    break;
+                if (!res.ok) {
+                    // Detect fatal errors (e.g. errcode -14 "session timeout") — retrying won't help
+                    if (res.errcode === -14 || isFatalReconnectError(res.error)) {
+                        log.warn(`ClawBot fatal error (errcode=${res.errcode}), entering slow-probe mode`);
+                        fatal = true;
+                        getUpdatesBuf = ''; // session expired, cursor is stale
+                        updateState('error');
+                        scheduleReconnect();
+                        return;
+                    }
+                    log.warn(`ClawBot getupdates error: ${res.error ?? 'unknown'}`);
+                    await sleep(CLAWBOT_POLL_INTERVAL_MS, signal);
+                    continue;
+                }
+                // Successful response — clear fatal mode and reset backoff
+                if (fatal || reconnectAttempt > 0) {
+                    log.info('ClawBot connection recovered');
+                    fatal = false;
+                    reconnectAttempt = 0;
+                }
+                // Update cursor for next poll
+                if (res.updatesBuf) {
+                    getUpdatesBuf = res.updatesBuf;
+                }
+                // Process messages
+                const messages = res.messages ?? [];
+                for (const msg of messages) {
+                    if (signal.aborted)
+                        break;
+                    if (msg.message_type !== 1)
+                        continue; // skip BOT messages, only process USER
+                    const extracted = extractTextContent(msg);
+                    if (!extracted)
+                        continue;
+                    const chatId = msg.from_user_id ?? '';
+                    const msgId = String(msg.message_id ?? msg.seq ?? '');
+                    const content = extracted;
+                    if (!chatId) {
+                        log.warn('ClawBot message missing from_user_id, skipping');
+                        continue;
+                    }
+                    // Cache context_token for reply capability
+                    if (msg.context_token) {
+                        cacheContextToken(chatId, msg.context_token);
+                    }
+                    log.info(`ClawBot message: chatId=${chatId}, msgId=${msgId}, content="${content.substring(0, 100)}"`);
+                    if (messageHandler) {
+                        try {
+                            await messageHandler(chatId, msgId, content);
+                        }
+                        catch (err) {
+                            log.error('Error in ClawBot message handler:', err);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (signal.aborted)
+                    break;
+                if (err instanceof Error && err.name === 'AbortError')
+                    break;
+                log.error('ClawBot polling error:', err);
+                updateState('error');
+                scheduleReconnect();
+                return;
+            }
+        }
+    })();
+}
+function scheduleReconnect() {
+    if (stopped)
+        return;
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
+    const baseDelay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+    const delay = fatal ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
+    reconnectAttempt++;
+    if (fatal) {
+        log.warn(`ClawBot fatal error, slow-probe in ${Math.round(delay / 1000)}s (attempt ${reconnectAttempt})...`);
+    }
+    else {
+        log.info(`ClawBot reconnecting in ${delay}ms (attempt ${reconnectAttempt})...`);
+    }
+    reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        if (stopped)
+            return;
+        updateState('connected');
+        startPolling();
+    }, delay);
+}
+function updateState(state) {
+    channelState = state;
+    stateChangeHandler?.(state);
+    log.debug(`ClawBot state: ${state}`);
+}
+/**
+ * Extract text content from an iLink message's item_list.
+ * Returns the first text item found, or a placeholder for media types.
+ */
+function extractTextContent(msg) {
+    if (!msg.item_list?.length)
+        return null;
+    for (const item of msg.item_list) {
+        switch (item.type) {
+            case 1 /* MessageItemType.TEXT */: {
+                if (!item.text_item?.text)
+                    continue;
+                let text = item.text_item.text;
+                if (item.ref_msg?.title) {
+                    text = `[引用: ${item.ref_msg.title}]\n${text}`;
+                }
+                return text;
+            }
+            case 3 /* MessageItemType.VOICE */: {
+                const transcript = item.voice_item?.text;
+                if (transcript)
+                    return `[语音转文字] ${transcript}`;
+                return '[语音消息（无文字转录）]';
+            }
+            case 2 /* MessageItemType.IMAGE */:
+                return '[图片]';
+            case 4 /* MessageItemType.FILE */: {
+                const name = item.file_item?.file_name ? ` "${item.file_item.file_name}"` : '';
+                return `[文件${name}]`;
+            }
+            case 5 /* MessageItemType.VIDEO */:
+                return '[视频]';
+            default:
+                return `[未知消息类型 ${item.type}]`;
+        }
+    }
+    return null;
+}
+/**
+ * POST to iLink API with JSON body and Bearer token auth.
+ */
+async function postApi(endpoint, body, signal) {
+    const url = `${apiUrl}${endpoint}`;
+    const bodyStr = JSON.stringify(body);
+    const headers = {
+        'Content-Type': 'application/json',
+        'AuthorizationType': 'ilink_bot_token',
+        'X-WECHAT-UIN': randomBytes(4).readUInt32BE(0).toString(10),
+        'Authorization': `Bearer ${apiToken}`,
+    };
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: bodyStr,
+            signal,
+        });
+        const text = await res.text();
+        const raw = JSON.parse(text);
+        // iLink API: { ret: 0 } for success, { errcode: -14 } for session timeout, etc.
+        const ret = typeof raw.ret === 'number' ? raw.ret : undefined;
+        const errcode = typeof raw.errcode === 'number' ? raw.errcode : undefined;
+        const ok = ret === 0 || ret === undefined;
+        const error = ok ? undefined : String(raw.errmsg ?? raw.msg ?? `ret=${ret}`);
+        if (!ok) {
+            log.warn(`ClawBot API ${endpoint} response: ${text.substring(0, 500)}`);
+        }
+        return {
+            ok,
+            error,
+            errcode,
+            updatesBuf: typeof raw.get_updates_buf === 'string' ? raw.get_updates_buf : undefined,
+            messages: Array.isArray(raw.msgs) ? raw.msgs : undefined,
+        };
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            throw err;
+        }
+        log.warn(`ClawBot API ${endpoint} error:`, err);
+        throw err;
+    }
+}
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => { clearTimeout(timer); resolve(); }, { once: true });
+    });
+}
+export function stopClawbot() {
+    log.info('Stopping ClawBot client...');
+    stopped = true;
+    if (pollController) {
+        pollController.abort();
+        pollController = null;
+    }
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
+    messageHandler = null;
+    updateState('disconnected');
+    log.info('ClawBot client stopped');
+}

package/dist/clawbot/event-handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ClawBot Event Handler - Handle messages from iLink API long-polling
+ */
+import type { Config } from '../config.js';
+import type { SessionManager } from '../session/session-manager.js';
+export interface ClawBotEventHandlerHandle {
+    stop: () => void;
+    runningTasks: Map<string, import('../shared/ai-task.js').TaskRunState>;
+    getRunningTaskCount: () => number;
+    handleEvent: (chatId: string, msgId: string, content: string) => Promise<void>;
+}
+export declare function setupClawbotHandlers(config: Config, sessionManager: SessionManager): ClawBotEventHandlerHandle;

package/dist/clawbot/event-handler.js

@@ -0,0 +1,85 @@
+/**
+ * ClawBot Event Handler - Handle messages from iLink API long-polling
+ */
+import { sendTextReply, sendErrorReply } from './message-sender.js';
+import { startTaskCleanup } from '../shared/task-cleanup.js';
+import { CLAWBOT_THROTTLE_MS } from '../constants.js';
+import { createLogger } from '../logger.js';
+import { createPlatformEventContext } from '../platform/create-event-context.js';
+import { createPlatformAIRequestHandler } from '../platform/handle-ai-request.js';
+import { handleTextFlow } from '../platform/handle-text-flow.js';
+const log = createLogger('ClawBotHandler');
+export function setupClawbotHandlers(config, sessionManager) {
+    const ctx = createPlatformEventContext({
+        platform: 'clawbot',
+        allowedUserIds: config.clawbotAllowedUserIds,
+        config,
+        sessionManager,
+        sender: {
+            sendTextReply: async (chatId, text) => {
+                await sendTextReply(chatId, text);
+            },
+        },
+    });
+    const stopTaskCleanup = startTaskCleanup(ctx.runningTasks);
+    const platformSender = {
+        sendThinkingMessage: async (_chatId, _replyToMessageId, _toolId) => {
+            return 'clawbot_no_thinking';
+        },
+        sendTextReply: async (chatId, text) => {
+            await sendTextReply(chatId, text);
+        },
+        startTyping: (_chatId) => {
+            return () => { };
+        },
+    };
+    async function handleEvent(chatId, msgId, content) {
+        log.info(`[handleEvent] chatId=${chatId}, msgId=${msgId}, content="${content.substring(0, 100)}"`);
+        const userId = chatId;
+        const text = content.trim();
+        const msgIdSender = {
+            ...platformSender,
+            sendTextReply: async (c, t) => {
+                await sendTextReply(c, t);
+            },
+        };
+        const handleAIRequest = createPlatformAIRequestHandler({
+            platform: 'clawbot',
+            config,
+            sessionManager,
+            sender: msgIdSender,
+            throttleMs: CLAWBOT_THROTTLE_MS,
+            runningTasks: ctx.runningTasks,
+            taskKeyBuilder: (userId, _msgId) => `${userId}:${msgId}`,
+            taskCallbacksFactory: ({ chatId: c }) => ({
+                streamUpdate: async () => { },
+                sendComplete: async (content) => {
+                    await sendTextReply(c, content);
+                },
+                sendError: async (error) => {
+                    await sendErrorReply(c, error);
+                },
+            }),
+        });
+        await handleTextFlow({
+            platform: 'clawbot',
+            userId,
+            chatId,
+            text,
+            ctx,
+            handleAIRequest,
+            sendTextReply: (c, t) => sendTextReply(c, t),
+            workDir: sessionManager.getWorkDir(userId),
+            convId: sessionManager.getConvId(userId),
+            accessDeniedMessage: (uid) => `抱歉，您没有访问权限。\n您的 ID: ${uid}`,
+            queueFullMessage: '请求队列已满，请稍后再试。',
+            queuedMessage: '您的请求已排队等待。',
+        });
+    }
+    return {
+        stop: () => stopTaskCleanup(),
+        runningTasks: ctx.runningTasks,
+        getRunningTaskCount: () => ctx.runningTasks.size,
+        handleEvent,
+    };
+}

package/dist/clawbot/message-sender.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ClawBot Message Sender - Send messages via iLink Bot API
+ *
+ * Uses POST + JSON body + Bearer token auth (iLink protocol).
+ */
+export declare function initClawBotSender(url: string, token: string): void;
+/** Cache a context_token for a chatId (called when receiving messages) */
+export declare function cacheContextToken(chatId: string, token: string): void;
+/** Get cached context_token for a chatId */
+export declare function getCachedContextToken(chatId: string): string | undefined;
+/**
+ * Send text reply to a ClawBot chat, splitting long messages automatically.
+ */
+export declare function sendTextReply(chatId: string, text: string, contextToken?: string): Promise<void>;
+/**
+ * Send error reply to a ClawBot chat.
+ */
+export declare function sendErrorReply(chatId: string, error: string): Promise<void>;

package/dist/clawbot/message-sender.js

@@ -0,0 +1,109 @@
+/**
+ * ClawBot Message Sender - Send messages via iLink Bot API
+ *
+ * Uses POST + JSON body + Bearer token auth (iLink protocol).
+ */
+import { randomBytes } from 'node:crypto';
+import { createLogger } from '../logger.js';
+import { splitLongContent, toReplyPlainText } from '../shared/utils.js';
+import { MAX_CLAWBOT_MESSAGE_LENGTH } from '../constants.js';
+import { getChannelState } from './client.js';
+const log = createLogger('ClawBotSender');
+let apiUrl = 'https://ilinkai.weixin.qq.com';
+let apiToken = '';
+/** Cache of context_token per chatId, populated by incoming messages */
+const contextTokenCache = new Map();
+export function initClawBotSender(url, token) {
+    apiUrl = url;
+    apiToken = token;
+}
+/** Cache a context_token for a chatId (called when receiving messages) */
+export function cacheContextToken(chatId, token) {
+    contextTokenCache.set(chatId, token);
+}
+/** Get cached context_token for a chatId */
+export function getCachedContextToken(chatId) {
+    return contextTokenCache.get(chatId);
+}
+/** Build iLink API request headers */
+function buildHeaders() {
+    return {
+        'Content-Type': 'application/json',
+        'AuthorizationType': 'ilink_bot_token',
+        'X-WECHAT-UIN': randomBytes(4).readUInt32BE(0).toString(10),
+        'Authorization': `Bearer ${apiToken}`,
+    };
+}
+/** Generate a unique client_id for outbound messages */
+function generateClientId() {
+    return `open-im:${Date.now()}-${randomBytes(4).toString('hex')}`;
+}
+async function postMessage(chatId, text, contextToken) {
+    if (getChannelState() !== 'connected') {
+        log.warn('ClawBot not connected, cannot send message');
+        return false;
+    }
+    const token = contextToken ?? getCachedContextToken(chatId);
+    if (!token) {
+        log.warn(`ClawBot no context_token for chatId=${chatId}, cannot send reply`);
+        return false;
+    }
+    try {
+        const url = `${apiUrl}/ilink/bot/sendmessage`;
+        const body = JSON.stringify({
+            msg: {
+                from_user_id: '',
+                to_user_id: chatId,
+                client_id: generateClientId(),
+                message_type: 2, // BOT
+                message_state: 2, // FINISH
+                item_list: [{ type: 1, text_item: { text } }],
+                context_token: token,
+            },
+            base_info: { channel_version: '0.1.0' },
+        });
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: buildHeaders(),
+            body,
+        });
+        const data = await res.json();
+        const ok = data.ret === 0 || data.ret === undefined;
+        if (!ok) {
+            log.error(`ClawBot sendmessage failed: ret=${data.ret} errcode=${data.errcode} errmsg=${data.errmsg}`);
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        log.error('ClawBot sendmessage error:', err);
+        return false;
+    }
+}
+/**
+ * Send text reply to a ClawBot chat, splitting long messages automatically.
+ */
+export async function sendTextReply(chatId, text, contextToken) {
+    const plainText = toReplyPlainText(text);
+    const parts = splitLongContent(plainText, MAX_CLAWBOT_MESSAGE_LENGTH);
+    if (parts.length === 1) {
+        log.info(`Sending ClawBot reply to chatId=${chatId}, len=${plainText.length}`);
+        await postMessage(chatId, plainText, contextToken);
+        return;
+    }
+    log.info(`Sending ClawBot reply in ${parts.length} parts to chatId=${chatId}, totalLen=${plainText.length}`);
+    for (let i = 0; i < parts.length; i++) {
+        const partText = i === 0
+            ? `${parts[i]}\n\n_(1/${parts.length})_`
+            : `_(续 ${i + 1}/${parts.length})_\n\n${parts[i]}`;
+        await postMessage(chatId, partText, contextToken);
+        log.info(`ClawBot part ${i + 1}/${parts.length} sent`);
+    }
+}
+/**
+ * Send error reply to a ClawBot chat.
+ */
+export async function sendErrorReply(chatId, error) {
+    log.warn(`Sending ClawBot error to chatId=${chatId}`);
+    await postMessage(chatId, `错误: ${error}`);
+}

package/dist/clawbot/qr-login.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ClawBot QR Code Login - WeChat iLink API
+ *
+ * Calls https://ilinkai.weixin.qq.com to get QR code and poll for login confirmation.
+ * Returns bot_token on success.
+ */
+export interface QRLoginSession {
+    sessionKey: string;
+    qrcode: string;
+    qrcodeUrl: string;
+    startedAt: number;
+}
+export interface QRLoginResult {
+    connected: boolean;
+    botToken?: string;
+    accountId?: string;
+    baseUrl?: string;
+    userId?: string;
+    message: string;
+}
+export declare function fetchQRCode(): Promise<{
+    qrcode: string;
+    qrcodeUrl: string;
+}>;
+/**
+ * Start QR code login session. Returns QR code URL for display.
+ */
+export declare function startQRLogin(): Promise<QRLoginSession>;
+/**
+ * Wait for user to scan QR code. Polls until confirmed or timeout.
+ * Returns bot_token on success.
+ */
+export declare function waitForQRLogin(session: QRLoginSession, onStatusChange?: (status: string) => void): Promise<QRLoginResult>;

package/dist/clawbot/qr-login.js

@@ -0,0 +1,120 @@
+/**
+ * ClawBot QR Code Login - WeChat iLink API
+ *
+ * Calls https://ilinkai.weixin.qq.com to get QR code and poll for login confirmation.
+ * Returns bot_token on success.
+ */
+import { randomUUID } from 'node:crypto';
+import { createLogger } from '../logger.js';
+const log = createLogger('ClawBotQR');
+const ILINK_BASE_URL = 'https://ilinkai.weixin.qq.com';
+const ILINK_APP_ID = 'bot';
+const BOT_TYPE = '3';
+const POLL_TIMEOUT_MS = 35_000;
+const LOGIN_TIMEOUT_MS = 5 * 60_000;
+function buildHeaders() {
+    return {
+        'Content-Type': 'application/json',
+        'AuthorizationType': 'ilink_bot_token',
+        'X-WECHAT-UIN': randomUUID(),
+        'iLink-App-Id': ILINK_APP_ID,
+        'iLink-App-ClientVersion': '131588', // 2.4.4 encoded
+    };
+}
+export async function fetchQRCode() {
+    const url = `${ILINK_BASE_URL}/ilink/bot/get_bot_qrcode?bot_type=${BOT_TYPE}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: buildHeaders(),
+        body: JSON.stringify({ local_token_list: [] }),
+    });
+    const data = await res.json();
+    if (!data.qrcode) {
+        throw new Error('Failed to get QR code from iLink API');
+    }
+    return { qrcode: data.qrcode, qrcodeUrl: data.qrcode_img_content };
+}
+async function pollQRStatus(qrcode) {
+    const url = `${ILINK_BASE_URL}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), POLL_TIMEOUT_MS);
+    try {
+        const headers = buildHeaders();
+        delete headers['Content-Type'];
+        const res = await fetch(url, {
+            method: 'GET',
+            headers,
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        return await res.json();
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === 'AbortError') {
+            return { status: 'wait' };
+        }
+        throw err;
+    }
+}
+/**
+ * Start QR code login session. Returns QR code URL for display.
+ */
+export async function startQRLogin() {
+    log.info('Starting ClawBot QR login...');
+    const { qrcode, qrcodeUrl } = await fetchQRCode();
+    log.info(`QR code received, url=${qrcodeUrl}`);
+    return {
+        sessionKey: randomUUID(),
+        qrcode,
+        qrcodeUrl,
+        startedAt: Date.now(),
+    };
+}
+/**
+ * Wait for user to scan QR code. Polls until confirmed or timeout.
+ * Returns bot_token on success.
+ */
+export async function waitForQRLogin(session, onStatusChange) {
+    const deadline = Date.now() + LOGIN_TIMEOUT_MS;
+    let currentBaseUrl = ILINK_BASE_URL;
+    let redirectCount = 0;
+    log.info('Waiting for QR code scan...');
+    while (Date.now() < deadline) {
+        const result = await pollQRStatus(session.qrcode);
+        onStatusChange?.(result.status);
+        switch (result.status) {
+            case 'wait':
+            case 'scaned':
+                break;
+            case 'scaned_but_redirect':
+                if (result.redirect_host) {
+                    currentBaseUrl = `https://${result.redirect_host}`;
+                    redirectCount++;
+                    log.info(`IDC redirect to ${result.redirect_host} (${redirectCount})`);
+                }
+                break;
+            case 'confirmed':
+                if (!result.bot_token) {
+                    return { connected: false, message: '登录失败：服务器未返回 bot_token' };
+                }
+                log.info(`Login confirmed! botId=${result.ilink_bot_id}, baseurl=${result.baseurl ?? '(empty)'}`);
+                return {
+                    connected: true,
+                    botToken: result.bot_token,
+                    accountId: result.ilink_bot_id,
+                    baseUrl: result.baseurl || ILINK_BASE_URL,
+                    userId: result.ilink_user_id,
+                    message: '登录成功',
+                };
+            case 'expired':
+                return { connected: false, message: '二维码已过期，请重新生成' };
+            case 'binded_redirect':
+                return { connected: false, message: '已连接过，无需重复连接' };
+            default:
+                log.warn(`Unknown QR status: ${result.status}`);
+        }
+        await new Promise(r => setTimeout(r, 1000));
+    }
+    return { connected: false, message: '登录超时，请重试' };
+}