meross-cli 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0] - 2026-01-20
+
+### Added
+- Enhanced `info` command with normalized capabilities display
+  - Displays user-friendly device capabilities using the new `device.capabilities` map
+  - Shows channel information and supported features in an organized format
+  - Verbose mode support for displaying raw abilities (namespaces) when `MEROSS_VERBOSE=true` is set
+
 ## [0.5.0] - 2026-01-20
 
 ### Changed

package/README.md

@@ -23,7 +23,7 @@ Command-line interface for controlling and managing Meross smart home devices.
 npm install -g meross-cli@alpha
 
 # Or install specific version
-npm install -g meross-cli@0.5.0
+npm install -g meross-cli@0.6.0
 ```
 
 Or use via npx:
@@ -77,6 +77,17 @@ The CLI supports all devices that are supported by the underlying `meross-iot` l
 
 ## Changelog
 
+### [0.6.0] - 2026-01-20
+
+#### Added
+- Enhanced `info` command with normalized capabilities display
+  - Displays user-friendly device capabilities using the new `device.capabilities` map
+  - Shows channel information and supported features in an organized format
+  - Verbose mode support for displaying raw abilities (namespaces) when `MEROSS_VERBOSE=true` is set
+
+<details>
+<summary>Older</summary>
+
 ### [0.5.0] - 2026-01-20
 
 #### Changed
@@ -103,24 +114,6 @@ The CLI supports all devices that are supported by the underlying `meross-iot` l
 - Centralized error handler utility (`cli/utils/error-handler.js`) with formatted error messages
 - Enhanced error display with better context and user-friendly formatting
 
-<details>
-<summary>Older</summary>
-
-### [0.4.0] - 2026-01-19
-
-#### Changed
-- **BREAKING**: Updated to use new manager module structure from `meross-iot` v0.5.0
-  - Updated to use manager properties (`manager.devices`, `manager.mqtt`, `manager.http`, etc.) instead of direct methods
-  - Updated all commands and helpers to use new property-based access patterns
-- **BREAKING**: Updated to use standardized error handling from `meross-iot` v0.5.0
-  - Updated to use new `MerossError*` error class names
-  - Replaced inline error handling with centralized `handleError()` function
-  - All error handling now uses the new error handler utility for consistent, user-friendly formatted messages
-
-#### Added
-- Centralized error handler utility (`cli/utils/error-handler.js`) with formatted error messages
-- Enhanced error display with better context and user-friendly formatting
-
 ### [0.3.0] - 2026-01-16
 
 #### Changed

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

@@ -163,7 +163,7 @@ async function collectSetTimerXParams(methodMetadata, device) {
 }
 
 /**
- * Collects parameters for deleteTimerX with interactive prompts.
+ * Collects parameters for timer.delete with interactive prompts.
  */
 async function collectDeleteTimerXParams(methodMetadata, device) {
     const params = {};
@@ -171,10 +171,15 @@ async function collectDeleteTimerXParams(methodMetadata, device) {
 
     try {
         if (device.timer && typeof device.timer.get === 'function') {
+            // Clear cache to force fresh fetch after potential deletions
+            if (device._timerxStateByChannel) {
+                device._timerxStateByChannel.delete(channel);
+            }
             console.log(chalk.dim('Fetching existing timers...'));
             const response = await device.timer.get({ channel });
-            if (response && response.timerx && Array.isArray(response.timerx) && response.timerx.length > 0) {
-                const items = response.timerx;
+            const items = response && response.timerx && Array.isArray(response.timerx) ? response.timerx : [];
+            
+            if (items.length > 0) {
                 console.log(chalk.cyan(`\nExisting Timers (Channel ${channel}):`));
                 items.forEach((item, index) => {
                     const timeMinutes = item.time || 0;
@@ -200,12 +205,6 @@ async function collectDeleteTimerXParams(methodMetadata, device) {
                     };
                 });
 
-                choices.push(new inquirer.Separator());
-                choices.push({
-                    name: 'Enter ID Manually',
-                    value: '__manual__'
-                });
-
                 const selected = await inquirer.prompt([{
                     type: 'list',
                     name: 'id',
@@ -213,31 +212,24 @@ async function collectDeleteTimerXParams(methodMetadata, device) {
                     choices
                 }]);
 
-                if (selected.id === '__manual__') {
-                    const manualAnswer = await inquirer.prompt([{
-                        type: 'input',
-                        name: 'id',
-                        message: 'Timer ID',
-                        validate: (value) => {
-                            if (!value || value.trim() === '') {
-                                return 'ID is required';
-                            }
-                            return true;
-                        }
-                    }]);
-                    params.timerId = manualAnswer.id;
-                } else {
-                    params.timerId = selected.id;
-                }
-
-                params.channel = channel;
-                return params;
+                params.timerId = selected.id;
+            } else {
+                throw new Error(`No timers found on channel ${channel}. Nothing to delete.`);
             }
+
+            params.channel = channel;
+            return params;
         }
     } catch (e) {
-        // Fall back to generic collection if fetch fails
+        // If it's our "no timers" error, re-throw it
+        if (e.message && e.message.includes('No timers found')) {
+            throw e;
+        }
+        // If fetch fails, throw error
+        throw new Error('Unable to fetch timers from device. Please try again.');
     }
 
+    // Fallback if timer feature is not available
     return null;
 }
 

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

@@ -132,7 +132,7 @@ async function collectSetTriggerXParams(methodMetadata, device) {
 }
 
 /**
- * Collects parameters for deleteTriggerX interactively.
+ * Collects parameters for trigger.delete interactively.
  *
  * Displays existing triggers and allows selection from a list, or manual ID entry
  * if no triggers are found. Returns null to fall back to generic collection when
@@ -148,10 +148,15 @@ async function collectDeleteTriggerXParams(methodMetadata, device) {
 
     try {
         if (device.trigger && typeof device.trigger.get === 'function') {
+            // Clear cache to force fresh fetch after potential deletions
+            if (device._triggerxStateByChannel) {
+                device._triggerxStateByChannel.delete(channel);
+            }
             console.log(chalk.dim('Fetching existing triggers...'));
             const response = await device.trigger.get({ channel });
-            if (response && response.triggerx && Array.isArray(response.triggerx) && response.triggerx.length > 0) {
-                const items = response.triggerx;
+            const items = response && response.triggerx && Array.isArray(response.triggerx) ? response.triggerx : [];
+            
+            if (items.length > 0) {
                 console.log(chalk.cyan(`\nExisting Triggers (Channel ${channel}):`));
                 items.forEach((item, index) => {
                     const durationSeconds = item.rule?.duration || 0;
@@ -172,12 +177,6 @@ async function collectDeleteTriggerXParams(methodMetadata, device) {
                     };
                 });
 
-                choices.push(new inquirer.Separator());
-                choices.push({
-                    name: 'Enter ID Manually',
-                    value: '__manual__'
-                });
-
                 const selected = await inquirer.prompt([{
                     type: 'list',
                     name: 'id',
@@ -185,31 +184,24 @@ async function collectDeleteTriggerXParams(methodMetadata, device) {
                     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;
+                params.triggerId = selected.id;
+            } else {
+                throw new Error(`No triggers found on channel ${channel}. Nothing to delete.`);
             }
+
+            params.channel = channel;
+            return params;
         }
     } catch (e) {
-        // Fall back to generic collection if fetch fails
+        // If it's our "no triggers" error, re-throw it
+        if (e.message && e.message.includes('No triggers found')) {
+            throw e;
+        }
+        // If fetch fails, throw error
+        throw new Error('Unable to fetch triggers from device. Please try again.');
     }
 
+    // Fallback if trigger feature is not available
     return null;
 }
 

package/cli/commands/info.js

@@ -177,13 +177,21 @@ function _buildAbilityCategories(abilityNames) {
 }
 
 /**
- * Displays device capabilities grouped by category.
+ * Displays device abilities (raw namespace list) when verbose mode is enabled.
  *
  * @param {Object} device - Device instance
+ * @param {Object} manager - ManagerMeross instance (to check verbose state)
  */
-function _displayCapabilities(device) {
+function _displayAbilities(device, manager) {
+    // Check verbose mode via environment variable or manager logger option
+    const isVerbose = process.env.MEROSS_VERBOSE === 'true' ||
+        (manager && manager.options && manager.options.logger !== null);
+    
+    if (!isVerbose) {
+        return;
+    }
+
     if (!device.deviceConnected) {
-        console.log(`\n${chalk.yellow('Device is not connected. Connect to see capabilities.')}`);
         return;
     }
 
@@ -198,7 +206,7 @@ function _displayCapabilities(device) {
         const abilityCount = abilityNames.length;
         const categories = _buildAbilityCategories(abilityNames);
 
-        console.log(`\n${chalk.bold.underline('Capabilities')}`);
+        console.log(`\n${chalk.bold.underline('Abilities (Raw Namespaces)')}`);
         console.log(`  Total: ${chalk.cyan(abilityCount)} abilities\n`);
 
         Object.entries(categories).forEach(([category, items]) => {
@@ -215,6 +223,173 @@ function _displayCapabilities(device) {
     }
 }
 
+/**
+ * Displays device capabilities using the normalized capabilities map.
+ *
+ * @param {Object} device - Device instance
+ */
+function _displayCapabilities(device) {
+    if (!device.deviceConnected) {
+        console.log(`\n${chalk.yellow('Device is not connected. Connect to see capabilities.')}`);
+        return;
+    }
+
+    try {
+        const capabilities = device.capabilities;
+
+        if (!capabilities) {
+            console.log(`\n${chalk.yellow('Capabilities not yet available. Device may need to connect first.')}`);
+            return;
+        }
+
+        console.log(`\n${chalk.bold.underline('Capabilities')}`);
+
+        // Display channel information
+        if (capabilities.channels) {
+            console.log(`\n  ${chalk.white.bold('Channels')}:`);
+            console.log(`    Count: ${chalk.cyan(capabilities.channels.count)}`);
+            console.log(`    IDs: ${chalk.cyan(capabilities.channels.ids.join(', '))}`);
+        }
+
+        // Display feature capabilities
+        const featureKeys = Object.keys(capabilities).filter(key => key !== 'channels');
+        if (featureKeys.length > 0) {
+            console.log(`\n  ${chalk.white.bold('Features')}:`);
+            featureKeys.forEach(featureKey => {
+                const feature = capabilities[featureKey];
+                if (feature && feature.supported) {
+                    let featureInfo = `    ${chalk.green('✓')} ${chalk.bold(featureKey)}`;
+                    if (feature.channels) {
+                        featureInfo += ` (channels: ${chalk.cyan(feature.channels.join(', '))})`;
+                    }
+                    if (feature.multiChannel) {
+                        featureInfo += ` ${chalk.gray('[multi-channel]')}`;
+                    }
+                    if (feature.rgb || feature.luminance || feature.temperature) {
+                        const lightFeatures = [];
+                        if (feature.rgb) {lightFeatures.push('RGB');}
+                        if (feature.luminance) {lightFeatures.push('brightness');}
+                        if (feature.temperature) {lightFeatures.push('temperature');}
+                        featureInfo += ` ${chalk.gray(`[${lightFeatures.join(', ')}]`)}`;
+                    }
+                    if (featureKey === 'thermostat') {
+                        const thermostatFeatures = [];
+                        if (feature.modeB) {thermostatFeatures.push('ModeB');}
+                        if (feature.schedule) {thermostatFeatures.push('schedule');}
+                        if (feature.windowOpened) {thermostatFeatures.push('window detection');}
+                        if (feature.sensor) {thermostatFeatures.push('sensor selection');}
+                        if (feature.summerMode) {thermostatFeatures.push('summer mode');}
+                        if (feature.holdAction) {thermostatFeatures.push('hold action');}
+                        if (feature.calibration) {thermostatFeatures.push('calibration');}
+                        if (feature.deadZone) {thermostatFeatures.push('dead zone');}
+                        if (feature.frost) {thermostatFeatures.push('frost protection');}
+                        if (feature.overheat) {thermostatFeatures.push('overheat protection');}
+                        if (thermostatFeatures.length > 0) {
+                            featureInfo += ` ${chalk.gray(`[${thermostatFeatures.join(', ')}]`)}`;
+                        }
+                    }
+                    if (feature.light !== undefined || feature.spray !== undefined) {
+                        const diffuserFeatures = [];
+                        if (feature.light) {diffuserFeatures.push('light');}
+                        if (feature.spray) {diffuserFeatures.push('spray');}
+                        featureInfo += ` ${chalk.gray(`[${diffuserFeatures.join(', ')}]`)}`;
+                    }
+                    if (feature.multiple || feature.upgrade) {
+                        const controlFeatures = [];
+                        if (feature.multiple) {controlFeatures.push('batch');}
+                        if (feature.upgrade) {controlFeatures.push('upgrade');}
+                        featureInfo += ` ${chalk.gray(`[${controlFeatures.join(', ')}]`)}`;
+                    }
+                    if (feature.subDeviceList || feature.battery) {
+                        const hubFeatures = [];
+                        if (feature.subDeviceList) {hubFeatures.push('subdevices');}
+                        if (feature.battery) {hubFeatures.push('battery');}
+                        featureInfo += ` ${chalk.gray(`[${hubFeatures.join(', ')}]`)}`;
+                    }
+                    if (featureKey === 'presence' && (feature.presenceEvents !== undefined || feature.lux !== undefined || feature.distance !== undefined)) {
+                        const presenceFeatures = [];
+                        if (feature.presenceEvents) {presenceFeatures.push('presence events');}
+                        if (feature.lux) {presenceFeatures.push('LUX');}
+                        if (feature.distance) {presenceFeatures.push('distance');}
+                        featureInfo += ` ${chalk.gray(`[${presenceFeatures.join(', ')}]`)}`;
+                    }
+                    if (featureKey === 'sensor' && (feature.temperature !== undefined || feature.humidity !== undefined || feature.lux !== undefined || feature.waterLeak !== undefined || feature.smoke !== undefined)) {
+                        const sensorFeatures = [];
+                        if (feature.temperature) {sensorFeatures.push('temperature');}
+                        if (feature.humidity) {sensorFeatures.push('humidity');}
+                        if (feature.lux) {sensorFeatures.push('LUX');}
+                        if (feature.waterLeak) {sensorFeatures.push('water leak');}
+                        if (feature.smoke) {sensorFeatures.push('smoke');}
+                        featureInfo += ` ${chalk.gray(`[${sensorFeatures.join(', ')}]`)}`;
+                    }
+                    console.log(featureInfo);
+                }
+            });
+        } else {
+            console.log(`\n  ${chalk.gray('No features detected')}`);
+        }
+    } catch (error) {
+        // Capabilities display is optional, continue without it
+    }
+}
+
+/**
+ * Displays subdevice information for hub devices.
+ *
+ * @param {Object} device - Device instance (should be a hub)
+ */
+async function _displaySubdevices(device) {
+    // Check if device is a hub and has getSubdevices method
+    if (!device || typeof device.getSubdevices !== 'function') {
+        return;
+    }
+
+    const subdevices = device.getSubdevices();
+    if (!subdevices || subdevices.length === 0) {
+        return;
+    }
+
+    console.log(`\n${chalk.bold.underline('Subdevices')}`);
+    console.log(`  Total: ${chalk.cyan(subdevices.length)} subdevice${subdevices.length !== 1 ? 's' : ''}\n`);
+
+    for (const subdevice of subdevices) {
+        console.log(`  ${chalk.white.bold(subdevice.name || subdevice.subdeviceId)}`);
+        console.log(`    Type: ${chalk.cyan(subdevice.type || 'unknown')}`);
+        console.log(`    ID: ${chalk.cyan(subdevice.subdeviceId)}`);
+
+        // Display subdevice capabilities if available
+        if (subdevice.capabilities) {
+            const subCaps = subdevice.capabilities;
+            const subFeatureKeys = Object.keys(subCaps).filter(key => key !== 'channels');
+            if (subFeatureKeys.length > 0) {
+                const subFeatures = [];
+                subFeatureKeys.forEach(featureKey => {
+                    const feature = subCaps[featureKey];
+                    if (feature && feature.supported) {
+                        if (featureKey === 'sensor') {
+                            const sensorTypes = [];
+                            if (feature.temperature) {sensorTypes.push('temperature');}
+                            if (feature.humidity) {sensorTypes.push('humidity');}
+                            if (feature.lux) {sensorTypes.push('LUX');}
+                            if (feature.waterLeak) {sensorTypes.push('water leak');}
+                            if (feature.smoke) {sensorTypes.push('smoke');}
+                            if (sensorTypes.length > 0) {
+                                subFeatures.push(`sensor [${sensorTypes.join(', ')}]`);
+                            }
+                        } else {
+                            subFeatures.push(featureKey);
+                        }
+                    }
+                });
+                if (subFeatures.length > 0) {
+                    console.log(`    Capabilities: ${chalk.gray(subFeatures.join(', '))}`);
+                }
+            }
+        }
+        console.log();
+    }
+}
+
 /**
  * Displays comprehensive device information.
  *
@@ -242,6 +417,8 @@ async function showDeviceInfo(manager, uuid) {
     _displayChannels(device);
     _displayHttpInfo(device);
     _displayCapabilities(device);
+    _displayAbilities(device, manager);
+    await _displaySubdevices(device);
 }
 
 module.exports = { showDeviceInfo };

package/cli/tests/test-timer.js

@@ -181,7 +181,7 @@ async function runTests(context) {
             
             let deleteResponse;
             try {
-                deleteResponse = await testDevice.deleteTimerX({ timerId: createdTimerId, channel: 0 });
+                deleteResponse = await testDevice.timer.delete({ timerId: createdTimerId, channel: 0 });
             } catch (deleteError) {
                 results.push({
                     name: 'should delete timer',

package/cli/tests/test-trigger.js

@@ -176,7 +176,7 @@ async function runTests(context) {
     // Test 2: Delete the trigger
     if (createdTriggerId) {
         try {
-            const deleteResponse = await testDevice.deleteTriggerX(createdTriggerId, 0);
+            const deleteResponse = await testDevice.trigger.delete({ triggerId: createdTriggerId, channel: 0 });
             
             // Check what the DELETE response contains
             const deleteResponseError = deleteResponse?.error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meross-cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Command-line interface for controlling Meross smart home devices",
   "author": "Abe Haverkamp",
   "homepage": "https://github.com/Doekse/merossiot#readme",
@@ -24,7 +24,7 @@
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
     "inquirer": "^8.2.6",
-    "meross-iot": "^0.6.0",
+    "meross-iot": "^0.7.0",
     "ora": "^5.4.1"
   },
   "devDependencies": {