matterbridge-roborock-vacuum-plugin 1.0.5

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -0,0 +1,79 @@
+import { RoomInfo } from '../Zmodel/roomInfo.js';
+import { SimpleMessageListener } from './listener/index.js';
+import { RequestMessage } from './model/requestMessage.js';
+import { DeviceStatus } from '../Zmodel/deviceStatus.js';
+export class MessageProcessor {
+    client;
+    messageListener;
+    logger;
+    constructor(client) {
+        this.client = client;
+        this.messageListener = new SimpleMessageListener();
+        this.client.registerMessageListener(this.messageListener);
+    }
+    injectLogger(logger) {
+        this.logger = logger;
+    }
+    registerListener(listener) {
+        this.messageListener.registerListener(listener);
+    }
+    async getNetworkInfo(duid) {
+        const request = new RequestMessage({ method: 'get_network_info' });
+        return await this.client.get(duid, request);
+    }
+    async getDeviceStatus(duid) {
+        const request = new RequestMessage({ method: 'get_status' });
+        const response = await this.client.get(duid, request);
+        this.logger?.debug('Device status: ', JSON.stringify(response));
+        return new DeviceStatus(response);
+    }
+    async getRooms(duid, rooms) {
+        const request = new RequestMessage({ method: 'get_room_mapping' });
+        return this.client.get(duid, request).then((response) => new RoomInfo(rooms, response));
+    }
+    async gotoDock(duid) {
+        const request = new RequestMessage({ method: 'app_charge' });
+        return this.client.send(duid, request);
+    }
+    async startClean(duid) {
+        const request = new RequestMessage({ method: 'app_start' });
+        return this.client.send(duid, request);
+    }
+    async startRoomClean(duid, roomIds, repeat) {
+        const request = new RequestMessage({
+            method: 'app_segment_clean',
+            params: [{ segments: roomIds, repeat: repeat }],
+        });
+        return this.client.send(duid, request);
+    }
+    async pauseClean(duid) {
+        const request = new RequestMessage({ method: 'app_pause' });
+        return this.client.send(duid, request);
+    }
+    async resumeClean(duid) {
+        const request = new RequestMessage({ method: 'app_resume' });
+        return this.client.send(duid, request);
+    }
+    async stopClean(duid) {
+        const request = new RequestMessage({ method: 'app_stop' });
+        return this.client.send(duid, request);
+    }
+    async sendCustomMessage(duid, def) {
+        const request = new RequestMessage(def);
+        return this.client.send(duid, request);
+    }
+    async getCustomMessage(duid, def) {
+        const response = this.client.get(duid, def);
+        this.logger?.warn('XXXXXXX: ', JSON.stringify(response));
+        return response;
+    }
+    async findMyRobot(duid) {
+        const request = new RequestMessage({ method: 'find_me' });
+        return this.client.send(duid, request);
+    }
+    async changeCleanMode(duid, suctionPower, waterFlow) {
+        this.logger?.notice(`Change clean mode for ${duid} to suctionPower: ${suctionPower}, waterFlow: ${waterFlow}`);
+        await this.client.send(duid, new RequestMessage({ method: 'set_custom_mode', params: [suctionPower] }));
+        await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: [waterFlow] }));
+    }
+}

package/dist/roborockCommunication/broadcast/model/dps.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/model/messageContext.js

@@ -0,0 +1,26 @@
+import { randomBytes } from 'node:crypto';
+import { CryptoUtils } from '../../helper/cryptoHelper.js';
+export class MessageContext {
+    endpoint;
+    nonce;
+    devices = new Map();
+    constructor(userdata) {
+        this.endpoint = CryptoUtils.md5bin(userdata.rriot.k).subarray(8, 14).toString('base64');
+        this.nonce = randomBytes(16);
+    }
+    registerDevice(duid, localKey, pv) {
+        this.devices.set(duid, { localKey: localKey, protocolVersion: pv });
+    }
+    getNonceAsHex() {
+        return this.nonce.toString('hex').toUpperCase();
+    }
+    getLocalKey(duid) {
+        return this.devices.get(duid)?.localKey;
+    }
+    getProtocolVersion(duid) {
+        return this.devices.get(duid)?.protocolVersion;
+    }
+    getEndpoint() {
+        return this.endpoint;
+    }
+}

package/dist/roborockCommunication/broadcast/model/protocol.js

@@ -0,0 +1,19 @@
+export var Protocol;
+(function (Protocol) {
+    Protocol[Protocol["hello_request"] = 0] = "hello_request";
+    Protocol[Protocol["hello_response"] = 1] = "hello_response";
+    Protocol[Protocol["ping_request"] = 2] = "ping_request";
+    Protocol[Protocol["ping_response"] = 3] = "ping_response";
+    Protocol[Protocol["general_request"] = 4] = "general_request";
+    Protocol[Protocol["general_response"] = 5] = "general_response";
+    Protocol[Protocol["rpc_request"] = 101] = "rpc_request";
+    Protocol[Protocol["rpc_response"] = 102] = "rpc_response";
+    Protocol[Protocol["error"] = 120] = "error";
+    Protocol[Protocol["status_update"] = 121] = "status_update";
+    Protocol[Protocol["battery"] = 122] = "battery";
+    Protocol[Protocol["suction_power"] = 123] = "suction_power";
+    Protocol[Protocol["water_box_mode"] = 124] = "water_box_mode";
+    Protocol[Protocol["additional_props"] = 128] = "additional_props";
+    Protocol[Protocol["back_type"] = 139] = "back_type";
+    Protocol[Protocol["map_response"] = 301] = "map_response";
+})(Protocol || (Protocol = {}));

package/dist/roborockCommunication/broadcast/model/requestMessage.js

@@ -0,0 +1,33 @@
+import { Protocol } from './protocol.js';
+import { randomInt } from 'crypto';
+export class RequestMessage {
+    messageId;
+    protocol;
+    method;
+    params;
+    secure;
+    constructor(args) {
+        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;
+    }
+    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,
+            });
+        }
+        else {
+            return this;
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/model/responseMessage.js

@@ -0,0 +1,14 @@
+export class ResponseMessage {
+    duid;
+    dps;
+    constructor(duid, dps) {
+        this.duid = duid;
+        this.dps = dps;
+    }
+    contain(index) {
+        return this.dps[index.toString()] !== undefined;
+    }
+    get(index) {
+        return this.dps[index.toString()];
+    }
+}

package/dist/roborockCommunication/helper/chunkBuffer.js

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

package/dist/roborockCommunication/helper/cryptoHelper.js

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

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -0,0 +1,74 @@
+import crypto from 'crypto';
+import CRC32 from 'crc-32';
+import { Parser } from 'binary-parser';
+import assert from 'node:assert';
+import { ResponseMessage } from '../broadcast/model/responseMessage.js';
+import { CryptoUtils, MessageUtils } from './cryptoHelper.js';
+import { Protocol } from '../broadcast/model/protocol.js';
+export class MessageDeserializer {
+    context;
+    mqttMessageParser;
+    constructor(context) {
+        this.context = context;
+        this.mqttMessageParser = new Parser()
+            .endianess('big')
+            .string('version', {
+            length: 3,
+        })
+            .uint32('seq')
+            .uint32('random')
+            .uint32('timestamp')
+            .uint16('protocol')
+            .uint16('payloadLen')
+            .buffer('payload', {
+            length: 'payloadLen',
+        })
+            .uint32('crc32');
+    }
+    deserialize(duid, message) {
+        const version = message.toString('latin1', 0, 3);
+        if (version !== '1.0' && version !== 'A01') {
+            throw new Error('unknown protocol version ' + version);
+        }
+        const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
+        const expectedCrc32 = message.readUint32BE(message.length - 4);
+        if (crc32 != expectedCrc32) {
+            return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+        }
+        const localKey = this.context.getLocalKey(duid);
+        assert(localKey, 'unable to retrieve local key for ' + duid);
+        const data = this.mqttMessageParser.parse(message);
+        if (version == '1.0') {
+            const aesKey = CryptoUtils.md5bin(MessageUtils.encodeTimestamp(data.timestamp) + localKey + MessageUtils.SALT);
+            const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
+            data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+        }
+        else if (version == 'A01') {
+            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()]);
+        }
+        if (data.protocol == Protocol.map_response) {
+            return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+        }
+        if (data.protocol == Protocol.rpc_response || data.protocol == Protocol.general_request) {
+            return this.deserializeProtocolRpcResponse(duid, data);
+        }
+        else {
+            return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+        }
+    }
+    deserializeProtocolRpcResponse(duid, data) {
+        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);
+    }
+    parseJsonInDps(dps, index) {
+        const indexString = index.toString();
+        if (dps[indexString] !== undefined) {
+            dps[indexString] = JSON.parse(dps[indexString]);
+        }
+    }
+}

package/dist/roborockCommunication/helper/messageSerializer.js

@@ -0,0 +1,70 @@
+import { CryptoUtils, MessageUtils } from './cryptoHelper.js';
+import crypto from 'crypto';
+import CRC32 from 'crc-32';
+export class MessageSerializer {
+    context;
+    seq = 1;
+    random = 4711;
+    constructor(context) {
+        this.context = context;
+    }
+    serialize(duid, request) {
+        const messageId = request.messageId;
+        const buffer = this.buildBuffer(duid, messageId, request);
+        return { messageId: messageId, buffer: buffer };
+    }
+    buildPayload(messageId, request) {
+        const data = {
+            id: messageId,
+            method: request.method ?? '',
+            params: request.params,
+            security: undefined,
+            result: undefined,
+        };
+        if (request.secure) {
+            data.security = {
+                endpoint: this.context.getEndpoint(),
+                nonce: this.context.getNonceAsHex(),
+            };
+        }
+        const timestamp = Math.floor(Date.now() / 1000);
+        return {
+            dps: {
+                [request.protocol]: JSON.stringify(data),
+            },
+            t: timestamp,
+        };
+    }
+    buildBuffer(duid, messageId, request) {
+        const version = this.context.getProtocolVersion(duid);
+        const localKey = this.context.getLocalKey(duid);
+        const payloadData = this.buildPayload(messageId, request);
+        const payload = JSON.stringify(payloadData);
+        let encrypted;
+        if (version == '1.0') {
+            const aesKey = CryptoUtils.md5bin(MessageUtils.encodeTimestamp(payloadData.t) + localKey + MessageUtils.SALT);
+            const cipher = crypto.createCipheriv('aes-128-ecb', aesKey, null);
+            encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+        }
+        else if (version == 'A01') {
+            const encoder = new TextEncoder();
+            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 {
+            throw new Error('unable to build the message: unsupported protocol version: ' + version);
+        }
+        const msg = Buffer.alloc(23 + encrypted.length);
+        msg.write(version);
+        msg.writeUint32BE(this.seq++ & 0xffffffff, 3);
+        msg.writeUint32BE(this.random++ & 0xffffffff, 7);
+        msg.writeUint32BE(payloadData.t, 11);
+        msg.writeUint16BE(request.protocol, 15);
+        msg.writeUint16BE(encrypted.length, 17);
+        encrypted.copy(msg, 19);
+        const crc32 = CRC32.buf(msg.subarray(0, msg.length - 4)) >>> 0;
+        msg.writeUint32BE(crc32, msg.length - 4);
+        return msg;
+    }
+}

package/dist/roborockCommunication/helper/nameDecoder.js

@@ -0,0 +1,66 @@
+const token = '%[a-f0-9]{2}';
+const singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');
+const multiMatcher = new RegExp('(' + token + ')+', 'gi');
+function decodeComponents(components, split = undefined) {
+    try {
+        return [decodeURIComponent(components.join(''))];
+    }
+    catch {
+    }
+    if (components.length === 1) {
+        return components;
+    }
+    split = split || 1;
+    const left = components.slice(0, split);
+    const right = components.slice(split);
+    return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode(input) {
+    try {
+        return decodeURIComponent(input);
+    }
+    catch {
+        let tokens = input.match(singleMatcher) || [];
+        for (let i = 1; i < tokens.length; i++) {
+            input = decodeComponents(tokens, i).join('');
+            tokens = input.match(singleMatcher) || [];
+        }
+        return input;
+    }
+}
+function customDecodeURIComponent(input) {
+    const replaceMap = {
+        '%FE%FF': '\uFFFD\uFFFD',
+        '%FF%FE': '\uFFFD\uFFFD',
+    };
+    let match = multiMatcher.exec(input);
+    while (match) {
+        try {
+            replaceMap[match[0]] = decodeURIComponent(match[0]);
+        }
+        catch {
+            const result = decode(match[0]);
+            if (result !== match[0]) {
+                replaceMap[match[0]] = result;
+            }
+        }
+        match = multiMatcher.exec(input);
+    }
+    replaceMap['%C2'] = '\uFFFD';
+    const entries = Object.keys(replaceMap);
+    for (const key of entries) {
+        input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+    }
+    return input;
+}
+export default function decodeComponent(encodedURI) {
+    if (encodedURI === undefined) {
+        return undefined;
+    }
+    try {
+        return decodeURIComponent(encodedURI);
+    }
+    catch {
+        return customDecodeURIComponent(encodedURI);
+    }
+}

package/dist/roborockCommunication/helper/sequence.js

@@ -0,0 +1,16 @@
+export class Sequence {
+    min;
+    max;
+    current;
+    constructor(min, max) {
+        this.min = min;
+        this.max = max;
+        this.current = min;
+    }
+    next() {
+        if (this.current > this.max) {
+            this.current = this.min;
+        }
+        return this.current++;
+    }
+}

package/dist/roborockCommunication/index.js

@@ -0,0 +1,9 @@
+export { RoborockAuthenticateApi } from './RESTAPI/roborockAuthenticateApi.js';
+export { RoborockIoTApi } from './RESTAPI/roborockIoTApi.js';
+export { MessageProcessor } from './broadcast/messageProcessor.js';
+export { VacuumErrorCode } from './Zenum/vacuumAndDockErrorCode.js';
+export { RequestMessage } from './broadcast/model/requestMessage.js';
+export { Protocol } from './broadcast/model/protocol.js';
+export { ClientRouter } from './broadcast/clientRouter.js';
+export { DeviceStatus } from './Zmodel/deviceStatus.js';
+export { ResponseMessage } from './broadcast/model/responseMessage.js';