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

package/CHANGELOG.md

@@ -52,10 +52,12 @@ Modified clusters:
 
 - [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
 
@@ -67,6 +69,11 @@ Modified clusters:
 ### Changed
 
 - [package]: Update dependencies.
+- [package]: Use node:https.
+
+### Fixed
+
+- [homepage]: Fixed warning log for homepage property in package.json.
 
 <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/frontend.js

@@ -1,9 +1,9 @@
 import { EndpointServer, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, Lifecycle } from '@matter/main';
 import { createServer } from 'node:http';
+import https from 'node:https';
 import os from 'node:os';
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
-import https from 'https';
 import express from 'express';
 import WebSocket, { WebSocketServer } from 'ws';
 import multer from 'multer';

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';
@@ -19,6 +20,10 @@ import { ValveConfigurationAndControlBehavior } from '@matter/main/behaviors/val
 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;
@@ -348,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' } };
+    }
+}

package/dist/matterbridgeEndpoint.js

@@ -1,7 +1,7 @@
 import { AnsiLogger, BLUE, CYAN, YELLOW, db, debugStringify, er, hk, or, zb } from './logger/export.js';
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidNumber, isValidObject } from './utils/export.js';
-import { MatterbridgeBehavior, MatterbridgeBehaviorDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, } from './matterbridgeBehaviors.js';
+import { MatterbridgeBehavior, MatterbridgeBehaviorDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeRvcRunModeServer, MatterbridgeRvcCleanModeServer, MatterbridgeRvcOperationalStateServer, } from './matterbridgeBehaviors.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, capitalizeFirstLetter, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, } from './matterbridgeEndpointHelpers.js';
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, VendorId } from '@matter/main';
 import { ClusterType, getClusterNameById, MeasurementType } from '@matter/main/types';
@@ -57,9 +57,7 @@ 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 { RvcRunModeServer } from '@matter/main/behaviors/rvc-run-mode';
-import { RvcOperationalStateServer } from '@matter/main/behaviors/rvc-operational-state';
-import { RvcCleanModeServer } from '@matter/main/behaviors/rvc-clean-mode';
+import { RvcCleanMode } from '@matter/main/clusters/rvc-clean-mode';
 export class MatterbridgeEndpoint extends Endpoint {
     static bridgeMode = '';
     static logLevel = "info";
@@ -1157,17 +1155,33 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createDefaultRvcRunModeClusterServer() {
-        this.behaviors.require(RvcRunModeServer, {
+        this.behaviors.require(MatterbridgeRvcRunModeServer.with(RvcRunMode.Feature.OnOff), {
             supportedModes: [
                 { label: 'Idle', mode: 1, modeTags: [{ value: RvcRunMode.ModeTag.Idle }] },
                 { label: 'Cleaning', mode: 2, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }] },
+                { label: 'SpotCleaning', mode: 3, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }] },
             ],
             currentMode: 1,
+            startUpMode: null,
+            onMode: null,
+        });
+        return this;
+    }
+    createDefaultRvcCleanModeClusterServer() {
+        this.behaviors.require(MatterbridgeRvcCleanModeServer.with(RvcCleanMode.Feature.OnOff), {
+            supportedModes: [
+                { label: 'Vacuum', mode: 1, modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }] },
+                { label: 'Mop', mode: 2, modeTags: [{ value: RvcCleanMode.ModeTag.Mop }] },
+                { label: 'Clean', mode: 3, modeTags: [{ value: RvcCleanMode.ModeTag.DeepClean }] },
+            ],
+            currentMode: 1,
+            startUpMode: null,
+            onMode: null,
         });
         return this;
     }
     createDefaultRvcOperationalStateClusterServer() {
-        this.behaviors.require(RvcOperationalStateServer, {
+        this.behaviors.require(MatterbridgeRvcOperationalStateServer, {
             phaseList: [],
             currentPhase: null,
             operationalStateList: [
@@ -1179,19 +1193,8 @@ export class MatterbridgeEndpoint extends Endpoint {
                 { operationalStateId: RvcOperationalState.OperationalState.Charging, operationalStateLabel: 'Charging' },
                 { operationalStateId: RvcOperationalState.OperationalState.Docked, operationalStateLabel: 'Docked' },
             ],
-            operationalState: RvcOperationalState.OperationalState.Stopped,
-            operationalError: { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' },
-        });
-        return this;
-    }
-    createDefaultRvcCleanModeClusterServer() {
-        this.behaviors.require(RvcCleanModeServer, {
-            supportedModes: [
-                { label: 'Idle', mode: 1, modeTags: [] },
-                { label: 'Cleaning', mode: 2, modeTags: [] },
-                { label: 'SpotCleaning', mode: 3, modeTags: [] },
-            ],
-            currentMode: 1,
+            operationalState: RvcOperationalState.OperationalState.Docked,
+            operationalError: { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operative' },
         });
         return this;
     }

package/dist/pluginManager.js

@@ -226,7 +226,7 @@ export class PluginManager {
             if (!packageJson.author)
                 this.log.warn(`Plugin ${plg}${plugin.name}${wr} has no author in package.json`);
             if (!packageJson.homepage)
-                this.log.warn(`Plugin ${plg}${plugin.name}${wr} has no homepage in package.json`);
+                this.log.info(`Plugin ${plg}${plugin.name}${nf} has no homepage in package.json`);
             if (!packageJson.type || packageJson.type !== 'module')
                 this.log.error(`Plugin ${plg}${plugin.name}${er} is not a module`);
             if (!packageJson.main)
@@ -748,7 +748,13 @@ export class PluginManager {
             return schema;
         }
         catch (err) {
-            this.log.debug(`Schema file ${schemaFile} for plugin ${plg}${plugin.name}${db} not found. Loading default schema. Error: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
+            const nodeErr = err;
+            if (nodeErr.code === 'ENOENT') {
+                this.log.debug(`Schema file ${schemaFile} for plugin ${plg}${plugin.name}${db} not found. Loading default schema.`);
+            }
+            else {
+                this.log.debug(`Schema file ${schemaFile} for plugin ${plg}${plugin.name}${db} not found. Loading default schema. Error: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
+            }
             return this.getDefaultSchema(plugin);
         }
     }

package/frontend/build/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.ea7910e9.css",
-    "main.js": "./static/js/main.1fa50342.js",
+    "main.js": "./static/js/main.fe57dcc8.js",
     "static/js/453.d855a71b.chunk.js": "./static/js/453.d855a71b.chunk.js",
     "static/media/roboto-latin-700-normal.woff2": "./static/media/roboto-latin-700-normal.c4d6cab43bec89049809.woff2",
     "static/media/roboto-latin-500-normal.woff2": "./static/media/roboto-latin-500-normal.599f66a60bdf974e578e.woff2",
@@ -77,11 +77,11 @@
     "static/media/roboto-greek-ext-300-normal.woff": "./static/media/roboto-greek-ext-300-normal.60729cafbded24073dfb.woff",
     "index.html": "./index.html",
     "main.ea7910e9.css.map": "./static/css/main.ea7910e9.css.map",
-    "main.1fa50342.js.map": "./static/js/main.1fa50342.js.map",
+    "main.fe57dcc8.js.map": "./static/js/main.fe57dcc8.js.map",
     "453.d855a71b.chunk.js.map": "./static/js/453.d855a71b.chunk.js.map"
   },
   "entrypoints": [
     "static/css/main.ea7910e9.css",
-    "static/js/main.1fa50342.js"
+    "static/js/main.fe57dcc8.js"
   ]
 }

package/frontend/build/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><base href="./"><link rel="icon" href="./matterbridge 32x32.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><title>Matterbridge</title><link rel="manifest" href="./manifest.json"/><script defer="defer" src="./static/js/main.1fa50342.js"></script><link href="./static/css/main.ea7910e9.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><base href="./"><link rel="icon" href="./matterbridge 32x32.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><title>Matterbridge</title><link rel="manifest" href="./manifest.json"/><script defer="defer" src="./static/js/main.fe57dcc8.js"></script><link href="./static/css/main.ea7910e9.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>