@riddix/hamh 2.1.0-alpha.526 → 2.1.0-alpha.528

package/dist/backend/cli.js

@@ -166283,6 +166283,7 @@ function validatePluginDevice(device) {
 }
 var PluginManager = class {
   instances = /* @__PURE__ */ new Map();
+  domainMappings = /* @__PURE__ */ new Map();
   storageDir;
   bridgeId;
   runner = new SafePluginRunner();
@@ -166414,6 +166415,21 @@ var PluginManager = class {
           clusterId3,
           attributes7
         );
+      },
+      registerDomainMapping: (mapping) => {
+        if (!mapping.domain || typeof mapping.domain !== "string" || !mapping.matterDeviceType || typeof mapping.matterDeviceType !== "string") {
+          pluginLogger.warn("Invalid domain mapping, skipping");
+          return;
+        }
+        if (this.domainMappings.has(mapping.domain)) {
+          pluginLogger.warn(
+            `Domain "${mapping.domain}" already mapped by another plugin, overwriting`
+          );
+        }
+        this.domainMappings.set(mapping.domain, mapping);
+        pluginLogger.info(
+          `Registered domain mapping: ${mapping.domain} \u2192 ${mapping.matterDeviceType}`
+        );
       }
     };
     this.instances.set(plugin.name, {
@@ -166539,6 +166555,9 @@ var PluginManager = class {
     if (!instance) return void 0;
     return instance.plugin.getConfigSchema?.();
   }
+  getDomainMappings() {
+    return new Map(this.domainMappings);
+  }
   async updateConfig(pluginName, config10) {
     const instance = this.instances.get(pluginName);
     if (!instance) return false;
@@ -169227,6 +169246,9 @@ init_esm7();
 import debounce4 from "debounce";
 init_home_assistant_entity_behavior();
 
+// src/matter/endpoints/legacy/create-legacy-endpoint-type.ts
+init_esm();
+
 // src/matter/endpoints/legacy/air-purifier/index.ts
 init_dist();
 init_home_assistant_entity_behavior();
@@ -173623,8 +173645,38 @@ var PumpType = PumpDevice.with(
   PumpOnOffServer,
   PumpConfigurationAndControlServer2
 );
+var PumpWithBatteryType = PumpDevice.with(
+  IdentifyServer2,
+  BasicInformationServer2,
+  HomeAssistantEntityBehavior,
+  PumpOnOffServer,
+  PumpConfigurationAndControlServer2,
+  PowerSourceServer2({
+    getBatteryPercent: (entity, agent) => {
+      const homeAssistant = agent.get(HomeAssistantEntityBehavior);
+      const batteryEntity = homeAssistant.state.mapping?.batteryEntity;
+      if (batteryEntity) {
+        const stateProvider = agent.env.get(EntityStateProvider);
+        const battery = stateProvider.getBatteryPercent(batteryEntity);
+        if (battery != null) {
+          return Math.max(0, Math.min(100, battery));
+        }
+      }
+      const attrs = entity.attributes;
+      const level = attrs.battery_level ?? attrs.battery;
+      if (level == null || Number.isNaN(Number(level))) {
+        return null;
+      }
+      return Number(level);
+    }
+  })
+);
 function PumpEndpoint(homeAssistantEntity) {
-  return PumpType.set({ homeAssistantEntity });
+  const attrs = homeAssistantEntity.entity.state.attributes;
+  const hasBatteryAttr = attrs.battery_level != null || attrs.battery != null;
+  const hasBatteryEntity = !!homeAssistantEntity.mapping?.batteryEntity;
+  const device = hasBatteryAttr || hasBatteryEntity ? PumpWithBatteryType : PumpType;
+  return device.set({ homeAssistantEntity });
 }
 
 // src/matter/endpoints/legacy/remote/index.ts
@@ -177644,8 +177696,37 @@ var ValveEndpointType = WaterValveDevice.with(
   HomeAssistantEntityBehavior,
   ValveServer
 );
+var ValveWithBatteryEndpointType = WaterValveDevice.with(
+  BasicInformationServer2,
+  IdentifyServer2,
+  HomeAssistantEntityBehavior,
+  ValveServer,
+  PowerSourceServer2({
+    getBatteryPercent: (entity, agent) => {
+      const homeAssistant = agent.get(HomeAssistantEntityBehavior);
+      const batteryEntity = homeAssistant.state.mapping?.batteryEntity;
+      if (batteryEntity) {
+        const stateProvider = agent.env.get(EntityStateProvider);
+        const battery = stateProvider.getBatteryPercent(batteryEntity);
+        if (battery != null) {
+          return Math.max(0, Math.min(100, battery));
+        }
+      }
+      const attrs = entity.attributes;
+      const level = attrs.battery_level ?? attrs.battery;
+      if (level == null || Number.isNaN(Number(level))) {
+        return null;
+      }
+      return Number(level);
+    }
+  })
+);
 function ValveDevice(homeAssistantEntity) {
-  return ValveEndpointType.set({ homeAssistantEntity });
+  const attrs = homeAssistantEntity.entity.state.attributes;
+  const hasBatteryAttr = attrs.battery_level != null || attrs.battery != null;
+  const hasBatteryEntity = !!homeAssistantEntity.mapping?.batteryEntity;
+  const device = hasBatteryAttr || hasBatteryEntity ? ValveWithBatteryEndpointType : ValveEndpointType;
+  return device.set({ homeAssistantEntity });
 }
 
 // src/matter/endpoints/legacy/water-heater/index.ts
@@ -177766,6 +177847,7 @@ function WaterHeaterDevice(homeAssistantEntity) {
 }
 
 // src/matter/endpoints/legacy/create-legacy-endpoint-type.ts
+var legacyLogger = Logger.get("LegacyEndpointType");
 function createLegacyEndpointType(entity, mapping, areaName, options) {
   const domain = entity.entity_id.split(".")[0];
   const customName = mapping?.customName;
@@ -177785,10 +177867,20 @@ function createLegacyEndpointType(entity, mapping, areaName, options) {
       );
     } else {
       const factory = deviceCtrs[domain];
-      if (!factory) {
+      if (factory) {
+        type = factory({ entity, customName, mapping });
+      } else if (options?.pluginDomainMappings?.has(domain)) {
+        const mappedType = options.pluginDomainMappings.get(domain);
+        const mappedFactory = matterDeviceTypeFactories[mappedType];
+        if (mappedFactory) {
+          legacyLogger.info(
+            `Using plugin domain mapping for "${domain}" \u2192 "${mappedType}"`
+          );
+          type = mappedFactory({ entity, customName, mapping });
+        }
+      } else {
         return void 0;
       }
-      type = factory({ entity, customName, mapping });
     }
   }
   if (!type) {
@@ -178131,7 +178223,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
 // src/matter/endpoints/legacy/legacy-endpoint.ts
 var logger199 = Logger.get("LegacyEndpoint");
 var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
-  static async create(registry2, entityId, mapping) {
+  static async create(registry2, entityId, mapping, pluginDomainMappings) {
     const deviceRegistry = registry2.deviceOf(entityId);
     let state = registry2.initialState(entityId);
     const entity = registry2.entity(entityId);
@@ -178426,7 +178518,8 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
     const areaName = registry2.getAreaName(entityId);
     const type = createLegacyEndpointType(payload, effectiveMapping, areaName, {
       vacuumOnOff: registry2.isVacuumOnOffEnabled(),
-      cleaningModeOptions
+      cleaningModeOptions,
+      pluginDomainMappings
     });
     if (!type) {
       return;
@@ -178930,6 +179023,16 @@ var BridgeEndpointManager = class extends Service {
       }
     }
   }
+  getPluginDomainMappings() {
+    if (!this.pluginManager) return void 0;
+    const mappings = this.pluginManager.getDomainMappings();
+    if (mappings.size === 0) return void 0;
+    const result = /* @__PURE__ */ new Map();
+    for (const [domain, mapping] of mappings) {
+      result.set(domain, mapping.matterDeviceType);
+    }
+    return result;
+  }
   getEntityMapping(entityId) {
     return this.mappingStorage.getMapping(this.bridgeId, entityId);
   }
@@ -179085,10 +179188,12 @@ var BridgeEndpointManager = class extends Service {
       let endpoint = existingEndpoints.find((e) => e.entityId === entityId);
       if (!endpoint) {
         try {
+          const domainMappings = this.getPluginDomainMappings();
           endpoint = await LegacyEndpoint.create(
             this.registry,
             entityId,
-            mapping
+            mapping,
+            domainMappings
           );
         } catch (e) {
           const reason = this.extractErrorReason(e);
@@ -181111,8 +181216,7 @@ process.on("unhandledRejection", (reason) => {
   if (shouldSuppressError(reason)) {
     return;
   }
-  console.error("Unhandled rejection:", reason);
-  process.exit(1);
+  console.error("Unhandled rejection (process continuing):", reason);
 });
 function registerFinalErrorHandlers() {
   process.removeAllListeners("uncaughtException");
@@ -181138,8 +181242,7 @@ function registerFinalErrorHandlers() {
       console.warn("Suppressed Matter.js internal error:", reason);
       return;
     }
-    console.error("Unhandled rejection:", reason);
-    process.exit(1);
+    console.error("Unhandled rejection (process continuing):", reason);
   });
 }
 async function startHandler(startOptions, webUiDist) {