@camstack/addon-provider-homeassistant 1.2.635 → 1.2.637

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

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_dist = require("../dist-C_PMvyYa.js");
+const require_dist = require("../dist-DYCWN6ge.js");
 let node_crypto = require("node:crypto");
 require("node:zlib");
 let node_fs = require("node:fs");
@@ -585,6 +585,7 @@ var KNOWN_PLATFORMS = new Set([
 	"camera",
 	"alarm_control_panel",
 	"number",
+	"notify",
 	"cover",
 	"climate",
 	"lock",
@@ -3488,10 +3489,18 @@ function controlEntitySpecs(slice, quantity) {
 	}, kindExtra];
 }
 var CAPS_NOT_EXPORTED = [
+	{
+		cap: "pet-fountain",
+		reason: "A fountain is BUILT here from the loose entities Home Assistant already holds (a pump switch, two number boxes, a button), so exporting it back would publish a second copy of entities that already exist there. A dedicated mapping can follow when an ecosystem asks for the built device."
+	},
 	{
 		cap: "ir-transmitter",
 		reason: "A pulse-train emitter with no state: it is driven by the remote that owns a command table, and a raw send has no meaningful single entity."
 	},
+	{
+		cap: "remote",
+		reason: "A named command map sent through a transmitter. Its useful surface for an ecosystem is the `media-player` the same device provides (power, volume, source); the free-form command name has no typed entity. Its state (last command, last send time) is session-only bookkeeping."
+	},
 	{
 		cap: "group-status",
 		reason: "Bookkeeping for a helper group (D944): how many members were included, excluded, or named. The value an operator automates on is the output capability (the temperature, the motion, the watts). These counts are session-only, have no history, and would publish a second entity that never means the reading."
@@ -5683,7 +5692,8 @@ function renderCapValue(mapping, raw) {
 		case "alarm_control_panel":
 		case "image":
 		case "camera": return typeof raw === "string" ? raw : null;
-		case "button": return null;
+		case "button":
+		case "notify": return null;
 		case "cover":
 		case "climate":
 		case "lock":
@@ -6640,7 +6650,8 @@ function projectSynthetic(input, nowMs) {
 		}, {
 			topic: stateTopic(srv, `${slug}_cpu`),
 			value: String(Math.round(node.cpuPercent))
-		}, {
+		});
+		if (node.memoryPercent !== null) values.push({
 			topic: stateTopic(srv, `${slug}_memory`),
 			value: String(Math.round(node.memoryPercent))
 		});
@@ -6670,6 +6681,225 @@ function projectSynthetic(input, nowMs) {
 	return values;
 }
 //#endregion
+//#region src/ha-export/exported-entities.ts
+/**
+* Actions and notification targets exported to Home Assistant (D968).
+*
+* An action is a `button`: pressing it runs the action through `actions.run`.
+* A notification target is a `notify` entity: a message sent to it goes out
+* through `notification-output.send` to that target. Both live on ONE
+* synthetic device — they are list entries, never camstack devices (D954), so
+* nothing here touches the device registry or the membership store.
+*
+* The selection is this addon's own setting. The class holds it, validates an
+* entry against the live lists, prunes what the operator deleted (a failed
+* read changes nothing, D49), and answers the commands Home Assistant sends
+* back. The addon supplies `persist` and `reconcile`, so the lifecycle is
+* testable without an Home Assistant.
+*
+* `notify` is a platform the custom component must BUILD (see
+* `component-support.ts`): against a component that does not, the targets are
+* withheld from the plan and the caller logs which ones, by name — an entity
+* announced to a component that drops it would read as "exported nothing".
+*/
+/** The stable id of the synthetic device that carries them. A WIRE FORMAT. */
+var EXPORTED_ENTITIES_STABLE_ID = "synthetic-exported-entities";
+var EXPORTER = "homeassistant-export";
+/** `action_<slug>` — derived from the action ID, so a rename keeps its entity. */
+function actionEntity(actionId) {
+	return `action_${toSlug(actionId)}`;
+}
+/** `notify_<slug>` — derived from the target ID. */
+function targetEntity(targetId) {
+	return `notify_${toSlug(targetId)}`;
+}
+function errMsg$1(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+var ExportedEntities = class {
+	ports;
+	state;
+	constructor(ports, initial) {
+		this.ports = ports;
+		this.state = initial;
+	}
+	/** The cap's `listExposedEntities` rows for actions and notifiers. */
+	list() {
+		return [...this.state.actions.map((e) => ({
+			entity: {
+				kind: "action",
+				actionId: e.actionId
+			},
+			exposedAs: e.displayName
+		})), ...this.state.targets.map((e) => ({
+			entity: {
+				kind: "notifier",
+				targetId: e.targetId
+			},
+			exposedAs: e.displayName
+		}))];
+	}
+	async expose(entity) {
+		if (entity.kind === "device") throw new Error("homeassistant-export: a device is not an action or a notification target");
+		if (entity.kind === "action") {
+			const action = (await this.ports.api.actions.list.query({})).find((a) => a.id === entity.actionId);
+			if (action === void 0) throw new Error(`homeassistant-export: action '${entity.actionId}' does not exist`);
+			const previous = this.state.actions.find((e) => e.actionId === entity.actionId);
+			const entry = {
+				actionId: entity.actionId,
+				displayName: action.name,
+				addedAt: previous?.addedAt ?? Date.now()
+			};
+			await this.save({
+				...this.state,
+				actions: [...this.state.actions.filter((e) => e.actionId !== entity.actionId), entry]
+			});
+			this.ports.logger.info("homeassistant-export: exposed action", {
+				tags: { actionId: entity.actionId },
+				meta: { displayName: action.name }
+			});
+		} else {
+			const target = (await this.ports.api.notificationOutput.listTargets.query({})).find((t) => t.id === entity.targetId);
+			if (target === void 0) throw new Error(`homeassistant-export: notification target '${entity.targetId}' does not exist`);
+			const previous = this.state.targets.find((e) => e.targetId === entity.targetId);
+			const entry = {
+				targetId: entity.targetId,
+				displayName: target.name,
+				addedAt: previous?.addedAt ?? Date.now()
+			};
+			await this.save({
+				...this.state,
+				targets: [...this.state.targets.filter((e) => e.targetId !== entity.targetId), entry]
+			});
+			this.ports.logger.info("homeassistant-export: exposed notification target", {
+				tags: { targetId: entity.targetId },
+				meta: { displayName: target.name }
+			});
+		}
+		await this.ports.reconcile();
+	}
+	async unexpose(entity) {
+		if (entity.kind === "device") throw new Error("homeassistant-export: a device is not an action or a notification target");
+		const next = entity.kind === "action" ? {
+			...this.state,
+			actions: this.state.actions.filter((e) => e.actionId !== entity.actionId)
+		} : {
+			...this.state,
+			targets: this.state.targets.filter((e) => e.targetId !== entity.targetId)
+		};
+		await this.save(next);
+		await this.ports.reconcile();
+	}
+	/**
+	* Drop what the operator deleted, logging each drop. A list that could not
+	* be read changes nothing: a failed read must never destroy the selection.
+	*/
+	async pruneDeleted() {
+		if (this.state.actions.length === 0 && this.state.targets.length === 0) return;
+		let actionIds;
+		let targetIds;
+		try {
+			const [actions, targets] = await Promise.all([this.ports.api.actions.list.query({}), this.ports.api.notificationOutput.listTargets.query({})]);
+			actionIds = new Set(actions.map((a) => a.id));
+			targetIds = new Set(targets.map((t) => t.id));
+		} catch (err) {
+			this.ports.logger.warn("homeassistant-export: exported entities not reconciled — a list was unanswered", { meta: { error: errMsg$1(err) } });
+			return;
+		}
+		const { dropped } = require_dist.pruneDeletedEntities([...this.state.actions.map((e) => ({
+			kind: "action",
+			actionId: e.actionId
+		})), ...this.state.targets.map((e) => ({
+			kind: "notifier",
+			targetId: e.targetId
+		}))], {
+			actionIds,
+			targetIds
+		}, this.ports.logger, EXPORTER);
+		if (dropped.length === 0) return;
+		const goneActions = new Set(dropped.flatMap((r) => r.kind === "action" ? [r.actionId] : []));
+		const goneTargets = new Set(dropped.flatMap((r) => r.kind === "notifier" ? [r.targetId] : []));
+		await this.save({
+			actions: this.state.actions.filter((e) => !goneActions.has(e.actionId)),
+			targets: this.state.targets.filter((e) => !goneTargets.has(e.targetId))
+		});
+	}
+	/** The synthetic device the selection announces. Null when nothing is exported. */
+	plan(support) {
+		const deviceKey = syntheticDeviceKeyFor(EXPORTED_ENTITIES_STABLE_ID);
+		const cmps = {};
+		for (const e of this.state.actions) {
+			const entity = actionEntity(e.actionId);
+			cmps[toComponentKey("button", entity)] = {
+				platform: "button",
+				unique_id: `${EXPORTED_ENTITIES_STABLE_ID}_${entity}`,
+				name: e.displayName,
+				command_topic: commandTopic(deviceKey, entity),
+				payload_press: "PRESS",
+				icon: "mdi:play-circle-outline"
+			};
+		}
+		const withheld = [];
+		for (const e of this.state.targets) {
+			if (!support.has("notify")) {
+				withheld.push(e.targetId);
+				continue;
+			}
+			const entity = targetEntity(e.targetId);
+			cmps[toComponentKey("notify", entity)] = {
+				platform: "notify",
+				unique_id: `${EXPORTED_ENTITIES_STABLE_ID}_${entity}`,
+				name: e.displayName,
+				command_topic: commandTopic(deviceKey, entity),
+				icon: "mdi:message-text-outline"
+			};
+		}
+		if (Object.keys(cmps).length === 0) return {
+			plan: null,
+			withheld
+		};
+		return {
+			plan: {
+				deviceKey,
+				deviceId: null,
+				dev: {
+					ids: [deviceKey],
+					name: "CamStack Actions and Notifications",
+					mf: "CamStack",
+					mdl: "Synthetic"
+				},
+				cmps
+			},
+			withheld
+		};
+	}
+	/** Answer a command Home Assistant sent for this device. */
+	async handleCommand(entity, value) {
+		const action = this.state.actions.find((e) => actionEntity(e.actionId) === entity);
+		if (action !== void 0) return {
+			handled: true,
+			applied: (await require_dist.runExportedAction(this.ports.api, this.ports.logger, {
+				exporter: EXPORTER,
+				actionId: action.actionId
+			})).status === "started"
+		};
+		const target = this.state.targets.find((e) => targetEntity(e.targetId) === entity);
+		if (target !== void 0) return {
+			handled: true,
+			applied: (await require_dist.sendToExportedTarget(this.ports.api, this.ports.logger, {
+				exporter: EXPORTER,
+				targetId: target.targetId,
+				notification: { body: value }
+			})).status === "sent"
+		};
+		return { handled: false };
+	}
+	async save(next) {
+		this.state = next;
+		await this.ports.persist(next);
+	}
+};
+//#endregion
 //#region src/ha-export/supported-device-kinds.ts
 /**
 * Device types the Home Assistant export picker offers.
@@ -6774,6 +7004,10 @@ var DEFAULT_CONFIG = {
 	reconcileIntervalSec: 300,
 	membership: {},
 	knownBrokers: [],
+	exportedEntities: {
+		actions: [],
+		targets: []
+	},
 	publicBaseUrl: ""
 };
 var HaExportAddon = class extends require_dist.BaseAddon {
@@ -6845,6 +7079,8 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 	* whenever the synthetic devices are, never written to.
 	*/
 	syntheticRules = [];
+	/** D968: the actions and notification targets exported beside the devices. */
+	exportedEntities = null;
 	/**
 	* `pipelineOrchestrator.getCameraStatuses`, keyed by deviceId — ONE call
 	* per reconcile pass for every exported camera (Task C3), never per
@@ -6905,6 +7141,13 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			for (const link of this.links.values()) await link.client.dispose();
 			this.links.clear();
 		});
+		const exportedEntities = new ExportedEntities({
+			api: this.ctx.api,
+			logger: this.ctx.logger,
+			persist: (next) => this.updateGlobalSettings({ exportedEntities: next }),
+			reconcile: () => this.reconcile("exported-entities-changed")
+		}, this.config.exportedEntities ?? DEFAULT_CONFIG.exportedEntities);
+		this.exportedEntities = exportedEntities;
 		return [
 			{
 				capability: require_dist.deviceExportCapability,
@@ -6917,6 +7160,23 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 					})),
 					exposeDevice: async ({ deviceId }) => this.setMembershipEverywhere(deviceId, true),
 					unexposeDevice: async ({ deviceId }) => this.setMembershipEverywhere(deviceId, false),
+					listSupportedEntityKinds: async () => [
+						"device",
+						"action",
+						"notifier"
+					],
+					listExposedEntities: async () => {
+						await exportedEntities.pruneDeleted();
+						return [...exposedDeviceIds(this.config.membership, this.enabledBrokerIds()).map((deviceId) => ({
+							entity: {
+								kind: "device",
+								deviceId
+							},
+							exposedAs: brokersExposing(this.config.membership, deviceId).map((brokerId) => this.brokerName(brokerId)).join(", ")
+						})), ...exportedEntities.list()];
+					},
+					exposeEntity: async ({ entity }) => entity.kind === "device" ? this.setMembershipEverywhere(entity.deviceId, true) : exportedEntities.expose(entity),
+					unexposeEntity: async ({ entity }) => entity.kind === "device" ? this.setMembershipEverywhere(entity.deviceId, false) : exportedEntities.unexpose(entity),
 					getDeviceSettingsContribution: async ({ deviceId }) => this.buildContribution(deviceId),
 					getDeviceLiveContribution: async () => null,
 					applyDeviceSettingsPatch: async ({ deviceId, patch }) => this.applyDeviceSettingsPatch(deviceId, patch)
@@ -7554,6 +7814,32 @@ 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.
 			*/
+			/**
+			* The exported actions and notification targets (D968): one more
+			* synthetic device. What the operator deleted is dropped first (a failed
+			* read changes nothing); a target the component cannot build as `notify`
+			* is named, not silently lost.
+			*/
+			if (this.exportedEntities !== null) {
+				await this.exportedEntities.pruneDeleted();
+				const { plan: entitiesPlan, withheld } = this.exportedEntities.plan(this.componentSupport.supportForAll([...enabled]));
+				if (withheld.length > 0) this.ctx.logger.warn("ha-export: notification targets withheld — the Home Assistant component does not build notify entities yet", { meta: { targetIds: withheld } });
+				if (entitiesPlan !== null) {
+					exported.set(entitiesPlan.deviceKey, {
+						plan: entitiesPlan,
+						deviceId: -1,
+						target: {
+							deviceId: -1,
+							type: "synthetic",
+							boundCaps: []
+						},
+						brokerIds: [...enabled],
+						streams: [],
+						cameraFunctions: null
+					});
+					entityCount += Object.keys(entitiesPlan.cmps).length;
+				}
+			}
 			const synthetic = await this.buildSynthetic(byId);
 			if (synthetic !== null) for (const plan of syntheticPlans(synthetic)) {
 				exported.set(plan.deviceKey, {
@@ -8576,6 +8862,21 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 		* `setRuleEnabled`, never a store of its own. A second knob that can
 		* disagree with the admin UI is worse than no knob (D62).
 		*/
+		if (this.exportedEntities !== null && parsed.deviceKey === syntheticDeviceKeyFor("synthetic-exported-entities")) {
+			const outcome = await this.exportedEntities.handleCommand(parsed.entity, value);
+			if (!outcome.handled) {
+				this.ctx.logger.warn("ha-export: dropping a command for an entity that is not exported", { meta: {
+					topic,
+					entity: parsed.entity
+				} });
+				reply.status(422);
+				reply.send({ error: "entity not exported" });
+				return;
+			}
+			reply.status(outcome.applied ? 200 : 422);
+			reply.send(outcome.applied ? {} : { error: "command not applied" });
+			return;
+		}
 		if (isSyntheticDeviceKey(parsed.deviceKey)) {
 			const ruleId = ruleIdFromEntity(parsed.entity, this.syntheticRules);
 			if (ruleId === null) {