@matterbridge/core 3.10.14-dev-20261010-607ee18 → 3.10.14-dev-20261013-e87a0c8

package/dist/matterNode.js

@@ -10,11 +10,11 @@ import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/brid
 import { PowerSourceServer } from '@matter/node/behaviors/power-source';
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
 import { MdnsService, PaseClient } from '@matter/protocol';
-import { DeviceTypeId, EndpointNumber, VendorId } from '@matter/types';
 import { PowerSource } from '@matter/types/clusters/power-source';
+import { DeviceTypeId, EndpointNumber, VendorId } from '@matter/types/datatype';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg } from '@matterbridge/types';
-import { getIntParameter, getParameter, hasParameter } from '@matterbridge/utils/cli';
+import { getIntParameter, getParameter, hasAnyParameter, hasParameter } from '@matterbridge/utils/cli';
 import { copyDirectory } from '@matterbridge/utils/copy-dir';
 import { getErrorMessage, inspectError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
@@ -22,10 +22,9 @@ import { isValidInteger, isValidString, parseVersionString } from '@matterbridge
 import { fireAndForget, wait, withTimeout } from '@matterbridge/utils/wait';
 import { AnsiLogger, BLUE, CYAN, db, debugStringify, er, nf, or, zb } from 'node-ansi-logger';
 import { NodeStorageManager } from 'node-persist-manager';
-import { toBaseDevice } from './deviceManager.js';
 import { addVirtualDevice } from './helpers.js';
 import { bridge } from './matterbridgeDeviceTypes.js';
-import { deleteAdvertisingNode, getServerNodeData, setAdvertisingNode } from './matterNodeHelpers.js';
+import { deleteAdvertisingNode, getServerNodeData, setAdvertisingNode, toBaseDevice } from './matterNodeHelpers.js';
 import { PluginManager } from './pluginManager.js';
 logModuleLoaded('MatterNode');
 export class MatterNode extends EventEmitter {
@@ -59,14 +58,16 @@ export class MatterNode extends EventEmitter {
     pluginManager;
     dependantMatterNodes = new Map();
     server;
-    debug = hasParameter('debug') || hasParameter('verbose');
-    verbose = hasParameter('verbose');
+    debug = hasAnyParameter('debug', 'verbose', 'debug-node', 'verbose-node');
+    verbose = hasAnyParameter('verbose', 'verbose-node');
     constructor(matterbridge, pluginName, device) {
         super();
         this.matterbridge = matterbridge;
         this.pluginName = pluginName;
         this.device = device;
         this.log.logNameColor = '\x1b[38;5;65m';
+        this.log.logLevel = matterbridge.logLevel;
+        this.matterLog.logLevel = matterbridge.matterLogLevel;
         if (this.debug)
             this.log.debug(`MatterNode ${this.pluginName ? 'for plugin ' + this.pluginName : 'bridge'} loading...`);
         this.storeId = this.device?.deviceName ? this.device.deviceName.replace(/[ .]/g, '') : (this.pluginName ?? 'Matterbridge');
@@ -75,12 +76,20 @@ export class MatterNode extends EventEmitter {
         this.discriminator = matterbridge.discriminator;
         this.mdnsInterface = matterbridge.mdnsInterface;
         this.server = new BroadcastServer('matter', this.log);
-        this.server.on('broadcast_message', this.msgHandler.bind(this));
+        this.server.on('broadcast_message', (msg) => fireAndForget(this.msgHandler(msg), this.log, 'Broadcast message handler'));
         if (this.verbose)
             this.log.debug(`BroadcastServer is ready`);
-        this.pluginManager = new PluginManager(this.matterbridge);
-        this.pluginManager.logLevel = this.debug ? "debug" : "info";
+        const injectMatterbridge = {
+            ...this.matterbridge,
+            getPlatformMatterbridge: () => this.matterbridge,
+            addBridgedEndpoint: this.addBridgedEndpoint.bind(this),
+            removeBridgedEndpoint: this.removeBridgedEndpoint.bind(this),
+            removeAllBridgedEndpoints: this.removeAllBridgedEndpoints.bind(this),
+            addVirtualEndpoint: this.addVirtualEndpoint.bind(this),
+        };
+        this.pluginManager = new PluginManager(injectMatterbridge);
         this.pluginManager.server.close();
+        this.pluginManager.logLevel = this.debug ? "debug" : "info";
         if (this.verbose)
             this.log.debug(`PluginManager is ready`);
         this.environment.vars.set('log.level', MatterLogLevel.DEBUG);
@@ -88,6 +97,7 @@ export class MatterNode extends EventEmitter {
         this.environment.vars.set('path.root', path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR));
         this.environment.vars.set('runtime.signals', false);
         this.environment.vars.set('runtime.exitcode', false);
+        this.environment.vars.set('endpoint.validation', 'strict');
         if (this.mdnsInterface)
             this.environment.vars.set('mdns.networkInterface', this.mdnsInterface);
         if (this.verbose)
@@ -106,10 +116,10 @@ export class MatterNode extends EventEmitter {
         if (this.verbose)
             this.log.debug(`Matter logLevel: ${levels[Logger.level]} fileLogger: ${matterbridge.matterFileLogger}.`);
         if (this.debug)
-            this.log.debug(`MatterNode ${this.pluginName ? 'for plugin ' + this.pluginName : 'bridge'} loaded`);
+            this.log.debug(`MatterNode for ${this.storeId} loaded`);
     }
     async msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'matter')) {
+        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) {
@@ -159,6 +169,8 @@ export class MatterNode extends EventEmitter {
             switch (msg.type) {
                 case 'get_log_level':
                 case 'set_log_level':
+                case 'matterbridge_platform':
+                case 'matterbridge_shared':
                     break;
                 default:
                     if (this.verbose)
@@ -183,11 +195,12 @@ export class MatterNode extends EventEmitter {
             this.log.debug(`Destroyed MatterNode instance for ${this.storeId}`);
     }
     async create() {
-        this.log.info('Creating Matter node...');
+        this.log.info(`Creating Matter node for ${this.storeId}...`);
         const { result } = await this.server.fetch({ type: 'matterbridge_matterdata', src: this.server.name, dst: 'matterbridge' });
         this.port = result.port;
         this.passcode = result.passcode;
         this.discriminator = result.discriminator;
+        this.log.debug(`Loaded Matter node  parameters for ${this.storeId}: port ${CYAN}${this.port}${db} passcode ${CYAN}${this.passcode}${db} discriminator ${CYAN}${this.discriminator}${db}`);
         await this.startMatterStorage();
         this.pluginManager.matterbridge.nodeStorage = new NodeStorageManager({
             dir: path.join(this.matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR),
@@ -204,7 +217,16 @@ export class MatterNode extends EventEmitter {
             this.emit('ready', this.device.deviceName.replace(/[ .]/g, ''));
             return;
         }
-        if (!this.pluginName) {
+        if (this.pluginName) {
+            this.log.debug(`Creating MatterNode instance for plugin ${CYAN}${this.pluginName}${db}...`);
+            this.log.debug(`Loading plugin ${CYAN}${this.pluginName}${db}...`);
+            await this.pluginManager.load(this.pluginName);
+            this.pluginStatusUpdate(this.pluginName, { loaded: this.pluginManager.get(this.pluginName)?.loaded });
+            this.log.debug(`Loaded plugin ${CYAN}${this.pluginName}${db}`);
+            this.log.debug(`Created MatterNode instance for plugin ${CYAN}${this.pluginName}${db}`);
+            this.emit('ready', this.pluginName);
+        }
+        else {
             this.log.debug('Creating MatterNode instance for all plugins...');
             await this.createMatterbridgeServerNode();
             this.log.debug('Loading all plugins...');
@@ -213,25 +235,20 @@ export class MatterNode extends EventEmitter {
                 loadPromises.push(this.pluginManager.load(plugin));
             }
             await Promise.all(loadPromises);
+            for (const plugin of this.pluginManager.array().filter((p) => p.enabled)) {
+                this.pluginStatusUpdate(plugin.name, { loaded: plugin.loaded });
+            }
             this.log.debug('Loaded all plugins');
             this.log.debug('Created MatterNode instance for all plugins');
             this.emit('ready', 'Matterbridge');
         }
-        else {
-            this.log.debug(`Creating MatterNode instance for plugin ${CYAN}${this.pluginName}${db}...`);
-            this.log.debug(`Loading plugin ${CYAN}${this.pluginName}${db}...`);
-            await this.pluginManager.load(this.pluginName);
-            this.log.debug(`Loaded plugin ${CYAN}${this.pluginName}${db}`);
-            this.log.debug(`Created MatterNode instance for plugin ${CYAN}${this.pluginName}${db}`);
-            this.emit('ready', this.pluginName);
-        }
-        this.log.info('Created Matter node');
+        this.log.info(`Created Matter node for ${this.storeId}`);
         await this.yieldToNode();
     }
     async start() {
         if (!this.serverNode && !this.pluginName)
-            throw new Error('Matter server node not created yet. Call create() first.');
-        this.log.info('Starting MatterNode...');
+            throw new Error(`Matter server node for ${this.storeId} not created yet. Call create() first.`);
+        this.log.info(`Starting MatterNode for ${this.storeId}...`);
         if (this.pluginName && this.device?.deviceName) {
             this.log.debug(`Starting MatterNode for server device ${this.pluginName}:${this.device.deviceName}...`);
             await this.startServerNode();
@@ -239,43 +256,56 @@ export class MatterNode extends EventEmitter {
             return;
         }
         if (!this.pluginName) {
-            this.log.debug('Starting all plugins...');
+            this.log.debug(`Starting all plugins for ${this.storeId}...`);
             const startPromises = [];
             for (const plugin of this.pluginManager.array().filter((p) => p.enabled && p.loaded)) {
                 startPromises.push(this.pluginManager.start(plugin, 'Starting MatterNode'));
             }
             await Promise.all(startPromises);
-            this.log.debug('Started all plugins');
-            this.log.debug('Starting MatterNode for all plugins...');
+            for (const plugin of this.pluginManager.array().filter((p) => p.enabled)) {
+                this.pluginStatusUpdate(plugin.name, { started: plugin.started, registeredDevices: plugin.registeredDevices });
+            }
+            this.log.debug(`Started all plugins for ${this.storeId}`);
+            this.log.debug(`Starting MatterNode for ${this.storeId}...`);
             await this.startServerNode();
-            this.log.debug('Started MatterNode for all plugins');
-            this.log.debug('Configuring all plugins...');
+            this.log.debug(`Started MatterNode for ${this.storeId}`);
+            this.log.debug(`Configuring all plugins for ${this.storeId}...`);
             const configurePromises = [];
             for (const plugin of this.pluginManager.array().filter((p) => p.enabled && p.started)) {
                 configurePromises.push(this.pluginManager.configure(plugin));
             }
             await Promise.all(configurePromises);
-            this.log.debug('Configured all plugins');
+            for (const plugin of this.pluginManager.array().filter((p) => p.enabled)) {
+                this.pluginStatusUpdate(plugin.name, { configured: plugin.configured });
+            }
+            this.log.debug(`Configured all plugins for ${this.storeId}`);
         }
         else {
+            this.log.debug(`Starting plugin ${this.pluginName}...`);
             await this.pluginManager.start(this.pluginName, 'Starting MatterNode');
-            this.log.debug(`Starting MatterNode for plugin ${this.pluginName}...`);
+            const plugin = this.pluginManager.get(this.pluginName);
+            this.pluginStatusUpdate(this.pluginName, { started: plugin?.started, registeredDevices: plugin?.registeredDevices });
+            this.log.debug(`Started plugin ${this.pluginName}...`);
+            this.log.debug(`Starting MatterNode for plugin ${this.storeId}...`);
             await this.startServerNode();
-            this.log.debug(`Started MatterNode for plugin ${this.pluginName}`);
+            this.log.debug(`Started MatterNode for plugin ${this.storeId}`);
+            this.log.debug(`Configuring plugin ${this.pluginName}...`);
             await this.pluginManager.configure(this.pluginName);
+            this.pluginStatusUpdate(this.pluginName, { configured: this.pluginManager.get(this.pluginName)?.configured });
+            this.log.debug(`Configured plugin ${this.pluginName}...`);
         }
-        this.log.debug(`Starting dependant MatterNodes...`);
+        this.log.debug(`Starting dependant MatterNodes for ${this.storeId}...`);
         for (const dependantMatterNode of this.dependantMatterNodes.values()) {
             await dependantMatterNode.start();
         }
-        this.log.debug(`Started dependant MatterNodes`);
-        this.log.info('Started MatterNode');
+        this.log.debug(`Started dependant MatterNodes for ${this.storeId}`);
+        this.log.info(`Started MatterNode for ${this.storeId}`);
         await this.yieldToNode();
     }
     async stop() {
         if (!this.serverNode)
-            throw new Error('Matter server node not created yet. Call create() first.');
-        this.log.info('Stopping MatterNode...');
+            throw new Error(`Matter server node for ${this.storeId} not created yet. Call create() first.`);
+        this.log.info(`Stopping MatterNode for ${this.storeId}...`);
         if (this.pluginName && this.device?.deviceName) {
             this.log.debug(`Stopping MatterNode for server device ${this.pluginName}:${this.device.deviceName}...`);
             await this.stopServerNode();
@@ -284,34 +314,34 @@ export class MatterNode extends EventEmitter {
             await this.stopMatterStorage();
             await this.destroy(false);
             this.log.debug(`Stopped MatterNode for server device ${this.pluginName}:${this.device.deviceName}`);
-            this.log.info('Stopped MatterNode');
+            this.log.info(`Stopped MatterNode for ${this.storeId}`);
             await this.yieldToNode();
             return;
         }
         if (!this.pluginName) {
-            this.log.debug('Stopping all plugins...');
+            this.log.debug(`Stopping all plugins for ${this.storeId}...`);
             const shutdownPromises = [];
             for (const plugin of this.pluginManager.array().filter((p) => p.enabled && p.started)) {
                 shutdownPromises.push(this.pluginManager.shutdown(plugin, 'Stopping MatterNode'));
             }
             await Promise.all(shutdownPromises);
-            this.log.debug('Stopped all plugins');
+            this.log.debug(`Stopped all plugins for ${this.storeId}`);
         }
         else {
             this.log.debug(`Stopping plugin ${this.pluginName}...`);
             await this.pluginManager.shutdown(this.pluginName, 'Stopping MatterNode');
             this.log.debug(`Stopped plugin ${this.pluginName}`);
         }
-        this.log.debug(`Stopping dependant MatterNodes...`);
+        this.log.debug(`Stopping dependant MatterNodes for ${this.storeId}...`);
         for (const dependantMatterNode of this.dependantMatterNodes.values()) {
             await dependantMatterNode.stop();
         }
-        this.log.debug(`Stopped dependant MatterNodes`);
+        this.log.debug(`Stopped dependant MatterNodes for ${this.storeId}`);
         await this.stopServerNode();
         this.serverNode = undefined;
         this.aggregatorNode = undefined;
         await this.stopMatterStorage();
-        this.log.info('Stopped MatterNode');
+        this.log.info(`Stopped MatterNode for ${this.storeId}`);
         await this.yieldToNode();
     }
     createDestinationMatterLogger() {
@@ -375,23 +405,28 @@ export class MatterNode extends EventEmitter {
         const storageManager = await this.matterStorageService.open(storeId);
         const storageContext = storageManager.createContext('persist');
         const random = randomBytes(8).toString('hex');
-        await storageContext.set('storeId', storeId);
-        await storageContext.set('deviceName', deviceName);
-        await storageContext.set('deviceType', deviceType);
-        await storageContext.set('vendorId', vendorId);
-        await storageContext.set('vendorName', vendorName.slice(0, 32));
-        await storageContext.set('productId', productId);
-        await storageContext.set('productName', productName.slice(0, 32));
-        await storageContext.set('productLabel', productLabel.replace(vendorName, '').trim().slice(0, 64));
-        await storageContext.set('productUrl', isValidString(productUrl, 8, 256) && productUrl.startsWith('https://') ? productUrl : 'https://matterbridge.io');
-        await storageContext.set('nodeLabel', deviceName.slice(0, 32));
-        await storageContext.set('serialNumber', await storageContext.get('serialNumber', serialNumber ? serialNumber.slice(0, 32) : 'SN' + random));
-        await storageContext.set('uniqueId', await storageContext.get('uniqueId', uniqueId ? uniqueId.slice(0, 32) : 'UI' + random));
-        await storageContext.set('softwareVersion', isValidInteger(softwareVersion, 0, UINT32_MAX) ? softwareVersion : 1);
-        await storageContext.set('softwareVersionString', isValidString(softwareVersionString, 1, 64) ? softwareVersionString : '1.0.0');
-        await storageContext.set('hardwareVersion', isValidInteger(hardwareVersion, 0, UINT16_MAX) ? hardwareVersion : 1);
-        await storageContext.set('hardwareVersionString', isValidString(hardwareVersionString, 1, 64) ? hardwareVersionString : '1.0.0');
-        await storageContext.set('configurationVersion', isValidInteger(configurationVersion, 1, UINT32_MAX) ? configurationVersion : 1);
+        async function setIfDifferent(key, value) {
+            if (!(await storageContext.has(key)) || (await storageContext.get(key)) !== value) {
+                await storageContext.set(key, value);
+            }
+        }
+        await setIfDifferent('storeId', storeId);
+        await setIfDifferent('deviceName', deviceName);
+        await setIfDifferent('deviceType', deviceType);
+        await setIfDifferent('vendorId', vendorId);
+        await setIfDifferent('vendorName', vendorName.slice(0, 32));
+        await setIfDifferent('productId', productId);
+        await setIfDifferent('productName', productName.slice(0, 32));
+        await setIfDifferent('productLabel', productLabel.replace(vendorName, '').trim().slice(0, 64));
+        await setIfDifferent('productUrl', isValidString(productUrl, 8, 256) && productUrl.startsWith('https://') ? productUrl : 'https://matterbridge.io');
+        await setIfDifferent('nodeLabel', deviceName.slice(0, 32));
+        await setIfDifferent('serialNumber', await storageContext.get('serialNumber', serialNumber ? serialNumber.slice(0, 32) : 'SN' + random));
+        await setIfDifferent('uniqueId', await storageContext.get('uniqueId', uniqueId ? uniqueId.slice(0, 32) : 'UI' + random));
+        await setIfDifferent('softwareVersion', isValidInteger(softwareVersion, 0, UINT32_MAX) ? softwareVersion : 1);
+        await setIfDifferent('softwareVersionString', isValidString(softwareVersionString, 1, 64) ? softwareVersionString : '1.0.0');
+        await setIfDifferent('hardwareVersion', isValidInteger(hardwareVersion, 0, UINT16_MAX) ? hardwareVersion : 1);
+        await setIfDifferent('hardwareVersionString', isValidString(hardwareVersionString, 1, 64) ? hardwareVersionString : '1.0.0');
+        await setIfDifferent('configurationVersion', isValidInteger(configurationVersion, 1, UINT32_MAX) ? configurationVersion : 1);
         this.log.debug(`Created server node storage context "${storeId}.persist" for ${storeId}:`);
         this.log.debug(`- storeId: ${await storageContext.get('storeId')}`);
         this.log.debug(`- deviceName: ${await storageContext.get('deviceName')}`);
@@ -626,7 +661,7 @@ export class MatterNode extends EventEmitter {
     async createMatterbridgeServerNode() {
         this.log.debug(`Creating ${plg}Matterbridge${db} server node...`);
         this.matterStorageContext = await this.createServerNodeContext('Matterbridge', 'Matterbridge', this.aggregatorDeviceType, this.aggregatorVendorId, this.aggregatorVendorName, this.aggregatorProductId, this.aggregatorProductName, this.aggregatorSerialNumber, this.aggregatorUniqueId, parseVersionString(this.matterbridge.matterbridgeVersion), this.matterbridge.matterbridgeVersion, parseVersionString(this.matterbridge.systemInformation.osRelease), this.matterbridge.systemInformation.osRelease, 'Matter Bridge', 'https://matterbridge.io', 1);
-        this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+        this.serverNode = await this.createServerNode(this.port, this.passcode, this.discriminator);
         this.aggregatorNode = await this.createAggregatorNode();
         this.log.debug(`Adding ${plg}Matterbridge${db} aggregator node...`);
         await this.serverNode.add(this.aggregatorNode);
@@ -647,7 +682,7 @@ export class MatterNode extends EventEmitter {
             plugin.locked = true;
             this.log.debug(`Creating accessory plugin ${plg}${plugin.name}${db} server node...`);
             this.matterStorageContext = await this.createServerNodeContext(plugin.name, device.deviceName, DeviceTypeId(device.deviceType), VendorId(device.vendorId), device.vendorName, device.productId, device.productName, device.serialNumber, device.uniqueId, device.softwareVersion, device.softwareVersionString, device.hardwareVersion, device.hardwareVersionString, device.productLabel, device.productUrl, device.configurationVersion);
-            this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+            this.serverNode = await this.createServerNode(this.port, this.passcode, this.discriminator);
             this.log.debug(`Adding ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db} to ${plg}${plugin.name}${db} server node...`);
             await this.serverNode.add(device);
             this.log.debug(`Added ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db} to ${plg}${plugin.name}${db} server node`);
@@ -668,7 +703,7 @@ export class MatterNode extends EventEmitter {
             plugin.locked = true;
             this.log.debug(`Creating dynamic plugin ${plg}${plugin.name}${db} server node...`);
             this.matterStorageContext = await this.createServerNodeContext(plugin.name, plugin.description, this.aggregatorDeviceType, this.aggregatorVendorId, this.aggregatorVendorName, this.aggregatorProductId, this.aggregatorProductName, undefined, undefined, parseVersionString(this.matterbridge.matterbridgeVersion), this.matterbridge.matterbridgeVersion, parseVersionString(this.matterbridge.systemInformation.osRelease), this.matterbridge.systemInformation.osRelease, plugin.description, plugin.homepage ?? 'https://matterbridge.io', plugin.configurationVersion);
-            this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+            this.serverNode = await this.createServerNode(this.port, this.passcode, this.discriminator);
             this.log.debug(`Creating dynamic plugin ${plg}${plugin.name}${db} aggregator node...`);
             this.aggregatorNode = await this.createAggregatorNode();
             this.log.debug(`Adding dynamic plugin ${plg}${plugin.name}${db} aggregator node...`);
@@ -690,7 +725,7 @@ export class MatterNode extends EventEmitter {
         if (device.mode === 'server' && device.deviceType && device.deviceName && device.vendorId && device.vendorName && device.productId && device.productName) {
             this.log.debug(`Creating device ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db} server node...`);
             this.matterStorageContext = await this.createServerNodeContext(device.deviceName.replace(/[ .]/g, ''), device.deviceName, DeviceTypeId(device.deviceType), VendorId(device.vendorId), device.vendorName, device.productId, device.productName, device.serialNumber, device.uniqueId, device.softwareVersion, device.softwareVersionString, device.hardwareVersion, device.hardwareVersionString, device.productLabel, device.productUrl, device.configurationVersion);
-            this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+            this.serverNode = await this.createServerNode(this.port, this.passcode, this.discriminator);
             this.log.debug(`Adding ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db} to server node...`);
             await this.serverNode.add(device);
             this.log.debug(`Added ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db} to server node`);
@@ -708,9 +743,6 @@ export class MatterNode extends EventEmitter {
             try {
                 this.log.debug(`Creating MatterNode for device ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})...`);
                 const matterNode = new MatterNode(this.matterbridge, pluginName, device);
-                matterNode.port = this.port ? this.port++ : undefined;
-                matterNode.passcode = this.passcode ? this.passcode++ : undefined;
-                matterNode.discriminator = this.discriminator ? this.discriminator++ : undefined;
                 this.dependantMatterNodes.set(device.id, matterNode);
                 await matterNode.create();
                 this.log.debug(`Created MatterNode for device ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})`);
@@ -1002,6 +1034,23 @@ export class MatterNode extends EventEmitter {
             child.act((agent) => child.eventsOf(BridgedDeviceBasicInformationServer).reachableChanged.emit({ reachableNewValue: true }, agent.context));
         }
     }
+    pluginStatusUpdate(pluginName, status) {
+        this.server.request({ type: 'plugins_set', src: 'matter', dst: 'plugins', params: { plugin: { name: pluginName, ...status } } });
+        this.server.request({
+            type: 'frontend_broadcast_message',
+            src: 'matter',
+            dst: 'frontend',
+            params: { msg: { id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_status_update', success: true, response: { plugin: pluginName, status } } },
+        });
+    }
+    matterbridgeStatusUpdate(status) {
+        this.server.request({
+            type: 'frontend_broadcast_message',
+            src: 'matter',
+            dst: 'frontend',
+            params: { msg: { id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'matterbridge_status_update', success: true, response: { status } } },
+        });
+    }
     async yieldToNode(timeout = 10) {
         await Promise.resolve();
         await new Promise((resolve) => {

package/dist/matterNodeHelpers.d.ts

@@ -1,7 +1,9 @@
 import { ServerNode, type SessionsBehavior } from '@matter/node';
 import type { ExposedFabricInformation } from '@matter/protocol';
-import type { ApiMatter, SanitizedExposedFabricInformation, SanitizedSession } from '@matterbridge/types';
+import type { ApiDevice, ApiMatter, BaseDevice, SanitizedExposedFabricInformation, SanitizedSession } from '@matterbridge/types';
 import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+export declare function toBaseDevice(device: MatterbridgeEndpoint | BaseDevice): BaseDevice;
+export declare function toApiDevice(device: MatterbridgeEndpoint): ApiDevice | undefined;
 export declare function getReachability(device: MatterbridgeEndpoint): boolean;
 export declare function getPowerSource(endpoint: MatterbridgeEndpoint): 'ac' | 'dc' | 'ok' | 'warning' | 'critical' | undefined;
 export declare function getBatteryLevel(endpoint: MatterbridgeEndpoint): number | undefined;

package/dist/matterNodeHelpers.js

@@ -20,6 +20,54 @@ import { isValidArray, isValidNumber, isValidObject } from '@matterbridge/utils/
 import { stringify } from 'node-ansi-logger';
 import { featuresFor, getAttribute } from './matterbridgeEndpointHelpers.js';
 const advertisingNodes = new Map();
+export function toBaseDevice(device) {
+    return {
+        mode: device.mode,
+        plugin: device.plugin,
+        configUrl: device.configUrl,
+        deviceName: device.deviceName,
+        serialNumber: device.serialNumber,
+        uniqueId: device.uniqueId,
+        vendorId: device.vendorId,
+        vendorName: device.vendorName,
+        productId: device.productId,
+        productName: device.productName,
+        productLabel: device.productLabel,
+        productUrl: device.productUrl,
+        configurationVersion: device.configurationVersion,
+        softwareVersion: device.softwareVersion,
+        softwareVersionString: device.softwareVersionString,
+        hardwareVersion: device.hardwareVersion,
+        hardwareVersionString: device.hardwareVersionString,
+        tagList: device.tagList,
+        originalId: device.originalId,
+        name: device.name,
+        deviceType: device.deviceType,
+        deviceTypes: device.deviceTypes instanceof Map ? Array.from(device.deviceTypes.keys()) : device.deviceTypes,
+        number: device.number,
+        id: device.id,
+    };
+}
+export function toApiDevice(device) {
+    if (!device.plugin || !device.deviceType || !device.name || !device.deviceName || !device.serialNumber || !device.uniqueId || !device.lifecycle.isReady)
+        return undefined;
+    return {
+        plugin: device.plugin,
+        type: device.name + ' (0x' + device.deviceType.toString(16).padStart(4, '0') + ')',
+        number: device.number,
+        id: device.id,
+        deviceName: device.deviceName,
+        serialNumber: device.serialNumber,
+        productUrl: device.productUrl,
+        configUrl: device.configUrl,
+        uniqueId: device.uniqueId,
+        reachable: getReachability(device),
+        powerSource: getPowerSource(device),
+        batteryLevel: getBatteryLevel(device),
+        matter: device.mode === 'server' && device.serverNode ? getServerNodeData(device.serverNode) : undefined,
+        cluster: getClusterTextFromDevice(device),
+    };
+}
 export function getReachability(device) {
     if (!device.lifecycle.isReady || device.construction.status !== Lifecycle.Status.Active)
         return false;

package/dist/matterbridge.js

@@ -16,7 +16,7 @@ import { DeviceTypeId, EndpointNumber, VendorId } from '@matter/types/datatype';
 import { ManualPairingCodeCodec } from '@matter/types/schema';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, typ } from '@matterbridge/types';
-import { isBun, getGlobalBunModules, memoryFootprint } from '@matterbridge/utils/bun';
+import { constrainedMemory, isBun, getGlobalBunModules, memoryFootprint } from '@matterbridge/utils/bun';
 import { getIntParameter, getParameter, hasAnyParameter, hasParameter } from '@matterbridge/utils/cli';
 import { copyDirectory } from '@matterbridge/utils/copy-dir';
 import { createDirectory } from '@matterbridge/utils/create-dir';
@@ -53,6 +53,7 @@ export class Matterbridge extends EventEmitter {
         osArch: '',
         totalMemory: '',
         freeMemory: '',
+        constrainedMemory: '',
         systemUptime: '',
         processUptime: '',
         cpuUsage: '',
@@ -171,6 +172,7 @@ export class Matterbridge extends EventEmitter {
     }
     getPlatformMatterbridge() {
         this.systemInformation.totalMemory = formatBytes(os.totalmem());
+        this.systemInformation.constrainedMemory = formatBytes(constrainedMemory());
         this.systemInformation.freeMemory = formatBytes(os.freemem());
         this.systemInformation.systemUptime = formatUptime(os.uptime());
         this.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
@@ -201,6 +203,7 @@ export class Matterbridge extends EventEmitter {
     }
     getSharedMatterbridge() {
         this.systemInformation.totalMemory = formatBytes(os.totalmem());
+        this.systemInformation.constrainedMemory = formatBytes(constrainedMemory());
         this.systemInformation.freeMemory = formatBytes(os.freemem());
         this.systemInformation.systemUptime = formatUptime(os.uptime());
         this.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
@@ -246,6 +249,7 @@ export class Matterbridge extends EventEmitter {
     }
     getApiSettings() {
         this.systemInformation.totalMemory = formatBytes(os.totalmem());
+        this.systemInformation.constrainedMemory = formatBytes(constrainedMemory());
         this.systemInformation.freeMemory = formatBytes(os.freemem());
         this.systemInformation.systemUptime = formatUptime(os.uptime());
         this.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
@@ -275,9 +279,6 @@ export class Matterbridge extends EventEmitter {
                 bridgeStatus: this.bridgeStatus,
                 profile: this.profile,
                 readOnly: hasParameter('readonly'),
-                shellyBoard: false,
-                shellySysUpdate: false,
-                shellyMainUpdate: false,
                 loggerLevel: this.logLevel,
                 fileLogger: this.fileLogger,
                 matterLoggerLevel: this.matterLogLevel,
@@ -299,7 +300,7 @@ export class Matterbridge extends EventEmitter {
         };
     }
     async msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'matterbridge')) {
+        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) {
@@ -355,21 +356,6 @@ export class Matterbridge extends EventEmitter {
                     this.server.respond({ ...msg, result: { success: true } });
                     await this.shutdownProcess();
                     break;
-                case 'matterbridge_apimatter': {
-                    let serverNode;
-                    if (msg.params.id === 'Matterbridge')
-                        serverNode = this.serverNode;
-                    else
-                        serverNode =
-                            this.plugins.array().find((p) => p.serverNode && p.serverNode.id === msg.params.id)?.serverNode ??
-                                this.devices.array().find((d) => d.serverNode && d.serverNode.id === msg.params.id)?.serverNode;
-                    if (!serverNode) {
-                        this.server.respond({ ...msg, result: { matter: undefined } });
-                        break;
-                    }
-                    this.server.respond({ ...msg, result: { matter: getServerNodeData(serverNode) } });
-                    break;
-                }
                 case 'matterbridge_apisettings':
                     this.server.respond({ ...msg, result: { data: this.getApiSettings(), success: true } });
                     break;
@@ -474,6 +460,7 @@ export class Matterbridge extends EventEmitter {
         this.environment.vars.set('path.root', path.join(this.matterbridgeDirectory, MATTER_STORAGE_DIR));
         this.environment.vars.set('runtime.signals', false);
         this.environment.vars.set('runtime.exitcode', false);
+        this.environment.vars.set('endpoint.validation', 'strict');
         this.registerProcessHandlers();
         try {
             this.log.debug(`Creating node storage manager: ${CYAN}${NODE_STORAGE_DIR}${db}`);
@@ -1204,6 +1191,7 @@ export class Matterbridge extends EventEmitter {
         this.systemInformation.osPlatform = os.platform();
         this.systemInformation.osArch = os.arch();
         this.systemInformation.totalMemory = formatBytes(os.totalmem());
+        this.systemInformation.constrainedMemory = formatBytes(constrainedMemory());
         this.systemInformation.freeMemory = formatBytes(os.freemem());
         this.systemInformation.systemUptime = formatUptime(os.uptime());
         this.systemInformation.processUptime = formatUptime(process.uptime());
@@ -1226,6 +1214,7 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`- Architecture: ${this.systemInformation.osArch}`);
         this.log.debug(`- Total Memory: ${this.systemInformation.totalMemory}`);
         this.log.debug(`- Free Memory: ${this.systemInformation.freeMemory}`);
+        this.log.debug(`- Constrained Memory: ${this.systemInformation.constrainedMemory}`);
         this.log.debug(`- System Uptime: ${this.systemInformation.systemUptime}`);
         this.log.debug(`- Process Uptime: ${this.systemInformation.processUptime}`);
         this.log.debug(`- RSS: ${this.systemInformation.rss}`);
@@ -1400,6 +1389,7 @@ export class Matterbridge extends EventEmitter {
                 this.reachabilityTimeout = undefined;
                 this.log.debug('Matterbridge reachability timeout cleared');
             }
+            this.server.request({ type: 'manager_shutdown', src: 'matterbridge', dst: 'manager', params: {} });
             for (const plugin of this.plugins) {
                 if (!plugin.enabled || plugin.error)
                     continue;
@@ -1530,12 +1520,12 @@ export class Matterbridge extends EventEmitter {
                 this.log.info(`Matterbridge has run ${CYAN}${this.runningTimes}${nf} times for a total of ${CYAN}${this.runningDays}${nf} days`);
                 this.log.info(`Matterbridge last started at ${CYAN}${new Date(this.startupAt).toLocaleString()}${nf} and shut down at ${CYAN}${new Date(this.shutdownAt).toLocaleString()}${nf}`);
             }
-            await this.frontend.stop();
-            this.frontend.destroy();
+            if (!hasParameter('experimental-backend')) {
+                await this.frontend.stop();
+                this.frontend.destroy();
+            }
             this.plugins.destroy();
             this.devices.destroy();
-            this.server.request({ type: 'manager_shutdown', src: 'matterbridge', dst: 'manager', params: {} });
-            await wait(100);
             this.server.close();
             if (this.nodeStorage && this.nodeContext) {
                 this.log.debug(`Closing node storage context for ${plg}Matterbridge${db}...`);

package/dist/matterbridgeDeviceTypes.d.ts

@@ -1,4 +1,4 @@
-import type { ClusterType } from '@matter/types';
+import type { ClusterType } from '@matter/types/cluster';
 import { type ClusterId, DeviceTypeId } from '@matter/types/datatype';
 export declare enum DeviceClasses {
     Node = "Node",