matterbridge 2.1.6-dev.8 → 2.2.0-dev.1

package/CHANGELOG.md

@@ -33,7 +33,7 @@ matterbridge-zigbee2mqtt v. 2.4.4
 matterbridge-somfy-tahoma v. 1.2.3
 matterbridge-hass v. 0.0.8
 
-## [2.1.6] - 2025-02-20
+## [2.2.0] - 2025-02-25
 
 ### Added
 
@@ -41,7 +41,7 @@ matterbridge-hass v. 0.0.8
 - [platform]: Saving in the storage the selects for faster loading of plugins.
 - [icon]: Added matterbridge svg icon (thanks: https://github.com/robvanoostenrijk https://github.com/stuntguy3000).
 - [pluginManager]: Refactor PluginManager to optimize memory and load time.
-- [frontend]: Frontend v.2.4.2.
+- [frontend]: Frontend v.2.4.3. Please refresh the frontend page after the update.
 - [frontend]: Added processUptime.
 - [frontend]: Added Share fabrics and Stop sharing to the menu. This allows to pair other controllers without the need to share from the first controller.
 - [frontend]: Added subscriptions to QRDiv.
@@ -53,6 +53,8 @@ matterbridge-hass v. 0.0.8
 - [package]: Update matter.js to 0.12.4-alpha.0-20250213-1187f81eb
 - [package]: Update matter.js to 0.12.4-alpha.0-20250215-5af08a8d6
 - [package]: Update matter.js to 0.12.4-alpha.0-20250217-b0bba5179
+- [package]: Update matter.js to 0.12.4-alpha.0-20250223-1e0341a1a
+- [package]: Update matter.js to 0.12.4-alpha.0-20250224-46934b522
 
 ### Fixed
 

package/README-NGINX.md

@@ -16,18 +16,19 @@
 
 ## Run matterbridge with nginx
 
-### Create the nginx configuration file
+### Create a basic nginx configuration file
 
 ```
 sudo nano /etc/nginx/sites-available/matterbridge
 ```
 
-paste this configuration and change the port to listen and the server_name using yours:
+paste this configuration and if desired change the port to listen (here is 80) and the server_name using yours:
 
 ```
 server {
-    listen 8099;
-    server_name ubuntu.local;
+    listen 80 default_server;
+    listen [::]:80 default_server;
+    server_name _;
 
     location /matterbridge/ {
         # Redirect to Matterbridge frontend
@@ -45,7 +46,72 @@ server {
 }
 ```
 
-add matterbridge to enabled sites
+Add matterbridge to enabled sites
+
+```
+sudo ln -s /etc/nginx/sites-available/matterbridge /etc/nginx/sites-enabled/
+```
+
+### Create an advanced nginx configuration file that redirect to ssl
+
+```
+sudo nano /etc/nginx/sites-available/matterbridge
+```
+
+paste this configuration adding your certificates:
+
+```
+# Redirect all HTTP requests to HTTPS
+server {
+    listen 80 default_server;
+    listen [::]:80 default_server;
+    server_name _;
+
+    return 301 https://$host$request_uri;
+}
+
+# HTTPS server configuration
+server {
+	listen 443 ssl default_server;
+    listen [::]:443 ssl default_server;
+	http2 on;
+	server_name _;
+
+	# SSL certificate paths
+    ssl_certificate /etc/nginx/certs/cert.pem;
+    ssl_certificate_key /etc/nginx/certs/key.pem;
+
+    # SSL security settings
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers HIGH:!aNULL:!MD5;
+    ssl_prefer_server_ciphers on;
+
+	root /var/www/html;
+	index index.html index.htm index.nginx-debian.html;
+
+	location / {
+		# First attempt to serve request as file, then
+		# as directory, then fall back to displaying a 404.
+		try_files $uri $uri/ =404;
+	}
+
+    location /matterbridge/ {
+	    # Redirect to Matterbridge frontend
+        proxy_pass http://localhost:8283/;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+	    # WebSocket support
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}
+```
+
+Add matterbridge to enabled sites
 
 ```
 sudo ln -s /etc/nginx/sites-available/matterbridge /etc/nginx/sites-enabled/
@@ -60,4 +126,8 @@ sudo nginx -t
 
 ### Use matterbridge with nginx
 
-http://ubuntu.local:8099/matterbridge/
+http://ubuntu/matterbridge/
+
+or
+
+https://ubuntu/matterbridge/

package/dist/frontend.js

@@ -17,6 +17,8 @@ export const WS_ID_CPU_UPDATE = 3;
 export const WS_ID_MEMORY_UPDATE = 4;
 export const WS_ID_UPTIME_UPDATE = 5;
 export const WS_ID_SNACKBAR = 6;
+export const WS_ID_SHELLY_SYS_UPDATE = 100;
+export const WS_ID_SHELLY_MAIN_UPDATE = 101;
 export class Frontend {
     matterbridge;
     log;
@@ -656,8 +658,9 @@ export class Frontend {
                     if (!plugin)
                         return;
                     this.matterbridge.plugins.saveConfigFromJson(plugin, req.body);
+                    this.wssSendSnackbarMessage(`Saved config for plugin ${param}`);
+                    this.wssSendRestartRequired();
                 }
-                this.wssSendRestartRequired();
                 res.json({ message: 'Command received' });
                 return;
             }
@@ -1075,6 +1078,22 @@ export class Frontend {
                 });
                 return;
             }
+            else if (data.method === '/api/shellysysupdate') {
+                const { triggerShellySysUpdate } = await import('./shelly.js');
+                triggerShellySysUpdate(this.matterbridge);
+                return;
+            }
+            else if (data.method === '/api/shellymainupdate') {
+                const { triggerShellyMainUpdate } = await import('./shelly.js');
+                triggerShellyMainUpdate(this.matterbridge);
+                return;
+            }
+            else if (data.method === '/api/shellynetconfig') {
+                this.log.debug('/api/shellynetconfig:', data.params);
+                const { triggerShellyChangeIp: triggerShellyChangeNet } = await import('./shelly.js');
+                triggerShellyChangeNet(this.matterbridge, data.params);
+                return;
+            }
             else if (data.method === '/api/restart') {
                 this.wssSendSnackbarMessage(`Restarting matterbridge...`, 0);
                 await this.matterbridge.restartProcess();
@@ -1242,7 +1261,7 @@ export class Frontend {
                 client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, plugin: data.params.plugin, deviceName, serialNumber, endpoint: data.params.endpoint, deviceTypes, response: clusters }));
                 return;
             }
-            else if (data.method === '/api/select') {
+            else if (data.method === '/api/select' || data.method === '/api/select/devices') {
                 if (!isValidString(data.params.plugin, 10)) {
                     client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/select' }));
                     return;
@@ -1319,6 +1338,7 @@ export class Frontend {
     wssSendRestartRequired() {
         this.log.debug('Sending a restart required message to all connected clients');
         this.matterbridge.matterbridgeInformation.restartRequired = true;
+        this.wssSendSnackbarMessage(`Restart required`, 0);
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_RESTART_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', params: {} }));
@@ -1357,4 +1377,12 @@ export class Frontend {
             }
         });
     }
+    wssBroadcastMessage(id, method, params) {
+        this.log.debug(`Sending a broadcast message id ${id} method ${method} params ${debugStringify(params ?? {})} to all connected clients`);
+        this.webSocketServer?.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({ id, src: 'Matterbridge', dst: 'Frontend', method, params }));
+            }
+        });
+    }
 }

package/dist/matterbridge.js

@@ -2,10 +2,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
 import EventEmitter from 'node:events';
-import { AnsiLogger, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, CYAN, nt } from './logger/export.js';
+import { AnsiLogger, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, CYAN } from './logger/export.js';
 import { NodeStorageManager } from './storage/export.js';
 import { getParameter, getIntParameter, hasParameter, copyDirectory, withTimeout } from './utils/export.js';
-import { logInterfaces, getNpmPackageVersion, getGlobalNodeModules } from './utils/network.js';
+import { logInterfaces, getGlobalNodeModules } from './utils/network.js';
 import { PluginManager } from './pluginManager.js';
 import { DeviceManager } from './deviceManager.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
@@ -14,6 +14,9 @@ import { Frontend } from './frontend.js';
 import { DeviceTypeId, Endpoint as EndpointNode, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, VendorId, StorageService, Environment, ServerNode } from '@matter/main';
 import { DeviceCommissioner, FabricAction, MdnsService, PaseClient } from '@matter/main/protocol';
 import { AggregatorEndpoint } from '@matter/main/endpoints';
+import { BasicInformationServer } from '@matter/main/behaviors/basic-information';
+import { BridgedDeviceBasicInformation } from '@matter/main/clusters/bridged-device-basic-information';
+import { BasicInformation } from '@matter/main/clusters/basic-information';
 const plg = '\u001B[38;5;33m';
 const dev = '\u001B[38;5;79m';
 const typ = '\u001B[38;5;207m';
@@ -57,6 +60,8 @@ export class Matterbridge extends EventEmitter {
         restartMode: '',
         readOnly: hasParameter('readonly') || hasParameter('shelly'),
         shellyBoard: hasParameter('shelly'),
+        shellySysUpdate: false,
+        shellyMainUpdate: false,
         profile: getParameter('profile'),
         loggerLevel: "info",
         fileLogger: false,
@@ -102,6 +107,7 @@ export class Matterbridge extends EventEmitter {
     execRunningCount = 0;
     startMatterInterval;
     checkUpdateInterval;
+    checkUpdateTimeout;
     configureTimeout;
     reachabilityTimeout;
     sigintHandler;
@@ -565,17 +571,14 @@ export class Matterbridge extends EventEmitter {
         }
         if (getIntParameter('frontend') !== 0 || getIntParameter('frontend') === undefined)
             await this.frontend.start(getIntParameter('frontend'));
-        this.getMatterbridgeLatestVersion();
-        for (const plugin of this.plugins) {
-            this.getPluginLatestVersion(plugin);
-        }
-        this.checkUpdateInterval = setInterval(() => {
-            this.getMatterbridgeLatestVersion();
-            for (const plugin of this.plugins) {
-                this.getPluginLatestVersion(plugin);
-            }
-            this.frontend.wssSendRefreshRequired();
-        }, 60 * 60 * 1000);
+        this.checkUpdateTimeout = setTimeout(async () => {
+            const { checkUpdates } = await import('./update.js');
+            checkUpdates(this);
+        }, 30 * 1000).unref();
+        this.checkUpdateInterval = setInterval(async () => {
+            const { checkUpdates } = await import('./update.js');
+            checkUpdates(this);
+        }, 24 * 60 * 60 * 1000).unref();
         if (hasParameter('test')) {
             this.bridgeMode = 'bridge';
             MatterbridgeEndpoint.bridgeMode = 'bridge';
@@ -812,37 +815,6 @@ export class Matterbridge extends EventEmitter {
         const cmdArgs = process.argv.slice(2).join(' ');
         this.log.debug(`Command Line Arguments: ${cmdArgs}`);
     }
-    async getMatterbridgeLatestVersion() {
-        getNpmPackageVersion('matterbridge')
-            .then(async (version) => {
-            this.matterbridgeLatestVersion = version;
-            this.matterbridgeInformation.matterbridgeLatestVersion = version;
-            await this.nodeContext?.set('matterbridgeLatestVersion', this.matterbridgeLatestVersion);
-            if (this.matterbridgeVersion !== this.matterbridgeLatestVersion) {
-                this.log.notice(`Matterbridge is out of date. Current version: ${this.matterbridgeVersion}. Latest version: ${this.matterbridgeLatestVersion}.`);
-            }
-            else {
-                this.log.debug(`Matterbridge is up to date. Current version: ${this.matterbridgeVersion}. Latest version: ${this.matterbridgeLatestVersion}.`);
-            }
-            this.frontend.wssSendRefreshRequired();
-        })
-            .catch((error) => {
-            this.log.warn(`Error getting Matterbridge latest version: ${error.message}`);
-        });
-    }
-    async getPluginLatestVersion(plugin) {
-        getNpmPackageVersion(plugin.name)
-            .then((version) => {
-            plugin.latestVersion = version;
-            if (plugin.version !== plugin.latestVersion)
-                this.log.notice(`The plugin ${plg}${plugin.name}${nt} is out of date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
-            else
-                this.log.debug(`The plugin ${plg}${plugin.name}${db} is up to date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
-        })
-            .catch((error) => {
-            this.log.warn(`Error getting ${plg}${plugin.name}${er} latest version: ${error.message}`);
-        });
-    }
     createMatterLogger() {
         const matterLogger = new AnsiLogger({ logName: 'Matter', logTimestampFormat: 4, logLevel: "debug" });
         return (_level, formattedLog) => {
@@ -966,6 +938,11 @@ export class Matterbridge extends EventEmitter {
                 this.startMatterInterval = undefined;
                 this.log.debug('Start matter interval cleared');
             }
+            if (this.checkUpdateTimeout) {
+                clearInterval(this.checkUpdateTimeout);
+                this.checkUpdateTimeout = undefined;
+                this.log.debug('Check update timeout cleared');
+            }
             if (this.checkUpdateInterval) {
                 clearInterval(this.checkUpdateInterval);
                 this.checkUpdateInterval = undefined;
@@ -1673,11 +1650,18 @@ export class Matterbridge extends EventEmitter {
             };
         });
     }
-    setServerNodeReachability(serverNode, reachable) {
+    async setServerNodeReachability(serverNode, reachable) {
+        await serverNode.setStateOf(BasicInformationServer, { reachable });
     }
-    setAggregatorReachability(aggregatorNode, reachable) {
+    async setAggregatorReachability(aggregatorNode, reachable) {
+        for (const child of aggregatorNode.parts) {
+            await child.setAttribute(BridgedDeviceBasicInformation.Cluster.id, 'reachable', reachable);
+            await child.triggerEvent(BridgedDeviceBasicInformation.Cluster.id, 'reachableChanged', { reachableNewValue: reachable });
+        }
     }
-    setDeviceReachability(device, reachable) {
+    async setDeviceReachability(device, reachable) {
+        await device.setAttribute(BasicInformation.Cluster.id, 'reachable', reachable);
+        await device.triggerEvent(BasicInformation.Cluster.id, 'reachableChanged', { reachableNewValue: reachable });
     }
     getVendorIdName = (vendorId) => {
         if (!vendorId)

package/dist/shelly.js

@@ -0,0 +1,176 @@
+import { WS_ID_SHELLY_MAIN_UPDATE, WS_ID_SHELLY_SYS_UPDATE } from './frontend.js';
+import { debugStringify } from './logger/export.js';
+export async function getShellySysUpdate(matterbridge) {
+    getShelly('/api/updates/sys/check', 60 * 1000)
+        .then(async (data) => {
+        if (data.length > 0) {
+            matterbridge.matterbridgeInformation.shellySysUpdate = true;
+            matterbridge.log.notice(`Shelly system update available: ${debugStringify(data)}`);
+            matterbridge.frontend.wssSendSnackbarMessage('Shelly system update available', 60);
+            matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_SYS_UPDATE, 'shelly-sys-update', { available: true });
+            for (const update of data) {
+                if (update.name)
+                    matterbridge.frontend.wssSendSnackbarMessage('Shelly system update available: ' + update.name, 10);
+            }
+        }
+    })
+        .catch((error) => {
+        matterbridge.log.warn(`Error getting Shelly system updates: ${error instanceof Error ? error.message : error}`);
+    });
+}
+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(() => {
+        matterbridge.matterbridgeInformation.shellySysUpdate = false;
+        matterbridge.log.notice(`Installing Shelly system update...`);
+        matterbridge.frontend.wssSendSnackbarMessage('Installing Shelly system update...', 60);
+        matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_SYS_UPDATE, 'shelly-sys-update', { available: false });
+    });
+}
+export async function getShellyMainUpdate(matterbridge) {
+    getShelly('/api/updates/main/check', 60 * 1000)
+        .then(async (data) => {
+        if (data.length > 0) {
+            matterbridge.matterbridgeInformation.shellyMainUpdate = true;
+            matterbridge.log.notice(`Shelly software update available: ${debugStringify(data)}`);
+            matterbridge.frontend.wssSendSnackbarMessage('Shelly software update available', 60);
+            matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_MAIN_UPDATE, 'shelly-main-update', { available: true });
+            for (const update of data) {
+                if (update.name)
+                    matterbridge.frontend.wssSendSnackbarMessage('Shelly software update available: ' + update.name, 10);
+            }
+        }
+    })
+        .catch((error) => {
+        matterbridge.log.warn(`Error getting Shelly main updates: ${error instanceof Error ? error.message : error}`);
+    });
+}
+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(() => {
+        matterbridge.matterbridgeInformation.shellyMainUpdate = false;
+        matterbridge.log.notice(`Installing Shelly software update...`);
+        matterbridge.frontend.wssSendSnackbarMessage('Installing Shelly software update...', 60);
+        matterbridge.frontend.wssBroadcastMessage(WS_ID_SHELLY_MAIN_UPDATE, 'shelly-main-update', { available: false });
+    });
+}
+export async function triggerShellyChangeIp(matterbridge, config) {
+    const api = config.type === 'static' ? '/api/network/connection/static' : '/api/network/connection/dynamic';
+    const data = { interface: 'end0' };
+    if (config.type === 'static') {
+        data['addr'] = config.ip;
+        data['mask'] = config.subnet;
+        data['gw'] = config.gateway;
+        data['dns'] = config.dns;
+    }
+    matterbridge.log.debug(`Triggering Shelly network configuration change: ${debugStringify(config)}`);
+    postShelly(api, data, 60 * 1000)
+        .then(async () => {
+        matterbridge.log.debug(`Triggered Shelly network configuration change: ${debugStringify(config)}`);
+    })
+        .catch((error) => {
+        matterbridge.log.debug(`****Error triggering Shelly network configuration change: ${error instanceof Error ? error.message : error}`);
+    })
+        .finally(() => {
+        matterbridge.log.notice(`Changed Shelly network configuration`);
+        matterbridge.frontend.wssSendSnackbarMessage('Changed Shelly network configuration');
+    });
+}
+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}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`Request timed out after ${timeout / 1000} seconds`));
+        }, timeout).unref();
+        const req = http.get(url, { signal: controller.signal }, (res) => {
+            let data = '';
+            if (res.statusCode !== 200) {
+                clearTimeout(timeoutId);
+                res.resume();
+                req.destroy();
+                reject(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
+                return;
+            }
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                clearTimeout(timeoutId);
+                try {
+                    const jsonData = JSON.parse(data);
+                    resolve(jsonData);
+                }
+                catch (error) {
+                    reject(new Error(`Failed to parse response JSON: ${error instanceof Error ? error.message : error}`));
+                }
+            });
+        });
+        req.on('error', (error) => {
+            clearTimeout(timeoutId);
+            reject(new Error(`Request failed: ${error instanceof Error ? error.message : error}`));
+        });
+    });
+}
+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}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`Request timed out after ${timeout / 1000} seconds`));
+        }, timeout).unref();
+        const jsonData = JSON.stringify(data);
+        const options = {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(jsonData),
+            },
+            signal: controller.signal,
+        };
+        const req = http.request(url, options, (res) => {
+            let responseData = '';
+            if (res.statusCode && res.statusCode >= 300) {
+                clearTimeout(timeoutId);
+                res.resume();
+                req.destroy();
+                return reject(new Error(`Failed to post data. Status code: ${res.statusCode}`));
+            }
+            res.on('data', (chunk) => {
+                responseData += chunk;
+            });
+            res.on('end', () => {
+                clearTimeout(timeoutId);
+                try {
+                    const jsonResponse = JSON.parse(responseData);
+                    resolve(jsonResponse);
+                }
+                catch (err) {
+                    reject(new Error(`Failed to parse response JSON: ${err instanceof Error ? err.message : err}`));
+                }
+            });
+        });
+        req.on('error', (error) => {
+            clearTimeout(timeoutId);
+            reject(new Error(`Request failed: ${error instanceof Error ? error.message : error}`));
+        });
+        req.write(jsonData);
+        req.end();
+    });
+}

package/dist/update.js

@@ -0,0 +1,50 @@
+import { plg } from './matterbridgeTypes.js';
+import { db, er, nt } from './logger/export.js';
+export async function checkUpdates(matterbridge) {
+    const { hasParameter } = await import('./utils/parameter.js');
+    getMatterbridgeLatestVersion(matterbridge);
+    for (const plugin of matterbridge.plugins) {
+        getPluginLatestVersion(matterbridge, plugin);
+    }
+    if (hasParameter('shelly')) {
+        const { getShellySysUpdate, getShellyMainUpdate } = await import('./shelly.js');
+        getShellySysUpdate(matterbridge);
+        getShellyMainUpdate(matterbridge);
+    }
+}
+async function getMatterbridgeLatestVersion(matterbridge) {
+    const { getNpmPackageVersion } = await import('./utils/network.js');
+    getNpmPackageVersion('matterbridge')
+        .then(async (version) => {
+        matterbridge.matterbridgeLatestVersion = version;
+        matterbridge.matterbridgeInformation.matterbridgeLatestVersion = version;
+        await matterbridge.nodeContext?.set('matterbridgeLatestVersion', matterbridge.matterbridgeLatestVersion);
+        if (matterbridge.matterbridgeVersion !== matterbridge.matterbridgeLatestVersion) {
+            matterbridge.log.notice(`Matterbridge is out of date. Current version: ${matterbridge.matterbridgeVersion}. Latest version: ${matterbridge.matterbridgeLatestVersion}.`);
+            matterbridge.frontend.wssSendRefreshRequired();
+        }
+        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}`);
+    });
+}
+async function getPluginLatestVersion(matterbridge, plugin) {
+    const { getNpmPackageVersion } = await import('./utils/network.js');
+    getNpmPackageVersion(plugin.name)
+        .then((version) => {
+        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}.`);
+            matterbridge.frontend.wssSendRefreshRequired();
+        }
+        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}${er} latest version: ${error.message}`);
+    });
+}

package/frontend/build/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.cf25d33e.css",
-    "main.js": "./static/js/main.f3c386d7.js",
+    "main.js": "./static/js/main.fed77626.js",
     "static/js/453.abd36b29.chunk.js": "./static/js/453.abd36b29.chunk.js",
     "static/media/roboto-latin-700-normal.woff2": "./static/media/roboto-latin-700-normal.4535474e1cf8598695ad.woff2",
     "static/media/roboto-latin-500-normal.woff2": "./static/media/roboto-latin-500-normal.7077203b1982951ecf76.woff2",
@@ -61,11 +61,11 @@
     "static/media/roboto-greek-ext-400-normal.woff": "./static/media/roboto-greek-ext-400-normal.16eb83b4a3b1ea994243.woff",
     "index.html": "./index.html",
     "main.cf25d33e.css.map": "./static/css/main.cf25d33e.css.map",
-    "main.f3c386d7.js.map": "./static/js/main.f3c386d7.js.map",
+    "main.fed77626.js.map": "./static/js/main.fed77626.js.map",
     "453.abd36b29.chunk.js.map": "./static/js/453.abd36b29.chunk.js.map"
   },
   "entrypoints": [
     "static/css/main.cf25d33e.css",
-    "static/js/main.f3c386d7.js"
+    "static/js/main.fed77626.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.f3c386d7.js"></script><link href="./static/css/main.cf25d33e.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.fed77626.js"></script><link href="./static/css/main.cf25d33e.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>