@riddix/hamh 2.1.0-alpha.855 → 2.1.0-alpha.856

package/dist/backend/cli.js

@@ -136588,7 +136588,7 @@ import * as nodePath from "node:path";
 import express14 from "express";
 
 // src/plugins/builtin/names.ts
-var BUILTIN_PLUGIN_NAMES = ["camera"];
+var BUILTIN_PLUGIN_NAMES = ["camera", "security"];
 
 // src/plugins/plugin-installer.ts
 init_esm();
@@ -175365,9 +175365,943 @@ var CameraPlugin = class {
   }
 };
 
+// src/plugins/builtin/security/security-plugin.ts
+init_esm();
+import {
+  callService as callService2,
+  createConnection as createConnection4,
+  createLongLivedTokenAuth as createLongLivedTokenAuth3
+} from "home-assistant-js-websocket";
+
+// src/plugins/builtin/security/security-state-machine.ts
+var ARM_MODES = [
+  "home",
+  "away",
+  "night",
+  "vacation"
+];
+var defaultSecurityScheduler = {
+  schedule(ms, fn) {
+    const timer = setTimeout(fn, ms);
+    timer.unref?.();
+    return () => clearTimeout(timer);
+  }
+};
+function parseEntityList(value) {
+  if (typeof value !== "string") return [];
+  return [
+    ...new Set(
+      value.split(",").map((s) => s.trim()).filter(Boolean)
+    )
+  ];
+}
+var SILENCEABLE_ALERT_DOMAINS = /* @__PURE__ */ new Set([
+  "siren",
+  "switch",
+  "light"
+]);
+var FIRE_ONLY_ALERT_DOMAINS = /* @__PURE__ */ new Set([
+  "script",
+  "scene"
+]);
+function resolveSecurityLists(config8, warn) {
+  const warned = /* @__PURE__ */ new Set();
+  const alerts = (value) => parseEntityList(value).filter((id) => {
+    const domain = id.split(".")[0];
+    if (SILENCEABLE_ALERT_DOMAINS.has(domain) || FIRE_ONLY_ALERT_DOMAINS.has(domain)) {
+      return true;
+    }
+    if (!warned.has(id)) {
+      warned.add(id);
+      warn?.(
+        `alert entity ${id} dropped, only siren/switch/light and script/scene are supported`
+      );
+    }
+    return false;
+  });
+  const awaySetters = parseEntityList(config8.awaySetters);
+  const awayTriggers = parseEntityList(config8.awayTriggers);
+  const awayAlerts = alerts(config8.awayAlerts);
+  const vacationSetters = parseEntityList(config8.vacationSetters);
+  const vacationTriggers = parseEntityList(config8.vacationTriggers);
+  const vacationAlerts = alerts(config8.vacationAlerts);
+  return {
+    setters: {
+      home: parseEntityList(config8.homeSetters),
+      away: awaySetters,
+      night: parseEntityList(config8.nightSetters),
+      vacation: vacationSetters.length > 0 ? vacationSetters : awaySetters
+    },
+    offSetters: parseEntityList(config8.offSetters),
+    triggers: {
+      home: parseEntityList(config8.homeTriggers),
+      away: awayTriggers,
+      night: parseEntityList(config8.nightTriggers),
+      vacation: vacationTriggers.length > 0 ? vacationTriggers : awayTriggers
+    },
+    triggers24h: parseEntityList(config8.triggers24h),
+    alerts: {
+      home: alerts(config8.homeAlerts),
+      away: awayAlerts,
+      night: alerts(config8.nightAlerts),
+      vacation: vacationAlerts.length > 0 ? vacationAlerts : awayAlerts
+    },
+    alerts24h: alerts(config8.alerts24h),
+    alwaysAlerts: alerts(config8.alwaysAlerts)
+  };
+}
+function alertsForTier(lists, tier) {
+  const base = tier === "24h" ? lists.alerts24h : lists.alerts[tier];
+  return [.../* @__PURE__ */ new Set([...base, ...lists.alwaysAlerts])];
+}
+function watchedTriggerEntities(lists) {
+  const all = new Set(lists.triggers24h);
+  for (const mode of ARM_MODES) {
+    for (const id of lists.triggers[mode]) all.add(id);
+  }
+  return all;
+}
+var PERIMETER_DEVICE_CLASSES = /* @__PURE__ */ new Set([
+  "door",
+  "window",
+  "garage_door",
+  "opening"
+]);
+function isPerimeterTrigger(entityId, deviceClass) {
+  return entityId.startsWith("binary_sensor.") && deviceClass != null && PERIMETER_DEVICE_CLASSES.has(deviceClass);
+}
+var SecurityStateMachine = class {
+  constructor(config8, effects, scheduler = defaultSecurityScheduler) {
+    this.config = config8;
+    this.effects = effects;
+    this.scheduler = scheduler;
+  }
+  config;
+  effects;
+  scheduler;
+  mode = null;
+  phase = "disarmed";
+  // Where a triggered alarm returns to when the trigger time runs out.
+  returnMode = null;
+  // Tier of the current trip, only meaningful while triggered.
+  trippedTier = null;
+  // False while an exit delay is still running, so an auto-return after a
+  // trip that cut the delay short can run the setters late.
+  modeReachedRan = true;
+  cancelTimer;
+  get snapshot() {
+    return { mode: this.mode, phase: this.phase };
+  }
+  // Live config swap: state survives, already running timers keep the delay
+  // they started with.
+  setConfig(config8) {
+    this.config = config8;
+  }
+  // Applied once on start from the persisted snapshot. Interrupted delays
+  // resolve to armed; triggered stays only when the trigger time is infinite.
+  // A resolution that changed the phase is persisted right away so a second
+  // restart replays no effects. An interrupted exit delay is the one case
+  // where the setters never ran, so that restore dispatches modeReached.
+  restore(snapshot) {
+    if (!snapshot) return;
+    const mode = ARM_MODES.includes(snapshot.mode) ? snapshot.mode : null;
+    const reached = snapshot.modeReached ?? true;
+    switch (snapshot.phase) {
+      case "arming":
+      case "pending":
+      case "armed":
+        if (mode) {
+          this.mode = mode;
+          this.phase = "armed";
+          this.modeReachedRan = true;
+          if (snapshot.phase !== "armed") this.persist();
+          if (snapshot.phase === "arming") this.effects.modeReached(mode);
+        }
+        break;
+      case "triggered":
+        if (this.config.triggerTimeSeconds === 0) {
+          this.mode = mode;
+          this.returnMode = mode;
+          this.phase = "triggered";
+          this.modeReachedRan = reached;
+        } else {
+          if (mode) {
+            this.mode = mode;
+            this.phase = "armed";
+            this.modeReachedRan = true;
+          }
+          this.persist();
+          if (mode && !reached) this.effects.modeReached(mode);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  // A mode switch changed on the Matter side. Exclusivity lives here: arming
+  // one mode reports the other three off, turning the active one off disarms.
+  handleModeSwitch(mode, on) {
+    if (on) {
+      if (this.mode === mode && this.phase !== "disarmed") {
+        this.reportSwitches();
+        return;
+      }
+      this.arm(mode);
+    } else if (this.mode === mode && this.phase !== "disarmed" || this.mode === null && this.phase === "triggered") {
+      this.disarm();
+    } else {
+      this.reportSwitches();
+    }
+  }
+  arm(mode) {
+    const wasTriggered = this.phase === "triggered";
+    this.clearTimer();
+    this.mode = mode;
+    this.returnMode = null;
+    const delayMs = this.config.exitDelaySeconds * 1e3;
+    if (delayMs > 0) {
+      this.phase = "arming";
+      this.modeReachedRan = false;
+      this.reportSwitches();
+      if (wasTriggered) this.effects.alarmCleared();
+      this.persist();
+      this.cancelTimer = this.scheduler.schedule(
+        delayMs,
+        () => this.becomeArmed()
+      );
+    } else {
+      this.phase = "armed";
+      this.modeReachedRan = true;
+      this.reportSwitches();
+      if (wasTriggered) this.effects.alarmCleared();
+      this.persist();
+      this.effects.modeReached(mode);
+    }
+  }
+  disarm() {
+    if (this.phase === "disarmed") {
+      this.reportSwitches();
+      return;
+    }
+    const wasTriggered = this.phase === "triggered";
+    this.clearTimer();
+    this.mode = null;
+    this.returnMode = null;
+    this.phase = "disarmed";
+    this.reportSwitches();
+    if (wasTriggered) this.effects.alarmCleared();
+    this.persist();
+    this.effects.disarmed();
+  }
+  // A watched entity entered on/open. The 24h list trips in every state and
+  // skips the entry delay; mode triggers only count while armed (the exit
+  // delay exists so leaving does not trip the alarm).
+  handleEntityOn(entityId, isPerimeter) {
+    if (this.config.triggers24h.includes(entityId)) {
+      if (this.phase !== "triggered" || this.trippedTier !== "24h") {
+        this.trip("24h", entityId);
+      }
+      return;
+    }
+    const mode = this.mode;
+    if (!mode) return;
+    if (!this.config.triggers[mode].includes(entityId)) return;
+    if (this.phase === "armed") {
+      const entryMs = this.config.entryDelaySeconds * 1e3;
+      if (isPerimeter && entryMs > 0) {
+        this.phase = "pending";
+        this.persist();
+        this.cancelTimer = this.scheduler.schedule(
+          entryMs,
+          () => this.trip(mode, entityId)
+        );
+      } else {
+        this.trip(mode, entityId);
+      }
+    } else if (this.phase === "pending" && !isPerimeter) {
+      this.trip(mode, entityId);
+    }
+  }
+  shutdown() {
+    this.clearTimer();
+  }
+  becomeArmed() {
+    this.cancelTimer = void 0;
+    const mode = this.mode;
+    if (!mode || this.phase !== "arming") return;
+    this.phase = "armed";
+    this.modeReachedRan = true;
+    this.persist();
+    this.effects.modeReached(mode);
+  }
+  trip(tier, entityId) {
+    this.clearTimer();
+    this.returnMode = this.mode;
+    this.trippedTier = tier;
+    this.phase = "triggered";
+    this.effects.tripped(tier, entityId);
+    this.persist();
+    const holdMs = this.config.triggerTimeSeconds * 1e3;
+    if (holdMs > 0) {
+      this.cancelTimer = this.scheduler.schedule(
+        holdMs,
+        () => this.autoReturn()
+      );
+    }
+  }
+  autoReturn() {
+    this.cancelTimer = void 0;
+    this.mode = this.returnMode;
+    this.returnMode = null;
+    this.phase = this.mode ? "armed" : "disarmed";
+    const lateSetters = this.mode != null && !this.modeReachedRan;
+    this.modeReachedRan = true;
+    this.effects.alarmCleared();
+    this.persist();
+    if (lateSetters && this.mode) this.effects.modeReached(this.mode);
+  }
+  reportSwitches() {
+    const active = this.phase === "disarmed" ? null : this.mode;
+    const states = {};
+    for (const mode of ARM_MODES) states[mode] = mode === active;
+    this.effects.switchStates(states);
+  }
+  persist() {
+    this.effects.persist({
+      ...this.snapshot,
+      modeReached: this.modeReachedRan
+    });
+  }
+  clearTimer() {
+    this.cancelTimer?.();
+    this.cancelTimer = void 0;
+  }
+};
+
+// src/plugins/builtin/security/security-plugin.ts
+var CONFIG_KEY2 = "config";
+var STATE_KEY = "state";
+var PENDING_SILENCE_KEY = "pendingSilence";
+var PENDING_SETTERS_KEY = "pendingSetters";
+var ALARM_DEVICE_ID = "alarm";
+var MODE_DEVICE_IDS = {
+  home: "mode_home",
+  away: "mode_away",
+  night: "mode_night",
+  vacation: "mode_vacation"
+};
+var MODE_NAMES = {
+  home: "Home",
+  away: "Away",
+  night: "Night",
+  vacation: "Vacation"
+};
+var RETRY_BASE_MS = 1e3;
+var RETRY_MAX_MS = 6e4;
+var CALL_DEADLINE_MS = 1e4;
+var SecurityPlugin = class {
+  constructor(config8 = {}, deps = {}) {
+    this.deps = deps;
+    this.config = config8;
+  }
+  deps;
+  name = "security";
+  version = "0.1.0";
+  log = Logger.get("SecurityPlugin");
+  context;
+  config;
+  lists = resolveSecurityLists({});
+  watched = /* @__PURE__ */ new Set();
+  machine;
+  activeAlerts = [];
+  // Effect tasks run strictly FIFO: a disarm's silence can never overtake the
+  // trip's turn_on loop it is chasing. Queued (not yet started) intent is
+  // coalesced per entity so a hung call cannot pile up work behind it.
+  tasks = [];
+  draining = false;
+  connection;
+  unsubscribeEvents;
+  retryTimer;
+  backoffMs = RETRY_BASE_MS;
+  // Bumped on every teardown; a dial resolving under a stale generation is
+  // discarded instead of installing an old target.
+  dialGeneration = 0;
+  async onStart(context) {
+    this.context = context;
+    const stored = await context.storage.get(CONFIG_KEY2);
+    this.config = { ...this.config, ...stored ?? {} };
+    this.applyLists();
+    this.machine = new SecurityStateMachine(
+      this.machineConfig(),
+      this.effects()
+    );
+    await this.registerDevices();
+    const state = await context.storage.get(STATE_KEY);
+    this.machine.restore(state);
+    await context.storage.flush?.();
+    if (state?.phase === "triggered") {
+      const known = state.activeAlerts;
+      if (this.machine.snapshot.phase === "triggered") {
+        this.activeAlerts = known ?? this.allSilenceableAlerts();
+      } else {
+        const candidates = (known ?? this.allSilenceableAlerts()).filter(
+          (id) => SILENCEABLE_ALERT_DOMAINS.has(id.split(".")[0])
+        );
+        this.enqueueSilence(candidates);
+      }
+    }
+    this.pushDeviceStates();
+    this.startConnection();
+  }
+  async onConfigChanged(config8) {
+    this.config = config8;
+    await this.context?.storage.set(CONFIG_KEY2, this.config);
+    this.applyLists();
+    this.machine?.setConfig(this.machineConfig());
+    await this.stopConnection();
+    this.startConnection();
+  }
+  async onShutdown() {
+    this.machine?.shutdown();
+    await this.stopConnection();
+    for (const id of [...Object.values(MODE_DEVICE_IDS), ALARM_DEVICE_ID]) {
+      await this.context?.unregisterDevice(id).catch(() => {
+      });
+    }
+  }
+  getCurrentConfig() {
+    return { ...this.config };
+  }
+  getConfigSchema() {
+    const entityList = (title, description) => ({
+      type: "string",
+      title,
+      description,
+      required: false
+    });
+    return {
+      title: "Security",
+      description: "A small alarm system: four exclusive mode switches plus an Alarm contact sensor. All entity fields are comma-separated lists.",
+      properties: {
+        exitDelaySeconds: {
+          type: "number",
+          title: "Exit delay (seconds)",
+          description: "Delay before an armed mode takes effect. 0 disables.",
+          default: 60,
+          required: false
+        },
+        entryDelaySeconds: {
+          type: "number",
+          title: "Entry delay (seconds)",
+          description: "Delay for door/window/garage door/opening sensors while armed. Other trigger classes trip instantly. 0 disables.",
+          default: 60,
+          required: false
+        },
+        triggerTimeSeconds: {
+          type: "number",
+          title: "Trigger time (seconds)",
+          description: "How long the alarm stays triggered before returning to the state it was tripped from. 0 keeps it triggered until disarm.",
+          default: 120,
+          required: false
+        },
+        homeSetters: entityList(
+          "Home setters",
+          "Invoked when Home is armed, e.g. scene.arm_home,script.notify"
+        ),
+        homeTriggers: entityList(
+          "Home triggers",
+          "Sensors that trip the alarm while armed Home."
+        ),
+        homeAlerts: entityList(
+          "Home alerts",
+          "Turned on when the alarm trips while armed Home."
+        ),
+        awaySetters: entityList("Away setters", "Invoked when Away is armed."),
+        awayTriggers: entityList(
+          "Away triggers",
+          "Sensors that trip the alarm while armed Away."
+        ),
+        awayAlerts: entityList(
+          "Away alerts",
+          "Turned on when the alarm trips while armed Away."
+        ),
+        nightSetters: entityList(
+          "Night setters",
+          "Invoked when Night is armed."
+        ),
+        nightTriggers: entityList(
+          "Night triggers",
+          "Sensors that trip the alarm while armed Night."
+        ),
+        nightAlerts: entityList(
+          "Night alerts",
+          "Turned on when the alarm trips while armed Night."
+        ),
+        vacationSetters: entityList(
+          "Vacation setters",
+          "Leave empty to use the Away setters."
+        ),
+        vacationTriggers: entityList(
+          "Vacation triggers",
+          "Leave empty to use the Away triggers."
+        ),
+        vacationAlerts: entityList(
+          "Vacation alerts",
+          "Leave empty to use the Away alerts."
+        ),
+        offSetters: entityList(
+          "Off setters",
+          "Invoked on disarm, e.g. scene.alarm_off"
+        ),
+        triggers24h: entityList(
+          "24h triggers",
+          "Trip the alarm in every state including disarmed, without entry delay. For smoke, gas, water leak and similar."
+        ),
+        alerts24h: entityList(
+          "24h alerts",
+          "Turned on when a 24h trigger trips the alarm."
+        ),
+        alwaysAlerts: entityList(
+          "Always",
+          "The master alert list: fired on every trip in addition to the tier's alerts."
+        ),
+        haUrl: {
+          type: "string",
+          title: "Home Assistant URL",
+          description: "e.g. http://homeassistant.local:8123. Set together with the token to use a different Home Assistant; leave both empty to use the bridge's credentials. One without the other is ignored.",
+          required: false
+        },
+        haToken: {
+          type: "string",
+          title: "Long-lived access token",
+          description: "Token for the custom URL, only used together with it. Leave both empty to use the bridge's credentials.",
+          required: false,
+          secret: true
+        }
+      }
+    };
+  }
+  // A watched entity changed state, from the websocket or from tests.
+  handleTriggerEvent(entityId, state, deviceClass) {
+    if (state !== "on" && state !== "open") return;
+    if (!this.watched.has(entityId)) return;
+    this.machine?.handleEntityOn(
+      entityId,
+      isPerimeterTrigger(entityId, deviceClass)
+    );
+  }
+  applyLists() {
+    this.lists = resolveSecurityLists(
+      this.config,
+      (message) => this.log.warn(message)
+    );
+    this.watched = watchedTriggerEntities(this.lists);
+  }
+  machineConfig() {
+    const seconds = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+    return {
+      exitDelaySeconds: seconds(this.config.exitDelaySeconds, 60),
+      entryDelaySeconds: seconds(this.config.entryDelaySeconds, 60),
+      triggerTimeSeconds: seconds(this.config.triggerTimeSeconds, 120),
+      triggers: this.lists.triggers,
+      triggers24h: this.lists.triggers24h
+    };
+  }
+  effects() {
+    return {
+      switchStates: (states) => {
+        for (const mode of ARM_MODES) {
+          this.context?.updateDeviceState(MODE_DEVICE_IDS[mode], "onOff", {
+            onOff: states[mode]
+          });
+        }
+      },
+      modeReached: (mode) => {
+        this.enqueueSetters(mode);
+      },
+      disarmed: () => {
+        this.enqueueSetters("off");
+      },
+      tripped: (tier, entityId) => {
+        this.log.info(`alarm tripped by ${entityId} (${tier})`);
+        this.context?.updateDeviceState(ALARM_DEVICE_ID, "booleanState", {
+          stateValue: false
+        });
+        const alerts = alertsForTier(this.lists, tier);
+        this.activeAlerts = [.../* @__PURE__ */ new Set([...this.activeAlerts, ...alerts])];
+        this.enqueueAlerts(alerts);
+      },
+      alarmCleared: () => {
+        this.context?.updateDeviceState(ALARM_DEVICE_ID, "booleanState", {
+          stateValue: true
+        });
+        const toSilence = this.activeAlerts.filter(
+          (id) => SILENCEABLE_ALERT_DOMAINS.has(id.split(".")[0])
+        );
+        this.activeAlerts = [];
+        this.enqueueSilence(toSilence);
+      },
+      persist: (snapshot) => {
+        const state = {
+          ...snapshot,
+          activeAlerts: [...this.activeAlerts]
+        };
+        void this.context?.storage.set(STATE_KEY, state).catch((e) => this.log.warn("failed to persist alarm state:", e));
+      }
+    };
+  }
+  setters(key) {
+    return key === "off" ? this.lists.offSetters : this.lists.setters[key];
+  }
+  // Every alert a clear can turn off, across all tiers.
+  allSilenceableAlerts() {
+    const all = /* @__PURE__ */ new Set([
+      ...ARM_MODES.flatMap((mode) => this.lists.alerts[mode]),
+      ...this.lists.alerts24h,
+      ...this.lists.alwaysAlerts
+    ]);
+    return [...all].filter(
+      (id) => SILENCEABLE_ALERT_DOMAINS.has(id.split(".")[0])
+    );
+  }
+  async registerDevices() {
+    const context = this.context;
+    if (!context) return;
+    for (const mode of ARM_MODES) {
+      await context.registerDevice({
+        id: MODE_DEVICE_IDS[mode],
+        name: MODE_NAMES[mode],
+        deviceType: "on_off_plugin_unit",
+        clusters: [{ clusterId: "onOff", attributes: { onOff: false } }],
+        onAttributeWrite: async (clusterId3, attribute, value) => {
+          if (clusterId3 !== "onOff" || attribute !== "onOff") return;
+          this.machine?.handleModeSwitch(mode, value === true);
+        }
+      });
+    }
+    await context.registerDevice({
+      id: ALARM_DEVICE_ID,
+      name: "Alarm",
+      deviceType: "contact_sensor",
+      // stateValue true = closed = all quiet; false = open = tripped.
+      clusters: [
+        { clusterId: "booleanState", attributes: { stateValue: true } }
+      ]
+    });
+  }
+  // Reflect the restored snapshot onto the endpoints.
+  pushDeviceStates() {
+    const context = this.context;
+    const machine = this.machine;
+    if (!context || !machine) return;
+    const snap = machine.snapshot;
+    for (const mode of ARM_MODES) {
+      context.updateDeviceState(MODE_DEVICE_IDS[mode], "onOff", {
+        onOff: snap.mode === mode && snap.phase !== "disarmed"
+      });
+    }
+    context.updateDeviceState(ALARM_DEVICE_ID, "booleanState", {
+      stateValue: snap.phase !== "triggered"
+    });
+  }
+  pushTask(task) {
+    this.tasks.push(task);
+    queueMicrotask(() => void this.drain());
+  }
+  enqueueSetters(mode) {
+    this.tasks = this.tasks.filter((t) => t.kind !== "setters");
+    this.pushTask({ kind: "setters", mode });
+  }
+  enqueueAlerts(entityIds) {
+    this.dropQueuedIntent("silence", entityIds);
+    const queued = this.tasks.find((t) => t.kind === "alerts");
+    if (queued && queued.kind === "alerts") {
+      queued.entities = [.../* @__PURE__ */ new Set([...queued.entities, ...entityIds])];
+      return;
+    }
+    this.pushTask({ kind: "alerts", entities: [...entityIds] });
+  }
+  enqueueSilence(entityIds) {
+    this.dropQueuedIntent("alerts", entityIds);
+    const queued = this.tasks.find((t) => t.kind === "silence");
+    if (queued && queued.kind === "silence") {
+      queued.entities = [.../* @__PURE__ */ new Set([...queued.entities, ...entityIds])];
+      return;
+    }
+    this.pushTask({ kind: "silence", entities: [...entityIds] });
+  }
+  enqueueReconnect() {
+    if (this.tasks.some((t) => t.kind === "reconnect")) return;
+    this.pushTask({ kind: "reconnect" });
+  }
+  // A newer turn_on/turn_off intent for an entity replaces the queued
+  // opposite one. Only queued tasks are touched, an in-flight batch keeps
+  // its order guarantee.
+  dropQueuedIntent(kind, entityIds) {
+    const drop = new Set(entityIds);
+    this.tasks = this.tasks.flatMap((t) => {
+      if (t.kind !== kind) return [t];
+      const rest = t.entities.filter((id) => !drop.has(id));
+      return rest.length > 0 ? [{ ...t, entities: rest }] : [];
+    });
+  }
+  async drain() {
+    if (this.draining) return;
+    this.draining = true;
+    try {
+      for (; ; ) {
+        const task = this.tasks.shift();
+        if (!task) return;
+        try {
+          await this.runTask(task);
+        } catch (e) {
+          this.log.warn("effect batch failed:", e);
+        }
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+  async runTask(task) {
+    switch (task.kind) {
+      case "setters":
+        return this.runSetters(task.mode);
+      case "alerts":
+        return this.runAlerts(task.entities);
+      case "silence":
+        return this.runSilence(task.entities);
+      case "reconnect":
+        return this.flushAfterConnect();
+    }
+  }
+  // Setter turn_on per domain: script.turn_on for script.*, scene.turn_on for
+  // scene.*, else <domain>.turn_on. The intent goes to disk first and leaves
+  // it only once every call resolved, so a crash, gap or failed call is
+  // replayed on reconnect if the mode is still current.
+  async runSetters(key) {
+    const entities = this.setters(key);
+    if (entities.length === 0) return;
+    const storage2 = this.context?.storage;
+    await storage2?.set(PENDING_SETTERS_KEY, { mode: key });
+    await storage2?.flush?.();
+    if (this.connection?.connected !== true) {
+      this.log.debug(
+        `no Home Assistant connection, ${key} setters wait for the reconnect`
+      );
+      return;
+    }
+    const ok2 = await this.callSequential(entities, "turn_on");
+    if (ok2) await storage2?.delete(PENDING_SETTERS_KEY);
+  }
+  async runAlerts(entityIds) {
+    if (entityIds.length === 0) return;
+    await this.context?.storage.flush?.();
+    const connection = this.connection;
+    if (!connection || !connection.connected) {
+      this.log.warn(
+        `no Home Assistant connection, alerts skipped: ${entityIds.join(",")}`
+      );
+      return;
+    }
+    await this.callSequential(entityIds, "turn_on");
+  }
+  // Every due turn_off goes to storage first and leaves it only once HA
+  // confirmed the call, so a crash or gap can never lose a silence.
+  async runSilence(entityIds) {
+    const storage2 = this.context?.storage;
+    if (storage2 && entityIds.length > 0) {
+      const pending = await storage2.get(PENDING_SILENCE_KEY) ?? [];
+      await storage2.set(PENDING_SILENCE_KEY, [
+        .../* @__PURE__ */ new Set([...pending, ...entityIds])
+      ]);
+      await storage2.flush?.();
+    }
+    await this.flushPendingSilence();
+  }
+  async flushPendingSilence() {
+    const storage2 = this.context?.storage;
+    if (!storage2) return;
+    let pending = await storage2.get(PENDING_SILENCE_KEY) ?? [];
+    if (pending.length === 0) return;
+    const connection = this.connection;
+    if (!connection || !connection.connected) {
+      this.log.warn(
+        `no Home Assistant connection, silence stays pending for ${pending.join(",")}`
+      );
+      return;
+    }
+    for (const entityId of [...pending]) {
+      const domain = entityId.split(".")[0];
+      try {
+        await this.callWithDeadline(connection, domain, "turn_off", entityId);
+        pending = pending.filter((id) => id !== entityId);
+        await storage2.set(PENDING_SILENCE_KEY, pending);
+      } catch (e) {
+        this.log.warn(
+          `${domain}.turn_off failed for ${entityId}, retried on reconnect:`,
+          e
+        );
+      }
+    }
+    if (pending.length === 0) await storage2.delete(PENDING_SILENCE_KEY);
+  }
+  // Ran after every (re)connect: sirens first, then any setter batch a gap
+  // swallowed, but only if the machine still stands where it did.
+  async flushAfterConnect() {
+    await this.flushPendingSilence();
+    const storage2 = this.context?.storage;
+    if (!storage2) return;
+    const held = await storage2.get(
+      PENDING_SETTERS_KEY
+    );
+    if (!held) return;
+    const snap = this.machine?.snapshot;
+    const stillCurrent = held.mode === "off" ? snap?.phase === "disarmed" : snap?.mode === held.mode && snap?.phase !== "disarmed";
+    if (!stillCurrent) {
+      await storage2.delete(PENDING_SETTERS_KEY);
+      return;
+    }
+    const ok2 = await this.callSequential(this.setters(held.mode), "turn_on");
+    if (ok2) await storage2.delete(PENDING_SETTERS_KEY);
+  }
+  async callSequential(entityIds, service) {
+    const connection = this.connection;
+    if (!connection || !connection.connected) return false;
+    let allOk = true;
+    for (const entityId of entityIds) {
+      const domain = entityId.split(".")[0];
+      try {
+        await this.callWithDeadline(connection, domain, service, entityId);
+      } catch (e) {
+        allOk = false;
+        this.log.warn(`${domain}.${service} failed for ${entityId}:`, e);
+      }
+    }
+    return allOk;
+  }
+  async callWithDeadline(connection, domain, service, entityId) {
+    let timer;
+    try {
+      await Promise.race([
+        callService2(connection, domain, service, void 0, {
+          entity_id: entityId
+        }),
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(
+              new Error(
+                `${domain}.${service} for ${entityId} timed out after ${CALL_DEADLINE_MS}ms`
+              )
+            ),
+            CALL_DEADLINE_MS
+          );
+          timer.unref?.();
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  startConnection() {
+    const hasCustomUrl = !!this.config.haUrl;
+    const hasCustomToken = !!this.config.haToken;
+    if (hasCustomUrl !== hasCustomToken) {
+      this.log.warn(
+        "haUrl and haToken must both be set for a custom Home Assistant, using the bridge credentials instead"
+      );
+    }
+    const custom = hasCustomUrl && hasCustomToken;
+    const haUrl = custom ? this.config.haUrl : this.context?.homeAssistant?.url;
+    const haToken = custom ? this.config.haToken : this.context?.homeAssistant?.accessToken;
+    if (!haUrl || !haToken) {
+      this.log.info(
+        "no Home Assistant connection, setters, alerts and triggers stay inactive"
+      );
+      return;
+    }
+    void this.connect(haUrl, haToken);
+  }
+  async connect(haUrl, haToken) {
+    const generation = this.dialGeneration;
+    let connection;
+    try {
+      connection = this.deps.connect ? await this.deps.connect(haUrl, haToken) : await createConnection4({
+        auth: createLongLivedTokenAuth3(haUrl, haToken)
+      });
+      if (generation !== this.dialGeneration) {
+        connection.close();
+        return;
+      }
+      this.connection = connection;
+      this.backoffMs = RETRY_BASE_MS;
+      connection.addEventListener(
+        "disconnected",
+        () => this.log.info("Home Assistant connection lost, waiting for reconnect")
+      );
+      connection.addEventListener("ready", () => this.enqueueReconnect());
+      const unsubscribe = await connection.subscribeEvents(
+        (event3) => this.handleStateChanged(event3),
+        "state_changed"
+      );
+      if (generation !== this.dialGeneration) {
+        return;
+      }
+      this.unsubscribeEvents = unsubscribe;
+      this.log.info(`watching ${this.watched.size} trigger entities`);
+      this.enqueueReconnect();
+    } catch (e) {
+      connection?.close();
+      if (this.connection === connection) this.connection = void 0;
+      if (generation !== this.dialGeneration) return;
+      this.log.warn(
+        `Home Assistant connection failed, retrying in ${this.backoffMs}ms:`,
+        e
+      );
+      const delay = this.backoffMs;
+      this.backoffMs = Math.min(this.backoffMs * 2, RETRY_MAX_MS);
+      this.retryTimer = setTimeout(() => {
+        this.retryTimer = void 0;
+        if (generation !== this.dialGeneration) return;
+        void this.connect(haUrl, haToken);
+      }, delay);
+      this.retryTimer.unref?.();
+    }
+  }
+  async stopConnection() {
+    this.dialGeneration++;
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+    const unsubscribe = this.unsubscribeEvents;
+    this.unsubscribeEvents = void 0;
+    if (unsubscribe) {
+      try {
+        await unsubscribe();
+      } catch {
+      }
+    }
+    this.connection?.close();
+    this.connection = void 0;
+    this.backoffMs = RETRY_BASE_MS;
+  }
+  handleStateChanged(event3) {
+    const entityId = event3.data?.entity_id;
+    const newState = event3.data?.new_state;
+    if (!entityId || !newState?.state) return;
+    if (event3.data?.old_state?.state === newState.state) return;
+    this.handleTriggerEvent(
+      entityId,
+      newState.state,
+      newState.attributes?.device_class
+    );
+  }
+};
+
 // src/plugins/builtin/index.ts
 var BUILTIN_PLUGINS = [
-  CameraPlugin
+  CameraPlugin,
+  SecurityPlugin
 ];
 
 // src/services/bridges/bridge-endpoint-manager.ts
@@ -175796,8 +176730,13 @@ var BridgeEndpointManager = class extends Service {
       if (behaviorId === "pluginDevice") continue;
       const behaviorEvents = allEvents[behaviorId];
       if (!behaviorEvents || typeof behaviorEvents !== "object") continue;
-      for (const eventName of Object.keys(behaviorEvents)) {
-        if (!eventName.endsWith("$Changed")) continue;
+      const eventNames = /* @__PURE__ */ new Set();
+      for (let proto = behaviorEvents; proto && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+        for (const name of Object.getOwnPropertyNames(proto)) {
+          if (name.endsWith("$Changed")) eventNames.add(name);
+        }
+      }
+      for (const eventName of eventNames) {
         const observable = behaviorEvents[eventName];
         if (!observable || typeof observable.on !== "function") continue;
         const attrName = eventName.slice(0, -"$Changed".length);
@@ -176349,7 +177288,7 @@ var BridgeEndpointManager = class extends Service {
 init_dist();
 init_esm();
 init_send_ha_message();
-import { callService as callService2 } from "home-assistant-js-websocket";
+import { callService as callService3 } from "home-assistant-js-websocket";
 import { keys as keys2, pickBy, values as values3 } from "lodash-es";
 var BridgeRegistry = class _BridgeRegistry {
   constructor(registry3, dataProvider, client) {
@@ -176735,7 +177674,7 @@ var BridgeRegistry = class _BridgeRegistry {
   async resolveRoborockRooms(entityId) {
     if (!this.client) return [];
     try {
-      const raw = await callService2(
+      const raw = await callService3(
         this.client.connection,
         "roborock",
         "get_maps",