matterbridge 1.6.6-dev.9 → 1.6.7-dev.1

package/CHANGELOG.md

@@ -4,37 +4,62 @@ All notable changes to this project will be documented in this file.
 
 If you like this project and find it useful, please consider giving it a star on GitHub at https://github.com/Luligu/matterbridge and sponsoring it.
 
-### Home Assistant Community Add-ons
+### Home Assistant
 
-The Home Assistant Community Add-ons and plugins are not verified to work with Matterbridge. I strongly advise against using them. If you do use them and encounter an issue (which is likely because some do not meet the Matterbridge guidelines), please do not open an issue in the Matterbridge repository.
-
-If you want to run Matterbridge in Home Assistant please use the official add-on https://github.com/Luligu/matterbridge-home-assistant-addon that also has Ingress and side panel.
+If you want to run Matterbridge in Home Assistant please use the official add-on https://github.com/Luligu/matterbridge-home-assistant-addon that also has Ingress and side panel. 
+It is also available the official Matterbridge Home Assistant plugin https://github.com/Luligu/matterbridge-hass.
 
 ### Discord
 
 Tamer (https://github.com/tammeryousef1006) has created the Matterbridge Discord group: https://discord.gg/QX58CDe6hd.
 
-## [1.6.6] - 2024-12-06
+### Breaking Changes
+
+In this release some device types and the OnOff, LevelControl and ColorControl have been updated to be fully compliant with Matter 1.3 specifications.
+It is possible that some controllers see them as new devices or need time to read the new clusters. It can be useful after the upgrade to power off the controller, wait a few minutes and power it on again.
+
+## [1.6.7-dev.1] - 2024-12-??
+
+### Added
+
+- [readme]: Update README to clarify Node.js installation instructions and emphasize LTS version.
+
+### Changed
+
+- [Docker]: Add matterbridge-hass to Dockerfile for latest and main builds.
+- [package]: Update dependencies.
+
+### Fixed
+
+- [Device]: Fix addChildDeviceType methods to include debug parameter in MatterbridgeDevice instantiation.
+
+## [1.6.6] - 2024-12-12
 
 ### Added
 
-- [frontend]: Add the possibility to install a specific version or the dev of any plugin (i.e. you can install matterbridge-hass@dev or matterbridge-hass@0.0.3).
+- [frontend]: Added the possibility to install a specific version or the dev of any plugin (i.e. you can install matterbridge-hass@dev or matterbridge-hass@0.0.3).
   It is also possible to use the install plugin to install a specific version of matterbridge (i.e. you can install matterbridge@dev or matterbridge@1.6.5)
-- [frontend]: Add the possibility to set the matter discriminator for commissioning (you can always override passing **-discriminator [DISCRIMINATOR]** on the command line).
-- [frontend]: Add the possibility to set the matter passcode for commissioning (you can always override passing **-passcode [PASSCODE]** on the command line).
-- [frontend]: Add the possibility to set the matter port for commissioning (you can always override passing **-port [PORT]** on the command line).
-- [deviceTypes]: Add device type airConditioner (not supported by the Apple Home).
-- [docker]: Add matterbridge-hass to docker dev.
+- [frontend]: Added the possibility to set the matter discriminator for commissioning (you can always override passing **-discriminator [DISCRIMINATOR]** on the command line).
+- [frontend]: Added the possibility to set the matter passcode for commissioning (you can always override passing **-passcode [PASSCODE]** on the command line).
+- [frontend]: Added the possibility to set the matter port for commissioning (you can always override passing **-port [PORT]** on the command line).
+- [deviceTypes]: Added the device type airConditioner (not supported by the Apple Home).
+- [docker]: Added matterbridge-hass to docker dev.
 - [platform]: Added validateDeviceWhiteBlackList and validateEntityBlackList to be used consistently by all plugins.
+- [/api/devices]: Added productUrl and configUrl.
 
 ### Changed
 
 - [package]: Update matter.js to 0.11.9-alpha.0-20241206-22f23333.
 - [package]: Update matter.js to 0.11.9-alpha.0-20241207-b604cfa44
+- [package]: Update matter.js to 0.11.9-alpha.0-20241209-06a8040e1
+- [package]: Update matter.js to 0.11.9
 - [plugin]: Removed check on package types since we are moving to production plugins.
 - [package]: Set required node version to 18, 20 and 22.
 - [package]: Update dependencies.
-- [levelControl]: Set default to OnOff.Feature.Lighting.
+- [onOff]: Set default to OnOff.Feature.Lighting.
+- [levelControl]: Set default to LevelControl.Feature.Lighting.
+- [colorControl]: Set default cluster helpers to have ColorTemperature.
+- [lightSensor]: Refactor lightSensor removing Group optional cluster server.
 - [jest]: Update Jest tests.
 
 ### Fixed

package/README-DEV.md

@@ -71,9 +71,9 @@ I added some error messages when a plugin has wrong imports or configurations an
 
 I'm working with matter.js team to define the strategy for the migration of Matterbridge to the new API.
 
-- First phase: crete MatterbridgeEdge class: completed 90%
-- Second phase: create MatterbridgeEndpoint and MatterbridgeBehaviors classes: completed 90%
-- Third phase: modifiy all plugins to support both normal and edge mode of Matterbridge: completed 80%
+- First phase: create MatterbridgeEdge class: completed 95%
+- Second phase: create MatterbridgeEndpoint and MatterbridgeBehaviors classes: completed 95%
+- Third phase: modifiy all plugins to support both normal and edge mode of Matterbridge: completed 90%
 - Fourth phase: remove all old api code from Matterbridge and all plugins...
 
 ## How to create your plugin

package/README.md

@@ -44,7 +44,13 @@ A special thank to Apollon77 for his incredible work.
 
 ## Prerequisites
 
-To run Matterbridge, you need either a [Node.js](https://nodejs.org/en/download/package-manager) environment or [Docker](https://docs.docker.com/get-started/get-docker/) installed on your system.
+To run Matterbridge, you need either a [Node.js](https://nodejs.org/en) environment or [Docker](https://docs.docker.com/get-started/get-docker/) installed on your system.
+
+If you don't have Node.js already install, please use this method to install it on a debian device: https://github.com/nodesource/distributions. 
+The supported versions of node are 18, 20 and 22. Please install node 22 LTS.
+Nvm is not a good choice and should not be used for production.
+
+If you don't have Docker already install, please use this method to install it on a debian device: https://docs.docker.com/desktop/setup/install/linux/debian/.
 
 ## Installation
 
@@ -372,7 +378,7 @@ Then, from the dots menu in the frontend, download the `matterbridge.log` and `m
 
 # Known general issues
 
-## Session XYZ does not exist
+## Session XYZ does not exist or Cannot find a session for ID XYZ
 
 This message may appear after Matterbridge restarts, indicating that the controller is still using a session from the previous connection that has since been closed.
 After some time, the controller will reconnect.

package/dist/matterbridge.js

@@ -60,6 +60,7 @@ export class Matterbridge extends EventEmitter {
         bridgeMode: '',
         restartMode: '',
         edge: hasParameter('edge'),
+        readOnly: hasParameter('readonly'),
         profile: getParameter('profile'),
         loggerLevel: "info",
         fileLogger: false,
@@ -201,8 +202,9 @@ export class Matterbridge extends EventEmitter {
             throw new Error('Fatal error creating node storage manager and context for matterbridge');
         }
         this.port = getIntParameter('port') ?? (await this.nodeContext.get('matterport', 5540)) ?? 5540;
-        this.passcode = getIntParameter('passcode') ?? (await this.nodeContext.get('matterpasscode'));
-        this.discriminator = getIntParameter('discriminator') ?? (await this.nodeContext.get('matterdiscriminator'));
+        this.passcode = this.passcode ?? getIntParameter('passcode') ?? (await this.nodeContext.get('matterpasscode'));
+        this.discriminator = this.discriminator ?? getIntParameter('discriminator') ?? (await this.nodeContext.get('matterdiscriminator'));
+        this.log.debug(`Initializing commissioning server for Matterbridge... on port ${this.port} with passcode ${this.passcode} and discriminator ${this.discriminator}`);
         if (hasParameter('logger')) {
             const level = getParameter('logger');
             if (level === 'debug') {
@@ -2335,7 +2337,7 @@ export class Matterbridge extends EventEmitter {
         });
         this.expressApp.get('/api/devices', (req, res) => {
             this.log.debug('The frontend sent /api/devices');
-            const data = [];
+            const devices = [];
             this.devices.forEach(async (device) => {
                 const pluginName = device.plugin ?? 'Unknown';
                 if (this.edge)
@@ -2346,21 +2348,26 @@ export class Matterbridge extends EventEmitter {
                 let serial = device.getClusterServer(BasicInformationCluster)?.attributes.serialNumber?.getLocal();
                 if (!serial)
                     serial = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.serialNumber?.getLocal() ?? 'Unknown';
+                let productUrl = device.getClusterServer(BasicInformationCluster)?.attributes.productUrl?.getLocal();
+                if (!productUrl)
+                    productUrl = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.productUrl?.getLocal() ?? 'Unknown';
                 let uniqueId = device.getClusterServer(BasicInformationCluster)?.attributes.uniqueId?.getLocal();
                 if (!uniqueId)
                     uniqueId = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.uniqueId?.getLocal() ?? 'Unknown';
                 const cluster = this.getClusterTextFromDevice(device);
-                data.push({
+                devices.push({
                     pluginName,
                     type: device.name + ' (0x' + device.deviceType.toString(16).padStart(4, '0') + ')',
                     endpoint: device.number,
                     name,
                     serial,
+                    productUrl,
+                    configUrl: device.configUrl,
                     uniqueId,
                     cluster: cluster,
                 });
             });
-            res.json(data);
+            res.json(devices);
         });
         this.expressApp.get('/api/devices_clusters/:selectedPluginName/:selectedDeviceEndpoint', (req, res) => {
             const selectedPluginName = req.params.selectedPluginName;

package/dist/matterbridgeBehaviors.js

@@ -23,6 +23,10 @@ export class MatterbridgeBehaviorDevice {
         this.log.info(`Identifying device for ${identifyTime} seconds`);
         this.commandHandler.executeHandler('identify', { request: { identifyTime }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
     }
+    triggerEffect({ effectIdentifier, effectVariant }) {
+        this.log.info(`Triggering effect ${effectIdentifier} variant ${effectVariant}`);
+        this.commandHandler.executeHandler('triggerEffect', { request: { effectIdentifier, effectVariant }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
+    }
     on() {
         this.log.info(`Switching device on (endpoint ${this.endpointId}.${this.endpointNumber})`);
         this.commandHandler.executeHandler('on', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
@@ -125,6 +129,11 @@ export class MatterbridgeIdentifyServer extends IdentifyServer {
         device.identify({ identifyTime });
         super.identify({ identifyTime });
     }
+    triggerEffect({ effectIdentifier, effectVariant }) {
+        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        device.triggerEffect({ effectIdentifier, effectVariant });
+        super.triggerEffect({ effectIdentifier, effectVariant });
+    }
 }
 export class MatterbridgeOnOffServer extends OnOffServer {
     async on() {

package/dist/matterbridgeDevice.js

@@ -12,6 +12,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     static logLevel = "info";
     log;
     plugin = undefined;
+    configUrl = undefined;
     serialNumber = undefined;
     deviceName = undefined;
     uniqueId = undefined;
@@ -80,7 +81,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
         this.log.debug(`addChildDeviceType: ${CYAN}${endpointName}${db}`);
         let child = this.getChildEndpoints().find((endpoint) => endpoint.uniqueStorageKey === endpointName);
         if (!child) {
-            child = new MatterbridgeDevice(deviceTypes, { uniqueStorageKey: endpointName });
+            child = new MatterbridgeDevice(deviceTypes, { uniqueStorageKey: endpointName }, debug);
             if ('tagList' in options) {
                 for (const tag of options.tagList) {
                     this.log.debug(`- with tagList: mfgCode ${CYAN}${tag.mfgCode}${db} namespaceId ${CYAN}${tag.namespaceId}${db} tag ${CYAN}${tag.tag}${db} label ${CYAN}${tag.label}${db}`);
@@ -104,7 +105,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
         this.log.debug(`addChildDeviceTypeWithClusterServer: ${CYAN}${endpointName}${db}`);
         let child = this.getChildEndpoints().find((endpoint) => endpoint.uniqueStorageKey === endpointName);
         if (!child) {
-            child = new MatterbridgeDevice(deviceTypes, { uniqueStorageKey: endpointName });
+            child = new MatterbridgeDevice(deviceTypes, { uniqueStorageKey: endpointName }, debug);
             if ('tagList' in options) {
                 for (const tag of options.tagList) {
                     this.log.debug(`- with tagList: mfgCode ${CYAN}${tag.mfgCode}${db} namespaceId ${CYAN}${tag.namespaceId}${db} tag ${CYAN}${tag.tag}${db} label ${CYAN}${tag.label}${db}`);
@@ -458,6 +459,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             vendorName: vendorName.slice(0, 32),
             productId: productId,
             productName: productName.slice(0, 32),
+            productUrl: 'https://www.npmjs.com/package/matterbridge',
             productLabel: deviceName.slice(0, 64),
             nodeLabel: deviceName.slice(0, 32),
             serialNumber: serialNumber.slice(0, 32),
@@ -502,6 +504,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             vendorId: vendorId !== undefined ? VendorId(vendorId) : undefined,
             vendorName: vendorName.slice(0, 32),
             productName: productName.slice(0, 32),
+            productUrl: 'https://www.npmjs.com/package/matterbridge',
             productLabel: deviceName.slice(0, 64),
             nodeLabel: deviceName.slice(0, 32),
             serialNumber: serialNumber.slice(0, 32),
@@ -644,12 +647,14 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     createDefaultOnOffClusterServer(onOff = false, globalSceneControl = false, onTime = 0, offWaitTime = 0, startUpOnOff = null) {
         this.addClusterServer(this.getDefaultOnOffClusterServer(onOff, globalSceneControl, onTime, offWaitTime, startUpOnOff));
     }
-    getDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 0, maxLevel = 254, onLevel = null) {
-        return ClusterServer(LevelControlCluster.with(LevelControl.Feature.OnOff), {
+    getDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 1, maxLevel = 254, onLevel = null, startUpCurrentLevel = null) {
+        return ClusterServer(LevelControlCluster.with(LevelControl.Feature.OnOff, LevelControl.Feature.Lighting), {
             currentLevel,
             minLevel,
             maxLevel,
             onLevel,
+            remainingTime: 0,
+            startUpCurrentLevel,
             options: {
                 executeIfOff: false,
                 coupleColorTempToLevel: false,
@@ -683,8 +688,8 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             },
         });
     }
-    createDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 0, maxLevel = 254, onLevel = null) {
-        this.addClusterServer(this.getDefaultLevelControlClusterServer(currentLevel, minLevel, maxLevel, onLevel));
+    createDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 1, maxLevel = 254, onLevel = null, startUpCurrentLevel = null) {
+        this.addClusterServer(this.getDefaultLevelControlClusterServer(currentLevel, minLevel, maxLevel, onLevel, startUpCurrentLevel));
     }
     getDefaultColorControlClusterServer(currentX = 0, currentY = 0, currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         return ClusterServer(ColorControlCluster.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.ColorTemperature), {
@@ -703,6 +708,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
             coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
+            remainingTime: 0,
             startUpColorTemperatureMireds: null,
         }, {
             moveToColor: async (data) => {
@@ -757,17 +763,23 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     createDefaultColorControlClusterServer(currentX = 0, currentY = 0, currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         this.addClusterServer(this.getDefaultColorControlClusterServer(currentX, currentY, currentHue, currentSaturation, colorTemperatureMireds, colorTempPhysicalMinMireds, colorTempPhysicalMaxMireds));
     }
-    getXyColorControlClusterServer(currentX = 0, currentY = 0) {
-        return ClusterServer(ColorControlCluster.with(ColorControl.Feature.Xy), {
+    getXyColorControlClusterServer(currentX = 0, currentY = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+        return ClusterServer(ColorControlCluster.with(ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentXAndCurrentY,
             enhancedColorMode: ColorControl.EnhancedColorMode.CurrentXAndCurrentY,
-            colorCapabilities: { xy: true, hueSaturation: false, colorLoop: false, enhancedHue: false, colorTemperature: false },
+            colorCapabilities: { xy: true, hueSaturation: false, colorLoop: false, enhancedHue: false, colorTemperature: true },
             options: {
                 executeIfOff: false,
             },
             numberOfPrimaries: null,
             currentX,
             currentY,
+            colorTemperatureMireds,
+            colorTempPhysicalMinMireds,
+            colorTempPhysicalMaxMireds,
+            coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
+            startUpColorTemperatureMireds: null,
+            remainingTime: 0,
         }, {
             moveToColor: async (data) => {
                 this.log.debug('Matter command: moveToColor request:', data.request, 'attributes.currentX:', data.attributes.currentX.getLocal(), 'attributes.currentY:', data.attributes.currentY.getLocal());
@@ -782,22 +794,38 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             stopMoveStep: async () => {
                 this.log.error('Matter command: stopMoveStep not implemented');
             },
+            moveToColorTemperature: async ({ request, attributes, endpoint }) => {
+                this.log.debug('Matter command: moveToColorTemperature request:', request, 'attributes.colorTemperatureMireds:', attributes.colorTemperatureMireds.getLocal());
+                this.commandHandler.executeHandler('moveToColorTemperature', { request, attributes, endpoint });
+            },
+            moveColorTemperature: async () => {
+                this.log.error('Matter command: moveColorTemperature not implemented');
+            },
+            stepColorTemperature: async () => {
+                this.log.error('Matter command: stepColorTemperature not implemented');
+            },
         }, {});
     }
-    createXyColorControlClusterServer(currentX = 0, currentY = 0) {
-        this.addClusterServer(this.getXyColorControlClusterServer(currentX, currentY));
+    createXyColorControlClusterServer(currentX = 0, currentY = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+        this.addClusterServer(this.getXyColorControlClusterServer(currentX, currentY, colorTemperatureMireds, colorTempPhysicalMinMireds, colorTempPhysicalMaxMireds));
     }
-    getHsColorControlClusterServer(currentHue = 0, currentSaturation = 0) {
-        return ClusterServer(ColorControlCluster.with(ColorControl.Feature.HueSaturation), {
+    getHsColorControlClusterServer(currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+        return ClusterServer(ColorControlCluster.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
             enhancedColorMode: ColorControl.EnhancedColorMode.CurrentHueAndCurrentSaturation,
-            colorCapabilities: { xy: false, hueSaturation: true, colorLoop: false, enhancedHue: false, colorTemperature: false },
+            colorCapabilities: { xy: false, hueSaturation: true, colorLoop: false, enhancedHue: false, colorTemperature: true },
             options: {
                 executeIfOff: false,
             },
             numberOfPrimaries: null,
             currentHue,
             currentSaturation,
+            colorTemperatureMireds,
+            colorTempPhysicalMinMireds,
+            colorTempPhysicalMaxMireds,
+            coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
+            startUpColorTemperatureMireds: null,
+            remainingTime: 0,
         }, {
             moveToHue: async ({ request, attributes, endpoint }) => {
                 this.log.debug('Matter command: moveToHue request:', request, 'attributes.currentHue:', attributes.currentHue.getLocal());
@@ -826,10 +854,20 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             stopMoveStep: async () => {
                 this.log.error('Matter command: stopMoveStep not implemented');
             },
+            moveToColorTemperature: async ({ request, attributes, endpoint }) => {
+                this.log.debug('Matter command: moveToColorTemperature request:', request, 'attributes.colorTemperatureMireds:', attributes.colorTemperatureMireds.getLocal());
+                this.commandHandler.executeHandler('moveToColorTemperature', { request, attributes, endpoint });
+            },
+            moveColorTemperature: async () => {
+                this.log.error('Matter command: moveColorTemperature not implemented');
+            },
+            stepColorTemperature: async () => {
+                this.log.error('Matter command: stepColorTemperature not implemented');
+            },
         }, {});
     }
-    createHsColorControlClusterServer(currentHue = 0, currentSaturation = 0) {
-        this.addClusterServer(this.getHsColorControlClusterServer(currentHue, currentSaturation));
+    createHsColorControlClusterServer(currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+        this.addClusterServer(this.getHsColorControlClusterServer(currentHue, currentSaturation, colorTemperatureMireds, colorTempPhysicalMinMireds, colorTempPhysicalMaxMireds));
     }
     getCtColorControlClusterServer(colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         return ClusterServer(ColorControlCluster.with(ColorControl.Feature.ColorTemperature), {
@@ -844,6 +882,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
             coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
+            remainingTime: 0,
             startUpColorTemperatureMireds: null,
         }, {
             stopMoveStep: async () => {

package/dist/matterbridgeDeviceTypes.js

@@ -116,7 +116,6 @@ export const lightSensor = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, IlluminanceMeasurement.Cluster.id],
-    optionalClientClusters: [Groups.Cluster.id],
 });
 export const occupancySensor = DeviceTypeDefinition({
     name: 'MA-occupancysensor',

package/dist/matterbridgeEdge.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import os from 'os';
 import { randomBytes } from 'crypto';
-import { rs, GREEN, debugStringify, er, zb, nf } from 'node-ansi-logger';
+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';
@@ -9,7 +9,7 @@ import { copyDirectory, getParameter, hasParameter } from './utils/utils.js';
 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';
@@ -45,6 +45,11 @@ export class MatterbridgeEdge extends Matterbridge {
         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);
+        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();
         if (this.mdnsInterface)
             this.environment.vars.set('mdns.networkInterface', this.mdnsInterface);
@@ -74,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'))
@@ -85,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;
@@ -143,7 +150,7 @@ 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')}`);
@@ -284,7 +291,7 @@ export class MatterbridgeEdge extends Matterbridge {
     async addBridgedEndpoint(pluginName, device) {
         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;
         }
         if (this.bridgeMode === 'bridge') {
@@ -304,11 +311,59 @@ export class MatterbridgeEdge extends Matterbridge {
         if (plugin.addedDevices !== undefined)
             plugin.addedDevices++;
         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) {
+        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) {
+        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'))
@@ -330,7 +385,7 @@ 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) => {
@@ -363,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 });