meross-cli 0.4.0 → 0.5.0

package/cli/meross-cli.js

@@ -300,7 +300,7 @@ Examples:
             console.log();
         }
         console.log('Usage: meross-cli control <uuid> <method> [options]');
-        console.log('Example: meross-cli control <uuid> setToggleX --channel 0 --on');
+        console.log('Example: meross-cli control <uuid> toggle.set --channel 0 --on true');
     }
 
     function _findMethodInfo(availableMethods, methodName) {

package/cli/tests/README.md

@@ -41,6 +41,7 @@ The test system is designed for simplicity, maintainability, and excellent error
 - `test-config.js` - Tests for config features (over temp)
 - `test-control.js` - Tests for control features (multiple commands, upgrade, over temp)
 - `test-presence.js` - Tests for presence sensor devices
+- `test-system.js` - Tests for system information, hardware, firmware, abilities, and configuration
 
 ## Running Tests
 
@@ -107,6 +108,7 @@ meross-cli test electricity --email your@email.com --password yourpass
 - `config` - Config features (over temp)
 - `control` - Control features (multiple commands, upgrade, over temp)
 - `presence` - Presence sensor devices
+- `system` - System information, hardware, firmware, abilities, and configuration
 
 ## Writing New Tests
 

package/cli/tests/test-alarm.js

@@ -47,7 +47,17 @@ async function runTests(context) {
     
     // Test 1: Get alarm status
     try {
-        const response = await testDevice.getAlarmStatus({ channel: 0 });
+        if (!testDevice.alarm) {
+            results.push({
+                name: 'should get alarm status',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support alarm feature',
+                device: deviceName
+            });
+            return results;
+        }
+        const response = await testDevice.alarm.get({ channel: 0 });
         
         if (!response) {
             results.push({
@@ -87,8 +97,18 @@ async function runTests(context) {
     
     // Test 2: Store alarm events from push notifications
     try {
+        if (!testDevice.alarm) {
+            results.push({
+                name: 'should store alarm events from push notifications',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support alarm feature',
+                device: deviceName
+            });
+            return results;
+        }
         // Get initial alarm events (should be empty or existing events)
-        const initialEvents = testDevice.getLastAlarmEvents();
+        const initialEvents = testDevice.alarm.getLastEvents();
         
         if (!Array.isArray(initialEvents)) {
             results.push({

package/cli/tests/test-child-lock.js

@@ -49,14 +49,24 @@ async function runTests(context) {
     
     // Test 1: Get child lock status
     try {
-        const lockStatus = await testDevice.getChildLock({ channel: 0 });
+        if (!testDevice.childLock) {
+            results.push({
+                name: 'should get child lock status',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support child lock feature',
+                device: deviceName
+            });
+            return results;
+        }
+        const lockStatus = await testDevice.childLock.get({ channel: 0 });
         
         if (!lockStatus) {
             results.push({
                 name: 'should get child lock status',
                 passed: false,
                 skipped: false,
-                error: 'getChildLock returned null or undefined',
+                error: 'childLock.get() returned null or undefined',
                 device: deviceName
             });
         } else if (!lockStatus.lock) {
@@ -89,8 +99,18 @@ async function runTests(context) {
     
     // Test 2: Control child lock status
     try {
+        if (!testDevice.childLock) {
+            results.push({
+                name: 'should control child lock status',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support child lock feature',
+                device: deviceName
+            });
+            return results;
+        }
         // Get initial lock status
-        const initialStatus = await testDevice.getChildLock({ channel: 0 });
+        const initialStatus = await testDevice.childLock.get({ channel: 0 });
         
         if (!initialStatus || !initialStatus.lock || !Array.isArray(initialStatus.lock) || initialStatus.lock.length === 0) {
             results.push({
@@ -110,11 +130,11 @@ async function runTests(context) {
                 onoff: newLockState
             };
             
-            await testDevice.setChildLock(lockData);
+            await testDevice.childLock.set({ channel: 0, onoff: newLockState });
             await new Promise(resolve => setTimeout(resolve, 2000));
             
             // Verify the change
-            const updatedStatus = await testDevice.getChildLock({ channel: 0 });
+            const updatedStatus = await testDevice.childLock.get({ channel: 0 });
             
             if (!updatedStatus || !updatedStatus.lock || !updatedStatus.lock[0]) {
                 results.push({
@@ -138,10 +158,10 @@ async function runTests(context) {
                     channel: 0,
                     onoff: initialLockState
                 };
-                await testDevice.setChildLock(restoreLockData);
+                await testDevice.childLock.set({ channel: 0, onoff: initialLockState });
                 await new Promise(resolve => setTimeout(resolve, 2000));
                 
-                const restoredStatus = await testDevice.getChildLock({ channel: 0 });
+                const restoredStatus = await testDevice.childLock.get({ channel: 0 });
                 
                 if (!restoredStatus || !restoredStatus.lock || !restoredStatus.lock[0] || 
                     restoredStatus.lock[0].onoff !== initialLockState) {
@@ -175,8 +195,18 @@ async function runTests(context) {
     
     // Test 3: Handle multiple channel lock control
     try {
+        if (!testDevice.childLock) {
+            results.push({
+                name: 'should handle multiple channel lock control',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support child lock feature',
+                device: deviceName
+            });
+            return results;
+        }
         // Get initial status for all channels
-        const initialStatus = await testDevice.getChildLock({ channel: 0 });
+        const initialStatus = await testDevice.childLock.get({ channel: 0 });
         
         if (!initialStatus || !initialStatus.lock) {
             results.push({
@@ -205,11 +235,11 @@ async function runTests(context) {
                 }
             }
             
-            await testDevice.setChildLock({ lockData: lockDataArray });
+            await testDevice.childLock.set({ lockData: lockDataArray });
             await new Promise(resolve => setTimeout(resolve, 2000));
             
             // Verify all channels were set
-            const updatedStatus = await testDevice.getChildLock({ channel: 0 });
+            const updatedStatus = await testDevice.childLock.get({ channel: 0 });
             
             if (!updatedStatus) {
                 results.push({

package/cli/tests/test-config.js

@@ -47,7 +47,17 @@ async function runTests(context) {
     
     // Test 1: Get config over temp
     try {
-        const response = await testDevice.getConfigOverTemp();
+        if (!testDevice.config) {
+            results.push({
+                name: 'should get config over temp',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support config feature',
+                device: deviceName
+            });
+            return results;
+        }
+        const response = await testDevice.config.get();
         
         if (!response) {
             results.push({
@@ -87,8 +97,18 @@ async function runTests(context) {
     
     // Test 2: Control config over temp
     try {
+        if (!testDevice.config) {
+            results.push({
+                name: 'should control config over temp',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support config feature',
+                device: deviceName
+            });
+            return results;
+        }
         // Get current config first
-        const currentResponse = await testDevice.getConfigOverTemp();
+        const currentResponse = await testDevice.config.get();
         await new Promise(resolve => setTimeout(resolve, 1000));
         
         if (!currentResponse || !currentResponse.overTemp) {

package/cli/tests/test-control.js

@@ -63,12 +63,12 @@ async function runTests(context) {
     
     // Test 1: Control Multiple
     try {
-        if (typeof device.setMultiple !== 'function') {
+        if (!device.control || typeof device.control.setMultiple !== 'function') {
             results.push({
                 name: 'should execute multiple commands',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support setMultiple',
+                error: 'Device does not support control.setMultiple',
                 device: deviceName
             });
         } else {
@@ -85,14 +85,14 @@ async function runTests(context) {
                 }
             ];
             
-            const response = await device.setMultiple(commands);
+            const response = await device.control.setMultiple({ commands });
             
             if (!response) {
                 results.push({
                     name: 'should execute multiple commands',
                     passed: false,
                     skipped: false,
-                    error: 'setMultiple returned null or undefined',
+                    error: 'control.setMultiple returned null or undefined',
                     device: deviceName
                 });
             } else {
@@ -117,12 +117,12 @@ async function runTests(context) {
     
     // Test 2: Control Over Temp
     try {
-        if (typeof device.acknowledgeControlOverTemp !== 'function') {
+        if (!device.control || typeof device.control.acknowledgeOverTemp !== 'function') {
             results.push({
                 name: 'should acknowledge over temp event',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support acknowledgeControlOverTemp',
+                error: 'Device does not support control.acknowledgeOverTemp',
                 device: deviceName
             });
         } else {
@@ -149,12 +149,12 @@ async function runTests(context) {
     
     // Test 3: Control Upgrade
     try {
-        if (typeof device.setUpgrade !== 'function') {
+        if (!device.control || typeof device.control.setUpgrade !== 'function') {
             results.push({
                 name: 'should have upgrade method available',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support setUpgrade',
+                error: 'Device does not support control.setUpgrade',
                 device: deviceName
             });
         } else {

package/cli/tests/test-diffuser.js

@@ -43,13 +43,13 @@ async function runTests(context) {
     // Wait for devices to be connected
     for (const device of lightDevices) {
         await waitForDeviceConnection(device, timeout);
-        await device.getDiffuserLightState();
+        await device.diffuser.get({ type: 'light', channel: 0 });
         await new Promise(resolve => setTimeout(resolve, 1000));
     }
     
     for (const device of sprayDevices) {
         await waitForDeviceConnection(device, timeout);
-        await device.getDiffuserSprayState();
+        await device.diffuser.get({ type: 'spray', channel: 0 });
         await new Promise(resolve => setTimeout(resolve, 1000));
     }
     
@@ -67,7 +67,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(light);
         
         try {
-            await light.getDiffuserLightState();
+            await light.diffuser.get({ type: 'light', channel: 0 });
             
             // Set mode to FIXED_RGB
             await light.setDiffuserLight({
@@ -142,7 +142,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(light);
         
         try {
-            await light.getDiffuserLightState();
+            await light.diffuser.get({ type: 'light', channel: 0 });
             
             // Set mode to FIXED RGB
             await light.setDiffuserLight({
@@ -275,7 +275,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(light);
         
         try {
-            await light.getDiffuserLightState();
+            await light.diffuser.get({ type: 'light', channel: 0 });
             
             await light.setDiffuserLight({
                 channel: 0,
@@ -365,7 +365,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(light);
         
         try {
-            await light.getDiffuserLightState();
+            await light.diffuser.get({ type: 'light', channel: 0 });
             
             await light.setDiffuserLight({
                 channel: 0,
@@ -430,7 +430,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(spray);
         
         try {
-            await spray.getDiffuserSprayState();
+            await spray.diffuser.getSpray({ channel: 0 });
             
             await spray.setDiffuserSpray(0, DiffuserSprayMode.LIGHT);
             await new Promise(resolve => setTimeout(resolve, 1000));

package/cli/tests/test-dnd.js

@@ -27,8 +27,9 @@ async function runTests(context) {
         const allDevices = manager.devices.list();
         testDevices = allDevices.filter(d => {
             return d.onlineStatus === OnlineStatus.ONLINE &&
-                   typeof d.getDNDMode === 'function' &&
-                   typeof d.setDNDMode === 'function';
+                   d.dnd &&
+                   typeof d.dnd.get === 'function' &&
+                   typeof d.dnd.set === 'function';
         });
     }
     
@@ -56,67 +57,77 @@ async function runTests(context) {
     
     // Test 1: Get and set DND mode
     try {
-        // Get current DND mode
-        const initialMode = await testDevice.getDNDMode();
-        
-        if (initialMode === null || initialMode === undefined) {
+        if (!testDevice.dnd) {
             results.push({
                 name: 'should get and set DND mode',
                 passed: false,
-                skipped: false,
-                error: 'getDNDMode returned null or undefined',
-                device: deviceName
-            });
-        } else if (initialMode !== DNDMode.DND_DISABLED && initialMode !== DNDMode.DND_ENABLED) {
-            results.push({
-                name: 'should get and set DND mode',
-                passed: false,
-                skipped: false,
-                error: `Invalid DND mode value: ${initialMode}`,
+                skipped: true,
+                error: 'Device does not support DND feature',
                 device: deviceName
             });
         } else {
-            // Toggle DND mode
-            const newMode = initialMode === DNDMode.DND_ENABLED ? DNDMode.DND_DISABLED : DNDMode.DND_ENABLED;
-            await testDevice.setDNDMode({ mode: newMode });
+            // Get current DND mode
+            const initialMode = await testDevice.dnd.get();
             
-            // Wait for the change to take effect
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            
-            // Verify the change
-            const updatedMode = await testDevice.getDNDMode();
-            
-            if (updatedMode !== newMode) {
+            if (initialMode === null || initialMode === undefined) {
                 results.push({
                     name: 'should get and set DND mode',
                     passed: false,
                     skipped: false,
-                    error: `DND mode did not change. Expected ${newMode}, got ${updatedMode}`,
+                    error: 'dnd.get() returned null or undefined',
+                    device: deviceName
+                });
+            } else if (initialMode !== DNDMode.DND_DISABLED && initialMode !== DNDMode.DND_ENABLED) {
+                results.push({
+                    name: 'should get and set DND mode',
+                    passed: false,
+                    skipped: false,
+                    error: `Invalid DND mode value: ${initialMode}`,
                     device: deviceName
                 });
             } else {
-                // Restore original mode
-                await testDevice.setDNDMode({ mode: initialMode });
+                // Toggle DND mode
+                const newMode = initialMode === DNDMode.DND_ENABLED ? DNDMode.DND_DISABLED : DNDMode.DND_ENABLED;
+                await testDevice.dnd.set({ mode: newMode });
+                
+                // Wait for the change to take effect
                 await new Promise(resolve => setTimeout(resolve, 2000));
                 
-                const restoredMode = await testDevice.getDNDMode();
+                // Verify the change
+                const updatedMode = await testDevice.dnd.get();
                 
-                if (restoredMode !== initialMode) {
+                if (updatedMode !== newMode) {
                     results.push({
                         name: 'should get and set DND mode',
                         passed: false,
                         skipped: false,
-                        error: `Failed to restore DND mode. Expected ${initialMode}, got ${restoredMode}`,
+                        error: `DND mode did not change. Expected ${newMode}, got ${updatedMode}`,
                         device: deviceName
                     });
                 } else {
-                    results.push({
-                        name: 'should get and set DND mode',
-                        passed: true,
-                        skipped: false,
-                        error: null,
-                        device: deviceName
-                    });
+                    // Restore original mode
+                    await testDevice.dnd.set({ mode: initialMode });
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    
+                    const restoredMode = await testDevice.dnd.get();
+                    
+                    if (restoredMode !== initialMode) {
+                        results.push({
+                            name: 'should get and set DND mode',
+                            passed: false,
+                            skipped: false,
+                            error: `Failed to restore DND mode. Expected ${initialMode}, got ${restoredMode}`,
+                            device: deviceName
+                        });
+                    } else {
+                        results.push({
+                            name: 'should get and set DND mode',
+                            passed: true,
+                            skipped: false,
+                            error: null,
+                            device: deviceName
+                        });
+                    }
                 }
             }
         }
@@ -132,37 +143,47 @@ async function runTests(context) {
     
     // Test 2: Accept boolean values for DND mode
     try {
-        // Get current mode
-        const initialMode = await testDevice.getDNDMode();
-        const initialBoolean = initialMode === DNDMode.DND_ENABLED;
-        
-        // Set using boolean (true = enabled)
-        await testDevice.setDNDMode({ mode: !initialBoolean });
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        
-        const updatedMode = await testDevice.getDNDMode();
-        const expectedMode = !initialBoolean ? DNDMode.DND_ENABLED : DNDMode.DND_DISABLED;
-        
-        if (updatedMode !== expectedMode) {
+        if (!testDevice.dnd) {
             results.push({
                 name: 'should accept boolean values for DND mode',
                 passed: false,
-                skipped: false,
-                error: `Boolean set failed. Expected ${expectedMode}, got ${updatedMode}`,
+                skipped: true,
+                error: 'Device does not support DND feature',
                 device: deviceName
             });
         } else {
-            // Restore original mode
-            await testDevice.setDNDMode({ mode: initialBoolean });
+            // Get current mode
+            const initialMode = await testDevice.dnd.get();
+            const initialBoolean = initialMode === DNDMode.DND_ENABLED;
+            
+            // Set using boolean (true = enabled)
+            await testDevice.dnd.set({ mode: !initialBoolean });
             await new Promise(resolve => setTimeout(resolve, 2000));
             
-            results.push({
-                name: 'should accept boolean values for DND mode',
-                passed: true,
-                skipped: false,
-                error: null,
-                device: deviceName
-            });
+            const updatedMode = await testDevice.dnd.get();
+            const expectedMode = !initialBoolean ? DNDMode.DND_ENABLED : DNDMode.DND_DISABLED;
+            
+            if (updatedMode !== expectedMode) {
+                results.push({
+                    name: 'should accept boolean values for DND mode',
+                    passed: false,
+                    skipped: false,
+                    error: `Boolean set failed. Expected ${expectedMode}, got ${updatedMode}`,
+                    device: deviceName
+                });
+            } else {
+                // Restore original mode
+                await testDevice.dnd.set({ mode: initialBoolean });
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                
+                results.push({
+                    name: 'should accept boolean values for DND mode',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName
+                });
+            }
         }
     } catch (error) {
         results.push({
@@ -176,16 +197,16 @@ async function runTests(context) {
     
     // Test 3: Get raw DND mode value
     try {
-        if (typeof testDevice.getRawDNDMode !== 'function') {
+        if (!testDevice.dnd || typeof testDevice.dnd.getRaw !== 'function') {
             results.push({
                 name: 'should get raw DND mode value',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support getRawDNDMode',
+                error: 'Device does not support dnd.getRaw',
                 device: deviceName
             });
         } else {
-            const rawMode = await testDevice.getRawDNDMode();
+            const rawMode = await testDevice.dnd.getRaw();
             
             if (typeof rawMode !== 'number') {
                 results.push({
@@ -205,7 +226,7 @@ async function runTests(context) {
                 });
             } else {
                 // Verify it matches enum value
-                const enumMode = await testDevice.getDNDMode();
+                const enumMode = await testDevice.dnd.get();
                 
                 if (rawMode !== enumMode) {
                     results.push({