evolclaw 2.1.2 → 2.3.0

package/dist/channels/feishu.js

@@ -2,31 +2,36 @@ import * as lark from '@larksuiteoapi/node-sdk';
 import fs from 'fs';
 import path from 'path';
 import imageType from 'image-type';
-import { ensureDir } from '../config.js';
+import { sanitizeFileName, saveToUploads, validateImage } from '../utils/media-cache.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;
+    interactionCallback;
+    connected = false;
+    enableRichContent;
     constructor(config) {
         this.config = config;
-        this.db = config.db;
-        this.initChatTypeTable();
-    }
-    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
-      )
-    `);
+        this.enableRichContent = config.enableRichContent ?? false; // 默认关闭
+    }
+    /**
+     * 预填充已知的 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 +56,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 +71,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 }
@@ -94,7 +113,7 @@ export class FeishuChannel {
                                 const quotedContent = res.data.items[0].body.content;
                                 if (quotedMsgType === 'text') {
                                     const parsed = JSON.parse(quotedContent);
-                                    quotedText = `> ${parsed.text}\n\n`;
+                                    quotedText = `> 以下是引用的原消息\n> ================\n> ${parsed.text}\n> ================\n\n`;
                                 }
                                 else if (quotedMsgType === 'post') {
                                     const parsed = JSON.parse(quotedContent);
@@ -110,7 +129,7 @@ export class FeishuChannel {
                                             text += '\n';
                                         }
                                     }
-                                    quotedText = `> ${text.trim()}\n\n`;
+                                    quotedText = `> 以下是引用的原消息\n> ================\n> ${text.trim()}\n> ================\n\n`;
                                 }
                                 else if (quotedMsgType === 'image') {
                                     const parsed = JSON.parse(quotedContent);
@@ -121,10 +140,10 @@ export class FeishuChannel {
                                     const imageData = await this.downloadAndSaveImage(imageKey, msg.chat_id, msg.parent_id, projectPath);
                                     if (imageData) {
                                         quotedImages.push(imageData);
-                                        quotedText = `> [引用的图片]\n\n`;
+                                        quotedText = `> 以下是引用的原消息\n> ================\n> [引用的图片]\n> ================\n\n`;
                                     }
                                     else {
-                                        quotedText = `> [图片消息]\n\n`;
+                                        quotedText = `> 以下是引用的原消息\n> ================\n> [图片消息]\n> ================\n\n`;
                                     }
                                 }
                                 else if (quotedMsgType === 'file') {
@@ -136,14 +155,14 @@ export class FeishuChannel {
                                         : process.cwd();
                                     const quotedFilePath = await this.downloadFile(quotedFileKey, quotedFileName, msg.parent_id, projectPath);
                                     if (quotedFilePath) {
-                                        quotedText = `> [引用的文件：${quotedFileName}]\n> 文件已保存到：${quotedFilePath}\n\n`;
+                                        quotedText = `> 以下是引用的原消息\n> ================\n> [引用的文件：${quotedFileName}]\n> 文件已保存到：${quotedFilePath}\n> ================\n\n`;
                                     }
                                     else {
-                                        quotedText = `> [文件消息]\n\n`;
+                                        quotedText = `> 以下是引用的原消息\n> ================\n> [文件消息]\n> ================\n\n`;
                                     }
                                 }
                                 else {
-                                    quotedText = `> [${quotedMsgType}消息]\n\n`;
+                                    quotedText = `> 以下是引用的原消息\n> ================\n> [${quotedMsgType}消息]\n> ================\n\n`;
                                 }
                             }
                             catch (err) {
@@ -154,9 +173,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 +191,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 +210,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,27 +246,75 @@ 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 () => { }
+                'im.message.reaction.created_v1': async () => { },
+                'card.action.trigger': async (data) => {
+                    try {
+                        const action = data?.action;
+                        if (!action?.value)
+                            return;
+                        const value = action.value;
+                        const requestId = value._request_id;
+                        if (!requestId) {
+                            logger.debug('[Feishu] Card action without _request_id, ignoring');
+                            return;
+                        }
+                        // Legacy field change (non-form select_static with _field_key): ignore silently
+                        if (value._field_key) {
+                            logger.debug(`[Feishu] Legacy field change: requestId=${requestId}, field=${value._field_key}`);
+                            return;
+                        }
+                        // Form submit: `action.form_value` contains all field values from form container
+                        const formValues = action.form_value || {};
+                        const response = {
+                            type: 'interaction.response',
+                            id: requestId,
+                            action: value._action || 'submit',
+                            values: { ...formValues, ...value },
+                            operatorId: data.operator?.open_id,
+                        };
+                        // Remove internal fields from values
+                        delete response.values._request_id;
+                        delete response.values._action;
+                        delete response.values._card_title;
+                        logger.info(`[Feishu] Card action: requestId=${requestId}, action=${response.action}, values=${JSON.stringify(response.values)}`);
+                        this.interactionCallback?.(response);
+                        // Return updated card (buttons disabled + result shown)
+                        const cardTitle = value._card_title || '操作';
+                        return this.buildResolvedCard(cardTitle, response);
+                    }
+                    catch (err) {
+                        logger.error('[Feishu] Failed to handle card action:', err);
+                    }
+                },
             });
             this.wsClient = new lark.WSClient({
                 appId: this.config.appId,
                 appSecret: this.config.appSecret,
             });
             await this.wsClient.start({ eventDispatcher });
+            this.connected = true;
             this.startCleanupTask();
         }
         catch (error) {
@@ -248,43 +327,36 @@ export class FeishuChannel {
     onMessage(handler) {
         this.messageHandler = handler;
     }
+    onRecall(handler) {
+        this.recallHandler = handler;
+    }
+    onInteraction(callback) {
+        this.interactionCallback = callback;
+    }
     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);
-        }
-        // 检查数据库
-        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';
+        if (this.userNameCache.has(userId)) {
+            return this.userNameCache.get(userId);
+        }
         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) {
@@ -294,29 +366,89 @@ export class FeishuChannel {
             logger.warn('[Feishu] Attempted to send empty message, skipping');
             return;
         }
+        // 飞书消息内容限制约 30KB（text）/ 150KB（post），安全阈值 28000 字符
+        // 超长消息自动拆分，按段落边界分割
+        const MAX_CONTENT_LENGTH = 28000;
+        if (content.length > MAX_CONTENT_LENGTH) {
+            logger.info(`[Feishu] Message too long (${content.length} chars), splitting into parts`);
+            const parts = splitLongMessage(content, MAX_CONTENT_LENGTH);
+            for (let i = 0; i < parts.length; i++) {
+                // 首条消息保留 reply 选项，后续消息不再 reply
+                const partOptions = i === 0 ? options : { ...options, replyToMessageId: undefined };
+                await this.sendMessage(chatId, parts[i], partOptions);
+            }
+            return;
+        }
         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，否则 text
+            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 };
@@ -330,11 +462,16 @@ export class FeishuChannel {
             }
             else {
                 await this.client.im.message.create({
-                    params: { receive_id_type: 'chat_id' },
+                    params: { receive_id_type: chatId.startsWith('ou_') ? 'open_id' : chatId.startsWith('on_') ? 'union_id' : 'chat_id' },
                     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: 消息已被撤回，降级为普通消息重试
@@ -342,14 +479,31 @@ export class FeishuChannel {
                 logger.warn('[Feishu] Message withdrawn (230011), retrying without reply');
                 return this.sendMessage(chatId, content, { ...options, replyToMessageId: undefined });
             }
+            // 230025: 消息内容超长，截断后重试
+            if (error.response?.data?.code === 230025) {
+                logger.warn(`[Feishu] Message too long (230025, ${content.length} chars), truncating`);
+                const truncated = content.slice(0, 28000) + '\n\n⚠️ 消息过长，已截断';
+                return this.sendMessage(chatId, truncated, options);
+            }
             logger.error('[Feishu] Failed to send message:', error);
             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 +519,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: chatId.startsWith('ou_') ? 'open_id' : chatId.startsWith('on_') ? 'union_id' : '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: chatId.startsWith('ou_') ? 'open_id' : chatId.startsWith('on_') ? 'union_id' : '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 +627,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;
@@ -428,28 +671,17 @@ export class FeishuChannel {
                     logger.warn('[Feishu] Empty response from image download');
                     return null;
                 }
-                // 使用 image-type 检测真实的图片格式
-                const type = await imageType(buffer);
-                if (!type) {
-                    logger.warn('[Feishu] Unable to detect image type');
-                    return null;
-                }
-                // 白名单验证：只允许常见的图片格式
-                const allowedMimes = ['image/png', 'image/jpeg', 'image/gif', 'image/webp'];
-                if (!allowedMimes.includes(type.mime)) {
-                    logger.warn('[Feishu] Unsupported image type:', type.mime);
-                    return null;
-                }
-                // 大小限制：10MB
-                if (buffer.length > 10 * 1024 * 1024) {
-                    logger.warn('[Feishu] Image too large:', buffer.length, 'bytes');
+                // 统一图片验证（类型白名单 + 大小限制）
+                const result = await validateImage(buffer);
+                if (result.mime === null) {
+                    logger.warn(`[Feishu] Image validation failed: ${result.reason}`);
                     return null;
                 }
                 const base64Data = buffer.toString('base64');
-                logger.debug('[Feishu] Image downloaded successfully, type:', type.mime, 'size:', base64Data.length);
+                logger.debug('[Feishu] Image downloaded successfully, type:', result.mime, 'size:', base64Data.length);
                 return {
                     data: base64Data,
-                    mimeType: type.mime // 使用真实检测的 MIME 类型
+                    mimeType: result.mime
                 };
             }
             logger.error('[Feishu] Image download failed: no valid method');
@@ -490,11 +722,7 @@ export class FeishuChannel {
                     logger.warn('[Feishu] Empty response from file download');
                     return null;
                 }
-                const uploadsDir = path.join(projectPath, '.claude', 'uploads');
-                ensureDir(uploadsDir);
-                const filePath = path.join(uploadsDir, fileName);
-                fs.writeFileSync(filePath, buffer);
-                logger.info('[Feishu] File downloaded successfully:', filePath, 'size:', buffer.length);
+                const { filePath } = saveToUploads(buffer, sanitizeFileName(fileName), projectPath);
                 return filePath;
             }
             logger.error('[Feishu] File download failed: no valid method');
@@ -505,12 +733,101 @@ 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;
+    async sendInteraction(chatId, interaction, options) {
+        if (!this.client)
+            return false;
+        const card = buildInteractionCard(interaction);
+        if (!card)
+            return false;
+        try {
+            let messageId;
+            if (options?.replyToMessageId) {
+                const replyData = {
+                    msg_type: 'interactive',
+                    content: JSON.stringify(card),
+                };
+                if (options.replyInThread)
+                    replyData.reply_in_thread = true;
+                const res = await this.client.im.message.reply({
+                    path: { message_id: options.replyToMessageId },
+                    data: replyData,
+                });
+                messageId = res?.data?.message_id;
+            }
+            else {
+                const res = await this.client.im.message.create({
+                    params: { receive_id_type: chatId.startsWith('ou_') ? 'open_id' : chatId.startsWith('on_') ? 'union_id' : 'chat_id' },
+                    data: {
+                        receive_id: chatId,
+                        msg_type: 'interactive',
+                        content: JSON.stringify(card),
+                    },
+                });
+                messageId = res?.data?.message_id;
+            }
+            logger.info(`[Feishu] Sent interaction card: ${interaction.id}, messageId=${messageId}`);
+            return messageId || false;
+        }
+        catch (error) {
+            const detail = error?.response?.data || error?.message || error;
+            logger.error(`[Feishu] Failed to send interaction card (id=${interaction.id}, replyTo=${options?.replyToMessageId || 'none'}):`, detail);
+            return false;
+        }
     }
-    markSeen(msgId) {
-        this.db.prepare('INSERT OR IGNORE INTO processed_messages (message_id, channel, channel_id, processed_at) VALUES (?, ?, ?, ?)').run(msgId, 'feishu', '', Date.now());
+    async patchInteractionCard(messageId, card) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.im.message.patch({
+                path: { message_id: messageId },
+                data: { content: JSON.stringify(card) },
+            });
+        }
+        catch (error) {
+            logger.warn(`[Feishu] Failed to patch card ${messageId}:`, error?.response?.data || error?.message);
+        }
+    }
+    buildResolvedCard(cardTitle, response) {
+        const action = response.action;
+        const labelMap = {
+            'allow': '✅ 已允许',
+            'always': '🔓 已设为始终允许',
+            'deny': '❌ 已拒绝',
+            'cancel': '取消',
+            'submit': '✅ 已提交',
+        };
+        const statusText = labelMap[action] || `✅ ${action}`;
+        const now = new Date().toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' });
+        // Build summary of selected values
+        const elements = [];
+        if (response.values && action === 'submit') {
+            const entries = Object.entries(response.values).filter(([k]) => !k.startsWith('_'));
+            if (entries.length > 0) {
+                const lines = entries.map(([k, v]) => {
+                    const display = Array.isArray(v) ? v.join(', ') : String(v);
+                    return `**${k}**: ${display}`;
+                });
+                elements.push({ tag: 'markdown', content: lines.join('\n') });
+            }
+        }
+        elements.push({ tag: 'markdown', content: `操作时间：${now}` });
+        return {
+            toast: {
+                type: 'success',
+                content: statusText,
+            },
+            card: {
+                type: 'raw',
+                data: {
+                    config: { wide_screen_mode: true },
+                    header: {
+                        template: action === 'deny' ? 'red' : 'green',
+                        title: { tag: 'plain_text', content: `${cardTitle} — ${statusText}` },
+                    },
+                    elements,
+                },
+            },
+        };
     }
     addAckReaction(messageId) {
         if (!this.client)
@@ -522,13 +839,449 @@ 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);
+}
+// ── 交互卡片构建工具 ──
+export function buildInteractionCard(interaction) {
+    const { kind } = interaction;
+    if (kind.kind === 'action') {
+        return buildActionCard(interaction.id, kind);
+    }
+    if (kind.kind === 'form') {
+        return buildFormCard(interaction.id, kind);
+    }
+    // menu kind: not rendered as card (handled via menu.response JSON)
+    return null;
+}
+export function buildActionCard(requestId, action) {
+    const elements = [];
+    // Body text
+    if (action.body) {
+        elements.push({ tag: 'markdown', content: action.body });
+    }
+    // Buttons row
+    const buttons = action.buttons.map(btn => {
+        const buttonEl = {
+            tag: 'button',
+            text: { tag: 'plain_text', content: btn.label },
+            type: btn.style === 'danger' ? 'danger' : btn.style === 'primary' ? 'primary' : 'default',
+            value: {
+                _request_id: requestId,
+                _action: btn.key,
+                _card_title: action.title,
+            },
+        };
+        if (btn.confirm) {
+            buttonEl.confirm = {
+                title: { tag: 'plain_text', content: btn.confirm.title },
+                text: { tag: 'plain_text', content: btn.confirm.body },
+            };
+        }
+        return buttonEl;
+    });
+    elements.push({
+        tag: 'action',
+        actions: buttons,
+    });
+    return {
+        config: { wide_screen_mode: true },
+        header: {
+            template: 'blue',
+            title: { tag: 'plain_text', content: action.title },
+        },
+        elements,
+    };
+}
+export function buildFormCard(requestId, form) {
+    // Use Feishu card v2 form container: all fields wrapped in a `form` tag.
+    // On submit, callback receives `action.form_value` with all field values keyed by `name`.
+    // This eliminates per-field callbacks when selecting dropdown options.
+    const formElements = [];
+    // Body text
+    if (form.body) {
+        formElements.push({ tag: 'markdown', content: form.body });
+    }
+    // Fields — inside form, components use `name` (not `value`) for identification
+    for (const field of form.fields) {
+        formElements.push(buildFormFieldElement(field));
+        if (field.hint) {
+            formElements.push({
+                tag: 'note',
+                elements: [{ tag: 'plain_text', content: field.hint }],
+            });
+        }
+    }
+    // Submit button (inside form, uses form_action_type)
+    const submitBtn = {
+        tag: 'button',
+        text: { tag: 'plain_text', content: form.submitLabel || '确认' },
+        type: form.submitStyle === 'danger' ? 'danger' : 'primary',
+        form_action_type: 'submit',
+        name: 'submit',
+        value: {
+            _request_id: requestId,
+            _action: 'submit',
+            _card_title: form.title,
+        },
+    };
+    if (form.submitConfirm) {
+        submitBtn.confirm = {
+            title: { tag: 'plain_text', content: form.submitConfirm.title },
+            text: { tag: 'plain_text', content: form.submitConfirm.body },
+        };
+    }
+    const actions = [submitBtn];
+    if (form.cancelable !== false) {
+        actions.push({
+            tag: 'button',
+            text: { tag: 'plain_text', content: '取消' },
+            type: 'default',
+            // Cancel is NOT form_action_type — it's a regular button that triggers callback directly
+            value: {
+                _request_id: requestId,
+                _action: 'cancel',
+                _card_title: form.title,
+            },
+        });
+    }
+    formElements.push({ tag: 'action', actions });
+    return {
+        schema: '2.0',
+        config: { update_multi: true },
+        header: {
+            template: 'blue',
+            title: { tag: 'plain_text', content: form.title },
+        },
+        body: {
+            elements: [
+                {
+                    tag: 'form',
+                    name: requestId,
+                    elements: formElements,
+                },
+            ],
+        },
+    };
+}
+/** Build a field element for use inside a form container (uses `name` for identification) */
+export function buildFormFieldElement(field) {
+    switch (field.type) {
+        case 'select': {
+            const options = field.options.map(opt => ({
+                text: { tag: 'plain_text', content: opt.label },
+                value: opt.value,
+            }));
+            const selectedOpt = field.options.find(opt => opt.selected);
+            return {
+                tag: 'select_static',
+                name: field.key,
+                placeholder: { tag: 'plain_text', content: field.placeholder || `选择${field.label}` },
+                options,
+                ...(selectedOpt ? { initial_option: selectedOpt.value } : {}),
+            };
+        }
+        case 'text': {
+            return {
+                tag: 'input',
+                name: field.key,
+                placeholder: { tag: 'plain_text', content: field.placeholder || `输入${field.label}` },
+                ...(field.defaultValue != null ? { default_value: String(field.defaultValue) } : {}),
+            };
+        }
+        case 'toggle': {
+            const checked = field.defaultValue ?? false;
+            return {
+                tag: 'select_static',
+                name: field.key,
+                placeholder: { tag: 'plain_text', content: field.label },
+                options: [
+                    { text: { tag: 'plain_text', content: '开启' }, value: 'true' },
+                    { text: { tag: 'plain_text', content: '关闭' }, value: 'false' },
+                ],
+                initial_option: checked ? 'true' : 'false',
+            };
+        }
+        case 'multi-select': {
+            const options = field.options.map(opt => ({
+                text: { tag: 'plain_text', content: opt.label },
+                value: opt.value,
+            }));
+            const selectedValues = field.options.filter(opt => opt.selected).map(opt => opt.value);
+            return {
+                tag: 'multi_select_static',
+                name: field.key,
+                placeholder: { tag: 'plain_text', content: `选择${field.label}` },
+                options,
+                ...(selectedValues.length > 0 ? { initial_options: selectedValues } : {}),
+            };
+        }
+        default:
+            return { tag: 'markdown', content: `[不支持的字段类型: ${field.type}]` };
+    }
+}
+export function buildFieldElement(requestId, field) {
+    switch (field.type) {
+        case 'select': {
+            const options = field.options.map(opt => ({
+                text: { tag: 'plain_text', content: opt.label },
+                value: opt.value,
+            }));
+            const selectedOpt = field.options.find(opt => opt.selected);
+            return {
+                tag: 'action',
+                actions: [{
+                        tag: 'select_static',
+                        placeholder: { tag: 'plain_text', content: field.placeholder || `选择${field.label}` },
+                        options,
+                        ...(selectedOpt ? { initial_option: selectedOpt.value } : {}),
+                        value: {
+                            _request_id: requestId,
+                            _field_key: field.key,
+                        },
+                    }],
+            };
+        }
+        case 'text': {
+            // Feishu cards don't have a native text input component.
+            // Use a note element as placeholder label; actual input via form submit.
+            return {
+                tag: 'note',
+                elements: [
+                    { tag: 'plain_text', content: `${field.label}: ${field.placeholder || '(请在提交时输入)'}` },
+                ],
+            };
+        }
+        case 'toggle': {
+            const checked = field.defaultValue ?? false;
+            return {
+                tag: 'action',
+                actions: [{
+                        tag: 'select_static',
+                        placeholder: { tag: 'plain_text', content: field.label },
+                        options: [
+                            { text: { tag: 'plain_text', content: '开启' }, value: 'true' },
+                            { text: { tag: 'plain_text', content: '关闭' }, value: 'false' },
+                        ],
+                        initial_option: checked ? 'true' : 'false',
+                        value: {
+                            _request_id: requestId,
+                            _field_key: field.key,
+                        },
+                    }],
+            };
+        }
+        case 'multi-select': {
+            // Feishu cards: use multi_select_static (checker)
+            const options = field.options.map(opt => ({
+                text: { tag: 'plain_text', content: opt.label },
+                value: opt.value,
+            }));
+            const selectedValues = field.options.filter(opt => opt.selected).map(opt => opt.value);
+            return {
+                tag: 'action',
+                actions: [{
+                        tag: 'multi_select_static',
+                        placeholder: { tag: 'plain_text', content: `选择${field.label}` },
+                        options,
+                        ...(selectedValues.length > 0 ? { initial_options: selectedValues } : {}),
+                        value: {
+                            _request_id: requestId,
+                            _field_key: field.key,
+                        },
+                    }],
+            };
+        }
+        default:
+            return { tag: 'markdown', content: `[不支持的字段类型: ${field.type}]` };
+    }
+}
+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```';
+    });
+}
+/**
+ * 按段落边界拆分超长消息
+ * 优先在 \n\n 处分割，其次 \n，最后强制截断
+ */
+function splitLongMessage(content, maxLength) {
+    const parts = [];
+    let remaining = content;
+    while (remaining.length > maxLength) {
+        let splitAt = remaining.lastIndexOf('\n\n', maxLength);
+        if (splitAt <= 0)
+            splitAt = remaining.lastIndexOf('\n', maxLength);
+        if (splitAt <= 0)
+            splitAt = maxLength;
+        parts.push(remaining.slice(0, splitAt).trimEnd());
+        remaining = remaining.slice(splitAt).trimStart();
+    }
+    if (remaining)
+        parts.push(remaining);
+    return parts;
+}
+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() }]]
+        }
+    };
+}
+/**
+ * 将 Markdown 内容转为飞书消息卡片格式（interactive msg_type）
+ * 飞书卡片的 markdown 组件支持完整 Markdown 渲染（代码块、表格、列表等）
+ * 当前消息类型决策统一走 post + md tag，此函数为 interactive 卡片场景预留。
+ */
+export function markdownToFeishuCard(markdown, defaultTitle) {
+    const match = markdown.match(/^# (.+)$/m);
+    const title = match?.[1] ?? defaultTitle;
+    let body = match ? markdown.replace(/^# .+\n?/, '') : markdown;
+    body = convertTablesToText(body).trim();
+    const card = {
+        config: { wide_screen_mode: true },
+        elements: [
+            { tag: 'markdown', content: body }
+        ]
+    };
+    if (title) {
+        card.header = {
+            title: { tag: 'plain_text', content: title }
+        };
+    }
+    return card;
+}
+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));
+}
+import { normalizeChannelInstances } from '../config.js';
+export class FeishuChannelPlugin {
+    name = 'feishu';
+    isEnabled(config) {
+        const raw = config.channels?.feishu;
+        if (!raw)
+            return false;
+        if (Array.isArray(raw)) {
+            return raw.some(inst => inst.enabled !== false && inst.appId && inst.appSecret);
+        }
+        if (raw.enabled === false)
+            return false;
+        return !!(raw.appId && raw.appSecret);
+    }
+    async createChannels(config) {
+        const instances = normalizeChannelInstances(config.channels?.feishu, 'feishu');
+        const result = [];
+        for (const inst of instances) {
+            if (inst.enabled === false || !inst.appId || !inst.appSecret)
+                continue;
+            const channel = new FeishuChannel({
+                appId: inst.appId,
+                appSecret: inst.appSecret,
+                enableRichContent: config.enableRichContent,
+            });
+            const adapter = {
+                channelName: inst.name,
+                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(); },
+                sendInteraction: (id, interaction, context) => channel.sendInteraction(id, interaction, context),
+                patchInteractionCard: (messageId, card) => channel.patchInteractionCard(messageId, card),
+                onInteraction: (callback) => channel.onInteraction(callback),
+            };
+            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 = inst.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 = inst.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: inst.flushDelay,
+            };
+            result.push({
+                channelType: 'feishu',
+                adapter,
+                channel,
+                policy,
+                options,
+                connect: () => channel.connect(),
+                disconnect: () => channel.disconnect(),
+                onProjectPathRequest: (channelId) => Promise.resolve(config.projects?.defaultPath || process.cwd()),
+            });
+        }
+        return result;
+    }
+    async createChannel(config) {
+        const instances = await this.createChannels(config);
+        if (instances.length === 0) {
+            throw new Error('Feishu config missing');
+        }
+        return instances[0];
     }
 }