matterbridge 1.0.6 → 1.1.2

package/dist/matterbridge.js

@@ -1,21 +1,47 @@
+/**
+ * This file contains the class Matterbridge.
+ *
+ * @file matterbridge.ts
+ * @author Luca Liguori
+ * @date 2023-12-29
+ * @version 1.1.1
+ *
+ * Copyright 2023, 2024 Luca Liguori.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License. *
+ */
 import { NodeStorageManager } from 'node-persist-manager';
-import { AnsiLogger, BLUE, BRIGHT, GREEN, RESET, REVERSE, REVERSEOFF, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, nf, rs, } from 'node-ansi-logger';
+import { AnsiLogger, BRIGHT, GREEN, RESET, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, stringify, er, nf, rs, wr } from 'node-ansi-logger';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { promises as fs } from 'fs';
-import EventEmitter from 'events';
 import express from 'express';
 import os from 'os';
 import path from 'path';
 import { CommissioningServer, MatterServer } from '@project-chip/matter-node.js';
-import { VendorId } from '@project-chip/matter-node.js/datatype';
+import { BasicInformationCluster, BridgedDeviceBasicInformationCluster, ClusterServer } from '@project-chip/matter-node.js/cluster';
+import { DeviceTypeId, VendorId } from '@project-chip/matter-node.js/datatype';
 import { Aggregator, DeviceTypes } from '@project-chip/matter-node.js/device';
 import { Format, Level, Logger } from '@project-chip/matter-node.js/log';
 import { QrCodeSchema } from '@project-chip/matter-node.js/schema';
 import { StorageBackendDisk, StorageBackendJsonFile, StorageManager } from '@project-chip/matter-node.js/storage';
-import { requireMinNodeVersion, getParameter, hasParameter } from '@project-chip/matter-node.js/util';
+import { requireMinNodeVersion, getParameter, getIntParameter, hasParameter } from '@project-chip/matter-node.js/util';
 import { CryptoNode } from '@project-chip/matter-node.js/crypto';
-import { BasicInformationCluster, BridgedDeviceBasicInformationCluster } from '@project-chip/matter-node.js/cluster';
-export class Matterbridge extends EventEmitter {
+const plg = '\u001B[38;5;33m';
+const dev = '\u001B[38;5;79m';
+/**
+ * Represents the Matterbridge application.
+ */
+export class Matterbridge {
     systemInformation = {
         ipv4Address: '',
         ipv6Address: '',
@@ -29,14 +55,16 @@ export class Matterbridge extends EventEmitter {
         freeMemory: '',
         systemUptime: '',
     };
+    homeDirectory;
     rootDirectory;
+    matterbridgeDirectory;
     bridgeMode = '';
     log;
     hasCleanupStarted = false;
     registeredPlugins = [];
     registeredDevices = [];
-    storage = undefined;
-    context = undefined;
+    nodeStorage = undefined;
+    nodeContext = undefined;
     app;
     storageManager;
     matterbridgeContext;
@@ -45,13 +73,58 @@ export class Matterbridge extends EventEmitter {
     matterAggregator;
     commissioningServer;
     commissioningController;
+    static instance;
     constructor() {
-        super();
+        // we load asynchroneously the instance
+    }
+    /**
+     * Loads an instance of the Matterbridge class.
+     * If an instance already exists, an error will be thrown.
+     * @returns The loaded instance of the Matterbridge class.
+     * @throws Error if an instance of Matterbridge already exists.
+     */
+    static async loadInstance() {
+        if (!Matterbridge.instance) {
+            Matterbridge.instance = new Matterbridge();
+            await Matterbridge.instance.initialize();
+        }
+        else {
+            throw new Error('Matterbridge instance already exists');
+        }
+        return Matterbridge.instance;
+    }
+    /**
+     * Initializes the Matterbridge application.
+     *
+     * @remarks
+     * This method performs the necessary setup and initialization steps for the Matterbridge application.
+     * It displays the help information if the 'help' parameter is provided, sets up the logger, checks the
+     * node version, registers signal handlers, initializes storage, and parses the command line.
+     *
+     * @returns A Promise that resolves when the initialization is complete.
+     */
+    async initialize() {
+        // Display the help
+        if (hasParameter('help')) {
+            // eslint-disable-next-line no-console
+            console.log(`\nUsage: matterbridge [options]\n
+      Options:
+      - help:                  show the help
+      - bridge:                start Matterbridge in bridge mode
+      - childbridge:           start Matterbridge in childbridge mode
+      - frontend [port]:       start the frontend on the given port (default 3000)
+      - list:                  list the registered plugins
+      - add [plugin path]:     register the plugin
+      - remove [plugin path]:  remove the plugin
+      - enable [plugin path]:  enable the plugin
+      - disable [plugin path]: disable the plugin\n`);
+            process.exit(0);
+        }
         // set Matterbridge logger
         this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */ });
         this.log.info('Matterbridge is running...');
-        // log system info
-        this.logNodeAndSystemInfo();
+        // log system info and create .matterbridge directory
+        await this.logNodeAndSystemInfo();
         // check node version and throw error
         requireMinNodeVersion(18);
         // register SIGINT SIGTERM signal handlers
@@ -59,32 +132,33 @@ export class Matterbridge extends EventEmitter {
         // set matter.js logger level and format
         Logger.defaultLogLevel = Level.DEBUG;
         Logger.format = Format.ANSI;
-        this.initialize();
-    }
-    async initialize() {
         // Initialize NodeStorage
-        this.storage = new NodeStorageManager();
-        this.context = await this.storage.createStorage('matterbridge');
-        this.registeredPlugins = await this.context?.get('plugins', []);
-        // Initialize frontend
-        this.initializeFrontend();
+        this.log.debug('Creating node storage manager');
+        this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, 'storage') });
+        this.log.debug('Creating node storage context for matterbridge');
+        this.nodeContext = await this.nodeStorage.createStorage('matterbridge');
+        this.registeredPlugins = await this.nodeContext.get('plugins', []);
+        /*
+        this.registeredPlugins.forEach(async (plugin) => {
+          this.log.debug(`Creating node storage context for plugin ${plg}${plugin.name}${db}`);
+          plugin.nodeContext = await this.nodeStorage?.createStorage(plugin.name);
+        });
+        */
         // Parse command line
-        await this.parseCommandLine();
+        this.parseCommandLine();
     }
+    /**
+     * Parses the command line arguments and performs the corresponding actions.
+     * @private
+     * @returns {Promise<void>} A promise that resolves when the command line arguments have been processed.
+     */
     async parseCommandLine() {
-        if (hasParameter('help')) {
-            this.log.info(`\nmatterbridge -help -bridge -add <plugin path> -remove <plugin path>
-      - help:                 show the help
-      - bridge:               start the bridge
-      - list:                 list the registered plugin
-      - add <plugin path>:    register the plugin
-      - remove <plugin path>: remove the plugin\n`);
-            process.exit(0);
-        }
         if (hasParameter('list')) {
             this.log.info('Registered plugins:');
             this.registeredPlugins.forEach((plugin) => {
-                this.log.info(`- ${BLUE}${plugin.name}${nf} '${BLUE}${BRIGHT}${plugin.description}${RESET}${nf}' type: ${GREEN}${plugin.type}${nf}`);
+                this.log.info(`- ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" version: ${plugin.version}` +
+                    ` author: "${plugin.author}" type: ${GREEN}${plugin.type}${nf} ${YELLOW}${plugin.enabled ? 'enabled' : 'disabled'}${nf}`);
+                //  loaded: ${plugin.loaded} started: ${plugin.started} paired: ${plugin.paired} connected: ${plugin.connected}
             });
             process.exit(0);
         }
@@ -98,11 +172,26 @@ export class Matterbridge extends EventEmitter {
             await this.loadPlugin(getParameter('remove'), 'remove');
             process.exit(0);
         }
-        await this.startStorage('json', '.matterbridge.json');
+        if (getParameter('enable')) {
+            this.log.debug(`Enable plugin ${getParameter('enable')}`);
+            await this.loadPlugin(getParameter('enable'), 'enable');
+            process.exit(0);
+        }
+        if (getParameter('disable')) {
+            this.log.debug(`Disable plugin ${getParameter('disable')}`);
+            await this.loadPlugin(getParameter('disable'), 'disable');
+            process.exit(0);
+        }
+        // Start the storage (we need it now for frontend and later for matterbridge)
+        await this.startStorage('json', path.join(this.matterbridgeDirectory, 'matterbridge.json'));
+        // Initialize frontend
+        await this.initializeFrontend(getIntParameter('frontend'));
         if (hasParameter('childbridge')) {
             this.bridgeMode = 'childbridge';
             this.registeredPlugins.forEach(async (plugin) => {
-                this.log.info(`Loading plugin ${BLUE}${plugin.name}${nf} type ${GREEN}${plugin.type}${nf}`);
+                if (!plugin.enabled)
+                    return;
+                this.log.info(`Loading registered plugin ${plg}${plugin.name}${nf} type ${GREEN}${plugin.type}${nf}`);
                 await this.loadPlugin(plugin.path, 'load');
             });
             await this.startMatterBridge();
@@ -110,67 +199,59 @@ export class Matterbridge extends EventEmitter {
         if (hasParameter('bridge')) {
             this.bridgeMode = 'bridge';
             this.registeredPlugins.forEach(async (plugin) => {
-                this.log.info(`Loading plugin ${BLUE}${plugin.name}${nf} type ${GREEN}${plugin.type}${nf}`);
+                if (!plugin.enabled)
+                    return;
+                this.log.info(`Loading registered plugin ${plg}${plugin.name}${nf} type ${GREEN}${plugin.type}${nf}`);
                 await this.loadPlugin(plugin.path, 'load');
             });
             await this.startMatterBridge();
         }
     }
-    // Typed method for emitting events
-    emit(event, ...args) {
-        return super.emit(event, ...args);
-    }
-    // Typed method for listening to events
-    on(event, listener) {
-        super.on(event, listener);
-        return this;
-    }
+    /**
+     * Loads a plugin from the specified package.json file path.
+     * @param packageJsonPath - The path to the package.json file of the plugin.
+     * @param mode - The mode of operation. Possible values are 'load', 'add', 'remove', 'enable', 'disable'.
+     * @returns A Promise that resolves when the plugin is loaded successfully, or rejects with an error if loading fails.
+     */
     async loadPlugin(packageJsonPath, mode = 'load') {
         if (!packageJsonPath.endsWith('package.json'))
             packageJsonPath = path.join(packageJsonPath, 'package.json');
-        this.log.debug(`Loading plugin ${BLUE}${packageJsonPath}${RESET}`);
+        packageJsonPath = path.resolve(packageJsonPath);
+        this.log.debug(`Loading plugin from ${plg}${packageJsonPath}${db}`);
         try {
             // Load the package.json of the plugin
             const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+            const plugin = this.registeredPlugins.find((plugin) => plugin.name === packageJson.name);
+            if (plugin && plugin.platform) {
+                this.log.error(`Plugin ${plg}${plugin.name}${er} already loaded`);
+            }
             // Resolve the main module path relative to package.json
             const pluginPath = path.resolve(path.dirname(packageJsonPath), packageJson.main);
             // Convert the file path to a URL
             const pluginUrl = pathToFileURL(pluginPath);
             // Dynamically import the plugin
-            this.log.debug(`Importing plugin ${BLUE}${pluginUrl.href}${RESET}`);
-            const plugin = await import(pluginUrl.href);
+            this.log.debug(`Importing plugin ${plg}${plugin?.name}${db} from ${pluginUrl.href}`);
+            const pluginInstance = await import(pluginUrl.href);
+            this.log.debug(`Imported plugin ${plg}${plugin?.name}${db} from ${pluginUrl.href}`);
             // Call the default export function of the plugin, passing this MatterBridge instance
-            if (plugin.default) {
-                const platform = plugin.default(this, new AnsiLogger({ logName: packageJson.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */ }));
+            if (pluginInstance.default) {
+                const platform = pluginInstance.default(this, new AnsiLogger({ logName: packageJson.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */ }));
                 platform.name = packageJson.name;
                 if (mode === 'load') {
-                    this.log.info(`Plugin ${BLUE}${packageJsonPath}${RESET} type ${GREEN}${platform.type}${RESET} loaded (entrypoint ${UNDERLINE}${pluginPath}${UNDERLINEOFF})`);
+                    this.log.info(`Plugin ${plg}${plugin?.name}${nf} type ${GREEN}${platform.type}${nf} loaded (entrypoint ${UNDERLINE}${pluginPath}${UNDERLINEOFF})`);
                     // Update plugin info
-                    const plugin = this.registeredPlugins.find((plugin) => plugin.name === packageJson.name);
                     if (plugin) {
+                        plugin.path = packageJsonPath;
                         plugin.name = packageJson.name;
                         plugin.description = packageJson.description;
                         plugin.version = packageJson.version;
                         plugin.author = packageJson.author;
                         plugin.type = platform.type;
                         plugin.loaded = true;
+                        plugin.platform = platform;
                     }
                     else {
-                        this.log.error(`Plugin ${packageJson.name} not found`);
-                    }
-                    // Register handlers
-                    if (platform.type === 'AccessoryPlatform') {
-                        platform.on('registerDeviceAccessoryPlatform', (device) => {
-                            this.log.debug(`Received ${REVERSE}registerDeviceAccessoryPlatform${REVERSEOFF} for device ${device.name}`);
-                        });
-                    }
-                    else if (platform.type === 'DynamicPlatform') {
-                        platform.on('registerDeviceDynamicPlatform', (device) => {
-                            this.log.debug(`Received ${REVERSE}registerDeviceDynamicPlatform${REVERSEOFF} for device ${device.name}`);
-                        });
-                    }
-                    else {
-                        this.log.error(`loadPlugin error platform.type ${REVERSE}${platform.type}${REVERSEOFF} for plugin ${packageJson.name}`);
+                        this.log.error(`Plugin ${plg}${packageJson.name}${er} not found`);
                     }
                 }
                 else if (mode === 'add') {
@@ -182,34 +263,61 @@ export class Matterbridge extends EventEmitter {
                             version: packageJson.version,
                             description: packageJson.description,
                             author: packageJson.author,
+                            enabled: true,
                         });
-                        await this.context?.set('plugins', this.registeredPlugins);
-                        this.log.info(`Plugin ${packageJsonPath} type ${platform.type} added to matterbridge`);
+                        await this.nodeContext?.set('plugins', this.registeredPlugins);
+                        this.log.info(`Plugin ${plg}${packageJsonPath}${nf} type ${platform.type} added to matterbridge`);
                     }
                     else {
-                        this.log.warn(`Plugin ${packageJsonPath} already added to matterbridge`);
+                        this.log.warn(`Plugin ${plg}${packageJsonPath}${wr} already added to matterbridge`);
                     }
                 }
                 else if (mode === 'remove') {
-                    if (this.registeredPlugins.find((plugin) => plugin.name === packageJson.name)) {
-                        this.registeredPlugins.splice(this.registeredPlugins.findIndex((plugin) => plugin.name === packageJson.name));
-                        await this.context?.set('plugins', this.registeredPlugins);
-                        this.log.info(`Plugin ${packageJsonPath} removed from matterbridge`);
+                    if (this.registeredPlugins.find((registeredPlugin) => registeredPlugin.name === packageJson.name)) {
+                        this.registeredPlugins.splice(this.registeredPlugins.findIndex((registeredPlugin) => registeredPlugin.name === packageJson.name), 1);
+                        await this.nodeContext?.set('plugins', this.registeredPlugins);
+                        this.log.info(`Plugin ${plg}${packageJsonPath}${nf} removed from matterbridge`);
                     }
                     else {
-                        this.log.warn(`Plugin ${packageJsonPath} not registerd in matterbridge`);
+                        this.log.warn(`Plugin ${plg}${packageJsonPath}${wr} not registerd in matterbridge`);
                     }
                 }
-            }
-            else {
-                this.log.error(`Plugin at ${pluginPath} does not provide a default export`);
+                else if (mode === 'enable') {
+                    const plugin = this.registeredPlugins.find((registeredPlugin) => registeredPlugin.name === packageJson.name);
+                    if (plugin) {
+                        plugin.enabled = true;
+                        await this.nodeContext?.set('plugins', this.registeredPlugins);
+                        this.log.info(`Plugin ${plg}${packageJsonPath}${nf} enabled`);
+                    }
+                    else {
+                        this.log.warn(`Plugin ${plg}${packageJsonPath}${wr} not registerd in matterbridge`);
+                    }
+                }
+                else if (mode === 'disable') {
+                    const plugin = this.registeredPlugins.find((registeredPlugin) => registeredPlugin.name === packageJson.name);
+                    if (plugin) {
+                        plugin.enabled = false;
+                        await this.nodeContext?.set('plugins', this.registeredPlugins);
+                        this.log.info(`Plugin ${plg}${packageJsonPath}${nf} disabled`);
+                    }
+                    else {
+                        this.log.warn(`Plugin ${plg}${packageJsonPath}${wr} not registerd in matterbridge`);
+                    }
+                }
+                else {
+                    this.log.error(`Plugin at ${plg}${pluginPath}${er} does not provide a default export`);
+                }
             }
         }
         catch (err) {
-            this.log.error(`Failed to load plugin from ${packageJsonPath}: ${err}`);
+            this.log.error(`Failed to load plugin from ${plg}${packageJsonPath}${er}: ${err}`);
         }
     }
-    registerSignalHandlers() {
+    /**
+     * Registers the signal handlers for SIGINT and SIGTERM.
+     * When either of these signals are received, the cleanup method is called with an appropriate message.
+     */
+    async registerSignalHandlers() {
         process.on('SIGINT', async () => {
             await this.cleanup('SIGINT received, cleaning up...');
         });
@@ -217,71 +325,127 @@ export class Matterbridge extends EventEmitter {
             await this.cleanup('SIGTERM received, cleaning up...');
         });
     }
+    /**
+     * Performs cleanup operations before shutting down Matterbridge.
+     * @param message - The reason for the cleanup.
+     */
     async cleanup(message) {
         if (!this.hasCleanupStarted) {
             this.hasCleanupStarted = true;
             this.log.debug(message);
-            // Emitting the shutdown event with a reason
-            this.emit('shutdown', 'Matterbridge is closing: ' + message);
+            // Callint the shutdown functions with a reason
+            this.registeredPlugins.forEach((plugin) => {
+                if (plugin.platform) {
+                    plugin.platform.onShutdown('Matterbridge is closing: ' + message);
+                }
+            });
             // Set reachability to false
-            this.log.debug(`*Changing reachability for ${this.registeredDevices.length} devices:`);
-            this.registeredDevices.forEach((device) => {
-                this.log.debug(`*--child device: ${device.device.name}`);
-                if (this.bridgeMode === 'bridge')
-                    device.device.setBridgedDeviceReachability(false);
+            /*
+            this.log.debug(`*Changing reachability to false for ${this.registeredDevices.length} devices (${this.bridgeMode} mode):`);
+            this.registeredDevices.forEach((registeredDevice) => {
+              const plugin = this.registeredPlugins.find((plugin) => plugin.name === registeredDevice.plugin);
+              if (!plugin) {
+                this.log.error(`Plugin ${plg}${registeredDevice.plugin}${er} not found`);
+                return;
+              }
+              this.log.debug(`*-- device: ${dev}${registeredDevice.device.name}${db} plugin ${plg}${registeredDevice.plugin}${db} type ${GREEN}${plugin.type}${db}`);
+              if (this.bridgeMode === 'bridge') registeredDevice.device.setBridgedDeviceReachability(false);
+              if (this.bridgeMode === 'childbridge' && plugin.type === 'DynamicPlatform') plugin.aggregator?.removeBridgedDevice(registeredDevice.device);
+              if (this.bridgeMode === 'childbridge') plugin.commissioningServer?.setReachability(false);
+              if (this.bridgeMode === 'childbridge' && plugin.type === 'AccessoryPlatform') this.setReachableAttribute(registeredDevice.device, false);
+              if (this.bridgeMode === 'childbridge' && plugin.type === 'DynamicPlatform') registeredDevice.device.setBridgedDeviceReachability(false);
             });
+            */
             setTimeout(async () => {
                 // Closing matter
                 await this.stopMatter();
                 // Closing storage
                 await this.stopStorage();
+                //await this.context?.set<RegisteredDevice[]>('plugins', this.registeredDevices);
                 this.log.debug('Cleanup completed.');
                 process.exit(0);
-            }, this.bridgeMode === 'bridge' ? 2000 : 0);
+            }, 2 * 1000);
+        }
+    }
+    /**
+     * Sets the reachable attribute of a device.
+     *
+     * @param device - The device for which to set the reachable attribute.
+     * @param reachable - The value to set for the reachable attribute.
+     */
+    setReachableAttribute(device, reachable) {
+        const basicInformationCluster = device.getClusterServer(BasicInformationCluster);
+        if (!basicInformationCluster) {
+            this.log.error('setReachableAttribute BasicInformationCluster needs to be set!');
+            return;
         }
+        basicInformationCluster.setReachableAttribute(reachable);
     }
+    /**
+     * Adds a device to the Matterbridge.
+     * @param pluginName - The name of the plugin.
+     * @param device - The device to be added.
+     */
     async addDevice(pluginName, device) {
+        this.log.info(`Adding device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
+        // Check if the plugin is registered
+        const plugin = this.registeredPlugins.find((plugin) => plugin.name === pluginName);
+        if (!plugin) {
+            this.log.error(`addDevice error: device ${dev}${device.name}${nf} plugin ${plg}${pluginName}${er} not found`);
+            return;
+        }
+        // Add and register the device to the matterbridge in bridge mode
         if (this.bridgeMode === 'bridge') {
             const basic = device.getClusterServerById(BasicInformationCluster.id);
             if (!basic) {
-                this.log.error('addDevice error: cannot find the BasicInformationCluster');
+                this.log.error(`addDevice error: cannot find the BasicInformationCluster device ${dev}${device.name}${nf} plugin ${plg}${pluginName}${nf}`);
                 return;
             }
-            device.createDefaultBridgedDeviceBasicInformationClusterServer(basic.getNodeLabelAttribute(), basic.getUniqueIdAttribute(), basic.getVendorIdAttribute(), basic.getVendorNameAttribute(), basic.getProductNameAttribute());
+            device.createDefaultBridgedDeviceBasicInformationClusterServer(basic.getNodeLabelAttribute(), basic.getSerialNumberAttribute(), basic.getVendorIdAttribute(), basic.getVendorNameAttribute(), basic.getProductNameAttribute(), basic.getSoftwareVersionAttribute(), basic.getSoftwareVersionStringAttribute(), basic.getHardwareVersionAttribute(), basic.getHardwareVersionStringAttribute());
+            //console.log(basic.getSoftwareVersionAttribute(), basic.getSoftwareVersionStringAttribute());
             this.matterAggregator.addBridgedDevice(device);
-            this.registeredDevices.push({ plugin: pluginName, device });
-            this.log.debug(`addDevice called from plugin ${pluginName}`);
+            this.registeredDevices.push({ plugin: pluginName, device, added: true });
+            this.log.info(`Added and registered device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
         }
+        // Only register the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
-            const plugin = this.registeredPlugins.find((plugin) => plugin.name === pluginName);
-            if (plugin) {
-                plugin.started = true;
-                this.registeredDevices.push({ plugin: pluginName, device });
-                this.log.debug(`addDevice called from plugin ${pluginName}`);
-            }
-            else {
-                this.log.error(`addDevice error: plugin ${pluginName} not found`);
-            }
+            this.registeredDevices.push({ plugin: pluginName, device, added: false });
+            this.log.info(`Registered device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
         }
     }
+    /**
+     * Adds a bridged device to the Matterbridge.
+     * @param pluginName - The name of the plugin.
+     * @param device - The bridged device to add.
+     */
     async addBridgedDevice(pluginName, device) {
+        this.log.info(`Adding bridged device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
+        // Check if the plugin is registered
+        const plugin = this.registeredPlugins.find((plugin) => plugin.name === pluginName);
+        if (!plugin) {
+            this.log.error(`addBridgedDevice error: device ${dev}${device.name}${nf} plugin ${plg}${pluginName}${er} not found`);
+            return;
+        }
+        // Add and register the device to the matterbridge in bridge mode
         if (this.bridgeMode === 'bridge') {
             this.matterAggregator.addBridgedDevice(device);
-            this.registeredDevices.push({ plugin: pluginName, device });
-            this.log.debug(`addBridgedDevice called from plugin ${pluginName}`);
+            this.registeredDevices.push({ plugin: pluginName, device, added: true });
+            this.log.info(`Added and registered bridged device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
         }
+        // Only register the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
-            const plugin = this.registeredPlugins.find((plugin) => plugin.name === pluginName);
-            if (plugin) {
-                plugin.started = true;
-                this.registeredDevices.push({ plugin: pluginName, device });
-                this.log.debug(`addBridgedDevice called from plugin ${pluginName}`);
-            }
-            else {
-                this.log.error(`addBridgedDevice error: plugin ${pluginName} not found`);
-            }
+            this.registeredDevices.push({ plugin: pluginName, device, added: false });
+            this.log.info(`Registered bridged device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
+            //const basic = device.getClusterServerById(BridgedDeviceBasicInformationCluster.id);
+            //console.log(JSON.stringify(basic, null, 2));
         }
     }
+    /**
+     * Starts the storage process based on the specified storage type and name.
+     * @param {string} storageType - The type of storage to start (e.g., 'disk', 'json').
+     * @param {string} storageName - The name of the storage file.
+     * @returns {Promise<void>} - A promise that resolves when the storage process is started.
+     */
     async startStorage(storageType, storageName) {
         if (!storageName.endsWith('.json')) {
             storageName += '.json';
@@ -299,7 +463,7 @@ export class Matterbridge extends EventEmitter {
             await this.storageManager.initialize();
             this.log.debug('Storage initialized');
             if (storageType === 'json') {
-                this.backupJsonStorage(storageName, storageName.replace('.json', '') + '.backup.json');
+                await this.backupJsonStorage(storageName, storageName.replace('.json', '') + '.backup.json');
             }
         }
         catch (error) {
@@ -307,6 +471,12 @@ export class Matterbridge extends EventEmitter {
             process.exit(1);
         }
     }
+    /**
+     * Makes a backup copy of the specified JSON storage file.
+     *
+     * @param storageName - The name of the JSON storage file to be backed up.
+     * @param backupName - The name of the backup file to be created.
+     */
     async backupJsonStorage(storageName, backupName) {
         try {
             this.log.debug(`Making backup copy of ${storageName}`);
@@ -327,94 +497,103 @@ export class Matterbridge extends EventEmitter {
             }
         }
     }
+    /**
+     * Stops the storage.
+     * @returns {Promise<void>} A promise that resolves when the storage is stopped.
+     */
     async stopStorage() {
         this.log.debug('Stopping storage');
-        await this.storageManager?.close();
+        await this.storageManager.close();
         this.log.debug('Storage closed');
     }
+    /**
+     * Starts the Matterbridge based on the bridge mode.
+     * If the bridge mode is 'bridge', it creates a commissioning server, matter aggregator,
+     * and starts the matter server.
+     * If the bridge mode is 'childbridge', it starts the plugins, creates commissioning servers,
+     * and starts the matter server when all plugins are loaded and started.
+     * @private
+     * @returns {Promise<void>} A promise that resolves when the Matterbridge is started.
+     */
     async startMatterBridge() {
         this.log.debug('Starting matterbridge in mode', this.bridgeMode);
         await this.createMatterServer(this.storageManager);
-        this.log.debug('Creating matterbridge context: matterbridge');
-        this.matterbridgeContext = this.storageManager.createContext('matterbridge');
-        this.matterbridgeContext.set('port', 5500);
-        this.matterbridgeContext.set('passcode', 20232024);
-        this.matterbridgeContext.set('discriminator', 3940);
-        this.matterbridgeContext.set('deviceName', 'matterbridge aggregator');
-        this.matterbridgeContext.set('deviceType', DeviceTypes.AGGREGATOR.code);
-        this.matterbridgeContext.set('vendorId', 0xfff1);
-        this.matterbridgeContext.set('vendorName', 'matterbridge');
-        this.matterbridgeContext.set('productId', 0x8000);
-        this.matterbridgeContext.set('productName', 'node-matterbridge');
-        this.matterbridgeContext.set('uniqueId', this.matterbridgeContext.get('uniqueId', CryptoNode.getRandomData(8).toHex()));
-        this.log.debug('Creating matterbridge commissioning server');
-        this.commissioningServer = await this.createMatterCommisioningServer(this.matterbridgeContext, 'Matterbridge');
         if (this.bridgeMode === 'bridge') {
+            // Plugins are loaded by loadPlugin on startup and plugin.loaded is set to true
+            // Plugins are started by callback when Matterbridge is commissioned and plugin.started is set to true
+            this.log.debug('Creating commissioning server context for Matterbridge');
+            this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggragator');
+            this.log.debug('Creating commissioning server for Matterbridge');
+            this.commissioningServer = this.createCommisioningServer(this.matterbridgeContext, 'Matterbridge');
             this.log.debug('Creating matter aggregator for matterbridge');
-            this.matterAggregator = await this.createMatterAggregator();
-            this.log.debug('Adding matter aggregator to commissioning server');
+            this.matterAggregator = this.createMatterAggregator(this.matterbridgeContext);
+            this.log.debug('Adding matterbridge aggregator to matterbridge commissioning server');
             this.commissioningServer.addDevice(this.matterAggregator);
-            this.matterServer.addCommissioningServer(this.commissioningServer);
+            this.log.debug('Adding matterbridge commissioning server to matter server');
+            await this.matterServer.addCommissioningServer(this.commissioningServer, { uniqueStorageKey: 'Matterbridge' });
             this.log.debug('Starting matter server');
             await this.matterServer.start();
             this.log.debug('Started matter server');
             this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, 'Matterbridge');
         }
         if (this.bridgeMode === 'childbridge') {
-            this.log.debug('Creating matter aggregator for matterbridge');
-            this.matterAggregator = await this.createMatterAggregator();
-            this.log.debug('Adding matter aggregator to commissioning server');
-            this.commissioningServer.addDevice(this.matterAggregator);
-            this.matterServer.addCommissioningServer(this.commissioningServer);
+            // Plugins are loaded by loadPlugin on startup and plugin.loaded is set to true
+            // Plugins are started here and plugin.started is set to true.
+            // addDevice and addBridgedDeevice just register the devices that are added here to the plugin commissioning server for Accessory Platform
+            // or to the plugin aggregator for Dynamic Platform after the commissioning is done
             this.registeredPlugins.forEach(async (plugin) => {
-                // Start the interval to check if all plugins are loaded
+                if (!plugin.enabled)
+                    return;
+                // Start the interval to check if the plugin is loaded
                 const loadedInterval = setInterval(async () => {
-                    this.log.debug(`Waiting for plugin ${BLUE}${plugin.name}${db} to load (${plugin.loaded}) and send device (${plugin.started})...`);
+                    this.log.debug(`Waiting in load interval for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) and send devices ...`);
                     if (!plugin.loaded)
                         return;
-                    this.log.debug(`Sending start platform for plugin ${BLUE}${plugin.name}${db}`);
-                    this.emit('startAccessoryPlatform', 'Matterbridge is commissioned and controllers are connected');
-                    this.emit('startDynamicPlatform', 'Matterbridge is commissioned and controllers are connected');
+                    plugin.started = true;
+                    plugin.registeredDevices = 0;
                     clearInterval(loadedInterval);
                 }, 1000);
-                // Start the interval to check if all plugins are started
+                // Start the interval to check if the plugins is started
                 const startedInterval = setInterval(async () => {
-                    this.log.debug(`**Waiting for plugin ${BLUE}${plugin.name}${db} to load (${plugin.loaded}) and send device (${plugin.started})...`);
+                    this.log.debug(`Waiting in started interval for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) and send devices ...`);
                     if (!plugin.started)
                         return;
-                    this.log.debug(`**Creating storage context for plugin ${BLUE}${plugin.name}${db}`);
-                    plugin.storageContext = this.storageManager.createContext(plugin.name);
-                    //plugin.storageContext.set('port', undefined);
-                    //plugin.storageContext.set('passcode', undefined);
-                    //plugin.storageContext.set('discriminator', undefined);
-                    plugin.storageContext.set('deviceName', 'matterbridge aggregator');
-                    plugin.storageContext.set('deviceType', DeviceTypes.AGGREGATOR.code);
-                    plugin.storageContext.set('vendorId', 0xfff1);
-                    plugin.storageContext.set('vendorName', 'matterbridge');
-                    plugin.storageContext.set('productId', 0x8000);
-                    plugin.storageContext.set('productName', plugin.name.slice(0, 32));
-                    plugin.storageContext.set('uniqueId', plugin.storageContext.get('uniqueId', CryptoNode.getRandomData(8).toHex()));
-                    this.log.debug(`**Creating commissioning server for plugin ${BLUE}${plugin.name}${db}`);
-                    plugin.commissioningServer = await this.createMatterCommisioningServer(plugin.storageContext, plugin.name);
                     if (plugin.type === 'AccessoryPlatform') {
-                        this.registeredDevices.forEach((registeredDevice) => {
+                        this.log.debug(`Starting accessory platform for plugin ${plg}${plugin.name}${db}`);
+                        if (plugin.platform)
+                            await plugin.platform.onStart('Matterbridge Accessory platform has started commissioning');
+                        else
+                            this.log.error(`Platform not found for plugin ${plg}${plugin.name}${er}`);
+                        this.registeredDevices.forEach(async (registeredDevice) => {
                             if (registeredDevice.plugin === plugin.name) {
-                                plugin.commissioningServer?.addDevice(registeredDevice.device);
-                                this.matterServer.addCommissioningServer(plugin.commissioningServer);
+                                plugin.storageContext = this.importCommissioningServerContext(plugin.name, registeredDevice.device); // Generate serialNumber and uniqueId
+                                plugin.commissioningServer = this.createCommisioningServer(plugin.storageContext, plugin.name);
+                                this.log.debug(`Adding device ${dev}${registeredDevice.device.name}${db} to commissioning server for plugin ${plg}${plugin.name}${db}`);
+                                plugin.commissioningServer.addDevice(registeredDevice.device);
+                                if (plugin.registeredDevices !== undefined)
+                                    plugin.registeredDevices++;
+                                this.log.debug(`Adding commissioning server to matter server for plugin ${plg}${plugin.name}${db} `);
+                                await this.matterServer.addCommissioningServer(plugin.commissioningServer, { uniqueStorageKey: plugin.name });
                                 return;
                             }
                         });
                     }
                     if (plugin.type === 'DynamicPlatform') {
-                        this.log.debug(`**Creating aggregator for plugin ${BLUE}${plugin.name}${db}`);
-                        plugin.aggregator = await this.createMatterAggregator();
-                        this.log.debug(`**Adding matter aggregator to commissioning server for plugin ${BLUE}${plugin.name}${db}`);
-                        plugin.commissioningServer?.addDevice(plugin.aggregator);
-                        this.registeredDevices.forEach((registeredDevice) => {
-                            if (registeredDevice.plugin === plugin.name)
-                                plugin.aggregator?.addBridgedDevice(registeredDevice.device);
-                        });
-                        this.matterServer.addCommissioningServer(plugin.commissioningServer);
+                        plugin.storageContext = this.createCommissioningServerContext(
+                        // Generate serialNumber and uniqueId
+                        plugin.name, 'Matterbridge Dynamic Platform', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Dynamic Platform');
+                        plugin.commissioningServer = this.createCommisioningServer(plugin.storageContext, plugin.name);
+                        this.log.debug(`Creating aggregator for plugin ${plg}${plugin.name}${db}`);
+                        plugin.aggregator = this.createMatterAggregator(plugin.storageContext); // Generate serialNumber and uniqueId
+                        this.log.debug(`Starting dynamic platform for plugin ${plg}${plugin.name}${db}`);
+                        if (plugin.platform)
+                            await plugin.platform.onStart('Matterbridge Dynamic platform has started commissioning');
+                        else
+                            this.log.error(`Platform not found for plugin ${plg}${plugin.name}${er}`);
+                        this.log.debug(`Adding matter aggregator to commissioning server for plugin ${plg}${plugin.name}${db}`);
+                        plugin.commissioningServer.addDevice(plugin.aggregator);
+                        this.log.debug(`Adding commissioning server to matter server for plugin ${plg}${plugin.name}${db}`);
+                        await this.matterServer.addCommissioningServer(plugin.commissioningServer, { uniqueStorageKey: plugin.name });
                     }
                     clearInterval(startedInterval);
                 }, 1000);
@@ -422,30 +601,112 @@ export class Matterbridge extends EventEmitter {
             // Start the interval to check if all plugins are loaded and started and so start the matter server
             const startMatterInterval = setInterval(async () => {
                 let allStarted = true;
-                this.registeredPlugins.forEach(async (plugin) => {
-                    this.log.debug(`***Waiting in startMatter interval for plugin ${BLUE}${plugin.name}${db} to load (${plugin.loaded}) and send device (${plugin.started})...`);
-                    if (!plugin.loaded || !plugin.started)
+                this.registeredPlugins.forEach((plugin) => {
+                    if (!plugin.enabled)
+                        return;
+                    this.log.debug(`Waiting in start matter server interval for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) and send devices ...`);
+                    if (plugin.enabled && (!plugin.loaded || !plugin.started))
                         allStarted = false;
                 });
                 if (!allStarted)
                     return;
-                this.log.debug('***Starting matter server from startMatter interval');
+                // Setting reachability to true
+                this.registeredPlugins.forEach((plugin) => {
+                    if (!plugin.enabled)
+                        return;
+                    this.log.debug(`Setting reachability to true for ${plg}${plugin.name}${db}`);
+                    plugin.commissioningServer?.setReachability(true);
+                    this.registeredDevices.forEach((registeredDevice) => {
+                        if (registeredDevice.plugin === plugin.name) {
+                            if (plugin.type === 'AccessoryPlatform')
+                                this.setReachableAttribute(registeredDevice.device, true);
+                            if (plugin.type === 'DynamicPlatform')
+                                registeredDevice.device.setBridgedDeviceReachability(true);
+                        }
+                    });
+                });
+                this.log.debug('Starting matter server');
                 await this.matterServer.start();
-                this.log.debug('***Started matter server from startMatter interval');
-                this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, 'Matterbridge');
+                this.log.debug('Started matter server');
                 this.registeredPlugins.forEach(async (plugin) => {
                     this.showCommissioningQRCode(plugin.commissioningServer, plugin.storageContext, plugin.name);
                 });
+                Logger.defaultLogLevel = Level.DEBUG;
                 clearInterval(startMatterInterval);
             }, 1000);
             return;
         }
     }
+    /**
+     * Imports the commissioning server context for a specific plugin and device.
+     * @param pluginName - The name of the plugin.
+     * @param device - The MatterbridgeDevice object representing the device.
+     * @returns The commissioning server context.
+     * @throws Error if the BasicInformationCluster is not found.
+     */
+    importCommissioningServerContext(pluginName, device) {
+        this.log.debug(`Importing matter commissioning server storage context from device for ${plg}${pluginName}${db}`);
+        const basic = device.getClusterServer(BasicInformationCluster);
+        if (!basic) {
+            throw new Error('importCommissioningServerContext error: cannot find the BasicInformationCluster');
+        }
+        //const random = 'CS' + CryptoNode.getRandomData(8).toHex();
+        return this.createCommissioningServerContext(pluginName, basic.getNodeLabelAttribute(), DeviceTypeId(device.deviceType), basic.getVendorIdAttribute(), basic.getVendorNameAttribute(), basic.getProductIdAttribute(), basic.getProductNameAttribute(), basic.attributes.serialNumber?.getLocal(), basic.attributes.uniqueId?.getLocal(), basic.attributes.softwareVersion?.getLocal(), basic.attributes.softwareVersionString?.getLocal(), basic.attributes.hardwareVersion?.getLocal(), basic.attributes.hardwareVersionString?.getLocal());
+    }
+    /**
+     * Creates a commissioning server storage context.
+     *
+     * @param pluginName - The name of the plugin.
+     * @param deviceName - The name of the device.
+     * @param deviceType - The type of the device.
+     * @param vendorId - The vendor ID.
+     * @param vendorName - The vendor name.
+     * @param productId - The product ID.
+     * @param productName - The product name.
+     * @param serialNumber - The serial number of the device (optional).
+     * @param uniqueId - The unique ID of the device (optional).
+     * @param softwareVersion - The software version of the device (optional).
+     * @param softwareVersionString - The software version string of the device (optional).
+     * @param hardwareVersion - The hardware version of the device (optional).
+     * @param hardwareVersionString - The hardware version string of the device (optional).
+     * @returns The storage context for the commissioning server.
+     */
+    createCommissioningServerContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber, uniqueId, softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString) {
+        this.log.debug(`Creating commissioning server storage context for ${plg}${pluginName}${db}`);
+        const random = 'CS' + CryptoNode.getRandomData(8).toHex();
+        const storageContext = this.storageManager.createContext(pluginName);
+        storageContext.set('deviceName', deviceName);
+        storageContext.set('deviceType', deviceType);
+        storageContext.set('vendorId', vendorId);
+        storageContext.set('vendorName', vendorName.slice(0, 32));
+        storageContext.set('productId', productId);
+        storageContext.set('productName', productName.slice(0, 32));
+        storageContext.set('nodeLabel', productName.slice(0, 32));
+        storageContext.set('productLabel', productName.slice(0, 32));
+        storageContext.set('serialNumber', storageContext.get('serialNumber', random));
+        storageContext.set('uniqueId', storageContext.get('uniqueId', random));
+        storageContext.set('softwareVersion', softwareVersion ?? 1);
+        storageContext.set('softwareVersionString', softwareVersionString ?? '1.0.0');
+        storageContext.set('hardwareVersion', hardwareVersion ?? 1);
+        storageContext.set('hardwareVersionString', hardwareVersionString ?? '1.0.0');
+        return storageContext;
+    }
+    /**
+     * Shows the commissioning QR code for a given commissioning server, storage context, and name.
+     * If any of the parameters are missing, the method returns early.
+     * If the commissioning server is not commissioned, it logs the QR code and pairing code.
+     * If the commissioning server is already commissioned, it waits for controllers to connect.
+     * If the bridge mode is 'childbridge', it sets the 'paired' property of the plugin to true.
+     *
+     * @param commissioningServer - The commissioning server to show the QR code for.
+     * @param storageContext - The storage context to store the pairing codes.
+     * @param name - The name of the commissioning server.
+     */
     showCommissioningQRCode(commissioningServer, storageContext, name) {
         if (!commissioningServer || !storageContext || !name)
             return;
         if (!commissioningServer.isCommissioned()) {
-            this.log.info(`***The commissioning server for ${BLUE}${name}${nf} is not commissioned. Pair it and restart the process to run matterbridge.`);
+            this.log.info(`***The commissioning server for ${plg}${name}${nf} is not commissioned. Pair it scanning the QR code ...`);
             const { qrPairingCode, manualPairingCode } = commissioningServer.getPairingCode();
             storageContext.set('qrPairingCode', qrPairingCode);
             storageContext.set('manualPairingCode', manualPairingCode);
@@ -453,23 +714,48 @@ export class Matterbridge extends EventEmitter {
             this.log.debug(`Pairing code\n\n${QrCode.encode(qrPairingCode)}\nManual pairing code: ${manualPairingCode}\n`);
         }
         else {
-            this.log.info(`***The commissioning server for ${BLUE}${name}${nf} is already commissioned. Waiting for controllers to connect ...`);
+            this.log.info(`***The commissioning server for ${plg}${name}${nf} is already commissioned. Waiting for controllers to connect ...`);
+            if (this.bridgeMode === 'childbridge') {
+                const plugin = this.findPlugin(name);
+                if (plugin)
+                    plugin.paired = true;
+            }
         }
     }
-    async createMatterCommisioningServer(context, name) {
-        //const port = context.get('port') as number;
-        //const passcode = context.get('passcode') as number;
-        //const discriminator = context.get('discriminator') as number;
+    /**
+     * Finds a plugin by its name.
+     *
+     * @param pluginName - The name of the plugin to find.
+     * @returns The found plugin, or undefined if not found.
+     */
+    findPlugin(pluginName) {
+        const plugin = this.registeredPlugins.find((registeredPlugin) => registeredPlugin.name === pluginName);
+        if (!plugin) {
+            this.log.error(`Plugin ${plg}${pluginName}${er} not found`);
+            return;
+        }
+        return plugin;
+    }
+    /**
+     * Creates a matter commissioning server.
+     *
+     * @param {StorageContext} context - The storage context.
+     * @param {string} name - The name of the commissioning server.
+     * @returns {CommissioningServer} The created commissioning server.
+     */
+    createCommisioningServer(context, name) {
+        this.log.debug(`Creating matter commissioning server for plugin ${plg}${name}${db}`);
         const deviceName = context.get('deviceName');
         const deviceType = context.get('deviceType');
         const vendorId = context.get('vendorId');
         const vendorName = context.get('vendorName'); // Home app = Manufacturer
         const productId = context.get('productId');
         const productName = context.get('productName'); // Home app = Model
+        const serialNumber = context.get('serialNumber');
         const uniqueId = context.get('uniqueId');
+        this.log.debug(
         // eslint-disable-next-line max-len
-        //this.log.debug(`Creating matter commissioning server with port ${port} passcode ${passcode} discriminator ${discriminator} deviceName ${deviceName} deviceType ${deviceType}`);
-        this.log.debug(`Creating matter commissioning server with deviceName ${deviceName} deviceType ${deviceType}`);
+        `Creating matter commissioning server for plugin ${plg}${name}${db} with deviceName ${deviceName} deviceType ${deviceType}(0x${deviceType.toString(16).padStart(4, '0')}) uniqueId ${uniqueId} serialNumber ${serialNumber}`);
         const commissioningServer = new CommissioningServer({
             port: undefined,
             passcode: undefined,
@@ -483,44 +769,128 @@ export class Matterbridge extends EventEmitter {
                 productName,
                 nodeLabel: productName,
                 productLabel: productName,
-                softwareVersion: 1,
-                softwareVersionString: '1.0.0', // Home app = Firmware Revision
-                hardwareVersion: 1,
-                hardwareVersionString: '1.0.0',
+                softwareVersion: context.get('softwareVersion', 1),
+                softwareVersionString: context.get('softwareVersionString', '1.0.0'), // Home app = Firmware Revision
+                hardwareVersion: context.get('hardwareVersion', 1),
+                hardwareVersionString: context.get('hardwareVersionString', '1.0.0'),
                 uniqueId,
-                serialNumber: `matterbridge-${uniqueId}`,
+                serialNumber,
                 reachable: true,
             },
             activeSessionsChangedCallback: (fabricIndex) => {
                 const info = commissioningServer.getActiveSessionInformation(fabricIndex);
-                this.log.debug(`Active sessions changed on fabric ${fabricIndex}`, debugStringify(info));
+                this.log.debug(`***Active sessions changed on fabric ${fabricIndex} for ${plg}${name}${nf}`, debugStringify(info));
                 if (info && info[0]?.isPeerActive === true && info[0]?.secure === true && info[0]?.numberOfActiveSubscriptions >= 1) {
-                    this.log.info(`Controller connected to ${BLUE}${name}${nf} ready to start...`);
-                    Logger.defaultLogLevel = Level.INFO;
+                    this.log.info(`***Controller connected to ${plg}${name}${nf} ready to start...`);
+                    if (this.bridgeMode === 'childbridge') {
+                        const plugin = this.findPlugin(name);
+                        if (plugin) {
+                            if (plugin.connected === true)
+                                return; // Only once cause the devices are already added to the plugins aggregator
+                            plugin.paired = true;
+                            plugin.connected = true;
+                        }
+                    }
                     setTimeout(() => {
                         if (this.bridgeMode === 'bridge') {
-                            this.emit('startAccessoryPlatform', 'Matterbridge is commissioned and controllers are connected');
-                            this.emit('startDynamicPlatform', 'Matterbridge is commissioned and controllers are connected');
+                            //Logger.defaultLogLevel = Level.INFO;
+                            this.registeredPlugins.forEach(async (plugin) => {
+                                if (!plugin.enabled)
+                                    return;
+                                if (plugin.platform && !plugin.started) {
+                                    this.log.info(`***Starting plugin ${plg}${plugin.name}${nf}`);
+                                    await plugin.platform.onStart('Matterbridge is commissioned and controllers are connected');
+                                    plugin.started = true;
+                                    this.log.info(`***Started plugin ${plg}${plugin.name}${nf}`);
+                                }
+                                else {
+                                    this.log.error(`***Platform not found for plugin ${plg}${plugin.name}${er}`);
+                                }
+                            });
+                            Logger.defaultLogLevel = Level.DEBUG;
                         }
+                        if (this.bridgeMode === 'childbridge') {
+                            //Logger.defaultLogLevel = Level.INFO;
+                            const plugin = this.findPlugin(name);
+                            if (!plugin || plugin.type === 'AccessoryPlatform')
+                                return;
+                            this.registeredDevices.forEach(async (registeredDevice) => {
+                                if (registeredDevice.plugin !== name)
+                                    return;
+                                this.log.debug(`***Adding device ${registeredDevice.device.name} to aggregator for plugin ${plg}${plugin.name}${db}`);
+                                if (!plugin.aggregator) {
+                                    this.log.error(`***Aggregator not found for plugin ${plg}${plugin.name}${er}`);
+                                    return;
+                                }
+                                plugin.aggregator.addBridgedDevice(registeredDevice.device);
+                                if (plugin.registeredDevices !== undefined)
+                                    plugin.registeredDevices++;
+                                registeredDevice.added = true;
+                            });
+                            Logger.defaultLogLevel = Level.DEBUG;
+                        }
+                        //logEndpoint(commissioningServer.getRootEndpoint());
                     }, 2000);
                 }
             },
             commissioningChangedCallback: (fabricIndex) => {
                 const info = commissioningServer.getCommissionedFabricInformation(fabricIndex);
-                this.log.debug(`Commissioning changed on fabric ${fabricIndex}`, debugStringify(info));
+                this.log.debug(`***Commissioning changed on fabric ${fabricIndex} for ${plg}${name}${nf}`, debugStringify(info));
+                if (info.length === 0) {
+                    this.log.warn(`***Commissioning removed from fabric ${fabricIndex} for ${plg}${name}${nf}`);
+                }
             },
         });
         commissioningServer.addCommandHandler('testEventTrigger', async ({ request: { enableKey, eventTrigger } }) => this.log.info(`testEventTrigger called on GeneralDiagnostic cluster: ${enableKey} ${eventTrigger}`));
         return commissioningServer;
     }
-    async createMatterServer(storageManager) {
+    /**
+     * Creates a Matter server using the provided storage manager.
+     * @param storageManager The storage manager to be used by the Matter server.
+     *
+     */
+    createMatterServer(storageManager) {
         this.log.debug('Creating matter server');
         this.matterServer = new MatterServer(storageManager, { mdnsAnnounceInterface: undefined });
     }
-    async createMatterAggregator() {
+    /**
+     * Creates a Matter Aggregator.
+     * @param {StorageContext} context - The storage context.
+     * @returns {Aggregator} - The created Matter Aggregator.
+     */
+    createMatterAggregator(context) {
+        const random = 'AG' + CryptoNode.getRandomData(8).toHex();
+        context.set('aggregatorSerialNumber', context.get('aggregatorSerialNumber', random));
+        context.set('aggregatorUniqueId', context.get('aggregatorUniqueId', random));
         const matterAggregator = new Aggregator();
+        matterAggregator.addClusterServer(ClusterServer(BasicInformationCluster, {
+            dataModelRevision: 1,
+            location: 'XX',
+            vendorId: VendorId(0xfff1),
+            vendorName: 'Matterbridge',
+            productId: 0x8000,
+            productName: 'Matterbridge aggregator',
+            productLabel: 'Matterbridge aggregator',
+            nodeLabel: 'Matterbridge aggregator',
+            serialNumber: context.get('aggregatorSerialNumber'),
+            uniqueId: context.get('aggregatorUniqueId'),
+            softwareVersion: 1,
+            softwareVersionString: 'v.1.0',
+            hardwareVersion: 1,
+            hardwareVersionString: 'v.1.0',
+            reachable: true,
+            capabilityMinima: { caseSessionsPerFabric: 3, subscriptionsPerFabric: 3 },
+        }, {}, {
+            startUp: true,
+            shutDown: true,
+            leave: true,
+            reachableChanged: true,
+        }));
         return matterAggregator;
     }
+    /**
+     * Stops the Matter server and associated controllers.
+     */
     async stopMatter() {
         this.log.debug('Stopping matter commissioningServer');
         await this.commissioningServer?.close();
@@ -530,7 +900,10 @@ export class Matterbridge extends EventEmitter {
         await this.matterServer?.close();
         this.log.debug('Matter server closed');
     }
-    logNodeAndSystemInfo() {
+    /**
+     * Logs the node and system information.
+     */
+    async logNodeAndSystemInfo() {
         // IP address information
         const networkInterfaces = os.networkInterfaces();
         this.systemInformation.ipv4Address = 'Not found';
@@ -579,16 +952,45 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`- Total Memory: ${this.systemInformation.totalMemory}`);
         this.log.debug(`- Free Memory: ${this.systemInformation.freeMemory}`);
         this.log.debug(`- System Uptime: ${this.systemInformation.systemUptime}`);
-        // Command line arguments (excluding 'node' and the script name)
-        const cmdArgs = process.argv.slice(2).join(' ');
-        this.log.debug(`Command Line Arguments: ${cmdArgs}`);
-        // Current working directory
-        const currentDir = process.cwd();
-        this.log.debug(`Current Working Directory: ${currentDir}`);
+        // Home directory
+        this.homeDirectory = os.homedir();
+        this.log.debug(`Home Directory: ${this.homeDirectory}`);
         // Package root directory
         const currentFileDirectory = path.dirname(fileURLToPath(import.meta.url));
         this.rootDirectory = path.resolve(currentFileDirectory, '../');
         this.log.debug(`Root Directory: ${this.rootDirectory}`);
+        // Create the data directory .matterbridge in the home directory
+        this.matterbridgeDirectory = path.join(this.homeDirectory, '.matterbridge');
+        try {
+            await fs.access(this.matterbridgeDirectory);
+        }
+        catch (err) {
+            await fs.mkdir(this.matterbridgeDirectory);
+        }
+        this.log.debug(`Matterbridge Directory: ${this.matterbridgeDirectory}`);
+        // Current working directory
+        const currentDir = process.cwd();
+        this.log.debug(`Current Working Directory: ${currentDir}`);
+        // Command line arguments (excluding 'node' and the script name)
+        const cmdArgs = process.argv.slice(2).join(' ');
+        this.log.debug(`Command Line Arguments: ${cmdArgs}`);
+    }
+    getBaseRegisteredPlugin() {
+        const baseRegisteredPlugins = this.registeredPlugins.map((plugin) => ({
+            path: plugin.path,
+            type: plugin.type,
+            name: plugin.name,
+            version: plugin.version,
+            description: plugin.description,
+            author: plugin.author,
+            enabled: plugin.enabled,
+            loaded: plugin.loaded,
+            started: plugin.started,
+            paired: plugin.paired,
+            connected: plugin.connected,
+            registeredDevices: plugin.registeredDevices,
+        }));
+        return baseRegisteredPlugins;
     }
     /**
      * Initializes the frontend of Matterbridge.
@@ -596,8 +998,6 @@ export class Matterbridge extends EventEmitter {
      * @param port The port number to run the frontend server on. Default is 3000.
      */
     async initializeFrontend(port = 3000) {
-        //const __filename = fileURLToPath(import.meta.url);
-        //const __dirname = path.dirname(__filename);
         this.log.debug(`Initializing the frontend on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${rs}`);
         this.app = express();
         // Serve React build directory
@@ -605,8 +1005,19 @@ export class Matterbridge extends EventEmitter {
         // Endpoint to provide QR pairing code
         this.app.get('/api/qr-code', (req, res) => {
             this.log.debug('The frontend sent /api/qr-code');
-            const qrData = { qrPairingCode: this.matterbridgeContext.get('qrPairingCode') };
-            res.json(qrData);
+            if (this.bridgeMode === 'childbridge') {
+                this.log.debug('qrPairingCode for /api/qr-code not available in childbridge mode');
+                res.json({});
+                return;
+            }
+            try {
+                const qrData = { qrPairingCode: this.matterbridgeContext.get('qrPairingCode'), manualPairingCode: this.matterbridgeContext.get('manualPairingCode') };
+                res.json(qrData);
+            }
+            catch (error) {
+                this.log.error('qrPairingCode for /api/qr-code not found');
+                res.json({});
+            }
         });
         // Endpoint to provide system information
         this.app.get('/api/system-info', (req, res) => {
@@ -616,35 +1027,127 @@ export class Matterbridge extends EventEmitter {
         // Endpoint to provide plugins
         this.app.get('/api/plugins', (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
-            const data = [];
-            this.registeredPlugins.forEach((plugin) => {
-                data.push({ name: plugin.name, description: plugin.description, version: plugin.version, author: plugin.author, type: plugin.type });
-            });
-            res.json(data);
+            const baseRegisteredPlugins = this.getBaseRegisteredPlugin();
+            res.json(baseRegisteredPlugins);
         });
         // Endpoint to provide devices
         this.app.get('/api/devices', (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             const data = [];
-            this.registeredDevices.forEach((device) => {
-                let name = device.device.getClusterServer(BasicInformationCluster)?.getNodeLabelAttribute();
-                if (!name && device.device.getClusterServer(BridgedDeviceBasicInformationCluster)) {
-                    const bridgeInfo = device.device.getClusterServer(BridgedDeviceBasicInformationCluster);
-                    if (bridgeInfo && bridgeInfo.getNodeLabelAttribute)
-                        name = bridgeInfo.getNodeLabelAttribute();
+            this.registeredDevices.forEach((registeredDevice) => {
+                let name = registeredDevice.device.getClusterServer(BasicInformationCluster)?.attributes.nodeLabel?.getLocal();
+                if (!name)
+                    name = registeredDevice.device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.nodeLabel?.getLocal() ?? 'Unknown';
+                let serial = registeredDevice.device.getClusterServer(BasicInformationCluster)?.attributes.serialNumber?.getLocal();
+                if (!serial)
+                    serial = registeredDevice.device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.serialNumber?.getLocal() ?? 'Unknown';
+                let uniqueId = registeredDevice.device.getClusterServer(BasicInformationCluster)?.attributes.uniqueId?.getLocal();
+                if (!uniqueId)
+                    uniqueId = registeredDevice.device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.uniqueId?.getLocal() ?? 'Unknown';
+                const cluster = this.getClusterTextFromDevice(registeredDevice.device);
+                data.push({
+                    pluginName: registeredDevice.plugin,
+                    type: registeredDevice.device.name + ' (0x' + registeredDevice.device.deviceType.toString(16).padStart(4, '0') + ')',
+                    endpoint: registeredDevice.device.id,
+                    name,
+                    serial,
+                    uniqueId,
+                    cluster: cluster,
+                });
+            });
+            res.json(data);
+        });
+        // Endpoint to provide the cluster servers of the devices
+        this.app.get('/api/devices_clusters/:selectedPluginName', (req, res) => {
+            const selectedPluginName = req.params.selectedPluginName;
+            this.log.debug('The frontend sent /api/devices_clusters', selectedPluginName);
+            if (selectedPluginName === 'none') {
+                res.json([]);
+                return;
+            }
+            const data = [];
+            this.registeredDevices.forEach((registeredDevice) => {
+                if (registeredDevice.plugin === selectedPluginName) {
+                    const clusterServers = registeredDevice.device.getAllClusterServers();
+                    clusterServers.forEach((clusterServer) => {
+                        Object.entries(clusterServer.attributes).forEach(([key, value]) => {
+                            if (clusterServer.name === 'EveHistory')
+                                return;
+                            //this.log.debug(`***--clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute:${key}(${value.id}) ${value.isFixed} ${value.isWritable} ${value.isWritable}`);
+                            let attributeValue;
+                            try {
+                                if (typeof value.getLocal() === 'object')
+                                    attributeValue = stringify(value.getLocal());
+                                else
+                                    attributeValue = value.getLocal().toString();
+                            }
+                            catch (error) {
+                                attributeValue = 'Unavailable';
+                                this.log.debug(`****${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
+                                //console.log(error);
+                            }
+                            data.push({
+                                clusterName: clusterServer.name,
+                                clusterId: '0x' + clusterServer.id.toString(16).padStart(2, '0'),
+                                attributeName: key,
+                                attributeId: '0x' + value.id.toString(16).padStart(2, '0'),
+                                attributeValue,
+                            });
+                        });
+                    });
                 }
-                data.push({ pluginName: device.plugin, type: device.device.name, endpoint: device.device.id, name: name ?? 'Unknown', cluster: 'Unknown' });
             });
             res.json(data);
         });
         // Fallback for routing
         this.app.get('*', (req, res) => {
-            this.log.warn('The frontend sent *');
+            this.log.warn('The frontend sent *', req.url);
             res.sendFile(path.join(this.rootDirectory, 'frontend/build/index.html'));
         });
         this.app.listen(port, () => {
-            this.log.debug(`The frontend is running on ${UNDERLINE}http://localhost:${port}${rs}`);
+            this.log.info(`The frontend is running on ${UNDERLINE}http://localhost:${port}${rs}`);
+        });
+        this.log.debug(`Frontend initialized on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${rs}`);
+    }
+    /**
+     * Retrieves the cluster text from a given device.
+     * @param device - The MatterbridgeDevice object.
+     * @returns The attributes of the cluster servers in the device.
+     */
+    getClusterTextFromDevice(device) {
+        let attributes = '';
+        //this.log.debug(`getClusterTextFromDevice: ${device.name}`);
+        const clusterServers = device.getAllClusterServers();
+        clusterServers.forEach((clusterServer) => {
+            //this.log.debug(`***--clusterServer: ${clusterServer.id} (${clusterServer.name})`);
+            if (clusterServer.name === 'OnOff')
+                attributes += `OnOff: ${clusterServer.getOnOffAttribute()} `;
+            if (clusterServer.name === 'Switch')
+                attributes += `Position: ${clusterServer.getCurrentPositionAttribute()} `;
+            if (clusterServer.name === 'WindowCovering')
+                attributes += `Cover position: ${clusterServer.attributes.currentPositionLiftPercent100ths.getLocal() / 100}% `;
+            if (clusterServer.name === 'LevelControl')
+                attributes += `Level: ${clusterServer.getCurrentLevelAttribute()}% `;
+            if (clusterServer.name === 'ColorControl')
+                attributes += `Hue: ${clusterServer.getCurrentHueAttribute()} Saturation: ${clusterServer.getCurrentSaturationAttribute()}% `;
+            if (clusterServer.name === 'BooleanState')
+                attributes += `Contact: ${clusterServer.getStateValueAttribute()} `;
+            if (clusterServer.name === 'OccupancySensing')
+                attributes += `Occupancy: ${clusterServer.getOccupancyAttribute().occupied} `;
+            if (clusterServer.name === 'IlluminanceMeasurement')
+                attributes += `Illuminance: ${clusterServer.getMeasuredValueAttribute()} `;
+            if (clusterServer.name === 'AirQuality')
+                attributes += `Air quality: ${clusterServer.getAirQualityAttribute()} `;
+            if (clusterServer.name === 'TvocMeasurement')
+                attributes += `Voc: ${clusterServer.getMeasuredValueAttribute()} `;
+            if (clusterServer.name === 'TemperatureMeasurement')
+                attributes += `Temperature: ${clusterServer.getMeasuredValueAttribute() / 100}°C `;
+            if (clusterServer.name === 'RelativeHumidityMeasurement')
+                attributes += `Humidity: ${clusterServer.getMeasuredValueAttribute() / 100}% `;
+            if (clusterServer.name === 'PressureMeasurement')
+                attributes += `Pressure: ${clusterServer.getMeasuredValueAttribute()} `;
         });
+        return attributes;
     }
 }
 /*