@wu529778790/open-im 0.3.12 → 1.0.0

package/dist/feishu/event-handler.js

@@ -0,0 +1,255 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { AccessControl } from '../access/access-control.js';
+import { RequestQueue } from '../queue/request-queue.js';
+import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, startTypingLoop, sendImageReply, } 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 { MessageDedup } from '../shared/message-dedup.js';
+import { THROTTLE_MS, IMAGE_DIR } from '../constants.js';
+import { setActiveChatId } from '../shared/active-chats.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('FeishuHandler');
+async function downloadFeishuImage(client, imageKey) {
+    await mkdir(IMAGE_DIR, { recursive: true });
+    // Get tenant access token
+    const tokenResp = await client.auth.tenantAccessToken.internal({
+        data: {
+            app_id: client.appId,
+            app_secret: client.appSecret,
+        },
+    });
+    if (tokenResp.code !== 0 || !tokenResp.data) {
+        throw new Error(`Failed to get tenant access token: ${tokenResp.msg}`);
+    }
+    const token = tokenResp.data.tenant_access_token;
+    // Get the image download URL using the correct API endpoint
+    const resourceResp = await fetch(`https://open.feishu.cn/open-apis/im/v1/images/${imageKey}`, {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!resourceResp.ok) {
+        throw new Error(`Failed to get image resource: ${resourceResp.statusText}`);
+    }
+    const resourceData = await resourceResp.json();
+    if (resourceData.code !== 0) {
+        throw new Error(`Failed to get image resource: ${resourceData.msg}`);
+    }
+    // Download the image
+    const imageUrl = resourceData.data?.file_download_url || resourceData.data?.url;
+    if (!imageUrl) {
+        throw new Error('No image URL found in response');
+    }
+    const imgResp = await fetch(imageUrl, {
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!imgResp.ok) {
+        throw new Error(`Failed to download image: ${imgResp.statusText}`);
+    }
+    const buffer = Buffer.from(await imgResp.arrayBuffer());
+    const safeId = imageKey.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const imagePath = join(IMAGE_DIR, `${Date.now()}-${safeId.slice(-8)}.jpg`);
+    await writeFile(imagePath, buffer);
+    return imagePath;
+}
+export function setupFeishuHandlers(config, sessionManager) {
+    const accessControl = new AccessControl(config.feishuAllowedUserIds);
+    const requestQueue = new RequestQueue();
+    const runningTasks = new Map();
+    const stopTaskCleanup = startTaskCleanup(runningTasks);
+    const dedup = new MessageDedup();
+    const commandHandler = new CommandHandler({
+        config,
+        sessionManager,
+        requestQueue,
+        sender: { sendTextReply },
+        getRunningTasksSize: () => runningTasks.size,
+    });
+    registerPermissionSender('feishu', {});
+    async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
+        log.info(`[handleAIRequest] START: userId=${userId}, chatId=${chatId}, prompt="${prompt.slice(0, 50)}..."`);
+        const toolAdapter = getAdapter(config.aiCommand);
+        if (!toolAdapter) {
+            log.error(`[handleAIRequest] No adapter found for: ${config.aiCommand}`);
+            await sendTextReply(chatId, `未配置 AI 工具: ${config.aiCommand}`);
+            return;
+        }
+        log.info(`[handleAIRequest] Adapter found, getting session...`);
+        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);
+        }
+        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: 'feishu', taskKey }, prompt, toolAdapter, {
+            throttleMs: THROTTLE_MS,
+            streamUpdate: async (content, toolNote) => {
+                const note = toolNote ? '输出中...\n' + toolNote : '输出中...';
+                try {
+                    await updateMessage(chatId, msgId, content, 'streaming', note, toolId);
+                }
+                catch (err) {
+                    log.debug('Stream update failed (will retry on next update):', err);
+                }
+            },
+            sendComplete: async (content, note) => {
+                // Use sendFinalMessages to handle the final result
+                await sendFinalMessages(chatId, msgId, content, note ?? '', toolId);
+            },
+            sendError: async (error) => {
+                await updateMessage(chatId, msgId, `错误：${error}`, 'error', '执行失败', toolId);
+            },
+            extraCleanup: () => {
+                stopTyping();
+                runningTasks.delete(taskKey);
+            },
+            onTaskReady: (state) => {
+                runningTasks.set(taskKey, state);
+            },
+            sendImage: (path) => sendImageReply(chatId, path),
+        });
+    }
+    async function handleEvent(data) {
+        log.info('[handleEvent] Called with data:', JSON.stringify(data).slice(0, 500));
+        try {
+            log.info('[handleEvent] Starting processing');
+            // Parse the event data
+            // Feishu event structure (long connection mode):
+            // {
+            //   "event_type": "im.message.receive_v1",
+            //   "event_id": "...",
+            //   "tenant_key": "...",
+            //   "app_id": "...",
+            //   "message": { "chat_id": "...", "content": "...", ... },
+            //   "sender": { "sender_id": { "open_id": "..." } }
+            // }
+            const event = data;
+            const eventType = event?.event_type;
+            log.info('Feishu event type:', eventType);
+            // Handle message received events
+            if (eventType === 'im.message.receive_v1') {
+                log.info('[handleEvent] Processing im.message.receive_v1 event');
+                const message = event?.message;
+                if (!message) {
+                    log.warn('No message data in event');
+                    return;
+                }
+                const chatId = message.chat_id ?? '';
+                const messageId = message.message_id ?? '';
+                const msgType = message.message_type;
+                const contentStr = message.content ?? '{}';
+                log.info(`[handleEvent] Parsed: chatId=${chatId}, msgType=${msgType}`);
+                log.info(`Message: chatId=${chatId}, messageId=${messageId}, msgType=${msgType}`);
+                // Parse message content
+                let content;
+                try {
+                    content = JSON.parse(contentStr);
+                    log.info(`Parsed content:`, JSON.stringify(content).slice(0, 200));
+                }
+                catch (err) {
+                    log.error('Failed to parse message content:', err);
+                    return;
+                }
+                // Get user ID
+                const senderId = event?.sender?.sender_id?.open_id ?? '';
+                if (!senderId) {
+                    log.warn('No sender ID in event');
+                    return;
+                }
+                log.info(`Sender ID: ${senderId}`);
+                // Dedup check
+                const dedupKey = `${chatId}:${messageId}`;
+                if (dedup.isDuplicate(dedupKey)) {
+                    log.info(`Duplicate message detected: ${dedupKey}`);
+                    return;
+                }
+                // Access control check
+                if (!accessControl.isAllowed(senderId)) {
+                    log.warn(`Access denied for sender: ${senderId}`);
+                    sendTextReply(chatId, '抱歉，您没有访问权限。\n您的 ID: ' + senderId).catch(() => { });
+                    return;
+                }
+                log.info(`Access granted for sender: ${senderId}`);
+                setActiveChatId('feishu', chatId);
+                // Handle different message types
+                if (msgType === 'text') {
+                    const text = content.text?.trim() ?? '';
+                    log.info(`Processing text message from ${senderId}: ${text}`);
+                    // Handle commands
+                    try {
+                        const handled = await commandHandler.dispatch(text, chatId, senderId, 'feishu', handleAIRequest);
+                        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(senderId);
+                    const convId = sessionManager.getConvId(senderId);
+                    const enqueueResult = requestQueue.enqueue(senderId, convId, text, async (prompt) => {
+                        log.info(`Executing AI request for: ${prompt}`);
+                        await handleAIRequest(senderId, chatId, prompt, workDir, convId, undefined, messageId);
+                    });
+                    if (enqueueResult === 'rejected') {
+                        sendTextReply(chatId, '请求队列已满，请稍后再试。').catch(() => { });
+                    }
+                    else if (enqueueResult === 'queued') {
+                        sendTextReply(chatId, '您的请求已排队等待。').catch(() => { });
+                    }
+                }
+                else if (msgType === 'image') {
+                    const imageKey = content.image_key;
+                    if (!imageKey)
+                        return;
+                    log.info(`Processing image message from ${senderId}, image_key: ${imageKey}`);
+                    try {
+                        const { getClient } = await import('./client.js');
+                        const c = getClient();
+                        let imagePath;
+                        try {
+                            imagePath = await downloadFeishuImage(c, imageKey);
+                        }
+                        catch (err) {
+                            log.error('Failed to download image:', err);
+                            sendTextReply(chatId, '图片下载失败。').catch(() => { });
+                            return;
+                        }
+                        const prompt = `用户发送了一张图片，已保存到 ${imagePath}。请用 Read 工具查看并分析。`;
+                        const workDir = sessionManager.getWorkDir(senderId);
+                        const convId = sessionManager.getConvId(senderId);
+                        requestQueue.enqueue(senderId, convId, prompt, async (p) => {
+                            await handleAIRequest(senderId, chatId, p, workDir, convId, undefined, messageId);
+                        });
+                    }
+                    catch (err) {
+                        log.error('Error processing image message:', err);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            log.error('[handleEvent] Error processing event:', err);
+        }
+    }
+    return {
+        stop: () => stopTaskCleanup(),
+        getRunningTaskCount: () => runningTasks.size,
+        handleEvent,
+    };
+}

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

@@ -0,0 +1,7 @@
+export type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
+export declare function sendThinkingMessage(chatId: string, replyToMessageId: string | undefined, toolId?: string): Promise<string>;
+export declare function updateMessage(chatId: string, messageId: string, content: string, status: MessageStatus, note?: string, toolId?: string): Promise<void>;
+export declare function sendFinalMessages(chatId: string, messageId: string, fullContent: string, note: string, toolId?: string): Promise<void>;
+export declare function sendTextReply(chatId: string, text: string): Promise<void>;
+export declare function sendImageReply(chatId: string, imagePath: string): Promise<void>;
+export declare function startTypingLoop(_chatId: string): () => void;

package/dist/feishu/message-sender.js

@@ -0,0 +1,253 @@
+import { getClient } from './client.js';
+import { messageCard } from '@larksuiteoapi/node-sdk';
+import { readFileSync } from 'node:fs';
+import { createLogger } from '../logger.js';
+import { splitLongContent } from '../shared/utils.js';
+import { MAX_FEISHU_MESSAGE_LENGTH } from '../constants.js';
+const log = createLogger('FeishuSender');
+const STATUS_ICONS = {
+    thinking: '🔵',
+    streaming: '🔵',
+    done: '🟢',
+    error: '🔴',
+};
+const TOOL_DISPLAY_NAMES = {
+    claude: 'claude-code',
+    codex: 'codex',
+    cursor: 'cursor',
+};
+function getToolTitle(toolId, status) {
+    const name = TOOL_DISPLAY_NAMES[toolId] ?? toolId;
+    if (status === 'thinking')
+        return `${name} - 思考中...`;
+    if (status === 'error')
+        return `${name} - 错误`;
+    return name;
+}
+async function getTenantAccessToken() {
+    const client = getClient();
+    const resp = await client.auth.tenantAccessToken.internal({
+        data: {
+            app_id: client.appId,
+            app_secret: client.appSecret,
+        },
+    });
+    if (resp.code !== 0 || !resp.data) {
+        throw new Error(`Failed to get tenant access token: ${resp.msg}`);
+    }
+    return resp.data.tenant_access_token;
+}
+export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'claude') {
+    const client = getClient();
+    // Use SDK's built-in card builder for simpler messages
+    const cardContent = messageCard.defaultCard({
+        title: `${STATUS_ICONS.thinking} ${getToolTitle(toolId, 'thinking')}`,
+        content: '正在思考...\n\n请稍候...',
+    });
+    try {
+        log.info(`Sending thinking message to chat ${chatId}, replyTo: ${replyToMessageId}`);
+        // 注意：飞书 create 接口不支持 uuid 参数，传 uuid 会导致请求失败
+        const resp = await client.im.message.create({
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: cardContent,
+            },
+            params: { receive_id_type: 'chat_id' },
+        });
+        if (!resp.data || !resp.data.message_id) {
+            throw new Error(`Failed to send message: ${resp.msg}`);
+        }
+        log.info(`Thinking message created with ID: ${resp.data.message_id}`);
+        return resp.data.message_id;
+    }
+    catch (err) {
+        log.error('Failed to send thinking message:', err);
+        throw err;
+    }
+}
+export async function updateMessage(chatId, messageId, content, status, note, toolId = 'claude') {
+    const client = getClient();
+    // Build content with note
+    let fullContent = content;
+    if (note) {
+        fullContent = `${content}\n\n─────────\n${note}`;
+    }
+    const icon = STATUS_ICONS[status];
+    const title = getToolTitle(toolId, status);
+    const cardContent = messageCard.defaultCard({
+        title: `${icon} ${title}`,
+        content: fullContent,
+    });
+    // Try to use patch API for in-place update (streaming)
+    try {
+        const resp = await client.im.message.patch({
+            path: { message_id: messageId },
+            data: {
+                content: cardContent,
+            },
+        });
+        if (resp.code === 0) {
+            log.info(`Message updated in-place: ${messageId}`);
+            return;
+        }
+        // If patch failed with validation error, fall back to delete+create
+        log.warn(`Patch API failed (code: ${resp.code}, msg: ${resp.msg}), falling back to delete+create`);
+    }
+    catch (err) {
+        // Log but don't throw - we'll fall back to delete+create
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        log.debug(`Patch API error: ${errorMsg}, falling back to delete+create`);
+    }
+    // Fallback: Delete old message and send new one
+    try {
+        log.info(`Deleting old message ${messageId}`);
+        await client.im.message.delete({
+            path: { message_id: messageId },
+        });
+        log.info(`Old message deleted successfully`);
+    }
+    catch (err) {
+        log.warn('Failed to delete old message:', err);
+    }
+    // Send new message
+    try {
+        const resp = await client.im.message.create({
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: cardContent,
+            },
+            params: { receive_id_type: 'chat_id' },
+        });
+        log.info(`New message created with ID: ${resp.data?.message_id}`);
+    }
+    catch (err) {
+        log.error('Failed to send new message:', err);
+        throw err;
+    }
+}
+export async function sendFinalMessages(chatId, messageId, fullContent, note, toolId = 'claude') {
+    const client = getClient();
+    const parts = splitLongContent(fullContent, MAX_FEISHU_MESSAGE_LENGTH);
+    // If content fits in one message, try patch for smooth transition
+    if (parts.length === 1) {
+        const cardContent = messageCard.defaultCard({
+            title: `${STATUS_ICONS.done} ${getToolTitle(toolId, 'done')}`,
+            content: fullContent,
+        });
+        // Try to use patch API for in-place update
+        try {
+            const resp = await client.im.message.patch({
+                path: { message_id: messageId },
+                data: {
+                    content: cardContent,
+                },
+            });
+            if (resp.code === 0) {
+                log.info(`Final message updated in-place: ${messageId}`);
+                return;
+            }
+            log.warn(`Patch API failed (code: ${resp.code}), falling back to delete+create`);
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            log.debug(`Patch API error: ${errorMsg}, falling back to delete+create`);
+        }
+    }
+    // Fallback: Delete old message first (for multi-part or failed patch)
+    try {
+        log.info(`Deleting old message ${messageId}`);
+        await client.im.message.delete({
+            path: { message_id: messageId },
+        });
+        log.info(`Old message deleted successfully`);
+    }
+    catch (err) {
+        log.warn('Failed to delete old message:', err);
+    }
+    // Send new messages
+    for (let i = 0; i < parts.length; i++) {
+        try {
+            const cardContent = messageCard.defaultCard({
+                title: `${STATUS_ICONS.done} ${getToolTitle(toolId, 'done')}`,
+                content: i === 0 ? parts[0] : parts[i] + `\n\n(续 ${i + 1}/${parts.length})`,
+            });
+            await client.im.message.create({
+                data: {
+                    receive_id: chatId,
+                    msg_type: 'interactive',
+                    content: cardContent,
+                },
+                params: { receive_id_type: 'chat_id' },
+            });
+        }
+        catch (err) {
+            log.error(`Failed to send part ${i + 1}:`, err);
+        }
+    }
+}
+export async function sendTextReply(chatId, text) {
+    const client = getClient();
+    // Use SDK's built-in card builder for simpler messages
+    const cardContent = messageCard.defaultCard({
+        title: 'open-im',
+        content: text,
+    });
+    try {
+        await client.im.message.create({
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: cardContent,
+            },
+            params: { receive_id_type: 'chat_id' },
+        });
+    }
+    catch (err) {
+        log.error('Failed to send text:', err);
+    }
+}
+export async function sendImageReply(chatId, imagePath) {
+    const client = getClient();
+    try {
+        // First, upload the image to get an image key
+        const imageBuffer = readFileSync(imagePath);
+        const form = new FormData();
+        form.append('file', new Blob([imageBuffer]), 'image.jpg');
+        form.append('image_type', 'message');
+        const token = await getTenantAccessToken();
+        const uploadResp = await fetch('https://open.feishu.cn/open-apis/im/v1/images', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+            body: form,
+        });
+        if (!uploadResp.ok) {
+            throw new Error(`Failed to upload image: ${uploadResp.statusText}`);
+        }
+        const uploadData = await uploadResp.json();
+        if (uploadData.code !== 0) {
+            throw new Error(`Failed to upload image: ${uploadData.msg}`);
+        }
+        const imageKey = uploadData.data.image_key;
+        // Now send the image message
+        await client.im.message.create({
+            data: {
+                receive_id: chatId,
+                msg_type: 'image',
+                content: JSON.stringify({ image_key: imageKey }),
+            },
+            params: { receive_id_type: 'chat_id' },
+        });
+    }
+    catch (err) {
+        log.error('Failed to send image:', err);
+    }
+}
+export function startTypingLoop(_chatId) {
+    // Feishu doesn't have a typing indicator like Telegram
+    // Return a no-op function
+    return () => { };
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { needsSetup } from './config.js';
-import { runInteractiveSetup } from './setup.js';
+import { needsSetup } from "./config.js";
+import { runInteractiveSetup } from "./setup.js";
 export { needsSetup, runInteractiveSetup };
 export declare function main(): Promise<void>;