meross-cli 0.1.0

package/cli/commands/mqtt.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const chalk = require('chalk');
+
+async function listMqttConnections(manager, options = {}) {
+    const { verbose = false, json = false } = options;
+    const mqttConnections = manager.mqttConnections || {};
+    const domains = Object.keys(mqttConnections);
+
+    if (domains.length === 0) {
+        if (json) {
+            console.log(JSON.stringify({ connections: [] }, null, 2));
+        } else {
+            console.log(chalk.yellow('No MQTT connections found.'));
+        }
+        return;
+    }
+
+    const connectionsData = domains.map(domain => {
+        const conn = mqttConnections[domain];
+        const client = conn?.client;
+
+        let status = 'disconnected';
+        if (client) {
+            if (client.connected) {
+                status = 'connected';
+            } else if (client.reconnecting) {
+                status = 'reconnecting';
+            }
+        }
+
+        const deviceCount = conn?.deviceList?.length || 0;
+        const deviceUuids = conn?.deviceList || [];
+
+        const subscribedTopics = [];
+        if (manager.userId) {
+            subscribedTopics.push(`/app/${manager.userId}/subscribe`);
+        }
+        if (manager.clientResponseTopic) {
+            subscribedTopics.push(manager.clientResponseTopic);
+        }
+
+        const namespaces = new Set();
+        deviceUuids.forEach(uuid => {
+            const device = manager.getDevice(uuid);
+            if (device && device.abilities) {
+                Object.keys(device.abilities).forEach(namespace => {
+                    namespaces.add(namespace);
+                });
+            }
+        });
+        const namespacesList = Array.from(namespaces).sort();
+
+        let clientId = 'N/A';
+        let keepalive = 'N/A';
+        let port = 'N/A';
+        let protocol = 'N/A';
+        let protocolRaw = 'N/A';
+
+        if (client && client.options) {
+            clientId = client.options.clientId || 'N/A';
+            keepalive = client.options.keepalive || 'N/A';
+            port = client.options.port || 'N/A';
+            const protocolValue = client.options.protocol || client.options.protocolId;
+            if (protocolValue) {
+                protocolRaw = protocolValue;
+                protocol = protocolValue === 'mqtts' ? 'MQTTS (TLS)' : protocolValue.toUpperCase();
+            }
+        }
+
+        return {
+            domain,
+            status,
+            deviceCount,
+            deviceUuids,
+            clientId,
+            keepalive,
+            port,
+            protocol: protocolRaw,
+            protocolDisplay: protocol,
+            subscribedTopics,
+            namespaces: namespacesList
+        };
+    });
+
+    if (json) {
+        const jsonData = connectionsData.map(conn => ({
+            domain: conn.domain,
+            status: conn.status,
+            deviceCount: conn.deviceCount,
+            deviceUuids: conn.deviceUuids,
+            clientId: conn.clientId,
+            keepalive: conn.keepalive,
+            port: conn.port,
+            protocol: conn.protocol,
+            subscribedTopics: conn.subscribedTopics,
+            namespaces: conn.namespaces
+        }));
+        console.log(JSON.stringify({ connections: jsonData }, null, 2));
+        return;
+    }
+
+    console.log(`\n${chalk.bold.underline('MQTT Connections')}\n`);
+
+    connectionsData.forEach((conn, index) => {
+        console.log(`  [${index}] ${chalk.bold.underline(conn.domain)}`);
+
+        const statusColor = conn.status === 'connected'
+            ? chalk.green('Connected')
+            : conn.status === 'reconnecting'
+                ? chalk.yellow('Reconnecting')
+                : chalk.red('Disconnected');
+
+        const connectionInfo = [
+            ['Status', statusColor],
+            ['Port', chalk.cyan(conn.port)],
+            ['Protocol', chalk.cyan(conn.protocolDisplay || conn.protocol)],
+            ['Devices', chalk.cyan(conn.deviceCount.toString())]
+        ];
+
+        const maxLabelLength = Math.max(...connectionInfo.map(([label]) => label.length));
+
+        connectionInfo.forEach(([label, value]) => {
+            const padding = ' '.repeat(maxLabelLength - label.length);
+            console.log(`  ${chalk.white.bold(label)}:${padding} ${chalk.italic(value)}`);
+        });
+
+        if (conn.subscribedTopics.length > 0) {
+            console.log(`\n  ${chalk.white.bold(`Subscribed Topics (${chalk.cyan(conn.subscribedTopics.length)}):`)}`);
+            conn.subscribedTopics.forEach(topic => {
+                console.log(`    ${chalk.cyan(topic)}`);
+            });
+        }
+
+        if (conn.namespaces.length > 0) {
+            console.log(`\n  ${chalk.white.bold(`Namespaces (${chalk.cyan(conn.namespaces.length)}):`)}`);
+            if (verbose) {
+                conn.namespaces.forEach(namespace => {
+                    console.log(`    ${chalk.cyan(namespace)}`);
+                });
+            } else {
+                const displayCount = Math.min(5, conn.namespaces.length);
+                conn.namespaces.slice(0, displayCount).forEach(namespace => {
+                    console.log(`    ${chalk.cyan(namespace)}`);
+                });
+                const remainingCount = conn.namespaces.length - displayCount;
+                if (remainingCount > 0) {
+                    console.log(`    ${chalk.gray(`... and ${remainingCount} more (use --verbose to see all)`)}`);
+                }
+            }
+        } else if (conn.deviceCount > 0) {
+            console.log(`\n  ${chalk.gray('Namespaces: No abilities loaded yet')}`);
+        }
+
+        if (verbose) {
+            const clientIdDisplay = conn.clientId !== 'N/A' && conn.clientId.length > 20
+                ? `${conn.clientId.substring(0, 8)}...${conn.clientId.substring(conn.clientId.length - 8)}`
+                : conn.clientId;
+
+            const verboseInfo = [
+                ['Client ID', chalk.cyan(clientIdDisplay)],
+                ['Keepalive', chalk.cyan(`${conn.keepalive}s`)]
+            ];
+
+            verboseInfo.forEach(([label, value]) => {
+                const padding = ' '.repeat(maxLabelLength - label.length);
+                console.log(`  ${chalk.white.bold(label)}:${padding} ${chalk.italic(value)}`);
+            });
+
+            if (conn.deviceUuids.length > 0) {
+                console.log(`\n  ${chalk.white.bold(`Device UUIDs (${chalk.cyan(conn.deviceUuids.length)}):`)}`);
+                conn.deviceUuids.forEach((uuid) => {
+                    const device = manager.getDevice(uuid);
+                    const deviceName = device ? (device.name || 'Unknown') : 'Unknown';
+                    console.log(`    ${chalk.cyan(uuid)} ${chalk.gray(`(${deviceName})`)}`);
+                });
+            }
+        }
+
+        if (index < connectionsData.length - 1) {
+            console.log('');
+        }
+    });
+}
+
+module.exports = { listMqttConnections };
+

package/cli/commands/sniffer/device-sniffer.js

@@ -0,0 +1,217 @@
+'use strict';
+
+const mqtt = require('mqtt');
+const crypto = require('crypto');
+const { buildDeviceRequestTopic } = require('meross-iot/lib/utilities/mqtt');
+const MessageQueue = require('./message-queue');
+
+/**
+ * DeviceSniffer - Impersonates a Meross device to intercept app commands.
+ *
+ * Connects to MQTT broker using device credentials and subscribes to the device's
+ * request topic to capture commands sent from the Meross app.
+ */
+class DeviceSniffer {
+    constructor(options) {
+        const { uuid, macAddress, userId, cloudKey, mqttHost, mqttPort, logger } = options;
+
+        this._uuid = uuid.toLowerCase();
+        this._macAddress = macAddress;
+        this._userId = userId;
+        this._cloudKey = cloudKey;
+        this._mqttHost = mqttHost;
+        this._mqttPort = mqttPort || 2001;
+        this._logger = logger || console.log;
+
+        this._client = null;
+        this._msgQueue = new MessageQueue();
+        this._connected = false;
+        this._subscribed = false;
+        this._deviceTopic = buildDeviceRequestTopic(this._uuid);
+
+        // Build client ID: fmware:{uuid}_random
+        this._clientId = `fmware:${this._uuid}_random`;
+
+        // Build device password: {userId}_{MD5(macAddress + cloudKey).toLowerCase()}
+        const macKeyDigest = crypto.createHash('md5')
+            .update(`${macAddress}${cloudKey}`)
+            .digest('hex')
+            .toLowerCase();
+        this._devicePassword = `${userId}_${macKeyDigest}`;
+    }
+
+    /**
+     * Start the device sniffer and connect to MQTT broker
+     * @param {number} timeout - Connection timeout in milliseconds
+     * @returns {Promise<void>}
+     */
+    async start(timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                if (!this._connected) {
+                    this._client?.end();
+                    reject(new Error('Device sniffer connection timeout'));
+                }
+            }, timeout);
+
+            this._client = mqtt.connect({
+                protocol: 'mqtts',
+                host: this._mqttHost,
+                port: this._mqttPort,
+                clientId: this._clientId,
+                username: this._macAddress,
+                password: this._devicePassword,
+                rejectUnauthorized: true,
+                reconnectPeriod: 0 // Disable auto-reconnect for sniffer
+            });
+
+            this._client.on('connect', (connack) => {
+                this._connected = true;
+                clearTimeout(timeoutId);
+                this._logger(`Device sniffer connected to ${this._mqttHost}:${this._mqttPort}`);
+
+                if (connack && connack.returnCode !== 0) {
+                    const error = new Error(`Connection refused: return code ${connack.returnCode}`);
+                    this._logger(`Connection error: ${error.message}`);
+                    reject(error);
+                    return;
+                }
+
+                // Subscribe to device topic after connection is established
+                // Match Python pattern: subscribe after connect, wait for subscription callback
+                this._logger(`Subscribing to device topic: ${this._deviceTopic}`);
+                this._client.subscribe(this._deviceTopic, (err) => {
+                    if (err) {
+                        const errorMsg = err.message || err.toString() || 'Unknown subscription error';
+                        this._logger(`Warning: Subscription to device topic failed: ${errorMsg}`);
+                        this._logger(`Topic: ${this._deviceTopic}`);
+                        this._logger(`Client ID: ${this._clientId}`);
+                        this._logger(`Username: ${this._macAddress}`);
+                        // In Python, subscription failure doesn't stop the sniffer
+                        // Messages may still be routed automatically based on client ID
+                        this._subscribed = true;
+                        this._logger('Continuing anyway - messages may be routed automatically');
+                        resolve();
+                        return;
+                    }
+                    // Subscription successful - match Python's _on_subscribe behavior
+                    this._subscribed = true;
+                    this._logger(`Subscribed to topic: ${this._deviceTopic}`);
+                    resolve();
+                });
+            });
+
+            // Handle subscription acknowledgments (like Python's on_subscribe)
+            this._client.on('packetsend', (packet) => {
+                if (packet.cmd === 'subscribe') {
+                    this._logger(`Subscription packet sent for topic: ${this._deviceTopic}`);
+                }
+            });
+
+            this._client.on('error', (error) => {
+                clearTimeout(timeoutId);
+                this._logger(`Device sniffer MQTT error: ${error.message}`);
+                if (!this._connected) {
+                    reject(error);
+                }
+            });
+
+            this._client.on('message', (topic, message) => {
+                try {
+                    const parsed = JSON.parse(message.toString());
+                    this._logger(`Device sniffer received message on ${topic}: ${JSON.stringify(parsed)}`);
+                    this._msgQueue.syncPut({ topic, message: message.toString(), parsed });
+                } catch (err) {
+                    this._logger(`Error parsing message: ${err.message}`);
+                }
+            });
+
+            this._client.on('close', () => {
+                this._connected = false;
+                this._subscribed = false;
+                this._logger('Device sniffer disconnected');
+            });
+        });
+    }
+
+    /**
+     * Stop the device sniffer and disconnect from MQTT broker
+     * @returns {Promise<void>}
+     */
+    async stop() {
+        return new Promise((resolve) => {
+            if (!this._client) {
+                resolve();
+                return;
+            }
+
+            // Remove event listeners to prevent memory leaks
+            this._client.removeAllListeners();
+
+            // Set a timeout to force resolve if end() doesn't callback
+            const timeout = setTimeout(() => {
+                this._connected = false;
+                this._subscribed = false;
+                this._client = null;
+                resolve();
+            }, 2000);
+
+            try {
+                this._client.end(false, () => {
+                    clearTimeout(timeout);
+                    this._connected = false;
+                    this._subscribed = false;
+                    this._client = null;
+                    resolve();
+                });
+            } catch (err) {
+                clearTimeout(timeout);
+                this._connected = false;
+                this._subscribed = false;
+                this._client = null;
+                resolve();
+            }
+        });
+    }
+
+    /**
+     * Wait for a message from the device topic
+     * Filters for SET/GET methods only (ignores ACKs and PUSH)
+     * @param {string[]} validMethods - Array of valid methods to accept (default: ['SET', 'GET'])
+     * @returns {Promise<{topic: string, message: string, parsed: Object, namespace: string, method: string, payload: Object}>}
+     */
+    async waitForMessage(validMethods = ['SET', 'GET']) {
+        while (true) {
+            const { topic, message, parsed } = await this._msgQueue.asyncGet();
+
+            if (!parsed || !parsed.header) {
+                continue;
+            }
+
+            const { namespace, method } = parsed.header;
+            const payload = parsed.payload || {};
+
+            // Filter for valid methods only
+            if (validMethods.includes(method)) {
+                return {
+                    topic,
+                    message,
+                    parsed,
+                    namespace,
+                    method,
+                    payload
+                };
+            }
+        }
+    }
+
+    /**
+     * Check if the sniffer is connected
+     * @returns {boolean}
+     */
+    get isConnected() {
+        return this._connected && this._subscribed;
+    }
+}
+
+module.exports = DeviceSniffer;

package/cli/commands/sniffer/fake-app.js

@@ -0,0 +1,233 @@
+'use strict';
+
+const mqtt = require('mqtt');
+const {
+    buildDeviceRequestTopic,
+    buildClientResponseTopic,
+    buildClientUserTopic,
+    generateClientAndAppId,
+    generateMqttPassword
+} = require('meross-iot/lib/utilities/mqtt');
+const MessageQueue = require('./message-queue');
+
+/**
+ * AppSniffer - Impersonates a Meross app client to capture push notifications.
+ *
+ * Connects to MQTT broker using app credentials and subscribes to multiple topics
+ * to capture push notifications and device responses.
+ */
+class AppSniffer {
+    constructor(options) {
+        const { userId, cloudKey, deviceUuid, mqttHost, mqttPort, logger } = options;
+
+        this._userId = userId;
+        this._cloudKey = cloudKey;
+        this._deviceUuid = deviceUuid.toLowerCase();
+        this._mqttHost = mqttHost;
+        this._mqttPort = mqttPort || 2001;
+        this._logger = logger || console.log;
+
+        this._client = null;
+        this._pushQueue = new MessageQueue();
+        this._connected = false;
+        this._subscribed = false;
+
+        // Generate app ID and client ID
+        // Match Python: app_id is "sniffer", client_id is "app:sniffer-{randomHash}"
+        const { clientId } = generateClientAndAppId();
+        this._appId = 'sniffer'; // Fixed app ID like Python version
+        this._clientId = `app:sniffer-${clientId.replace('app:', '')}`;
+
+        // Build topics
+        this._deviceTopic = buildDeviceRequestTopic(this._deviceUuid);
+        this._clientResponseTopic = buildClientResponseTopic(this._userId, this._appId);
+        this._userTopic = buildClientUserTopic(this._userId);
+
+        // Generate MQTT password
+        this._mqttPassword = generateMqttPassword(this._userId, this._cloudKey);
+
+        // Track subscription state
+        this._subscriptionPromise = null;
+        this._subscriptionResolve = null;
+        this._subscriptionReject = null;
+    }
+
+    /**
+     * Subscribe to topics sequentially, waiting for each subscription to complete
+     * Matches Python implementation pattern
+     * @private
+     */
+    _subscribeSequentially(resolve, _reject) {
+        const topics = [
+            { topic: this._deviceTopic, name: 'device' },
+            { topic: this._clientResponseTopic, name: 'client-response' },
+            { topic: this._userTopic, name: 'user' }
+        ];
+
+        let currentIndex = 0;
+
+        const subscribeNext = () => {
+            if (currentIndex >= topics.length) {
+                // All subscriptions completed
+                this._subscribed = true;
+                resolve();
+                return;
+            }
+
+            const { topic, name } = topics[currentIndex];
+            this._logger(`Subscribing to ${name} topic: ${topic}`);
+
+            // Subscribe and wait for acknowledgment
+            this._client.subscribe(topic, (err) => {
+                if (err) {
+                    const errorMsg = err.message || err.toString() || 'Unknown subscription error';
+                    this._logger(`Warning: Subscription to ${name} topic failed: ${errorMsg}`);
+                    this._logger(`Topic: ${topic}`);
+                    // Continue to next subscription even if this one fails
+                    currentIndex++;
+                    setImmediate(() => subscribeNext());
+                    return;
+                }
+                // Success - proceed to next subscription
+                this._logger(`Subscribed to ${name} topic: ${topic}`);
+                currentIndex++;
+                // Wait a tiny bit before next subscription (like Python's event.wait())
+                setImmediate(() => subscribeNext());
+            });
+        };
+
+        // Start sequential subscriptions
+        subscribeNext();
+    }
+
+    /**
+     * Start the app sniffer and connect to MQTT broker
+     * @param {number} timeout - Connection timeout in milliseconds
+     * @returns {Promise<void>}
+     */
+    async start(timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                if (!this._connected) {
+                    this._client?.end();
+                    reject(new Error('App sniffer connection timeout'));
+                }
+            }, timeout);
+
+            this._client = mqtt.connect({
+                protocol: 'mqtts',
+                host: this._mqttHost,
+                port: this._mqttPort,
+                clientId: this._clientId,
+                username: this._userId,
+                password: this._mqttPassword,
+                rejectUnauthorized: true,
+                reconnectPeriod: 0 // Disable auto-reconnect for sniffer
+            });
+
+            this._client.on('connect', (connack) => {
+                this._connected = true;
+                clearTimeout(timeoutId);
+                this._logger(`App sniffer connected to ${this._mqttHost}:${this._mqttPort}`);
+
+                if (connack && connack.returnCode !== 0) {
+                    const error = new Error(`Connection refused: return code ${connack.returnCode}`);
+                    this._logger(`Connection error: ${error.message}`);
+                    reject(error);
+                    return;
+                }
+
+                // Subscribe to topics sequentially, matching Python implementation
+                // Python subscribes one at a time, waiting for each to complete
+                this._subscribeSequentially(resolve, reject);
+            });
+
+            this._client.on('error', (error) => {
+                clearTimeout(timeoutId);
+                this._logger(`App sniffer MQTT error: ${error.message}`);
+                if (!this._connected) {
+                    reject(error);
+                }
+            });
+
+            this._client.on('message', (topic, message) => {
+                try {
+                    const parsed = JSON.parse(message.toString());
+                    const method = parsed.header?.method || 'UNKNOWN';
+
+                    // Only capture PUSH notifications
+                    if (method === 'PUSH') {
+                        this._logger(`App sniffer received PUSH on ${topic}: ${JSON.stringify(parsed)}`);
+                        this._pushQueue.syncPut(parsed);
+                    }
+                } catch (err) {
+                    this._logger(`Error parsing message: ${err.message}`);
+                }
+            });
+
+            this._client.on('close', () => {
+                this._connected = false;
+                this._subscribed = false;
+                this._logger('App sniffer disconnected');
+            });
+        });
+    }
+
+    /**
+     * Stop the app sniffer and disconnect from MQTT broker
+     * @returns {Promise<void>}
+     */
+    async stop() {
+        return new Promise((resolve) => {
+            if (!this._client) {
+                resolve();
+                return;
+            }
+
+            // Remove event listeners to prevent memory leaks
+            this._client.removeAllListeners();
+
+            // Set a timeout to force resolve if end() doesn't callback
+            const timeout = setTimeout(() => {
+                this._connected = false;
+                this._subscribed = false;
+                this._client = null;
+                resolve();
+            }, 2000);
+
+            try {
+                this._client.end(false, () => {
+                    clearTimeout(timeout);
+                    this._connected = false;
+                    this._subscribed = false;
+                    this._client = null;
+                    resolve();
+                });
+            } catch (err) {
+                clearTimeout(timeout);
+                this._connected = false;
+                this._subscribed = false;
+                this._client = null;
+                resolve();
+            }
+        });
+    }
+
+    /**
+     * Wait for a push notification
+     * @returns {Promise<Object>} Parsed push notification message
+     */
+    async waitForPushNotification() {
+        return await this._pushQueue.asyncGet();
+    }
+
+    /**
+     * Check if the sniffer is connected
+     * @returns {boolean}
+     */
+    get isConnected() {
+        return this._connected && this._subscribed;
+    }
+}
+
+module.exports = AppSniffer;

package/cli/commands/sniffer/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { snifferMenu } = require('./sniffer-menu');
+
+module.exports = {
+    snifferMenu
+};