matterbridge 3.0.1-dev-20250505-cbd2c6e → 3.0.1-dev-20250505-1dd1d7e

package/CHANGELOG.md

@@ -13,7 +13,7 @@ If you like this project and find it useful, please consider giving it a star on
 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.
 
-## [3.0.1] - 2025-05-??
+## [3.0.1] - 2025-05-05
 
 ### Added
 
@@ -24,6 +24,7 @@ It is also available the official Matterbridge Home Assistant plugin https://git
 - [frontend]: Moved all plugin actions from express to web socket.
 - [frontend]: Moved all config from express to web socket.
 - [endpoint]: Added OperationalState cluster helper and behavior.
+- [behaviors]: Added Jest test on MatterbridgeBehaviors.
 
 ### Changed
 

package/README.md

@@ -5,7 +5,7 @@
 [![Docker Version](https://img.shields.io/docker/v/luligu/matterbridge?label=docker%20version&sort=semver)](https://hub.docker.com/r/luligu/matterbridge)
 [![Docker Pulls](https://img.shields.io/docker/pulls/luligu/matterbridge.svg)](https://hub.docker.com/r/luligu/matterbridge)
 ![Node.js CI](https://github.com/Luligu/matterbridge/actions/workflows/build.yml/badge.svg)
-![Coverage](https://img.shields.io/badge/Jest%20coverage-80%25-brightgreen)
+![Coverage](https://img.shields.io/badge/Jest%20coverage-84%25-brightgreen)
 
 [![power by](https://img.shields.io/badge/powered%20by-matter--history-blue)](https://www.npmjs.com/package/matter-history)
 [![power by](https://img.shields.io/badge/powered%20by-node--ansi--logger-blue)](https://www.npmjs.com/package/node-ansi-logger)

package/dist/matterbridgeBehaviors.js

@@ -15,12 +15,12 @@ import { ColorControlServer } from '@matter/main/behaviors/color-control';
 import { WindowCoveringServer } from '@matter/main/behaviors/window-covering';
 import { DoorLockServer } from '@matter/main/behaviors/door-lock';
 import { FanControlServer } from '@matter/main/behaviors/fan-control';
-import { ThermostatBehavior } from '@matter/main/behaviors/thermostat';
-import { ValveConfigurationAndControlBehavior } from '@matter/main/behaviors/valve-configuration-and-control';
+import { ThermostatServer } from '@matter/main/behaviors/thermostat';
+import { ValveConfigurationAndControlServer } from '@matter/main/behaviors/valve-configuration-and-control';
 import { ModeSelectServer } from '@matter/main/behaviors/mode-select';
 import { SmokeCoAlarmServer } from '@matter/main/behaviors/smoke-co-alarm';
 import { SwitchServer } from '@matter/main/behaviors/switch';
-import { OperationalStateBehavior } from '@matter/main/behaviors/operational-state';
+import { OperationalStateServer } from '@matter/main/behaviors/operational-state';
 export class MatterbridgeServerDevice {
     log;
     commandHandler;
@@ -161,6 +161,12 @@ export class MatterbridgeServerDevice {
 }
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
+    initialize() {
+        const device = this.state.deviceCommand;
+        device?.setEndpointId(this.endpoint.maybeId);
+        device?.setEndpointNumber(this.endpoint.maybeNumber);
+        super.initialize();
+    }
 }
 (function (MatterbridgeServer) {
     class State {
@@ -169,128 +175,141 @@ export class MatterbridgeServer extends Behavior {
     MatterbridgeServer.State = State;
 })(MatterbridgeServer || (MatterbridgeServer = {}));
 export class MatterbridgeIdentifyServer extends IdentifyServer {
-    initialize() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.setEndpointId(this.endpoint.maybeId);
-        device.setEndpointNumber(this.endpoint.maybeNumber);
-        super.initialize();
-    }
     identify({ identifyTime }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.identify({ identifyTime });
+        device.log.debug(`MatterbridgeIdentifyServer: identify called`);
         super.identify({ identifyTime });
     }
     triggerEffect({ effectIdentifier, effectVariant }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.triggerEffect({ effectIdentifier, effectVariant });
+        device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called`);
         super.triggerEffect({ effectIdentifier, effectVariant });
     }
 }
 export class MatterbridgeOnOffServer extends OnOffServer {
-    async on() {
+    on() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.on();
+        device.log.debug(`MatterbridgeOnOffServer: on called`);
         super.on();
     }
-    async off() {
+    off() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.off();
+        device.log.debug(`MatterbridgeOnOffServer: off called`);
         super.off();
     }
-    async toggle() {
+    toggle() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.toggle();
+        device.log.debug(`MatterbridgeOnOffServer: toggle called`);
         super.toggle();
     }
 }
 export class MatterbridgeLevelControlServer extends LevelControlServer {
-    async moveToLevel({ level, transitionTime, optionsMask, optionsOverride }) {
+    moveToLevel({ level, transitionTime, optionsMask, optionsOverride }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToLevel({ level, transitionTime, optionsMask, optionsOverride });
+        device.log.debug(`MatterbridgeLevelControlServer: moveToLevel called`);
         super.moveToLevel({ level, transitionTime, optionsMask, optionsOverride });
     }
-    async moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride }) {
+    moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride });
+        device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called`);
         super.moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride });
     }
 }
 export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
-    async moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime }) {
+    moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime });
+        device.log.debug(`MatterbridgeColorControlServer: moveToHue called`);
         super.moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime });
     }
-    async moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime }) {
+    moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime });
+        device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called`);
         super.moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime });
     }
-    async moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime }) {
+    moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime });
+        device.log.debug(`MatterbridgeColorControlServer: moveToHueAndSaturation called`);
         super.moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime });
     }
-    async moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime }) {
+    moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime });
+        device.log.debug(`MatterbridgeColorControlServer: moveToColor called`);
         super.moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime });
     }
-    async moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime }) {
+    moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime });
+        device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called`);
         super.moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime });
     }
 }
 export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift) {
-    async upOrOpen() {
+    upOrOpen() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.upOrOpen();
+        device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen called`);
         super.upOrOpen();
     }
-    async downOrClose() {
+    downOrClose() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.downOrClose();
+        device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose called`);
         super.downOrClose();
     }
     stopMotion() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.stopMotion();
+        device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion called`);
         super.stopMotion();
     }
     goToLiftPercentage({ liftPercent100thsValue }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.goToLiftPercentage({ liftPercent100thsValue });
+        device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage with ${liftPercent100thsValue}`);
         super.goToLiftPercentage({ liftPercent100thsValue });
     }
     async handleMovement(type, reversed, direction, targetPercent100ths) {
     }
 }
 export class MatterbridgeDoorLockServer extends DoorLockServer {
-    async lockDoor() {
+    lockDoor() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.lockDoor();
+        device.log.debug(`MatterbridgeDoorLockServer: lockDoor called`);
         super.lockDoor();
     }
-    async unlockDoor() {
+    unlockDoor() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.unlockDoor();
+        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called`);
         super.unlockDoor();
     }
 }
 export class MatterbridgeModeSelectServer extends ModeSelectServer {
-    async changeToMode({ newMode }) {
+    changeToMode({ newMode }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.changeToMode({ newMode });
+        device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode: ${newMode}`);
         super.changeToMode({ newMode });
     }
 }
 export class MatterbridgeFanControlServer extends FanControlServer.with(FanControl.Feature.MultiSpeed, FanControl.Feature.Auto, FanControl.Feature.Step) {
-    async step({ direction, wrap, lowestOff }) {
+    step({ direction, wrap, lowestOff }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.step({ direction, wrap, lowestOff });
         const lookupStepDirection = ['Increase', 'Decrease'];
-        device.log.debug(`Command step called with direction: ${lookupStepDirection[direction]} wrap: ${wrap} lowestOff: ${lowestOff}`);
+        device.log.debug(`MatterbridgeFanControlServer: step called with direction: ${lookupStepDirection[direction]} wrap: ${wrap} lowestOff: ${lowestOff}`);
         device.log.debug(`- current percentCurrent: ${this.state.percentCurrent}`);
         if (direction === FanControl.StepDirection.Increase) {
             if (wrap && this.state.percentCurrent === 100) {
@@ -307,15 +326,14 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
                 this.state.percentCurrent = Math.max(this.state.percentCurrent - 10, lowestOff ? 0 : 10);
         }
         device.log.debug('Set percentCurrent to:', this.state.percentCurrent);
-        super.step({ direction, wrap, lowestOff });
     }
 }
-export class MatterbridgeThermostatServer extends ThermostatBehavior.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
-    async setpointRaiseLower({ mode, amount }) {
+export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
+    setpointRaiseLower({ mode, amount }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.setpointRaiseLower({ mode, amount });
         const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
-        device.log.debug(`Command setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[mode]} amount: ${amount / 10}`);
+        device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[mode]} amount: ${amount / 10}`);
         device.log.debug(`- current occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint / 100}`);
         device.log.debug(`- current occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint / 100}`);
         if ((mode === Thermostat.SetpointRaiseLowerMode.Heat || mode === Thermostat.SetpointRaiseLowerMode.Both) && this.state.occupiedHeatingSetpoint !== undefined) {
@@ -330,43 +348,41 @@ export class MatterbridgeThermostatServer extends ThermostatBehavior.with(Thermo
         }
     }
 }
-export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigurationAndControlBehavior.with(ValveConfigurationAndControl.Feature.Level) {
-    initialize() {
-    }
+export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigurationAndControlServer.with(ValveConfigurationAndControl.Feature.Level) {
     open({ openDuration, targetLevel }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.log.debug(`Command open called with openDuration: ${openDuration} targetLevel: ${targetLevel}`);
+        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${openDuration} targetLevel: ${targetLevel}`);
         device.open({ openDuration, targetLevel });
         this.state.targetLevel = targetLevel ?? 100;
         this.state.currentLevel = targetLevel ?? 100;
     }
     close() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.log.debug(`Command close called`);
+        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called`);
         device.close();
         this.state.targetLevel = 0;
         this.state.currentLevel = 0;
     }
 }
 export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm) {
-    async selfTestRequest() {
+    selfTestRequest() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called`);
         device.selfTestRequest();
-        super.selfTestRequest();
     }
 }
 export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
-    async enableDisableAlarm({ alarmsToEnableDisable }) {
+    enableDisableAlarm({ alarmsToEnableDisable }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called`);
         device.enableDisableAlarm({ alarmsToEnableDisable });
-        super.enableDisableAlarm({ alarmsToEnableDisable });
     }
 }
 export class MatterbridgeSwitchServer extends SwitchServer {
     initialize() {
     }
 }
-export class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
+export class MatterbridgeOperationalStateServer extends OperationalStateServer {
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.debug('MatterbridgeOperationalStateServer initialized: setting operational state to Stopped');

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.1-dev-20250505-cbd2c6e",
+  "version": "3.0.1-dev-20250505-1dd1d7e",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.1-dev-20250505-cbd2c6e",
+      "version": "3.0.1-dev-20250505-1dd1d7e",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.1-dev-20250505-cbd2c6e",
+  "version": "3.0.1-dev-20250505-1dd1d7e",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",