@riddix/hamh 2.1.0-alpha.455 → 2.1.0-alpha.456

package/dist/backend/cli.js

@@ -146556,6 +146556,13 @@ var init_lock_credential = __esm({
   }
 });
 
+// ../common/dist/mapping-profile.js
+var init_mapping_profile = __esm({
+  "../common/dist/mapping-profile.js"() {
+    "use strict";
+  }
+});
+
 // ../common/dist/schemas/bridge-config-schema.js
 var homeAssistantMatcherSchema, homeAssistantFilterSchema, featureFlagSchema, bridgeConfigSchema;
 var init_bridge_config_schema = __esm({
@@ -147034,6 +147041,7 @@ var init_dist = __esm({
     init_home_assistant_entity_state();
     init_home_assistant_filter();
     init_lock_credential();
+    init_mapping_profile();
     init_schemas();
     init_utils();
     init_websocket_message();
@@ -147455,7 +147463,7 @@ import * as ws from "ws";
 
 // src/api/web-api.ts
 init_service();
-import express14 from "express";
+import express15 from "express";
 import basicAuth from "express-basic-auth";
 import AccessControl5 from "express-ip-access-control";
 import nocache from "nocache";
@@ -148529,6 +148537,7 @@ function healthApi(bridgeService, haClient, version, startTime) {
         status: data.status,
         statusReason: data.statusReason,
         port: data.port,
+        priority: data.priority ?? 100,
         deviceCount: data.deviceCount,
         fabricCount: fabrics.length,
         fabrics: fabrics.map((f) => ({
@@ -148893,10 +148902,165 @@ function lockCredentialApi(lockCredentialStorage) {
   return router;
 }
 
+// src/api/mapping-profile-api.ts
+import express10 from "express";
+function configToProfileEntry(config10) {
+  const domain = config10.entityId.split(".")[0];
+  return {
+    domain,
+    entityIdPattern: config10.entityId,
+    matterDeviceType: config10.matterDeviceType,
+    customName: config10.customName,
+    disabled: config10.disabled,
+    filterLifeEntity: config10.filterLifeEntity,
+    cleaningModeEntity: config10.cleaningModeEntity,
+    humidityEntity: config10.humidityEntity,
+    pressureEntity: config10.pressureEntity,
+    batteryEntity: config10.batteryEntity,
+    roomEntities: config10.roomEntities,
+    disableLockPin: config10.disableLockPin,
+    powerEntity: config10.powerEntity,
+    energyEntity: config10.energyEntity,
+    suctionLevelEntity: config10.suctionLevelEntity,
+    mopIntensityEntity: config10.mopIntensityEntity,
+    customServiceAreas: config10.customServiceAreas,
+    customFanSpeedTags: config10.customFanSpeedTags
+  };
+}
+function mappingProfileApi(mappingStorage) {
+  const router = express10.Router();
+  router.get("/export/:bridgeId", (req, res) => {
+    const { bridgeId } = req.params;
+    const profileName = req.query.name || "Unnamed Profile";
+    const mappings = mappingStorage.getMappingsForBridge(bridgeId);
+    if (mappings.length === 0) {
+      res.status(404).json({ error: "No mappings found for this bridge" });
+      return;
+    }
+    const entries = mappings.map(configToProfileEntry);
+    const domains = [...new Set(entries.map((e) => e.domain))];
+    const profile = {
+      version: 1,
+      name: profileName,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      domains,
+      entryCount: entries.length,
+      entries
+    };
+    res.json(profile);
+  });
+  router.post("/import/preview/:bridgeId", (req, res) => {
+    const { bridgeId } = req.params;
+    const { profile, availableEntityIds } = req.body;
+    if (!profile?.entries || !Array.isArray(profile.entries)) {
+      res.status(400).json({ error: "Invalid mapping profile format" });
+      return;
+    }
+    if (!availableEntityIds || !Array.isArray(availableEntityIds)) {
+      res.status(400).json({ error: "Missing availableEntityIds" });
+      return;
+    }
+    const existingMappings = mappingStorage.getMappingsForBridge(bridgeId);
+    const existingMap = new Map(existingMappings.map((m) => [m.entityId, m]));
+    const matches = [];
+    const unmatchedEntries = [];
+    for (const entry of profile.entries) {
+      let matched = false;
+      if (entry.entityIdPattern && availableEntityIds.includes(entry.entityIdPattern)) {
+        matches.push({
+          entry,
+          matchedEntityId: entry.entityIdPattern,
+          matchType: "exact",
+          existingMapping: existingMap.get(entry.entityIdPattern)
+        });
+        matched = true;
+      }
+      if (!matched) {
+        const domainEntities = availableEntityIds.filter(
+          (id) => id.split(".")[0] === entry.domain
+        );
+        if (domainEntities.length === 1) {
+          matches.push({
+            entry,
+            matchedEntityId: domainEntities[0],
+            matchType: "domain",
+            existingMapping: existingMap.get(domainEntities[0])
+          });
+          matched = true;
+        }
+      }
+      if (!matched) {
+        unmatchedEntries.push(entry);
+      }
+    }
+    const preview = {
+      profileName: profile.name,
+      totalEntries: profile.entries.length,
+      matches,
+      unmatchedEntries
+    };
+    res.json(preview);
+  });
+  router.post("/import/apply/:bridgeId", async (req, res) => {
+    const { bridgeId } = req.params;
+    const { profile, selectedEntityIds } = req.body;
+    if (!profile?.entries || !selectedEntityIds) {
+      res.status(400).json({ error: "Missing profile or selectedEntityIds" });
+      return;
+    }
+    const selectedSet = new Set(selectedEntityIds);
+    let applied = 0;
+    let skipped = 0;
+    const errors = [];
+    for (const entry of profile.entries) {
+      const targetEntityId = entry.entityIdPattern;
+      if (!targetEntityId || !selectedSet.has(targetEntityId)) {
+        skipped++;
+        continue;
+      }
+      try {
+        await mappingStorage.setMapping({
+          bridgeId,
+          entityId: targetEntityId,
+          matterDeviceType: entry.matterDeviceType,
+          customName: entry.customName,
+          disabled: entry.disabled,
+          filterLifeEntity: entry.filterLifeEntity,
+          cleaningModeEntity: entry.cleaningModeEntity,
+          humidityEntity: entry.humidityEntity,
+          pressureEntity: entry.pressureEntity,
+          batteryEntity: entry.batteryEntity,
+          roomEntities: entry.roomEntities,
+          disableLockPin: entry.disableLockPin,
+          powerEntity: entry.powerEntity,
+          energyEntity: entry.energyEntity,
+          suctionLevelEntity: entry.suctionLevelEntity,
+          mopIntensityEntity: entry.mopIntensityEntity,
+          customServiceAreas: entry.customServiceAreas,
+          customFanSpeedTags: entry.customFanSpeedTags
+        });
+        applied++;
+      } catch (e) {
+        errors.push({
+          entityId: targetEntityId,
+          error: e instanceof Error ? e.message : "Unknown error"
+        });
+      }
+    }
+    const result = {
+      applied,
+      skipped,
+      errors
+    };
+    res.json(result);
+  });
+  return router;
+}
+
 // src/api/matter-api.ts
 init_dist();
 import { Ajv } from "ajv";
-import express10 from "express";
+import express11 from "express";
 
 // src/services/bridges/matcher/matches-entity-filter.ts
 function testMatchers(matchers, device, entity, mode = "any", entityState, labels) {
@@ -149042,7 +149206,7 @@ function endpointToJson(endpoint, parentId) {
 // src/api/matter-api.ts
 var ajv = new Ajv();
 function matterApi(bridgeService, haRegistry) {
-  const router = express10.Router();
+  const router = express11.Router();
   router.get("/", (_, res) => {
     res.status(200).json({});
   });
@@ -149483,9 +149647,9 @@ function matterApi(bridgeService, haRegistry) {
 }
 
 // src/api/metrics-api.ts
-import express11 from "express";
+import express12 from "express";
 function metricsApi(bridgeService, haClient, haRegistry, startTime) {
-  const router = express11.Router();
+  const router = express12.Router();
   router.get("/", (_, res) => {
     const memoryUsage = process.memoryUsage();
     const bridges = bridgeService.bridges;
@@ -149729,7 +149893,7 @@ import { exec } from "node:child_process";
 import os2 from "node:os";
 import { promisify } from "node:util";
 import v8 from "node:v8";
-import express12 from "express";
+import express13 from "express";
 var execAsync = promisify(exec);
 var logger141 = Logger.get("SystemApi");
 function detectEnvironment2() {
@@ -149749,7 +149913,7 @@ function detectEnvironment2() {
   return "Standalone";
 }
 function systemApi(version) {
-  const router = express12.Router();
+  const router = express13.Router();
   router.get("/update-check", async (_req, res) => {
     try {
       const response = await fetch(
@@ -149939,14 +150103,14 @@ async function getUnixStorageInfo(path9) {
 // src/api/web-ui.ts
 import fs4 from "node:fs";
 import path5 from "node:path";
-import express13 from "express";
+import express14 from "express";
 function webUi(dist) {
-  const router = express13.Router();
+  const router = express14.Router();
   if (dist) {
     const index = replaceBase(dist);
     router.get("/", index);
     router.get("/index.html", index);
-    router.use(express13.static(dist));
+    router.use(express14.static(dist));
     router.get(/.*/, index);
   }
   return router;
@@ -150126,8 +150290,8 @@ var WebApi = class extends Service {
     return this.wsApi;
   }
   async initialize() {
-    const api = express14.Router();
-    api.use(express14.json()).use(nocache()).use("/matter", matterApi(this.bridgeService, this.haRegistry)).use(
+    const api = express15.Router();
+    api.use(express15.json()).use(nocache()).use("/matter", matterApi(this.bridgeService, this.haRegistry)).use(
       "/health",
       healthApi(
         this.bridgeService,
@@ -150138,7 +150302,7 @@ 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("/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.props.auth)).use(
       "/backup",
       backupApi(
         this.bridgeStorage,
@@ -150187,9 +150351,9 @@ var WebApi = class extends Service {
         })
       );
     }
-    const appRouter = express14.Router();
+    const appRouter = express15.Router();
     appRouter.use(...middlewares).use("/api", api).use(webUi(this.props.webUiDist));
-    this.app = express14();
+    this.app = express15();
     const basePath = this.props.basePath;
     if (basePath !== "/") {
       this.log.info(`Base path configured: ${basePath}`);