@camstack/system 1.2.443 → 1.2.445

package/dist/{restore-archive-BMNXwWWD.js → restore-archive-DjJnCgap.js}

@@ -1,5 +1,7 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-D9qT3jHr.js");
+const require_dist = require("./dist-DgOG8flk.js");
+const require_read_all_rows$1 = require("./read-all-rows-CVoO1ONM.js");
+let zod = require("zod");
 let node_crypto = require("node:crypto");
 let buffer = require("buffer");
 let node_fs_promises = require("node:fs/promises");
@@ -394,6 +396,334 @@ async function decryptBackupFile(input, output, secretKey) {
 	}
 }
 //#endregion
+//#region src/builtins/backup-orchestrator/encryption-key-store.ts
+var import_read_all_rows = require_read_all_rows$1.require_read_all_rows();
+/**
+* @durable class=config owner=backup-orchestrator
+*   write="`setupEncryption` inserts one row per generated key and retires the
+*     previous active row; `disableEncryption` retires the active row"
+*   retention="none — one small row per key ever generated; a retired row
+*     names the key older archives need"
+*/
+var BACKUP_ENCRYPTION_KEYS_COLLECTION = "backup_encryption_keys";
+var COLUMNS$1 = [
+	{
+		name: "key_id",
+		type: "TEXT",
+		primaryKey: true
+	},
+	{
+		name: "public_key",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "created_at",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "retired_at",
+		type: "INTEGER"
+	}
+];
+var BackupEncryptionKeyStore = class {
+	store;
+	now;
+	declared = false;
+	keysKind;
+	constructor(store, now = Date.now, keysKind = null) {
+		this.store = store;
+		this.now = now;
+		this.keysKind = keysKind;
+	}
+	async ensureDeclared() {
+		if (this.keysKind !== null) return;
+		if (this.declared) return;
+		await this.store.declareCollection({
+			collection: BACKUP_ENCRYPTION_KEYS_COLLECTION,
+			columns: COLUMNS$1
+		});
+		this.declared = true;
+	}
+	/** Every key, newest first. */
+	async list() {
+		await this.ensureDeclared();
+		const kind = this.keysKind;
+		if (kind !== null) {
+			const rows = await (0, import_read_all_rows.readAllRows)(kind);
+			rows.sort((a, b) => b.data.createdAt - a.data.createdAt);
+			const out = [];
+			for (const row of rows) {
+				const record = bodyToRecord(row.id, row.data);
+				if (record !== null) out.push(record);
+			}
+			return out;
+		}
+		const rows = await this.store.query({
+			collection: BACKUP_ENCRYPTION_KEYS_COLLECTION,
+			filter: { orderBy: {
+				field: "created_at",
+				direction: "desc"
+			} }
+		});
+		const out = [];
+		for (const row of rows) {
+			const record = toRecord(row.data);
+			if (record !== null) out.push(record);
+		}
+		return out;
+	}
+	/** The key new archives are encrypted to; `null` = encryption off. */
+	async active() {
+		return (await this.list()).find((k) => k.retiredAt === null) ?? null;
+	}
+	/** Make `publicKey` the active key; the previous one is retired, kept listed. */
+	async activate(input) {
+		const parsed = parseBackupPublicKey(input.publicKey);
+		const t = this.now();
+		await this.retireActive(t);
+		const record = {
+			keyId: parsed.keyId,
+			publicKey: input.publicKey.trim(),
+			createdAt: t,
+			retiredAt: null
+		};
+		await this.write(record);
+		return record;
+	}
+	/** Encryption off: the active key is retired. Archives already made keep needing it. */
+	async disable() {
+		await this.retireActive(this.now());
+	}
+	async retireActive(at) {
+		for (const key of await this.list()) if (key.retiredAt === null) await this.write({
+			...key,
+			retiredAt: at
+		});
+	}
+	async write(record) {
+		await this.ensureDeclared();
+		const kind = this.keysKind;
+		if (kind !== null) {
+			const body = {
+				keyId: record.keyId,
+				publicKey: record.publicKey,
+				createdAt: record.createdAt,
+				retiredAt: record.retiredAt
+			};
+			const data = backupOrchestratorRecordKinds["encryption-keys"].schema.parse(body);
+			await kind.put({
+				id: record.keyId,
+				data
+			});
+			return;
+		}
+		await this.store.deleteWhere({
+			collection: BACKUP_ENCRYPTION_KEYS_COLLECTION,
+			filter: { where: { key_id: record.keyId } }
+		});
+		await this.store.insert({
+			collection: BACKUP_ENCRYPTION_KEYS_COLLECTION,
+			record: {
+				id: record.keyId,
+				data: {
+					key_id: record.keyId,
+					public_key: record.publicKey,
+					created_at: record.createdAt,
+					retired_at: record.retiredAt
+				}
+			}
+		});
+	}
+};
+function bodyToRecord(keyId, body) {
+	if (!keyId) return null;
+	return {
+		keyId: body.keyId,
+		publicKey: body.publicKey,
+		createdAt: body.createdAt,
+		retiredAt: body.retiredAt
+	};
+}
+function toRecord(row) {
+	const keyId = row["key_id"];
+	const publicKey = row["public_key"];
+	const createdAt = row["created_at"];
+	if (typeof keyId !== "string" || typeof publicKey !== "string") return null;
+	const retired = row["retired_at"];
+	return {
+		keyId,
+		publicKey,
+		createdAt: typeof createdAt === "number" ? createdAt : Number(createdAt ?? 0),
+		retiredAt: typeof retired === "number" ? retired : null
+	};
+}
+//#endregion
+//#region src/builtins/backup-orchestrator/seed-marker-store.ts
+/**
+* @durable class=config owner=backup-orchestrator
+*   write="the orchestrator inserts one row per seed id the first time that
+*     seed is created (or found already created); never updated"
+*   retention="none — one tiny row per seed ever made; deleting it lets the
+*     seed be re-created once more on the next boot"
+*/
+var BACKUP_SEED_MARKERS_COLLECTION = "backup_seed_markers";
+var COLUMNS = [{
+	name: "seed_id",
+	type: "TEXT",
+	primaryKey: true
+}, {
+	name: "seeded_at",
+	type: "INTEGER",
+	notNull: true
+}];
+var BackupSeedMarkerStore = class {
+	store;
+	now;
+	declared = false;
+	markersKind;
+	constructor(store, now = Date.now, markersKind = null) {
+		this.store = store;
+		this.now = now;
+		this.markersKind = markersKind;
+	}
+	async ensureDeclared() {
+		if (this.markersKind !== null) return;
+		if (this.declared) return;
+		await this.store.declareCollection({
+			collection: BACKUP_SEED_MARKERS_COLLECTION,
+			columns: COLUMNS
+		});
+		this.declared = true;
+	}
+	async has(seedId) {
+		await this.ensureDeclared();
+		const kind = this.markersKind;
+		if (kind !== null) return await kind.get(seedId) !== null;
+		return (await this.store.query({
+			collection: BACKUP_SEED_MARKERS_COLLECTION,
+			filter: {
+				where: { seed_id: seedId },
+				limit: 1
+			}
+		})).length > 0;
+	}
+	async mark(seedId) {
+		await this.ensureDeclared();
+		if (await this.has(seedId)) return;
+		const kind = this.markersKind;
+		if (kind !== null) {
+			const body = { seededAt: this.now() };
+			const data = backupOrchestratorRecordKinds["seed-markers"].schema.parse(body);
+			await kind.put({
+				id: seedId,
+				data
+			});
+			return;
+		}
+		await this.store.insert({
+			collection: BACKUP_SEED_MARKERS_COLLECTION,
+			record: {
+				id: seedId,
+				data: {
+					seed_id: seedId,
+					seeded_at: this.now()
+				}
+			}
+		});
+	}
+};
+//#endregion
+//#region src/builtins/backup-orchestrator/record-kinds.ts
+var BACKUP_SCHEDULES_LEGACY = "backup_schedules";
+var BACKUP_DESTINATION_POLICIES_LEGACY = "backup_destination_policies";
+var BackupScheduleBodySchema = zod.z.object({
+	label: zod.z.string(),
+	cron: zod.z.string(),
+	enabled: zod.z.boolean(),
+	locationIds: zod.z.array(zod.z.string()).readonly(),
+	retentionCount: zod.z.number(),
+	dataSources: zod.z.array(zod.z.string()).readonly().optional(),
+	databases: zod.z.array(require_dist.DataStoreDatabaseSchema).readonly().optional(),
+	lastAttemptAt: zod.z.number().optional(),
+	lastSuccessAt: zod.z.number().optional(),
+	lastError: zod.z.string().optional()
+});
+var BackupDestinationPolicyBodySchema = zod.z.object({
+	enabled: zod.z.boolean(),
+	retentionCount: zod.z.number(),
+	label: zod.z.string().optional(),
+	lastAttemptAt: zod.z.number().optional(),
+	lastError: zod.z.string().optional()
+});
+var BackupEncryptionKeyBodySchema = zod.z.object({
+	keyId: zod.z.string(),
+	publicKey: zod.z.string(),
+	createdAt: zod.z.number(),
+	retiredAt: zod.z.number().nullable()
+});
+var BackupSeedMarkerBodySchema = zod.z.object({ seededAt: zod.z.number() });
+var _backupOrchestratorRecordKinds = require_dist.defineRecordKinds({
+	schedules: {
+		schema: BackupScheduleBodySchema,
+		class: "config",
+		writeTrigger: "operator upsert/delete; orchestrator stamps lastAttempt/success/error",
+		device: "none",
+		at: "none",
+		indexes: [{
+			name: "enabled",
+			fields: ["enabled"]
+		}],
+		retention: { none: "operator delete only" },
+		adoptsFrom: BACKUP_SCHEDULES_LEGACY,
+		entry: {
+			title: "Backup schedules",
+			nameField: "label"
+		}
+	},
+	"destination-policies": {
+		schema: BackupDestinationPolicyBodySchema,
+		class: "config",
+		writeTrigger: "ensureDefault, operator upsert, recordAttempt after each archive write",
+		device: "none",
+		at: "none",
+		retention: { none: "row outlives location; ensureDefault recreates" },
+		adoptsFrom: BACKUP_DESTINATION_POLICIES_LEGACY
+	},
+	"encryption-keys": {
+		schema: BackupEncryptionKeyBodySchema,
+		class: "config",
+		writeTrigger: "setupEncryption activate; disableEncryption retires active row",
+		device: "none",
+		at: "none",
+		retention: { none: "retired keys kept for archive decryption hints" },
+		adoptsFrom: BACKUP_ENCRYPTION_KEYS_COLLECTION
+	},
+	"seed-markers": {
+		schema: BackupSeedMarkerBodySchema,
+		class: "config",
+		writeTrigger: "mark() once per seed id after seed landed",
+		device: "none",
+		at: "none",
+		retention: { none: "one row per seed id ever" },
+		adoptsFrom: BACKUP_SEED_MARKERS_COLLECTION
+	}
+});
+var backupOrchestratorRecordKinds = _backupOrchestratorRecordKinds;
+var backupSchedulesRecordKind = _backupOrchestratorRecordKinds.schedules;
+var backupDestinationPoliciesRecordKind = _backupOrchestratorRecordKinds["destination-policies"];
+var backupEncryptionKeysRecordKind = _backupOrchestratorRecordKinds["encryption-keys"];
+var backupSeedMarkersRecordKind = _backupOrchestratorRecordKinds["seed-markers"];
+function backupRecordStoresOf(records) {
+	return {
+		schedules: records.kind(backupSchedulesRecordKind),
+		destinationPolicies: records.kind(backupDestinationPoliciesRecordKind),
+		encryptionKeys: records.kind(backupEncryptionKeysRecordKind),
+		seedMarkers: records.kind(backupSeedMarkersRecordKind)
+	};
+}
+//#endregion
 //#region node_modules/tar/dist/esm/index.min.js
 var Mr = Object.defineProperty;
 var Br = (s, t) => {
@@ -4150,6 +4480,12 @@ Object.defineProperty(exports, "BackupDecryptError", {
 		return BackupDecryptError;
 	}
 });
+Object.defineProperty(exports, "BackupEncryptionKeyStore", {
+	enumerable: true,
+	get: function() {
+		return BackupEncryptionKeyStore;
+	}
+});
 Object.defineProperty(exports, "BackupKeyFormatError", {
 	enumerable: true,
 	get: function() {
@@ -4168,6 +4504,12 @@ Object.defineProperty(exports, "BackupKeyRequiredError", {
 		return BackupKeyRequiredError;
 	}
 });
+Object.defineProperty(exports, "BackupSeedMarkerStore", {
+	enumerable: true,
+	get: function() {
+		return BackupSeedMarkerStore;
+	}
+});
 Object.defineProperty(exports, "BackupSnapshotRefusedError", {
 	enumerable: true,
 	get: function() {
@@ -4192,16 +4534,22 @@ Object.defineProperty(exports, "SystemBackupService", {
 		return SystemBackupService;
 	}
 });
-Object.defineProperty(exports, "generateBackupKeyPair", {
+Object.defineProperty(exports, "backupOrchestratorRecordKinds", {
 	enumerable: true,
 	get: function() {
-		return generateBackupKeyPair;
+		return backupOrchestratorRecordKinds;
 	}
 });
-Object.defineProperty(exports, "parseBackupPublicKey", {
+Object.defineProperty(exports, "backupRecordStoresOf", {
 	enumerable: true,
 	get: function() {
-		return parseBackupPublicKey;
+		return backupRecordStoresOf;
+	}
+});
+Object.defineProperty(exports, "generateBackupKeyPair", {
+	enumerable: true,
+	get: function() {
+		return generateBackupKeyPair;
 	}
 });
 Object.defineProperty(exports, "parseBackupSecretKey", {

package/dist/tls/agent-https-names.d.ts

@@ -2,26 +2,22 @@
 * Which names the hub has certified to which agent (D856): the memory behind "a name
 * already certified to another node is never signed again". Hub only.
 */
-import type { CollectionColumn, SettingsStoreClient } from "@camstack/types";
-/**
-* @durable class=config owner=system-config
-*   write="the hub records the names it signed into an agent's HTTPS leaf, replacing that
-*     node's previous row"
-*   retention="one row per node, replaced on every issue; a forgotten node's row stays until
-*     the node is issued again or an operator clears it (it only blocks reuse of its names)"
-*/
+import type { CollectionColumn, RecordKindHandle, SettingsStoreClient } from "@camstack/types";
+import type { AgentHttpsNameBody } from "../builtins/system-config/record-kinds.js";
 export declare const AGENT_HTTPS_NAMES_COLLECTION = "agent_https_names";
 export declare const AGENT_HTTPS_NAMES_COLUMNS: readonly CollectionColumn[];
+export interface AgentHttpsNamesDeps {
+	readonly agentHttpsNamesKind: RecordKindHandle<AgentHttpsNameBody>;
+	readonly legacyStore?: SettingsStoreClient;
+}
 export declare class AgentHttpsNames {
-	private readonly store;
 	private readonly byNode;
-	constructor(store: SettingsStoreClient);
+	private readonly kind;
+	private readonly store;
+	constructor(deps: SettingsStoreClient | AgentHttpsNamesDeps);
 	load(): Promise<void>;
-	/** The names certified to `nodeId` (its id and the address of its live mesh socket), or `null`. */
 	namesOf(nodeId: string): readonly string[] | null;
-	/** Every name certified to a node other than `nodeId`. */
 	takenByOthers(nodeId: string): ReadonlySet<string>;
-	/** Free every name certified to a node that was forgotten. */
 	release(nodeId: string): Promise<boolean>;
 	record(nodeId: string, names: readonly string[]): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.443",
+  "version": "1.2.445",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",
@@ -75,6 +75,9 @@
           },
           {
             "name": "storage-admin"
+          },
+          {
+            "name": "records"
           }
         ]
       },
@@ -199,6 +202,24 @@
           }
         ]
       },
+      {
+        "id": "record-entries",
+        "category": "system",
+        "name": "Record Entries",
+        "icon": "assets/record-entries/icon.svg",
+        "color": "#0d9488",
+        "description": "The ONE admin surface for every list of user-created entries (notification targets, brokers, LLM profiles): any addon declares an entry kind with `defineEntryKind` and the entries UI lists, adds, edits and deletes it, with password fields derived from the schema (`.meta({ secret: true })`). Holds no data of its own: it acts for each entry's owner on the records door and the keychain, in-process on the hub.",
+        "entry": "./dist/builtins/record-entries/index.js",
+        "protected": true,
+        "execution": {
+          "placement": "hub-only"
+        },
+        "capabilities": [
+          {
+            "name": "record-entries"
+          }
+        ]
+      },
       {
         "id": "metrics-native",
         "category": "system",