meross-cli 0.1.0

package/cli/commands/control/params/trigger.js

@@ -0,0 +1,206 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { TriggerType, TriggerUtils } = require('meross-iot');
+const { durationToSeconds, secondsToDuration } = TriggerUtils;
+
+/**
+ * Collects parameters for setTriggerX with interactive prompts.
+ */
+async function collectSetTriggerXParams(methodMetadata, device) {
+    const params = {};
+    const channel = methodMetadata.params.find(p => p.name === 'triggerx')?.properties?.find(prop => prop.name === 'channel')?.default || 0;
+
+    // Show existing triggers
+    let hasTriggers = false;
+    try {
+        if (typeof device.getTriggerX === 'function') {
+            console.log(chalk.dim('Fetching existing triggers...'));
+            const response = await device.getTriggerX({ channel });
+            if (response && response.triggerx && Array.isArray(response.triggerx) && response.triggerx.length > 0) {
+                hasTriggers = true;
+                console.log(chalk.cyan(`\nExisting Triggers (Channel ${channel}):`));
+                response.triggerx.forEach((trigger, index) => {
+                    const durationSeconds = trigger.rule?.duration || 0;
+                    const durationStr = secondsToDuration(durationSeconds);
+                    const alias = trigger.alias || `Trigger ${index + 1}`;
+                    const enabled = trigger.enable === 1 ? chalk.green('Enabled') : chalk.red('Disabled');
+                    console.log(chalk.dim(`  [${trigger.id}] ${alias} - ${durationStr} - ${enabled}`));
+                });
+                console.log();
+            }
+        }
+    } catch (e) {
+        // Failed to fetch, continue
+    }
+
+    if (!hasTriggers) {
+        console.log(chalk.yellow('No triggers currently set.\n'));
+    }
+
+    // Collect trigger configuration
+    const aliasAnswer = await inquirer.prompt([{
+        type: 'input',
+        name: 'alias',
+        message: 'Trigger Name',
+        default: 'My Trigger',
+        validate: (value) => {
+            if (!value || value.trim() === '') {
+                return 'Trigger name is required';
+            }
+            return true;
+        }
+    }]);
+
+    const durationAnswer = await inquirer.prompt([{
+        type: 'input',
+        name: 'duration',
+        message: 'Countdown Duration (e.g., "30m", "1h", "600", "30:00")',
+        default: '10m',
+        validate: (value) => {
+            if (!value || value.trim() === '') {
+                return 'Duration is required';
+            }
+            try {
+                durationToSeconds(value.trim());
+                return true;
+            } catch (e) {
+                return e.message;
+            }
+        }
+    }]);
+
+    const typeAnswer = await inquirer.prompt([{
+        type: 'list',
+        name: 'type',
+        message: 'Trigger Type',
+        choices: [
+            { name: 'Single Point Weekly Cycle (repeats every week)', value: TriggerType.SINGLE_POINT_WEEKLY_CYCLE },
+            { name: 'Single Point Single Shot (one time only)', value: TriggerType.SINGLE_POINT_SINGLE_SHOT },
+            { name: 'Continuous Weekly Cycle (active continuously, repeats weekly)', value: TriggerType.CONTINUOUS_WEEKLY_CYCLE },
+            { name: 'Continuous Single Shot (active continuously, one time only)', value: TriggerType.CONTINUOUS_SINGLE_SHOT }
+        ],
+        default: 0
+    }]);
+
+    const daysAnswer = await inquirer.prompt([{
+        type: 'checkbox',
+        name: 'days',
+        message: 'Days of week',
+        choices: [
+            { name: 'Monday', value: 'monday' },
+            { name: 'Tuesday', value: 'tuesday' },
+            { name: 'Wednesday', value: 'wednesday' },
+            { name: 'Thursday', value: 'thursday' },
+            { name: 'Friday', value: 'friday' },
+            { name: 'Saturday', value: 'saturday' },
+            { name: 'Sunday', value: 'sunday' }
+        ],
+        validate: (answer) => {
+            if (answer.length === 0) {
+                return 'Please select at least one day';
+            }
+            return true;
+        }
+    }]);
+
+    const enableAnswer = await inquirer.prompt([{
+        type: 'list',
+        name: 'enabled',
+        message: 'Trigger Status',
+        choices: [
+            { name: 'Enabled', value: true },
+            { name: 'Disabled', value: false }
+        ],
+        default: 0
+    }]);
+
+    // Pass user-friendly format to API (API handles conversion)
+    params.channel = channel;
+    params.alias = aliasAnswer.alias;
+    params.duration = durationAnswer.duration;
+    params.days = daysAnswer.days;
+    params.type = typeAnswer.type;
+    params.enabled = enableAnswer.enabled;
+
+    return params;
+}
+
+/**
+ * Collects parameters for deleteTriggerX with interactive prompts.
+ */
+async function collectDeleteTriggerXParams(methodMetadata, device) {
+    const params = {};
+    const channel = methodMetadata.params.find(p => p.name === 'channel')?.default || 0;
+
+    try {
+        if (typeof device.getTriggerX === 'function') {
+            console.log(chalk.dim('Fetching existing triggers...'));
+            const response = await device.getTriggerX({ channel });
+            if (response && response.triggerx && Array.isArray(response.triggerx) && response.triggerx.length > 0) {
+                const items = response.triggerx;
+                console.log(chalk.cyan(`\nExisting Triggers (Channel ${channel}):`));
+                items.forEach((item, index) => {
+                    const durationSeconds = item.rule?.duration || 0;
+                    const durationStr = secondsToDuration(durationSeconds);
+                    const alias = item.alias || `Trigger ${index + 1}`;
+                    const enabled = item.enable === 1 ? chalk.green('Enabled') : chalk.red('Disabled');
+                    console.log(chalk.dim(`  [${item.id}] ${alias} - ${durationStr} - ${enabled}`));
+                });
+                console.log();
+
+                // Allow selection from list
+                const choices = items.map(item => {
+                    const durationSeconds = item.rule?.duration || 0;
+                    const durationStr = secondsToDuration(durationSeconds);
+                    const alias = item.alias || 'Unnamed Trigger';
+                    return {
+                        name: `${alias} - ${durationStr}`,
+                        value: item.id
+                    };
+                });
+
+                choices.push(new inquirer.Separator());
+                choices.push({
+                    name: 'Enter ID Manually',
+                    value: '__manual__'
+                });
+
+                const selected = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'id',
+                    message: 'Select trigger to delete:',
+                    choices
+                }]);
+
+                if (selected.id === '__manual__') {
+                    const manualAnswer = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'id',
+                        message: 'Trigger ID',
+                        validate: (value) => {
+                            if (!value || value.trim() === '') {
+                                return 'ID is required';
+                            }
+                            return true;
+                        }
+                    }]);
+                    params.triggerId = manualAnswer.id;
+                } else {
+                    params.triggerId = selected.id;
+                }
+
+                params.channel = channel;
+                return params;
+            }
+        }
+    } catch (e) {
+        // Failed to fetch, continue with generic collection
+    }
+
+    return null; // Return null to fall back to generic collection
+}
+
+module.exports = { collectSetTriggerXParams, collectDeleteTriggerXParams };
+

package/cli/commands/dump.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const fs = require('fs');
+
+async function dumpRegistry(manager, filename) {
+    const devices = manager.getAllDevices();
+    const registry = devices.map(device => {
+        return {
+            uuid: device.uuid,
+            devName: device.name,
+            deviceType: device.deviceType,
+            fmwareVersion: device.firmwareVersion,
+            hdwareVersion: device.hardwareVersion,
+            onlineStatus: device.onlineStatus,
+            abilities: device.abilities || null,
+            macAddress: device.macAddress || null,
+            lanIp: device.lanIp || null,
+            mqttHost: device.mqttHost || null,
+            mqttPort: device.mqttPort || null
+        };
+    });
+
+    const output = {
+        timestamp: new Date().toISOString(),
+        deviceCount: devices.length,
+        devices: registry
+    };
+
+    fs.writeFileSync(filename, JSON.stringify(output, null, 2));
+    console.log(`Device registry dumped to ${filename}`);
+    console.log(`Total devices: ${devices.length}`);
+}
+
+module.exports = { dumpRegistry };
+

package/cli/commands/index.js

@@ -0,0 +1,34 @@
+'use strict';
+
+// Export all command handlers
+const { listDevices } = require('./list');
+const { showStats } = require('./stats');
+const { dumpRegistry } = require('./dump');
+const { listMqttConnections } = require('./mqtt');
+const { getDeviceStatus } = require('./status');
+const { showDeviceInfo } = require('./info');
+const { controlDeviceMenu, executeControlCommand, collectControlParameters } = require('./control');
+const { runTestCommand, selectDeviceForTest } = require('./test');
+const { snifferMenu } = require('./sniffer');
+
+// Note: The following large functions still need to be extracted:
+// - menuMode and all menu-related functions
+
+// For now, these will remain in the main CLI file until extracted
+// TODO: Extract remaining command handlers
+
+module.exports = {
+    listDevices,
+    showStats,
+    dumpRegistry,
+    listMqttConnections,
+    getDeviceStatus,
+    showDeviceInfo,
+    controlDeviceMenu,
+    executeControlCommand,
+    collectControlParameters,
+    runTestCommand,
+    selectDeviceForTest,
+    snifferMenu
+};
+

package/cli/commands/info.js

@@ -0,0 +1,221 @@
+'use strict';
+
+const chalk = require('chalk');
+const { OnlineStatus } = require('meross-iot');
+const { getTransportModeName } = require('../helpers/client');
+
+/**
+ * Displays formatted info rows with proper alignment.
+ */
+function _displayInfoRows(infoData, maxLabelLength) {
+    infoData.forEach(([label, value]) => {
+        const padding = ' '.repeat(maxLabelLength - label.length);
+        const displayValue = value === 'Not available' ? chalk.gray.bold(value) : value;
+        console.log(`  ${chalk.white.bold(label)}:${padding} ${chalk.italic(displayValue)}`);
+    });
+}
+
+/**
+ * Builds basic device information array.
+ */
+function _buildBasicDeviceInfo(device, manager) {
+    const info = [
+        ['Name', chalk.bold(device.name || 'Unknown')],
+        ['Type', device.deviceType || 'unknown'],
+        ['UUID', chalk.cyan(device.uuid || 'unknown')],
+        ['Firmware', device.firmwareVersion || 'unknown'],
+        ['Hardware', device.hardwareVersion || 'unknown']
+    ];
+
+    const status = device.deviceConnected ? chalk.green('Yes') : chalk.red('No');
+    const onlineStatus = device.isOnline
+        ? chalk.green('Online')
+        : chalk.red('Offline');
+
+    info.push(['Connected', status]);
+    info.push(['Online', onlineStatus]);
+    info.push(['Transport', getTransportModeName(manager.defaultTransportMode)]);
+
+    return info;
+}
+
+/**
+ * Fetches network info if needed and displays it.
+ */
+async function _displayNetworkInfo(device, maxLabelLength) {
+    // Use device getters for network info (already populated from System.All)
+    const lanIp = device.lanIp;
+    const macAddress = device.macAddress;
+
+    // If not available and device is connected, try to fetch System.All to populate it
+    if (device.deviceConnected && (!lanIp || !macAddress)) {
+        try {
+            await device.getSystemAllData();
+        } catch (error) {
+            // Silently fail - network info is not critical
+        }
+    }
+
+    // Always show network info (use getters again after potential fetch)
+    const networkInfo = [
+        ['IP', device.lanIp || 'Not available'],
+        ['MAC', device.macAddress || 'Not available']
+    ];
+
+    console.log();
+    _displayInfoRows(networkInfo, maxLabelLength);
+}
+
+/**
+ * Displays channel information.
+ */
+function _displayChannels(device) {
+    if (!device.channels || device.channels.length === 0) {
+        return;
+    }
+
+    console.log(`\n${chalk.bold.underline('Channels')}`);
+    console.log(`  Total: ${chalk.cyan(device.channels.length)} channel${device.channels.length !== 1 ? 's' : ''}\n`);
+    device.channels.forEach((channel) => {
+        const channelLabel = channel.isMasterChannel ? 'Master' : `Channel ${channel.index}`;
+        const channelName = channel.name ? ` (${channel.name})` : '';
+        console.log(`  ${chalk.white.bold(channelLabel)}:${channelName} - Index: ${chalk.cyan(channel.index)}`);
+    });
+}
+
+/**
+ * Builds HTTP device info data array.
+ */
+function _buildHttpInfoData(httpInfo) {
+    const httpInfoData = [];
+
+    if (httpInfo.domain) {
+        httpInfoData.push(['MQTT Domain', httpInfo.domain]);
+    }
+    if (httpInfo.reservedDomain) {
+        httpInfoData.push(['Reserved Domain', httpInfo.reservedDomain]);
+    }
+    if (httpInfo.subType) {
+        httpInfoData.push(['Sub Type', httpInfo.subType]);
+    }
+    if (httpInfo.region) {
+        httpInfoData.push(['Region', httpInfo.region]);
+    }
+    if (httpInfo.skillNumber) {
+        httpInfoData.push(['Skill Number', httpInfo.skillNumber]);
+    }
+    if (httpInfo.devIconId) {
+        httpInfoData.push(['Icon ID', httpInfo.devIconId]);
+    }
+    if (httpInfo.bindTime) {
+        httpInfoData.push(['Bind Time', httpInfo.bindTime.toLocaleString()]);
+    }
+    if (httpInfo.onlineStatus !== undefined) {
+        const onlineStatusText = httpInfo.onlineStatus === OnlineStatus.ONLINE ? chalk.green('Online') :
+            httpInfo.onlineStatus === OnlineStatus.OFFLINE ? chalk.red('Offline') :
+                chalk.yellow('Unknown');
+        httpInfoData.push(['Online Status', onlineStatusText]);
+    }
+
+    return httpInfoData;
+}
+
+/**
+ * Displays HTTP device info if available.
+ */
+function _displayHttpInfo(device) {
+    if (!device.cachedHttpInfo) {
+        return;
+    }
+
+    const httpInfo = device.cachedHttpInfo;
+    const httpInfoData = _buildHttpInfoData(httpInfo);
+
+    if (httpInfoData.length === 0) {
+        return;
+    }
+
+    console.log(`\n${chalk.bold.underline('HTTP Device Info')}`);
+    const httpMaxLabelLength = Math.max(...httpInfoData.map(([label]) => label.length));
+    _displayInfoRows(httpInfoData, httpMaxLabelLength);
+}
+
+/**
+ * Builds ability categories grouped by namespace type.
+ */
+function _buildAbilityCategories(abilityNames) {
+    return {
+        'Config': abilityNames.filter(a => a.includes('.Config.')),
+        'System': abilityNames.filter(a => a.includes('.System.')),
+        'Control': abilityNames.filter(a => a.includes('.Control.')),
+        'Digest': abilityNames.filter(a => a.includes('.Digest.')),
+        'Other': abilityNames.filter(a =>
+            !a.includes('.Config.') &&
+            !a.includes('.System.') &&
+            !a.includes('.Control.') &&
+            !a.includes('.Digest.')
+        )
+    };
+}
+
+/**
+ * Displays device capabilities.
+ */
+function _displayCapabilities(device) {
+    if (!device.deviceConnected) {
+        console.log(`\n${chalk.yellow('Device is not connected. Connect to see capabilities.')}`);
+        return;
+    }
+
+    try {
+        const abilities = device.abilities;
+
+        if (!abilities) {
+            return;
+        }
+
+        const abilityNames = Object.keys(abilities);
+        const abilityCount = abilityNames.length;
+        const categories = _buildAbilityCategories(abilityNames);
+
+        console.log(`\n${chalk.bold.underline('Capabilities')}`);
+        console.log(`  Total: ${chalk.cyan(abilityCount)} abilities\n`);
+
+        // Show abilities grouped by category
+        Object.entries(categories).forEach(([category, items]) => {
+            if (items.length > 0) {
+                console.log(`  ${chalk.white.bold(category)}:`);
+                items.forEach(ability => {
+                    console.log(`    - ${ability}`);
+                });
+                console.log();
+            }
+        });
+    } catch (error) {
+        // Silently fail - abilities are not critical
+    }
+}
+
+async function showDeviceInfo(manager, uuid) {
+    const device = manager.getDevice(uuid);
+
+    if (!device) {
+        console.error(`Device with UUID ${chalk.cyan(uuid)} not found.`);
+        process.exit(1);
+    }
+
+    // Format device information nicely
+    console.log(`\n${chalk.bold.underline('Device Information')}\n`);
+
+    const info = _buildBasicDeviceInfo(device, manager);
+    const maxLabelLength = Math.max(...info.map(([label]) => label.length));
+    _displayInfoRows(info, maxLabelLength);
+
+    await _displayNetworkInfo(device, maxLabelLength);
+    _displayChannels(device);
+    _displayHttpInfo(device);
+    _displayCapabilities(device);
+}
+
+module.exports = { showDeviceInfo };
+

package/cli/commands/list.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const { MerossHubDevice, MerossSubDevice, OnlineStatus, parsePushNotification } = require('meross-iot');
+const { formatDevice } = require('../utils/display');
+
+async function listDevices(manager) {
+    const hubs = manager.getAllDevices().filter(device => device instanceof MerossHubDevice);
+    if (hubs.length > 0) {
+        const spinner = ora('Loading devices and refreshing hub status').start();
+        // Refresh hub state to update subdevice online status
+        // This queries the hub for current subdevice status
+        const refreshPromises = hubs
+            .filter(hub => hub.onlineStatus === OnlineStatus.ONLINE)
+            .map(async hub => {
+                try {
+                    // Refresh state (queries sensors/MTS100 which may include online status)
+                    await hub.refreshState().catch(err => {
+                        const logger = manager.options?.logger || console.debug;
+                        logger(`Failed to refresh hub ${hub.uuid}: ${err.message}`);
+                    });
+
+                    // Also explicitly query online status and route to subdevices
+                    // Some hubs (e.g., msh300hk) may not include online status in sensor responses
+                    try {
+                        if (typeof hub.getHubOnline === 'function') {
+                            const onlineResponse = await hub.getHubOnline();
+                            if (onlineResponse && onlineResponse.online) {
+                                // Parse and route the online status notification to subdevices
+                                const notification = parsePushNotification('Appliance.Hub.Online', onlineResponse, hub.uuid);
+                                if (notification && typeof notification.routeToSubdevices === 'function') {
+                                    notification.routeToSubdevices(hub);
+                                }
+                            }
+                        }
+                    } catch (onlineErr) {
+                        // Log but don't fail - online status query might not be supported
+                        const logger = manager.options?.logger || console.debug;
+                        logger(`Failed to query online status for hub ${hub.uuid}: ${onlineErr.message}`);
+                    }
+                } catch (err) {
+                    const logger = manager.options?.logger || console.debug;
+                    logger(`Error refreshing hub ${hub.uuid}: ${err.message}`);
+                }
+            });
+        await Promise.all(refreshPromises);
+        spinner.stop();
+    }
+
+    const allDevices = manager.getAllDevices();
+    const devices = allDevices.filter(device => !(device instanceof MerossSubDevice));
+
+    if (devices.length === 0) {
+        console.log(chalk.yellow('No devices found.'));
+        return;
+    }
+
+    console.log(`\n${chalk.bold.underline('Devices')}\n`);
+    devices.forEach((device, index) => {
+        const info = formatDevice(device);
+
+        console.log(`  [${index}] ${chalk.bold.underline(info.name)}`);
+
+        const deviceInfo = [
+            ['Type', info.type],
+            ['UUID', chalk.cyan(info.uuid)]
+        ];
+
+        if (device.channels && device.channels.length > 0) {
+            deviceInfo.push(['Channels', chalk.cyan(device.channels.length.toString())]);
+        }
+
+        const maxLabelLength = Math.max(...deviceInfo.map(([label]) => label.length));
+
+        deviceInfo.forEach(([label, value]) => {
+            const padding = ' '.repeat(maxLabelLength - label.length);
+            console.log(`  ${chalk.white.bold(label)}:${padding} ${chalk.italic(value)}`);
+        });
+
+        const statusColor = info.status === 'connected' ? chalk.green('Connected') : chalk.red('Disconnected');
+        const onlineColor = info.online === 'online' ? chalk.green('Online') : chalk.red('Offline');
+
+        const fwHwPadding = ' '.repeat(Math.max(0, 'Hardware'.length - 'Firmware'.length));
+        console.log(`  ${chalk.white.bold('Hardware')}: ${chalk.italic(info.hardware)}    ${chalk.white.bold('Firmware')}:${fwHwPadding} ${chalk.italic(info.firmware)}`);
+
+        const statusOnlinePadding = ' '.repeat(Math.max(0, 'Online'.length - 'Status'.length));
+        console.log(`  ${chalk.white.bold('Status')}: ${chalk.italic(statusColor)}  ${chalk.white.bold('Online')}:${statusOnlinePadding} ${chalk.italic(onlineColor)}`);
+
+        if (device instanceof MerossHubDevice) {
+            const subdevices = device.getSubdevices();
+            if (subdevices.length > 0) {
+                console.log(`\n  ${chalk.white.bold(`Subdevices (${chalk.cyan(subdevices.length)}):`)}`);
+                subdevices.forEach((subdevice) => {
+                    const subName = subdevice.name || subdevice.subdeviceId;
+                    const subType = subdevice.type || 'unknown';
+                    const subId = subdevice.subdeviceId;
+                    const subOnline = subdevice.onlineStatus === OnlineStatus.ONLINE ? 'online' : 'offline';
+                    const subOnlineColor = subOnline === 'online' ? chalk.green('Online') : chalk.red('Offline');
+                    console.log(`    ${chalk.bold(subName)} (${subType}) - ID: ${chalk.cyan(subId)} [${subOnlineColor}]`);
+                });
+            } else {
+                console.log(`\n  ${chalk.white.bold('Subdevices: 0')}`);
+            }
+        }
+
+        console.log('');
+    });
+}
+
+module.exports = { listDevices };
+