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

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

@@ -0,0 +1,50 @@
+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>();
+  logger: AnsiLogger;
+
+  constructor(logger: AnsiLogger) {
+    this.logger = logger;
+  }
+
+  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(new Error(`Message timeout for messageId: ${messageId}, request: ${debugStringify(request)}`));
+    }, 10000);
+  }
+
+  public async onMessage(message: ResponseMessage): Promise<void> {
+    if (message.contain(Protocol.rpc_response)) {
+      const dps = message.get(Protocol.rpc_response) as DpsPayload;
+      const messageId = dps.id;
+
+      const responseHandler = this.pending.get(messageId);
+      // const result = dps.result as Record<string, unknown>;
+      // if (result && result.length == 1 && result[0] == 'ok') {
+      //   return;
+      // }
+
+      if (responseHandler) {
+        responseHandler(dps.result as ResponseMessage);
+      }
+      this.pending.delete(messageId);
+      return;
+    }
+
+    // map data
+    if (message.contain(Protocol.map_response)) {
+      const dps = message.get(Protocol.map_response) as DpsPayload;
+      this.pending.delete(dps.id);
+      return;
+    }
+  }
+}

package/src/roborockCommunication/broadcast/listener/index.ts

@@ -0,0 +1,3 @@
+export type { AbstractConnectionListener } from './abstractConnectionListener.js';
+export type { AbstractMessageListener } from './abstractMessageListener.js';
+export { SimpleMessageListener } from './implementation/simpleMessageListener.js';

package/src/roborockCommunication/broadcast/messageProcessor.ts

@@ -0,0 +1,184 @@
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
+import { CloudMessageResult } from '../Zmodel/messageResult.js';
+import { AbstractMessageHandler } from './listener/abstractMessageHandler.js';
+import { SimpleMessageListener } from './listener/index.js';
+import { RequestMessage } from './model/requestMessage.js';
+import { DeviceStatus } from '../Zmodel/deviceStatus.js';
+import { Client } from './client.js';
+import { NetworkInfo } from '../Zmodel/networkInfo.js';
+import { CleanModeSetting } from '../../behaviors/roborock.vacuum/default/default.js';
+
+export class MessageProcessor {
+  private readonly client: Client;
+  private readonly messageListener: SimpleMessageListener;
+  logger: AnsiLogger | undefined;
+
+  constructor(client: Client) {
+    this.client = client;
+
+    this.messageListener = new SimpleMessageListener();
+    this.client.registerMessageListener(this.messageListener);
+  }
+
+  public injectLogger(logger: AnsiLogger): void {
+    this.logger = logger;
+  }
+
+  public registerListener(listener: AbstractMessageHandler): void {
+    this.messageListener.registerListener(listener);
+  }
+
+  public async getNetworkInfo(duid: string): Promise<NetworkInfo | undefined> {
+    const request = new RequestMessage({ method: 'get_network_info' });
+    return await this.client.get(duid, request);
+  }
+
+  public async getDeviceStatus(duid: string): Promise<DeviceStatus | undefined> {
+    const request = new RequestMessage({ method: 'get_status' });
+    const response = await this.client.get<CloudMessageResult[]>(duid, request);
+
+    if (response) {
+      this.logger?.debug('Device status: ', debugStringify(response));
+      return new DeviceStatus(response);
+    }
+
+    return undefined;
+  }
+
+  public async getDeviceStatusOverMQTT(duid: string): Promise<DeviceStatus | undefined> {
+    const request = new RequestMessage({ method: 'get_status', secure: true });
+    const response = await this.client.get<CloudMessageResult[]>(duid, request);
+
+    if (response) {
+      this.logger?.debug('MQTT - Device status: ', debugStringify(response));
+      return new DeviceStatus(response);
+    }
+
+    return undefined;
+  }
+
+  public async getRooms(duid: string): Promise<number[][] | undefined> {
+    const request = new RequestMessage({ method: 'get_room_mapping' });
+    return this.client.get<number[][] | undefined>(duid, request); // .then((response) => new RoomInfo(rooms, response ?? []));
+  }
+
+  public async gotoDock(duid: string): Promise<void> {
+    const request = new RequestMessage({ method: 'app_charge' });
+    return this.client.send(duid, request);
+  }
+
+  public async startClean(duid: string): Promise<void> {
+    const request = new RequestMessage({ method: 'app_start' });
+    return this.client.send(duid, request);
+  }
+
+  public async startRoomClean(duid: string, roomIds: number[], repeat: number): Promise<void> {
+    const request = new RequestMessage({
+      method: 'app_segment_clean',
+      params: [{ segments: roomIds, repeat: repeat }],
+    });
+    return this.client.send(duid, request);
+  }
+
+  public async pauseClean(duid: string): Promise<void> {
+    const request = new RequestMessage({ method: 'app_pause' });
+    return this.client.send(duid, request);
+  }
+
+  public async resumeClean(duid: string): Promise<void> {
+    const request = new RequestMessage({ method: 'app_resume' });
+    return this.client.send(duid, request);
+  }
+
+  public async stopClean(duid: string): Promise<void> {
+    const request = new RequestMessage({ method: 'app_stop' });
+    return this.client.send(duid, request);
+  }
+
+  public async sendCustomMessage(duid: string, def: RequestMessage): Promise<void> {
+    const request = new RequestMessage(def);
+    return this.client.send(duid, request);
+  }
+
+  public getCustomMessage(duid: string, def: RequestMessage): Promise<unknown> {
+    return this.client.get(duid, def);
+  }
+
+  public async findMyRobot(duid: string): Promise<unknown> {
+    const request = new RequestMessage({ method: 'find_me' });
+    return this.client.get(duid, request);
+  }
+
+  public async getCleanModeData(duid: string): Promise<CleanModeSetting> {
+    const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_mop_mode' }));
+    const suctionPowerRaw = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_custom_mode' }));
+    const waterFlowRaw = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_water_box_custom_mode' }));
+
+    let suctionPower: number;
+    let waterFlow: number;
+    let mopRoute: number;
+    let distance_off = 0;
+
+    if (Array.isArray(suctionPowerRaw)) {
+      suctionPower = suctionPowerRaw[0];
+    } else {
+      suctionPower = suctionPowerRaw as number;
+    }
+
+    if (Array.isArray(currentMopMode)) {
+      mopRoute = currentMopMode[0];
+    } else {
+      mopRoute = currentMopMode as number;
+    }
+
+    if (typeof waterFlowRaw === 'object' && waterFlowRaw !== null && 'water_box_mode' in waterFlowRaw) {
+      waterFlow = waterFlowRaw.water_box_mode as number;
+
+      if ('distance_off' in waterFlowRaw) {
+        distance_off = (waterFlowRaw.distance_off as number) ?? 0;
+      }
+    } else {
+      waterFlow = waterFlowRaw as number;
+    }
+
+    return {
+      suctionPower: suctionPower,
+      waterFlow: waterFlow,
+      distance_off: distance_off,
+      mopRoute: mopRoute,
+    } satisfies CleanModeSetting;
+  }
+
+  public async changeCleanMode(duid: string, suctionPower: number, waterFlow: number, mopRoute: number, distance_off: number): Promise<void> {
+    this.logger?.notice(`Change clean mode for ${duid} to suctionPower: ${suctionPower}, waterFlow: ${waterFlow}, mopRoute: ${mopRoute}, distance_off: ${distance_off}`);
+
+    const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_custom_mode' }));
+    const smartMopMode = 110;
+    const smartMopRoute = 306;
+    const customMopMode = 106;
+    const customMopRoute = 302;
+
+    if (currentMopMode == smartMopMode && mopRoute == smartMopRoute) return;
+    if (currentMopMode == customMopMode && mopRoute == customMopRoute) return;
+
+    // if change mode from smart plan, firstly change to custom
+    if (currentMopMode == smartMopMode) {
+      await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [customMopRoute] }));
+    }
+
+    if (suctionPower && suctionPower != 0) {
+      await this.client.send(duid, new RequestMessage({ method: 'set_custom_mode', params: [suctionPower] }));
+    }
+
+    const CustomizeWithDistanceOff = 207;
+    if (waterFlow && waterFlow == CustomizeWithDistanceOff && distance_off && distance_off != 0) {
+      await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: { 'water_box_mode': waterFlow, 'distance_off': distance_off } }));
+    } else if (waterFlow && waterFlow != 0) {
+      await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: [waterFlow] }));
+    }
+
+    if (mopRoute && mopRoute != 0) {
+      await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [mopRoute] }));
+    }
+  }
+}

package/src/roborockCommunication/broadcast/model/contentMessage.ts

@@ -0,0 +1,5 @@
+export interface ContentMessage {
+  payloadLen?: number;
+  payload: Buffer<ArrayBufferLike>;
+  crc32: number;
+}

package/src/roborockCommunication/broadcast/model/dps.ts

@@ -0,0 +1,19 @@
+interface Security {
+  endpoint: string;
+  nonce: string;
+}
+
+export interface DpsPayload {
+  id: number;
+  method?: string;
+  params?: unknown[] | Record<string, unknown> | undefined;
+  security?: Security;
+  result: unknown;
+}
+
+export type Dps = Record<number | string, string | DpsPayload>;
+
+export interface Payload {
+  dps: Dps;
+  t: number;
+}

package/src/roborockCommunication/broadcast/model/headerMessage.ts

@@ -0,0 +1,7 @@
+export interface HeaderMessage {
+  version: string;
+  seq: number;
+  nonce: number;
+  timestamp: number;
+  protocol: number;
+}

package/src/roborockCommunication/broadcast/model/messageContext.ts

@@ -0,0 +1,53 @@
+import { randomBytes, randomInt } from 'node:crypto';
+import * as CryptoUtils from '../../helper/cryptoHelper.js';
+import { UserData } from '../../Zmodel/userData.js';
+
+interface DeviceInfo {
+  localKey: string;
+  protocolVersion: string;
+  nonce: number | undefined;
+}
+
+export class MessageContext {
+  private readonly endpoint: string;
+  private readonly devices = new Map<string, DeviceInfo>();
+  public readonly nonce: number;
+  public readonly serializeNonce: Buffer;
+
+  constructor(userdata: UserData) {
+    this.endpoint = CryptoUtils.md5bin(userdata.rriot.k).subarray(8, 14).toString('base64');
+    this.nonce = randomInt(1000, 1000000);
+    this.serializeNonce = randomBytes(16);
+  }
+
+  public registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined) {
+    this.devices.set(duid, { localKey: localKey, protocolVersion: pv, nonce });
+  }
+
+  public updateNonce(duid: string, nonce: number): void {
+    const device = this.devices.get(duid);
+    if (device) {
+      device.nonce = nonce;
+    }
+  }
+
+  public getSerializeNonceAsHex(): string {
+    return this.serializeNonce.toString('hex').toUpperCase();
+  }
+
+  public getLocalKey(duid: string): string | undefined {
+    return this.devices.get(duid)?.localKey;
+  }
+
+  public getProtocolVersion(duid: string): string | undefined {
+    return this.devices.get(duid)?.protocolVersion;
+  }
+
+  public getDeviceNonce(duid: string): number | undefined {
+    return this.devices.get(duid)?.nonce;
+  }
+
+  public getEndpoint(): string {
+    return this.endpoint;
+  }
+}

package/src/roborockCommunication/broadcast/model/protocol.ts

@@ -0,0 +1,28 @@
+export enum Protocol {
+  hello_request = 0,
+  hello_response = 1,
+  ping_request = 2,
+  ping_response = 3,
+  general_request = 4,
+  general_response = 5,
+  rpc_request = 101,
+  rpc_response = 102,
+  error = 120,
+  status_update = 121,
+  battery = 122,
+  suction_power = 123,
+  water_box_mode = 124,
+  main_brush_work_time = 125,
+  side_brush_work_time = 126,
+  filter_work_time = 127,
+  additional_props = 128,
+  task_complete = 130,
+  task_cancel_low_power = 131,
+  task_cancel_in_motion = 132,
+  charge_status = 133,
+  drying_status = 134,
+  back_type = 139, // WTF is this
+  map_response = 301,
+  some_thing_happened_when_socket_closed = 500,
+}
+// "deviceStatus":{"120":0,"121":8,"122":100,"123":110,"124":209,"125":99,"126":96,"127":97,"128":0,"133":1,"134":1,"135":0,"139":0}

package/src/roborockCommunication/broadcast/model/requestMessage.ts

@@ -0,0 +1,51 @@
+import { Protocol } from './protocol.js';
+import { randomInt } from 'node:crypto';
+
+export interface ProtocolRequest {
+  messageId?: number;
+  protocol?: Protocol;
+  method?: string | undefined;
+  params?: unknown[] | Record<string, unknown> | undefined;
+  secure?: boolean;
+  nonce?: number;
+  timestamp?: number;
+}
+
+export class RequestMessage {
+  public readonly messageId: number;
+  public readonly protocol: Protocol;
+  public readonly method: string | undefined;
+  public readonly params: unknown[] | Record<string, unknown> | undefined;
+  public readonly secure: boolean;
+  public readonly timestamp: number;
+  public readonly nonce: number;
+
+  constructor(args: ProtocolRequest) {
+    this.messageId = args.messageId ?? randomInt(10000, 32767);
+    this.protocol = args.protocol ?? Protocol.rpc_request;
+    this.method = args.method;
+    this.params = args.params;
+    this.secure = args.secure ?? false;
+    this.nonce = args.nonce ?? randomInt(10000, 32767);
+    this.timestamp = args.timestamp ?? Math.floor(Date.now() / 1000);
+  }
+
+  toMqttRequest() {
+    return this;
+  }
+
+  toLocalRequest() {
+    if (this.protocol == Protocol.rpc_request) {
+      return new RequestMessage({
+        messageId: this.messageId,
+        protocol: Protocol.general_request,
+        method: this.method,
+        params: this.params,
+        secure: this.secure,
+        timestamp: this.timestamp,
+      });
+    } else {
+      return this;
+    }
+  }
+}

package/src/roborockCommunication/broadcast/model/responseMessage.ts

@@ -0,0 +1,19 @@
+import { Dps, DpsPayload } from './dps.js';
+
+export class ResponseMessage {
+  readonly duid: string;
+  readonly dps: Dps;
+
+  constructor(duid: string, dps: Dps) {
+    this.duid = duid;
+    this.dps = dps;
+  }
+
+  contain(index: number | string): boolean {
+    return this.dps[index.toString()] !== undefined;
+  }
+
+  get(index: number | string): string | DpsPayload {
+    return this.dps[index.toString()];
+  }
+}

package/src/roborockCommunication/helper/chunkBuffer.ts

@@ -0,0 +1,18 @@
+export class ChunkBuffer {
+  private buffer: Buffer = Buffer.alloc(0);
+
+  get(): Buffer {
+    return this.buffer;
+  }
+  reset(): void {
+    this.buffer = Buffer.alloc(0);
+  }
+
+  append(message: Buffer): void {
+    if (this.buffer.length == 0) {
+      this.buffer = message;
+    } else {
+      this.buffer = Buffer.concat([this.buffer, message]);
+    }
+  }
+}

package/src/roborockCommunication/helper/cryptoHelper.ts

@@ -0,0 +1,30 @@
+import crypto, { CipherKey, BinaryLike } from 'node:crypto';
+
+export function md5bin(str: BinaryLike): Buffer {
+  return crypto.createHash('md5').update(str).digest();
+}
+
+export function md5hex(str: BinaryLike): string {
+  return crypto.createHash('md5').update(str).digest('hex');
+}
+
+export function decryptECB(encrypted: string, aesKey: CipherKey) {
+  const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
+  decipher.setAutoPadding(false);
+  let decrypted = decipher.update(encrypted, 'binary', 'utf8');
+  decrypted += decipher.final('utf8');
+  return removePadding(decrypted);
+}
+
+function removePadding(str: string) {
+  const paddingLength = str.charCodeAt(str.length - 1);
+  return str.slice(0, -paddingLength);
+}
+
+// MessageUtils as plain exports
+export const SALT = 'TXdfu$jyZ#TZHsg4';
+
+export function encodeTimestamp(timestamp: number) {
+  const hex = timestamp.toString(16).padStart(8, '0').split('');
+  return [5, 6, 3, 7, 1, 2, 0, 4].map((idx) => hex[idx]).join('');
+}

package/src/roborockCommunication/helper/messageDeserializer.ts

@@ -0,0 +1,119 @@
+import crypto from 'node:crypto';
+import CRC32 from 'crc-32';
+import { ResponseMessage } from '../broadcast/model/responseMessage.js';
+import * as CryptoUtils from './cryptoHelper.js';
+import { Protocol } from '../broadcast/model/protocol.js';
+import { MessageContext } from '../broadcast/model/messageContext.js';
+import { AnsiLogger } from 'matterbridge/logger';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
+import { ContentMessage } from '../broadcast/model/contentMessage.js';
+import { HeaderMessage } from '../broadcast/model/headerMessage.js';
+import { DpsPayload } from '../broadcast/model/dps.js';
+
+export class MessageDeserializer {
+  private readonly context: MessageContext;
+  private readonly headerMessageParser: Parser;
+  private readonly contentMessageParser: Parser;
+  private readonly logger: AnsiLogger;
+  private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
+
+  constructor(context: MessageContext, logger: AnsiLogger) {
+    this.context = context;
+    this.logger = logger;
+
+    this.headerMessageParser = new Parser()
+      .endianness('big')
+      .string('version', {
+        length: 3,
+      })
+      .uint32('seq')
+      .uint32('nonce')
+      .uint32('timestamp')
+      .uint16('protocol');
+
+    this.contentMessageParser = new Parser()
+      .endianness('big')
+      .uint16('payloadLen')
+      .buffer('payload', {
+        length: 'payloadLen',
+      })
+      .uint32('crc32');
+  }
+
+  public deserialize(duid: string, message: Buffer<ArrayBufferLike>): ResponseMessage {
+    // check message header
+    const header: HeaderMessage = this.headerMessageParser.parse(message);
+    if (!this.supportedVersions.includes(header.version)) {
+      throw new Error('unknown protocol version ' + header.version);
+    }
+
+    if (header.protocol === Protocol.hello_response || header.protocol === Protocol.ping_response) {
+      const dpsValue: DpsPayload = {
+        id: header.seq,
+        result: {
+          version: header.version,
+          nonce: header.nonce,
+        },
+      };
+      return new ResponseMessage(duid, { [header.protocol.toString()]: dpsValue });
+    }
+
+    // parse message content
+    const data: ContentMessage = this.contentMessageParser.parse(message.subarray(this.headerMessageParser.sizeOf()));
+
+    // check crc32
+    const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
+    const expectedCrc32 = message.readUInt32BE(message.length - 4);
+    if (crc32 != expectedCrc32) {
+      throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
+    }
+
+    const localKey = this.context.getLocalKey(duid);
+    if (!localKey) {
+      this.logger.notice(`Unable to retrieve local key for ${duid}, it should be from other vacuums`);
+      return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+    }
+
+    if (header.version == '1.0') {
+      const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(header.timestamp) + localKey + CryptoUtils.SALT);
+      const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
+      data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+    } else if (header.version == 'A01') {
+      const iv = CryptoUtils.md5hex(header.nonce.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 (header.version == 'B01') {
+      const iv = CryptoUtils.md5hex(header.nonce.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
+    if (header.protocol == Protocol.map_response) {
+      return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+    }
+
+    if (header.protocol == Protocol.rpc_response || header.protocol == Protocol.general_request) {
+      return this.deserializeRpcResponse(duid, data);
+    } else {
+      this.logger.error('unknown protocol: ' + header.protocol);
+      return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+    }
+  }
+
+  private deserializeRpcResponse(duid: string, data: ContentMessage): ResponseMessage {
+    const payload = JSON.parse(data.payload.toString());
+    const dps = payload.dps;
+    this.parseJsonInDps(dps, Protocol.general_request);
+    this.parseJsonInDps(dps, Protocol.rpc_response);
+    return new ResponseMessage(duid, dps);
+  }
+
+  private parseJsonInDps(dps: Record<string, unknown>, index: Protocol) {
+    const indexString = index.toString();
+    if (dps[indexString] !== undefined) {
+      dps[indexString] = JSON.parse(dps[indexString] as string);
+    }
+  }
+}