matterbridge 1.2.22 → 1.3.1

package/dist/matterbridgeV8.js

@@ -32,36 +32,48 @@ import { DeviceTypeId, FabricIndex, VendorId } from '@project-chip/matter-node.j
 import { Format, Level, Logger, createFileLogger } from '@project-chip/matter-node.js/log';
 import { Environment, StorageService } from '@project-chip/matter.js/environment';
 import { ServerNode } from '@project-chip/matter.js/node';
-import { logEndpoint } from '@project-chip/matter-node.js/device';
+import { DeviceTypes } from '@project-chip/matter-node.js/device';
 import { QrCode } from '@project-chip/matter-node.js/schema';
 import { FabricAction } from '@project-chip/matter-node.js/fabric';
-import { Endpoint, EndpointServer } from '@project-chip/matter.js/endpoint';
+import { Endpoint } from '@project-chip/matter.js/endpoint';
 import { AggregatorEndpoint } from '@project-chip/matter.js/endpoints/AggregatorEndpoint';
-import { IdentifyServer } from '@project-chip/matter.js/behavior/definitions/identify';
-import { OnOffServer } from '@project-chip/matter.js/behavior/definitions/on-off';
-import { GroupsServer } from '@project-chip/matter.js/behavior/definitions/groups';
-import { ScenesServer } from '@project-chip/matter.js/behavior/definitions/scenes';
 import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behavior/definitions/bridged-device-basic-information';
+import { SwitchServer } from '@project-chip/matter.js/behavior/definitions/switch';
 import { OnOffLightDevice } from '@project-chip/matter.js/devices/OnOffLightDevice';
-import { MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
-import { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
+import { GenericSwitchDevice } from '@project-chip/matter.js/devices/GenericSwitchDevice';
+import { AnsiLogger, UNDERLINE, UNDERLINEOFF, db, er, nf } from 'node-ansi-logger';
+import { NodeStorageManager } from 'node-persist-manager';
 import EventEmitter from 'events';
 import path from 'path';
 import { promises as fs } from 'fs';
+import { MatterbridgeDeviceV8 } from './matterbridgeDeviceV8.js';
+import { pathToFileURL } from 'url';
+import { shelly_config, somfytahoma_config, zigbee2mqtt_config } from './defaultConfigSchema.js';
+const plg = '\u001B[38;5;33m';
+const dev = '\u001B[38;5;79m';
+const typ = '\u001B[38;5;207m';
+const log = Logger.get('Matterbridge');
 /**
  * Represents the Matterbridge application.
  */
 export class MatterbridgeV8 extends EventEmitter {
     environment = Environment.default;
-    matterbridgeVersion = '2.0.0';
-    osVersion = '10.0.22631';
+    matterbridgeVersion = '';
+    osVersion = '';
     matterbridgeDirectory = '';
     matterbridgePluginDirectory = '';
     globalModulesDirectory = '';
+    matterbridgeLogFile = '';
+    registeredPlugins = [];
+    // Node storage
+    nodeStorage;
+    nodeContext;
+    // Matter storage
     matterStorageService;
     matterStorageManager;
     matterStorageContext;
     matterServerNode;
+    matterAggregator;
     matterLogger;
     constructor() {
         super();
@@ -72,13 +84,36 @@ export class MatterbridgeV8 extends EventEmitter {
         return matterbridge;
     }
     async initialize() {
-        this.matterLogger = Logger.get('Matterbridge');
+        // Set up the temporary Matterbridge environment
+        this.matterbridgeVersion = '2.0.0';
+        this.osVersion = '10.0.22631';
         this.matterbridgeDirectory = 'C:\\Users\\lligu\\.matterbridge';
         this.matterbridgePluginDirectory = 'C:\\Users\\lligu\\Matterbridge';
-        await this.deleteMatterLogfile('matterbridge.log');
+        this.globalModulesDirectory = 'C:\\Users\\lligu\\AppData\\Roaming\\npm\\node_modules';
+        this.matterbridgeLogFile = 'matterbridge.log';
+        this.matterLogger = Logger.get('Matterbridge');
+        await this.deleteMatterLogfile(this.matterbridgeLogFile);
+        await this.setupMatterFileLogger(this.matterbridgeLogFile);
+        this.matterLogger?.notice(`Starting Matterbridge v${this.matterbridgeVersion} on Node.js ${process.version} (${process.platform} ${process.arch})`);
         this.setupMatterVars(Level.DEBUG, Format.ANSI);
         await this.setupMatterStorage();
-        await this.setupMatterFileLogger('matterbridge.log');
+        await this.setupNodeStorage();
+        // Get the plugins from node storage
+        if (!this.nodeStorage)
+            throw new Error('No node storage initialized');
+        if (!this.nodeContext)
+            throw new Error('No node storage context initialized');
+        this.registeredPlugins = await this.nodeContext.get('plugins', []);
+        for (const plugin of this.registeredPlugins) {
+            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);
+            this.matterLogger?.notice(`Created node storage context for plugin ${plugin.name}`);
+        }
     }
     setupMatterVars(level, format) {
         this.environment.vars.set('log.level', level);
@@ -91,16 +126,22 @@ export class MatterbridgeV8 extends EventEmitter {
         this.matterStorageService = this.environment.get(StorageService);
         this.matterLogger?.notice(`Storage service created: ${this.matterStorageService.location}`);
         this.matterStorageManager = await this.matterStorageService.open('Matterbridge');
-        this.matterLogger?.notice('Storage manager created');
+        this.matterLogger?.notice('Storage manager "Matterbridge" created');
         this.matterStorageContext = this.matterStorageManager.createContext('persist');
-        this.matterLogger?.notice('Storage context created');
+        this.matterLogger?.notice('Storage context "Matterbridge.persist" created');
+    }
+    async setupNodeStorage() {
+        this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, 'storage'), logging: false });
+        this.matterLogger?.notice(`Created node storage manager: ${path.join(this.matterbridgeDirectory, 'storage')}`);
+        this.nodeContext = await this.nodeStorage.createStorage('matterbridge');
+        this.matterLogger?.notice('Created node storage context "matterbridge"');
     }
     async deleteMatterLogfile(filename) {
         try {
             await fs.unlink(path.join(this.matterbridgeDirectory, filename));
         }
         catch (err) {
-            console.error(`Error deleting old log file: ${err}`);
+            this.matterLogger?.error(`Error deleting old log file: ${err}`);
         }
     }
     async setupMatterFileLogger(filename) {
@@ -110,11 +151,11 @@ export class MatterbridgeV8 extends EventEmitter {
         this.matterLogger?.notice('File logger created: ' + path.join(this.matterbridgeDirectory, filename));
     }
     /**
-     * Creates a commissioning server storage context.
+     * Creates a server node storage context.
      *
      * @param pluginName - The name of the plugin.
      * @param deviceName - The name of the device.
-     * @param deviceType - The type of the device.
+     * @param deviceType - The deviceType of the device.
      * @param vendorId - The vendor ID.
      * @param vendorName - The vendor name.
      * @param productId - The product ID.
@@ -127,17 +168,16 @@ export class MatterbridgeV8 extends EventEmitter {
      * @param hardwareVersionString - The hardware version string of the device (optional).
      * @returns The storage context for the commissioning server.
      */
-    async createServerNodeContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName) {
+    async createServerNodeContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber) {
         if (!this.matterLogger)
-            return;
+            throw new Error('No logger initialized');
         const log = this.matterLogger;
-        if (!this.matterStorageService || !this.matterStorageManager) {
-            log.error('No storage manager initialized');
-            return;
-        }
-        log.debug(`Creating commissioning server storage context for ${pluginName}...`);
-        const storageContext = this.matterStorageManager.createContext('persist');
-        const random = 'AG' + CryptoNode.getRandomData(8).toHex();
+        if (!this.matterStorageService)
+            throw new Error('No storage service initialized');
+        log.notice(`Creating server node storage context "${pluginName}.persist" for ${pluginName}...`);
+        const storageManager = await this.matterStorageService.open(pluginName);
+        const storageContext = storageManager.createContext('persist');
+        const random = 'SN' + CryptoNode.getRandomData(8).toHex();
         await storageContext.set('storeId', pluginName);
         await storageContext.set('deviceName', deviceName);
         await storageContext.set('deviceType', deviceType);
@@ -147,36 +187,30 @@ export class MatterbridgeV8 extends EventEmitter {
         await storageContext.set('productName', productName.slice(0, 32));
         await storageContext.set('nodeLabel', productName.slice(0, 32));
         await storageContext.set('productLabel', productName.slice(0, 32));
-        await storageContext.set('serialNumber', await storageContext.get('serialNumber', random));
+        await storageContext.set('serialNumber', await storageContext.get('serialNumber', serialNumber ? serialNumber.slice(0, 32) : random));
         await storageContext.set('uniqueId', await storageContext.get('uniqueId', random));
         await storageContext.set('softwareVersion', this.matterbridgeVersion && this.matterbridgeVersion.includes('.') ? parseInt(this.matterbridgeVersion.split('.')[0], 10) : 1);
         await storageContext.set('softwareVersionString', this.matterbridgeVersion ?? '1.0.0');
         await storageContext.set('hardwareVersion', this.osVersion && this.osVersion.includes('.') ? parseInt(this.osVersion.split('.')[0], 10) : 1);
         await storageContext.set('hardwareVersionString', this.osVersion ?? '1.0.0');
-        log.debug(`Created commissioning server storage context for ${pluginName}:`);
+        log.debug(`Created server node storage context "${pluginName}.persist"  for ${pluginName}:`);
         log.debug(`- deviceName: ${await storageContext.get('deviceName')} deviceType: ${await storageContext.get('deviceType')}(0x${(await storageContext.get('deviceType'))?.toString(16).padStart(4, '0')})`);
         log.debug(`- serialNumber: ${await storageContext.get('serialNumber')} uniqueId: ${await storageContext.get('uniqueId')}`);
         log.debug(`- softwareVersion: ${await storageContext.get('softwareVersion')} softwareVersionString: ${await storageContext.get('softwareVersionString')}`);
         log.debug(`- hardwareVersion: ${await storageContext.get('hardwareVersion')} hardwareVersionString: ${await storageContext.get('hardwareVersionString')}`);
-        log.notice(`Created commissioning server storage context for ${pluginName}`);
         return storageContext;
     }
-    async startServerNode(port = 5080, passcode = 20202021, discriminator = 3840) {
+    async createServerNode(storageContext, port = 5540, passcode = 20242025, discriminator = 3850) {
         if (!this.matterLogger)
-            return;
+            throw new Error('No logger initialized');
         const log = this.matterLogger;
-        log.notice('Starting Matterbridge');
-        this.matterStorageContext = await this.createServerNodeContext('Matterbridge', 'Matterbridge', AggregatorEndpoint.deviceType, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Aggregator');
-        if (!this.matterStorageContext) {
-            log.error('Error creating storage context for Matterbridge');
-            return;
-        }
+        log.notice(`Creating server node for ${await storageContext.get('storeId')}`);
         /**
          * Create a Matter ServerNode, which contains the Root Endpoint and all relevant data and configuration
          */
-        this.matterServerNode = await ServerNode.create({
+        const serverNode = await ServerNode.create({
             // Required: Give the Node a unique ID which is used to store the state of this node
-            id: await this.matterStorageContext.get('storeId'),
+            id: await storageContext.get('storeId'),
             // Provide Network relevant configuration like the port
             // Optional when operating only one device on a host, Default port is 5540
             network: {
@@ -191,114 +225,42 @@ export class MatterbridgeV8 extends EventEmitter {
             // Provide Node announcement settings
             // Optional: If Ommitted some development defaults are used
             productDescription: {
-                name: await this.matterStorageContext.get('deviceName'),
-                deviceType: DeviceTypeId(await this.matterStorageContext.get('deviceType')),
+                name: await storageContext.get('deviceName'),
+                deviceType: DeviceTypeId(await storageContext.get('deviceType')),
             },
             // Provide defaults for the BasicInformation cluster on the Root endpoint
             // Optional: If Omitted some development defaults are used
             basicInformation: {
-                vendorId: VendorId(await this.matterStorageContext.get('vendorId')),
-                vendorName: await this.matterStorageContext.get('vendorName'),
-                productId: await this.matterStorageContext.get('productId'),
-                productName: await this.matterStorageContext.get('productName'),
-                productLabel: await this.matterStorageContext.get('productName'),
-                nodeLabel: await this.matterStorageContext.get('productName'),
-                serialNumber: await this.matterStorageContext.get('serialNumber'),
-                uniqueId: await this.matterStorageContext.get('uniqueId'),
-                softwareVersion: await this.matterStorageContext.get('softwareVersion'),
-                softwareVersionString: await this.matterStorageContext.get('softwareVersionString'),
-                hardwareVersion: await this.matterStorageContext.get('hardwareVersion'),
-                hardwareVersionString: await this.matterStorageContext.get('hardwareVersionString'),
-            },
-        });
-        /**
-         * Matter Nodes are a composition of endpoints. Create and add a single endpoint to the node. This example uses the
-         * OnOffLightDevice or OnOffPlugInUnitDevice depending on the value of the type parameter. It also assigns this Part a
-         * unique ID to store the endpoint number for it in the storage to restore the device on restart.
-         * In this case we directly use the default command implementation from matter.js. Check out the DeviceNodeFull example
-         * to see how to customize the command handlers.
-         */
-        const lightEndpoint = new Endpoint(OnOffLightDevice.with(BridgedDeviceBasicInformationServer), {
-            id: 'OnOffLight',
-            bridgedDeviceBasicInformation: {
-                vendorId: VendorId(await this.matterStorageContext.get('vendorId')),
-                vendorName: await this.matterStorageContext.get('vendorName'),
-                productName: 'Light',
-                productLabel: 'Light',
-                nodeLabel: 'Light',
-                serialNumber: '0x123456789',
-                uniqueId: '0x123456789',
-                reachable: true,
-            },
-        });
-        /**
-         * Register state change handlers and events of the node for identify and onoff states to react to the commands.
-         * If the code in these change handlers fail then the change is also rolled back and not executed and an error is
-         * reported back to the controller.
-         */
-        lightEndpoint.events.identify.startIdentifying.on(() => log.notice('Run identify logic, ideally blink a light every 0.5s ...'));
-        lightEndpoint.events.identify.stopIdentifying.on(() => log.notice('Stop identify logic ...'));
-        lightEndpoint.events.onOff.onOff$Changed.on((value) => log.notice(`OnOff is now ${value ? 'ON' : 'OFF'}`));
-        const OnOffSwitchDeviceDefinition = MutableEndpoint({
-            name: 'OnOffSwitch',
-            deviceType: 0x103,
-            deviceRevision: 2,
-            requirements: {
-                server: {
-                    mandatory: {},
-                    optional: {},
-                },
-                client: {
-                    optional: {},
-                    mandatory: {},
-                },
-            },
-            behaviors: SupportedBehaviors(IdentifyServer, GroupsServer, ScenesServer, OnOffServer, BridgedDeviceBasicInformationServer),
-        });
-        console.log('OnOffSwitchDeviceDefinition\n', OnOffSwitchDeviceDefinition);
-        const switchEndpoint = new Endpoint(OnOffSwitchDeviceDefinition, {
-            id: 'OnOffSwitch',
-            onOff: {
-                onOff: false,
-            },
-            bridgedDeviceBasicInformation: {
-                vendorId: VendorId(await this.matterStorageContext.get('vendorId')),
-                vendorName: await this.matterStorageContext.get('vendorName'),
-                productName: 'Switch',
-                productLabel: 'Switch',
-                nodeLabel: 'Switch',
-                serialNumber: '0x123456789S',
-                uniqueId: '0x123456789S',
-                reachable: true,
+                vendorId: VendorId(await storageContext.get('vendorId')),
+                vendorName: await storageContext.get('vendorName'),
+                productId: await storageContext.get('productId'),
+                productName: await storageContext.get('productName'),
+                productLabel: await storageContext.get('productName'),
+                nodeLabel: await storageContext.get('productName'),
+                serialNumber: await storageContext.get('serialNumber'),
+                uniqueId: await storageContext.get('uniqueId'),
+                softwareVersion: await storageContext.get('softwareVersion'),
+                softwareVersionString: await storageContext.get('softwareVersionString'),
+                hardwareVersion: await storageContext.get('hardwareVersion'),
+                hardwareVersionString: await storageContext.get('hardwareVersionString'),
             },
         });
-        // await this.matterServerNode.add(endpoint);
-        // const mbV8 = new MatterbridgeDeviceV8(DeviceTypes.OnOffLight);
-        // const endpoint = mbV8.getBridgedNodeEndpointV8();
-        const aggregator = new Endpoint(AggregatorEndpoint, { id: 'aggregator' });
-        await this.matterServerNode.add(aggregator);
-        await aggregator.add(lightEndpoint);
-        await aggregator.add(switchEndpoint);
-        /**
-         * Log the endpoint structure for debugging reasons and to allow to verify anything is correct
-         */
-        logEndpoint(EndpointServer.forEndpoint(this.matterServerNode));
         /**
          * This event is triggered when the device is initially commissioned successfully.
          * This means: It is added to the first fabric.
          */
-        this.matterServerNode.lifecycle.commissioned.on(() => log.notice('Server was initially commissioned successfully!'));
+        serverNode.lifecycle.commissioned.on(() => log.notice('Server was initially commissioned successfully!'));
         /** This event is triggered when all fabrics are removed from the device, usually it also does a factory reset then. */
-        this.matterServerNode.lifecycle.decommissioned.on(() => log.notice('Server was fully decommissioned successfully!'));
+        serverNode.lifecycle.decommissioned.on(() => log.notice('Server was fully decommissioned successfully!'));
         /** This event is triggered when the device went online. This means that it is discoverable in the network. */
-        this.matterServerNode.lifecycle.online.on(() => log.notice('Server is online'));
+        serverNode.lifecycle.online.on(() => log.notice('Server is online'));
         /** This event is triggered when the device went offline. it is not longer discoverable or connectable in the network. */
-        this.matterServerNode.lifecycle.offline.on(() => log.notice('Server is offline'));
+        serverNode.lifecycle.offline.on(() => log.notice('Server is offline'));
         /**
          * This event is triggered when a fabric is added, removed or updated on the device. Use this if more granular
          * information is needed.
          */
-        this.matterServerNode.events.commissioning.fabricsChanged.on((fabricIndex, fabricAction) => {
+        serverNode.events.commissioning.fabricsChanged.on((fabricIndex, fabricAction) => {
             let action = '';
             switch (fabricAction) {
                 case FabricAction.Added:
@@ -318,19 +280,17 @@ export class MatterbridgeV8 extends EventEmitter {
          * This event is triggered when an operative new session was opened by a Controller.
          * It is not triggered for the initial commissioning process, just afterwards for real connections.
          */
-        this.matterServerNode.events.sessions.opened.on((session) => log.notice('Session opened', session));
+        serverNode.events.sessions.opened.on((session) => log.notice('Session opened', session));
         /**
          * This event is triggered when an operative session is closed by a Controller or because the Device goes offline.
          */
-        this.matterServerNode.events.sessions.closed.on((session) => log.notice('Session closed', session));
+        serverNode.events.sessions.closed.on((session) => log.notice('Session closed', session));
         /** This event is triggered when a subscription gets added or removed on an operative session. */
-        this.matterServerNode.events.sessions.subscriptionsChanged.on((session) => {
+        serverNode.events.sessions.subscriptionsChanged.on((session) => {
             log.notice('Session subscriptions changed', session);
             log.notice('Status of all sessions', this.matterServerNode?.state.sessions.sessions);
         });
-        await this.matterServerNode.bringOnline();
-        console.log('lightEndpoint\n', lightEndpoint);
-        console.log('switchEndpoint\n', switchEndpoint);
+        return serverNode;
     }
     showServerNodeQR() {
         if (!this.matterServerNode || !this.matterLogger)
@@ -356,12 +316,322 @@ export class MatterbridgeV8 extends EventEmitter {
             return;
         await this.matterServerNode.close();
     }
+    async createAggregator(storageContext) {
+        if (!this.matterLogger)
+            throw new Error('No logger initialized');
+        const log = this.matterLogger;
+        log.notice(`Creating ${await storageContext.get('storeId')} aggregator `);
+        const aggregator = new Endpoint(AggregatorEndpoint, { id: `${await storageContext.get('storeId')} aggregator` });
+        return aggregator;
+    }
+    async startBridge() {
+        if (!this.matterLogger)
+            throw new Error('No logger initialized');
+        const log = this.matterLogger;
+        const storageContext = await this.createServerNodeContext('Matterbridge', 'Matterbridge', AggregatorEndpoint.deviceType, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Aggregator');
+        this.matterServerNode = await this.createServerNode(storageContext);
+        this.matterAggregator = await this.createAggregator(storageContext);
+        log.notice(`Adding ${await storageContext.get('storeId')} aggregator to ${await storageContext.get('storeId')} server node`);
+        await this.matterServerNode.add(this.matterAggregator);
+        for (const plugin of this.registeredPlugins) {
+            if (!plugin.enabled) {
+                log.info(`Plugin ${plg}${plugin.name}${nf} not enabled`);
+                continue;
+            }
+            plugin.error = false;
+            plugin.loaded = false;
+            plugin.started = false;
+            plugin.configured = false;
+            plugin.connected = undefined;
+            plugin.qrPairingCode = undefined;
+            plugin.manualPairingCode = undefined;
+            this.loadPlugin(plugin, true, 'Matterbridge is starting'); // No await do it asyncronously
+        }
+        log.notice(`Adding lightEndpoint1 to ${await storageContext.get('storeId')} aggregator`);
+        const lightEndpoint1 = new Endpoint(OnOffLightDevice.with(BridgedDeviceBasicInformationServer), {
+            id: 'OnOffLight',
+            bridgedDeviceBasicInformation: {
+                vendorId: VendorId(await storageContext.get('vendorId')),
+                vendorName: await storageContext.get('vendorName'),
+                productName: 'Light',
+                productLabel: 'Light',
+                nodeLabel: 'Light',
+                serialNumber: '0x123456789',
+                uniqueId: '0x123456789',
+                reachable: true,
+            },
+        });
+        this.matterAggregator.add(lightEndpoint1);
+        log.notice(`Adding switchEnpoint2 to ${await storageContext.get('storeId')} aggregator`);
+        const switchEnpoint2 = new Endpoint(GenericSwitchDevice.with(BridgedDeviceBasicInformationServer, SwitchServer.with('MomentarySwitch', 'MomentarySwitchLongPress', 'MomentarySwitchMultiPress', 'MomentarySwitchRelease')), {
+            id: 'GenericSwitch',
+            bridgedDeviceBasicInformation: {
+                vendorId: VendorId(await storageContext.get('vendorId')),
+                vendorName: await storageContext.get('vendorName'),
+                productName: 'GenericSwitch',
+                productLabel: 'GenericSwitch',
+                nodeLabel: 'GenericSwitch',
+                serialNumber: '0x123456739',
+                uniqueId: '0x123456739',
+                reachable: true,
+            },
+            switch: {
+                numberOfPositions: 2,
+                currentPosition: 0,
+                multiPressMax: 2,
+            },
+        });
+        this.matterAggregator.add(switchEnpoint2);
+        switchEnpoint2.events.identify.startIdentifying.on(() => log.notice('Run identify logic, ideally blink a light every 0.5s ...'));
+        switchEnpoint2.events.switch.currentPosition$Changed.on(() => log.notice('Run identify logic, ideally blink a light every 0.5s ...'));
+        // switchEnpoint2.events.switch.emit('initialPress', { newPosition: 1 }, ActionContext.agentFor(switchEnpoint2) );
+        log.notice(`Adding matterbridge device to ${await storageContext.get('storeId')} aggregator`);
+        const matterbridgeDevice3 = new MatterbridgeDeviceV8(DeviceTypes.TEMPERATURE_SENSOR, { uniqueStorageKey: 'TemperatureSensor' });
+        this.matterAggregator.add(matterbridgeDevice3);
+        log.notice(`Starting ${await storageContext.get('storeId')} server node`);
+        await this.matterServerNode.bringOnline();
+        /*
+        logEndpoint(EndpointServer.forEndpoint(this.matterServerNode));
+        console.log('matterbridgeDevice3\n', matterbridgeDevice3);
+        console.log('matterbridgeDevice3.events\n', matterbridgeDevice3.events);
+        console.log('matterbridgeDevice3.events.identify\n', matterbridgeDevice3.eventsOf(IdentifyServer));
+        console.log('matterbridgeDevice3.state\n', matterbridgeDevice3.state);
+        console.log('matterbridgeDevice3.state.temperatureMeasurement\n', matterbridgeDevice3.stateOf(TemperatureMeasurementServer));
+        // matterbridgeDevice3.eventsOf(IdentifyServer);
+        // matterbridgeDevice3.events.identify.startIdentifying.on(() => log.notice('Run identify logic, ideally blink a light every 0.5s ...'));
+        */
+        this.showServerNodeQR();
+    }
+    async startChildbridge() {
+        //
+    }
+    async startController() {
+        //
+    }
+    /**
+     * 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) {
+        log.info(`Adding bridged device ${dev}${device.deviceName}${nf} for plugin ${plg}${pluginName}${nf}`);
+    }
+    /**
+     * Loads a plugin and returns the corresponding MatterbridgePlatform instance.
+     * @param plugin - The plugin to load.
+     * @param start - Optional flag indicating whether to start the plugin after loading. Default is false.
+     * @param message - Optional message to pass to the plugin when starting.
+     * @returns A Promise that resolves to the loaded MatterbridgePlatform instance.
+     * @throws An error if the plugin is not enabled, already loaded, or fails to load.
+     */
+    async loadPlugin(plugin, start = false, message = '') {
+        if (!plugin.enabled) {
+            return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} not enabled`));
+        }
+        if (plugin.platform) {
+            return Promise.resolve(plugin.platform);
+        }
+        log.info(`Loading plugin ${plg}${plugin.name}${nf} type ${typ}${plugin.type}${nf}`);
+        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);
+            log.debug(`Importing plugin ${plg}${plugin.name}${db} from ${pluginUrl.href}`);
+            const pluginInstance = await import(pluginUrl.href);
+            log.debug(`Imported plugin ${plg}${plugin.name}${db} from ${pluginUrl.href}`);
+            // Call the default export function of the plugin, passing this MatterBridge instance, the log and the config
+            if (pluginInstance.default) {
+                const config = await this.loadPluginConfig(plugin);
+                const log = new AnsiLogger({ logName: plugin.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: true });
+                const platform = pluginInstance.default(this, log, config);
+                platform.name = packageJson.name;
+                platform.config = config;
+                platform.version = packageJson.version;
+                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;
+                // Save the updated plugin data in the node storage
+                // await this.nodeContext?.set<RegisteredPlugin[]>('plugins', await this.getBaseRegisteredPlugins());
+                // await this.getPluginLatestVersion(plugin);
+                log.info(`Loaded plugin ${plg}${plugin.name}${nf} type ${typ}${platform.type} ${db}(entrypoint ${UNDERLINE}${pluginEntry}${UNDERLINEOFF})`);
+                if (start)
+                    this.startPlugin(plugin, message); // No await do it asyncronously
+                return Promise.resolve(platform);
+            }
+            else {
+                plugin.error = true;
+                return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} does not provide a default export`));
+            }
+        }
+        catch (err) {
+            plugin.error = true;
+            return Promise.reject(new Error(`Failed to load plugin ${plg}${plugin.name}${er}: ${err}`));
+        }
+    }
+    /**
+     * Starts a plugin.
+     *
+     * @param {RegisteredPlugin} plugin - The plugin to start.
+     * @param {string} [message] - Optional message to pass to the plugin's onStart method.
+     * @param {boolean} [configure=false] - Indicates whether to configure the plugin after starting.
+     * @returns {Promise<void>} A promise that resolves when the plugin is started successfully, or rejects with an error if starting the plugin fails.
+     */
+    async startPlugin(plugin, message, configure = false) {
+        if (!plugin.loaded || !plugin.platform) {
+            return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} not loaded or no platform`));
+        }
+        if (plugin.started) {
+            log.debug(`Plugin ${plg}${plugin.name}${db} already started`);
+            return Promise.resolve();
+        }
+        log.info(`Starting plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
+        try {
+            plugin.platform
+                .onStart(message)
+                .then(() => {
+                plugin.started = true;
+                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) => {
+                plugin.error = true;
+                return Promise.reject(new Error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`));
+            });
+        }
+        catch (err) {
+            plugin.error = true;
+            return Promise.reject(new Error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`));
+        }
+    }
+    /**
+     * Configures a plugin.
+     *
+     * @param {RegisteredPlugin} plugin - The plugin to configure.
+     * @returns {Promise<void>} A promise that resolves when the plugin is configured successfully, or rejects with an error if configuration fails.
+     */
+    async configurePlugin(plugin) {
+        if (!plugin.loaded || !plugin.started || !plugin.platform) {
+            return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} not loaded (${plugin.loaded}) or not started (${plugin.started}) or not platform (${plugin.platform?.name})`));
+        }
+        if (plugin.configured) {
+            log.info(`Plugin ${plg}${plugin.name}${nf} already configured`);
+            return Promise.resolve();
+        }
+        log.info(`Configuring plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
+        try {
+            plugin.platform
+                .onConfigure()
+                .then(() => {
+                plugin.configured = true;
+                log.info(`Configured plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
+                // this.savePluginConfig(plugin);
+                return Promise.resolve();
+            })
+                .catch((err) => {
+                plugin.error = true;
+                return Promise.reject(new Error(`Failed to configure plugin ${plg}${plugin.name}${er}: ${err}`));
+            });
+        }
+        catch (err) {
+            plugin.error = true;
+            return Promise.reject(new Error(`Failed to configure plugin ${plg}${plugin.name}${er}: ${err}`));
+        }
+    }
+    /**
+     * Loads the configuration for a plugin.
+     * If the configuration file exists, it reads the file and returns the parsed JSON data.
+     * If the configuration file does not exist, it creates a new file with default configuration and returns it.
+     * If any error occurs during file access or creation, it logs an error and rejects the promise with the error.
+     *
+     * @param plugin - The plugin for which to load the configuration.
+     * @returns A promise that resolves to the loaded or created configuration.
+     */
+    async loadPluginConfig(plugin) {
+        const configFile = path.join(this.matterbridgeDirectory, `${plugin.name}.config.json`);
+        try {
+            await fs.access(configFile);
+            const data = await fs.readFile(configFile, 'utf8');
+            const config = JSON.parse(data);
+            // this.log.debug(`Config file found: ${configFile}.\nConfig:${rs}\n`, config);
+            log.debug(`Config file found: ${configFile}.`);
+            /* The first time a plugin is added to the system, the config file is created with the plugin name and type "".*/
+            config.name = plugin.name;
+            config.type = plugin.type;
+            return config;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                const nodeErr = err;
+                if (nodeErr.code === 'ENOENT') {
+                    let config;
+                    if (plugin.name === 'matterbridge-zigbee2mqtt')
+                        config = zigbee2mqtt_config;
+                    else if (plugin.name === 'matterbridge-somfy-tahoma')
+                        config = somfytahoma_config;
+                    else if (plugin.name === 'matterbridge-shelly')
+                        config = shelly_config;
+                    else
+                        config = { name: plugin.name, type: plugin.type, unregisterOnShutdown: false };
+                    try {
+                        await this.writeFile(configFile, JSON.stringify(config, null, 2));
+                        log.debug(`Created config file: ${configFile}.`);
+                        // this.log.debug(`Created config file: ${configFile}.\nConfig:${rs}\n`, config);
+                        return config;
+                    }
+                    catch (err) {
+                        log.error(`Error creating config file ${configFile}: ${err}`);
+                        return config;
+                    }
+                }
+                else {
+                    log.error(`Error accessing config file ${configFile}: ${err}`);
+                    return {};
+                }
+            }
+            log.error(`Error loading config file ${configFile}: ${err}`);
+            return {};
+        }
+    }
+    /**
+     * Writes data to a file.
+     *
+     * @param {string} filePath - The path of the file to write to.
+     * @param {string} data - The data to write to the file.
+     * @returns {Promise<void>} - A promise that resolves when the data is successfully written to the file.
+     */
+    async writeFile(filePath, data) {
+        // Write the data to a file
+        await fs
+            .writeFile(`${filePath}`, data, 'utf8')
+            .then(() => {
+            log.debug(`Successfully wrote to ${filePath}`);
+        })
+            .catch((error) => {
+            log.error(`Error writing to ${filePath}:`, error);
+        });
+    }
 }
 // node dist/matterbridgeV8.js MatterbridgeV8
 if (process.argv.includes('MatterbridgeV8')) {
     const matterbridge = await MatterbridgeV8.create();
-    await matterbridge.startServerNode(5070, 20242025, 3950);
-    matterbridge.showServerNodeQR();
+    if (process.argv.includes('-bridge'))
+        await matterbridge.startBridge();
+    if (process.argv.includes('-childbridge'))
+        await matterbridge.startChildbridge();
+    if (process.argv.includes('-controller'))
+        await matterbridge.startController();
     process.on('SIGINT', async function () {
         console.log('Caught interrupt signal');
         await matterbridge.stopServerNode();