matterbridge 3.0.2-dev-20250513-ae61aa7 → 3.0.2-dev-20250514-827b4f2

package/CHANGELOG.md

@@ -12,17 +12,21 @@ 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.
+- [shelly] Refactor shelly api and added full Jest test.
 
 ### 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
 
+- [frontend]: Fixed refresh of start/stop sharing.
+
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
 </a>

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

@@ -1,80 +1,82 @@
 import { WS_ID_SHELLY_MAIN_UPDATE, WS_ID_SHELLY_SYS_UPDATE } from './frontend.js';
 import { debugStringify } from './logger/export.js';
+let verifyIntervalSecs = 15;
+let verifyTimeoutSecs = 600;
+export function setVerifyIntervalSecs(seconds) {
+    verifyIntervalSecs = seconds;
+}
+export function setVerifyTimeoutSecs(seconds) {
+    verifyTimeoutSecs = seconds;
+}
 export async function getShellySysUpdate(matterbridge) {
-    getShelly('/api/updates/sys/check', 60 * 1000)
-        .then(async (data) => {
-        if (data.length > 0) {
-            matterbridge.matterbridgeInformation.shellySysUpdate = true;
-            matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_SYS_UPDATE, 'shelly-sys-update', { available: true });
-            for (const update of data) {
-                if (update.name)
-                    matterbridge.log.notice(`Shelly system update available: ${update.name}`);
-                if (update.name)
-                    matterbridge.frontend.wssSendSnackbarMessage(`Shelly system update available: ${update.name}`, 10);
-            }
+    try {
+        const updates = (await getShelly('/api/updates/sys/check'));
+        if (updates.length === 0)
+            return;
+        matterbridge.matterbridgeInformation.shellySysUpdate = true;
+        matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_SYS_UPDATE, 'shelly-sys-update', { available: true });
+        for (const { name } of updates) {
+            if (!name)
+                continue;
+            matterbridge.log.notice(`Shelly system update available: ${name}`);
+            matterbridge.frontend.wssSendSnackbarMessage(`Shelly system update available: ${name}`, 10);
         }
-    })
-        .catch((error) => {
-        matterbridge.log.warn(`Error getting Shelly system updates: ${error instanceof Error ? error.message : error}`);
-    });
+    }
+    catch (err) {
+        matterbridge.log.error(`Error getting Shelly system updates: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 export async function triggerShellySysUpdate(matterbridge) {
-    getShelly('/api/updates/sys/perform', 10 * 1000)
-        .then(async () => {
-        matterbridge.log.debug(`Triggered Shelly system updates`);
-    })
-        .catch((error) => {
-        matterbridge.log.debug(`****Error triggering Shelly system updates: ${error instanceof Error ? error.message : error}`);
-    })
-        .finally(() => {
+    try {
+        await getShelly('/api/updates/sys/perform');
+        matterbridge.log.notice('Installing Shelly system update...');
         matterbridge.matterbridgeInformation.shellySysUpdate = false;
-        matterbridge.log.notice(`Installing Shelly system update...`);
         matterbridge.frontend.wssSendSnackbarMessage('Installing Shelly system update...', 15);
         matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_SYS_UPDATE, 'shelly-sys-update', { available: false });
-        verifyShellyUpdate(matterbridge, '/api/updates/sys/status', 'Shelly system update');
-    });
+        await verifyShellyUpdate(matterbridge, '/api/updates/sys/status', 'Shelly system update');
+    }
+    catch (err) {
+        matterbridge.log.error(`Error triggering Shelly system update: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 export async function getShellyMainUpdate(matterbridge) {
-    getShelly('/api/updates/main/check', 60 * 1000)
-        .then(async (data) => {
-        if (data.length > 0) {
-            matterbridge.matterbridgeInformation.shellyMainUpdate = true;
-            matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_MAIN_UPDATE, 'shelly-main-update', { available: true });
-            for (const update of data) {
-                if (update.name)
-                    matterbridge.log.notice(`Shelly software update available: ${update.name}`);
-                if (update.name)
-                    matterbridge.frontend.wssSendSnackbarMessage(`Shelly software update available: ${update.name}`, 10);
-            }
+    try {
+        const updates = (await getShelly('/api/updates/main/check'));
+        if (updates.length === 0)
+            return;
+        matterbridge.matterbridgeInformation.shellyMainUpdate = true;
+        matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_MAIN_UPDATE, 'shelly-main-update', { available: true });
+        for (const { name } of updates) {
+            if (!name)
+                continue;
+            matterbridge.log.notice(`Shelly software update available: ${name}`);
+            matterbridge.frontend.wssSendSnackbarMessage(`Shelly software update available: ${name}`, 10);
         }
-    })
-        .catch((error) => {
-        matterbridge.log.warn(`Error getting Shelly main updates: ${error instanceof Error ? error.message : error}`);
-    });
+    }
+    catch (err) {
+        matterbridge.log.error(`Error getting Shelly main updates: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 export async function triggerShellyMainUpdate(matterbridge) {
-    getShelly('/api/updates/main/perform', 10 * 1000)
-        .then(async () => {
-        matterbridge.log.debug(`Triggered Shelly main updates`);
-    })
-        .catch((error) => {
-        matterbridge.log.debug(`****Error triggering Shelly main updates: ${error instanceof Error ? error.message : error}`);
-    })
-        .finally(() => {
+    try {
+        await getShelly('/api/updates/main/perform');
+        matterbridge.log.notice('Installing Shelly software update...');
         matterbridge.matterbridgeInformation.shellyMainUpdate = false;
-        matterbridge.log.notice(`Installing Shelly software update...`);
         matterbridge.frontend.wssSendSnackbarMessage('Installing Shelly software update...', 15);
         matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_MAIN_UPDATE, 'shelly-main-update', { available: false });
-        verifyShellyUpdate(matterbridge, '/api/updates/main/status', 'Shelly software update');
-    });
+        await verifyShellyUpdate(matterbridge, '/api/updates/main/status', 'Shelly software update');
+    }
+    catch (err) {
+        matterbridge.log.error(`Error triggering Shelly main update: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 async function verifyShellyUpdate(matterbridge, api, name) {
     return new Promise((resolve) => {
         const timeout = setTimeout(() => {
-            matterbridge.log.warn(`${name} check timed out`);
+            matterbridge.log.error(`${name} check timed out`);
             clearInterval(interval);
             resolve();
-        }, 600 * 1000);
+        }, verifyTimeoutSecs * 1000);
         const interval = setInterval(() => {
             getShelly(api, 10 * 1000)
                 .then(async (data) => {
@@ -91,12 +93,12 @@ async function verifyShellyUpdate(matterbridge, api, name) {
                 }
             })
                 .catch((error) => {
-                matterbridge.log.warn(`Error getting status of ${name}: ${error instanceof Error ? error.message : error}`);
+                matterbridge.log.error(`Error getting status of ${name}: ${error instanceof Error ? error.message : String(error)}`);
                 clearInterval(interval);
                 clearTimeout(timeout);
                 resolve();
             });
-        }, 15 * 1000);
+        }, verifyIntervalSecs * 1000);
     });
 }
 export async function triggerShellyChangeIp(matterbridge, config) {
@@ -109,88 +111,75 @@ export async function triggerShellyChangeIp(matterbridge, config) {
         data['dns'] = config.dns;
     }
     matterbridge.log.debug(`Triggering Shelly network configuration change: ${debugStringify(config)}`);
-    postShelly(api, data, 60 * 1000)
-        .then(async () => {
+    try {
+        await postShelly(api, data);
         matterbridge.log.debug(`Triggered Shelly network configuration change: ${debugStringify(config)}`);
         matterbridge.log.notice(`Changed Shelly network configuration`);
         matterbridge.frontend.wssSendSnackbarMessage('Changed Shelly network configuration');
-    })
-        .catch((error) => {
-        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}`);
+    }
+    catch (error) {
+        matterbridge.log.debug(`****Error triggering Shelly network configuration change ${debugStringify(config)}: ${error instanceof Error ? error.message : String(error)}`);
+        matterbridge.log.error(`Error changing Shelly network configuration: ${error instanceof Error ? error.message : String(error)}`);
         matterbridge.frontend.wssSendSnackbarMessage('Error changing Shelly network configuration', 10, 'error');
-    })
-        .finally(() => {
-    });
+    }
 }
 export async function triggerShellyReboot(matterbridge) {
     matterbridge.log.debug(`Triggering Shelly system reboot`);
-    postShelly('/api/system/reboot', {}, 60 * 1000)
-        .then(async () => {
+    try {
+        await postShelly('/api/system/reboot', {});
         matterbridge.log.debug(`Triggered Shelly system reboot`);
         matterbridge.log.notice(`Rebooting Shelly board...`);
         matterbridge.frontend.wssSendSnackbarMessage('Rebooting Shelly board...');
-    })
-        .catch((error) => {
-        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}`);
+    }
+    catch (error) {
+        matterbridge.log.debug(`****Error triggering Shelly system reboot: ${error instanceof Error ? error.message : String(error)}`);
+        matterbridge.log.error(`Error rebooting Shelly board: ${error instanceof Error ? error.message : String(error)}`);
         matterbridge.frontend.wssSendSnackbarMessage('Error rebooting Shelly board', 10, 'error');
-    })
-        .finally(() => {
-    });
+    }
 }
 export async function triggerShellySoftReset(matterbridge) {
     matterbridge.log.debug(`Triggering Shelly soft reset`);
-    getShelly('/api/reset/soft', 60 * 1000)
-        .then(async () => {
+    try {
+        await getShelly('/api/reset/soft');
         matterbridge.log.debug(`Triggered Shelly soft reset`);
         matterbridge.log.notice(`Resetting the network parameters on Shelly board...`);
         matterbridge.frontend.wssSendSnackbarMessage('Resetting the network parameters on Shelly board...');
-    })
-        .catch((error) => {
-        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}`);
+    }
+    catch (error) {
+        matterbridge.log.debug(`****Error triggering Shelly soft reset: ${error instanceof Error ? error.message : String(error)}`);
+        matterbridge.log.error(`Error resetting the network parameters on Shelly board: ${error instanceof Error ? error.message : String(error)}`);
         matterbridge.frontend.wssSendSnackbarMessage('Error resetting the network parameters on Shelly board', 10, 'error');
-    })
-        .finally(() => {
-    });
+    }
 }
 export async function triggerShellyHardReset(matterbridge) {
     matterbridge.log.debug(`Triggering Shelly hard reset`);
-    getShelly('/api/reset/hard', 60 * 1000)
-        .then(async () => {
+    try {
+        await getShelly('/api/reset/hard');
         matterbridge.log.debug(`Triggered Shelly hard reset`);
         matterbridge.log.notice(`Factory resetting Shelly board...`);
         matterbridge.frontend.wssSendSnackbarMessage('Factory resetting Shelly board...');
-    })
-        .catch((error) => {
-        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}`);
+    }
+    catch (error) {
+        matterbridge.log.debug(`****Error triggering Shelly hard reset: ${error instanceof Error ? error.message : String(error)}`);
+        matterbridge.log.error(`Error while factory resetting the Shelly board: ${error instanceof Error ? error.message : String(error)}`);
         matterbridge.frontend.wssSendSnackbarMessage('Error while factory resetting the Shelly board', 10, 'error');
-    })
-        .finally(() => {
-    });
+    }
 }
 export async function createShellySystemLog(matterbridge) {
     const { promises: fs } = await import('node:fs');
     const path = await import('node:path');
     matterbridge.log.debug(`Downloading Shelly system log...`);
-    getShelly('/api/logs/system', 60 * 1000)
-        .then(async (data) => {
-        fs.writeFile(path.join(matterbridge.matterbridgeDirectory, 'shelly.log'), data)
-            .then(() => {
-            matterbridge.log.notice(`Shelly system log ready for download`);
-            matterbridge.frontend.wssSendSnackbarMessage('Shelly system log ready for download');
-        })
-            .catch((error) => {
-            matterbridge.log.warn(`Error writing Shelly system log to file: ${error instanceof Error ? error.message : error}`);
-        });
-    })
-        .catch((error) => {
-        matterbridge.log.warn(`Error getting Shelly system log: ${error instanceof Error ? error.message : error}`);
-    });
+    try {
+        const data = await getShelly('/api/logs/system');
+        await fs.writeFile(path.join(matterbridge.matterbridgeDirectory, 'shelly.log'), data);
+        matterbridge.log.notice(`Shelly system log ready for download`);
+        matterbridge.frontend.wssSendSnackbarMessage('Shelly system log ready for download');
+    }
+    catch (error) {
+        matterbridge.log.error(`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 +222,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/frontend/build/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.944b63c3.css",
-    "main.js": "./static/js/main.15906009.js",
+    "main.js": "./static/js/main.f6e0f736.js",
     "static/js/453.d855a71b.chunk.js": "./static/js/453.d855a71b.chunk.js",
     "static/media/roboto-latin-700-normal.woff2": "./static/media/roboto-latin-700-normal.c4d6cab43bec89049809.woff2",
     "static/media/roboto-latin-500-normal.woff2": "./static/media/roboto-latin-500-normal.599f66a60bdf974e578e.woff2",
@@ -77,11 +77,11 @@
     "static/media/roboto-greek-ext-300-normal.woff": "./static/media/roboto-greek-ext-300-normal.60729cafbded24073dfb.woff",
     "index.html": "./index.html",
     "main.944b63c3.css.map": "./static/css/main.944b63c3.css.map",
-    "main.15906009.js.map": "./static/js/main.15906009.js.map",
+    "main.f6e0f736.js.map": "./static/js/main.f6e0f736.js.map",
     "453.d855a71b.chunk.js.map": "./static/js/453.d855a71b.chunk.js.map"
   },
   "entrypoints": [
     "static/css/main.944b63c3.css",
-    "static/js/main.15906009.js"
+    "static/js/main.f6e0f736.js"
   ]
 }

package/frontend/build/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><base href="./"><link rel="icon" href="./matterbridge 32x32.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><title>Matterbridge</title><link rel="manifest" href="./manifest.json"/><script defer="defer" src="./static/js/main.15906009.js"></script><link href="./static/css/main.944b63c3.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><base href="./"><link rel="icon" href="./matterbridge 32x32.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><title>Matterbridge</title><link rel="manifest" href="./manifest.json"/><script defer="defer" src="./static/js/main.f6e0f736.js"></script><link href="./static/css/main.944b63c3.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>