matterbridge 1.6.6 → 1.6.7-dev.1

package/dist/matterbridgeEdge.js

@@ -1,61 +1,25 @@
-/* eslint-disable no-console */
-/**
- * This file contains the class MatterbridgeEdge that extends the Matterbridge class.
- *
- * @file matterbridgeEdge.ts
- * @author Luca Liguori
- * @date 2024-10-01
- * @version 1.0.0
- *
- * Copyright 2024, 2025, 2026 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. *
- */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// Node.js modules
 import path from 'path';
 import os from 'os';
 import { randomBytes } from 'crypto';
-// NodeStorage and AnsiLogger modules
-import { rs, GREEN, debugStringify, er, zb, nf } from 'node-ansi-logger';
-// Matterbridge
+import { rs, GREEN, debugStringify, er, zb, nf, db } from 'node-ansi-logger';
 import { Matterbridge } from './matterbridge.js';
 import { bridge } from './matterbridgeDeviceTypes.js';
 import { dev, plg } from './matterbridgeTypes.js';
 import { copyDirectory, getParameter, hasParameter } from './utils/utils.js';
-// @matter
 import { DeviceTypeId, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, VendorId, EndpointServer } from '@matter/main';
 import { ServerNode, Endpoint as EndpointNode, Environment, StorageService } from '@matter/main';
 import { BasicInformationCluster } from '@matter/main/clusters';
-import { FabricAction, MdnsService } from '@matter/main/protocol';
+import { FabricAction, MdnsService, PaseClient } from '@matter/main/protocol';
 import { GenericSwitchDevice } from '@matter/main/devices';
 import { AggregatorEndpoint } from '@matter/main/endpoints';
 import { BridgedDeviceBasicInformationServer, SwitchServer } from '@matter/main/behaviors';
 import { Device, logEndpoint } from '@project-chip/matter.js/device';
-/**
- * Represents the MatterbridgeEdge application.
- */
 export class MatterbridgeEdge extends Matterbridge {
     static instance;
-    // Matter environment
     environment = Environment.default;
-    // Matter storage
     matterStorageService;
-    // Mapping of CommissioningServer to ServerNode
     csToServerNode = new Map();
-    // Mapping of Aggregator to AggregatorEndpoint
     agToAggregatorEndpoint = new Map();
-    // Mapping of sessions
     activeSessions = new Map();
     constructor() {
         super();
@@ -73,28 +37,24 @@ export class MatterbridgeEdge extends Matterbridge {
     async initialize() {
         if (hasParameter('debug'))
             console.log('Initializing MatterbridgeEdge...');
-        // Set the matterbridge directory
         this.homeDirectory = getParameter('homedir') ?? os.homedir();
         this.matterbridgeDirectory = path.join(this.homeDirectory, '.matterbridge');
         this.matterStorageName = 'matterstorage' + (getParameter('profile') ? '.' + getParameter('profile') : '');
-        // Setup matter environment
         this.environment.vars.set('log.level', MatterLogLevel.INFO);
         this.environment.vars.set('log.format', MatterLogFormat.ANSI);
         this.environment.vars.set('path.root', path.join(this.matterbridgeDirectory, this.matterStorageName));
         this.environment.vars.set('runtime.signals', false);
         this.environment.vars.set('runtime.exitcode', false);
-        // Initialize the base Matterbridge class
+        this.port = 5540;
+        this.passcode = PaseClient.generateRandomPasscode();
+        this.discriminator = PaseClient.generateRandomDiscriminator();
+        if (hasParameter('debug'))
+            console.log(`Initializing server node for Matterbridge... on port ${this.port} with passcode ${this.passcode} and discriminator ${this.discriminator}`);
         await super.initialize();
-        // Setup Matter mdnsInterface
         if (this.mdnsInterface)
             this.environment.vars.set('mdns.networkInterface', this.mdnsInterface);
-        // Setup Matter commissioning server
-        // this.port = 5540;
-        // this.passcode = PaseClient.generateRandomPasscode();
-        // this.discriminator = PaseClient.generateRandomDiscriminator();
     }
     async startMatterStorage(storageType, storageName) {
-        // Setup Matter storage
         this.log.info(`Starting matter node storage...`);
         this.matterStorageService = this.environment.get(StorageService);
         this.log.info(`Matter node storage service created: ${this.matterStorageService.location}`);
@@ -102,7 +62,6 @@ export class MatterbridgeEdge extends Matterbridge {
         this.log.info('Matter node storage manager "Matterbridge" created');
         this.matterbridgeContext = await this.createServerNodeContext('Matterbridge', 'Matterbridge', bridge.code, this.aggregatorVendorId, 'Matterbridge', this.aggregatorProductId, 'Matterbridge aggregator');
         this.log.info('Matter node storage started');
-        // Backup matter storage since it is created/opened correctly
         await this.backupMatterStorage(path.join(this.matterbridgeDirectory, this.matterStorageName), path.join(this.matterbridgeDirectory, this.matterStorageName + '.backup'));
     }
     async backupMatterStorage(storageName, backupName) {
@@ -120,7 +79,7 @@ export class MatterbridgeEdge extends Matterbridge {
     }
     createMatterServer(storageManager) {
         if (hasParameter('debug'))
-            this.log.warn('createMatterServer() => mock matterServer');
+            this.log.warn('createMatterServer() => mock MatterServer.addCommissioningServer()');
         const matterServer = {
             addCommissioningServer: (commissioningServer, nodeOptions) => {
                 if (hasParameter('debug'))
@@ -131,9 +90,11 @@ export class MatterbridgeEdge extends Matterbridge {
     }
     async startMatterServer() {
         if (hasParameter('debug'))
-            this.log.warn('createMatterServer() => do nothing');
+            this.log.warn('startMatterServer() => do nothing');
     }
     async stopMatterServer() {
+        if (hasParameter('debug'))
+            this.log.warn('stopMatterServer() => ...');
         this.log.info(`Stopping matter server nodes in ${this.bridgeMode} mode...`);
         if (this.bridgeMode === 'bridge') {
             const serverNode = this.csToServerNode.get('Matterbridge')?.serverNode;
@@ -155,24 +116,6 @@ export class MatterbridgeEdge extends Matterbridge {
         await this.environment.get(MdnsService)[Symbol.asyncDispose]();
         this.log.info('Stopped MdnsService');
     }
-    /**
-     * Creates a server node storage context.
-     *
-     * @param pluginName - The name of the plugin.
-     * @param deviceName - The name 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.
-     * @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.
-     */
     async createServerNodeContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber) {
         if (!this.matterStorageService)
             throw new Error('No storage service initialized');
@@ -207,40 +150,28 @@ export class MatterbridgeEdge extends Matterbridge {
     }
     async createServerNode(storageContext, port = 5540, passcode = 20242025, discriminator = 3850) {
         const storeId = await storageContext.get('storeId');
-        this.log.info(`Creating server node for ${storeId}...`);
+        this.log.info(`Creating server node for ${storeId} on port ${port} with passcode ${passcode} and discriminator ${discriminator}...`);
         this.log.debug(`- deviceName: ${await storageContext.get('deviceName')}`);
         this.log.debug(`- deviceType: ${await storageContext.get('deviceType')}(0x${(await storageContext.get('deviceType'))?.toString(16).padStart(4, '0')})`);
         this.log.debug(`- serialNumber: ${await storageContext.get('serialNumber')}`);
         this.log.debug(`- uniqueId: ${await storageContext.get('uniqueId')}`);
         this.log.debug(`- softwareVersion: ${await storageContext.get('softwareVersion')} softwareVersionString: ${await storageContext.get('softwareVersionString')}`);
         this.log.debug(`- hardwareVersion: ${await storageContext.get('hardwareVersion')} hardwareVersionString: ${await storageContext.get('hardwareVersionString')}`);
-        /**
-         * Create a Matter ServerNode, which contains the Root Endpoint and all relevant data and configuration
-         */
         const serverNode = await ServerNode.create({
-            // Required: Give the Node a unique ID which is used to store the state of this node
             id: storeId,
-            // Provide Network relevant configuration like the port
-            // Optional when operating only one device on a host, Default port is 5540
             network: {
                 listeningAddressIpv4: this.ipv4address,
                 listeningAddressIpv6: this.ipv6address,
                 port,
             },
-            // Provide Commissioning relevant settings
-            // Optional for development/testing purposes
             commissioning: {
                 passcode,
                 discriminator,
             },
-            // Provide Node announcement settings
-            // Optional: If Ommitted some development defaults are used
             productDescription: {
                 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 storageContext.get('vendorId')),
                 vendorName: await storageContext.get('vendorName'),
@@ -257,7 +188,6 @@ export class MatterbridgeEdge extends Matterbridge {
             },
         });
         const sanitizeFabrics = (fabrics) => {
-            // New type of fabric information: Record<FabricIndex, ExposedFabricInformation>
             const sanitizedFabrics = this.sanitizeFabricInformations(Array.from(Object.values(serverNode.state.commissioning.fabrics)));
             this.log.info(`Fabrics: ${debugStringify(sanitizedFabrics)}`);
             if (this.bridgeMode === 'bridge') {
@@ -266,14 +196,8 @@ export class MatterbridgeEdge extends Matterbridge {
                 this.matterbridgePaired = true;
             }
         };
-        /**
-         * This event is triggered when the device is initially commissioned successfully.
-         * This means: It is added to the first fabric.
-         */
         serverNode.lifecycle.commissioned.on(() => this.log.notice(`Server node for ${storeId} was initially commissioned successfully!`));
-        /** This event is triggered when all fabrics are removed from the device, usually it also does a factory reset then. */
         serverNode.lifecycle.decommissioned.on(() => this.log.notice(`Server node for ${storeId} was fully decommissioned successfully!`));
-        /** This event is triggered when the device went online. This means that it is discoverable in the network. */
         serverNode.lifecycle.online.on(() => {
             this.log.notice(`Server node for ${storeId} is online`);
             if (!serverNode.lifecycle.isCommissioned) {
@@ -295,7 +219,6 @@ export class MatterbridgeEdge extends Matterbridge {
                 sanitizeFabrics(serverNode.state.commissioning.fabrics);
             }
         });
-        /** This event is triggered when the device went offline. it is not longer discoverable or connectable in the network. */
         serverNode.lifecycle.offline.on(() => {
             this.log.notice(`Server node for ${storeId} is offline`);
             if (this.bridgeMode === 'bridge') {
@@ -307,10 +230,6 @@ export class MatterbridgeEdge extends Matterbridge {
                 this.matterbridgeConnected = false;
             }
         });
-        /**
-         * This event is triggered when a fabric is added, removed or updated on the device. Use this if more granular
-         * information is needed.
-         */
         serverNode.events.commissioning.fabricsChanged.on((fabricIndex, fabricAction) => {
             let action = '';
             switch (fabricAction) {
@@ -337,22 +256,14 @@ export class MatterbridgeEdge extends Matterbridge {
                 this.matterbridgeSessionInformations = sanitizedSessions;
             }
         };
-        /**
-         * 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.
-         */
         serverNode.events.sessions.opened.on((session) => {
             this.log.notice(`Session opened on server node for ${storeId}: ${debugStringify(session)}`);
             sanitizeSessions(Object.values(serverNode.state.sessions.sessions));
         });
-        /**
-         * This event is triggered when an operative session is closed by a Controller or because the Device goes offline.
-         */
         serverNode.events.sessions.closed.on((session) => {
             this.log.notice(`Session closed on server node for ${storeId}: ${debugStringify(session)}`);
             sanitizeSessions(Object.values(serverNode.state.sessions.sessions));
         });
-        /** This event is triggered when a subscription gets added or removed on an operative session. */
         serverNode.events.sessions.subscriptionsChanged.on((session) => {
             this.log.notice(`Session subscriptions changed on server node for ${storeId}: ${debugStringify(session)}`);
             sanitizeSessions(Object.values(serverNode.state.sessions.sessions));
@@ -378,13 +289,11 @@ export class MatterbridgeEdge extends Matterbridge {
         return aggregator;
     }
     async addBridgedEndpoint(pluginName, device) {
-        // Check if the plugin is registered
         const plugin = this.plugins.get(pluginName);
         if (!plugin) {
-            this.log.error(`Error adding bridged device ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error adding bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) plugin ${plg}${pluginName}${er} not found`);
             return;
         }
-        // Register and add the device to the matterbridge aggregator node
         if (this.bridgeMode === 'bridge') {
             this.log.info(`Adding ${pluginName}:${device.deviceName} to Matterbridge aggregator node`);
             const aggregatorNode = this.agToAggregatorEndpoint.get('Matterbridge')?.aggregatorNode;
@@ -397,20 +306,64 @@ export class MatterbridgeEdge extends Matterbridge {
                 await aggregatorNode?.add(device);
             }
         }
-        // TODO: Implement plugins and devices
         if (plugin.registeredDevices !== undefined)
             plugin.registeredDevices++;
         if (plugin.addedDevices !== undefined)
             plugin.addedDevices++;
-        // Add the device to the DeviceManager
         this.devices.set(device);
-        this.log.info(`Added and registered bridged device (${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${dev}${device.id}${nf}) for plugin ${plg}${pluginName}${nf}`);
+        this.log.info(`Added and registered bridged endpoint (${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${dev}${device.id}${nf}) for plugin ${plg}${pluginName}${nf}`);
     }
     async removeBridgedEndpoint(pluginName, device) {
-        // TODO: Implement removeBridgedEndpoint
+        this.log.debug(`Removing bridged endpoint ${dev}${device.deviceName}${db} (${zb}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
+        const plugin = this.plugins.get(pluginName);
+        if (!plugin) {
+            this.log.error(`Error removing bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: plugin not found`);
+            return;
+        }
+        if (this.bridgeMode === 'bridge') {
+            const aggregatoreNode = this.agToAggregatorEndpoint.get('Matterbridge')?.aggregatorNode;
+            if (!aggregatoreNode) {
+                this.log.error(`Error removing bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: matterAggregator node not found`);
+                return;
+            }
+            await device.delete();
+            this.log.info(`Removed bridged endpoint(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${zb}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
+            if (plugin.registeredDevices !== undefined)
+                plugin.registeredDevices--;
+            if (plugin.addedDevices !== undefined)
+                plugin.addedDevices--;
+        }
+        else if (this.bridgeMode === 'childbridge') {
+            if (plugin.type === 'AccessoryPlatform') {
+            }
+            else if (plugin.type === 'DynamicPlatform') {
+                const aggregatoreNode = this.agToAggregatorEndpoint.get(pluginName)?.aggregatorNode;
+                if (!aggregatoreNode) {
+                    this.log.error(`Error removing bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: aggregator not found`);
+                    return;
+                }
+                await device.delete();
+            }
+            this.log.info(`Removed bridged endpoint(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${zb}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
+            if (plugin.registeredDevices !== undefined)
+                plugin.registeredDevices--;
+            if (plugin.addedDevices !== undefined)
+                plugin.addedDevices--;
+            if (plugin.registeredDevices === 0 && plugin.addedDevices === 0) {
+                const serverNode = this.csToServerNode.get(pluginName)?.serverNode;
+                if (serverNode)
+                    await this.stopServerNode(serverNode);
+                this.csToServerNode.delete(pluginName);
+                this.log.info(`Removed server node for plugin ${plg}${pluginName}${nf}`);
+            }
+        }
+        this.devices.remove(device);
     }
     async removeAllBridgedEndpoints(pluginName) {
-        // TODO: Implement removeAllBridgedEndpoints
+        this.log.debug(`Removing all bridged endpoints for plugin ${plg}${pluginName}${db}`);
+        for (const device of this.devices.array().filter((device) => device.plugin === pluginName)) {
+            await this.removeBridgedEndpoint(pluginName, device);
+        }
     }
     async createCommissioningServerContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName) {
         if (hasParameter('debug'))
@@ -432,11 +385,10 @@ export class MatterbridgeEdge extends Matterbridge {
         if (hasParameter('debug'))
             this.log.warn(`createCommisioningServer() for ${pluginName} => createServerNode()`);
         const port = this.port;
-        const serverNode = await this.createServerNode(context, this.port++, this.passcode ? this.passcode++ : 20242025, this.discriminator ? this.discriminator++ : 3840);
+        const serverNode = await this.createServerNode(context, this.port++, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
         const commissioningServer = {
             getPort: () => port,
             addDevice: async (device) => {
-                // if (hasParameter('debug')) this.log.warn('CommissioningServer.addDevice()', device.name);
                 if (device instanceof Device) {
                     if (hasParameter('debug'))
                         this.log.warn('CommissioningServer.addDevice() => Device');
@@ -451,7 +403,6 @@ export class MatterbridgeEdge extends Matterbridge {
                     await serverNode.add(aggregatorNode);
                     if (!this.test) {
                         this.test = true;
-                        // await this.testEndpoints();
                     }
                 }
             },
@@ -467,11 +418,11 @@ export class MatterbridgeEdge extends Matterbridge {
             name: 'MA-aggregator',
             addBridgedDevice: (device) => {
                 if (hasParameter('debug'))
-                    this.log.warn('Aggregator.addBridgedDevice() => not inplemented');
+                    this.log.error('****Aggregator.addBridgedDevice() => not inplemented');
             },
             removeBridgedDevice: (device) => {
                 if (hasParameter('debug'))
-                    this.log.warn('Aggregator.removeBridgedDevice() => not inplemented');
+                    this.log.error('****Aggregator.removeBridgedDevice() => not inplemented');
             },
         };
         this.agToAggregatorEndpoint.set(pluginName, { aggregator, aggregatorNode });
@@ -508,37 +459,6 @@ export class MatterbridgeEdge extends Matterbridge {
         const aggregatorNode = this.agToAggregatorEndpoint.get('Matterbridge')?.aggregatorNode;
         if (!aggregatorNode)
             return;
-        /*
-        this.log.notice(`Creating OnOffLight1`);
-        const lightEndpoint = new MatterbridgeEndpoint(onOffLight, { uniqueStorageKey: 'OnOffLight1' }, true);
-        lightEndpoint.addDeviceType(bridgedNode);
-        lightEndpoint.createDefaultBridgedDeviceBasicInformationClusterServer('OnOffLight 1', '123456789', 0xfff1, 'Matterbridge', 'Light');
-        lightEndpoint.addDeviceType(powerSource);
-        lightEndpoint.createDefaultPowerSourceWiredClusterServer();
-        lightEndpoint.addDeviceType(electricalSensor);
-        lightEndpoint.addClusterServer(lightEndpoint.getDefaultElectricalEnergyMeasurementClusterServer());
-        lightEndpoint.addClusterServer(lightEndpoint.getDefaultElectricalPowerMeasurementClusterServer());
-        lightEndpoint.addRequiredClusterServers(lightEndpoint);
-        this.log.notice(`Adding OnOffLight1 to ${await this.matterbridgeContext.get<string>('storeId')} aggregator`);
-        await aggregatorNode.add(lightEndpoint);
-        logEndpoint(EndpointServer.forEndpoint(lightEndpoint));
-    
-        this.log.notice(`Creating Outlet1`);
-        const outletEndpoint = new MatterbridgeEndpoint(onOffOutlet, { uniqueStorageKey: 'OnOffOutlet1' }, true);
-        outletEndpoint.addDeviceType(bridgedNode);
-        outletEndpoint.createDefaultBridgedDeviceBasicInformationClusterServer('OnOffOutlet 1', '123456789', 0xfff1, 'Matterbridge', 'Outlet');
-        outletEndpoint.addDeviceType(powerSource);
-        outletEndpoint.createDefaultPowerSourceReplaceableBatteryClusterServer();
-        outletEndpoint.addDeviceType(electricalSensor);
-        outletEndpoint.addClusterServer(outletEndpoint.getDefaultElectricalEnergyMeasurementClusterServer());
-        outletEndpoint.addClusterServer(outletEndpoint.getDefaultElectricalPowerMeasurementClusterServer());
-        outletEndpoint.addRequiredClusterServers(outletEndpoint);
-        const input0 = outletEndpoint.addChildDeviceTypeWithClusterServer('Input:0', [genericSwitch], undefined, undefined, true);
-        const input1 = outletEndpoint.addChildDeviceTypeWithClusterServer('Input:1', [genericSwitch], undefined, undefined, true);
-        this.log.notice(`Adding OnOffOutlet1 to ${await this.matterbridgeContext.get<string>('storeId')} aggregator`);
-        await aggregatorNode.add(outletEndpoint);
-        logEndpoint(EndpointServer.forEndpoint(outletEndpoint));
-        */
         this.log.notice(`Creating switchEnpoint1`);
         const switchEnpoint1 = new EndpointNode(GenericSwitchDevice.with(BridgedDeviceBasicInformationServer, SwitchServer.with('MomentarySwitch', 'MomentarySwitchLongPress', 'MomentarySwitchMultiPress', 'MomentarySwitchRelease')), {
             id: 'GenericSwitch',
@@ -561,398 +481,5 @@ export class MatterbridgeEdge extends Matterbridge {
         this.log.notice(`Adding switchEnpoint1 to ${await this.matterbridgeContext.get('storeId')} aggregator`);
         await aggregatorNode.add(switchEnpoint1);
         logEndpoint(EndpointServer.forEndpoint(switchEnpoint1), { logNotSupportedClusterAttributes: true, logNotSupportedClusterEvents: true, logNotSupportedClusterCommands: true });
-        // if (switchEnpoint2.behaviors.has(SwitchServer)) this.log.notice(`SwitchServer found`);
-        // switchEnpoint2.act((agent) => agent['switch'].events['initialPress'].emit({ newPosition: 1 }, agent.context));
-        /*
-        const device = new MatterbridgeEndpoint(genericSwitch, { uniqueStorageKey: 'GenericSwitch 2' }, true);
-        device.createDefaultSwitchClusterServer();
-        device.addRequiredClusterServers(device);
-        await aggregatorNode.add(device);
-        logEndpoint(EndpointServer.forEndpoint(device));
-        await device.triggerSwitchEvent('Single', this.log);
-        await device.triggerSwitchEvent('Double', this.log);
-        await device.triggerSwitchEvent('Long', this.log);
-    
-        const device1 = new MatterbridgeEndpoint(genericSwitch, { uniqueStorageKey: 'GenericSwitch 3' }, true);
-        device1.createDefaultLatchingSwitchClusterServer();
-        device1.addRequiredClusterServers(device1);
-        await aggregatorNode.add(device1);
-        logEndpoint(EndpointServer.forEndpoint(device1));
-        await device1.triggerSwitchEvent('Press', this.log);
-        await device1.triggerSwitchEvent('Release', this.log);
-    
-        this.log.notice(`Creating TestLight`);
-        const matterbridgeDevice = new MatterbridgeEndpoint(onOffLight, { uniqueStorageKey: 'Test .Light:2' }, true);
-        matterbridgeDevice.behaviors.require(MatterbridgeIdentifyServer, {
-          identifyTime: 0,
-          identifyType: Identify.IdentifyType.None,
-        });
-        matterbridgeDevice.behaviors.require(GroupsServer);
-        matterbridgeDevice.behaviors.require(MatterbridgeOnOffServer, {
-          onOff: false,
-        });
-        matterbridgeDevice.behaviors.require(MatterbridgeLevelControlServer, {
-          currentLevel: 0,
-          options: { executeIfOff: false },
-        });
-        matterbridgeDevice.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature), {
-          colorCapabilities: { xy: true, hueSaturation: true, colorLoop: false, enhancedHue: false, colorTemperature: true },
-          colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
-          enhancedColorMode: ColorControl.EnhancedColorMode.ColorTemperatureMireds,
-          options: { executeIfOff: false },
-          numberOfPrimaries: null,
-          currentX: 24939,
-          currentY: 24701,
-          currentHue: 0,
-          currentSaturation: 0,
-          colorTemperatureMireds: 450,
-          colorTempPhysicalMinMireds: 150,
-          colorTempPhysicalMaxMireds: 450,
-          coupleColorTempToLevelMinMireds: 150,
-          startUpColorTemperatureMireds: null,
-        });
-        matterbridgeDevice.behaviors.require(BridgedDeviceBasicInformationServer, {
-          vendorId: VendorId(await this.matterbridgeContext.get<number>('vendorId')),
-          vendorName: await this.matterbridgeContext.get<string>('vendorName'),
-          productName: 'TestLight2',
-          productLabel: 'TestLight2',
-          nodeLabel: 'TestLight2',
-          serialNumber: 'SN 0x123456789',
-          uniqueId: '0x123456789',
-          reachable: true,
-        });
-    
-        // await matterbridgeDevice.setTagList(null, 0x07, 1, 'endpoint 2');
-        // await matterbridgeDevice.configureColorControlCluster(false, false, true, ColorControl.ColorMode.ColorTemperatureMireds);
-    
-        this.log.notice(`Adding TestLight`);
-        await aggregatorNode?.add(matterbridgeDevice);
-    
-        this.log.notice(`Creating switchEnpoint1`);
-        const switchEnpoint2 = new EndpointNode(
-          GenericSwitchDevice.with(DescriptorServer.with(Descriptor.Feature.TagList), BridgedDeviceBasicInformationServer, SwitchServer.with('MomentarySwitch', 'MomentarySwitchLongPress', 'MomentarySwitchMultiPress', 'MomentarySwitchRelease')),
-          {
-            id: 'GenericSwitch1',
-            descriptor: {
-              tagList: [{ mfgCode: null, namespaceId: 0x07, tag: 1, label: 'Switch1' }],
-            },
-            bridgedDeviceBasicInformation: {
-              vendorId: VendorId(await this.matterbridgeContext.get<number>('vendorId')),
-              vendorName: await this.matterbridgeContext.get<string>('vendorName'),
-    
-              productName: 'GenericSwitch',
-              productLabel: 'GenericSwitch',
-              nodeLabel: 'GenericSwitch',
-    
-              serialNumber: 'SN 0x1234567397',
-              uniqueId: '0x1234567397',
-              reachable: true,
-            },
-            switch: {
-              numberOfPositions: 2,
-              currentPosition: 0,
-              multiPressMax: 2,
-            },
-          },
-        );
-        this.log.notice(`Creating switchEnpoint2`);
-        await aggregatorNode?.add(switchEnpoint2);
-        */
-        /*
-        const lightEndpoint1 = new EndpointNode(ColorTemperatureLightDevice.with(BridgedDeviceBasicInformationServer), {
-          // }, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer), {
-          id: 'OnOffLight',
-          bridgedDeviceBasicInformation: {
-            vendorId: VendorId(await this.matterbridgeContext.get<number>('vendorId')),
-            vendorName: await this.matterbridgeContext.get<string>('vendorName'),
-    
-            productName: 'Light',
-            productLabel: 'Light',
-            nodeLabel: 'Light',
-    
-            serialNumber: 'SN 0x123456789',
-            uniqueId: '0x123456789',
-            reachable: true,
-          },
-          levelControl: {
-            currentLevel: 0,
-            options: { executeIfOff: false, coupleColorTempToLevel: false },
-          },
-          colorControl: {
-            colorTemperatureMireds: 450,
-            colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
-            colorTempPhysicalMinMireds: 150,
-            colorTempPhysicalMaxMireds: 450,
-            coupleColorTempToLevelMinMireds: 150,
-            startUpColorTemperatureMireds: 450,
-          },
-        });
-        lightEndpoint1.behaviors.require(ColorControlServer.with('ColorTemperature'), {
-          colorTemperatureMireds: 450,
-          colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
-          colorTempPhysicalMinMireds: 150,
-          colorTempPhysicalMaxMireds: 450,
-          coupleColorTempToLevelMinMireds: 150,
-          startUpColorTemperatureMireds: 450,
-        });
-        await aggregatorNode?.add(lightEndpoint1);
-    
-        /*
-        lightEndpoint1.behaviors.require(MatterbridgeIdentifyServer);
-        lightEndpoint1.behaviors.require(MatterbridgeOnOffServer);
-        lightEndpoint1.behaviors.require(MatterbridgeLevelControlServer);
-        lightEndpoint1.behaviors.require(MatterbridgeColorControlServer, {
-          colorTemperatureMireds: 250,
-          colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
-          colorTempPhysicalMinMireds: 150,
-          colorTempPhysicalMaxMireds: 450,
-          coupleColorTempToLevelMinMireds: 150,
-          startUpColorTemperatureMireds: 450,
-        });
-        await aggregatorNode?.add(lightEndpoint1);
-    
-        this.log.notice(`Creating switchEnpoint2`);
-        const switchEnpoint2 = new EndpointNode(GenericSwitchDevice.with(BridgedDeviceBasicInformationServer, SwitchServer.with('MomentarySwitch', 'MomentarySwitchLongPress', 'MomentarySwitchMultiPress', 'MomentarySwitchRelease')), {
-          id: 'GenericSwitch',
-          bridgedDeviceBasicInformation: {
-            vendorId: VendorId(await this.matterbridgeContext.get<number>('vendorId')),
-            vendorName: await this.matterbridgeContext.get<string>('vendorName'),
-    
-            productName: 'GenericSwitch',
-            productLabel: 'GenericSwitch',
-            nodeLabel: 'GenericSwitch',
-    
-            serialNumber: 'SN 0x123456739',
-            uniqueId: '0x123456739',
-            reachable: true,
-          },
-          switch: {
-            numberOfPositions: 2,
-            currentPosition: 0,
-            multiPressMax: 2,
-          },
-        });
-        await aggregatorNode?.add(switchEnpoint2);
-        */
-        /*
-        for (let i = 1; i <= max; i++) {
-          this.log.notice(`Creating lightEndpoint${i}`);
-          const lightEndpoint = new MatterbridgeEndpoint(onOffLight, { uniqueStorageKey: 'OnOffLight' + i });
-          lightEndpoint.addClusterServer(lightEndpoint.getDefaultBridgedDeviceBasicInformationClusterServer('OnOffLight' + i, '123456789', 0xfff1, 'Matterbridge', 'Light'));
-          this.log.notice(`Adding lightEndpoint${i} to ${await this.matterbridgeContext.get<string>('storeId')} aggregator`);
-          await aggregatorNode?.add(lightEndpoint);
-          setInterval(async () => {
-            const state = lightEndpoint.getAttribute(OnOffCluster.id, 'onOff');
-            lightEndpoint.setAttribute(OnOffCluster.id, 'onOff', !state);
-            this.log.notice(`Setting state for lightEndpoint${i} from:`, state, 'to:', !state);
-          }, 10000);
-        }
-        for (let i = 1; i <= max; i++) {
-          this.log.notice(`Creating outletEndpoint${i}`);
-          const lightEndpoint = new MatterbridgeEndpoint(onOffOutlet, { uniqueStorageKey: 'OnOffOutlet' + i });
-          lightEndpoint.addClusterServer(lightEndpoint.getDefaultBridgedDeviceBasicInformationClusterServer('OnOffOutlet' + i, '123456789', 0xfff1, 'Matterbridge', 'Outlet'));
-          this.log.notice(`Adding outletEndpoint${i} to ${await this.matterbridgeContext.get<string>('storeId')} aggregator`);
-          await aggregatorNode?.add(lightEndpoint);
-          setInterval(async () => {
-            const state = lightEndpoint.getAttribute(OnOffCluster.id, 'onOff');
-            lightEndpoint.setAttribute(OnOffCluster.id, 'onOff', !state);
-            this.log.notice(`Setting state for outletEndpoint${i} from:`, state, 'to:', !state);
-          }, 10000);
-        }
-        */
     }
 }
-/*
-    /*
-    matterbridgeDevice.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature), {
-      colorCapabilities: { xy: true, hueSaturation: true, colorLoop: false, enhancedHue: false, colorTemperature: true },
-      colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
-      enhancedColorMode: ColorControl.EnhancedColorMode.ColorTemperatureMireds,
-      options: { executeIfOff: false },
-      numberOfPrimaries: null,
-      currentX: 24939,
-      currentY: 24701,
-      currentHue: 0,
-      currentSaturation: 0,
-      colorTemperatureMireds: 450,
-      colorTempPhysicalMinMireds: 150,
-      colorTempPhysicalMaxMireds: 450,
-      coupleColorTempToLevelMinMireds: 150,
-      startUpColorTemperatureMireds: null,
-    });
-    matterbridgeDevice.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.ColorTemperature), {
-      colorCapabilities: { xy: false, hueSaturation: false, colorLoop: false, enhancedHue: false, colorTemperature: true },
-      colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
-      enhancedColorMode: ColorControl.EnhancedColorMode.ColorTemperatureMireds,
-      options: { executeIfOff: false },
-      numberOfPrimaries: null,
-      colorTemperatureMireds: 450,
-      colorTempPhysicalMinMireds: 150,
-      colorTempPhysicalMaxMireds: 450,
-      coupleColorTempToLevelMinMireds: 150,
-      startUpColorTemperatureMireds: null,
-    });
-    */
-/*
-    matterbridgeDevice.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy), {
-      colorCapabilities: { xy: true, hueSaturation: true, colorLoop: false, enhancedHue: false, colorTemperature: false },
-      colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
-      enhancedColorMode: ColorControl.EnhancedColorMode.CurrentHueAndCurrentSaturation,
-      options: { executeIfOff: false },
-      numberOfPrimaries: null,
-      currentX: 24939,
-      currentY: 24701,
-      currentHue: 0,
-      currentSaturation: 0,
-    });
-// node dist/matterbridgeEdge.js MatterbridgeEdge -debug -ssl -frontend 443
-if (process.argv.includes('MatterbridgeEdge')) {
-  const matterbridge = await MatterbridgeEdge.loadInstance(true);
-
-  process.on('SIGINT', async function () {
-    // eslint-disable-next-line no-console
-    console.log('Caught interrupt signal');
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    if (matterbridge) await (matterbridge as any).cleanup('shutting down...', false);
-    // if (matterbridge && matterbridge.matterServerNode && matterbridge.matterServerNodeContext) await matterbridge.stopServerNode(matterbridge.matterServerNode, matterbridge.matterServerNodeContext);
-    const exit = setTimeout(() => {
-      // eslint-disable-next-line no-console
-      console.log('Exiting after caught interrupt signal');
-      process.exit();
-    }, 10000);
-    exit.unref();
-  });
-}
-*/
-/*
-async startBridgeNode(): Promise<void> {
-this.log.notice(`Creating lightEndpoint1`);
-const lightEndpoint1 = new Endpoint(OnOffLightDevice.with(BridgedDeviceBasicInformationServer), {
-  id: 'OnOffLight',
-  bridgedDeviceBasicInformation: {
-    vendorId: VendorId(await storageContext.get<number>('vendorId')),
-    vendorName: await storageContext.get<string>('vendorName'),
-
-    productName: 'Light',
-    productLabel: 'Light',
-    nodeLabel: 'Light',
-
-    serialNumber: 'SN 0x123456789',
-    uniqueId: '0x123456789',
-    reachable: true,
-  },
-});
-this.log.notice(`Adding lightEndpoint1 to ${await storageContext.get<string>('storeId')} aggregator`);
-await this.matterAggregatorNode.add(lightEndpoint1);
-// logEndpoint(EndpointServer.forEndpoint(lightEndpoint1));
-
-this.log.notice(`Creating switchEnpoint2`);
-const switchEnpoint2 = new Endpoint(GenericSwitchDevice.with(BridgedDeviceBasicInformationServer, SwitchServer.with('MomentarySwitch', 'MomentarySwitchLongPress', 'MomentarySwitchMultiPress', 'MomentarySwitchRelease')), {
-  id: 'GenericSwitch',
-  bridgedDeviceBasicInformation: {
-    vendorId: VendorId(await storageContext.get<number>('vendorId')),
-    vendorName: await storageContext.get<string>('vendorName'),
-
-    productName: 'GenericSwitch',
-    productLabel: 'GenericSwitch',
-    nodeLabel: 'GenericSwitch',
-
-    serialNumber: 'SN 0x123456739',
-    uniqueId: '0x123456739',
-    reachable: true,
-  },
-  switch: {
-    numberOfPositions: 2,
-    currentPosition: 0,
-    multiPressMax: 2,
-  },
-});
-this.log.notice(`Adding switchEnpoint2 to ${await storageContext.get<string>('storeId')} aggregator`);
-await this.matterAggregatorNode.add(switchEnpoint2);
-// logEndpoint(EndpointServer.forEndpoint(switchEnpoint2));
-
-// switchEnpoint2.events.identify.startIdentifying.on(() => this.log.notice('GenericSwitch.identify logic, ideally blink a light every 0.5s ...'));
-// switchEnpoint2.events.switch.currentPosition$Changed.on(() => this.log.notice('GenericSwitch.currentPosition changed ...'));
-// switchEnpoint2.act((agent) => agent.switch.events.initialPress.emit({ newPosition: 1 }, agent.context));
-// switchEnpoint2.events.switch.emit('initialPress', { newPosition: 1 }, switchEnpoint2.events.switch.context);
-*/
-/*
-log.notice(`Creating matterbridge device ClimateSensor`);
-const matterbridgeDevice3 = new MatterbridgeDeviceV8(DeviceTypes.TEMPERATURE_SENSOR, { uniqueStorageKey: 'ClimateSensor' });
-matterbridgeDevice3.addDeviceTypeWithClusterServer([DeviceTypes.TEMPERATURE_SENSOR], [TemperatureMeasurement.Cluster.id]);
-matterbridgeDevice3.addDeviceTypeWithClusterServer([DeviceTypes.HUMIDITY_SENSOR], [RelativeHumidityMeasurement.Cluster.id]);
-matterbridgeDevice3.addDeviceTypeWithClusterServer([DeviceTypes.PRESSURE_SENSOR], [PressureMeasurement.Cluster.id]);
-matterbridgeDevice3.behaviors.require(IdentifyServer, {
-  identifyTime: 5,
-});
-matterbridgeDevice3.behaviors.require(TemperatureMeasurementServer, {
-  measuredValue: 25.0,
-  minMeasuredValue: null,
-  maxMeasuredValue: null,
-});
-*/
-/*
-log.notice(`Adding BridgedDeviceBasicInformationServer to ClimateSensor`);
-matterbridgeDevice3.behaviors.require(BridgedDeviceBasicInformationServer, {
-  vendorId: VendorId(await storageContext.get<number>('vendorId')),
-  vendorName: await storageContext.get<string>('vendorName'),
-
-  productName: 'ClimateSensor',
-  productLabel: 'ClimateSensor',
-  nodeLabel: 'ClimateSensor',
-
-  serialNumber: '0x145433356739',
-  uniqueId: '0x1254446739',
-  reachable: true,
-});
-
-log.notice(`Adding DescriptorServer to ClimateSensor`);
-matterbridgeDevice3.behaviors.require(DescriptorServer, {
-  deviceTypeList: [
-    { deviceType: 0x0302, revision: 2 },
-    { deviceType: 0x0307, revision: 2 },
-    { deviceType: 0x0305, revision: 2 },
-  ],
-});
-
-this.log.notice(`Adding ClimateSensor to ${await storageContext.get<string>('storeId')} aggregator`);
-await this.matterAggregator.add(matterbridgeDevice3);
-logEndpoint(EndpointServer.forEndpoint(matterbridgeDevice3));
-*/
-/*
-await lightEndpoint1.set({
-  onOff: {
-    onOff: true,
-  },
-});
-await switchEnpoint2.set({
-  switch: {
-    currentPosition: 1,
-  },
-});
-switchEnpoint2.act((agent) => agent.switch.events.initialPress.emit({ newPosition: 1 }, agent.context));
-*/
-/*
-await matterbridgeDevice3.set({
-  temperatureMeasurement: {
-    measuredValue: 20 * 100,
-  },
-  relativeHumidityMeasurement: {
-    measuredValue: 50 * 100,
-  },
-});
-*/
-// logEndpoint(EndpointServer.forEndpoint(this.matterServerNode));
-/*
-logEndpoint(EndpointServer.forEndpoint(this.matterServerNode));
-logEndpoint(EndpointServer.forEndpoint(matterbridgeDevice3));
-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 ...'));
-}
-*/
-//# sourceMappingURL=matterbridgeEdge.js.map