meross-cli 0.1.0

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

@@ -0,0 +1,188 @@
+'use strict';
+
+const inquirer = require('inquirer');
+
+/**
+ * Validates an RGB color value.
+ */
+function _validateRgb(value) {
+    if (!value || value.trim() === '') {
+        return true; // Optional
+    }
+    const parts = value.split(',');
+    if (parts.length !== 3) {
+        return 'RGB must be in format: r,g,b (e.g., 255,0,0)';
+    }
+    for (const part of parts) {
+        const num = parseInt(part.trim(), 10);
+        if (isNaN(num) || num < 0 || num > 255) {
+            return 'Each RGB value must be between 0 and 255';
+        }
+    }
+    return true;
+}
+
+/**
+ * Builds a channel question for inquirer.
+ */
+function _buildChannelQuestion(channelParam) {
+    return {
+        type: 'number',
+        name: 'channel',
+        message: channelParam.label || 'Channel',
+        default: channelParam.default || 0
+    };
+}
+
+/**
+ * Builds an on/off question for inquirer.
+ */
+function _buildOnOffQuestion(onoffParam) {
+    return {
+        type: 'list',
+        name: 'onoff',
+        message: onoffParam.label || 'Turn On/Off',
+        choices: [
+            { name: 'Skip (no change)', value: undefined },
+            { name: 'On', value: true },
+            { name: 'Off', value: false }
+        ],
+        default: 0, // Default to "Skip"
+        required: false
+    };
+}
+
+/**
+ * Builds an RGB question for inquirer.
+ */
+function _buildRgbQuestion(rgbParam) {
+    return {
+        type: 'input',
+        name: 'rgb',
+        message: rgbParam.label || 'RGB Color (r,g,b)',
+        required: false,
+        validate: _validateRgb,
+        filter: (value) => {
+            if (!value || value.trim() === '') {
+                return undefined;
+            }
+            return value.split(',').map(p => parseInt(p.trim(), 10));
+        }
+    };
+}
+
+/**
+ * Builds a temperature question for inquirer.
+ */
+function _buildTemperatureQuestion(tempParam) {
+    return {
+        type: 'number',
+        name: 'temperature',
+        message: tempParam.label || 'Temperature (0-100)',
+        min: tempParam.min || 0,
+        max: tempParam.max || 100,
+        required: false
+    };
+}
+
+/**
+ * Builds a luminance question for inquirer.
+ */
+function _buildLuminanceQuestion(luminanceParam) {
+    return {
+        type: 'number',
+        name: 'luminance',
+        message: luminanceParam.label || 'Brightness (0-100)',
+        min: luminanceParam.min || 0,
+        max: luminanceParam.max || 100,
+        required: false
+    };
+}
+
+/**
+ * Builds a gradual transition question for inquirer.
+ */
+function _buildGradualQuestion(gradualParam) {
+    return {
+        type: 'list',
+        name: 'gradual',
+        message: gradualParam.label || 'Transition Type',
+        choices: [
+            { name: 'Skip (use default)', value: undefined },
+            { name: 'Gradual (smooth transition)', value: true },
+            { name: 'Instant (immediate change)', value: false }
+        ],
+        default: 0, // Default to "Skip"
+        required: false
+    };
+}
+
+/**
+ * Collects parameters for setLightColor method, filtering options based on device capabilities.
+ * Only shows RGB, temperature, and luminance options if the device actually supports them.
+ */
+async function collectSetLightColorParams(methodMetadata, device) {
+    const params = {};
+    const questions = [];
+
+    if (!methodMetadata || !methodMetadata.params) {
+        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);
+
+    // 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));
+    }
+
+    // RGB parameter (only if device supports it)
+    if (supportsRgb) {
+        const rgbParam = methodMetadata.params.find(p => p.name === 'rgb');
+        if (rgbParam) {
+            questions.push(_buildRgbQuestion(rgbParam));
+        }
+    }
+
+    // Temperature parameter (only if device supports it)
+    if (supportsTemperature) {
+        const tempParam = methodMetadata.params.find(p => p.name === 'temperature');
+        if (tempParam) {
+            questions.push(_buildTemperatureQuestion(tempParam));
+        }
+    }
+
+    // Luminance parameter (only if device supports it)
+    if (supportsLuminance) {
+        const luminanceParam = methodMetadata.params.find(p => p.name === 'luminance');
+        if (luminanceParam) {
+            questions.push(_buildLuminanceQuestion(luminanceParam));
+        }
+    }
+
+    // Gradual parameter (always available as an option)
+    const gradualParam = methodMetadata.params.find(p => p.name === 'gradual');
+    if (gradualParam) {
+        questions.push(_buildGradualQuestion(gradualParam));
+    }
+
+    if (questions.length > 0) {
+        const answers = await inquirer.prompt(questions);
+        Object.assign(params, answers);
+    }
+
+    return params;
+}
+
+module.exports = { collectSetLightColorParams };
+

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

@@ -0,0 +1,166 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { ThermostatMode } = require('meross-iot');
+
+/**
+ * Collects parameters for setThermostatMode with interactive prompts.
+ */
+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') {
+            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];
+                console.log(chalk.cyan('\nCurrent Thermostat State:'));
+                if (currentState.mode !== undefined) {
+                    const modeNames = {
+                        [ThermostatMode.HEAT]: 'Heat',
+                        [ThermostatMode.COOL]: 'Cool',
+                        [ThermostatMode.ECONOMY]: 'Economy',
+                        [ThermostatMode.AUTO]: 'Auto',
+                        [ThermostatMode.MANUAL]: 'Manual'
+                    };
+                    const modeName = modeNames[currentState.mode] || `Mode ${currentState.mode}`;
+                    console.log(chalk.dim(`  Mode: ${modeName}`));
+                }
+                if (currentState.onoff !== undefined) {
+                    console.log(chalk.dim(`  Power: ${currentState.onoff ? 'On' : 'Off'}`));
+                }
+                if (currentState.heatTemp !== undefined) {
+                    console.log(chalk.dim(`  Heat Temp: ${currentState.heatTemp / 10}°C`));
+                }
+                if (currentState.coolTemp !== undefined) {
+                    console.log(chalk.dim(`  Cool Temp: ${currentState.coolTemp / 10}°C`));
+                }
+                if (currentState.ecoTemp !== undefined) {
+                    console.log(chalk.dim(`  Eco Temp: ${currentState.ecoTemp / 10}°C`));
+                }
+                if (currentState.manualTemp !== undefined) {
+                    console.log(chalk.dim(`  Manual Temp: ${currentState.manualTemp / 10}°C`));
+                }
+                console.log();
+            }
+        }
+    } catch (e) {
+        // Failed to fetch, continue without current state
+    }
+
+    // Collect parameters interactively
+    params.channel = channel;
+    params.partialUpdate = true;
+
+    // Ask which fields to update
+    const fieldsToUpdate = await inquirer.prompt([{
+        type: 'checkbox',
+        name: 'fields',
+        message: 'Select fields to update (use space to select, enter to confirm):',
+        choices: [
+            { name: 'Mode (Heat/Cool/Economy/Auto/Manual)', value: 'mode', checked: false },
+            { name: 'Power (On/Off)', value: 'onoff', checked: false },
+            { name: 'Heat Temperature (°C)', value: 'heatTemperature', checked: false },
+            { name: 'Cool Temperature (°C)', value: 'coolTemperature', checked: false },
+            { name: 'Eco Temperature (°C)', value: 'ecoTemperature', checked: false },
+            { name: 'Manual Temperature (°C)', value: 'manualTemperature', checked: false }
+        ],
+        validate: (answer) => {
+            if (answer.length === 0) {
+                return 'Please select at least one field to update';
+            }
+            return true;
+        }
+    }]);
+
+    // Prompt for each selected field
+    for (const field of fieldsToUpdate.fields) {
+        if (field === 'mode') {
+            const answer = await inquirer.prompt([{
+                type: 'list',
+                name: 'mode',
+                message: 'Thermostat Mode',
+                choices: [
+                    { name: 'Heat', value: ThermostatMode.HEAT },
+                    { name: 'Cool', value: ThermostatMode.COOL },
+                    { name: 'Economy', value: ThermostatMode.ECONOMY },
+                    { name: 'Auto', value: ThermostatMode.AUTO },
+                    { name: 'Manual', value: ThermostatMode.MANUAL }
+                ]
+            }]);
+            params.mode = answer.mode;
+        } else if (field === 'onoff') {
+            const answer = await inquirer.prompt([{
+                type: 'list',
+                name: 'onoff',
+                message: 'Power State',
+                choices: [
+                    { name: 'On', value: 1 },
+                    { name: 'Off', value: 0 }
+                ]
+            }]);
+            params.onoff = answer.onoff;
+        } else if (field === 'heatTemperature') {
+            const answer = await inquirer.prompt([{
+                type: 'number',
+                name: 'heatTemperature',
+                message: 'Heat Temperature (°C)',
+                validate: (value) => {
+                    if (value === null || value === undefined) {
+                        return 'Temperature is required';
+                    }
+                    return true;
+                }
+            }]);
+            params.heatTemperature = answer.heatTemperature;
+        } else if (field === 'coolTemperature') {
+            const answer = await inquirer.prompt([{
+                type: 'number',
+                name: 'coolTemperature',
+                message: 'Cool Temperature (°C)',
+                validate: (value) => {
+                    if (value === null || value === undefined) {
+                        return 'Temperature is required';
+                    }
+                    return true;
+                }
+            }]);
+            params.coolTemperature = answer.coolTemperature;
+        } else if (field === 'ecoTemperature') {
+            const answer = await inquirer.prompt([{
+                type: 'number',
+                name: 'ecoTemperature',
+                message: 'Eco Temperature (°C)',
+                validate: (value) => {
+                    if (value === null || value === undefined) {
+                        return 'Temperature is required';
+                    }
+                    return true;
+                }
+            }]);
+            params.ecoTemperature = answer.ecoTemperature;
+        } else if (field === 'manualTemperature') {
+            const answer = await inquirer.prompt([{
+                type: 'number',
+                name: 'manualTemperature',
+                message: 'Manual Temperature (°C)',
+                validate: (value) => {
+                    if (value === null || value === undefined) {
+                        return 'Temperature is required';
+                    }
+                    return true;
+                }
+            }]);
+            params.manualTemperature = answer.manualTemperature;
+        }
+    }
+
+    return params;
+}
+
+module.exports = { collectThermostatModeParams };
+

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

@@ -0,0 +1,242 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { TimerType, TimerUtils } = require('meross-iot');
+const { timeToMinutes } = TimerUtils;
+
+/**
+ * Collects parameters for setTimerX with interactive prompts.
+ */
+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') {
+            console.log(chalk.dim('Fetching existing timers...'));
+            const response = await device.getTimerX({ channel });
+            if (response && response.timerx && Array.isArray(response.timerx) && response.timerx.length > 0) {
+                hasTimers = true;
+                console.log(chalk.cyan(`\nExisting Timers (Channel ${channel}):`));
+                response.timerx.forEach((timer, index) => {
+                    const timeMinutes = timer.time || 0;
+                    const hours = Math.floor(timeMinutes / 60);
+                    const minutes = timeMinutes % 60;
+                    const timeStr = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
+                    const alias = timer.alias || `Timer ${index + 1}`;
+                    const enabled = timer.enable === 1 ? chalk.green('Enabled') : chalk.red('Disabled');
+                    const action = timer.extend?.toggle?.onoff === 1 ? 'ON' : 'OFF';
+                    console.log(chalk.dim(`  [${timer.id}] ${alias} - ${timeStr} (Action: ${action}) - ${enabled}`));
+                });
+                console.log();
+            }
+        }
+    } catch (e) {
+        // Failed to fetch, continue
+    }
+
+    if (!hasTimers) {
+        console.log(chalk.yellow('No timers currently set.\n'));
+    }
+
+    // Collect timer configuration
+    const aliasAnswer = await inquirer.prompt([{
+        type: 'input',
+        name: 'alias',
+        message: 'Timer Name',
+        default: 'My Timer',
+        validate: (value) => {
+            if (!value || value.trim() === '') {
+                return 'Timer name is required';
+            }
+            return true;
+        }
+    }]);
+
+    const actionAnswer = await inquirer.prompt([{
+        type: 'list',
+        name: 'on',
+        message: 'Action when timer triggers',
+        choices: [
+            { name: 'Turn Device ON', value: true },
+            { name: 'Turn Device OFF', value: false }
+        ]
+    }]);
+
+    const typeAnswer = await inquirer.prompt([{
+        type: 'list',
+        name: 'type',
+        message: 'Timer Type',
+        choices: [
+            { name: 'Single Point Weekly Cycle (repeats every week)', value: TimerType.SINGLE_POINT_WEEKLY_CYCLE },
+            { name: 'Single Point Single Shot (one time only)', value: TimerType.SINGLE_POINT_SINGLE_SHOT }
+        ],
+        default: 0
+    }]);
+
+    // Get current time for context
+    let currentTimeStr = '';
+    try {
+        if (typeof device.getSystemTime === 'function') {
+            const timeResponse = await device.getSystemTime();
+            if (timeResponse && timeResponse.time && timeResponse.time.timestamp) {
+                const date = new Date(timeResponse.time.timestamp * 1000);
+                const hours = date.getHours();
+                const minutes = date.getMinutes();
+                currentTimeStr = ` (Device time: ${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')})`;
+            }
+        }
+    } catch (e) {
+        // Failed to get device time
+    }
+    if (!currentTimeStr) {
+        const now = new Date();
+        currentTimeStr = ` (Current time: ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')})`;
+    }
+
+    const timeAnswer = await inquirer.prompt([{
+        type: 'input',
+        name: 'time',
+        message: `Time (HH:MM format, 24-hour)${currentTimeStr}`,
+        validate: (value) => {
+            if (!value || value.trim() === '') {
+                return 'Time is required';
+            }
+            try {
+                timeToMinutes(value.trim());
+                return true;
+            } catch (e) {
+                return e.message;
+            }
+        }
+    }]);
+
+    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: 'Timer 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.time = timeAnswer.time;
+    params.days = daysAnswer.days;
+    params.on = actionAnswer.on;
+    params.type = typeAnswer.type;
+    params.enabled = enableAnswer.enabled;
+
+    return params;
+}
+
+/**
+ * Collects parameters for deleteTimerX with interactive prompts.
+ */
+async function collectDeleteTimerXParams(methodMetadata, device) {
+    const params = {};
+    const channel = methodMetadata.params.find(p => p.name === 'channel')?.default || 0;
+
+    try {
+        if (typeof device.getTimerX === 'function') {
+            console.log(chalk.dim('Fetching existing timers...'));
+            const response = await device.getTimerX({ 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}):`));
+                items.forEach((item, index) => {
+                    const timeMinutes = item.time || 0;
+                    const hours = Math.floor(timeMinutes / 60);
+                    const minutes = timeMinutes % 60;
+                    const timeStr = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
+                    const alias = item.alias || `Timer ${index + 1}`;
+                    const enabled = item.enable === 1 ? chalk.green('Enabled') : chalk.red('Disabled');
+                    const action = item.extend?.toggle?.onoff === 1 ? 'ON' : 'OFF';
+                    console.log(chalk.dim(`  [${item.id}] ${alias} - ${timeStr} (Action: ${action}) - ${enabled}`));
+                });
+                console.log();
+
+                // Allow selection from list
+                const choices = items.map(item => {
+                    const timeMinutes = item.time || 0;
+                    const hours = Math.floor(timeMinutes / 60);
+                    const minutes = timeMinutes % 60;
+                    const timeStr = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
+                    const alias = item.alias || 'Unnamed Timer';
+                    return {
+                        name: `${alias} - ${timeStr}`,
+                        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 timer to delete:',
+                    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;
+            }
+        }
+    } catch (e) {
+        // Failed to fetch, continue with generic collection
+    }
+
+    return null; // Return null to fall back to generic collection
+}
+
+module.exports = { collectSetTimerXParams, collectDeleteTimerXParams };
+