matterbridge 1.1.4 → 1.1.5

package/dist/matterbridge.js

@@ -20,8 +20,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License. *
  */
+import { MatterbridgeDevice } from './matterbridgeDevice.js';
 import { NodeStorageManager } from 'node-persist-manager';
-import { AnsiLogger, BRIGHT, GREEN, RESET, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, stringify, er, nf, rs, wr } from 'node-ansi-logger';
+import { AnsiLogger, BRIGHT, 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 express from 'express';
@@ -38,6 +39,7 @@ import { requireMinNodeVersion, getParameter, getIntParameter, hasParameter } fr
 import { CryptoNode } from '@project-chip/matter-node.js/crypto';
 const plg = '\u001B[38;5;33m';
 const dev = '\u001B[38;5;79m';
+const typ = '\u001B[38;5;207m';
 /**
  * Represents the Matterbridge application.
  */
@@ -55,16 +57,18 @@ export class Matterbridge {
         freeMemory: '',
         systemUptime: '',
     };
-    homeDirectory;
-    rootDirectory;
-    matterbridgeDirectory;
+    homeDirectory = '';
+    rootDirectory = '';
+    matterbridgeDirectory = '';
+    matterbridgeVersion = '';
     bridgeMode = '';
+    debugEnabled = false;
     log;
     hasCleanupStarted = false;
     registeredPlugins = [];
     registeredDevices = [];
-    nodeStorage = undefined;
-    nodeContext = undefined;
+    nodeStorage;
+    nodeContext;
     app;
     storageManager;
     matterbridgeContext;
@@ -79,7 +83,7 @@ export class Matterbridge {
     }
     /**
      * Loads an instance of the Matterbridge class.
-     * If an instance already exists, an error will be thrown.
+     * If an instance already exists, return that instance.
      * @returns The loaded instance of the Matterbridge class.
      */
     static async loadInstance(cli = false) {
@@ -118,6 +122,7 @@ export class Matterbridge {
       - bridge:                start Matterbridge in bridge mode
       - childbridge:           start Matterbridge in childbridge mode
       - frontend [port]:       start the frontend on the given port (default 3000)
+      - debug:                 enable debug mode (default false)
       - list:                  list the registered plugins
       - add [plugin path]:     register the plugin
       - remove [plugin path]:  remove the plugin
@@ -126,29 +131,38 @@ export class Matterbridge {
             process.exit(0);
         }
         // set Matterbridge logger
-        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */ });
-        this.log.info('Matterbridge is running...');
+        if (hasParameter('debug'))
+            this.debugEnabled = true;
+        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled });
+        this.log.debug('Matterbridge is starting...');
         // log system info and create .matterbridge directory
         await this.logNodeAndSystemInfo();
+        this.log.info(
+        // eslint-disable-next-line max-len
+        `Matterbridge version ${this.matterbridgeVersion} mode ${hasParameter('bridge') ? 'bridge' : ''}${hasParameter('childbridge') ? 'childbridge' : ''} running on ${this.systemInformation.osType} ${this.systemInformation.osRelease} ${this.systemInformation.osPlatform} ${this.systemInformation.osArch}`);
         // check node version and throw error
         requireMinNodeVersion(18);
         // register SIGINT SIGTERM signal handlers
         this.registerSignalHandlers();
         // set matter.js logger level and format
-        Logger.defaultLogLevel = Level.DEBUG;
+        Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
         Logger.format = Format.ANSI;
         // Initialize NodeStorage
         this.log.debug('Creating node storage manager');
-        this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, 'storage') });
+        this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, 'storage'), logging: false });
         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);
-        });
-        */
+        for (const plugin of this.registeredPlugins) {
+            this.log.debug(`Creating node storage context for plugin ${plugin.name}`);
+            plugin.nodeContext = await this.nodeStorage?.createStorage(plugin.name);
+            await plugin.nodeContext?.set('name', plugin.name);
+            await plugin.nodeContext?.set('type', plugin.type);
+            await plugin.nodeContext?.set('path', plugin.path);
+            await plugin.nodeContext?.set('version', plugin.version);
+            await plugin.nodeContext?.set('description', plugin.description);
+            await plugin.nodeContext?.set('author', plugin.author);
+        }
         // Parse command line
         this.parseCommandLine();
     }
@@ -161,30 +175,28 @@ export class Matterbridge {
         if (hasParameter('list')) {
             this.log.info('Registered plugins:');
             this.registeredPlugins.forEach((plugin) => {
-                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}
+                this.log.info(`- ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} ${YELLOW}${plugin.enabled ? 'enabled' : 'disabled'}${nf}`);
             });
             process.exit(0);
         }
         if (getParameter('add')) {
             this.log.debug(`Registering plugin ${getParameter('add')}`);
-            await this.loadPlugin(getParameter('add'), 'add');
+            await this.executeCommandLine(getParameter('add'), 'add');
             process.exit(0);
         }
         if (getParameter('remove')) {
             this.log.debug(`Unregistering plugin ${getParameter('remove')}`);
-            await this.loadPlugin(getParameter('remove'), 'remove');
+            await this.executeCommandLine(getParameter('remove'), 'remove');
             process.exit(0);
         }
         if (getParameter('enable')) {
             this.log.debug(`Enable plugin ${getParameter('enable')}`);
-            await this.loadPlugin(getParameter('enable'), 'enable');
+            await this.executeCommandLine(getParameter('enable'), 'enable');
             process.exit(0);
         }
         if (getParameter('disable')) {
             this.log.debug(`Disable plugin ${getParameter('disable')}`);
-            await this.loadPlugin(getParameter('disable'), 'disable');
+            await this.executeCommandLine(getParameter('disable'), 'disable');
             process.exit(0);
         }
         // Start the storage (we need it now for frontend and later for matterbridge)
@@ -193,128 +205,96 @@ export class Matterbridge {
         this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
         // Initialize frontend
         await this.initializeFrontend(getIntParameter('frontend'));
-        if (hasParameter('childbridge')) {
+        if (hasParameter('test')) {
             this.bridgeMode = 'childbridge';
-            this.registeredPlugins.forEach(async (plugin) => {
-                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();
+            MatterbridgeDevice.bridgeMode = 'childbridge';
+            this.testStartMatterBridge(); // No await do it asyncronously
         }
         if (hasParameter('bridge')) {
             this.bridgeMode = 'bridge';
-            this.registeredPlugins.forEach(async (plugin) => {
+            MatterbridgeDevice.bridgeMode = 'bridge';
+            for (const plugin of this.registeredPlugins) {
                 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');
-            });
+                    continue;
+                this.loadPlugin(plugin); // No await do it asyncronously
+            }
+            await this.startMatterBridge();
+        }
+        if (hasParameter('childbridge')) {
+            this.bridgeMode = 'childbridge';
+            MatterbridgeDevice.bridgeMode = 'childbridge';
+            for (const plugin of this.registeredPlugins) {
+                if (!plugin.enabled)
+                    continue;
+                this.loadPlugin(plugin); // No await do it asyncronously
+            }
             await this.startMatterBridge();
         }
     }
     /**
      * 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'.
+     * @param mode - The mode of operation. Possible values are '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') {
+    async executeCommandLine(packageJsonPath, mode) {
         if (!packageJsonPath.endsWith('package.json'))
             packageJsonPath = path.join(packageJsonPath, 'package.json');
+        // Resolve the package.json of the plugin
         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 ${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 (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 ${plg}${plugin?.name}${nf} type ${GREEN}${platform.type}${nf} loaded (entrypoint ${UNDERLINE}${pluginPath}${UNDERLINEOFF})`);
-                    // Update plugin info
-                    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;
+            if (mode === 'add') {
+                if (!this.registeredPlugins.find((plugin) => plugin.name === packageJson.name)) {
+                    const plugin = { path: packageJsonPath, type: '', name: packageJson.name, version: packageJson.version, description: packageJson.description, author: packageJson.author, enabled: true };
+                    if (await this.loadPlugin(plugin)) {
+                        this.registeredPlugins.push(plugin);
+                        await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
+                        this.log.info(`Plugin ${plg}${packageJsonPath}${nf} type ${plugin.type} added to matterbridge`);
                     }
                     else {
-                        this.log.error(`Plugin ${plg}${packageJson.name}${er} not found`);
+                        this.log.error(`Plugin ${plg}${packageJsonPath}${wr} not added to matterbridge error`);
                     }
                 }
-                else if (mode === 'add') {
-                    if (!this.registeredPlugins.find((plugin) => plugin.name === packageJson.name)) {
-                        this.registeredPlugins.push({
-                            path: packageJsonPath,
-                            type: platform.type,
-                            name: packageJson.name,
-                            version: packageJson.version,
-                            description: packageJson.description,
-                            author: packageJson.author,
-                            enabled: true,
-                        });
-                        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 ${plg}${packageJsonPath}${wr} already added to matterbridge`);
-                    }
+                else {
+                    this.log.warn(`Plugin ${plg}${packageJsonPath}${wr} already added to matterbridge`);
                 }
-                else if (mode === 'remove') {
-                    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 ${plg}${packageJsonPath}${wr} not registerd in matterbridge`);
-                    }
+            }
+            else if (mode === 'remove') {
+                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.getBaseRegisteredPlugins());
+                    this.log.info(`Plugin ${plg}${packageJsonPath}${nf} removed from matterbridge`);
                 }
-                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 {
+                    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 if (mode === 'enable') {
+                const plugin = this.registeredPlugins.find((registeredPlugin) => registeredPlugin.name === packageJson.name);
+                if (plugin) {
+                    plugin.enabled = true;
+                    await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
+                    this.log.info(`Plugin ${plg}${packageJsonPath}${nf} enabled`);
                 }
                 else {
-                    this.log.error(`Plugin at ${plg}${pluginPath}${er} does not provide a default export`);
+                    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.getBaseRegisteredPlugins());
+                    this.log.info(`Plugin ${plg}${packageJsonPath}${nf} disabled`);
+                }
+                else {
+                    this.log.warn(`Plugin ${plg}${packageJsonPath}${wr} not registerd in matterbridge`);
+                }
+            }
+            //}
         }
         catch (err) {
             this.log.error(`Failed to load plugin from ${plg}${packageJsonPath}${er}: ${err}`);
@@ -339,13 +319,12 @@ export class Matterbridge {
     async cleanup(message) {
         if (!this.hasCleanupStarted) {
             this.hasCleanupStarted = true;
-            this.log.debug(message);
+            this.log.info(message);
             // Callint the shutdown functions with a reason
-            this.registeredPlugins.forEach((plugin) => {
-                if (plugin.platform) {
-                    plugin.platform.onShutdown('Matterbridge is closing: ' + message);
-                }
-            });
+            for (const plugin of this.registeredPlugins) {
+                if (plugin.platform)
+                    await plugin.platform.onShutdown('Matterbridge is closing: ' + message);
+            }
             // Set reachability to false
             /*
             this.log.debug(`*Changing reachability to false for ${this.registeredDevices.length} devices (${this.bridgeMode} mode):`);
@@ -368,10 +347,15 @@ export class Matterbridge {
                 await this.stopMatter();
                 // Closing storage
                 await this.stopStorage();
-                //await this.context?.set<RegisteredDevice[]>('plugins', this.registeredDevices);
-                this.log.debug('Cleanup completed.');
+                const serializedRegisteredDevices = [];
+                this.registeredDevices.forEach((registeredDevice) => {
+                    serializedRegisteredDevices.push(registeredDevice.device.serialize(registeredDevice.plugin));
+                });
+                //console.log('serializedRegisteredDevices:', serializedRegisteredDevices);
+                await this.nodeContext?.set('devices', serializedRegisteredDevices);
+                this.log.info('Cleanup completed.');
                 process.exit(0);
-            }, 2 * 1000);
+            }, 3 * 1000);
         }
     }
     /**
@@ -392,6 +376,7 @@ export class Matterbridge {
      * Adds a device to the Matterbridge.
      * @param pluginName - The name of the plugin.
      * @param device - The device to be added.
+     * @returns A Promise that resolves when the device is added successfully.
      */
     async addDevice(pluginName, device) {
         this.log.info(`Adding device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
@@ -403,20 +388,19 @@ export class Matterbridge {
         }
         // 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 device ${dev}${device.name}${nf} plugin ${plg}${pluginName}${nf}`);
-                return;
-            }
-            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, added: true });
-            this.log.info(`Added and registered device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
+            if (plugin.registeredDevices !== undefined)
+                plugin.registeredDevices++;
+            if (plugin.addedDevices !== undefined)
+                plugin.addedDevices++;
+            this.log.info(`Added and registered device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
         }
         // Only register the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
             this.registeredDevices.push({ plugin: pluginName, device, added: false });
+            if (plugin.registeredDevices !== undefined)
+                plugin.registeredDevices++;
             this.log.info(`Registered device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
         }
     }
@@ -424,6 +408,7 @@ export class Matterbridge {
      * Adds a bridged device to the Matterbridge.
      * @param pluginName - The name of the plugin.
      * @param device - The bridged device to add.
+     * @returns {Promise<void>} - A promise that resolves when the storage process is started.
      */
     async addBridgedDevice(pluginName, device) {
         this.log.info(`Adding bridged device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
@@ -437,14 +422,18 @@ export class Matterbridge {
         if (this.bridgeMode === 'bridge') {
             this.matterAggregator.addBridgedDevice(device);
             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}`);
+            if (plugin.registeredDevices !== undefined)
+                plugin.registeredDevices++;
+            if (plugin.addedDevices !== undefined)
+                plugin.addedDevices++;
+            this.log.info(`Added and registered bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
         }
         // Only register the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
             this.registeredDevices.push({ plugin: pluginName, device, added: false });
+            if (plugin.registeredDevices !== undefined)
+                plugin.registeredDevices++;
             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));
         }
     }
     /**
@@ -513,6 +502,144 @@ export class Matterbridge {
         await this.storageManager.close();
         this.log.debug('Storage closed');
     }
+    async testStartMatterBridge() {
+        for (const plugin of this.registeredPlugins) {
+            if (!plugin.enabled)
+                continue;
+            // No await do it asyncronously
+            this.loadPlugin(plugin)
+                .then(() => {
+                // No await do it asyncronously
+                this.startPlugin(plugin)
+                    .then(() => { })
+                    .catch((err) => {
+                    this.log.error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`);
+                });
+            })
+                .catch((err) => {
+                this.log.error(`Failed to load plugin ${plg}${plugin.name}${er}: ${err}`);
+            });
+        }
+        for (const plugin of this.registeredPlugins) {
+            if (!plugin.enabled)
+                continue;
+            // Start the interval to check if the plugin is loaded and started
+            let times = 0;
+            const interval = setInterval(() => {
+                times++;
+                this.log.info(`Waiting ${times} secs for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) and send devices ...`);
+                if (!plugin.loaded || !plugin.started)
+                    return;
+                this.log.info(`Plugin ${plg}${plugin.name}${db} sent ${plugin.registeredDevices} devices`);
+                clearInterval(interval);
+            }, 1000);
+        }
+    }
+    async startPlugin(plugin, message, configure = false) {
+        if (!plugin.loaded || !plugin.platform) {
+            this.log.error(`Plugin ${plg}${plugin.name}${er} not loaded or no platform`);
+            return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} not loaded or no platform`));
+        }
+        if (plugin.started) {
+            this.log.error(`Plugin ${plg}${plugin.name}${er} already started`);
+            return Promise.resolve();
+        }
+        this.log.info(`Starting plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
+        try {
+            plugin.platform
+                .onStart(message)
+                .then(() => {
+                plugin.started = true;
+                this.log.info(`Started plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
+                if (configure)
+                    this.configurePlugin(plugin); // No await do it asyncronously
+                return Promise.resolve();
+            })
+                .catch((err) => {
+                this.log.error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`);
+                return Promise.reject(new Error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`));
+            });
+        }
+        catch (err) {
+            this.log.error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`);
+            return Promise.reject(new Error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`));
+        }
+    }
+    async configurePlugin(plugin) {
+        if (!plugin.loaded || !plugin.started || !plugin.platform) {
+            this.log.error(`Plugin ${plg}${plugin.name}${er} not loaded or not started or not platform`);
+            return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} not loaded or not started or not platform`));
+        }
+        if (plugin.configured) {
+            this.log.error(`Plugin ${plg}${plugin.name}${er} already configured`);
+            return Promise.resolve();
+        }
+        this.log.info(`Configuring plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
+        try {
+            plugin.platform
+                .onConfigure()
+                .then(() => {
+                plugin.configured = true;
+                this.log.info(`Configured plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
+                return Promise.resolve();
+            })
+                .catch((err) => {
+                this.log.error(`Failed to configure plugin ${plg}${plugin.name}${er}: ${err}`);
+                return Promise.reject(new Error(`Failed to configure plugin ${plg}${plugin.name}${er}: ${err}`));
+            });
+        }
+        catch (err) {
+            this.log.error(`Failed to configure plugin ${plg}${plugin.name}${er}: ${err}`);
+            return Promise.reject(new Error(`Failed to configure plugin ${plg}${plugin.name}${er}: ${err}`));
+        }
+    }
+    async loadPlugin(plugin) {
+        if (!plugin.enabled) {
+            this.log.error(`Plugin ${plg}${plugin.name}${er} not enabled`);
+            return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} not enabled`));
+        }
+        if (plugin.platform) {
+            this.log.error(`Plugin ${plg}${plugin.name}${er} already loaded`);
+            return Promise.resolve(plugin.platform);
+        }
+        this.log.info(`Loading plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
+        try {
+            // Load the package.json of the plugin
+            const packageJson = JSON.parse(await fs.readFile(plugin.path, 'utf8'));
+            // Resolve the main module path relative to package.json
+            const pluginEntry = path.resolve(path.dirname(plugin.path), packageJson.main);
+            // Dynamically import the plugin
+            const pluginUrl = pathToFileURL(pluginEntry);
+            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 (pluginInstance.default) {
+                const platform = pluginInstance.default(this, new AnsiLogger({ logName: plugin.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled }));
+                platform.name = packageJson.name;
+                plugin.name = packageJson.name;
+                plugin.description = packageJson.description;
+                plugin.version = packageJson.version;
+                plugin.author = packageJson.author;
+                plugin.type = platform.type;
+                plugin.platform = platform;
+                plugin.loaded = true;
+                plugin.registeredDevices = 0;
+                plugin.addedDevices = 0;
+                await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
+                this.log.info(`Loaded plugin ${plg}${plugin.name}${db} type ${typ}${platform.type}${db} (entrypoint ${UNDERLINE}${pluginEntry}${UNDERLINEOFF})`);
+                return Promise.resolve(platform);
+            }
+            else {
+                this.log.error(`Plugin ${plg}${plugin.name}${er} does not provide a default export`);
+                return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} does not provide a default export`));
+            }
+        }
+        catch (err) {
+            this.log.error(`Failed to load plugin ${plg}${plugin.name}${er}: ${err}`);
+            return Promise.reject(new Error(`Failed to load plugin ${plg}${plugin.name}${er}: ${err}`));
+        }
+    }
     /**
      * Starts the Matterbridge based on the bridge mode.
      * If the bridge mode is 'bridge', it creates a commissioning server, matter aggregator,
@@ -527,7 +654,7 @@ export class Matterbridge {
         this.createMatterServer(this.storageManager);
         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
+            // Plugins are started and configured by callback when Matterbridge is commissioned and plugin.started is set to true
             this.log.debug(`Creating commissioning server context for ${plg}Matterbridge${db}`);
             this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
             this.log.debug(`Creating commissioning server for ${plg}Matterbridge${db}`);
@@ -540,10 +667,6 @@ export class Matterbridge {
             await this.matterServer.addCommissioningServer(this.commissioningServer, { uniqueStorageKey: 'Matterbridge' });
             this.log.debug('Starting matter server');
             await this.startMatterServer();
-            this.registeredPlugins.forEach(async (plugin) => {
-                if (plugin.platform)
-                    await plugin.platform.onMatterStarted();
-            });
             this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, 'Matterbridge');
         }
         if (this.bridgeMode === 'childbridge') {
@@ -554,26 +677,13 @@ export class Matterbridge {
             this.registeredPlugins.forEach(async (plugin) => {
                 if (!plugin.enabled)
                     return;
-                // Start the interval to check if the plugin is loaded
-                const loadedInterval = setInterval(async () => {
-                    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;
-                    plugin.started = true;
-                    plugin.registeredDevices = 0;
-                    clearInterval(loadedInterval);
-                }, 1000);
                 // Start the interval to check if the plugins is started
-                const startedInterval = setInterval(async () => {
-                    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)
+                const startInterval = setInterval(async () => {
+                    this.log.debug(`Waiting in start interval for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) and send devices ...`);
+                    if (!plugin.loaded)
                         return;
                     if (plugin.type === 'AccessoryPlatform') {
-                        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}`);
+                        await this.startPlugin(plugin, 'Matterbridge Accessory platform has started');
                         this.registeredDevices.forEach(async (registeredDevice) => {
                             if (registeredDevice.plugin === plugin.name) {
                                 plugin.storageContext = this.importCommissioningServerContext(plugin.name, registeredDevice.device); // Generate serialNumber and uniqueId
@@ -595,17 +705,13 @@ export class Matterbridge {
                         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}`);
+                        await this.startPlugin(plugin, 'Matterbridge Dynamic platform has started');
                         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);
+                    clearInterval(startInterval);
                 }, 1000);
             });
             // Start the interval to check if all plugins are loaded and started and so start the matter server
@@ -635,20 +741,18 @@ export class Matterbridge {
                         }
                     });
                 });
-                this.log.debug('Starting matter server');
                 await this.startMatterServer();
-                this.registeredPlugins.forEach(async (plugin) => {
-                    if (plugin.platform)
-                        await plugin.platform.onMatterStarted();
+                for (const plugin of this.registeredPlugins) {
                     this.showCommissioningQRCode(plugin.commissioningServer, plugin.storageContext, plugin.name);
-                });
-                Logger.defaultLogLevel = Level.DEBUG;
+                }
+                Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
                 clearInterval(startMatterInterval);
             }, 1000);
             return;
         }
     }
     async startMatterServer() {
+        this.log.debug('Starting matter server');
         await this.matterServer.start();
         this.log.debug('Started matter server');
     }
@@ -794,14 +898,18 @@ export class Matterbridge {
             },
             activeSessionsChangedCallback: (fabricIndex) => {
                 const info = commissioningServer.getActiveSessionInformation(fabricIndex);
-                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 ${plg}${name}${nf} ready to start...`);
+                let connected = false;
+                info.forEach((session) => {
+                    this.log.debug(`***Active session changed on fabric ${fabricIndex} ${session.fabric?.rootVendorId}/${session.fabric?.label} for ${plg}${name}${nf}`, debugStringify(session));
+                    if (session.isPeerActive === true && session.secure === true && session.numberOfActiveSubscriptions >= 1) {
+                        this.log.info(`***Controller ${session.fabric?.rootVendorId}/${session.fabric?.label} connected to ${plg}${name}${nf}`);
+                        connected = true;
+                    }
+                });
+                if (connected) {
                     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;
                         }
@@ -809,45 +917,40 @@ export class Matterbridge {
                     setTimeout(() => {
                         if (this.bridgeMode === 'bridge') {
                             //Logger.defaultLogLevel = Level.INFO;
-                            this.registeredPlugins.forEach(async (plugin) => {
+                            for (const plugin of this.registeredPlugins) {
                                 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;
+                                    continue;
+                                this.startPlugin(plugin, 'Matterbridge is commissioned and controllers are connected', true); // No await do it asyncronously
+                                //this.configurePlugin(plugin); // No await do it asyncronously
+                            }
+                            Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
                         }
                         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;
+                            if (plugin && plugin.type === 'DynamicPlatform') {
+                                for (const registeredDevice of this.registeredDevices) {
+                                    if (registeredDevice.plugin === name) {
+                                        this.log.info(`Adding bridged device ${dev}${registeredDevice.device.name}${nf} to aggregator for plugin ${plg}${plugin.name}${db}`);
+                                        if (!plugin.aggregator) {
+                                            this.log.error(`****Aggregator not found for plugin ${plg}${plugin.name}${er}`);
+                                            continue;
+                                        }
+                                        plugin.aggregator.addBridgedDevice(registeredDevice.device);
+                                        if (plugin.addedDevices !== undefined)
+                                            plugin.addedDevices++;
+                                        this.log.info(`Added bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${registeredDevice.device.name}${nf} for plugin ${plg}${plugin.name}${nf}`);
+                                        registeredDevice.added = true;
+                                    }
                                 }
-                                plugin.aggregator.addBridgedDevice(registeredDevice.device);
-                                if (plugin.registeredDevices !== undefined)
-                                    plugin.registeredDevices++;
-                                registeredDevice.added = true;
-                            });
-                            Logger.defaultLogLevel = Level.DEBUG;
+                            }
+                            for (const plugin of this.registeredPlugins) {
+                                if (plugin.name === name && plugin.platform) {
+                                    this.configurePlugin(plugin); // No await do it asyncronously
+                                }
+                            }
+                            Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
                         }
-                        this.registeredPlugins.forEach(async (plugin) => {
-                            if (plugin.name === name && plugin.platform)
-                                plugin.platform.onConfigure();
-                        });
                         //logEndpoint(commissioningServer.getRootEndpoint());
                     }, 2000);
                 }
@@ -987,6 +1090,10 @@ export class Matterbridge {
             await fs.mkdir(this.matterbridgeDirectory);
         }
         this.log.debug(`Matterbridge Directory: ${this.matterbridgeDirectory}`);
+        // Matterbridge version
+        const packageJson = JSON.parse(await fs.readFile(path.join(this.rootDirectory, 'package.json'), 'utf-8'));
+        this.matterbridgeVersion = packageJson.version;
+        this.log.debug(`Matterbridge Version: ${this.matterbridgeVersion}`);
         // Current working directory
         const currentDir = process.cwd();
         this.log.debug(`Current Working Directory: ${currentDir}`);
@@ -994,7 +1101,24 @@ export class Matterbridge {
         const cmdArgs = process.argv.slice(2).join(' ');
         this.log.debug(`Command Line Arguments: ${cmdArgs}`);
     }
-    getBaseRegisteredPlugin() {
+    getBaseRegisteredPlugins() {
+        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;
+    }
+    getBaseRegisteredDevices() {
         const baseRegisteredPlugins = this.registeredPlugins.map((plugin) => ({
             path: plugin.path,
             type: plugin.type,
@@ -1044,8 +1168,7 @@ export class Matterbridge {
         // Endpoint to provide plugins
         this.app.get('/api/plugins', (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
-            const baseRegisteredPlugins = this.getBaseRegisteredPlugin();
-            res.json(baseRegisteredPlugins);
+            res.json(this.getBaseRegisteredPlugins());
         });
         // Endpoint to provide devices
         this.app.get('/api/devices', (req, res) => {
@@ -1077,15 +1200,15 @@ export class Matterbridge {
         // Endpoint to provide the cluster servers of the devices
         this.app.get('/api/devices_clusters/:selectedPluginName/:selectedDeviceEndpoint', (req, res) => {
             const selectedPluginName = req.params.selectedPluginName;
-            const selectedDeviceEndpoint = req.params.selectedDeviceEndpoint;
+            const selectedDeviceEndpoint = parseInt(req.params.selectedDeviceEndpoint, 10);
             this.log.debug(`The frontend sent /api/devices_clusters plugin:${selectedPluginName} endpoint:${selectedDeviceEndpoint}`);
-            if (selectedPluginName === 'none' /* || selectedDeviceEndpoint === 'none'*/) {
+            if (selectedPluginName === 'none') {
                 res.json([]);
                 return;
             }
             const data = [];
             this.registeredDevices.forEach((registeredDevice) => {
-                if (registeredDevice.plugin === selectedPluginName) {
+                if (registeredDevice.plugin === selectedPluginName && registeredDevice.device.id === selectedDeviceEndpoint) {
                     const clusterServers = registeredDevice.device.getAllClusterServers();
                     clusterServers.forEach((clusterServer) => {
                         Object.entries(clusterServer.attributes).forEach(([key, value]) => {
@@ -1189,6 +1312,13 @@ ws.onmessage = (event) => {
   console.log(`Received message => ${event.data}`);
 };
 
+*/
+/*
+// In Matterbridge
+global.matterbridgeInstance = Matterbridge.loadInstance();
+
+// In plugins
+const matterbridge = global.matterbridgeInstance;
 */
 /*
 npx create-react-app matterbridge-frontend