homebridge-roborock-matter 3.4.1 → 3.4.3

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 3.4.3
+
+**A robot with no model profile no longer fills your log with the same request forever.** Models the plugin has no dedicated profile for — the Saros 10 in [#8](https://github.com/mathiashornbek/homebridge-roborock-matter/issues/8), the Qrevo CurvX in [#6](https://github.com/mathiashornbek/homebridge-roborock-matter/issues/6) — run on the capability-derived path, which works, but every status field the profile did not name produced its own `Unsupported attribute … Please contact the dev` warning on every status poll. For the Saros 10 that is eight warnings a minute: about 11,500 requests a day to report the same eight fields. Both issues were promised this would be quietened.
+
+- **Each unmapped field is now reported once per robot, in one line, and then never again.** A firmware's set of unmapped fields is fixed, so a repeat says nothing a user can act on. Repeats go to debug. A time-based throttle was the wrong shape: it would bring the message back forever, which is the complaint rather than the fix.
+- **A field nobody has seen before still gets through.** If a robot starts sending something new after hours of uptime, it is reported on its own — quietening the noise must not also hide the signal, since these lines are the raw material for a model profile.
+- **The line is now usable in a model report.** It names the robot and model, lists every field with its value, and says plainly that control, battery, rooms and state do not depend on them. Object values are serialised instead of arriving as `[object Object]`, which is what `cleaning_info` looked like in #8 — the one field where the shape was the interesting part.
+- **Two startup tests no longer assert on the clock.** Both checked that per-robot probes run concurrently by timing them against a 180 ms budget — and on a quiet machine they finish in ~65 ms, so the assertion could only ever fail for a reason it was not testing. A scheduling hiccup was enough to fail a build with the concurrency perfectly correct. The check was also redundant: serialized probes give a peak concurrency of 1, which the neighbouring assertion already catches exactly. They now assert the property directly — every probe started before the first one finished — which holds on any machine under any load. Same defect 3.4.2 removed from the B01 full-chain simulation.
+- **The log-naming rule from 3.3.2 was itself only half enumerated.** It listed three files by hand, and the files it left out held twelve log lines still printing a bare 22-character duid — including `Device <duid> is offline.`, which is exactly the line someone quotes when asking why a robot dropped out. A hand-written file list is the same mistake as a hand-written line list, one level up. The rule now discovers the file list from the source tree, so a new file is covered the moment it exists, and all twelve lines now name the robot.
+
+## 3.4.2
+
+**Q7-series robots are no longer asked for things they cannot answer.** Every restart, each Q7-generation robot (`roborock.vacuum.sc05`, `ss07`, and the rest of the B01 family) logged an unsupported-method notice — most visibly for `get_water_box_custom_mode`, and also for `get_timer` and `get_carpet_clean_mode`. The message blamed the robot, and the robot was never involved: the plugin's own send path rejects v1-only requests for B01 devices before anything reaches the network, and the poller then recorded that self-rejection as though the robot had answered it.
+
+- **The periodic poller now consults the dialect before asking.** For a B01 robot it skips exactly the requests that have neither a Q7 translation nor a neutral placeholder, and says so once per robot at debug level instead of once per robot as a notice. Classic S- and Q-series robots poll precisely as before.
+- **The check derives from the translation table itself**, not from a hand-written list of method names — a second list would drift the first time a translation was added, and the drift would only ever show up as noise in somebody's log.
+- **The poll-profile line stops promising a water-box probe it will not perform** on a robot whose water tank is filled by hand and has no electronic level to read.
+- **A test enumerates the rule rather than the three reported methods:** for a B01 robot, no periodic poll may be one the dialect cannot answer. Probes added later are covered without anyone having to remember this.
+- Also fixed: the B01 full-chain simulation ran under Jest's 5-second default, which quietly made suite-wide CPU load an implicit assertion — it began failing on an unrelated new test file. Its wall-clock time was never what it set out to verify.
+
 ## 3.4.1
 
 **The Matter fault attribute is withdrawn.** Wazza151 ran three controlled tests on an S8 Pro Ultra with a genuinely empty clean water tank ([#5](https://github.com/mathiashornbek/homebridge-roborock-matter/issues/5)) and the result was unambiguous: Apple Home drew no warning with the fault published beside a Charging state, drew no warning with it published beside a forced Error state either, and the tile went into a stuck "Updating…" that needed a manual poke to clear. Everything off, and the tile behaved perfectly.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-roborock-matter",
-  "version": "3.4.1",
+  "version": "3.4.3",
   "description": "The most complete Roborock plugin for Apple Home. Supports the entire Roborock lineup — from the classic S-series to the new 2025 Q7 series that no other plugin can control. Sign in with your Roborock account and get native start/stop, room cleaning, suction levels, battery, and live 'cleaning in the kitchen' room tracking. Verified by Homebridge.",
   "license": "MIT",
   "author": {

package/roborockLib/lib/b01Q7Adapter.js

@@ -714,6 +714,31 @@ function neutralResponse(method) {
   return factory ? { value: factory() } : undefined;
 }
 
+/**
+ * True when a v1-shaped request has *any* answer on a Q7 robot — a real
+ * translation or a neutral placeholder. Everything else is rejected by the
+ * send choke point in messageQueueHandler with a B01_METHOD_UNSUPPORTED
+ * error, so the periodic poller can consult this instead of asking for
+ * something the plugin already knows will fail.
+ *
+ * Derived from the same two sources the choke point uses, deliberately: a
+ * separate hand-written list would drift the first time a translation is
+ * added, and the drift would only show up as noise in a user's log.
+ * @param {string} method
+ * @returns {boolean}
+ */
+function canAnswerV1Method(method) {
+  if (NEUTRAL_RESPONSES.has(method)) {
+    return true;
+  }
+
+  try {
+    return Boolean(translateOutgoing(method, []));
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Map a Q7 `prop.get` status payload to v1-shaped status fields.
  * Fixture reference: {"status":4,"quantity":87,"fault":0,...}
@@ -796,5 +821,6 @@ module.exports = {
   createB01MessageId,
   translateOutgoing,
   neutralResponse,
+  canAnswerV1Method,
   mapStatusToV1,
 };

package/roborockLib/lib/describeDevice.js

@@ -0,0 +1,33 @@
+"use strict";
+
+/**
+ * Friendly name for a robot, for use in user-visible log lines.
+ *
+ * `roborockAPI` has had its own `describeDevice` for a while, but the library
+ * modules underneath it only have the adapter reference, so their log lines
+ * kept printing the raw duid — a 22-character opaque string that tells the
+ * reader nothing, in exactly the messages people are asked to paste into an
+ * issue. This is the shared wrapper so the answer to "how is a robot named to
+ * a human" lives in one place rather than being re-decided per module.
+ *
+ * The fallback matters: these lines are reachable before HomeData has been
+ * fetched, and a log line is worth more than a crash, so an adapter without
+ * the helper (or a robot with no cached name) degrades to the duid.
+ *
+ * @param {{ describeDevice?: (duid: string) => string } | null | undefined} adapter
+ * @param {string} duid
+ * @returns {string}
+ */
+function describeDevice(adapter, duid) {
+  if (adapter && typeof adapter.describeDevice === "function") {
+    const name = adapter.describeDevice(duid);
+
+    if (typeof name === "string" && name.length > 0) {
+      return name;
+    }
+  }
+
+  return String(duid);
+}
+
+module.exports = { describeDevice };

package/roborockLib/lib/message.js

@@ -4,6 +4,7 @@ const crypto = require("crypto");
 const CRC32 = require("crc-32");
 const Parser = require("binary-parser").Parser;
 const roborockCrypto = require("./roborockCrypto");
+const { describeDevice } = require("./describeDevice");
 
 let seq = 1;
 let random = 4711; // Should be initialized with a number 0 - 1999?
@@ -243,7 +244,7 @@ class message {
         if (!this.missingLocalKeyWarnings.has(duid)) {
           this.missingLocalKeyWarnings.add(duid);
           this.adapter.log.warn(
-            `Skipping MQTT message for device ${duid}: no localKey available.`
+            `Skipping MQTT message for ${describeDevice(this.adapter, duid)}: no localKey available.`
           );
         }
 
@@ -321,7 +322,7 @@ class message {
         .toString("hex");
       const reason = error && error.message ? error.message : String(error);
       this.adapter.log.error(
-        `failed to _decodeMsg for ${duid}: ${reason} (len=${message.length}, preview=${preview})`
+        `failed to _decodeMsg for ${describeDevice(this.adapter, duid)}: ${reason} (len=${message.length}, preview=${preview})`
       );
       // this.adapter.catchError(error, "_decodeMessage", "none");
       return null;

package/roborockLib/lib/roborock_mqtt_connector.js

@@ -5,6 +5,7 @@ const crypto = require("crypto");
 const Parser = require("binary-parser").Parser;
 const zlib = require("zlib");
 const roborockCrypto = require("./roborockCrypto");
+const { describeDevice } = require("./describeDevice");
 
 const PHOTO_MAGIC = "ROBOROCK";
 const PHOTO_HEADER_MIN_LENGTH = 9;
@@ -499,7 +500,7 @@ class roborock_mqtt_connector {
           } catch (error) {
             // If parsing fails, the data might be corrupted or in an unexpected format
             this.adapter.log.warn(
-              `Unable to parse message for ${duid}. Error: ${error.message}. Data: ${dataString}`
+              `Unable to parse message for ${describeDevice(this.adapter, duid)}. Error: ${error.message}. Data: ${dataString}`
             );
             return;
           }
@@ -507,10 +508,10 @@ class roborock_mqtt_connector {
           // Check if the device is online
           if (parsedData.online == false) {
             this.adapter.log.info(
-              `Couldn't process message. The device ${duid} is offline.`
+              `Couldn't process message. ${describeDevice(this.adapter, duid)} is offline.`
             );
           } else if (parsedData.online == true) {
-            // this.adapter.log.info(`Device ${duid} is online.`);
+            // this.adapter.log.info(`${describeDevice(this.adapter, duid)} is online.`);
           } else if (
             // Check for firmware update information
             parsedData.mqttOtaData
@@ -521,19 +522,19 @@ class roborock_mqtt_connector {
 
             if (otaStatus) {
               this.adapter.log.info(
-                `Device ${duid} firmware update status: ${otaStatus}`
+                `${describeDevice(this.adapter, duid)} firmware update status: ${otaStatus}`
               );
             }
 
             if (otaProgress !== undefined) {
               this.adapter.log.info(
-                `Device ${duid} firmware update progress: ${otaProgress}%`
+                `${describeDevice(this.adapter, duid)} firmware update progress: ${otaProgress}%`
               );
             }
           } else {
             // Received an unrecognized message
             this.adapter.log.warn(
-              `Received an unrecognized message for ${duid}. Data: ${dataString}`
+              `Received an unrecognized message for ${describeDevice(this.adapter, duid)}. Data: ${dataString}`
             );
           }
         } else {

package/roborockLib/lib/vacuum.js

@@ -4,12 +4,45 @@ const rrMessage = require("./message").message;
 const RRMapParser = require("./RRMapParser");
 const fs = require("fs");
 const zlib = require("zlib");
+const { describeDevice } = require("./describeDevice");
 
 // Minimum spacing between periodic (non-forced) get_status polls per robot.
 // MQTT push remains the primary live channel; this is the safety net that
 // catches a dropped push long before the 3-minute full refresh would.
 const STATUS_POLL_MIN_INTERVAL_MS = 60 * 1000;
 
+// Longest rendering of a single unmapped attribute value in the report line
+// below. `cleaning_info` is an object, and one robot's status can carry a
+// nested blob big enough to bury the rest of the message.
+const MAX_REPORTED_STATUS_VALUE_LENGTH = 60;
+
+/**
+ * Render a `get_status` value for a log line. The old per-attribute warning
+ * interpolated the raw value, so an object arrived as the useless
+ * `[object Object]` — visible in skmzwanke's log for `cleaning_info`, which is
+ * the one field where the shape was the interesting part.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+function describeStatusValue(value) {
+  let text;
+
+  if (value === null || typeof value !== "object") {
+    text = String(value);
+  } else {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = "[unserialisable]";
+    }
+  }
+
+  return text.length > MAX_REPORTED_STATUS_VALUE_LENGTH
+    ? `${text.slice(0, MAX_REPORTED_STATUS_VALUE_LENGTH)}…`
+    : text;
+}
+
 const mappedCleanSummary = {
   0: "clean_time",
   1: "clean_area",
@@ -55,6 +88,41 @@ class vacuum {
 
     /** @type {Map<string, number>} last periodic status poll, per duid */
     this.lastStatusPollAt = new Map();
+
+    /**
+     * `get_status` attributes with no mapping in the robot's feature profile
+     * that have already been reported, per duid. The set of unmapped fields a
+     * given robot sends is fixed by its firmware, so reporting it once says
+     * everything a repeat would; a time-based throttle would still bring the
+     * message back forever, which is the complaint, not the fix.
+     *
+     * @type {Map<string, Set<string>>}
+     */
+    this.reportedUnmappedStatusAttributes = new Map();
+  }
+
+  /**
+   * Record that an unmapped `get_status` attribute is about to be reported for
+   * a robot, and say whether this is the initial sighting.
+   *
+   * @param {string} duid
+   * @param {string} attribute
+   * @returns {boolean} true only the one time the pair has not been seen before
+   */
+  rememberUnmappedStatusAttribute(duid, attribute) {
+    let reported = this.reportedUnmappedStatusAttributes.get(duid);
+
+    if (!reported) {
+      reported = new Set();
+      this.reportedUnmappedStatusAttributes.set(duid, reported);
+    }
+
+    if (reported.has(attribute)) {
+      return false;
+    }
+
+    reported.add(attribute);
+    return true;
   }
 
   /**
@@ -182,7 +250,7 @@ class vacuum {
 
           if (roomList.segments.length === 0) {
             this.adapter.log.warn(
-              `No room segments supplied for app_segment_clean_by_ids on ${duid}.`
+              `No room segments supplied for app_segment_clean_by_ids on ${describeDevice(this.adapter, duid)}.`
             );
             break;
           }
@@ -221,7 +289,7 @@ class vacuum {
           const mapId = Number(value);
           if (!Number.isInteger(mapId) || mapId < 0) {
             this.adapter.log.warn(
-              `Invalid map id '${value}' supplied for load_multi_map on ${duid}.`
+              `Invalid map id '${value}' supplied for load_multi_map on ${describeDevice(this.adapter, duid)}.`
             );
             break;
           }
@@ -391,6 +459,12 @@ class vacuum {
             status: deviceStatus[0] || null,
           });
 
+          // Collected across the whole poll and reported as one line. Eight
+          // separate warnings, once a minute, was ~11,500 identical requests a
+          // day to contact the dev about the same eight fields (#8).
+          /** @type {string[]} */
+          const newlyUnmappedAttributes = [];
+
           for (const attribute in deviceStatus[0]) {
             const isCleaning = this.adapter.isCleaning(
               deviceStatus[0]["state"]
@@ -412,9 +486,15 @@ class vacuum {
                 this.adapter.log.debug(
                   `Skipping known get_status attribute without a Homebridge state object: ${attribute}. Model: ${this.robotModel}`
                 );
+              } else if (
+                this.rememberUnmappedStatusAttribute(duid, attribute)
+              ) {
+                newlyUnmappedAttributes.push(
+                  `${attribute}=${describeStatusValue(deviceStatus[0][attribute])}`
+                );
               } else {
-                this.adapter.log.warn(
-                  `Unsupported attribute: ${attribute} of get_status with value ${deviceStatus[0][attribute]}. Please contact the dev to add the newly found attribute of your robot. Model: ${this.robotModel}`
+                this.adapter.log.debug(
+                  `Unmapped get_status attribute ${attribute}=${describeStatusValue(deviceStatus[0][attribute])} for ${describeDevice(this.adapter, duid)}; already reported, not repeating.`
                 );
               }
               continue; // skip unsupported attributes
@@ -511,6 +591,13 @@ class vacuum {
               { val: deviceStatus[0][attribute], ack: true }
             );
           }
+
+          if (newlyUnmappedAttributes.length > 0) {
+            this.adapter.log.warn(
+              `${describeDevice(this.adapter, duid)} (${this.robotModel}) sends ${newlyUnmappedAttributes.length} get_status field(s) this plugin has no mapping for: ${newlyUnmappedAttributes.join(", ")}. Control, battery, rooms and state come from a model-agnostic path and do not depend on them, so nothing is broken — but a model report issue on GitHub quoting this line is how they get added. Logged once per field per robot, so it will not repeat.`
+            );
+          }
+
           this.adapter.manageDeviceIntervals(duid);
         }
       } else if (parameter == "get_room_mapping") {
@@ -536,7 +623,7 @@ class vacuum {
         // if no rooms have been named, processing them can't work
         if (!Array.isArray(mappedRooms) || mappedRooms.length < 1) {
           this.adapter.log.info(
-            `No room mappings returned for ${duid}. Room-based controls will stay unavailable until the Roborock app exposes named rooms.`
+            `No room mappings returned for ${describeDevice(this.adapter, duid)}. Room-based controls will stay unavailable until the Roborock app exposes named rooms.`
           );
         } else {
           let unnamedRooms = 0;
@@ -566,7 +653,7 @@ class vacuum {
 
           if (unnamedRooms > 0) {
             this.adapter.log.info(
-              `${unnamedRooms} room(s) for ${duid} were missing names from HomeData. Using fallback labels like 'Room <id>' until the Roborock app syncs names.`
+              `${unnamedRooms} room(s) for ${describeDevice(this.adapter, duid)} were missing names from HomeData. Using fallback labels like 'Room <id>' until the Roborock app syncs names.`
             );
           }
         }

package/roborockLib/roborockAPI.js

@@ -201,6 +201,7 @@ class Roborock {
     // repeated warnings for requests they will never answer.
     this.unsupportedPollCommands = new Set();
     this.loggedPollProfiles = new Set();
+    this.skippedDialectPolls = new Set();
     this.baseURL = options.baseURL || "usiot.roborock.com";
 
     this.userData = options.userData || null;
@@ -2470,6 +2471,29 @@ class Roborock {
     return true;
   }
 
+  /**
+   * Poll one v1 parameter, unless the robot speaks a dialect that has no
+   * answer for it. Every periodic probe goes through here so the rule holds
+   * for probes added later, not just the three that were reported.
+   * @param {string} duid @param {any} vacuum @param {string} method
+   * @param {boolean} isB01
+   * @returns {Promise<any>}
+   */
+  async pollParameter(duid, vacuum, method, isB01) {
+    if (isB01 && !b01Q7Adapter.canAnswerV1Method(method)) {
+      const key = `${duid}:${method}`;
+      if (!this.skippedDialectPolls.has(key)) {
+        this.skippedDialectPolls.add(key);
+        this.log.debug(
+          `Not polling '${method}' for ${this.describeDevice(duid)}: the Q7/B01 dialect has no equivalent request, so the robot could only ever reject it.`
+        );
+      }
+      return undefined;
+    }
+
+    return vacuum.getParameter(duid, method);
+  }
+
   startMainUpdateInterval(duid, online) {
     if (!this.hasInitializedVacuum(duid)) {
       return;
@@ -2628,18 +2652,26 @@ class Roborock {
     this.log.debug(`Latest data requested`);
 
     if (this.isSupportedVacuumModel(robotModel)) {
+      // Q7-series robots speak the B01 dialect, where a good half of the v1
+      // poll chain has no equivalent request at all. Asking anyway produced
+      // an "unsupported" notice per robot per restart for a request the
+      // plugin itself rejected before it ever reached the robot.
+      const isB01 = b01Q7Adapter.isB01Protocol(
+        await this.getRobotVersion(duid)
+      );
+
       const refreshedServiceAreaRooms =
         await this.refreshMatterServiceAreaRoomMappings(duid, vacuum);
 
       if (!refreshedServiceAreaRooms) {
-        await vacuum.getParameter(duid, "get_room_mapping");
+        await this.pollParameter(duid, vacuum, "get_room_mapping", isB01);
       }
 
-      await vacuum.getParameter(duid, "get_consumable");
+      await this.pollParameter(duid, vacuum, "get_consumable", isB01);
 
-      await vacuum.getParameter(duid, "get_server_timer");
+      await this.pollParameter(duid, vacuum, "get_server_timer", isB01);
 
-      await vacuum.getParameter(duid, "get_timer");
+      await this.pollParameter(duid, vacuum, "get_timer", isB01);
 
       await this.checkForNewFirmware(duid);
 
@@ -2657,13 +2689,28 @@ class Roborock {
           //do nothing
           break;
         case "roborock.vacuum.s6":
-          await vacuum.getParameter(duid, "get_carpet_mode");
+          await this.pollParameter(duid, vacuum, "get_carpet_mode", isB01);
           break;
         case "roborock.vacuum.a27":
-          await vacuum.getParameter(duid, "get_dust_collection_switch_status");
-          await vacuum.getParameter(duid, "get_wash_towel_mode");
-          await vacuum.getParameter(duid, "get_smart_wash_params");
-          await vacuum.getParameter(duid, "app_get_dryer_setting");
+          await this.pollParameter(
+            duid,
+            vacuum,
+            "get_dust_collection_switch_status",
+            isB01
+          );
+          await this.pollParameter(duid, vacuum, "get_wash_towel_mode", isB01);
+          await this.pollParameter(
+            duid,
+            vacuum,
+            "get_smart_wash_params",
+            isB01
+          );
+          await this.pollParameter(
+            duid,
+            vacuum,
+            "app_get_dryer_setting",
+            isB01
+          );
           break;
         default: {
           // No dedicated poll profile for this model: derive it from the
@@ -2675,18 +2722,31 @@ class Roborock {
           const carpetSupported = featureList
             ? Boolean(featureList.isCarpetSupported)
             : true;
+          const waterBoxProbe =
+            !isB01 ||
+            b01Q7Adapter.canAnswerV1Method("get_water_box_custom_mode");
           const profileKey = `${duid}:${robotModel}`;
           if (!this.loggedPollProfiles.has(profileKey)) {
             this.loggedPollProfiles.add(profileKey);
             this.log.info(
-              `No dedicated poll profile for model '${robotModel}'; using ${featureList ? "capability-derived" : "generic"} polls (carpet=${carpetSupported ? "yes" : "no"}, water-box probe=yes). Requests the robot reports as unsupported are disabled automatically. If states look wrong for this model, please open a model report issue on GitHub.`
+              `No dedicated poll profile for model '${robotModel}'; using ${featureList ? "capability-derived" : "generic"} polls (carpet=${carpetSupported ? "yes" : "no"}, water-box probe=${waterBoxProbe ? "yes" : "no, the Q7/B01 dialect has no such request"}). Requests the robot reports as unsupported are disabled automatically. If states look wrong for this model, please open a model report issue on GitHub.`
             );
           }
           if (carpetSupported) {
-            await vacuum.getParameter(duid, "get_carpet_mode");
-            await vacuum.getParameter(duid, "get_carpet_clean_mode");
+            await this.pollParameter(duid, vacuum, "get_carpet_mode", isB01);
+            await this.pollParameter(
+              duid,
+              vacuum,
+              "get_carpet_clean_mode",
+              isB01
+            );
           }
-          await vacuum.getParameter(duid, "get_water_box_custom_mode");
+          await this.pollParameter(
+            duid,
+            vacuum,
+            "get_water_box_custom_mode",
+            isB01
+          );
         }
       }
     } else {