domotz-mcp/dist/tools/MQTTSubscriptionsTool.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 MQTTSubscriptionsTool extends MCPTool {
    name = "mqtt_subscriptions";
    description = "Manage MQTT subscriptions and database settings";
    schema = {
        action: {
            type: z.string(),
            description: "Action to perform: list, stop, stats, cleanup, set_retention"
        },
        connection_id: {
            type: z.string().optional(),
            description: "Connection ID (required for stop action)"
        },
        topic_pattern: {
            type: z.string().optional(),
            description: "Topic pattern (required for stop action)"
        },
        retention_days: {
            type: z.number().optional(),
            description: "Number of days to retain messages (required for set_retention action)"
        }
    };
    async execute(params) {
        try {
            const { action, connection_id, topic_pattern, retention_days } = params;
            const db = mqttPersistentManager.getDatabaseManager();
            switch (action) {
                case "list": {
                    // List all active subscriptions
                    const dbSubscriptions = db.getActiveSubscriptions(connection_id);
                    const memorySubscriptions = mqttPersistentManager.getActivePersistentSubscriptions(connection_id);
                    return {
                        success: true,
                        subscriptions: {
                            database: dbSubscriptions,
                            active_memory: memorySubscriptions,
                            total_count: dbSubscriptions.length
                        }
                    };
                }
                case "stop": {
                    // Stop a persistent subscription
                    if (!connection_id || !topic_pattern) {
                        return {
                            success: false,
                            error: "Both connection_id and topic_pattern are required for stop action"
                        };
                    }
                    const result = mqttPersistentManager.stopPersistentSubscription(connection_id, topic_pattern);
                    if (result.success) {
                        return {
                            success: true,
                            message: "Subscription stopped",
                            unsubscribed: {
                                connection_id,
                                topic_pattern
                            }
                        };
                    }
                    else {
                        return {
                            success: false,
                            error: result.error
                        };
                    }
                }
                case "stats": {
                    // Get database statistics
                    const stats = db.getStatistics();
                    const subscriptions = db.getActiveSubscriptions();
                    // Get top topics
                    const topicStats = subscriptions.map(sub => ({
                        topic: sub.topic_pattern,
                        connection: sub.connection_id,
                        message_count: sub.message_count || 0
                    })).sort((a, b) => b.message_count - a.message_count);
                    return {
                        success: true,
                        statistics: {
                            database: stats,
                            active_subscriptions: subscriptions.length,
                            top_topics: topicStats.slice(0, 10)
                        }
                    };
                }
                case "cleanup": {
                    // Clean up old messages
                    const deletedCount = db.cleanupOldMessages();
                    const stats = db.getStatistics();
                    return {
                        success: true,
                        cleanup: {
                            messages_deleted: deletedCount,
                            retention_days: stats.retention_days,
                            remaining_messages: stats.total_messages
                        }
                    };
                }
                case "set_retention": {
                    // Set retention period
                    if (retention_days === undefined || retention_days < 1) {
                        return {
                            success: false,
                            error: "retention_days must be a positive number"
                        };
                    }
                    db.setRetentionDays(retention_days);
                    return {
                        success: true,
                        message: "Retention period updated",
                        retention_days: retention_days
                    };
                }
                default:
                    return {
                        success: false,
                        error: `Unknown action: ${action}. Valid actions are: list, stop, stats, cleanup, set_retention`
                    };
            }
        }
        catch (error) {
            return {
                success: false,
                error: error.message || "Failed to manage subscriptions"
            };
        }
    }
}