@wu529778790/open-im 1.0.3 → 1.1.0

package/dist/wework/event-handler.js

@@ -0,0 +1,245 @@
+/**
+ * WeWork (企业微信) Event Handler - Handle WeWork message events
+ */
+import { AccessControl } from '../access/access-control.js';
+import { RequestQueue } from '../queue/request-queue.js';
+import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, startTypingLoop, sendPermissionCard, sendModeCard, setCurrentReqId, } from './message-sender.js';
+import { registerPermissionSender } from '../hook/permission-server.js';
+import { CommandHandler } from '../commands/handler.js';
+import { getAdapter } from '../adapters/registry.js';
+import { runAITask } from '../shared/ai-task.js';
+import { startTaskCleanup } from '../shared/task-cleanup.js';
+import { WEWORK_THROTTLE_MS } from '../constants.js';
+import { setActiveChatId } from '../shared/active-chats.js';
+import { setChatUser } from '../shared/chat-user-map.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('WeWorkHandler');
+export function setupWeWorkHandlers(config, sessionManager) {
+    const accessControl = new AccessControl(config.weworkAllowedUserIds);
+    const requestQueue = new RequestQueue();
+    const runningTasks = new Map();
+    const stopTaskCleanup = startTaskCleanup(runningTasks);
+    const commandHandler = new CommandHandler({
+        config,
+        sessionManager,
+        requestQueue,
+        sender: { sendTextReply, sendModeCard },
+        getRunningTasksSize: () => runningTasks.size,
+    });
+    registerPermissionSender('wework', { sendTextReply, sendPermissionCard });
+    async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId, reqId) {
+        log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
+        if (reqId)
+            setCurrentReqId(reqId);
+        try {
+            const toolAdapter = getAdapter(config.aiCommand);
+            if (!toolAdapter) {
+                log.error(`[handleAIRequest] No adapter found for: ${config.aiCommand}`);
+                await sendTextReply(chatId, `未配置 AI 工具: ${config.aiCommand}`, reqId);
+                return;
+            }
+            const sessionId = convId ? sessionManager.getSessionIdForConv(userId, convId) : undefined;
+            log.info(`[handleAIRequest] Running ${config.aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
+            const toolId = config.aiCommand;
+            let msgId;
+            try {
+                msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, reqId);
+            }
+            catch (err) {
+                log.error('Failed to send thinking message:', err);
+                return;
+            }
+            const stopTyping = startTypingLoop(chatId);
+            const taskKey = `${userId}:${msgId}`;
+            await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'wework', taskKey }, prompt, toolAdapter, {
+                throttleMs: WEWORK_THROTTLE_MS,
+                streamUpdate: async (content, toolNote) => {
+                    const note = toolNote ? '输出中...\n' + toolNote : '输出中...';
+                    try {
+                        await updateMessage(chatId, msgId, content, 'streaming', note, toolId, reqId);
+                    }
+                    catch (err) {
+                        log.debug('Stream update failed:', err);
+                    }
+                },
+                sendComplete: async (content, note) => {
+                    await sendFinalMessages(chatId, msgId, content, note ?? '', toolId, reqId);
+                },
+                sendError: async (error) => {
+                    await updateMessage(chatId, msgId, `错误：${error}`, 'error', '执行失败', toolId, reqId);
+                },
+                extraCleanup: () => {
+                    stopTyping();
+                    runningTasks.delete(taskKey);
+                },
+                onTaskReady: (state) => {
+                    runningTasks.set(taskKey, state);
+                },
+                sendImage: async (path) => {
+                    // WeWork image handling
+                    await sendTextReply(chatId, `图片已保存: ${path}`, reqId);
+                },
+            });
+        }
+        finally {
+            setCurrentReqId(null);
+        }
+    }
+    /**
+     * Extract text content from WeWork message body
+     */
+    function extractTextContent(data) {
+        const body = data.body;
+        // Direct text message
+        if (body.msgtype === 'text' && body.text?.content) {
+            return body.text.content.trim();
+        }
+        // Mixed message (text + images)
+        if (body.msgtype === 'mixed' && body.mixed?.msg_item) {
+            const textItems = body.mixed.msg_item
+                .filter(item => item.msgtype === 'text' && item.text?.content)
+                .map(item => item.text.content)
+                .join('\n');
+            return textItems;
+        }
+        return '';
+    }
+    /**
+     * Extract image content from WeWork message body
+     */
+    function extractImageContent(data) {
+        const body = data.body;
+        // Direct image message
+        if (body.msgtype === 'image' && body.image) {
+            return {
+                url: body.image.url,
+                base64: body.image.base64,
+            };
+        }
+        // Mixed message with images
+        if (body.msgtype === 'mixed' && body.mixed?.msg_item) {
+            const firstImage = body.mixed.msg_item.find(item => item.msgtype === 'image' && item.image);
+            if (firstImage?.image) {
+                return {
+                    url: firstImage.image.url,
+                    base64: firstImage.image.base64,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Handle incoming WeWork callback event
+     */
+    async function handleEvent(data) {
+        log.info('[handleEvent] Called with data:', JSON.stringify(data).slice(0, 800));
+        const reqId = data.headers?.req_id ?? '';
+        setCurrentReqId(reqId);
+        try {
+            const body = data.body;
+            const msgType = body.msgtype;
+            const fromUser = body.from.userid;
+            // 单聊时 chatid 可能不返回，用 userid 作为会话标识
+            const chatId = body.chatid ?? fromUser;
+            const chatType = body.chattype;
+            log.info(`WeWork event: msgType=${msgType}, from=${fromUser}, chatId=${chatId}, chatType=${chatType}`);
+            // Access control check
+            if (!accessControl.isAllowed(fromUser)) {
+                log.warn(`Access denied for sender: ${fromUser}`);
+                await sendTextReply(fromUser, `抱歉，您没有访问权限。\n您的 ID: ${fromUser}`, reqId);
+                return;
+            }
+            log.info(`Access granted for sender: ${fromUser}`);
+            setActiveChatId('wework', fromUser);
+            setChatUser(fromUser, fromUser);
+            // Handle text messages
+            if (msgType === 'text' || msgType === 'mixed') {
+                const text = extractTextContent(data);
+                if (!text) {
+                    log.debug('[MSG] No text content found in message');
+                    return;
+                }
+                log.info(`[MSG] Type=${msgType}, User=${fromUser}, Length=${text.length}, Content="${text}"`);
+                // Handle commands (sync, uses setCurrentReqId)
+                try {
+                    const handleAIRequestWithReqId = (u, c, p, w, conv, tc, replyTo) => handleAIRequest(u, c, p, w, conv, tc, replyTo, reqId);
+                    const handled = await commandHandler.dispatch(text, fromUser, fromUser, 'wework', handleAIRequestWithReqId);
+                    if (handled) {
+                        log.info(`Command handled for message: ${text}`);
+                        return;
+                    }
+                }
+                catch (err) {
+                    log.error('Error in commandHandler.dispatch:', err);
+                }
+                // Handle AI request
+                log.info(`Enqueueing AI request for: ${text}`);
+                const workDir = sessionManager.getWorkDir(fromUser);
+                const convId = sessionManager.getConvId(fromUser);
+                const enqueueResult = requestQueue.enqueue(fromUser, convId, text, async (prompt) => {
+                    log.info(`Executing AI request for: ${prompt}`);
+                    await handleAIRequest(fromUser, fromUser, prompt, workDir, convId, undefined, undefined, reqId);
+                });
+                if (enqueueResult === 'rejected') {
+                    await sendTextReply(fromUser, '请求队列已满，请稍后再试。', reqId);
+                }
+                else if (enqueueResult === 'queued') {
+                    await sendTextReply(fromUser, '您的请求已排队等待。', reqId);
+                }
+            }
+            // Handle image messages
+            else if (msgType === 'image') {
+                const imageData = extractImageContent(data);
+                if (!imageData) {
+                    log.warn('[MSG] Image message has no content');
+                    return;
+                }
+                const imageDesc = imageData.url ? `URL: ${imageData.url}` : `Base64数据 (${imageData.base64?.length || 0} 字符)`;
+                log.info(`Processing image message from ${fromUser}, ${imageDesc}`);
+                // TODO: Implement image analysis
+                const prompt = `用户发送了一张图片。请分析图片内容。`;
+                const workDir = sessionManager.getWorkDir(fromUser);
+                const convId = sessionManager.getConvId(fromUser);
+                requestQueue.enqueue(fromUser, convId, prompt, async (p) => {
+                    await handleAIRequest(fromUser, fromUser, p, workDir, convId, undefined, undefined, reqId);
+                });
+            }
+            // Handle file messages
+            else if (msgType === 'file') {
+                log.info(`[MSG] File message from ${fromUser} - not supported`);
+                await sendTextReply(fromUser, '文件消息暂不支持', reqId);
+            }
+            // Handle voice messages
+            else if (msgType === 'voice') {
+                log.info(`[MSG] Voice message from ${fromUser} - not supported`);
+                await sendTextReply(fromUser, '语音消息暂不支持', reqId);
+            }
+            // Handle video messages
+            else if (msgType === 'video') {
+                log.info(`[MSG] Video message from ${fromUser} - not supported`);
+                await sendTextReply(fromUser, '视频消息暂不支持', reqId);
+            }
+            // Handle stream messages (WebSocket streaming response)
+            else if (msgType === 'stream') {
+                log.debug(`[MSG] Stream message from ${fromUser}, streamId=${body.stream?.id}`);
+                // Stream messages are typically responses, not requests
+                // We can ignore them or handle them if needed
+            }
+            // Unsupported message type
+            else {
+                log.warn(`[MSG] Unsupported message type: ${msgType}, fromUser=${fromUser}`);
+            }
+        }
+        catch (err) {
+            log.error('[handleEvent] Error processing event:', err);
+        }
+        finally {
+            setCurrentReqId(null);
+        }
+    }
+    return {
+        stop: () => stopTaskCleanup(),
+        getRunningTaskCount: () => runningTasks.size,
+        handleEvent,
+    };
+}

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

@@ -0,0 +1,57 @@
+/**
+ * WeWork (企业微信) Message Sender - Send messages to WeWork
+ * 通过 WebSocket aibot_respond_msg 发送，需透传 req_id
+ */
+export declare function setCurrentReqId(reqId: string | null): void;
+type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
+/**
+ * Send thinking message to WeWork
+ * Returns a stream ID that can be used for updates
+ * @param reqId - 消息回调的 req_id，用于 WebSocket 回复
+ */
+export declare function sendThinkingMessage(chatId: string, _replyToMessageId: string | undefined, toolId?: string, reqId?: string): Promise<string>;
+/**
+ * Update existing message in WeWork
+ * Note: WeWork doesn't support message editing, so we send new stream messages
+ */
+export declare function updateMessage(chatId: string, streamId: string, content: string, status: MessageStatus, note?: string, toolId?: string, reqId?: string): Promise<void>;
+/**
+ * Send final messages to WeWork (handle long content)
+ */
+export declare function sendFinalMessages(chatId: string, streamId: string, fullContent: string, note: string, toolId?: string, reqId?: string): Promise<void>;
+/**
+ * 主动推送文本（用于启动/关闭通知等，无需 req_id）
+ */
+export declare function sendProactiveTextReply(chatId: string, text: string): Promise<void>;
+/**
+ * Send simple text reply to WeWork
+ * @param threadCtxOrReqId - 兼容 MessageSender 的 threadCtx；若为 string 则作为 reqId 使用
+ */
+export declare function sendTextReply(chatId: string, text: string, threadCtxOrReqId?: import('../shared/types.js').ThreadContext | string): Promise<void>;
+/**
+ * Send permission card with action buttons (for permission prompts)
+ * Note: WeWork doesn't support interactive cards, so we send text with instructions
+ */
+export declare function sendPermissionCard(chatId: string, requestId: string, toolName: string, toolInput: string, reqId?: string): Promise<void>;
+/**
+ * Send mode switch card
+ */
+export declare function sendModeCard(chatId: string, _userId: string, currentMode: string, reqId?: string): Promise<void>;
+/**
+ * Send image reply
+ * Note: WeWork requires media_id for image messages
+ */
+export declare function sendImageReply(chatId: string, imagePath: string): Promise<void>;
+/**
+ * Send directory selection (not supported in WeWork, use text instead)
+ */
+export declare function sendDirectorySelection(chatId: string, currentDir: string, _userId: string): Promise<void>;
+/**
+ * Start typing indicator (WeWork doesn't support this)
+ */
+export declare function startTypingLoop(_chatId: string): () => void;
+/**
+ * Send error message
+ */
+export declare function sendErrorMessage(chatId: string, error: string, reqId?: string): Promise<void>;
+export {};

package/dist/wework/message-sender.js

@@ -0,0 +1,258 @@
+/**
+ * WeWork (企业微信) Message Sender - Send messages to WeWork
+ * 通过 WebSocket aibot_respond_msg 发送，需透传 req_id
+ */
+import { sendText, sendStream, sendProactiveMessage } from './client.js';
+import { createLogger } from '../logger.js';
+import { splitLongContent } from '../shared/utils.js';
+import { MAX_WEWORK_MESSAGE_LENGTH } from '../constants.js';
+import { randomBytes } from 'node:crypto';
+const log = createLogger('WeWorkSender');
+/** 当前同步处理中的 req_id（仅用于 commandHandler 等同步调用） */
+let currentReqId = null;
+export function setCurrentReqId(reqId) {
+    currentReqId = reqId;
+}
+function getReqId(explicitReqId) {
+    const id = explicitReqId ?? currentReqId;
+    if (!id) {
+        log.warn('No req_id - cannot send WeWork reply');
+        return '';
+    }
+    return id;
+}
+const STATUS_CONFIG = {
+    thinking: { icon: '🔵', title: '思考中' },
+    streaming: { icon: '🔄', title: '执行中' },
+    done: { icon: '✅', title: '完成' },
+    error: { icon: '❌', title: '错误' },
+};
+const TOOL_DISPLAY_NAMES = {
+    claude: 'Claude Code',
+    codex: 'Codex',
+    cursor: 'Cursor',
+};
+function getToolTitle(toolId, status) {
+    const name = TOOL_DISPLAY_NAMES[toolId] ?? toolId;
+    const statusText = STATUS_CONFIG[status].title;
+    return status === 'done' ? name : `${name} - ${statusText}`;
+}
+/**
+ * Generate unique request ID
+ */
+function generateReqId() {
+    return `${Date.now()}-${randomBytes(8).toString('hex')}`;
+}
+/**
+ * Generate unique stream ID for WeWork streaming responses
+ */
+function generateStreamId() {
+    return `${Date.now()}-${randomBytes(8).toString('hex')}`;
+}
+/**
+ * Format message for WeWork (markdown-like format)
+ */
+function formatWeWorkMessage(title, content, status, note) {
+    const statusConfig = STATUS_CONFIG[status];
+    let message = `${statusConfig.icon} **${title}**\n\n`;
+    if (content) {
+        message += `${content}\n\n`;
+    }
+    else if (status === 'thinking') {
+        message += `_正在思考，请稍候..._\n\n💭 **准备中**\n\n`;
+    }
+    if (note) {
+        message += `---\n\n💡 **${note}**`;
+    }
+    return message;
+}
+/**
+ * Local tracking for stream states
+ * WeWork doesn't support message editing, so we track stream IDs locally
+ */
+const streamStates = new Map();
+/**
+ * Send thinking message to WeWork
+ * Returns a stream ID that can be used for updates
+ * @param reqId - 消息回调的 req_id，用于 WebSocket 回复
+ */
+export async function sendThinkingMessage(chatId, _replyToMessageId, toolId = 'claude', reqId) {
+    const streamId = generateStreamId();
+    const title = getToolTitle(toolId, 'thinking');
+    const content = formatWeWorkMessage(title, '', 'thinking');
+    try {
+        log.info(`Sending thinking message to user ${chatId}, streamId=${streamId}`);
+        // Store initial stream state
+        streamStates.set(streamId, { content: '', chatId });
+        // Send initial stream message (not finished)
+        sendStream(getReqId(reqId), streamId, content, false);
+        log.info(`Thinking message sent: ${streamId}`);
+        return streamId;
+    }
+    catch (err) {
+        log.error('Failed to send thinking message:', err);
+        throw err;
+    }
+}
+/**
+ * Update existing message in WeWork
+ * Note: WeWork doesn't support message editing, so we send new stream messages
+ */
+export async function updateMessage(chatId, streamId, content, status, note, toolId = 'claude', reqId) {
+    const title = getToolTitle(toolId, status);
+    const message = formatWeWorkMessage(title, content, status, note);
+    try {
+        // Update stream state
+        streamStates.set(streamId, { content, chatId });
+        // Send stream update (not finished yet)
+        sendStream(getReqId(reqId), streamId, message, false);
+        log.info(`Message updated: ${status}, streamId=${streamId}`);
+    }
+    catch (err) {
+        log.error('Failed to update message:', err);
+        throw err;
+    }
+}
+/**
+ * Send final messages to WeWork (handle long content)
+ */
+export async function sendFinalMessages(chatId, streamId, fullContent, note, toolId = 'claude', reqId) {
+    const title = getToolTitle(toolId, 'done');
+    const parts = splitLongContent(fullContent, MAX_WEWORK_MESSAGE_LENGTH);
+    // Send final stream message to finish the stream
+    const finalMessage = formatWeWorkMessage(title, parts[0], 'done', parts.length > 1 ? `内容较长，已分段发送 (1/${parts.length})` : note);
+    try {
+        sendStream(getReqId(reqId), streamId, finalMessage, true);
+        log.info(`Final stream message sent, streamId=${streamId}`);
+        // Clean up stream state
+        streamStates.delete(streamId);
+        // Send remaining parts as separate messages
+        for (let i = 1; i < parts.length; i++) {
+            try {
+                const partContent = `${parts[i]}\n\n_*(续 ${i + 1}/${parts.length})*_`;
+                const partMessage = formatWeWorkMessage(title, partContent, 'done', i === parts.length - 1 ? note : undefined);
+                sendText(getReqId(reqId), partMessage);
+                log.info(`Final message part ${i + 1}/${parts.length} sent`);
+            }
+            catch (err) {
+                log.error(`Failed to send part ${i + 1}:`, err);
+            }
+        }
+    }
+    catch (err) {
+        log.error('Failed to send final messages:', err);
+    }
+}
+/**
+ * 主动推送文本（用于启动/关闭通知等，无需 req_id）
+ */
+export async function sendProactiveTextReply(chatId, text) {
+    const message = formatWeWorkMessage('📢 open-im', text, 'done');
+    try {
+        sendProactiveMessage(chatId, message);
+        log.info(`Proactive text sent to user ${chatId}`);
+    }
+    catch (err) {
+        log.error('Failed to send proactive text:', err);
+    }
+}
+/**
+ * Send simple text reply to WeWork
+ * @param threadCtxOrReqId - 兼容 MessageSender 的 threadCtx；若为 string 则作为 reqId 使用
+ */
+export async function sendTextReply(chatId, text, threadCtxOrReqId) {
+    const message = formatWeWorkMessage('📢 open-im', text, 'done');
+    const reqId = typeof threadCtxOrReqId === 'string' ? threadCtxOrReqId : undefined;
+    try {
+        sendText(getReqId(reqId), message);
+        log.info(`Text reply sent to user ${chatId}`);
+    }
+    catch (err) {
+        log.error('Failed to send text reply:', err);
+    }
+}
+/**
+ * Send permission card with action buttons (for permission prompts)
+ * Note: WeWork doesn't support interactive cards, so we send text with instructions
+ */
+export async function sendPermissionCard(chatId, requestId, toolName, toolInput, reqId) {
+    const message = `🔐 **权限请求**
+
+**工具:** \`${toolName}\`
+
+**参数:**
+\`\`\`
+${toolInput.length > 300 ? toolInput.slice(0, 300) + '...' : toolInput}
+\`\`\`
+
+请回复以下命令进行操作:
+• \`/allow\` - 允许
+• \`/deny\` - 拒绝
+
+**请求 ID:** \`${requestId.slice(-8)}\``;
+    try {
+        sendText(getReqId(reqId), message);
+        log.info(`Permission card sent to user ${chatId}`);
+    }
+    catch (err) {
+        log.error('Failed to send permission card:', err);
+    }
+}
+/**
+ * Send mode switch card
+ */
+export async function sendModeCard(chatId, _userId, currentMode, reqId) {
+    const { MODE_LABELS } = await import('../permission-mode/types.js');
+    const message = `🔐 **权限模式**
+
+**当前模式:** \`${MODE_LABELS[currentMode] || currentMode}\`
+
+发送命令切换模式:
+• \`/mode ask\` - 每次询问
+• \`/mode accept-edits\` - 自动批准编辑
+• \`/mode plan\` - 仅分析
+• \`/mode yolo\` - 跳过所有权限`;
+    try {
+        sendText(getReqId(reqId), message);
+        log.info(`Mode card sent to user ${chatId}`);
+    }
+    catch (err) {
+        log.error('Failed to send mode card:', err);
+    }
+}
+/**
+ * Send image reply
+ * Note: WeWork requires media_id for image messages
+ */
+export async function sendImageReply(chatId, imagePath) {
+    // For now, send text with image path
+    // TODO: Implement media upload and send with media_id
+    await sendTextReply(chatId, `图片已保存: ${imagePath}`);
+}
+/**
+ * Send directory selection (not supported in WeWork, use text instead)
+ */
+export async function sendDirectorySelection(chatId, currentDir, _userId) {
+    await sendTextReply(chatId, `📁 当前目录: \`${currentDir}\`\n\n请使用 \`/cd <目录>\` 命令切换目录`);
+}
+/**
+ * Start typing indicator (WeWork doesn't support this)
+ */
+export function startTypingLoop(_chatId) {
+    // WeWork doesn't have a typing indicator like Telegram
+    // Return a no-op function
+    return () => { };
+}
+/**
+ * Send error message
+ */
+export async function sendErrorMessage(chatId, error, reqId) {
+    const message = formatWeWorkMessage('❌ 错误', error, 'error');
+    try {
+        sendText(getReqId(reqId), message);
+        log.info(`Error message sent to user ${chatId}`);
+    }
+    catch (err) {
+        log.error('Failed to send error message:', err);
+    }
+}