@wu529778790/open-im 1.10.9-beta.18 → 1.10.9-beta.19

package/dist/clawbot/client.d.ts

@@ -1,8 +1,11 @@
 /**
- * ClawBot Client - WeChat iLink API long-polling client
+ * ClawBot Client - WeChat iLink Bot API long-polling client
  *
- * Receives messages via long-polling ilink/bot/getupdates
- * and dispatches them to the event handler.
+ * 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 type { Config } from '../config.js';
 import type { ClawBotState } from './types.js';

package/dist/clawbot/client.js

@@ -1,25 +1,32 @@
 /**
- * ClawBot Client - WeChat iLink API long-polling client
+ * ClawBot Client - WeChat iLink Bot API long-polling client
  *
- * Receives messages via long-polling ilink/bot/getupdates
- * and dispatches them to the event handler.
+ * 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 { randomUUID } from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import { createLogger } from '../logger.js';
-import { jitteredDelay } from '../shared/reconnect.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 = 'http://127.0.0.1:26322';
+let apiUrl = 'https://ilinkai.weixin.qq.com';
 let apiToken = '';
-let lastUpdateId = 0;
+/** Opaque cursor for getupdates pagination (replaces numeric offset) */
+let getUpdatesBuf = '';
 export function getChannelState() {
     return channelState;
 }
@@ -31,25 +38,39 @@ export async function initClawbot(config, eventHandler, onStateChange) {
     if (!pc.apiToken) {
         throw new Error('ClawBot apiToken required');
     }
-    apiUrl = pc.apiUrl ?? 'http://127.0.0.1:26322';
+    apiUrl = pc.apiUrl ?? 'https://ilinkai.weixin.qq.com';
     apiToken = pc.apiToken;
     messageHandler = eventHandler;
     stateChangeHandler = onStateChange ?? null;
     stopped = false;
     reconnectAttempt = 0;
-    lastUpdateId = 0;
+    fatal = false;
+    getUpdatesBuf = '';
     // Verify connectivity — non-fatal, reconnect loop will retry
     try {
-        const res = await fetchApi('/ilink/bot/getupdates?timeout=1');
+        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) {
-        log.warn('ClawBot API not reachable, will retry:', 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();
     }
@@ -64,30 +85,57 @@ function startPolling() {
         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);
+                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;
                 }
-                const updates = res.result ?? [];
-                for (const update of updates) {
+                // 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;
-                    lastUpdateId = Math.max(lastUpdateId, update.update_id);
-                    const msg = update.message;
-                    if (!msg?.text)
+                    if (msg.message_type !== 1)
+                        continue; // skip BOT messages, only process USER
+                    const extracted = extractTextContent(msg);
+                    if (!extracted)
                         continue;
-                    const chatId = msg.chat?.id ?? msg.from?.id ?? '';
-                    const msgId = String(msg.message_id ?? update.update_id);
-                    const content = msg.text;
+                    const chatId = msg.from_user_id ?? '';
+                    const msgId = String(msg.message_id ?? msg.seq ?? '');
+                    const content = extracted;
                     if (!chatId) {
-                        log.warn('ClawBot message missing chatId, skipping');
+                        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 {
@@ -120,9 +168,14 @@ function scheduleReconnect() {
         reconnectTimer = null;
     }
     const baseDelay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
-    const delay = jitteredDelay(baseDelay);
+    const delay = fatal ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
     reconnectAttempt++;
-    log.info(`ClawBot reconnecting in ${delay}ms (attempt ${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)
@@ -136,41 +189,87 @@ function updateState(state) {
     stateChangeHandler?.(state);
     log.debug(`ClawBot state: ${state}`);
 }
-async function fetchApi(path, signal) {
-    const url = `${apiUrl}${path}`;
+/**
+ * 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',
-        'iLink-App-Id': 'bot',
-        'iLink-App-ClientVersion': '131588',
-        'X-WECHAT-UIN': randomUUID(),
+        'X-WECHAT-UIN': randomBytes(4).readUInt32BE(0).toString(10),
+        'Authorization': `Bearer ${apiToken}`,
     };
-    // Add bot_token to URL for authenticated endpoints
-    const sep = path.includes('?') ? '&' : '?';
-    const authedUrl = apiToken ? `${url}${sep}bot_token=${encodeURIComponent(apiToken)}` : url;
-    const res = await fetch(authedUrl, { headers, signal });
-    const text = await res.text();
     try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: bodyStr,
+            signal,
+        });
+        const text = await res.text();
         const raw = JSON.parse(text);
-        // iLink API uses {"ret": 0} for success, {"ret": -1} for error
-        if ('ret' in raw) {
-            const ok = raw.ret === 0 || raw.ret === '0';
-            const result = raw.result ?? raw.data ?? raw;
-            if (!ok) {
-                log.warn(`ClawBot API ${path.split('?')[0]} response: ${text.substring(0, 500)}`);
-            }
-            return { ok, error: ok ? undefined : String(raw.retmsg ?? raw.errmsg ?? raw.msg ?? `ret=${raw.ret}`), result };
+        // 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)}`);
         }
-        // Fallback: {"ok": true/false} format
-        const json = raw;
-        if (!json.ok) {
-            log.warn(`ClawBot API ${path.split('?')[0]} response: ${text.substring(0, 500)}`);
-        }
-        return json;
+        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 {
-        log.warn(`ClawBot API non-JSON response (${res.status}): ${text.substring(0, 300)}`);
-        return { ok: false, error: `HTTP ${res.status}: non-JSON response` };
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            throw err;
+        }
+        log.warn(`ClawBot API ${endpoint} error:`, err);
+        throw err;
     }
 }
 function sleep(ms, signal) {

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

@@ -1,11 +1,17 @@
 /**
- * ClawBot Message Sender - Send messages via iLink API
+ * 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): Promise<void>;
+export declare function sendTextReply(chatId: string, text: string, contextToken?: string): Promise<void>;
 /**
  * Send error reply to a ClawBot chat.
  */

package/dist/clawbot/message-sender.js

@@ -1,40 +1,76 @@
 /**
- * ClawBot Message Sender - Send messages via iLink API
+ * ClawBot Message Sender - Send messages via iLink Bot API
+ *
+ * Uses POST + JSON body + Bearer token auth (iLink protocol).
  */
-import { randomUUID } from 'node:crypto';
+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 = 'http://127.0.0.1:26322';
+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;
 }
-async function postMessage(chatId, text) {
+/** 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?bot_token=${encodeURIComponent(apiToken)}`;
+        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: {
-                'Content-Type': 'application/json',
-                'AuthorizationType': 'ilink_bot_token',
-                'iLink-App-Id': 'bot',
-                'iLink-App-ClientVersion': '131588',
-                'X-WECHAT-UIN': randomUUID(),
-            },
-            body: JSON.stringify({ chat_id: chatId, text }),
+            headers: buildHeaders(),
+            body,
         });
         const data = await res.json();
-        const ok = data.ok === true || data.ret === 0 || data.ret === '0';
+        const ok = data.ret === 0 || data.ret === undefined;
         if (!ok) {
-            log.error(`ClawBot sendmessage failed: ${JSON.stringify(data).substring(0, 300)}`);
+            log.error(`ClawBot sendmessage failed: ret=${data.ret} errcode=${data.errcode} errmsg=${data.errmsg}`);
             return false;
         }
         return true;
@@ -47,12 +83,12 @@ async function postMessage(chatId, text) {
 /**
  * Send text reply to a ClawBot chat, splitting long messages automatically.
  */
-export async function sendTextReply(chatId, text) {
+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);
+        await postMessage(chatId, plainText, contextToken);
         return;
     }
     log.info(`Sending ClawBot reply in ${parts.length} parts to chatId=${chatId}, totalLen=${plainText.length}`);
@@ -60,7 +96,7 @@ export async function sendTextReply(chatId, text) {
         const partText = i === 0
             ? `${parts[i]}\n\n_(1/${parts.length})_`
             : `_(续 ${i + 1}/${parts.length})_\n\n${parts[i]}`;
-        await postMessage(chatId, partText);
+        await postMessage(chatId, partText, contextToken);
         log.info(`ClawBot part ${i + 1}/${parts.length} sent`);
     }
 }

package/dist/clawbot/types.d.ts

@@ -1,43 +1,111 @@
 /**
- * ClawBot Types - WeChat iLink API
+ * ClawBot Types - WeChat iLink Bot API
+ *
+ * Matches the official iLink API protocol (POST + JSON body + Bearer token).
+ * Reference: @tencent-weixin/openclaw-weixin, cc-wechat, claude-code-wechat-channel
  */
 /** 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) */
+    /** iLink API base URL (default: https://ilinkai.weixin.qq.com) */
     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;
+/** iLink message content item types */
+export declare const enum MessageItemType {
+    NONE = 0,
+    TEXT = 1,
+    IMAGE = 2,
+    VOICE = 3,
+    FILE = 4,
+    VIDEO = 5
+}
+/** Text content item */
+export interface TextItem {
+    text?: string;
+}
+/** Image content item */
+export interface ImageItem {
+    media?: {
+        aes_key?: string;
+        cdn_url?: string;
+    };
+    width?: number;
+    height?: number;
+}
+/** Voice content item */
+export interface VoiceItem {
+    text?: string;
+    media?: {
+        aes_key?: string;
+        cdn_url?: string;
+    };
+    playtime?: number;
+}
+/** File content item */
+export interface FileItem {
+    file_name?: string;
+    file_size?: number;
+    media?: {
+        aes_key?: string;
+        cdn_url?: string;
     };
 }
+/** Video content item */
+export interface VideoItem {
+    media?: {
+        aes_key?: string;
+        cdn_url?: string;
+    };
+    duration_ms?: number;
+}
+/** A single content item in a message */
+export interface MessageItem {
+    type?: number;
+    text_item?: TextItem;
+    image_item?: ImageItem;
+    voice_item?: VoiceItem;
+    file_item?: FileItem;
+    video_item?: VideoItem;
+    ref_msg?: {
+        title?: string;
+        message_item?: MessageItem;
+    };
+    msg_id?: string;
+}
+/** iLink message from getupdates */
+export interface ILinkMessage {
+    seq?: number;
+    message_id?: number;
+    from_user_id?: string;
+    to_user_id?: string;
+    client_id?: string;
+    create_time_ms?: number;
+    session_id?: string;
+    /** 1=USER (inbound), 2=BOT (outbound) */
+    message_type?: number;
+    /** 0=NEW, 1=GENERATING, 2=FINISH */
+    message_state?: number;
+    item_list?: MessageItem[];
+    /** Token required for sending replies to this conversation */
+    context_token?: string;
+    group_id?: string;
+}
 /** getupdates response */
-export interface ClawBotUpdatesResponse {
-    ok: boolean;
-    result?: ClawBotUpdate[];
-    error?: string;
+export interface GetUpdatesResponse {
+    ret?: number;
+    errcode?: number;
+    errmsg?: string;
+    msgs?: ILinkMessage[];
+    /** Opaque cursor for next poll — pass back as-is */
+    get_updates_buf?: string;
+    longpolling_timeout_ms?: number;
 }
 /** sendmessage response */
-export interface ClawBotSendResponse {
-    ok: boolean;
-    result?: {
-        message_id: number;
-    };
-    error?: string;
+export interface SendMessageResponse {
+    ret?: number;
+    errcode?: number;
+    errmsg?: string;
 }

package/dist/clawbot/types.js

@@ -1,4 +1,7 @@
 /**
- * ClawBot Types - WeChat iLink API
+ * ClawBot Types - WeChat iLink Bot API
+ *
+ * Matches the official iLink API protocol (POST + JSON body + Bearer token).
+ * Reference: @tencent-weixin/openclaw-weixin, cc-wechat, claude-code-wechat-channel
  */
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.10.9-beta.18",
+  "version": "1.10.9-beta.19",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",