opencode-bridge 2.9.0-beta

package/dist/feishu/client.js

@@ -0,0 +1,952 @@
+import * as lark from '@larksuiteoapi/node-sdk';
+import { feishuConfig } from '../config.js';
+import { EventEmitter } from 'events';
+function formatError(error) {
+    if (error instanceof Error) {
+        const responseData = typeof error === 'object' && error !== null && 'response' in error
+            ? error.response?.data
+            : undefined;
+        return { message: `${error.name}: ${error.message}`, responseData };
+    }
+    const responseData = typeof error === 'object' && error !== null && 'response' in error
+        ? error.response?.data
+        : undefined;
+    let message = '';
+    try {
+        message = JSON.stringify(error);
+    }
+    catch {
+        message = String(error);
+    }
+    return { message, responseData };
+}
+function extractApiCode(responseData) {
+    if (!responseData || typeof responseData !== 'object')
+        return undefined;
+    const value = responseData.code;
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    return undefined;
+}
+function stringifyErrorPayload(payload) {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    try {
+        return JSON.stringify(payload);
+    }
+    catch {
+        return String(payload);
+    }
+}
+function isUniversalCardBuildFailure(responseData) {
+    const apiCode = extractApiCode(responseData);
+    if (apiCode === 230099) {
+        return true;
+    }
+    const text = stringifyErrorPayload(responseData).toLowerCase();
+    return text.includes('230099')
+        || text.includes('200800')
+        || text.includes('create universal card fail');
+}
+function buildFallbackInteractiveCard(sourceCard) {
+    const cardRecord = sourceCard;
+    const rawTitle = cardRecord.header?.title?.content;
+    const title = typeof rawTitle === 'string' && rawTitle.trim()
+        ? rawTitle.trim().slice(0, 60)
+        : 'OpenCode 输出（已精简）';
+    const rawTemplate = cardRecord.header?.template;
+    const template = typeof rawTemplate === 'string' && rawTemplate.trim()
+        ? rawTemplate.trim()
+        : 'blue';
+    return {
+        schema: '2.0',
+        config: {
+            wide_screen_mode: true,
+        },
+        header: {
+            title: {
+                tag: 'plain_text',
+                content: title,
+            },
+            template,
+        },
+        body: {
+            elements: [
+                {
+                    tag: 'markdown',
+                    content: '⚠️ 卡片内容过长或结构超限，已自动精简显示。\n请在 OpenCode Web 查看完整输出。',
+                },
+            ],
+        },
+    };
+}
+function getString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function getNumber(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    return undefined;
+}
+function collectAttachmentsFromContent(content) {
+    if (!content || typeof content !== 'object')
+        return [];
+    const attachments = [];
+    const visited = new Set();
+    const stack = [content];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current || typeof current !== 'object')
+            continue;
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        if (Array.isArray(current)) {
+            for (const item of current)
+                stack.push(item);
+            continue;
+        }
+        const record = current;
+        const imageKey = getString(record.image_key) || getString(record.imageKey);
+        if (imageKey) {
+            attachments.push({ type: 'image', fileKey: imageKey });
+        }
+        const fileKey = getString(record.file_key) || getString(record.fileKey);
+        if (fileKey) {
+            attachments.push({
+                type: 'file',
+                fileKey,
+                fileName: getString(record.file_name) || getString(record.fileName),
+                fileType: getString(record.file_type) || getString(record.fileType),
+                fileSize: getNumber(record.file_size) || getNumber(record.fileSize),
+            });
+        }
+        for (const value of Object.values(record)) {
+            stack.push(value);
+        }
+    }
+    return attachments;
+}
+function extractTextFromPost(content) {
+    if (!content || typeof content !== 'object')
+        return '';
+    const record = content;
+    const parts = [];
+    const root = record.content;
+    if (!root)
+        return '';
+    const stack = [root];
+    const visited = new Set();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current || typeof current !== 'object')
+            continue;
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        if (Array.isArray(current)) {
+            for (const item of current)
+                stack.push(item);
+            continue;
+        }
+        const node = current;
+        const tag = getString(node.tag);
+        if ((tag === 'text' || tag === 'a') && typeof node.text === 'string') {
+            parts.push(node.text);
+        }
+        for (const value of Object.values(node)) {
+            stack.push(value);
+        }
+    }
+    return parts.join('');
+}
+class FeishuClient extends EventEmitter {
+    client;
+    wsClient = null;
+    eventDispatcher;
+    cardActionHandler;
+    cardUpdateQueue = new Map();
+    constructor() {
+        super();
+        this.client = new lark.Client({
+            appId: feishuConfig.appId,
+            appSecret: feishuConfig.appSecret,
+            disableTokenCache: false,
+        });
+        // 创建事件分发器
+        this.eventDispatcher = new lark.EventDispatcher({
+            encryptKey: feishuConfig.encryptKey,
+            verificationToken: feishuConfig.verificationToken,
+        });
+    }
+    // 启动长连接
+    async start() {
+        console.log('[飞书] 正在启动长连接...');
+        // 注册消息接收事件
+        this.eventDispatcher.register({
+            'im.message.receive_v1': (data) => {
+                this.handleMessage(data);
+                return { msg: 'ok' };
+            },
+            // 注册消息已读事件（消除警告）
+            'im.message.message_read_v1': (data) => {
+                return { msg: 'ok' };
+            },
+        });
+        // 注册卡片回调事件
+        this.eventDispatcher.register({
+            'card.action.trigger': async (data) => {
+                return await this.handleCardAction(data);
+            },
+        });
+        // 监听消息撤回事件
+        // 本地不再重复注册撤回事件，避免与 onMessageRecalled 冲突
+        this.wsClient = new lark.WSClient({
+            appId: feishuConfig.appId,
+            appSecret: feishuConfig.appSecret,
+        });
+        // 启动连接
+        await this.wsClient.start({ eventDispatcher: this.eventDispatcher });
+        console.log('[飞书] 长连接已建立');
+    }
+    // 监听群成员退群事件
+    onMemberLeft(callback) {
+        // @ts-ignore: using loose types for dynamic registration
+        this.eventDispatcher.register({
+            'im.chat.member.user.deleted_v1': (data) => {
+                const chatId = data.chat_id;
+                const users = data.users || [];
+                for (const user of users) {
+                    const openId = user.user_id?.open_id;
+                    if (openId)
+                        callback(chatId, openId);
+                }
+                return { msg: 'ok' };
+            }
+        });
+    }
+    // 监听群解散事件
+    onChatDisbanded(callback) {
+        // @ts-ignore
+        this.eventDispatcher.register({
+            'im.chat.disbanded_v1': (data) => {
+                if (data.chat_id)
+                    callback(data.chat_id);
+                return { msg: 'ok' };
+            }
+        });
+    }
+    // 监听消息撤回事件
+    onMessageRecalled(callback) {
+        // @ts-ignore
+        this.eventDispatcher.register({
+            'im.message.recalled_v1': (data) => {
+                callback(data);
+                return { msg: 'ok' };
+            }
+        });
+    }
+    // 处理接收到的消息
+    handleMessage(data) {
+        try {
+            const message = data.message;
+            const sender = data.sender;
+            // 忽略机器人自己发的消息
+            if (sender.sender_type === 'bot') {
+                return;
+            }
+            const msgType = message.message_type;
+            let content = '';
+            let parsedContent = null;
+            try {
+                parsedContent = JSON.parse(message.content);
+                if (parsedContent && typeof parsedContent.text === 'string') {
+                    content = parsedContent.text;
+                }
+            }
+            catch {
+                content = message.content;
+            }
+            if (!content && parsedContent && msgType === 'post') {
+                const postText = extractTextFromPost(parsedContent);
+                if (postText)
+                    content = postText;
+            }
+            const attachments = [];
+            const attachmentMap = new Map();
+            const addAttachment = (item) => {
+                const key = `${item.type}:${item.fileKey}`;
+                const existing = attachmentMap.get(key);
+                if (!existing) {
+                    attachmentMap.set(key, item);
+                    return;
+                }
+                attachmentMap.set(key, {
+                    type: existing.type,
+                    fileKey: existing.fileKey,
+                    fileName: existing.fileName || item.fileName,
+                    fileType: existing.fileType || item.fileType,
+                    fileSize: existing.fileSize ?? item.fileSize,
+                });
+            };
+            if (parsedContent && msgType === 'image') {
+                const imageKey = getString(parsedContent.image_key) || getString(parsedContent.imageKey);
+                if (imageKey) {
+                    addAttachment({ type: 'image', fileKey: imageKey });
+                }
+            }
+            if (parsedContent && msgType === 'file') {
+                const fileKey = getString(parsedContent.file_key) || getString(parsedContent.fileKey);
+                if (fileKey) {
+                    addAttachment({
+                        type: 'file',
+                        fileKey,
+                        fileName: getString(parsedContent.file_name) || getString(parsedContent.fileName),
+                        fileType: getString(parsedContent.file_type) || getString(parsedContent.fileType),
+                        fileSize: getNumber(parsedContent.file_size) || getNumber(parsedContent.fileSize),
+                    });
+                }
+            }
+            if (parsedContent) {
+                const collected = collectAttachmentsFromContent(parsedContent);
+                for (const item of collected) {
+                    addAttachment(item);
+                }
+            }
+            attachments.push(...attachmentMap.values());
+            // 移除@机器人的部分
+            if (message.mentions) {
+                for (const mention of message.mentions) {
+                    content = content.replace(mention.key, '').trim();
+                }
+            }
+            const messageEvent = {
+                messageId: message.message_id,
+                chatId: message.chat_id,
+                threadId: message.thread_id,
+                chatType: message.chat_type,
+                senderId: sender.sender_id?.open_id || '',
+                senderType: sender.sender_type,
+                content: content.trim(),
+                msgType,
+                attachments: attachments.length > 0 ? attachments : undefined,
+                mentions: message.mentions?.map(m => ({
+                    key: m.key,
+                    id: { open_id: m.id.open_id || '' },
+                    name: m.name,
+                })),
+                rawEvent: data,
+            };
+            this.emit('message', messageEvent);
+        }
+        catch (error) {
+            console.error('[飞书] 解析消息失败:', error);
+        }
+    }
+    // 设置卡片动作处理器（支持直接返回新卡片）
+    setCardActionHandler(handler) {
+        this.cardActionHandler = handler;
+    }
+    // 处理卡片按钮点击（通过 CardActionHandler 处理，需要单独设置）
+    async handleCardAction(data) {
+        try {
+            const event = data;
+            const messageId = event.open_message_id ||
+                event.message_id ||
+                event.context?.open_message_id ||
+                event.context?.message_id;
+            const chatId = event.open_chat_id ||
+                event.chat_id ||
+                event.context?.open_chat_id ||
+                event.context?.chat_id;
+            const threadId = event.open_thread_id ||
+                event.thread_id ||
+                event.context?.open_thread_id ||
+                event.context?.thread_id;
+            const cardEvent = {
+                openId: event.operator.open_id,
+                action: event.action,
+                token: event.token,
+                messageId,
+                chatId,
+                threadId,
+                rawEvent: data,
+            };
+            if (this.cardActionHandler) {
+                const response = await this.cardActionHandler(cardEvent);
+                if (response !== undefined) {
+                    return response;
+                }
+                return { msg: 'ok' };
+            }
+            this.emit('cardAction', cardEvent);
+            return { msg: 'ok' };
+        }
+        catch (error) {
+            console.error('[飞书] 解析卡片事件失败:', error);
+            return { msg: 'ok' };
+        }
+    }
+    // 下载消息中的资源文件
+    async downloadMessageResource(messageId, fileKey, type) {
+        try {
+            const response = await this.client.im.messageResource.get({
+                path: { message_id: messageId, file_key: fileKey },
+                params: { type },
+            });
+            return {
+                writeFile: response.writeFile,
+                headers: response.headers,
+            };
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 下载消息资源失败:', formatted.message, formatted.responseData ?? '');
+            return null;
+        }
+    }
+    // 发送文本消息
+    async sendText(chatId, text) {
+        try {
+            const response = await this.client.im.message.create({
+                params: { receive_id_type: 'chat_id' },
+                data: {
+                    receive_id: chatId,
+                    msg_type: 'text',
+                    content: JSON.stringify({ text }),
+                },
+            });
+            const msgId = response.data?.message_id || null;
+            if (msgId) {
+                console.log(`[飞书] 发送文字成功: msgId=${msgId.slice(0, 16)}...`);
+            }
+            else {
+                console.log('[飞书] 发送文字返回空消息ID');
+            }
+            return msgId;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            const errCode = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+            const apiCode = extractApiCode(formatted.responseData);
+            if (apiCode === 230002) {
+                console.warn(`[飞书] 群不可用，发送文字失败: chatId=${chatId}`);
+                this.emit('chatUnavailable', chatId);
+                return null;
+            }
+            console.error(`[飞书] 发送文字失败: code=${errCode}, ${formatted.message}`);
+            return null;
+        }
+    }
+    // 回复消息
+    async reply(messageId, text) {
+        try {
+            const response = await this.client.im.message.reply({
+                path: { message_id: messageId },
+                data: {
+                    msg_type: 'text',
+                    content: JSON.stringify({ text }),
+                },
+            });
+            const msgId = response.data?.message_id || null;
+            if (msgId) {
+                console.log(`[飞书] 回复成功: msgId=${msgId.slice(0, 16)}...`);
+            }
+            else {
+                console.log('[飞书] 回复返回空消息ID');
+            }
+            return msgId;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            const errCode = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+            console.error(`[飞书] 回复失败: code=${errCode}, ${formatted.message}`);
+            return null;
+        }
+    }
+    // 回复卡片
+    async replyCard(messageId, card) {
+        try {
+            const response = await this.client.im.message.reply({
+                path: { message_id: messageId },
+                data: {
+                    msg_type: 'interactive',
+                    content: JSON.stringify(card),
+                },
+            });
+            const msgId = response.data?.message_id || null;
+            if (msgId) {
+                console.log(`[飞书] 回复卡片成功: msgId=${msgId.slice(0, 16)}...`);
+            }
+            else {
+                console.log('[飞书] 回复卡片返回空消息ID');
+            }
+            return msgId;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            const errCode = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+            console.error(`[飞书] 回复卡片失败: code=${errCode}, ${formatted.message}`);
+            return null;
+        }
+    }
+    // 更新卡片
+    async updateCard(messageId, card) {
+        const prev = this.cardUpdateQueue.get(messageId) || Promise.resolve(true);
+        const next = prev
+            .catch(() => true)
+            .then(async () => {
+            return await this.doUpdateCard(messageId, card);
+        })
+            .finally(() => {
+            if (this.cardUpdateQueue.get(messageId) === next) {
+                this.cardUpdateQueue.delete(messageId);
+            }
+        });
+        this.cardUpdateQueue.set(messageId, next);
+        return await next;
+    }
+    async doUpdateCard(messageId, card) {
+        try {
+            const data = {
+                msg_type: 'interactive',
+                content: JSON.stringify(card),
+            };
+            await this.client.im.message.patch({
+                path: { message_id: messageId },
+                data,
+            });
+            console.log(`[飞书] 更新卡片成功: msgId=${messageId.slice(0, 16)}...`);
+            return true;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            const errCode = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+            const errMsg = typeof error === 'object' && error !== null && 'msg' in error ? error.msg : undefined;
+            console.error(`[飞书] 更新卡片失败: code=${errCode}, msg=${errMsg}, msgId=${messageId}`);
+            console.error(`[飞书] 更新卡片错误详情: ${formatted.message}`);
+            if (formatted.responseData) {
+                try {
+                    console.error(`[飞书] 响应数据: ${JSON.stringify(formatted.responseData).slice(0, 500)}`);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (isUniversalCardBuildFailure(formatted.responseData)) {
+                console.warn(`[飞书] 更新卡片触发 230099/200800，尝试发送精简卡片: msgId=${messageId}`);
+                try {
+                    const fallbackData = {
+                        msg_type: 'interactive',
+                        content: JSON.stringify(buildFallbackInteractiveCard(card)),
+                    };
+                    await this.client.im.message.patch({
+                        path: { message_id: messageId },
+                        data: fallbackData,
+                    });
+                    console.log(`[飞书] 精简卡片更新成功: msgId=${messageId.slice(0, 16)}...`);
+                    return true;
+                }
+                catch (fallbackError) {
+                    const fallbackFormatted = formatError(fallbackError);
+                    console.error(`[飞书] 精简卡片更新失败: ${fallbackFormatted.message}`);
+                }
+            }
+            return false;
+        }
+    }
+    // 更新消息（用于定时刷新输出）
+    async updateMessage(messageId, text) {
+        try {
+            await this.client.im.message.patch({
+                path: { message_id: messageId },
+                data: {
+                    content: JSON.stringify({ text }),
+                },
+            });
+            return true;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 更新消息失败:', formatted.message, formatted.responseData ?? '');
+            return false;
+        }
+    }
+    // 发送消息卡片
+    async sendCard(chatId, card) {
+        try {
+            const response = await this.client.im.message.create({
+                params: { receive_id_type: 'chat_id' },
+                data: {
+                    receive_id: chatId,
+                    msg_type: 'interactive',
+                    content: JSON.stringify(card),
+                },
+            });
+            const msgId = response.data?.message_id || null;
+            if (msgId) {
+                console.log(`[飞书] 发送卡片成功: msgId=${msgId.slice(0, 16)}...`);
+            }
+            else {
+                console.log('[飞书] 发送卡片返回空消息ID');
+            }
+            return msgId;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            const errCode = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+            const apiCode = extractApiCode(formatted.responseData);
+            if (apiCode === 230002) {
+                console.warn(`[飞书] 群不可用，发送卡片失败: chatId=${chatId}`);
+                this.emit('chatUnavailable', chatId);
+                return null;
+            }
+            if (isUniversalCardBuildFailure(formatted.responseData)) {
+                console.warn(`[飞书] 发送卡片触发 230099/200800，尝试发送精简卡片: chatId=${chatId}`);
+                try {
+                    const fallbackResponse = await this.client.im.message.create({
+                        params: { receive_id_type: 'chat_id' },
+                        data: {
+                            receive_id: chatId,
+                            msg_type: 'interactive',
+                            content: JSON.stringify(buildFallbackInteractiveCard(card)),
+                        },
+                    });
+                    const fallbackMsgId = fallbackResponse.data?.message_id || null;
+                    if (fallbackMsgId) {
+                        console.log(`[飞书] 精简卡片发送成功: msgId=${fallbackMsgId.slice(0, 16)}...`);
+                    }
+                    return fallbackMsgId;
+                }
+                catch (fallbackError) {
+                    const fallbackFormatted = formatError(fallbackError);
+                    console.error(`[飞书] 精简卡片发送失败: ${fallbackFormatted.message}`);
+                }
+            }
+            console.error(`[飞书] 发送卡片失败: code=${errCode}, ${formatted.message}`);
+            return null;
+        }
+    }
+    // 撤回消息
+    async deleteMessage(messageId) {
+        try {
+            await this.client.im.message.delete({
+                path: { message_id: messageId },
+            });
+            return true;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 撤回消息失败:', formatted.message, formatted.responseData ?? '');
+            return false;
+        }
+    }
+    // 指定群管理员
+    async addChatManager(chatId, managerId, idType) {
+        try {
+            const response = await this.client.im.chatManagers.addManagers({
+                path: { chat_id: chatId },
+                params: { member_id_type: idType },
+                data: { manager_ids: [managerId] },
+            });
+            return response.code === 0;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 设置群管理员失败:', formatted.message, formatted.responseData ?? '');
+            return false;
+        }
+    }
+    // 创建群聊
+    async createChat(name, userIds, description) {
+        try {
+            const response = await this.client.im.chat.create({
+                params: {
+                    user_id_type: 'open_id',
+                    set_bot_manager: true, // 设置机器人为管理员
+                },
+                data: {
+                    name,
+                    description,
+                    user_id_list: userIds,
+                },
+            });
+            const chatId = response.data?.chat_id || null;
+            // 飞书 API 返回的 invalid_id_list 包含无法添加的用户 ID
+            const invalidUserIds = response.data?.invalid_id_list || [];
+            if (response.code === 0 && chatId) {
+                console.log(`[飞书] 创建群聊成功: chatId=${chatId}, name=${name}, userIds=${userIds.join(',')}`);
+                if (invalidUserIds.length > 0) {
+                    console.warn(`[飞书] 创建群聊时部分用户添加失败: invalidIds=${invalidUserIds.join(',')}`);
+                }
+            }
+            else {
+                console.error(`[飞书] 创建群聊失败: code=${response.code}, msg=${response.msg}, name=${name}, userIds=${userIds.join(',')}`);
+                if (response.data) {
+                    console.error(`[飞书] 创建群聊错误详情: ${JSON.stringify(response.data)}`);
+                }
+            }
+            return { chatId, invalidUserIds };
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 创建群聊失败:', formatted.message, formatted.responseData ?? '');
+            return { chatId: null, invalidUserIds: [] };
+        }
+    }
+    // 解散群聊
+    async disbandChat(chatId) {
+        try {
+            await this.client.im.chat.delete({
+                path: { chat_id: chatId },
+            });
+            console.log(`[飞书] 解散群聊成功: chatId=${chatId}`);
+            return true;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 解散群聊失败:', formatted.message, formatted.responseData ?? '');
+            return false;
+        }
+    }
+    // 获取群成员列表 (返回 open_id 列表)
+    async getChatMembers(chatId) {
+        try {
+            // 获取所有成员，支持分页
+            const memberIds = [];
+            let pageToken;
+            do {
+                const response = await this.client.im.chatMembers.get({
+                    path: { chat_id: chatId },
+                    params: {
+                        member_id_type: 'open_id',
+                        page_size: 100,
+                        page_token: pageToken,
+                    },
+                });
+                if (response.data?.items) {
+                    for (const item of response.data.items) {
+                        if (item.member_id) {
+                            memberIds.push(item.member_id);
+                        }
+                    }
+                }
+                pageToken = response.data?.page_token;
+            } while (pageToken);
+            return memberIds;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 获取群成员失败:', formatted.message, formatted.responseData ?? '');
+            return [];
+        }
+    }
+    // 获取机器人所在的群列表
+    async getUserChats() {
+        try {
+            const chatIds = [];
+            let pageToken;
+            do {
+                const response = await this.client.im.chat.list({
+                    params: {
+                        page_size: 100,
+                        page_token: pageToken,
+                    },
+                });
+                if (response.data?.items) {
+                    for (const item of response.data.items) {
+                        if (item.chat_id) {
+                            chatIds.push(item.chat_id);
+                        }
+                    }
+                }
+                pageToken = response.data?.page_token;
+            } while (pageToken);
+            return chatIds;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 获取群列表失败:', formatted.message, formatted.responseData ?? '');
+            return [];
+        }
+    }
+    // 获取群信息
+    async getChat(chatId) {
+        try {
+            const response = await this.client.im.chat.get({
+                path: { chat_id: chatId },
+                params: { user_id_type: 'open_id' },
+            });
+            if (response.code === 0 && response.data) {
+                return {
+                    ownerId: response.data.owner_id || '',
+                    name: response.data.name || '',
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 获取群信息失败:', formatted.message, formatted.responseData ?? '');
+            return null;
+        }
+    }
+    // 邀请用户进群
+    async addChatMembers(chatId, userIds) {
+        try {
+            const response = await this.client.im.chatMembers.create({
+                path: { chat_id: chatId },
+                params: { member_id_type: 'open_id' },
+                data: { id_list: userIds },
+            });
+            if (response.code === 0) {
+                console.log(`[飞书] 邀请用户 ${userIds.join(', ')} 进群 ${chatId} 成功`);
+            }
+            else {
+                console.error(`[飞书] 邀请用户进群 ${chatId} 失败: code=${response.code}, msg=${response.msg}, userIds=${userIds.join(', ')}`);
+                if (response.data) {
+                    console.error(`[飞书] 邀请用户进群错误详情: ${JSON.stringify(response.data)}`);
+                }
+            }
+            return response.code === 0;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error('[飞书] 邀请进群失败:', formatted.message, formatted.responseData ?? '');
+            return false;
+        }
+    }
+    // 上传图片，返回 image_key
+    async uploadImage(imageData) {
+        try {
+            const response = await this.client.im.image.create({
+                data: {
+                    image_type: 'message',
+                    image: imageData,
+                },
+            });
+            const imageKey = response?.image_key || null;
+            if (imageKey) {
+                console.log(`[飞书] 上传图片成功: imageKey=${imageKey.slice(0, 16)}...`);
+            }
+            else {
+                console.log('[飞书] 上传图片返回空 image_key');
+            }
+            return imageKey;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error(`[飞书] 上传图片失败: ${formatted.message}`);
+            return null;
+        }
+    }
+    // 上传文件，返回 file_key
+    async uploadFile(fileData, fileName, fileType) {
+        try {
+            const response = await this.client.im.file.create({
+                data: {
+                    file_type: fileType,
+                    file_name: fileName,
+                    file: fileData,
+                },
+            });
+            const fileKey = response?.file_key || null;
+            if (fileKey) {
+                console.log(`[飞书] 上传文件成功: fileKey=${fileKey.slice(0, 16)}..., name=${fileName}`);
+            }
+            else {
+                console.log('[飞书] 上传文件返回空 file_key');
+            }
+            return fileKey;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            console.error(`[飞书] 上传文件失败: ${formatted.message}`);
+            return null;
+        }
+    }
+    // 发送图片消息
+    async sendImageMessage(chatId, imageKey) {
+        try {
+            const response = await this.client.im.message.create({
+                params: { receive_id_type: 'chat_id' },
+                data: {
+                    receive_id: chatId,
+                    msg_type: 'image',
+                    content: JSON.stringify({ image_key: imageKey }),
+                },
+            });
+            const msgId = response.data?.message_id || null;
+            if (msgId) {
+                console.log(`[飞书] 发送图片消息成功: msgId=${msgId.slice(0, 16)}...`);
+            }
+            else {
+                console.log('[飞书] 发送图片消息返回空消息ID');
+            }
+            return msgId;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            const apiCode = extractApiCode(formatted.responseData);
+            if (apiCode === 230002) {
+                console.warn(`[飞书] 群不可用，发送图片消息失败: chatId=${chatId}`);
+                this.emit('chatUnavailable', chatId);
+                return null;
+            }
+            console.error(`[飞书] 发送图片消息失败: ${formatted.message}`);
+            return null;
+        }
+    }
+    // 发送文件消息
+    async sendFileMessage(chatId, fileKey) {
+        try {
+            const response = 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 }),
+                },
+            });
+            const msgId = response.data?.message_id || null;
+            if (msgId) {
+                console.log(`[飞书] 发送文件消息成功: msgId=${msgId.slice(0, 16)}...`);
+            }
+            else {
+                console.log('[飞书] 发送文件消息返回空消息ID');
+            }
+            return msgId;
+        }
+        catch (error) {
+            const formatted = formatError(error);
+            const apiCode = extractApiCode(formatted.responseData);
+            if (apiCode === 230002) {
+                console.warn(`[飞书] 群不可用，发送文件消息失败: chatId=${chatId}`);
+                this.emit('chatUnavailable', chatId);
+                return null;
+            }
+            console.error(`[飞书] 发送文件消息失败: ${formatted.message}`);
+            return null;
+        }
+    }
+    // 停止长连接
+    stop() {
+        if (this.wsClient) {
+            this.wsClient.close();
+            this.wsClient = null;
+        }
+        console.log('[飞书] 已断开连接');
+    }
+}
+// 单例导出
+export const feishuClient = new FeishuClient();
+//# sourceMappingURL=client.js.map