@diveflo/matterbridge-mova 0.1.18

package/dist/movaCloud.js

@@ -0,0 +1,1096 @@
+import { createHash } from 'node:crypto';
+import { inflateSync } from 'node:zlib';
+import { MovaState, MovaStatus, MovaFanSpeed, MovaWaterFlow, MovaCleaningMode, MovaErrorCode, } from './types.js';
+import { getMovaApiUrl, getMovaUserAgent, getMovaTenantId, MOVA_AUTH_ENDPOINT, MOVA_AUTH_HEADER, MOVA_CLIENT_ID, MOVA_DEVICE_LIST_ENDPOINT, MOVA_DOWNLOAD_ENDPOINT, MOVA_GET_DEVICE_DATA_ENDPOINT, MOVA_OSS_DOWNLOAD_ENDPOINT, MOVA_PASSWORD_SALT, getMovaSendCommandEndpoint, MIOT_PROPERTIES, MIOT_ACTIONS, MIOT_ACTION_PARAMS, MOVA_STATUS_VALUES, isSupportedModel, } from './constants.js';
+const TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+const RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 10000,
+};
+const RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
+export class MovaCloudProtocol {
+    log;
+    session = null;
+    mqttClients = new Map();
+    messageId = 0;
+    pendingRequests = new Map();
+    deviceStatusCallbacks = new Map();
+    deviceOwnerIds = new Map();
+    deviceModels = new Map();
+    deviceBindDomains = new Map();
+    loginCredentials = null;
+    isRefreshing = false;
+    constructor(log) {
+        this.log = log;
+    }
+    async ensureValidToken() {
+        if (!this.session) {
+            return false;
+        }
+        const now = Date.now();
+        const expiresAt = this.session.expiresAt;
+        if (now < expiresAt - TOKEN_REFRESH_BUFFER_MS) {
+            return true;
+        }
+        this.log.info('Token is expiring soon, refreshing...');
+        return this.refreshToken();
+    }
+    async refreshToken() {
+        if (this.isRefreshing) {
+            this.log.debug('Token refresh already in progress, waiting...');
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            return this.session !== null;
+        }
+        this.isRefreshing = true;
+        try {
+            if (this.loginCredentials) {
+                this.log.info('Re-authenticating with stored credentials...');
+                const result = await this.login(this.loginCredentials.username, this.loginCredentials.password, this.loginCredentials.country);
+                return result.success;
+            }
+            this.log.error('No credentials available for token refresh');
+            return false;
+        }
+        finally {
+            this.isRefreshing = false;
+        }
+    }
+    async login(username, password, country) {
+        this.log.info(`Logging in to Mova Cloud (${country})...`);
+        try {
+            const baseUrl = getMovaApiUrl(country);
+            const userAgent = getMovaUserAgent();
+            const tenantId = getMovaTenantId();
+            const passwordHash = createHash('md5')
+                .update(password + MOVA_PASSWORD_SALT)
+                .digest('hex');
+            const loginBody = `platform=IOS&scope=all&grant_type=password&username=${encodeURIComponent(username)}&password=${encodeURIComponent(passwordHash)}&type=account`;
+            this.log.debug(`Login URL: ${baseUrl}${MOVA_AUTH_ENDPOINT}`);
+            const headers = {
+                'Accept': '*/*',
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept-Language': 'en-US;q=0.8',
+                'Accept-Encoding': 'gzip, deflate',
+                'User-Agent': userAgent,
+                'Authorization': MOVA_AUTH_HEADER,
+                'Tenant-Id': tenantId,
+            };
+            if (country === 'cn') {
+                headers['Dreame-Rlc'] = MOVA_CLIENT_ID;
+            }
+            const response = await fetch(`${baseUrl}${MOVA_AUTH_ENDPOINT}`, {
+                method: 'POST',
+                headers,
+                body: loginBody,
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                this.log.error(`Login failed: ${response.status} ${text}`);
+                return { success: false, error: `Login failed: ${response.status} - ${text}` };
+            }
+            const data = (await response.json());
+            if (!data.access_token) {
+                return { success: false, error: data.msg || 'No access token received' };
+            }
+            const mqttKey = data.access_token;
+            this.session = {
+                token: data.access_token,
+                refreshToken: data.refresh_token || '',
+                expiresAt: Date.now() + (data.expires_in || 3600) * 1000,
+                userId: data.uid || data.tenant_id || '',
+                country,
+                mqttKey,
+            };
+            this.log.info(`Got MQTT credentials: uid=${this.session.userId}, key length=${mqttKey?.length || 0}`);
+            if (!this.isRefreshing) {
+                this.loginCredentials = { username, password, country };
+            }
+            this.log.info('Login successful');
+            return {
+                success: true,
+                token: this.session.token,
+                refreshToken: this.session.refreshToken,
+                expiresAt: this.session.expiresAt,
+                userId: this.session.userId,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log.error(`Login error: ${message}`);
+            return { success: false, error: message };
+        }
+    }
+    async apiCall(endpoint, method = 'GET', body) {
+        if (!this.session) {
+            this.log.error('No active session');
+            return null;
+        }
+        const tokenValid = await this.ensureValidToken();
+        if (!tokenValid) {
+            this.log.error('Failed to ensure valid token');
+            return null;
+        }
+        const baseUrl = getMovaApiUrl(this.session.country);
+        const userAgent = getMovaUserAgent();
+        const tenantId = getMovaTenantId();
+        const url = `${baseUrl}${endpoint}`;
+        const headers = {
+            'Accept': '*/*',
+            'Accept-Language': 'en-US;q=0.8',
+            'Accept-Encoding': 'gzip, deflate',
+            'Content-Type': 'application/json',
+            'User-Agent': userAgent,
+            'Authorization': MOVA_AUTH_HEADER,
+            'Tenant-Id': tenantId,
+            'Dreame-Auth': this.session.token,
+        };
+        if (this.session.country === 'cn') {
+            headers['Dreame-Rlc'] = MOVA_CLIENT_ID;
+        }
+        const options = {
+            method,
+            headers,
+        };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+        let lastError = null;
+        for (let attempt = 0; attempt <= RETRY_CONFIG.maxRetries; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const delay = Math.min(RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt - 1), RETRY_CONFIG.maxDelayMs);
+                    const jitter = delay * 0.2 * Math.random();
+                    this.log.debug(`Retry attempt ${attempt}/${RETRY_CONFIG.maxRetries} after ${Math.round(delay + jitter)}ms`);
+                    await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+                }
+                const response = await fetch(url, options);
+                if (!response.ok) {
+                    if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < RETRY_CONFIG.maxRetries) {
+                        lastError = new Error(`HTTP ${response.status}`);
+                        this.log.warn(`API call got ${response.status}, will retry...`);
+                        continue;
+                    }
+                    const text = await response.text();
+                    this.log.error(`API call failed: ${response.status} - ${text}`);
+                    return null;
+                }
+                return (await response.json());
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < RETRY_CONFIG.maxRetries) {
+                    this.log.warn(`API call error (attempt ${attempt + 1}): ${lastError.message}`);
+                    continue;
+                }
+            }
+        }
+        this.log.error(`API call failed after ${RETRY_CONFIG.maxRetries + 1} attempts: ${lastError?.message}`);
+        return null;
+    }
+    async getDevices() {
+        let response = await this.apiCall(MOVA_DEVICE_LIST_ENDPOINT, 'POST', {
+            page: 1,
+            pageSize: 100,
+        });
+        if (!response?.data?.page?.records) {
+            response = await this.apiCall(MOVA_DEVICE_LIST_ENDPOINT, 'POST');
+        }
+        if (!response?.data?.page?.records) {
+            this.log.debug('No devices found in response');
+            this.log.debug(`Response: ${JSON.stringify(response)}`);
+            return [];
+        }
+        this.log.info(`API returned ${response.data.page.records.length} device(s)`);
+        const devices = response.data.page.records
+            .filter((d) => d.model?.startsWith('mova.vacuum') || isSupportedModel(d.model))
+            .map((d) => {
+            const deviceName = d.customName || d.deviceInfo?.displayName || `Mova ${d.model}`;
+            if (d.masterUid) {
+                this.deviceOwnerIds.set(d.did, d.masterUid);
+            }
+            this.deviceModels.set(d.did, d.model);
+            if (d.bindDomain) {
+                this.deviceBindDomains.set(d.did, d.bindDomain);
+            }
+            return {
+                did: d.did,
+                name: deviceName,
+                model: d.model,
+                mac: d.mac,
+                localIp: d.localIp || d.localip,
+                online: d.online,
+                ownerId: d.masterUid || '',
+                bindDomain: d.bindDomain,
+                property: d.property,
+            };
+        });
+        this.log.info(`Found ${devices.length} Mova vacuum(s)`);
+        return devices;
+    }
+    async getDeviceProperties(did) {
+        const props = [
+            { siid: MIOT_PROPERTIES.batteryLevel.siid, piid: MIOT_PROPERTIES.batteryLevel.piid },
+            { siid: MIOT_PROPERTIES.chargingState.siid, piid: MIOT_PROPERTIES.chargingState.piid },
+            { siid: MIOT_PROPERTIES.deviceFault.siid, piid: MIOT_PROPERTIES.deviceFault.piid },
+            { siid: MIOT_PROPERTIES.deviceStatus.siid, piid: MIOT_PROPERTIES.deviceStatus.piid },
+            { siid: MIOT_PROPERTIES.operatingMode.siid, piid: MIOT_PROPERTIES.operatingMode.piid },
+            { siid: MIOT_PROPERTIES.suctionLevel.siid, piid: MIOT_PROPERTIES.suctionLevel.piid },
+            { siid: MIOT_PROPERTIES.waterFlow.siid, piid: MIOT_PROPERTIES.waterFlow.piid },
+            { siid: MIOT_PROPERTIES.cleaningMode.siid, piid: MIOT_PROPERTIES.cleaningMode.piid },
+            { siid: MIOT_PROPERTIES.selfWashBaseStatus.siid, piid: MIOT_PROPERTIES.selfWashBaseStatus.piid },
+            { siid: MIOT_PROPERTIES.waterTankInstalled.siid, piid: MIOT_PROPERTIES.waterTankInstalled.piid },
+            { siid: MIOT_PROPERTIES.mopPadInstalled.siid, piid: MIOT_PROPERTIES.mopPadInstalled.piid },
+            { siid: MIOT_PROPERTIES.dustCollectionStatus.siid, piid: MIOT_PROPERTIES.dustCollectionStatus.piid },
+            { siid: MIOT_PROPERTIES.cleanWaterTankStatus.siid, piid: MIOT_PROPERTIES.cleanWaterTankStatus.piid },
+            { siid: MIOT_PROPERTIES.dirtyWaterTankStatus.siid, piid: MIOT_PROPERTIES.dirtyWaterTankStatus.piid },
+        ];
+        try {
+            const response = await this.sendCloudCommand(did, 'get_properties', props);
+            let results;
+            if (Array.isArray(response)) {
+                results = response;
+            }
+            else if (response && typeof response === 'object' && 'result' in response) {
+                const wrapped = response;
+                if (Array.isArray(wrapped.result)) {
+                    results = wrapped.result;
+                }
+                else {
+                    this.log.debug(`No valid result array in response: ${JSON.stringify(response)}`);
+                    return null;
+                }
+            }
+            else {
+                return null;
+            }
+            const getValue = (siid, piid) => {
+                const prop = results.find((p) => p.siid === siid && p.piid === piid && p.code === 0);
+                return prop?.value;
+            };
+            const waterTankRaw = getValue(MIOT_PROPERTIES.waterTankInstalled.siid, MIOT_PROPERTIES.waterTankInstalled.piid);
+            const mopPadRaw = getValue(MIOT_PROPERTIES.mopPadInstalled.siid, MIOT_PROPERTIES.mopPadInstalled.piid);
+            const status = {
+                state: getValue(MIOT_PROPERTIES.operatingMode.siid, MIOT_PROPERTIES.operatingMode.piid) ?? MovaState.Unknown,
+                status: getValue(MIOT_PROPERTIES.deviceStatus.siid, MIOT_PROPERTIES.deviceStatus.piid) ?? MovaStatus.Unknown,
+                battery: getValue(MIOT_PROPERTIES.batteryLevel.siid, MIOT_PROPERTIES.batteryLevel.piid) ?? 0,
+                fanSpeed: getValue(MIOT_PROPERTIES.suctionLevel.siid, MIOT_PROPERTIES.suctionLevel.piid) ?? MovaFanSpeed.Standard,
+                waterFlow: getValue(MIOT_PROPERTIES.waterFlow.siid, MIOT_PROPERTIES.waterFlow.piid) ?? MovaWaterFlow.Medium,
+                cleaningMode: getValue(MIOT_PROPERTIES.cleaningMode.siid, MIOT_PROPERTIES.cleaningMode.piid),
+                errorCode: getValue(MIOT_PROPERTIES.deviceFault.siid, MIOT_PROPERTIES.deviceFault.piid) ?? MovaErrorCode.None,
+                waterTankInstalled: waterTankRaw !== undefined ? waterTankRaw === 1 : undefined,
+                mopPadInstalled: mopPadRaw !== undefined ? mopPadRaw === 1 : undefined,
+                dustCollectionStatus: getValue(MIOT_PROPERTIES.dustCollectionStatus.siid, MIOT_PROPERTIES.dustCollectionStatus.piid),
+                cleanWaterTankStatus: getValue(MIOT_PROPERTIES.cleanWaterTankStatus.siid, MIOT_PROPERTIES.cleanWaterTankStatus.piid),
+                dirtyWaterTankStatus: getValue(MIOT_PROPERTIES.dirtyWaterTankStatus.siid, MIOT_PROPERTIES.dirtyWaterTankStatus.piid),
+            };
+            const accessoryInfo = [];
+            if (status.waterTankInstalled !== undefined)
+                accessoryInfo.push(`waterTank=${status.waterTankInstalled}`);
+            if (status.mopPadInstalled !== undefined)
+                accessoryInfo.push(`mopPad=${status.mopPadInstalled}`);
+            const accessoryStr = accessoryInfo.length > 0 ? `, ${accessoryInfo.join(', ')}` : '';
+            this.log.info(`Device status: state=${status.state}, status=${status.status}, battery=${status.battery}%${accessoryStr}`);
+            this.cachedStatus.set(did, status);
+            return status;
+        }
+        catch (error) {
+            this.log.error(`Failed to get device properties: ${error}`);
+            return null;
+        }
+    }
+    async getRoomInfo(did) {
+        const cachedRooms = this.cachedRooms.get(did);
+        if (cachedRooms && cachedRooms.length > 0) {
+            this.log.info(`Using ${cachedRooms.length} cached rooms from MQTT for ${did}`);
+            return cachedRooms;
+        }
+        this.log.debug('No cached room data available - rooms will be received via MQTT when device is active');
+        return [];
+    }
+    decodeMapPayload(mapData) {
+        try {
+            if (typeof mapData === 'string') {
+                try {
+                    return JSON.parse(mapData);
+                }
+                catch {
+                    try {
+                        const decoded = Buffer.from(mapData, 'base64');
+                        if (decoded[0] === 0x78) {
+                            const decompressed = inflateSync(decoded);
+                            if (decompressed.length > 1000) {
+                                const searchStart = Math.max(0, decompressed.length - 50000);
+                                const endSection = decompressed.subarray(searchStart).toString('latin1');
+                                const rismIndex = endSection.indexOf('"rism"');
+                                if (rismIndex !== -1) {
+                                    for (let searchBack = rismIndex; searchBack >= 0; searchBack--) {
+                                        if (endSection[searchBack] !== '{')
+                                            continue;
+                                        let braceCount = 0;
+                                        let braceEnd = -1;
+                                        for (let i = searchBack; i < endSection.length; i++) {
+                                            if (endSection[i] === '{')
+                                                braceCount++;
+                                            if (endSection[i] === '}')
+                                                braceCount--;
+                                            if (braceCount === 0) {
+                                                braceEnd = i;
+                                                break;
+                                            }
+                                        }
+                                        if (braceEnd > searchBack) {
+                                            const jsonStr = endSection.substring(searchBack, braceEnd + 1);
+                                            if (jsonStr.includes('"rism"') && jsonStr.length < 50000) {
+                                                try {
+                                                    return JSON.parse(jsonStr);
+                                                }
+                                                catch {
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            return JSON.parse(decoded.toString('utf-8'));
+                        }
+                    }
+                    catch {
+                        return null;
+                    }
+                }
+            }
+            else if (typeof mapData === 'object' && mapData !== null) {
+                return mapData;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    decodeRismPayload(rism) {
+        if (!rism || typeof rism !== 'string' || rism.length === 0) {
+            return null;
+        }
+        try {
+            const standardBase64 = rism.replace(/-/g, '+').replace(/_/g, '/');
+            const rismDecoded = Buffer.from(standardBase64, 'base64');
+            if (rismDecoded[0] !== 0x78) {
+                return JSON.parse(rismDecoded.toString('utf-8'));
+            }
+            const rismDecompressed = inflateSync(rismDecoded);
+            const rismStr = rismDecompressed.toString('utf-8');
+            try {
+                return JSON.parse(rismStr);
+            }
+            catch {
+                const segInfIndex = rismStr.indexOf('"seg_inf"');
+                if (segInfIndex === -1) {
+                    return null;
+                }
+                const segInfStart = rismStr.indexOf('{', segInfIndex);
+                if (segInfStart === -1) {
+                    return null;
+                }
+                let braceCount = 0;
+                let segInfEnd = -1;
+                for (let i = segInfStart; i < rismStr.length; i++) {
+                    if (rismStr[i] === '{')
+                        braceCount++;
+                    if (rismStr[i] === '}')
+                        braceCount--;
+                    if (braceCount === 0) {
+                        segInfEnd = i;
+                        break;
+                    }
+                }
+                if (segInfEnd <= segInfStart) {
+                    return null;
+                }
+                return { seg_inf: JSON.parse(rismStr.substring(segInfStart, segInfEnd + 1)) };
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    parseRoomsFromMapData(mapData) {
+        try {
+            const parsed = this.decodeMapPayload(mapData);
+            if (!parsed) {
+                return [];
+            }
+            const rism = this.decodeRismPayload(parsed.rism);
+            if (parsed.seg_inf) {
+                return this.parseSegInf(parsed.seg_inf);
+            }
+            if (rism?.seg_inf) {
+                return this.parseSegInf(rism.seg_inf);
+            }
+            return [];
+        }
+        catch (error) {
+            this.log.error(`Failed to parse map data: ${error}`);
+            return [];
+        }
+    }
+    static ROOM_TYPE_NAMES = {
+        0: 'Room',
+        1: 'Living Room',
+        2: 'Primary Bedroom',
+        3: 'Study',
+        4: 'Kitchen',
+        5: 'Dining Hall',
+        6: 'Bathroom',
+        7: 'Balcony',
+        8: 'Corridor',
+        9: 'Utility Room',
+        10: 'Closet',
+        11: 'Meeting Room',
+        12: 'Office',
+        13: 'Fitness Area',
+        14: 'Recreation Area',
+        15: 'Secondary Bedroom',
+    };
+    parseSegInf(segInf) {
+        const rooms = [];
+        const keys = Object.keys(segInf);
+        const typeCounters = {};
+        for (const segIdStr of keys) {
+            const segId = parseInt(segIdStr, 10);
+            if (isNaN(segId))
+                continue;
+            const segData = segInf[segIdStr];
+            const roomType = typeof segData?.type === 'number' ? segData.type : 0;
+            let roomName = null;
+            if (segData?.name && typeof segData.name === 'string' && segData.name.length > 0) {
+                try {
+                    const decoded = Buffer.from(segData.name, 'base64').toString('utf-8');
+                    if (decoded && decoded.trim().length > 0) {
+                        roomName = decoded;
+                    }
+                }
+                catch {
+                    if (segData.name.trim().length > 0) {
+                        roomName = segData.name;
+                    }
+                }
+            }
+            if (!roomName) {
+                const typeName = MovaCloudProtocol.ROOM_TYPE_NAMES[roomType] || 'Room';
+                typeCounters[roomType] = (typeCounters[roomType] || 0) + 1;
+                if (typeCounters[roomType] > 1) {
+                    roomName = `${typeName} ${typeCounters[roomType]}`;
+                }
+                else {
+                    roomName = typeName;
+                }
+            }
+            rooms.push({
+                id: segId,
+                name: roomName,
+                floorId: roomType,
+            });
+        }
+        if (rooms.length > 0) {
+            this.log.info(`Extracted ${rooms.length} rooms: ${rooms.map((r) => r.name).join(', ')}`);
+        }
+        return rooms;
+    }
+    async tryFetchMapOnStartup(did) {
+        const ownerId = this.deviceOwnerIds.get(did);
+        if (!ownerId) {
+            this.log.debug('No owner ID stored, cannot try proactive map fetch');
+            return false;
+        }
+        const mapPaths = [`ali_dreame/${ownerId}/${did}/1`, `ali_dreame/${ownerId}/${did}/0`, `ali_dreame/${ownerId}/${did}/2`];
+        for (const path of mapPaths) {
+            this.log.info(`Proactively trying to fetch map from: ${path}`);
+            await this.fetchMapFromCloudStorage(did, path);
+            const rooms = this.cachedRooms.get(did);
+            if (rooms && rooms.length > 0) {
+                this.log.info(`Successfully fetched ${rooms.length} rooms from ${path}`);
+                return true;
+            }
+        }
+        this.log.debug('Proactive map fetch did not find any rooms');
+        return false;
+    }
+    async fetchMapFromCloudStorage(did, objectPath) {
+        try {
+            this.log.info(`Fetching map data from cloud storage: ${objectPath}`);
+            const mapKeys = [`${objectPath}/map`, `${objectPath}/seg_inf`, `${objectPath}`];
+            for (const key of mapKeys) {
+                const response = await this.apiCall(MOVA_GET_DEVICE_DATA_ENDPOINT, 'POST', {
+                    did,
+                    model: [key],
+                });
+                if (response?.code === 0 && response.data) {
+                    for (const [, value] of Object.entries(response.data)) {
+                        if (value && typeof value === 'string' && value.length > 50) {
+                            if (value.includes('seg_inf') || value.includes('"name"')) {
+                                const rooms = this.parseRoomsFromMapData(value);
+                                if (rooms.length > 0) {
+                                    this.log.info(`Found ${rooms.length} rooms from cloud storage: ${rooms.map((r) => r.name).join(', ')}`);
+                                    this.cachedRooms.set(did, rooms);
+                                    const roomCallback = this.roomUpdateCallbacks.get(did);
+                                    if (roomCallback) {
+                                        roomCallback(rooms);
+                                    }
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const deviceModel = this.deviceModels.get(did);
+            if (!deviceModel) {
+                this.log.debug('No device model stored, cannot fetch from cloud storage');
+                return;
+            }
+            const tryDownloadMap = async (url, source) => {
+                try {
+                    const mapResponse = await fetch(url);
+                    if (mapResponse.ok) {
+                        const mapText = await mapResponse.text();
+                        let rooms = this.parseRoomsFromMapData(mapText);
+                        if (rooms.length > 0) {
+                            this.log.info(`Found ${rooms.length} rooms from ${source}: ${rooms.map((r) => r.name).join(', ')}`);
+                            this.cachedRooms.set(did, rooms);
+                            const roomCallback = this.roomUpdateCallbacks.get(did);
+                            if (roomCallback) {
+                                roomCallback(rooms);
+                            }
+                            return true;
+                        }
+                        if (mapText.charCodeAt(0) < 32 || mapText.charCodeAt(0) > 126) {
+                            const mapBuffer = await (await fetch(url)).arrayBuffer();
+                            rooms = this.parseRoomsFromMapData(Buffer.from(mapBuffer).toString('base64'));
+                            if (rooms.length > 0) {
+                                this.log.info(`Found ${rooms.length} rooms from ${source}: ${rooms.map((r) => r.name).join(', ')}`);
+                                this.cachedRooms.set(did, rooms);
+                                const roomCallback = this.roomUpdateCallbacks.get(did);
+                                if (roomCallback) {
+                                    roomCallback(rooms);
+                                }
+                                return true;
+                            }
+                        }
+                    }
+                }
+                catch {
+                }
+                return false;
+            };
+            const ossResponse = await this.apiCall(MOVA_OSS_DOWNLOAD_ENDPOINT, 'POST', {
+                did,
+                filename: objectPath,
+                model: deviceModel,
+            });
+            if (ossResponse?.code === 0 && ossResponse.data) {
+                if (typeof ossResponse.data === 'string' && ossResponse.data.startsWith('http')) {
+                    if (await tryDownloadMap(ossResponse.data, 'OSS'))
+                        return;
+                }
+                else if (typeof ossResponse.data === 'object') {
+                    for (const [key, url] of Object.entries(ossResponse.data)) {
+                        if (url && typeof url === 'string' && url.startsWith('http')) {
+                            if (await tryDownloadMap(url, `OSS[${key}]`))
+                                return;
+                        }
+                    }
+                }
+            }
+            const fileResponse = await this.apiCall(MOVA_DOWNLOAD_ENDPOINT, 'POST', {
+                did,
+                filename: objectPath,
+                model: deviceModel,
+            });
+            if (fileResponse?.code === 0 && fileResponse.data) {
+                if (typeof fileResponse.data === 'string' && fileResponse.data.startsWith('http')) {
+                    if (await tryDownloadMap(fileResponse.data, 'Download'))
+                        return;
+                }
+                else if (typeof fileResponse.data === 'object') {
+                    for (const [key, url] of Object.entries(fileResponse.data)) {
+                        if (url && typeof url === 'string' && url.startsWith('http')) {
+                            if (await tryDownloadMap(url, `Download[${key}]`))
+                                return;
+                        }
+                    }
+                }
+            }
+            this.log.debug('No room data found in cloud storage');
+        }
+        catch (error) {
+            this.log.debug(`Failed to fetch map from cloud storage: ${error}`);
+        }
+    }
+    async connectMqtt(device) {
+        if (!this.session || !device.bindDomain) {
+            this.log.warn(`Cannot connect MQTT: no session=${!!this.session} or bindDomain=${device.bindDomain}`);
+            return false;
+        }
+        const { userId: uid, mqttKey: accessToken, token } = this.session;
+        if (!uid || !accessToken) {
+            this.log.warn(`Cannot connect MQTT: missing uid=${!!uid} or access_token=${!!accessToken}`);
+            return false;
+        }
+        const [host, portStr] = device.bindDomain.split(':');
+        const port = parseInt(portStr, 10) || 8883;
+        const randomId = Math.random().toString(36).substring(2, 15);
+        const clientId = `p_${uid}_${randomId}_${host}`;
+        this.log.info(`Connecting MQTT to ${host}:${port}`);
+        try {
+            const mqtt = await import('mqtt');
+            const client = mqtt.connect({
+                host,
+                port,
+                protocol: 'mqtts',
+                username: uid,
+                password: accessToken,
+                clientId,
+                rejectUnauthorized: false,
+                connectTimeout: 15000,
+                keepalive: 60,
+                clean: true,
+                reconnectPeriod: 5000,
+            });
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    this.log.warn('MQTT connection timeout after 20s');
+                    client.end(true);
+                    resolve(false);
+                }, 20000);
+                client.on('connect', () => {
+                    clearTimeout(timeout);
+                    this.log.info(`MQTT connected for ${device.name}`);
+                    this.mqttClients.set(device.did, client);
+                    const country = this.session?.country || 'eu';
+                    const topics = [`/status/${device.did}/${uid}/${device.model}/${country}/`, `/status/${device.did}/#`, `+/${device.did}/#`];
+                    for (const topic of topics) {
+                        client.subscribe(topic, { qos: 0 });
+                    }
+                    this.requestMapDataViaMqtt(device.did, client);
+                    resolve(true);
+                });
+                client.on('error', (err) => {
+                    clearTimeout(timeout);
+                    this.log.warn(`MQTT error: ${err.message}`);
+                    if (err.message.includes('Not authorized') || err.message.includes('Connection refused')) {
+                        this.log.debug(`Auth may have failed. uid=${uid}, token preview=${token.substring(0, 20)}...`);
+                    }
+                    resolve(false);
+                });
+                client.on('offline', () => {
+                    this.log.debug('MQTT client went offline');
+                });
+                client.on('reconnect', () => {
+                    this.log.debug('MQTT client reconnecting...');
+                });
+                client.on('message', (topic, payload) => {
+                    this.handleMqttMessage(device.did, topic, payload.toString());
+                });
+                client.on('close', () => {
+                    this.log.debug(`MQTT connection closed for ${device.name}`);
+                    this.mqttClients.delete(device.did);
+                });
+            });
+        }
+        catch (error) {
+            this.log.error(`MQTT connection failed: ${error}`);
+            return false;
+        }
+    }
+    requestMapDataViaMqtt(did, client) {
+        const id = ++this.messageId;
+        const uid = this.session?.userId || '';
+        const message = {
+            id,
+            method: 'get_properties',
+            params: [
+                { siid: 6, piid: 1 },
+                { siid: 6, piid: 2 },
+                { siid: 6, piid: 8 },
+                { siid: 99, piid: 98 },
+            ],
+        };
+        const commandTopic = `device/${did}/command`;
+        const altCommandTopic = `/command/${did}/${uid}/`;
+        client.publish(commandTopic, JSON.stringify(message), { qos: 0 });
+        client.publish(altCommandTopic, JSON.stringify(message), { qos: 0 });
+        const actionMessage = {
+            id: ++this.messageId,
+            method: 'action',
+            params: {
+                siid: 6,
+                aiid: 1,
+                in: [],
+            },
+        };
+        setTimeout(() => {
+            client.publish(commandTopic, JSON.stringify(actionMessage), { qos: 0 });
+        }, 2000);
+    }
+    handleMqttMessage(did, _topic, payload) {
+        try {
+            const data = JSON.parse(payload);
+            if (data.id !== undefined && typeof data.id === 'number') {
+                const pending = this.pendingRequests.get(data.id);
+                if (pending) {
+                    this.pendingRequests.delete(data.id);
+                    if (data.error) {
+                        pending.reject(new Error(String(data.error)));
+                    }
+                    else {
+                        pending.resolve(data.result);
+                    }
+                }
+            }
+            const innerData = data.data || data;
+            const params = innerData.params;
+            if (params && Array.isArray(params)) {
+                const props = params;
+                const status = this.parseStatusFromMqtt(did, params);
+                if (status) {
+                    const callback = this.deviceStatusCallbacks.get(did);
+                    if (callback) {
+                        callback(status);
+                    }
+                }
+                const mapDataProps = props.filter((p) => (p.siid === 6 && (p.piid === 1 || p.piid === 2 || p.piid === 8)) || (p.siid === 99 && p.piid === 98));
+                for (const prop of mapDataProps) {
+                    if (prop.value) {
+                        const rooms = this.parseRoomsFromMapData(prop.value);
+                        if (rooms.length > 0) {
+                            this.log.info(`Parsed ${rooms.length} rooms from MQTT: ${rooms.map((r) => r.name).join(', ')}`);
+                            this.cachedRooms.set(did, rooms);
+                            const roomCallback = this.roomUpdateCallbacks.get(did);
+                            if (roomCallback) {
+                                roomCallback(rooms);
+                            }
+                        }
+                    }
+                }
+                const mapPathProp = props.find((p) => p.siid === 6 && p.piid === 3);
+                if (mapPathProp?.value && typeof mapPathProp.value === 'string') {
+                    this.log.info(`Received map storage path: ${mapPathProp.value}`);
+                    this.fetchMapFromCloudStorage(did, mapPathProp.value).catch((err) => {
+                        this.log.debug(`Failed to fetch map from cloud storage: ${err}`);
+                    });
+                }
+            }
+            if (data.result && Array.isArray(data.result)) {
+                this.log.debug(`MQTT result array with ${data.result.length} items`);
+                const results = data.result;
+                for (const result of results) {
+                    if (result.siid === 6 && result.value && result.code === 0) {
+                        this.log.info(`Got map property from MQTT result: siid=6 piid=${result.piid}`);
+                        const rooms = this.parseRoomsFromMapData(result.value);
+                        if (rooms.length > 0) {
+                            this.log.info(`Parsed ${rooms.length} rooms from MQTT result: ${rooms.map((r) => r.name).join(', ')}`);
+                            this.cachedRooms.set(did, rooms);
+                            const roomCallback = this.roomUpdateCallbacks.get(did);
+                            if (roomCallback) {
+                                roomCallback(rooms);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            this.log.debug(`Failed to parse MQTT message: ${e}`);
+            this.log.debug(`Raw payload: ${payload.substring(0, 200)}`);
+        }
+    }
+    roomUpdateCallbacks = new Map();
+    onRoomUpdate(did, callback) {
+        this.roomUpdateCallbacks.set(did, callback);
+    }
+    cachedRooms = new Map();
+    cachedStatus = new Map();
+    getCachedRooms(did) {
+        return this.cachedRooms.get(did) || [];
+    }
+    parseStatusFromMqtt(did, params) {
+        try {
+            const props = params;
+            const primaryStateProps = [
+                { siid: MIOT_PROPERTIES.deviceStatus.siid, piid: MIOT_PROPERTIES.deviceStatus.piid },
+                { siid: MIOT_PROPERTIES.operatingMode.siid, piid: MIOT_PROPERTIES.operatingMode.piid },
+            ];
+            const secondaryStateProps = [
+                { siid: MIOT_PROPERTIES.suctionLevel.siid, piid: MIOT_PROPERTIES.suctionLevel.piid },
+            ];
+            const hasPrimaryStateProps = props.some((p) => primaryStateProps.some((r) => r.siid === p.siid && r.piid === p.piid));
+            const hasSecondaryStateProps = props.some((p) => secondaryStateProps.some((r) => r.siid === p.siid && r.piid === p.piid));
+            if (hasSecondaryStateProps && !hasPrimaryStateProps) {
+                this.log.info(`Detected suctionLevel change without state update - triggering status poll for ${did}`);
+                this.getDeviceProperties(did)
+                    .then((freshStatus) => {
+                    if (freshStatus) {
+                        this.log.info(`Poll returned fresh status: state=${freshStatus.state}, status=${freshStatus.status}`);
+                        const callback = this.deviceStatusCallbacks.get(did);
+                        callback?.(freshStatus);
+                    }
+                    return undefined;
+                })
+                    .catch((e) => this.log.debug(`Status poll failed: ${e}`));
+                return null;
+            }
+            if (!hasPrimaryStateProps && !hasSecondaryStateProps) {
+                const batteryProp = props.find((p) => p.siid === MIOT_PROPERTIES.batteryLevel.siid && p.piid === MIOT_PROPERTIES.batteryLevel.piid);
+                if (batteryProp && typeof batteryProp.value === 'number') {
+                    const cached = this.cachedStatus.get(did);
+                    if (cached) {
+                        cached.battery = batteryProp.value;
+                        this.cachedStatus.set(did, cached);
+                        this.log.debug(`Updated cached battery to ${batteryProp.value}% (no state change)`);
+                    }
+                }
+                return null;
+            }
+            const getValue = (siid, piid) => {
+                const prop = props.find((p) => p.siid === siid && p.piid === piid);
+                return prop?.value;
+            };
+            const cached = this.cachedStatus.get(did) || {
+                state: MovaState.Unknown,
+                status: MovaStatus.Unknown,
+                battery: 0,
+                fanSpeed: MovaFanSpeed.Standard,
+                waterFlow: MovaWaterFlow.Medium,
+                cleaningMode: undefined,
+                errorCode: MovaErrorCode.None,
+            };
+            const newStatus = {
+                state: getValue(MIOT_PROPERTIES.operatingMode.siid, MIOT_PROPERTIES.operatingMode.piid) ?? cached.state,
+                status: getValue(MIOT_PROPERTIES.deviceStatus.siid, MIOT_PROPERTIES.deviceStatus.piid) ?? cached.status,
+                battery: getValue(MIOT_PROPERTIES.batteryLevel.siid, MIOT_PROPERTIES.batteryLevel.piid) ?? cached.battery,
+                fanSpeed: getValue(MIOT_PROPERTIES.suctionLevel.siid, MIOT_PROPERTIES.suctionLevel.piid) ?? cached.fanSpeed,
+                waterFlow: getValue(MIOT_PROPERTIES.waterFlow.siid, MIOT_PROPERTIES.waterFlow.piid) ?? cached.waterFlow,
+                cleaningMode: getValue(MIOT_PROPERTIES.cleaningMode.siid, MIOT_PROPERTIES.cleaningMode.piid) ?? cached.cleaningMode,
+                errorCode: getValue(MIOT_PROPERTIES.deviceFault.siid, MIOT_PROPERTIES.deviceFault.piid) ?? cached.errorCode,
+            };
+            this.cachedStatus.set(did, newStatus);
+            this.log.debug(`Device ${did} raw values: state=${newStatus.state}, status=${newStatus.status}`);
+            return newStatus;
+        }
+        catch {
+            return null;
+        }
+    }
+    async sendCommand(did, method, params = []) {
+        return this.sendCloudCommand(did, method, params);
+    }
+    async sendCloudCommand(did, method, params) {
+        const id = ++this.messageId;
+        let formattedParams;
+        if (method === 'action' && Array.isArray(params) && params.length >= 2) {
+            formattedParams = {
+                did,
+                siid: params[0],
+                aiid: params[1],
+                in: params[2] || [],
+            };
+        }
+        else if (method === 'set_properties' && Array.isArray(params)) {
+            formattedParams = params.map((p) => {
+                const prop = p;
+                return { did, siid: prop.siid, piid: prop.piid, value: prop.value };
+            });
+        }
+        else {
+            formattedParams = params;
+        }
+        const requestBody = {
+            did,
+            id,
+            data: {
+                did,
+                id,
+                method,
+                params: formattedParams,
+            },
+        };
+        this.log.info(`Sending cloud command: ${method}`);
+        this.log.debug(`Request body: ${JSON.stringify(requestBody)}`);
+        const response = await this.apiCall(getMovaSendCommandEndpoint(this.deviceBindDomains.get(did)), 'POST', requestBody);
+        this.log.info(`Cloud command ${method} response: code=${response?.code}, msg=${response?.msg}, data=${JSON.stringify(response?.data)}`);
+        if (response?.code !== 0) {
+            this.log.error(`Cloud command ${method} failed: code=${response?.code}, msg=${response?.msg}`);
+        }
+        return response?.data;
+    }
+    onDeviceStatus(did, callback) {
+        this.deviceStatusCallbacks.set(did, callback);
+    }
+    async confirmCommandSuccess(did, expectedStates, expectedStatuses, maxAttempts = 5, pollIntervalMs = 2000) {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            const status = await this.getDeviceProperties(did);
+            if (!status) {
+                this.log.debug(`Confirmation poll ${attempt}/${maxAttempts}: failed to get status`);
+                continue;
+            }
+            const stateMatch = expectedStates.includes(status.state);
+            const statusMatch = !expectedStatuses || expectedStatuses.includes(status.status);
+            if (stateMatch && statusMatch) {
+                this.log.info(`Command confirmed: state=${status.state}, status=${status.status}`);
+                return true;
+            }
+            this.log.debug(`Confirmation poll ${attempt}/${maxAttempts}: state=${status.state}, status=${status.status} (expected states: ${expectedStates.join(',')})`);
+        }
+        this.log.warn(`Command confirmation failed after ${maxAttempts} attempts`);
+        return false;
+    }
+    async startCleaning(did, cleaningMode, fanSpeed, confirm = false) {
+        try {
+            if (cleaningMode !== undefined) {
+                await this.setCleaningMode(did, cleaningMode);
+            }
+            if (fanSpeed !== undefined) {
+                await this.setSuctionLevel(did, fanSpeed);
+            }
+            await this.sendCommand(did, 'action', [MIOT_ACTIONS.startClean.siid, MIOT_ACTIONS.startClean.aiid, []]);
+            if (confirm) {
+                return this.confirmCommandSuccess(did, [MovaState.Cleaning, MovaState.Mopping, MovaState.ZonedCleaning, MovaState.ManualCleaning]);
+            }
+            return true;
+        }
+        catch (error) {
+            this.log.error(`Failed to start cleaning: ${error}`);
+            return false;
+        }
+    }
+    async stopCleaning(did, confirm = false) {
+        try {
+            await this.sendCommand(did, 'action', [MIOT_ACTIONS.stopClean.siid, MIOT_ACTIONS.stopClean.aiid, []]);
+            if (confirm) {
+                return this.confirmCommandSuccess(did, [MovaState.Idle, MovaState.Paused, MovaState.Dormant]);
+            }
+            return true;
+        }
+        catch (error) {
+            this.log.error(`Failed to stop cleaning: ${error}`);
+            return false;
+        }
+    }
+    async pauseCleaning(did, confirm = false) {
+        try {
+            await this.sendCommand(did, 'action', [MIOT_ACTIONS.pauseClean.siid, MIOT_ACTIONS.pauseClean.aiid, []]);
+            if (confirm) {
+                return this.confirmCommandSuccess(did, [MovaState.Paused], [MovaStatus.Paused]);
+            }
+            return true;
+        }
+        catch (error) {
+            this.log.error(`Failed to pause cleaning: ${error}`);
+            return false;
+        }
+    }
+    async resumeCleaning(did, confirm = false) {
+        try {
+            await this.sendCommand(did, 'action', [MIOT_ACTIONS.startClean.siid, MIOT_ACTIONS.startClean.aiid, []]);
+            if (confirm) {
+                return this.confirmCommandSuccess(did, [MovaState.Cleaning, MovaState.Mopping, MovaState.ZonedCleaning, MovaState.ManualCleaning]);
+            }
+            return true;
+        }
+        catch (error) {
+            this.log.error(`Failed to resume cleaning: ${error}`);
+            return false;
+        }
+    }
+    async goHome(did, confirm = false) {
+        try {
+            await this.sendCommand(did, 'action', [MIOT_ACTIONS.charge.siid, MIOT_ACTIONS.charge.aiid, []]);
+            if (confirm) {
+                return this.confirmCommandSuccess(did, [MovaState.Returning, MovaState.GoCharging, MovaState.Charging, MovaState.Idle], [MovaStatus.BackHome, MovaStatus.Charging, MovaStatus.Standby]);
+            }
+            return true;
+        }
+        catch (error) {
+            this.log.error(`Failed to send vacuum home: ${error}`);
+            return false;
+        }
+    }
+    async locate(did) {
+        try {
+            await this.sendCommand(did, 'action', [MIOT_ACTIONS.locate.siid, MIOT_ACTIONS.locate.aiid, []]);
+            return true;
+        }
+        catch (error) {
+            this.log.error(`Failed to locate vacuum: ${error}`);
+            return false;
+        }
+    }
+    async cleanRooms(did, roomIds, repeat = 1, cleaningMode = MovaCleaningMode.SweepingAndMopping, fanSpeed) {
+        try {
+            await this.setCleaningMode(did, cleaningMode);
+            if (fanSpeed !== undefined) {
+                await this.setSuctionLevel(did, fanSpeed);
+            }
+            const suctionLevel = fanSpeed ?? MovaFanSpeed.Standard;
+            const waterLevel = this.roomWaterLevelForCleaningMode(cleaningMode);
+            const segmentData = JSON.stringify({
+                selects: roomIds.map((id, index) => [id, repeat, suctionLevel, waterLevel, index + 1]),
+            });
+            this.log.info(`Starting room clean for ${roomIds.join(', ')} (mode=${cleaningMode}, fan=${suctionLevel})`);
+            this.log.debug(`Segment data: ${segmentData}`);
+            const payload = [
+                { piid: MIOT_ACTION_PARAMS.status, value: MOVA_STATUS_VALUES.segmentCleaning },
+                { piid: MIOT_ACTION_PARAMS.cleaningProperties, value: segmentData },
+            ];
+            await this.sendCommand(did, 'action', [MIOT_ACTIONS.startCustom.siid, MIOT_ACTIONS.startCustom.aiid, payload]);
+            return true;
+        }
+        catch (error) {
+            this.log.error(`Failed to clean rooms: ${error}`);
+            return false;
+        }
+    }
+    async setCleaningMode(did, cleaningMode) {
+        this.log.info(`Setting cleaning mode to ${cleaningMode}`);
+        await this.sendCommand(did, 'set_properties', [
+            {
+                siid: MIOT_PROPERTIES.cleaningMode.siid,
+                piid: MIOT_PROPERTIES.cleaningMode.piid,
+                value: cleaningMode,
+            },
+        ]);
+    }
+    roomWaterLevelForCleaningMode(cleaningMode) {
+        return cleaningMode === MovaCleaningMode.SweepingAndMopping ? 0 : 2;
+    }
+    async setSuctionLevel(did, fanSpeed) {
+        this.log.info(`Setting suction level to ${fanSpeed} (0=quiet, 1=standard, 2=strong, 3=turbo)`);
+        await this.sendCommand(did, 'set_properties', [
+            {
+                siid: MIOT_PROPERTIES.suctionLevel.siid,
+                piid: MIOT_PROPERTIES.suctionLevel.piid,
+                value: fanSpeed,
+            },
+        ]);
+    }
+    async disconnect() {
+        for (const [did, client] of this.mqttClients) {
+            this.log.info(`Disconnecting from ${did}`);
+            client.end();
+        }
+        this.mqttClients.clear();
+        this.pendingRequests.clear();
+        this.deviceStatusCallbacks.clear();
+        this.cachedStatus.clear();
+        this.cachedRooms.clear();
+        this.deviceModels.clear();
+        this.deviceOwnerIds.clear();
+        this.deviceBindDomains.clear();
+        this.session = null;
+    }
+}