matterbridge 3.0.6-dev-20250611-6f49811 → 3.0.6-dev-20250612-a8a696e

package/README.md

@@ -324,6 +324,8 @@ It exposes 38 devices:
 - a microwave Oven device (supported by SmartThings, Alexa and Home Assistant)
 - an extractor Hood device (supported by SmartThings, Alexa and Home Assistant)
 - a cooktop device (supported by SmartThings, Alexa and Home Assistant)
+- a water heater device (supported by SmartThings and Home Assistant)
+- a car charger device (supported by Home Assistant)
 
 All these virtual devices continuously change state and position. The plugin also shows how to use all the command handlers (you can control all the devices).
 

package/dist/evse.js

@@ -15,7 +15,7 @@ export class Evse extends MatterbridgeEndpoint {
             .createDefaultPowerTopologyClusterServer()
             .createDefaultElectricalPowerMeasurementClusterServer()
             .createDefaultElectricalEnergyMeasurementClusterServer()
-            .createDefaultDeviceEnergyManagementCluster(DeviceEnergyManagement.EsaType.Evse, false, DeviceEnergyManagement.EsaState.Online, absMinPower, absMaxPower)
+            .createDefaultDeviceEnergyManagementClusterServer(DeviceEnergyManagement.EsaType.Evse, false, DeviceEnergyManagement.EsaState.Online, absMinPower, absMaxPower)
             .createDefaultEnergyEvseClusterServer(state, supplyState, faultState)
             .createDefaultEnergyEvseModeClusterServer(currentMode, supportedModes)
             .addRequiredClusterServers();
@@ -49,39 +49,42 @@ export class Evse extends MatterbridgeEndpoint {
 }
 export class MatterbridgeEnergyEvseServer extends EnergyEvseServer {
     disable() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.disable();
-        device.log.info(`MatterbridgeEnergyEvseServer disable called`);
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Disable charging (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('disable', { request: {}, cluster: EnergyEvseServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeEnergyEvseServer disable called`);
         this.state.supplyState = EnergyEvse.SupplyState.Disabled;
         if (this.state.state === EnergyEvse.State.PluggedInCharging) {
             this.state.state = EnergyEvse.State.PluggedInDemand;
         }
         this.state.chargingEnabledUntil = 0;
     }
-    enableCharging({ chargingEnabledUntil, minimumChargeCurrent, maximumChargeCurrent }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.enableCharging();
-        device.log.info(`MatterbridgeEnergyEvseServer enableCharging called`);
+    enableCharging(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`EnableCharging (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('enableCharging', { request, cluster: EnergyEvseServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeEnergyEvseServer enableCharging called`);
         this.state.supplyState = EnergyEvse.SupplyState.ChargingEnabled;
         if (this.state.state === EnergyEvse.State.PluggedInDemand) {
             this.state.state = EnergyEvse.State.PluggedInCharging;
         }
-        this.state.chargingEnabledUntil = chargingEnabledUntil;
-        this.state.minimumChargeCurrent = minimumChargeCurrent;
-        this.state.maximumChargeCurrent = maximumChargeCurrent;
+        this.state.chargingEnabledUntil = request.chargingEnabledUntil;
+        this.state.minimumChargeCurrent = request.minimumChargeCurrent;
+        this.state.maximumChargeCurrent = request.maximumChargeCurrent;
     }
 }
 export class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
-    changeToMode({ newMode }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('changeToMode', { request, cluster: EnergyEvseModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
-            device.log.error(`MatterbridgeEnergyEvseModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            device.log.error(`MatterbridgeEnergyEvseModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
-        device.log.info(`MatterbridgeEnergyEvseModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        this.state.currentMode = request.newMode;
+        device.log.debug(`MatterbridgeEnergyEvseModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
         return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }

package/dist/laundryWasher.js

@@ -64,14 +64,16 @@ export class LaundryWasher extends MatterbridgeEndpoint {
 export class MatterbridgeLevelTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel) {
     initialize() {
         if (this.state.supportedTemperatureLevels.length >= 2) {
-            const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+            const device = this.endpoint.stateOf(MatterbridgeServer);
             device.log.info(`MatterbridgeLevelTemperatureControlServer initialized with selectedTemperatureLevel ${this.state.selectedTemperatureLevel} and supportedTemperatureLevels: ${this.state.supportedTemperatureLevels.join(', ')}`);
         }
     }
     setTemperature(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`SetTemperature (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('setTemperature', { request, cluster: TemperatureControlServer.id, attributes: this.state, endpoint: this.endpoint });
         if (request.targetTemperatureLevel !== undefined && request.targetTemperatureLevel >= 0 && request.targetTemperatureLevel < this.state.supportedTemperatureLevels.length) {
-            device.log.info(`MatterbridgeLevelTemperatureControlServer: setTemperature called setting selectedTemperatureLevel to ${request.targetTemperatureLevel}: ${this.state.supportedTemperatureLevels[request.targetTemperatureLevel]}`);
+            device.log.debug(`MatterbridgeLevelTemperatureControlServer: setTemperature called setting selectedTemperatureLevel to ${request.targetTemperatureLevel}: ${this.state.supportedTemperatureLevels[request.targetTemperatureLevel]}`);
             this.state.selectedTemperatureLevel = request.targetTemperatureLevel;
         }
         else {
@@ -81,13 +83,15 @@ export class MatterbridgeLevelTemperatureControlServer extends TemperatureContro
 }
 export class MatterbridgeNumberTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep) {
     initialize() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeNumberTemperatureControlServer initialized with temperatureSetpoint ${this.state.temperatureSetpoint} minTemperature ${this.state.minTemperature} maxTemperature ${this.state.maxTemperature} step ${this.state.step}`);
     }
     setTemperature(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`SetTemperature (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('setTemperature', { request, cluster: TemperatureControlServer.id, attributes: this.state, endpoint: this.endpoint });
         if (request.targetTemperature !== undefined && request.targetTemperature >= this.state.minTemperature && request.targetTemperature <= this.state.maxTemperature) {
-            device.log.info(`MatterbridgeNumberTemperatureControlServer: setTemperature called setting temperatureSetpoint to ${request.targetTemperature}`);
+            device.log.debug(`MatterbridgeNumberTemperatureControlServer: setTemperature called setting temperatureSetpoint to ${request.targetTemperature}`);
             this.state.temperatureSetpoint = request.targetTemperature;
         }
         else {
@@ -97,23 +101,25 @@ export class MatterbridgeNumberTemperatureControlServer extends TemperatureContr
 }
 export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
     initialize() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeLaundryWasherModeServer initialized: currentMode is ${this.state.currentMode}`);
         this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
     }
     handleOnOffChange(onOff) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`HandleOnOffChange (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (onOff === false) {
             device.log.notice('OnOffServer changed to OFF: setting Dead Front state to Manufacturer Specific');
             this.state.currentMode = 2;
         }
     }
     changeToMode(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`ChangeToMode (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('changeToMode', { request, cluster: LaundryWasherModeServer.id, attributes: this.state, endpoint: this.endpoint });
         const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
         if (supportedMode) {
-            device.log.info(`MatterbridgeLaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} => ${supportedMode.label}`);
-            device.changeToMode({ newMode: request.newMode });
+            device.log.debug(`MatterbridgeLaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} => ${supportedMode.label}`);
             this.state.currentMode = request.newMode;
             return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
         }

package/dist/matterbridgeBehaviors.js

@@ -25,423 +25,288 @@ import { SwitchServer } from '@matter/main/behaviors/switch';
 import { OperationalStateServer } from '@matter/main/behaviors/operational-state';
 import { ServiceAreaServer } from '@matter/main/behaviors/service-area';
 import { DeviceEnergyManagementModeServer } from '@matter/main/behaviors/device-energy-management-mode';
-export class MatterbridgeServerDevice {
-    log;
-    commandHandler;
-    device;
-    endpointId = undefined;
-    endpointNumber = undefined;
-    constructor(log, commandHandler, device) {
-        this.log = log;
-        this.commandHandler = commandHandler;
-        this.device = device;
-    }
-    setEndpointId(endpointId) {
-        this.endpointId = endpointId;
-    }
-    setEndpointNumber(endpointNumber) {
-        this.endpointNumber = endpointNumber;
-    }
-    identify({ identifyTime }) {
-        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 } });
-    }
-    off() {
-        this.log.info(`Switching device off (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('off', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    toggle() {
-        this.log.info(`Toggle device on/off (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('toggle', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    moveToLevel({ level, transitionTime, optionsMask, optionsOverride }) {
-        this.log.info(`Setting level to ${level} with transitionTime ${transitionTime} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('moveToLevel', { request: { level, transitionTime, optionsMask, optionsOverride }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride }) {
-        this.log.info(`Setting level to ${level} with transitionTime ${transitionTime} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('moveToLevelWithOnOff', { request: { level, transitionTime, optionsMask, optionsOverride }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime }) {
-        this.log.info(`Setting hue to ${hue} with transitionTime ${transitionTime} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('moveToHue', { request: { optionsMask, optionsOverride, hue, direction, transitionTime }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime }) {
-        this.log.info(`Setting saturation to ${saturation} with transitionTime ${transitionTime} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('moveToSaturation', { request: { optionsMask, optionsOverride, saturation, transitionTime }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime }) {
-        this.log.info(`Setting hue to ${hue} and saturation to ${saturation} with transitionTime ${transitionTime} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('moveToHueAndSaturation', { request: { optionsOverride, optionsMask, saturation, hue, transitionTime }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime }) {
-        this.log.info(`Setting color to ${colorX}, ${colorY} with transitionTime ${transitionTime} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('moveToColor', { request: { optionsMask, optionsOverride, colorX, colorY, transitionTime }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime }) {
-        this.log.info(`Setting color temperature to ${colorTemperatureMireds} with transitionTime ${transitionTime} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('moveToColorTemperature', {
-            request: { optionsOverride, optionsMask, colorTemperatureMireds, transitionTime },
-            attributes: {},
-            endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId },
-        });
-    }
-    upOrOpen() {
-        this.log.info(`Opening cover (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler(`upOrOpen`, { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    downOrClose() {
-        this.log.info(`Closing cover (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler(`downOrClose`, { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    stopMotion() {
-        this.log.info(`Stopping cover (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('stopMotion', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    goToLiftPercentage({ liftPercent100thsValue }) {
-        this.log.info(`Setting cover lift percentage to ${liftPercent100thsValue} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('goToLiftPercentage', { request: { liftPercent100thsValue }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    goToTiltPercentage({ tiltPercent100thsValue }) {
-        this.log.info(`Setting cover tilt percentage to ${tiltPercent100thsValue} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('goToTiltPercentage', { request: { tiltPercent100thsValue }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    lockDoor() {
-        this.log.info(`Locking door (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('lockDoor', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    unlockDoor() {
-        this.log.info(`Unlocking door (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('unlockDoor', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    step({ direction, wrap, lowestOff }) {
-        this.log.info(`Stepping fan with direction ${direction} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('step', { request: { direction, wrap, lowestOff }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    setpointRaiseLower({ mode, amount }) {
-        this.log.info(`Setting setpoint by ${amount} in mode ${mode} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('setpointRaiseLower', { request: { mode, amount }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    open({ openDuration, targetLevel }) {
-        this.log.info(`Opening valve to ${targetLevel}% (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('open', { request: { openDuration, targetLevel }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    close() {
-        this.log.info(`Closing valve (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('close', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    changeToMode({ newMode }) {
-        this.log.info(`Changing mode to ${newMode} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('changeToMode', { request: { newMode }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    selfTestRequest() {
-        this.log.info(`Testing SmokeCOAlarm (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('selfTestRequest', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    enableDisableAlarm({ alarmsToEnableDisable }) {
-        this.log.info(`Enabling/disabling alarm ${alarmsToEnableDisable} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('enableDisableAlarm', { request: { alarmsToEnableDisable }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    pause() {
-        this.log.info(`Pause (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('pause', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    stop() {
-        this.log.info(`Stop (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('stop', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    start() {
-        this.log.info(`Start (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('start', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    resume() {
-        this.log.info(`Resume (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('resume', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    goHome() {
-        this.log.info(`GoHome (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('goHome', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    selectAreas({ newAreas }) {
-        this.log.info(`Selecting areas ${newAreas} (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('selectAreas', { request: { newAreas }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    boost({ boostInfo }) {
-        this.log.info(`Boost (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('boost', { request: { boostInfo }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    cancelBoost() {
-        this.log.info(`Cancel boost (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('cancelBoost', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    enableCharging() {
-        this.log.info(`EnableCharging (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('enableCharging', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-    disable() {
-        this.log.info(`Disable charging (endpoint ${this.endpointId}.${this.endpointNumber})`);
-        this.commandHandler.executeHandler('disable', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
-    }
-}
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
     initialize() {
-        const device = this.state.deviceCommand;
-        device?.setEndpointId(this.endpoint.maybeId);
-        device?.setEndpointNumber(this.endpoint.maybeNumber);
+        this.state.log.debug(`MatterbridgeServer initialized (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         super.initialize();
     }
 }
 (function (MatterbridgeServer) {
     class State {
-        deviceCommand;
+        log;
+        commandHandler;
     }
     MatterbridgeServer.State = State;
 })(MatterbridgeServer || (MatterbridgeServer = {}));
 export class MatterbridgeIdentifyServer extends IdentifyServer {
-    identify({ identifyTime }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.identify({ identifyTime });
+    identify(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Identifying device for ${request.identifyTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('identify', { request, cluster: IdentifyServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeIdentifyServer: identify called`);
-        super.identify({ identifyTime });
+        super.identify(request);
     }
-    triggerEffect({ effectIdentifier, effectVariant }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.triggerEffect({ effectIdentifier, effectVariant });
+    triggerEffect(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Triggering effect ${request.effectIdentifier} variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('triggerEffect', { request, cluster: IdentifyServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called`);
-        super.triggerEffect({ effectIdentifier, effectVariant });
+        super.triggerEffect(request);
     }
 }
 export class MatterbridgeOnOffServer extends OnOffServer {
     on() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.on();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('on', { request: {}, cluster: OnOffServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeOnOffServer: on called`);
         super.on();
     }
     off() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.off();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('off', { request: {}, cluster: OnOffServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeOnOffServer: off called`);
         super.off();
     }
     toggle() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.toggle();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Toggle device on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('toggle', { request: {}, cluster: OnOffServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeOnOffServer: toggle called`);
         super.toggle();
     }
 }
 export class MatterbridgeLevelControlServer extends LevelControlServer {
-    moveToLevel({ level, transitionTime, optionsMask, optionsOverride }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.moveToLevel({ level, transitionTime, optionsMask, optionsOverride });
+    moveToLevel(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToLevel', { request, cluster: LevelControlServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeLevelControlServer: moveToLevel called`);
-        super.moveToLevel({ level, transitionTime, optionsMask, optionsOverride });
+        super.moveToLevel(request);
     }
-    moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride });
+    moveToLevelWithOnOff(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToLevelWithOnOff', { request, cluster: LevelControlServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called`);
-        super.moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride });
+        super.moveToLevelWithOnOff(request);
     }
 }
 export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
-    moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime });
+    moveToHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting hue to ${request.hue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToHue', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeColorControlServer: moveToHue called`);
-        super.moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime });
+        super.moveToHue(request);
     }
-    moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime });
+    moveToSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called`);
-        super.moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime });
+        super.moveToSaturation(request);
     }
-    moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime });
+    moveToHueAndSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting hue to ${request.hue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToHueAndSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeColorControlServer: moveToHueAndSaturation called`);
-        super.moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime });
+        super.moveToHueAndSaturation(request);
     }
-    moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime });
+    moveToColor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting color to ${request.colorX}, ${request.colorY} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToColor', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeColorControlServer: moveToColor called`);
-        super.moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime });
+        super.moveToColor(request);
     }
-    moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime });
+    moveToColorTemperature(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting color temperature to ${request.colorTemperatureMireds} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToColorTemperature', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called`);
-        super.moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime });
+        super.moveToColorTemperature(request);
     }
 }
 export class MatterbridgeLiftWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift) {
     upOrOpen() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.upOrOpen();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Opening cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler(`upOrOpen`, { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen called`);
         super.upOrOpen();
     }
     downOrClose() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.downOrClose();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Closing cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler(`downOrClose`, { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose called`);
         super.downOrClose();
     }
     stopMotion() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.stopMotion();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stopping cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('stopMotion', { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
         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 });
+    goToLiftPercentage(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting cover lift percentage to ${request.liftPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('goToLiftPercentage', { request, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage with ${request.liftPercent100thsValue}`);
+        super.goToLiftPercentage(request);
     }
     async handleMovement(type, reversed, direction, targetPercent100ths) {
     }
 }
 export class MatterbridgeLiftTiltWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt) {
     upOrOpen() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.upOrOpen();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Opening cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler(`upOrOpen`, { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: upOrOpen called`);
         super.upOrOpen();
     }
     downOrClose() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.downOrClose();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Closing cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler(`downOrClose`, { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: downOrClose called`);
         super.downOrClose();
     }
     stopMotion() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.stopMotion();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stopping cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('stopMotion', { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: stopMotion called`);
         super.stopMotion();
     }
-    goToLiftPercentage({ liftPercent100thsValue }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.goToLiftPercentage({ liftPercent100thsValue });
-        device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: goToLiftPercentage with ${liftPercent100thsValue}`);
-        super.goToLiftPercentage({ liftPercent100thsValue });
+    goToLiftPercentage(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting cover lift percentage to ${request.liftPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('goToLiftPercentage', { request, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: goToLiftPercentage with ${request.liftPercent100thsValue}`);
+        super.goToLiftPercentage(request);
     }
-    goToTiltPercentage({ tiltPercent100thsValue }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.goToTiltPercentage({ tiltPercent100thsValue });
-        device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: goToTiltPercentage with ${tiltPercent100thsValue}`);
-        super.goToTiltPercentage({ tiltPercent100thsValue });
+    goToTiltPercentage(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting cover tilt percentage to ${request.tiltPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('goToTiltPercentage', { request, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: goToTiltPercentage with ${request.tiltPercent100thsValue}`);
+        super.goToTiltPercentage(request);
     }
     async handleMovement(type, reversed, direction, targetPercent100ths) {
     }
 }
 export class MatterbridgeDoorLockServer extends DoorLockServer {
     lockDoor() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.lockDoor();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Locking door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('lockDoor', { request: {}, cluster: DoorLockServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeDoorLockServer: lockDoor called`);
         super.lockDoor();
     }
     unlockDoor() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.unlockDoor();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Unlocking door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('unlockDoor', { request: {}, cluster: DoorLockServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called`);
         super.unlockDoor();
     }
 }
-export class MatterbridgeModeSelectServer extends ModeSelectServer {
-    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) {
-    step({ direction, wrap, lowestOff }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.step({ direction, wrap, lowestOff });
+    step(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping fan with direction ${request.direction} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('step', { request, cluster: FanControlServer.id, attributes: this.state, endpoint: this.endpoint });
         const lookupStepDirection = ['Increase', 'Decrease'];
-        device.log.debug(`MatterbridgeFanControlServer: step called with direction: ${lookupStepDirection[direction]} wrap: ${wrap} lowestOff: ${lowestOff}`);
+        device.log.debug(`MatterbridgeFanControlServer: step called with direction: ${lookupStepDirection[request.direction]} wrap: ${request.wrap} lowestOff: ${request.lowestOff}`);
         device.log.debug(`- current percentCurrent: ${this.state.percentCurrent}`);
-        if (direction === FanControl.StepDirection.Increase) {
-            if (wrap && this.state.percentCurrent === 100) {
-                this.state.percentCurrent = lowestOff ? 0 : 10;
+        if (request.direction === FanControl.StepDirection.Increase) {
+            if (request.wrap && this.state.percentCurrent === 100) {
+                this.state.percentCurrent = request.lowestOff ? 0 : 10;
             }
             else
                 this.state.percentCurrent = Math.min(this.state.percentCurrent + 10, 100);
         }
-        else if (direction === FanControl.StepDirection.Decrease) {
-            if (wrap && this.state.percentCurrent === (lowestOff ? 0 : 10)) {
+        else if (request.direction === FanControl.StepDirection.Decrease) {
+            if (request.wrap && this.state.percentCurrent === (request.lowestOff ? 0 : 10)) {
                 this.state.percentCurrent = 100;
             }
             else
-                this.state.percentCurrent = Math.max(this.state.percentCurrent - 10, lowestOff ? 0 : 10);
+                this.state.percentCurrent = Math.max(this.state.percentCurrent - 10, request.lowestOff ? 0 : 10);
         }
         device.log.debug('Set percentCurrent to:', this.state.percentCurrent);
     }
 }
 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 });
+    setpointRaiseLower(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('setpointRaiseLower', { request, cluster: ThermostatServer.id, attributes: this.state, endpoint: this.endpoint });
         const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
-        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) {
-            const setpoint = this.state.occupiedHeatingSetpoint / 100 + amount / 10;
+        device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10}`);
+        if (this.state.occupiedHeatingSetpoint !== undefined)
+            device.log.debug(`- current occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint / 100}`);
+        if (this.state.occupiedCoolingSetpoint !== undefined)
+            device.log.debug(`- current occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint / 100}`);
+        if ((request.mode === Thermostat.SetpointRaiseLowerMode.Heat || request.mode === Thermostat.SetpointRaiseLowerMode.Both) && this.state.occupiedHeatingSetpoint !== undefined) {
+            const setpoint = this.state.occupiedHeatingSetpoint / 100 + request.amount / 10;
             this.state.occupiedHeatingSetpoint = setpoint * 100;
             device.log.debug(`Set occupiedHeatingSetpoint to ${setpoint}`);
         }
-        if ((mode === Thermostat.SetpointRaiseLowerMode.Cool || mode === Thermostat.SetpointRaiseLowerMode.Both) && this.state.occupiedCoolingSetpoint !== undefined) {
-            const setpoint = this.state.occupiedCoolingSetpoint / 100 + amount / 10;
+        if ((request.mode === Thermostat.SetpointRaiseLowerMode.Cool || request.mode === Thermostat.SetpointRaiseLowerMode.Both) && this.state.occupiedCoolingSetpoint !== undefined) {
+            const setpoint = this.state.occupiedCoolingSetpoint / 100 + request.amount / 10;
             this.state.occupiedCoolingSetpoint = setpoint * 100;
             device.log.debug(`Set occupiedCoolingSetpoint to ${setpoint}`);
         }
     }
 }
 export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigurationAndControlServer.with(ValveConfigurationAndControl.Feature.Level) {
-    open({ openDuration, targetLevel }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        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;
+    open(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Opening valve to ${request.targetLevel ? request.targetLevel + '%' : 'fully opened'} ${request.openDuration ? 'for ' + request.openDuration + 's' : 'until closed'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('open', { request, cluster: ValveConfigurationAndControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${request.openDuration} targetLevel: ${request.targetLevel}`);
+        this.state.targetState = ValveConfigurationAndControl.ValveState.Open;
+        this.state.currentState = ValveConfigurationAndControl.ValveState.Open;
+        this.state.targetLevel = request.targetLevel ?? 100;
+        this.state.currentLevel = request.targetLevel ?? 100;
+        this.state.openDuration = request.openDuration ?? this.state.defaultOpenDuration;
+        if (this.state.openDuration === null)
+            this.state.remainingDuration = null;
     }
     close() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Closing valve (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('close', { request: {}, cluster: ValveConfigurationAndControlServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called`);
-        device.close();
+        this.state.targetState = ValveConfigurationAndControl.ValveState.Closed;
+        this.state.currentState = ValveConfigurationAndControl.ValveState.Closed;
         this.state.targetLevel = 0;
         this.state.currentLevel = 0;
+        this.state.openDuration = null;
+        this.state.remainingDuration = null;
     }
 }
 export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm) {
     selfTestRequest() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Testing SmokeCOAlarm (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('selfTestRequest', { request: {}, cluster: SmokeCoAlarmServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called`);
-        device.selfTestRequest();
     }
 }
 export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
-    enableDisableAlarm({ alarmsToEnableDisable }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+    enableDisableAlarm(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Enabling/disabling alarm ${request.alarmsToEnableDisable} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('enableDisableAlarm', { request, cluster: BooleanStateConfigurationServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called`);
-        device.enableDisableAlarm({ alarmsToEnableDisable });
     }
 }
 export class MatterbridgeSwitchServer extends SwitchServer {
@@ -450,15 +315,17 @@ export class MatterbridgeSwitchServer extends SwitchServer {
 }
 export class MatterbridgeOperationalStateServer extends OperationalStateServer {
     initialize() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.debug('MatterbridgeOperationalStateServer initialized: setting operational state to Stopped');
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        super.initialize();
     }
     pause() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Pause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('pause', { request: {}, cluster: OperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug('MatterbridgeOperationalStateServer: pause called setting operational state to Paused');
-        device.pause();
         this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
         return {
@@ -466,9 +333,10 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
         };
     }
     stop() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('stop', { request: {}, cluster: OperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped');
-        device.stop();
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
         return {
@@ -476,9 +344,10 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
         };
     }
     start() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Start (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('start', { request: {}, cluster: OperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug('MatterbridgeOperationalStateServer: start called setting operational state to Running');
-        device.start();
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
         return {
@@ -486,9 +355,10 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
         };
     }
     resume() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Resume (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('resume', { request: {}, cluster: OperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug('MatterbridgeOperationalStateServer: resume called setting operational state to Running');
-        device.resume();
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
         return {
@@ -497,32 +367,43 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
     }
 }
 export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
-    selectAreas({ newAreas }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        for (const area of newAreas) {
+    selectAreas(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Selecting areas ${request.newAreas} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('selectAreas', { request, cluster: ServiceAreaServer.id, attributes: this.state, endpoint: this.endpoint });
+        for (const area of request.newAreas) {
             const supportedArea = this.state.supportedAreas.find((supportedArea) => supportedArea.areaId === area);
             if (!supportedArea) {
                 device.log.error(`MatterbridgeServiceAreaServer selectAreas called with unsupported area: ${area}`);
                 return { status: ServiceArea.SelectAreasStatus.UnsupportedArea, statusText: 'Unsupported areas' };
             }
         }
-        device.selectAreas({ newAreas });
-        this.state.selectedAreas = newAreas;
-        device.log.info(`MatterbridgeServiceAreaServer selectAreas called with: ${newAreas.map((area) => area.toString()).join(', ')}`);
-        return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
+        this.state.selectedAreas = request.newAreas;
+        device.log.debug(`MatterbridgeServiceAreaServer selectAreas called with: ${request.newAreas.map((area) => area.toString()).join(', ')}`);
+        return super.selectAreas(request);
+    }
+}
+export class MatterbridgeModeSelectServer extends ModeSelectServer {
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('changeToMode', { request, cluster: ModeSelectServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode: ${request.newMode}`);
+        super.changeToMode(request);
     }
 }
 export class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyManagementModeServer {
-    changeToMode({ newMode }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('changeToMode', { request, cluster: DeviceEnergyManagementModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
-            device.log.error(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            device.log.error(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
-        device.log.info(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
-        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+        this.state.currentMode = request.newMode;
+        device.log.debug(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
+        return super.changeToMode(request);
     }
 }

package/dist/matterbridgeEndpoint.js

@@ -1,7 +1,7 @@
 import { AnsiLogger, CYAN, YELLOW, db, debugStringify, hk, or, zb } from './logger/export.js';
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidNumber, isValidObject, isValidString } from './utils/export.js';
-import { MatterbridgeServer, MatterbridgeServerDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, } from './matterbridgeBehaviors.js';
+import { MatterbridgeServer, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, } from './matterbridgeBehaviors.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultOperationalStateClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, invokeBehaviorCommand, triggerEvent, } from './matterbridgeEndpointHelpers.js';
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, UINT16_MAX, UINT32_MAX, VendorId } from '@matter/main';
 import { getClusterNameById, MeasurementType } from '@matter/main/types';
@@ -143,7 +143,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             this.deviceTypes.set(firstDefinition.code, firstDefinition);
         this.log = new AnsiLogger({ logName: options.uniqueStorageKey ?? 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
         this.log.debug(`${YELLOW}new${db} MatterbridgeEndpoint: ${zb}${'0x' + firstDefinition.code.toString(16).padStart(4, '0')}${db}-${zb}${firstDefinition.name}${db} id: ${CYAN}${options.uniqueStorageKey}${db} number: ${CYAN}${options.endpointId}${db} taglist: ${CYAN}${options.tagList ? debugStringify(options.tagList) : 'undefined'}${db}`);
-        this.behaviors.require(MatterbridgeServer, { deviceCommand: new MatterbridgeServerDevice(this.log, this.commandHandler, undefined) });
+        this.behaviors.require(MatterbridgeServer, { log: this.log, commandHandler: this.commandHandler });
     }
     static async loadInstance(definition, options = {}, debug = false) {
         return new MatterbridgeEndpoint(definition, options, debug);
@@ -871,13 +871,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.behaviors.require(MatterbridgeValveConfigurationAndControlServer.with(ValveConfigurationAndControl.Feature.Level), {
             currentState: valveState,
             targetState: valveState,
-            currentLevel: valveLevel,
-            targetLevel: valveLevel,
             openDuration: null,
             defaultOpenDuration: null,
             remainingDuration: null,
-            defaultOpenLevel: 100,
             valveFault: { generalFault: false, blocked: false, leaking: false, notConnected: false, shortCircuit: false, currentExceeded: false },
+            currentLevel: valveLevel,
+            targetLevel: valveLevel,
+            defaultOpenLevel: 100,
             levelStep: 1,
         });
         return this;
@@ -1043,7 +1043,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultDeviceEnergyManagementCluster(esaType = DeviceEnergyManagement.EsaType.Other, esaCanGenerate = false, esaState = DeviceEnergyManagement.EsaState.Online, absMinPower = 0, absMaxPower = 0) {
+    createDefaultDeviceEnergyManagementClusterServer(esaType = DeviceEnergyManagement.EsaType.Other, esaCanGenerate = false, esaState = DeviceEnergyManagement.EsaState.Online, absMinPower = 0, absMaxPower = 0) {
         this.behaviors.require(DeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting), {
             forecast: null,
             esaType,
@@ -1054,7 +1054,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultDeviceEnergyManagementModeCluster(currentMode, supportedModes) {
+    createDefaultDeviceEnergyManagementModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MatterbridgeDeviceEnergyManagementModeServer, {
             supportedModes: supportedModes ?? [
                 { label: 'No Energy Management (Forecast reporting only)', mode: 1, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.NoOptimization }] },

package/dist/matterbridgeEndpointHelpers.js

@@ -42,6 +42,8 @@ import { Pm10ConcentrationMeasurement } from '@matter/main/clusters/pm10-concent
 import { RadonConcentrationMeasurement } from '@matter/main/clusters/radon-concentration-measurement';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurement } from '@matter/main/clusters/total-volatile-organic-compounds-concentration-measurement';
 import { OperationalState } from '@matter/main/clusters/operational-state';
+import { DeviceEnergyManagement } from '@matter/main/clusters/device-energy-management';
+import { DeviceEnergyManagementMode } from '@matter/main/clusters/device-energy-management-mode';
 import { PowerSourceServer } from '@matter/main/behaviors/power-source';
 import { UserLabelServer } from '@matter/main/behaviors/user-label';
 import { FixedLabelServer } from '@matter/main/behaviors/fixed-label';
@@ -71,10 +73,11 @@ import { Pm25ConcentrationMeasurementServer } from '@matter/main/behaviors/pm25-
 import { Pm10ConcentrationMeasurementServer } from '@matter/main/behaviors/pm10-concentration-measurement';
 import { RadonConcentrationMeasurementServer } from '@matter/main/behaviors/radon-concentration-measurement';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@matter/main/behaviors/total-volatile-organic-compounds-concentration-measurement';
+import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
 import { createHash } from 'node:crypto';
 import { BLUE, CYAN, db, debugStringify, er, hk, or, YELLOW, zb } from 'node-ansi-logger';
 import { deepCopy, deepEqual, isValidArray } from './utils/export.js';
-import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, } from './matterbridgeBehaviors.js';
+import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, } from './matterbridgeBehaviors.js';
 export function capitalizeFirstLetter(name) {
     if (!name)
         return name;
@@ -204,6 +207,10 @@ export function getBehaviourTypeFromClusterServerId(clusterId) {
         return RadonConcentrationMeasurementServer.with('NumericMeasurement');
     if (clusterId === TotalVolatileOrganicCompoundsConcentrationMeasurement.Cluster.id)
         return TotalVolatileOrganicCompoundsConcentrationMeasurementServer.with('NumericMeasurement');
+    if (clusterId === DeviceEnergyManagement.Cluster.id)
+        return DeviceEnergyManagementServer.with('PowerForecastReporting');
+    if (clusterId === DeviceEnergyManagementMode.Cluster.id)
+        return MatterbridgeDeviceEnergyManagementModeServer;
     return MatterbridgeIdentifyServer;
 }
 export function getBehaviourTypeFromClusterClientId(_clusterId) {
@@ -240,6 +247,25 @@ export async function invokeBehaviorCommand(endpoint, cluster, command, params)
     });
     return true;
 }
+export async function invokeSubscribeHandler(endpoint, cluster, attribute, newValue, oldValue) {
+    const event = attribute + '$Changed';
+    const clusterName = getBehavior(endpoint, cluster)?.id;
+    if (!clusterName) {
+        endpoint.log.error(`invokeSubscribeHandler ${hk}${event}${er} error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+        return false;
+    }
+    if (endpoint.construction.status !== Lifecycle.Status.Active) {
+        endpoint.log.error(`invokeSubscribeHandler ${hk}${clusterName}.${event}${er} error: Endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er} is in the ${BLUE}${endpoint.construction.status}${er} state`);
+        return false;
+    }
+    const events = endpoint.events;
+    if (!(clusterName in events) || !(event in events[clusterName])) {
+        endpoint.log.error(`invokeSubscribeHandler ${hk}${event}${er} error: cluster ${clusterName} not found on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
+        return false;
+    }
+    await endpoint.act((agent) => agent[clusterName].events[event].emit(newValue, oldValue, { ...agent.context, offline: false }));
+    return true;
+}
 export function addRequiredClusterServers(endpoint) {
     const requiredServerList = [];
     endpoint.log.debug(`addRequiredClusterServers for ${CYAN}${endpoint.maybeId}${db}`);
@@ -343,6 +369,10 @@ export function addClusterServers(endpoint, serverList) {
         endpoint.createDefaultRadonConcentrationMeasurementClusterServer();
     if (serverList.includes(TotalVolatileOrganicCompoundsConcentrationMeasurement.Cluster.id))
         endpoint.createDefaultTvocMeasurementClusterServer();
+    if (serverList.includes(DeviceEnergyManagement.Cluster.id))
+        endpoint.createDefaultDeviceEnergyManagementClusterServer();
+    if (serverList.includes(DeviceEnergyManagementMode.Cluster.id))
+        endpoint.createDefaultDeviceEnergyManagementModeClusterServer();
 }
 export async function addFixedLabel(endpoint, label, value) {
     if (!endpoint.hasClusterServer(FixedLabel.Cluster.id)) {

package/dist/matterbridgePlatform.js

@@ -137,8 +137,8 @@ export class MatterbridgePlatform {
         this.selectEntity.clear();
         await this.saveSelects();
     }
-    async clearDeviceSelect(device) {
-        this.selectDevice.delete(device);
+    async clearDeviceSelect(serial) {
+        this.selectDevice.delete(serial);
         await this.saveSelects();
     }
     setSelectDevice(serial, name, configUrl, icon, entities) {

package/dist/roboticVacuumCleaner.js

@@ -94,49 +94,52 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
     }
 }
 export class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
-    changeToMode({ newMode }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('changeToMode', { request, cluster: RvcRunModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
-            device.log.error(`MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            device.log.error(`MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
+        this.state.currentMode = request.newMode;
         if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Cleaning)) {
-            device.log.info('MatterbridgeRvcRunModeServer changeToMode called with newMode Cleaning => Running');
+            device.log.debug('MatterbridgeRvcRunModeServer changeToMode called with newMode Cleaning => Running');
             this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
             return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Running' };
         }
         else if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Idle)) {
-            device.log.info('MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => Docked');
+            device.log.debug('MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => Docked');
             this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Docked;
             return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Docked' };
         }
-        device.log.info(`MatterbridgeRvcRunModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        device.log.debug(`MatterbridgeRvcRunModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
         this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
         return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }
 export class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
-    changeToMode({ newMode }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('changeToMode', { request, cluster: RvcCleanModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
-            device.log.error(`MatterbridgeRvcCleanModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            device.log.error(`MatterbridgeRvcCleanModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
-        device.log.info(`MatterbridgeRvcCleanModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        this.state.currentMode = request.newMode;
+        device.log.debug(`MatterbridgeRvcCleanModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
         return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }
 export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
     pause() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.log.info('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
-        device.pause();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Pause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('pause', { request: {}, cluster: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
         this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
         this.state.operationalState = RvcOperationalState.OperationalState.Paused;
         this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
@@ -145,9 +148,10 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
         };
     }
     resume() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.log.info('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
-        device.resume();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Resume (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('resume', { request: {}, cluster: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
         this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
         this.state.operationalState = RvcOperationalState.OperationalState.Running;
         this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
@@ -156,9 +160,10 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
         };
     }
     goHome() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.log.info('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
-        device.goHome();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`GoHome (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('goHome', { request: {}, cluster: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
         this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
         this.state.operationalState = RvcOperationalState.OperationalState.Docked;
         this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };

package/dist/waterHeater.js

@@ -48,30 +48,33 @@ export class WaterHeater extends MatterbridgeEndpoint {
     }
 }
 export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
-    boost({ boostInfo }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.boost({ boostInfo });
-        device.log.info(`MatterbridgeWaterHeaterManagementServer boost called with: ${JSON.stringify(boostInfo)}`);
+    boost(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Boost (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('boost', { request, cluster: WaterHeaterManagementServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeWaterHeaterManagementServer boost called with: ${JSON.stringify(request)}`);
         this.state.boostState = WaterHeaterManagement.BoostState.Active;
     }
     cancelBoost() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.cancelBoost();
-        device.log.info(`MatterbridgeWaterHeaterManagementServer cancelBoost called`);
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Cancel boost (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('cancelBoost', { request: {}, cluster: WaterHeaterManagementServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeWaterHeaterManagementServer cancelBoost called`);
         this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
     }
 }
 export class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
-    changeToMode({ newMode }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('changeToMode', { request, cluster: WaterHeaterModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
-            device.log.error(`MatterbridgeWaterHeaterModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            device.log.error(`MatterbridgeWaterHeaterModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
-        device.log.info(`MatterbridgeWaterHeaterModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        this.state.currentMode = request.newMode;
+        device.log.debug(`MatterbridgeWaterHeaterModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
         return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.6-dev-20250611-6f49811",
+  "version": "3.0.6-dev-20250612-a8a696e",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.6-dev-20250611-6f49811",
+      "version": "3.0.6-dev-20250612-a8a696e",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.14.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.6-dev-20250611-6f49811",
+  "version": "3.0.6-dev-20250612-a8a696e",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",