matterbridge 3.4.1-dev-20251127-826b2bf → 3.4.1-dev-20251129-ff1e22f

package/CHANGELOG.md

@@ -14,8 +14,9 @@ The project will evolve to a multi-threaded architecture (the CLI will become th
 - frontend;
 - plugins;
 - devices;
-- check_updates;
-- npm_install;
+- check updates;
+- npm install;
+- ✅ get global node_modules;
 - all plugins in bridge mode;
 - each plugin in childbridge mode;
 
@@ -31,7 +32,9 @@ Advantages:
 ### Added
 
 - [matterbridge.io]: Updated website https://matterbridge.io with all guides.
-- [matterbridge]: Added addVirtualEndpoint() to match thread module.
+- [matterbridge]: Added addVirtualEndpoint() to match Matterbridge thread module.
+- [BroadcastServer]: Backport BroadcastServer v.2.0.0 from Matterbridge thread module.
+- [MatterbridgePrefix]: Added worker thread to get global node_modules.
 
 ### Changed
 
@@ -39,10 +42,12 @@ Advantages:
 - [frontend]: Updated dependencies.
 - [frontend]: Bumped `frontend` version to 3.3.2.
 - [platform]: Bumped MatterbridgePlatform v.1.5.0.
+- [thread]: Bump BroadcastServer to v1.0.4.
 
 ### Fixed
 
 - [frontend]: Fixed when the user put special characters in password. Thanks Dabern (https://github.com/Luligu/matterbridge/issues/443).
+- [frontend]: Fixed minimum size to 1300x1024 and add a max width to Url. Thanks Ricardo B. (https://github.com/Luligu/matterbridge-home-assistant-addon/issues/23).
 
 <a href="https://www.buymeacoffee.com/luligugithub"><img src="https://matterbridge.io/bmc-button.svg" alt="Buy me a coffee" width="80"></a>
 

package/README-DEV.md

@@ -251,9 +251,25 @@ It is called when the plugin config has been updated.
 
 Retrieves the devices registered with the platform.
 
+### getDeviceByName(deviceName: string): MatterbridgeEndpoint | undefined
+
+### getDeviceByUniqueId(uniqueId: string): MatterbridgeEndpoint | undefined
+
+### getDeviceBySerialNumber(serialNumber: string): MatterbridgeEndpoint | undefined
+
+### getDeviceById(id: string): MatterbridgeEndpoint | undefined
+
+### getDeviceByOriginalId(originalId: string): MatterbridgeEndpoint | undefined
+
+### getDeviceByNumber(number: EndpointNumber | number): MatterbridgeEndpoint | undefined
+
+They all return MatterbridgeEndpoint or undefined if not found.
+
 ### hasDeviceName(deviceName: string): boolean
 
-Checks if a device with this name is already registered in the platform.
+### hasDeviceUniqueId(deviceUniqueId: string): boolean
+
+Checks if a device with this name or uniqueId is already registered in the platform.
 
 ### async registerDevice(device: MatterbridgeEndpoint)
 
@@ -288,7 +304,7 @@ You create a Matter device with a new instance of MatterbridgeEndpoint(definitio
 
 In the above example we create a contact sensor device type with also a power source device type feature replaceble battery.
 
-All device types are defined in src\matterbridgeDeviceTypes.ts and taken from the 'Matter-1.4.1-Device-Library-Specification.pdf'.
+All device types are defined in src\matterbridgeDeviceTypes.ts and taken from the 'Matter-1.4.2-Device-Library-Specification.pdf'.
 
 All default cluster helpers are available as methods of MatterbridgeEndpoint.
 
@@ -388,7 +404,7 @@ const heatPump = new HeatPump('Heat Pump', 'HP1234567890');
 
 ## Plugin config file
 
-Each plugin has a minimal default config file injected by Matterbridge when it is loaded:
+Each plugin has a minimal default config file injected by Matterbridge when it is loaded and the plugin doesn't have its own default one:
 
 ```typescript
 {
@@ -408,7 +424,7 @@ In all subsequent loads the config file is loaded from the '.matterbridge' direc
 
 ## Plugin schema file
 
-Each plugin has a minimal default schema file injected by Matterbridge when it is loaded:
+Each plugin has a minimal default schema file injected by Matterbridge when it is loaded and the plugin doesn't have its own default one:
 
 ```typescript
 {

package/README.md

@@ -56,6 +56,8 @@ Join us in the Matterbridge [Discord group](https://discord.gg/QX58CDe6hd) creat
 
 https://www.youtube.com/watch?v=goNB9Cgh_Fk
 
+https://www.youtube.com/watch?v=06zzl7o_IqQ
+
 ## Reviews
 
 https://www.matteralpha.com/how-to/how-to-configure-an-open-source-matter-bridge-at-home

package/dist/broadcastServer.js

@@ -2,8 +2,9 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mBroadcastServer loaded.\u001B[40;0m');
 import { EventEmitter } from 'node:events';
 import { BroadcastChannel } from 'node:worker_threads';
-import { CYAN, db, debugStringify } from 'node-ansi-logger';
+import { CYAN, db, debugStringify, er } from 'node-ansi-logger';
 import { hasParameter } from './utils/commandLine.js';
+import { logError } from './utils/error.js';
 export class BroadcastServer extends EventEmitter {
     name;
     log;
@@ -24,24 +25,64 @@ export class BroadcastServer extends EventEmitter {
         this.broadcastChannel.close();
     }
     getUniqueId() {
-        return Math.floor(Math.random() * (999999 - 100000 + 1)) + 100000;
+        return Math.floor(Math.random() * 900000000) + 100000000;
     }
-    isWorkerRequest(msg, type) {
-        return typeof msg === 'object' && msg !== null && 'id' in msg && 'timestamp' in msg && 'type' in msg && msg.type === type && !('response' in msg) && 'src' in msg && 'dst' in msg;
+    isWorkerRequest(value) {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        const message = value;
+        if (typeof message.type !== 'string' || typeof message.src !== 'string' || typeof message.dst !== 'string' || typeof message.id !== 'number' || typeof message.timestamp !== 'number') {
+            return false;
+        }
+        return message.result === undefined && message.error === undefined;
+    }
+    isWorkerRequestOfType(value, type) {
+        return this.isWorkerRequest(value) && value.type === type;
+    }
+    isWorkerResponse(value) {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        const message = value;
+        if (typeof message.type !== 'string' || typeof message.src !== 'string' || typeof message.dst !== 'string' || typeof message.id !== 'number' || typeof message.timestamp !== 'number') {
+            return false;
+        }
+        const hasError = typeof message.error === 'string';
+        const hasResult = message.result !== undefined;
+        return hasError !== hasResult;
     }
-    isWorkerResponse(msg, type) {
-        return typeof msg === 'object' && msg !== null && 'id' in msg && 'timestamp' in msg && 'type' in msg && msg.type === type && 'response' in msg && 'src' in msg && 'dst' in msg;
+    isWorkerResponseOfType(value, type) {
+        return this.isWorkerResponse(value) && value.type === type;
     }
     broadcastMessageHandler(event) {
-        const data = event.data;
-        if (this.verbose && (data.dst === this.name || data.dst === 'all'))
-            this.log.debug(`Server ${CYAN}${this.name}${db} received broadcast message: ${debugStringify(data)}`);
-        this.emit('broadcast_message', data);
+        const msg = event.data;
+        if (msg.dst === this.name || msg.dst === 'all') {
+            if (this.verbose)
+                this.log.debug(`Server ${CYAN}${this.name}${db} received broadcast message: ${debugStringify(msg)}`);
+            this.emit('broadcast_message', msg);
+        }
+        else {
+            if (this.verbose)
+                this.log.debug(`Server ${CYAN}${this.name}${db} received unrelated broadcast message: ${debugStringify(msg)}`);
+        }
     }
     broadcast(message) {
+        if (message.id === undefined) {
+            message.id = this.getUniqueId();
+        }
+        if (message.timestamp === undefined) {
+            message.timestamp = Date.now();
+        }
+        message.src = this.name;
         if (this.verbose)
             this.log.debug(`Broadcasting message: ${debugStringify(message)}`);
-        this.broadcastChannel.postMessage(message);
+        try {
+            this.broadcastChannel.postMessage(message);
+        }
+        catch (error) {
+            logError(this.log, `Failed to broadcast message ${debugStringify(message)}${er}`, error);
+        }
     }
     request(message) {
         if (message.id === undefined) {
@@ -50,25 +91,43 @@ export class BroadcastServer extends EventEmitter {
         if (message.timestamp === undefined) {
             message.timestamp = Date.now();
         }
-        if (!this.isWorkerRequest(message, message.type)) {
-            this.log.error(`Invalid request message format for broadcast: ${debugStringify(message)}`);
+        message.src = this.name;
+        if (!this.isWorkerRequest(message)) {
+            this.log.error(`Invalid request message format: ${debugStringify(message)}`);
             return;
         }
         if (this.verbose)
             this.log.debug(`Broadcasting request message: ${debugStringify(message)}`);
-        this.broadcastChannel.postMessage(message);
+        try {
+            this.broadcastChannel.postMessage(message);
+        }
+        catch (error) {
+            logError(this.log, `Failed to broadcast request message ${debugStringify(message)}${er}`, error);
+        }
     }
     respond(message) {
+        if (typeof message.timestamp === 'number') {
+            message.elapsed = Date.now() - message.timestamp;
+        }
         if (message.timestamp === undefined) {
             message.timestamp = Date.now();
         }
-        if (!this.isWorkerResponse(message, message.type)) {
-            this.log.error(`Invalid response message format for broadcast: ${debugStringify(message)}`);
+        if (message.dst === this.name || message.dst === 'all') {
+            message.dst = message.src;
+        }
+        message.src = this.name;
+        if (!this.isWorkerResponse(message)) {
+            this.log.error(`Invalid response message format: ${debugStringify(message)}`);
             return;
         }
         if (this.verbose)
             this.log.debug(`Broadcasting response message: ${debugStringify(message)}`);
-        this.broadcastChannel.postMessage(message);
+        try {
+            this.broadcastChannel.postMessage(message);
+        }
+        catch (error) {
+            logError(this.log, `Failed to broadcast response message ${debugStringify(message)}${er}`, error);
+        }
     }
     async fetch(message, timeout = 250) {
         if (message.id === undefined) {
@@ -81,23 +140,28 @@ export class BroadcastServer extends EventEmitter {
             this.log.debug(`Fetching message: ${debugStringify(message)}`);
         return new Promise((resolve, reject) => {
             const responseHandler = (msg) => {
-                if (this.isWorkerResponse(msg, message.type) && msg.id === message.id) {
+                if (this.isWorkerResponseOfType(msg, message.type) && msg.id === message.id) {
                     clearTimeout(timeoutId);
                     this.off('broadcast_message', responseHandler);
                     if (this.verbose)
                         this.log.debug(`Fetch response: ${debugStringify(msg)}`);
-                    resolve(msg);
-                }
-                else if (this.isWorkerResponse(msg, message.type) && msg.id !== message.id) {
-                    if (this.verbose)
-                        this.log.debug(`Fetch received unrelated response: ${debugStringify(msg)}`);
+                    if ('error' in msg && typeof msg.error === 'string') {
+                        reject(new Error(`Fetch received error response ${msg.error} to message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
+                    }
+                    else if ('result' in msg) {
+                        resolve(msg);
+                    }
+                    else {
+                        reject(new Error(`Fetch received malformed response for message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
+                    }
+                    return;
                 }
             };
             this.on('broadcast_message', responseHandler);
             this.request(message);
             const timeoutId = setTimeout(() => {
                 this.off('broadcast_message', responseHandler);
-                reject(new Error(`Fetch timeout after ${timeout}ms for message id ${message.id}`));
+                reject(new Error(`Fetch timeout after ${timeout}ms for message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
             }, timeout);
         });
     }

package/dist/deviceManager.js

@@ -44,44 +44,44 @@ export class DeviceManager {
         this.server.close();
     }
     async msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg, msg.type) && (msg.dst === 'all' || msg.dst === 'devices')) {
+        if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'devices')) {
             if (this.verbose)
                 this.log.debug(`Received request message ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
             switch (msg.type) {
                 case 'get_log_level':
-                    this.server.respond({ ...msg, response: { success: true, logLevel: this.log.logLevel } });
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
                 case 'set_log_level':
                     this.log.logLevel = msg.params.logLevel;
-                    this.server.respond({ ...msg, response: { success: true, logLevel: this.log.logLevel } });
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
                 case 'devices_length':
-                    this.server.respond({ ...msg, response: { length: this.length } });
+                    this.server.respond({ ...msg, result: { length: this.length } });
                     break;
                 case 'devices_size':
-                    this.server.respond({ ...msg, response: { size: this.size } });
+                    this.server.respond({ ...msg, result: { size: this.size } });
                     break;
                 case 'devices_has':
-                    this.server.respond({ ...msg, response: { has: this.has(msg.params.uniqueId) } });
+                    this.server.respond({ ...msg, result: { has: this.has(msg.params.uniqueId) } });
                     break;
                 case 'devices_get':
                     {
                         const endpoint = this.get(msg.params.uniqueId);
-                        this.server.respond({ ...msg, response: { device: endpoint ? toBaseDevice(endpoint) : undefined } });
+                        this.server.respond({ ...msg, result: { device: endpoint ? toBaseDevice(endpoint) : undefined } });
                     }
                     break;
                 case 'devices_set':
-                    this.server.respond({ ...msg, response: { device: this.set(toBaseDevice(msg.params.device)) } });
+                    this.server.respond({ ...msg, result: { device: this.set(toBaseDevice(msg.params.device)) } });
                     break;
                 case 'devices_remove':
-                    this.server.respond({ ...msg, response: { success: this.remove(toBaseDevice(msg.params.device)) } });
+                    this.server.respond({ ...msg, result: { success: this.remove(toBaseDevice(msg.params.device)) } });
                     break;
                 case 'devices_clear':
                     this.clear();
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'devices_basearray':
-                    this.server.respond({ ...msg, response: { devices: this.baseArray(msg.params.pluginName) } });
+                    this.server.respond({ ...msg, result: { devices: this.baseArray(msg.params.pluginName) } });
                     break;
                 default:
                     if (this.verbose)

package/dist/frontend.js

@@ -46,90 +46,88 @@ export class Frontend extends EventEmitter {
         this.server.close();
     }
     async msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg, msg.type) && (msg.dst === 'all' || msg.dst === 'frontend')) {
+        if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'frontend')) {
             if (this.verbose)
                 this.log.debug(`Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
             switch (msg.type) {
                 case 'get_log_level':
-                    this.server.respond({ ...msg, response: { success: true, logLevel: this.log.logLevel } });
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
                 case 'set_log_level':
                     this.log.logLevel = msg.params.logLevel;
-                    this.server.respond({ ...msg, response: { success: true, logLevel: this.log.logLevel } });
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
                 case 'frontend_start':
                     await this.start(msg.params.port);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_stop':
                     await this.stop();
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_refreshrequired':
-                    this.wssSendRefreshRequired(msg.params.changed, { matter: msg.params.matter });
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.wssSendRefreshRequired(msg.params.changed, msg.params.matter ? { matter: msg.params.matter } : undefined);
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_restartrequired':
                     this.wssSendRestartRequired(msg.params.snackbar, msg.params.fixed);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_restartnotrequired':
                     this.wssSendRestartNotRequired(msg.params.snackbar);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_updaterequired':
                     this.wssSendUpdateRequired(msg.params.devVersion);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_snackbarmessage':
                     this.wssSendSnackbarMessage(msg.params.message, msg.params.timeout, msg.params.severity);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_attributechanged':
                     this.wssSendAttributeChangedMessage(msg.params.plugin, msg.params.serialNumber, msg.params.uniqueId, msg.params.number, msg.params.id, msg.params.cluster, msg.params.attribute, msg.params.value);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_logmessage':
                     this.wssSendLogMessage(msg.params.level, msg.params.time, msg.params.name, msg.params.message);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
+                    break;
+                case 'frontend_broadcast_message':
+                    this.wssBroadcastMessage(msg.params.msg);
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 default:
                     if (this.verbose)
                         this.log.debug(`Unknown broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
             }
         }
-        if (this.server.isWorkerResponse(msg, msg.type)) {
+        if (this.server.isWorkerResponse(msg) && msg.result && (msg.dst === 'all' || msg.dst === 'frontend')) {
             if (this.verbose)
                 this.log.debug(`Received broadcast response ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
             switch (msg.type) {
-                case 'get_log_level':
-                case 'set_log_level':
-                    break;
                 case 'plugins_install':
-                    this.wssSendCloseSnackbarMessage(`Installing package ${msg.response.packageName}...`);
-                    if (msg.response.success) {
+                    this.wssSendCloseSnackbarMessage(`Installing package ${msg.result.packageName}...`);
+                    if (msg.result.success) {
                         this.wssSendRestartRequired(true, true);
                         this.wssSendRefreshRequired('plugins');
-                        this.wssSendSnackbarMessage(`Installed package ${msg.response.packageName}`, 5, 'success');
+                        this.wssSendSnackbarMessage(`Installed package ${msg.result.packageName}`, 5, 'success');
                     }
                     else {
-                        this.wssSendSnackbarMessage(`Package ${msg.response.packageName} not installed`, 10, 'error');
+                        this.wssSendSnackbarMessage(`Package ${msg.result.packageName} not installed`, 10, 'error');
                     }
                     break;
                 case 'plugins_uninstall':
-                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${msg.response.packageName}...`);
-                    if (msg.response.success) {
+                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${msg.result.packageName}...`);
+                    if (msg.result.success) {
                         this.wssSendRestartRequired(true, true);
                         this.wssSendRefreshRequired('plugins');
-                        this.wssSendSnackbarMessage(`Uninstalled package ${msg.response.packageName}`, 5, 'success');
+                        this.wssSendSnackbarMessage(`Uninstalled package ${msg.result.packageName}`, 5, 'success');
                     }
                     else {
-                        this.wssSendSnackbarMessage(`Package ${msg.response.packageName} not uninstalled`, 10, 'error');
+                        this.wssSendSnackbarMessage(`Package ${msg.result.packageName} not uninstalled`, 10, 'error');
                     }
                     break;
-                default:
-                    if (this.verbose)
-                        this.log.debug(`Unknown broadcast response ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
             }
         }
     }

package/dist/jestutils/jestHelpers.js

@@ -11,6 +11,9 @@ import { NodeStorageManager } from 'node-persist-manager';
 import { Matterbridge } from '../matterbridge.js';
 import { MATTER_STORAGE_NAME, NODE_STORAGE_DIR } from '../matterbridgeTypes.js';
 import { bridge } from '../matterbridgeDeviceTypes.js';
+import { PluginManager } from '../pluginManager.js';
+import { Frontend } from '../frontend.js';
+import { BroadcastServer } from '../broadcastServer.js';
 export const originalProcessArgv = Object.freeze([...process.argv]);
 export const originalProcessEnv = Object.freeze({ ...process.env });
 export let loggerLogSpy;
@@ -28,6 +31,30 @@ export let consoleErrorSpy;
 export let addBridgedEndpointSpy;
 export let removeBridgedEndpointSpy;
 export let removeAllBridgedEndpointsSpy;
+export let addVirtualEndpointSpy;
+export let installPluginSpy;
+export let uninstallPluginSpy;
+export let addPluginSpy;
+export let loadPluginSpy;
+export let startPluginSpy;
+export let configurePluginSpy;
+export let shutdownPluginSpy;
+export let removePluginSpy;
+export let enablePluginSpy;
+export let disablePluginSpy;
+export let wssSendSnackbarMessageSpy;
+export let wssSendCloseSnackbarMessageSpy;
+export let wssSendUpdateRequiredSpy;
+export let wssSendRefreshRequiredSpy;
+export let wssSendRestartRequiredSpy;
+export let wssSendRestartNotRequiredSpy;
+export let broadcastServerIsWorkerRequestSpy;
+export let broadcastServerIsWorkerResponseSpy;
+export let broadcastServerBroadcastSpy;
+export let broadcastServerRequestSpy;
+export let broadcastServerRespondSpy;
+export let broadcastServerFetchSpy;
+export let broadcastMessageHandlerSpy;
 export let NAME;
 export let HOMEDIR;
 export let matterbridge;
@@ -71,6 +98,30 @@ export async function setupTest(name, debug = false) {
     addBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'addBridgedEndpoint');
     removeBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'removeBridgedEndpoint');
     removeAllBridgedEndpointsSpy = jest.spyOn(Matterbridge.prototype, 'removeAllBridgedEndpoints');
+    addVirtualEndpointSpy = jest.spyOn(Matterbridge.prototype, 'addVirtualEndpoint');
+    installPluginSpy = jest.spyOn(PluginManager.prototype, 'install');
+    uninstallPluginSpy = jest.spyOn(PluginManager.prototype, 'uninstall');
+    addPluginSpy = jest.spyOn(PluginManager.prototype, 'add');
+    loadPluginSpy = jest.spyOn(PluginManager.prototype, 'load');
+    startPluginSpy = jest.spyOn(PluginManager.prototype, 'start');
+    configurePluginSpy = jest.spyOn(PluginManager.prototype, 'configure');
+    shutdownPluginSpy = jest.spyOn(PluginManager.prototype, 'shutdown');
+    removePluginSpy = jest.spyOn(PluginManager.prototype, 'remove');
+    enablePluginSpy = jest.spyOn(PluginManager.prototype, 'enable');
+    disablePluginSpy = jest.spyOn(PluginManager.prototype, 'disable');
+    wssSendSnackbarMessageSpy = jest.spyOn(Frontend.prototype, 'wssSendSnackbarMessage');
+    wssSendCloseSnackbarMessageSpy = jest.spyOn(Frontend.prototype, 'wssSendCloseSnackbarMessage');
+    wssSendUpdateRequiredSpy = jest.spyOn(Frontend.prototype, 'wssSendUpdateRequired');
+    wssSendRefreshRequiredSpy = jest.spyOn(Frontend.prototype, 'wssSendRefreshRequired');
+    wssSendRestartRequiredSpy = jest.spyOn(Frontend.prototype, 'wssSendRestartRequired');
+    wssSendRestartNotRequiredSpy = jest.spyOn(Frontend.prototype, 'wssSendRestartNotRequired');
+    broadcastServerIsWorkerRequestSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerRequest');
+    broadcastServerIsWorkerResponseSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerResponse');
+    broadcastServerBroadcastSpy = jest.spyOn(BroadcastServer.prototype, 'broadcast');
+    broadcastServerRequestSpy = jest.spyOn(BroadcastServer.prototype, 'request');
+    broadcastServerRespondSpy = jest.spyOn(BroadcastServer.prototype, 'respond');
+    broadcastServerFetchSpy = jest.spyOn(BroadcastServer.prototype, 'fetch');
+    broadcastMessageHandlerSpy = jest.spyOn(BroadcastServer.prototype, 'broadcastMessageHandler');
 }
 export async function setDebug(debug) {
     const { jest } = await import('@jest/globals');

package/dist/matterNode.js

@@ -92,23 +92,23 @@ export class MatterNode extends EventEmitter {
             this.log.debug(`MatterNode ${this.pluginName ? 'for plugin ' + this.pluginName : 'bridge'} loaded`);
     }
     async msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg, msg.type) && (msg.dst === 'all' || msg.dst === 'matter')) {
+        if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'matter')) {
             if (this.verbose)
                 this.log.debug(`Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
             switch (msg.type) {
                 case 'get_log_level':
-                    this.server.respond({ ...msg, response: { success: true, logLevel: this.log.logLevel } });
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
                 case 'set_log_level':
                     this.log.logLevel = msg.params.logLevel;
-                    this.server.respond({ ...msg, response: { success: true, logLevel: this.log.logLevel } });
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
                 default:
                     if (this.verbose)
                         this.log.debug(`Unknown broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
             }
         }
-        if (this.server.isWorkerResponse(msg, msg.type) && (msg.dst === 'all' || msg.dst === 'matter')) {
+        if (this.server.isWorkerResponse(msg) && (msg.dst === 'all' || msg.dst === 'matter')) {
             if (this.verbose)
                 this.log.debug(`Received broadcast response ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
             switch (msg.type) {
@@ -669,6 +669,7 @@ export class MatterNode extends EventEmitter {
         await device.construction.ready;
         await this.subscribeAttributeChanged(plugin, device);
         this.log.info(`Added endpoint #${plugin.registeredDevices} ${plg}${pluginName}${nf}:${dev}${device.deviceName}${nf} (${zb}${device.name}${nf})`);
+        await this.yieldToNode(10);
         return device;
     }
     async removeBridgedEndpoint(pluginName, device) {
@@ -697,6 +698,7 @@ export class MatterNode extends EventEmitter {
         if (plugin.registeredDevices !== undefined)
             plugin.registeredDevices--;
         await this.server.fetch({ type: 'devices_remove', src: this.server.name, dst: 'devices', params: { device: toBaseDevice(device) } });
+        await this.yieldToNode(10);
         return device;
     }
     async removeAllBridgedEndpoints(pluginName, delay = 0) {
@@ -704,7 +706,7 @@ export class MatterNode extends EventEmitter {
         if (!plugin)
             throw new Error(`Error removing all bridged endpoints for plugin ${plg}${pluginName}${er}: plugin not found`);
         this.log.debug(`Removing all #${plugin.registeredDevices} bridged endpoints for plugin ${plg}${pluginName}${db}${delay > 0 ? ` with delay ${delay} ms` : ''}...`);
-        const devices = (await this.server.fetch({ type: 'devices_basearray', src: this.server.name, dst: 'devices', params: { pluginName } })).response.devices;
+        const devices = (await this.server.fetch({ type: 'devices_basearray', src: this.server.name, dst: 'devices', params: { pluginName } })).result.devices;
         for (const device of devices) {
             const endpoint = (this.aggregatorNode?.parts.get(device.id || '') || this.serverNode?.parts.get(device.id || ''));
             if (!endpoint)
@@ -715,6 +717,7 @@ export class MatterNode extends EventEmitter {
             if (plugin.registeredDevices !== undefined)
                 plugin.registeredDevices--;
             await this.server.fetch({ type: 'devices_remove', src: this.server.name, dst: 'devices', params: { device: toBaseDevice(device) } });
+            await this.yieldToNode(10);
             if (delay > 0)
                 await wait(delay);
         }
@@ -742,6 +745,7 @@ export class MatterNode extends EventEmitter {
         }
         await addVirtualDevice(this.aggregatorNode, name.slice(0, 32), type, callback);
         this.log.debug(`Created virtual device ${plg}${pluginName}${db}:${dev}${name}${db}`);
+        await this.yieldToNode(10);
         return true;
     }
     async subscribeAttributeChanged(plugin, device) {