@camstack/system 1.2.444 → 1.2.446

package/dist/{restore-archive-daKyE24F.mjs → restore-archive-CMr4V7Fi.mjs}

@@ -1,4 +1,6 @@
-import { x as DATABASE_SNAPSHOT_SUFFIX } from "./dist-DERK-gP5.mjs";
+import { A as DataStoreDatabaseSchema, Di as defineRecordKinds, b as DATABASE_SNAPSHOT_SUFFIX } from "./dist-CkZIrsAP.mjs";
+import { t as require_read_all_rows } from "./read-all-rows-TaPqdWNF.mjs";
+import { z } from "zod";
 import { createCipheriv, createDecipheriv, createHash, createPrivateKey, createPublicKey, diffieHellman, generateKeyPairSync, hkdfSync, randomBytes } from "node:crypto";
 import { Buffer as Buffer$1 } from "buffer";
 import * as fsp from "node:fs/promises";
@@ -383,6 +385,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();
+/**
+* @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 = z.object({
+	label: z.string(),
+	cron: z.string(),
+	enabled: z.boolean(),
+	locationIds: z.array(z.string()).readonly(),
+	retentionCount: z.number(),
+	dataSources: z.array(z.string()).readonly().optional(),
+	databases: z.array(DataStoreDatabaseSchema).readonly().optional(),
+	lastAttemptAt: z.number().optional(),
+	lastSuccessAt: z.number().optional(),
+	lastError: z.string().optional()
+});
+var BackupDestinationPolicyBodySchema = z.object({
+	enabled: z.boolean(),
+	retentionCount: z.number(),
+	label: z.string().optional(),
+	lastAttemptAt: z.number().optional(),
+	lastError: z.string().optional()
+});
+var BackupEncryptionKeyBodySchema = z.object({
+	keyId: z.string(),
+	publicKey: z.string(),
+	createdAt: z.number(),
+	retiredAt: z.number().nullable()
+});
+var BackupSeedMarkerBodySchema = z.object({ seededAt: z.number() });
+var _backupOrchestratorRecordKinds = 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) => {
@@ -394,7 +724,7 @@ var Br = (s, t) => {
 var xs = typeof process == "object" && process ? process : {
 	stdout: null,
 	stderr: null
-}, zr = (s) => !!s && typeof s == "object" && (s instanceof A || s instanceof As || Ur(s) || Hr(s)), Ur = (s) => !!s && typeof s == "object" && s instanceof EventEmitter && typeof s.pipe == "function" && s.pipe !== As.Writable.prototype.pipe, Hr = (s) => !!s && typeof s == "object" && s instanceof EventEmitter && typeof s.write == "function" && typeof s.end == "function", q = Symbol("EOF"), Q = Symbol("maybeEmitEnd"), rt = Symbol("emittedEnd"), Le = Symbol("emittingEnd"), qt = Symbol("emittedError"), Ne = Symbol("closed"), Ls = Symbol("read"), De = Symbol("flush"), Ns = Symbol("flushChunk"), z = Symbol("encoding"), Mt = Symbol("decoder"), g = Symbol("flowing"), Qt = Symbol("paused"), Bt = Symbol("resume"), b = Symbol("buffer"), D = Symbol("pipes"), _ = Symbol("bufferLength"), gi = Symbol("bufferPush"), Ae = Symbol("bufferShift"), L = Symbol("objectMode"), w = Symbol("destroyed"), bi = Symbol("error"), _i = Symbol("emitData"), Ds = Symbol("emitEnd"), Oi = Symbol("emitEnd2"), Z = Symbol("async"), Ti = Symbol("abort"), Ie = Symbol("aborted"), Jt = Symbol("signal"), Rt = Symbol("dataListeners"), F = Symbol("discarded"), jt = (s) => Promise.resolve().then(s), Wr = (s) => s(), Gr = (s) => s === "end" || s === "finish" || s === "prefinish", Zr = (s) => s instanceof ArrayBuffer || !!s && typeof s == "object" && s.constructor && s.constructor.name === "ArrayBuffer" && s.byteLength >= 0, Yr = (s) => !Buffer.isBuffer(s) && ArrayBuffer.isView(s), Fe = class {
+}, zr = (s) => !!s && typeof s == "object" && (s instanceof A || s instanceof As || Ur(s) || Hr(s)), Ur = (s) => !!s && typeof s == "object" && s instanceof EventEmitter && typeof s.pipe == "function" && s.pipe !== As.Writable.prototype.pipe, Hr = (s) => !!s && typeof s == "object" && s instanceof EventEmitter && typeof s.write == "function" && typeof s.end == "function", q = Symbol("EOF"), Q = Symbol("maybeEmitEnd"), rt = Symbol("emittedEnd"), Le = Symbol("emittingEnd"), qt = Symbol("emittedError"), Ne = Symbol("closed"), Ls = Symbol("read"), De = Symbol("flush"), Ns = Symbol("flushChunk"), z$1 = Symbol("encoding"), Mt = Symbol("decoder"), g = Symbol("flowing"), Qt = Symbol("paused"), Bt = Symbol("resume"), b = Symbol("buffer"), D = Symbol("pipes"), _ = Symbol("bufferLength"), gi = Symbol("bufferPush"), Ae = Symbol("bufferShift"), L = Symbol("objectMode"), w = Symbol("destroyed"), bi = Symbol("error"), _i = Symbol("emitData"), Ds = Symbol("emitEnd"), Oi = Symbol("emitEnd2"), Z = Symbol("async"), Ti = Symbol("abort"), Ie = Symbol("aborted"), Jt = Symbol("signal"), Rt = Symbol("dataListeners"), F = Symbol("discarded"), jt = (s) => Promise.resolve().then(s), Wr = (s) => s(), Gr = (s) => s === "end" || s === "finish" || s === "prefinish", Zr = (s) => s instanceof ArrayBuffer || !!s && typeof s == "object" && s.constructor && s.constructor.name === "ArrayBuffer" && s.byteLength >= 0, Yr = (s) => !Buffer.isBuffer(s) && ArrayBuffer.isView(s), Fe = class {
 	src;
 	dest;
 	opts;
@@ -422,7 +752,7 @@ var xs = typeof process == "object" && process ? process : {
 	[D] = [];
 	[b] = [];
 	[L];
-	[z];
+	[z$1];
 	[Z];
 	[Mt];
 	[q] = !1;
@@ -441,7 +771,7 @@ var xs = typeof process == "object" && process ? process : {
 	constructor(...t) {
 		let e = t[0] || {};
 		if (super(), e.objectMode && typeof e.encoding == "string") throw new TypeError("Encoding and objectMode may not be used together");
-		Kr(e) ? (this[L] = !0, this[z] = null) : Vr(e) ? (this[z] = e.encoding, this[L] = !1) : (this[L] = !1, this[z] = null), this[Z] = !!e.async, this[Mt] = this[z] ? new StringDecoder(this[z]) : null, e && e.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[b] }), e && e.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[D] });
+		Kr(e) ? (this[L] = !0, this[z$1] = null) : Vr(e) ? (this[z$1] = e.encoding, this[L] = !1) : (this[L] = !1, this[z$1] = null), this[Z] = !!e.async, this[Mt] = this[z$1] ? new StringDecoder(this[z$1]) : null, e && e.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[b] }), e && e.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[D] });
 		let { signal: i } = e;
 		i && (this[Jt] = i, i.aborted ? this[Ti]() : i.addEventListener("abort", () => this[Ti]()));
 	}
@@ -449,7 +779,7 @@ var xs = typeof process == "object" && process ? process : {
 		return this[_];
 	}
 	get encoding() {
-		return this[z];
+		return this[z$1];
 	}
 	set encoding(t) {
 		throw new Error("Encoding must be set at instantiation time");
@@ -487,12 +817,12 @@ var xs = typeof process == "object" && process ? process : {
 			else if (Zr(t)) t = Buffer.from(t);
 			else if (typeof t != "string") throw new Error("Non-contiguous data written to non-objectMode stream");
 		}
-		return this[L] ? (this[g] && this[_] !== 0 && this[De](!0), this[g] ? this.emit("data", t) : this[gi](t), this[_] !== 0 && this.emit("readable"), i && r(i), this[g]) : t.length ? (typeof t == "string" && !(e === this[z] && !this[Mt]?.lastNeed) && (t = Buffer.from(t, e)), Buffer.isBuffer(t) && this[z] && (t = this[Mt].write(t)), this[g] && this[_] !== 0 && this[De](!0), this[g] ? this.emit("data", t) : this[gi](t), this[_] !== 0 && this.emit("readable"), i && r(i), this[g]) : (this[_] !== 0 && this.emit("readable"), i && r(i), this[g]);
+		return this[L] ? (this[g] && this[_] !== 0 && this[De](!0), this[g] ? this.emit("data", t) : this[gi](t), this[_] !== 0 && this.emit("readable"), i && r(i), this[g]) : t.length ? (typeof t == "string" && !(e === this[z$1] && !this[Mt]?.lastNeed) && (t = Buffer.from(t, e)), Buffer.isBuffer(t) && this[z$1] && (t = this[Mt].write(t)), this[g] && this[_] !== 0 && this[De](!0), this[g] ? this.emit("data", t) : this[gi](t), this[_] !== 0 && this.emit("readable"), i && r(i), this[g]) : (this[_] !== 0 && this.emit("readable"), i && r(i), this[g]);
 	}
 	read(t) {
 		if (this[w]) return null;
 		if (this[F] = !1, this[_] === 0 || t === 0 || t && t > this[_]) return this[Q](), null;
-		this[L] && (t = null), this[b].length > 1 && !this[L] && (this[b] = [this[z] ? this[b].join("") : Buffer.concat(this[b], this[_])]);
+		this[L] && (t = null), this[b].length > 1 && !this[L] && (this[b] = [this[z$1] ? this[b].join("") : Buffer.concat(this[b], this[_])]);
 		let e = this[Ls](t || null, this[b][0]);
 		return this[Q](), e;
 	}
@@ -634,7 +964,7 @@ while (this[Ns](this[Ae]()) && this[b].length);
 	async concat() {
 		if (this[L]) throw new Error("cannot concat in objectMode");
 		let t = await this.collect();
-		return this[z] ? t.join("") : Buffer.concat(t, t.dataLength);
+		return this[z$1] ? t.join("") : Buffer.concat(t, t.dataLength);
 	}
 	async promise() {
 		return new Promise((t, e) => {
@@ -4127,4 +4457,4 @@ async function prepareRestoreArchive(input) {
 	}
 }
 //#endregion
-export { BackupSnapshotRefusedError as a, BackupDecryptError as c, ENCRYPTED_BACKUP_SUFFIX as d, generateBackupKeyPair as f, readBackupEncryptionHeader as h, BackupCancelledError as i, BackupKeyFormatError as l, parseBackupSecretKey as m, precheckRestoreKey as n, DEFAULT_BACKUP_DATABASES as o, parseBackupPublicKey as p, prepareRestoreArchive as r, SystemBackupService as s, BackupKeyRequiredError as t, BackupKeyMismatchError as u };
+export { parseBackupSecretKey as _, BackupSnapshotRefusedError as a, backupOrchestratorRecordKinds as c, BackupEncryptionKeyStore as d, BackupDecryptError as f, generateBackupKeyPair as g, ENCRYPTED_BACKUP_SUFFIX as h, BackupCancelledError as i, backupRecordStoresOf as l, BackupKeyMismatchError as m, precheckRestoreKey as n, DEFAULT_BACKUP_DATABASES as o, BackupKeyFormatError as p, prepareRestoreArchive as r, SystemBackupService as s, BackupKeyRequiredError as t, BackupSeedMarkerStore as u, readBackupEncryptionHeader as v };

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.444",
+  "version": "1.2.446",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",