@mega-yfue/eufy-sdk 0.5.0-beta.14 → 0.5.0-beta.16

package/dist/client/device-registry.d.ts

@@ -16,7 +16,10 @@ export interface DeviceRecord {
     deviceType?: number;
     model?: string;
     category?: string;
-    /** The app-shown device name (`device_name`); see {@link CloudRecord.name}. */
+    /**
+     * The app-shown device name: `alias_name` first on a vacuum, `device_name` first otherwise;
+     * see {@link CloudRecord.name}.
+     */
     name?: string;
     /** Parent HomeBase serial when attached (topology signal; see {@link CloudRecord.parentSn}). */
     parentSn?: string;
@@ -92,6 +95,8 @@ export declare class DeviceRegistry {
     private overlayRefusalReported;
     /** Per-serial capability cache for {@link capabilitiesForDevice}; `null` = negative hit. */
     private readonly deviceCapsCache;
+    /** Per-serial cloud data points of an AIoT robot, joined beneath the params in {@link record} — see {@link loadCloudDps}. */
+    private readonly cloudDps;
     /** Per-serial realtime state, keyed by param id in the device's own namespace (see {@link DeviceRecord.dpParams}). */
     private readonly dpParams;
     /** Callers blocked in {@link awaitRealtimeState}, released by the device's first report. */
@@ -181,9 +186,26 @@ export declare class DeviceRegistry {
      * transport stacks own the claim predicate over the record.
      */
     require(sn: string): EufyDevice;
+    /**
+     * Hold an AIoT robot's cloud data points: the cloud's last-known value of each one it has reported,
+     * from `getDeviceRelationList`'s per-device `dps`.
+     *
+     * The device list carries only some of a robot's data points, so a point the robot publishes on change
+     * alone (its scene list, its schedules, its consumables) has no value until it next reports. The
+     * relation list holds every one, for an account the robot is shared with as well as its owner.
+     *
+     * Kept apart from the device list's params rather than merged into them: those are what a poll diffs,
+     * and a diff retires the realtime report for that id, so a cloud value lagging the robot's last report
+     * would replace it. {@link record} joins this beneath both halves. A failure keeps what was held.
+     *
+     * Limited to {@link CLOUD_DPS_MODELS}, the models whose relation-list `dps` are checked to carry the
+     * DP numbers their realtime reports use.
+     */
+    private loadCloudDps;
     /**
      * Resolve a serial to a {@link DeviceRecord} with current params: starts from the device-list params, then
-     * overlays a fresh `get_device_param_list` when that call is available to this account.
+     * overlays a fresh `get_device_param_list` when that call is available to this account. An AIoT robot's
+     * cloud data points ({@link loadCloudDps}) sit beneath both, filling only ids neither carries.
      *
      * The overlay is **owner-gated** — a shared or member account is refused it for every device, permanently,
      * which {@link OWNER_ONLY_CODE} identifies — so when it is unavailable the device list is the source

package/dist/index.js

@@ -1996,6 +1996,17 @@ ${this.auth_?.authToken ?? ""}`;
       device_sns: [deviceSn]
     });
   }
+  /**
+   * Fetch the account's devices as the `devicerelation` service lists them, `{attribute: 7, house_id: ""}`.
+   *
+   * Each entry is `{device: {device_sn, dps, …}}`, and `dps` is the cloud's last-known value of every
+   * data point that device has reported, keyed by DP number. Answered for an account a device is shared
+   * with as well as for its owner. Sent with `category: eufy_home`, without which the service answers
+   * `10000`.
+   */
+  getDeviceRelationList() {
+    return this.post("devicerelation", "/app/devicerelation/get_device_list", { attribute: 7, house_id: "" }, { category: "eufy_home" });
+  }
   /**
    * Fetch one page of a device's **cleaning history** from the mega `clean` service.
    *
@@ -11046,6 +11057,8 @@ var MODEL_REGISTRY = {
   T8210: { codec: "camera", caps: ["doorbell", "battery"], name: "Video Doorbell" },
   // Confirmed against a real owned unit (named "Doorbell"): Video Doorbell Dual.
   T8214: { codec: "camera", caps: ["doorbell", "battery"], name: "Video Doorbell Dual" },
+  // Battery Video Doorbell Dual, vendor deviceType 91 (BATTERY_DOORBELL_PLUS), reported by two users.
+  T8213: { codec: "camera", caps: ["doorbell", "battery"], name: "Video Doorbell Dual" },
   // Confirmed against a real owned unit: the mains-powered Wired Doorbell 2K. No `battery` row
   // member on purpose — this model is wired, so the codec baseline plus inference is the whole
   // truth for power. Without this row it classified as a plain camera, so the doorbell capability
@@ -26330,7 +26343,14 @@ function deviceClassOf(codec, realtime) {
   const cls = CLASS_BY_CODEC[codec];
   return cls === "camera" && realtime !== "p2p" ? "other" : cls;
 }
+function recordName(raw, deviceClass) {
+  if (deviceClass === "vacuum") {
+    return raw.alias_name || raw.device_alias_name || raw.device_name || void 0;
+  }
+  return raw.device_name ?? raw.device_alias_name ?? raw.alias_name;
+}
 var LIST_REUSE_MS = 5e3;
+var CLOUD_DPS_MODELS = /* @__PURE__ */ new Set(["T2351"]);
 var DeviceRegistry = class {
   mega;
   onError;
@@ -26355,6 +26375,8 @@ var DeviceRegistry = class {
   overlayRefusalReported = false;
   /** Per-serial capability cache for {@link capabilitiesForDevice}; `null` = negative hit. */
   deviceCapsCache = /* @__PURE__ */ new Map();
+  /** Per-serial cloud data points of an AIoT robot, joined beneath the params in {@link record} — see {@link loadCloudDps}. */
+  cloudDps = /* @__PURE__ */ new Map();
   /** Per-serial realtime state, keyed by param id in the device's own namespace (see {@link DeviceRecord.dpParams}). */
   dpParams = /* @__PURE__ */ new Map();
   /** Callers blocked in {@link awaitRealtimeState}, released by the device's first report. */
@@ -26449,9 +26471,10 @@ var DeviceRegistry = class {
           category: raw.category,
           params
         }).codec;
+        const deviceClass = deviceClassOf(codec, c.realtime);
         seen.set(raw.device_sn, {
           sn: raw.device_sn,
-          name: raw.device_name ?? raw.device_alias_name ?? raw.alias_name,
+          name: recordName(raw, deviceClass),
           model: raw.device_model,
           stationSn: resolvedStationSn(raw, raw.device_sn),
           p2pDid: raw.p2p_did,
@@ -26459,11 +26482,12 @@ var DeviceRegistry = class {
           paramUpdatedAt,
           lastSeenMs: lastSeenMsOf(paramUpdatedAt),
           raw,
-          deviceClass: deviceClassOf(codec, c.realtime),
+          deviceClass,
           ...c
         });
       }
     }
+    await this.loadCloudDps(seen);
     this.lastRefreshPartial = partial;
     if (partial) {
       for (const prev of this.devices)
@@ -26554,9 +26578,46 @@ var DeviceRegistry = class {
     }
     return dev;
   }
+  /**
+   * Hold an AIoT robot's cloud data points: the cloud's last-known value of each one it has reported,
+   * from `getDeviceRelationList`'s per-device `dps`.
+   *
+   * The device list carries only some of a robot's data points, so a point the robot publishes on change
+   * alone (its scene list, its schedules, its consumables) has no value until it next reports. The
+   * relation list holds every one, for an account the robot is shared with as well as its owner.
+   *
+   * Kept apart from the device list's params rather than merged into them: those are what a poll diffs,
+   * and a diff retires the realtime report for that id, so a cloud value lagging the robot's last report
+   * would replace it. {@link record} joins this beneath both halves. A failure keeps what was held.
+   *
+   * Limited to {@link CLOUD_DPS_MODELS}, the models whose relation-list `dps` are checked to carry the
+   * DP numbers their realtime reports use.
+   */
+  async loadCloudDps(seen) {
+    const robots = [...seen.values()].filter((d) => CLOUD_DPS_MODELS.has(d.model ?? ""));
+    if (!robots.length)
+      return;
+    let res;
+    try {
+      res = await this.mega.getDeviceRelationList();
+    } catch (e) {
+      if (e instanceof SessionExpiredError)
+        throw e;
+      this.logger.debug(`[registry] device relation list unavailable: ${e?.message ?? e}`);
+      return;
+    }
+    const wanted = new Set(robots.map((d) => d.sn));
+    for (const entry of res.devices ?? []) {
+      const sn = entry?.device?.device_sn;
+      const dps = parseAiotDpReport({ payload: entry?.device?.dps });
+      if (sn && wanted.has(sn) && dps)
+        this.cloudDps.set(sn, dps);
+    }
+  }
   /**
    * Resolve a serial to a {@link DeviceRecord} with current params: starts from the device-list params, then
-   * overlays a fresh `get_device_param_list` when that call is available to this account.
+   * overlays a fresh `get_device_param_list` when that call is available to this account. An AIoT robot's
+   * cloud data points ({@link loadCloudDps}) sit beneath both, filling only ids neither carries.
    *
    * The overlay is **owner-gated** — a shared or member account is refused it for every device, permanently,
    * which {@link OWNER_ONLY_CODE} identifies — so when it is unavailable the device list is the source
@@ -26585,7 +26646,7 @@ var DeviceRegistry = class {
     let dev = this.devices.find((d) => d.sn === sn);
     if (!dev)
       throw new Error(`device ${sn} not found (have: ${this.devices.map((d) => d.sn).join(", ")})`);
-    const params = { ...dev.params ?? {} };
+    const params = { ...this.cloudDps.get(sn), ...dev.params ?? {} };
     const paramUpdatedAt = { ...dev.paramUpdatedAt ?? {} };
     if (!this.overlayRefused.has(sn)) {
       try {