meross-cli 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -5,6 +5,15 @@ 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.3.0] - 2026-01-16
+
+### Changed
+- **BREAKING**: Updated to use simplified device API from `meross-iot` v0.4.0
+  - Updated to use `initializeDevices()` instead of `getDevices()`
+  - Updated to use direct device properties instead of `cachedHttpInfo`
+  - Updated to use camelCase property names consistently
+  - Updated all tests and commands to use new API patterns
+
 ## [0.2.0] - 2026-01-15
 
 ### 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.2.0
+npm install -g meross-cli@0.3.0
 ```
 
 Or use via npx:
@@ -77,6 +77,18 @@ The CLI supports all devices that are supported by the underlying `meross-iot` l
 
 ## Changelog
 
+### [0.3.0] - 2026-01-16
+
+#### Changed
+- **BREAKING**: Updated to use simplified device API from `meross-iot` v0.4.0
+  - Updated to use `initializeDevices()` instead of `getDevices()`
+  - Updated to use direct device properties instead of `cachedHttpInfo`
+  - Updated to use camelCase property names consistently
+  - Updated all tests and commands to use new API patterns
+
+<details>
+<summary>Older</summary>
+
 ### [0.2.0] - 2026-01-15
 
 #### Changed
@@ -107,11 +119,6 @@ The CLI supports all devices that are supported by the underlying `meross-iot` l
 - This is an initial, pre-stable release. Please expect bugs.
 - Some edge cases may not be fully handled yet.
 
-<details>
-<summary>Older</summary>
-
-<!-- Older changelog entries will appear here -->
-
 </details>
 
 ## Disclaimer

package/cli/commands/info.js

@@ -84,35 +84,41 @@ function _displayChannels(device) {
 }
 
 /**
- * Builds HTTP device info data array.
+ * Extracts HTTP device info properties for display.
+ *
+ * Collects HTTP metadata properties (domain, reservedDomain, subType, region, etc.)
+ * that are now directly accessible on the device instance for formatting in the CLI output.
+ *
+ * @param {Object} device - MerossDevice instance
+ * @returns {Array<Array<string>>} Array of [label, value] pairs for display
  */
-function _buildHttpInfoData(httpInfo) {
+function _buildHttpInfoData(device) {
     const httpInfoData = [];
 
-    if (httpInfo.domain) {
-        httpInfoData.push(['MQTT Domain', httpInfo.domain]);
+    if (device.domain) {
+        httpInfoData.push(['MQTT Domain', device.domain]);
     }
-    if (httpInfo.reservedDomain) {
-        httpInfoData.push(['Reserved Domain', httpInfo.reservedDomain]);
+    if (device.reservedDomain) {
+        httpInfoData.push(['Reserved Domain', device.reservedDomain]);
     }
-    if (httpInfo.subType) {
-        httpInfoData.push(['Sub Type', httpInfo.subType]);
+    if (device.subType) {
+        httpInfoData.push(['Sub Type', device.subType]);
     }
-    if (httpInfo.region) {
-        httpInfoData.push(['Region', httpInfo.region]);
+    if (device.region) {
+        httpInfoData.push(['Region', device.region]);
     }
-    if (httpInfo.skillNumber) {
-        httpInfoData.push(['Skill Number', httpInfo.skillNumber]);
+    if (device.skillNumber) {
+        httpInfoData.push(['Skill Number', device.skillNumber]);
     }
-    if (httpInfo.devIconId) {
-        httpInfoData.push(['Icon ID', httpInfo.devIconId]);
+    if (device.devIconId) {
+        httpInfoData.push(['Icon ID', device.devIconId]);
     }
-    if (httpInfo.bindTime) {
-        httpInfoData.push(['Bind Time', httpInfo.bindTime.toLocaleString()]);
+    if (device.bindTime) {
+        httpInfoData.push(['Bind Time', device.bindTime.toLocaleString()]);
     }
-    if (httpInfo.onlineStatus !== undefined) {
-        const onlineStatusText = httpInfo.onlineStatus === OnlineStatus.ONLINE ? chalk.green('Online') :
-            httpInfo.onlineStatus === OnlineStatus.OFFLINE ? chalk.red('Offline') :
+    if (device.onlineStatus !== undefined) {
+        const onlineStatusText = device.onlineStatus === OnlineStatus.ONLINE ? chalk.green('Online') :
+            device.onlineStatus === OnlineStatus.OFFLINE ? chalk.red('Offline') :
                 chalk.yellow('Unknown');
         httpInfoData.push(['Online Status', onlineStatusText]);
     }
@@ -121,15 +127,12 @@ function _buildHttpInfoData(httpInfo) {
 }
 
 /**
- * Displays HTTP device info if available.
+ * Displays HTTP device info section if properties are available.
+ *
+ * @param {Object} device - MerossDevice instance
  */
 function _displayHttpInfo(device) {
-    if (!device.cachedHttpInfo) {
-        return;
-    }
-
-    const httpInfo = device.cachedHttpInfo;
-    const httpInfoData = _buildHttpInfoData(httpInfo);
+    const httpInfoData = _buildHttpInfoData(device);
 
     if (httpInfoData.length === 0) {
         return;

package/cli/control-registry.js

@@ -762,10 +762,10 @@ function getMethodsByCategory() {
  * @returns {boolean} True if device supports the namespace
  */
 function deviceSupportsNamespace(device, namespace) {
-    if (!device._abilities || typeof device._abilities !== 'object') {
+    if (!device.abilities || typeof device.abilities !== 'object') {
         return false;
     }
-    return !!device._abilities[namespace];
+    return !!device.abilities[namespace];
 }
 
 /**

package/cli/tests/test-control.js

@@ -28,15 +28,14 @@ async function runTests(context) {
         // Also get any online device for testing control features
         const allDevices = manager.devices.list();
         const onlineDevices = allDevices.filter(device => {
-            const status = device.onlineStatus !== undefined ? device.onlineStatus : (device.dev?.onlineStatus);
-            return status === OnlineStatus.ONLINE;
+            return device.onlineStatus === OnlineStatus.ONLINE;
         });
         
         // Combine and deduplicate
         testDevices = [...multipleDevices];
         for (const device of onlineDevices.slice(0, 2)) {
-            const uuid = device.dev?.uuid || device.uuid;
-            if (!testDevices.find(d => (d.dev?.uuid || d.uuid) === uuid)) {
+            const uuid = device.uuid;
+            if (!testDevices.find(d => d.uuid === uuid)) {
                 testDevices.push(device);
             }
         }

package/cli/tests/test-diffuser.js

@@ -27,10 +27,10 @@ async function runTests(context) {
     if (devices && devices.length > 0) {
         // Use provided devices, filter by capabilities
         lightDevices = devices.filter(d => 
-            d._abilities && d._abilities['Appliance.Control.Diffuser.Light']
+            d.abilities && d.abilities['Appliance.Control.Diffuser.Light']
         );
         sprayDevices = devices.filter(d => 
-            d._abilities && d._abilities['Appliance.Control.Diffuser.Spray']
+            d.abilities && d.abilities['Appliance.Control.Diffuser.Spray']
         );
     } else {
         // Find diffuser light devices

package/cli/tests/test-dnd.js

@@ -26,8 +26,7 @@ async function runTests(context) {
         // Find devices that support DND mode (most devices support this)
         const allDevices = manager.devices.list();
         testDevices = allDevices.filter(d => {
-            const status = d.onlineStatus !== undefined ? d.onlineStatus : (d.dev?.onlineStatus);
-            return status === OnlineStatus.ONLINE &&
+            return d.onlineStatus === OnlineStatus.ONLINE &&
                    typeof d.getDNDMode === 'function' &&
                    typeof d.setDNDMode === 'function';
         });

package/cli/tests/test-encryption.js

@@ -31,7 +31,7 @@ async function runTests(context) {
         // Combine and deduplicate
         const allDevices = [...encryptionDevices];
         for (const device of suiteDevices) {
-            if (!allDevices.find(d => d.dev.uuid === device.dev.uuid)) {
+            if (!allDevices.find(d => d.uuid === device.uuid)) {
                 allDevices.push(device);
             }
         }
@@ -115,8 +115,8 @@ async function runTests(context) {
             const isKeySet = testDevice.isEncryptionKeySet();
             
             // If key is not set and we have the required info, set it
-            if (!isKeySet && testDevice.dev && testDevice.dev.uuid && manager.key && testDevice._macAddress) {
-                testDevice.setEncryptionKey(testDevice.dev.uuid, manager.key, testDevice._macAddress);
+            if (!isKeySet && testDevice.uuid && manager.key && testDevice.macAddress) {
+                testDevice.setEncryptionKey(testDevice.uuid, manager.key, testDevice.macAddress);
                 
                 const keySetAfter = testDevice.isEncryptionKeySet();
                 
@@ -180,8 +180,8 @@ async function runTests(context) {
         } else {
             // Ensure encryption key is set
             if (!testDevice.isEncryptionKeySet()) {
-                if (testDevice.dev && testDevice.dev.uuid && manager.key && testDevice._macAddress) {
-                    testDevice.setEncryptionKey(testDevice.dev.uuid, manager.key, testDevice._macAddress);
+                if (testDevice.uuid && manager.key && testDevice.macAddress) {
+                    testDevice.setEncryptionKey(testDevice.uuid, manager.key, testDevice.macAddress);
                 } else {
                     results.push({
                         name: 'should encrypt and decrypt messages if encryption key is set',

package/cli/tests/test-helper.js

@@ -10,10 +10,15 @@ const { OnlineStatus } = require('meross-iot');
  */
 
 /**
- * Waits for devices to be discovered
+ * Waits for devices to be discovered.
+ *
+ * Returns an array of MerossDevice instances once they are initialized. Uses
+ * device UUID (or subdevice ID) for deduplication to avoid returning the same
+ * device multiple times.
+ *
  * @param {Object} manager - ManagerMeross instance
  * @param {number} timeout - Timeout in milliseconds (default: 5000)
- * @returns {Promise<Array>} Array of device objects with structure: { deviceId, deviceDef, device }
+ * @returns {Promise<Array<MerossDevice>>} Array of device instances
  */
 function waitForDevices(manager, timeout = 5000) {
     return new Promise((resolve) => {
@@ -24,33 +29,28 @@ function waitForDevices(manager, timeout = 5000) {
             const deviceIds = new Set();
             
             for (const device of existingDevices) {
-                // Use unique identifier for subdevices (internalId) or UUID for base devices
+                // Use unique identifier for subdevices (parentUUID:subdeviceId) or UUID for base devices
                 const deviceId = device.subdeviceId 
-                    ? `${device.dev?.uuid || device.uuid}:${device.subdeviceId}` 
-                    : (device.dev?.uuid || device.uuid);
+                    ? `${device.uuid}:${device.subdeviceId}` 
+                    : device.uuid;
                 
                 if (!deviceIds.has(deviceId)) {
                     deviceIds.add(deviceId);
-                    devices.push({ 
-                        deviceId: deviceId, 
-                        deviceDef: device.dev || { uuid: device.uuid }, 
-                        device 
-                    });
+                    devices.push(device);
                 }
             }
             resolve(devices);
             return;
         }
         
-        // Wait for devices to be initialized
         const devices = [];
         const deviceIds = new Set();
         let timeoutId = null;
         
-        const onDeviceInitialized = (deviceId, deviceDef, device) => {
+        const onDeviceInitialized = (deviceId, device) => {
             if (!deviceIds.has(deviceId)) {
                 deviceIds.add(deviceId);
-                devices.push({ deviceId, deviceDef, device });
+                devices.push(device);
             }
         };
         
@@ -61,7 +61,8 @@ function waitForDevices(manager, timeout = 5000) {
             resolve(devices);
         }, timeout);
         
-        // Also check periodically if devices were added (in case event was missed)
+        // Periodic check handles cases where deviceInitialized event was missed
+        // (e.g., devices initialized before event handler was attached)
         const checkInterval = setInterval(() => {
             const currentDevices = manager.devices.list();
             if (currentDevices && currentDevices.length > 0) {
@@ -71,19 +72,14 @@ function waitForDevices(manager, timeout = 5000) {
                 }
                 manager.removeListener('deviceInitialized', onDeviceInitialized);
                 
-                // Add any new devices
                 for (const device of currentDevices) {
                     const deviceId = device.subdeviceId 
-                        ? `${device.dev?.uuid || device.uuid}:${device.subdeviceId}` 
-                        : (device.dev?.uuid || device.uuid);
+                        ? `${device.uuid}:${device.subdeviceId}` 
+                        : device.uuid;
                     
                     if (!deviceIds.has(deviceId)) {
                         deviceIds.add(deviceId);
-                        devices.push({ 
-                            deviceId: deviceId, 
-                            deviceDef: device.dev || { uuid: device.uuid }, 
-                            device 
-                        });
+                        devices.push(device);
                     }
                 }
                 resolve(devices);
@@ -98,13 +94,7 @@ function waitForDevices(manager, timeout = 5000) {
  * @returns {number|null} OnlineStatus value or null if not available
  */
 function getDeviceOnlineStatus(device) {
-    if (device.onlineStatus !== undefined) {
-        return device.onlineStatus;
-    }
-    if (device.dev && device.dev.onlineStatus !== undefined) {
-        return device.dev.onlineStatus;
-    }
-    return null;
+    return device.onlineStatus !== undefined ? device.onlineStatus : null;
 }
 
 /**
@@ -114,7 +104,7 @@ function getDeviceOnlineStatus(device) {
  * @returns {boolean} True if device has the ability
  */
 function deviceHasAbility(device, namespace) {
-    return !!(device._abilities && device._abilities[namespace]);
+    return !!(device.abilities && device.abilities[namespace]);
 }
 
 /**
@@ -146,7 +136,7 @@ async function findDevicesByAbility(manager, namespace, onlineStatus = null, dev
     const devices = await waitForDevices(manager, 2000);
     const filteredDevices = [];
     
-    for (const { device } of devices) {
+    for (const device of devices) {
         // Check if device has the ability
         if (deviceHasAbility(device, namespace)) {
             // Filter by online status if specified
@@ -176,7 +166,7 @@ async function findDevicesByType(manager, deviceType, onlineStatus = null, devic
     // If device filter is provided, use it instead of discovering devices
     if (deviceFilter && Array.isArray(deviceFilter) && deviceFilter.length > 0) {
         return deviceFilter.filter(device => {
-            const baseDeviceType = device.dev?.deviceType;
+            const baseDeviceType = device.deviceType;
             const subdeviceType = device.type || device._type;
             const matchesType = baseDeviceType === deviceType || subdeviceType === deviceType;
             
@@ -197,9 +187,9 @@ async function findDevicesByType(manager, deviceType, onlineStatus = null, devic
     const devices = await waitForDevices(manager, 2000);
     const filteredDevices = [];
     
-    for (const { device } of devices) {
+    for (const device of devices) {
         // Check both base device type and subdevice type
-        const baseDeviceType = device.dev?.deviceType;
+        const baseDeviceType = device.deviceType;
         const subdeviceType = device.type || device._type;
         const matchesType = baseDeviceType === deviceType || subdeviceType === deviceType;
         

package/cli/tests/test-hub-sensors.js

@@ -36,7 +36,7 @@ async function runTests(context) {
         // Also try finding by hub sensor abilities
         const sensorHubs = await findDevicesByAbility(manager, 'Appliance.Hub.Sensor.All', OnlineStatus.ONLINE);
         for (const device of sensorHubs) {
-            if (!hubDevices.find(d => (d.dev?.uuid || d.uuid) === (device.dev?.uuid || device.uuid))) {
+            if (!hubDevices.find(d => d.uuid === device.uuid)) {
                 hubDevices.push(device);
             }
         }

package/cli/tests/test-runner.js

@@ -325,7 +325,7 @@ async function findDevicesForTestType(testType, manager) {
     if (!allDevices || allDevices.length === 0) {
         const { waitForDevices } = require('./test-helper');
         const deviceList = await waitForDevices(manager, 1000);
-        return deviceList.map(({ device }) => device).filter(d => d);
+        return deviceList.filter(d => d);
     }
     
     const matchingDevices = [];
@@ -340,13 +340,12 @@ async function findDevicesForTestType(testType, manager) {
     }
     
     for (const device of allDevices) {
-        const uuid = device.dev?.uuid || device.uuid;
+        const uuid = device.uuid;
         if (seenUuids.has(uuid)) {
             continue;
         }
         
-        if (device.onlineStatus !== OnlineStatus.ONLINE && 
-            device.dev?.onlineStatus !== OnlineStatus.ONLINE) {
+        if (device.onlineStatus !== OnlineStatus.ONLINE) {
             continue;
         }
         
@@ -371,7 +370,7 @@ async function findDevicesForTestType(testType, manager) {
         }
         
         const hasAbility = abilities.some(ability => 
-            device._abilities && device._abilities[ability]
+            device.abilities && device.abilities[ability]
         );
         
         if (hasAbility) {
@@ -383,17 +382,15 @@ async function findDevicesForTestType(testType, manager) {
     // For garage, also try by device type if no matches found
     if (testType.toLowerCase() === 'garage' && matchingDevices.length === 0) {
         for (const device of allDevices) {
-            const uuid = device.dev?.uuid || device.uuid;
+            const uuid = device.uuid;
             if (seenUuids.has(uuid)) {
                 continue;
             }
             
-            const baseDeviceType = device.dev?.deviceType;
             const subdeviceType = device.type || device._type;
-            const matchesType = baseDeviceType === 'msg100' || subdeviceType === 'msg100';
+            const matchesType = device.deviceType === 'msg100' || subdeviceType === 'msg100';
             
-            if (matchesType && (device.onlineStatus === OnlineStatus.ONLINE || 
-                                device.dev?.onlineStatus === OnlineStatus.ONLINE)) {
+            if (matchesType && device.onlineStatus === OnlineStatus.ONLINE) {
                 seenUuids.add(uuid);
                 matchingDevices.push(device);
             }

package/cli/tests/test-runtime.js

@@ -25,11 +25,10 @@ async function runTests(context) {
         // Runtime is typically available on most devices, so we'll test with any online device
         const allDevices = manager.devices.list();
         testDevices = allDevices.filter(device => {
-            const status = device.onlineStatus !== undefined ? device.onlineStatus : (device.dev?.onlineStatus);
-            if (status !== OnlineStatus.ONLINE) return false;
+            if (device.onlineStatus !== OnlineStatus.ONLINE) return false;
             // Check if device has runtime ability or if it's a common device type
-            return device._abilities && (
-                device._abilities['Appliance.System.Runtime'] ||
+            return device.abilities && (
+                device.abilities['Appliance.System.Runtime'] ||
                 // Most devices support runtime, so we'll test with any online device
                 true
             );

package/cli/tests/test-template.js

@@ -52,8 +52,8 @@ async function runTests(context) {
         // Combine and deduplicate
         testDevices = [...toggleXDevices];
         for (const device of toggleDevices) {
-            const uuid = device.dev?.uuid || device.uuid;
-            if (!testDevices.find(d => (d.dev?.uuid || d.uuid) === uuid)) {
+            const uuid = device.uuid;
+            if (!testDevices.find(d => d.uuid === uuid)) {
                 testDevices.push(device);
             }
         }

package/cli/tests/test-toggle.js

@@ -29,8 +29,8 @@ async function findAllToggleDevices(manager) {
     // Combine and deduplicate
     const allToggleDevices = [...toggleXDevices];
     for (const device of toggleDevices) {
-        const uuid = device.dev?.uuid || device.uuid;
-        if (!allToggleDevices.find(d => (d.dev?.uuid || d.uuid) === uuid)) {
+        const uuid = device.uuid;
+        if (!allToggleDevices.find(d => d.uuid === uuid)) {
             allToggleDevices.push(device);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meross-cli",
-  "version": "0.2.0",
+  "version": "0.3.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.2.1",
+    "meross-iot": "^0.4.0",
     "ora": "^5.4.1"
   },
   "devDependencies": {