@camstack/addon-advanced-notifier 1.1.13 → 1.1.15

package/dist/addon.js

@@ -4632,7 +4632,7 @@ function _instanceof(cls, params = {}) {
 	return inst;
 }
 //#endregion
-//#region ../types/dist/sleep-C2M2zF7x.mjs
+//#region ../types/dist/sleep-MHm--th-.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -5894,6 +5894,7 @@ var CamStreamKindSchema = _enum([
 	"pull-rtsp",
 	"pull-rtmp",
 	"pull-http",
+	"pull-flv",
 	"pull-rfc4571",
 	"push-annexb",
 	"derived"
@@ -13217,7 +13218,7 @@ var AddBrokerInputSchema = object({
 });
 var AddBrokerResultSchema = object({ id: string() });
 var IdInputSchema = object({ id: string() });
-var TestResultSchema = discriminatedUnion("ok", [object({
+var TestResultSchema$1 = discriminatedUnion("ok", [object({
 	ok: literal(true),
 	latencyMs: number()
 }), object({
@@ -13240,7 +13241,7 @@ var StatusSchema = object({
 	brokerCount: number(),
 	embeddedRunning: boolean()
 });
-method(_void(), array(BrokerInfoSchema)), method(IdInputSchema, BrokerConnectionDetailsSchema), method(AddBrokerInputSchema, AddBrokerResultSchema, { kind: "mutation" }), method(IdInputSchema, _void(), { kind: "mutation" }), method(IdInputSchema, TestResultSchema, { kind: "mutation" }), method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, { kind: "mutation" }), method(IdInputSchema, _void(), { kind: "mutation" }), method(_void(), StatusSchema);
+method(_void(), array(BrokerInfoSchema)), method(IdInputSchema, BrokerConnectionDetailsSchema), method(AddBrokerInputSchema, AddBrokerResultSchema, { kind: "mutation" }), method(IdInputSchema, _void(), { kind: "mutation" }), method(IdInputSchema, TestResultSchema$1, { kind: "mutation" }), method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, { kind: "mutation" }), method(IdInputSchema, _void(), { kind: "mutation" }), method(_void(), StatusSchema);
 var NetworkEndpointSchema = object({
 	url: string(),
 	hostname: string(),
@@ -13274,29 +13275,210 @@ var NetworkEndpointEntrySchema = NetworkEndpointSchema.extend({
 	sourcePort: number().optional()
 });
 method(_void(), NetworkEndpointSchema, { kind: "mutation" }), method(_void(), _void(), { kind: "mutation" }), method(_void(), NetworkEndpointSchema.nullable()), method(_void(), NetworkAccessStatusSchema), method(_void(), array(NetworkEndpointEntrySchema).readonly());
+/**
+* notification-output — canonical, capability-gated notification delivery.
+*
+* Apprise-derived model (see
+* `docs/superpowers/specs/2026-07-03-notification-output-notifier-matrix.md`):
+* callers emit ONE canonical `Notification`; each provider declares a
+* per-kind capability descriptor (`TargetKind`), and the pure degrade
+* engine (`@camstack/types` `prepareNotification`) transcodes / degrades the
+* message to what the kind supports — callers never special-case a service.
+*
+* DESIGN DECISIONS (locked):
+*  - Target CRUD lives on THIS cap (`upsertTarget` / `deleteTarget` /
+*    `setTargetEnabled`), each provider persisting via the `settings-store`
+*    cap. Rationale: the admin UI needs one uniform surface across the
+*    notifiers addon AND the HA addon; the addon-`globalSettingsSchema`-array
+*    alternative would fork the UI per addon and cannot host the
+*    discovery→adopt flow.
+*  - `listTargetKinds` / `listTargets` / `discoverTargets` return arrays →
+*    the generated cap-mount auto-`concatCollection`-fans them across every
+*    registered provider (notifiers addon + HA addon) so one catalog is
+*    routable. `send` / `testTarget` / CRUD route to ONE provider by the
+*    `addonId` the generated collection router extracts from the call input.
+*  - `Attachment.bytes` is `Uint8Array`. Transport-safe: superjson (the tRPC
+*    transformer) + UDS MsgPack both round-trip typed arrays — already used by
+*    `storage` / `storage-provider` / `recording` caps over the same path. No
+*    base64 fallback needed.
+*
+* TODO (deferred, closed-set change — separate decision): add
+* `providerKind: 'notify'` so notification providers surface on the unified
+* admin "Integrations" page.
+*/
+/**
+* Zentik-derived typed-media enum — the superset across every kind. Each
+* adapter picks what it supports and the degrade engine filters the rest.
+*/
+var AttachmentMediaTypeSchema = _enum([
+	"image",
+	"video",
+	"gif",
+	"audio",
+	"icon"
+]);
+/**
+* A single attachment. Exactly one of `url` (remote source, most adapters
+* prefer this) or `bytes` (inline source; required for Pushover-style
+* bytes-only kinds) MUST be present — the degrade engine expresses a
+* url→bytes fetch as a `needsFetch` directive the adapter executes.
+*/
+var AttachmentSchema = object({
+	mediaType: AttachmentMediaTypeSchema,
+	url: string().optional(),
+	bytes: _instanceof(Uint8Array).optional(),
+	mime: string().optional(),
+	name: string().optional()
+}).refine((a) => a.url !== void 0 || a.bytes !== void 0, { message: "Attachment requires either `url` or `bytes`" });
+var NotificationFormatSchema = _enum([
+	"text",
+	"markdown",
+	"html"
+]);
+/** A single tap-through action button. */
+var NotificationActionSchema = object({
+	id: string(),
+	label: string(),
+	url: string().optional()
+});
+/**
+* The canonical notification. `body` is the only hard field (Apprise model).
+* `priority` is a 5-level ORDINAL (1=lowest … 3=normal(default) … 5=urgent),
+* NOT a fixed severity enum — each kind declares its own `caps.levels` and
+* the adapter maps this ordinal onto its native level. `level?` is an
+* optional kind-native level id (`emergency`, `silent`, …) that overrides
+* `priority` for that one target.
+*/
+var NotificationSchema = object({
+	body: string(),
+	title: string().optional(),
+	format: NotificationFormatSchema.default("text"),
+	priority: number().int().min(1).max(5).default(3),
+	level: string().optional(),
+	attachments: array(AttachmentSchema).optional(),
+	clickUrl: string().optional(),
+	actions: array(NotificationActionSchema).optional(),
+	sound: string().optional(),
+	ttl: number().optional(),
+	tag: string().optional(),
+	deviceId: number().optional(),
+	eventId: string().optional(),
+	metadata: record(string(), unknown()).optional()
+});
+/** One declared native severity/priority level for a kind. */
+var TargetKindLevelSchema = object({
+	id: string(),
+	label: string(),
+	/** Which canonical priority (1..5) this level maps to. `null` = qualitative-only. */
+	ordinal: number().int().min(1).max(5).nullable(),
+	flags: object({
+		critical: boolean().optional(),
+		silent: boolean().optional(),
+		noPush: boolean().optional()
+	}).optional(),
+	/** e.g. Pushover `emergency` requires `retry` / `expire`. */
+	requires: array(string()).optional(),
+	description: string().optional()
+});
+/** The full capability block consulted before dispatch. */
+var TargetKindCapsSchema = object({
+	attachments: object({
+		mediaTypes: array(AttachmentMediaTypeSchema),
+		mode: _enum([
+			"url",
+			"bytes",
+			"both"
+		]),
+		max: number().int().nonnegative(),
+		maxBytes: number().int().positive().optional()
+	}),
+	/** Max action buttons (0 = none). */
+	actions: number().int().nonnegative(),
+	levels: array(TargetKindLevelSchema),
+	format: array(NotificationFormatSchema),
+	clickUrl: boolean(),
+	sound: boolean(),
+	ttl: boolean(),
+	bodyMaxLen: number().int().positive()
+});
+/**
+* `configSchema` is a `ConfigUISchema` tree passed through to the admin
+* FormBuilder. Stored as `z.unknown()` at the cap seam (mirrors
+* `device-provider.getChildCreationSchema` `CreationSchemaOutputSchema`) —
+* the union is large and not meant for runtime validation here; the exported
+* `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
+*/
+var ConfigSchemaPassthrough = unknown();
+var TargetKindSchema = object({
+	kind: string(),
+	label: string(),
+	icon: string(),
+	/** Stamped by each provider so the concat-fanned catalog stays routable. */
+	addonId: string(),
+	configSchema: ConfigSchemaPassthrough,
+	supportsDiscovery: boolean(),
+	caps: TargetKindCapsSchema
+});
+/**
+* A persisted target. `config` holds secrets; providers REDACT secret fields
+* (return a presence marker only) when serving `listTargets` — never
+* round-trip a stored secret to the UI.
+*/
+var TargetSchema = object({
+	id: string(),
+	name: string(),
+	kind: string(),
+	addonId: string(),
+	enabled: boolean(),
+	config: record(string(), unknown())
+});
+/** A discovery-surfaced candidate (config is partial + non-secret). */
+var DiscoveredTargetSchema = object({
+	kind: string(),
+	suggestedName: string(),
+	config: record(string(), unknown())
+});
+/** The degrade engine's report — what was resolved / dropped / degraded. */
+var RenderedAsSchema = object({
+	level: string(),
+	format: NotificationFormatSchema,
+	attachmentsSent: number().int().nonnegative(),
+	actionsSent: number().int().nonnegative(),
+	truncated: boolean(),
+	dropped: array(string())
+});
+var SendResultSchema = object({
+	success: boolean(),
+	error: string().optional(),
+	renderedAs: RenderedAsSchema.optional()
+});
+/** Same shape as SendResult — kept as a distinct name for the test panel. */
+var TestResultSchema = SendResultSchema;
 var notificationOutputCapability = {
 	name: "notification-output",
 	scope: "system",
 	mode: "collection",
 	methods: {
+		listTargetKinds: method(object({}), array(TargetKindSchema)),
+		listTargets: method(object({}), array(TargetSchema)),
+		discoverTargets: method(object({
+			kind: string(),
+			config: record(string(), unknown()).optional()
+		}), array(DiscoveredTargetSchema)),
 		send: method(object({
-			title: string(),
-			body: string(),
-			imageUrl: string().optional(),
-			deviceId: number().optional(),
-			eventId: string().optional(),
-			priority: _enum([
-				"low",
-				"normal",
-				"high",
-				"critical"
-			]).default("normal"),
-			metadata: record(string(), unknown()).optional()
-		}), _void(), { kind: "mutation" }),
-		sendTest: method(_void(), object({
-			success: boolean(),
-			error: string().optional()
-		}), { kind: "mutation" })
+			targetId: string(),
+			notification: NotificationSchema
+		}), SendResultSchema, { kind: "mutation" }),
+		testTarget: method(object({
+			targetId: string(),
+			sample: NotificationSchema.optional()
+		}), TestResultSchema, { kind: "mutation" }),
+		upsertTarget: method(object({ target: TargetSchema }), TargetSchema, { kind: "mutation" }),
+		deleteTarget: method(object({ targetId: string() }), _void(), { kind: "mutation" }),
+		setTargetEnabled: method(object({
+			targetId: string(),
+			enabled: boolean()
+		}), _void(), { kind: "mutation" })
 	}
 };
 /**
@@ -19293,13 +19475,49 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"notificationOutput.deleteTarget": {
+		capName: "notification-output",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"notificationOutput.discoverTargets": {
+		capName: "notification-output",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationOutput.listTargetKinds": {
+		capName: "notification-output",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationOutput.listTargets": {
+		capName: "notification-output",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationOutput.send": {
 		capName: "notification-output",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"notificationOutput.sendTest": {
+	"notificationOutput.setTargetEnabled": {
+		capName: "notification-output",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"notificationOutput.testTarget": {
+		capName: "notification-output",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"notificationOutput.upsertTarget": {
 		capName: "notification-output",
 		capScope: "system",
 		addonId: null,
@@ -21285,42 +21503,120 @@ object({
 	schemaVersion: literal(1)
 });
 //#endregion
-//#region src/rules/rule-store.ts
+//#region src/history/audit-log.ts
 var COLLECTION$1 = "addon-settings";
-var KEY = "advanced-notifier:rules";
-var RuleStore = class {
+var LOG_KEY = "notifier-history:log";
+var AuditLog = class {
 	api;
-	constructor(api) {
+	maxEntries;
+	constructor(api, maxEntries = 1e3) {
 		this.api = api;
+		this.maxEntries = maxEntries;
 	}
-	async getRules() {
+	async record(entry) {
+		const updated = [...await this.getAll(), entry];
+		const trimmed = updated.length > this.maxEntries ? updated.slice(updated.length - this.maxEntries) : updated;
+		await this.api.settingsStore.set.mutate({
+			collection: COLLECTION$1,
+			key: LOG_KEY,
+			value: trimmed
+		});
+	}
+	async getHistory(filter) {
+		let entries = await this.getAll();
+		if (filter?.ruleId) entries = entries.filter((e) => e.ruleId === filter.ruleId);
+		if (filter?.deviceId) {
+			const deviceId = filter.deviceId;
+			entries = entries.filter((e) => e.deviceId === deviceId);
+		}
+		if (filter?.from !== void 0) {
+			const from = filter.from;
+			entries = entries.filter((e) => e.timestamp >= from);
+		}
+		if (filter?.to !== void 0) {
+			const to = filter.to;
+			entries = entries.filter((e) => e.timestamp <= to);
+		}
+		if (filter?.limit) entries = entries.slice(-filter.limit);
+		return entries;
+	}
+	async getAll() {
 		const raw = await this.api.settingsStore.get.query({
 			collection: COLLECTION$1,
-			key: KEY
+			key: LOG_KEY
 		});
 		if (!raw || !Array.isArray(raw)) return [];
 		return raw;
 	}
-	async saveRules(rules) {
-		await this.api.settingsStore.set.mutate({
-			collection: COLLECTION$1,
-			key: KEY,
-			value: [...rules]
+};
+//#endregion
+//#region src/outputs/console.ts
+var ConsoleOutput = class {
+	id = "console";
+	name = "Console Log";
+	icon = "terminal";
+	logger;
+	constructor(logger) {
+		this.logger = logger;
+	}
+	async send(notification) {
+		this.logger.info(`[p${notification.priority}] ${notification.title ?? ""}: ${notification.body}`, notification.deviceId !== void 0 ? { tags: { deviceId: notification.deviceId } } : void 0);
+	}
+	async sendTest() {
+		await this.send({
+			title: "Test",
+			body: "Console output working",
+			format: "text",
+			priority: 3
 		});
+		return { success: true };
 	}
-	async upsertRule(rule) {
-		const rules = await this.getRules();
-		const idx = rules.findIndex((r) => r.id === rule.id);
-		if (idx >= 0) rules[idx] = rule;
-		else rules.push(rule);
-		await this.saveRules(rules);
+};
+//#endregion
+//#region src/rules/cooldown.ts
+var CooldownTracker = class {
+	lastFired = /* @__PURE__ */ new Map();
+	canFire(ruleId, cooldownSeconds) {
+		const last = this.lastFired.get(ruleId);
+		if (last === void 0) return true;
+		return (Date.now() - last) / 1e3 >= cooldownSeconds;
 	}
-	async deleteRule(ruleId) {
-		const rules = await this.getRules();
-		await this.saveRules(rules.filter((r) => r.id !== ruleId));
+	recordFire(ruleId) {
+		this.lastFired.set(ruleId, Date.now());
+	}
+	reset() {
+		this.lastFired.clear();
 	}
 };
 //#endregion
+//#region src/rules/recent-events.ts
+/**
+* Rehydrate serialized recent events into `SystemEvent`s and drop any that
+* fall before `since`. Order is preserved (the hub returns oldest → newest).
+*/
+function reconstructRecentEvents(serialized, since) {
+	const sinceMs = since.getTime();
+	const events = [];
+	for (const e of serialized) {
+		const timestamp = new Date(e.timestamp);
+		if (timestamp.getTime() < sinceMs) continue;
+		events.push({
+			id: e.id,
+			timestamp,
+			source: {
+				type: e.source.type,
+				id: e.source.id,
+				...e.source.nodeId !== void 0 ? { nodeId: e.source.nodeId } : {},
+				...e.source.addonId !== void 0 ? { addonId: e.source.addonId } : {},
+				...e.source.deviceId !== void 0 ? { deviceId: e.source.deviceId } : {}
+			},
+			category: e.category,
+			data: e.data
+		});
+	}
+	return events;
+}
+//#endregion
 //#region src/rules/rule-engine.ts
 var RuleEngine = class {
 	clip;
@@ -21393,19 +21689,39 @@ var RuleEngine = class {
 	}
 };
 //#endregion
-//#region src/rules/cooldown.ts
-var CooldownTracker = class {
-	lastFired = /* @__PURE__ */ new Map();
-	canFire(ruleId, cooldownSeconds) {
-		const last = this.lastFired.get(ruleId);
-		if (last === void 0) return true;
-		return (Date.now() - last) / 1e3 >= cooldownSeconds;
+//#region src/rules/rule-store.ts
+var COLLECTION = "addon-settings";
+var KEY = "advanced-notifier:rules";
+var RuleStore = class {
+	api;
+	constructor(api) {
+		this.api = api;
 	}
-	recordFire(ruleId) {
-		this.lastFired.set(ruleId, Date.now());
+	async getRules() {
+		const raw = await this.api.settingsStore.get.query({
+			collection: COLLECTION,
+			key: KEY
+		});
+		if (!raw || !Array.isArray(raw)) return [];
+		return raw;
 	}
-	reset() {
-		this.lastFired.clear();
+	async saveRules(rules) {
+		await this.api.settingsStore.set.mutate({
+			collection: COLLECTION,
+			key: KEY,
+			value: [...rules]
+		});
+	}
+	async upsertRule(rule) {
+		const rules = await this.getRules();
+		const idx = rules.findIndex((r) => r.id === rule.id);
+		if (idx >= 0) rules[idx] = rule;
+		else rules.push(rule);
+		await this.saveRules(rules);
+	}
+	async deleteRule(ruleId) {
+		const rules = await this.getRules();
+		await this.saveRules(rules.filter((r) => r.id !== ruleId));
 	}
 };
 //#endregion
@@ -21417,77 +21733,6 @@ function renderTemplate(template, variables) {
 	});
 }
 //#endregion
-//#region src/outputs/console.ts
-var ConsoleOutput = class {
-	id = "console";
-	name = "Console Log";
-	icon = "terminal";
-	logger;
-	constructor(logger) {
-		this.logger = logger;
-	}
-	async send(notification) {
-		this.logger.info(`[${notification.severity}] ${notification.title}: ${notification.message}`, notification.deviceId !== void 0 ? { tags: { deviceId: notification.deviceId } } : void 0);
-	}
-	async sendTest() {
-		await this.send({
-			title: "Test",
-			message: "Console output working",
-			severity: "info",
-			category: "test",
-			timestamp: Date.now()
-		});
-		return { success: true };
-	}
-};
-//#endregion
-//#region src/history/audit-log.ts
-var COLLECTION = "addon-settings";
-var LOG_KEY = "notifier-history:log";
-var AuditLog = class {
-	api;
-	maxEntries;
-	constructor(api, maxEntries = 1e3) {
-		this.api = api;
-		this.maxEntries = maxEntries;
-	}
-	async record(entry) {
-		const updated = [...await this.getAll(), entry];
-		const trimmed = updated.length > this.maxEntries ? updated.slice(updated.length - this.maxEntries) : updated;
-		await this.api.settingsStore.set.mutate({
-			collection: COLLECTION,
-			key: LOG_KEY,
-			value: trimmed
-		});
-	}
-	async getHistory(filter) {
-		let entries = await this.getAll();
-		if (filter?.ruleId) entries = entries.filter((e) => e.ruleId === filter.ruleId);
-		if (filter?.deviceId) {
-			const deviceId = filter.deviceId;
-			entries = entries.filter((e) => e.deviceId === deviceId);
-		}
-		if (filter?.from !== void 0) {
-			const from = filter.from;
-			entries = entries.filter((e) => e.timestamp >= from);
-		}
-		if (filter?.to !== void 0) {
-			const to = filter.to;
-			entries = entries.filter((e) => e.timestamp <= to);
-		}
-		if (filter?.limit) entries = entries.slice(-filter.limit);
-		return entries;
-	}
-	async getAll() {
-		const raw = await this.api.settingsStore.get.query({
-			collection: COLLECTION,
-			key: LOG_KEY
-		});
-		if (!raw || !Array.isArray(raw)) return [];
-		return raw;
-	}
-};
-//#endregion
 //#region src/addon.ts
 var EVENT_CATEGORIES = [
 	EventCategory.DetectionRaw,
@@ -21539,7 +21784,9 @@ var AdvancedNotifierAddon = class extends BaseAddon {
 			const rule = this.cachedRules.find((r) => r.id === ruleId);
 			if (!rule) return { results: [] };
 			const since = /* @__PURE__ */ new Date(Date.now() - lookbackMinutes * 60 * 1e3);
-			return { results: this.ctx.eventBus.getRecent({ category: void 0 }, 1e3).filter((e) => e.timestamp >= since).map((event) => {
+			const api = this.ctx.api;
+			if (!api) return { results: [] };
+			return { results: reconstructRecentEvents(await api.eventBusProxy.getRecent.query({ limit: 1e3 }), since).map((event) => {
 				const matched = this.ruleEngine.evaluate(event, [rule]);
 				return {
 					ruleId,
@@ -21703,12 +21950,11 @@ var AdvancedNotifierAddon = class extends BaseAddon {
 			const deviceId = Number.isFinite(deviceIdNum) ? deviceIdNum : void 0;
 			const notification = {
 				title,
-				message,
-				severity: this.priorityToSeverity(rule.priority),
-				category: event.category,
+				body: message,
+				format: "text",
+				priority: this.priorityToOrdinal(rule.priority),
 				deviceId,
-				data: event.data,
-				timestamp: event.timestamp.getTime()
+				metadata: event.data
 			};
 			let success = true;
 			let dispatchError;
@@ -21753,10 +21999,18 @@ var AdvancedNotifierAddon = class extends BaseAddon {
 			timestamp: event.timestamp.toISOString()
 		};
 	}
-	priorityToSeverity(priority) {
-		if (priority === "critical") return "critical";
-		if (priority === "high") return "warning";
-		return "info";
+	/**
+	* Map a rule's qualitative priority onto the canonical 1..5 ordinal.
+	* Callers now pass ordinal priority; each `notification-output` provider
+	* maps the ordinal onto its declared native level.
+	*/
+	priorityToOrdinal(priority) {
+		switch (priority) {
+			case "critical": return 5;
+			case "high": return 4;
+			case "low": return 2;
+			default: return 3;
+		}
 	}
 };
 //#endregion