meross-cli 0.3.0 → 0.5.0

package/cli/tests/test-toggle.js

@@ -87,22 +87,19 @@ async function runTests(context) {
     
     // Test 2: Get toggle state
     try {
-        if (typeof testDevice.getToggleState === 'function') {
-            const toggleState = await testDevice.getToggleState(0);
+        if (testDevice.toggle) {
+            const toggleState = await testDevice.toggle.get({ channel: 0 });
+            const isOn = testDevice.toggle.isOn({ channel: 0 });
             
             if (!toggleState) {
                 results.push({
                     name: 'should get toggle state',
                     passed: false,
                     skipped: false,
-                    error: 'getToggleState returned null or undefined',
+                    error: 'toggle.get() returned null or undefined',
                     device: deviceName
                 });
             } else {
-                // Check cached toggle state
-                const cachedState = testDevice.getCachedToggleState(0);
-                const isOn = testDevice.isOn(0);
-                
                 results.push({
                     name: 'should get toggle state',
                     passed: true,
@@ -111,7 +108,6 @@ async function runTests(context) {
                     device: deviceName,
                     details: {
                         toggleState: toggleState,
-                        cachedState: cachedState,
                         isOn: isOn
                     }
                 });
@@ -121,7 +117,7 @@ async function runTests(context) {
                 name: 'should get toggle state',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support getToggleState',
+                error: 'Device does not support toggle feature',
                 device: deviceName
             });
         }
@@ -137,141 +133,69 @@ async function runTests(context) {
     
     // Test 3: Control toggle state (turn on/off)
     try {
-        // Get initial state
-        let initialState = undefined;
-        if (typeof testDevice.getToggleState === 'function') {
-            const stateResponse = await testDevice.getToggleState(0);
-            if (stateResponse && stateResponse.togglex) {
-                initialState = stateResponse.togglex[0]?.onoff || stateResponse.togglex.onoff;
-            }
-        } else if (typeof testDevice.isOn === 'function') {
-            initialState = testDevice.isOn(0);
-        }
-        
-        // Test turnOn if available
-        if (typeof testDevice.turnOn === 'function') {
-            const turnOnResult = await testDevice.turnOn(0);
+        if (!testDevice.toggle) {
+            results.push({
+                name: 'should control toggle state',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support toggle feature',
+                device: deviceName
+            });
+        } else {
+            // Get initial state
+            let initialState = testDevice.toggle.isOn({ channel: 0 });
             
-            if (!turnOnResult) {
+            // Test turn on
+            await testDevice.toggle.set({ channel: 0, on: true });
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            const isOnAfter = testDevice.toggle.isOn({ channel: 0 });
+            if (!isOnAfter) {
                 results.push({
                     name: 'should control toggle state (turn on)',
                     passed: false,
                     skipped: false,
-                    error: 'turnOn() returned null or undefined',
+                    error: 'Device did not turn on after set({ on: true })',
                     device: deviceName
                 });
             } else {
-                // Wait a bit for state to update
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                
-                // Verify state
-                if (typeof testDevice.isOn === 'function') {
-                    const isOnAfter = testDevice.isOn(0);
-                    if (!isOnAfter) {
-                        results.push({
-                            name: 'should control toggle state (turn on)',
-                            passed: false,
-                            skipped: false,
-                            error: 'Device did not turn on after turnOn() call',
-                            device: deviceName
-                        });
-                    } else {
-                        results.push({
-                            name: 'should control toggle state (turn on)',
-                            passed: true,
-                            skipped: false,
-                            error: null,
-                            device: deviceName
-                        });
-                    }
-                } else {
-                    // Can't verify, but command succeeded
-                    results.push({
-                        name: 'should control toggle state (turn on)',
-                        passed: true,
-                        skipped: false,
-                        error: null,
-                        device: deviceName,
-                        details: { note: 'turnOn succeeded but cannot verify state (isOn not available)' }
-                    });
-                }
+                results.push({
+                    name: 'should control toggle state (turn on)',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName
+                });
             }
-        } else {
-            results.push({
-                name: 'should control toggle state (turn on)',
-                passed: false,
-                skipped: true,
-                error: 'Device does not support turnOn',
-                device: deviceName
-            });
-        }
-        
-        // Test turnOff if available
-        if (typeof testDevice.turnOff === 'function') {
-            const turnOffResult = await testDevice.turnOff(0);
             
-            if (!turnOffResult) {
+            // Test turn off
+            await testDevice.toggle.set({ channel: 0, on: false });
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            const isOffAfter = testDevice.toggle.isOn({ channel: 0 });
+            if (isOffAfter) {
                 results.push({
                     name: 'should control toggle state (turn off)',
                     passed: false,
                     skipped: false,
-                    error: 'turnOff() returned null or undefined',
+                    error: 'Device did not turn off after set({ on: false })',
                     device: deviceName
                 });
             } else {
-                // Wait a bit for state to update
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                
-                // Verify state
-                if (typeof testDevice.isOn === 'function') {
-                    const isOnAfter = testDevice.isOn(0);
-                    if (isOnAfter) {
-                        results.push({
-                            name: 'should control toggle state (turn off)',
-                            passed: false,
-                            skipped: false,
-                            error: 'Device did not turn off after turnOff() call',
-                            device: deviceName
-                        });
-                    } else {
-                        results.push({
-                            name: 'should control toggle state (turn off)',
-                            passed: true,
-                            skipped: false,
-                            error: null,
-                            device: deviceName
-                        });
-                    }
-                } else {
-                    // Can't verify, but command succeeded
-                    results.push({
-                        name: 'should control toggle state (turn off)',
-                        passed: true,
-                        skipped: false,
-                        error: null,
-                        device: deviceName,
-                        details: { note: 'turnOff succeeded but cannot verify state (isOn not available)' }
-                    });
-                }
+                results.push({
+                    name: 'should control toggle state (turn off)',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName
+                });
             }
-        } else {
-            results.push({
-                name: 'should control toggle state (turn off)',
-                passed: false,
-                skipped: true,
-                error: 'Device does not support turnOff',
-                device: deviceName
-            });
-        }
-        
-        // Restore initial state if we changed it
-        if (initialState !== undefined && typeof testDevice.turnOn === 'function' && typeof testDevice.turnOff === 'function') {
-            if (initialState === 1 || initialState === true) {
-                await testDevice.turnOn(0);
-            } else {
-                await testDevice.turnOff(0);
+            
+            // Restore initial state if we changed it
+            if (initialState !== undefined) {
+                await testDevice.toggle.set({ channel: 0, on: initialState });
+                await new Promise(resolve => setTimeout(resolve, 2000));
             }
-            await new Promise(resolve => setTimeout(resolve, 2000));
         }
         
     } catch (error) {
@@ -284,54 +208,6 @@ async function runTests(context) {
         });
     }
     
-    // Test 4: Handle toggle push notifications
-    try {
-        const testDeviceForPush = toggleDevices[0];
-        
-        // Set up listener for toggle push notifications
-        let receivedNotification = false;
-        const notificationHandler = (notification) => {
-            if (notification.namespace === 'Appliance.Control.ToggleX' || 
-                notification.namespace === 'Appliance.Control.Toggle') {
-                receivedNotification = true;
-            }
-        };
-        
-        testDeviceForPush.on('pushNotification', notificationHandler);
-        
-        // Get toggle state (may trigger a push notification)
-        if (typeof testDeviceForPush.getToggleState === 'function') {
-            await testDeviceForPush.getToggleState(0);
-        }
-        
-        // Wait a bit for potential push notifications
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        
-        // Remove listener
-        testDeviceForPush.removeListener('pushNotification', notificationHandler);
-        
-        // Note: We don't assert on receivedNotification since push notifications
-        // are device-initiated and may not occur during testing
-        // This test just verifies the listener mechanism works
-        results.push({
-            name: 'should handle toggle push notifications',
-            passed: true,
-            skipped: false,
-            error: null,
-            device: getDeviceName(testDeviceForPush),
-            details: { notificationReceived: receivedNotification }
-        });
-        
-    } catch (error) {
-        results.push({
-            name: 'should handle toggle push notifications',
-            passed: false,
-            skipped: false,
-            error: error.message,
-            device: toggleDevices.length > 0 ? getDeviceName(toggleDevices[0]) : null
-        });
-    }
-    
     return results;
 }
 

package/cli/tests/test-trigger.js

@@ -81,7 +81,7 @@ async function runTests(context) {
                     }
                 }
             };
-            testDevice.on('pushNotification', handler);
+            testDevice.on('pushNotificationReceived', handler);
             
             // Timeout after 5 seconds if no push notification arrives
             setTimeout(() => {
@@ -90,7 +90,7 @@ async function runTests(context) {
             }, 5000);
         });
         
-        const createResult = await testDevice.setTriggerX(testTrigger);
+        const createResult = await testDevice.trigger.set({ triggerx: testTrigger });
         
         if (!createResult) {
             results.push({
@@ -114,7 +114,7 @@ async function runTests(context) {
         } else {
             // Wait a bit and query by alias to find it
             await new Promise(resolve => setTimeout(resolve, 2000));
-            const triggers = await testDevice.getTriggerX(0);
+            const triggers = await testDevice.trigger.get({ channel: 0 });
             const foundTrigger = triggers?.triggerx?.find(t => t.alias === 'Test Trigger - CLI Test');
             if (foundTrigger && foundTrigger.id) {
                 createdTriggerId = foundTrigger.id;
@@ -133,7 +133,7 @@ async function runTests(context) {
         }
         
         // Verify trigger exists by querying it
-        const triggerInfo = await testDevice.getTriggerX(0);
+        const triggerInfo = await testDevice.trigger.get({ channel: 0 });
         const triggerExists = triggerInfo?.triggerx?.some(t => t.id === createdTriggerId);
         
         if (!triggerExists) {
@@ -148,7 +148,8 @@ async function runTests(context) {
         }
         
         // Verify cached trigger state
-        const cachedTriggers = testDevice.getCachedTriggerX(0);
+        const triggerResponse = await testDevice.trigger.get({ channel: 0 });
+        const cachedTriggers = triggerResponse?.triggerx || [];
         
         results.push({
             name: 'should create trigger',
@@ -158,7 +159,7 @@ async function runTests(context) {
             device: deviceName,
             details: { 
                 triggerId: createdTriggerId,
-                cachedTriggerCount: cachedTriggers ? cachedTriggers.length : 0
+                cachedTriggerCount: cachedTriggers.length
             }
         });
     } catch (error) {
@@ -226,50 +227,6 @@ async function runTests(context) {
         }
     }
     
-    // Test 3: Handle trigger push notifications
-    try {
-        // Set up listener for trigger push notifications
-        let receivedNotification = false;
-        const notificationHandler = (notification) => {
-            if (notification.namespace === 'Appliance.Control.TriggerX') {
-                receivedNotification = true;
-            }
-        };
-        
-        testDevice.on('pushNotification', notificationHandler);
-        
-        // Get trigger info (may trigger a push notification)
-        await testDevice.getTriggerX(0);
-        
-        // Wait a bit for potential push notifications
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        
-        // Remove listener
-        testDevice.removeListener('pushNotification', notificationHandler);
-        
-        // Note: We don't assert on receivedNotification since push notifications
-        // are device-initiated and may not occur during testing
-        results.push({
-            name: 'should handle trigger push notifications',
-            passed: true,
-            skipped: false,
-            error: null,
-            device: deviceName,
-            details: { 
-                notificationReceived: receivedNotification,
-                note: 'Push notifications are device-initiated and may not occur during testing'
-            }
-        });
-    } catch (error) {
-        results.push({
-            name: 'should handle trigger push notifications',
-            passed: false,
-            skipped: false,
-            error: error.message,
-            device: deviceName
-        });
-    }
-    
     return results;
 }
 

package/cli/utils/error-handler.js

@@ -0,0 +1,257 @@
+'use strict';
+
+const chalk = require('chalk');
+const ManagerMeross = require('meross-iot');
+
+/**
+ * Formats error messages for display in the CLI.
+ *
+ * Provides user-friendly error messages based on error type, with specific
+ * guidance for common error scenarios like MFA, authentication, and command failures.
+ *
+ * @param {Error} error - The error to format
+ * @param {boolean} verbose - Whether to show detailed error information
+ * @returns {string} Formatted error message
+ */
+function formatError(error, verbose = false) {
+    if (error instanceof ManagerMeross.MerossErrorMFARequired) {
+        return chalk.red('\n✗ MFA (Multi-Factor Authentication) is required.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.yellow('  Please provide MFA code using --mfa-code option or set MEROSS_MFA_CODE environment variable.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorWrongMFA) {
+        return chalk.red('\n✗ MFA code is incorrect.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.yellow('  Please check your MFA code and try again.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorAuthentication) {
+        return chalk.red('\n✗ Authentication failed.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.yellow('  Please check your email and password.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorTokenExpired) {
+        return chalk.yellow('\n⚠ Authentication token has expired.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.dim('  The library will automatically attempt to login again.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorBadDomain) {
+        return chalk.yellow('\n⚠ Bad domain error.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.dim('  The API domain may be incorrect. Auto-retry is enabled.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorCommand) {
+        let message = chalk.red('\n✗ Device command failed.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.deviceUuid) {
+            message += chalk.dim(`  Device: ${error.deviceUuid}\n`);
+        }
+        if (error.errorPayload) {
+            message += chalk.dim(`  Device Response: ${JSON.stringify(error.errorPayload, null, 2)}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorCommandTimeout) {
+        let message = chalk.yellow('\n⚠ Command timeout.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.deviceUuid) {
+            message += chalk.dim(`  Device: ${error.deviceUuid}\n`);
+        }
+        if (error.timeout) {
+            message += chalk.dim(`  Timeout: ${error.timeout}ms\n`);
+        }
+        message += chalk.dim('  The device may be offline or experiencing network issues.\n');
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorMqtt) {
+        let message = chalk.red('\n✗ MQTT error.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.topic) {
+            message += chalk.dim(`  Topic: ${error.topic}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorUnauthorized) {
+        return chalk.red('\n✗ Unauthorized access.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.dim(`  HTTP Status: ${error.httpStatusCode || 401}\n`) +
+            chalk.yellow('  Authentication token may be invalid or expired.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorHttpApi) {
+        let message = chalk.red('\n✗ HTTP API error.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.httpStatusCode) {
+            message += chalk.dim(`  HTTP Status: ${error.httpStatusCode}\n`);
+        }
+        if (error.cause && verbose) {
+            message += chalk.dim(`  Caused by: ${error.cause.message}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorApiLimitReached) {
+        return chalk.yellow('\n⚠ API rate limit reached.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.dim('  Please wait before making more requests.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorResourceAccessDenied) {
+        return chalk.red('\n✗ Resource access denied.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.yellow('  You may not have permission to access this resource.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorUnconnected) {
+        return chalk.yellow('\n⚠ Device is not connected.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.dim('  Please wait for the device to connect before sending commands.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorValidation) {
+        let message = chalk.red('\n✗ Validation error.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.field) {
+            message += chalk.dim(`  Field: ${error.field}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorNotFound) {
+        let message = chalk.red('\n✗ Resource not found.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.resourceType) {
+            message += chalk.dim(`  Type: ${error.resourceType}\n`);
+        }
+        if (error.resourceId) {
+            message += chalk.dim(`  ID: ${error.resourceId}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorTooManyTokens) {
+        return chalk.red('\n✗ Too many authentication tokens.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.yellow('  You have issued too many tokens without logging out. Please log out from other sessions.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorRateLimit) {
+        return chalk.yellow('\n⚠ Request rate limit exceeded.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.dim('  Please wait before making more requests.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorOperationLocked) {
+        return chalk.yellow('\n⚠ Operation is locked.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`) +
+            chalk.dim('  The operation may become available after a delay.\n');
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorUnsupported) {
+        let message = chalk.red('\n✗ Unsupported operation.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.operation) {
+            message += chalk.dim(`  Operation: ${error.operation}\n`);
+        }
+        if (error.reason) {
+            message += chalk.dim(`  Reason: ${error.reason}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorInitialization) {
+        let message = chalk.red('\n✗ Initialization failed.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.component) {
+            message += chalk.dim(`  Component: ${error.component}\n`);
+        }
+        if (error.reason) {
+            message += chalk.dim(`  Reason: ${error.reason}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorNetworkTimeout) {
+        let message = chalk.yellow('\n⚠ Network request timeout.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.timeout) {
+            message += chalk.dim(`  Timeout: ${error.timeout}ms\n`);
+        }
+        if (error.url) {
+            message += chalk.dim(`  URL: ${error.url}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorParse) {
+        let message = chalk.red('\n✗ Parse error.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.format) {
+            message += chalk.dim(`  Format: ${error.format}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossErrorUnknownDeviceType) {
+        let message = chalk.red('\n✗ Unknown or unsupported device type.\n') +
+            chalk.dim(`  Error Code: ${error.code}\n`);
+        if (error.deviceType) {
+            message += chalk.dim(`  Device Type: ${error.deviceType}\n`);
+        }
+        return message;
+    }
+
+    if (error instanceof ManagerMeross.MerossError) {
+        let message = chalk.red(`\n✗ ${error.message}\n`);
+        if (error.code) {
+            message += chalk.dim(`  Error Code: ${error.code}\n`);
+        }
+        if (error.errorCode !== null && error.errorCode !== undefined) {
+            message += chalk.dim(`  API Error Code: ${error.errorCode}\n`);
+        }
+        return message;
+    }
+
+    // Generic error fallback
+    return chalk.red(`\n✗ ${error.message}\n`);
+}
+
+/**
+ * Handles and displays errors with appropriate formatting.
+ *
+ * Formats the error message and optionally displays the stack trace
+ * if verbose mode is enabled.
+ *
+ * @param {Error} error - The error to handle
+ * @param {Object} options - Options for error handling
+ * @param {boolean} [options.verbose=false] - Whether to show stack trace
+ * @param {boolean} [options.exit=false] - Whether to exit the process after displaying error
+ * @param {number} [options.exitCode=1] - Exit code to use if exiting
+ */
+function handleError(error, options = {}) {
+    const { verbose = false, exit = false, exitCode = 1 } = options;
+
+    const formattedMessage = formatError(error, verbose);
+    console.error(formattedMessage);
+
+    if (verbose && error.stack) {
+        console.error(chalk.dim('\nStack trace:'));
+        console.error(chalk.dim(error.stack));
+    }
+
+    if (exit) {
+        process.exit(exitCode);
+    }
+}
+
+module.exports = {
+    formatError,
+    handleError
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meross-cli",
-  "version": "0.3.0",
+  "version": "0.5.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.4.0",
+    "meross-iot": "^0.6.0",
     "ora": "^5.4.1"
   },
   "devDependencies": {