@wu529778790/open-im 1.10.9-beta.11 → 1.10.9-beta.13

package/dist/channels/capabilities.js

@@ -5,6 +5,7 @@ const PLATFORM_LABELS = {
     wework: "企业微信",
     dingtalk: "钉钉",
     workbuddy: "WorkBuddy",
+    clawbot: "ClawBot",
 };
 export const CHANNEL_CAPABILITIES = {
     telegram: {
@@ -31,6 +32,10 @@ export const CHANNEL_CAPABILITIES = {
         inbound: { text: "native", image: "none", file: "none", voice: "none", video: "none" },
         outbound: { streamEdit: "none", streamPush: "none", image: "none", card: "none", typing: "none" },
     },
+    clawbot: {
+        inbound: { text: "native", image: "none", file: "none", voice: "none", video: "none" },
+        outbound: { streamEdit: "none", streamPush: "none", image: "none", card: "none", typing: "none" },
+    },
 };
 function listPreferredPlatforms(kind) {
     return Object.entries(CHANNEL_CAPABILITIES)

package/dist/clawbot/client.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ClawBot Client - WeChat iLink API long-polling client
+ *
+ * Receives messages via long-polling ilink/bot/getupdates
+ * and dispatches them to the event handler.
+ */
+import type { Config } from '../config.js';
+import type { ClawBotState } from './types.js';
+export declare function getChannelState(): ClawBotState;
+export declare function initClawbot(config: Config, eventHandler: (chatId: string, msgId: string, content: string) => Promise<void>, onStateChange?: (state: ClawBotState) => void): Promise<void>;
+export declare function stopClawbot(): void;

package/dist/clawbot/client.js

@@ -0,0 +1,169 @@
+/**
+ * ClawBot Client - WeChat iLink API long-polling client
+ *
+ * Receives messages via long-polling ilink/bot/getupdates
+ * and dispatches them to the event handler.
+ */
+import { createLogger } from '../logger.js';
+import { jitteredDelay } from '../shared/reconnect.js';
+import { CLAWBOT_POLL_INTERVAL_MS } from '../constants.js';
+const log = createLogger('ClawBot');
+const RECONNECT_DELAYS_MS = [3000, 5000, 10000, 20000, 30000];
+let pollController = null;
+let channelState = 'disconnected';
+let messageHandler = null;
+let stateChangeHandler = null;
+let reconnectTimer = null;
+let reconnectAttempt = 0;
+let stopped = false;
+let apiUrl = 'http://127.0.0.1:26322';
+let apiToken = '';
+let lastUpdateId = 0;
+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 ?? 'http://127.0.0.1:26322';
+    apiToken = pc.apiToken;
+    messageHandler = eventHandler;
+    stateChangeHandler = onStateChange ?? null;
+    stopped = false;
+    reconnectAttempt = 0;
+    lastUpdateId = 0;
+    // Verify connectivity
+    try {
+        const res = await fetchApi('/ilink/bot/getupdates?timeout=1');
+        if (!res.ok) {
+            throw new Error(`API check failed: ${res.error ?? 'unknown'}`);
+        }
+        log.info(`ClawBot API reachable at ${apiUrl}`);
+    }
+    catch (err) {
+        log.error('ClawBot API connectivity check failed:', err);
+        throw err;
+    }
+    updateState('connected');
+    startPolling();
+    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 url = `/ilink/bot/getupdates?timeout=30${lastUpdateId > 0 ? `&offset=${lastUpdateId + 1}` : ''}`;
+                const res = await fetchApi(url, signal);
+                if (signal.aborted)
+                    break;
+                if (!res.ok) {
+                    log.warn(`ClawBot getupdates error: ${res.error ?? 'unknown'}`);
+                    await sleep(CLAWBOT_POLL_INTERVAL_MS, signal);
+                    continue;
+                }
+                const updates = res.result ?? [];
+                for (const update of updates) {
+                    if (signal.aborted)
+                        break;
+                    lastUpdateId = Math.max(lastUpdateId, update.update_id);
+                    const msg = update.message;
+                    if (!msg?.text)
+                        continue;
+                    const chatId = msg.chat?.id ?? msg.from?.id ?? '';
+                    const msgId = String(msg.message_id ?? update.update_id);
+                    const content = msg.text;
+                    if (!chatId) {
+                        log.warn('ClawBot message missing chatId, skipping');
+                        continue;
+                    }
+                    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 = jitteredDelay(baseDelay);
+    reconnectAttempt++;
+    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}`);
+}
+async function fetchApi(path, signal) {
+    const url = `${apiUrl}${path}`;
+    const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${apiToken}` },
+        signal,
+    });
+    return res.json();
+}
+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,12 @@
+/**
+ * ClawBot Message Sender - Send messages via iLink API
+ */
+export declare function initClawBotSender(url: string, token: string): void;
+/**
+ * Send text reply to a ClawBot chat, splitting long messages automatically.
+ */
+export declare function sendTextReply(chatId: string, text: 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,67 @@
+/**
+ * ClawBot Message Sender - Send messages via iLink API
+ */
+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 = 'http://127.0.0.1:26322';
+let apiToken = '';
+export function initClawBotSender(url, token) {
+    apiUrl = url;
+    apiToken = token;
+}
+async function postMessage(chatId, text) {
+    if (getChannelState() !== 'connected') {
+        log.warn('ClawBot not connected, cannot send message');
+        return false;
+    }
+    try {
+        const res = await fetch(`${apiUrl}/ilink/bot/sendmessage`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiToken}`,
+            },
+            body: JSON.stringify({ chat_id: chatId, text }),
+        });
+        const data = await res.json();
+        if (!data.ok) {
+            log.error(`ClawBot sendmessage failed: ${data.error ?? 'unknown'}`);
+            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) {
+    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);
+        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);
+        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}`);
+                return {
+                    connected: true,
+                    botToken: result.bot_token,
+                    accountId: result.ilink_bot_id,
+                    baseUrl: result.baseurl,
+                    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: '登录超时，请重试' };
+}

package/dist/clawbot/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ClawBot Types - WeChat iLink API
+ */
+/** Connection state */
+export type ClawBotState = 'disconnected' | 'connecting' | 'connected' | 'error';
+/** ClawBot configuration */
+export interface ClawBotConfig {
+    /** iLink API base URL (default: http://127.0.0.1:26322) */
+    apiUrl: string;
+    /** Bearer token for authentication */
+    apiToken: string;
+}
+/** Message from getupdates */
+export interface ClawBotUpdate {
+    update_id: number;
+    message?: {
+        message_id: number;
+        from?: {
+            id: string;
+            name?: string;
+        };
+        chat?: {
+            id: string;
+            type?: string;
+        };
+        text?: string;
+        date?: number;
+    };
+}
+/** getupdates response */
+export interface ClawBotUpdatesResponse {
+    ok: boolean;
+    result?: ClawBotUpdate[];
+    error?: string;
+}
+/** sendmessage response */
+export interface ClawBotSendResponse {
+    ok: boolean;
+    result?: {
+        message_id: number;
+    };
+    error?: string;
+}

package/dist/clawbot/types.js

@@ -0,0 +1,4 @@
+/**
+ * ClawBot Types - WeChat iLink API
+ */
+export {};

package/dist/config/types.d.ts

@@ -1,5 +1,5 @@
 import type { LogLevel } from '../logger.js';
-export type Platform = 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wework' | 'workbuddy';
+export type Platform = 'clawbot' | 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wework' | 'workbuddy';
 export type AiCommand = 'claude' | 'codex' | 'codebuddy';
 export interface Config {
     enabledPlatforms: Platform[];
@@ -21,6 +21,7 @@ export interface Config {
     weworkAllowedUserIds: string[];
     dingtalkAllowedUserIds: string[];
     workbuddyAllowedUserIds: string[];
+    clawbotAllowedUserIds: string[];
     codexCliPath: string;
     codebuddyCliPath: string;
     /** Claude 访问 API 的代理（如 http://127.0.0.1:7890） */
@@ -87,6 +88,13 @@ export interface Config {
             guid?: string;
             workspacePath?: string;
         };
+        clawbot?: {
+            enabled: boolean;
+            aiCommand?: AiCommand;
+            allowedUserIds: string[];
+            apiUrl?: string;
+            apiToken?: string;
+        };
     };
 }
 export interface FilePlatformTelegram {
@@ -147,6 +155,13 @@ export interface FilePlatformWorkBuddy {
     guid?: string;
     workspacePath?: string;
 }
+export interface FilePlatformClawbot {
+    enabled?: boolean;
+    aiCommand?: AiCommand;
+    allowedUserIds?: string[];
+    apiUrl?: string;
+    apiToken?: string;
+}
 export interface FileToolClaude {
     cliPath?: string;
     workDir?: string;
@@ -180,6 +195,7 @@ export interface FileConfig {
         wework?: FilePlatformWework;
         dingtalk?: FilePlatformDingtalk;
         workbuddy?: FilePlatformWorkBuddy;
+        clawbot?: FilePlatformClawbot;
     };
     /** @deprecated 仅旧配置兼容；运行时以各 platforms.*.aiCommand 为准 */
     aiCommand?: string;