@camstack/system 1.2.444 → 1.2.445

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,6 @@
-import { $i as EventCategory, Fr as BaseAddon, Pr as errMsg, ct as alertsCapability, i as AlertSchema, yi as createEvent } from "../../dist-DERK-gP5.mjs";
+import { Ci as createEvent, Di as defineRecordKinds, Lr as errMsg, Rr as BaseAddon, ft as alertsCapability, i as AlertSchema, la as EventCategory } from "../../dist-BNunRyXT.mjs";
+import { t as require_read_all_rows } from "../../read-all-rows-TaPqdWNF.mjs";
+import { t as resolvePhase6UseRecordsPathForHub } from "../../phase6-declare-gate-tkKOEitw.mjs";
 //#region src/builtins/alerts/critical-push.ts
 /** Alert categories that are critical system findings. */
 var CRITICAL_CATEGORIES = new Set([
@@ -277,6 +279,210 @@ function runnerPushLine(record) {
 	return record.state === "refused" ? `${where}: refused to start. ${record.remedy ?? "See the Addons page."}` : `${where}: stopped after repeated crashes. Restart it from the Addons page.`;
 }
 //#endregion
+//#region src/builtins/alerts/record-kinds.ts
+var import_read_all_rows = require_read_all_rows();
+/**
+* Record kinds owned by alert-center (records plan phase 4).
+*/
+/** Legacy collection / adoptsFrom target (canonical KV before phase 4). */
+var ALERTS_COLLECTION = "alerts";
+var _alertCenterRecordKinds = defineRecordKinds({ alerts: {
+	schema: AlertSchema.omit({ id: true }),
+	class: "audit",
+	writeTrigger: "EventBus categories the alert center tracks, operator mark read/dismiss, and model-download progress merges",
+	device: "none",
+	at: "none",
+	indexes: [
+		{
+			name: "read",
+			fields: ["read"]
+		},
+		{
+			name: "created_at",
+			fields: ["createdAt"]
+		},
+		{
+			name: "updated_at",
+			fields: ["updatedAt"]
+		}
+	],
+	retention: {
+		owner: "alert-center",
+		reason: "maxAlerts cap and retentionDays enforced on write (enforceMaxAlerts / enforceRetention); read alerts preferred when trimming overflow"
+	},
+	adoptsFrom: ALERTS_COLLECTION
+} });
+var alertCenterRecordKinds = _alertCenterRecordKinds;
+/** Narrow kind for `records.kind()` — `IsolatedRecordKinds` string index is `| undefined`. */
+var alertsRecordKind = _alertCenterRecordKinds.alerts;
+//#endregion
+//#region src/builtins/alerts/alert-store.ts
+function toRecord(row) {
+	return {
+		id: row.id,
+		data: row.data
+	};
+}
+function toRecordFromLegacy(row) {
+	return {
+		id: row.id,
+		data: row.data
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function legacyGetData(value) {
+	if (!isRecord(value)) return null;
+	if ("data" in value) {
+		const data = value.data;
+		return isRecord(data) ? data : null;
+	}
+	return value;
+}
+var AlertStore = class AlertStore {
+	kind;
+	legacyStore;
+	constructor(kind, legacyStore) {
+		this.kind = kind;
+		this.legacyStore = legacyStore;
+	}
+	static of(records) {
+		return new AlertStore(records.kind(alertsRecordKind), null);
+	}
+	static legacy(store) {
+		return new AlertStore(null, store);
+	}
+	async legacyRows() {
+		const store = this.legacyStore;
+		if (store === null) return [];
+		return (await store.query.query({
+			collection: ALERTS_COLLECTION,
+			filter: {}
+		})).map((row) => toRecordFromLegacy({
+			id: row.id,
+			data: row.data
+		}));
+	}
+	async list(filter) {
+		let out;
+		const kind = this.kind;
+		if (kind !== null) out = (await (0, import_read_all_rows.readAllRows)(kind, { order: "id" })).map(toRecord);
+		else out = [...await this.legacyRows()];
+		if (filter?.unreadOnly === true) out = out.filter((r) => r.data["read"] === false);
+		out.sort((a, b) => Number(b.data["updatedAt"] ?? 0) - Number(a.data["updatedAt"] ?? 0));
+		const limit = filter?.limit ?? 100;
+		return out.slice(0, limit);
+	}
+	async countUnread() {
+		return (await this.list({
+			unreadOnly: true,
+			limit: 1e4
+		})).length;
+	}
+	async countAll() {
+		const kind = this.kind;
+		if (kind !== null) return (await (0, import_read_all_rows.readAllRows)(kind)).length;
+		return (await this.legacyRows()).length;
+	}
+	async getData(id) {
+		const kind = this.kind;
+		if (kind !== null) {
+			const row = await kind.get(id);
+			if (row === null) return null;
+			return row.data;
+		}
+		const store = this.legacyStore;
+		if (store === null) return null;
+		return legacyGetData(await store.get.query({
+			collection: ALERTS_COLLECTION,
+			key: id
+		}));
+	}
+	async mergeUpdate(id, patch) {
+		const existing = await this.getData(id);
+		if (existing === null) return;
+		await this.putRaw(id, {
+			...existing,
+			...patch
+		});
+	}
+	async persist(alert) {
+		const { id, ...body } = alert;
+		const data = alertsRecordKind.schema.parse(body);
+		const kind = this.kind;
+		if (kind !== null) {
+			await kind.put({
+				id,
+				data
+			});
+			return;
+		}
+		await this.putRaw(id, {
+			...body,
+			id
+		});
+	}
+	async putRaw(id, data) {
+		const { id: _drop, ...body } = AlertSchema.parse({
+			id,
+			...data
+		});
+		const kind = this.kind;
+		if (kind !== null) {
+			await kind.put({
+				id,
+				data: body
+			});
+			return;
+		}
+		const store = this.legacyStore;
+		if (store === null) return;
+		await store.set.mutate({
+			collection: ALERTS_COLLECTION,
+			key: id,
+			value: {
+				id,
+				...body
+			}
+		});
+	}
+	async delete(id) {
+		const kind = this.kind;
+		if (kind !== null) {
+			await kind.delete(id);
+			return;
+		}
+		const store = this.legacyStore;
+		if (store === null) return;
+		await store.delete.mutate({
+			collection: ALERTS_COLLECTION,
+			key: id
+		});
+	}
+	async listAllByCreatedAtAsc() {
+		const kind = this.kind;
+		let out;
+		if (kind !== null) out = (await (0, import_read_all_rows.readAllRows)(kind)).map(toRecord);
+		else out = [...await this.legacyRows()];
+		out.sort((a, b) => Number(a.data["createdAt"] ?? 0) - Number(b.data["createdAt"] ?? 0));
+		return out;
+	}
+	async listRecent(limit) {
+		const kind = this.kind;
+		let out;
+		if (kind !== null) out = (await (0, import_read_all_rows.readAllRows)(kind, { order: "id" })).map(toRecord);
+		else out = [...await this.legacyRows()];
+		out.sort((a, b) => Number(b.data["updatedAt"] ?? 0) - Number(a.data["updatedAt"] ?? 0));
+		return out.slice(0, limit);
+	}
+	async findWhereDataField(field, value) {
+		const kind = this.kind;
+		if (kind !== null) return (await (0, import_read_all_rows.readAllRows)(kind)).filter((r) => r.data[field] === value).map(toRecord);
+		return (await this.legacyRows()).filter((r) => r.data[field] === value);
+	}
+};
+//#endregion
 //#region src/builtins/alerts/alerts.addon.ts
 var CATEGORY_MAPPINGS = {
 	"addon.crashed": {
@@ -449,13 +655,18 @@ var DEFAULT_CONFIG = {
 	maxAlerts: 500,
 	retentionDays: 30,
 	criticalPushEnabled: true,
-	criticalPushTargetIds: ""
+	criticalPushTargetIds: []
 };
+/** Accept the live `string[]` shape and the pre-multiselect CSV string. */
+function normalizeCriticalPushTargetIds(raw) {
+	if (Array.isArray(raw)) return raw.filter((id) => typeof id === "string" && id.trim().length > 0).map((id) => id.trim());
+	if (typeof raw === "string" && raw.trim().length > 0) return raw.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
+	return [];
+}
 /** One burst of critical findings (a whole boot of refused runners) is ONE digest push. */
 var PUSH_COALESCE_MS = 2e3;
 /** Addons whose (re)start is a reason to retry pending critical pushes. */
 var PUSH_RECONCILE_ADDONS = new Set(["notifiers", "notification-center"]);
-var ALERTS_COLLECTION = "alerts";
 var EVENT_SOURCE = {
 	type: "addon",
 	id: "alert-center"
@@ -476,6 +687,7 @@ function toPrunable(record) {
 	};
 }
 var AlertCenterAddon = class extends BaseAddon {
+	alertStore = null;
 	unsubscribers = [];
 	/** How long a burst of critical findings is gathered into one digest push. */
 	pushCoalesceMs;
@@ -490,6 +702,11 @@ var AlertCenterAddon = class extends BaseAddon {
 	*/
 	rateLimitCounters = /* @__PURE__ */ new Map();
 	async onInitialize() {
+		const records = this.ctx.records;
+		const store = this.ctx.api?.settingsStore;
+		const useRecords = records !== void 0 && store !== void 0 && await resolvePhase6UseRecordsPathForHub(this.ctx, "alert-center", alertCenterRecordKinds, ["alerts"]);
+		this.alertStore = useRecords && records !== void 0 ? AlertStore.of(records) : store === void 0 ? null : AlertStore.legacy(store);
+		if (this.alertStore === null) throw new Error("alert-center needs ctx.records or settings-store on the hub");
 		const alertsProvider = {
 			emit: (alert) => this.emitAlert(alert),
 			update: (input) => this.updateAlert(input.alertId, input.patch),
@@ -509,6 +726,7 @@ var AlertCenterAddon = class extends BaseAddon {
 		this.unsubscribers = unsubs;
 		this.reconcilePendingPushes();
 		this.dismissLegacyStreamCards(void 0);
+		this.migrateCriticalPushTargetIds();
 		this.ctx.logger.info("Initialized", { meta: { trackedCategoriesCount: TRACKED_CATEGORIES.length } });
 		return [{
 			capability: alertsCapability,
@@ -556,43 +774,28 @@ var AlertCenterAddon = class extends BaseAddon {
 					type: "boolean",
 					key: "criticalPushEnabled",
 					label: "Push critical system alerts",
-					description: "A runner that failed or refused to start, or a node whose runners are degraded, is pushed straight to the notifier targets - even when notification-center is down.",
+					description: "A runner that failed or refused to start, or a node whose runners are degraded, is pushed straight to the notifier targets — even when Notification Center is down. This path does not use notification rules.",
 					default: true
 				}),
 				this.field({
-					type: "text",
+					type: "notification-target-multiselect",
 					key: "criticalPushTargetIds",
 					label: "Critical push targets",
-					description: "Comma-separated notifier target ids. Empty = every enabled shared (not personal) target.",
-					default: ""
+					description: "Notifier targets that receive critical system alerts. Empty = every enabled shared (not personal) target.",
+					default: []
 				})
 			]
 		}] });
 	}
 	async listAlerts(filter) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return [];
-		const whereClause = {};
-		if (filter?.unreadOnly) whereClause.read = false;
-		return (await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: {
-				where: Object.keys(whereClause).length > 0 ? whereClause : void 0,
-				orderBy: {
-					field: "updatedAt",
-					direction: "desc"
-				},
-				limit: filter?.limit ?? 100
-			}
-		})).map(parseAlert);
+		const store = this.alertStore;
+		if (store === null) return [];
+		return (await store.list(filter)).map(parseAlert);
 	}
 	async getUnreadCount() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return 0;
-		return backend.count.query({
-			collection: ALERTS_COLLECTION,
-			filter: { where: { read: false } }
-		});
+		const store = this.alertStore;
+		if (store === null) return 0;
+		return store.countUnread();
 	}
 	async markRead(alertId) {
 		await this.mergeUpdate(alertId, {
@@ -601,11 +804,11 @@ var AlertCenterAddon = class extends BaseAddon {
 		});
 	}
 	async markAllRead() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		const unread = await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: { where: { read: false } }
+		const store = this.alertStore;
+		if (store === null) return;
+		const unread = await store.list({
+			unreadOnly: true,
+			limit: 1e4
 		});
 		const now = Date.now();
 		for (const record of unread) await this.mergeUpdate(record.id, {
@@ -702,14 +905,14 @@ var AlertCenterAddon = class extends BaseAddon {
 		}
 	}
 	async readRunnerRecord(alertId) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return null;
-		const raw = await backend.get.query({
-			collection: ALERTS_COLLECTION,
-			key: alertId
+		const store = this.alertStore;
+		if (store === null) return null;
+		const raw = await store.getData(alertId);
+		if (raw === null) return null;
+		const alert = AlertSchema.safeParse({
+			id: alertId,
+			...raw
 		});
-		if (raw === null || raw === void 0 || typeof raw !== "object") return null;
-		const alert = AlertSchema.safeParse(raw);
 		if (!alert.success || alert.data.status === "dismissed") return null;
 		return parseRunnerRecord(alert.data.metadata?.["runner"]);
 	}
@@ -837,13 +1040,10 @@ var AlertCenterAddon = class extends BaseAddon {
 		});
 	}
 	async readAlertRaw(alertId) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return null;
-		const raw = await backend.get.query({
-			collection: ALERTS_COLLECTION,
-			key: alertId
-		});
-		if (raw === null || raw === void 0 || typeof raw !== "object") return null;
+		const store = this.alertStore;
+		if (store === null) return null;
+		const raw = await store.getData(alertId);
+		if (raw === null) return null;
 		const rec = Object.fromEntries(Object.entries(raw));
 		const meta = rec["metadata"];
 		const push = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta["push"] : void 0;
@@ -861,9 +1061,19 @@ var AlertCenterAddon = class extends BaseAddon {
 	pushPolicy() {
 		return {
 			enabled: this.config.criticalPushEnabled,
-			targetIds: this.config.criticalPushTargetIds.split(",").map((id) => id.trim()).filter((id) => id.length > 0)
+			targetIds: normalizeCriticalPushTargetIds(this.config.criticalPushTargetIds)
 		};
 	}
+	/** Rewrite a legacy CSV `criticalPushTargetIds` string into `string[]`. */
+	async migrateCriticalPushTargetIds() {
+		const raw = this.config.criticalPushTargetIds;
+		if (typeof raw !== "string") return;
+		try {
+			await this.updateGlobalSettings({ criticalPushTargetIds: normalizeCriticalPushTargetIds(raw) });
+		} catch (err) {
+			this.ctx.logger.warn("criticalPushTargetIds CSV migration failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
 	pushPorts() {
 		const api = this.ctx.api;
 		return {
@@ -940,27 +1150,16 @@ var AlertCenterAddon = class extends BaseAddon {
 		return this.pushChain;
 	}
 	async storePushState(alertId, push) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		const raw = await backend.get.query({
-			collection: ALERTS_COLLECTION,
-			key: alertId
-		});
-		if (raw === null || raw === void 0 || typeof raw !== "object") return;
-		const existing = Object.fromEntries(Object.entries(raw));
-		const meta = existing["metadata"];
+		const store = this.alertStore;
+		if (store === null) return;
+		const raw = await store.getData(alertId);
+		if (raw === null) return;
+		const meta = raw["metadata"];
 		const metadata = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : {};
-		await backend.set.mutate({
-			collection: ALERTS_COLLECTION,
-			key: alertId,
-			value: {
-				...existing,
-				metadata: {
-					...metadata,
-					push
-				}
-			}
-		});
+		await store.mergeUpdate(alertId, { metadata: {
+			...metadata,
+			push
+		} });
 	}
 	/**
 	* Retry every critical alert whose push is still pending - at boot and when
@@ -968,19 +1167,10 @@ var AlertCenterAddon = class extends BaseAddon {
 	* delivered is skipped by its key, so reconciling never sends twice.
 	*/
 	async reconcilePendingPushes() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
+		const store = this.alertStore;
+		if (store === null) return;
 		try {
-			const rows = await backend.query.query({
-				collection: ALERTS_COLLECTION,
-				filter: {
-					orderBy: {
-						field: "updatedAt",
-						direction: "desc"
-					},
-					limit: 500
-				}
-			});
+			const rows = await store.listRecent(500);
 			for (const row of rows) {
 				const parsed = AlertSchema.safeParse({
 					id: row.id,
@@ -1007,12 +1197,9 @@ var AlertCenterAddon = class extends BaseAddon {
 		const modelId = data.modelId ?? "unknown";
 		const progress = data.progress ?? 0;
 		const stableId = `model-download:${modelId}`;
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		if ((await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: { where: { id: stableId } }
-		})).length > 0) {
+		const store = this.alertStore;
+		if (store === null) return;
+		if (await store.getData(stableId) !== null) {
 			const now = Date.now();
 			if (progress >= 100) {
 				await this.mergeUpdate(stableId, {
@@ -1353,45 +1540,14 @@ var AlertCenterAddon = class extends BaseAddon {
 	* so we must read the existing record, merge the patch, and write back.
 	*/
 	async mergeUpdate(id, patch) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		const raw = await backend.get.query({
-			collection: ALERTS_COLLECTION,
-			key: id
-		});
-		if (raw === null || raw === void 0 || typeof raw !== "object") return;
-		const existing = Object.fromEntries(Object.entries(raw));
-		await backend.set.mutate({
-			collection: ALERTS_COLLECTION,
-			key: id,
-			value: {
-				...existing,
-				...patch
-			}
-		});
+		const store = this.alertStore;
+		if (store === null) return;
+		await store.mergeUpdate(id, patch);
 	}
 	async persistAlert(alert) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		const data = {
-			id: alert.id,
-			category: alert.category,
-			severity: alert.severity,
-			title: alert.title,
-			message: alert.message,
-			status: alert.status,
-			read: alert.read,
-			createdAt: alert.createdAt,
-			updatedAt: alert.updatedAt,
-			...alert.progress !== void 0 ? { progress: alert.progress } : {},
-			...alert.source ? { source: alert.source } : {},
-			...alert.metadata ? { metadata: alert.metadata } : {}
-		};
-		await backend.set.mutate({
-			collection: ALERTS_COLLECTION,
-			key: alert.id,
-			value: data
-		});
+		const store = this.alertStore;
+		if (store === null) return;
+		await store.persist(alert);
 	}
 	emitAlertCreatedEvent(alert) {
 		this.ctx.eventBus?.emit(createEvent("alert.created", EVENT_SOURCE, {
@@ -1411,36 +1567,18 @@ var AlertCenterAddon = class extends BaseAddon {
 		}));
 	}
 	async enforceMaxAlerts() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		if (await backend.count.query({ collection: ALERTS_COLLECTION }) <= this.config.maxAlerts) return;
-		const all = await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: { orderBy: {
-				field: "createdAt",
-				direction: "asc"
-			} }
-		});
-		for (const id of selectOverflow(all.map(toPrunable), this.config.maxAlerts)) await backend.delete.mutate({
-			collection: ALERTS_COLLECTION,
-			key: id
-		});
+		const store = this.alertStore;
+		if (store === null) return;
+		if (await store.countAll() <= this.config.maxAlerts) return;
+		const all = await store.listAllByCreatedAtAsc();
+		for (const id of selectOverflow(all.map(toPrunable), this.config.maxAlerts)) await store.delete(id);
 	}
 	async enforceRetention() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
+		const store = this.alertStore;
+		if (store === null) return;
 		const cutoff = Date.now() - this.config.retentionDays * 24 * 60 * 60 * 1e3;
-		const all = await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: { orderBy: {
-				field: "createdAt",
-				direction: "asc"
-			} }
-		});
-		for (const id of selectExpired(all.map(toPrunable), cutoff)) await backend.delete.mutate({
-			collection: ALERTS_COLLECTION,
-			key: id
-		});
+		const all = await store.listAllByCreatedAtAsc();
+		for (const id of selectExpired(all.map(toPrunable), cutoff)) await store.delete(id);
 	}
 };
 //#endregion

package/dist/builtins/alerts/record-kinds.d.ts

@@ -0,0 +1,15 @@
+/**
+* Record kinds owned by alert-center (records plan phase 4).
+*/
+import { type Alert, type DefinedRecordKind } from "@camstack/types";
+import { z } from "zod";
+/** Legacy collection / adoptsFrom target (canonical KV before phase 4). */
+export declare const ALERTS_COLLECTION = "alerts";
+export type AlertBody = Omit<Alert, "id">;
+export declare const AlertBodySchema: z.ZodType<AlertBody>;
+export type AlertCenterRecordKindsMap = {
+	readonly alerts: DefinedRecordKind<z.ZodType<AlertBody>>;
+};
+export declare const alertCenterRecordKinds: AlertCenterRecordKindsMap;
+/** Narrow kind for `records.kind()` — `IsolatedRecordKinds` string index is `| undefined`. */
+export declare const alertsRecordKind: DefinedRecordKind<z.ZodType<AlertBody>>;

package/dist/builtins/autotrack/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-D1vECb_6.js");
+const require_dist = require("../../dist-DgOG8flk.js");
 //#region src/builtins/autotrack/autotrack-config.ts
 var DEFAULT_AUTOTRACK_LOOP_CONFIG = {
 	deadZoneFraction: .5,

package/dist/builtins/autotrack/index.mjs

@@ -1,4 +1,4 @@
-import { $i as EventCategory, Fn as ptzAutotrackCapability, Fr as BaseAddon, N as FIRST_LEVEL_MACRO_CLASSES, Oi as isEvent, Pr as errMsg, dt as bareAddonId } from "../../dist-DERK-gP5.mjs";
+import { Lr as errMsg, P as FIRST_LEVEL_MACRO_CLASSES, Pi as isEvent, Rr as BaseAddon, ht as bareAddonId, la as EventCategory, zn as ptzAutotrackCapability } from "../../dist-BNunRyXT.mjs";
 //#region src/builtins/autotrack/autotrack-config.ts
 var DEFAULT_AUTOTRACK_LOOP_CONFIG = {
 	deadZoneFraction: .5,

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.d.ts

@@ -2,6 +2,7 @@ import type { ProviderRegistration } from "@camstack/types";
 import { BaseAddon } from "@camstack/types";
 export declare class BackupOrchestratorAddon extends BaseAddon<Record<string, never>> {
 	private systemBackup;
+	private backupRecords;
 	private policies;
 	private schedules;
 	/** Backup encryption keys — PUBLIC keys only (see encryption-key-store.ts). */