matterbridge 3.0.2-dev-20250512-ae61aa7 → 3.0.2-dev-20250514-175db7e

package/CHANGELOG.md

@@ -12,14 +12,15 @@ If you like this project and find it useful, please consider giving it a star on
 
 ### Added
 
-- [virtual] Added virtual devices Restart Matterbridge and Update Matterbridge.
+- [virtual] Added virtual devices Restart Matterbridge and Update Matterbridge and full Jest tests.
+- [virtual] Added virtual devices Reboot Matterbridge for Shelly board and full Jest tests.
 
 ### Changed
 
 - [package]: Updated dependencies.
 - [utils]: Refactor utils functions.
 - [utils]: Updated Jest tests on utils functions.
-- [devices]: Added RoboticVacuumCleaner class to create the Robotic Vacuum Cleaner device type.
+- [devices]: Added RoboticVacuumCleaner class to create the Robotic Vacuum Cleaner device type in one line of code.
 
 ### Fixed
 

package/dist/helpers.js

@@ -0,0 +1,67 @@
+import { OnOff } from '@matter/main/clusters/on-off';
+import { Endpoint } from '@matter/node';
+import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
+import { OnOffBaseServer } from '@matter/node/behaviors/on-off';
+import { OnOffPlugInUnitDevice } from '@matter/node/devices/on-off-plug-in-unit';
+import { hasParameter } from './utils/commandLine.js';
+export async function addVirtualDevice(aggregatorEndpoint, name, callback) {
+    const device = new Endpoint(OnOffPlugInUnitDevice.with(BridgedDeviceBasicInformationServer), {
+        id: name.replaceAll(' ', ''),
+        bridgedDeviceBasicInformation: { nodeLabel: name },
+        onOff: { onOff: false, startUpOnOff: OnOff.StartUpOnOff.Off },
+    });
+    device.events.onOff.onOff$Changed.on(async (value) => {
+        if (value) {
+            await device.setStateOf(OnOffBaseServer, { onOff: false });
+            callback();
+        }
+    });
+    await aggregatorEndpoint.add(device);
+    await device.setStateOf(OnOffBaseServer, { onOff: false });
+    return device;
+}
+export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
+    if (!hasParameter('novirtual') && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
+        matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);
+        await addVirtualDevice(aggregatorEndpoint, 'Restart Matterbridge', async () => {
+            if (matterbridge.restartMode === '')
+                await matterbridge.restartProcess();
+            else
+                await matterbridge.shutdownProcess();
+        });
+        await addVirtualDevice(aggregatorEndpoint, 'Update Matterbridge', async () => {
+            if (hasParameter('shelly')) {
+                const { getShelly } = await import('./shelly.js');
+                getShelly('/api/updates/sys/perform', 10 * 1000)
+                    .then(() => {
+                    matterbridge.log.notice('Shelly system updated successfully');
+                })
+                    .catch((error) => {
+                    matterbridge.log.error(`Error updating shelly system: ${error}`);
+                });
+                getShelly('/api/updates/main/perform', 10 * 1000)
+                    .then(() => {
+                    matterbridge.log.notice('Shelly software updated successfully');
+                })
+                    .catch((error) => {
+                    matterbridge.log.error(`Error updating shelly software: ${error}`);
+                });
+            }
+            else {
+                await matterbridge.updateProcess();
+            }
+        });
+        if (hasParameter('shelly')) {
+            await addVirtualDevice(aggregatorEndpoint, 'Reboot Matterbridge', async () => {
+                const { postShelly } = await import('./shelly.js');
+                postShelly('/api/system/reboot', {}, 60 * 1000)
+                    .then(() => {
+                    matterbridge.log.notice('Rebooting shelly board...');
+                })
+                    .catch((error) => {
+                    matterbridge.log.error(`Error rebooting shelly board: ${error}`);
+                });
+            });
+        }
+    }
+}

package/dist/matterbridge.js

@@ -7,21 +7,18 @@ import { AnsiLogger, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, BRIGHT
 import { NodeStorageManager } from './storage/export.js';
 import { getParameter, getIntParameter, hasParameter, copyDirectory, withTimeout, waiter, isValidString, parseVersionString, isValidNumber } from './utils/export.js';
 import { logInterfaces, getGlobalNodeModules } from './utils/network.js';
+import { dev, plg, typ } from './matterbridgeTypes.js';
 import { PluginManager } from './pluginManager.js';
 import { DeviceManager } from './deviceManager.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { bridge } from './matterbridgeDeviceTypes.js';
 import { Frontend } from './frontend.js';
-import { DeviceTypeId, Endpoint as EndpointNode, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, VendorId, StorageService, Environment, ServerNode, UINT32_MAX, UINT16_MAX, Endpoint, } from '@matter/main';
+import { addVirtualDevices } from './helpers.js';
+import { DeviceTypeId, Endpoint, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, VendorId, StorageService, Environment, ServerNode, UINT32_MAX, UINT16_MAX, } from '@matter/main';
 import { DeviceCommissioner, FabricAction, MdnsService, PaseClient } from '@matter/main/protocol';
-import { OnOffPlugInUnitDevice } from '@matter/main/devices/on-off-plug-in-unit';
 import { AggregatorEndpoint } from '@matter/main/endpoints';
 import { BasicInformationServer } from '@matter/main/behaviors/basic-information';
-import { OnOffBaseServer } from '@matter/main/behaviors/on-off';
 import { BridgedDeviceBasicInformationServer } from '@matter/main/behaviors/bridged-device-basic-information';
-const plg = '\u001B[38;5;33m';
-const dev = '\u001B[38;5;79m';
-const typ = '\u001B[38;5;207m';
 export class Matterbridge extends EventEmitter {
     systemInformation = {
         interfaceName: '',
@@ -1244,6 +1241,7 @@ export class Matterbridge extends EventEmitter {
         this.serverNode = await this.createServerNode(this.matterbridgeContext, this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
         this.aggregatorNode = await this.createAggregatorNode(this.matterbridgeContext);
         await this.serverNode.add(this.aggregatorNode);
+        await addVirtualDevices(this, this.aggregatorNode);
         await this.startPlugins();
         this.log.debug('Starting start matter interval in bridge mode');
         let failCount = 0;
@@ -1521,30 +1519,6 @@ export class Matterbridge extends EventEmitter {
         serverNode.lifecycle.decommissioned.on(() => this.log.notice(`Server node for ${storeId} was fully decommissioned successfully!`));
         serverNode.lifecycle.online.on(async () => {
             this.log.notice(`Server node for ${storeId} is online`);
-            if (!hasParameter('novirtual') && this.bridgeMode === 'bridge') {
-                this.log.notice(`Creating virtual devices for server node ${storeId}`);
-                const virtualRestart = new Endpoint(OnOffPlugInUnitDevice.with(BridgedDeviceBasicInformationServer), { id: 'Restart Matterbridge', bridgedDeviceBasicInformation: { nodeLabel: 'Restart' } });
-                virtualRestart.events.onOff.onOff$Changed.on(async (value) => {
-                    if (value) {
-                        await virtualRestart.setStateOf(OnOffBaseServer, { onOff: false });
-                        if (this.restartMode === '')
-                            this.restartProcess();
-                        else
-                            this.shutdownProcess();
-                    }
-                });
-                await this.aggregatorNode?.add(virtualRestart);
-                await virtualRestart.setStateOf(OnOffBaseServer, { onOff: false });
-                const virtualUpdate = new Endpoint(OnOffPlugInUnitDevice.with(BridgedDeviceBasicInformationServer), { id: 'Update Matterbridge', bridgedDeviceBasicInformation: { nodeLabel: 'Update' } });
-                virtualUpdate.events.onOff.onOff$Changed.on(async (value) => {
-                    if (value) {
-                        await virtualUpdate.setStateOf(OnOffBaseServer, { onOff: false });
-                        this.updateProcess();
-                    }
-                });
-                await this.aggregatorNode?.add(virtualUpdate);
-                await virtualUpdate.setStateOf(OnOffBaseServer, { onOff: false });
-            }
             if (!serverNode.lifecycle.isCommissioned) {
                 this.log.notice(`Server node for ${storeId} is not commissioned. Pair to commission ...`);
                 const { qrPairingCode, manualPairingCode } = serverNode.state.commissioning.pairingCodes;
@@ -1719,7 +1693,7 @@ export class Matterbridge extends EventEmitter {
     }
     async createAggregatorNode(storageContext) {
         this.log.notice(`Creating ${await storageContext.get('storeId')} aggregator `);
-        const aggregatorNode = new EndpointNode(AggregatorEndpoint, { id: `${await storageContext.get('storeId')}` });
+        const aggregatorNode = new Endpoint(AggregatorEndpoint, { id: `${await storageContext.get('storeId')}` });
         return aggregatorNode;
     }
     async addBridgedEndpoint(pluginName, device) {

package/dist/matterbridgeEndpointHelpers.js

@@ -227,17 +227,18 @@ export function getBehavior(endpoint, cluster) {
 export async function invokeBehaviorCommand(endpoint, cluster, command, params) {
     const behaviorId = getBehavior(endpoint, cluster)?.id;
     if (!behaviorId) {
-        endpoint.log.error(`invokeBehaviorCommand error: command ${hk}${command}${er} not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
-        return;
+        endpoint.log?.error(`invokeBehaviorCommand error: command ${hk}${command}${er} not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+        return false;
     }
     await endpoint.act((agent) => {
         const behavior = agent[behaviorId];
         if (!(command in behavior) || typeof behavior[command] !== 'function') {
-            endpoint.log.error(`invokeBehaviorCommand error: command ${hk}${command}${er} not found on agent for endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
-            return;
+            endpoint.log?.error(`invokeBehaviorCommand error: command ${hk}${command}${er} not found on agent for endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+            return false;
         }
         behavior[command](params);
     });
+    return true;
 }
 export function addRequiredClusterServers(endpoint) {
     const requiredServerList = [];

package/dist/shelly.js

@@ -119,8 +119,6 @@ export async function triggerShellyChangeIp(matterbridge, config) {
         matterbridge.log.debug(`****Error triggering Shelly network configuration change: ${error instanceof Error ? error.message : error}`);
         matterbridge.log.error(`Error changing Shelly network configuration: ${error instanceof Error ? error.message : error}`);
         matterbridge.frontend.wssSendSnackbarMessage('Error changing Shelly network configuration', 10, 'error');
-    })
-        .finally(() => {
     });
 }
 export async function triggerShellyReboot(matterbridge) {
@@ -135,8 +133,6 @@ export async function triggerShellyReboot(matterbridge) {
         matterbridge.log.debug(`****Error triggering Shelly system reboot: ${error instanceof Error ? error.message : error}`);
         matterbridge.log.error(`Error rebooting Shelly board: ${error instanceof Error ? error.message : error}`);
         matterbridge.frontend.wssSendSnackbarMessage('Error rebooting Shelly board', 10, 'error');
-    })
-        .finally(() => {
     });
 }
 export async function triggerShellySoftReset(matterbridge) {
@@ -151,8 +147,6 @@ export async function triggerShellySoftReset(matterbridge) {
         matterbridge.log.debug(`****Error triggering Shelly soft reset: ${error instanceof Error ? error.message : error}`);
         matterbridge.log.error(`Error resetting the network parameters on Shelly board: ${error instanceof Error ? error.message : error}`);
         matterbridge.frontend.wssSendSnackbarMessage('Error resetting the network parameters on Shelly board', 10, 'error');
-    })
-        .finally(() => {
     });
 }
 export async function triggerShellyHardReset(matterbridge) {
@@ -167,8 +161,6 @@ export async function triggerShellyHardReset(matterbridge) {
         matterbridge.log.debug(`****Error triggering Shelly hard reset: ${error instanceof Error ? error.message : error}`);
         matterbridge.log.error(`Error while factory resetting the Shelly board: ${error instanceof Error ? error.message : error}`);
         matterbridge.frontend.wssSendSnackbarMessage('Error while factory resetting the Shelly board', 10, 'error');
-    })
-        .finally(() => {
     });
 }
 export async function createShellySystemLog(matterbridge) {
@@ -190,7 +182,7 @@ export async function createShellySystemLog(matterbridge) {
         matterbridge.log.warn(`Error getting Shelly system log: ${error instanceof Error ? error.message : error}`);
     });
 }
-async function getShelly(api, timeout = 60000) {
+export async function getShelly(api, timeout = 60000) {
     const http = await import('node:http');
     return new Promise((resolve, reject) => {
         const url = `http://127.0.0.1:8101${api}`;
@@ -233,7 +225,7 @@ async function getShelly(api, timeout = 60000) {
         });
     });
 }
-async function postShelly(api, data, timeout = 60000) {
+export async function postShelly(api, data, timeout = 60000) {
     const http = await import('node:http');
     return new Promise((resolve, reject) => {
         const url = `http://127.0.0.1:8101${api}`;

package/dist/update.js

@@ -1,22 +1,28 @@
+import { db, nt, wr } from 'node-ansi-logger';
 import { plg } from './matterbridgeTypes.js';
-import { db, nt, wr } from './logger/export.js';
 export async function checkUpdates(matterbridge) {
     const { hasParameter } = await import('./utils/commandLine.js');
-    getMatterbridgeLatestVersion(matterbridge);
-    getMatterbridgeDevVersion(matterbridge);
+    const latestVersion = getMatterbridgeLatestVersion(matterbridge);
+    const devVersion = getMatterbridgeDevVersion(matterbridge);
+    const pluginsVersions = [];
+    const shellyUpdates = [];
     for (const plugin of matterbridge.plugins) {
-        getPluginLatestVersion(matterbridge, plugin);
+        const pluginVersion = getPluginLatestVersion(matterbridge, plugin);
+        pluginsVersions.push(pluginVersion);
     }
     if (hasParameter('shelly')) {
         const { getShellySysUpdate, getShellyMainUpdate } = await import('./shelly.js');
-        getShellySysUpdate(matterbridge);
-        getShellyMainUpdate(matterbridge);
+        const systemUpdate = getShellySysUpdate(matterbridge);
+        shellyUpdates.push(systemUpdate);
+        const mainUpdate = getShellyMainUpdate(matterbridge);
+        shellyUpdates.push(mainUpdate);
     }
+    await Promise.all([latestVersion, devVersion, ...pluginsVersions, ...shellyUpdates]);
 }
-async function getMatterbridgeLatestVersion(matterbridge) {
+export async function getMatterbridgeLatestVersion(matterbridge) {
     const { getNpmPackageVersion } = await import('./utils/network.js');
-    getNpmPackageVersion('matterbridge')
-        .then(async (version) => {
+    try {
+        const version = await getNpmPackageVersion('matterbridge');
         matterbridge.matterbridgeLatestVersion = version;
         matterbridge.matterbridgeInformation.matterbridgeLatestVersion = version;
         await matterbridge.nodeContext?.set('matterbridgeLatestVersion', matterbridge.matterbridgeLatestVersion);
@@ -28,15 +34,16 @@ async function getMatterbridgeLatestVersion(matterbridge) {
         else {
             matterbridge.log.debug(`Matterbridge is up to date. Current version: ${matterbridge.matterbridgeVersion}. Latest version: ${matterbridge.matterbridgeLatestVersion}.`);
         }
-    })
-        .catch((error) => {
-        matterbridge.log.warn(`Error getting Matterbridge latest version: ${error.message}`);
-    });
+        return version;
+    }
+    catch (error) {
+        matterbridge.log.warn(`Error getting Matterbridge latest version: ${error instanceof Error ? error.message : error}`);
+    }
 }
-async function getMatterbridgeDevVersion(matterbridge) {
+export async function getMatterbridgeDevVersion(matterbridge) {
     const { getNpmPackageVersion } = await import('./utils/network.js');
-    getNpmPackageVersion('matterbridge', 'dev')
-        .then(async (version) => {
+    try {
+        const version = await getNpmPackageVersion('matterbridge', 'dev');
         matterbridge.matterbridgeDevVersion = version;
         matterbridge.matterbridgeInformation.matterbridgeDevVersion = version;
         await matterbridge.nodeContext?.set('matterbridgeDevVersion', version);
@@ -45,15 +52,19 @@ async function getMatterbridgeDevVersion(matterbridge) {
             matterbridge.frontend.wssSendRefreshRequired('matterbridgeDevVersion');
             matterbridge.frontend.wssSendUpdateRequired();
         }
-    })
-        .catch((error) => {
-        matterbridge.log.warn(`Error getting Matterbridge latest dev version: ${error.message}`);
-    });
+        else {
+            matterbridge.log.debug(`Matterbridge@dev is up to date. Current version: ${matterbridge.matterbridgeVersion}. Latest dev version: ${matterbridge.matterbridgeDevVersion}.`);
+        }
+        return version;
+    }
+    catch (error) {
+        matterbridge.log.warn(`Error getting Matterbridge latest dev version: ${error instanceof Error ? error.message : error}`);
+    }
 }
-async function getPluginLatestVersion(matterbridge, plugin) {
+export async function getPluginLatestVersion(matterbridge, plugin) {
     const { getNpmPackageVersion } = await import('./utils/network.js');
-    getNpmPackageVersion(plugin.name)
-        .then((version) => {
+    try {
+        const version = await getNpmPackageVersion(plugin.name);
         plugin.latestVersion = version;
         if (plugin.version !== plugin.latestVersion) {
             matterbridge.log.notice(`The plugin ${plg}${plugin.name}${nt} is out of date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
@@ -62,8 +73,9 @@ async function getPluginLatestVersion(matterbridge, plugin) {
         else {
             matterbridge.log.debug(`The plugin ${plg}${plugin.name}${db} is up to date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
         }
-    })
-        .catch((error) => {
-        matterbridge.log.warn(`Error getting ${plg}${plugin.name}${wr} latest version: ${error.message}`);
-    });
+        return version;
+    }
+    catch (error) {
+        matterbridge.log.warn(`Error getting plugin ${plg}${plugin.name}${wr} latest version: ${error instanceof Error ? error.message : error}`);
+    }
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.2-dev-20250512-ae61aa7",
+  "version": "3.0.2-dev-20250514-175db7e",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.2-dev-20250512-ae61aa7",
+      "version": "3.0.2-dev-20250514-175db7e",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.2-dev-20250512-ae61aa7",
+  "version": "3.0.2-dev-20250514-175db7e",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",