matterbridge-roborock-vacuum-plugin-regions 1.1.1-jb.1

package/README_REPORT_ISSUE.md

@@ -0,0 +1,34 @@
+### ⚙️ Matterbridge Setup
+
+<div align="center">
+  <img src="./screenshot/IMG_6.PNG" alt="Matterbridge Configuration Screenshot" style="border-radius: 8px; max-width: 100%; box-shadow: 0 4px 12px rgba(0,0,0,0.1);" />
+</div>
+
+> 🛠️ Follow the configuration shown above to set up Matterbridge correctly for your Roborock vacuum.
+
+---
+
+### 🔄 Steps to Reproduce
+
+1. Apply the configuration shown above.  
+2. Restart **Matterbridge**.  
+3. Reproduce the issue you're encountering.
+
+---
+
+### 🪵 Collect Logs
+
+After reproducing the issue, download the **MATTERBRIDGE LOG** file:
+
+<div align="center">
+  <img src="./screenshot/IMG_7.PNG" alt="Download Matterbridge Log Screenshot" style="border-radius: 8px; max-width: 100%; box-shadow: 0 4px 12px rgba(0,0,0,0.1);" />
+</div>
+
+---
+
+### 📬 Submit an Issue
+
+Please upload the log file and describe the problem at:  
+[https://github.com/RinDevJunior/matterbridge-roborock-vacuum-plugin/issues](https://github.com/RinDevJunior/matterbridge-roborock-vacuum-plugin/issues)
+
+Your logs help me troubleshoot and improve compatibility. Thank you! 🙏

package/README_SUPPORTED.md

@@ -0,0 +1,67 @@
+# 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.
+
+---
+
+## ⚠️ Not Supported Devices
+
+This plugin does NOT support these models:
+
+| Device Name                | Model String                  |
+|----------------------------|-------------------------------|
+| Roborock Q10 Series        | `roborock.vacuum.ss07`        |
+
+**Reason:**
+Roborock recently released a new series of models, Q10. Roborock has changed the protocol for how these devices interact.
+
+---
+
+## ⚠️ 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

@@ -0,0 +1,26 @@
+import { BehaviorDeviceGeneric } from './behaviors/BehaviorDeviceGeneric.js';
+import { setDefaultCommandHandler } from './behaviors/roborock.vacuum/default/default.js';
+import { DeviceModel } from './roborockCommunication/Zmodel/deviceModel.js';
+import { setCommandHandlerSmart } from './behaviors/roborock.vacuum/smart/smart.js';
+export function configurateBehavior(model, duid, roborockService, cleanModeSettings, forceRunAtDefault, logger) {
+    if (forceRunAtDefault) {
+        const deviceHandler = new BehaviorDeviceGeneric(logger);
+        setDefaultCommandHandler(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+        return deviceHandler;
+    }
+    switch (model) {
+        case DeviceModel.QREVO_EDGE_5V1: {
+            const deviceHandler = new BehaviorDeviceGeneric(logger);
+            setCommandHandlerSmart(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+            return deviceHandler;
+        }
+        case DeviceModel.S7_MAXV:
+        case DeviceModel.S8_PRO_ULTRA:
+        case DeviceModel.S6_PURE:
+        default: {
+            const deviceHandler = new BehaviorDeviceGeneric(logger);
+            setDefaultCommandHandler(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+            return deviceHandler;
+        }
+    }
+}

package/dist/behaviors/BehaviorDeviceGeneric.js

@@ -0,0 +1,22 @@
+import { Behavior } from 'matterbridge/matter';
+export class BehaviorDeviceGeneric {
+    log;
+    commands = {};
+    constructor(log) {
+        this.log = log;
+    }
+    setCommandHandler(command, handler) {
+        if (this.commands[command])
+            throw new Error(`Handler already registered for command ${String(command)}`);
+        this.commands[command] = handler;
+    }
+    async executeCommand(command, ...args) {
+        const handler = this.commands[command];
+        if (!handler)
+            throw new Error(`${String(command)} not implemented`);
+        await handler(...args);
+    }
+}
+export class BehaviorRoborock extends Behavior {
+    static id = 'roborock.vacuum.axx';
+}

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

@@ -0,0 +1,183 @@
+import { debugStringify } from 'matterbridge/logger';
+import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
+export class DefaultBehavior extends BehaviorRoborock {
+}
+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["CustomizeWithDistanceOff"] = 207] = "CustomizeWithDistanceOff";
+})(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 = {}));
+export const RvcRunMode = {
+    [1]: 'Idle',
+    [2]: 'Cleaning',
+    [3]: 'Mapping',
+};
+export const RvcCleanMode = {
+    [5]: 'Mop & Vacuum: Default',
+    [6]: 'Mop & Vacuum: Quick',
+    [7]: 'Mop & Vacuum: Max',
+    [8]: 'Mop & Vacuum: Min',
+    [9]: 'Mop & Vacuum: Quiet',
+    [10]: 'Mop & Vacuum: Custom',
+    [31]: 'Mop: Default',
+    [32]: 'Mop: Max',
+    [33]: 'Mop: Min',
+    [34]: 'Mop: Quick',
+    [35]: 'Mop: DeepClean',
+    [66]: 'Vacuum: Default',
+    [67]: 'Vacuum: Max',
+    [68]: 'Vacuum: Quiet',
+    [69]: 'Vacuum: Quick',
+    [99]: 'Go Vacation',
+};
+export const CleanSetting = {
+    [5]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [6]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Fast },
+    [7]: { suctionPower: VacuumSuctionPower.Max, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [8]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Low, distance_off: 0, mopRoute: MopRoute.Standard },
+    [9]: { suctionPower: VacuumSuctionPower.Quiet, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [10]: { suctionPower: VacuumSuctionPower.Custom, waterFlow: MopWaterFlow.Custom, distance_off: 0, mopRoute: MopRoute.Custom },
+    [31]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [32]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.High, distance_off: 0, mopRoute: MopRoute.Standard },
+    [33]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Low, distance_off: 0, mopRoute: MopRoute.Standard },
+    [34]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Fast },
+    [35]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Deep },
+    [66]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
+    [67]: { suctionPower: VacuumSuctionPower.Max, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
+    [68]: { suctionPower: VacuumSuctionPower.Quiet, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
+    [69]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Fast },
+};
+export function setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings) {
+    handler.setCommandHandler('changeToMode', async (newMode) => {
+        const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+        switch (activity) {
+            case 'Cleaning': {
+                logger.notice('DefaultBehavior-ChangeRunMode to: ', activity);
+                await roborockService.startClean(duid);
+                break;
+            }
+            case 'Go Vacation': {
+                logger.notice('DefaultBehavior-GoHome');
+                await roborockService.stopAndGoHome(duid);
+                break;
+            }
+            case 'Mop & Vacuum: Custom': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
+                break;
+            }
+            case 'Mop & Vacuum: Default':
+            case 'Mop: Default':
+            case 'Vacuum: Default': {
+                const setting = cleanModeSettings ? (getSettingFromCleanMode(activity, cleanModeSettings) ?? CleanSetting[newMode]) : CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                break;
+            }
+            case 'Mop & Vacuum: Quick':
+            case 'Mop & Vacuum: Max':
+            case 'Mop & Vacuum: Min':
+            case 'Mop & Vacuum: Quiet':
+            case 'Mop: Max':
+            case 'Mop: Min':
+            case 'Mop: Quick':
+            case 'Mop: DeepClean':
+            case 'Vacuum: Max':
+            case 'Vacuum: Min':
+            case 'Vacuum: Quiet':
+            case 'Vacuum: Quick': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                break;
+            }
+            default:
+                logger.notice('DefaultBehavior-changeToMode-Unknown: ', newMode);
+                break;
+        }
+    });
+    handler.setCommandHandler('selectAreas', async (newAreas) => {
+        logger.notice(`DefaultBehavior-selectAreas: ${newAreas}`);
+        roborockService.setSelectedAreas(duid, newAreas ?? []);
+    });
+    handler.setCommandHandler('pause', async () => {
+        logger.notice('DefaultBehavior-Pause');
+        await roborockService.pauseClean(duid);
+    });
+    handler.setCommandHandler('resume', async () => {
+        logger.notice('DefaultBehavior-Resume');
+        await roborockService.resumeClean(duid);
+    });
+    handler.setCommandHandler('goHome', async () => {
+        logger.notice('DefaultBehavior-GoHome');
+        await roborockService.stopAndGoHome(duid);
+    });
+    handler.setCommandHandler('playSoundToLocate', async () => {
+        logger.notice('DefaultBehavior-playSoundToLocate');
+        await roborockService.playSoundToLocate(duid);
+    });
+}
+export const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+    switch (activity) {
+        case 'Mop: Default': {
+            const mopSetting = cleanModeSettings?.mopping;
+            const waterFlow = MopWaterFlow[mopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
+            const distance_off = waterFlow == MopWaterFlow.CustomizeWithDistanceOff ? 210 - 5 * (mopSetting?.distanceOff ?? 25) : 0;
+            return {
+                suctionPower: VacuumSuctionPower.Off,
+                waterFlow,
+                distance_off,
+                mopRoute: MopRoute[mopSetting?.mopRouteMode] ?? MopRoute.Standard,
+            };
+        }
+        case 'Vacuum: Default': {
+            const vacuumSetting = cleanModeSettings?.vacuuming;
+            return {
+                suctionPower: VacuumSuctionPower[vacuumSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
+                waterFlow: MopWaterFlow.Off,
+                distance_off: 0,
+                mopRoute: MopRoute[vacuumSetting?.mopRouteMode] ?? MopRoute.Standard,
+            };
+        }
+        case 'Mop & Vacuum: Default': {
+            const vacmopSetting = cleanModeSettings?.vacmop;
+            const waterFlow = MopWaterFlow[vacmopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
+            const distance_off = waterFlow == MopWaterFlow.CustomizeWithDistanceOff ? 210 - 5 * (vacmopSetting?.distanceOff ?? 25) : 0;
+            return {
+                suctionPower: VacuumSuctionPower[vacmopSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
+                waterFlow,
+                distance_off,
+                mopRoute: MopRoute[vacmopSetting?.mopRouteMode] ?? MopRoute.Standard,
+            };
+        }
+        default:
+            return undefined;
+    }
+};

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

@@ -0,0 +1,143 @@
+import { RvcCleanMode, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+import { RvcCleanMode as RvcCleanModeDisplayMap } from './default.js';
+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(enableExperimentalFeature) {
+    const result = [
+        {
+            label: RvcCleanModeDisplayMap[5],
+            mode: 5,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[6],
+            mode: 6,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[7],
+            mode: 7,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Max }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[8],
+            mode: 8,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Min }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[9],
+            mode: 9,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quiet }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[10],
+            mode: 10,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.LowEnergy }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[31],
+            mode: 31,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[32],
+            mode: 32,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Max }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[33],
+            mode: 33,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Min }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[34],
+            mode: 34,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Quick }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[35],
+            mode: 35,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.DeepClean }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[66],
+            mode: 66,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[67],
+            mode: 67,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Max }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[68],
+            mode: 68,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quiet }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[69],
+            mode: 69,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
+        },
+    ];
+    if (enableExperimentalFeature?.advancedFeature?.useVacationModeToSendVacuumToDock ?? false) {
+        return [
+            ...result,
+            {
+                label: RvcCleanModeDisplayMap[99],
+                mode: 99,
+                modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Vacation }],
+            },
+        ];
+    }
+    return result;
+}
+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/default/runtimes.js

@@ -0,0 +1,21 @@
+import { CleanSetting, MopRoute, MopWaterFlow, VacuumSuctionPower } from './default.js';
+export function getCurrentCleanModeDefault(setting) {
+    if (!setting || typeof setting !== 'object') {
+        return undefined;
+    }
+    if (setting.suctionPower === VacuumSuctionPower.Custom || setting.waterFlow === MopWaterFlow.Custom || setting.mopRoute === MopRoute.Custom) {
+        return 10;
+    }
+    for (const [key, value] of Object.entries(CleanSetting)) {
+        if (value.suctionPower === setting.suctionPower && value.waterFlow === setting.waterFlow && value.mopRoute === setting.mopRoute) {
+            return Number(key);
+        }
+    }
+    if (setting.suctionPower == VacuumSuctionPower.Off)
+        return 31;
+    if (setting.waterFlow == MopWaterFlow.Off)
+        return 66;
+    if ((setting.suctionPower !== VacuumSuctionPower.Off && setting.waterFlow) !== MopWaterFlow.Off)
+        return 5;
+    return undefined;
+}

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

@@ -0,0 +1,18 @@
+import { RvcCleanMode } from 'matterbridge/matter/clusters';
+import { RvcCleanMode as RvcCleanModeDisplayMap } from './smart.js';
+import { getDefaultSupportedCleanModes } from '../default/initalData.js';
+export function getSupportedCleanModesSmart(enableExperimentalFeature) {
+    return [
+        {
+            label: RvcCleanModeDisplayMap[4],
+            mode: 4,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: RvcCleanModeDisplayMap[5],
+            mode: 5,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Day }],
+        },
+        ...getDefaultSupportedCleanModes(enableExperimentalFeature).filter((x) => x.mode !== 4 && x.mode !== 5),
+    ];
+}

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

@@ -0,0 +1,11 @@
+import { getCurrentCleanModeDefault } from '../default/runtimes.js';
+import { MopRouteSmart, MopWaterFlowSmart, VacuumSuctionPowerSmart } from './smart.js';
+export function getCurrentCleanModeSmart(setting) {
+    if (!setting || typeof setting !== 'object') {
+        return undefined;
+    }
+    if (setting.suctionPower === VacuumSuctionPowerSmart.Smart || setting.waterFlow === MopWaterFlowSmart.Smart || setting.mopRoute === MopRouteSmart.Smart) {
+        return 4;
+    }
+    return getCurrentCleanModeDefault(setting);
+}

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

@@ -0,0 +1,119 @@
+import { debugStringify } from 'matterbridge/logger';
+import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
+import { RvcCleanMode as DefaultRvcCleanMode, CleanSetting as DefaultCleanSetting, getSettingFromCleanMode, RvcRunMode } from '../default/default.js';
+export class BehaviorSmart extends BehaviorRoborock {
+}
+export var VacuumSuctionPowerSmart;
+(function (VacuumSuctionPowerSmart) {
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Quiet"] = 101] = "Quiet";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Balanced"] = 102] = "Balanced";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Turbo"] = 103] = "Turbo";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Max"] = 104] = "Max";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Off"] = 105] = "Off";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Custom"] = 106] = "Custom";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["MaxPlus"] = 108] = "MaxPlus";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Smart"] = 110] = "Smart";
+})(VacuumSuctionPowerSmart || (VacuumSuctionPowerSmart = {}));
+export var MopWaterFlowSmart;
+(function (MopWaterFlowSmart) {
+    MopWaterFlowSmart[MopWaterFlowSmart["Off"] = 200] = "Off";
+    MopWaterFlowSmart[MopWaterFlowSmart["Low"] = 201] = "Low";
+    MopWaterFlowSmart[MopWaterFlowSmart["Medium"] = 202] = "Medium";
+    MopWaterFlowSmart[MopWaterFlowSmart["High"] = 203] = "High";
+    MopWaterFlowSmart[MopWaterFlowSmart["Custom"] = 204] = "Custom";
+    MopWaterFlowSmart[MopWaterFlowSmart["CustomizeWithDistanceOff"] = 207] = "CustomizeWithDistanceOff";
+    MopWaterFlowSmart[MopWaterFlowSmart["Smart"] = 209] = "Smart";
+})(MopWaterFlowSmart || (MopWaterFlowSmart = {}));
+export var MopRouteSmart;
+(function (MopRouteSmart) {
+    MopRouteSmart[MopRouteSmart["Standard"] = 300] = "Standard";
+    MopRouteSmart[MopRouteSmart["Deep"] = 301] = "Deep";
+    MopRouteSmart[MopRouteSmart["Custom"] = 302] = "Custom";
+    MopRouteSmart[MopRouteSmart["DeepPlus"] = 303] = "DeepPlus";
+    MopRouteSmart[MopRouteSmart["Fast"] = 304] = "Fast";
+    MopRouteSmart[MopRouteSmart["Smart"] = 306] = "Smart";
+})(MopRouteSmart || (MopRouteSmart = {}));
+export const RvcCleanMode = {
+    [4]: 'Smart Plan',
+    ...DefaultRvcCleanMode,
+};
+export const CleanSetting = {
+    [4]: { suctionPower: 0, waterFlow: 0, distance_off: 0, mopRoute: MopRouteSmart.Smart },
+    ...DefaultCleanSetting,
+};
+export function setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings) {
+    handler.setCommandHandler('changeToMode', async (newMode) => {
+        const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+        switch (activity) {
+            case 'Cleaning': {
+                logger.notice('BehaviorSmart-ChangeRunMode to: ', activity);
+                await roborockService.startClean(duid);
+                break;
+            }
+            case 'Go Vacation': {
+                logger.notice('BehaviorSmart-GoHome');
+                await roborockService.stopAndGoHome(duid);
+                break;
+            }
+            case 'Smart Plan':
+            case 'Mop & Vacuum: Custom': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`BehaviorSmart-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
+                break;
+            }
+            case 'Mop & Vacuum: Default':
+            case 'Mop: Default':
+            case 'Vacuum: Default': {
+                const setting = cleanModeSettings ? (getSettingFromCleanMode(activity, cleanModeSettings) ?? CleanSetting[newMode]) : CleanSetting[newMode];
+                logger.notice(`BehaviorSmart-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                break;
+            }
+            case 'Mop & Vacuum: Quick':
+            case 'Mop & Vacuum: Max':
+            case 'Mop & Vacuum: Min':
+            case 'Mop & Vacuum: Quiet':
+            case 'Mop: Max':
+            case 'Mop: Min':
+            case 'Mop: Quick':
+            case 'Mop: DeepClean':
+            case 'Vacuum: Max':
+            case 'Vacuum: Min':
+            case 'Vacuum: Quiet':
+            case 'Vacuum: Quick': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`BehaviorSmart-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                break;
+            }
+            default:
+                logger.notice('BehaviorSmart-changeToMode-Unknown: ', newMode);
+                break;
+        }
+    });
+    handler.setCommandHandler('selectAreas', async (newAreas) => {
+        logger.notice(`BehaviorSmart-selectAreas: ${newAreas}`);
+        roborockService.setSelectedAreas(duid, newAreas ?? []);
+    });
+    handler.setCommandHandler('pause', async () => {
+        logger.notice('BehaviorSmart-Pause');
+        await roborockService.pauseClean(duid);
+    });
+    handler.setCommandHandler('resume', async () => {
+        logger.notice('BehaviorSmart-Resume');
+        await roborockService.resumeClean(duid);
+    });
+    handler.setCommandHandler('goHome', async () => {
+        logger.notice('BehaviorSmart-GoHome');
+        await roborockService.stopAndGoHome(duid);
+    });
+    handler.setCommandHandler('playSoundToLocate', async () => {
+        logger.notice('BehaviorSmart-playSoundToLocate');
+        await roborockService.playSoundToLocate(duid);
+    });
+}

package/dist/clientManager.js

@@ -0,0 +1,17 @@
+import { ClientRouter } from './roborockCommunication/broadcast/clientRouter.js';
+export default class ClientManager {
+    clients = new Map();
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    get(username, userdata) {
+        if (!this.clients.has(username)) {
+            this.clients.set(username, new ClientRouter(this.logger, userdata));
+        }
+        return this.clients.get(username);
+    }
+    destroy(username) {
+        this.clients.delete(username);
+    }
+}