@camstack/addon-provider-homeassistant 1.2.43 → 1.2.45

package/dist/ha-export/ha-export.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 //#endregion
-const require_dist = require("../dist-DiprHh6i.js");
+const require_dist = require("../dist-BXcwGSn_.js");
 let node_crypto = require("node:crypto");
 //#region src/ha-export/topics.ts
 /**
@@ -4302,6 +4302,58 @@ function pruneBrokers(membership, knownBrokerIds) {
 function enabledBrokerIds(store, knownBrokerIds) {
 	return knownBrokerIds.filter((brokerId) => store[`exportTo:${brokerId}`] === true);
 }
+/** Same brokers, same order, same names — nothing for the form to re-render. */
+function sameBrokers(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((broker, index) => {
+		const other = b[index];
+		return other !== void 0 && other.id === broker.id && other.name === broker.name;
+	});
+}
+/**
+* What a broker refresh persists — and, above all, what it must NOT.
+*
+* **A patch never names a key it did not change.** That reads like tidiness
+* and is not: `updateGlobalSettings` is a read-modify-write over the addon
+* store, so naming `membership` writes whatever `this.config.membership`
+* currently holds — and `this.config` is not always the store.
+* `BaseAddon.resolveConfig` falls back to the CONSTRUCTOR DEFAULTS whenever
+* the settings read answers empty, and the kernel's `readAddonStore` answers
+* empty for a FAILED read exactly as it does for a missing one, silently. A
+* boot-window read that misses therefore gives the addon `membership: {}`,
+* and the first refresh that merely re-records `knownBrokers` hands that
+* empty object to the store as if the operator had unexported everything.
+*
+* That is not a hypothetical. On 2026-08-24 the hub restarted at 21:49; the
+* export runner came up while the cap resolver was still answering
+* "no provider registered" for hub-resident caps; at 21:55:13 a refresh
+* found `knownBrokers` stale (`[]` vs `[ha_001]`) and wrote BOTH keys. The
+* two exported cameras (590 salone, 615 ingresso) were erased from the
+* store, `devices` fell from 4 to 2 (the two synthetic devices), and Home
+* Assistant kept every camera entity as a restored/unavailable orphan for
+* three days: no stream ("the hub does not export this camera"), no
+* doorbell, no camera state. Nothing logged it, because from the store's
+* point of view the addon simply asked for `{}`.
+*
+* With the keys split, that pass writes `knownBrokers` alone, the
+* `resolveConfig` that follows the write re-reads a store that still holds
+* the membership, and the next reconcile exports both cameras again.
+*
+* Identity, not deep equality, decides `membership`: `pruneBrokers` returns
+* the SAME reference when it removed nothing, which is precisely the
+* "nothing changed" signal this needs.
+*
+* @returns the patch to persist, or `null` when there is nothing to write.
+*/
+function brokerRefreshPatch(current, next) {
+	const brokersChanged = !sameBrokers(next.knownBrokers, current.knownBrokers);
+	const membershipChanged = next.membership !== current.membership;
+	if (!brokersChanged && !membershipChanged) return null;
+	return {
+		...brokersChanged ? { knownBrokers: next.knownBrokers } : {},
+		...membershipChanged ? { membership: next.membership } : {}
+	};
+}
 /**
 * What a linked Home Assistant NEEDS to function — one entry per thing it
 * actually calls with this token, each named. Not a blast radius, not a
@@ -5165,6 +5217,11 @@ function ruleEntity(ruleId) {
 function ruleIdFromEntity(entity, rules) {
 	return rules.find((rule) => ruleEntity(rule.id) === entity)?.id ?? null;
 }
+/** The entity id of one per-rule last-trigger fact. Derived from the rule
+*  ID, same identity rule as {@link ruleEntity}. */
+function ruleTriggerEntity(ruleId, suffix) {
+	return `${ruleEntity(ruleId)}_last_trigger_${suffix}`;
+}
 function notificationCenterSpecs(input) {
 	return [
 		{
@@ -5195,13 +5252,110 @@ function notificationCenterSpecs(input) {
 			writable: true,
 			options: SNOOZE_OPTIONS
 		}),
+		(
+		/**
+		* The last trigger, six entities: five facts plus its picture — "conoscere
+		* gli ultimi trigger, le ultime immagini... e da quale label" (operator,
+		* 2026-08-25). ENABLED by default like every other entity on this device
+		* (see {@link buildComponents}'s docblock): a rule the operator wrote is a
+		* rule they want to watch fire.
+		*
+		* Fixed count regardless of camera fleet size — the fan-out this design
+		* explicitly avoids (960 entities at 30 cameras × 32 rules) lives ONLY in
+		* the per-rule switches and per-rule trigger facts below, which scale
+		* with the RULE count only (this module has no camera dimension at all).
+		* These six are on ONE synthetic device and never repeat per camera or
+		* per rule.
+		*/
+		{
+			entity: "last_trigger_at",
+			platform: "sensor",
+			label: "Last trigger",
+			deviceClass: "timestamp"
+		}),
+		{
+			entity: "last_trigger_rule",
+			platform: "sensor",
+			label: "Last trigger rule",
+			icon: "mdi:bell-ring-outline"
+		},
+		{
+			entity: "last_trigger_camera",
+			platform: "sensor",
+			label: "Last trigger camera",
+			icon: "mdi:cctv"
+		},
+		(
+		/** The identified label, or the detected class when none was resolved —
+		*  see {@link SyntheticLastTrigger.label}. Never blank. */
+		{
+			entity: "last_trigger_label",
+			platform: "sensor",
+			label: "Last trigger label",
+			icon: "mdi:tag-outline"
+		}),
+		(
+		/** `pending` / `sent` / `dead` — the outbox row's own status, straight
+		*  from `getHistory`, never a second delivery ledger. */
+		{
+			entity: "last_trigger_status",
+			platform: "sensor",
+			label: "Last trigger delivery status",
+			icon: "mdi:send-check-outline",
+			entityCategory: "diagnostic"
+		}),
+		(
+		/** See {@link SyntheticLastTrigger.imageUrl} for the expired/unreachable
+		*  degrade: no value is published rather than a link that 404s. */
+		{
+			entity: "last_trigger_image",
+			platform: "image",
+			label: "Last trigger image"
+		}),
 		...input.rules.map((rule) => ({
 			entity: ruleEntity(rule.id),
 			platform: "switch",
 			label: rule.name,
 			writable: true,
 			icon: "mdi:bell-cog"
-		}))
+		})),
+		...input.rules.flatMap((rule) => [
+			{
+				entity: ruleTriggerEntity(rule.id, "at"),
+				platform: "sensor",
+				label: `${rule.name} last trigger`,
+				deviceClass: "timestamp"
+			},
+			{
+				entity: ruleTriggerEntity(rule.id, "camera"),
+				platform: "sensor",
+				label: `${rule.name} last trigger camera`,
+				icon: "mdi:cctv"
+			},
+			(
+			/** See {@link SyntheticLastTrigger.label}. Never blank. */
+			{
+				entity: ruleTriggerEntity(rule.id, "label"),
+				platform: "sensor",
+				label: `${rule.name} last trigger label`,
+				icon: "mdi:tag-outline"
+			}),
+			{
+				entity: ruleTriggerEntity(rule.id, "status"),
+				platform: "sensor",
+				label: `${rule.name} last trigger delivery status`,
+				icon: "mdi:send-check-outline",
+				entityCategory: "diagnostic"
+			},
+			(
+			/** See {@link SyntheticLastTrigger.imageUrl} for the expired/
+			*  unreachable degrade: no value published rather than a dead link. */
+			{
+				entity: ruleTriggerEntity(rule.id, "image"),
+				platform: "image",
+				label: `${rule.name} last trigger image`
+			})
+		])
 	];
 }
 function serverSpecs(input) {
@@ -5375,6 +5529,39 @@ function syntheticPlans(input) {
 	return [plan(NOTIFICATION_CENTER_STABLE_ID, "Notification Center", notificationCenterSpecs(input)), plan(SERVER_STABLE_ID, "CamStack Server", serverSpecs(input))];
 }
 /**
+* The four state facts plus the picture, shared by the GLOBAL `last_trigger_*`
+* entities and every per-rule `rule_<slug>_last_trigger_*` one. `entityFor` is
+* the SAME function that named the entity in `notificationCenterSpecs` — a
+* `sensor` whose declared `state_topic` and its published topic come from two
+* different expressions is exactly the class of bug
+* `camera-entity-feeds.spec.ts` exists to catch on the camera side.
+*/
+function projectTriggerFacts(deviceKey, entityFor, t) {
+	const values = [
+		{
+			topic: stateTopic(deviceKey, entityFor("at")),
+			value: new Date(t.at).toISOString()
+		},
+		{
+			topic: stateTopic(deviceKey, entityFor("camera")),
+			value: t.deviceName
+		},
+		{
+			topic: stateTopic(deviceKey, entityFor("label")),
+			value: t.label
+		},
+		{
+			topic: stateTopic(deviceKey, entityFor("status")),
+			value: t.status
+		}
+	];
+	if (t.imageUrl !== null) values.push({
+		topic: stateTopic(deviceKey, entityFor("image")),
+		value: t.imageUrl
+	});
+	return values;
+}
+/**
 * Every synthetic value, for the reconcile to push.
 *
 * Uptime is published as an ISO timestamp of the BOOT INSTANT, not as a
@@ -5440,6 +5627,18 @@ function projectSynthetic(input, nowMs) {
 			value: String(input.alertsActiveCount)
 		}
 	];
+	if (input.lastTrigger !== null) {
+		values.push({
+			topic: stateTopic(nc, "last_trigger_rule"),
+			value: input.lastTrigger.ruleName
+		});
+		values.push(...projectTriggerFacts(nc, (suffix) => `last_trigger_${suffix}`, input.lastTrigger));
+	}
+	for (const rule of input.rules) {
+		const t = input.lastTriggerByRule.get(rule.id);
+		if (t === void 0) continue;
+		values.push(...projectTriggerFacts(nc, (suffix) => ruleTriggerEntity(rule.id, suffix), t));
+	}
 	if (input.alertsLastTitle !== null) values.push({
 		topic: stateTopic(srv, "alerts_last_title"),
 		value: input.alertsLastTitle
@@ -5490,6 +5689,38 @@ function projectSynthetic(input, nowMs) {
 	return values;
 }
 //#endregion
+//#region src/ha-export/rule-triggers.ts
+function reduceOne(row) {
+	return {
+		ruleId: row.ruleId,
+		ruleName: row.ruleName,
+		deviceId: row.deviceId,
+		at: row.createdAt,
+		label: row.subject.label ?? row.subject.className,
+		status: row.status,
+		artifactId: row.artifactIds?.[0] ?? null
+	};
+}
+/**
+* Reduce a newest-first page of history rows.
+*
+* A rule missing from `rows` (never fired, or its last fire fell outside the
+* page this pass could afford) is simply absent from `byRule` — the caller
+* renders that as `unknown`, never as an invented value.
+*/
+function reduceLastTriggers(rows) {
+	const byRule = /* @__PURE__ */ new Map();
+	let overall = null;
+	for (const row of rows) {
+		if (overall === null) overall = reduceOne(row);
+		if (!byRule.has(row.ruleId)) byRule.set(row.ruleId, reduceOne(row));
+	}
+	return {
+		overall,
+		byRule
+	};
+}
+//#endregion
 //#region src/ha-export/reconcile-fingerprint.ts
 function structureFingerprint(exported) {
 	return JSON.stringify([...exported.keys()].sort().map((key) => {
@@ -6259,7 +6490,7 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			* `brokerIds` is every enabled broker, because they belong to the server
 			* and not to a membership the operator picks per camera.
 			*/
-			const synthetic = await this.buildSynthetic(snoozes);
+			const synthetic = await this.buildSynthetic(snoozes, byId);
 			if (synthetic !== null) for (const plan of syntheticPlans(synthetic)) {
 				exported.set(plan.deviceKey, {
 					plan,
@@ -6342,7 +6573,7 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 	* Returns `null` only when NOTHING answered, so the devices are not
 	* announced empty on a hub that is still booting.
 	*/
-	async buildSynthetic(snoozes) {
+	async buildSynthetic(snoozes, byId) {
 		const rules = await this.ctx.api.notificationRules.listRules.query({}).then((r) => r.rules.map((rule) => ({
 			id: rule.id,
 			name: rule.name,
@@ -6371,10 +6602,14 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 		const alerts = await this.readActiveAlerts();
 		if (rules === null && topology === null && addons === null && server === null) return null;
 		this.syntheticRules = rules ?? this.syntheticRules;
+		const effectiveRules = this.syntheticRules;
+		const { lastTrigger, lastTriggerByRule } = await this.buildLastTrigger(byId, effectiveRules);
 		const { nodes, oldestFootageMs } = await this.buildSyntheticNodes(topology ?? []);
 		return {
-			rules: rules ?? this.syntheticRules,
+			rules: effectiveRules,
 			snoozed: anySnoozed,
+			lastTrigger,
+			lastTriggerByRule,
 			nodes,
 			addonsRunning: addons?.running ?? 0,
 			addonsFailed: addons?.failed ?? 0,
@@ -6388,6 +6623,81 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 		};
 	}
 	/**
+	* The most recent notification-rule trigger, GLOBAL and PER RULE —
+	* "conoscere gli ultimi trigger, le ultime immagini... e da quale label"
+	* (operator, 2026-08-25), extended to "l'ultimo trigger PER REGOLA, con
+	* immagine e metadati" (operator, 2026-08-27).
+	*
+	* ONE `getHistory` read serves BOTH: `reduceLastTriggers`
+	* (`rule-triggers.ts`) reduces the same newest-first page into "the very
+	* first row" (global) and "the first row per rule id" (per rule) — never
+	* a query per rule, which is exactly the shape a previous session spent
+	* hours removing from the events path. `NC_HISTORY_LIMIT_MAX` (the cap's
+	* own ceiling) is used rather than the global feature's old `limit: 1`,
+	* so a page wide enough to find every rule's last trigger is fetched in
+	* this one call.
+	*
+	* `rules` bounds the per-rule work to rules that still exist: a deleted
+	* rule's row may still be in the page, but this never mints a signed URL
+	* for it. `resolveArtifactUrl` calls this pass makes are therefore bounded
+	* by the RULE count (~15 measured live), never by fleet size or history
+	* depth — and de-duplicated by artefact id, since two rules matching the
+	* same evaluated record can share one indexed still.
+	*
+	* Best-effort like every other synthetic source here: a failed read costs
+	* only these entities, never the rest of the device.
+	*/
+	async buildLastTrigger(byId, rules) {
+		const NONE = {
+			lastTrigger: null,
+			lastTriggerByRule: /* @__PURE__ */ new Map()
+		};
+		try {
+			const { entries } = await this.ctx.api.notificationRules.getHistory.query({ filter: { limit: 500 } });
+			const { overall, byRule } = reduceLastTriggers(entries);
+			const urlCache = /* @__PURE__ */ new Map();
+			const resolveUrl = async (artifactId, deviceId) => {
+				if (artifactId === null) return null;
+				const cached = urlCache.get(artifactId);
+				if (cached !== void 0) return cached;
+				const url = await this.ctx.api.notificationRules.resolveArtifactUrl.query({ artifactId }).then((r) => r.url).catch((err) => {
+					this.ctx.logger.debug("ha-export: could not resolve a trigger image url", {
+						tags: { deviceId },
+						meta: {
+							artifactId,
+							error: errMsg(err)
+						}
+					});
+					return null;
+				});
+				urlCache.set(artifactId, url);
+				return url;
+			};
+			const toSynthetic = async (t) => ({
+				at: t.at,
+				ruleName: t.ruleName,
+				deviceName: byId.get(t.deviceId)?.name ?? `camera ${t.deviceId}`,
+				label: t.label,
+				status: t.status,
+				imageUrl: await resolveUrl(t.artifactId, t.deviceId)
+			});
+			const lastTrigger = overall === null ? null : await toSynthetic(overall);
+			const lastTriggerByRule = /* @__PURE__ */ new Map();
+			for (const rule of rules) {
+				const reduced = byRule.get(rule.id);
+				if (reduced === void 0) continue;
+				lastTriggerByRule.set(rule.id, await toSynthetic(reduced));
+			}
+			return {
+				lastTrigger,
+				lastTriggerByRule
+			};
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not read the last notification triggers", { meta: { error: errMsg(err) } });
+			return NONE;
+		}
+	}
+	/**
 	* `alerts.list` — the conditions nobody said (Task D1). Best-effort: a
 	* failed read yields "nothing active", not a fabricated absence dressed up
 	* as a clean one — this addon logs the drop rather than pretending the
@@ -6861,10 +7171,24 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 		*/
 		const pruned = haBrokers.length === 0 ? this.config.membership : pruneBrokers(this.config.membership, haBrokers.map((broker) => broker.id));
 		if (haBrokers.length === 0 && Object.keys(this.config.membership).length > 0) this.ctx.logger.warn("ha-export: no Home Assistant broker answered — keeping the export membership rather than pruning it", { meta: { brokers: Object.keys(this.config.membership) } });
-		if (pruned !== this.config.membership || !sameBrokers(known, this.config.knownBrokers)) await this.updateGlobalSettings({
+		/**
+		* ONE key per thing that actually changed — see `brokerRefreshPatch`.
+		*
+		* This used to write `knownBrokers` and `membership` together whenever
+		* EITHER differed. A boot-window settings read that answers empty leaves
+		* `this.config` on its constructor defaults, and that joint write then
+		* persisted `membership: {}` over the operator's real export list on a
+		* pass whose only news was the broker roster. It cost this hub three days
+		* of Home Assistant: 2026-08-24 21:55:13.
+		*/
+		const patch = brokerRefreshPatch({
+			knownBrokers: this.config.knownBrokers,
+			membership: this.config.membership
+		}, {
 			knownBrokers: known,
 			membership: pruned
 		});
+		if (patch !== null) await this.updateGlobalSettings(patch);
 		await this.refreshEnabledBrokers(known);
 		const wanted = new Set(this.enabledBrokerIds());
 		for (const [brokerId, link] of this.links) {
@@ -7740,13 +8064,6 @@ function randomSecret() {
 	crypto.getRandomValues(bytes);
 	return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function sameBrokers(a, b) {
-	if (a.length !== b.length) return false;
-	return a.every((broker, index) => {
-		const other = b[index];
-		return other !== void 0 && other.id === broker.id && other.name === broker.name;
-	});
-}
 function toSnapshot(raw) {
 	if (raw === null || raw === void 0 || typeof raw !== "object") return {};
 	const out = {};