matterbridge 3.4.1-dev-20251128-441f8db → 3.4.1-dev-20251130-f066d82

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,10 @@ 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.
+- [PluginManager]: Improved the resolve method to resolve automatically also in the plugin directory Usefull for developing with DevContainer.
 
 ### Changed
 

package/dist/broadcastServer.js

@@ -25,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) {
@@ -51,8 +91,9 @@ 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)
@@ -65,11 +106,18 @@ export class BroadcastServer extends EventEmitter {
         }
     }
     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)
@@ -92,16 +140,21 @@ 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);

package/dist/deviceManager.js

@@ -41,47 +41,48 @@ export class DeviceManager {
         this.log.debug('Matterbridge device manager started');
     }
     destroy() {
+        this.server.off('broadcast_message', this.msgHandler.bind(this));
         this.server.close();
     }
     async msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg, msg.type) && (msg.dst === 'all' || msg.dst === 'devices')) {
+        if (this.server.isWorkerRequest(msg)) {
             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

@@ -43,97 +43,92 @@ export class Frontend extends EventEmitter {
         this.server.on('broadcast_message', this.msgHandler.bind(this));
     }
     destroy() {
+        this.server.off('broadcast_message', this.msgHandler.bind(this));
         this.server.close();
     }
     async msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg, msg.type) && (msg.dst === 'all' || msg.dst === 'frontend')) {
+        if (this.server.isWorkerRequest(msg)) {
             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, msg.params.matter ? { matter: msg.params.matter } : undefined);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    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, response: { success: true } });
+                    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) {
             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

@@ -50,6 +50,7 @@ export let wssSendRestartRequiredSpy;
 export let wssSendRestartNotRequiredSpy;
 export let broadcastServerIsWorkerRequestSpy;
 export let broadcastServerIsWorkerResponseSpy;
+export let broadcastServerBroadcastSpy;
 export let broadcastServerRequestSpy;
 export let broadcastServerRespondSpy;
 export let broadcastServerFetchSpy;
@@ -116,6 +117,7 @@ export async function setupTest(name, debug = false) {
     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');

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) {

package/dist/matterbridge.js

@@ -133,52 +133,45 @@ export class Matterbridge extends EventEmitter {
         this.server.close();
     }
     async msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg, msg.type) && (msg.dst === 'all' || msg.dst === 'matterbridge')) {
+        if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'matterbridge')) {
             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 'matterbridge_latest_version':
                     this.matterbridgeLatestVersion = msg.params.version;
                     await this.nodeContext?.set('matterbridgeLatestVersion', msg.params.version);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'matterbridge_dev_version':
                     this.matterbridgeDevVersion = msg.params.version;
                     await this.nodeContext?.set('matterbridgeDevVersion', msg.params.version);
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
+                    break;
+                case 'matterbridge_global_prefix':
+                    this.globalModulesDirectory = msg.params.prefix;
+                    await this.nodeContext?.set('globalModulesDirectory', msg.params.prefix);
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'matterbridge_sys_update':
                     this.shellySysUpdate = true;
-                    this.server.respond({ ...msg, response: { success: true } });
+                    this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'matterbridge_main_update':
                     this.shellyMainUpdate = true;
-                    this.server.respond({ ...msg, response: { success: true } });
+                    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.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;
-                default:
-                    if (this.verbose)
-                        this.log.debug(`Unknown broadcast response ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
-            }
-        }
     }
     static async loadInstance(initialize = false) {
         if (!Matterbridge.instance) {
@@ -832,16 +825,9 @@ export class Matterbridge extends EventEmitter {
             }
         }
         else {
-            this.log.debug(`Checking global node_modules directory: ${this.globalModulesDirectory}`);
-            try {
-                const { getGlobalNodeModules } = await import('./utils/network.js');
-                this.globalModulesDirectory = await getGlobalNodeModules();
-                this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
-                await this.nodeContext?.set('globalModulesDirectory', this.globalModulesDirectory);
-            }
-            catch (error) {
-                this.log.error(`Error checking global node_modules directory: ${error}`);
-            }
+            this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
+            const { createESMWorker } = await import('./workers.js');
+            createESMWorker('NpmGlobalPrefix', './dist/workerGlobalPrefix.js');
         }
         this.log.debug(`Reading matterbridge package.json...`);
         const packageJson = JSON.parse(await fs.promises.readFile(path.join(this.rootDirectory, 'package.json'), 'utf-8'));

package/dist/matterbridgePlatform.js

@@ -124,7 +124,7 @@ export class MatterbridgePlatform {
         this.#server.request({ type: 'plugins_saveconfigfromjson', src: 'platform', dst: 'plugins', params: { name: this.name, config } });
     }
     async getSchema() {
-        return (await this.#server.fetch({ type: 'plugins_getschema', src: 'platform', dst: 'plugins', params: { name: this.name } })).response.schema;
+        return (await this.#server.fetch({ type: 'plugins_getschema', src: 'platform', dst: 'plugins', params: { name: this.name } })).result.schema;
     }
     setSchema(schema) {
         this.#server.request({ type: 'plugins_setschema', src: 'platform', dst: 'plugins', params: { name: this.name, schema } });