domotz-mcp/dist/tools/MQTTQueryTool.js

MCP server for Domotz API and BMS (Building Management System) integration with IoT device monitoring

import { z } from "zod";
import { MCPTool } from "mcp-framework";
import { mqttPersistentManager } from "./MQTTPersistentManager.js";
export default class MQTTQueryTool extends MCPTool {
    name = "mqtt_query";
    description = "Query stored MQTT messages from the database";
    schema = {
        topic_pattern: {
            type: z.string().optional(),
            description: "Topic pattern to filter messages (supports MQTT wildcards: + and #)"
        },
        connection_id: {
            type: z.string().optional(),
            description: "Filter messages by connection ID"
        },
        start_time: {
            type: z.string().optional(),
            description: "Start time for time range query (ISO 8601 format)"
        },
        end_time: {
            type: z.string().optional(),
            description: "End time for time range query (ISO 8601 format)"
        },
        limit: {
            type: z.number().optional(),
            description: "Maximum number of messages to return (default: 100)"
        },
        offset: {
            type: z.number().optional(),
            description: "Offset for pagination (default: 0)"
        }
    };
    async execute(params) {
        try {
            const { topic_pattern, connection_id, start_time, end_time, limit = 100, offset = 0 } = params;
            const db = mqttPersistentManager.getDatabaseManager();
            let messages = [];
            // Query based on provided parameters
            if (start_time && end_time) {
                // Time range query
                messages = db.getMessagesByTimeRange(start_time, end_time, topic_pattern);
            }
            else if (topic_pattern) {
                // Topic pattern query
                messages = db.getMessagesByTopic(topic_pattern, limit, offset);
            }
            else if (connection_id) {
                // Connection ID query
                messages = db.getMessagesByConnection(connection_id, limit);
            }
            else {
                // Get all recent messages
                messages = db.getMessagesByTopic('%', limit, offset);
            }
            // Get statistics
            const stats = db.getStatistics();
            // Parse JSON messages where possible
            const parsedMessages = messages.map(msg => {
                let parsedContent = msg.message;
                try {
                    parsedContent = JSON.parse(msg.message);
                }
                catch (e) {
                    // Keep as string if not valid JSON
                }
                return {
                    id: msg.id,
                    connection_id: msg.connection_id,
                    topic: msg.topic,
                    message: parsedContent,
                    qos: msg.qos,
                    retain: msg.retain,
                    timestamp: msg.timestamp,
                    created_at: msg.created_at
                };
            });
            return {
                success: true,
                query: {
                    topic_pattern,
                    connection_id,
                    start_time,
                    end_time,
                    limit,
                    offset
                },
                results: {
                    count: parsedMessages.length,
                    messages: parsedMessages,
                    has_more: messages.length === limit
                },
                database_stats: {
                    total_messages: stats.total_messages,
                    unique_topics: stats.unique_topics,
                    oldest_message: stats.oldest_message,
                    newest_message: stats.newest_message
                }
            };
        }
        catch (error) {
            return {
                success: false,
                error: error.message || "Failed to query messages"
            };
        }
    }
}