matterbridge 3.2.8-dev-20250916-da71182 → 3.2.8-dev-20250919-e967b55

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');
@@ -666,20 +636,12 @@ export class Frontend extends EventEmitter {
         this.matterbridge.matterbridgeInformation.profile = this.matterbridge.profile;
         this.matterbridge.matterbridgeInformation.loggerLevel = this.matterbridge.log.logLevel;
         this.matterbridge.matterbridgeInformation.matterLoggerLevel = Logger.defaultLogLevel;
-        this.matterbridge.matterbridgeInformation.mattermdnsinterface = this.matterbridge.mdnsInterface;
-        this.matterbridge.matterbridgeInformation.matteripv4address = this.matterbridge.ipv4address;
-        this.matterbridge.matterbridgeInformation.matteripv6address = this.matterbridge.ipv6address;
+        this.matterbridge.matterbridgeInformation.matterMdnsInterface = this.matterbridge.mdnsInterface;
+        this.matterbridge.matterbridgeInformation.matterIpv4Address = this.matterbridge.ipv4address;
+        this.matterbridge.matterbridgeInformation.matterIpv6Address = this.matterbridge.ipv6address;
         this.matterbridge.matterbridgeInformation.matterPort = (await this.matterbridge.nodeContext?.get('matterport', 5540)) ?? 5540;
         this.matterbridge.matterbridgeInformation.matterDiscriminator = await this.matterbridge.nodeContext?.get('matterdiscriminator');
         this.matterbridge.matterbridgeInformation.matterPasscode = await this.matterbridge.nodeContext?.get('matterpasscode');
-        if (this.matterbridge.bridgeMode === 'bridge' && this.matterbridge.serverNode && !this.matterbridge.hasCleanupStarted) {
-            this.matterbridge.matterbridgeInformation.matter = this.matterbridge.getServerNodeData(this.matterbridge.serverNode);
-            this.matterbridge.matterbridgeInformation.matterbridgePaired = this.matterbridge.serverNode.state.commissioning.commissioned;
-            this.matterbridge.matterbridgeInformation.matterbridgeQrPairingCode = this.matterbridge.matterbridgeInformation.matterbridgeEndAdvertise ? undefined : this.matterbridge.serverNode.state.commissioning.pairingCodes.qrPairingCode;
-            this.matterbridge.matterbridgeInformation.matterbridgeManualPairingCode = this.matterbridge.matterbridgeInformation.matterbridgeEndAdvertise ? undefined : this.matterbridge.serverNode.state.commissioning.pairingCodes.manualPairingCode;
-            this.matterbridge.matterbridgeInformation.matterbridgeFabricInformations = this.matterbridge.sanitizeFabricInformations(Object.values(this.matterbridge.serverNode.state.commissioning.fabrics));
-            this.matterbridge.matterbridgeInformation.matterbridgeSessionInformations = this.matterbridge.sanitizeSessionInformation(Object.values(this.matterbridge.serverNode.state.sessions.sessions));
-        }
         return { systemInformation: this.matterbridge.systemInformation, matterbridgeInformation: this.matterbridge.matterbridgeInformation };
     }
     getReachability(device) {
@@ -956,50 +918,66 @@ export class Frontend extends EventEmitter {
     }
     async wsMessageHandler(client, message) {
         let data;
+        const sendResponse = (data) => {
+            if (client.readyState === WebSocket.OPEN) {
+                if ('response' in data) {
+                    const { response, ...rest } = data;
+                    this.log.debug(`Sending api response message: ${debugStringify(rest)}`);
+                }
+                else if ('error' in data) {
+                    this.log.debug(`Sending api error message: ${debugStringify(data)}`);
+                }
+                else {
+                    this.log.debug(`Sending api response message: ${debugStringify(data)}`);
+                }
+                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') {
+                const localData = data;
                 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 }));
-                    this.wssSendCloseSnackbarMessage(`Installing package ${data.params.packageName}...`);
-                    this.wssSendSnackbarMessage(`Installed package ${data.params.packageName}`, 5, 'success');
-                    const packageName = data.params.packageName.replace(/@.*$/, '');
-                    if (data.params.restart === false && packageName !== 'matterbridge') {
+                    .then((_response) => {
+                    sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: data.src, success: true });
+                    this.wssSendCloseSnackbarMessage(`Installing package ${localData.params.packageName}...`);
+                    this.wssSendSnackbarMessage(`Installed package ${localData.params.packageName}`, 5, 'success');
+                    const packageName = localData.params.packageName.replace(/@.*$/, '');
+                    if (localData.params.restart === false && packageName !== 'matterbridge') {
                         this.matterbridge.plugins
                             .add(packageName)
                             .then((plugin) => {
@@ -1040,14 +1018,15 @@ 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 }));
-                    this.wssSendCloseSnackbarMessage(`Installing package ${data.params.packageName}...`);
-                    this.wssSendSnackbarMessage(`Package ${data.params.packageName} not installed`, 10, 'error');
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error });
+                    this.wssSendCloseSnackbarMessage(`Installing package ${localData.params.packageName}...`);
+                    this.wssSendSnackbarMessage(`Package ${localData.params.packageName} not installed`, 10, 'error');
                 });
             }
             else if (data.method === '/api/uninstall') {
+                const localData = data;
                 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);
@@ -1061,53 +1040,54 @@ 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 }));
-                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${data.params.packageName}...`);
-                    this.wssSendSnackbarMessage(`Uninstalled package ${data.params.packageName}`, 5, 'success');
+                    .then((_response) => {
+                    sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: data.src, success: true });
+                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${localData.params.packageName}...`);
+                    this.wssSendSnackbarMessage(`Uninstalled package ${localData.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 }));
-                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${data.params.packageName}...`);
-                    this.wssSendSnackbarMessage(`Package ${data.params.packageName} not uninstalled`, 10, 'error');
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error });
+                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${localData.params.packageName}...`);
+                    this.wssSendSnackbarMessage(`Package ${localData.params.packageName} not uninstalled`, 10, 'error');
                     this.wssSendSnackbarMessage(`Restart required`, 0);
                 });
             }
             else if (data.method === '/api/addplugin') {
+                const localData = data;
                 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, success: true });
                     this.wssSendSnackbarMessage(`Added plugin ${data.params.pluginNameOrPath}`, 5, 'success');
                     this.matterbridge.plugins
                         .load(plugin, true, 'The plugin has been added', true)
                         .then(() => {
                         this.wssSendRefreshRequired('plugins');
                         this.wssSendRefreshRequired('devices');
-                        this.wssSendSnackbarMessage(`Started plugin ${data.params.pluginNameOrPath}`, 5, 'success');
+                        this.wssSendSnackbarMessage(`Started plugin ${localData.params.pluginNameOrPath}`, 5, 'success');
                         return;
                     })
                         .catch((_error) => {
                     });
                 }
                 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);
@@ -1116,11 +1096,12 @@ 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') {
+                const localData = data;
                 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);
@@ -1140,17 +1121,17 @@ export class Frontend extends EventEmitter {
                         .then(() => {
                         this.wssSendRefreshRequired('plugins');
                         this.wssSendRefreshRequired('devices');
-                        this.wssSendSnackbarMessage(`Started plugin ${data.params.pluginName}`, 5, 'success');
+                        this.wssSendSnackbarMessage(`Started plugin ${localData.params.pluginName}`, 5, 'success');
                         return;
                     })
                         .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);
@@ -1159,11 +1140,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);
@@ -1195,15 +1176,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}...`);
@@ -1211,61 +1192,60 @@ export class Frontend extends EventEmitter {
                 if (plugin) {
                     this.matterbridge.plugins.saveConfigFromJson(plugin, data.params.formData, true);
                     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);
@@ -1274,158 +1254,157 @@ 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 }));
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/matter') {
+                const localData = data;
                 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;
                 if (data.params.id === 'Matterbridge')
                     serverNode = this.matterbridge.serverNode;
                 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;
+                    serverNode = this.matterbridge.getPlugins().find((p) => p.serverNode && p.serverNode.id === localData.params.id)?.serverNode || this.matterbridge.getDevices().find((d) => d.serverNode && d.serverNode.id === localData.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.log.debug(`*Allow commissioning has been sent for node ${data.params.id}`);
+                    this.wssSendRefreshRequired('matter', { matter: { ...matter, advertiseTime: Date.now(), 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.log.debug(`*End commissioning has been sent for node ${data.params.id}`);
+                    this.wssSendRefreshRequired('matter', { matter: { ...matter, advertiseTime: 0, 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, success: true, 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, success: true, 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, success: true, 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,
-                    }));
+                        success: true,
+                        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, success: true, 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, success: true, response: selectEntityValues });
             }
             else if (data.method === '/api/action') {
+                const localData = data;
                 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: localData.id, method: localData.method, src: 'Matterbridge', dst: localData.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}` }));
+                    this.log.error(`Error in plugin ${plugin.name} action ${localData.params.action}: ${error}`);
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Error in plugin ${plugin.name} action ${localData.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}`);
@@ -1433,14 +1412,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':
@@ -1465,7 +1444,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':
@@ -1477,7 +1456,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':
@@ -1503,7 +1482,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':
@@ -1517,87 +1496,88 @@ 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':
                         if (isValidString(data.params.value)) {
                             this.log.debug(`Matter.js mdns interface: ${data.params.value === '' ? 'all interfaces' : data.params.value}`);
                             this.matterbridge.mdnsInterface = data.params.value === '' ? undefined : data.params.value;
-                            this.matterbridge.matterbridgeInformation.mattermdnsinterface = this.matterbridge.mdnsInterface;
+                            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':
                         if (isValidString(data.params.value)) {
                             this.log.debug(`Matter.js ipv4 address: ${data.params.value === '' ? 'all ipv4 addresses' : data.params.value}`);
                             this.matterbridge.ipv4address = data.params.value === '' ? undefined : data.params.value;
-                            this.matterbridge.matterbridgeInformation.matteripv4address = this.matterbridge.ipv4address;
+                            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':
                         if (isValidString(data.params.value)) {
                             this.log.debug(`Matter.js ipv6 address: ${data.params.value === '' ? 'all ipv6 addresses' : data.params.value}`);
                             this.matterbridge.ipv6address = data.params.value === '' ? undefined : data.params.value;
-                            this.matterbridge.matterbridgeInformation.matteripv6address = this.matterbridge.ipv6address;
+                            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':
-                        data.params.value = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
-                        if (isValidNumber(data.params.value, 5540, 5580)) {
-                            this.log.debug(`Set matter commissioning port to ${CYAN}${data.params.value}${db}`);
-                            this.matterbridge.matterbridgeInformation.matterPort = data.params.value;
-                            await this.matterbridge.nodeContext?.set('matterport', data.params.value);
+                        const port = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
+                        if (isValidNumber(port, 5540, 5600)) {
+                            this.log.debug(`Set matter commissioning port to ${CYAN}${port}${db}`);
+                            this.matterbridge.matterbridgeInformation.matterPort = port;
+                            await this.matterbridge.nodeContext?.set('matterport', port);
                             this.wssSendRestartRequired();
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
                         else {
                             this.log.debug(`Reset matter commissioning port to ${CYAN}5540${db}`);
                             this.matterbridge.matterbridgeInformation.matterPort = 5540;
                             await this.matterbridge.nodeContext?.set('matterport', 5540);
                             this.wssSendRestartRequired();
+                            sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid value: reset matter commissioning port to default 5540' });
                         }
-                        client.send(JSON.stringify({ 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;
-                        if (isValidNumber(data.params.value, 1000, 4095)) {
-                            this.log.debug(`Set matter commissioning discriminator to ${CYAN}${data.params.value}${db}`);
-                            this.matterbridge.matterbridgeInformation.matterDiscriminator = data.params.value;
-                            await this.matterbridge.nodeContext?.set('matterdiscriminator', data.params.value);
+                        const discriminator = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
+                        if (isValidNumber(discriminator, 1000, 4095)) {
+                            this.log.debug(`Set matter commissioning discriminator to ${CYAN}${discriminator}${db}`);
+                            this.matterbridge.matterbridgeInformation.matterDiscriminator = discriminator;
+                            await this.matterbridge.nodeContext?.set('matterdiscriminator', discriminator);
                             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, error: 'Invalid value: reset matter commissioning discriminator to default undefined' });
                         }
                         break;
                     case 'setmatterpasscode':
-                        data.params.value = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
-                        if (isValidNumber(data.params.value, 10000000, 90000000)) {
-                            this.matterbridge.matterbridgeInformation.matterPasscode = data.params.value;
-                            this.log.debug(`Set matter commissioning passcode to ${CYAN}${data.params.value}${db}`);
-                            await this.matterbridge.nodeContext?.set('matterpasscode', data.params.value);
+                        const passcode = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
+                        if (isValidNumber(passcode, 10000000, 90000000)) {
+                            this.matterbridge.matterbridgeInformation.matterPasscode = passcode;
+                            this.log.debug(`Set matter commissioning passcode to ${CYAN}${passcode}${db}`);
+                            await this.matterbridge.nodeContext?.set('matterpasscode', passcode);
                             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, error: 'Invalid value: reset matter commissioning passcode to default undefined' });
                         }
                         break;
                     case 'setvirtualmode':
@@ -1607,22 +1587,23 @@ 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') {
+                const localData = data;
                 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;
@@ -1645,31 +1626,28 @@ export class Frontend extends EventEmitter {
                         }
                         if (isValidArray(config.blackList, 1)) {
                             if (select === 'serial' && config.blackList.includes(data.params.serial)) {
-                                config.blackList = config.blackList.filter((item) => item !== data.params.serial);
+                                config.blackList = config.blackList.filter((item) => item !== localData.params.serial);
                             }
                             else if (select === 'name' && config.blackList.includes(data.params.name)) {
-                                config.blackList = config.blackList.filter((item) => item !== data.params.name);
+                                config.blackList = config.blackList.filter((item) => item !== localData.params.name);
                             }
                         }
                         if (plugin.platform)
                             plugin.platform.config = config;
                         plugin.configJson = config;
-                        const restartRequired = plugin.restartRequired;
                         await this.matterbridge.plugins.saveConfigFromPlugin(plugin, true);
-                        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;
@@ -1684,10 +1662,10 @@ export class Frontend extends EventEmitter {
                         }
                         if (isValidArray(config.whiteList, 1)) {
                             if (select === 'serial' && config.whiteList.includes(data.params.serial)) {
-                                config.whiteList = config.whiteList.filter((item) => item !== data.params.serial);
+                                config.whiteList = config.whiteList.filter((item) => item !== localData.params.serial);
                             }
                             else if (select === 'name' && config.whiteList.includes(data.params.name)) {
-                                config.whiteList = config.whiteList.filter((item) => item !== data.params.name);
+                                config.whiteList = config.whiteList.filter((item) => item !== localData.params.name);
                             }
                         }
                         if (isValidArray(config.blackList)) {
@@ -1701,29 +1679,27 @@ export class Frontend extends EventEmitter {
                         if (plugin.platform)
                             plugin.platform.config = config;
                         plugin.configJson = config;
-                        const restartRequired = plugin.restartRequired;
                         await this.matterbridge.plugins.saveConfigFromPlugin(plugin, true);
-                        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' }));
+                const localData = data;
+                this.log.error(`Invalid method from websocket client: ${debugStringify(localData)}`);
+                sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: localData.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, '');
@@ -1744,19 +1720,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, 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');
@@ -1764,88 +1732,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: Math.round(cpuUsage * 100) / 100 } });
     }
     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);
             }
         });
     }