matterbridge-roborock-vacuum-plugin 1.1.0-rc10 → 1.1.0-rc11

package/dist/platform.js

@@ -140,7 +140,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             if (!configurateSuccess.get(duid)) {
                 continue;
             }
-            await this.roborockService.activateDeviceNotify(robot.device);
+            this.roborockService.activateDeviceNotify(robot.device);
         }
         await this.platformRunner?.requestHomeData();
         this.log.info('onConfigurateDevice finished');
@@ -196,7 +196,4 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
         this.log.logLevel = logLevel;
         return Promise.resolve();
     }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
 }

package/dist/roborockCommunication/RESTAPI/roborockIoTApi.js

@@ -81,4 +81,15 @@ export class RoborockIoTApi {
             return undefined;
         }
     }
+    async getCustom(url) {
+        const result = await this.api.get(url);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to execute scene');
+            return undefined;
+        }
+    }
 }

package/dist/roborockCommunication/Zmodel/mapInfo.js

@@ -6,12 +6,14 @@ export class MapInfo {
             this.maps.push({
                 id: map.mapFlag,
                 name: decodeComponent(map.name)?.toLowerCase(),
-                rooms: map.rooms.map((room) => {
-                    return {
-                        id: room.iot_name_id,
-                        name: room.iot_name,
-                    };
-                }),
+                rooms: map.rooms && map.rooms.length > 0
+                    ? map.rooms.map((room) => {
+                        return {
+                            id: room.iot_name_id,
+                            name: room.iot_name,
+                        };
+                    })
+                    : [],
             });
         });
     }

package/dist/roborockCommunication/broadcast/abstractClient.js

@@ -29,8 +29,15 @@ export class AbstractClient {
     }
     async get(duid, request) {
         return new Promise((resolve, reject) => {
-            this.syncMessageListener.waitFor(request.messageId, (response) => resolve(response), reject);
+            this.syncMessageListener.waitFor(request.messageId, request, (response) => resolve(response), reject);
             this.send(duid, request);
+        })
+            .then((result) => {
+            return result;
+        })
+            .catch((error) => {
+            this.logger.error(error.message);
+            return undefined;
         });
     }
     registerDevice(duid, localKey, pv) {

package/dist/roborockCommunication/broadcast/listener/implementation/syncMessageListener.js

@@ -1,3 +1,4 @@
+import { debugStringify } from 'matterbridge/logger';
 import { Protocol } from '../../model/protocol.js';
 export class SyncMessageListener {
     pending = new Map();
@@ -5,11 +6,11 @@ export class SyncMessageListener {
     constructor(logger) {
         this.logger = logger;
     }
-    waitFor(messageId, resolve, reject) {
+    waitFor(messageId, request, resolve, reject) {
         this.pending.set(messageId, resolve);
         setTimeout(() => {
             this.pending.delete(messageId);
-            reject();
+            reject(new Error(`Message timeout for messageId: ${messageId}, request: ${debugStringify(request)}`));
         }, 10000);
     }
     async onMessage(message) {

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -25,12 +25,15 @@ export class MessageProcessor {
     async getDeviceStatus(duid) {
         const request = new RequestMessage({ method: 'get_status' });
         const response = await this.client.get(duid, request);
-        this.logger?.debug('Device status: ', debugStringify(response));
-        return new DeviceStatus(response);
+        if (response) {
+            this.logger?.debug('Device status: ', debugStringify(response));
+            return new DeviceStatus(response);
+        }
+        return undefined;
     }
     async getRooms(duid, rooms) {
         const request = new RequestMessage({ method: 'get_room_mapping' });
-        return this.client.get(duid, request).then((response) => new RoomInfo(rooms, response));
+        return this.client.get(duid, request).then((response) => new RoomInfo(rooms, response ?? []));
     }
     async gotoDock(duid) {
         const request = new RequestMessage({ method: 'app_charge' });

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -8,6 +8,7 @@ export class MessageDeserializer {
     context;
     messageParser;
     logger;
+    supportedVersions = ['1.0', 'A01', 'B01'];
     constructor(context, logger) {
         this.context = context;
         this.logger = logger;
@@ -28,7 +29,7 @@ export class MessageDeserializer {
     }
     deserialize(duid, message) {
         const version = message.toString('latin1', 0, 3);
-        if (version !== '1.0' && version !== 'A01') {
+        if (!this.supportedVersions.includes(version)) {
             throw new Error('unknown protocol version ' + version);
         }
         const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
@@ -52,6 +53,11 @@ export class MessageDeserializer {
             const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
             data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
         }
+        else if (version == 'B01') {
+            const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+            const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
+            data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+        }
         if (data.protocol == Protocol.map_response) {
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }

package/dist/roborockCommunication/helper/messageSerializer.js

@@ -54,6 +54,12 @@ export class MessageSerializer {
             const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
             encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
         }
+        else if (version == 'B01') {
+            const encoder = new TextEncoder();
+            const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+            const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
+            encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+        }
         else {
             throw new Error('unable to build the message: unsupported protocol version: ' + version);
         }

package/dist/roborockService.js

@@ -15,12 +15,14 @@ export default class RoborockService {
     messageProcessorMap = new Map();
     ipMap = new Map();
     localClientMap = new Map();
+    mqttAlwaysOnDevices = new Map();
     clientManager;
     refreshInterval;
     requestDeviceStatusInterval;
     supportedAreas = new Map();
     supportedRoutines = new Map();
     selectedAreas = new Map();
+    vacuumNeedAPIV3 = ['roborock.vacuum.ss07'];
     constructor(authenticateApiSupplier = (logger) => new RoborockAuthenticateApi(logger), iotApiSupplier = (logger, ud) => new RoborockIoTApi(ud, logger), refreshInterval, clientManager, logger) {
         this.logger = logger;
         this.loginApi = authenticateApiSupplier(logger);
@@ -77,7 +79,8 @@ export default class RoborockService {
         this.logger.debug('RoborockService - getMapInformation', duid);
         assert(this.messageClient !== undefined);
         return this.messageClient.get(duid, new RequestMessage({ method: 'get_multi_maps_list' })).then((response) => {
-            return new MapInfo(response[0]);
+            this.logger.debug('RoborockService - getMapInformation response', debugStringify(response ?? []));
+            return response ? new MapInfo(response[0]) : undefined;
         });
     }
     async changeCleanMode(duid, { suctionPower, waterFlow, distance_off, mopRoute }) {
@@ -147,6 +150,17 @@ export default class RoborockService {
     async customSend(duid, request) {
         return this.getMessageProcessor(duid)?.sendCustomMessage(duid, request);
     }
+    async getCustomAPI(url) {
+        this.logger.debug('RoborockService - getCustomAPI', url);
+        assert(this.iotApi !== undefined);
+        try {
+            return await this.iotApi.getCustom(url);
+        }
+        catch (error) {
+            this.logger.error(`Failed to get custom API with url ${url}: ${error ? debugStringify(error) : 'undefined'}`);
+            return { result: undefined, error: `Failed to get custom API with url ${url}` };
+        }
+    }
     stopService() {
         if (this.messageClient) {
             this.messageClient.disconnect();
@@ -175,14 +189,14 @@ export default class RoborockService {
     setDeviceNotify(callback) {
         this.deviceNotify = callback;
     }
-    async activateDeviceNotify(device) {
+    activateDeviceNotify(device) {
         const self = this;
         this.logger.debug('Requesting device info for device', device.duid);
         const messageProcessor = this.getMessageProcessor(device.duid);
         this.requestDeviceStatusInterval = setInterval(async () => {
             if (messageProcessor) {
                 await messageProcessor.getDeviceStatus(device.duid).then((response) => {
-                    if (self.deviceNotify) {
+                    if (self.deviceNotify && response) {
                         const message = { duid: device.duid, ...response.errorStatus, ...response.message };
                         self.logger.debug('Device status update', debugStringify(message));
                         self.deviceNotify(NotifyMessageTypes.LocalMessage, message);
@@ -208,6 +222,15 @@ export default class RoborockService {
         const scenes = (await this.iotApi.getScenes(homeDetails.rrHomeId)) ?? [];
         const products = new Map();
         homeData.products.forEach((p) => products.set(p.id, p.model));
+        if (homeData.products.some((p) => this.vacuumNeedAPIV3.includes(p.model))) {
+            this.logger.debug('Using v3 API for home data retrieval');
+            const homeDataV3 = await this.iotApi.getHomev3(homeDetails.rrHomeId);
+            if (!homeDataV3) {
+                throw new Error('Failed to retrieve the home data from v3 API');
+            }
+            homeData.devices = [...homeData.devices, ...homeDataV3.devices.filter((d) => !homeData.devices.some((x) => x.duid === d.duid))];
+            homeData.receivedDevices = [...homeData.receivedDevices, ...homeDataV3.receivedDevices.filter((d) => !homeData.receivedDevices.some((x) => x.duid === d.duid))];
+        }
         if (homeData.rooms.length === 0) {
             const homeDataV2 = await this.iotApi.getHomev2(homeDetails.rrHomeId);
             if (homeDataV2 && homeDataV2.rooms && homeDataV2.rooms.length > 0) {
@@ -237,6 +260,7 @@ export default class RoborockService {
                     model: homeData.products.find((p) => p.id === device.productId)?.model,
                     category: homeData.products.find((p) => p.id === device.productId)?.category,
                     batteryLevel: device.deviceStatus?.[Protocol.battery] ?? 100,
+                    schema: homeData.products.find((p) => p.id === device.productId)?.schema,
                 },
                 store: {
                     username: username,
@@ -259,6 +283,18 @@ export default class RoborockService {
         const products = new Map();
         homeData.products.forEach((p) => products.set(p.id, p.model));
         const devices = homeData.devices.length > 0 ? homeData.devices : homeData.receivedDevices;
+        if (homeData.rooms.length === 0) {
+            const homeDataV3 = await this.iotApi.getHomev3(homeid);
+            if (homeDataV3 && homeDataV3.rooms && homeDataV3.rooms.length > 0) {
+                homeData.rooms = homeDataV3.rooms;
+            }
+            else {
+                const homeDataV1 = await this.iotApi.getHome(homeid);
+                if (homeDataV1 && homeDataV1.rooms && homeDataV1.rooms.length > 0) {
+                    homeData.rooms = homeDataV1.rooms;
+                }
+            }
+        }
         const dvs = devices.map((device) => {
             return {
                 ...device,
@@ -272,6 +308,7 @@ export default class RoborockService {
                     model: homeData.products.find((p) => p.id === device.productId)?.model,
                     category: homeData.products.find((p) => p.id === device.productId)?.category,
                     batteryLevel: device.deviceStatus?.[Protocol.battery] ?? 100,
+                    schema: homeData.products.find((p) => p.id === device.productId)?.schema,
                 },
                 store: {
                     userData: this.userdata,
@@ -297,9 +334,9 @@ export default class RoborockService {
     getRoomMappings(duid) {
         if (!this.messageClient) {
             this.logger.warn('messageClient not initialized. Waititing for next execution');
-            return undefined;
+            return Promise.resolve(undefined);
         }
-        return this.messageClient.get(duid, new RequestMessage({ method: 'get_room_mapping' }));
+        return this.messageClient.get(duid, new RequestMessage({ method: 'get_room_mapping', secure: this.isRequestSecure(duid) }));
     }
     async initializeMessageClient(username, device, userdata) {
         if (this.clientManager === undefined) {
@@ -351,6 +388,15 @@ export default class RoborockService {
             },
         });
         this.messageProcessorMap.set(device.duid, messageProcessor);
+        this.logger.debug('Checking if device supports local connection', device.pv, device.data.model, device.duid);
+        if (device.pv === 'B01') {
+            this.logger.warn('Device does not support local connection', device.duid);
+            this.mqttAlwaysOnDevices.set(device.duid, true);
+            return true;
+        }
+        else {
+            this.mqttAlwaysOnDevices.set(device.duid, false);
+        }
         this.logger.debug('Local device', device.duid);
         let localIp = this.ipMap.get(device.duid);
         try {
@@ -389,7 +435,7 @@ export default class RoborockService {
         return true;
     }
     onLocalClientDisconnect(duid) {
-        this.logger.debug('Local client disconnected for device', duid);
+        this.mqttAlwaysOnDevices.set(duid, true);
     }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
@@ -399,4 +445,7 @@ export default class RoborockService {
         this.iotApi = this.iotApiFactory(this.logger, userdata);
         return userdata;
     }
+    isRequestSecure(duid) {
+        return this.mqttAlwaysOnDevices.get(duid) ?? false;
+    }
 }

package/eslint.config.js

@@ -9,7 +9,7 @@ import eslintPluginN from 'eslint-plugin-n';
 export default [
   {
     name: 'global ignores',
-    ignores: ['dist/', 'build/', 'node_modules/', 'coverage/', 'frontend/', 'rock-s0/', 'webui/', 'exampleData/', '.shouldnotcommit/'],
+    ignores: ['dist/', 'build/', 'node_modules/', 'coverage/', 'frontend/', 'rock-s0/', 'webui/', 'exampleData/', '.shouldnotcommit/', 'web-for-testing/'],
   },
   eslint.configs.recommended,
   ...tseslint.configs.strict,

package/matterbridge-roborock-vacuum-plugin.config.json

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.0-rc10",
+  "version": "1.1.0-rc11",
   "whiteList": [],
   "blackList": [],
   "useInterval": true,

package/matterbridge-roborock-vacuum-plugin.schema.json

@@ -1,6 +1,6 @@
 {
   "title": "Matterbridge Roborock Vacuum Plugin",
-  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc10 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc11 by https://github.com/RinDevJunior",
   "type": "object",
   "required": ["username", "password"],
   "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.1.0-rc10",
+  "version": "1.1.0-rc11",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",

package/src/platform.ts

@@ -199,7 +199,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
       if (!configurateSuccess.get(duid)) {
         continue;
       }
-      await this.roborockService.activateDeviceNotify(robot.device);
+      this.roborockService.activateDeviceNotify(robot.device);
     }
 
     await this.platformRunner?.requestHomeData();
@@ -279,8 +279,4 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     this.log.logLevel = logLevel;
     return Promise.resolve();
   }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
 }

package/src/roborockCommunication/RESTAPI/roborockIoTApi.ts

@@ -46,7 +46,7 @@ export class RoborockIoTApi {
   }
 
   public async getHomev2(homeId: number): Promise<Home | undefined> {
-    const result = await this.api.get('v2/user/homes/' + homeId); // can be v3 also
+    const result = await this.api.get('v2/user/homes/' + homeId);
 
     const apiResponse: ApiResponse<Home> = result.data;
     if (apiResponse.result) {
@@ -92,4 +92,16 @@ export class RoborockIoTApi {
       return undefined;
     }
   }
+
+  public async getCustom(url: string): Promise<unknown> {
+    const result = await this.api.get(url);
+    const apiResponse: ApiResponse<unknown> = result.data;
+
+    if (apiResponse.result) {
+      return apiResponse.result;
+    } else {
+      this.logger.error('Failed to execute scene');
+      return undefined;
+    }
+  }
 }

package/src/roborockCommunication/Zmodel/device.ts

@@ -36,6 +36,7 @@ export interface Device {
     model: string;
     category: string;
     batteryLevel: number;
+    // schema: DeviceSchema[];
   };
 
   scenes: Scene[];

package/src/roborockCommunication/Zmodel/mapInfo.ts

@@ -11,12 +11,15 @@ export class MapInfo {
       this.maps.push({
         id: map.mapFlag,
         name: decodeComponent(map.name)?.toLowerCase(),
-        rooms: map.rooms.map((room: RoomInformation) => {
-          return {
-            id: room.iot_name_id,
-            name: room.iot_name,
-          } as unknown as Room;
-        }),
+        rooms:
+          map.rooms && map.rooms.length > 0
+            ? map.rooms.map((room: RoomInformation) => {
+                return {
+                  id: room.iot_name_id,
+                  name: room.iot_name,
+                } as unknown as Room;
+              })
+            : [],
       });
     });
   }

package/src/roborockCommunication/Zmodel/userData.ts

@@ -7,9 +7,6 @@ export interface UserData {
   country: string;
   nickname: string;
   rriot: Rriot;
-
-  // For caching purposes
-  baseUrl: string;
 }
 
 export interface Rriot {

package/src/roborockCommunication/broadcast/abstractClient.ts

@@ -49,11 +49,18 @@ export abstract class AbstractClient implements Client {
   abstract disconnect(): Promise<void>;
   abstract send(duid: string, request: RequestMessage): Promise<void>;
 
-  public async get<T>(duid: string, request: RequestMessage): Promise<T> {
+  public async get<T>(duid: string, request: RequestMessage): Promise<T | undefined> {
     return new Promise<T>((resolve, reject) => {
-      this.syncMessageListener.waitFor(request.messageId, (response: ResponseMessage) => resolve(response as unknown as T), reject);
+      this.syncMessageListener.waitFor(request.messageId, request, (response: ResponseMessage) => resolve(response as unknown as T), reject);
       this.send(duid, request);
-    });
+    })
+      .then((result: T) => {
+        return result;
+      })
+      .catch((error: Error) => {
+        this.logger.error(error.message);
+        return undefined;
+      });
   }
 
   public registerDevice(duid: string, localKey: string, pv: string): void {

package/src/roborockCommunication/broadcast/client.ts

@@ -15,5 +15,5 @@ export interface Client {
 
   send(duid: string, request: RequestMessage): Promise<void>;
 
-  get<T>(duid: string, request: RequestMessage): Promise<T>;
+  get<T>(duid: string, request: RequestMessage): Promise<T | undefined>;
 }

package/src/roborockCommunication/broadcast/clientRouter.ts

@@ -81,7 +81,7 @@ export class ClientRouter implements Client {
     }
   }
 
-  async get<T>(duid: string, request: RequestMessage): Promise<T> {
+  async get<T>(duid: string, request: RequestMessage): Promise<T | undefined> {
     if (request.secure) {
       return await this.mqttClient.get(duid, request);
     } else {

package/src/roborockCommunication/broadcast/listener/implementation/syncMessageListener.ts

@@ -1,8 +1,9 @@
-import { AnsiLogger } from 'matterbridge/logger';
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 import { DpsPayload } from '../../model/dps.js';
 import { Protocol } from '../../model/protocol.js';
 import { ResponseMessage } from '../../model/responseMessage.js';
 import { AbstractMessageListener } from '../index.js';
+import { RequestMessage } from '../../model/requestMessage.js';
 
 export class SyncMessageListener implements AbstractMessageListener {
   private readonly pending = new Map<number, (response: ResponseMessage) => void>();
@@ -12,12 +13,12 @@ export class SyncMessageListener implements AbstractMessageListener {
     this.logger = logger;
   }
 
-  public waitFor(messageId: number, resolve: (response: ResponseMessage) => void, reject: () => void): void {
+  public waitFor(messageId: number, request: RequestMessage, resolve: (response: ResponseMessage) => void, reject: (error?: Error) => void): void {
     this.pending.set(messageId, resolve);
 
     setTimeout(() => {
       this.pending.delete(messageId);
-      reject();
+      reject(new Error(`Message timeout for messageId: ${messageId}, request: ${debugStringify(request)}`));
     }, 10000);
   }
 

package/src/roborockCommunication/broadcast/messageProcessor.ts

@@ -29,7 +29,7 @@ export class MessageProcessor {
     this.messageListener.registerListener(listener);
   }
 
-  public async getNetworkInfo(duid: string): Promise<NetworkInfo> {
+  public async getNetworkInfo(duid: string): Promise<NetworkInfo | undefined> {
     const request = new RequestMessage({ method: 'get_network_info' });
     return await this.client.get(duid, request);
   }
@@ -39,17 +39,21 @@ export class MessageProcessor {
   //   return this.client.get<CloudMessageResult[]>(duid, request).then((response) => new DeviceStatus(response[0]));
   // }
 
-  public async getDeviceStatus(duid: string): Promise<DeviceStatus> {
+  public async getDeviceStatus(duid: string): Promise<DeviceStatus | undefined> {
     const request = new RequestMessage({ method: 'get_status' });
     const response = await this.client.get<CloudMessageResult[]>(duid, request);
 
-    this.logger?.debug('Device status: ', debugStringify(response));
-    return new DeviceStatus(response);
+    if (response) {
+      this.logger?.debug('Device status: ', debugStringify(response));
+      return new DeviceStatus(response);
+    }
+
+    return undefined;
   }
 
   public async getRooms(duid: string, rooms: Room[]): Promise<RoomInfo> {
     const request = new RequestMessage({ method: 'get_room_mapping' });
-    return this.client.get<number[][]>(duid, request).then((response) => new RoomInfo(rooms, response));
+    return this.client.get<number[][] | undefined>(duid, request).then((response) => new RoomInfo(rooms, response ?? []));
   }
 
   public async gotoDock(duid: string): Promise<void> {

package/src/roborockCommunication/helper/messageDeserializer.ts

@@ -23,6 +23,7 @@ export class MessageDeserializer {
   private readonly context: MessageContext;
   private readonly messageParser: Parser;
   private readonly logger: AnsiLogger;
+  private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
 
   constructor(context: MessageContext, logger: AnsiLogger) {
     this.context = context;
@@ -46,7 +47,7 @@ export class MessageDeserializer {
 
   public deserialize(duid: string, message: Buffer<ArrayBufferLike>): ResponseMessage {
     const version = message.toString('latin1', 0, 3);
-    if (version !== '1.0' && version !== 'A01') {
+    if (!this.supportedVersions.includes(version)) {
       throw new Error('unknown protocol version ' + version);
     }
 
@@ -71,6 +72,11 @@ export class MessageDeserializer {
       const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
       const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
       data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+    } else if (version == 'B01') {
+      const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+      const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
+      // unpad ??
+      data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
     }
 
     // map visualization not support

package/src/roborockCommunication/helper/messageSerializer.ts

@@ -66,6 +66,12 @@ export class MessageSerializer {
       const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
       const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
       encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+    } else if (version == 'B01') {
+      const encoder = new TextEncoder();
+      const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+      const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
+      // pad ??
+      encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
     } else {
       throw new Error('unable to build the message: unsupported protocol version: ' + version);
     }