matterbridge-valetudo 1.0.2

package/dist/module.js

@@ -0,0 +1,933 @@
+import { MatterbridgeDynamicPlatform, MatterbridgeEndpoint, contactSensor } from 'matterbridge';
+import { RoboticVacuumCleaner } from 'matterbridge/devices';
+import { RvcCleanMode, RvcRunMode } from 'matterbridge/matter/clusters';
+import { ValetudoClient } from './valetudo-client.js';
+import { ValetudoDiscovery } from './valetudo-discovery.js';
+var RvcRunModeValue;
+(function (RvcRunModeValue) {
+    RvcRunModeValue[RvcRunModeValue["Idle"] = 1] = "Idle";
+    RvcRunModeValue[RvcRunModeValue["Cleaning"] = 2] = "Cleaning";
+    RvcRunModeValue[RvcRunModeValue["Mapping"] = 3] = "Mapping";
+})(RvcRunModeValue || (RvcRunModeValue = {}));
+var RvcCleanModeValue;
+(function (RvcCleanModeValue) {
+    RvcCleanModeValue[RvcCleanModeValue["VacuumMopQuiet"] = 5] = "VacuumMopQuiet";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumMopAuto"] = 6] = "VacuumMopAuto";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumMopQuick"] = 7] = "VacuumMopQuick";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumMopMax"] = 8] = "VacuumMopMax";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumMopTurbo"] = 9] = "VacuumMopTurbo";
+    RvcCleanModeValue[RvcCleanModeValue["MopMin"] = 31] = "MopMin";
+    RvcCleanModeValue[RvcCleanModeValue["MopLow"] = 32] = "MopLow";
+    RvcCleanModeValue[RvcCleanModeValue["MopMedium"] = 33] = "MopMedium";
+    RvcCleanModeValue[RvcCleanModeValue["MopHigh"] = 34] = "MopHigh";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumQuiet"] = 66] = "VacuumQuiet";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumAuto"] = 67] = "VacuumAuto";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumQuick"] = 68] = "VacuumQuick";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumMax"] = 69] = "VacuumMax";
+    RvcCleanModeValue[RvcCleanModeValue["VacuumTurbo"] = 70] = "VacuumTurbo";
+})(RvcCleanModeValue || (RvcCleanModeValue = {}));
+var OperationalStateValue;
+(function (OperationalStateValue) {
+    OperationalStateValue[OperationalStateValue["Stopped"] = 0] = "Stopped";
+    OperationalStateValue[OperationalStateValue["Running"] = 1] = "Running";
+    OperationalStateValue[OperationalStateValue["Paused"] = 2] = "Paused";
+    OperationalStateValue[OperationalStateValue["Error"] = 3] = "Error";
+    OperationalStateValue[OperationalStateValue["SeekingCharger"] = 64] = "SeekingCharger";
+    OperationalStateValue[OperationalStateValue["Charging"] = 65] = "Charging";
+    OperationalStateValue[OperationalStateValue["Docked"] = 66] = "Docked";
+})(OperationalStateValue || (OperationalStateValue = {}));
+export default function initializePlugin(matterbridge, log, config) {
+    return new ValetudoPlatform(matterbridge, log, config);
+}
+export class ValetudoPlatform extends MatterbridgeDynamicPlatform {
+    vacuums = new Map();
+    mdns = null;
+    discoveryInterval = null;
+    constructor(matterbridge, log, config) {
+        super(matterbridge, log, config);
+        if (!this.verifyMatterbridgeVersion?.('3.4.0')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.4.0". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
+        }
+        this.log.info('Initializing platform for multi-vacuum support...');
+    }
+    async onStart(reason) {
+        this.log.info(`onStart called with reason: ${reason ?? 'none'}`);
+        await this.ready;
+        await this.clearSelect();
+        await this.discoverDevices();
+    }
+    async onConfigure() {
+        await super.onConfigure();
+        this.log.info('onConfigure called');
+    }
+    async onChangeLoggerLevel(logLevel) {
+        this.log.info(`onChangeLoggerLevel called with: ${logLevel}`);
+    }
+    async onShutdown(reason) {
+        await super.onShutdown(reason);
+        this.log.info(`onShutdown called with reason: ${reason ?? 'none'}`);
+        if (this.discoveryInterval) {
+            clearInterval(this.discoveryInterval);
+            this.discoveryInterval = null;
+        }
+        if (this.mdns) {
+            this.mdns.destroy();
+            this.mdns = null;
+        }
+        for (const vacuum of this.vacuums.values()) {
+            if (vacuum.pollingInterval) {
+                clearInterval(vacuum.pollingInterval);
+                vacuum.pollingInterval = null;
+            }
+        }
+        this.vacuums.clear();
+        if (this.config.unregisterOnShutdown === true)
+            await this.unregisterAllDevices();
+    }
+    async loadManualVacuums() {
+        const config = this.config;
+        const manualVacuums = config.vacuums || [];
+        this.log.info(`Loading ${manualVacuums.length} manually configured vacuums...`);
+        for (const vacuumConfig of manualVacuums) {
+            if (vacuumConfig.enabled === false) {
+                this.log.info(`Skipping disabled vacuum at ${vacuumConfig.ip}`);
+                continue;
+            }
+            try {
+                await this.addVacuum(vacuumConfig.ip, vacuumConfig.name, 'manual');
+            }
+            catch (error) {
+                this.log.error(`Failed to add manual vacuum at ${vacuumConfig.ip}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async discoverAndAddVacuums() {
+        const config = this.config;
+        const discoveryEnabled = config.discovery?.enabled !== false;
+        if (!discoveryEnabled) {
+            this.log.info('mDNS discovery is disabled');
+            return;
+        }
+        this.log.info('Starting mDNS discovery for Valetudo vacuums...');
+        try {
+            this.mdns = new ValetudoDiscovery(this.log);
+            const timeout = config.discovery?.timeout || 5000;
+            const discovered = await this.mdns.discover(timeout);
+            this.log.info(`mDNS discovery found ${discovered.length} vacuum(s)`);
+            for (const vacuum of discovered) {
+                try {
+                    const existing = Array.from(this.vacuums.values()).find((v) => v.ip === vacuum.ip);
+                    if (existing) {
+                        this.log.info(`Vacuum at ${vacuum.ip} already added manually, skipping mDNS entry`);
+                        continue;
+                    }
+                    await this.addVacuum(vacuum.ip, undefined, 'mdns');
+                }
+                catch (error) {
+                    this.log.error(`Failed to add discovered vacuum at ${vacuum.ip}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        catch (error) {
+            this.log.error(`mDNS discovery failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (this.mdns) {
+                this.mdns.destroy();
+                this.mdns = null;
+            }
+        }
+    }
+    async addVacuum(ip, customName, source) {
+        this.log.info(`Adding vacuum from ${source}: ${ip}${customName ? ` (${customName})` : ''}`);
+        const client = new ValetudoClient(ip, this.log);
+        const isConnected = await client.testConnection();
+        if (!isConnected) {
+            throw new Error(`Failed to connect to Valetudo at ${ip}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        const info = await client.getInfo();
+        if (!info) {
+            throw new Error(`Failed to fetch Valetudo info from ${ip}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        const existing = this.vacuums.get(info.systemId);
+        if (existing) {
+            if (existing.ip !== ip) {
+                this.log.warn(`Vacuum ${info.systemId} already exists at ${existing.ip}, now found at ${ip}. Updating IP address.`);
+                existing.ip = ip;
+                existing.client = client;
+                existing.lastSeen = Date.now();
+                return;
+            }
+            else {
+                this.log.warn(`Vacuum ${info.systemId} at ${ip} already added, skipping`);
+                return;
+            }
+        }
+        const robotInfo = await client.getRobotInfo();
+        if (!robotInfo) {
+            throw new Error(`Failed to fetch robot info from ${ip}`);
+        }
+        let deviceName;
+        if (customName) {
+            deviceName = customName;
+        }
+        else {
+            deviceName = `${robotInfo.manufacturer} ${robotInfo.modelName}`;
+        }
+        const vacuum = {
+            id: info.systemId,
+            ip,
+            name: deviceName,
+            client,
+            device: null,
+            pollingInterval: null,
+            capabilities: [],
+            operationModes: [],
+            areaToSegmentMap: new Map(),
+            selectedSegmentIds: [],
+            selectedRoomNames: [],
+            consumableMap: new Map(),
+            mapLayersCache: null,
+            mapCacheValidUntil: 0,
+            lastCurrentArea: null,
+            lastConsumablesCheck: 0,
+            lastBatteryLevel: null,
+            lastBatteryChargeState: null,
+            lastOperationalState: null,
+            lastRunMode: null,
+            initialStatePending: true,
+            source,
+            lastSeen: Date.now(),
+            online: true,
+        };
+        this.vacuums.set(info.systemId, vacuum);
+        this.log.info(`Added vacuum: ${deviceName} (ID: ${info.systemId}, IP: ${ip})`);
+        await this.initializeVacuum(vacuum);
+    }
+    async initializeVacuum(vacuum) {
+        this.log.info(`Initializing vacuum: ${vacuum.name}`);
+        try {
+            const capabilities = await vacuum.client.getCapabilities();
+            if (capabilities) {
+                vacuum.capabilities = capabilities;
+                this.log.info(`  Capabilities: ${capabilities.join(', ')}`);
+            }
+            await this.createDeviceForVacuum(vacuum);
+            this.startPollingForVacuum(vacuum);
+            this.log.info(`Successfully initialized vacuum: ${vacuum.name}`);
+        }
+        catch (error) {
+            this.log.error(`Failed to initialize vacuum ${vacuum.name}: ${error instanceof Error ? error.message : String(error)}`);
+            vacuum.online = false;
+        }
+    }
+    async createDeviceForVacuum(vacuum) {
+        this.log.info(`Creating Matter device for vacuum: ${vacuum.name}`);
+        try {
+            const robotInfo = await vacuum.client.getRobotInfo();
+            if (!robotInfo) {
+                throw new Error('Failed to fetch robot information');
+            }
+            let supportedAreas;
+            if (vacuum.capabilities.includes('MapSegmentationCapability')) {
+                const segments = await vacuum.client.getMapSegments();
+                if (segments && segments.length > 0) {
+                    const usedNames = new Map();
+                    const validSegments = segments.filter((segment) => segment.name && segment.name.trim().length > 0);
+                    supportedAreas = validSegments.map((segment, index) => {
+                        let locationName = segment.name.trim() || `Room ${index + 1}`;
+                        if (usedNames.has(locationName)) {
+                            const count = (usedNames.get(locationName) ?? 0) + 1;
+                            usedNames.set(locationName, count);
+                            locationName = `${locationName} ${count}`;
+                        }
+                        else {
+                            usedNames.set(locationName, 1);
+                        }
+                        const areaId = index + 1;
+                        vacuum.areaToSegmentMap.set(areaId, { id: segment.id, name: locationName });
+                        return {
+                            areaId,
+                            mapId: null,
+                            areaInfo: {
+                                locationInfo: {
+                                    locationName,
+                                    floorNumber: 0,
+                                    areaType: null,
+                                },
+                                landmarkInfo: null,
+                            },
+                        };
+                    });
+                    if (supportedAreas && supportedAreas.length > 0) {
+                        this.log.info(`  Found ${supportedAreas.length} areas: ${supportedAreas.map((a) => a.areaInfo.locationInfo?.locationName || 'Unknown').join(', ')}`);
+                    }
+                }
+            }
+            const supportedRunModes = [
+                { label: 'Idle', mode: 1, modeTags: [{ value: RvcRunMode.ModeTag.Idle }] },
+                { label: 'Cleaning', mode: 2, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }] },
+            ];
+            if (vacuum.capabilities.includes('MappingPassCapability')) {
+                supportedRunModes.push({
+                    label: 'Mapping',
+                    mode: 3,
+                    modeTags: [{ value: RvcRunMode.ModeTag.Mapping }],
+                });
+            }
+            const supportedCleanModes = [];
+            let fanSpeedPresets = null;
+            let waterUsagePresets = null;
+            if (vacuum.capabilities.includes('FanSpeedControlCapability')) {
+                fanSpeedPresets = await vacuum.client.getFanSpeedPresets();
+            }
+            if (vacuum.capabilities.includes('WaterUsageControlCapability')) {
+                waterUsagePresets = await vacuum.client.getWaterUsagePresets();
+            }
+            if (vacuum.capabilities.includes('OperationModeControlCapability')) {
+                const operationModes = await vacuum.client.getOperationModePresets();
+                if (operationModes && operationModes.length > 0) {
+                    vacuum.operationModes = operationModes;
+                    if (operationModes.includes('vacuum') || operationModes.includes('vaccum')) {
+                        supportedCleanModes.push(...this.createIntensityVariants('vacuum', 66, [RvcCleanMode.ModeTag.Vacuum], fanSpeedPresets));
+                    }
+                    if (operationModes.includes('mop')) {
+                        supportedCleanModes.push(...this.createMopVariants(fanSpeedPresets, waterUsagePresets));
+                    }
+                    if (operationModes.includes('vacuum_and_mop')) {
+                        supportedCleanModes.push(...this.createIntensityVariants('vacuum_and_mop', 5, [RvcCleanMode.ModeTag.Mop, RvcCleanMode.ModeTag.Vacuum], fanSpeedPresets));
+                    }
+                }
+            }
+            if (supportedCleanModes.length === 0) {
+                supportedCleanModes.push({
+                    label: 'Vacuum',
+                    mode: 66,
+                    modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+                });
+            }
+            const useServerMode = this.config.enableServerMode === true;
+            vacuum.device = new RoboticVacuumCleaner(vacuum.name, vacuum.id, useServerMode ? 'server' : undefined, 1, supportedRunModes, supportedCleanModes.length > 0 ? supportedCleanModes[0].mode : 1, supportedCleanModes, null, null, undefined, undefined, supportedAreas, [], undefined, undefined);
+            this.setupCommandHandlersForVacuum(vacuum);
+            vacuum.device.softwareVersion = 1;
+            vacuum.device.softwareVersionString = this.version || '1.0.0';
+            vacuum.device.hardwareVersion = 1;
+            vacuum.device.hardwareVersionString = this.matterbridge.matterbridgeVersion;
+            if (!vacuum.device.mode) {
+                vacuum.device.createDefaultBridgedDeviceBasicInformationClusterServer(vacuum.device.deviceName || vacuum.name, vacuum.device.serialNumber || vacuum.id, this.matterbridge.aggregatorVendorId, vacuum.device.vendorName || 'Valetudo', vacuum.device.productName || 'Robot Vacuum', vacuum.device.softwareVersion, vacuum.device.softwareVersionString, vacuum.device.hardwareVersion, vacuum.device.hardwareVersionString);
+            }
+            await this.registerDevice(vacuum.device);
+            this.log.info(`  Matter device created and registered successfully`);
+            await this.setInitialVacuumState(vacuum);
+            await this.setupConsumablesForVacuum(vacuum);
+        }
+        catch (error) {
+            throw new Error(`Failed to create device: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    startPollingForVacuum(vacuum) {
+        const config = this.config;
+        const baseInterval = Math.max(5000, Math.min(60000, config.pollingInterval || 30000));
+        const MIN_INITIAL_DELAY = 10000;
+        const vacuumIndex = Array.from(this.vacuums.keys()).indexOf(vacuum.id);
+        const staggerOffset = vacuumIndex * 1000;
+        const totalDelay = MIN_INITIAL_DELAY + staggerOffset;
+        setTimeout(async () => {
+            try {
+                this.log.info(`[${vacuum.name}] Running initial state update...`);
+                await this.updateVacuumState(vacuum);
+            }
+            catch (error) {
+                this.log.error(`[${vacuum.name}] Error in initial poll: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            vacuum.pollingInterval = setInterval(async () => {
+                try {
+                    await this.updateVacuumState(vacuum);
+                }
+                catch (error) {
+                    this.log.error(`Error polling vacuum ${vacuum.name}: ${error instanceof Error ? error.message : String(error)}`);
+                    vacuum.online = false;
+                }
+            }, baseInterval);
+            this.log.info(`Started polling for ${vacuum.name} (${baseInterval}ms interval, ${totalDelay}ms initial delay)`);
+        }, totalDelay);
+    }
+    setupCommandHandlersForVacuum(vacuum) {
+        if (!vacuum.device)
+            return;
+        this.log.info(`Setting up command handlers for vacuum: ${vacuum.name}`);
+        vacuum.device.addCommandHandler('identify', async () => {
+            this.log.info(`[${vacuum.name}] Identify/Locate handler called`);
+            const success = await vacuum.client.locate();
+            if (success) {
+                this.log.info(`[${vacuum.name}] Successfully triggered locate sound`);
+            }
+            else {
+                this.log.error(`[${vacuum.name}] Failed to trigger locate sound`);
+            }
+        });
+        vacuum.device.addCommandHandler('changeToMode', async (data) => {
+            this.log.info(`[${vacuum.name}] changeToMode called: ${JSON.stringify(data)}`);
+            const request = data.request;
+            const isRunMode = request.newMode >= 1 && request.newMode <= 3;
+            if (isRunMode) {
+                if (request.newMode === 2) {
+                    if (vacuum.selectedSegmentIds.length > 0) {
+                        this.log.info(`[${vacuum.name}] Starting room cleaning: ${vacuum.selectedRoomNames.join(', ')}`);
+                        const properties = await vacuum.client.getMapSegmentationProperties();
+                        await vacuum.client.cleanSegments(vacuum.selectedSegmentIds, 1, properties?.customOrderSupported ?? false);
+                    }
+                    else {
+                        this.log.info(`[${vacuum.name}] Starting full home cleaning`);
+                        await vacuum.client.startCleaning();
+                    }
+                }
+                else if (request.newMode === 1) {
+                    this.log.info(`[${vacuum.name}] Stopping cleaning`);
+                    await vacuum.client.stopCleaning();
+                    vacuum.selectedSegmentIds = [];
+                    vacuum.selectedRoomNames = [];
+                }
+            }
+            else {
+                const settings = this.getIntensitySettings(request.newMode);
+                const mode = this.getBaseModeFromNumber(request.newMode);
+                if (mode) {
+                    this.log.info(`[${vacuum.name}] Setting mode '${mode}' with fan '${settings.fan}', water '${settings.water}'`);
+                    await vacuum.client.setOperationMode(mode);
+                    if (settings.fan && vacuum.capabilities.includes('FanSpeedControlCapability')) {
+                        await vacuum.client.setFanSpeed(settings.fan);
+                    }
+                    if (settings.water && vacuum.capabilities.includes('WaterUsageControlCapability')) {
+                        await vacuum.client.setWaterUsage(settings.water);
+                    }
+                }
+            }
+        });
+        vacuum.device.addCommandHandler('pause', async () => {
+            this.log.info(`[${vacuum.name}] Pause called`);
+            await vacuum.client.pauseCleaning();
+        });
+        vacuum.device.addCommandHandler('resume', async () => {
+            this.log.info(`[${vacuum.name}] Resume called`);
+            await vacuum.client.startCleaning();
+        });
+        vacuum.device.addCommandHandler('goHome', async () => {
+            this.log.info(`[${vacuum.name}] GoHome called`);
+            await vacuum.client.returnHome();
+        });
+        vacuum.device.addCommandHandler('selectAreas', async (data) => {
+            this.log.info(`[${vacuum.name}] selectAreas called: ${JSON.stringify(data)}`);
+            const request = data.request;
+            if (!request.newAreas || request.newAreas.length === 0) {
+                vacuum.selectedSegmentIds = [];
+                vacuum.selectedRoomNames = [];
+                return;
+            }
+            const segmentIds = [];
+            const roomNames = [];
+            for (const areaId of request.newAreas) {
+                const segmentInfo = vacuum.areaToSegmentMap.get(areaId);
+                if (segmentInfo) {
+                    segmentIds.push(segmentInfo.id);
+                    roomNames.push(segmentInfo.name);
+                }
+            }
+            vacuum.selectedSegmentIds = segmentIds;
+            vacuum.selectedRoomNames = roomNames;
+            this.log.info(`[${vacuum.name}] Selected rooms: ${roomNames.join(', ')}`);
+        });
+    }
+    getBaseModeFromNumber(mode) {
+        if (mode >= 66 && mode <= 70)
+            return 'vacuum';
+        if (mode >= 31 && mode <= 42)
+            return 'mop';
+        if (mode >= 5 && mode <= 9)
+            return 'vacuum_and_mop';
+        return '';
+    }
+    async setupConsumablesForVacuum(vacuum) {
+        const config = this.config;
+        if (!config.consumables?.enabled) {
+            this.log.debug(`[${vacuum.name}] Consumable tracking disabled`);
+            return;
+        }
+        if (!vacuum.capabilities.includes('ConsumableMonitoringCapability')) {
+            this.log.warn(`[${vacuum.name}] ConsumableMonitoringCapability not supported`);
+            return;
+        }
+        const consumables = await vacuum.client.getConsumables();
+        if (!consumables || consumables.length === 0) {
+            this.log.info(`[${vacuum.name}] No consumables found`);
+            return;
+        }
+        this.log.info(`[${vacuum.name}] Found ${consumables.length} consumables`);
+        const maxLifetimes = config.consumables?.maxLifetimes || {
+            mainBrush: 18000,
+            sideBrush: 12000,
+            dustFilter: 9000,
+            sensor: 1800,
+        };
+        const exposeAsContactSensors = config.consumables?.exposeAsContactSensors === true;
+        const warningThreshold = config.consumables?.warningThreshold ?? 10;
+        for (const consumable of consumables) {
+            const name = this.getConsumableName(consumable);
+            const maxLifetime = this.getMaxLifetime(consumable, maxLifetimes);
+            const remainingMinutes = consumable.remaining.value;
+            const lifePercent = Math.round((remainingMinutes / maxLifetime) * 100);
+            const needsReplacement = lifePercent <= warningThreshold;
+            this.log.info(`  ${name}: ${remainingMinutes}min (${lifePercent}%)`);
+            if (exposeAsContactSensors) {
+                const sensorName = `${vacuum.name} ${name}`;
+                const sensorId = `${vacuum.id}-consumable-${consumable.type}-${consumable.subType}`.replace(/[^a-zA-Z0-9-]/g, '_');
+                this.log.info(`  Creating contact sensor: ${sensorName} (ID: ${sensorId})`);
+                const sensor = new MatterbridgeEndpoint(contactSensor, { id: sensorId }, this.config.debug);
+                sensor.createDefaultBridgedDeviceBasicInformationClusterServer(sensorName, sensorId, this.matterbridge.aggregatorVendorId, 'Valetudo', name);
+                sensor.createDefaultBooleanStateClusterServer(!needsReplacement);
+                await this.registerDevice(sensor);
+                vacuum.consumableMap.set(name, { endpoint: sensor, consumable, lastState: needsReplacement });
+                this.log.info(`  Contact sensor registered: ${sensorName} (${needsReplacement ? 'OPEN - needs replacement' : 'CLOSED - OK'})`);
+            }
+            else {
+                vacuum.consumableMap.set(name, { consumable });
+            }
+        }
+    }
+    async setInitialVacuumState(vacuum) {
+        if (!vacuum.device)
+            return;
+        try {
+            const attributes = await vacuum.client.getStateAttributes();
+            if (!attributes) {
+                this.log.warn(`[${vacuum.name}] Failed to fetch initial state attributes`);
+                return;
+            }
+            const battery = attributes.find((attr) => attr.__class === 'BatteryStateAttribute');
+            if (battery) {
+                const batPercentRemaining = Math.round(battery.level * 2);
+                let batChargeState = 0;
+                if (battery.flag === 'charging') {
+                    batChargeState = 1;
+                }
+                else if (battery.flag === 'charged') {
+                    batChargeState = 2;
+                }
+                else if (battery.flag === 'discharging' || battery.flag === 'none') {
+                    batChargeState = 3;
+                }
+                await vacuum.device.setAttribute('PowerSource', 'batPercentRemaining', batPercentRemaining, this.log);
+                await vacuum.device.setAttribute('PowerSource', 'batChargeState', batChargeState, this.log);
+                vacuum.lastBatteryLevel = batPercentRemaining;
+                vacuum.lastBatteryChargeState = batChargeState;
+                this.log.info(`  Initial battery: ${battery.level}% (${batPercentRemaining}/200), charge state: ${batChargeState}`);
+            }
+            const statusAttr = attributes.find((attr) => attr.__class === 'StatusStateAttribute');
+            const dockStatus = attributes.find((attr) => attr.__class === 'DockStatusStateAttribute');
+            if (statusAttr) {
+                const operationalState = this.mapValetudoStatusToOperationalState(statusAttr.value, dockStatus?.value);
+                await vacuum.device.setAttribute('RvcOperationalState', 'operationalState', operationalState, this.log);
+                vacuum.lastOperationalState = operationalState;
+                const runMode = this.mapValetudoStatusToRunMode(statusAttr.value);
+                await vacuum.device.setAttribute('RvcRunMode', 'currentMode', runMode, this.log);
+                vacuum.lastRunMode = runMode;
+                this.log.info(`  Initial state: "${statusAttr.value}" (operational: ${operationalState}, run mode: ${runMode})`);
+            }
+        }
+        catch (error) {
+            this.log.error(`[${vacuum.name}] Error setting initial state: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async updateVacuumState(vacuum) {
+        if (!vacuum.device)
+            return;
+        try {
+            const attributes = await vacuum.client.getStateAttributes();
+            if (!attributes) {
+                this.log.warn(`[${vacuum.name}] Failed to fetch state attributes`);
+                return;
+            }
+            const battery = attributes.find((attr) => attr.__class === 'BatteryStateAttribute');
+            if (battery) {
+                const batPercentRemaining = Math.round(battery.level * 2);
+                let batChargeState = 0;
+                if (battery.flag === 'charging') {
+                    batChargeState = 1;
+                }
+                else if (battery.flag === 'charged') {
+                    batChargeState = 2;
+                }
+                else if (battery.flag === 'discharging' || battery.flag === 'none') {
+                    batChargeState = 3;
+                }
+                const batteryChanged = vacuum.lastBatteryLevel !== batPercentRemaining;
+                const chargeStateChanged = vacuum.lastBatteryChargeState !== batChargeState;
+                if (vacuum.initialStatePending || batteryChanged) {
+                    this.log.info(`[${vacuum.name}] Battery: ${battery.level}% (${batPercentRemaining}/200)`);
+                    await vacuum.device.setAttribute('PowerSource', 'batPercentRemaining', batPercentRemaining, this.log);
+                    vacuum.lastBatteryLevel = batPercentRemaining;
+                    await new Promise((resolve) => setTimeout(resolve, 200));
+                }
+                if (vacuum.initialStatePending || chargeStateChanged) {
+                    this.log.info(`[${vacuum.name}] Battery charge state: ${batChargeState}`);
+                    await vacuum.device.setAttribute('PowerSource', 'batChargeState', batChargeState, this.log);
+                    vacuum.lastBatteryChargeState = batChargeState;
+                    await new Promise((resolve) => setTimeout(resolve, 200));
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            const statusAttr = attributes.find((attr) => attr.__class === 'StatusStateAttribute');
+            const dockStatus = attributes.find((attr) => attr.__class === 'DockStatusStateAttribute');
+            if (statusAttr) {
+                const status = statusAttr;
+                const operationalState = this.mapValetudoStatusToOperationalState(status.value, dockStatus?.value);
+                const operationalStateChanged = vacuum.lastOperationalState !== operationalState;
+                if (vacuum.initialStatePending || operationalStateChanged) {
+                    this.log.info(`[${vacuum.name}] Operational state: "${status.value}" → ${operationalState}`);
+                    await vacuum.device.setAttribute('RvcOperationalState', 'operationalState', operationalState, this.log);
+                    vacuum.lastOperationalState = operationalState;
+                    await new Promise((resolve) => setTimeout(resolve, 200));
+                }
+                const runMode = this.mapValetudoStatusToRunMode(status.value);
+                const runModeChanged = vacuum.lastRunMode !== runMode;
+                if (vacuum.initialStatePending || runModeChanged) {
+                    this.log.info(`[${vacuum.name}] Run mode: ${status.value} → ${runMode === 1 ? 'Idle' : 'Cleaning'}`);
+                    await vacuum.device.setAttribute('RvcRunMode', 'currentMode', runMode, this.log);
+                    vacuum.lastRunMode = runMode;
+                    await new Promise((resolve) => setTimeout(resolve, 200));
+                }
+            }
+            if (vacuum.initialStatePending) {
+                vacuum.initialStatePending = false;
+                this.log.debug(`[${vacuum.name}] Initial state set successfully`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            const config = this.config;
+            if (config.positionTracking?.enabled !== false && vacuum.mapLayersCache && vacuum.areaToSegmentMap.size > 0) {
+                try {
+                    if (Date.now() > vacuum.mapCacheValidUntil) {
+                        await this.refreshMapCacheForVacuum(vacuum);
+                    }
+                    const positionData = await vacuum.client.getMapPositionData();
+                    if (positionData) {
+                        if (positionData.metaData?.version !== undefined && positionData.metaData.version !== vacuum.mapLayersCache.version) {
+                            this.log.warn(`[${vacuum.name}] Map version changed, refreshing cache...`);
+                            await this.refreshMapCacheForVacuum(vacuum);
+                        }
+                        const robotEntity = positionData.entities.find((entity) => entity.type === 'robot_position');
+                        if (robotEntity && robotEntity.points.length >= 2) {
+                            const robotPos = {
+                                x: Math.round(robotEntity.points[0] / vacuum.mapLayersCache.pixelSize),
+                                y: Math.round(robotEntity.points[1] / vacuum.mapLayersCache.pixelSize),
+                            };
+                            const currentSegment = vacuum.client.findSegmentAtPositionCached(vacuum.mapLayersCache, robotPos.x, robotPos.y);
+                            if (currentSegment) {
+                                let foundAreaId = null;
+                                for (const [areaId, segmentInfo] of vacuum.areaToSegmentMap.entries()) {
+                                    if (segmentInfo.id === currentSegment.metaData.segmentId) {
+                                        foundAreaId = areaId;
+                                        break;
+                                    }
+                                }
+                                if (foundAreaId !== null && vacuum.lastCurrentArea !== foundAreaId) {
+                                    const segmentInfo = vacuum.areaToSegmentMap.get(foundAreaId);
+                                    this.log.info(`[${vacuum.name}] Location: ${segmentInfo?.name || 'Unknown'} (area ${foundAreaId})`);
+                                    await vacuum.device.setAttribute('ServiceArea', 'currentArea', foundAreaId, this.log);
+                                    vacuum.lastCurrentArea = foundAreaId;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    this.log.debug(`[${vacuum.name}] Position tracking error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            if (vacuum.consumableMap.size > 0) {
+                await this.updateConsumableStatesForVacuum(vacuum);
+            }
+            vacuum.lastSeen = Date.now();
+            vacuum.online = true;
+        }
+        catch (error) {
+            this.log.error(`[${vacuum.name}] Error updating state: ${error instanceof Error ? error.message : String(error)}`);
+            vacuum.online = false;
+        }
+    }
+    async refreshMapCacheForVacuum(vacuum) {
+        const config = this.config;
+        const refreshHours = Math.max(0.1, Math.min(24, config.mapCache?.refreshIntervalHours ?? 1));
+        const mapData = await vacuum.client.getMapDataWithTimeout(60000);
+        if (mapData) {
+            vacuum.mapLayersCache = vacuum.client.createCachedLayers(mapData);
+            vacuum.mapCacheValidUntil = Date.now() + refreshHours * 60 * 60 * 1000;
+            this.log.debug(`[${vacuum.name}] Map cache refreshed`);
+        }
+    }
+    async updateConsumableStatesForVacuum(vacuum) {
+        const CONSUMABLES_CHECK_INTERVAL = 5 * 60 * 1000;
+        const now = Date.now();
+        if (now - vacuum.lastConsumablesCheck < CONSUMABLES_CHECK_INTERVAL) {
+            return;
+        }
+        vacuum.lastConsumablesCheck = now;
+        const config = this.config;
+        const maxLifetimes = config.consumables?.maxLifetimes || {
+            mainBrush: 18000,
+            sideBrush: 12000,
+            dustFilter: 9000,
+            sensor: 1800,
+        };
+        const warningThreshold = config.consumables?.warningThreshold || 10;
+        try {
+            const consumables = await vacuum.client.getConsumables();
+            if (!consumables)
+                return;
+            for (const consumable of consumables) {
+                const name = this.getConsumableName(consumable);
+                const entry = vacuum.consumableMap.get(name);
+                if (!entry)
+                    continue;
+                const maxLifetime = this.getMaxLifetime(consumable, maxLifetimes);
+                const remainingMinutes = consumable.remaining.value;
+                const lifePercent = Math.round((remainingMinutes / maxLifetime) * 100);
+                entry.consumable = consumable;
+                const needsReplacement = lifePercent <= warningThreshold;
+                if (entry.lastState === undefined || entry.lastState !== needsReplacement) {
+                    const status = needsReplacement ? '⚠️ NEEDS REPLACEMENT' : '✓ OK';
+                    this.log.info(`[${vacuum.name}] ${name}: ${remainingMinutes}min (${lifePercent}%) - ${status}`);
+                    entry.lastState = needsReplacement;
+                }
+                if (entry.endpoint) {
+                    await entry.endpoint.setAttribute('BooleanState', 'stateValue', !needsReplacement, this.log);
+                }
+            }
+        }
+        catch (error) {
+            this.log.debug(`[${vacuum.name}] Error updating consumables: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    mapValetudoStatusToOperationalState(status, dockStatus) {
+        const statusLower = status.toLowerCase();
+        const statusMap = {
+            idle: 66,
+            docked: 66,
+            cleaning: 1,
+            returning: 64,
+            manual_control: 1,
+            moving: 66,
+            paused: 2,
+            error: 3,
+            charging: 65,
+        };
+        const baseState = statusMap[statusLower] ?? 0;
+        if (dockStatus && (statusLower === 'docked' || statusLower === 'idle' || statusLower === 'charging')) {
+            const dockStatusLower = dockStatus.toLowerCase();
+            if (dockStatusLower === 'emptying' || dockStatusLower === 'drying' || dockStatusLower === 'cleaning') {
+                return 66;
+            }
+        }
+        return baseState;
+    }
+    mapValetudoStatusToRunMode(status) {
+        const statusLower = status.toLowerCase();
+        if (statusLower === 'cleaning') {
+            return 2;
+        }
+        return 1;
+    }
+    createIntensityVariants(baseMode, baseModeNumber, baseTags, fanSpeedPresets) {
+        const modes = [];
+        const intensityMap = {
+            off: { tag: RvcCleanMode.ModeTag.Min, label: 'Off', offset: 4 },
+            min: { tag: RvcCleanMode.ModeTag.Min, label: 'Min', offset: 4 },
+            low: { tag: RvcCleanMode.ModeTag.Quiet, label: 'Quiet', offset: 2 },
+            medium: { tag: RvcCleanMode.ModeTag.Auto, label: 'Auto', offset: 0 },
+            high: { tag: RvcCleanMode.ModeTag.Quick, label: 'Quick', offset: 1 },
+            max: { tag: RvcCleanMode.ModeTag.Max, label: 'Max', offset: 3 },
+            turbo: { tag: RvcCleanMode.ModeTag.Max, label: 'Turbo', offset: 3 },
+        };
+        const modeLabel = baseMode === 'vacuum_and_mop' ? 'Vacuum & Mop' : baseMode.charAt(0).toUpperCase() + baseMode.slice(1);
+        if (!fanSpeedPresets || fanSpeedPresets.length === 0) {
+            modes.push({
+                label: modeLabel,
+                mode: baseModeNumber,
+                modeTags: [...baseTags.map((tag) => ({ value: tag })), { value: RvcCleanMode.ModeTag.Auto }],
+            });
+            return modes;
+        }
+        const usedOffsets = new Set();
+        for (const preset of fanSpeedPresets) {
+            const presetLower = preset.toLowerCase();
+            const intensity = intensityMap[presetLower];
+            if (intensity && !usedOffsets.has(intensity.offset)) {
+                usedOffsets.add(intensity.offset);
+                modes.push({
+                    label: `${modeLabel} (${intensity.label})`,
+                    mode: baseModeNumber + intensity.offset,
+                    modeTags: [...baseTags.map((tag) => ({ value: tag })), { value: intensity.tag }],
+                });
+            }
+        }
+        if (modes.length === 0) {
+            modes.push({
+                label: modeLabel,
+                mode: baseModeNumber,
+                modeTags: [...baseTags.map((tag) => ({ value: tag })), { value: RvcCleanMode.ModeTag.Auto }],
+            });
+        }
+        return modes;
+    }
+    createMopVariants(fanSpeedPresets, waterUsagePresets) {
+        if (!fanSpeedPresets || !waterUsagePresets) {
+            return this.createIntensityVariants('mop', 31, [RvcCleanMode.ModeTag.Mop], fanSpeedPresets);
+        }
+        const modes = [];
+        const mopConfigs = [
+            { fanPreset: 'medium', waterPreset: 'medium', tag: RvcCleanMode.ModeTag.Auto, label: 'Mop (Auto)', mode: 31 },
+            { fanPreset: 'low', waterPreset: 'low', tag: RvcCleanMode.ModeTag.Quiet, label: 'Mop (Quiet)', mode: 32 },
+            { fanPreset: 'high', waterPreset: 'high', tag: RvcCleanMode.ModeTag.Quick, label: 'Mop (Quick)', mode: 33 },
+            { fanPreset: 'max', waterPreset: 'high', tag: RvcCleanMode.ModeTag.Max, label: 'Mop (Max)', mode: 34 },
+        ];
+        for (const config of mopConfigs) {
+            const hasFan = fanSpeedPresets.includes(config.fanPreset);
+            const hasWater = waterUsagePresets.includes(config.waterPreset);
+            if (hasFan && hasWater) {
+                modes.push({
+                    label: config.label,
+                    mode: config.mode,
+                    modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: config.tag }],
+                });
+            }
+        }
+        if (modes.length === 0) {
+            return this.createIntensityVariants('mop', 31, [RvcCleanMode.ModeTag.Mop], fanSpeedPresets);
+        }
+        return modes;
+    }
+    getIntensitySettings(mode) {
+        let intensityKey;
+        let defaultFan;
+        let defaultWater;
+        if (mode >= 66 && mode <= 70) {
+            const offset = mode - 66;
+            const offsetMap = {
+                0: { key: 'quiet', fan: 'low', water: 'low' },
+                1: { key: 'auto', fan: 'medium', water: 'medium' },
+                2: { key: 'quick', fan: 'high', water: 'high' },
+                3: { key: 'max', fan: 'max', water: 'high' },
+                4: { key: 'max', fan: 'turbo', water: 'high' },
+            };
+            const mapping = offsetMap[offset] || offsetMap[1];
+            intensityKey = mapping.key;
+            defaultFan = mapping.fan;
+            defaultWater = mapping.water;
+        }
+        else if (mode >= 31 && mode <= 34) {
+            const modeMap = {
+                [31]: { key: 'auto', fan: 'medium', water: 'medium' },
+                [32]: { key: 'quiet', fan: 'low', water: 'low' },
+                [33]: { key: 'quick', fan: 'high', water: 'high' },
+                [34]: { key: 'max', fan: 'max', water: 'high' },
+            };
+            const mapping = modeMap[mode] || modeMap[31];
+            intensityKey = mapping.key;
+            defaultFan = mapping.fan;
+            defaultWater = mapping.water;
+        }
+        else if (mode >= 5 && mode <= 9) {
+            const offset = mode - 5;
+            const offsetMap = {
+                0: { key: 'quiet', fan: 'low', water: 'low' },
+                1: { key: 'auto', fan: 'medium', water: 'medium' },
+                2: { key: 'quick', fan: 'high', water: 'high' },
+                3: { key: 'max', fan: 'max', water: 'high' },
+                4: { key: 'max', fan: 'turbo', water: 'high' },
+            };
+            const mapping = offsetMap[offset] || offsetMap[1];
+            intensityKey = mapping.key;
+            defaultFan = mapping.fan;
+            defaultWater = mapping.water;
+        }
+        else {
+            return { fan: 'medium', water: 'medium' };
+        }
+        const config = this.config;
+        const overrides = config.intensityPresets?.[intensityKey];
+        return {
+            fan: overrides?.fanSpeed || defaultFan,
+            water: overrides?.waterUsage || defaultWater,
+        };
+    }
+    getConsumableName(consumable) {
+        const typeMap = {
+            'brush-main': 'Main Brush',
+            'brush-side_right': 'Side Brush',
+            'brush-side_left': 'Side Brush Left',
+            'filter-main': 'Dust Filter',
+            'cleaning-sensor': 'Sensor',
+            'cleaning-wheel': 'Wheel',
+            'consumable-detergent': 'Detergent',
+        };
+        const key = `${consumable.type}-${consumable.subType}`;
+        if (consumable.subType.includes('dock')) {
+            return 'Detergent';
+        }
+        return typeMap[key] || `${consumable.type} ${consumable.subType}`;
+    }
+    getMaxLifetime(consumable, maxLifetimes) {
+        if (consumable.remaining.value <= 100 && consumable.remaining.value >= 0) {
+            const isPercentage = consumable.type === 'consumable' || consumable.subType.includes('detergent') || consumable.subType.includes('dock');
+            if (isPercentage) {
+                return 100;
+            }
+        }
+        let key;
+        if (consumable.type === 'brush' && consumable.subType === 'main') {
+            key = 'mainBrush';
+        }
+        else if (consumable.type === 'brush' && (consumable.subType === 'side_right' || consumable.subType === 'side_left')) {
+            key = 'sideBrush';
+        }
+        else if (consumable.type === 'filter' && consumable.subType === 'main') {
+            key = 'dustFilter';
+        }
+        else if (consumable.type === 'cleaning' && consumable.subType === 'sensor') {
+            key = 'sensor';
+        }
+        else {
+            return 10000;
+        }
+        return maxLifetimes[key] || 10000;
+    }
+    startPeriodicDiscovery() {
+        const config = this.config;
+        const discoveryEnabled = config.discovery?.enabled !== false;
+        if (!discoveryEnabled) {
+            this.log.debug('Periodic mDNS discovery not started (mDNS discovery is disabled)');
+            return;
+        }
+        const intervalSeconds = config.discovery?.scanIntervalSeconds || 0;
+        if (intervalSeconds > 0) {
+            const intervalMs = intervalSeconds * 1000;
+            this.log.info(`Starting periodic mDNS discovery (every ${intervalSeconds} seconds)`);
+            this.discoveryInterval = setInterval(async () => {
+                this.log.info('Running periodic mDNS discovery...');
+                await this.discoverAndAddVacuums();
+            }, intervalMs);
+        }
+    }
+    async discoverDevices() {
+        this.log.info('Discovering Valetudo devices with multi-vacuum support...');
+        await this.loadManualVacuums();
+        await this.discoverAndAddVacuums();
+        if (this.vacuums.size === 0) {
+            this.log.error('No vacuums found! Please configure vacuums manually or enable mDNS discovery.');
+            return;
+        }
+        this.log.info(`Successfully configured ${this.vacuums.size} vacuum(s)`);
+        this.startPeriodicDiscovery();
+    }
+}