matterbridge 3.4.0-dev-20251123-62db0d7 → 3.4.0-dev-20251126-5087664

package/CHANGELOG.md

@@ -28,7 +28,7 @@ Advantages:
 - individual plugin isolation in childbridge mode;
 - ability to update the plugin in childbridge mode without restarting matterbridge;
 
-## [3.4.0] - Not published
+## [3.4.0] - 2025-11-26
 
 ### Development Breaking Changes
 
@@ -46,8 +46,9 @@ Removed the following long deprecated elements:
 - [doorLock]: Added autoRelockTime attribute with default 0.
 - [DevContainer]: Added instructions for testing a plugin with a paired controller when using DevContainer.
 - [platform]: Made internal use methods and properties hard-private.
-- [platform]: Added size(), getDeviceByName(), getDeviceByUniqueId(), getDeviceBySerialNumber(), getDeviceById(), getDeviceByOriginalId(), getDeviceByNumber() and hasDeviceUniqueId() methods.
+- [platform]: Added size(), getDeviceByName(), getDeviceByUniqueId(), getDeviceBySerialNumber(), getDeviceById(), getDeviceByOriginalId(), getDeviceByNumber() and hasDeviceUniqueId() methods to retrieve a registered device.
 - [platform]: Added isReady, isLoaded, isStarted and isConfigured properties.
+- [matterbridge.io]: Updated website https://matterbridge.io.
 
 ### Changed
 

package/README.md

@@ -108,7 +108,7 @@ Test the installation with:
 matterbridge
 ```
 
-Now it is possible to open the frontend at the link provided in the log (e.g. http://MATTERBIDGE-IPV4-ADDRESS:8283).
+Now it is possible to open the frontend at the link provided in the log (e.g. http://MATTERBRIDGE-IPV4-ADDRESS:8283).
 
 You can then change the bridge mode and other parameters from the frontend.
 

package/dist/broadcastServer.js

@@ -2,7 +2,7 @@ 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 { debugStringify } from 'node-ansi-logger';
+import { CYAN, db, debugStringify } from 'node-ansi-logger';
 import { hasParameter } from './utils/commandLine.js';
 export class BroadcastServer extends EventEmitter {
     name;
@@ -34,8 +34,8 @@ export class BroadcastServer extends EventEmitter {
     }
     broadcastMessageHandler(event) {
         const data = event.data;
-        if (this.verbose)
-            this.log.debug(`Received broadcast message: ${debugStringify(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);
     }
     broadcast(message) {

package/dist/jestutils/jestHelpers.js

@@ -325,6 +325,35 @@ export async function flushAsync(ticks = 3, microTurns = 10, pause = 250) {
     if (pause)
         await new Promise((resolve) => setTimeout(resolve, pause));
 }
+export function logKeepAlives(log) {
+    const handles = process._getActiveHandles?.() ?? [];
+    const requests = process._getActiveRequests?.() ?? [];
+    const fmtHandle = (h, i) => {
+        const ctor = h?.constructor?.name ?? 'Unknown';
+        const hasRef = typeof h?.hasRef === 'function' ? h.hasRef() : undefined;
+        const isPort = h?.constructor?.name?.includes('MessagePort');
+        const fd = h?.fd ?? h?._handle?.fd;
+        return { i, type: ctor, hasRef, isPort, fd };
+    };
+    const fmtReq = (r, i) => {
+        const ctor = r?.constructor?.name ?? 'Unknown';
+        return { i, type: ctor };
+    };
+    const summary = {
+        handles: handles.map(fmtHandle),
+        requests: requests.map(fmtReq),
+    };
+    if (summary.handles.length === 0 && summary.requests.length === 0) {
+        log?.debug('KeepAlive: no active handles or requests.');
+    }
+    else {
+        log?.debug(`KeepAlive:${rs}\n${inspect(summary, { depth: 5, colors: true })}`);
+        if (!log) {
+            process.stdout.write(`KeepAlive:\n${inspect(summary, { depth: 5, colors: true })}\n`);
+        }
+    }
+    return summary.handles.length + summary.requests.length;
+}
 export async function flushAllEndpointNumberPersistence(targetServer, rounds = 2) {
     const nodeStore = targetServer.env.get(ServerNodeStore);
     for (let i = 0; i < rounds; i++) {
@@ -360,6 +389,11 @@ export async function assertAllEndpointNumbersPersisted(targetServer) {
     }
     return all.length;
 }
+export async function closeServerNodeStores(targetServer) {
+    if (!targetServer)
+        targetServer = server;
+    await targetServer?.env.get(ServerNodeStore)?.endpointStores.close();
+}
 export async function startServerNode(name, port, deviceType = bridge.code) {
     const { randomBytes } = await import('node:crypto');
     const random = randomBytes(8).toString('hex');

package/dist/matterNode.js

@@ -0,0 +1,933 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import EventEmitter from 'node:events';
+import { AnsiLogger, BLUE, CYAN, db, debugStringify, er, nf, or, zb } from 'node-ansi-logger';
+import { NodeStorageManager } from 'node-persist-manager';
+import '@matter/nodejs';
+import { Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, StorageService, UINT32_MAX, UINT16_MAX, Environment } from '@matter/general';
+import { FabricAction, MdnsService } from '@matter/protocol';
+import { VendorId, DeviceTypeId } from '@matter/types';
+import { ServerNode, Endpoint } from '@matter/node';
+import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
+import { BasicInformationServer } from '@matter/node/behaviors/basic-information';
+import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
+import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, plg, NODE_STORAGE_DIR, MATTERBRIDGE_LOGGER_FILE } from './matterbridgeTypes.js';
+import { bridge } from './matterbridgeDeviceTypes.js';
+import { getIntParameter, getParameter, hasParameter } from './utils/commandLine.js';
+import { copyDirectory } from './utils/copyDirectory.js';
+import { isValidNumber, isValidString, parseVersionString } from './utils/isvalid.js';
+import { wait, withTimeout } from './utils/wait.js';
+import { inspectError } from './utils/error.js';
+import { BroadcastServer } from './broadcastServer.js';
+import { toBaseDevice } from './deviceManager.js';
+import { PluginManager } from './pluginManager.js';
+import { addVirtualDevice } from './helpers.js';
+export class MatterNode extends EventEmitter {
+    matterbridge;
+    pluginName;
+    device;
+    log = new AnsiLogger({ logName: 'MatterNode', logTimestampFormat: 4, logLevel: "debug" });
+    matterLog = new AnsiLogger({ logName: 'MatterNode', logTimestampFormat: 4, logLevel: "debug" });
+    environment = Environment.default;
+    storeId;
+    matterMdnsService;
+    matterStorageService;
+    matterStorageManager;
+    matterStorageContext;
+    mdnsInterface;
+    ipv4Address;
+    ipv6Address;
+    port;
+    passcode;
+    discriminator;
+    certification;
+    serverNode;
+    aggregatorNode;
+    aggregatorVendorId = VendorId(getIntParameter('vendorId') ?? 0xfff1);
+    aggregatorVendorName = getParameter('vendorName') ?? 'Matterbridge';
+    aggregatorProductId = getIntParameter('productId') ?? 0x8000;
+    aggregatorProductName = getParameter('productName') ?? 'Matterbridge aggregator';
+    aggregatorDeviceType = DeviceTypeId(getIntParameter('deviceType') ?? bridge.code);
+    aggregatorSerialNumber = getParameter('serialNumber');
+    aggregatorUniqueId = getParameter('uniqueId');
+    advertisingNodes = new Map();
+    pluginManager;
+    dependantMatterNodes = new Map();
+    server;
+    debug = hasParameter('debug') || hasParameter('verbose');
+    verbose = hasParameter('verbose');
+    constructor(matterbridge, pluginName, device) {
+        super();
+        this.matterbridge = matterbridge;
+        this.pluginName = pluginName;
+        this.device = device;
+        this.log.logNameColor = '\x1b[38;5;65m';
+        if (this.debug)
+            this.log.debug(`MatterNode ${this.pluginName ? 'for plugin ' + this.pluginName : 'bridge'} loading...`);
+        this.server = new BroadcastServer('matter', this.log);
+        this.server.on('broadcast_message', this.msgHandler.bind(this));
+        if (this.verbose)
+            this.log.debug(`BroadcastServer is ready`);
+        fs.mkdirSync(matterbridge.matterbridgeDirectory, { recursive: true });
+        this.pluginManager = new PluginManager(this.matterbridge);
+        this.pluginManager.logLevel = this.debug ? "debug" : "info";
+        this.pluginManager.server.close();
+        if (this.verbose)
+            this.log.debug(`PluginManager is ready`);
+        this.environment.vars.set('log.level', MatterLogLevel.DEBUG);
+        this.environment.vars.set('log.format', MatterLogFormat.ANSI);
+        this.environment.vars.set('path.root', path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_NAME));
+        this.environment.vars.set('runtime.signals', false);
+        this.environment.vars.set('runtime.exitcode', false);
+        if (this.verbose)
+            this.log.debug(`Matter Environment is ready`);
+        if (this.matterbridge.fileLogger) {
+            AnsiLogger.setGlobalLogfile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_LOGGER_FILE), this.matterbridge.logLevel);
+        }
+        Logger.destinations.default.write = this.createDestinationMatterLogger();
+        const levels = ['debug', 'info', 'notice', 'warn', 'error', 'fatal'];
+        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`);
+    }
+    async msgHandler(msg) {
+        if (this.server.isWorkerRequest(msg, msg.type) && (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 } });
+                    break;
+                case 'set_log_level':
+                    this.log.logLevel = msg.params.logLevel;
+                    this.server.respond({ ...msg, response: { success: true, 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.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}`);
+            }
+        }
+    }
+    async destroy(closeMdns = true) {
+        if (this.verbose)
+            this.log.debug(`Destroying MatterNode instance for ${this.storeId}...`);
+        if (closeMdns) {
+            if (this.verbose)
+                this.log.debug(`Closing Matter MdnsService for ${this.storeId}...`);
+            this.matterMdnsService = this.environment.get(MdnsService);
+            if (typeof this.matterMdnsService[Symbol.asyncDispose] === 'function')
+                await this.matterMdnsService[Symbol.asyncDispose]();
+            else
+                await this.matterMdnsService.close();
+            if (this.verbose)
+                this.log.debug(`Closed Matter MdnsService for ${this.storeId}`);
+        }
+        this.pluginManager.destroy();
+        this.server.close();
+        await this.yieldToNode();
+        if (this.verbose)
+            this.log.debug(`Destroyed MatterNode instance for ${this.storeId}`);
+    }
+    async create() {
+        this.log.info('Creating Matter node...');
+        await this.startMatterStorage();
+        this.pluginManager.matterbridge.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR), writeQueue: false, expiredInterval: undefined, logging: false });
+        this.pluginManager.matterbridge.nodeContext = await this.pluginManager.matterbridge.nodeStorage.createStorage('matterbridge');
+        await this.pluginManager.loadFromStorage();
+        if (this.pluginName && this.device && this.device.deviceName) {
+            this.log.debug(`Creating MatterNode instance for server node device ${CYAN}${this.device.deviceName}${db}...`);
+            await this.createDeviceServerNode(this.pluginName, this.device);
+            this.log.debug(`Created MatterNode instance for server node device ${CYAN}${this.device.deviceName}${db}`);
+            this.emit('ready', this.device.deviceName.replace(/[ .]/g, ''));
+            return;
+        }
+        if (!this.pluginName) {
+            this.log.debug('Creating MatterNode instance for all plugins...');
+            await this.createMatterbridgeServerNode();
+            this.log.debug('Loading all plugins...');
+            const loadPromises = [];
+            for (const plugin of this.pluginManager.array().filter((p) => p.enabled)) {
+                loadPromises.push(this.pluginManager.load(plugin));
+            }
+            await Promise.all(loadPromises);
+            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');
+        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...');
+        if (this.pluginName && this.device && this.device.deviceName) {
+            this.log.debug(`Starting MatterNode for server device ${this.pluginName}:${this.device.deviceName}...`);
+            await this.startServerNode();
+            this.log.debug(`Started MatterNode for server device ${this.pluginName}:${this.device.deviceName}`);
+            return;
+        }
+        if (!this.pluginName) {
+            this.log.debug('Starting all plugins...');
+            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...');
+            await this.startServerNode();
+            this.log.debug('Started MatterNode for all plugins');
+            this.log.debug('Configuring all plugins...');
+            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');
+        }
+        else {
+            await this.pluginManager.start(this.pluginName, 'Starting MatterNode');
+            this.log.debug(`Starting MatterNode for plugin ${this.pluginName}...`);
+            await this.startServerNode();
+            this.log.debug(`Started MatterNode for plugin ${this.pluginName}`);
+            await this.pluginManager.configure(this.pluginName);
+        }
+        this.log.debug(`Starting dependant MatterNodes...`);
+        for (const dependantMatterNode of this.dependantMatterNodes.values()) {
+            await dependantMatterNode.start();
+        }
+        this.log.debug(`Started dependant MatterNodes`);
+        this.log.info('Started MatterNode');
+        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...');
+        if (this.pluginName && this.device && this.device.deviceName) {
+            this.log.debug(`Stopping MatterNode for server device ${this.pluginName}:${this.device.deviceName}...`);
+            await this.stopServerNode();
+            this.serverNode = undefined;
+            this.aggregatorNode = undefined;
+            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');
+            await this.yieldToNode();
+            return;
+        }
+        if (!this.pluginName) {
+            this.log.debug('Stopping all plugins...');
+            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');
+        }
+        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...`);
+        for (const dependantMatterNode of this.dependantMatterNodes.values()) {
+            await dependantMatterNode.stop();
+        }
+        this.log.debug(`Stopped dependant MatterNodes`);
+        await this.stopServerNode();
+        this.serverNode = undefined;
+        this.aggregatorNode = undefined;
+        await this.stopMatterStorage();
+        this.log.info('Stopped MatterNode');
+        await this.yieldToNode();
+    }
+    createDestinationMatterLogger() {
+        this.matterLog.logNameColor = '\x1b[34m';
+        if (this.matterbridge.matterFileLogger) {
+            this.matterLog.logFilePath = path.join(this.matterbridge.matterbridgeDirectory, MATTER_LOGGER_FILE);
+        }
+        return (text, message) => {
+            const logger = text.slice(44, 44 + 20).trim();
+            const msg = text.slice(65);
+            this.matterLog.logName = logger;
+            this.matterLog.log(MatterLogLevel.names[message.level], msg);
+        };
+    }
+    async startMatterStorage() {
+        this.log.info(`Starting matter node storage...`);
+        this.matterStorageService = this.environment.get(StorageService);
+        this.log.info(`Started matter node storage in ${CYAN}${this.matterStorageService.location}${nf}`);
+        await this.backupMatterStorage(path.join(this.matterbridge.matterbridgeDirectory, MATTER_STORAGE_NAME), path.join(this.matterbridge.matterbridgeDirectory, MATTER_STORAGE_NAME + '.backup'));
+    }
+    async backupMatterStorage(storageName, backupName) {
+        this.log.info(`Creating matter node storage backup from ${CYAN}${storageName}${nf} to ${CYAN}${backupName}${nf}...`);
+        try {
+            await copyDirectory(storageName, backupName);
+            this.log.info('Created matter node storage backup');
+        }
+        catch (error) {
+            if (error instanceof Error && error?.code === 'ENOENT') {
+                this.log.info(`No matter node storage found to backup from ${CYAN}${storageName}${nf} to ${CYAN}${backupName}${nf}`);
+            }
+            else {
+                this.log.error(`Error creating matter node storage backup from ${storageName} to ${backupName}:`, error);
+            }
+        }
+    }
+    async stopMatterStorage() {
+        this.log.info('Closing matter node storage...');
+        await this.matterStorageManager?.close();
+        this.matterStorageService = undefined;
+        this.matterStorageManager = undefined;
+        this.matterStorageContext = undefined;
+        this.log.info('Closed matter node storage');
+        this.emit('closed');
+    }
+    async createServerNodeContext(storeId, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber, uniqueId) {
+        if (!this.matterStorageService) {
+            throw new Error('No storage service initialized');
+        }
+        const { randomBytes } = await import('node:crypto');
+        this.log.info(`Creating server node storage context "${storeId}.persist" for ${storeId}...`);
+        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('nodeLabel', productName.slice(0, 32));
+        await storageContext.set('productLabel', productName.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', isValidNumber(parseVersionString(this.matterbridge.matterbridgeVersion), 0, UINT32_MAX) ? parseVersionString(this.matterbridge.matterbridgeVersion) : 1);
+        await storageContext.set('softwareVersionString', isValidString(this.matterbridge.matterbridgeVersion, 5, 64) ? this.matterbridge.matterbridgeVersion : '1.0.0');
+        await storageContext.set('hardwareVersion', isValidNumber(parseVersionString(this.matterbridge.systemInformation.osRelease), 0, UINT16_MAX) ? parseVersionString(this.matterbridge.systemInformation.osRelease) : 1);
+        await storageContext.set('hardwareVersionString', isValidString(this.matterbridge.systemInformation.osRelease, 5, 64) ? this.matterbridge.systemInformation.osRelease : '1.0.0');
+        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')}`);
+        this.log.debug(`- deviceType: ${await storageContext.get('deviceType')}(0x${(await storageContext.get('deviceType'))?.toString(16).padStart(4, '0')})`);
+        this.log.debug(`- vendorId: ${await storageContext.get('vendorId')}`);
+        this.log.debug(`- vendorName: ${await storageContext.get('vendorName')}`);
+        this.log.debug(`- productId: ${await storageContext.get('productId')}`);
+        this.log.debug(`- productName: ${await storageContext.get('productName')}`);
+        this.log.debug(`- nodeLabel: ${await storageContext.get('nodeLabel')}`);
+        this.log.debug(`- productLabel: ${await storageContext.get('productLabel')}`);
+        this.log.debug(`- serialNumber: ${await storageContext.get('serialNumber')}`);
+        this.log.debug(`- uniqueId: ${await storageContext.get('uniqueId')}`);
+        this.log.debug(`- softwareVersion: ${await storageContext.get('softwareVersion')}`);
+        this.log.debug(`- softwareVersionString: ${await storageContext.get('softwareVersionString')}`);
+        this.log.debug(`- hardwareVersion: ${await storageContext.get('hardwareVersion')}`);
+        this.log.debug(`- hardwareVersionString: ${await storageContext.get('hardwareVersionString')}`);
+        return storageContext;
+    }
+    async createServerNode(port = 5540, passcode = 20252026, discriminator = 3850) {
+        if (!this.matterStorageContext) {
+            throw new Error('Matter server node context not created yet. Call createServerNodeContext() first.');
+        }
+        const storeId = await this.matterStorageContext.get('storeId');
+        this.log.notice(`Creating server node for ${storeId} on port ${port} with passcode ${passcode} and discriminator ${discriminator}...`);
+        const serverNode = await ServerNode.create({
+            id: storeId,
+            environment: this.environment,
+            network: {
+                listeningAddressIpv4: this.ipv4Address,
+                listeningAddressIpv6: this.ipv6Address,
+                port,
+            },
+            operationalCredentials: {
+                certification: this.certification,
+            },
+            commissioning: {
+                passcode,
+                discriminator,
+            },
+            productDescription: {
+                name: await this.matterStorageContext.get('deviceName'),
+                deviceType: DeviceTypeId(await this.matterStorageContext.get('deviceType')),
+                vendorId: VendorId(await this.matterStorageContext.get('vendorId')),
+                productId: await this.matterStorageContext.get('productId'),
+            },
+            basicInformation: {
+                vendorId: VendorId(await this.matterStorageContext.get('vendorId')),
+                vendorName: await this.matterStorageContext.get('vendorName'),
+                productId: await this.matterStorageContext.get('productId'),
+                productName: await this.matterStorageContext.get('productName'),
+                productLabel: await this.matterStorageContext.get('productLabel'),
+                nodeLabel: await this.matterStorageContext.get('nodeLabel'),
+                serialNumber: await this.matterStorageContext.get('serialNumber'),
+                uniqueId: await this.matterStorageContext.get('uniqueId'),
+                softwareVersion: await this.matterStorageContext.get('softwareVersion'),
+                softwareVersionString: await this.matterStorageContext.get('softwareVersionString'),
+                hardwareVersion: await this.matterStorageContext.get('hardwareVersion'),
+                hardwareVersionString: await this.matterStorageContext.get('hardwareVersionString'),
+                reachable: true,
+            },
+        });
+        serverNode.lifecycle.commissioned.on(() => {
+            this.log.notice(`Server node for ${storeId} was initially commissioned successfully!`);
+            this.advertisingNodes.delete(storeId);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+        });
+        serverNode.lifecycle.decommissioned.on(() => {
+            this.log.notice(`Server node for ${storeId} was fully decommissioned successfully!`);
+            this.advertisingNodes.delete(storeId);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            this.server.request({ type: 'frontend_snackbarmessage', src: 'matter', dst: 'frontend', params: { message: `${storeId} is offline`, timeout: 5, severity: 'warning' } });
+        });
+        serverNode.lifecycle.online.on(async () => {
+            this.log.notice(`Server node for ${storeId} is online`);
+            if (!serverNode.lifecycle.isCommissioned) {
+                this.log.notice(`Server node for ${storeId} is not commissioned. Pair to commission ...`);
+                this.advertisingNodes.set(storeId, Date.now());
+                const { qrPairingCode, manualPairingCode } = serverNode.state.commissioning.pairingCodes;
+                this.log.notice(`QR Code URL: https://project-chip.github.io/connectedhomeip/qrcode.html?data=${qrPairingCode}`);
+                this.log.notice(`Manual pairing code: ${manualPairingCode}`);
+            }
+            else {
+                this.log.notice(`Server node for ${storeId} is already commissioned. Waiting for controllers to connect ...`);
+                this.advertisingNodes.delete(storeId);
+            }
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            this.server.request({ type: 'frontend_snackbarmessage', src: 'matter', dst: 'frontend', params: { message: `${storeId} is online`, timeout: 5, severity: 'success' } });
+            this.emit('online', storeId);
+        });
+        serverNode.lifecycle.offline.on(() => {
+            this.log.notice(`Server node for ${storeId} is offline`);
+            this.advertisingNodes.delete(storeId);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            this.server.request({ type: 'frontend_snackbarmessage', src: 'matter', dst: 'frontend', params: { message: `${storeId} is offline`, timeout: 5, severity: 'warning' } });
+            this.emit('offline', storeId);
+        });
+        serverNode.events.commissioning.fabricsChanged.on((fabricIndex, fabricAction) => {
+            let action = '';
+            switch (fabricAction) {
+                case FabricAction.Added:
+                    this.advertisingNodes.delete(storeId);
+                    action = 'added';
+                    break;
+                case FabricAction.Removed:
+                    action = 'removed';
+                    break;
+                case FabricAction.Updated:
+                    action = 'updated';
+                    break;
+            }
+            this.log.notice(`Commissioned fabric index ${fabricIndex} ${action} on server node for ${storeId}: ${debugStringify(serverNode.state.commissioning.fabrics[fabricIndex])}`);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+        });
+        serverNode.events.sessions.opened.on((session) => {
+            this.log.notice(`Session opened on server node for ${storeId}: ${debugStringify(session)}`);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+        });
+        serverNode.events.sessions.closed.on((session) => {
+            this.log.notice(`Session closed on server node for ${storeId}: ${debugStringify(session)}`);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+        });
+        serverNode.events.sessions.subscriptionsChanged.on((session) => {
+            this.log.notice(`Session subscriptions changed on server node for ${storeId}: ${debugStringify(session)}`);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+        });
+        this.storeId = storeId;
+        this.log.info(`Created server node for ${this.storeId}`);
+        return serverNode;
+    }
+    getServerNodeData(serverNode) {
+        const advertiseTime = this.advertisingNodes.get(serverNode.id) || 0;
+        return {
+            id: serverNode.id,
+            online: serverNode.lifecycle.isOnline,
+            commissioned: serverNode.state.commissioning.commissioned,
+            advertising: advertiseTime > Date.now() - 15 * 60 * 1000,
+            advertiseTime,
+            windowStatus: serverNode.state.administratorCommissioning.windowStatus,
+            qrPairingCode: serverNode.state.commissioning.pairingCodes.qrPairingCode,
+            manualPairingCode: serverNode.state.commissioning.pairingCodes.manualPairingCode,
+            fabricInformations: this.sanitizeFabricInformations(Object.values(serverNode.state.commissioning.fabrics)),
+            sessionInformations: this.sanitizeSessionInformation(Object.values(serverNode.state.sessions.sessions)),
+            serialNumber: serverNode.state.basicInformation.serialNumber,
+        };
+    }
+    async startServerNode(timeout = 30000) {
+        if (!this.serverNode) {
+            throw new Error('Matter server node not created yet. Call create() first.');
+        }
+        this.log.notice(`Starting ${this.serverNode.id} server node...`);
+        try {
+            await withTimeout(this.serverNode.start(), timeout);
+            this.log.notice(`Started ${this.serverNode.id} server node`);
+        }
+        catch (error) {
+            this.log.error(`Failed to start ${this.serverNode.id} server node: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    async stopServerNode(timeout = 30000) {
+        if (!this.serverNode) {
+            throw new Error('Matter server node not created yet. Call create() first.');
+        }
+        this.log.notice(`Closing ${this.serverNode.id} server node`);
+        try {
+            await withTimeout(this.serverNode.close(), timeout);
+            this.log.info(`Closed ${this.serverNode.id} server node`);
+        }
+        catch (error) {
+            this.log.error(`Failed to close ${this.serverNode.id} server node: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    async createAggregatorNode() {
+        if (!this.matterStorageContext) {
+            throw new Error('Matter server node context not created yet. Call createServerNodeContext() first.');
+        }
+        this.log.notice(`Creating ${await this.matterStorageContext.get('storeId')} aggregator...`);
+        const aggregatorNode = new Endpoint(AggregatorEndpoint, { id: `${await this.matterStorageContext.get('storeId')}` });
+        this.log.info(`Created ${await this.matterStorageContext.get('storeId')} aggregator`);
+        return aggregatorNode;
+    }
+    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);
+        this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+        this.aggregatorNode = await this.createAggregatorNode();
+        this.log.debug(`Adding ${plg}Matterbridge${db} aggregator node...`);
+        await this.serverNode.add(this.aggregatorNode);
+        this.log.debug(`Added ${plg}Matterbridge${db} aggregator node`);
+        await this.serverNode.construction.ready;
+        await this.aggregatorNode.construction.ready;
+        this.log.debug(`Created ${plg}Matterbridge${db} server node`);
+        return this.serverNode;
+    }
+    async createAccessoryPlugin(plugin, device) {
+        if (typeof plugin === 'string') {
+            const _plugin = this.pluginManager.get(plugin);
+            if (!_plugin)
+                throw new Error(`Plugin ${BLUE}${this.pluginName}${er} not found`);
+            plugin = _plugin;
+        }
+        if (!plugin.locked && device.deviceType && device.deviceName && device.vendorId && device.vendorName && device.productId && device.productName) {
+            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);
+            this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+            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`);
+            await this.serverNode.construction.ready;
+            await device.construction.ready;
+            this.log.debug(`Created accessory plugin ${plg}${plugin.name}${db} server node`);
+        }
+        return this.serverNode;
+    }
+    async createDynamicPlugin(plugin) {
+        if (typeof plugin === 'string') {
+            const _plugin = this.pluginManager.get(plugin);
+            if (!_plugin)
+                throw new Error(`Plugin ${BLUE}${this.pluginName}${er} not found`);
+            plugin = _plugin;
+        }
+        if (!plugin.locked) {
+            plugin.locked = true;
+            this.log.debug(`Creating dynamic plugin ${plg}${plugin.name}${db} server node...`);
+            this.matterStorageContext = await this.createServerNodeContext(plugin.name, 'Matterbridge', this.aggregatorDeviceType, this.aggregatorVendorId, this.aggregatorVendorName, this.aggregatorProductId, plugin.description);
+            this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+            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...`);
+            await this.serverNode.add(this.aggregatorNode);
+            this.log.debug(`Added dynamic plugin ${plg}${plugin.name}${db} aggregator node`);
+            await this.serverNode.construction.ready;
+            await this.aggregatorNode.construction.ready;
+            this.log.debug(`Created dynamic plugin ${plg}${plugin.name}${db} server node`);
+        }
+        return this.serverNode;
+    }
+    async createDeviceServerNode(plugin, device) {
+        if (typeof plugin === 'string') {
+            const _plugin = this.pluginManager.get(plugin);
+            if (!_plugin)
+                throw new Error(`Plugin ${BLUE}${this.pluginName}${er} not found`);
+            plugin = _plugin;
+        }
+        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);
+            this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+            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`);
+            await this.serverNode.construction.ready;
+            await device.construction.ready;
+            this.log.debug(`Created device ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db} server node`);
+        }
+        return this.serverNode;
+    }
+    async addBridgedEndpoint(pluginName, device) {
+        const plugin = this.pluginManager.get(pluginName);
+        if (!plugin)
+            throw new Error(`Error adding bridged endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er}): plugin not found`);
+        if (device.mode === 'server') {
+            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);
+                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})`);
+            }
+            catch (error) {
+                inspectError(this.log, `Error creating MatterNode for device ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er})`, error);
+                return;
+            }
+        }
+        else if (this.matterbridge.bridgeMode === 'bridge') {
+            if (device.mode === 'matter') {
+                this.log.debug(`Adding matter endpoint ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})...`);
+                if (!this.serverNode)
+                    throw new Error(`Server node not found for matter endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er})`);
+                try {
+                    await this.serverNode.add(device);
+                }
+                catch (error) {
+                    inspectError(this.log, `Matter error adding matter endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er})`, error);
+                    return;
+                }
+            }
+            else {
+                this.log.debug(`Adding bridged endpoint ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})...`);
+                if (!this.aggregatorNode)
+                    throw new Error(`Aggregator node not found for endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er})`);
+                try {
+                    await this.aggregatorNode.add(device);
+                }
+                catch (error) {
+                    inspectError(this.log, `Matter error adding bridged endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er})`, error);
+                    return;
+                }
+            }
+        }
+        else if (this.matterbridge.bridgeMode === 'childbridge') {
+            if (plugin.type === 'AccessoryPlatform') {
+                try {
+                    this.log.debug(`Adding accessory endpoint ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})...`);
+                    if (this.serverNode) {
+                        await this.serverNode.add(device);
+                    }
+                    else {
+                        await this.createAccessoryPlugin(plugin, device);
+                    }
+                }
+                catch (error) {
+                    inspectError(this.log, `Matter error adding accessory endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er})`, error);
+                    return;
+                }
+            }
+            if (plugin.type === 'DynamicPlatform') {
+                try {
+                    this.log.debug(`Adding bridged endpoint ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})...`);
+                    if (!this.serverNode) {
+                        await this.createDynamicPlugin(plugin);
+                    }
+                    if (device.mode === 'matter')
+                        await this.serverNode?.add(device);
+                    else
+                        await this.aggregatorNode?.add(device);
+                }
+                catch (error) {
+                    inspectError(this.log, `Matter error adding bridged endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er})`, error);
+                    return;
+                }
+            }
+        }
+        if (plugin.registeredDevices !== undefined)
+            plugin.registeredDevices++;
+        await this.server.fetch({ type: 'devices_set', src: this.server.name, dst: 'devices', params: { device: toBaseDevice(device) } });
+        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})`);
+        return device;
+    }
+    async removeBridgedEndpoint(pluginName, device) {
+        this.log.debug(`Removing bridged endpoint ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})...`);
+        const plugin = this.pluginManager.get(pluginName);
+        if (!plugin)
+            throw new Error(`Error removing bridged endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er}): plugin not found`);
+        if (this.matterbridge.bridgeMode === 'bridge') {
+            if (!this.aggregatorNode)
+                throw new Error(`Error removing bridged endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er}): aggregator node not found`);
+            await device.delete();
+        }
+        else if (this.matterbridge.bridgeMode === 'childbridge') {
+            if (plugin.type === 'AccessoryPlatform') {
+                if (!this.serverNode)
+                    throw new Error(`Error removing endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er}): server node not found`);
+                await device.delete();
+            }
+            else if (plugin.type === 'DynamicPlatform') {
+                if (!this.aggregatorNode)
+                    throw new Error(`Error removing bridged endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er}): aggregator node not found`);
+                await device.delete();
+            }
+        }
+        this.log.info(`Removed bridged endpoint #${plugin.registeredDevices} ${plg}${pluginName}${nf}:${dev}${device.deviceName}${nf} (${zb}${device.name}${nf})`);
+        if (plugin.registeredDevices !== undefined)
+            plugin.registeredDevices--;
+        await this.server.fetch({ type: 'devices_remove', src: this.server.name, dst: 'devices', params: { device: toBaseDevice(device) } });
+        return device;
+    }
+    async removeAllBridgedEndpoints(pluginName, delay = 0) {
+        const plugin = this.pluginManager.get(pluginName);
+        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;
+        for (const device of devices) {
+            const endpoint = (this.aggregatorNode?.parts.get(device.id || '') || this.serverNode?.parts.get(device.id || ''));
+            if (!endpoint)
+                throw new Error(`Endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} id ${device.id} not found removing all endpoints`);
+            this.log.debug(`Removing bridged endpoint ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${endpoint?.name}${db})...`);
+            await endpoint.delete();
+            this.log.info(`Removed bridged endpoint #${plugin.registeredDevices} ${plg}${pluginName}${nf}:${dev}${device.deviceName}${nf} (${zb}${endpoint?.name}${nf})`);
+            if (plugin.registeredDevices !== undefined)
+                plugin.registeredDevices--;
+            await this.server.fetch({ type: 'devices_remove', src: this.server.name, dst: 'devices', params: { device: toBaseDevice(device) } });
+            if (delay > 0)
+                await wait(delay);
+        }
+        if (delay > 0)
+            await wait(Number(process.env['MATTERBRIDGE_REMOVE_ALL_ENDPOINT_TIMEOUT_MS']) || 2000);
+    }
+    async addVirtualEndpoint(pluginName, name, type, callback) {
+        this.log.debug(`Creating virtual device ${plg}${pluginName}${db}:${dev}${name}${db}...`);
+        const plugin = this.pluginManager.get(pluginName);
+        if (!plugin) {
+            this.log.error(`Error adding virtual endpoint ${plg}${pluginName}${er}:${dev}${name}${er}: plugin not found`);
+            return false;
+        }
+        if (this.matterbridge.bridgeMode === 'childbridge' && plugin.type !== 'DynamicPlatform') {
+            this.log.error(`Virtual devices are only supported in bridge mode and childbridge mode with a DynamicPlatform`);
+            return false;
+        }
+        if (!this.aggregatorNode) {
+            this.log.error(`Aggregator node not found for plugin ${plg}${plugin.name}${er} adding virtual endpoint ${dev}${name}${er}`);
+            return false;
+        }
+        if (this.aggregatorNode.parts.has(name.replaceAll(' ', '') + ':' + type)) {
+            this.log.error(`Virtual device ${plg}${pluginName}${er}:${dev}${name}${er} already registered. Please use a different name.`);
+            return false;
+        }
+        await addVirtualDevice(this.aggregatorNode, name.slice(0, 32), type, callback);
+        this.log.debug(`Created virtual device ${plg}${pluginName}${db}:${dev}${name}${db}`);
+        return true;
+    }
+    async subscribeAttributeChanged(plugin, device) {
+        if (!plugin || !device || !device.plugin || !device.serialNumber || !device.uniqueId || !device.maybeNumber)
+            return;
+        this.log.debug(`Subscribing attributes for endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${device.id}${db}:${or}${device.number}${db} (${zb}${device.name}${db})`);
+        if (this.matterbridge.bridgeMode === 'childbridge' && plugin.type === 'AccessoryPlatform' && this.serverNode) {
+            this.serverNode.eventsOf(BasicInformationServer).reachable$Changed?.on((reachable) => {
+                this.log.debug(`Accessory endpoint ${plg}${plugin.name}${nf}:${dev}${device.deviceName}${nf}:${or}${device.id}${nf}:${or}${device.number}${nf} is ${reachable ? 'reachable' : 'unreachable'}`);
+                this.server.request({
+                    type: 'frontend_attributechanged',
+                    src: 'matter',
+                    dst: 'frontend',
+                    params: { plugin: device.plugin, serialNumber: device.serialNumber, uniqueId: device.uniqueId, number: device.number, id: device.id, cluster: 'BasicInformation', attribute: 'reachable', value: reachable },
+                });
+            });
+        }
+        const subscriptions = [
+            { cluster: 'BridgedDeviceBasicInformation', attribute: 'reachable' },
+            { cluster: 'OnOff', attribute: 'onOff' },
+            { cluster: 'LevelControl', attribute: 'currentLevel' },
+            { cluster: 'ColorControl', attribute: 'colorMode' },
+            { cluster: 'ColorControl', attribute: 'currentHue' },
+            { cluster: 'ColorControl', attribute: 'currentSaturation' },
+            { cluster: 'ColorControl', attribute: 'currentX' },
+            { cluster: 'ColorControl', attribute: 'currentY' },
+            { cluster: 'ColorControl', attribute: 'colorTemperatureMireds' },
+            { cluster: 'Thermostat', attribute: 'localTemperature' },
+            { cluster: 'Thermostat', attribute: 'occupiedCoolingSetpoint' },
+            { cluster: 'Thermostat', attribute: 'occupiedHeatingSetpoint' },
+            { cluster: 'Thermostat', attribute: 'systemMode' },
+            { cluster: 'WindowCovering', attribute: 'operationalStatus' },
+            { cluster: 'WindowCovering', attribute: 'currentPositionLiftPercent100ths' },
+            { cluster: 'DoorLock', attribute: 'lockState' },
+            { cluster: 'PumpConfigurationAndControl', attribute: 'pumpStatus' },
+            { cluster: 'FanControl', attribute: 'fanMode' },
+            { cluster: 'FanControl', attribute: 'fanModeSequence' },
+            { cluster: 'FanControl', attribute: 'percentSetting' },
+            { cluster: 'ModeSelect', attribute: 'currentMode' },
+            { cluster: 'RvcRunMode', attribute: 'currentMode' },
+            { cluster: 'RvcCleanMode', attribute: 'currentMode' },
+            { cluster: 'RvcOperationalState', attribute: 'operationalState' },
+            { cluster: 'RvcOperationalState', attribute: 'operationalError' },
+            { cluster: 'ServiceArea', attribute: 'currentArea' },
+            { cluster: 'AirQuality', attribute: 'airQuality' },
+            { cluster: 'TotalVolatileOrganicCompoundsConcentrationMeasurement', attribute: 'measuredValue' },
+            { cluster: 'BooleanState', attribute: 'stateValue' },
+            { cluster: 'OccupancySensing', attribute: 'occupancy' },
+            { cluster: 'IlluminanceMeasurement', attribute: 'measuredValue' },
+            { cluster: 'TemperatureMeasurement', attribute: 'measuredValue' },
+            { cluster: 'RelativeHumidityMeasurement', attribute: 'measuredValue' },
+            { cluster: 'PressureMeasurement', attribute: 'measuredValue' },
+            { cluster: 'FlowMeasurement', attribute: 'measuredValue' },
+            { cluster: 'SmokeCoAlarm', attribute: 'smokeState' },
+            { cluster: 'SmokeCoAlarm', attribute: 'coState' },
+        ];
+        for (const sub of subscriptions) {
+            if (device.hasAttributeServer(sub.cluster, sub.attribute)) {
+                this.log.debug(`Subscribing to endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
+                await device.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
+                    this.log.debug(`Bridged endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${value}${db}`);
+                    this.server.request({
+                        type: 'frontend_attributechanged',
+                        src: 'matter',
+                        dst: 'frontend',
+                        params: { plugin: device.plugin, serialNumber: device.serialNumber, uniqueId: device.uniqueId, number: device.number, id: device.id, cluster: sub.cluster, attribute: sub.attribute, value: value },
+                    });
+                });
+            }
+            for (const child of device.getChildEndpoints()) {
+                if (child.hasAttributeServer(sub.cluster, sub.attribute)) {
+                    this.log.debug(`Subscribing to child endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
+                    await child.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
+                        this.log.debug(`Bridged child endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${value}${db}`);
+                        this.server.request({
+                            type: 'frontend_attributechanged',
+                            src: 'matter',
+                            dst: 'frontend',
+                            params: { plugin: device.plugin, serialNumber: device.serialNumber, uniqueId: device.uniqueId, number: child.number, id: child.id, cluster: sub.cluster, attribute: sub.attribute, value: value },
+                        });
+                    });
+                }
+            }
+        }
+    }
+    sanitizeFabricInformations(fabricInfo) {
+        return fabricInfo.map((info) => {
+            return {
+                fabricIndex: info.fabricIndex,
+                fabricId: info.fabricId.toString(),
+                nodeId: info.nodeId.toString(),
+                rootNodeId: info.rootNodeId.toString(),
+                rootVendorId: info.rootVendorId,
+                rootVendorName: this.getVendorIdName(info.rootVendorId),
+                label: info.label,
+            };
+        });
+    }
+    sanitizeSessionInformation(sessions) {
+        return sessions
+            .filter((session) => session.isPeerActive)
+            .map((session) => {
+            return {
+                name: session.name,
+                nodeId: session.nodeId.toString(),
+                peerNodeId: session.peerNodeId.toString(),
+                fabric: session.fabric
+                    ? {
+                        fabricIndex: session.fabric.fabricIndex,
+                        fabricId: session.fabric.fabricId.toString(),
+                        nodeId: session.fabric.nodeId.toString(),
+                        rootNodeId: session.fabric.rootNodeId.toString(),
+                        rootVendorId: session.fabric.rootVendorId,
+                        rootVendorName: this.getVendorIdName(session.fabric.rootVendorId),
+                        label: session.fabric.label,
+                    }
+                    : undefined,
+                isPeerActive: session.isPeerActive,
+                lastInteractionTimestamp: session.lastInteractionTimestamp?.toString(),
+                lastActiveTimestamp: session.lastActiveTimestamp?.toString(),
+                numberOfActiveSubscriptions: session.numberOfActiveSubscriptions,
+            };
+        });
+    }
+    async setServerReachability(reachable) {
+        await this.serverNode?.setStateOf(BasicInformationServer, { reachable });
+        this.serverNode?.act((agent) => this.serverNode?.eventsOf(BasicInformationServer).reachableChanged?.emit({ reachableNewValue: reachable }, agent.context));
+    }
+    async setAggregatorReachability(aggregatorNode, reachable) {
+        for (const child of aggregatorNode.parts) {
+            this.log.debug(`Setting reachability of ${child?.deviceName} to ${reachable}`);
+            await child.setStateOf(BridgedDeviceBasicInformationServer, { reachable });
+            child.act((agent) => child.eventsOf(BridgedDeviceBasicInformationServer).reachableChanged.emit({ reachableNewValue: true }, agent.context));
+        }
+    }
+    getVendorIdName = (vendorId) => {
+        if (!vendorId)
+            return '';
+        let vendorName = '(Unknown vendorId)';
+        switch (vendorId) {
+            case 4937:
+                vendorName = '(AppleHome)';
+                break;
+            case 4996:
+                vendorName = '(AppleKeyChain)';
+                break;
+            case 4362:
+                vendorName = '(SmartThings)';
+                break;
+            case 4939:
+                vendorName = '(HomeAssistant)';
+                break;
+            case 24582:
+                vendorName = '(GoogleHome)';
+                break;
+            case 4631:
+                vendorName = '(Alexa)';
+                break;
+            case 4701:
+                vendorName = '(Tuya)';
+                break;
+            case 4718:
+                vendorName = '(Xiaomi)';
+                break;
+            case 4742:
+                vendorName = '(eWeLink)';
+                break;
+            case 5264:
+                vendorName = '(Shelly)';
+                break;
+            case 0x1488:
+                vendorName = '(ShortcutLabsFlic)';
+                break;
+            case 65521:
+                vendorName = '(MatterTest)';
+                break;
+        }
+        return vendorName;
+    };
+    async yieldToNode(timeout = 100) {
+        await Promise.resolve();
+        await new Promise((resolve) => {
+            setImmediate(resolve);
+        });
+        await new Promise((resolve) => {
+            setTimeout(resolve, Math.min(timeout, 10));
+        });
+    }
+}

package/dist/utils/tracker.js

@@ -40,7 +40,7 @@ export class Tracker extends EventEmitter {
         this.name = name;
         this.debug = debug;
         this.verbose = verbose;
-        if (process.argv.includes('--debug') || process.argv.includes('-debug')) {
+        if (process.argv.includes('--debug') || process.argv.includes('-debug') || process.argv.includes('--verbose') || process.argv.includes('-verbose')) {
             this.debug = true;
         }
         if (process.argv.includes('--verbose') || process.argv.includes('-verbose')) {

package/marked.ps1

@@ -0,0 +1,10 @@
+(Get-Content .\docs\markedHeader.html) + (marked .\README-DEV.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README-DEV.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\README-DOCKER.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README-DOCKER.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\README-MACOS-PLIST.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README-MACOS-PLIST.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\README-NGINX.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README-NGINX.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\README-PODMAN.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README-PODMAN.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\README-SERVICE-LOCAL.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README-SERVICE-LOCAL.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\README-SERVICE-OPT.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README-SERVICE-OPT.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\README-SERVICE.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README-SERVICE.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\README.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\README.html -Encoding utf8
+(Get-Content .\docs\markedHeader.html) + (marked .\CHANGELOG.md) + (Get-Content .\docs\markedFooter.html) | Out-File .\docs\CHANGELOG.html -Encoding utf8

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.4.0-dev-20251123-62db0d7",
+  "version": "3.4.0-dev-20251126-5087664",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.4.0-dev-20251123-62db0d7",
+      "version": "3.4.0-dev-20251126-5087664",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.4.0-dev-20251123-62db0d7",
+  "version": "3.4.0-dev-20251126-5087664",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",