@wu529778790/open-im 1.0.3 → 1.1.0

package/dist/wechat/auth/wechat-login.js

@@ -0,0 +1,172 @@
+/**
+ * 微信扫码登录流程
+ * 1. 获取 state → 2. 显示二维码 → 3. 等待 code → 4. 换 token → 5. 设备绑定
+ */
+import { createInterface } from 'node:readline';
+import { QClawAPI } from './qclaw-api.js';
+import { getDeviceGuid } from './device-guid.js';
+import { getEnvironment } from './environments.js';
+import { performDeviceBinding } from './device-bind.js';
+function nested(obj, ...keys) {
+    let cur = obj;
+    for (const k of keys) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[k];
+    }
+    return cur;
+}
+function buildAuthUrl(state, env) {
+    const params = new URLSearchParams({
+        appid: env.wxAppId,
+        redirect_uri: env.wxLoginRedirectUri,
+        response_type: 'code',
+        scope: 'snsapi_login',
+        state,
+    });
+    return `https://open.weixin.qq.com/connect/qrconnect?${params.toString()}#wechat_redirect`;
+}
+async function displayQrCode(url) {
+    console.log('\n' + '='.repeat(64));
+    console.log('请用微信扫描下方二维码登录');
+    console.log('='.repeat(64));
+    try {
+        const { generate } = await import('qrcode-terminal');
+        if (generate)
+            generate(url, { small: true }, (qrcode) => console.log(qrcode));
+    }
+    catch {
+        console.log('\n(未安装 qrcode-terminal，无法在终端显示二维码)');
+        console.log('可运行: npm install qrcode-terminal');
+    }
+    console.log('\n或在浏览器中打开以下链接：');
+    console.log(url);
+    console.log('='.repeat(64) + '\n');
+}
+function readLine(prompt) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function waitForAuthCode() {
+    console.log('微信扫码授权后，浏览器会跳转到新页面，地址栏 URL 形如：');
+    console.log('https://security.guanjia.qq.com/login?code=0a1B2c...&state=xxx');
+    console.log('\n请复制 code= 后面的值（到 & 之前），或直接粘贴完整 URL。\n');
+    const raw = await readLine('请粘贴 code 值或完整 URL: ');
+    if (!raw)
+        return '';
+    const cleaned = raw.replace(/\\([?=&#])/g, '$1');
+    if (cleaned.includes('code=')) {
+        try {
+            const url = new URL(cleaned);
+            const code = url.searchParams.get('code');
+            if (code)
+                return code;
+            if (url.hash) {
+                const fragmentParams = new URLSearchParams(url.hash.replace(/^#/, ''));
+                const fCode = fragmentParams.get('code');
+                if (fCode)
+                    return fCode;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        const match = cleaned.match(/[?&#]code=([^&#]+)/);
+        if (match?.[1])
+            return match[1];
+    }
+    return cleaned;
+}
+/**
+ * 执行微信扫码登录，返回 token、guid、userId
+ */
+export async function performWeChatLogin(options = {}) {
+    const envName = options.envName ?? 'production';
+    const appId = options.appId;
+    if (!appId) {
+        throw new Error('appId is required. 请在配置中提供 wechatAppId 或通过环境变量 WECHAT_APP_ID 设置');
+    }
+    const env = getEnvironment(envName, appId);
+    const guid = getDeviceGuid();
+    const api = new QClawAPI(env, guid);
+    // 1. 获取 state
+    console.log('[微信登录] 步骤 1/5: 获取登录 state...');
+    let state = String(Math.floor(Math.random() * 10000));
+    const stateResult = await api.getWxLoginState();
+    if (stateResult.success) {
+        const s = nested(stateResult.data, 'state');
+        if (s)
+            state = s;
+    }
+    // 2. 显示二维码
+    console.log('[微信登录] 步骤 2/5: 生成微信登录二维码...');
+    const authUrl = buildAuthUrl(state, env);
+    await displayQrCode(authUrl);
+    // 3. 等待 code
+    console.log('[微信登录] 步骤 3/5: 等待微信扫码授权...');
+    const code = await waitForAuthCode();
+    if (!code) {
+        throw new Error('未获取到授权 code');
+    }
+    // 4. 用 code 换 token
+    console.log(`[微信登录] 步骤 4/5: 用授权码登录 (code=${code.substring(0, 10)}...)`);
+    const loginResult = await api.wxLogin(code, state);
+    if (!loginResult.success) {
+        throw new Error(`登录失败: ${loginResult.message ?? '未知错误'}`);
+    }
+    const loginData = loginResult.data;
+    const jwtToken = nested(loginData, 'token') || nested(loginData, 'data', 'token') || '';
+    const channelToken = nested(loginData, 'openclaw_channel_token') ||
+        nested(loginData, 'data', 'openclaw_channel_token') ||
+        '';
+    const userInfo = nested(loginData, 'user_info') ||
+        nested(loginData, 'data', 'user_info') ||
+        {};
+    const loginKey = userInfo.loginKey;
+    if (loginKey)
+        api.loginKey = loginKey;
+    api.jwtToken = jwtToken;
+    api.userId = String(userInfo.user_id ?? '');
+    const nickname = userInfo.nickname ?? 'unknown';
+    console.log(`[微信登录] 登录成功! 用户: ${nickname}`);
+    // 5. 设备绑定（服务端要求先绑定才接受 WebSocket，顺序不可颠倒）
+    console.log('[微信登录] 步骤 5/5: 设备绑定...');
+    const credentials = {
+        channelToken,
+        jwtToken,
+        userId: api.userId,
+        guid,
+        loginKey: api.loginKey,
+        userInfo,
+    };
+    const bindResult = await performDeviceBinding(api, {
+        showQr: async (url) => {
+            console.log('\n' + '='.repeat(64));
+            console.log('【设备绑定】请复制下方链接，在微信中发给「文件传输助手」后点击打开：');
+            console.log('='.repeat(64));
+            console.log(url);
+            console.log('='.repeat(64) + '\n');
+        },
+    });
+    if (bindResult.success) {
+        console.log(`[微信登录] ${bindResult.message}`);
+    }
+    else {
+        console.warn(`[微信登录] ${bindResult.message}`);
+        console.warn('[微信登录] 可稍后重新登录完成绑定。');
+    }
+    return {
+        channelToken,
+        jwtToken,
+        userId: api.userId,
+        guid,
+        loginKey: api.loginKey,
+        userInfo,
+    };
+}
+export { getEnvironment };

package/dist/wechat/client.js

@@ -35,8 +35,17 @@ export function getCurrentToken() {
  * Initialize WeChat client with AGP WebSocket connection
  */
 export async function initWeChat(config, eventHandler, onStateChange) {
-    if (!config.wechatAppId || !config.wechatAppSecret) {
-        throw new Error('WeChat app_id and app_secret are required');
+    // 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;

package/dist/wework/client.d.ts

@@ -0,0 +1,46 @@
+/**
+ * WeWork (企业微信/WeCom) Client
+ * 基于企业微信官方 AI_BOT WebSocket 协议
+ * WebSocket URL: wss://openws.work.weixin.qq.com
+ *
+ * 消息接收：通过 WebSocket (aibot_msg_callback)
+ * 消息发送：通过 WebSocket (aibot_respond_msg)，必须透传 req_id
+ * 注意：长连接模式下不能用 HTTP response_url，会报 40008 invalid message type
+ */
+import type { Config } from '../config.js';
+import { WeWorkConnectionState, WeWorkCallbackMessage, WeWorkResponseMessage, WeWorkHttpResponseBody } from './types.js';
+/**
+ * Get current connection state
+ */
+export declare function getConnectionState(): WeWorkConnectionState;
+/**
+ * 主动推送消息 (aibot_send_msg)
+ * 用于启动/关闭通知等场景，无需用户消息触发
+ * 注意：需用户曾与机器人对话后，才能向该会话主动推送
+ */
+export declare function sendProactiveMessage(chatId: string, content: string): void;
+/**
+ * Send reply via WebSocket (aibot_respond_msg)
+ * 长连接模式下必须用此方式回复，透传 req_id
+ */
+export declare function sendWebSocketReply(reqId: string, body: WeWorkHttpResponseBody): void;
+/**
+ * Initialize WeWork client with WebSocket connection
+ */
+export declare function initWeWork(cfg: Config, eventHandler: (data: WeWorkCallbackMessage) => Promise<void>, onStateChange?: (state: WeWorkConnectionState) => void): Promise<void>;
+/**
+ * Send message to WeWork
+ */
+export declare function sendMessage(message: WeWorkResponseMessage): void;
+/**
+ * Send text message via WebSocket (requires req_id from callback)
+ */
+export declare function sendText(reqId: string, content: string): void;
+/**
+ * Send stream message via WebSocket (requires req_id from callback)
+ */
+export declare function sendStream(reqId: string, streamId: string, content: string, finish: boolean): void;
+/**
+ * Stop WeWork client
+ */
+export declare function stopWeWork(): void;

package/dist/wework/client.js

@@ -0,0 +1,356 @@
+/**
+ * WeWork (企业微信/WeCom) Client
+ * 基于企业微信官方 AI_BOT WebSocket 协议
+ * WebSocket URL: wss://openws.work.weixin.qq.com
+ *
+ * 消息接收：通过 WebSocket (aibot_msg_callback)
+ * 消息发送：通过 WebSocket (aibot_respond_msg)，必须透传 req_id
+ * 注意：长连接模式下不能用 HTTP response_url，会报 40008 invalid message type
+ */
+import { WebSocket } from 'ws';
+import { randomBytes } from 'node:crypto';
+import { createLogger } from '../logger.js';
+const log = createLogger('WeWork');
+const DEFAULT_WS_URL = 'wss://openws.work.weixin.qq.com';
+const HEARTBEAT_INTERVAL = 30000; // 30秒
+const MAX_RECONNECT_ATTEMPTS = 100;
+// Global state
+let ws = null;
+let connectionState = 'disconnected';
+let reconnectTimer = null;
+let heartbeatTimer = null;
+let reconnectAttempts = 0;
+// Event handlers
+let messageHandler = null;
+let stateChangeHandler = null;
+// Configuration
+let config = null;
+/**
+ * Generate unique request ID
+ */
+function generateReqId() {
+    return `${Date.now()}-${randomBytes(8).toString('hex')}`;
+}
+/**
+ * Get current connection state
+ */
+export function getConnectionState() {
+    return connectionState;
+}
+/**
+ * 主动推送消息 (aibot_send_msg)
+ * 用于启动/关闭通知等场景，无需用户消息触发
+ * 注意：需用户曾与机器人对话后，才能向该会话主动推送
+ */
+export function sendProactiveMessage(chatId, content) {
+    if (!ws || connectionState !== 'connected') {
+        log.error('Cannot send proactive message: WebSocket not connected');
+        return;
+    }
+    if (!chatId) {
+        log.error('Cannot send proactive message: chatId is required');
+        return;
+    }
+    const message = {
+        cmd: "aibot_send_msg" /* WeWorkCommand.AIBOT_SEND_MSG */,
+        headers: { req_id: generateReqId() },
+        body: {
+            chatid: chatId,
+            chat_type: 1, // 单聊
+            msgtype: 'markdown',
+            markdown: { content },
+        },
+    };
+    try {
+        ws.send(JSON.stringify(message));
+        log.info(`[WeWork] Sent aibot_send_msg to ${chatId}`);
+    }
+    catch (err) {
+        log.error('Error sending proactive message:', err);
+    }
+}
+/**
+ * Send reply via WebSocket (aibot_respond_msg)
+ * 长连接模式下必须用此方式回复，透传 req_id
+ */
+export function sendWebSocketReply(reqId, body) {
+    if (!ws || connectionState !== 'connected') {
+        log.error('Cannot send reply: WebSocket not connected');
+        return;
+    }
+    if (!reqId) {
+        log.error('Cannot send reply: req_id is required');
+        return;
+    }
+    const message = {
+        cmd: "aibot_respond_msg" /* WeWorkCommand.AIBOT_RESPOND_MSG */,
+        headers: { req_id: reqId },
+        body,
+    };
+    try {
+        ws.send(JSON.stringify(message));
+        log.debug(`[WeWork] Sent aibot_respond_msg: msgtype=${body.msgtype}`);
+    }
+    catch (err) {
+        log.error('Error sending WebSocket reply:', err);
+    }
+}
+/**
+ * Initialize WeWork client with WebSocket connection
+ */
+export async function initWeWork(cfg, eventHandler, onStateChange) {
+    if (!cfg.weworkCorpId || !cfg.weworkSecret) {
+        throw new Error('WeWork botId and secret are required');
+    }
+    config = {
+        botId: cfg.weworkCorpId, // CorpId 实际上就是 botId
+        secret: cfg.weworkSecret,
+        websocketUrl: cfg.weworkWsUrl || DEFAULT_WS_URL,
+    };
+    messageHandler = eventHandler;
+    stateChangeHandler = onStateChange ?? null;
+    log.info(`Initializing WeWork client (botId: ${config.botId})`);
+    await connectWebSocket();
+}
+/**
+ * Connect to WeWork WebSocket server
+ */
+async function connectWebSocket() {
+    if (connectionState === 'connecting') {
+        log.warn('WebSocket connection already in progress');
+        return;
+    }
+    if (!config) {
+        throw new Error('WeWork config not initialized');
+    }
+    updateState('connecting');
+    // Store config values locally to avoid null issues in Promise callback
+    const websocketUrl = config.websocketUrl || DEFAULT_WS_URL;
+    return new Promise((resolve, reject) => {
+        try {
+            ws = new WebSocket(websocketUrl);
+            ws.on('open', async () => {
+                log.info('WeWork WebSocket connected');
+                reconnectAttempts = 0;
+                updateState('connected');
+                startHeartbeat();
+                // 发送认证订阅消息，并等待服务端确认（否则 aibot_send_msg 会报 846609 not subscribed）
+                try {
+                    await sendSubscribeAndWaitAck(resolve, reject);
+                    log.info('WeWork authentication successful');
+                }
+                catch (err) {
+                    log.error('WeWork authentication failed:', err);
+                    reject(err);
+                }
+            });
+            ws.on('message', async (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    await handleMessage(message);
+                }
+                catch (err) {
+                    log.error('Error parsing WebSocket message:', err);
+                }
+            });
+            ws.on('error', (err) => {
+                log.error('WeWork WebSocket error:', err);
+                updateState('error');
+                reject(err);
+            });
+            ws.on('close', () => {
+                log.info('WeWork WebSocket closed');
+                stopHeartbeat();
+                updateState('disconnected');
+                scheduleReconnect();
+            });
+        }
+        catch (err) {
+            log.error('Error creating WebSocket connection:', err);
+            updateState('error');
+            reject(err);
+        }
+    });
+}
+/** 等待订阅确认的回调，收到服务端 errcode 响应后调用 */
+let subscribeAckResolve = null;
+let subscribeAckReject = null;
+/**
+ * 发送认证订阅消息，并等待服务端 errcode: 0 确认
+ * 必须在收到确认后才能发送 aibot_send_msg，否则报 846609 not subscribed
+ */
+function sendSubscribeAndWaitAck(onSuccess, onError) {
+    if (!config || !ws) {
+        throw new Error('WebSocket not connected');
+    }
+    subscribeAckResolve = onSuccess;
+    subscribeAckReject = onError;
+    const subscribeMessage = {
+        cmd: "aibot_subscribe" /* WeWorkCommand.SUBSCRIBE */,
+        headers: { req_id: generateReqId() },
+        body: {
+            secret: config.secret,
+            bot_id: config.botId,
+        },
+    };
+    ws.send(JSON.stringify(subscribeMessage));
+    log.debug('Sent subscribe message, waiting for ack...');
+}
+/**
+ * Handle incoming WebSocket message
+ */
+async function handleMessage(message) {
+    // 检查是否是响应消息（我们发送的消息的响应）
+    if ('errcode' in message) {
+        const response = message;
+        // 若在等待订阅确认，优先处理
+        if (subscribeAckResolve || subscribeAckReject) {
+            const resolve = subscribeAckResolve;
+            const reject = subscribeAckReject;
+            subscribeAckResolve = null;
+            subscribeAckReject = null;
+            if (response.errcode === 0) {
+                log.debug('Subscribe ack received');
+                resolve?.();
+            }
+            else {
+                log.error(`WeWork subscribe failed: ${response.errcode} - ${response.errmsg}`);
+                reject?.(new Error(`Subscribe failed: ${response.errcode} ${response.errmsg}`));
+            }
+            return;
+        }
+        if (response.errcode !== 0) {
+            log.error(`WeWork error response: ${response.errcode} - ${response.errmsg}`);
+        }
+        else {
+            log.debug('WeWork message sent successfully');
+        }
+        return;
+    }
+    // 处理回调消息
+    if ('cmd' in message && message.cmd === "aibot_msg_callback" /* WeWorkCommand.AIBOT_CALLBACK */) {
+        const callback = message;
+        log.info(`[WeWork] Received message: msgtype=${callback.body.msgtype}, from=${callback.body.from.userid}, chatid=${callback.body.chatid}`);
+        if (messageHandler) {
+            try {
+                await messageHandler(callback);
+            }
+            catch (err) {
+                log.error('Error in message handler:', err);
+            }
+        }
+    }
+}
+/**
+ * Send message to WeWork
+ */
+export function sendMessage(message) {
+    if (!ws || connectionState !== 'connected') {
+        log.warn('Cannot send message: WebSocket not connected');
+        return;
+    }
+    try {
+        ws.send(JSON.stringify(message));
+        log.info(`[WeWork] Sent message: ${message.cmd}, msgtype=${message.body.msgtype}`);
+    }
+    catch (err) {
+        log.error('Error sending message:', err);
+    }
+}
+/**
+ * Send text message via WebSocket (requires req_id from callback)
+ */
+export function sendText(reqId, content) {
+    sendWebSocketReply(reqId, {
+        msgtype: 'text',
+        text: { content },
+    });
+}
+/**
+ * Send stream message via WebSocket (requires req_id from callback)
+ */
+export function sendStream(reqId, streamId, content, finish) {
+    sendWebSocketReply(reqId, {
+        msgtype: 'stream',
+        stream: { id: streamId, finish, content },
+    });
+}
+/**
+ * Update connection state and notify listeners
+ */
+function updateState(state) {
+    connectionState = state;
+    if (stateChangeHandler) {
+        stateChangeHandler(state);
+    }
+    log.debug('Connection state:', state);
+}
+/**
+ * Start heartbeat to keep connection alive
+ */
+function startHeartbeat() {
+    stopHeartbeat();
+    heartbeatTimer = setInterval(() => {
+        if (connectionState === 'connected' && ws) {
+            const pingMessage = {
+                cmd: "ping" /* WeWorkCommand.PING */,
+                headers: {
+                    req_id: generateReqId(),
+                },
+                body: {},
+            };
+            try {
+                ws.send(JSON.stringify(pingMessage));
+                log.debug('Sent ping');
+            }
+            catch (err) {
+                log.error('Error sending ping:', err);
+            }
+        }
+    }, HEARTBEAT_INTERVAL);
+}
+/**
+ * Stop heartbeat
+ */
+function stopHeartbeat() {
+    if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+    }
+}
+/**
+ * Schedule reconnection attempt
+ */
+function scheduleReconnect() {
+    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        log.error('Max reconnect attempts reached');
+        return;
+    }
+    const interval = 5000; // 5秒后重连
+    reconnectTimer = setTimeout(async () => {
+        reconnectAttempts++;
+        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}`);
+        try {
+            await connectWebSocket();
+        }
+        catch (err) {
+            log.error('Reconnection failed:', err);
+        }
+    }, interval);
+}
+/**
+ * Stop WeWork client
+ */
+export function stopWeWork() {
+    stopHeartbeat();
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
+    if (ws) {
+        ws.close();
+        ws = null;
+    }
+    updateState('disconnected');
+    log.info('WeWork client stopped');
+}

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

@@ -0,0 +1,12 @@
+/**
+ * WeWork (企业微信) Event Handler - Handle WeWork message events
+ */
+import type { Config } from '../config.js';
+import type { SessionManager } from '../session/session-manager.js';
+import type { WeWorkCallbackMessage } from './types.js';
+export interface WeWorkEventHandlerHandle {
+    stop: () => void;
+    getRunningTaskCount: () => number;
+    handleEvent: (data: WeWorkCallbackMessage) => Promise<void>;
+}
+export declare function setupWeWorkHandlers(config: Config, sessionManager: SessionManager): WeWorkEventHandlerHandle;