evolclaw 2.1.1 → 2.2.0

package/dist/channels/feishu.js

@@ -4,29 +4,33 @@ import path from 'path';
 import imageType from 'image-type';
 import { ensureDir } from '../config.js';
 import { logger } from '../utils/logger.js';
-import { markdownToFeishuPost, hasMarkdownSyntax } from '../utils/markdown-to-feishu.js';
+import { hasRichContent, renderAllRichContent, checkDependencies } from '../utils/rich-content-renderer.js';
 export class FeishuChannel {
     config;
     client = null;
     wsClient = null;
     messageHandler;
     projectPathProvider;
-    db;
     cleanupInterval;
-    chatTypeCache = new Map();
+    seenMessages = new Map(); // messageId -> timestamp
+    seenThreads = new Set(); // 已见的 thread_id，用于判断话题创建消息
+    userNameCache = new Map(); // userId -> userName
+    recallHandler;
+    connected = false;
+    enableRichContent;
     constructor(config) {
         this.config = config;
-        this.db = config.db;
-        this.initChatTypeTable();
+        this.enableRichContent = config.enableRichContent ?? true; // 默认启用
     }
-    initChatTypeTable() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS chat_types (
-        chat_id TEXT PRIMARY KEY,
-        chat_mode TEXT NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
-    `);
+    /**
+     * 预填充已知的 thread_id（重启后从数据库恢复，避免误判话题创建）
+     */
+    preloadThreads(threadIds) {
+        for (const id of threadIds)
+            this.seenThreads.add(id);
+        if (threadIds.length > 0) {
+            logger.info(`[Feishu] Preloaded ${threadIds.length} known thread(s)`);
+        }
     }
     async connect() {
         // 检查配置有效性
@@ -51,10 +55,11 @@ export class FeishuChannel {
                         return;
                     }
                     this.markSeen(msg.message_id);
-                    this.addAckReaction(msg.message_id);
                     if (!this.messageHandler)
                         return;
-                    // 话题消息检测日志（去重后）
+                    // 提取 chatType（从 SDK 事件直接获取）
+                    const chatType = msg.chat_type === 'group' ? 'group' : 'private';
+                    // 话题消息检测日志
                     if (msg.thread_id) {
                         logger.info('[Feishu] Thread message, thread_id:', msg.thread_id, 'root_id:', msg.root_id);
                     }
@@ -65,24 +70,37 @@ export class FeishuChannel {
                         key: m.key
                     })).filter((m) => m.userId && m.userId !== this.config.appId);
                     // 提取发送者信息
-                    const userId = data.sender?.sender_id?.open_id;
-                    let userName;
-                    try {
-                        userName = await this.getUserName(userId);
+                    const peerId = data.sender?.sender_id?.open_id;
+                    // 尝试从 mentions 中查找发送者名字（群聊中可能包含）
+                    let peerName;
+                    if (mentions.length > 0) {
+                        const senderMention = mentions.find((m) => m.userId === peerId);
+                        peerName = senderMention?.name;
                     }
-                    catch {
-                        userName = undefined;
+                    // 如果 mentions 中没有，尝试调用 API 获取
+                    if (!peerName && peerId) {
+                        try {
+                            peerName = await this.getUserName(peerId);
+                        }
+                        catch (err) {
+                            logger.debug('[Feishu] getUserName error:', err);
+                        }
                     }
                     try {
                         // 提取话题信息
                         const threadId = msg.thread_id || undefined;
                         const rootId = msg.root_id || undefined;
-                        // 处理引用消息（话题内消息跳过，避免每条都拼接引用前缀）
+                        // 处理引用消息（话题内后续消息跳过，避免每条都拼接引用前缀）
                         let quotedText = '';
                         let quotedImages = [];
-                        // 话题创建消息检测：DB 中无对应 thread session 时为首条消息
-                        const isThreadCreating = threadId && !this.hasThreadSession(threadId);
-                        if (msg.parent_id && (!msg.thread_id || isThreadCreating) && this.client) {
+                        // 引用消息处理：
+                        // - 非话题：直接回复某条消息时，拉取被引用的消息内容
+                        // - 话题首条：创建话题时，拉取根消息内容作为上下文
+                        // - 话题后续：不拉取（上下文由 session 维护）
+                        const isThreadCreation = !!(msg.thread_id && msg.parent_id && !this.seenThreads.has(msg.thread_id));
+                        if (msg.thread_id)
+                            this.seenThreads.add(msg.thread_id);
+                        if (msg.parent_id && (!msg.thread_id || isThreadCreation) && this.client) {
                             try {
                                 const res = await this.client.im.message.get({
                                     path: { message_id: msg.parent_id }
@@ -154,9 +172,11 @@ export class FeishuChannel {
                         if (msg.message_type === 'text') {
                             const parsed = JSON.parse(msg.content);
                             // 优先使用 text_without_at_bot（去除机器人 @），否则使用 text
-                            const content = parsed.text_without_at_bot || parsed.text;
+                            let content = (parsed.text_without_at_bot || parsed.text || '').trim();
+                            // 清理残留的 mention 占位符（@_user_N 代表机器人）
+                            content = content.replace(/@_user_\d+/g, '').trim();
                             const finalContent = quotedText + content;
-                            await this.messageHandler({ channelId: msg.chat_id, content: finalContent, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, mentions: mentions.length > 0 ? mentions : undefined, threadId, rootId });
+                            await this.messageHandler({ channelId: msg.chat_id, content: finalContent, images: quotedImages.length > 0 ? quotedImages : undefined, peerId, peerName, messageId: msg.message_id, mentions: mentions.length > 0 ? mentions : undefined, threadId, rootId, chatType });
                         }
                         // 处理图片消息
                         else if (msg.message_type === 'image') {
@@ -170,11 +190,11 @@ export class FeishuChannel {
                             if (imageData) {
                                 const allImages = [...quotedImages, imageData];
                                 const prompt = quotedText + '用户发送了一张图片，请分析这张图片的内容。';
-                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: allImages, userId, userName, messageId: msg.message_id, threadId, rootId });
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: allImages, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
                             }
                             else {
                                 const prompt = quotedText + '[图片下载失败] 应用可能缺少 im:message 或 im:message:readonly 权限';
-                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
                             }
                         }
                         // 处理文件消息
@@ -189,24 +209,34 @@ export class FeishuChannel {
                             const filePath = await this.downloadFile(fileKey, fileName, msg.message_id, projectPath);
                             if (filePath) {
                                 const prompt = quotedText + `用户发送了文件：${fileName}\n文件已保存到：${filePath}\n请使用 Read 工具读取并分析文件内容。`;
-                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
                             }
                             else {
                                 const prompt = quotedText + '[文件下载失败] 应用可能缺少 im:resource 权限';
-                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
                             }
                         }
                         // 处理富文本消息
                         else if (msg.message_type === 'post') {
                             const parsed = JSON.parse(msg.content);
                             let text = '';
+                            const postImages = [];
                             const title = parsed.zh_cn?.title || parsed.en_us?.title || parsed.title;
                             const content = parsed.zh_cn?.content || parsed.en_us?.content || parsed.content;
                             if (content) {
+                                const projectPath = this.projectPathProvider
+                                    ? await this.projectPathProvider(msg.chat_id)
+                                    : process.cwd();
                                 for (const line of content) {
                                     for (const elem of line) {
-                                        if (elem.text)
+                                        if (elem.tag === 'img' && elem.image_key) {
+                                            const imageData = await this.downloadAndSaveImage(elem.image_key, msg.chat_id, msg.message_id, projectPath);
+                                            if (imageData)
+                                                postImages.push(imageData);
+                                        }
+                                        else if (elem.text) {
                                             text += elem.text;
+                                        }
                                     }
                                     text += '\n';
                                 }
@@ -215,19 +245,27 @@ export class FeishuChannel {
                             if (title)
                                 finalContent = `${title}\n${finalContent}`;
                             finalContent = quotedText + finalContent;
-                            await this.messageHandler({ channelId: msg.chat_id, content: finalContent, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
+                            const allImages = [...quotedImages, ...postImages];
+                            await this.messageHandler({ channelId: msg.chat_id, content: finalContent, images: allImages.length > 0 ? allImages : undefined, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
                         }
                         // 处理其他类型消息
                         else {
                             logger.debug('[Feishu] Unsupported message type:', msg.message_type);
                             const prompt = quotedText + `[不支持的消息类型: ${msg.message_type}]`;
-                            await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
+                            await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
                         }
                     }
                     catch (error) {
                         logger.error('[Feishu] Failed to process message:', error);
                     }
                 },
+                'im.message.recalled_v1': async (data) => {
+                    const messageId = data?.message_id;
+                    if (messageId) {
+                        logger.info('[Feishu] Message recalled:', messageId);
+                        this.recallHandler?.(messageId);
+                    }
+                },
                 'im.message.message_read_v1': async () => { },
                 'im.message.reaction.created_v1': async () => { }
             });
@@ -236,6 +274,7 @@ export class FeishuChannel {
                 appSecret: this.config.appSecret,
             });
             await this.wsClient.start({ eventDispatcher });
+            this.connected = true;
             this.startCleanupTask();
         }
         catch (error) {
@@ -248,43 +287,33 @@ export class FeishuChannel {
     onMessage(handler) {
         this.messageHandler = handler;
     }
+    onRecall(handler) {
+        this.recallHandler = handler;
+    }
     onProjectPathRequest(provider) {
         this.projectPathProvider = provider;
     }
-    async getChatMode(chatId) {
-        logger.info(`[Feishu] getChatMode called for chatId: ${chatId}`);
+    async getUserName(userId) {
+        if (!userId || !this.client)
+            return undefined;
         // 检查缓存
-        if (this.chatTypeCache.has(chatId)) {
-            logger.info(`[Feishu] getChatMode from cache: ${this.chatTypeCache.get(chatId)}`);
-            return this.chatTypeCache.get(chatId);
+        if (this.userNameCache.has(userId)) {
+            return this.userNameCache.get(userId);
         }
-        // 检查数据库
-        const row = this.db.prepare('SELECT chat_mode FROM chat_types WHERE chat_id = ?').get(chatId);
-        if (row) {
-            logger.info(`[Feishu] getChatMode from db: ${row.chat_mode}`);
-            this.chatTypeCache.set(chatId, row.chat_mode);
-            return row.chat_mode;
-        }
-        // 调用 API 获取
-        if (!this.client)
-            return 'p2p';
         try {
-            logger.info(`[Feishu] Calling API to get chat mode for ${chatId}`);
-            const res = await this.client.im.chat.get({ path: { chat_id: chatId } });
-            const chatMode = res.data?.chat_mode || 'p2p';
-            logger.info(`[Feishu] API returned chat_mode: ${chatMode}`);
-            // 保存到数据库和缓存
-            this.db.prepare('INSERT OR REPLACE INTO chat_types (chat_id, chat_mode, updated_at) VALUES (?, ?, ?)').run(chatId, chatMode, Date.now());
-            this.chatTypeCache.set(chatId, chatMode);
-            return chatMode;
+            const res = await this.client.contact.user.get({
+                path: { user_id: userId },
+                params: { user_id_type: 'open_id' }
+            });
+            const userName = res.data?.user?.name;
+            if (userName) {
+                this.userNameCache.set(userId, userName);
+                return userName;
+            }
         }
-        catch (error) {
-            logger.warn('[Feishu] Failed to get chat mode, defaulting to p2p:', error);
-            return 'p2p';
+        catch (err) {
+            logger.debug('[Feishu] Failed to get user name, code:', err?.code, 'msg:', err?.message);
         }
-    }
-    async getUserName(_userId) {
-        // TODO: 需要开通 contact:contact.base:readonly 权限后启用
         return undefined;
     }
     async sendMessage(chatId, content, options) {
@@ -296,27 +325,74 @@ export class FeishuChannel {
         }
         logger.debug(`[Feishu] sendMessage called, chatId: ${chatId}, content length: ${content.length}`);
         try {
+            // 检测富内容并渲染（受 enableRichContent 开关控制，且依赖必须可用）
+            const richItems = (this.enableRichContent && checkDependencies() && hasRichContent(content))
+                ? await renderAllRichContent(content)
+                : [];
+            // 上传所有图片获取 image_key，建立位置映射
+            const richItemsWithKeys = [];
+            for (const item of richItems) {
+                try {
+                    const uploadResponse = await this.client.im.image.create({
+                        data: { image_type: 'message', image: Buffer.from(item.png) }
+                    });
+                    if (uploadResponse?.image_key) {
+                        richItemsWithKeys.push({ start: item.start, end: item.end, imageKey: uploadResponse.image_key });
+                        logger.debug(`[Feishu] Uploaded ${item.type} image, image_key:`, uploadResponse.image_key);
+                    }
+                }
+                catch (err) {
+                    logger.warn(`[Feishu] Failed to upload ${item.type} image:`, err);
+                }
+            }
             const useMarkdown = !options?.forceText && hasMarkdownSyntax(content);
             const hasMention = !!(options?.mentionUserIds && options.mentionUserIds.length > 0);
-            // 如果需要 @，强制使用 post 格式
-            const msgType = (useMarkdown || hasMention) ? 'post' : 'text';
+            const hasRichImages = richItemsWithKeys.length > 0;
+            // 如果有富内容图片、Markdown 或 @，使用 post 格式
+            const msgType = (useMarkdown || hasMention || hasRichImages) ? 'post' : 'text';
             let msgContent;
-            if (hasMention) {
-                // 构造带 @ 的富文本消息
-                const postData = useMarkdown
-                    ? markdownToFeishuPost(content, options?.title)
-                    : { zh_cn: { title: options?.title || '', content: [[{ tag: 'text', text: content }]] } };
+            if (msgType === 'post') {
+                let postData;
+                if (hasRichImages) {
+                    // 有富内容图片：按位置分段文本并插入图片
+                    postData = { zh_cn: { title: options?.title || '', content: [] } };
+                    const sorted = [...richItemsWithKeys].sort((a, b) => a.start - b.start);
+                    let lastEnd = 0;
+                    for (const item of sorted) {
+                        // 插入图片前的文本段
+                        if (item.start > lastEnd) {
+                            const textSegment = content.slice(lastEnd, item.start).trim();
+                            if (textSegment) {
+                                postData.zh_cn.content.push([{ tag: 'text', text: textSegment }]);
+                            }
+                        }
+                        // 插入图片
+                        postData.zh_cn.content.push([{ tag: 'img', image_key: item.imageKey }]);
+                        lastEnd = item.end;
+                    }
+                    // 插入最后一段文本
+                    if (lastEnd < content.length) {
+                        const textSegment = content.slice(lastEnd).trim();
+                        if (textSegment) {
+                            postData.zh_cn.content.push([{ tag: 'text', text: textSegment }]);
+                        }
+                    }
+                }
+                else {
+                    // 无富内容图片：使用原有逻辑
+                    postData = useMarkdown
+                        ? markdownToFeishuPost(content, options?.title)
+                        : { zh_cn: { title: options?.title || '', content: [[{ tag: 'text', text: content }]] } };
+                }
                 // 在第一行开头插入所有 @ 标签
-                if (postData.zh_cn.content.length > 0) {
+                if (hasMention && postData.zh_cn.content.length > 0) {
                     const atTags = options.mentionUserIds.map(uid => ({ tag: 'at', user_id: uid }));
                     postData.zh_cn.content[0].unshift(...atTags);
                 }
                 msgContent = JSON.stringify(postData);
             }
             else {
-                msgContent = useMarkdown
-                    ? JSON.stringify(markdownToFeishuPost(content, options?.title))
-                    : JSON.stringify({ text: content });
+                msgContent = JSON.stringify({ text: content });
             }
             if (options?.replyToMessageId) {
                 const replyData = { msg_type: msgType, content: msgContent };
@@ -334,7 +410,12 @@ export class FeishuChannel {
                     data: { receive_id: chatId, msg_type: msgType, content: msgContent }
                 });
             }
-            logger.debug(`[Feishu] Sent message as ${useMarkdown ? 'post (Markdown)' : 'text'}`);
+            if (hasRichImages) {
+                logger.info(`[Feishu] Sent message with ${richItemsWithKeys.length} embedded images`);
+            }
+            else {
+                logger.debug(`[Feishu] Sent message as ${useMarkdown ? 'post (Markdown)' : 'text'}`);
+            }
         }
         catch (error) {
             // 230011: 消息已被撤回，降级为普通消息重试
@@ -346,10 +427,21 @@ export class FeishuChannel {
             throw error;
         }
     }
-    async sendFile(chatId, filePath) {
+    async sendFile(chatId, filePath, options) {
         if (!this.client)
             return;
         try {
+            // 检测是否为图片，是则走 sendImage（内联预览）而非文件卡片
+            const header = Buffer.alloc(12);
+            const fd = fs.openSync(filePath, 'r');
+            fs.readSync(fd, header, 0, 12, 0);
+            fs.closeSync(fd);
+            const imgType = await imageType(header);
+            if (imgType) {
+                logger.info(`[Feishu] Detected image (${imgType.mime}), sending as inline image:`, filePath);
+                const buf = fs.readFileSync(filePath);
+                return this.sendImage(chatId, buf, options);
+            }
             logger.info('[Feishu] Uploading file:', filePath);
             const fileStream = fs.createReadStream(filePath);
             const fileName = path.basename(filePath);
@@ -365,32 +457,104 @@ export class FeishuChannel {
                 return;
             }
             const fileKey = uploadResponse.file_key;
+            const msgContent = JSON.stringify({ file_key: fileKey });
             logger.info('[Feishu] File uploaded, file_key:', fileKey);
-            await this.client.im.message.create({
-                params: { receive_id_type: 'chat_id' },
-                data: {
-                    receive_id: chatId,
-                    msg_type: 'file',
-                    content: JSON.stringify({ file_key: fileKey })
+            if (options?.replyToMessageId) {
+                const replyData = { msg_type: 'file', content: msgContent };
+                if (options.replyInThread) {
+                    replyData.reply_in_thread = true;
                 }
-            });
+                await this.client.im.message.reply({
+                    path: { message_id: options.replyToMessageId },
+                    data: replyData
+                });
+            }
+            else {
+                await this.client.im.message.create({
+                    params: { receive_id_type: 'chat_id' },
+                    data: {
+                        receive_id: chatId,
+                        msg_type: 'file',
+                        content: msgContent
+                    }
+                });
+            }
             logger.info('[Feishu] File message sent successfully');
         }
         catch (error) {
+            // 230011: 消息已被撤回，降级为普通消息重试
+            if (error.response?.data?.code === 230011 && options?.replyToMessageId) {
+                logger.warn('[Feishu] Message withdrawn (230011), retrying file send without reply');
+                return this.sendFile(chatId, filePath);
+            }
             logger.error('[Feishu] Failed to send file:', error);
             throw error;
         }
     }
-    hasThreadSession(threadId) {
+    async sendImage(chatId, png, options) {
+        if (!this.client)
+            return;
         try {
-            const row = this.db.prepare('SELECT 1 FROM sessions WHERE thread_id = ? LIMIT 1').get(threadId);
-            return !!row;
+            const uploadResponse = await this.client.im.image.create({
+                data: {
+                    image_type: 'message',
+                    image: Buffer.from(png),
+                }
+            });
+            const imageKey = uploadResponse?.image_key;
+            if (!imageKey) {
+                logger.error('[Feishu] Image upload failed: no image_key returned');
+                return;
+            }
+            logger.debug('[Feishu] Image uploaded, image_key:', imageKey);
+            const msgContent = JSON.stringify({ image_key: imageKey });
+            if (options?.replyToMessageId) {
+                const replyData = { msg_type: 'image', content: msgContent };
+                if (options.replyInThread)
+                    replyData.reply_in_thread = true;
+                await this.client.im.message.reply({
+                    path: { message_id: options.replyToMessageId },
+                    data: replyData
+                });
+            }
+            else {
+                await this.client.im.message.create({
+                    params: { receive_id_type: 'chat_id' },
+                    data: { receive_id: chatId, msg_type: 'image', content: msgContent }
+                });
+            }
+            logger.debug('[Feishu] Image message sent successfully');
         }
-        catch {
-            return false;
+        catch (error) {
+            logger.error('[Feishu] Failed to send image:', error);
+            throw error;
         }
     }
+    isDuplicate(msgId) {
+        return this.seenMessages.has(msgId);
+    }
+    markSeen(msgId) {
+        this.seenMessages.set(msgId, Date.now());
+    }
+    startCleanupTask() {
+        this.cleanupInterval = setInterval(() => {
+            const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+            let cleaned = 0;
+            for (const [id, ts] of this.seenMessages) {
+                if (ts < cutoff) {
+                    this.seenMessages.delete(id);
+                    cleaned++;
+                }
+            }
+            if (cleaned > 0)
+                logger.info(`[Feishu] Cleaned ${cleaned} old message IDs`);
+            // seenThreads 无时间戳，仅限容量（话题持久存在，不按时间清理）
+            if (this.seenThreads.size > 1000)
+                this.seenThreads.clear();
+        }, 60 * 60 * 1000);
+    }
     async disconnect() {
+        this.connected = false;
         if (this.cleanupInterval) {
             clearInterval(this.cleanupInterval);
             this.cleanupInterval = undefined;
@@ -401,6 +565,23 @@ export class FeishuChannel {
         }
         this.client = null;
     }
+    /** Get current connection status */
+    getStatus() {
+        return { connected: this.connected };
+    }
+    /** Reconnect: disconnect then connect again */
+    async reconnect() {
+        if (this.connected) {
+            await this.disconnect();
+        }
+        try {
+            await this.connect();
+            return '重连成功';
+        }
+        catch (err) {
+            return `重连失败: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
     async downloadAndSaveImage(imageKey, chatId, messageId, projectPath) {
         if (!this.client)
             return null;
@@ -490,7 +671,7 @@ export class FeishuChannel {
                     logger.warn('[Feishu] Empty response from file download');
                     return null;
                 }
-                const uploadsDir = path.join(projectPath, '.claude', 'uploads');
+                const uploadsDir = path.join(projectPath, '.evolclaw', 'uploads');
                 ensureDir(uploadsDir);
                 const filePath = path.join(uploadsDir, fileName);
                 fs.writeFileSync(filePath, buffer);
@@ -505,13 +686,6 @@ export class FeishuChannel {
             return null;
         }
     }
-    isDuplicate(msgId) {
-        const result = this.db.prepare('SELECT 1 FROM processed_messages WHERE message_id = ? LIMIT 1').get(msgId);
-        return !!result;
-    }
-    markSeen(msgId) {
-        this.db.prepare('INSERT OR IGNORE INTO processed_messages (message_id, channel, channel_id, processed_at) VALUES (?, ?, ?, ?)').run(msgId, 'feishu', '', Date.now());
-    }
     addAckReaction(messageId) {
         if (!this.client)
             return;
@@ -522,13 +696,132 @@ export class FeishuChannel {
             }
         }).catch(() => { });
     }
-    startCleanupTask() {
-        this.cleanupInterval = setInterval(() => {
-            const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-            const result = this.db.prepare('DELETE FROM processed_messages WHERE processed_at < ?').run(cutoff);
-            if (result.changes > 0) {
-                logger.info(`[Feishu] Cleaned ${result.changes} old processed messages`);
-            }
-        }, 60 * 60 * 1000);
+}
+function displayWidth(str) {
+    let width = 0;
+    for (const ch of str) {
+        const code = ch.codePointAt(0);
+        if ((code >= 0x4E00 && code <= 0x9FFF) ||
+            (code >= 0x3400 && code <= 0x4DBF) ||
+            (code >= 0xF900 && code <= 0xFAFF) ||
+            (code >= 0xFF01 && code <= 0xFF60) ||
+            (code >= 0x3000 && code <= 0x303F)) {
+            width += 2;
+        }
+        else {
+            width += 1;
+        }
+    }
+    return width;
+}
+function padToWidth(str, targetWidth) {
+    const current = displayWidth(str);
+    const padding = Math.max(0, targetWidth - current);
+    return str + ' '.repeat(padding);
+}
+function convertTablesToText(text) {
+    const tableRegex = /^(\|.+\|)\n(\|[\s:|-]+\|)\n((?:\|.+\|\n?)+)/gm;
+    return text.replace(tableRegex, (_match, headerLine, _sep, bodyBlock) => {
+        const parseRow = (line) => line.split('|').slice(1, -1).map((c) => c.trim());
+        const headers = parseRow(headerLine);
+        const rows = bodyBlock.trim().split('\n').map(parseRow);
+        const colWidths = headers.map((h, i) => {
+            const cellWidths = rows.map(r => displayWidth(r[i] || ''));
+            return Math.max(displayWidth(h), ...cellWidths);
+        });
+        const headerStr = headers.map((h, i) => padToWidth(h, colWidths[i])).join('  ');
+        const sepStr = colWidths.map(w => '-'.repeat(w)).join('  ');
+        const rowStrs = rows.map(r => headers.map((_, i) => padToWidth(r[i] || '', colWidths[i])).join('  '));
+        return '```\n' + [headerStr, sepStr, ...rowStrs].join('\n') + '\n```';
+    });
+}
+export function markdownToFeishuPost(markdown, defaultTitle) {
+    const match = markdown.match(/^# (.+)$/m);
+    const title = match?.[1] ?? defaultTitle ?? '';
+    let body = match ? markdown.replace(/^# .+\n?/, '') : markdown;
+    body = convertTablesToText(body);
+    return {
+        zh_cn: {
+            title,
+            content: [[{ tag: 'md', text: body.trim() }]]
+        }
+    };
+}
+export function hasMarkdownSyntax(text) {
+    const markdownPatterns = [
+        /^#{1,6}\s/m, /\*\*.*?\*\*/, /\*.*?\*/, /__.*?__/, /_.*?_/, /~~.*?~~/,
+        /`.*?`/, /```[\s\S]*?```/, /\[.*?\]\(.*?\)/, /^[\s]*[-*+]\s/m,
+        /^[\s]*\d+\.\s/m, /^\|.+\|$/m
+    ];
+    return markdownPatterns.some(pattern => pattern.test(text));
+}
+export class FeishuChannelPlugin {
+    name = 'feishu';
+    isEnabled(config) {
+        const feishuConfig = config.channels?.feishu;
+        if (feishuConfig?.enabled === false)
+            return false;
+        return !!(feishuConfig?.appId && feishuConfig?.appSecret);
+    }
+    async createChannel(config) {
+        const feishuConfig = config.channels?.feishu;
+        if (!feishuConfig?.appId || !feishuConfig?.appSecret) {
+            throw new Error('Feishu config missing');
+        }
+        const channel = new FeishuChannel({
+            appId: feishuConfig.appId,
+            appSecret: feishuConfig.appSecret,
+            enableRichContent: feishuConfig.enableRichContent,
+        });
+        const adapter = {
+            name: 'feishu',
+            sendText: (id, text, context) => channel.sendMessage(id, text, context),
+            sendFile: (id, filePath, context) => channel.sendFile(id, filePath, context),
+            sendImage: (id, png, context) => channel.sendImage(id, png, context),
+            acknowledge: (messageId) => { channel.addAckReaction(messageId); return Promise.resolve(); },
+        };
+        const policy = {
+            canSwitchProject: (chatType, identity) => identity === 'owner',
+            canListProjects: (chatType, identity) => identity === 'owner',
+            canCreateSession: (chatType, identity) => true,
+            canDeleteSession: (chatType, identity) => true,
+            canImportCliSession: (chatType, identity) => identity === 'owner',
+            messagePrefix: (chatType, peerName) => (chatType === 'group' && peerName) ? `[${peerName}] ` : '',
+            showMiddleResult: (chatType, identity) => {
+                const mode = feishuConfig.showActivities ?? config.showActivities ?? 'all';
+                if (mode === 'none')
+                    return false;
+                if (mode === 'dm-only')
+                    return chatType === 'private';
+                if (mode === 'owner-dm-only')
+                    return chatType === 'private' && identity === 'owner';
+                return true;
+            },
+            showIdleMonitor: (chatType, identity) => {
+                const mode = feishuConfig.showActivities ?? config.showActivities ?? 'all';
+                if (mode === 'none')
+                    return false;
+                if (mode === 'dm-only')
+                    return chatType === 'private';
+                if (mode === 'owner-dm-only')
+                    return chatType === 'private' && identity === 'owner';
+                return true;
+            },
+            accumulateErrors: (chatType, identity) => true,
+        };
+        const options = {
+            fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g,
+            supportsImages: true,
+            flushDelay: feishuConfig.flushDelay,
+        };
+        return {
+            adapter,
+            channel,
+            policy,
+            options,
+            connect: () => channel.connect(),
+            disconnect: () => channel.disconnect(),
+            onProjectPathRequest: (channelId) => Promise.resolve(config.projects?.defaultPath || process.cwd()),
+        };
     }
 }