matterbridge-zigbee2mqtt 2.4.7 → 2.5.0-dev.2

package/CHANGELOG.md

@@ -8,6 +8,39 @@ If you like this project and find it useful, please consider giving it a star on
   <img src="bmc-button.svg" alt="Buy me a coffee" width="120">
 </a>
 
+### Breaking Changes
+
+New device types:
+
+- extendedColorLight
+- waterLeakDetector
+- rainSensor
+- smokeSensor
+
+If your controller has issues detecting the new device type, blacklist these devices, restart, wait 5 minutes, remove the blacklist and restart again. This will create a new endpoint on the controller.
+
+## [2.5.0] - 2025-05-21
+
+### Added
+
+- [scenes]: Added scenes support for groups and devices. See the README.md for explanations.
+- [waterLeak]: Added waterLeakDetector device type for zigbee property "water_leak". Default to false (i.e. no alarm) since is not possible to get the property.
+- [rainSensor]: Added rainSensor device type for zigbee property "rain". Default to false (i.e. no alarm) since is not possible to get the property.
+- [smokeSensor]: Added smokeSensor device type for zigbee property "smoke". Default to false (i.e. no alarm) since is not possible to get the property.
+- [colorTemp]: Added conversion from color temperature to rgb for the devices that doesn't support color temperature.
+
+### Changed
+
+- [package]: Updated package.
+- [package]: Updated dependencies.
+- [plugin]: Requires Matterbridge 3.0.3.
+- [config]: As anticipated in the previous release, the parameter postfixHostname has been removed. Use postfix if needed.
+- [colorRgb]: Changed the default device type from colorTemperatureLight to extendedColorLight to solve the SmartThings issue with colors.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [2.4.7] - 2025-03-19
 
 ### Added

package/README.md

@@ -17,7 +17,7 @@ Matterbridge zigbee2mqtt is a matterbridge production-level plugin that expose a
 
 No hub or dedicated hardware needed.
 
-Interested in super fast and autonomous automations for zigbee2mqtt? Try this: https://github.com/Luligu/zigbee2mqtt-automations
+Interested in super fast and autonomous **[automations for zigbee2mqtt](https://github.com/Luligu/zigbee2mqtt-automations)**? Try this: https://github.com/Luligu/zigbee2mqtt-automations.
 
 If you like this project and find it useful, please consider giving it a star on GitHub at https://github.com/Luligu/matterbridge-zigbee2mqtt and sponsoring it.
 
@@ -150,8 +150,9 @@ These are the default vules:
   "outletList": [],
   "featureBlackList": [],
   "deviceFeatureBlackList": {},
-  "postfix": "",
-  "postfixHostname": true
+  "scenesType": "outlet",
+  "scenesPrefix: true,
+  "postfix": ""
 }
 ```
 
@@ -250,6 +251,20 @@ If one of your devices is not supported out of the box, open an issue and we wil
 
 ![See the screenshot here](https://github.com/Luligu/matterbridge-zigbee2mqtt/blob/main/screenshot/Smart%20button.png)
 
+## Scenes in groups and devices
+
+With release 2.5.0 has been added support for scenes in groups and devices.
+
+In the config select what device type you want to use to expose the command that runs the scene: 'light' | 'outlet' | 'switch' | 'mounted_switch'.
+
+Switch is not supported by Alexa. Mounted Switch is not supported by Apple Home.
+
+The virtual device takes the name of the group or device it belongs to, with added the name of scene. If scenesPrefix is disabled, it takes only the name of the scene. Consider that in Matter the node name is 32 characters long.
+
+The state of the virtual device is always reverted to off in a few seconds.
+
+It is possibile to disable the feature globally with featureBlackList and on a per device/group base with deviceFeatureBlackList.
+
 # Known issues
 
 For general controller issues check the Matterbridge Known issues section

package/dist/entity.js

@@ -1,12 +1,11 @@
-import { airQualitySensor, colorTemperatureSwitch, dimmableSwitch, onOffSwitch, powerSource, bridgedNode, electricalSensor, onOffLight, dimmableLight, colorTemperatureLight, onOffOutlet, coverDevice, thermostatDevice, MatterbridgeEndpoint, dimmableOutlet, doorLockDevice, occupancySensor, lightSensor, contactSensor, temperatureSensor, humiditySensor, pressureSensor, genericSwitch, } from 'matterbridge';
+import { airQualitySensor, colorTemperatureSwitch, dimmableSwitch, onOffSwitch, powerSource, bridgedNode, electricalSensor, onOffLight, dimmableLight, colorTemperatureLight, onOffOutlet, coverDevice, thermostatDevice, MatterbridgeEndpoint, dimmableOutlet, doorLockDevice, occupancySensor, lightSensor, contactSensor, temperatureSensor, humiditySensor, pressureSensor, genericSwitch, waterLeakDetector, rainSensor, smokeCoAlarm, extendedColorLight, } from 'matterbridge';
 import { AnsiLogger, gn, dn, ign, idn, rs, db, debugStringify, hk, zb, or, nf, CYAN, er, YELLOW } from 'matterbridge/logger';
-import { deepCopy, deepEqual, isValidNumber } from 'matterbridge/utils';
+import { deepCopy, deepEqual, isValidNumber, kelvinToRGB, miredToKelvin } from 'matterbridge/utils';
 import * as color from 'matterbridge/utils';
 import { SwitchesTag, NumberTag } from 'matterbridge/matter';
 import { getClusterNameById, ClusterId } from 'matterbridge/matter/types';
-import { ElectricalEnergyMeasurement, ElectricalPowerMeasurement, OnOffCluster, LevelControlCluster, WindowCoveringCluster, DoorLockCluster, BridgedDeviceBasicInformation, OnOff, LevelControl, ColorControl, ColorControlCluster, TemperatureMeasurement, BooleanState, RelativeHumidityMeasurement, PressureMeasurement, OccupancySensing, IlluminanceMeasurement, PowerSource, WindowCovering, DoorLock, ThermostatCluster, Thermostat, AirQuality, TotalVolatileOrganicCompoundsConcentrationMeasurement, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FormaldehydeConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, Pm10ConcentrationMeasurement, } from 'matterbridge/matter/clusters';
+import { ElectricalEnergyMeasurement, ElectricalPowerMeasurement, OnOffCluster, LevelControlCluster, WindowCoveringCluster, DoorLockCluster, BridgedDeviceBasicInformation, OnOff, LevelControl, ColorControl, ColorControlCluster, TemperatureMeasurement, BooleanState, RelativeHumidityMeasurement, PressureMeasurement, OccupancySensing, IlluminanceMeasurement, PowerSource, WindowCovering, DoorLock, ThermostatCluster, Thermostat, AirQuality, TotalVolatileOrganicCompoundsConcentrationMeasurement, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FormaldehydeConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, Pm10ConcentrationMeasurement, SmokeCoAlarm, } from 'matterbridge/matter/clusters';
 import EventEmitter from 'node:events';
-import { hostname } from 'node:os';
 export class ZigbeeEntity extends EventEmitter {
     log;
     serial = '';
@@ -110,7 +109,7 @@ export class ZigbeeEntity extends EventEmitter {
                     const propertyMap = this.propertyMap.get(('action_' + value));
                     if (propertyMap) {
                         const child = this.bridgedDevice.getChildEndpointByName(propertyMap.endpoint);
-                        if (child && child.number)
+                        if (child && child.maybeNumber)
                             child.triggerSwitchEvent(propertyMap.action, this.log);
                     }
                     else
@@ -294,11 +293,11 @@ export class ZigbeeEntity extends EventEmitter {
         }
         const localValue = deviceEndpoint.getAttribute(ClusterId(clusterId), attributeName, undefined);
         if (typeof value === 'object' ? deepEqual(value, localValue) : value === localValue) {
-            this.log.debug(`Skip update endpoint ${deviceEndpoint.name}:${deviceEndpoint.number}${childEndpointName ? ' (' + childEndpointName + ')' : ''} ` +
+            this.log.debug(`Skip update endpoint ${deviceEndpoint.name}:${deviceEndpoint.maybeNumber}${childEndpointName ? ' (' + childEndpointName + ')' : ''} ` +
                 `attribute ${getClusterNameById(ClusterId(clusterId))}.${attributeName} already ${typeof value === 'object' ? debugStringify(value) : value}`);
             return;
         }
-        this.log.info(`${db}Update endpoint ${this.eidn}${deviceEndpoint.name}:${deviceEndpoint.number}${db}${childEndpointName ? ' (' + zb + childEndpointName + db + ')' : ''} ` +
+        this.log.info(`${db}Update endpoint ${this.eidn}${deviceEndpoint.name}:${deviceEndpoint.maybeNumber}${db}${childEndpointName ? ' (' + zb + childEndpointName + db + ')' : ''} ` +
             `attribute ${hk}${getClusterNameById(ClusterId(clusterId))}${db}.${hk}${attributeName}${db} from ${YELLOW}${typeof localValue === 'object' ? debugStringify(localValue) : localValue}${db} to ${YELLOW}${typeof value === 'object' ? debugStringify(value) : value}${db}`);
         try {
             deviceEndpoint.setAttribute(ClusterId(clusterId), attributeName, value);
@@ -330,10 +329,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
     }
     static async create(platform, group) {
         const zigbeeGroup = new ZigbeeGroup(platform, group);
-        if (zigbeeGroup.platform.postfixHostname) {
-            zigbeeGroup.serial = `group-${group.id}_${hostname}`.slice(0, 32);
-        }
-        else if (zigbeeGroup.platform.postfix !== '') {
+        if (zigbeeGroup.platform.postfix !== '') {
             zigbeeGroup.serial = `group-${group.id}-${zigbeeGroup.platform.postfix}`.slice(0, 32);
         }
         else {
@@ -419,7 +415,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
                 zigbeeGroup.propertyMap.set('color_temp', { name: 'color_temp', type: 'light', endpoint: '' });
             }
             if (useColor) {
-                deviceType = colorTemperatureLight;
+                deviceType = extendedColorLight;
                 zigbeeGroup.propertyMap.set('color', { name: 'color', type: 'light', endpoint: '' });
             }
             if (isCover) {
@@ -440,9 +436,14 @@ export class ZigbeeGroup extends ZigbeeEntity {
                 return zigbeeGroup;
             zigbeeGroup.bridgedDevice = new MatterbridgeEndpoint([deviceType, bridgedNode, powerSource], { uniqueStorageKey: group.friendly_name }, zigbeeGroup.log.logLevel === "debug");
         }
-        if (platform.config.groupScenes === true) {
+        if (!platform.featureBlackList?.includes('scenes') && !platform.deviceFeatureBlackList[group.friendly_name]?.includes('scenes')) {
             group.scenes.forEach((scene) => {
                 zigbeeGroup.log.debug(`***Group ${gn}${group.friendly_name}${rs}${db} scene ${CYAN}${scene.name}${db} id ${CYAN}${scene.id}${db}`);
+                platform.setSelectDeviceEntity(`group-${group.id}`, 'scenes', 'Scenes', 'component');
+                platform.registerVirtualDevice(`${platform.config.scenesPrefix ? group.friendly_name + ' ' : ''}${scene.name}`, async () => {
+                    zigbeeGroup.log.info(`Triggered scene "${scene.name}" id ${scene.id} from group ${group.friendly_name}`);
+                    zigbeeGroup.publishCommand('scene_recall', group.friendly_name, { 'scene_recall': scene.id });
+                });
             });
         }
         zigbeeGroup.addBridgedDeviceBasicInformation();
@@ -458,7 +459,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
             if (isLight)
                 await zigbeeGroup.bridgedDevice.addFixedLabel('type', 'light');
             zigbeeGroup.bridgedDevice.addCommandHandler('identify', async ({ request: { identifyTime } }) => {
-                zigbeeGroup.log.warn(`Command identify called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} identifyTime:${identifyTime}`);
+                zigbeeGroup.log.debug(`Command identify called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} identifyTime:${identifyTime}`);
             });
             zigbeeGroup.bridgedDevice.addCommandHandler('on', async () => {
                 zigbeeGroup.log.debug(`Command on called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db}`);
@@ -520,6 +521,14 @@ export class ZigbeeGroup extends ZigbeeEntity {
                     const rgb = color.hslColorToRgbColor((request.hue / 254) * 360, (request.saturation / 254) * 100, 50);
                     zigbeeGroup.publishCommand('moveToHueAndSaturation', group.friendly_name, { color: { r: rgb.r, g: rgb.g, b: rgb.b } });
                 });
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToColor', async ({ request }) => {
+                    zigbeeGroup.log.debug(`Command moveToColor called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: X: ${request.colorX} Y: ${request.colorY}`);
+                    await zigbeeGroup.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentXAndCurrentY, zigbeeGroup.log);
+                    const payload = { color: { x: request.colorX / 65536, y: request.colorY / 65536 } };
+                    if (zigbeeGroup.transition && request.transitionTime && request.transitionTime / 10 >= 1)
+                        payload['transition'] = Math.round(request.transitionTime / 10);
+                    zigbeeGroup.publishCommand('moveToColor', group.friendly_name, payload);
+                });
             }
         }
         if (isCover) {
@@ -600,8 +609,8 @@ export const z2ms = [
     { type: 'outlet', name: 'brightness', property: 'brightness', deviceType: dimmableOutlet, cluster: LevelControl.Cluster.id, attribute: 'currentLevel', converter: (value) => { return Math.max(1, Math.min(254, value)); } },
     { type: 'light', name: 'state', property: 'state', deviceType: onOffLight, cluster: OnOff.Cluster.id, attribute: 'onOff', converter: (value) => { return value === 'ON' ? true : false; } },
     { type: 'light', name: 'brightness', property: 'brightness', deviceType: dimmableLight, cluster: LevelControl.Cluster.id, attribute: 'currentLevel', converter: (value) => { return Math.max(1, Math.min(254, value)); } },
-    { type: 'light', name: 'color_hs', property: 'color_hs', deviceType: colorTemperatureLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
-    { type: 'light', name: 'color_xy', property: 'color_xy', deviceType: colorTemperatureLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
+    { type: 'light', name: 'color_hs', property: 'color_hs', deviceType: extendedColorLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
+    { type: 'light', name: 'color_xy', property: 'color_xy', deviceType: extendedColorLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
     { type: 'light', name: 'color_temp', property: 'color_temp', deviceType: colorTemperatureLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
     { type: 'cover', name: 'state', property: 'state', deviceType: coverDevice, cluster: WindowCovering.Cluster.id, attribute: 'targetPositionLiftPercent100ths' },
     { type: 'cover', name: 'moving', property: 'moving', deviceType: coverDevice, cluster: WindowCovering.Cluster.id, attribute: 'operationalStatus' },
@@ -623,9 +632,10 @@ export const z2ms = [
     { type: '', name: 'occupancy', property: 'occupancy', deviceType: occupancySensor, cluster: OccupancySensing.Cluster.id, attribute: 'occupancy', converter: (value) => { return { occupied: value }; } },
     { type: '', name: 'illuminance', property: 'illuminance', deviceType: lightSensor, cluster: IlluminanceMeasurement.Cluster.id, attribute: 'measuredValue', converter: (value) => { return Math.round(Math.max(Math.min(10000 * Math.log10(value), 0xfffe), 0)); } },
     { type: '', name: 'contact', property: 'contact', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return value; } },
-    { type: '', name: 'water_leak', property: 'water_leak', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return !value; } },
+    { type: '', name: 'water_leak', property: 'water_leak', deviceType: waterLeakDetector, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return value; } },
+    { type: '', name: 'rain', property: 'rain', deviceType: rainSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return value; } },
     { type: '', name: 'vibration', property: 'vibration', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return !value; } },
-    { type: '', name: 'smoke', property: 'smoke', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return !value; } },
+    { type: '', name: 'smoke', property: 'smoke', deviceType: smokeCoAlarm, cluster: SmokeCoAlarm.Cluster.id, attribute: 'smokeState', converter: (value) => { return value ? SmokeCoAlarm.AlarmState.Critical : SmokeCoAlarm.AlarmState.Normal; } },
     { type: '', name: 'carbon_monoxide', property: 'carbon_monoxide', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return !value; } },
     { type: '', name: 'temperature', property: 'temperature', deviceType: temperatureSensor, cluster: TemperatureMeasurement.Cluster.id, attribute: 'measuredValue', converter: (value) => { return Math.round(value * 100); } },
     { type: '', name: 'humidity', property: 'humidity', deviceType: humiditySensor, cluster: RelativeHumidityMeasurement.Cluster.id, attribute: 'measuredValue', converter: (value) => { return Math.round(value * 100); } },
@@ -644,10 +654,10 @@ export const z2ms = [
     { type: '', name: '', property: 'battery', deviceType: powerSource, cluster: PowerSource.Cluster.id, attribute: 'batPercentRemaining', converter: (value) => { return Math.round(value * 2); } },
     { type: '', name: '', property: 'battery_low', deviceType: powerSource, cluster: PowerSource.Cluster.id, attribute: 'batChargeLevel', converter: (value) => { return value === true ? PowerSource.BatChargeLevel.Critical : PowerSource.BatChargeLevel.Ok; } },
     { type: '', name: '', property: 'battery_voltage', deviceType: powerSource, cluster: PowerSource.Cluster.id, attribute: 'batVoltage', converter: (value) => { return value; } },
-    { type: '', name: 'energy', property: 'energy', deviceType: electricalSensor, cluster: ElectricalEnergyMeasurement.Cluster.id, attribute: 'cumulativeEnergyImported', converter: (value) => { return { energy: value * 1000000 }; } },
-    { type: '', name: 'power', property: 'power', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'activePower', converter: (value) => { return value * 1000; } },
-    { type: '', name: 'voltage', property: 'voltage', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'voltage', converter: (value) => { return value * 1000; } },
-    { type: '', name: 'current', property: 'current', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'activeCurrent', converter: (value) => { return value * 1000; } },
+    { type: '', name: 'energy', property: 'energy', deviceType: electricalSensor, cluster: ElectricalEnergyMeasurement.Cluster.id, attribute: 'cumulativeEnergyImported', converter: (value) => { return { energy: Math.round(value * 1000000) }; } },
+    { type: '', name: 'power', property: 'power', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'activePower', converter: (value) => { return Math.round(value * 1000); } },
+    { type: '', name: 'voltage', property: 'voltage', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'voltage', converter: (value) => { return Math.round(value * 1000); } },
+    { type: '', name: 'current', property: 'current', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'activeCurrent', converter: (value) => { return Math.round(value * 1000); } },
 ];
 export class ZigbeeDevice extends ZigbeeEntity {
     constructor(platform, device) {
@@ -656,37 +666,42 @@ export class ZigbeeDevice extends ZigbeeEntity {
     static async create(platform, device) {
         const zigbeeDevice = new ZigbeeDevice(platform, device);
         zigbeeDevice.serial = `${device.ieee_address}`;
-        if (zigbeeDevice.platform.postfixHostname) {
-            zigbeeDevice.serial = `${zigbeeDevice.serial}_${hostname}`.slice(0, 32);
-        }
-        else if (zigbeeDevice.platform.postfix !== '') {
+        if (zigbeeDevice.platform.postfix !== '') {
             zigbeeDevice.serial = `${zigbeeDevice.serial}-${zigbeeDevice.platform.postfix}`.slice(0, 32);
         }
         if (device.friendly_name === 'Coordinator' || (device.model_id === 'ti.router' && device.manufacturer === 'TexasInstruments') || (device.model_id.startsWith('SLZB-') && device.manufacturer === 'SMLIGHT')) {
             zigbeeDevice.isRouter = true;
             platform.setSelectDevice(device.ieee_address, device.friendly_name, 'wifi');
-            zigbeeDevice.bridgedDevice = new MatterbridgeEndpoint([doorLockDevice], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
+            zigbeeDevice.bridgedDevice = new MatterbridgeEndpoint([doorLockDevice, bridgedNode, powerSource], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
             zigbeeDevice.addBridgedDeviceBasicInformation();
             zigbeeDevice.addPowerSource();
             zigbeeDevice.bridgedDevice.addRequiredClusterServers();
             await zigbeeDevice.bridgedDevice.addFixedLabel('type', 'lock');
             zigbeeDevice.verifyMutableDevice(zigbeeDevice.bridgedDevice);
+            zigbeeDevice.bridgedDevice.addCommandHandler('identify', async (data) => {
+                zigbeeDevice.log.debug(`Command identify called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request identifyTime:${data.request.identifyTime} `);
+            });
             zigbeeDevice.bridgedDevice.addCommandHandler('lockDoor', async () => {
-                zigbeeDevice.log.debug(`Command permit_join: false called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
+                zigbeeDevice.log.debug(`Command permit_join false called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(DoorLockCluster.id, 'lockState', DoorLock.LockState.Locked, zigbeeDevice.log);
-                zigbeeDevice.publishCommand('permit_join: false', 'bridge/request/permit_join', { value: false });
+                zigbeeDevice.publishCommand('permit_join false', 'bridge/request/permit_join', { value: false });
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('unlockDoor', async () => {
-                zigbeeDevice.log.debug(`Command permit_join: true called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
+                zigbeeDevice.log.debug(`Command permit_join true called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(DoorLockCluster.id, 'lockState', DoorLock.LockState.Unlocked, zigbeeDevice.log);
-                zigbeeDevice.publishCommand('permit_join: true', 'bridge/request/permit_join', { value: true });
+                zigbeeDevice.publishCommand('permit_join true', 'bridge/request/permit_join', { value: true });
             });
             return zigbeeDevice;
         }
-        if (platform.config.deviceScenes === true) {
+        if (!platform.featureBlackList?.includes('scenes') && !platform.deviceFeatureBlackList[device.friendly_name]?.includes('scenes')) {
             Object.entries(device.endpoints).forEach(([key, endpoint]) => {
                 Object.values(endpoint.scenes).forEach((scene) => {
                     zigbeeDevice.log.debug(`***Device ${dn}${device.friendly_name}${rs}${db} endpoint ${CYAN}${key}${db} scene ${CYAN}${scene.name}${db} id ${CYAN}${scene.id}${db}`);
+                    platform.setSelectDeviceEntity(device.ieee_address, 'scenes', 'Scenes', 'component');
+                    platform.registerVirtualDevice(`${platform.config.scenesPrefix ? device.friendly_name + ' ' : ''}${scene.name}`, async () => {
+                        zigbeeDevice.log.info(`Triggered scene "${scene.name}" id ${scene.id} from device ${device.friendly_name}`);
+                        zigbeeDevice.publishCommand('scene_recall', device.friendly_name, { 'scene_recall': scene.id });
+                    });
                 });
             });
         }
@@ -908,6 +923,11 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 deviceTypesMap.delete(onOffLight.code);
             if (deviceTypesMap.has(dimmableLight.code) && deviceTypesMap.has(colorTemperatureLight.code))
                 deviceTypesMap.delete(dimmableLight.code);
+            if (deviceTypesMap.has(dimmableLight.code) && deviceTypesMap.has(extendedColorLight.code))
+                deviceTypesMap.delete(dimmableLight.code);
+            if (deviceTypesMap.has(colorTemperatureLight.code) && deviceTypesMap.has(extendedColorLight.code))
+                deviceTypesMap.delete(colorTemperatureLight.code);
+            deviceTypesMap.delete(bridgedNode.code);
             deviceTypesMap.delete(powerSource.code);
             device.deviceTypes = Array.from(deviceTypesMap.values());
         }
@@ -943,12 +963,26 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${zigbeeDevice.device?.friendly_name}${rs}${db} endpoint: ${ign}${endpoint === '' ? 'main' : endpoint}${rs}${db} => ` +
                 `${nf}tagList: ${debugStringify(device.tagList)} deviceTypes: ${debugStringify(device.deviceTypes)} clusterServersIds: ${debugStringify(device.clusterServersIds)}`);
         }
+        if ((mainEndpoint.deviceTypes.find((dt) => dt.code === waterLeakDetector.code) || mainEndpoint.deviceTypes.find((dt) => dt.code === rainSensor.code)) && mainEndpoint.clusterServersIds.includes(BooleanState.Cluster.id)) {
+            zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} BooleanStateCluster cluster with`);
+            zigbeeDevice.bridgedDevice.createDefaultBooleanStateClusterServer(false);
+            mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(BooleanState.Cluster.id), 1);
+        }
+        if (mainEndpoint.deviceTypes.find((dt) => dt.code === smokeCoAlarm.code) && mainEndpoint.clusterServersIds.includes(SmokeCoAlarm.Cluster.id)) {
+            zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} SmokeCoAlarmCluster cluster with`);
+            zigbeeDevice.bridgedDevice.createSmokeOnlySmokeCOAlarmClusterServer(SmokeCoAlarm.AlarmState.Normal);
+            mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(SmokeCoAlarm.Cluster.id), 1);
+        }
         if (mainEndpoint.clusterServersIds.includes(ColorControl.Cluster.id)) {
-            zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} ColorControlCluster cluster with HS: ${names.includes('color_hs')} XY: ${names.includes('color_xy')} CT: ${names.includes('color_temp')}`);
             if (!names.includes('color_hs') && !names.includes('color_xy')) {
-                zigbeeDevice.bridgedDevice.createCtColorControlClusterServer();
-                mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(ColorControl.Cluster.id), 1);
+                zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} ColorControlCluster cluster with CT: ${names.includes('color_temp')} min: ${zigbeeDevice.propertyMap.get('color_temp')?.value_min} max: ${zigbeeDevice.propertyMap.get('color_temp')?.value_max}`);
+                zigbeeDevice.bridgedDevice.createCtColorControlClusterServer(zigbeeDevice.propertyMap.get('color_temp')?.value_max, zigbeeDevice.propertyMap.get('color_temp')?.value_min, zigbeeDevice.propertyMap.get('color_temp')?.value_max);
             }
+            else {
+                zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} ColorControlCluster cluster with HS: ${names.includes('color_hs')} XY: ${names.includes('color_xy')} CT: ${names.includes('color_temp')} min: ${zigbeeDevice.propertyMap.get('color_temp')?.value_min} max: ${zigbeeDevice.propertyMap.get('color_temp')?.value_max}`);
+                zigbeeDevice.bridgedDevice.createDefaultColorControlClusterServer(undefined, undefined, undefined, undefined, zigbeeDevice.propertyMap.get('color_temp')?.value_max, zigbeeDevice.propertyMap.get('color_temp')?.value_min, zigbeeDevice.propertyMap.get('color_temp')?.value_max);
+            }
+            mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(ColorControl.Cluster.id), 1);
         }
         if (mainEndpoint.clusterServersIds.includes(Thermostat.Cluster.id)) {
             const system_mode = zigbeeDevice.propertyMap.get('system_mode');
@@ -991,25 +1025,25 @@ export class ZigbeeDevice extends ZigbeeEntity {
         zigbeeDevice.mutableDevice.clear();
         zigbeeDevice.logPropertyMap();
         zigbeeDevice.bridgedDevice.addCommandHandler('identify', async (data) => {
-            zigbeeDevice.log.debug(`Command identify called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request identifyTime:${data.request.identifyTime} `);
+            zigbeeDevice.log.debug(`Command identify called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request identifyTime:${data.request.identifyTime} `);
         });
         if (zigbeeDevice.bridgedDevice.hasClusterServer(OnOffCluster.id) || zigbeeDevice.hasEndpoints) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
                 if (child.hasClusterServer(OnOffCluster)) {
                     child.addCommandHandler('on', async (data) => {
-                        zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
+                        zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
                         const payload = {};
                         payload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
                         zigbeeDevice.publishCommand('on', device.friendly_name, payload);
                     });
                     child.addCommandHandler('off', async (data) => {
-                        zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
+                        zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
                         const payload = {};
                         payload['state_' + data.endpoint.uniqueStorageKey] = 'OFF';
                         zigbeeDevice.publishCommand('off', device.friendly_name, payload);
                     });
                     child.addCommandHandler('toggle', async (data) => {
-                        zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
+                        zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
                         const payload = {};
                         payload['state_' + data.endpoint.uniqueStorageKey] = 'TOGGLE';
                         zigbeeDevice.publishCommand('toggle', device.friendly_name, payload);
@@ -1017,41 +1051,23 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 }
             }
             zigbeeDevice.bridgedDevice.addCommandHandler('on', async (data) => {
-                zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['state'] = 'ON';
-                else
-                    payload['state_' + label] = 'ON';
-                zigbeeDevice.publishCommand('on', device.friendly_name, payload);
+                zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
+                zigbeeDevice.publishCommand('on', device.friendly_name, { state: 'ON' });
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('off', async (data) => {
-                zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['state'] = 'OFF';
-                else
-                    payload['state_' + label] = 'OFF';
-                zigbeeDevice.publishCommand('off', device.friendly_name, payload);
+                zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
+                zigbeeDevice.publishCommand('off', device.friendly_name, { state: 'OFF' });
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('toggle', async (data) => {
-                zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['state'] = 'TOGGLE';
-                else
-                    payload['state_' + label] = 'TOGGLE';
-                zigbeeDevice.publishCommand('toggle', device.friendly_name, payload);
+                zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
+                zigbeeDevice.publishCommand('toggle', device.friendly_name, { state: 'TOGGLE' });
             });
         }
         if (zigbeeDevice.bridgedDevice.hasClusterServer(LevelControlCluster.id) || zigbeeDevice.hasEndpoints) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
                 if (child.hasClusterServer(LevelControlCluster)) {
                     child.addCommandHandler('moveToLevel', async (data) => {
-                        zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                        zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
                         const payload = {};
                         payload['brightness_' + data.endpoint.uniqueStorageKey] = data.request.level;
                         if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
@@ -1059,7 +1075,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                         zigbeeDevice.publishCommand('moveToLevel', device.friendly_name, payload);
                     });
                     child.addCommandHandler('moveToLevelWithOnOff', async (data) => {
-                        zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                        zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
                         const payload = {};
                         payload['brightness_' + data.endpoint.uniqueStorageKey] = data.request.level;
                         if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
@@ -1069,25 +1085,15 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 }
             }
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToLevel', async (data) => {
-                zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request: ${data.request.level} transition: ${data.request.transitionTime}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['brightness'] = data.request.level;
-                else
-                    payload['brightness_' + label] = data.request.level;
+                zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                const payload = { brightness: data.request.level };
                 if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
                     payload['transition'] = Math.round(data.request.transitionTime / 10);
                 zigbeeDevice.publishCommand('moveToLevel', device.friendly_name, payload);
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToLevelWithOnOff', async (data) => {
-                zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request: ${data.request.level} transition: ${data.request.transitionTime}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['brightness'] = data.request.level;
-                else
-                    payload['brightness_' + label] = data.request.level;
+                zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                const payload = { brightness: data.request.level };
                 if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
                     payload['transition'] = Math.round(data.request.transitionTime / 10);
                 zigbeeDevice.publishCommand('moveToLevelWithOnOff', device.friendly_name, payload);
@@ -1097,7 +1103,15 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToColorTemperature', async ({ request }) => {
                 zigbeeDevice.log.debug(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request: ${request.colorTemperatureMireds}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds, zigbeeDevice.log);
-                const payload = { color_temp: request.colorTemperatureMireds };
+                const payload = {};
+                if (zigbeeDevice.propertyMap.get('color_temp')) {
+                    payload['color_temp'] = request.colorTemperatureMireds;
+                }
+                else {
+                    const rgb = kelvinToRGB(miredToKelvin(request.colorTemperatureMireds));
+                    payload['color'] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                    zigbeeDevice.log.info(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${nf} but color_temp property is not available. Converting ${request.colorTemperatureMireds} to RGB ${debugStringify(payload['color'])}.`);
+                }
                 if (zigbeeDevice.transition && request.transitionTime && request.transitionTime / 10 >= 1)
                     payload['transition'] = Math.round(request.transitionTime / 10);
                 zigbeeDevice.publishCommand('moveToColorTemperature', device.friendly_name, payload);
@@ -1156,7 +1170,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.bridgedDevice.addCommandHandler('upOrOpen', async () => {
                 zigbeeDevice.log.debug(`Command upOrOpen called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
                 if (zigbeeDevice.isDevice && zigbeeDevice.propertyMap.has('position'))
-                    zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', 0, zigbeeDevice.log);
+                    await zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', 0, zigbeeDevice.log);
                 else
                     await zigbeeDevice.bridgedDevice?.setWindowCoveringTargetAndCurrentPosition(0);
                 zigbeeDevice.publishCommand('upOrOpen', device.friendly_name, { state: 'OPEN' });
@@ -1164,7 +1178,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.bridgedDevice.addCommandHandler('downOrClose', async () => {
                 zigbeeDevice.log.debug(`Command downOrClose called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
                 if (zigbeeDevice.isDevice && zigbeeDevice.propertyMap.has('position'))
-                    zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', 10000, zigbeeDevice.log);
+                    await zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', 10000, zigbeeDevice.log);
                 else
                     await zigbeeDevice.bridgedDevice?.setWindowCoveringTargetAndCurrentPosition(10000);
                 zigbeeDevice.publishCommand('downOrClose', device.friendly_name, { state: 'CLOSE' });
@@ -1177,7 +1191,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.bridgedDevice.addCommandHandler('goToLiftPercentage', async ({ request: { liftPercent100thsValue } }) => {
                 zigbeeDevice.log.debug(`Command goToLiftPercentage called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request liftPercent100thsValue: ${liftPercent100thsValue}`);
                 if (zigbeeDevice.isDevice && zigbeeDevice.propertyMap.has('position'))
-                    zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', liftPercent100thsValue, zigbeeDevice.log);
+                    await zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', liftPercent100thsValue, zigbeeDevice.log);
                 else
                     await zigbeeDevice.bridgedDevice?.setWindowCoveringTargetAndCurrentPosition(liftPercent100thsValue);
                 zigbeeDevice.publishCommand('goToLiftPercentage', device.friendly_name, { position: liftPercent100thsValue / 100 });
@@ -1202,7 +1216,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     const t = zigbeeDevice.bridgedDevice?.getAttribute(ThermostatCluster.id, 'occupiedHeatingSetpoint', zigbeeDevice.log);
                     const setpoint = Math.round(t / 100 + request.amount / 10);
                     if (zigbeeDevice.propertyMap.has('current_heating_setpoint')) {
-                        zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
+                        zigbeeDevice.publishCommand('CurrentHeatingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
                     }
                     else if (zigbeeDevice.propertyMap.has('occupied_heating_setpoint')) {
                         zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { occupied_heating_setpoint: setpoint });
@@ -1212,7 +1226,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     const t = zigbeeDevice.bridgedDevice?.getAttribute(ThermostatCluster.id, 'occupiedCoolingSetpoint', zigbeeDevice.log);
                     const setpoint = Math.round(t / 100 + request.amount / 10);
                     if (zigbeeDevice.propertyMap.has('current_heating_setpoint')) {
-                        zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
+                        zigbeeDevice.publishCommand('CurrentCoolingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
                     }
                     else if (zigbeeDevice.propertyMap.has('occupied_cooling_setpoint')) {
                         zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { occupied_cooling_setpoint: setpoint });

package/dist/platform.js

@@ -1,4 +1,4 @@
-import { MatterbridgeDynamicPlatform } from 'matterbridge';
+import { addVirtualDevice, MatterbridgeDynamicPlatform } from 'matterbridge';
 import { dn, gn, db, wr, zb, payloadStringify, rs, debugStringify, CYAN, er, nf } from 'matterbridge/logger';
 import { isValidNumber, isValidString, waiter } from 'matterbridge/utils';
 import { BridgedDeviceBasicInformation, DoorLock } from 'matterbridge/matter/clusters';
@@ -11,6 +11,7 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     bridgedDevices = [];
     zigbeeEntities = [];
     injectTimer;
+    namePostfix = 1;
     mqttHost = 'localhost';
     mqttPort = 1883;
     mqttTopic = 'zigbee2mqtt';
@@ -23,7 +24,6 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     featureBlackList = [];
     deviceFeatureBlackList = {};
     postfix = '';
-    postfixHostname = true;
     debugEnabled;
     shouldStart;
     shouldConfigure;
@@ -38,8 +38,8 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     availabilityTimer;
     constructor(matterbridge, log, config) {
         super(matterbridge, log, config);
-        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('2.2.5')) {
-            throw new Error(`This plugin requires Matterbridge version >= "2.2.5". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend."`);
+        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.0.3')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.0.3". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend."`);
         }
         this.debugEnabled = config.debug;
         this.shouldStart = false;
@@ -69,7 +69,6 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         if (config.postfix)
             this.postfix = config.postfix;
         this.postfix = this.postfix.trim().slice(0, 3);
-        this.postfixHostname = config.postfixHostname ?? true;
         config.host = this.mqttHost;
         config.port = this.mqttPort;
         config.protocolVersion = this.mqttProtocol;
@@ -77,7 +76,16 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         config.username = this.mqttUsername;
         config.password = this.mqttPassword;
         config.postfix = this.postfix;
-        config.postfixHostname = this.postfixHostname;
+        if (config.postfixHostname !== undefined)
+            delete config.postfixHostname;
+        if (config.deviceScenes !== undefined)
+            delete config.deviceScenes;
+        if (config.groupScenes !== undefined)
+            delete config.groupScenes;
+        if (config.scenesType === undefined)
+            config.scenesType = 'outlet';
+        if (config.scenesPrefix === undefined)
+            config.scenesPrefix = true;
         if (config.type === 'MatterbridgeExtension') {
             this.z2m = new Zigbee2MQTT(this.mqttHost, this.mqttPort, this.mqttTopic, this.mqttUsername, this.mqttPassword, this.mqttProtocol, this.debugEnabled);
             this.z2m.setLogDebug(this.debugEnabled);
@@ -86,7 +94,6 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         }
         this.log.info(`Initializing platform: ${CYAN}${this.config.name}${nf} version: ${CYAN}${this.config.version}${rs}`);
         this.log.info(`Loaded zigbee2mqtt parameters from ${CYAN}${path.join(matterbridge.matterbridgeDirectory, 'matterbridge-zigbee2mqtt.config.json')}${rs}`);
-        this.clearSelect();
         this.z2m = new Zigbee2MQTT(this.mqttHost, this.mqttPort, this.mqttTopic, this.mqttUsername, this.mqttPassword, this.mqttProtocol, this.debugEnabled);
         this.z2m.setLogDebug(this.debugEnabled);
         this.z2m.setDataPath(path.join(matterbridge.matterbridgePluginDirectory, 'matterbridge-zigbee2mqtt'));
@@ -292,6 +299,9 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     }
     async onStart(reason) {
         this.log.info(`Starting zigbee2mqtt dynamic platform v${this.version}: ` + reason);
+        await this.ready;
+        await this.clearSelect();
+        this.setSelectEntity('scenes', 'Scenes', 'component');
         const hasOnline = await waiter('z2mBridgeOnline', () => this.z2mBridgeOnline !== undefined);
         const hasInfo = await waiter('z2mBridgeInfo', () => this.z2mBridgeInfo !== undefined);
         const hasDevices = await waiter('z2mBridgeDevices & z2mBridgeGroups', () => this.z2mBridgeDevices !== undefined || this.z2mBridgeGroups !== undefined);
@@ -333,12 +343,12 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
                 this.log.info(`Configuring router ${bridgedEntity.bridgedDevice?.deviceName}.`);
                 if (this.z2mBridgeInfo?.permit_join) {
                     bridgedEntity.bridgedDevice?.setAttribute(DoorLock.Cluster.id, 'lockState', DoorLock.LockState.Unlocked, this.log);
-                    if (bridgedEntity.bridgedDevice.number)
+                    if (bridgedEntity.bridgedDevice.maybeNumber)
                         bridgedEntity.bridgedDevice?.triggerEvent(DoorLock.Cluster.id, 'lockOperation', { lockOperationType: DoorLock.LockOperationType.Unlock, operationSource: DoorLock.OperationSource.Manual, userIndex: null, fabricIndex: null, sourceNode: null }, this.log);
                 }
                 else {
                     bridgedEntity.bridgedDevice?.setAttribute(DoorLock.Cluster.id, 'lockState', DoorLock.LockState.Locked, this.log);
-                    if (bridgedEntity.bridgedDevice.number)
+                    if (bridgedEntity.bridgedDevice.maybeNumber)
                         bridgedEntity.bridgedDevice?.triggerEvent(DoorLock.Cluster.id, 'lockOperation', { lockOperationType: DoorLock.LockOperationType.Lock, operationSource: DoorLock.OperationSource.Manual, userIndex: null, fabricIndex: null, sourceNode: null }, this.log);
                 }
             }
@@ -481,6 +491,22 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         }
         return matterGroup;
     }
+    registerVirtualDevice(name, callback) {
+        let aggregator;
+        if (this.matterbridge.bridgeMode === 'bridge') {
+            aggregator = this.matterbridge.aggregatorNode;
+        }
+        else if (this.matterbridge.bridgeMode === 'childbridge') {
+            aggregator = this.matterbridge.plugins.get(this.name)?.aggregatorNode;
+        }
+        if (aggregator) {
+            if (aggregator.parts.has(name.replaceAll(' ', '') + ':' + this.config.scenesType)) {
+                this.log.warn(`Scene name ${name} already registered. Please use a different name. Changed to ${name + ' ' + this.namePostfix}`);
+                name = name + ' ' + this.namePostfix++;
+            }
+            addVirtualDevice(aggregator, name.slice(0, 32), this.config.scenesType, callback);
+        }
+    }
     async unregisterZigbeeEntity(friendly_name) {
         const entity = this.zigbeeEntities.find((entity) => entity.entityName === friendly_name);
         if (entity) {

package/matterbridge-zigbee2mqtt.schema.json

@@ -119,28 +119,39 @@
         "selectDeviceEntityFrom": "name"
       }
     },
-    "deviceScenes": {
-      "description": "Enable the devices scenes",
-      "type": "boolean",
-      "default": false,
-      "ui:widget": "hidden"
-    },
-    "groupScenes": {
-      "description": "Enable the groups scenes",
+    "scenesType": {
+      "description": "Device type to use to expose scenes",
+      "type": "string",
+      "oneOf": [
+        {
+          "title": "Light",
+          "enum": ["light"]
+        },
+        {
+          "title": "Outlet",
+          "enum": ["outlet"]
+        },
+        {
+          "title": "Switch",
+          "enum": ["switch"]
+        },
+        {
+          "title": "Mounted Switch",
+          "enum": ["mounted_switch"]
+        }
+      ],
+      "default": "outlet"
+    },
+    "scenesPrefix": {
+      "description": "Add the device/group friendly name before the scene name.",
       "type": "boolean",
-      "default": false,
-      "ui:widget": "hidden"
+      "default": true
     },
     "postfix": {
       "description": "Add this unique postfix (3 characters max) to each device serial to avoid collision with other instances (you may loose the configuration of the devices in your controller when changing this value).",
       "type": "string",
       "default": ""
     },
-    "postfixHostname": {
-      "description": "DEPRECATED: unique postfix added to each device identifier to avoid collision with other instances (you may loose the configuration of the devices in your controller when changing this value). Use postfix instead.",
-      "type": "boolean",
-      "default": true
-    },
     "debug": {
       "description": "Enable the debug for the plugin (development only)",
       "type": "boolean",

package/npm-shrinkwrap.json

@@ -1,16 +1,16 @@
 {
   "name": "matterbridge-zigbee2mqtt",
-  "version": "2.4.7",
+  "version": "2.5.0-dev.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge-zigbee2mqtt",
-      "version": "2.4.7",
+      "version": "2.5.0-dev.2",
       "license": "Apache-2.0",
       "dependencies": {
         "moment": "2.30.1",
-        "mqtt": "5.10.4",
+        "mqtt": "5.13.0",
         "node-ansi-logger": "3.0.1",
         "node-persist-manager": "1.0.8"
       },
@@ -23,40 +23,27 @@
       }
     },
     "node_modules/@babel/runtime": {
-      "version": "7.26.10",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.10.tgz",
-      "integrity": "sha512-2WJMeRQPHKSPemqk/awGrAiuFfzBmOIPXKizAsVhWH9YJqLZ0H+HS4c8loHGgW6utJ3E/ejXQUsiGaQy2NZ9Fw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.1.tgz",
+      "integrity": "sha512-1x3D2xEk2fRo3PAhwQwu5UubzgiVWSXTBfWpVd2Mx2AzRqJuDJCsgaDVZ7HB5iGzDW1Hl1sWN2mFyKjmR9uAog==",
       "license": "MIT",
-      "dependencies": {
-        "regenerator-runtime": "^0.14.0"
-      },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@types/node": {
-      "version": "22.13.10",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.13.10.tgz",
-      "integrity": "sha512-I6LPUvlRH+O6VRUqYOcMudhaIdUVWfsjnZavnsraHvpBwaEyMN29ry+0UVJhImYL16xsscu0aske3yA+uPOWfw==",
+      "version": "22.15.21",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.21.tgz",
+      "integrity": "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==",
       "license": "MIT",
       "dependencies": {
-        "undici-types": "~6.20.0"
+        "undici-types": "~6.21.0"
       }
     },
     "node_modules/@types/readable-stream": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-4.0.18.tgz",
-      "integrity": "sha512-21jK/1j+Wg+7jVw1xnSwy/2Q1VgVjWuFssbYGTREPUBeZ+rqVFl2udq0IkxzPC0ZhOzVceUbyIACFZKLqKEBlA==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "safe-buffer": "~5.1.1"
-      }
-    },
-    "node_modules/@types/ws": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.0.tgz",
-      "integrity": "sha512-8svvI3hMyvN0kKCJMvTJP/x6Y/EoQbepff882wL+Sn5QsXb3etnamgrJq4isrBxSJj5L2AuXcI0+bgkoAXGUJw==",
+      "version": "4.0.19",
+      "resolved": "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-4.0.19.tgz",
+      "integrity": "sha512-6Tgd3lMocKwOul/kwAAgSebkhdMCLhRvcJ6CKHA6wdql2qNIwK6hw3Y4PZQxn9HcJogoC/1ZOmkFM7OZKH/VrA==",
       "license": "MIT",
       "dependencies": {
         "@types/node": "*"
@@ -172,9 +159,9 @@
       }
     },
     "node_modules/debug": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
-      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
       "license": "MIT",
       "dependencies": {
         "ms": "^2.1.3"
@@ -251,6 +238,19 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
+    "node_modules/ip-address": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz",
+      "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==",
+      "license": "MIT",
+      "dependencies": {
+        "jsbn": "1.1.0",
+        "sprintf-js": "^1.1.3"
+      },
+      "engines": {
+        "node": ">= 12"
+      }
+    },
     "node_modules/js-sdsl": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.3.0.tgz",
@@ -261,6 +261,12 @@
         "url": "https://opencollective.com/js-sdsl"
       }
     },
+    "node_modules/jsbn": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz",
+      "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==",
+      "license": "MIT"
+    },
     "node_modules/minimist": {
       "version": "1.2.8",
       "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
@@ -280,24 +286,22 @@
       }
     },
     "node_modules/mqtt": {
-      "version": "5.10.4",
-      "resolved": "https://registry.npmjs.org/mqtt/-/mqtt-5.10.4.tgz",
-      "integrity": "sha512-wN+SuhT2/ZaG6NPxca0N6YtRivnMxk6VflxQUEeqDH4erKdj+wPAGhHmcTLzvqfE4sJRxrEJ+XJxUc0No0E7eQ==",
+      "version": "5.13.0",
+      "resolved": "https://registry.npmjs.org/mqtt/-/mqtt-5.13.0.tgz",
+      "integrity": "sha512-pR+z+ChxFl3n8AKLQbTONVOOg/jl4KiKQRBAi78tjd6PksOWvl1nl9L8ZHOZ3MiavZfrUOjok2ddwc1VymGWRg==",
       "license": "MIT",
       "dependencies": {
-        "@types/readable-stream": "^4.0.18",
-        "@types/ws": "^8.5.14",
         "commist": "^3.2.0",
         "concat-stream": "^2.0.0",
         "debug": "^4.4.0",
         "help-me": "^5.0.0",
         "lru-cache": "^10.4.3",
         "minimist": "^1.2.8",
-        "mqtt-packet": "^9.0.1",
+        "mqtt-packet": "^9.0.2",
         "number-allocator": "^1.0.14",
         "readable-stream": "^4.7.0",
-        "reinterval": "^1.1.0",
         "rfdc": "^1.4.1",
+        "socks": "^2.8.3",
         "split2": "^4.2.0",
         "worker-timers": "^7.1.8",
         "ws": "^8.18.0"
@@ -431,18 +435,6 @@
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       }
     },
-    "node_modules/regenerator-runtime": {
-      "version": "0.14.1",
-      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
-      "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
-      "license": "MIT"
-    },
-    "node_modules/reinterval": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/reinterval/-/reinterval-1.1.0.tgz",
-      "integrity": "sha512-QIRet3SYrGp0HUHO88jVskiG6seqUGC5iAG7AwI/BV4ypGcuqk9Du6YQBUOUqm9c8pw1eyLoIaONifRua1lsEQ==",
-      "license": "MIT"
-    },
     "node_modules/rfdc": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
@@ -450,11 +442,49 @@
       "license": "MIT"
     },
     "node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
       "license": "MIT"
     },
+    "node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks": {
+      "version": "2.8.4",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.4.tgz",
+      "integrity": "sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^9.0.5",
+        "smart-buffer": "^4.2.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
     "node_modules/split2": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
@@ -464,6 +494,12 @@
         "node": ">= 10.x"
       }
     },
+    "node_modules/sprintf-js": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
+      "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/string_decoder": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
@@ -473,26 +509,6 @@
         "safe-buffer": "~5.2.0"
       }
     },
-    "node_modules/string_decoder/node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
     "node_modules/tslib": {
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -506,9 +522,9 @@
       "license": "MIT"
     },
     "node_modules/undici-types": {
-      "version": "6.20.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
-      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
       "license": "MIT"
     },
     "node_modules/util-deprecate": {
@@ -552,9 +568,9 @@
       }
     },
     "node_modules/ws": {
-      "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz",
-      "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==",
+      "version": "8.18.2",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz",
+      "integrity": "sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-zigbee2mqtt",
-  "version": "2.4.7",
+  "version": "2.5.0-dev.2",
   "description": "Matterbridge zigbee2mqtt plugin",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "moment": "2.30.1",
-    "mqtt": "5.10.4",
+    "mqtt": "5.13.0",
     "node-ansi-logger": "3.0.1",
     "node-persist-manager": "1.0.8"
   }

package/tsconfig.jest.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    // enable isolatedModules just for ts-jest
+    "isolatedModules": true
+  },
+  "include": ["**/*.spec.ts", "**/*.test.ts", "**/__test__/*"]
+}