matterbridge-roborock-vacuum-plugin 1.0.7 → 1.0.8-rc02

package/.github/workflows/publish.yml

@@ -28,7 +28,10 @@ jobs:
       - name: Build (optional)
         run: npm run build
 
+      - name: Run tests
+        run: npm run test
+
       - name: Publish to npm
         run: npm publish
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -68,6 +68,8 @@ To get the **DUID** for your devices, you have two options:
 
 ---
 
+**➡️ [See Supported & Tested Roborock Devices](./README_SUPPORTED.md)**
+
 ### 📦 Prerequisites
 
 - A working installation of [Matterbridge](https://github.com/Luligu/matterbridge)

package/README_SUPPORTED.md

@@ -0,0 +1,54 @@
+# Supported & Tested Roborock Device Models
+
+## ✅ Tested Devices
+
+| Device Name                | Model Enum Key         | Model String                  |    Thank         |
+|----------------------------|------------------------|-------------------------------|------------------|
+| Roborock Qrevo Edge 5V1    | `QREVO_EDGE_5V1`       | `roborock.vacuum.a187`        |                  |
+| Roborock S8 Pro Ultra      | `S8_PRO_ULTRA`         | `roborock.vacuum.a70`         |                  |
+| Roborock S7 MaxV           | `S7_MAXV`              | `roborock.vacuum.a27`         |                  |
+
+These devices have been fully tested and are confirmed to work as expected.
+
+---
+
+## ⚠️ Other Supported Devices
+
+All other models listed in the code are supported, but **may have some limitations**.
+
+**Reason:**  
+I do not own these devices for direct testing.
+
+If you have one of these models, please try it out and let me know your results!
+
+---
+
+### List of Other Models that I know the mode string
+
+- Q5 (`roborock.vacuum.a34`)
+- Q5_PRO (`roborock.vacuum.a72`)
+- S5 (`roborock.vacuum.s5`)
+- S5_MAX (`roborock.vacuum.s5e`)
+- S6 (`roborock.vacuum.s6`)
+- S6_MAXV (`roborock.vacuum.a10`)
+- S6_PURE (`roborock.vacuum.a08`)
+- Q7 (`roborock.vacuum.a40`)
+- Q7_MAX (`roborock.vacuum.a38`)
+- Q7_PLUS (`roborock.vacuum.a40`)
+- S7 (`roborock.vacuum.a15`)
+- S7_MAXV_ULTRA (`roborock.vacuum.a65`)
+- S7_PRO_ULTRA (`roborock.vacuum.a62`)
+- Q8_MAX (`roborock.vacuum.a73`)
+- S8 (`roborock.vacuum.a51`)
+- S8_MAXV_ULTRA (`roborock.vacuum.a97`)
+- QREVO_MASTER (`roborock.vacuum.a117`)
+- QREVO_CURV (`roborock.vacuum.a135`)
+- QREVO_S (`roborock.vacuum.a104`)
+- QREVO_PRO (`roborock.vacuum.a101`)
+- QREVO_MAXV (`roborock.vacuum.a87`)
+- QREVO_EDGE_5AE (`roborock.vacuum.xxxx`)
+
+---
+
+> **Note:**  
+> If you have a device not listed above, feel free to try it and report your experience!

package/dist/behaviorFactory.js

@@ -3,6 +3,7 @@ import { setCommandHandlerA187 } from './behaviors/roborock.vacuum/QREVO_EDGE_5V
 import { setDefaultCommandHandler } from './behaviors/roborock.vacuum/default/default.js';
 import { DeviceModel } from './roborockCommunication/Zmodel/deviceModel.js';
 import { setCommandHandlerA27 } from './behaviors/roborock.vacuum/S7_MAXV/a27.js';
+import { setCommandHandlerA51 } from './behaviors/roborock.vacuum/S8_PRO_ULTRA/a51.js';
 export function configurateBehavior(model, duid, roborockService, cleanModeSettings, logger) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1: {
@@ -12,12 +13,17 @@ export function configurateBehavior(model, duid, roborockService, cleanModeSetti
         }
         case DeviceModel.S7_MAXV: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setCommandHandlerA27(duid, deviceHandler, logger, roborockService);
+            setCommandHandlerA27(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+            return deviceHandler;
+        }
+        case DeviceModel.S8_PRO_ULTRA: {
+            const deviceHandler = new BehaviorDeviceGeneric(logger);
+            setCommandHandlerA51(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
         default: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setDefaultCommandHandler(duid, deviceHandler, logger, roborockService);
+            setDefaultCommandHandler(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
     }

package/dist/behaviors/roborock.vacuum/QREVO_EDGE_5V1/a187.js

@@ -53,9 +53,9 @@ const RvcCleanMode = {
 };
 const CleanSetting = {
     [4]: { suctionPower: 0, waterFlow: 0, distance_off: 0, mopRoute: MopRouteA187.Smart },
-    [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Custom },
-    [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, distance_off: 0, mopRoute: MopRouteA187.Custom },
-    [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Custom },
+    [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, distance_off: 0, mopRoute: MopRouteA187.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Standard },
     [8]: { suctionPower: VacuumSuctionPowerA187.Custom, waterFlow: MopWaterFlowA187.Custom, distance_off: 0, mopRoute: MopRouteA187.Custom },
 };
 export function setCommandHandlerA187(duid, handler, logger, roborockService, cleanModeSettings) {

package/dist/behaviors/roborock.vacuum/S7_MAXV/a27.js

@@ -47,12 +47,12 @@ const RvcCleanMode = {
     [8]: 'Custom',
 };
 const CleanSetting = {
-    [5]: { suctionPower: VacuumSuctionPowerA27.Off, waterFlow: MopWaterFlowA27.Medium, mopRoute: MopRouteA27.Custom },
-    [6]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Off, mopRoute: MopRouteA27.Custom },
-    [7]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Medium, mopRoute: MopRouteA27.Custom },
-    [8]: { suctionPower: VacuumSuctionPowerA27.Custom, waterFlow: MopWaterFlowA27.Custom, mopRoute: MopRouteA27.Custom },
+    [5]: { suctionPower: VacuumSuctionPowerA27.Off, waterFlow: MopWaterFlowA27.Medium, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Off, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Medium, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [8]: { suctionPower: VacuumSuctionPowerA27.Custom, waterFlow: MopWaterFlowA27.Custom, distance_off: 0, mopRoute: MopRouteA27.Custom },
 };
-export function setCommandHandlerA27(duid, handler, logger, roborockService) {
+export function setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
@@ -63,10 +63,18 @@ export function setCommandHandlerA27(duid, handler, logger, roborockService) {
             }
             case 'Mop':
             case 'Vacuum':
-            case 'Vac & Mop':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
             case 'Custom': {
                 const setting = CleanSetting[newMode];
-                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, code: ${debugStringify(setting)}`);
+                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
                 return;
             }
             default:
@@ -74,6 +82,41 @@ export function setCommandHandlerA27(duid, handler, logger, roborockService) {
                 return;
         }
     });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlowA27[mopSetting?.waterFlowMode] ?? MopWaterFlowA27.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA27.Off,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[mopSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPowerA27[vacuumSetting?.fanMode] ?? VacuumSuctionPowerA27.Balanced,
+                    waterFlow: MopWaterFlowA27.Off,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[vacuumSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlowA27[vacmopSetting?.waterFlowMode] ?? MopWaterFlowA27.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA27[vacmopSetting?.fanMode] ?? VacuumSuctionPowerA27.Balanced,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[vacmopSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
     handler.setCommandHandler('selectAreas', async (newAreas) => {
         logger.notice(`BehaviorA27-selectAreas: ${newAreas}`);
         roborockService.setSelectedAreas(duid, newAreas ?? []);

package/dist/behaviors/roborock.vacuum/S8_PRO_ULTRA/a51.js

@@ -0,0 +1,139 @@
+import { debugStringify } from 'matterbridge/logger';
+import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
+export class BehaviorA51 extends BehaviorRoborock {
+}
+export var BehaviorRoborockA51;
+(function (BehaviorRoborockA51) {
+    class State {
+        device;
+    }
+    BehaviorRoborockA51.State = State;
+})(BehaviorRoborockA51 || (BehaviorRoborockA51 = {}));
+export var VacuumSuctionPowerA51;
+(function (VacuumSuctionPowerA51) {
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Quiet"] = 101] = "Quiet";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Balanced"] = 102] = "Balanced";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Turbo"] = 103] = "Turbo";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Max"] = 104] = "Max";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Off"] = 105] = "Off";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Custom"] = 106] = "Custom";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["MaxPlus"] = 108] = "MaxPlus";
+})(VacuumSuctionPowerA51 || (VacuumSuctionPowerA51 = {}));
+export var MopWaterFlowA51;
+(function (MopWaterFlowA51) {
+    MopWaterFlowA51[MopWaterFlowA51["Off"] = 200] = "Off";
+    MopWaterFlowA51[MopWaterFlowA51["Low"] = 201] = "Low";
+    MopWaterFlowA51[MopWaterFlowA51["Medium"] = 202] = "Medium";
+    MopWaterFlowA51[MopWaterFlowA51["High"] = 203] = "High";
+    MopWaterFlowA51[MopWaterFlowA51["Custom"] = 204] = "Custom";
+})(MopWaterFlowA51 || (MopWaterFlowA51 = {}));
+export var MopRouteA51;
+(function (MopRouteA51) {
+    MopRouteA51[MopRouteA51["Standard"] = 300] = "Standard";
+    MopRouteA51[MopRouteA51["Deep"] = 301] = "Deep";
+    MopRouteA51[MopRouteA51["Custom"] = 302] = "Custom";
+    MopRouteA51[MopRouteA51["DeepPlus"] = 303] = "DeepPlus";
+    MopRouteA51[MopRouteA51["Fast"] = 304] = "Fast";
+})(MopRouteA51 || (MopRouteA51 = {}));
+const RvcRunMode = {
+    [1]: 'Idle',
+    [2]: 'Cleaning',
+    [3]: 'Mapping',
+};
+const RvcCleanMode = {
+    [5]: 'Mop',
+    [6]: 'Vacuum',
+    [7]: 'Vac & Mop',
+    [8]: 'Custom',
+};
+const CleanSetting = {
+    [5]: { suctionPower: VacuumSuctionPowerA51.Off, waterFlow: MopWaterFlowA51.Medium, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA51.Balanced, waterFlow: MopWaterFlowA51.Off, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA51.Balanced, waterFlow: MopWaterFlowA51.Medium, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [8]: { suctionPower: VacuumSuctionPowerA51.Custom, waterFlow: MopWaterFlowA51.Custom, distance_off: 0, mopRoute: MopRouteA51.Custom },
+};
+export function setCommandHandlerA51(duid, handler, logger, roborockService, cleanModeSettings) {
+    handler.setCommandHandler('changeToMode', async (newMode) => {
+        const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+        switch (activity) {
+            case 'Cleaning': {
+                await roborockService.startClean(duid);
+                return;
+            }
+            case 'Mop':
+            case 'Vacuum':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`BehaviorA51-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
+            case 'Custom': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`BehaviorA51-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
+                return;
+            }
+            default:
+                logger.notice('BehaviorA51-changeToMode-Unknown: ', newMode);
+                return;
+        }
+    });
+    handler.setCommandHandler('selectAreas', async (newAreas) => {
+        logger.notice(`BehaviorA51-selectAreas: ${newAreas}`);
+        roborockService.setSelectedAreas(duid, newAreas ?? []);
+    });
+    handler.setCommandHandler('pause', async () => {
+        logger.notice('BehaviorA51-Pause');
+        await roborockService.pauseClean(duid);
+    });
+    handler.setCommandHandler('resume', async () => {
+        logger.notice('BehaviorA51-Resume');
+        await roborockService.resumeClean(duid);
+    });
+    handler.setCommandHandler('goHome', async () => {
+        logger.notice('BehaviorA51-GoHome');
+        await roborockService.stopAndGoHome(duid);
+    });
+    handler.setCommandHandler('PlaySoundToLocate', async (identifyTime) => {
+        logger.notice('BehaviorA51-PlaySoundToLocate');
+        await roborockService.playSoundToLocate(duid);
+    });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlowA51[mopSetting?.waterFlowMode] ?? MopWaterFlowA51.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA51.Off,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[mopSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPowerA51[vacuumSetting?.fanMode] ?? VacuumSuctionPowerA51.Balanced,
+                    waterFlow: MopWaterFlowA51.Off,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[vacuumSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlowA51[vacmopSetting?.waterFlowMode] ?? MopWaterFlowA51.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA51[vacmopSetting?.fanMode] ?? VacuumSuctionPowerA51.Balanced,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[vacmopSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
+}

package/dist/behaviors/roborock.vacuum/S8_PRO_ULTRA/initalData.js

@@ -0,0 +1,76 @@
+import { RvcCleanMode, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+export function getDefaultSupportedRunModes() {
+    return [
+        {
+            label: 'Idle',
+            mode: 1,
+            modeTags: [{ value: RvcRunMode.ModeTag.Idle }],
+        },
+        {
+            label: 'Cleaning',
+            mode: 2,
+            modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }],
+        },
+        {
+            label: 'Mapping',
+            mode: 3,
+            modeTags: [{ value: RvcRunMode.ModeTag.Mapping }],
+        },
+    ];
+}
+export function getDefaultSupportedCleanModes() {
+    return [
+        {
+            label: 'Mop',
+            mode: 5,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: 'Vacuum',
+            mode: 6,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: 'Mop & Vacuum',
+            mode: 7,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.DeepClean }],
+        },
+        {
+            label: 'Custom',
+            mode: 8,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
+        },
+    ];
+}
+export function getDefaultOperationalStates() {
+    return [
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Stopped,
+            operationalStateLabel: 'Stopped',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Running,
+            operationalStateLabel: 'Running',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Paused,
+            operationalStateLabel: 'Paused',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Error,
+            operationalStateLabel: 'Error',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.SeekingCharger,
+            operationalStateLabel: 'SeekingCharger',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Charging,
+            operationalStateLabel: 'Charging',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Docked,
+            operationalStateLabel: 'Docked',
+        },
+    ];
+}

package/dist/behaviors/roborock.vacuum/S8_PRO_ULTRA/runtimes.js

@@ -0,0 +1,33 @@
+import { MopWaterFlowA51, VacuumSuctionPowerA51 } from './a51.js';
+export function getCurrentCleanModeA51(fan_power, water_box_mode) {
+    if (!fan_power || !water_box_mode)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA51.Custom || water_box_mode == MopWaterFlowA51.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA51.Off)
+        return 5;
+    if (water_box_mode == MopWaterFlowA51.Off)
+        return 6;
+    else
+        return 7;
+}
+export function getCurrentCleanModeFromFanPowerA51(fan_power) {
+    if (!fan_power)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA51.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA51.Off)
+        return 5;
+    else
+        return undefined;
+}
+export function getCurrentCleanModeFromWaterBoxModeA51(water_box_mode) {
+    if (!water_box_mode)
+        return undefined;
+    if (water_box_mode == MopWaterFlowA51.Custom)
+        return 8;
+    if (water_box_mode == MopWaterFlowA51.Off)
+        return 6;
+    else
+        return undefined;
+}

package/dist/behaviors/roborock.vacuum/default/default.js

@@ -1,3 +1,4 @@
+import { debugStringify } from 'matterbridge/logger';
 import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
 export class DefaultBehavior extends BehaviorRoborock {
 }
@@ -8,16 +9,50 @@ export var DefaultBehaviorRoborock;
     }
     DefaultBehaviorRoborock.State = State;
 })(DefaultBehaviorRoborock || (DefaultBehaviorRoborock = {}));
+export var VacuumSuctionPower;
+(function (VacuumSuctionPower) {
+    VacuumSuctionPower[VacuumSuctionPower["Quiet"] = 101] = "Quiet";
+    VacuumSuctionPower[VacuumSuctionPower["Balanced"] = 102] = "Balanced";
+    VacuumSuctionPower[VacuumSuctionPower["Turbo"] = 103] = "Turbo";
+    VacuumSuctionPower[VacuumSuctionPower["Max"] = 104] = "Max";
+    VacuumSuctionPower[VacuumSuctionPower["Off"] = 105] = "Off";
+    VacuumSuctionPower[VacuumSuctionPower["Custom"] = 106] = "Custom";
+    VacuumSuctionPower[VacuumSuctionPower["MaxPlus"] = 108] = "MaxPlus";
+})(VacuumSuctionPower || (VacuumSuctionPower = {}));
+export var MopWaterFlow;
+(function (MopWaterFlow) {
+    MopWaterFlow[MopWaterFlow["Off"] = 200] = "Off";
+    MopWaterFlow[MopWaterFlow["Low"] = 201] = "Low";
+    MopWaterFlow[MopWaterFlow["Medium"] = 202] = "Medium";
+    MopWaterFlow[MopWaterFlow["High"] = 203] = "High";
+    MopWaterFlow[MopWaterFlow["Custom"] = 204] = "Custom";
+})(MopWaterFlow || (MopWaterFlow = {}));
+export var MopRoute;
+(function (MopRoute) {
+    MopRoute[MopRoute["Standard"] = 300] = "Standard";
+    MopRoute[MopRoute["Deep"] = 301] = "Deep";
+    MopRoute[MopRoute["Custom"] = 302] = "Custom";
+    MopRoute[MopRoute["DeepPlus"] = 303] = "DeepPlus";
+    MopRoute[MopRoute["Fast"] = 304] = "Fast";
+})(MopRoute || (MopRoute = {}));
 const RvcRunMode = {
     [1]: 'Idle',
     [2]: 'Cleaning',
     [3]: 'Mapping',
 };
 const RvcCleanMode = {
-    [4]: 'Mop',
-    [5]: 'Vacuum',
+    [5]: 'Mop',
+    [6]: 'Vacuum',
+    [7]: 'Vac & Mop',
+    [8]: 'Custom',
 };
-export function setDefaultCommandHandler(duid, handler, logger, roborockService) {
+const CleanSetting = {
+    [5]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [6]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
+    [7]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [8]: { suctionPower: VacuumSuctionPower.Custom, waterFlow: MopWaterFlow.Custom, distance_off: 0, mopRoute: MopRoute.Custom },
+};
+export function setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
@@ -26,8 +61,19 @@ export function setDefaultCommandHandler(duid, handler, logger, roborockService)
                 return;
             }
             case 'Mop':
-            case 'Vacuum': {
-                logger.notice('DefaultBehavior-ChangeCleanMode to: ', activity);
+            case 'Vacuum':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
+            case 'Custom': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
                 return;
             }
             default:
@@ -55,4 +101,39 @@ export function setDefaultCommandHandler(duid, handler, logger, roborockService)
         logger.notice('DefaultBehavior-PlaySoundToLocate');
         await roborockService.playSoundToLocate(duid);
     });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlow[mopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
+                return {
+                    suctionPower: VacuumSuctionPower.Off,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRoute[mopSetting?.mopRouteMode] ?? MopRoute.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPower[vacuumSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
+                    waterFlow: MopWaterFlow.Off,
+                    distance_off: 0,
+                    mopRoute: MopRoute[vacuumSetting?.mopRouteMode] ?? MopRoute.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlow[vacmopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
+                return {
+                    suctionPower: VacuumSuctionPower[vacmopSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRoute[vacmopSetting?.mopRouteMode] ?? MopRoute.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
 }

package/dist/behaviors/roborock.vacuum/default/initalData.js

@@ -20,15 +20,25 @@ export function getDefaultSupportedRunModes() {
 }
 export function getDefaultSupportedCleanModes() {
     return [
+        {
+            label: 'Mop',
+            mode: 5,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
         {
             label: 'Vacuum',
-            mode: 4,
-            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }],
+            mode: 6,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
         },
         {
-            label: 'Mop',
-            mode: 5,
-            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }],
+            label: 'Mop & Vacuum',
+            mode: 7,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.DeepClean }],
+        },
+        {
+            label: 'Custom',
+            mode: 8,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
         },
     ];
 }

package/dist/behaviors/roborock.vacuum/default/runtimes.js

@@ -0,0 +1,33 @@
+import { MopWaterFlow, VacuumSuctionPower } from './default.js';
+export function getCurrentCleanModeDefault(fan_power, water_box_mode) {
+    if (!fan_power || !water_box_mode)
+        return undefined;
+    if (fan_power == VacuumSuctionPower.Custom || water_box_mode == MopWaterFlow.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPower.Off)
+        return 5;
+    if (water_box_mode == MopWaterFlow.Off)
+        return 6;
+    else
+        return 7;
+}
+export function getCurrentCleanModeFromFanPowerDefault(fan_power) {
+    if (!fan_power)
+        return undefined;
+    if (fan_power == VacuumSuctionPower.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPower.Off)
+        return 5;
+    else
+        return undefined;
+}
+export function getCurrentCleanModeFromWaterBoxModeDefault(water_box_mode) {
+    if (!water_box_mode)
+        return undefined;
+    if (water_box_mode == MopWaterFlow.Custom)
+        return 8;
+    if (water_box_mode == MopWaterFlow.Off)
+        return 6;
+    else
+        return undefined;
+}

package/dist/initialData/getSupportedScenes.js

@@ -0,0 +1,26 @@
+import { debugStringify } from 'matterbridge/logger';
+import { randomInt } from 'crypto';
+export function getSupportedScenes(scenes, log) {
+    log?.debug('getSupportedScenes', debugStringify(scenes));
+    if (!scenes || scenes.length === 0) {
+        log?.error('No scenes found');
+        return [];
+    }
+    const supportedAreas = scenes
+        .filter((s) => s.enabled && s.id)
+        .map((scene) => {
+        return {
+            areaId: scene.id + randomInt(5000, 9000),
+            mapId: null,
+            areaInfo: {
+                locationInfo: {
+                    locationName: `Scene: ${scene.name}`,
+                    floorNumber: null,
+                    areaType: null,
+                },
+                landmarkInfo: null,
+            },
+        };
+    });
+    return supportedAreas;
+}

package/dist/initialData/index.js

@@ -3,3 +3,4 @@ export { getOperationalStates, getOperationalErrorState } from './getOperational
 export { getSupportedCleanModes } from './getSupportedCleanModes.js';
 export { getSupportedAreas } from './getSupportedAreas.js';
 export { getBatteryStatus, getBatteryState } from './getBatteryStatus.js';
+export { getSupportedScenes } from './getSupportedScenes.js';