@riddix/hamh 2.1.0-alpha.711 → 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
         },
@@ -145361,6 +145360,15 @@ var ServerModeServerNode = class extends ServerNode {
       );
     }
   }
+  // align the pairing device-type hint with the real device (default is vacuum)
+  async updateAdvertisedDeviceType(deviceType) {
+    try {
+      await this.set({ productDescription: { deviceType } });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      logger180.warn(`Failed to set server-mode device type: ${msg}`);
+    }
+  }
   async factoryReset() {
     await this.cancel();
     await this.erase();
@@ -147389,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 {
@@ -147427,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;
@@ -147579,6 +147616,7 @@ var Bridge = class {
         });
       }
       this.wireSessionDiagnostics();
+      this.startSessionRotation();
       logMemoryUsage(this.log, "bridge running");
       diagnosticEventBus.emit("bridge_started", `Bridge started`, {
         bridgeId: this.id,
@@ -147636,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;
@@ -147694,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}`
         );
@@ -147719,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}`
@@ -147826,6 +147867,8 @@ ${e?.toString()}`);
       clearTimeout(timer);
     }
     this.staleSessionTimers.clear();
+    this.stopSessionRotation();
+    this.sessionStartedAt.clear();
   }
   stopAutoForceSync() {
     if (this.autoForceSyncTimer) {
@@ -147833,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:";
@@ -160218,10 +160349,29 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
   }
 };
 
+// src/matter/endpoints/standalone-endpoint-type.ts
+init_esm7();
+var BRIDGED_INFO_ID = "bridgedDeviceBasicInformation";
+function asStandaloneEndpointType(type) {
+  const behaviors = type.behaviors;
+  if (!(BRIDGED_INFO_ID in behaviors)) {
+    return type;
+  }
+  const kept = Object.entries(behaviors).filter(([id]) => id !== BRIDGED_INFO_ID).map(([, behavior]) => behavior);
+  return MutableEndpoint({
+    name: type.name,
+    deviceType: type.deviceType,
+    deviceRevision: type.deviceRevision,
+    deviceClass: type.deviceClass,
+    requirements: type.requirements,
+    behaviors: SupportedBehaviors(...kept)
+  });
+}
+
 // src/matter/endpoints/legacy/legacy-endpoint.ts
 var logger225 = Logger.get("LegacyEndpoint");
 var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
-  static async create(registry2, entityId, mapping, pluginDomainMappings) {
+  static async create(registry2, entityId, mapping, pluginDomainMappings, standalone = false) {
     const deviceRegistry = registry2.deviceOf(entityId);
     let state = registry2.initialState(entityId);
     const entity = registry2.entity(entityId);
@@ -160547,7 +160697,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       }
     }
     const areaName = registry2.getAreaName(entityId);
-    const type = createLegacyEndpointType(payload, effectiveMapping, areaName, {
+    let type = createLegacyEndpointType(payload, effectiveMapping, areaName, {
       vacuumOnOff: registry2.isVacuumOnOffEnabled(),
       cleaningModeOptions,
       pluginDomainMappings
@@ -160555,6 +160705,9 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
     if (!type) {
       return;
     }
+    if (standalone) {
+      type = asStandaloneEndpointType(type);
+    }
     const customName = effectiveMapping?.customName;
     const mappedIds = getMappedEntityIds(effectiveMapping);
     return new _LegacyEndpoint(type, entityId, customName, mappedIds);
@@ -160879,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");
@@ -160912,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();
@@ -161114,7 +161271,25 @@ 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;
@@ -161135,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);
@@ -161201,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`
@@ -161244,6 +161440,7 @@ var BridgeEndpointManager = class extends Service {
         }
       }
     }
+    this.scheduleRemovalRecheck();
     let memoryLimitReached = false;
     for (const entityId of this.entityIds) {
       if (!memoryLimitReached && isHeapUnderPressure()) {
@@ -162128,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 };
 }
@@ -163243,7 +163420,9 @@ var ServerModeEndpointManager = class extends Service {
       const endpoint = await LegacyEndpoint.create(
         this.registry,
         entityId,
-        mapping
+        mapping,
+        void 0,
+        true
       );
       if (!endpoint) {
         this._failedEntities.push({
@@ -163286,6 +163465,10 @@ var ServerModeEndpointManager = class extends Service {
       mapping,
       friendlyName
     );
+    const deviceType = this.deviceEndpoint?.type?.deviceType;
+    if (deviceType != null) {
+      await this.serverNode.updateAdvertisedDeviceType(deviceType);
+    }
   }
   /**
    * Creates a Server Mode Vacuum endpoint without BridgedDeviceBasicInformation.