homebridge-roborock-matter 2.1.0

package/roborockLib/lib/messageQueueHandler.js

@@ -0,0 +1,411 @@
+// @ts-check
+"use strict";
+
+const b01Q7Adapter = require("./b01Q7Adapter");
+
+const DEFAULT_REQUEST_TIMEOUT = 10000; // 10s
+// Some commands legitimately take longer to acknowledge. Switching the active
+// saved map (load_multi_map) can take well over the default timeout on older
+// models such as the S6 Pure, so give it more headroom before timing out.
+/** @type {Record<string, number>} */
+const METHOD_REQUEST_TIMEOUTS = {
+  load_multi_map: 30000, // 30s
+};
+
+/**
+ * @param {string} method
+ * @param {number} [requestTimeoutMs]
+ * @returns {number}
+ */
+function getRequestTimeout(method, requestTimeoutMs) {
+  const override = Number(requestTimeoutMs);
+  if (Number.isFinite(override) && override > 0) {
+    return Math.round(override);
+  }
+
+  return METHOD_REQUEST_TIMEOUTS[method] || DEFAULT_REQUEST_TIMEOUT;
+}
+
+/**
+ * @typedef {Object} PendingRequest
+ * @property {(value: unknown) => void} resolve
+ * @property {(reason?: unknown) => void} reject
+ * @property {ReturnType<typeof setTimeout>} timeout
+ */
+
+/**
+ * @typedef {Object} TransportDiagnosticsUpdate
+ * @property {"cloud" | "local" | "local-pending"} [lastTransport]
+ * @property {string} [lastTransportReason]
+ * @property {string} [lastCommandMethod]
+ */
+
+/**
+ * @typedef {Object} MessageBuilder
+ * @property {(duid: string, protocol: number, messageID: number, method: string, params: unknown[], secure: boolean, photo: boolean) => Promise<unknown>} buildPayload
+ * @property {(duid: string, protocol: number, timestamp: number, payload: unknown) => Promise<Buffer | null | undefined>} buildRoborockMessage
+ */
+
+/**
+ * @typedef {Object} LocalConnector
+ * @property {(duid: string) => boolean} isConnected
+ * @property {(duid: string, message: Buffer) => void} sendMessage
+ * @property {(duid: string) => void} clearChunkBuffer
+ * @property {(duid: string) => Promise<void>} [ensureL01Handshake]
+ */
+
+/**
+ * @typedef {Object} MqttConnector
+ * @property {() => boolean} isConnected
+ * @property {(duid: string, message: Buffer) => void} sendMessage
+ */
+
+/**
+ * @typedef {Object} LoggerLike
+ * @property {(message: string) => void} debug
+ * @property {(message: string) => void} info
+ */
+
+/**
+ * @typedef {Object} RoborockConfig
+ * @property {boolean} [cloudOnlyMode]
+ */
+
+/**
+ * @typedef {Object} MessageQueueAdapter
+ * @property {RoborockConfig} [config]
+ * @property {(duid: string) => Promise<boolean>} isRemoteDevice
+ * @property {(duid: string) => Promise<string>} getRobotVersion
+ * @property {(duid: string) => Promise<boolean>} onlineChecker
+ * @property {MqttConnector} rr_mqtt_connector
+ * @property {LocalConnector} localConnector
+ * @property {MessageBuilder} message
+ * @property {() => number} getRequestId
+ * @property {Map<number, PendingRequest>} pendingRequests
+ * @property {(callback: () => void, timeout: number) => ReturnType<typeof setTimeout>} setTimeout
+ * @property {(timeout: ReturnType<typeof setTimeout>) => void} clearTimeout
+ * @property {LoggerLike} log
+ * @property {(duid: string, update: TransportDiagnosticsUpdate) => Promise<void>} updateTransportDiagnostics
+ * @property {(duid: string) => Promise<boolean>} [ensureLocalConnection]
+ * @property {(message: string, location: string, duid?: string) => void} catchError
+ */
+
+/**
+ * @typedef {Object} RequestOptions
+ * @property {boolean} [preferCloud]
+ * @property {boolean} [preferLocal]
+ * @property {boolean} [allowOfflineCloudSend]
+ * @property {number} [requestTimeoutMs]
+ */
+
+class messageQueueHandler {
+  /**
+   * @param {MessageQueueAdapter} adapter
+   */
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+
+  /**
+   * @param {string} duid
+   * @param {string} method
+   * @param {unknown[]} params
+   * @param {boolean} [secure=false]
+   * @param {boolean} [photo=false]
+   * @param {RequestOptions} [options]
+   * @returns {Promise<unknown | undefined>}
+   */
+  async sendRequest(
+    duid,
+    method,
+    params,
+    secure = false,
+    photo = false,
+    options = {}
+  ) {
+    const remoteConnection = await this.adapter.isRemoteDevice(duid);
+    const version = await this.adapter.getRobotVersion(duid);
+
+    const deviceOnline = await this.adapter.onlineChecker(duid);
+    const mqttConnectionState = this.adapter.rr_mqtt_connector.isConnected();
+    let localConnectionState = this.adapter.localConnector.isConnected(duid);
+    const cloudOnlyConnection = Boolean(this.adapter.config?.cloudOnlyMode);
+    const preferCloudConnection =
+      Boolean(options.preferCloud) && mqttConnectionState;
+    const preferLocalConnection =
+      Boolean(options.preferLocal) &&
+      !cloudOnlyConnection &&
+      !preferCloudConnection &&
+      !remoteConnection &&
+      !secure &&
+      !photo &&
+      method != "get_network_info";
+
+    if (
+      preferLocalConnection &&
+      !localConnectionState &&
+      typeof this.adapter.ensureLocalConnection == "function"
+    ) {
+      await this.adapter.updateTransportDiagnostics(duid, {
+        lastTransport: "local-pending",
+        lastTransportReason: "preferred-local-reconnect",
+        lastCommandMethod: method,
+      });
+      await this.adapter.ensureLocalConnection(duid);
+      localConnectionState = this.adapter.localConnector.isConnected(duid);
+    }
+
+    // B01 (Q7-series) devices are cloud/MQTT-only and speak a different RPC
+    // dialect. Translate the v1-shaped method to the Q7 equivalent here so a
+    // single choke point covers every caller (Matter, polling, UI).
+    if (b01Q7Adapter.isB01Protocol(version)) {
+      const neutral = b01Q7Adapter.neutralResponse(method);
+      const translated = b01Q7Adapter.translateOutgoing(method, params);
+
+      if (!translated) {
+        if (neutral) {
+          this.adapter.log.debug(
+            `Method ${method} has no B01/Q7 equivalent for ${duid}; returning a neutral response.`
+          );
+          return neutral.value;
+        }
+
+        const unsupported = /** @type {Error & {code?: string}} */ (
+          new Error(
+            `Method ${method} is not supported on B01/Q7 devices yet (${duid}).`
+          )
+        );
+        unsupported.code = "B01_METHOD_UNSUPPORTED";
+        throw unsupported;
+      }
+
+      method = translated.method;
+      params = /** @type {any} */ (translated.params);
+    }
+
+    let useCloudConnection =
+      b01Q7Adapter.isB01Protocol(version) ||
+      cloudOnlyConnection ||
+      preferCloudConnection ||
+      remoteConnection ||
+      secure ||
+      photo ||
+      method == "get_network_info";
+    if (!useCloudConnection && !localConnectionState && mqttConnectionState) {
+      useCloudConnection = true;
+      await this.adapter.updateTransportDiagnostics(duid, {
+        lastTransport: "cloud",
+        lastTransportReason: "local-unavailable-fallback",
+        lastCommandMethod: method,
+      });
+      this.adapter.log.debug(
+        `Local connection unavailable for ${duid}. Falling back to cloud connection for method ${method}.`
+      );
+    }
+
+    if (!useCloudConnection && version == "L01") {
+      try {
+        if (this.adapter.localConnector.ensureL01Handshake) {
+          await this.adapter.localConnector.ensureL01Handshake(duid);
+        }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        this.adapter.log.debug(
+          `L01 handshake before request failed for ${duid}: ${errorMessage}`
+        );
+      }
+    }
+
+    let messageID = /** @type {any} */ (
+      b01Q7Adapter.isB01Protocol(version)
+        ? b01Q7Adapter.createB01MessageId()
+        : this.adapter.getRequestId()
+    );
+    if (photo && typeof messageID === "number") {
+      messageID = messageID % 256; // this is a special case. Otherwise photo requests will not have the correct ID in the response.
+    }
+    const timestamp = Math.floor(Date.now() / 1000);
+
+    const protocol = useCloudConnection ? 101 : 4;
+    const allowOfflineCloudSend =
+      Boolean(options.allowOfflineCloudSend) && useCloudConnection;
+    const payload = await this.adapter.message.buildPayload(
+      duid,
+      protocol,
+      messageID,
+      method,
+      params,
+      secure,
+      photo
+    );
+    const roborockMessage = await this.adapter.message.buildRoborockMessage(
+      duid,
+      protocol,
+      timestamp,
+      payload
+    );
+
+    if (roborockMessage) {
+      return new Promise((resolve, reject) => {
+        if (
+          !deviceOnline &&
+          (useCloudConnection || !localConnectionState) &&
+          !allowOfflineCloudSend
+        ) {
+          this.adapter.updateTransportDiagnostics(duid, {
+            lastCommandMethod: method,
+            lastTransportReason: "device-offline",
+          });
+          this.adapter.pendingRequests.delete(messageID);
+          this.adapter.log.debug(
+            `Device ${duid} offline. Not sending for method ${method} request!`
+          );
+          reject(
+            new Error(
+              `Device ${duid} is offline. Not sending method ${method} request.`
+            )
+          );
+        } else if (!mqttConnectionState && useCloudConnection) {
+          this.adapter.updateTransportDiagnostics(duid, {
+            lastTransport: "cloud",
+            lastCommandMethod: method,
+            lastTransportReason: cloudOnlyConnection
+              ? "cloud-only-mqtt-unavailable"
+              : "mqtt-unavailable",
+          });
+          this.adapter.pendingRequests.delete(messageID);
+          this.adapter.log.debug(
+            `Cloud connection not available. Not sending for method ${method} request!`
+          );
+          reject(
+            new Error(
+              `Cloud connection not available. Not sending method ${method} request.`
+            )
+          );
+        } else if (!localConnectionState && !useCloudConnection) {
+          this.adapter.updateTransportDiagnostics(duid, {
+            lastCommandMethod: method,
+            lastTransportReason: "local-socket-unavailable",
+          });
+          this.adapter.pendingRequests.delete(messageID);
+          this.adapter.log.debug(
+            `Adapter not connect locally to robot ${duid}. Not sending for method ${method} request!`
+          );
+          reject(
+            new Error(
+              `Local connection not available for ${duid}. Not sending method ${method} request.`
+            )
+          );
+        } else {
+          // setup Timeout
+          const requestTimeout = getRequestTimeout(
+            method,
+            options.requestTimeoutMs
+          );
+          const timeoutSeconds = Math.round(requestTimeout / 1000);
+          const timeout = this.adapter.setTimeout(() => {
+            this.adapter.pendingRequests.delete(messageID);
+            this.adapter.localConnector.clearChunkBuffer(duid);
+            if (useCloudConnection) {
+              reject(
+                new Error(
+                  `Cloud request with id ${messageID} with method ${method} timed out after ${timeoutSeconds} seconds. MQTT connection state: ${mqttConnectionState}`
+                )
+              );
+            } else {
+              reject(
+                new Error(
+                  `Local request with id ${messageID} with method ${method} timed out after ${timeoutSeconds} seconds Local connect state: ${localConnectionState}`
+                )
+              );
+            }
+          }, requestTimeout);
+
+          // Store request with resolve and reject functions
+          this.adapter.pendingRequests.set(messageID, {
+            resolve,
+            reject,
+            timeout,
+          });
+
+          if (useCloudConnection) {
+            if (!deviceOnline && allowOfflineCloudSend) {
+              this.adapter.log.debug(
+                `Device ${duid} is marked offline, but sending method ${method} via cloud because the command explicitly allows offline cloud delivery.`
+              );
+            }
+            this.adapter.rr_mqtt_connector.sendMessage(duid, roborockMessage);
+            const lastTransportReason =
+              [
+                {
+                  condition: !deviceOnline && allowOfflineCloudSend,
+                  reason: "offline-cloud-command",
+                },
+                { condition: secure, reason: "secure-command" },
+                { condition: photo, reason: "photo-command" },
+                { condition: cloudOnlyConnection, reason: "cloud-only-mode" },
+                {
+                  condition: preferCloudConnection,
+                  reason: "preferred-cloud-command",
+                },
+                { condition: remoteConnection, reason: "remote-device" },
+                {
+                  condition: method == "get_network_info",
+                  reason: "network-info-cloud-only",
+                },
+              ].find((entry) => entry.condition)?.reason ?? "cloud-request";
+            this.adapter.updateTransportDiagnostics(duid, {
+              lastTransport: "cloud",
+              lastTransportReason,
+              lastCommandMethod: method,
+            });
+            this.adapter.log.debug(
+              `Sent payload for ${duid} with ${payload} using cloud connection`
+            );
+            //client.publish(`rr/m/i/${rriot.u}/${mqttUser}/${duid}`, roborockMessage, { qos: 1 });
+            // this.adapter.log.debug(`Promise for messageID ${messageID} created. ${this.adapter.message._decodeMsg(roborockMessage, duid).payload}`);
+          } else {
+            const lengthBuffer = Buffer.alloc(4);
+            lengthBuffer.writeUInt32BE(roborockMessage.length, 0);
+
+            const fullMessage = Buffer.concat([lengthBuffer, roborockMessage]);
+            this.adapter.localConnector.sendMessage(duid, fullMessage);
+            this.adapter.updateTransportDiagnostics(duid, {
+              lastTransport: "local",
+              lastTransportReason: "local-request",
+              lastCommandMethod: method,
+            });
+            // this.adapter.log.debug(`sent fullMessage: ${fullMessage.toString("hex")}`);
+            this.adapter.log.debug(
+              `Sent payload for ${duid} with ${payload} using local connection`
+            );
+          }
+        }
+      }).finally(() => {
+        this.adapter.log.debug(
+          `Size of message queue: ${this.adapter.pendingRequests.size}`
+        );
+      });
+    } else {
+      // Never resolve successfully when nothing was sent. Callers that wait
+      // for acknowledgement (Matter commands, HomeKit switches) would
+      // otherwise log the command as acknowledged even though the robot never
+      // received it.
+      this.adapter.catchError(
+        "Failed to build buildRoborockMessage!",
+        "function sendRequest",
+        duid
+      );
+      throw new Error(
+        `Failed to build Roborock message for method ${method} on ${duid}; the command was not sent.`
+      );
+    }
+  }
+}
+
+module.exports = {
+  messageQueueHandler,
+  getRequestTimeout,
+  DEFAULT_REQUEST_TIMEOUT,
+};

package/roborockLib/lib/roborockAuth.js

@@ -0,0 +1,178 @@
+"use strict";
+
+const crypto = require("crypto");
+const axios = require("axios");
+
+const API_V3_SIGN = "api/v3/key/sign";
+const API_V4_LOGIN_CODE = "api/v4/auth/email/login/code";
+const API_V4_LOGIN_PASSWORD = "api/v4/auth/email/login/pwd";
+const API_V4_EMAIL_CODE = "api/v4/email/code/send";
+
+const DEFAULT_HEADERS = {
+  header_appversion: "4.54.02",
+  header_clientlang: "en",
+  header_phonemodel: "Pixel 7",
+  header_phonesystem: "Android",
+};
+
+function normalizeBaseURL(baseURL) {
+  if (!baseURL) {
+    return "usiot.roborock.com";
+  }
+  return baseURL.replace(/^https?:\/\//i, "").replace(/\/+$/, "");
+}
+
+function parseHostname(baseURL) {
+  try {
+    return new URL(
+      `https://${normalizeBaseURL(baseURL)}`
+    ).hostname.toLowerCase();
+  } catch {
+    return normalizeBaseURL(baseURL).split("/")[0].split(":")[0].toLowerCase();
+  }
+}
+
+function getRegionConfig(baseURL) {
+  const hostname = parseHostname(baseURL);
+  const labels = hostname.split(".").filter(Boolean);
+  if (labels.includes("euiot")) {
+    return { country: "DE", countryCode: "49" };
+  }
+  if (labels.includes("usiot")) {
+    return { country: "US", countryCode: "1" };
+  }
+  if (labels.includes("cniot")) {
+    return { country: "CN", countryCode: "86" };
+  }
+  if (hostname === "api.roborock.com") {
+    return { country: "SG", countryCode: "65" };
+  }
+  return { country: "US", countryCode: "1" };
+}
+
+function encryptPassword(password, k) {
+  const derivedKey = k.slice(4) + k.slice(0, 4);
+  const cipher = crypto.createCipheriv(
+    "aes-128-ecb",
+    Buffer.from(derivedKey, "utf-8"),
+    null
+  );
+  cipher.setAutoPadding(true);
+  let encrypted = cipher.update(password, "utf8", "base64");
+  encrypted += cipher.final("base64");
+  return encrypted;
+}
+
+function createLoginApi({ baseURL, username, clientID, language }) {
+  return axios.create({
+    baseURL: `https://${normalizeBaseURL(baseURL)}`,
+    headers: {
+      header_clientid: crypto
+        .createHash("md5")
+        .update(username)
+        .update(clientID)
+        .digest()
+        .toString("base64"),
+      header_clientlang: language || DEFAULT_HEADERS.header_clientlang,
+      header_appversion: DEFAULT_HEADERS.header_appversion,
+      header_phonemodel: DEFAULT_HEADERS.header_phonemodel,
+      header_phonesystem: DEFAULT_HEADERS.header_phonesystem,
+    },
+  });
+}
+
+async function signRequest(loginApi, s) {
+  const res = await loginApi.post(`${API_V3_SIGN}?s=${s}`);
+  return res.data && res.data.data ? res.data.data : null;
+}
+
+async function requestEmailCode(loginApi, email) {
+  const params = new URLSearchParams();
+  params.append("type", "login");
+  params.append("email", email);
+  params.append("platform", "");
+
+  try {
+    const res = await loginApi.post(API_V4_EMAIL_CODE, params.toString());
+    if (res.data && res.data.code !== 200) {
+      throw new Error(
+        `Send code failed: ${res.data.msg || "Unknown error"} (Code: ${res.data.code})`
+      );
+    }
+    return res.data;
+  } catch (error) {
+    if (error.response && error.response.data) {
+      throw new Error(
+        `Send code failed: ${JSON.stringify(error.response.data)}`
+      );
+    }
+    throw error;
+  }
+}
+
+async function loginWithCode(
+  loginApi,
+  { email, code, country, countryCode, k, s }
+) {
+  const headers = {
+    "x-mercy-k": k,
+    "x-mercy-ks": s,
+  };
+
+  const params = new URLSearchParams({
+    country,
+    countryCode,
+    email,
+    code,
+    majorVersion: "14",
+    minorVersion: "0",
+  });
+
+  try {
+    const res = await loginApi.post(API_V4_LOGIN_CODE, params.toString(), {
+      headers,
+    });
+    return res.data;
+  } catch (error) {
+    if (error.response && error.response.data) {
+      return error.response.data;
+    }
+    throw error;
+  }
+}
+
+async function loginByPassword(loginApi, { email, password, k, s }) {
+  const headers = {
+    "x-mercy-k": k,
+    "x-mercy-ks": s,
+  };
+
+  const params = new URLSearchParams({
+    email,
+    password: encryptPassword(password, k),
+    majorVersion: "14",
+    minorVersion: "0",
+  });
+
+  try {
+    const res = await loginApi.post(API_V4_LOGIN_PASSWORD, params.toString(), {
+      headers,
+    });
+    return res.data;
+  } catch (error) {
+    if (error.response && error.response.data) {
+      return error.response.data;
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  createLoginApi,
+  getRegionConfig,
+  normalizeBaseURL,
+  signRequest,
+  requestEmailCode,
+  loginWithCode,
+  loginByPassword,
+};

package/roborockLib/lib/roborockCrypto.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const crypto = require("crypto");
+const forge = require("node-forge");
+
+function generateRsaKeyPair() {
+  const keypair = forge.pki.rsa.generateKeyPair(2048);
+  const keys = {
+    public: { n: null, e: null },
+    private: {
+      n: null,
+      e: null,
+      d: null,
+      p: null,
+      q: null,
+      dmp1: null,
+      dmq1: null,
+      coeff: null,
+    },
+  };
+
+  // Convert the keys to the desired format
+  keys.public.n = keypair.publicKey.n.toString(16);
+  keys.public.e = keypair.publicKey.e.toString(16);
+  keys.private.n = keypair.privateKey.n.toString(16);
+  keys.private.e = keypair.privateKey.e.toString(16);
+  keys.private.d = keypair.privateKey.d.toString(16);
+  keys.private.p = keypair.privateKey.p.toString(16);
+  keys.private.q = keypair.privateKey.q.toString(16);
+  keys.private.dmp1 = keypair.privateKey.dP.toString(16);
+  keys.private.dmq1 = keypair.privateKey.dQ.toString(16);
+  keys.private.coeff = keypair.privateKey.qInv.toString(16);
+
+  return keys;
+}
+
+function md5bin(str) {
+  return crypto.createHash("md5").update(str).digest();
+}
+
+function md5hex(str) {
+  return crypto.createHash("md5").update(str).digest("hex");
+}
+
+function 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("");
+}
+
+module.exports = {
+  generateRsaKeyPair,
+  md5bin,
+  md5hex,
+  encodeTimestamp,
+};