@wu529778790/open-im 1.8.2 → 1.8.3-beta.0

package/dist/config.d.ts

@@ -64,6 +64,7 @@ export interface Config {
         wechat?: {
             enabled: boolean;
             aiCommand?: AiCommand;
+            loginMode?: 'qclaw' | 'workbuddy';
             wsUrl?: string;
             token?: string;
             jwtToken?: string;
@@ -71,6 +72,10 @@ export interface Config {
             guid?: string;
             userId?: string;
             allowedUserIds: string[];
+            workbuddyAccessToken?: string;
+            workbuddyRefreshToken?: string;
+            workbuddyBaseUrl?: string;
+            workbuddyHostId?: string;
         };
         wework?: {
             enabled: boolean;
@@ -122,6 +127,8 @@ interface FilePlatformWechat {
     appId?: string;
     appSecret?: string;
     aiCommand?: AiCommand;
+    /** 连接模式：qclaw（QClaw JPRX 网关）或 workbuddy（Centrifuge） */
+    loginMode?: 'qclaw' | 'workbuddy';
     token?: string;
     jwtToken?: string;
     loginKey?: string;
@@ -129,6 +136,10 @@ interface FilePlatformWechat {
     userId?: string;
     wsUrl?: string;
     allowedUserIds?: string[];
+    workbuddyAccessToken?: string;
+    workbuddyRefreshToken?: string;
+    workbuddyBaseUrl?: string;
+    workbuddyHostId?: string;
 }
 export interface FilePlatformWework {
     enabled?: boolean;

package/dist/config.js

@@ -251,6 +251,7 @@ export function loadConfig() {
     // 微信支持两种协议：
     // 1. AGP 协议：token + guid + userId（推荐）
     // 2. 标准协议：appId + appSecret
+    const wechatLoginMode = fileWechat?.loginMode ?? 'qclaw';
     const wechatToken = process.env.WECHAT_TOKEN ??
         fileWechat?.token;
     const wechatJwtToken = fileWechat?.jwtToken;
@@ -265,6 +266,15 @@ export function loadConfig() {
         fileWechat?.appSecret;
     const wechatWsUrl = process.env.WECHAT_WS_URL ??
         fileWechat?.wsUrl;
+    // 微信 WorkBuddy 模式凭证（loginMode === 'workbuddy' 时使用）
+    const wechatWorkbuddyAccessToken = process.env.WECHAT_WORKBUDDY_ACCESS_TOKEN ??
+        fileWechat?.workbuddyAccessToken;
+    const wechatWorkbuddyRefreshToken = process.env.WECHAT_WORKBUDDY_REFRESH_TOKEN ??
+        fileWechat?.workbuddyRefreshToken;
+    const wechatWorkbuddyBaseUrl = process.env.WECHAT_WORKBUDDY_BASE_URL ??
+        fileWechat?.workbuddyBaseUrl;
+    const wechatWorkbuddyHostId = process.env.WECHAT_WORKBUDDY_HOST_ID ??
+        fileWechat?.workbuddyHostId;
     const weworkCorpId = process.env.WEWORK_CORP_ID ??
         fileWework?.corpId;
     const weworkSecret = process.env.WEWORK_SECRET ??
@@ -302,10 +312,15 @@ export function loadConfig() {
     const telegramEnabled = !!telegramBotToken && (telegramEnabledFlag !== false);
     const feishuEnabled = !!(feishuAppId && feishuAppSecret) && (feishuEnabledFlag !== false);
     const qqEnabled = !!(qqAppId && qqSecret) && (qqEnabledFlag !== false);
-    // 微信启用条件：AGP 协议凭证 或 标准协议凭证
+    // 微信启用条件：
+    // - qclaw 模式：AGP 协议凭证（token + guid + userId）或 标准协议凭证（appId + appSecret）
+    // - workbuddy 模式：workbuddy OAuth 凭证
     const hasWechatAGPCreds = !!(wechatToken && wechatGuid && wechatUserId);
     const hasWechatStandardCreds = !!(wechatAppId && wechatAppSecret);
-    const wechatEnabled = (hasWechatAGPCreds || hasWechatStandardCreds) && (wechatEnabledFlag !== false);
+    const hasWechatWorkbuddyCreds = !!(wechatWorkbuddyAccessToken && wechatWorkbuddyRefreshToken);
+    const wechatEnabled = (wechatLoginMode === 'workbuddy'
+        ? hasWechatWorkbuddyCreds
+        : (hasWechatAGPCreds || hasWechatStandardCreds)) && (wechatEnabledFlag !== false);
     // 企业微信只需要 corpId (botId) 和 secret
     const weworkEnabled = !!(weworkCorpId && weworkSecret) && (weworkEnabledFlag !== false);
     const dingtalkEnabled = !!(dingtalkClientId && dingtalkClientSecret) && (dingtalkEnabledFlag !== false);
@@ -558,6 +573,7 @@ export function loadConfig() {
             ? {
                 enabled: true,
                 aiCommand: normalizeAiCommand(file.platforms?.wechat?.aiCommand, aiCommand),
+                loginMode: wechatLoginMode,
                 wsUrl: wechatWsUrl,
                 token: wechatToken,
                 jwtToken: wechatJwtToken,
@@ -565,10 +581,15 @@ export function loadConfig() {
                 guid: wechatGuid,
                 userId: wechatUserId,
                 allowedUserIds: wechatAllowedUserIds,
+                workbuddyAccessToken: wechatWorkbuddyAccessToken,
+                workbuddyRefreshToken: wechatWorkbuddyRefreshToken,
+                workbuddyBaseUrl: wechatWorkbuddyBaseUrl,
+                workbuddyHostId: wechatWorkbuddyHostId,
             }
             : {
                 enabled: false,
                 aiCommand: normalizeAiCommand(file.platforms?.wechat?.aiCommand, aiCommand),
+                loginMode: wechatLoginMode,
                 wsUrl: wechatWsUrl,
                 token: wechatToken,
                 jwtToken: wechatJwtToken,
@@ -576,6 +597,10 @@ export function loadConfig() {
                 guid: wechatGuid,
                 userId: wechatUserId,
                 allowedUserIds: wechatAllowedUserIds,
+                workbuddyAccessToken: wechatWorkbuddyAccessToken,
+                workbuddyRefreshToken: wechatWorkbuddyRefreshToken,
+                workbuddyBaseUrl: wechatWorkbuddyBaseUrl,
+                workbuddyHostId: wechatWorkbuddyHostId,
             },
         wework: weworkEnabled
             ? {

package/dist/wechat/client.d.ts

@@ -1,8 +1,15 @@
 /**
- * WeChat Client - AGP WebSocket implementation for WeChat integration
+ * WeChat Client - 薄封装层，根据 loginMode 委托给对应 transport
+ *
+ * 支持两种通道：
+ * - qclaw: 直连腾讯 JPRX 网关（默认）
+ * - workbuddy: 通过 Centrifuge WebSocket 连接
  */
 import type { Config } from '../config.js';
 import type { AGPEnvelope, WeChatChannelState, WeChatToken } from './types.js';
+/**
+ * Dispatch incoming AGP envelope to the event handler
+ */
 export declare function dispatchIncomingAGPEnvelope(envelope: AGPEnvelope, handler: ((data: unknown) => Promise<void>) | null): Promise<void>;
 /**
  * Get current channel state
@@ -13,11 +20,11 @@ export declare function getChannelState(): WeChatChannelState;
  */
 export declare function getCurrentToken(): WeChatToken | null;
 /**
- * Initialize WeChat client with AGP WebSocket connection
+ * Initialize WeChat client
  */
 export declare function initWeChat(config: Config, eventHandler: (data: unknown) => Promise<void>, onStateChange?: (state: WeChatChannelState) => void): Promise<void>;
 /**
- * Send AGP message through WebSocket
+ * Send AGP message through the transport
  */
 export declare function sendAGPMessage<T>(method: string, payload: T, replyTo?: string): void;
 /**

package/dist/wechat/client.js

@@ -1,33 +1,36 @@
 /**
- * WeChat Client - AGP WebSocket implementation for WeChat integration
+ * WeChat Client - 薄封装层，根据 loginMode 委托给对应 transport
+ *
+ * 支持两种通道：
+ * - qclaw: 直连腾讯 JPRX 网关（默认）
+ * - workbuddy: 通过 Centrifuge WebSocket 连接
  */
-import { WebSocket } from 'ws';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { createLogger } from '../logger.js';
+import { QClawTransport } from './qclaw-transport.js';
+import { WorkBuddyTransport } from './workbuddy-transport.js';
 const log = createLogger('WeChat');
 const TOKEN_FILE = 'wechat-token.json';
-const DEFAULT_WECHAT_WS_URL = 'wss://openclau-wechat.henryxiaoyang.workers.dev';
-const PONG_TIMEOUT_FACTOR = 3; // 3倍心跳间隔无响应则判定连接死亡
 // Global state
-let ws = null;
+let transport = null;
 let channelState = 'disconnected';
-let reconnectTimer = null;
-let heartbeatTimer = null;
-let reconnectAttempts = 0;
 let currentToken = null;
 let tokenStoragePath = null;
-let lastServerResponseTime = 0; // 上次收到服务端消息的时间
-let wsConfigRef = null; // 保存配置供心跳重连使用
-let isStopping = false; // 防止 stop 后重连定时器继续触发
+let isStopping = false;
 // Event handlers
 let messageHandler = null;
 let stateChangeHandler = null;
+/**
+ * Dispatch incoming AGP envelope to the event handler
+ */
 export async function dispatchIncomingAGPEnvelope(envelope, handler) {
     switch (envelope.method) {
         case 'ping':
-            // Respond to ping with pong
-            sendAGPMessage('ping', { timestamp: Date.now() }, envelope.msg_id);
+            // Respond to ping with pong via transport
+            if (transport) {
+                transport.send('ping', { timestamp: Date.now() }, envelope.msg_id);
+            }
             break;
         case 'session.prompt':
         case 'session.update':
@@ -37,7 +40,6 @@ export async function dispatchIncomingAGPEnvelope(envelope, handler) {
             }
             break;
         case 'session.promptResponse':
-            // Handle response to our prompt
             log.debug('Received prompt response:', envelope.payload);
             break;
         default:
@@ -57,21 +59,9 @@ export function getCurrentToken() {
     return currentToken;
 }
 /**
- * Initialize WeChat client with AGP WebSocket connection
+ * Initialize WeChat client
  */
 export async function initWeChat(config, eventHandler, onStateChange) {
-    // AGP 协议使用 token + guid，标准协议使用 appId + appSecret
-    const hasAGPCreds = config.wechatToken && config.wechatGuid;
-    const hasStandardCreds = config.wechatAppId && config.wechatAppSecret;
-    if (!hasAGPCreds && !hasStandardCreds) {
-        throw new Error('WeChat credentials required: AGP (token + guid) or standard (appId + appSecret)');
-    }
-    if (hasAGPCreds) {
-        log.info('Using AGP protocol for WeChat');
-    }
-    else {
-        log.info('Using standard OAuth protocol for WeChat');
-    }
     messageHandler = eventHandler;
     stateChangeHandler = onStateChange ?? null;
     isStopping = false;
@@ -83,227 +73,77 @@ export async function initWeChat(config, eventHandler, onStateChange) {
     }
     // Load existing token if available
     await loadToken();
-    // Configure WebSocket
-    const wsConfig = {
-        url: config.wechatWsUrl ?? DEFAULT_WECHAT_WS_URL,
-        reconnectInterval: 5000,
-        maxReconnectAttempts: 10,
-        heartbeatInterval: 30000,
-    };
-    await connectWebSocket(wsConfig);
-    log.info('WeChat client initialized');
-}
-/**
- * Connect to AGP WebSocket server
- */
-async function connectWebSocket(config) {
-    wsConfigRef = config;
-    if (channelState === 'connecting') {
-        log.warn('WebSocket connection already in progress');
-        return;
+    // Determine login mode from config
+    const loginMode = config.platforms.wechat?.loginMode ?? 'qclaw';
+    log.info(`Initializing WeChat with loginMode: ${loginMode}`);
+    if (loginMode === 'workbuddy') {
+        transport = createWorkBuddyTransport(config);
     }
-    updateState('connecting');
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        // Connection timeout to prevent promise from hanging forever
-        const connectionTimeout = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            const err = new Error('WeChat WebSocket connection timeout');
-            log.error(err.message);
-            updateState('error');
-            try {
-                ws?.close();
-            }
-            catch { /* ignore */ }
-            reject(err);
-        }, 30000);
-        try {
-            ws = new WebSocket(config.url);
-            ws.on('open', () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(connectionTimeout);
-                log.info('WeChat WebSocket connected');
-                reconnectAttempts = 0;
-                updateState('connected');
-                startHeartbeat(config.heartbeatInterval ?? 30000);
-                resolve();
-            });
-            ws.on('message', async (data) => {
-                lastServerResponseTime = Date.now();
-                try {
-                    const envelope = JSON.parse(data.toString());
-                    log.debug('Received AGP message:', envelope.method);
-                    await handleAGPMessage(envelope);
-                }
-                catch (err) {
-                    log.error('Error parsing WebSocket message:', err);
-                }
-            });
-            ws.on('error', (err) => {
-                if (settled) {
-                    // Late error after connection was established — just log it
-                    log.error('WeChat WebSocket error (after open):', err);
-                    return;
-                }
-                settled = true;
-                clearTimeout(connectionTimeout);
-                log.error('WeChat WebSocket error:', err);
-                updateState('error');
-                reject(err);
-            });
-            ws.on('close', () => {
-                clearTimeout(connectionTimeout);
-                log.info('WeChat WebSocket closed');
-                stopHeartbeat();
-                updateState('disconnected');
-                if (!settled) {
-                    settled = true;
-                    reject(new Error('WeChat WebSocket closed before open'));
-                    return;
-                }
-                scheduleReconnect(config);
-            });
-        }
-        catch (err) {
-            settled = true;
-            clearTimeout(connectionTimeout);
-            log.error('Error creating WebSocket connection:', err);
-            updateState('error');
-            reject(err);
-        }
-    });
-}
-/**
- * Handle incoming AGP messages
- */
-async function handleAGPMessage(envelope) {
-    try {
-        await dispatchIncomingAGPEnvelope(envelope, messageHandler);
+    else {
+        transport = createQClawTransport(config);
     }
-    catch (err) {
-        if (envelope.method === 'session.prompt' || envelope.method === 'session.update' || envelope.method === 'session.cancel') {
-            log.error('Error in message handler:', err);
-            return;
+    // Wire up transport callbacks
+    transport.onMessage(async (envelope) => {
+        await dispatchIncomingAGPEnvelope(envelope, messageHandler);
+    });
+    transport.onStateChange((state) => {
+        channelState = state;
+        if (stateChangeHandler) {
+            stateChangeHandler(state);
         }
-        throw err;
-    }
+    });
+    await transport.start();
+    log.info(`WeChat client initialized (${loginMode} mode)`);
 }
 /**
- * Send AGP message through WebSocket
+ * Create QClaw transport from config
  */
-export function sendAGPMessage(method, payload, replyTo) {
-    if (!ws || channelState !== 'connected') {
-        log.warn('Cannot send message: WebSocket not connected');
-        return;
-    }
-    const envelope = {
-        msg_id: replyTo ?? generateMsgId(),
-        method: method,
-        payload,
+function createQClawTransport(config) {
+    const qclawConfig = {
+        channelToken: config.wechatToken,
+        jwtToken: config.wechatJwtToken ?? config.platforms.wechat?.jwtToken,
+        loginKey: config.wechatLoginKey ?? config.platforms.wechat?.loginKey,
+        guid: config.wechatGuid,
+        userId: config.wechatUserId,
+        wsUrl: config.wechatWsUrl,
     };
-    try {
-        ws.send(JSON.stringify(envelope));
-        log.debug('Sent AGP message:', method);
-    }
-    catch (err) {
-        log.error('Error sending AGP message:', err);
-    }
-}
-/**
- * Generate unique message ID
- */
-function generateMsgId() {
-    return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
-}
-/**
- * Update channel state and notify listeners
- */
-function updateState(state) {
-    channelState = state;
-    if (stateChangeHandler) {
-        stateChangeHandler(state);
-    }
-    log.debug('Channel state:', state);
+    return new QClawTransport(qclawConfig);
 }
 /**
- * Start heartbeat to keep connection alive
- * 同时检测服务端是否响应，超时无响应则主动断开触发重连
+ * Create WorkBuddy transport from config
  */
-function startHeartbeat(interval) {
-    stopHeartbeat();
-    lastServerResponseTime = Date.now();
-    heartbeatTimer = setInterval(() => {
-        if (channelState === 'connected') {
-            // 检测连接是否已死：长时间未收到任何服务端响应
-            const elapsed = Date.now() - lastServerResponseTime;
-            const pongTimeout = interval * PONG_TIMEOUT_FACTOR;
-            if (lastServerResponseTime > 0 && elapsed > pongTimeout) {
-                log.warn(`No server response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
-                stopHeartbeat();
-                if (ws) {
-                    try {
-                        ws.removeAllListeners();
-                        ws.close();
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                    ws = null;
-                }
-                updateState('disconnected');
-                if (wsConfigRef) {
-                    scheduleReconnect(wsConfigRef);
-                }
-                return;
-            }
-            sendAGPMessage('ping', { timestamp: Date.now() });
-        }
-    }, interval);
+function createWorkBuddyTransport(config) {
+    const wp = config.platforms.wechat;
+    const workbuddyConfig = {
+        accessToken: wp?.workbuddyAccessToken ?? '',
+        refreshToken: wp?.workbuddyRefreshToken ?? '',
+        userId: config.wechatUserId ?? wp?.userId ?? '',
+        hostId: wp?.workbuddyHostId,
+        baseUrl: wp?.workbuddyBaseUrl,
+    };
+    return new WorkBuddyTransport(workbuddyConfig);
 }
 /**
- * Stop heartbeat
+ * Send AGP message through the transport
  */
-function stopHeartbeat() {
-    if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
+export function sendAGPMessage(method, payload, replyTo) {
+    if (!transport) {
+        log.warn('Cannot send message: transport not initialized');
+        return;
     }
+    transport.send(method, payload, replyTo);
 }
 /**
- * Schedule reconnection attempt
- * 超过 maxAttempts 后自动重置计数器继续重试，避免永久断连
+ * Stop WeChat client
  */
-function scheduleReconnect(config) {
-    if (isStopping)
-        return;
-    const maxAttempts = config.maxReconnectAttempts ?? 10;
-    if (reconnectTimer) {
-        return;
-    }
-    // 超过最大重试次数后重置计数器，降低频率继续重试
-    if (reconnectAttempts >= maxAttempts) {
-        log.warn(`Max reconnect attempts (${maxAttempts}) reached, resetting counter and retrying at lower frequency`);
-        reconnectAttempts = 0;
+export function stopWeChat() {
+    isStopping = true;
+    if (transport) {
+        transport.stop();
+        transport = null;
     }
-    const baseInterval = config.reconnectInterval ?? 5000;
-    // 超过一半次数后逐渐增加间隔，最大 60 秒
-    const backoff = Math.min(baseInterval * Math.pow(1.5, Math.floor(reconnectAttempts / 3)), 60000);
-    const interval = Math.round(backoff);
-    reconnectTimer = setTimeout(async () => {
-        reconnectTimer = null;
-        reconnectAttempts++;
-        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${maxAttempts} (interval: ${interval}ms)`);
-        try {
-            await connectWebSocket(config);
-        }
-        catch (err) {
-            log.error('Reconnection failed:', err);
-        }
-    }, interval);
+    channelState = 'disconnected';
+    log.info('WeChat client stopped');
 }
 /**
  * Load token from storage
@@ -316,7 +156,6 @@ async function loadToken() {
         try {
             const data = readFileSync(tokenPath, 'utf-8');
             currentToken = JSON.parse(data);
-            // Check if token is expired
             if (currentToken.expires_at < Date.now()) {
                 log.info('Token expired, need to re-authenticate');
                 currentToken = null;
@@ -346,20 +185,3 @@ function saveToken() {
         log.error('Error saving token:', err);
     }
 }
-/**
- * Stop WeChat client
- */
-export function stopWeChat() {
-    isStopping = true;
-    stopHeartbeat();
-    if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-    }
-    if (ws) {
-        ws.close();
-        ws = null;
-    }
-    updateState('disconnected');
-    log.info('WeChat client stopped');
-}

package/dist/wechat/qclaw-transport.d.ts

@@ -0,0 +1,66 @@
+/**
+ * QClaw Transport - 通过腾讯 JPRX 网关直连微信
+ *
+ * 连接 wss://mmgrcalltoken.3g.qq.com/agentwss，
+ * 使用 QClaw API 获取 channelToken 进行认证。
+ * 支持消息去重、WS ping/pong 心跳、指数退避重连。
+ */
+import type { WeChatChannelState } from './types.js';
+import type { WeChatTransport, MessageHandler, StateChangeHandler } from './transport.js';
+export interface QClawTransportConfig {
+    /** QClaw 环境：production 或 test */
+    environment?: string;
+    /** QClaw wxAppId */
+    wxAppId?: string;
+    /** AGP channel token（连接凭证） */
+    channelToken?: string;
+    /** JWT Token（用于刷新 channelToken） */
+    jwtToken?: string;
+    /** loginKey（用于 API 调用） */
+    loginKey?: string;
+    /** 设备 GUID */
+    guid?: string;
+    /** 用户 ID */
+    userId?: string;
+    /** 自定义 WebSocket URL（覆盖默认 QClaw 地址） */
+    wsUrl?: string;
+    /** 心跳间隔 ms */
+    heartbeatInterval?: number;
+    /** 重连间隔 ms */
+    reconnectInterval?: number;
+    /** 最大重连次数 */
+    maxReconnectAttempts?: number;
+}
+export declare class QClawTransport implements WeChatTransport {
+    private config;
+    private state;
+    private ws;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private reconnectAttempts;
+    private isStopping;
+    private lastServerResponseTime;
+    private wsConfigRef;
+    private processedMsgIds;
+    private static readonly MAX_MSG_ID_CACHE;
+    private messageHandler;
+    private stateChangeHandler;
+    private channelToken;
+    private jwtToken;
+    private guid;
+    constructor(config: QClawTransportConfig);
+    start(): Promise<void>;
+    stop(): void;
+    send(method: string, payload: unknown, replyTo?: string): void;
+    onMessage(handler: MessageHandler): void;
+    onStateChange(handler: StateChangeHandler): void;
+    getState(): WeChatChannelState;
+    private connectWebSocket;
+    private handleAGPMessage;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private scheduleReconnect;
+    private updateState;
+    private generateMsgId;
+    private cleanMsgIdCache;
+}

package/dist/wechat/qclaw-transport.js

@@ -0,0 +1,303 @@
+/**
+ * QClaw Transport - 通过腾讯 JPRX 网关直连微信
+ *
+ * 连接 wss://mmgrcalltoken.3g.qq.com/agentwss，
+ * 使用 QClaw API 获取 channelToken 进行认证。
+ * 支持消息去重、WS ping/pong 心跳、指数退避重连。
+ */
+import { WebSocket } from 'ws';
+import { createLogger } from '../logger.js';
+import { QClawAPI } from './auth/qclaw-api.js';
+import { getEnvironment } from './auth/environments.js';
+import { getDeviceGuid } from './auth/device-guid.js';
+const log = createLogger('WeChat:QClaw');
+const PONG_TIMEOUT_FACTOR = 3;
+export class QClawTransport {
+    config;
+    state = 'disconnected';
+    ws = null;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    reconnectAttempts = 0;
+    isStopping = false;
+    lastServerResponseTime = 0;
+    wsConfigRef = null;
+    processedMsgIds = new Set();
+    static MAX_MSG_ID_CACHE = 1000;
+    messageHandler = null;
+    stateChangeHandler = null;
+    // Token management
+    channelToken;
+    jwtToken;
+    guid;
+    constructor(config) {
+        this.config = config;
+        this.channelToken = config.channelToken ?? '';
+        this.jwtToken = config.jwtToken ?? '';
+        this.guid = config.guid || getDeviceGuid();
+    }
+    async start() {
+        this.isStopping = false;
+        // Refresh channel token before connecting
+        if (this.jwtToken && this.config.loginKey) {
+            try {
+                const env = getEnvironment(this.config.environment ?? 'production', this.config.wxAppId ?? 'wx9d11056dd75b7240');
+                const api = new QClawAPI(env, this.guid, this.jwtToken);
+                api.loginKey = this.config.loginKey;
+                const freshToken = await api.refreshChannelToken();
+                if (freshToken) {
+                    this.channelToken = freshToken;
+                    log.info('Channel token refreshed successfully');
+                }
+            }
+            catch (err) {
+                log.warn('Failed to refresh channel token, using existing:', err);
+            }
+        }
+        const wsUrl = this.config.wsUrl
+            ?? `wss://mmgrcalltoken.3g.qq.com/agentwss?token=${encodeURIComponent(this.channelToken)}&guid=${encodeURIComponent(this.guid)}&user_id=${encodeURIComponent(this.config.userId ?? '')}`;
+        const wsConfig = {
+            url: wsUrl,
+            reconnectInterval: this.config.reconnectInterval ?? 3000,
+            maxReconnectAttempts: this.config.maxReconnectAttempts ?? 10,
+            heartbeatInterval: this.config.heartbeatInterval ?? 20000,
+        };
+        await this.connectWebSocket(wsConfig);
+    }
+    stop() {
+        this.isStopping = true;
+        this.stopHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.close();
+            this.ws = null;
+        }
+        this.updateState('disconnected');
+        log.info('QClaw transport stopped');
+    }
+    send(method, payload, replyTo) {
+        if (!this.ws || this.state !== 'connected') {
+            log.warn('Cannot send message: not connected');
+            return;
+        }
+        const envelope = {
+            msg_id: replyTo ?? this.generateMsgId(),
+            guid: this.guid,
+            user_id: this.config.userId,
+            method: method,
+            payload,
+        };
+        try {
+            this.ws.send(JSON.stringify(envelope));
+            log.debug('Sent AGP message:', method);
+        }
+        catch (err) {
+            log.error('Error sending AGP message:', err);
+        }
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onStateChange(handler) {
+        this.stateChangeHandler = handler;
+    }
+    getState() {
+        return this.state;
+    }
+    async connectWebSocket(config) {
+        this.wsConfigRef = config;
+        if (this.state === 'connecting') {
+            log.warn('WebSocket connection already in progress');
+            return;
+        }
+        this.updateState('connecting');
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const connectionTimeout = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                log.error('WebSocket connection timeout');
+                this.updateState('error');
+                try {
+                    this.ws?.close();
+                }
+                catch { /* ignore */ }
+                reject(new Error('WeChat QClaw WebSocket connection timeout'));
+            }, 30000);
+            try {
+                this.ws = new WebSocket(config.url);
+                this.ws.on('open', () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(connectionTimeout);
+                    log.info('QClaw WebSocket connected');
+                    this.reconnectAttempts = 0;
+                    this.lastServerResponseTime = Date.now();
+                    this.updateState('connected');
+                    this.startHeartbeat(config.heartbeatInterval ?? 20000);
+                    resolve();
+                });
+                this.ws.on('message', async (data) => {
+                    this.lastServerResponseTime = Date.now();
+                    try {
+                        const envelope = JSON.parse(data.toString());
+                        // Dedup
+                        if (envelope.msg_id) {
+                            if (this.processedMsgIds.has(envelope.msg_id)) {
+                                log.debug('Duplicate message, skipping:', envelope.msg_id);
+                                return;
+                            }
+                            this.processedMsgIds.add(envelope.msg_id);
+                            this.cleanMsgIdCache();
+                        }
+                        await this.handleAGPMessage(envelope);
+                    }
+                    catch (err) {
+                        log.error('Error parsing WebSocket message:', err);
+                    }
+                });
+                this.ws.on('error', (err) => {
+                    if (settled) {
+                        log.error('QClaw WebSocket error (after open):', err);
+                        return;
+                    }
+                    settled = true;
+                    clearTimeout(connectionTimeout);
+                    log.error('QClaw WebSocket error:', err);
+                    this.updateState('error');
+                    reject(err);
+                });
+                this.ws.on('close', () => {
+                    clearTimeout(connectionTimeout);
+                    log.info('QClaw WebSocket closed');
+                    this.stopHeartbeat();
+                    this.updateState('disconnected');
+                    if (!settled) {
+                        settled = true;
+                        reject(new Error('QClaw WebSocket closed before open'));
+                        return;
+                    }
+                    this.scheduleReconnect(config);
+                });
+                // WS-level ping/pong for heartbeat
+                this.ws.on('ping', () => {
+                    this.lastServerResponseTime = Date.now();
+                });
+            }
+            catch (err) {
+                settled = true;
+                clearTimeout(connectionTimeout);
+                log.error('Error creating WebSocket connection:', err);
+                this.updateState('error');
+                reject(err);
+            }
+        });
+    }
+    async handleAGPMessage(envelope) {
+        switch (envelope.method) {
+            case 'ping':
+                this.send('ping', { timestamp: Date.now() }, envelope.msg_id);
+                break;
+            case 'session.prompt':
+            case 'session.update':
+            case 'session.cancel':
+                if (this.messageHandler) {
+                    await this.messageHandler(envelope);
+                }
+                break;
+            case 'session.promptResponse':
+                log.debug('Received prompt response:', envelope.payload);
+                break;
+            default:
+                log.warn('Unknown AGP method:', envelope.method);
+        }
+    }
+    startHeartbeat(interval) {
+        this.stopHeartbeat();
+        this.lastServerResponseTime = Date.now();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.state !== 'connected')
+                return;
+            const elapsed = Date.now() - this.lastServerResponseTime;
+            const pongTimeout = interval * PONG_TIMEOUT_FACTOR;
+            if (this.lastServerResponseTime > 0 && elapsed > pongTimeout) {
+                log.warn(`No server response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
+                this.stopHeartbeat();
+                if (this.ws) {
+                    try {
+                        this.ws.removeAllListeners();
+                        this.ws.close();
+                    }
+                    catch { /* ignore */ }
+                    this.ws = null;
+                }
+                this.updateState('disconnected');
+                if (this.wsConfigRef) {
+                    this.scheduleReconnect(this.wsConfigRef);
+                }
+                return;
+            }
+            // WS-level ping
+            if (this.ws) {
+                try {
+                    this.ws.ping();
+                }
+                catch { /* ignore */ }
+            }
+        }, interval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    scheduleReconnect(config) {
+        if (this.isStopping)
+            return;
+        if (this.reconnectTimer)
+            return;
+        const maxAttempts = config.maxReconnectAttempts ?? 10;
+        if (this.reconnectAttempts >= maxAttempts) {
+            log.warn(`Max reconnect attempts (${maxAttempts}) reached, resetting counter`);
+            this.reconnectAttempts = 0;
+        }
+        const baseInterval = config.reconnectInterval ?? 3000;
+        const backoff = Math.min(baseInterval * Math.pow(1.5, Math.floor(this.reconnectAttempts / 3)), 25000);
+        const interval = Math.round(backoff);
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = null;
+            this.reconnectAttempts++;
+            log.info(`Reconnecting... Attempt ${this.reconnectAttempts}/${maxAttempts} (${interval}ms)`);
+            try {
+                await this.start();
+            }
+            catch (err) {
+                log.error('Reconnection failed:', err);
+            }
+        }, interval);
+    }
+    updateState(state) {
+        this.state = state;
+        this.stateChangeHandler?.(state);
+        log.debug('Channel state:', state);
+    }
+    generateMsgId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
+    cleanMsgIdCache() {
+        if (this.processedMsgIds.size > QClawTransport.MAX_MSG_ID_CACHE) {
+            const entries = [...this.processedMsgIds];
+            this.processedMsgIds.clear();
+            entries.slice(-QClawTransport.MAX_MSG_ID_CACHE / 2).forEach((id) => {
+                this.processedMsgIds.add(id);
+            });
+        }
+    }
+}

package/dist/wechat/transport.d.ts

@@ -0,0 +1,41 @@
+/**
+ * WeChat Transport Interface
+ * 抽象 QClaw 和 WorkBuddy 两种 WebSocket 传输方式
+ */
+import type { AGPEnvelope } from './types.js';
+import type { WeChatChannelState } from './types.js';
+/** 消息回调处理函数 */
+export type MessageHandler = (envelope: AGPEnvelope) => Promise<void>;
+/** 状态变更回调 */
+export type StateChangeHandler = (state: WeChatChannelState) => void;
+/**
+ * WeChat 传输接口
+ *
+ * 所有传输方式（QClaw WebSocket、WorkBuddy Centrifuge）都实现此接口。
+ * client.ts 通过此接口与传输层交互，无需关心底层协议。
+ */
+export interface WeChatTransport {
+    /** 连接到服务端 */
+    start(): Promise<void>;
+    /** 断开连接并释放资源 */
+    stop(): void;
+    /**
+     * 发送 AGP 消息
+     * @param method AGP 方法名（如 session.promptResponse, session.update）
+     * @param payload 消息负载
+     * @param replyTo 回复的 msg_id（可选）
+     */
+    send(method: string, payload: unknown, replyTo?: string): void;
+    /**
+     * 注册消息回调
+     * @param handler 收到 AGP envelope 时的回调
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * 注册状态变更回调
+     * @param handler 连接状态变更时的回调
+     */
+    onStateChange(handler: StateChangeHandler): void;
+    /** 获取当前连接状态 */
+    getState(): WeChatChannelState;
+}

package/dist/wechat/transport.js

@@ -0,0 +1,5 @@
+/**
+ * WeChat Transport Interface
+ * 抽象 QClaw 和 WorkBuddy 两种 WebSocket 传输方式
+ */
+export {};

package/dist/wechat/workbuddy-transport.d.ts

@@ -0,0 +1,33 @@
+/**
+ * WorkBuddy Transport - 通过 Centrifuge WebSocket 连接微信
+ *
+ * 使用 CodeBuddy/WorkBuddy OAuth 获取 Centrifuge 凭证，
+ * 订阅频道接收消息，通过 HTTP POST 发送回复。
+ */
+import type { WeChatChannelState } from './types.js';
+import type { WeChatTransport, MessageHandler, StateChangeHandler } from './transport.js';
+export interface WorkBuddyTransportConfig {
+    accessToken: string;
+    refreshToken: string;
+    userId: string;
+    hostId?: string;
+    baseUrl?: string;
+    guid?: string;
+    workspacePath?: string;
+}
+export declare class WorkBuddyTransport implements WeChatTransport {
+    private config;
+    private state;
+    private centrifugeClient;
+    private oauth;
+    private messageHandler;
+    private stateChangeHandler;
+    constructor(config: WorkBuddyTransportConfig);
+    start(): Promise<void>;
+    stop(): void;
+    send(method: string, payload: unknown, replyTo?: string): void;
+    onMessage(handler: MessageHandler): void;
+    onStateChange(handler: StateChangeHandler): void;
+    getState(): WeChatChannelState;
+    private updateState;
+}

package/dist/wechat/workbuddy-transport.js

@@ -0,0 +1,145 @@
+/**
+ * WorkBuddy Transport - 通过 Centrifuge WebSocket 连接微信
+ *
+ * 使用 CodeBuddy/WorkBuddy OAuth 获取 Centrifuge 凭证，
+ * 订阅频道接收消息，通过 HTTP POST 发送回复。
+ */
+import { randomUUID } from 'node:crypto';
+import { createLogger } from '../logger.js';
+import { WorkBuddyCentrifugeClient } from '../workbuddy/centrifuge-client.js';
+import { WorkBuddyOAuth } from '../workbuddy/oauth.js';
+const log = createLogger('WeChat:WorkBuddy');
+export class WorkBuddyTransport {
+    config;
+    state = 'disconnected';
+    centrifugeClient = null;
+    oauth = null;
+    messageHandler = null;
+    stateChangeHandler = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async start() {
+        this.updateState('connecting');
+        try {
+            // Initialize OAuth
+            this.oauth = new WorkBuddyOAuth(this.config.baseUrl ?? 'https://copilot.tencent.com');
+            this.oauth.accessToken = this.config.accessToken;
+            this.oauth.refreshToken = this.config.refreshToken;
+            this.oauth.userId = this.config.userId;
+            // Register workspace to get Centrifuge tokens
+            log.info('Registering workspace for Centrifuge tokens...');
+            const tokens = await this.oauth.registerWorkspace({
+                userId: this.config.userId,
+                hostId: this.config.hostId ?? randomUUID(),
+                workspaceId: randomUUID(),
+                workspaceName: 'open-im-wechat',
+            });
+            log.info(`Workspace registered: channel=${tokens.channel}`);
+            // Create Centrifuge client
+            const clientConfig = {
+                url: tokens.url,
+                connectionToken: tokens.connectionToken,
+                subscriptionToken: tokens.subscriptionToken,
+                channel: tokens.channel,
+                guid: this.config.guid ?? randomUUID(),
+                userId: this.config.userId,
+                httpBaseUrl: this.config.baseUrl ?? 'https://copilot.tencent.com',
+                httpAccessToken: this.config.accessToken,
+            };
+            const callbacks = {
+                onConnected: () => {
+                    log.info('WorkBuddy Centrifuge connected');
+                    this.updateState('connected');
+                },
+                onDisconnected: (reason) => {
+                    log.info(`WorkBuddy Centrifuge disconnected: ${reason}`);
+                    this.updateState('disconnected');
+                },
+                onError: (error) => {
+                    log.error('WorkBuddy Centrifuge error:', error);
+                    this.updateState('error');
+                },
+                onMessage: async (chatId, msgId, content) => {
+                    // Normalize WeChat KF or AGP message to AGPEnvelope
+                    const envelope = {
+                        msg_id: msgId,
+                        guid: this.config.guid,
+                        user_id: this.config.userId,
+                        method: 'session.prompt',
+                        payload: {
+                            session_id: chatId,
+                            content,
+                            options: { stream: true },
+                        },
+                    };
+                    if (this.messageHandler) {
+                        await this.messageHandler(envelope);
+                    }
+                },
+            };
+            this.centrifugeClient = new WorkBuddyCentrifugeClient(clientConfig, callbacks);
+            this.centrifugeClient.start();
+            log.info('WorkBuddy transport initialized');
+        }
+        catch (err) {
+            log.error('Failed to start WorkBuddy transport:', err);
+            this.updateState('error');
+            throw err;
+        }
+    }
+    stop() {
+        if (this.centrifugeClient) {
+            this.centrifugeClient.stop();
+            this.centrifugeClient = null;
+        }
+        this.updateState('disconnected');
+        log.info('WorkBuddy transport stopped');
+    }
+    send(method, payload, replyTo) {
+        if (!this.centrifugeClient) {
+            log.warn('Cannot send message: Centrifuge client not initialized');
+            return;
+        }
+        const msgId = replyTo ?? randomUUID();
+        // For prompt responses, use HTTP path (WorkBuddy's requirement)
+        if (method === 'session.promptResponse') {
+            const p = payload;
+            this.centrifugeClient.sendPromptResponse({
+                session_id: p.session_id,
+                prompt_id: p.prompt_id ?? msgId,
+                content: p.content,
+                error: p.error,
+                stop_reason: p.stop_reason ?? 'end_turn',
+            }, this.config.guid, this.config.userId);
+            return;
+        }
+        // Use sendMessageChunk for session.update, sendToolCall for tool calls
+        if (method === 'session.update') {
+            const p = payload;
+            const sessionId = p.session_id;
+            const promptId = p.prompt_id ?? msgId;
+            const content = p.content;
+            if (content?.[0]?.text) {
+                this.centrifugeClient.sendMessageChunk(sessionId, promptId, { type: 'text', text: content[0].text }, this.config.guid, this.config.userId);
+            }
+            return;
+        }
+        // Fallback: send via Centrifuge publish
+        log.debug(`WorkBuddy send: method=${method}, msg_id=${msgId}`);
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onStateChange(handler) {
+        this.stateChangeHandler = handler;
+    }
+    getState() {
+        return this.state;
+    }
+    updateState(state) {
+        this.state = state;
+        this.stateChangeHandler?.(state);
+        log.debug('Channel state:', state);
+    }
+}

package/package.json

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