@riddix/hamh 2.1.0-alpha.712 → 2.1.0-alpha.713

package/dist/backend/cli.js

@@ -124211,8 +124211,7 @@ var init_bridge_config_schema = __esm({
         sessionMaxAgeHours: {
           title: "Session Rotation Max Age (hours)",
           type: "number",
-          description: "Server Mode only. Rotate matter sessions older than this many hours so iPhone clients re-subscribe and Apple Home unsticks 'Updating' tiles. Set 0 to disable rotation. Range 0-168, default 4. (#287)",
-          default: 4,
+          description: "Rotate matter sessions older than this many hours so controllers re-establish and re-subscribe. Server Mode rotates every 4h by default; standard bridges only rotate when you set a value here. Set 0 to disable. Range 0 to 168. (#287)",
           minimum: 0,
           maximum: 168
         },
@@ -147398,6 +147397,30 @@ function ensureCommissioningConfig(server) {
 
 // src/services/bridges/bridge.ts
 init_diagnostic_event_bus();
+
+// src/services/bridges/session-rotation.ts
+var DEFAULT_SESSION_MAX_AGE_HOURS = 4;
+var SESSION_MAX_AGE_HOURS_RANGE = { min: 1, max: 168 };
+var ROTATION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
+function parseSessionMaxAgeHours(raw) {
+  if (raw == null || raw === "") return DEFAULT_SESSION_MAX_AGE_HOURS;
+  const n = Number.parseInt(raw, 10);
+  if (Number.isNaN(n) || n < 0) return null;
+  if (n === 0) return 0;
+  const { min, max } = SESSION_MAX_AGE_HOURS_RANGE;
+  if (n < min) return min;
+  if (n > max) return max;
+  return n;
+}
+function seedExistingSessionStarts(startedAt, sessions, now = Date.now()) {
+  for (const session of sessions) {
+    if (!startedAt.has(session.id)) {
+      startedAt.set(session.id, now);
+    }
+  }
+}
+
+// src/services/bridges/bridge.ts
 var AUTO_FORCE_SYNC_INTERVAL_MS = 9e4;
 var DEAD_SESSION_TIMEOUT_MS = 6e4;
 var Bridge = class {
@@ -147436,6 +147459,11 @@ var Bridge = class {
   autoForceSyncTimer = null;
   deadSessionTimer = null;
   staleSessionTimers = /* @__PURE__ */ new Map();
+  // Age-based session rotation (#287): track when each session opened so an
+  // aged controller session can be rotated, forcing it to re-subscribe.
+  sessionStartedAt = /* @__PURE__ */ new Map();
+  rotationTimer = null;
+  maxSessionAgeMs = 0;
   // Serialize concurrent lifecycle calls so auto-recovery and a manual
   // restartBridge can't race past each other's Starting/Stopping states.
   startInFlight;
@@ -147588,6 +147616,7 @@ var Bridge = class {
         });
       }
       this.wireSessionDiagnostics();
+      this.startSessionRotation();
       logMemoryUsage(this.log, "bridge running");
       diagnosticEventBus.emit("bridge_started", `Bridge started`, {
         bridgeId: this.id,
@@ -147645,6 +147674,7 @@ ${e?.toString()}`);
   wireSessionDiagnostics() {
     try {
       const sessionManager = this.server.env.get(SessionManager);
+      seedExistingSessionStarts(this.sessionStartedAt, sessionManager.sessions);
       this.sessionDiagHandler = (session) => {
         const sessions = [...sessionManager.sessions];
         let totalSubs = 0;
@@ -147703,6 +147733,7 @@ ${e?.toString()}`);
       };
       sessionManager.subscriptionsChanged.on(this.sessionDiagHandler);
       this.sessionAddedHandler = (newSession) => {
+        this.sessionStartedAt.set(newSession.id, Date.now());
         this.log.info(
           `Session opened: id=${newSession.id} peer=${newSession.peerNodeId}`
         );
@@ -147728,6 +147759,7 @@ ${e?.toString()}`);
         }
       };
       this.sessionDeletedHandler = (session) => {
+        this.sessionStartedAt.delete(session.id);
         const sessions = [...sessionManager.sessions];
         this.log.warn(
           `Session closed: id=${session.id} peer=${session.peerNodeId} | remaining sessions=${sessions.length}`
@@ -147835,6 +147867,8 @@ ${e?.toString()}`);
       clearTimeout(timer);
     }
     this.staleSessionTimers.clear();
+    this.stopSessionRotation();
+    this.sessionStartedAt.clear();
   }
   stopAutoForceSync() {
     if (this.autoForceSyncTimer) {
@@ -147842,12 +147876,100 @@ ${e?.toString()}`);
       this.autoForceSyncTimer = null;
     }
   }
+  // Start periodic age-based session rotation (#287). Aging out a controller's
+  // session forces it to re-establish and re-subscribe, recovering a wedged
+  // Alexa subscription that would otherwise stay stuck until a restart.
+  startSessionRotation() {
+    this.stopSessionRotation();
+    const hours = this.readSessionMaxAgeHours();
+    if (hours === 0) {
+      this.log.info(
+        "Session rotation disabled (HAMH_MATTER_SESSION_MAX_AGE_HOURS=0)"
+      );
+      return;
+    }
+    this.maxSessionAgeMs = hours * 60 * 60 * 1e3;
+    this.rotationTimer = setInterval(
+      () => this.rotateAgedSessions(),
+      ROTATION_CHECK_INTERVAL_MS
+    );
+    this.log.info(
+      `Session rotation: max age ${hours}h, check every ${ROTATION_CHECK_INTERVAL_MS / 6e4}min`
+    );
+  }
+  stopSessionRotation() {
+    if (this.rotationTimer) {
+      clearInterval(this.rotationTimer);
+      this.rotationTimer = null;
+    }
+  }
+  // Resolve the rotation max age. Bridge config wins, then the env var. An
+  // aggregator bridge holds many devices on one controller session, so
+  // rotating it re-subscribes them all at once. Rotation is therefore opt-in
+  // here: it stays disabled unless set via config or the env var.
+  readSessionMaxAgeHours() {
+    const { min, max } = SESSION_MAX_AGE_HOURS_RANGE;
+    const fromConfig = this.dataProvider.sessionMaxAgeHours;
+    if (fromConfig != null && Number.isFinite(fromConfig) && fromConfig >= 0) {
+      if (fromConfig === 0) return 0;
+      if (fromConfig < min) return min;
+      if (fromConfig > max) return max;
+      return fromConfig;
+    }
+    const raw = process.env.HAMH_MATTER_SESSION_MAX_AGE_HOURS;
+    if (raw == null || raw === "") {
+      return 0;
+    }
+    const parsed = parseSessionMaxAgeHours(raw);
+    if (parsed == null) {
+      this.log.warn(
+        `Invalid HAMH_MATTER_SESSION_MAX_AGE_HOURS=${raw}, disabling session rotation`
+      );
+      return 0;
+    }
+    return parsed;
+  }
+  // Gracefully close sessions older than maxSessionAgeMs that still hold
+  // subscriptions, so the controller re-establishes CASE and re-subscribes.
+  // 0-sub sessions are handled by the dead/stale-session path.
+  rotateAgedSessions() {
+    if (this.maxSessionAgeMs === 0) return;
+    try {
+      const sessionManager = this.server.env.get(SessionManager);
+      const now = Date.now();
+      const closes = [];
+      for (const s of [...sessionManager.sessions]) {
+        const startedAt = this.sessionStartedAt.get(s.id);
+        if (startedAt == null) continue;
+        const ageMs = now - startedAt;
+        if (ageMs < this.maxSessionAgeMs || s.isClosing || s.subscriptions.size === 0) {
+          continue;
+        }
+        const ageMin = Math.round(ageMs / 6e4);
+        this.log.info(
+          `Rotating session ${s.id} (peer ${s.peerNodeId}, age ${ageMin}min, subs ${s.subscriptions.size})`
+        );
+        closes.push(
+          s.initiateClose().catch(() => {
+            return s.initiateForceClose({
+              cause: new Error("session rotation, forcing")
+            });
+          })
+        );
+      }
+      if (closes.length > 0) {
+        Promise.allSettled(closes).then(() => this.triggerMdnsReAnnounce());
+      }
+    } catch {
+    }
+  }
   async update(update) {
     try {
       this.dataProvider.update(update);
       await this.refreshDevices();
       if (this.status.code === BridgeStatus.Running) {
         this.startAutoForceSyncIfEnabled();
+        this.startSessionRotation();
       }
     } catch (e) {
       const reason = "Failed to update bridge due to error:";
@@ -160910,6 +161032,7 @@ var EntityIsolationService = new EntityIsolationServiceImpl();
 
 // src/services/bridges/bridge-endpoint-manager.ts
 var MAX_ENTITY_ID_LENGTH = 150;
+var ENDPOINT_REMOVAL_GRACE_MS = 6e4;
 var BridgeEndpointManager = class extends Service {
   constructor(client, registry2, mappingStorage, bridgeId, log, pluginManager, pluginRegistry, pluginInstaller) {
     super("BridgeEndpointManager");
@@ -160943,6 +161066,9 @@ var BridgeEndpointManager = class extends Service {
   unsubscribe;
   _failedEntities = [];
   mappingFingerprints = /* @__PURE__ */ new Map();
+  // entityId -> first time it went missing from the registry (grace window)
+  pendingRemovals = /* @__PURE__ */ new Map();
+  removalRecheckTimer = null;
   pluginEndpoints = /* @__PURE__ */ new Map();
   pluginStateUpdating = /* @__PURE__ */ new Set();
   pluginListeners = /* @__PURE__ */ new Map();
@@ -161145,8 +161271,26 @@ var BridgeEndpointManager = class extends Service {
       } catch (e) {
         this.log.error(`Failed to delete isolated endpoint:`, e);
       }
+      this.pendingRemovals.delete(endpoint.entityId);
+      this.mappingFingerprints.delete(endpoint.entityId);
     }
   }
+  // refreshDevices only runs on registry-fingerprint changes, which may not
+  // recur, so drive any held removals to completion ourselves once the grace
+  // window has passed.
+  scheduleRemovalRecheck() {
+    if (this.removalRecheckTimer) {
+      clearTimeout(this.removalRecheckTimer);
+      this.removalRecheckTimer = null;
+    }
+    if (this.pendingRemovals.size === 0) return;
+    this.removalRecheckTimer = setTimeout(() => {
+      this.removalRecheckTimer = null;
+      this.refreshDevices().catch(
+        (e) => this.log.warn("Endpoint removal recheck failed:", e)
+      );
+    }, ENDPOINT_REMOVAL_GRACE_MS + 5e3);
+  }
   getPluginDomainMappings() {
     if (!this.pluginManager) return void 0;
     const mappings = this.pluginManager.getDomainMappings();
@@ -161166,6 +161310,11 @@ var BridgeEndpointManager = class extends Service {
   }
   async dispose() {
     this.stopObserving();
+    if (this.removalRecheckTimer) {
+      clearTimeout(this.removalRecheckTimer);
+      this.removalRecheckTimer = null;
+    }
+    this.pendingRemovals.clear();
     EntityIsolationService.unregisterIsolationCallback(this.bridgeId);
     EntityIsolationService.clearIsolatedEntities(this.bridgeId);
     const endpoints = this.root.parts.map((p) => p);
@@ -161232,14 +161381,30 @@ var BridgeEndpointManager = class extends Service {
       }
     }
     const existingEndpoints = [];
+    const now = Date.now();
     for (const endpoint of endpoints) {
-      if (!this.entityIds.includes(endpoint.entityId)) {
+      const present = this.entityIds.includes(endpoint.entityId);
+      if (present) {
+        this.pendingRemovals.delete(endpoint.entityId);
+      }
+      if (!present) {
+        const since = this.pendingRemovals.get(endpoint.entityId);
+        if (since == null) {
+          this.pendingRemovals.set(endpoint.entityId, now);
+          existingEndpoints.push(endpoint);
+          continue;
+        }
+        if (now - since < ENDPOINT_REMOVAL_GRACE_MS) {
+          existingEndpoints.push(endpoint);
+          continue;
+        }
         try {
           await endpoint.delete();
         } catch (e) {
           this.log.warn(`Failed to delete endpoint ${endpoint.entityId}:`, e);
         }
         this.mappingFingerprints.delete(endpoint.entityId);
+        this.pendingRemovals.delete(endpoint.entityId);
       } else if (this.registry.isAutoComposedDevicesEnabled() && this.registry.isComposedSubEntityUsed(endpoint.entityId)) {
         this.log.info(
           `Deleting standalone endpoint ${endpoint.entityId}, consumed by composed device`
@@ -161275,6 +161440,7 @@ var BridgeEndpointManager = class extends Service {
         }
       }
     }
+    this.scheduleRemovalRecheck();
     let memoryLimitReached = false;
     for (const entityId of this.entityIds) {
       if (!memoryLimitReached && isHeapUnderPressure()) {
@@ -162159,26 +162325,6 @@ init_dist();
 init_diagnostic_event_bus();
 var AUTO_FORCE_SYNC_INTERVAL_MS2 = 9e4;
 var DEAD_SESSION_TIMEOUT_MS2 = 6e4;
-var DEFAULT_SESSION_MAX_AGE_HOURS = 4;
-var SESSION_MAX_AGE_HOURS_RANGE = { min: 1, max: 168 };
-var ROTATION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
-function parseSessionMaxAgeHours(raw) {
-  if (raw == null || raw === "") return DEFAULT_SESSION_MAX_AGE_HOURS;
-  const n = Number.parseInt(raw, 10);
-  if (Number.isNaN(n) || n < 0) return null;
-  if (n === 0) return 0;
-  const { min, max } = SESSION_MAX_AGE_HOURS_RANGE;
-  if (n < min) return min;
-  if (n > max) return max;
-  return n;
-}
-function seedExistingSessionStarts(startedAt, sessions, now = Date.now()) {
-  for (const session of sessions) {
-    if (!startedAt.has(session.id)) {
-      startedAt.set(session.id, now);
-    }
-  }
-}
 function makeWarmStartState(state, now = (/* @__PURE__ */ new Date()).toISOString()) {
   return { ...state, last_updated: now };
 }