@apocaliss92/nodedreame 1.11.10 → 1.11.11

package/dist/index.cjs

@@ -73,6 +73,7 @@ __export(index_exports, {
   extractMowerConsumableValues: () => extractMowerConsumableValues,
   getMowerCapabilities: () => getMowerCapabilities,
   getVacuumCapabilities: () => getVacuumCapabilities,
+  isAuthRefusedError: () => isAuthRefusedError,
   isDreameConsumableKey: () => isDreameConsumableKey,
   mowerConsumableIndex: () => mowerConsumableIndex,
   mowerFaultSeverity: () => mowerFaultSeverity,
@@ -717,6 +718,10 @@ var TypedEmitter = class {
   emit(event, ...args) {
     return this.#emitter.emit(event, ...args);
   }
+  /** Number of listeners registered for `event`. */
+  listenerCount(event) {
+    return this.#emitter.listenerCount(event);
+  }
   removeAllListeners() {
     this.#emitter.removeAllListeners();
     return this;
@@ -729,6 +734,24 @@ function defaultConnect(url, opts) {
   const typed = client;
   return typed;
 }
+function isAuthRefusedError(err) {
+  let cur = err;
+  for (let depth = 0; cur != null && depth < 6; depth += 1) {
+    if (typeof cur !== "object") {
+      break;
+    }
+    const code = cur.code;
+    if (code === 4 || code === 5 || code === 134 || code === 135) {
+      return true;
+    }
+    const message = cur.message;
+    if (typeof message === "string" && /not authorized|bad user ?name|bad username or password|bad password/i.test(message)) {
+      return true;
+    }
+    cur = cur.cause;
+  }
+  return false;
+}
 var DreamePush = class extends TypedEmitter {
   #device;
   #session;
@@ -737,11 +760,15 @@ var DreamePush = class extends TypedEmitter {
   #backoffMs;
   #keepaliveSeconds;
   #rejectUnauthorized;
+  #onAuthFailure;
+  #maxAuthRetries;
   #topic;
   #client = null;
   #closed = false;
   #tearingDown = false;
   #reconnectTimer = null;
+  /** Consecutive auth-refused re-auths since the last successful connect. */
+  #authFailureCount = 0;
   /**
    * Per-instance bound close handler. Stored so we can pass the EXACT same
    * function reference to both `client.on('close', …)` and
@@ -758,6 +785,8 @@ var DreamePush = class extends TypedEmitter {
     this.#backoffMs = input.reconnectBackoffMs ?? 5e3;
     this.#keepaliveSeconds = input.keepaliveSeconds ?? 60;
     this.#rejectUnauthorized = input.rejectUnauthorized ?? false;
+    this.#onAuthFailure = input.onAuthFailure ?? null;
+    this.#maxAuthRetries = input.maxAuthRetries ?? 3;
     this.#topic = buildStatusTopic(this.#device, this.#session.uid, this.#region);
     this.#onClose = () => {
       if (this.#tearingDown) {
@@ -794,7 +823,11 @@ var DreamePush = class extends TypedEmitter {
       this.#reconnectTimer = null;
     }
     await this.#teardownClient();
-    await this.#connectAndSubscribe();
+    try {
+      await this.#connectAndSubscribe();
+    } catch {
+      this.#scheduleReconnect();
+    }
   }
   /** Tear down permanently. Closed subscriptions cannot be reopened. */
   async close() {
@@ -831,6 +864,7 @@ var DreamePush = class extends TypedEmitter {
               reject(new DreameTransportError(`mqtt subscribe failed: ${err.message}`, err));
               return;
             }
+            this.#authFailureCount = 0;
             this.emit("connect");
             resolve();
           });
@@ -864,12 +898,55 @@ var DreamePush = class extends TypedEmitter {
       if (this.#closed || this.#client) {
         return;
       }
-      void this.#connectAndSubscribe().catch((err) => {
-        this.emit("error", err instanceof Error ? err : new DreameTransportError(String(err)));
-        this.#scheduleReconnect();
-      });
+      void this.#attemptReconnect();
     }, this.#backoffMs);
   }
+  /**
+   * One reconnect attempt with reactive auth self-heal. If the broker refuses
+   * the CONNECT with an auth error (a stale access token) and an
+   * `onAuthFailure` provider is wired and the re-auth budget is not exhausted,
+   * mint a fresh session and retry with the new token instead of replaying the
+   * old one. Any other failure (or an exhausted budget) falls back to the plain
+   * backoff reconnect so bad credentials cannot hot-loop re-login.
+   */
+  async #attemptReconnect() {
+    try {
+      await this.#connectAndSubscribe();
+    } catch (err) {
+      if (this.#closed) {
+        return;
+      }
+      if (this.#onAuthFailure && isAuthRefusedError(err) && this.#authFailureCount < this.#maxAuthRetries) {
+        await this.#reauthenticateAndReconnect();
+        return;
+      }
+      this.emit("error", err instanceof Error ? err : new DreameTransportError(String(err)));
+      this.#scheduleReconnect();
+    }
+  }
+  /** Mint a fresh session via `onAuthFailure`, adopt its token, and reconnect. */
+  async #reauthenticateAndReconnect() {
+    this.#authFailureCount += 1;
+    let session;
+    try {
+      session = await this.#onAuthFailure();
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new DreameTransportError(String(err)));
+      if (!this.#client) {
+        this.#scheduleReconnect();
+      }
+      return;
+    }
+    if (this.#closed) {
+      return;
+    }
+    this.#session = session;
+    this.#topic = buildStatusTopic(this.#device, this.#session.uid, this.#region);
+    if (this.#client) {
+      return;
+    }
+    void this.#attemptReconnect();
+  }
   async #teardownClient() {
     const client = this.#client;
     this.#client = null;
@@ -1045,7 +1122,12 @@ function resolveCapabilities(model) {
 // src/device/base-device.ts
 function defaultBaseDeviceDeps() {
   return {
-    createPush: (device, session, region) => new DreamePush({ device, session, region }),
+    createPush: (device, session, region, onAuthFailure) => new DreamePush({
+      device,
+      session,
+      region,
+      ...onAuthFailure !== void 0 ? { onAuthFailure } : {}
+    }),
     getProperties: (base, props) => getProperties(base, props),
     getCachedProperties: (base, props) => getCachedProperties(base, props),
     setProperties: (base, writes) => setProperties(base, writes),
@@ -1057,6 +1139,7 @@ var BaseDevice = class extends TypedEmitter {
   #device;
   #region;
   #sessionRef;
+  #onAuthFailure;
   #deps;
   #fetchInitial;
   #initialProps;
@@ -1072,6 +1155,7 @@ var BaseDevice = class extends TypedEmitter {
     this.#device = input.device;
     this.#region = input.region;
     this.#sessionRef = input.sessionRef;
+    this.#onAuthFailure = input.onAuthFailure;
     this.#deps = input.deps ?? defaultBaseDeviceDeps();
     this.#fetchInitial = input.fetchInitialValues ?? true;
     this.#initialProps = input.initialProps ?? [];
@@ -1111,7 +1195,12 @@ var BaseDevice = class extends TypedEmitter {
   }
   /** Open the push, wire events, optionally seed the cache. */
   async start() {
-    const push = this.#deps.createPush(this.#device, this.#sessionRef(), this.#region);
+    const push = this.#deps.createPush(
+      this.#device,
+      this.#sessionRef(),
+      this.#region,
+      this.#onAuthFailure
+    );
     this.#push = push;
     push.on("properties", (changes) => this.#onProperties(changes));
     push.on(
@@ -5525,6 +5614,7 @@ function defaultDeps(opts) {
         device: args.device,
         region: args.region,
         sessionRef: args.sessionRef,
+        ...args.onAuthFailure !== void 0 ? { onAuthFailure: args.onAuthFailure } : {},
         ...opts.fetchInitialValues !== void 0 ? { fetchInitialValues: opts.fetchInitialValues } : {},
         ...opts.pollIntervalMs !== void 0 ? { pollIntervalMs: opts.pollIntervalMs } : {}
       });
@@ -5538,6 +5628,15 @@ var Nodreame = class extends TypedEmitter {
   #session = null;
   #devices = [];
   #closed = false;
+  /** Background timer that proactively refreshes before the token expires. */
+  #refreshTimer = null;
+  /** Guard against overlapping proactive-refresh runs. */
+  #refreshInFlight = false;
+  /**
+   * The single in-flight refresh, shared by concurrent callers so the proactive
+   * timer and a manual `ensureSession()`/`reauthenticate()` never double-refresh.
+   */
+  #inFlightRefresh = null;
   constructor(opts, deps) {
     super();
     if (!opts.username || !opts.password) {
@@ -5566,6 +5665,7 @@ var Nodreame = class extends TypedEmitter {
       ...this.#opts.lang !== void 0 ? { lang: this.#opts.lang } : {},
       ...this.#opts.fetchImpl !== void 0 ? { fetchImpl: this.#opts.fetchImpl } : {}
     });
+    this.#scheduleProactiveRefresh();
     return this.#session;
   }
   /** Return a valid session, refreshing proactively within the leeway window. */
@@ -5577,18 +5677,61 @@ var Nodreame = class extends TypedEmitter {
     if (Date.now() < current.expiresAt - this.#leewayMs) {
       return current;
     }
+    return this.#refreshNow(current);
+  }
+  /**
+   * Force a session refresh REGARDLESS of the current expiry, then propagate the
+   * new token to every live device push. Wired as each push's `onAuthFailure`:
+   * when a broker refuses a CONNECT because it considers the token stale (even
+   * though {@link ensureSession} still thinks it valid — e.g. server-side early
+   * revocation or clock skew), this mints a genuinely fresh token instead of
+   * replaying the rejected one.
+   */
+  async reauthenticate() {
+    if (this.#closed) {
+      throw new DreameAuthError("client is closed");
+    }
+    const current = this.#session;
+    if (!current) {
+      return this.login();
+    }
+    return this.#refreshNow(current);
+  }
+  /**
+   * Refresh via the refresh-token (with a full re-login fallback) and propagate
+   * the new token to every device push. Shared by {@link ensureSession} (within
+   * the leeway window) and {@link reauthenticate} (unconditional).
+   */
+  async #refreshNow(current) {
+    const existing = this.#inFlightRefresh;
+    if (existing) {
+      return existing;
+    }
+    const run = this.#doRefresh(current);
+    this.#inFlightRefresh = run;
+    try {
+      return await run;
+    } finally {
+      this.#inFlightRefresh = null;
+    }
+  }
+  async #doRefresh(current) {
     if (current.refreshToken) {
+      let next = null;
       try {
-        const next = await this.#deps.refresh({
+        next = await this.#deps.refresh({
           refreshToken: current.refreshToken,
           region: this.#opts.region,
           ...this.#opts.country !== void 0 ? { country: this.#opts.country } : {},
           ...this.#opts.lang !== void 0 ? { lang: this.#opts.lang } : {},
           ...this.#opts.fetchImpl !== void 0 ? { fetchImpl: this.#opts.fetchImpl } : {}
         });
+      } catch {
+        next = null;
+      }
+      if (next) {
         await this.#adoptSession(next);
         return next;
-      } catch {
       }
     }
     const fresh = await this.login();
@@ -5610,23 +5753,30 @@ var Nodreame = class extends TypedEmitter {
       (device) => this.#deps.createDevice({
         device,
         region: this.#opts.region,
-        sessionRef: () => this.#requireSession()
+        sessionRef: () => this.#requireSession(),
+        onAuthFailure: () => this.reauthenticate()
       })
     );
     for (const h of handles) {
       h.on("stateChanged", (e) => this.emit("stateChanged", e));
       h.on("event", (e) => this.emit("event", e));
-      h.on("error", (err) => this.emit("error", err));
+      h.on("error", (err) => {
+        if (this.listenerCount("error") > 0) {
+          this.emit("error", err);
+        }
+      });
       await h.start();
     }
     const previous = this.#devices;
     this.#devices = [...handles];
     await Promise.all(previous.map((d) => d.close()));
+    this.#scheduleProactiveRefresh();
     return this.#devices;
   }
   /** Tear everything down: close every device push and clear timers. */
   async close() {
     this.#closed = true;
+    this.#clearRefreshTimer();
     const devices = this.#devices;
     this.#devices = [];
     await Promise.all(devices.map((d) => d.close()));
@@ -5641,13 +5791,65 @@ var Nodreame = class extends TypedEmitter {
   async #adoptSession(session) {
     this.#session = session;
     await this.#propagateSession(session);
+    this.#scheduleProactiveRefresh();
+  }
+  #clearRefreshTimer() {
+    if (this.#refreshTimer) {
+      clearTimeout(this.#refreshTimer);
+      this.#refreshTimer = null;
+    }
+  }
+  /** Arm the proactive-refresh timer `delayMs` from now (clamped to ≥0). */
+  #armRefreshTimer(delayMs) {
+    this.#clearRefreshTimer();
+    if (this.#closed) {
+      return;
+    }
+    this.#refreshTimer = setTimeout(() => {
+      this.#refreshTimer = null;
+      void this.#runProactiveRefresh();
+    }, Math.max(0, delayMs));
+  }
+  /** (Re)arm the proactive-refresh timer against the current session's expiry. */
+  #scheduleProactiveRefresh() {
+    const session = this.#session;
+    if (!session) {
+      this.#clearRefreshTimer();
+      return;
+    }
+    this.#armRefreshTimer(session.expiresAt - this.#leewayMs - Date.now());
+  }
+  /**
+   * Timer body: refresh the session before it expires, then reschedule against
+   * the new expiry. Because {@link ensureSession} propagates the refreshed token
+   * to every device push, each MQTT connection is re-keyed BEFORE the broker
+   * would reject the old one — the reactive re-auth loop never even starts.
+   */
+  async #runProactiveRefresh() {
+    if (this.#closed || this.#refreshInFlight) {
+      return;
+    }
+    this.#refreshInFlight = true;
+    try {
+      await this.ensureSession();
+      this.#refreshInFlight = false;
+      this.#scheduleProactiveRefresh();
+    } catch (err) {
+      this.#refreshInFlight = false;
+      if (this.listenerCount("error") > 0) {
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      }
+      if (!this.#closed) {
+        this.#armRefreshTimer(this.#leewayMs);
+      }
+    }
   }
   /** Push the refreshed token to every live device push. */
   async #propagateSession(session) {
     if (this.#closed) {
       return;
     }
-    await Promise.all(this.#devices.map((d) => d.applySession(session)));
+    await Promise.allSettled(this.#devices.map((d) => d.applySession(session)));
   }
 };
 
@@ -6150,6 +6352,7 @@ function createClientDumper(client, options) {
   extractMowerConsumableValues,
   getMowerCapabilities,
   getVacuumCapabilities,
+  isAuthRefusedError,
   isDreameConsumableKey,
   mowerConsumableIndex,
   mowerFaultSeverity,