@riddix/hamh 2.1.0-alpha.756 → 2.1.0-alpha.757

package/dist/backend/cli.js

@@ -124630,7 +124630,8 @@ function buildEntityDiagnostics(exposed, failed, warnings) {
   const result = failed.map((f) => ({
     entityId: f.entityId,
     status: "failed",
-    reason: f.reason
+    reason: f.reason,
+    failedAt: f.failedAt
   }));
   const failedIds = new Set(failed.map((f) => f.entityId));
   const issuesByEntity = /* @__PURE__ */ new Map();
@@ -127169,7 +127170,8 @@ function healthApi(bridgeService, haClient, version2, startTime) {
       recovery: {
         enabled: bridgeService.autoRecoveryEnabled,
         lastRecoveryAttempt: bridgeService.lastRecoveryAttempt?.toISOString(),
-        recoveryCount: bridgeService.recoveryCount
+        recoveryCount: bridgeService.recoveryCount,
+        history: bridgeService.recoveryHistory
       }
     };
     res.json(detailed);
@@ -129336,7 +129338,177 @@ function buildPath(...paths) {
 
 // src/api/settings-api.ts
 import { Router as Router2 } from "express";
-function settingsApi(settingsStorage, envAuth) {
+
+// src/services/storage/app-settings-storage.ts
+init_service();
+import { randomBytes as randomBytes2, scryptSync, timingSafeEqual } from "node:crypto";
+var SCRYPT_KEYLEN = 64;
+var SCRYPT_COST_N = 16384;
+var SCRYPT_BLOCK_R = 8;
+var SCRYPT_PARALLEL_P = 1;
+var SALT_BYTES = 16;
+var DEFAULT_BACKUP_SETTINGS = {
+  autoBackup: true,
+  backupRetentionCount: 5
+};
+var MIN_RECOVERY_INTERVAL_MS = 1e4;
+var MAX_RECOVERY_INTERVAL_MS = 36e5;
+var DEFAULT_RECOVERY_SETTINGS = {
+  autoRecoveryEnabled: true,
+  recoveryIntervalMs: 6e4
+};
+function hashPassword(plain2) {
+  const salt = randomBytes2(SALT_BYTES);
+  const derived = scryptSync(plain2, salt, SCRYPT_KEYLEN, {
+    N: SCRYPT_COST_N,
+    r: SCRYPT_BLOCK_R,
+    p: SCRYPT_PARALLEL_P
+  });
+  return {
+    passwordHash: derived.toString("hex"),
+    passwordSalt: salt.toString("hex")
+  };
+}
+function verifyPasswordHash(plain2, passwordHash, passwordSalt) {
+  let expected;
+  let salt;
+  try {
+    expected = Buffer.from(passwordHash, "hex");
+    salt = Buffer.from(passwordSalt, "hex");
+  } catch {
+    return false;
+  }
+  if (expected.length !== SCRYPT_KEYLEN || salt.length === 0) {
+    return false;
+  }
+  const derived = scryptSync(plain2, salt, SCRYPT_KEYLEN, {
+    N: SCRYPT_COST_N,
+    r: SCRYPT_BLOCK_R,
+    p: SCRYPT_PARALLEL_P
+  });
+  return timingSafeEqual(derived, expected);
+}
+function constantTimeStringEquals(a, b) {
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  if (bufA.length !== bufB.length) {
+    timingSafeEqual(bufA, bufA);
+    return false;
+  }
+  return timingSafeEqual(bufA, bufB);
+}
+var AppSettingsStorage = class extends Service {
+  constructor(appStorage) {
+    super("AppSettingsStorage");
+    this.appStorage = appStorage;
+  }
+  appStorage;
+  storage;
+  settings = {};
+  // Caches the last plaintext password that was successfully verified
+  // against the stored hash, keyed by username. This lets repeated basic-auth
+  // calls avoid re-running scrypt on every HTTP request without persisting
+  // the plaintext to disk.
+  verifiedPassword = null;
+  async initialize() {
+    this.storage = this.appStorage.createContext("settings");
+    const stored = await this.storage.get(
+      "data",
+      {}
+    );
+    this.settings = stored ?? {};
+  }
+  get auth() {
+    if (!this.settings.auth) {
+      return void 0;
+    }
+    return { username: this.settings.auth.username };
+  }
+  async setAuth(credentials) {
+    if (!credentials) {
+      this.settings.auth = void 0;
+      this.verifiedPassword = null;
+    } else {
+      const { passwordHash, passwordSalt } = hashPassword(credentials.password);
+      this.settings.auth = {
+        username: credentials.username,
+        passwordHash,
+        passwordSalt
+      };
+      this.verifiedPassword = {
+        username: credentials.username,
+        password: credentials.password
+      };
+    }
+    await this.persist();
+  }
+  verifyAuth(username, password) {
+    const stored = this.settings.auth;
+    if (!stored) {
+      return false;
+    }
+    if (!constantTimeStringEquals(username, stored.username)) {
+      return false;
+    }
+    if (this.verifiedPassword && this.verifiedPassword.username === stored.username && constantTimeStringEquals(password, this.verifiedPassword.password)) {
+      return true;
+    }
+    if (stored.password !== void 0) {
+      const matches = constantTimeStringEquals(password, stored.password);
+      if (matches) {
+        this.verifiedPassword = { username: stored.username, password };
+        void this.migrateLegacyPlaintext(password);
+      }
+      return matches;
+    }
+    if (stored.passwordHash && stored.passwordSalt) {
+      if (verifyPasswordHash(password, stored.passwordHash, stored.passwordSalt)) {
+        this.verifiedPassword = { username: stored.username, password };
+        return true;
+      }
+    }
+    return false;
+  }
+  async migrateLegacyPlaintext(plain2) {
+    const current = this.settings.auth;
+    if (!current || current.password === void 0) {
+      return;
+    }
+    const { passwordHash, passwordSalt } = hashPassword(plain2);
+    this.settings.auth = {
+      username: current.username,
+      passwordHash,
+      passwordSalt
+    };
+    try {
+      await this.persist();
+    } catch {
+    }
+  }
+  get backupSettings() {
+    return { ...DEFAULT_BACKUP_SETTINGS, ...this.settings.backup };
+  }
+  async setBackupSettings(settings) {
+    this.settings.backup = { ...this.settings.backup, ...settings };
+    await this.persist();
+  }
+  get recoverySettings() {
+    return { ...DEFAULT_RECOVERY_SETTINGS, ...this.settings.recovery };
+  }
+  async setRecoverySettings(settings) {
+    this.settings.recovery = { ...this.settings.recovery, ...settings };
+    await this.persist();
+  }
+  async persist() {
+    await this.storage.set(
+      "data",
+      this.settings
+    );
+  }
+};
+
+// src/api/settings-api.ts
+function settingsApi(settingsStorage, bridgeService, envAuth) {
   const router = Router2();
   router.get("/auth", (_req, res) => {
     if (envAuth) {
@@ -129393,6 +129565,31 @@ function settingsApi(settingsStorage, envAuth) {
       res.json({ enabled: false, source: "none" });
     }
   );
+  router.get("/recovery", (_req, res) => {
+    res.json(settingsStorage.recoverySettings);
+  });
+  router.put(
+    "/recovery",
+    async (req, res) => {
+      const next = { ...settingsStorage.recoverySettings };
+      const { autoRecoveryEnabled, recoveryIntervalMs } = req.body;
+      if (typeof autoRecoveryEnabled === "boolean") {
+        next.autoRecoveryEnabled = autoRecoveryEnabled;
+      }
+      if (typeof recoveryIntervalMs === "number") {
+        if (recoveryIntervalMs < MIN_RECOVERY_INTERVAL_MS || recoveryIntervalMs > MAX_RECOVERY_INTERVAL_MS) {
+          res.status(400).json({
+            error: `recoveryIntervalMs must be between ${MIN_RECOVERY_INTERVAL_MS} and ${MAX_RECOVERY_INTERVAL_MS}`
+          });
+          return;
+        }
+        next.recoveryIntervalMs = recoveryIntervalMs;
+      }
+      await settingsStorage.setRecoverySettings(next);
+      bridgeService.applyRecoverySettings(next);
+      res.json(next);
+    }
+  );
   return router;
 }
 
@@ -129824,7 +130021,10 @@ var WebApi = class extends Service {
     ).use("/bridges", bridgeExportApi(this.bridgeStorage)).use("/bridge-icons", bridgeIconApi(this.props.storageLocation)).use(
       "/device-images",
       deviceImageApi(this.props.storageLocation, this.haRegistry)
-    ).use("/entity-mappings", entityMappingApi(this.mappingStorage)).use("/mapping-profiles", mappingProfileApi(this.mappingStorage)).use("/lock-credentials", lockCredentialApi(this.lockCredentialStorage)).use("/settings", settingsApi(this.settingsStorage, this.props.auth)).use(
+    ).use("/entity-mappings", entityMappingApi(this.mappingStorage)).use("/mapping-profiles", mappingProfileApi(this.mappingStorage)).use("/lock-credentials", lockCredentialApi(this.lockCredentialStorage)).use(
+      "/settings",
+      settingsApi(this.settingsStorage, this.bridgeService, this.props.auth)
+    ).use(
       "/backup",
       backupApi(
         this.bridgeStorage,
@@ -130611,13 +130811,23 @@ var BridgeFactory = class extends Service {
 init_esm();
 init_service();
 import crypto3 from "node:crypto";
-var BridgeService = class extends Service {
+function clampRecoveryInterval(ms) {
+  if (!Number.isFinite(ms)) return 6e4;
+  return Math.min(
+    Math.max(ms, MIN_RECOVERY_INTERVAL_MS),
+    MAX_RECOVERY_INTERVAL_MS
+  );
+}
+var BridgeService = class _BridgeService extends Service {
   constructor(bridgeStorage, bridgeFactory, props) {
     super("BridgeService");
     this.bridgeStorage = bridgeStorage;
     this.bridgeFactory = bridgeFactory;
     this.props = props;
     this.autoRecoveryEnabled = props.autoRecovery ?? true;
+    this.recoveryIntervalMs = clampRecoveryInterval(
+      props.recoveryIntervalMs ?? 6e4
+    );
   }
   bridgeStorage;
   bridgeFactory;
@@ -130631,6 +130841,12 @@ var BridgeService = class extends Service {
   // Set by the caller (e.g. start-handler) to broadcast updates via WebSocket.
   onBridgeChanged;
   recoveryInterval;
+  recoveryIntervalMs = 6e4;
+  recoveryInProgress = false;
+  _recoveryHistory = [];
+  lastReactiveRecovery = 0;
+  static MAX_RECOVERY_HISTORY = 20;
+  static REACTIVE_DEBOUNCE_MS = 5e3;
   async initialize() {
     for (const data of this.bridgeStorage.bridges) {
       const normalized = this.normalizeBridgeData(data);
@@ -130653,24 +130869,80 @@ var BridgeService = class extends Service {
     };
   }
   startAutoRecovery() {
-    const intervalMs = this.props.recoveryIntervalMs ?? 6e4;
     this.recoveryInterval = setInterval(() => {
       this.attemptRecovery();
-    }, intervalMs);
+    }, this.recoveryIntervalMs);
+  }
+  stopAutoRecovery() {
+    if (this.recoveryInterval) {
+      clearInterval(this.recoveryInterval);
+      this.recoveryInterval = void 0;
+    }
+  }
+  get recoverySettings() {
+    return {
+      autoRecoveryEnabled: this.autoRecoveryEnabled,
+      recoveryIntervalMs: this.recoveryIntervalMs
+    };
+  }
+  get recoveryHistory() {
+    return [...this._recoveryHistory];
+  }
+  // Apply persisted recovery settings (at startup) or a change from the UI.
+  applyRecoverySettings(settings) {
+    this.autoRecoveryEnabled = settings.autoRecoveryEnabled;
+    this.recoveryIntervalMs = clampRecoveryInterval(
+      settings.recoveryIntervalMs
+    );
+    this.stopAutoRecovery();
+    if (this.autoRecoveryEnabled) {
+      this.startAutoRecovery();
+    }
+  }
+  // Run a recovery pass right away, e.g. just after Home Assistant reconnects,
+  // instead of waiting for the next interval. Debounced so a burst of reconnect
+  // events only triggers one pass. Still only touches failed bridges.
+  recoverFailedBridgesNow() {
+    if (!this.autoRecoveryEnabled) return;
+    const now = Date.now();
+    if (now - this.lastReactiveRecovery < _BridgeService.REACTIVE_DEBOUNCE_MS) {
+      return;
+    }
+    this.lastReactiveRecovery = now;
+    void this.attemptRecovery();
   }
   async attemptRecovery() {
+    if (this.recoveryInProgress) return;
     const failedBridges = this.bridges.filter(
       (b) => b.data.status === "failed"
     );
     if (failedBridges.length === 0) return;
+    this.recoveryInProgress = true;
     this.lastRecoveryAttempt = /* @__PURE__ */ new Date();
-    for (const bridge of failedBridges) {
-      try {
-        await bridge.start();
-        this.recoveryCount++;
-      } catch (e) {
-        this.log.warn(`Recovery attempt failed for bridge ${bridge.id}:`, e);
+    try {
+      for (const bridge of failedBridges) {
+        try {
+          await bridge.start();
+          this.recoveryCount++;
+          this.recordRecovery(bridge, "success");
+        } catch (e) {
+          this.log.warn(`Recovery attempt failed for bridge ${bridge.id}:`, e);
+          this.recordRecovery(bridge, "failed");
+        }
       }
+    } finally {
+      this.recoveryInProgress = false;
+    }
+  }
+  recordRecovery(bridge, outcome) {
+    this._recoveryHistory.push({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      bridgeId: bridge.id,
+      bridgeName: bridge.data.name,
+      outcome
+    });
+    if (this._recoveryHistory.length > _BridgeService.MAX_RECOVERY_HISTORY) {
+      this._recoveryHistory.shift();
     }
   }
   async restartBridge(bridgeId) {
@@ -130681,9 +130953,7 @@ var BridgeService = class extends Service {
     return true;
   }
   async dispose() {
-    if (this.recoveryInterval) {
-      clearInterval(this.recoveryInterval);
-    }
+    this.stopAutoRecovery();
     await Promise.all(this.bridges.map((bridge) => bridge.dispose()));
   }
   getNextAvailablePort(startPort = 5540) {
@@ -131259,161 +131529,6 @@ function mockDeviceId(entityId) {
   return `e__${hash2}`;
 }
 
-// src/services/storage/app-settings-storage.ts
-init_service();
-import { randomBytes as randomBytes2, scryptSync, timingSafeEqual } from "node:crypto";
-var SCRYPT_KEYLEN = 64;
-var SCRYPT_COST_N = 16384;
-var SCRYPT_BLOCK_R = 8;
-var SCRYPT_PARALLEL_P = 1;
-var SALT_BYTES = 16;
-var DEFAULT_BACKUP_SETTINGS = {
-  autoBackup: true,
-  backupRetentionCount: 5
-};
-function hashPassword(plain2) {
-  const salt = randomBytes2(SALT_BYTES);
-  const derived = scryptSync(plain2, salt, SCRYPT_KEYLEN, {
-    N: SCRYPT_COST_N,
-    r: SCRYPT_BLOCK_R,
-    p: SCRYPT_PARALLEL_P
-  });
-  return {
-    passwordHash: derived.toString("hex"),
-    passwordSalt: salt.toString("hex")
-  };
-}
-function verifyPasswordHash(plain2, passwordHash, passwordSalt) {
-  let expected;
-  let salt;
-  try {
-    expected = Buffer.from(passwordHash, "hex");
-    salt = Buffer.from(passwordSalt, "hex");
-  } catch {
-    return false;
-  }
-  if (expected.length !== SCRYPT_KEYLEN || salt.length === 0) {
-    return false;
-  }
-  const derived = scryptSync(plain2, salt, SCRYPT_KEYLEN, {
-    N: SCRYPT_COST_N,
-    r: SCRYPT_BLOCK_R,
-    p: SCRYPT_PARALLEL_P
-  });
-  return timingSafeEqual(derived, expected);
-}
-function constantTimeStringEquals(a, b) {
-  const bufA = Buffer.from(a);
-  const bufB = Buffer.from(b);
-  if (bufA.length !== bufB.length) {
-    timingSafeEqual(bufA, bufA);
-    return false;
-  }
-  return timingSafeEqual(bufA, bufB);
-}
-var AppSettingsStorage = class extends Service {
-  constructor(appStorage) {
-    super("AppSettingsStorage");
-    this.appStorage = appStorage;
-  }
-  appStorage;
-  storage;
-  settings = {};
-  // Caches the last plaintext password that was successfully verified
-  // against the stored hash, keyed by username. This lets repeated basic-auth
-  // calls avoid re-running scrypt on every HTTP request without persisting
-  // the plaintext to disk.
-  verifiedPassword = null;
-  async initialize() {
-    this.storage = this.appStorage.createContext("settings");
-    const stored = await this.storage.get(
-      "data",
-      {}
-    );
-    this.settings = stored ?? {};
-  }
-  get auth() {
-    if (!this.settings.auth) {
-      return void 0;
-    }
-    return { username: this.settings.auth.username };
-  }
-  async setAuth(credentials) {
-    if (!credentials) {
-      this.settings.auth = void 0;
-      this.verifiedPassword = null;
-    } else {
-      const { passwordHash, passwordSalt } = hashPassword(credentials.password);
-      this.settings.auth = {
-        username: credentials.username,
-        passwordHash,
-        passwordSalt
-      };
-      this.verifiedPassword = {
-        username: credentials.username,
-        password: credentials.password
-      };
-    }
-    await this.persist();
-  }
-  verifyAuth(username, password) {
-    const stored = this.settings.auth;
-    if (!stored) {
-      return false;
-    }
-    if (!constantTimeStringEquals(username, stored.username)) {
-      return false;
-    }
-    if (this.verifiedPassword && this.verifiedPassword.username === stored.username && constantTimeStringEquals(password, this.verifiedPassword.password)) {
-      return true;
-    }
-    if (stored.password !== void 0) {
-      const matches = constantTimeStringEquals(password, stored.password);
-      if (matches) {
-        this.verifiedPassword = { username: stored.username, password };
-        void this.migrateLegacyPlaintext(password);
-      }
-      return matches;
-    }
-    if (stored.passwordHash && stored.passwordSalt) {
-      if (verifyPasswordHash(password, stored.passwordHash, stored.passwordSalt)) {
-        this.verifiedPassword = { username: stored.username, password };
-        return true;
-      }
-    }
-    return false;
-  }
-  async migrateLegacyPlaintext(plain2) {
-    const current = this.settings.auth;
-    if (!current || current.password === void 0) {
-      return;
-    }
-    const { passwordHash, passwordSalt } = hashPassword(plain2);
-    this.settings.auth = {
-      username: current.username,
-      passwordHash,
-      passwordSalt
-    };
-    try {
-      await this.persist();
-    } catch {
-    }
-  }
-  get backupSettings() {
-    return { ...DEFAULT_BACKUP_SETTINGS, ...this.settings.backup };
-  }
-  async setBackupSettings(settings) {
-    this.settings.backup = { ...this.settings.backup, ...settings };
-    await this.persist();
-  }
-  async persist() {
-    await this.storage.set(
-      "data",
-      this.settings
-    );
-  }
-};
-
 // src/services/storage/app-storage.ts
 init_service();
 var AppStorage = class extends Service {
@@ -163000,7 +163115,11 @@ var EntityIsolationServiceImpl = class {
       return true;
     }
     const reason = `${classification}. Entity isolated to protect bridge stability.`;
-    this.isolatedEntities.set(key, { entityId: entityName, reason });
+    this.isolatedEntities.set(key, {
+      entityId: entityName,
+      reason,
+      failedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     logger231.warn(
       `Isolating entity "${entityName}" from bridge ${bridgeId} due to: ${reason}`
     );
@@ -163088,6 +163207,13 @@ var BridgeEndpointManager = class extends Service {
     const isolated = EntityIsolationService.getIsolatedEntities(this.bridgeId);
     return [...this._failedEntities, ...isolated];
   }
+  addFailedEntity(entityId, reason) {
+    this._failedEntities.push({
+      entityId,
+      reason,
+      failedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
   wirePluginCallbacks() {
     if (!this.pluginManager) return;
     this.pluginManager.onDeviceRegistered = async (pluginName, device) => {
@@ -163498,10 +163624,10 @@ var BridgeEndpointManager = class extends Service {
       }
       if (memoryLimitReached) {
         if (!existingEndpoints.some((e) => e.entityId === entityId)) {
-          this._failedEntities.push({
+          this.addFailedEntity(
             entityId,
-            reason: "Skipped due to memory pressure, reduce entities or increase heap size"
-          });
+            "Skipped due to memory pressure, reduce entities or increase heap size"
+          );
         }
         continue;
       }
@@ -163519,7 +163645,7 @@ var BridgeEndpointManager = class extends Service {
       if (entityId.length > MAX_ENTITY_ID_LENGTH) {
         const reason = `Entity ID too long (${entityId.length} chars, max ${MAX_ENTITY_ID_LENGTH}). This would cause filesystem errors.`;
         this.log.warn(`Skipping entity: ${entityId}. Reason: ${reason}`);
-        this._failedEntities.push({ entityId, reason });
+        this.addFailedEntity(entityId, reason);
         continue;
       }
       let endpoint = existingEndpoints.find((e) => e.entityId === entityId);
@@ -163535,7 +163661,7 @@ var BridgeEndpointManager = class extends Service {
         } catch (e) {
           const reason = this.extractErrorReason(e);
           this.log.warn(`Failed to create device ${entityId}: ${reason}`);
-          this._failedEntities.push({ entityId, reason });
+          this.addFailedEntity(entityId, reason);
           continue;
         }
         if (endpoint) {
@@ -163551,10 +163677,7 @@ var BridgeEndpointManager = class extends Service {
               `Failed to add endpoint for ${entityId}: ${errorMessage}`
             );
             this.logDetailedError(entityId, e);
-            this._failedEntities.push({
-              entityId,
-              reason: this.extractErrorReason(e)
-            });
+            this.addFailedEntity(entityId, this.extractErrorReason(e));
           }
         }
       }
@@ -166000,6 +166123,14 @@ async function startHandler(startOptions, webUiDist) {
   bridgeService.onBridgeChanged = (bridgeId) => {
     webApi.websocket.broadcastBridgeUpdate(bridgeId);
   };
+  const [haClient, settingsStorage] = await Promise.all([
+    appEnvironment.load(HomeAssistantClient),
+    appEnvironment.load(AppSettingsStorage)
+  ]);
+  bridgeService.applyRecoverySettings(settingsStorage.recoverySettings);
+  haClient.connection.addEventListener("ready", () => {
+    bridgeService.recoverFailedBridgesNow();
+  });
   let shuttingDown = false;
   const gracefulShutdown = async (signal) => {
     if (shuttingDown) return;