team-anya 0.2.0

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

@@ -0,0 +1,353 @@
+import * as Lark from '@larksuiteoapi/node-sdk';
+import { getOrgMember, upsertOrgMember, upsertChat } from '@team-anya/db';
+// ── 消息解析 ──
+const ANYA_MENTION_PATTERN = /@anya\b/i;
+/**
+ * 将飞书消息中的 @_user_N 占位符替换为 @真实用户名
+ * 飞书 text 消息内容中 @ 人显示为 @_user_1、@_user_2 等占位符，
+ * 真实信息在 mentions 数组中，需要做映射替换。
+ */
+function resolveMentions(text, mentions) {
+    if (!mentions?.length)
+        return text;
+    let resolved = text;
+    for (const m of mentions) {
+        // m.key 形如 "@_user_1"，替换为 "@真实名字"
+        resolved = resolved.replace(m.key, `@${m.name}`);
+    }
+    return resolved;
+}
+/**
+ * 解析飞书消息事件为统一的 IncomingMessage 格式
+ *
+ * downloader 为可选参数，不传时退化为占位符模式（向后兼容，测试友好）
+ */
+export async function parseFeishuMessage(event, eventId, downloader) {
+    const msg = event.message;
+    const sender = event.sender;
+    const { text: rawText, media } = await extractContent(msg.message_type, msg.content, msg.message_id, downloader, msg.chat_id);
+    // 将 @_user_N 占位符替换为真实用户名（飞书 text 消息用占位符表示 @）
+    const text = resolveMentions(rawText, msg.mentions);
+    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',
+            ...(event.header?.create_time ? { event_create_time: event.header.create_time } : {}),
+            ...(msg.parent_id ? { parent_message_id: msg.parent_id } : {}),
+            ...(msg.root_id ? { root_message_id: msg.root_id } : {}),
+            ...(msg.thread_id ? { thread_id: msg.thread_id } : {}),
+        },
+    };
+}
+/**
+ * 从飞书消息内容中提取文本和媒体附件
+ *
+ * @param depth 递归深度（用于 merge_forward 防无限递归），默认 0
+ */
+async function extractContent(messageType, rawContent, messageId, downloader, chatId, depth = 0) {
+    try {
+        const parsed = JSON.parse(rawContent);
+        switch (messageType) {
+            case 'text':
+                return { text: parsed.text ?? '', media: [] };
+            case 'post': {
+                const title = parsed.title ?? '';
+                const textParts = [];
+                const mediaList = [];
+                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}](${element.href ?? ''})`);
+                                }
+                                else if (element.tag === 'at' && element.user_name) {
+                                    textParts.push(`@${element.user_name}`);
+                                }
+                                else if (element.tag === 'img' && element.image_key) {
+                                    // 富文本中的内嵌图片
+                                    if (downloader) {
+                                        const attachment = await downloader.download(messageId, 'image', { image_key: element.image_key }, chatId);
+                                        if (attachment) {
+                                            mediaList.push(attachment);
+                                            textParts.push(`[图片: ${attachment.originalName}] (本地路径: ${attachment.localPath})`);
+                                        }
+                                        else {
+                                            textParts.push(`[图片: 未能下载, key=${element.image_key}]`);
+                                        }
+                                    }
+                                    else {
+                                        textParts.push(`[图片: key=${element.image_key}]`);
+                                    }
+                                }
+                                else if (element.tag === 'media' && element.file_key) {
+                                    // 富文本中的内嵌视频/文件
+                                    if (downloader) {
+                                        const attachment = await downloader.download(messageId, 'video', { file_key: element.file_key }, chatId);
+                                        if (attachment) {
+                                            mediaList.push(attachment);
+                                            textParts.push(`[视频: ${attachment.originalName}] (本地路径: ${attachment.localPath})`);
+                                        }
+                                        else {
+                                            textParts.push(`[视频: 未能下载, key=${element.file_key}]`);
+                                        }
+                                    }
+                                    else {
+                                        textParts.push(`[视频: key=${element.file_key}]`);
+                                    }
+                                }
+                                else if (element.tag === 'code_block' && element.text) {
+                                    // 代码块
+                                    const lang = element.language?.toLowerCase() ?? '';
+                                    textParts.push(`\n\`\`\`${lang}\n${element.text}\n\`\`\`\n`);
+                                }
+                                else if (element.tag === 'emotion' && element.emoji_type) {
+                                    // 表情
+                                    textParts.push(`[${element.emoji_type}]`);
+                                }
+                                else if (element.tag === 'hr') {
+                                    // 分隔线
+                                    textParts.push('\n---\n');
+                                }
+                            }
+                        }
+                    }
+                }
+                return { text: textParts.join(' ').trim(), media: mediaList };
+            }
+            case 'image':
+            case 'file':
+            case 'audio':
+            case 'video': {
+                if (downloader) {
+                    const attachment = await downloader.download(messageId, messageType, parsed, chatId);
+                    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: [],
+                };
+            }
+            case 'sticker':
+                return { text: '[表情包]', media: [] };
+            case 'location': {
+                const name = parsed.name ?? '未知位置';
+                const lng = parsed.longitude ?? '';
+                const lat = parsed.latitude ?? '';
+                const coords = lng && lat ? ` (${lng}, ${lat})` : '';
+                return { text: `[位置: ${name}${coords}]`, media: [] };
+            }
+            case 'merge_forward': {
+                if (!downloader || depth >= 2) {
+                    return { text: '[合并转发消息]', media: [] };
+                }
+                const { items: subs, truncated, total } = await downloader.fetchSubMessages(messageId);
+                if (!subs.length) {
+                    return { text: '[合并转发消息: 无法获取内容]', media: [] };
+                }
+                const parts = ['--- 转发消息 ---'];
+                const allMedia = [];
+                for (const sub of subs) {
+                    const { text: subText, media: subMedia } = await extractContent(sub.msg_type, sub.content, sub.message_id, downloader, chatId, depth + 1);
+                    const sender = sub.sender_name ?? '未知';
+                    parts.push(`[${sender}] ${subText}`);
+                    allMedia.push(...subMedia);
+                }
+                if (truncated) {
+                    parts.push(`... 共 ${total} 条，仅展示前 ${subs.length} 条`);
+                }
+                parts.push('--- 转发消息结束 ---');
+                return { text: parts.join('\n'), media: allMedia };
+            }
+            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，大模型回复后会自动移除）
+                    // 群消息且未 @ Anya 时不添加 Reaction
+                    if (this.feishuSender && event.message.message_id && event.message.chat_id && (message.isDirectMessage || message.mentionsAnya)) {
+                        this.feishuSender.addTypingReaction(event.message.chat_id, event.message.message_id).catch(err => {
+                            this.log.warn({ err }, 'typing 表情添加失败');
+                        });
+                    }
+                    // 解析发送者名称（异步，不阻断消息处理）
+                    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

package/apps/server/dist/gateway/health-monitor.js

@@ -0,0 +1,154 @@
+import { getRecentMessages } from '@team-anya/db';
+// ── 话术池 ──
+const SILENT_RESULT_REPLIES = [
+    '刚才处理完了但好像漏说了结果，你再问我一下？',
+    '不好意思，刚才干完活忘了汇报，你可以再@我一下',
+    '处理完了但我好像没回你，抱歉，你再说一声我接上',
+];
+const STUCK_REPLIES = [
+    '我这边好像卡住了，正在尝试恢复，如果一直没反应你踢我一下',
+    '抱歉，我可能卡在某个环节了，你可以发条消息唤醒我试试',
+    '好像遇到了点问题转不动了，你再@我一下我重新来',
+];
+function pickRandom(pool) {
+    return pool[Math.floor(Math.random() * pool.length)];
+}
+// ── HealthMonitor ──
+/**
+ * 静默健康监控器
+ *
+ * 正常流程零感知，仅在异常时主动通知用户：
+ * 1. CC result 到了但没回复用户 → 兜底通知
+ * 2. CC 实例卡死（executing 但长时间无 progress） → 告警
+ */
+export class HealthMonitor {
+    deps;
+    config;
+    logger;
+    scanTimer = null;
+    pendingChecks = new Map(); // instanceId → timer
+    /** 已通知过卡死的实例，防止重复告警 */
+    stuckNotified = new Set();
+    constructor(deps, config = {}) {
+        this.deps = deps;
+        this.logger = deps.logger ?? { info: console.log, error: console.error };
+        this.config = {
+            resultCheckDelayMs: config.resultCheckDelayMs ?? 10_000,
+            stuckThresholdMs: config.stuckThresholdMs ?? 3 * 60_000,
+            scanIntervalMs: config.scanIntervalMs ?? 30_000,
+            recentOutboundWindowMs: config.recentOutboundWindowMs ?? 30_000,
+        };
+    }
+    /**
+     * 启动监控：监听 broker 事件 + 启动定时扫描
+     */
+    start() {
+        // 场景 2：监听 result 事件，延迟检查是否有回复
+        this.deps.broker.on('instance.result', (instanceId, role, _result) => {
+            this.scheduleResultCheck(instanceId, role);
+        });
+        // 场景 3：定时扫描卡死实例
+        this.scanTimer = setInterval(() => this.checkStuckInstances(), this.config.scanIntervalMs);
+        // 实例退出时清理追踪状态
+        this.deps.broker.on('instance.exited', (instanceId) => {
+            this.cleanup(instanceId);
+        });
+        this.deps.broker.on('instance.crash', (instanceId) => {
+            this.cleanup(instanceId);
+        });
+        this.logger.info('[HealthMonitor] 已启动');
+    }
+    /**
+     * 停止监控
+     */
+    stop() {
+        if (this.scanTimer) {
+            clearInterval(this.scanTimer);
+            this.scanTimer = null;
+        }
+        for (const timer of this.pendingChecks.values()) {
+            clearTimeout(timer);
+        }
+        this.pendingChecks.clear();
+        this.stuckNotified.clear();
+        this.logger.info('[HealthMonitor] 已停止');
+    }
+    // ── 场景 2：result 到了但没回复 ──
+    scheduleResultCheck(instanceId, role) {
+        // 如果已有待检查的 timer，先清掉（同一实例连续 result）
+        const existing = this.pendingChecks.get(instanceId);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.pendingChecks.delete(instanceId);
+            this.checkResultReply(instanceId, role);
+        }, this.config.resultCheckDelayMs);
+        this.pendingChecks.set(instanceId, timer);
+    }
+    checkResultReply(instanceId, role) {
+        const chatId = this.deps.resolveChatId(instanceId, role);
+        if (!chatId)
+            return; // 无法定位用户，跳过
+        if (this.hasRecentOutbound(chatId))
+            return; // 已回复，正常
+        // 没回复 → 发兜底通知
+        this.notify(chatId, 'silent_result');
+        this.logger.info(`[HealthMonitor] result 无回复兜底通知 (instance: ${instanceId}, chat: ${chatId})`);
+    }
+    // ── 场景 3：卡死检测 ──
+    checkStuckInstances() {
+        const now = Date.now();
+        const instances = this.deps.broker.status();
+        for (const inst of instances) {
+            if (inst.state !== 'executing') {
+                // 不在执行态，清除已通知标记
+                this.stuckNotified.delete(inst.id);
+                continue;
+            }
+            const lastActivity = new Date(inst.lastActivityAt).getTime();
+            const elapsed = now - lastActivity;
+            if (elapsed < this.config.stuckThresholdMs)
+                continue;
+            if (this.stuckNotified.has(inst.id))
+                continue; // 已通知过
+            const chatId = this.deps.resolveChatId(inst.id, inst.role);
+            if (!chatId)
+                continue;
+            this.stuckNotified.add(inst.id);
+            this.notify(chatId, 'stuck');
+            this.logger.info(`[HealthMonitor] 卡死告警 (instance: ${inst.id}, idle: ${Math.round(elapsed / 1000)}s)`);
+        }
+    }
+    // ── 工具方法 ──
+    hasRecentOutbound(chatId) {
+        const since = new Date(Date.now() - this.config.recentOutboundWindowMs).toISOString();
+        const messages = getRecentMessages(this.deps.db, {
+            direction: 'outbound',
+            chat_id: chatId,
+            since,
+            limit: 1,
+        });
+        return messages.length > 0;
+    }
+    notify(chatId, type) {
+        const text = type === 'silent_result'
+            ? pickRandom(SILENT_RESULT_REPLIES)
+            : pickRandom(STUCK_REPLIES);
+        this.deps.feishuSender.sendText({
+            receiveIdType: 'chat_id',
+            receiveId: chatId,
+            text,
+        }).catch(err => {
+            this.logger.error(`[HealthMonitor] 通知发送失败 (chat: ${chatId}):`, err);
+        });
+    }
+    cleanup(instanceId) {
+        const timer = this.pendingChecks.get(instanceId);
+        if (timer) {
+            clearTimeout(timer);
+            this.pendingChecks.delete(instanceId);
+        }
+        this.stuckNotified.delete(instanceId);
+    }
+}
+//# sourceMappingURL=health-monitor.js.map