team-anya-cli 0.1.0

package/apps/server/dist/gateway/feishu-sender.js

@@ -0,0 +1,346 @@
+import * as Lark from '@larksuiteoapi/node-sdk';
+import { insertMessageLog } from '@team-anya/db';
+import { messageEvents } from './message-events.js';
+// ── markdownToFeishuCard ──
+/**
+ * 将 markdown 内容转换为飞书交互式卡片格式
+ */
+export function markdownToFeishuCard(content, title) {
+    return {
+        schema: '2.0',
+        config: { wide_screen_mode: true },
+        header: {
+            title: { content: title, tag: 'plain_text' },
+        },
+        body: {
+            elements: [
+                { tag: 'markdown', content },
+            ],
+        },
+    };
+}
+// ── FeishuSender（基于官方 SDK）──
+/**
+ * 飞书消息发送器
+ *
+ * 使用 @larksuiteoapi/node-sdk 的 Client，SDK 内部自动处理 token 获取和缓存。
+ *
+ * 出站场景：
+ * - sendText / sendReply: 日常对话（纯文本，像正常同事说话）
+ * - sendBlockedAlert: 任务阻塞提醒
+ * - sendDailyReport: 日报推送（卡片，内容较长）
+ * - sendTaskDone: 任务完成通知（纯文本）
+ */
+export class FeishuSender {
+    client;
+    db;
+    constructor(config) {
+        this.client = new Lark.Client({
+            appId: config.appId,
+            appSecret: config.appSecret,
+            appType: Lark.AppType.SelfBuild,
+            domain: Lark.Domain.Feishu,
+        });
+        this.db = config.db ?? null;
+    }
+    /**
+     * 写入 outbound message_log 并 emit 事件
+     */
+    logOutbound(params) {
+        if (!this.db)
+            return;
+        try {
+            const chatId = params.receiveIdType === 'chat_id' ? params.receiver : null;
+            const chatType = params.receiveIdType === 'chat_id' ? 'group'
+                : params.receiveIdType === 'open_id' ? 'p2p' : null;
+            const entry = insertMessageLog(this.db, {
+                direction: 'outbound',
+                source_type: 'feishu',
+                sender: 'anya',
+                receiver: params.receiver,
+                chat_id: chatId,
+                chat_type: chatType,
+                content: params.content,
+                message_type: params.message_type,
+                related_task_id: params.related_task_id ?? null,
+            });
+            messageEvents.emit('message', {
+                id: entry.id,
+                direction: 'outbound',
+                source_type: entry.source_type,
+                sender: entry.sender,
+                receiver: entry.receiver,
+                content: entry.content,
+                message_type: entry.message_type,
+                related_task_id: entry.related_task_id,
+                chat_id: entry.chat_id ?? null,
+                chat_type: entry.chat_type,
+                created_at: entry.created_at,
+            });
+        }
+        catch {
+            // 日志写入失败不应阻断消息发送
+        }
+    }
+    // ── 消息发送 ──
+    async sendCard(params) {
+        const content = JSON.stringify(params.card);
+        // 回复消息
+        if (params.replyToMessageId) {
+            const response = await this.client.im.message.reply({
+                path: { message_id: params.replyToMessageId },
+                data: {
+                    content,
+                    msg_type: 'interactive',
+                },
+            });
+            if (response.code !== 0) {
+                throw new Error(`飞书回复失败: ${response.msg || `code ${response.code}`}`);
+            }
+            return response.data?.message_id ?? 'unknown';
+        }
+        // 发送新消息
+        const response = await this.client.im.message.create({
+            params: { receive_id_type: params.receiveIdType },
+            data: {
+                receive_id: params.receiveId,
+                content,
+                msg_type: 'interactive',
+            },
+        });
+        if (response.code !== 0) {
+            throw new Error(`飞书发送失败: ${response.msg || `code ${response.code}`}`);
+        }
+        return response.data?.message_id ?? 'unknown';
+    }
+    // ── 发送纯文本 ──
+    async sendText(params) {
+        const response = await this.client.im.message.create({
+            params: { receive_id_type: params.receiveIdType },
+            data: {
+                receive_id: params.receiveId,
+                content: JSON.stringify({ text: params.text }),
+                msg_type: 'text',
+            },
+        });
+        if (response.code !== 0) {
+            throw new Error(`飞书发送失败: ${response.msg || `code ${response.code}`}`);
+        }
+        return response.data?.message_id ?? 'unknown';
+    }
+    // ── 回复消息（纯文本，像正常同事说话）──
+    async sendReply(params) {
+        const response = await this.client.im.message.reply({
+            path: { message_id: params.replyToMessageId },
+            data: {
+                content: JSON.stringify({ text: params.text }),
+                msg_type: 'text',
+            },
+        });
+        if (response.code !== 0) {
+            throw new Error(`飞书回复失败: ${response.msg || `code ${response.code}`}`);
+        }
+        return response.data?.message_id ?? 'unknown';
+    }
+    // ── 图片上传与发送 ──
+    /**
+     * 上传图片到飞书（获取 image_key）
+     *
+     * 调用 POST /im/v1/images 接口。
+     * 支持格式: png, jpg, jpeg, gif, bmp, webp, ico, tiff, tif
+     */
+    async uploadImage(filePath) {
+        const fs = await import('node:fs');
+        const fileStream = fs.createReadStream(filePath);
+        const response = await this.client.im.image.create({
+            data: {
+                image_type: 'message',
+                image: fileStream,
+            },
+        });
+        const result = response;
+        if (result.code != null && result.code !== 0) {
+            throw new Error(`飞书图片上传失败: ${result.msg || `code ${result.code}`}`);
+        }
+        const imageKey = result.data?.image_key ?? result.image_key;
+        if (!imageKey) {
+            throw new Error('飞书图片上传成功但未返回 image_key');
+        }
+        return imageKey;
+    }
+    /**
+     * 发送图片消息
+     */
+    async sendImage(params) {
+        const content = JSON.stringify({ image_key: params.imageKey });
+        if (params.replyToMessageId) {
+            const response = await this.client.im.message.reply({
+                path: { message_id: params.replyToMessageId },
+                data: {
+                    content,
+                    msg_type: 'image',
+                },
+            });
+            if (response.code !== 0) {
+                throw new Error(`飞书图片回复失败: ${response.msg || `code ${response.code}`}`);
+            }
+            return response.data?.message_id ?? 'unknown';
+        }
+        const response = await this.client.im.message.create({
+            params: { receive_id_type: params.receiveIdType },
+            data: {
+                receive_id: params.receiveId,
+                content,
+                msg_type: 'image',
+            },
+        });
+        if (response.code !== 0) {
+            throw new Error(`飞书图片发送失败: ${response.msg || `code ${response.code}`}`);
+        }
+        return response.data?.message_id ?? 'unknown';
+    }
+    // ── 文件上传与发送 ──
+    /**
+     * 上传文件到飞书（获取 file_key）
+     *
+     * 调用 POST /im/v1/files 接口。
+     */
+    async uploadFile(params) {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const fileStream = fs.createReadStream(params.filePath);
+        const finalName = params.fileName || path.basename(params.filePath);
+        const fileType = params.fileType || 'stream';
+        const response = await this.client.im.file.create({
+            data: {
+                file_type: fileType,
+                file_name: finalName,
+                file: fileStream,
+                ...(params.duration != null ? { duration: params.duration } : {}),
+            },
+        });
+        // im.file.create 返回 { file_key?: string } 或含错误信息
+        const result = response;
+        if (result.code != null && result.code !== 0) {
+            throw new Error(`飞书文件上传失败: ${result.msg || `code ${result.code}`}`);
+        }
+        const fileKey = result.data?.file_key ?? result.file_key;
+        if (!fileKey) {
+            throw new Error('飞书文件上传成功但未返回 file_key');
+        }
+        return fileKey;
+    }
+    /**
+     * 发送文件消息
+     *
+     * @param msgType - 消息类型：'file'（默认）或 'audio'（opus 语音）
+     */
+    async sendFile(params) {
+        const msgType = params.msgType ?? 'file';
+        const content = JSON.stringify({ file_key: params.fileKey });
+        if (params.replyToMessageId) {
+            const response = await this.client.im.message.reply({
+                path: { message_id: params.replyToMessageId },
+                data: {
+                    content,
+                    msg_type: msgType,
+                },
+            });
+            if (response.code !== 0) {
+                throw new Error(`飞书${msgType === 'audio' ? '语音' : '文件'}回复失败: ${response.msg || `code ${response.code}`}`);
+            }
+            return response.data?.message_id ?? 'unknown';
+        }
+        const response = await this.client.im.message.create({
+            params: { receive_id_type: params.receiveIdType },
+            data: {
+                receive_id: params.receiveId,
+                content,
+                msg_type: msgType,
+            },
+        });
+        if (response.code !== 0) {
+            throw new Error(`飞书${msgType === 'audio' ? '语音' : '文件'}发送失败: ${response.msg || `code ${response.code}`}`);
+        }
+        return response.data?.message_id ?? 'unknown';
+    }
+    // ── 表情回复（Reaction）──
+    /**
+     * 给消息添加表情回复
+     *
+     * 用于收到用户消息后立即反馈"已收到"，无需等待 Agent 处理完成。
+     * 调用飞书 POST /im/v1/messages/{message_id}/reactions
+     */
+    async addReaction(messageId, emojiType = 'OnIt') {
+        try {
+            const response = await this.client.im.messageReaction.create({
+                path: { message_id: messageId },
+                data: {
+                    reaction_type: { emoji_type: emojiType },
+                },
+            });
+            if (response.code !== 0) {
+                console.warn(`[feishu-sender] 添加表情回复失败: ${response.msg || `code ${response.code}`}`);
+                return null;
+            }
+            return response.data?.reaction_id ?? null;
+        }
+        catch (err) {
+            console.warn('[feishu-sender] 添加表情回复异常:', err);
+            return null;
+        }
+    }
+    // ── 出站场景 ──
+    async sendBlockedAlert(params) {
+        // 用自然语言，不用制式模板
+        const text = `${params.taskId} 卡住了——${params.reason}`;
+        const results = await Promise.allSettled(params.targetUserIds.map(userId => this.sendText({
+            receiveIdType: 'open_id',
+            receiveId: userId,
+            text,
+        })));
+        for (const userId of params.targetUserIds) {
+            this.logOutbound({
+                receiver: userId,
+                content: text,
+                message_type: 'alert',
+                related_task_id: params.taskId,
+                receiveIdType: 'open_id',
+            });
+        }
+        return results;
+    }
+    async sendDailyReport(params) {
+        // 日报内容较长，保留卡片格式便于阅读
+        const card = markdownToFeishuCard(params.reportContent, `${params.date} 工作小结`);
+        await this.sendCard({
+            receiveIdType: 'chat_id',
+            receiveId: params.chatId,
+            card,
+        });
+        this.logOutbound({
+            receiver: params.chatId,
+            content: params.reportContent,
+            message_type: 'report',
+            receiveIdType: 'chat_id',
+        });
+    }
+    async sendTaskDone(params) {
+        // 用自然语言，像同事在群里说"搞定了"
+        const prPart = params.prUrl ? `，PR: ${params.prUrl}` : '';
+        const text = `${params.taskId} 搞定了——${params.summary}${prPart}`;
+        await this.sendText({
+            receiveIdType: 'chat_id',
+            receiveId: params.chatId,
+            text,
+        });
+        this.logOutbound({
+            receiver: params.chatId,
+            content: text,
+            message_type: 'task_done',
+            related_task_id: params.taskId,
+            receiveIdType: 'chat_id',
+        });
+    }
+}
+//# sourceMappingURL=feishu-sender.js.map

package/apps/server/dist/gateway/feishu-ws.js

@@ -0,0 +1,254 @@
+import * as Lark from '@larksuiteoapi/node-sdk';
+import { getOrgMember, upsertOrgMember, upsertChat } from '@team-anya/db';
+// ── 消息解析 ──
+const ANYA_MENTION_PATTERN = /@anya\b/i;
+/**
+ * 解析飞书消息事件为统一的 IncomingMessage 格式
+ *
+ * downloader 为可选参数，不传时退化为占位符模式（向后兼容，测试友好）
+ */
+export async function parseFeishuMessage(event, eventId, downloader) {
+    const msg = event.message;
+    const sender = event.sender;
+    const { text, media } = await extractContent(msg.message_type, msg.content, msg.message_id, downloader);
+    const hasMentionInList = msg.mentions?.some(m => /anya/i.test(m.name)) ?? false;
+    const hasMentionInContent = ANYA_MENTION_PATTERN.test(text);
+    return {
+        content: text,
+        media,
+        sender: sender?.sender_id.open_id,
+        chatId: msg.chat_id,
+        isDirectMessage: msg.chat_type === 'p2p',
+        mentionsAnya: hasMentionInList || hasMentionInContent,
+        metadata: {
+            ...(eventId ? { event_id: eventId } : {}),
+            message_id: msg.message_id,
+            message_type: msg.message_type,
+            source_type: 'feishu',
+            ...(msg.parent_id ? { parent_message_id: msg.parent_id } : {}),
+            ...(msg.root_id ? { root_message_id: msg.root_id } : {}),
+        },
+    };
+}
+/**
+ * 从飞书消息内容中提取文本和媒体附件
+ */
+async function extractContent(messageType, rawContent, messageId, downloader) {
+    try {
+        const parsed = JSON.parse(rawContent);
+        switch (messageType) {
+            case 'text':
+                return { text: parsed.text ?? '', media: [] };
+            case 'post': {
+                const title = parsed.title ?? '';
+                const textParts = [];
+                if (title)
+                    textParts.push(title);
+                const content = parsed.content;
+                if (Array.isArray(content)) {
+                    for (const paragraph of content) {
+                        if (Array.isArray(paragraph)) {
+                            for (const element of paragraph) {
+                                if (element.tag === 'text' && element.text) {
+                                    textParts.push(element.text);
+                                }
+                                else if (element.tag === 'a' && element.text) {
+                                    textParts.push(element.text);
+                                }
+                                else if (element.tag === 'at' && element.user_name) {
+                                    textParts.push(`@${element.user_name}`);
+                                }
+                            }
+                        }
+                    }
+                }
+                return { text: textParts.join(' ').trim(), media: [] };
+            }
+            case 'image':
+            case 'file':
+            case 'audio':
+            case 'video': {
+                if (downloader) {
+                    const attachment = await downloader.download(messageId, messageType, parsed);
+                    if (attachment) {
+                        return {
+                            text: `[${messageType}: ${attachment.originalName}] (本地路径: ${attachment.localPath})`,
+                            media: [attachment],
+                        };
+                    }
+                }
+                // 降级：无 downloader 或下载失败
+                const fallbackKey = parsed.image_key ?? parsed.file_name ?? parsed.file_key ?? 'unknown';
+                return {
+                    text: `[${messageType}: 未能下载, key=${fallbackKey}]`,
+                    media: [],
+                };
+            }
+            default:
+                return { text: `[${messageType}]`, media: [] };
+        }
+    }
+    catch {
+        return { text: rawContent, media: [] };
+    }
+}
+// ── 用户信息解析 ──
+/**
+ * 通过飞书 API 查询用户名称，优先从本地 DB 缓存读取
+ *
+ * 流程：DB 缓存命中 → 直接返回 | 未命中 → 飞书 API 查询 → 写入 DB → 返回
+ * 异常时降级返回 undefined，不阻断消息处理
+ */
+export async function resolveFeishuUser(client, openId, db, logger) {
+    try {
+        // 1. 查本地缓存
+        const cached = getOrgMember(db, openId);
+        if (cached)
+            return cached.name;
+        // 2. 调飞书 API
+        const resp = await client.contact.user.get({
+            path: { user_id: openId },
+            params: { user_id_type: 'open_id' },
+        });
+        const user = resp?.data?.user;
+        const name = user?.name;
+        if (!name) {
+            logger?.warn({ openId, fields: Object.keys(user ?? {}) }, '飞书 API 未返回 name（可能缺少 contact:user.base:readonly 权限）');
+        }
+        if (!name)
+            return undefined;
+        // 3. 写入缓存（含扩展字段）
+        upsertOrgMember(db, {
+            member_id: openId,
+            name,
+            platform: 'feishu',
+            union_id: user?.union_id ?? undefined,
+            user_id: user?.user_id ?? undefined,
+            en_name: user?.en_name ?? undefined,
+            email: user?.email ?? undefined,
+            employee_no: user?.employee_no ?? undefined,
+            avatar_url: user?.avatar?.avatar_origin ?? user?.avatar?.avatar_72 ?? undefined,
+            last_synced_at: new Date().toISOString(),
+        });
+        logger?.info({ openId, name }, '新用户缓存');
+        return name;
+    }
+    catch (err) {
+        logger?.warn({ openId, err }, '解析用户信息失败');
+        return undefined;
+    }
+}
+// ── FeishuWSClient（基于官方 SDK）──
+/**
+ * 飞书 WebSocket 长连接客户端
+ *
+ * 使用 @larksuiteoapi/node-sdk 的 WSClient 和 EventDispatcher
+ * SDK 内部自动处理 token 获取、刷新、断线重连
+ */
+export class FeishuWSClient {
+    wsClient;
+    eventDispatcher;
+    onMessageCallback;
+    mediaDownloader;
+    larkClient;
+    db;
+    chatSyncService;
+    feishuSender;
+    log;
+    started = false;
+    constructor(config, options) {
+        this.onMessageCallback = options.onMessage;
+        this.mediaDownloader = options.mediaDownloader;
+        this.larkClient = options.client;
+        this.db = options.db;
+        this.chatSyncService = options.chatSyncService;
+        this.feishuSender = options.feishuSender;
+        this.log = options.logger ?? {
+            info: (obj, msg) => console.log('[feishu-ws]', msg ?? '', obj),
+            warn: (obj, msg) => console.warn('[feishu-ws]', msg ?? '', obj),
+            error: (obj, msg) => console.error('[feishu-ws]', msg ?? '', obj),
+        };
+        // 创建事件分发器
+        this.eventDispatcher = new Lark.EventDispatcher({});
+        // 注册消息接收事件
+        this.eventDispatcher.register({
+            'im.message.receive_v1': async (data) => {
+                try {
+                    this.log.info({ raw_event: data }, '收到飞书消息事件');
+                    const event = data;
+                    if (!event.message)
+                        return;
+                    const eventId = event.header?.event_id;
+                    const message = await parseFeishuMessage(event, eventId, this.mediaDownloader);
+                    // 立即添加表情回复（fire-and-forget，不阻断消息处理）
+                    if (this.feishuSender && event.message.message_id) {
+                        this.feishuSender.addReaction(event.message.message_id, 'OnIt').catch(err => {
+                            this.log.warn({ err }, '表情回复失败');
+                        });
+                    }
+                    // 解析发送者名称（异步，不阻断消息处理）
+                    if (message.sender && this.larkClient && this.db) {
+                        message.senderName = await resolveFeishuUser(this.larkClient, message.sender, this.db, this.log);
+                    }
+                    // 异步触发群信息同步（群聊走完整同步，p2p 私聊直接写入 chats 表）
+                    if (message.chatId && !message.isDirectMessage && this.chatSyncService && this.chatSyncService.needsSync(message.chatId)) {
+                        this.chatSyncService.syncChatFull(message.chatId).catch(err => {
+                            this.log.warn({ err, chatId: message.chatId }, '群信息同步失败');
+                        });
+                    }
+                    else if (message.chatId && message.isDirectMessage && this.db) {
+                        // p2p 私聊：直接写入 chats 表，无需调飞书群 API
+                        try {
+                            const senderLabel = message.senderName ?? message.sender ?? 'unknown';
+                            upsertChat(this.db, {
+                                chat_id: message.chatId,
+                                platform: 'feishu',
+                                name: `p2p: ${senderLabel}`,
+                                chat_type: 'p2p',
+                                user_count: 2,
+                                last_synced_at: new Date().toISOString(),
+                            });
+                        }
+                        catch (err) {
+                            this.log.warn({ err, chatId: message.chatId }, 'p2p chat 写入失败');
+                        }
+                    }
+                    this.log.info({ parsed_message: message }, '消息解析完成');
+                    // 非阻塞：不 await，让 SDK 在 3 秒内确认收到
+                    this.onMessageCallback(message).catch(err => {
+                        this.log.error({ err }, '消息处理失败');
+                    });
+                }
+                catch (err) {
+                    this.log.error({ err }, '消息处理异常');
+                }
+            },
+        });
+        // 创建 WebSocket 客户端
+        this.wsClient = new Lark.WSClient({
+            appId: config.appId,
+            appSecret: config.appSecret,
+            domain: Lark.Domain.Feishu,
+            loggerLevel: Lark.LoggerLevel.warn,
+        });
+    }
+    get isConnected() {
+        return this.started;
+    }
+    /**
+     * 启动 WebSocket 长连接
+     */
+    async connect() {
+        this.wsClient.start({ eventDispatcher: this.eventDispatcher });
+        this.started = true;
+    }
+    /**
+     * 关闭连接
+     * 设置 started=false 并将回调置为 no-op，防止关闭后仍处理消息
+     */
+    async close() {
+        this.started = false;
+        this.onMessageCallback = async () => { };
+    }
+}
+//# sourceMappingURL=feishu-ws.js.map