matterbridge 3.2.8-dev-20250916-967e0b8 → 3.2.8-dev-20250918-52dc90c

package/dist/frontend.js

@@ -16,18 +16,6 @@ import { createZip, isValidArray, isValidNumber, isValidObject, isValidString, i
 import { plg } from './matterbridgeTypes.js';
 import { capitalizeFirstLetter, getAttribute } from './matterbridgeEndpointHelpers.js';
 import { cliEmitter, lastCpuUsage } from './cliEmitter.js';
-export const WS_ID_LOG = 0;
-export const WS_ID_REFRESH_NEEDED = 1;
-export const WS_ID_RESTART_NEEDED = 2;
-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_UPDATE_NEEDED = 7;
-export const WS_ID_STATEUPDATE = 8;
-export const WS_ID_CLOSE_SNACKBAR = 9;
-export const WS_ID_SHELLY_SYS_UPDATE = 100;
-export const WS_ID_SHELLY_MAIN_UPDATE = 101;
 export class Frontend extends EventEmitter {
     matterbridge;
     log;
@@ -212,7 +200,7 @@ export class Frontend extends EventEmitter {
                 callbackLogLevel = "info";
             if (this.matterbridge.matterbridgeInformation.loggerLevel === "debug" || this.matterbridge.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.DEBUG)
                 callbackLogLevel = "debug";
-            AnsiLogger.setGlobalCallback(this.wssSendMessage.bind(this), callbackLogLevel);
+            AnsiLogger.setGlobalCallback(this.wssSendLogMessage.bind(this), callbackLogLevel);
             this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
             this.log.info(`WebSocketServer client "${clientIp}" connected to Matterbridge`);
             ws.on('message', (message) => {
@@ -590,36 +578,18 @@ export class Frontend extends EventEmitter {
         }
         if (this.httpServer) {
             this.log.debug('Closing http server...');
-            await withTimeout(new Promise((resolve) => {
-                this.httpServer?.close((error) => {
-                    if (error) {
-                        this.log.error(`Error closing http server: ${error}`);
-                    }
-                    else {
-                        this.log.debug('Http server closed successfully');
-                        this.emit('server_stopped');
-                    }
-                    resolve();
-                });
-            }), 5000, false);
+            this.httpServer.close();
+            this.log.debug('Http server closed successfully');
+            this.emit('server_stopped');
             this.httpServer.removeAllListeners();
             this.httpServer = undefined;
             this.log.debug('Frontend http server closed successfully');
         }
         if (this.httpsServer) {
             this.log.debug('Closing https server...');
-            await withTimeout(new Promise((resolve) => {
-                this.httpsServer?.close((error) => {
-                    if (error) {
-                        this.log.error(`Error closing https server: ${error}`);
-                    }
-                    else {
-                        this.log.debug('Https server closed successfully');
-                        this.emit('server_stopped');
-                    }
-                    resolve();
-                });
-            }), 5000, false);
+            this.httpsServer.close();
+            this.log.debug('Https server closed successfully');
+            this.emit('server_stopped');
             this.httpsServer.removeAllListeners();
             this.httpsServer = undefined;
             this.log.debug('Frontend https server closed successfully');
@@ -853,7 +823,6 @@ export class Frontend extends EventEmitter {
                 funding: plugin.funding,
                 latestVersion: plugin.latestVersion,
                 devVersion: plugin.devVersion,
-                serialNumber: plugin.serialNumber,
                 locked: plugin.locked,
                 error: plugin.error,
                 enabled: plugin.enabled,
@@ -862,17 +831,11 @@ export class Frontend extends EventEmitter {
                 configured: plugin.configured,
                 restartRequired: plugin.restartRequired,
                 registeredDevices: plugin.registeredDevices,
-                addedDevices: plugin.addedDevices,
                 configJson: plugin.configJson,
                 schemaJson: plugin.schemaJson,
                 hasWhiteList: plugin.configJson?.whiteList !== undefined,
                 hasBlackList: plugin.configJson?.blackList !== undefined,
                 matter: plugin.serverNode ? this.matterbridge.getServerNodeData(plugin.serverNode) : undefined,
-                paired: plugin.serverNode && plugin.serverNode.lifecycle.isOnline ? plugin.serverNode.state.commissioning.commissioned : undefined,
-                qrPairingCode: this.matterbridge.matterbridgeInformation.matterbridgeEndAdvertise ? undefined : plugin.serverNode && plugin.serverNode.lifecycle.isOnline ? plugin.serverNode.state.commissioning.pairingCodes.qrPairingCode : undefined,
-                manualPairingCode: this.matterbridge.matterbridgeInformation.matterbridgeEndAdvertise ? undefined : plugin.serverNode && plugin.serverNode.lifecycle.isOnline ? plugin.serverNode.state.commissioning.pairingCodes.manualPairingCode : undefined,
-                fabricInformations: plugin.serverNode && plugin.serverNode.lifecycle.isOnline ? this.matterbridge.sanitizeFabricInformations(Object.values(plugin.serverNode.state.commissioning.fabrics)) : undefined,
-                sessionInformations: plugin.serverNode && plugin.serverNode.lifecycle.isOnline ? this.matterbridge.sanitizeSessionInformation(Object.values(plugin.serverNode.state.sessions.sessions)) : undefined,
             });
         }
         return baseRegisteredPlugins;
@@ -963,46 +926,53 @@ export class Frontend extends EventEmitter {
     }
     async wsMessageHandler(client, message) {
         let data;
+        const sendResponse = (data) => {
+            if (client.readyState === WebSocket.OPEN) {
+                const { response, ...rest } = data;
+                this.log.debug(`Sending api response broadcast message: ${debugStringify(rest)}`);
+                client.send(JSON.stringify(data));
+            }
+        };
         try {
             data = JSON.parse(message.toString());
-            if (!isValidNumber(data.id) || !isValidString(data.dst) || !isValidString(data.src) || !isValidString(data.method) || !isValidObject(data.params) || data.dst !== 'Matterbridge') {
+            if (!isValidNumber(data.id) || !isValidString(data.dst) || !isValidString(data.src) || !isValidString(data.method) || data.dst !== 'Matterbridge') {
                 this.log.error(`Invalid message from websocket client: ${debugStringify(data)}`);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid message' }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid message' });
                 return;
             }
             this.log.debug(`Received message from websocket client: ${debugStringify(data)}`);
             if (data.method === 'ping') {
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: 'pong' }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: 'pong' });
                 return;
             }
             else if (data.method === '/api/login') {
                 if (!this.matterbridge.nodeContext) {
                     this.log.error('Login nodeContext not found');
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Internal error: nodeContext not found' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Internal error: nodeContext not found' });
                     return;
                 }
                 const storedPassword = await this.matterbridge.nodeContext.get('password', '');
                 if (storedPassword === '' || storedPassword === data.params.password) {
                     this.log.debug('Login password valid');
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: { valid: true } }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                     return;
                 }
                 else {
                     this.log.debug('Error wrong password');
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong password' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong password' });
                     return;
                 }
             }
             else if (data.method === '/api/install') {
                 if (!isValidString(data.params.packageName, 10) || !isValidBoolean(data.params.restart)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter in /api/install' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter in /api/install' });
                     return;
                 }
                 this.wssSendSnackbarMessage(`Installing package ${data.params.packageName}...`, 0);
                 const { spawnCommand } = await import('./utils/spawn.js');
                 spawnCommand(this.matterbridge, 'npm', ['install', '-g', data.params.packageName, '--omit=dev', '--verbose'])
-                    .then((response) => {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response }));
+                    .then((_response) => {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                     this.wssSendCloseSnackbarMessage(`Installing package ${data.params.packageName}...`);
                     this.wssSendSnackbarMessage(`Installed package ${data.params.packageName}`, 5, 'success');
                     const packageName = data.params.packageName.replace(/@.*$/, '');
@@ -1047,14 +1017,14 @@ export class Frontend extends EventEmitter {
                     return;
                 })
                     .catch((error) => {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error });
                     this.wssSendCloseSnackbarMessage(`Installing package ${data.params.packageName}...`);
                     this.wssSendSnackbarMessage(`Package ${data.params.packageName} not installed`, 10, 'error');
                 });
             }
             else if (data.method === '/api/uninstall') {
                 if (!isValidString(data.params.packageName, 10)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter packageName in /api/uninstall' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter packageName in /api/uninstall' });
                     return;
                 }
                 const plugin = this.matterbridge.plugins.get(data.params.packageName);
@@ -1068,14 +1038,14 @@ export class Frontend extends EventEmitter {
                 this.wssSendSnackbarMessage(`Uninstalling package ${data.params.packageName}...`, 0);
                 const { spawnCommand } = await import('./utils/spawn.js');
                 spawnCommand(this.matterbridge, 'npm', ['uninstall', '-g', data.params.packageName, '--verbose'])
-                    .then((response) => {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response }));
+                    .then((_response) => {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                     this.wssSendCloseSnackbarMessage(`Uninstalling package ${data.params.packageName}...`);
                     this.wssSendSnackbarMessage(`Uninstalled package ${data.params.packageName}`, 5, 'success');
                     return;
                 })
                     .catch((error) => {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error });
                     this.wssSendCloseSnackbarMessage(`Uninstalling package ${data.params.packageName}...`);
                     this.wssSendSnackbarMessage(`Package ${data.params.packageName} not uninstalled`, 10, 'error');
                     this.wssSendSnackbarMessage(`Restart required`, 0);
@@ -1083,18 +1053,18 @@ export class Frontend extends EventEmitter {
             }
             else if (data.method === '/api/addplugin') {
                 if (!isValidString(data.params.pluginNameOrPath, 10)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginNameOrPath in /api/addplugin' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginNameOrPath in /api/addplugin' });
                     return;
                 }
                 data.params.pluginNameOrPath = data.params.pluginNameOrPath.replace(/@.*$/, '');
                 if (this.matterbridge.plugins.has(data.params.pluginNameOrPath)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Plugin ${data.params.pluginNameOrPath} already added` }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Plugin ${data.params.pluginNameOrPath} already added` });
                     this.wssSendSnackbarMessage(`Plugin ${data.params.pluginNameOrPath} already added`, 10, 'warning');
                     return;
                 }
                 const plugin = await this.matterbridge.plugins.add(data.params.pluginNameOrPath);
                 if (plugin) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: plugin.name }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: plugin.name });
                     this.wssSendSnackbarMessage(`Added plugin ${data.params.pluginNameOrPath}`, 5, 'success');
                     this.matterbridge.plugins
                         .load(plugin, true, 'The plugin has been added', true)
@@ -1108,13 +1078,13 @@ export class Frontend extends EventEmitter {
                     });
                 }
                 else {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Plugin ${data.params.pluginNameOrPath} not added` }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Plugin ${data.params.pluginNameOrPath} not added` });
                     this.wssSendSnackbarMessage(`Plugin ${data.params.pluginNameOrPath} not added`, 10, 'error');
                 }
             }
             else if (data.method === '/api/removeplugin') {
                 if (!isValidString(data.params.pluginName, 10) || !this.matterbridge.plugins.has(data.params.pluginName)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/removeplugin' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/removeplugin' });
                     return;
                 }
                 const plugin = this.matterbridge.plugins.get(data.params.pluginName);
@@ -1123,11 +1093,11 @@ export class Frontend extends EventEmitter {
                 this.wssSendSnackbarMessage(`Removed plugin ${data.params.pluginName}`, 5, 'success');
                 this.wssSendRefreshRequired('plugins');
                 this.wssSendRefreshRequired('devices');
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/enableplugin') {
                 if (!isValidString(data.params.pluginName, 10) || !this.matterbridge.plugins.has(data.params.pluginName)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/enableplugin' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/enableplugin' });
                     return;
                 }
                 const plugin = this.matterbridge.plugins.get(data.params.pluginName);
@@ -1139,7 +1109,7 @@ export class Frontend extends EventEmitter {
                     plugin.configured = undefined;
                     plugin.platform = undefined;
                     plugin.registeredDevices = undefined;
-                    plugin.addedDevices = undefined;
+                    plugin.matter = undefined;
                     await this.matterbridge.plugins.enable(data.params.pluginName);
                     this.wssSendSnackbarMessage(`Enabled plugin ${data.params.pluginName}`, 5, 'success');
                     this.matterbridge.plugins
@@ -1153,11 +1123,11 @@ export class Frontend extends EventEmitter {
                         .catch((_error) => {
                     });
                 }
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/disableplugin') {
                 if (!isValidString(data.params.pluginName, 10) || !this.matterbridge.plugins.has(data.params.pluginName)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/disableplugin' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/disableplugin' });
                     return;
                 }
                 const plugin = this.matterbridge.plugins.get(data.params.pluginName);
@@ -1166,11 +1136,11 @@ export class Frontend extends EventEmitter {
                 this.wssSendSnackbarMessage(`Disabled plugin ${data.params.pluginName}`, 5, 'success');
                 this.wssSendRefreshRequired('plugins');
                 this.wssSendRefreshRequired('devices');
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/restartplugin') {
                 if (!isValidString(data.params.pluginName, 10) || !this.matterbridge.plugins.has(data.params.pluginName)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/restartplugin' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/restartplugin' });
                     return;
                 }
                 const plugin = this.matterbridge.plugins.get(data.params.pluginName);
@@ -1185,9 +1155,8 @@ export class Frontend extends EventEmitter {
                         this.matterbridge.devices.remove(device);
                     }
                 }
-                if (plugin.type === 'DynamicPlatform' && !plugin.locked) {
+                if (plugin.type === 'DynamicPlatform' && !plugin.locked)
                     await this.matterbridge.createDynamicPlugin(plugin);
-                }
                 await this.matterbridge.plugins.load(plugin, true, 'The plugin has been restarted', true);
                 plugin.restartRequired = false;
                 let needRestart = 0;
@@ -1203,15 +1172,15 @@ export class Frontend extends EventEmitter {
                 this.wssSendSnackbarMessage(`Restarted plugin ${data.params.pluginName}`, 5, 'success');
                 this.wssSendRefreshRequired('plugins');
                 this.wssSendRefreshRequired('devices');
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/savepluginconfig') {
                 if (!isValidString(data.params.pluginName, 10) || !this.matterbridge.plugins.has(data.params.pluginName)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/savepluginconfig' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/savepluginconfig' });
                     return;
                 }
                 if (!isValidObject(data.params.formData, 5)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter formData in /api/savepluginconfig' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter formData in /api/savepluginconfig' });
                     return;
                 }
                 this.log.info(`Saving config for plugin ${plg}${data.params.pluginName}${nf}...`);
@@ -1221,59 +1190,59 @@ export class Frontend extends EventEmitter {
                     this.wssSendSnackbarMessage(`Saved config for plugin ${data.params.pluginName}`);
                     this.wssSendRefreshRequired('pluginsRestart');
                     this.wssSendRestartRequired();
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                 }
             }
             else if (data.method === '/api/checkupdates') {
                 const { checkUpdates } = await import('./update.js');
                 checkUpdates(this.matterbridge);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/shellysysupdate') {
                 const { triggerShellySysUpdate } = await import('./shelly.js');
                 triggerShellySysUpdate(this.matterbridge);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/shellymainupdate') {
                 const { triggerShellyMainUpdate } = await import('./shelly.js');
                 triggerShellyMainUpdate(this.matterbridge);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/shellycreatesystemlog') {
                 const { createShellySystemLog } = await import('./shelly.js');
                 createShellySystemLog(this.matterbridge);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             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);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/softreset') {
                 const { triggerShellySoftReset } = await import('./shelly.js');
                 triggerShellySoftReset(this.matterbridge);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/hardreset') {
                 const { triggerShellyHardReset } = await import('./shelly.js');
                 triggerShellyHardReset(this.matterbridge);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/reboot') {
                 const { triggerShellyReboot } = await import('./shelly.js');
                 triggerShellyReboot(this.matterbridge);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/restart') {
                 this.wssSendSnackbarMessage(`Restarting matterbridge...`, 0);
                 await this.matterbridge.restartProcess();
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/shutdown') {
                 this.wssSendSnackbarMessage(`Shutting down matterbridge...`, 0);
                 await this.matterbridge.shutdownProcess();
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/create-backup') {
                 this.wssSendSnackbarMessage('Creating backup...', 0);
@@ -1282,41 +1251,27 @@ export class Frontend extends EventEmitter {
                 this.log.notice(`Backup ready to be downloaded.`);
                 this.wssSendCloseSnackbarMessage('Creating backup...');
                 this.wssSendSnackbarMessage('Backup ready to be downloaded', 10);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/unregister') {
                 this.wssSendSnackbarMessage('Unregistering all bridged devices...', 0);
                 await this.matterbridge.unregisterAndShutdownProcess();
                 this.wssSendCloseSnackbarMessage('Unregistering all bridged devices...');
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/reset') {
                 this.wssSendSnackbarMessage('Resetting matterbridge commissioning...', 10);
                 await this.matterbridge.shutdownProcessAndReset();
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/factoryreset') {
                 this.wssSendSnackbarMessage('Factory reset of matterbridge...', 10);
                 await this.matterbridge.shutdownProcessAndFactoryReset();
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
-            }
-            else if (data.method === '/api/advertise') {
-                const pairingCodes = await this.matterbridge.advertiseServerNode(this.matterbridge.serverNode);
-                this.matterbridge.matterbridgeInformation.matterbridgeAdvertise = true;
-                this.wssSendRefreshRequired('matterbridgeAdvertise');
-                this.wssSendSnackbarMessage(`Started fabrics share`, 0);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: pairingCodes, success: true }));
-            }
-            else if (data.method === '/api/stopadvertise') {
-                await this.matterbridge.stopAdvertiseServerNode(this.matterbridge.serverNode);
-                this.matterbridge.matterbridgeInformation.matterbridgeAdvertise = false;
-                this.wssSendRefreshRequired('matterbridgeAdvertise');
-                this.wssSendSnackbarMessage(`Stopped fabrics share`, 0);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/matter') {
                 if (!isValidString(data.params.id)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter id in /api/matter' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter id in /api/matter' });
                     return;
                 }
                 let serverNode;
@@ -1325,129 +1280,125 @@ export class Frontend extends EventEmitter {
                 else
                     serverNode = this.matterbridge.getPlugins().find((p) => p.serverNode && p.serverNode.id === data.params.id)?.serverNode || this.matterbridge.getDevices().find((d) => d.serverNode && d.serverNode.id === data.params.id)?.serverNode;
                 if (!serverNode) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Unknown server node id in /api/matter' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Unknown server node id in /api/matter' });
                     return;
                 }
+                const matter = this.matterbridge.getServerNodeData(serverNode);
                 this.log.debug(`*Server node ${serverNode.id}: commissioned ${serverNode.state.commissioning.commissioned} upTime ${serverNode.state.generalDiagnostics.upTime}.`);
                 if (data.params.server) {
                     this.log.debug(`*Sending data for node ${data.params.id}`);
-                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode) } });
+                    this.wssSendRefreshRequired('matter', { matter: { ...matter } });
                 }
                 if (data.params.startCommission) {
                     await serverNode.env.get(DeviceCommissioner)?.allowBasicCommissioning();
                     this.matterbridge.advertisingNodes.set(serverNode.id, Date.now());
                     this.log.debug(`*Commissioning has been sent for node ${data.params.id}`);
-                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode), advertising: true } });
+                    this.wssSendRefreshRequired('matter', { matter: { ...matter, advertising: true } });
                 }
                 if (data.params.stopCommission) {
                     await serverNode.env.get(DeviceCommissioner)?.endCommissioning();
                     this.matterbridge.advertisingNodes.delete(serverNode.id);
                     this.log.debug(`*Stop commissioning has been sent for node ${data.params.id}`);
-                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode), advertising: false } });
+                    this.wssSendRefreshRequired('matter', { matter: { ...matter, advertising: false } });
                 }
                 if (data.params.advertise) {
                     await serverNode.env.get(DeviceAdvertiser)?.advertise(true);
                     this.log.debug(`*Advertising has been sent for node ${data.params.id}`);
-                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode), advertising: true } });
+                    this.wssSendRefreshRequired('matter', { matter: { ...matter, advertising: true } });
                 }
                 if (data.params.removeFabric) {
                     if (serverNode.env.get(FabricManager).has(FabricIndex(data.params.removeFabric)))
                         await serverNode.env.get(FabricManager).removeFabric(FabricIndex(data.params.removeFabric));
                     this.log.debug(`*Removed fabric index ${data.params.removeFabric} for node ${data.params.id}`);
-                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode) } });
+                    this.wssSendRefreshRequired('matter', { matter: { ...matter } });
                 }
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: matter });
             }
             else if (data.method === '/api/settings') {
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: await this.getApiSettings() }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: await this.getApiSettings() });
             }
             else if (data.method === '/api/plugins') {
-                const response = this.getPlugins();
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response }));
+                const plugins = this.getPlugins();
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: plugins });
             }
             else if (data.method === '/api/devices') {
                 const devices = await this.getDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: devices }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: devices });
             }
             else if (data.method === '/api/clusters') {
                 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/clusters' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/clusters' });
                     return;
                 }
                 if (!isValidNumber(data.params.endpoint, 1)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' });
                     return;
                 }
                 const response = this.getClusters(data.params.plugin, data.params.endpoint);
                 if (response) {
-                    client.send(JSON.stringify({
+                    sendResponse({
                         id: data.id,
                         method: data.method,
                         src: 'Matterbridge',
                         dst: data.src,
-                        plugin: data.params.plugin,
-                        deviceName: response.deviceName,
-                        serialNumber: response.serialNumber,
-                        endpoint: response.endpoint,
-                        deviceTypes: response.deviceTypes,
-                        response: response.clusters,
-                    }));
+                        response,
+                    });
                 }
                 else {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Endpoint not found in /api/clusters' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Endpoint not found in /api/clusters' });
                 }
             }
-            else if (data.method === '/api/select' || data.method === '/api/select/devices') {
+            else if (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' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/select/devices' });
                     return;
                 }
                 const plugin = this.matterbridge.plugins.get(data.params.plugin);
                 if (!plugin) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/select' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/select/devices' });
                     return;
                 }
                 const selectDeviceValues = plugin.platform?.getSelectDevices().sort((keyA, keyB) => keyA.name.localeCompare(keyB.name));
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, plugin: data.params.plugin, response: selectDeviceValues }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: selectDeviceValues });
             }
             else if (data.method === '/api/select/entities') {
                 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/entities' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/select/entities' });
                     return;
                 }
                 const plugin = this.matterbridge.plugins.get(data.params.plugin);
                 if (!plugin) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/select/entities' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/select/entities' });
                     return;
                 }
                 const selectEntityValues = plugin.platform?.getSelectEntities().sort((keyA, keyB) => keyA.name.localeCompare(keyB.name));
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, plugin: data.params.plugin, response: selectEntityValues }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: selectEntityValues });
             }
             else if (data.method === '/api/action') {
                 if (!isValidString(data.params.plugin, 5) || !isValidString(data.params.action, 1)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter in /api/action' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter in /api/action' });
                     return;
                 }
                 const plugin = this.matterbridge.plugins.get(data.params.plugin);
                 if (!plugin) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/action' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/action' });
                     return;
                 }
                 this.log.notice(`Action ${CYAN}${data.params.action}${nt}${data.params.value ? ' with ' + CYAN + data.params.value + nt : ''} for plugin ${CYAN}${plugin.name}${nt}`);
                 plugin.platform
                     ?.onAction(data.params.action, data.params.value, data.params.id, data.params.formData)
                     .then(() => {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                     return;
                 })
                     .catch((error) => {
                     this.log.error(`Error in plugin ${plugin.name} action ${data.params.action}: ${error}`);
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Error in plugin ${plugin.name} action ${data.params.action}: ${error}` }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Error in plugin ${plugin.name} action ${data.params.action}: ${error}` });
                 });
             }
             else if (data.method === '/api/config') {
                 if (!isValidString(data.params.name, 5) || data.params.value === undefined) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter in /api/config' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter in /api/config' });
                     return;
                 }
                 this.log.debug(`Received /api/config name ${CYAN}${data.params.name}${db} value ${CYAN}${data.params.value}${db}`);
@@ -1455,14 +1406,14 @@ export class Frontend extends EventEmitter {
                     case 'setpassword':
                         if (isValidString(data.params.value)) {
                             await this.matterbridge.nodeContext?.set('password', data.params.value);
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setbridgemode':
                         if (isValidString(data.params.value) && ['bridge', 'childbridge'].includes(data.params.value)) {
                             await this.matterbridge.nodeContext?.set('bridgeMode', data.params.value);
                             this.wssSendRestartRequired();
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setmbloglevel':
@@ -1487,7 +1438,7 @@ export class Frontend extends EventEmitter {
                                 await this.matterbridge.setLogLevel("fatal");
                             }
                             await this.matterbridge.nodeContext?.set('matterbridgeLogLevel', this.log.logLevel);
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setmblogfile':
@@ -1499,7 +1450,7 @@ export class Frontend extends EventEmitter {
                                 AnsiLogger.setGlobalLogfile(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterbridgeLoggerFile), this.matterbridge.matterbridgeInformation.loggerLevel, true);
                             else
                                 AnsiLogger.setGlobalLogfile(undefined);
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setmjloglevel':
@@ -1525,7 +1476,7 @@ export class Frontend extends EventEmitter {
                             }
                             this.matterbridge.matterbridgeInformation.matterLoggerLevel = Logger.level;
                             await this.matterbridge.nodeContext?.set('matterLogLevel', Logger.level);
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setmjlogfile':
@@ -1539,7 +1490,7 @@ export class Frontend extends EventEmitter {
                             else {
                                 this.matterbridge.matterLog.logFilePath = undefined;
                             }
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setmdnsinterface':
@@ -1549,7 +1500,7 @@ export class Frontend extends EventEmitter {
                             this.matterbridge.matterbridgeInformation.mattermdnsinterface = this.matterbridge.mdnsInterface;
                             await this.matterbridge.nodeContext?.set('mattermdnsinterface', data.params.value);
                             this.wssSendRestartRequired();
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setipv4address':
@@ -1559,7 +1510,7 @@ export class Frontend extends EventEmitter {
                             this.matterbridge.matterbridgeInformation.matteripv4address = this.matterbridge.ipv4address;
                             await this.matterbridge.nodeContext?.set('matteripv4address', data.params.value);
                             this.wssSendRestartRequired();
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setipv6address':
@@ -1569,7 +1520,7 @@ export class Frontend extends EventEmitter {
                             this.matterbridge.matterbridgeInformation.matteripv6address = this.matterbridge.ipv6address;
                             await this.matterbridge.nodeContext?.set('matteripv6address', data.params.value);
                             this.wssSendRestartRequired();
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         break;
                     case 'setmatterport':
@@ -1586,7 +1537,7 @@ export class Frontend extends EventEmitter {
                             await this.matterbridge.nodeContext?.set('matterport', 5540);
                             this.wssSendRestartRequired();
                         }
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         break;
                     case 'setmatterdiscriminator':
                         data.params.value = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
@@ -1595,14 +1546,14 @@ export class Frontend extends EventEmitter {
                             this.matterbridge.matterbridgeInformation.matterDiscriminator = data.params.value;
                             await this.matterbridge.nodeContext?.set('matterdiscriminator', data.params.value);
                             this.wssSendRestartRequired();
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         else {
                             this.log.debug(`Reset matter commissioning discriminator to ${CYAN}undefined${db}`);
                             this.matterbridge.matterbridgeInformation.matterDiscriminator = undefined;
                             await this.matterbridge.nodeContext?.remove('matterdiscriminator');
                             this.wssSendRestartRequired();
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: false }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: false });
                         }
                         break;
                     case 'setmatterpasscode':
@@ -1612,14 +1563,14 @@ export class Frontend extends EventEmitter {
                             this.log.debug(`Set matter commissioning passcode to ${CYAN}${data.params.value}${db}`);
                             await this.matterbridge.nodeContext?.set('matterpasscode', data.params.value);
                             this.wssSendRestartRequired();
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         else {
                             this.log.debug(`Reset matter commissioning passcode to ${CYAN}undefined${db}`);
                             this.matterbridge.matterbridgeInformation.matterPasscode = undefined;
                             await this.matterbridge.nodeContext?.remove('matterpasscode');
                             this.wssSendRestartRequired();
-                            client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: false }));
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: false });
                         }
                         break;
                     case 'setvirtualmode':
@@ -1629,22 +1580,22 @@ export class Frontend extends EventEmitter {
                             await this.matterbridge.nodeContext?.set('virtualmode', data.params.value);
                             this.wssSendRestartRequired();
                         }
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         break;
                     default:
                         this.log.warn(`Unknown parameter ${data.params.name} in /api/config`);
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Unknown parameter ${data.params.name} in /api/config` }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Unknown parameter ${data.params.name} in /api/config` });
                 }
             }
             else if (data.method === '/api/command') {
                 if (!isValidString(data.params.command, 5)) {
-                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter command in /api/command' }));
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter command in /api/command' });
                     return;
                 }
                 if (data.params.command === 'selectdevice' && isValidString(data.params.plugin, 10) && isValidString(data.params.serial, 1) && isValidString(data.params.name, 1)) {
                     const plugin = this.matterbridge.plugins.get(data.params.plugin);
                     if (!plugin) {
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/command' }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/command' });
                         return;
                     }
                     const config = plugin.configJson;
@@ -1681,17 +1632,17 @@ export class Frontend extends EventEmitter {
                         if (!restartRequired)
                             this.wssSendRefreshRequired('pluginsRestart');
                         this.wssSendRestartRequired(false);
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                     }
                     else {
                         this.log.error(`SelectDevice: select ${select} not supported`);
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `SelectDevice: select ${select} not supported` }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `SelectDevice: select ${select} not supported` });
                     }
                 }
                 else if (data.params.command === 'unselectdevice' && isValidString(data.params.plugin, 10) && isValidString(data.params.serial, 1) && isValidString(data.params.name, 1)) {
                     const plugin = this.matterbridge.plugins.get(data.params.plugin);
                     if (!plugin) {
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/command' }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/command' });
                         return;
                     }
                     const config = plugin.configJson;
@@ -1728,24 +1679,24 @@ export class Frontend extends EventEmitter {
                         if (!restartRequired)
                             this.wssSendRefreshRequired('pluginsRestart');
                         this.wssSendRestartRequired(false);
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                     }
                     else {
                         this.log.error(`SelectDevice: select ${select} not supported`);
-                        client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `SelectDevice: select ${select} not supported` }));
+                        sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `SelectDevice: select ${select} not supported` });
                     }
                 }
             }
             else {
                 this.log.error(`Invalid method from websocket client: ${debugStringify(data)}`);
-                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid method' }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid method' });
             }
         }
         catch (error) {
             inspectError(this.log, `Error processing message "${message}" from websocket client`, error);
         }
     }
-    wssSendMessage(level, time, name, message) {
+    wssSendLogMessage(level, time, name, message) {
         if (!level || !time || !name || !message)
             return;
         message = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
@@ -1766,19 +1717,11 @@ export class Frontend extends EventEmitter {
             return word;
         })
             .join(' ');
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_LOG, src: 'Matterbridge', level, time, name, message }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'log', params: { level, time, name, message } });
     }
-    wssSendRefreshRequired(changed = null, params = {}) {
+    wssSendRefreshRequired(changed = null, params) {
         this.log.debug('Sending a refresh required message to all connected clients');
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_REFRESH_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', params: { changed: changed, ...params } }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 1, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', params: { changed, ...params } });
     }
     wssSendRestartRequired(snackbar = true, fixed = false) {
         this.log.debug('Sending a restart required message to all connected clients');
@@ -1786,88 +1729,54 @@ export class Frontend extends EventEmitter {
         this.matterbridge.matterbridgeInformation.fixedRestartRequired = fixed;
         if (snackbar === 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: { fixed } }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 2, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', params: { fixed } });
     }
     wssSendRestartNotRequired(snackbar = true) {
         this.log.debug('Sending a restart not required message to all connected clients');
         this.matterbridge.matterbridgeInformation.restartRequired = false;
         if (snackbar === true)
             this.wssSendCloseSnackbarMessage(`Restart required`);
-        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_not_required', params: {} }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 3, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required' });
     }
     wssSendUpdateRequired(devVersion = false) {
         this.log.debug('Sending an update required message to all connected clients');
         this.matterbridge.matterbridgeInformation.updateRequired = true;
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_UPDATE_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: devVersion ? 'update_required_dev' : 'update_required', params: {} }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 8, src: 'Matterbridge', dst: 'Frontend', method: devVersion ? 'update_required_dev' : 'update_required' });
     }
     wssSendCpuUpdate(cpuUsage) {
         if (hasParameter('debug'))
             this.log.debug('Sending a cpu update message to all connected clients');
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_CPU_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'cpu_update', params: { cpuUsage } }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 4, src: 'Matterbridge', dst: 'Frontend', method: 'cpu_update', params: { cpuUsage } });
     }
     wssSendMemoryUpdate(totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers) {
         if (hasParameter('debug'))
             this.log.debug('Sending a memory update message to all connected clients');
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_MEMORY_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'memory_update', params: { totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers } }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 5, src: 'Matterbridge', dst: 'Frontend', method: 'memory_update', params: { totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers } });
     }
     wssSendUptimeUpdate(systemUptime, processUptime) {
         if (hasParameter('debug'))
             this.log.debug('Sending a uptime update message to all connected clients');
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_UPTIME_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'uptime_update', params: { systemUptime, processUptime } }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 6, src: 'Matterbridge', dst: 'Frontend', method: 'uptime_update', params: { systemUptime, processUptime } });
     }
     wssSendSnackbarMessage(message, timeout = 5, severity = 'info') {
         this.log.debug('Sending a snackbar message to all connected clients');
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_SNACKBAR, src: 'Matterbridge', dst: 'Frontend', params: { message, timeout, severity } }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 7, src: 'Matterbridge', dst: 'Frontend', method: 'snackbar', params: { message, timeout, severity } });
     }
     wssSendCloseSnackbarMessage(message) {
         this.log.debug('Sending a close snackbar message to all connected clients');
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_CLOSE_SNACKBAR, src: 'Matterbridge', dst: 'Frontend', params: { message } }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 10, src: 'Matterbridge', dst: 'Frontend', method: 'close_snackbar', params: { message } });
     }
     wssSendAttributeChangedMessage(plugin, serialNumber, uniqueId, cluster, attribute, value) {
         this.log.debug('Sending an attribute update message to all connected clients');
-        this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_STATEUPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'state_update', params: { plugin, serialNumber, uniqueId, cluster, attribute, value } }));
-            }
-        });
+        this.wssBroadcastMessage({ id: 9, src: 'Matterbridge', dst: 'Frontend', method: 'state_update', params: { plugin, serialNumber, uniqueId, cluster, attribute, value } });
     }
-    wssBroadcastMessage(id, method, params) {
-        this.log.debug(`Sending a broadcast message id ${id} method ${method} params ${debugStringify(params ?? {})} to all connected clients`);
+    wssBroadcastMessage(msg) {
+        const stringifiedMsg = JSON.stringify(msg);
+        if (msg.id !== 0)
+            this.log.debug(`Sending a broadcast message: ${debugStringify(msg)}`);
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id, src: 'Matterbridge', dst: 'Frontend', method, params }));
+                client.send(stringifiedMsg);
             }
         });
     }