wechaty-web-panel 1.6.112 → 1.6.113

package/dist/mcp/src/services/McpService.js

@@ -0,0 +1,521 @@
+import { Friend, Group, GroupMember, ChatMessage } from '../models/index.js';
+import { sequelize } from '../config/database.js';
+import { Op, fn, col, literal } from 'sequelize';
+/**
+ * MCP (Model Context Protocol) 服务
+ * 提供各种高级查询和分析功能
+ */
+class McpService {
+    /**
+     * 根据关键词搜索好友
+     * @param {Object} params - 搜索参数
+     * @returns {Promise<Array>} 搜索结果
+     */
+    async searchFriends(params = {}) {
+        const { robotId, keyword, tags, limit = 50, offset = 0, orderBy = 'createdAt', orderDirection = 'DESC' } = params;
+        const whereClause = {};
+        if (robotId)
+            whereClause.robotId = robotId;
+        // 关键词搜索：匹配姓名、备注、别名、微信号
+        if (keyword) {
+            whereClause[Op.or] = [
+                { name: { [Op.iLike]: `%${keyword}%` } },
+                { remark: { [Op.iLike]: `%${keyword}%` } },
+                { alias: { [Op.iLike]: `%${keyword}%` } },
+                { wxNumber: { [Op.iLike]: `%${keyword}%` } }
+            ];
+        }
+        // 标签搜索
+        if (tags) {
+            whereClause.tags = { [Op.iLike]: `%${tags}%` };
+        }
+        try {
+            const friends = await Friend.findAll({
+                where: whereClause,
+                limit,
+                offset,
+                order: [[orderBy, orderDirection]]
+            });
+            return {
+                data: friends,
+                total: await Friend.count({ where: whereClause }),
+                limit,
+                offset
+            };
+        }
+        catch (error) {
+            console.error('❌ 搜索好友失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 根据关键词搜索群组
+     * @param {Object} params - 搜索参数
+     * @returns {Promise<Array>} 搜索结果
+     */
+    async searchGroups(params = {}) {
+        const { robotId, keyword, includeMembers = false, minMemberCount = 0, maxMemberCount = null, limit = 50, offset = 0 } = params;
+        const whereClause = {};
+        if (robotId)
+            whereClause.robotId = robotId;
+        if (keyword) {
+            whereClause.name = { [Op.iLike]: `%${keyword}%` };
+        }
+        if (minMemberCount > 0) {
+            whereClause.memberCount = { [Op.gte]: minMemberCount };
+        }
+        if (maxMemberCount) {
+            whereClause.memberCount = {
+                ...whereClause.memberCount,
+                [Op.lte]: maxMemberCount
+            };
+        }
+        try {
+            const include = includeMembers ? [{
+                    model: GroupMember,
+                    as: 'members'
+                }] : [];
+            const groups = await Group.findAll({
+                where: whereClause,
+                include,
+                limit,
+                offset,
+                order: [['memberCount', 'DESC']]
+            });
+            return {
+                data: groups,
+                total: await Group.count({ where: whereClause }),
+                limit,
+                offset
+            };
+        }
+        catch (error) {
+            console.error('❌ 搜索群组失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 高级聊天记录搜索
+     * @param {Object} params - 搜索参数
+     * @returns {Promise<Array>} 搜索结果
+     */
+    async searchChatMessages(params = {}) {
+        const { robotId, conversationId, keyword, contentType, recordType, chatUserId, isRobotAnswer, startTime, endTime, limit = 100, offset = 0 } = params;
+        const whereClause = {};
+        if (robotId)
+            whereClause.robotId = robotId;
+        if (conversationId)
+            whereClause.conversationId = conversationId;
+        if (contentType)
+            whereClause.contentType = contentType;
+        if (recordType)
+            whereClause.recordType = recordType;
+        if (chatUserId)
+            whereClause.chatUserId = chatUserId;
+        if (typeof isRobotAnswer === 'boolean')
+            whereClause.isRobotAnswer = isRobotAnswer;
+        // 关键词搜索消息内容
+        if (keyword) {
+            whereClause.content = { [Op.iLike]: `%${keyword}%` };
+        }
+        // 时间范围搜索
+        if (startTime || endTime) {
+            whereClause.timestamp = {};
+            if (startTime)
+                whereClause.timestamp[Op.gte] = startTime;
+            if (endTime)
+                whereClause.timestamp[Op.lte] = endTime;
+        }
+        try {
+            const messages = await ChatMessage.findAll({
+                where: whereClause,
+                limit,
+                offset,
+                order: [['timestamp', 'DESC']]
+            });
+            return {
+                data: messages,
+                total: await ChatMessage.count({ where: whereClause }),
+                limit,
+                offset
+            };
+        }
+        catch (error) {
+            console.error('❌ 搜索聊天记录失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 获取机器人统计信息
+     * @param {string} robotId - 机器人ID
+     * @returns {Promise<Object>} 统计信息
+     */
+    async getRobotStatistics(robotId) {
+        try {
+            const [friendCount, groupCount, groupMemberCount, messageCount, todayMessageCount] = await Promise.all([
+                Friend.count({ where: { robotId } }),
+                Group.count({ where: { robotId } }),
+                GroupMember.count({ where: { robotId } }),
+                ChatMessage.count({ where: { robotId } }),
+                ChatMessage.count({
+                    where: {
+                        robotId,
+                        timestamp: {
+                            [Op.gte]: new Date().setHours(0, 0, 0, 0)
+                        }
+                    }
+                })
+            ]);
+            // 获取最近活跃的会话
+            const recentConversations = await ChatMessage.findAll({
+                where: { robotId },
+                attributes: [
+                    'conversationId',
+                    'conversationName',
+                    'recordType',
+                    [fn('MAX', col('timestamp')), 'lastMessageTime'],
+                    [fn('COUNT', col('id')), 'messageCount']
+                ],
+                group: ['conversationId', 'conversationName', 'recordType'],
+                order: [[literal('"lastMessageTime"'), 'DESC']],
+                limit: 10
+            });
+            // 获取消息类型统计
+            const messageTypeStats = await ChatMessage.findAll({
+                where: { robotId },
+                attributes: [
+                    'contentType',
+                    [fn('COUNT', col('id')), 'count']
+                ],
+                group: ['contentType'],
+                order: [[literal('count'), 'DESC']]
+            });
+            return {
+                robotId,
+                statistics: {
+                    friendCount,
+                    groupCount,
+                    groupMemberCount,
+                    messageCount,
+                    todayMessageCount
+                },
+                recentConversations: recentConversations.map(conv => ({
+                    conversationId: conv.conversationId,
+                    conversationName: conv.conversationName,
+                    recordType: conv.recordType,
+                    lastMessageTime: conv.getDataValue('lastMessageTime'),
+                    messageCount: conv.getDataValue('messageCount')
+                })),
+                messageTypeStats: messageTypeStats.map(stat => ({
+                    contentType: stat.contentType,
+                    count: stat.getDataValue('count')
+                }))
+            };
+        }
+        catch (error) {
+            console.error('❌ 获取机器人统计信息失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 获取会话详细信息
+     * @param {Object} params - 查询参数
+     * @returns {Promise<Object>} 会话信息
+     */
+    async getConversationDetails(params = {}) {
+        const { robotId, conversationId } = params;
+        if (!robotId || !conversationId) {
+            throw new Error('robotId 和 conversationId 是必需参数');
+        }
+        try {
+            // 获取会话基本信息
+            const firstMessage = await ChatMessage.findOne({
+                where: { robotId, conversationId },
+                order: [['timestamp', 'ASC']]
+            });
+            if (!firstMessage) {
+                throw new Error('未找到该会话');
+            }
+            // 获取会话统计
+            const messageStats = await ChatMessage.findAll({
+                where: { robotId, conversationId },
+                attributes: [
+                    [fn('COUNT', col('id')), 'totalMessages'],
+                    [fn('MIN', col('timestamp')), 'firstMessageTime'],
+                    [fn('MAX', col('timestamp')), 'lastMessageTime'],
+                    [fn('COUNT', literal('CASE WHEN "isRobotAnswer" = true THEN 1 END')), 'robotMessages'],
+                    [fn('COUNT', literal('CASE WHEN "isRobotAnswer" = false THEN 1 END')), 'userMessages']
+                ]
+            });
+            // 获取参与者信息
+            const participants = await ChatMessage.findAll({
+                where: { robotId, conversationId },
+                attributes: [
+                    'chatUserId',
+                    'chatUserName',
+                    [fn('COUNT', col('id')), 'messageCount'],
+                    [fn('MAX', col('timestamp')), 'lastActiveTime']
+                ],
+                group: ['chatUserId', 'chatUserName'],
+                order: [[literal('"messageCount"'), 'DESC']]
+            });
+            // 如果是群聊，获取群组详情
+            let groupDetails = null;
+            if (firstMessage.recordType === 'room') {
+                groupDetails = await Group.findOne({
+                    where: { robotId, wxid: conversationId },
+                    include: [{
+                            model: GroupMember,
+                            as: 'members'
+                        }]
+                });
+            }
+            return {
+                conversationId,
+                conversationName: firstMessage.conversationName,
+                recordType: firstMessage.recordType,
+                statistics: {
+                    totalMessages: messageStats[0]?.getDataValue('totalMessages') || 0,
+                    robotMessages: messageStats[0]?.getDataValue('robotMessages') || 0,
+                    userMessages: messageStats[0]?.getDataValue('userMessages') || 0,
+                    firstMessageTime: messageStats[0]?.getDataValue('firstMessageTime'),
+                    lastMessageTime: messageStats[0]?.getDataValue('lastMessageTime')
+                },
+                participants: participants.map(p => ({
+                    userId: p.chatUserId,
+                    userName: p.chatUserName,
+                    messageCount: p.getDataValue('messageCount'),
+                    lastActiveTime: p.getDataValue('lastActiveTime')
+                })),
+                groupDetails
+            };
+        }
+        catch (error) {
+            console.error('❌ 获取会话详情失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 获取群组成员详细信息
+     * @param {Object} params - 查询参数
+     * @returns {Promise<Object>} 群组成员信息
+     */
+    async getGroupMembersDetail(params = {}) {
+        const { robotId, roomWxid, includeMessageStats = true } = params;
+        if (!robotId || !roomWxid) {
+            throw new Error('robotId 和 roomWxid 是必需参数');
+        }
+        try {
+            // 获取群组信息
+            const group = await Group.findOne({
+                where: { robotId, wxid: roomWxid }
+            });
+            if (!group) {
+                throw new Error('未找到该群组');
+            }
+            // 获取群成员列表
+            const members = await GroupMember.findAll({
+                where: { robotId, roomWxid },
+                order: [['createdAt', 'ASC']]
+            });
+            // 如果需要消息统计
+            let membersWithStats = members;
+            if (includeMessageStats) {
+                const memberStats = await ChatMessage.findAll({
+                    where: {
+                        robotId,
+                        conversationId: roomWxid,
+                        recordType: 'room'
+                    },
+                    attributes: [
+                        'chatUserId',
+                        [fn('COUNT', col('id')), 'messageCount'],
+                        [fn('MAX', col('timestamp')), 'lastMessageTime']
+                    ],
+                    group: ['chatUserId']
+                });
+                const statsMap = new Map(memberStats.map(stat => [
+                    stat.chatUserId,
+                    {
+                        messageCount: stat.getDataValue('messageCount'),
+                        lastMessageTime: stat.getDataValue('lastMessageTime')
+                    }
+                ]));
+                membersWithStats = members.map(member => ({
+                    ...member.toJSON(),
+                    messageStats: statsMap.get(member.wxid) || {
+                        messageCount: 0,
+                        lastMessageTime: null
+                    }
+                }));
+            }
+            return {
+                group: group.toJSON(),
+                members: membersWithStats,
+                summary: {
+                    totalMembers: members.length,
+                    activeMembers: membersWithStats.filter(m => m.messageStats?.messageCount > 0).length
+                }
+            };
+        }
+        catch (error) {
+            console.error('❌ 获取群组成员详情失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 获取消息热力图数据（按时间分布）
+     * @param {Object} params - 查询参数
+     * @returns {Promise<Array>} 热力图数据
+     */
+    async getMessageHeatmap(params = {}) {
+        const { robotId, conversationId, startDate, endDate, granularity = 'hour' // hour, day, week, month
+         } = params;
+        const whereClause = {};
+        if (robotId)
+            whereClause.robotId = robotId;
+        if (conversationId)
+            whereClause.conversationId = conversationId;
+        // 设置时间范围
+        if (startDate || endDate) {
+            whereClause.timestamp = {};
+            if (startDate)
+                whereClause.timestamp[Op.gte] = new Date(startDate).getTime();
+            if (endDate)
+                whereClause.timestamp[Op.lte] = new Date(endDate).getTime();
+        }
+        let dateFormat;
+        switch (granularity) {
+            case 'hour':
+                dateFormat = "to_char(to_timestamp(timestamp/1000), 'YYYY-MM-DD HH24:00:00')";
+                break;
+            case 'day':
+                dateFormat = "to_char(to_timestamp(timestamp/1000), 'YYYY-MM-DD')";
+                break;
+            case 'week':
+                dateFormat = "to_char(date_trunc('week', to_timestamp(timestamp/1000)), 'YYYY-MM-DD')";
+                break;
+            case 'month':
+                dateFormat = "to_char(to_timestamp(timestamp/1000), 'YYYY-MM')";
+                break;
+            default:
+                dateFormat = "to_char(to_timestamp(timestamp/1000), 'YYYY-MM-DD HH24:00:00')";
+        }
+        try {
+            const heatmapData = await ChatMessage.findAll({
+                where: whereClause,
+                attributes: [
+                    [literal(dateFormat), 'timeSlot'],
+                    [fn('COUNT', col('id')), 'messageCount']
+                ],
+                group: [literal(dateFormat)],
+                order: [[literal('"timeSlot"'), 'ASC']]
+            });
+            return heatmapData.map(item => ({
+                timeSlot: item.getDataValue('timeSlot'),
+                messageCount: item.getDataValue('messageCount')
+            }));
+        }
+        catch (error) {
+            console.error('❌ 获取消息热力图数据失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 全文搜索
+     * @param {Object} params - 搜索参数
+     * @returns {Promise<Object>} 搜索结果
+     */
+    async fullTextSearch(params = {}) {
+        const { robotId, keyword, searchTypes = ['friends', 'groups', 'messages'], limit = 20 } = params;
+        if (!keyword) {
+            throw new Error('搜索关键词不能为空');
+        }
+        const results = {};
+        try {
+            // 搜索好友
+            if (searchTypes.includes('friends')) {
+                results.friends = await this.searchFriends({
+                    robotId,
+                    keyword,
+                    limit
+                });
+            }
+            // 搜索群组
+            if (searchTypes.includes('groups')) {
+                results.groups = await this.searchGroups({
+                    robotId,
+                    keyword,
+                    limit
+                });
+            }
+            // 搜索消息
+            if (searchTypes.includes('messages')) {
+                results.messages = await this.searchChatMessages({
+                    robotId,
+                    keyword,
+                    limit
+                });
+            }
+            return {
+                keyword,
+                searchTypes,
+                results,
+                summary: {
+                    friendCount: results.friends?.total || 0,
+                    groupCount: results.groups?.total || 0,
+                    messageCount: results.messages?.total || 0
+                }
+            };
+        }
+        catch (error) {
+            console.error('❌ 全文搜索失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 获取数据库连接状态和系统信息
+     * @returns {Promise<Object>} 系统信息
+     */
+    async getSystemInfo() {
+        try {
+            await sequelize.authenticate();
+            const [totalFriends, totalGroups, totalGroupMembers, totalMessages] = await Promise.all([
+                Friend.count(),
+                Group.count(),
+                GroupMember.count(),
+                ChatMessage.count()
+            ]);
+            return {
+                database: {
+                    status: 'connected',
+                    dialect: sequelize.getDialect(),
+                    version: await sequelize.databaseVersion()
+                },
+                statistics: {
+                    totalFriends,
+                    totalGroups,
+                    totalGroupMembers,
+                    totalMessages
+                },
+                system: {
+                    nodeVersion: process.version,
+                    platform: process.platform,
+                    uptime: process.uptime(),
+                    memoryUsage: process.memoryUsage()
+                }
+            };
+        }
+        catch (error) {
+            console.error('❌ 获取系统信息失败:', error);
+            return {
+                database: {
+                    status: 'disconnected',
+                    error: error.message
+                }
+            };
+        }
+    }
+}
+export default McpService;
+//# sourceMappingURL=McpService.js.map