matterbridge 2.2.8-dev.1 → 3.0.0-edge.2

package/CHANGELOG.md

@@ -29,7 +29,37 @@ Features:
 - It is possible to choose the method: GET or POST.
 - The webhook can be tested directly in the frontend.
 
-## [2.2.8] - 2025-04-09
+## Breaking changes
+
+Matter 1.4
+
+New device types:
+
+- onOffMountedSwitch: Mounted On/Off Control (an onOff switch without client cluster!).
+- dimmableMountedSwitch: Mounted Dimmable Load Control (a dimmer switch without client cluster!).
+
+Modified clusters:
+
+- OccupancySensing cluster.
+
+## [3.0.0] - 2025-04-??
+
+### Added
+
+- [addEndpoint]: Added an error handler with deep stack on aggregatorNode.add() and serverNode.add() calls.
+
+### Changed
+
+- [deviceTypes]: Updated device types to Matter 1.4
+- [matter.js]: Update to 0.13.0-alpha.0-20250405-7fc7db48.
+- [matter.js]: Update to 0.13.0-alpha.0-20250408-c916c7e8.
+
+### Fixed
+
+- [doorLock]: Fixed supportedOperatingModes inverted bitmap (Thanks Apollon).
+- [DevicesIcon]: Fixed rendering of leak freeze and rain sensors.
+
+## [2.2.8] - 2025-04-08
 
 ### Added
 
@@ -44,7 +74,6 @@ Features:
 ### Fixed
 
 - [homepage]: Fixed warning log for homepage property in package.json.
-- [DevicesIcon]: Fixed rendering of rain, freeze and leak sensors.
 
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="bmc-button.svg" alt="Buy me a coffee" width="80">

package/dist/cluster/export.js

@@ -1 +1,205 @@
-export {};
+import { ModeBase } from '@matter/main/clusters/mode-base';
+import { Attribute, BitFlag, ClusterRegistry, Command, Event, EventPriority, FixedAttribute, MutableCluster, OptionalAttribute, OptionalCommand, OptionalEvent, TlvArray, TlvEnum, TlvField, TlvNoArguments, TlvNullable, TlvObject, TlvOptionalField, TlvString, TlvUInt32, TlvUInt8, TlvVendorId, WritableAttribute, } from '@matter/main/types';
+import { OperationalState as OperationalStateNamespace } from '@matter/main/clusters/operational-state';
+export var RvcRunMode;
+(function (RvcRunMode) {
+    let Feature;
+    (function (Feature) {
+        Feature["OnOff"] = "OnOff";
+    })(Feature = RvcRunMode.Feature || (RvcRunMode.Feature = {}));
+    let ModeTag;
+    (function (ModeTag) {
+        ModeTag[ModeTag["Auto"] = 0] = "Auto";
+        ModeTag[ModeTag["Quick"] = 1] = "Quick";
+        ModeTag[ModeTag["Quiet"] = 2] = "Quiet";
+        ModeTag[ModeTag["LowNoise"] = 3] = "LowNoise";
+        ModeTag[ModeTag["LowEnergy"] = 4] = "LowEnergy";
+        ModeTag[ModeTag["Vacation"] = 5] = "Vacation";
+        ModeTag[ModeTag["Min"] = 6] = "Min";
+        ModeTag[ModeTag["Max"] = 7] = "Max";
+        ModeTag[ModeTag["Night"] = 8] = "Night";
+        ModeTag[ModeTag["Day"] = 9] = "Day";
+        ModeTag[ModeTag["Idle"] = 16384] = "Idle";
+        ModeTag[ModeTag["Cleaning"] = 16385] = "Cleaning";
+        ModeTag[ModeTag["Mapping"] = 16386] = "Mapping";
+    })(ModeTag = RvcRunMode.ModeTag || (RvcRunMode.ModeTag = {}));
+    RvcRunMode.TlvModeTagStruct = TlvObject({
+        mfgCode: TlvOptionalField(0, TlvVendorId),
+        value: TlvField(1, TlvEnum()),
+    });
+    RvcRunMode.TlvModeOption = TlvObject({
+        label: TlvField(0, TlvString.bound({ maxLength: 64 })),
+        mode: TlvField(1, TlvUInt8),
+        modeTags: TlvField(2, TlvArray(RvcRunMode.TlvModeTagStruct, { maxLength: 8 })),
+    });
+    let ModeChangeStatus;
+    (function (ModeChangeStatus) {
+        ModeChangeStatus[ModeChangeStatus["Stuck"] = 65] = "Stuck";
+        ModeChangeStatus[ModeChangeStatus["DustBinMissing"] = 66] = "DustBinMissing";
+        ModeChangeStatus[ModeChangeStatus["DustBinFull"] = 67] = "DustBinFull";
+        ModeChangeStatus[ModeChangeStatus["WaterTankEmpty"] = 68] = "WaterTankEmpty";
+        ModeChangeStatus[ModeChangeStatus["WaterTankMissing"] = 69] = "WaterTankMissing";
+        ModeChangeStatus[ModeChangeStatus["WaterTankLidOpen"] = 70] = "WaterTankLidOpen";
+        ModeChangeStatus[ModeChangeStatus["MopCleaningPadMissing"] = 71] = "MopCleaningPadMissing";
+        ModeChangeStatus[ModeChangeStatus["BatteryLow"] = 72] = "BatteryLow";
+    })(ModeChangeStatus = RvcRunMode.ModeChangeStatus || (RvcRunMode.ModeChangeStatus = {}));
+    RvcRunMode.OnOffComponent = MutableCluster.Component({
+        attributes: {
+            startUpMode: WritableAttribute(0x2, TlvNullable(TlvUInt8), { persistent: true }),
+            onMode: WritableAttribute(0x3, TlvNullable(TlvUInt8), { persistent: true, default: null }),
+        },
+    });
+    RvcRunMode.Base = MutableCluster.Component({
+        id: 0x54,
+        name: 'RvcRunMode',
+        revision: 3,
+        features: {
+            onOff: BitFlag(0),
+        },
+        attributes: {
+            supportedModes: FixedAttribute(0x0, TlvArray(RvcRunMode.TlvModeOption, { minLength: 2, maxLength: 255 }), { default: [] }),
+            currentMode: Attribute(0x1, TlvUInt8, { persistent: true }),
+        },
+        commands: {
+            changeToMode: Command(0x0, ModeBase.TlvChangeToModeRequest, 0x1, ModeBase.TlvChangeToModeResponse),
+        },
+        extensions: MutableCluster.Extensions({ flags: { onOff: true }, component: RvcRunMode.OnOffComponent }),
+    });
+    RvcRunMode.ClusterInstance = MutableCluster(RvcRunMode.Base);
+    RvcRunMode.Cluster = RvcRunMode.ClusterInstance;
+    RvcRunMode.Complete = RvcRunMode.Cluster;
+})(RvcRunMode || (RvcRunMode = {}));
+export const RvcRunModeCluster = RvcRunMode.Cluster;
+ClusterRegistry.register(RvcRunMode.Complete);
+export var RvcCleanMode;
+(function (RvcCleanMode) {
+    let Feature;
+    (function (Feature) {
+        Feature["OnOff"] = "OnOff";
+    })(Feature = RvcCleanMode.Feature || (RvcCleanMode.Feature = {}));
+    let ModeTag;
+    (function (ModeTag) {
+        ModeTag[ModeTag["Auto"] = 0] = "Auto";
+        ModeTag[ModeTag["Quick"] = 1] = "Quick";
+        ModeTag[ModeTag["Quiet"] = 2] = "Quiet";
+        ModeTag[ModeTag["LowNoise"] = 3] = "LowNoise";
+        ModeTag[ModeTag["LowEnergy"] = 4] = "LowEnergy";
+        ModeTag[ModeTag["Vacation"] = 5] = "Vacation";
+        ModeTag[ModeTag["Min"] = 6] = "Min";
+        ModeTag[ModeTag["Max"] = 7] = "Max";
+        ModeTag[ModeTag["Night"] = 8] = "Night";
+        ModeTag[ModeTag["Day"] = 9] = "Day";
+        ModeTag[ModeTag["DeepClean"] = 16384] = "DeepClean";
+        ModeTag[ModeTag["Vacuum"] = 16385] = "Vacuum";
+        ModeTag[ModeTag["Mop"] = 16386] = "Mop";
+    })(ModeTag = RvcCleanMode.ModeTag || (RvcCleanMode.ModeTag = {}));
+    RvcCleanMode.TlvModeTagStruct = TlvObject({
+        mfgCode: TlvOptionalField(0, TlvVendorId),
+        value: TlvField(1, TlvEnum()),
+    });
+    RvcCleanMode.TlvModeOption = TlvObject({
+        label: TlvField(0, TlvString.bound({ maxLength: 64 })),
+        mode: TlvField(1, TlvUInt8),
+        modeTags: TlvField(2, TlvArray(RvcCleanMode.TlvModeTagStruct, { maxLength: 8 })),
+    });
+    let ModeChangeStatus;
+    (function (ModeChangeStatus) {
+        ModeChangeStatus[ModeChangeStatus["CleaningInProgress"] = 64] = "CleaningInProgress";
+    })(ModeChangeStatus = RvcCleanMode.ModeChangeStatus || (RvcCleanMode.ModeChangeStatus = {}));
+    RvcCleanMode.OnOffComponent = MutableCluster.Component({
+        attributes: {
+            startUpMode: WritableAttribute(0x2, TlvNullable(TlvUInt8), { persistent: true }),
+            onMode: WritableAttribute(0x3, TlvNullable(TlvUInt8), { persistent: true, default: null }),
+        },
+    });
+    RvcCleanMode.Base = MutableCluster.Component({
+        id: 0x55,
+        name: 'RvcCleanMode',
+        revision: 3,
+        features: {
+            onOff: BitFlag(0),
+        },
+        attributes: {
+            supportedModes: FixedAttribute(0x0, TlvArray(RvcCleanMode.TlvModeOption, { minLength: 2, maxLength: 255 }), { default: [] }),
+            currentMode: Attribute(0x1, TlvUInt8, { persistent: true }),
+        },
+        commands: {
+            changeToMode: Command(0x0, ModeBase.TlvChangeToModeRequest, 0x1, ModeBase.TlvChangeToModeResponse),
+        },
+        extensions: MutableCluster.Extensions({ flags: { onOff: true }, component: RvcCleanMode.OnOffComponent }),
+    });
+    RvcCleanMode.ClusterInstance = MutableCluster(RvcCleanMode.Base);
+    RvcCleanMode.Cluster = RvcCleanMode.ClusterInstance;
+    RvcCleanMode.Complete = RvcCleanMode.Cluster;
+})(RvcCleanMode || (RvcCleanMode = {}));
+export const RvcCleanModeCluster = RvcCleanMode.Cluster;
+ClusterRegistry.register(RvcCleanMode.Complete);
+export var RvcOperationalState;
+(function (RvcOperationalState) {
+    let OperationalState;
+    (function (OperationalState) {
+        OperationalState[OperationalState["Stopped"] = 0] = "Stopped";
+        OperationalState[OperationalState["Running"] = 1] = "Running";
+        OperationalState[OperationalState["Paused"] = 2] = "Paused";
+        OperationalState[OperationalState["Error"] = 3] = "Error";
+        OperationalState[OperationalState["SeekingCharger"] = 64] = "SeekingCharger";
+        OperationalState[OperationalState["Charging"] = 65] = "Charging";
+        OperationalState[OperationalState["Docked"] = 66] = "Docked";
+    })(OperationalState = RvcOperationalState.OperationalState || (RvcOperationalState.OperationalState = {}));
+    RvcOperationalState.TlvOperationalStateStruct = TlvObject({
+        operationalStateId: TlvField(0, TlvEnum()),
+        operationalStateLabel: TlvOptionalField(1, TlvString.bound({ maxLength: 64 })),
+    });
+    let ErrorState;
+    (function (ErrorState) {
+        ErrorState[ErrorState["NoError"] = 0] = "NoError";
+        ErrorState[ErrorState["UnableToStartOrResume"] = 1] = "UnableToStartOrResume";
+        ErrorState[ErrorState["UnableToCompleteOperation"] = 2] = "UnableToCompleteOperation";
+        ErrorState[ErrorState["CommandInvalidInState"] = 3] = "CommandInvalidInState";
+        ErrorState[ErrorState["FailedToFindChargingDock"] = 64] = "FailedToFindChargingDock";
+        ErrorState[ErrorState["Stuck"] = 65] = "Stuck";
+        ErrorState[ErrorState["DustBinMissing"] = 66] = "DustBinMissing";
+        ErrorState[ErrorState["DustBinFull"] = 67] = "DustBinFull";
+        ErrorState[ErrorState["WaterTankEmpty"] = 68] = "WaterTankEmpty";
+        ErrorState[ErrorState["WaterTankMissing"] = 69] = "WaterTankMissing";
+        ErrorState[ErrorState["WaterTankLidOpen"] = 70] = "WaterTankLidOpen";
+        ErrorState[ErrorState["MopCleaningPadMissing"] = 71] = "MopCleaningPadMissing";
+    })(ErrorState = RvcOperationalState.ErrorState || (RvcOperationalState.ErrorState = {}));
+    RvcOperationalState.TlvErrorStateStruct = TlvObject({
+        errorStateId: TlvField(0, TlvEnum()),
+        errorStateLabel: TlvOptionalField(1, TlvString.bound({ maxLength: 64 })),
+        errorStateDetails: TlvOptionalField(2, TlvString.bound({ maxLength: 64 })),
+    });
+    RvcOperationalState.TlvOperationalCommandResponse = TlvObject({
+        commandResponseState: TlvField(0, RvcOperationalState.TlvErrorStateStruct),
+    });
+    RvcOperationalState.TlvOperationalErrorEvent = TlvObject({ errorState: TlvField(0, RvcOperationalState.TlvErrorStateStruct) });
+    RvcOperationalState.ClusterInstance = MutableCluster({
+        id: 0x61,
+        name: 'RvcOperationalState',
+        revision: 2,
+        attributes: {
+            phaseList: Attribute(0x0, TlvNullable(TlvArray(TlvString, { maxLength: 32 }))),
+            currentPhase: Attribute(0x1, TlvNullable(TlvUInt8)),
+            countdownTime: OptionalAttribute(0x2, TlvNullable(TlvUInt32.bound({ max: 259200 })), { default: null }),
+            operationalStateList: Attribute(0x3, TlvArray(RvcOperationalState.TlvOperationalStateStruct), { default: [] }),
+            operationalState: Attribute(0x4, TlvEnum()),
+            operationalError: Attribute(0x5, RvcOperationalState.TlvErrorStateStruct),
+        },
+        commands: {
+            pause: OptionalCommand(0x0, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            stop: OptionalCommand(0x1, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            start: OptionalCommand(0x2, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            resume: OptionalCommand(0x3, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            goHome: OptionalCommand(0x80, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+        },
+        events: {
+            operationalError: Event(0x0, EventPriority.Critical, RvcOperationalState.TlvOperationalErrorEvent),
+            operationCompletion: OptionalEvent(0x1, EventPriority.Info, OperationalStateNamespace.TlvOperationCompletionEvent),
+        },
+    });
+    RvcOperationalState.Cluster = RvcOperationalState.ClusterInstance;
+    RvcOperationalState.Complete = RvcOperationalState.Cluster;
+})(RvcOperationalState || (RvcOperationalState = {}));
+export const RvcOperationalStateCluster = RvcOperationalState.Cluster;
+ClusterRegistry.register(RvcOperationalState.Complete);

package/dist/matterbridge.js

@@ -2,6 +2,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
 import EventEmitter from 'node:events';
+import { inspect } from 'node:util';
 import { AnsiLogger, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, CYAN } from './logger/export.js';
 import { NodeStorageManager } from './storage/export.js';
 import { getParameter, getIntParameter, hasParameter, copyDirectory, withTimeout } from './utils/export.js';
@@ -306,30 +307,30 @@ export class Matterbridge extends EventEmitter {
         if (hasParameter('matterlogger')) {
             const level = getParameter('matterlogger');
             if (level === 'debug') {
-                Logger.defaultLogLevel = MatterLogLevel.DEBUG;
+                Logger.level = MatterLogLevel.DEBUG;
             }
             else if (level === 'info') {
-                Logger.defaultLogLevel = MatterLogLevel.INFO;
+                Logger.level = MatterLogLevel.INFO;
             }
             else if (level === 'notice') {
-                Logger.defaultLogLevel = MatterLogLevel.NOTICE;
+                Logger.level = MatterLogLevel.NOTICE;
             }
             else if (level === 'warn') {
-                Logger.defaultLogLevel = MatterLogLevel.WARN;
+                Logger.level = MatterLogLevel.WARN;
             }
             else if (level === 'error') {
-                Logger.defaultLogLevel = MatterLogLevel.ERROR;
+                Logger.level = MatterLogLevel.ERROR;
             }
             else if (level === 'fatal') {
-                Logger.defaultLogLevel = MatterLogLevel.FATAL;
+                Logger.level = MatterLogLevel.FATAL;
             }
             else {
                 this.log.warn(`Invalid matter.js logger level: ${level}. Using default level "info".`);
-                Logger.defaultLogLevel = MatterLogLevel.INFO;
+                Logger.level = MatterLogLevel.INFO;
             }
         }
         else {
-            Logger.defaultLogLevel = await this.nodeContext.get('matterLogLevel', this.matterbridgeInformation.shellyBoard ? MatterLogLevel.NOTICE : MatterLogLevel.INFO);
+            Logger.level = (await this.nodeContext.get('matterLogLevel', this.matterbridgeInformation.shellyBoard ? MatterLogLevel.NOTICE : MatterLogLevel.INFO));
         }
         Logger.format = MatterLogFormat.ANSI;
         Logger.setLogger('default', this.createMatterLogger());
@@ -1327,7 +1328,7 @@ export class Matterbridge extends EventEmitter {
                 }
                 this.startServerNode(plugin.serverNode);
                 plugin.reachabilityTimeout = setTimeout(() => {
-                    this.log.info(`Setting reachability to true for ${plg}${plugin.name}${db} type ${plugin.type} server node ${plugin.serverNode !== undefined} aggragator node ${plugin.aggregatorNode !== undefined} device ${plugin.device !== undefined}`);
+                    this.log.info(`Setting reachability to true for ${plg}${plugin.name}${nf} type ${plugin.type} server node ${plugin.serverNode !== undefined} aggregator node ${plugin.aggregatorNode !== undefined} device ${plugin.device !== undefined}`);
                     if (plugin.type === 'DynamicPlatform' && plugin.aggregatorNode)
                         this.setAggregatorReachability(plugin.aggregatorNode, true);
                     this.frontend.wssSendRefreshRequired('reachability');
@@ -1430,6 +1431,7 @@ export class Matterbridge extends EventEmitter {
                 softwareVersionString: await storageContext.get('softwareVersionString'),
                 hardwareVersion: await storageContext.get('hardwareVersion'),
                 hardwareVersionString: await storageContext.get('hardwareVersionString'),
+                reachable: true,
             },
         });
         const sanitizeFabrics = (fabrics, resetSessions = false) => {
@@ -1638,18 +1640,46 @@ export class Matterbridge extends EventEmitter {
             this.log.debug(`Adding bridged endpoint ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} to Matterbridge aggregator node`);
             if (!this.aggregatorNode)
                 this.log.error('Aggregator node not found for Matterbridge');
-            await this.aggregatorNode?.add(device);
+            try {
+                await this.aggregatorNode?.add(device);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : '';
+                const errorStack = error instanceof Error ? error.stack : '';
+                const errorDebug = inspect(error, { depth: 10 });
+                this.log.error(`Error adding bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for plugin ${plg}${pluginName}${er}: ${error} ${errorMessage} ${errorStack} ${errorDebug}`);
+                return;
+            }
         }
         else if (this.bridgeMode === 'childbridge') {
             if (plugin.type === 'AccessoryPlatform') {
-                await this.createAccessoryPlugin(plugin, device);
+                try {
+                    this.log.debug(`Creating endpoint ${dev}${device.deviceName}${db} for AccessoryPlatform plugin ${plg}${plugin.name}${db} server node`);
+                    await this.createAccessoryPlugin(plugin, device);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : '';
+                    const errorStack = error instanceof Error ? error.stack : '';
+                    const errorDebug = inspect(error, { depth: 10 });
+                    this.log.error(`Error creating endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for AccessoryPlatform plugin ${plg}${pluginName}${er} server node: ${error} ${errorMessage} ${errorStack} ${errorDebug}`);
+                    return;
+                }
             }
             if (plugin.type === 'DynamicPlatform') {
                 plugin.locked = true;
-                this.log.debug(`Adding bridged endpoint ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} to ${plg}${plugin.name}${db} aggregator node`);
+                this.log.debug(`Adding bridged endpoint ${dev}${device.deviceName}${db} for DynamicPlatform plugin ${plg}${plugin.name}${db} aggregator node`);
                 if (!plugin.aggregatorNode)
                     this.log.error(`Aggregator node not found for plugin ${plg}${plugin.name}${db}`);
-                await plugin.aggregatorNode?.add(device);
+                try {
+                    await plugin.aggregatorNode?.add(device);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : '';
+                    const errorStack = error instanceof Error ? error.stack : '';
+                    const errorDebug = inspect(error, { depth: 10 });
+                    this.log.error(`Error adding bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for DynamicPlatform plugin ${plg}${pluginName}${er} aggregator node: ${error} ${errorMessage} ${errorStack} ${errorDebug}`);
+                    return;
+                }
             }
         }
         if (plugin.registeredDevices !== undefined)

package/dist/matterbridgeBehaviors.js

@@ -1,4 +1,5 @@
-import { Behavior } from '@matter/main';
+import { Behavior, ClusterBehavior } from '@matter/main';
+import { Status } from '@matter/main/types';
 import { BooleanStateConfiguration } from '@matter/main/clusters/boolean-state-configuration';
 import { ColorControl } from '@matter/main/clusters/color-control';
 import { FanControl } from '@matter/main/clusters/fan-control';
@@ -14,11 +15,15 @@ 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 { ThermostatServer } from '@matter/main/behaviors/thermostat';
-import { ValveConfigurationAndControlServer } from '@matter/main/behaviors/valve-configuration-and-control';
+import { ThermostatBehavior } from '@matter/main/behaviors/thermostat';
+import { ValveConfigurationAndControlBehavior } 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 { RvcCleanMode } from 'matterbridge/cluster';
+import { RvcRunMode } from 'matterbridge/cluster';
+import { RvcOperationalState } from 'matterbridge/cluster';
+import { OperationalState } from '@matter/main/clusters/operational-state';
 export class MatterbridgeBehaviorDevice {
     log;
     commandHandler;
@@ -292,7 +297,7 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
         super.step({ direction, wrap, lowestOff });
     }
 }
-export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
+export class MatterbridgeThermostatServer extends ThermostatBehavior.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
     async setpointRaiseLower({ mode, amount }) {
         const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
         device.setpointRaiseLower({ mode, amount });
@@ -310,19 +315,24 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
             this.state.occupiedCoolingSetpoint = setpoint * 100;
             device.log.debug('Set occupiedCoolingSetpoint to:', setpoint);
         }
-        super.setpointRaiseLower({ mode, amount });
     }
 }
-export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigurationAndControlServer.with(ValveConfigurationAndControl.Feature.Level) {
-    async open({ openDuration, targetLevel }) {
+export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigurationAndControlBehavior.with(ValveConfigurationAndControl.Feature.Level) {
+    initialize() {
+    }
+    open({ openDuration, targetLevel }) {
         const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        device.log.debug(`Command open called with openDuration: ${openDuration} targetLevel: ${targetLevel}`);
         device.open({ openDuration, targetLevel });
-        super.open({ openDuration, targetLevel });
+        this.state.targetLevel = targetLevel ?? 100;
+        this.state.currentLevel = targetLevel ?? 100;
     }
-    async close() {
+    close() {
         const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        device.log.debug(`Command close called`);
         device.close();
-        super.close();
+        this.state.targetLevel = 0;
+        this.state.currentLevel = 0;
     }
 }
 export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm) {
@@ -343,3 +353,71 @@ export class MatterbridgeSwitchServer extends SwitchServer {
     initialize() {
     }
 }
+export const RvcRunModeBehavior = ClusterBehavior.withInterface().for(RvcRunMode.Cluster);
+export class MatterbridgeRvcRunModeServer extends RvcRunModeBehavior.with(RvcRunMode.Feature.OnOff) {
+    initialize() {
+    }
+    changeToMode({ newMode }) {
+        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        console.log('MatterbridgeRvcRunModeServer changeToMode called with newMode:', newMode);
+        return { status: Status.Success, statusText: 'Success' };
+    }
+}
+export const RvcCleanModeBehavior = ClusterBehavior.withInterface().for(RvcCleanMode.Cluster);
+export class MatterbridgeRvcCleanModeServer extends RvcCleanModeBehavior.with(RvcRunMode.Feature.OnOff) {
+    initialize() {
+    }
+    changeToMode({ newMode }) {
+        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        console.log('MatterbridgeRvcCleanModeServer changeToMode called with newMode:', newMode);
+        return { status: Status.Success, statusText: 'Success' };
+    }
+}
+export const RvcOperationalStateBehavior = ClusterBehavior.withInterface().for(RvcOperationalState.Cluster);
+export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBehavior {
+    initialize() {
+        console.log('MatterbridgeRvcOperationalStateServer initialized: setting operational state to Docked');
+        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
+        this.reactTo(this.agent.get(OnOffServer).events.onOff$Changed, this.handleOnOffChange);
+    }
+    handleOnOffChange(onOff) {
+        if (onOff) {
+            console.log('OnOffServer changed to ON: setting operational state to Running');
+            this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
+            this.state.operationalState = RvcOperationalState.OperationalState.Running;
+            this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
+        }
+        else {
+            console.log('OnOffServer changed to OFF: setting operational state to Docked');
+            this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
+            this.state.operationalState = RvcOperationalState.OperationalState.Docked;
+            this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
+        }
+    }
+    pause() {
+        console.log('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' };
+        return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error' } };
+    }
+    resume() {
+        console.log('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' };
+        return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error' } };
+    }
+    goHome() {
+        console.log('MatterbridgeRvcOperationalStateServer: go home 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' };
+        return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error' } };
+    }
+}