meross-cli 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.5.0] - 2026-01-20
+
+### Changed
+- **BREAKING**: Updated to use feature-based API architecture from `meross-iot` v0.6.0
+  - Updated all commands and helpers to use new feature-based API (`device.feature.method()`)
+  - Updated all test files to use new API structure
+  - Breaking changes include:
+    - `device.setLightColor()` → `device.light.set()`
+    - `device.getLightState()` → `device.light.get()`
+    - Similar changes for all features (toggle, thermostat, etc.)
+
 ## [0.4.0] - 2026-01-19
 
 ### 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.4.0
+npm install -g meross-cli@0.5.0
 ```
 
 Or use via npx:
@@ -55,7 +55,7 @@ meross-cli info <uuid> --email user@example.com --password mypass
 meross-cli status --email user@example.com --password mypass
 
 # Control a device
-meross-cli control <uuid> setToggleX --channel 0 --on
+meross-cli control <uuid> toggle.set --channel 0 --on true
 
 # Start interactive menu mode
 meross-cli
@@ -77,6 +77,17 @@ The CLI supports all devices that are supported by the underlying `meross-iot` l
 
 ## Changelog
 
+### [0.5.0] - 2026-01-20
+
+#### Changed
+- **BREAKING**: Updated to use feature-based API architecture from `meross-iot` v0.6.0
+  - Updated all commands and helpers to use new feature-based API (`device.feature.method()`)
+  - Updated all test files to use new API structure
+  - Breaking changes include:
+    - `device.setLightColor()` → `device.light.set()`
+    - `device.getLightState()` → `device.light.get()`
+    - Similar changes for all features (toggle, thermostat, etc.)
+
 ### [0.4.0] - 2026-01-19
 
 #### Changed
@@ -95,6 +106,21 @@ The CLI supports all devices that are supported by the underlying `meross-iot` l
 <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/execute.js

@@ -2,6 +2,18 @@
 
 const ManagerMeross = require('meross-iot');
 
+/**
+ * Executes a control command using the feature-based API.
+ *
+ * Routes commands to device feature modules based on method name format "feature.action".
+ * This allows dynamic command execution without hardcoding device-specific logic.
+ *
+ * @param {Object} manager - ManagerMeross instance
+ * @param {string} uuid - Device UUID
+ * @param {string} methodName - Method name in format "feature.action" (e.g., "toggle.set", "light.set")
+ * @param {Object} params - Parameters to pass to the feature method
+ * @returns {Promise<*>} Result from the feature method
+ */
 async function executeControlCommand(manager, uuid, methodName, params) {
     const device = manager.devices.get(uuid);
 
@@ -20,17 +32,35 @@ async function executeControlCommand(manager, uuid, methodName, params) {
         );
     }
 
-    if (typeof device[methodName] !== 'function') {
+    const parts = methodName.split('.');
+    if (parts.length !== 2) {
         throw new ManagerMeross.MerossErrorUnsupported(
-            `Control method not available: ${methodName}`,
+            `Invalid method name format: ${methodName}. Expected format: "feature.action" (e.g., "toggle.set")`,
             methodName,
-            'Method not supported by this device'
+            'Method name must be in format: feature.action'
         );
     }
 
-    // All methods now use unified options pattern, so we can call directly with params
-    return await device[methodName](params);
+    const [featureName, action] = parts;
+    const feature = device[featureName];
+
+    if (!feature) {
+        throw new ManagerMeross.MerossErrorUnsupported(
+            `Feature '${featureName}' not available on this device`,
+            methodName,
+            `Device does not support ${featureName} feature`
+        );
+    }
+
+    if (typeof feature[action] !== 'function') {
+        throw new ManagerMeross.MerossErrorUnsupported(
+            `Action '${action}' not available on feature '${featureName}'`,
+            methodName,
+            `Feature ${featureName} does not support ${action} action`
+        );
+    }
+
+    return await feature[action](params);
 }
 
 module.exports = { executeControlCommand };
-

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

@@ -7,48 +7,52 @@ const { collectSetLightColorParams } = require('./light');
 const { collectGenericParams } = require('./generic');
 
 /**
- * Main entry point for collecting control parameters.
- * Routes to feature-specific handlers or falls back to generic collection.
+ * Main entry point for collecting control parameters interactively.
+ *
+ * Routes to feature-specific parameter collection handlers when available, allowing
+ * specialized prompts for complex features. Falls back to generic collection for
+ * simpler methods or when feature-specific handlers are unavailable.
+ *
+ * @param {string} methodName - Control method name (e.g., "toggle.set", "light.set")
+ * @param {Object} methodMetadata - Method metadata from control registry
+ * @param {Object} device - Device instance
+ * @returns {Promise<Object>} Collected parameters object
  */
 async function collectControlParameters(methodName, methodMetadata, device) {
     if (!methodMetadata || !methodMetadata.params) {
         return {};
     }
 
-    // Route to feature-specific handlers
     switch (methodName) {
-    case 'setThermostatMode':
+    case 'thermostat.set':
         return await collectThermostatModeParams(methodMetadata, device);
 
-    case 'setLightColor':
+    case 'light.set':
         return await collectSetLightColorParams(methodMetadata, device);
 
-    case 'setTimerX':
+    case 'timer.set':
         return await collectSetTimerXParams(methodMetadata, device);
 
-    case 'deleteTimerX': {
+    case 'timer.delete': {
         const result = await collectDeleteTimerXParams(methodMetadata, device);
         if (result !== null) {
             return result;
         }
-        // Fall through to generic collection if no timers found
         break;
     }
 
-    case 'setTriggerX':
+    case 'trigger.set':
         return await collectSetTriggerXParams(methodMetadata, device);
 
-    case 'deleteTriggerX': {
+    case 'trigger.delete': {
         const result = await collectDeleteTriggerXParams(methodMetadata, device);
         if (result !== null) {
             return result;
         }
-        // Fall through to generic collection if no triggers found
         break;
     }
     }
 
-    // Default to generic parameter collection
     return await collectGenericParams(methodMetadata);
 }
 

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

@@ -3,7 +3,10 @@
 const inquirer = require('inquirer');
 
 /**
- * Validates an RGB color value.
+ * Validates RGB color input format for inquirer prompts.
+ *
+ * @param {string} value - RGB color string in format "r,g,b"
+ * @returns {boolean|string} True if valid, error message if invalid
  */
 function _validateRgb(value) {
     if (!value || value.trim() === '') {
@@ -23,7 +26,10 @@ function _validateRgb(value) {
 }
 
 /**
- * Builds a channel question for inquirer.
+ * Builds an inquirer question for channel selection.
+ *
+ * @param {Object} channelParam - Channel parameter metadata
+ * @returns {Object} Inquirer question configuration
  */
 function _buildChannelQuestion(channelParam) {
     return {
@@ -35,13 +41,16 @@ function _buildChannelQuestion(channelParam) {
 }
 
 /**
- * Builds an on/off question for inquirer.
+ * Builds an inquirer question for on/off state selection.
+ *
+ * @param {Object} onParam - On/off parameter metadata
+ * @returns {Object} Inquirer question configuration
  */
-function _buildOnOffQuestion(onoffParam) {
+function _buildOnOffQuestion(onParam) {
     return {
         type: 'list',
-        name: 'onoff',
-        message: onoffParam.label || 'Turn On/Off',
+        name: 'on',
+        message: onParam.label || 'Turn On/Off',
         choices: [
             { name: 'Skip (no change)', value: undefined },
             { name: 'On', value: true },
@@ -53,7 +62,10 @@ function _buildOnOffQuestion(onoffParam) {
 }
 
 /**
- * Builds an RGB question for inquirer.
+ * Builds an inquirer question for RGB color input.
+ *
+ * @param {Object} rgbParam - RGB parameter metadata
+ * @returns {Object} Inquirer question configuration
  */
 function _buildRgbQuestion(rgbParam) {
     return {
@@ -72,7 +84,10 @@ function _buildRgbQuestion(rgbParam) {
 }
 
 /**
- * Builds a temperature question for inquirer.
+ * Builds an inquirer question for color temperature input.
+ *
+ * @param {Object} tempParam - Temperature parameter metadata
+ * @returns {Object} Inquirer question configuration
  */
 function _buildTemperatureQuestion(tempParam) {
     return {
@@ -86,7 +101,10 @@ function _buildTemperatureQuestion(tempParam) {
 }
 
 /**
- * Builds a luminance question for inquirer.
+ * Builds an inquirer question for brightness (luminance) input.
+ *
+ * @param {Object} luminanceParam - Luminance parameter metadata
+ * @returns {Object} Inquirer question configuration
  */
 function _buildLuminanceQuestion(luminanceParam) {
     return {
@@ -100,7 +118,10 @@ function _buildLuminanceQuestion(luminanceParam) {
 }
 
 /**
- * Builds a gradual transition question for inquirer.
+ * Builds an inquirer question for transition type selection.
+ *
+ * @param {Object} gradualParam - Gradual parameter metadata
+ * @returns {Object} Inquirer question configuration
  */
 function _buildGradualQuestion(gradualParam) {
     return {
@@ -118,8 +139,14 @@ function _buildGradualQuestion(gradualParam) {
 }
 
 /**
- * Collects parameters for setLightColor method, filtering options based on device capabilities.
- * Only shows RGB, temperature, and luminance options if the device actually supports them.
+ * Collects parameters for light.set method interactively.
+ *
+ * Filters available options based on device capabilities to avoid showing unsupported
+ * features. Only displays RGB, temperature, and luminance options if the device supports them.
+ *
+ * @param {Object} methodMetadata - Method metadata from control registry
+ * @param {Object} device - Device instance
+ * @returns {Promise<Object>} Collected parameters object
  */
 async function collectSetLightColorParams(methodMetadata, device) {
     const params = {};
@@ -129,24 +156,30 @@ async function collectSetLightColorParams(methodMetadata, device) {
         return params;
     }
 
-    // Check device capabilities
-    const supportsRgb = typeof device.getSupportsRgb === 'function' && device.getSupportsRgb(0);
-    const supportsTemperature = typeof device.getSupportsTemperature === 'function' && device.getSupportsTemperature(0);
-    const supportsLuminance = typeof device.getSupportsLuminance === 'function' && device.getSupportsLuminance(0);
+    let supportsRgb = false;
+    let supportsTemperature = false;
+    let supportsLuminance = false;
+    
+    if (device.light && device.abilities && device.abilities['Appliance.Control.Light']) {
+        const lightAbility = device.abilities['Appliance.Control.Light'];
+        if (lightAbility && lightAbility.capacity) {
+            const { LightMode } = require('meross-iot');
+            supportsRgb = (lightAbility.capacity & LightMode.MODE_RGB) === LightMode.MODE_RGB;
+            supportsTemperature = (lightAbility.capacity & LightMode.MODE_TEMPERATURE) === LightMode.MODE_TEMPERATURE;
+            supportsLuminance = (lightAbility.capacity & LightMode.MODE_LUMINANCE) === LightMode.MODE_LUMINANCE;
+        }
+    }
 
-    // Channel parameter (always available)
     const channelParam = methodMetadata.params.find(p => p.name === 'channel');
     if (channelParam) {
         questions.push(_buildChannelQuestion(channelParam));
     }
 
-    // On/Off parameter (always available, but optional)
-    const onoffParam = methodMetadata.params.find(p => p.name === 'onoff');
-    if (onoffParam) {
-        questions.push(_buildOnOffQuestion(onoffParam));
+    const onParam = methodMetadata.params.find(p => p.name === 'on');
+    if (onParam) {
+        questions.push(_buildOnOffQuestion(onParam));
     }
 
-    // RGB parameter (only if device supports it)
     if (supportsRgb) {
         const rgbParam = methodMetadata.params.find(p => p.name === 'rgb');
         if (rgbParam) {
@@ -154,7 +187,6 @@ async function collectSetLightColorParams(methodMetadata, device) {
         }
     }
 
-    // Temperature parameter (only if device supports it)
     if (supportsTemperature) {
         const tempParam = methodMetadata.params.find(p => p.name === 'temperature');
         if (tempParam) {
@@ -162,7 +194,6 @@ async function collectSetLightColorParams(methodMetadata, device) {
         }
     }
 
-    // Luminance parameter (only if device supports it)
     if (supportsLuminance) {
         const luminanceParam = methodMetadata.params.find(p => p.name === 'luminance');
         if (luminanceParam) {
@@ -170,7 +201,6 @@ async function collectSetLightColorParams(methodMetadata, device) {
         }
     }
 
-    // Gradual parameter (always available as an option)
     const gradualParam = methodMetadata.params.find(p => p.name === 'gradual');
     if (gradualParam) {
         questions.push(_buildGradualQuestion(gradualParam));

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

@@ -5,21 +5,26 @@ const inquirer = require('inquirer');
 const { ThermostatMode } = require('meross-iot');
 
 /**
- * Collects parameters for setThermostatMode with interactive prompts.
+ * Collects parameters for thermostat.set interactively.
+ *
+ * Displays current thermostat state to provide context, then prompts for which
+ * fields to update. Supports partial updates to avoid overwriting unchanged values.
+ *
+ * @param {Object} methodMetadata - Method metadata from control registry
+ * @param {Object} device - Device instance
+ * @returns {Promise<Object>} Collected parameters object
  */
 async function collectThermostatModeParams(methodMetadata, device) {
     const params = {};
     const channel = methodMetadata.params.find(p => p.name === 'channel')?.default || 0;
 
-    // Display current state
     try {
-        if (typeof device.getThermostatMode === 'function') {
+        if (device.thermostat) {
             console.log(chalk.dim('Fetching current thermostat state...'));
-            const response = await device.getThermostatMode({ channel });
-            if (response && response.mode && Array.isArray(response.mode) && response.mode.length > 0) {
-                const currentState = response.mode[0];
+            const thermostatState = await device.thermostat.get({ channel });
+            if (thermostatState) {
                 console.log(chalk.cyan('\nCurrent Thermostat State:'));
-                if (currentState.mode !== undefined) {
+                if (thermostatState.mode !== undefined) {
                     const modeNames = {
                         [ThermostatMode.HEAT]: 'Heat',
                         [ThermostatMode.COOL]: 'Cool',
@@ -27,36 +32,34 @@ async function collectThermostatModeParams(methodMetadata, device) {
                         [ThermostatMode.AUTO]: 'Auto',
                         [ThermostatMode.MANUAL]: 'Manual'
                     };
-                    const modeName = modeNames[currentState.mode] || `Mode ${currentState.mode}`;
+                    const modeName = modeNames[thermostatState.mode] || `Mode ${thermostatState.mode}`;
                     console.log(chalk.dim(`  Mode: ${modeName}`));
                 }
-                if (currentState.onoff !== undefined) {
-                    console.log(chalk.dim(`  Power: ${currentState.onoff ? 'On' : 'Off'}`));
+                if (thermostatState.isOn !== undefined) {
+                    console.log(chalk.dim(`  Power: ${thermostatState.isOn ? 'On' : 'Off'}`));
                 }
-                if (currentState.heatTemp !== undefined) {
-                    console.log(chalk.dim(`  Heat Temp: ${currentState.heatTemp / 10}°C`));
+                if (thermostatState.heatTemperatureCelsius !== undefined) {
+                    console.log(chalk.dim(`  Heat Temp: ${thermostatState.heatTemperatureCelsius.toFixed(1)}°C`));
                 }
-                if (currentState.coolTemp !== undefined) {
-                    console.log(chalk.dim(`  Cool Temp: ${currentState.coolTemp / 10}°C`));
+                if (thermostatState.coolTemperatureCelsius !== undefined) {
+                    console.log(chalk.dim(`  Cool Temp: ${thermostatState.coolTemperatureCelsius.toFixed(1)}°C`));
                 }
-                if (currentState.ecoTemp !== undefined) {
-                    console.log(chalk.dim(`  Eco Temp: ${currentState.ecoTemp / 10}°C`));
+                if (thermostatState.ecoTemperatureCelsius !== undefined) {
+                    console.log(chalk.dim(`  Eco Temp: ${thermostatState.ecoTemperatureCelsius.toFixed(1)}°C`));
                 }
-                if (currentState.manualTemp !== undefined) {
-                    console.log(chalk.dim(`  Manual Temp: ${currentState.manualTemp / 10}°C`));
+                if (thermostatState.manualTemperatureCelsius !== undefined) {
+                    console.log(chalk.dim(`  Manual Temp: ${thermostatState.manualTemperatureCelsius.toFixed(1)}°C`));
                 }
                 console.log();
             }
         }
     } catch (e) {
-        // Failed to fetch, continue without current state
+        // Continue without current state if fetch fails
     }
 
-    // Collect parameters interactively
     params.channel = channel;
     params.partialUpdate = true;
 
-    // Ask which fields to update
     const fieldsToUpdate = await inquirer.prompt([{
         type: 'checkbox',
         name: 'fields',
@@ -77,7 +80,6 @@ async function collectThermostatModeParams(methodMetadata, device) {
         }
     }]);
 
-    // Prompt for each selected field
     for (const field of fieldsToUpdate.fields) {
         if (field === 'mode') {
             const answer = await inquirer.prompt([{

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

@@ -6,18 +6,24 @@ const { TimerType, TimerUtils } = require('meross-iot');
 const { timeToMinutes } = TimerUtils;
 
 /**
- * Collects parameters for setTimerX with interactive prompts.
+ * Collects parameters for setTimerX interactively.
+ *
+ * Displays existing timers for context, then prompts for timer configuration.
+ * Uses device time when available to help users set accurate trigger times.
+ *
+ * @param {Object} methodMetadata - Method metadata from control registry
+ * @param {Object} device - Device instance
+ * @returns {Promise<Object>} Collected parameters object
  */
 async function collectSetTimerXParams(methodMetadata, device) {
     const params = {};
     const channel = methodMetadata.params.find(p => p.name === 'timerx')?.properties?.find(prop => prop.name === 'channel')?.default || 0;
 
-    // Show existing timers
     let hasTimers = false;
     try {
-        if (typeof device.getTimerX === 'function') {
+        if (device.timer && typeof device.timer.get === 'function') {
             console.log(chalk.dim('Fetching existing timers...'));
-            const response = await device.getTimerX({ channel });
+            const response = await device.timer.get({ channel });
             if (response && response.timerx && Array.isArray(response.timerx) && response.timerx.length > 0) {
                 hasTimers = true;
                 console.log(chalk.cyan(`\nExisting Timers (Channel ${channel}):`));
@@ -35,7 +41,7 @@ async function collectSetTimerXParams(methodMetadata, device) {
             }
         }
     } catch (e) {
-        // Failed to fetch, continue
+        // Continue without existing timers if fetch fails
     }
 
     if (!hasTimers) {
@@ -77,11 +83,10 @@ async function collectSetTimerXParams(methodMetadata, device) {
         default: 0
     }]);
 
-    // Get current time for context
     let currentTimeStr = '';
     try {
-        if (typeof device.getSystemTime === 'function') {
-            const timeResponse = await device.getSystemTime();
+        if (device.system && typeof device.system.getTime === 'function') {
+            const timeResponse = await device.system.getTime();
             if (timeResponse && timeResponse.time && timeResponse.time.timestamp) {
                 const date = new Date(timeResponse.time.timestamp * 1000);
                 const hours = date.getHours();
@@ -90,7 +95,7 @@ async function collectSetTimerXParams(methodMetadata, device) {
             }
         }
     } catch (e) {
-        // Failed to get device time
+        // Fall back to system time if device time unavailable
     }
     if (!currentTimeStr) {
         const now = new Date();
@@ -146,7 +151,6 @@ async function collectSetTimerXParams(methodMetadata, device) {
         default: 0
     }]);
 
-    // Pass user-friendly format to API (API handles conversion)
     params.channel = channel;
     params.alias = aliasAnswer.alias;
     params.time = timeAnswer.time;
@@ -166,9 +170,9 @@ async function collectDeleteTimerXParams(methodMetadata, device) {
     const channel = methodMetadata.params.find(p => p.name === 'channel')?.default || 0;
 
     try {
-        if (typeof device.getTimerX === 'function') {
+        if (device.timer && typeof device.timer.get === 'function') {
             console.log(chalk.dim('Fetching existing timers...'));
-            const response = await device.getTimerX({ channel });
+            const response = await device.timer.get({ channel });
             if (response && response.timerx && Array.isArray(response.timerx) && response.timerx.length > 0) {
                 const items = response.timerx;
                 console.log(chalk.cyan(`\nExisting Timers (Channel ${channel}):`));
@@ -184,7 +188,6 @@ async function collectDeleteTimerXParams(methodMetadata, device) {
                 });
                 console.log();
 
-                // Allow selection from list
                 const choices = items.map(item => {
                     const timeMinutes = item.time || 0;
                     const hours = Math.floor(timeMinutes / 60);
@@ -232,10 +235,10 @@ async function collectDeleteTimerXParams(methodMetadata, device) {
             }
         }
     } catch (e) {
-        // Failed to fetch, continue with generic collection
+        // Fall back to generic collection if fetch fails
     }
 
-    return null; // Return null to fall back to generic collection
+    return null;
 }
 
 module.exports = { collectSetTimerXParams, collectDeleteTimerXParams };

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

@@ -6,18 +6,24 @@ const { TriggerType, TriggerUtils } = require('meross-iot');
 const { durationToSeconds, secondsToDuration } = TriggerUtils;
 
 /**
- * Collects parameters for setTriggerX with interactive prompts.
+ * Collects parameters for setTriggerX interactively.
+ *
+ * Displays existing triggers for context, then prompts for trigger configuration.
+ * Supports multiple trigger types and flexible duration formats.
+ *
+ * @param {Object} methodMetadata - Method metadata from control registry
+ * @param {Object} device - Device instance
+ * @returns {Promise<Object>} Collected parameters object
  */
 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') {
+        if (device.trigger && typeof device.trigger.get === 'function') {
             console.log(chalk.dim('Fetching existing triggers...'));
-            const response = await device.getTriggerX({ channel });
+            const response = await device.trigger.get({ channel });
             if (response && response.triggerx && Array.isArray(response.triggerx) && response.triggerx.length > 0) {
                 hasTriggers = true;
                 console.log(chalk.cyan(`\nExisting Triggers (Channel ${channel}):`));
@@ -32,14 +38,13 @@ async function collectSetTriggerXParams(methodMetadata, device) {
             }
         }
     } catch (e) {
-        // Failed to fetch, continue
+        // Continue without existing triggers if fetch fails
     }
 
     if (!hasTriggers) {
         console.log(chalk.yellow('No triggers currently set.\n'));
     }
 
-    // Collect trigger configuration
     const aliasAnswer = await inquirer.prompt([{
         type: 'input',
         name: 'alias',
@@ -116,7 +121,6 @@ async function collectSetTriggerXParams(methodMetadata, device) {
         default: 0
     }]);
 
-    // Pass user-friendly format to API (API handles conversion)
     params.channel = channel;
     params.alias = aliasAnswer.alias;
     params.duration = durationAnswer.duration;
@@ -128,16 +132,24 @@ async function collectSetTriggerXParams(methodMetadata, device) {
 }
 
 /**
- * Collects parameters for deleteTriggerX with interactive prompts.
+ * Collects parameters for deleteTriggerX 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
+ * no triggers are available.
+ *
+ * @param {Object} methodMetadata - Method metadata from control registry
+ * @param {Object} device - Device instance
+ * @returns {Promise<Object|null>} Collected parameters object, or null to use generic collection
  */
 async function collectDeleteTriggerXParams(methodMetadata, device) {
     const params = {};
     const channel = methodMetadata.params.find(p => p.name === 'channel')?.default || 0;
 
     try {
-        if (typeof device.getTriggerX === 'function') {
+        if (device.trigger && typeof device.trigger.get === 'function') {
             console.log(chalk.dim('Fetching existing triggers...'));
-            const response = await device.getTriggerX({ channel });
+            const response = await device.trigger.get({ 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}):`));
@@ -150,7 +162,6 @@ async function collectDeleteTriggerXParams(methodMetadata, device) {
                 });
                 console.log();
 
-                // Allow selection from list
                 const choices = items.map(item => {
                     const durationSeconds = item.rule?.duration || 0;
                     const durationStr = secondsToDuration(durationSeconds);
@@ -196,10 +207,10 @@ async function collectDeleteTriggerXParams(methodMetadata, device) {
             }
         }
     } catch (e) {
-        // Failed to fetch, continue with generic collection
+        // Fall back to generic collection if fetch fails
     }
 
-    return null; // Return null to fall back to generic collection
+    return null;
 }
 
 module.exports = { collectSetTriggerXParams, collectDeleteTriggerXParams };