@agimon-ai/po-vault 0.0.0-alpha.61

package/dist/extensions/server.cjs

@@ -0,0 +1,655 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_vaultRules = require("../vaultRules-CUudYo7G.cjs");
+const require_contracts = require("../contracts-Do7L_d_L.cjs");
+let _agimon_ai_po_core_extensionFile = require("@agimon-ai/po-core/extensionFile");
+let _agimon_ai_po_core_serverPlugin = require("@agimon-ai/po-core/serverPlugin");
+let _agimon_ai_po_db = require("@agimon-ai/po-db");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
+let node_buffer = require("node:buffer");
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+//#region src/services/vaultCrypto/index.ts
+/** AES-256-GCM with a fresh 12-byte IV, bound to `aad`. Ported from the MCP proxy's FileTokenStore. */
+function seal(key, plaintext, aad) {
+	const iv = (0, node_crypto.randomBytes)(12);
+	const cipher = (0, node_crypto.createCipheriv)("aes-256-gcm", key, iv);
+	cipher.setAAD(node_buffer.Buffer.from(aad, "utf8"));
+	const ciphertext = node_buffer.Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+	return {
+		iv,
+		tag: cipher.getAuthTag(),
+		ciphertext
+	};
+}
+/** The plaintext, or `undefined` when the key, the AAD or any byte of the box is wrong. */
+function open$1(key, box, aad) {
+	if (key.length !== 32 || box.iv.length !== 12 || box.tag.length !== 16) return void 0;
+	try {
+		const decipher = (0, node_crypto.createDecipheriv)("aes-256-gcm", key, box.iv);
+		decipher.setAAD(node_buffer.Buffer.from(aad, "utf8"));
+		decipher.setAuthTag(box.tag);
+		return node_buffer.Buffer.concat([decipher.update(box.ciphertext), decipher.final()]).toString("utf8");
+	} catch {
+		return;
+	}
+}
+/** `iv | tag | ciphertext`, the layout of the stored key check. */
+function packBox(box) {
+	return node_buffer.Buffer.concat([
+		box.iv,
+		box.tag,
+		box.ciphertext
+	]);
+}
+function unpackBox(packed) {
+	const bytes = node_buffer.Buffer.from(packed.buffer, packed.byteOffset, packed.byteLength);
+	if (bytes.length <= 28) return void 0;
+	return {
+		iv: bytes.subarray(0, 12),
+		tag: bytes.subarray(12, 28),
+		ciphertext: bytes.subarray(28)
+	};
+}
+function randomKey() {
+	return (0, node_crypto.randomBytes)(32);
+}
+//#endregion
+//#region src/services/vault/index.ts
+/** The vault's schema in po-db. Every object carries the `vault_` prefix po-db enforces. */
+const VAULT_MIGRATIONS = [{
+	version: 1,
+	statements: [
+		"CREATE TABLE vault_meta (name TEXT PRIMARY KEY, value BLOB NOT NULL) STRICT, WITHOUT ROWID",
+		`CREATE TABLE vault_entries (
+        namespace TEXT NOT NULL, key TEXT NOT NULL,
+        revision INTEGER NOT NULL CHECK (revision >= 1), updated_at INTEGER NOT NULL,
+        iv BLOB NOT NULL CHECK (length(iv) = 12), tag BLOB NOT NULL CHECK (length(tag) = 16),
+        ciphertext BLOB NOT NULL, PRIMARY KEY (namespace, key)
+      ) STRICT, WITHOUT ROWID`,
+		"CREATE TABLE vault_lease (name TEXT PRIMARY KEY, owner TEXT NOT NULL, expires_at INTEGER NOT NULL) STRICT, WITHOUT ROWID"
+	]
+}];
+const SELECT_ENTRY = "SELECT revision, updated_at, iv, tag, ciphertext FROM vault_entries WHERE namespace = ? AND key = ?";
+const PUT_LAST_WRITE_WINS = `INSERT INTO vault_entries (namespace, key, revision, updated_at, iv, tag, ciphertext)
+  VALUES (?, ?, 1, ?, ?, ?, ?)
+  ON CONFLICT (namespace, key) DO UPDATE SET revision = vault_entries.revision + 1, updated_at = excluded.updated_at,
+    iv = excluded.iv, tag = excluded.tag, ciphertext = excluded.ciphertext
+  RETURNING revision, updated_at`;
+const PUT_CREATE_ONLY = `INSERT INTO vault_entries (namespace, key, revision, updated_at, iv, tag, ciphertext)
+  VALUES (?, ?, 1, ?, ?, ?, ?)
+  ON CONFLICT (namespace, key) DO NOTHING
+  RETURNING revision, updated_at`;
+const PUT_EXPECT_REVISION = `UPDATE vault_entries SET revision = ?, updated_at = ?, iv = ?, tag = ?, ciphertext = ?
+  WHERE namespace = ? AND key = ? AND revision = ?
+  RETURNING revision, updated_at`;
+const ACQUIRE_LEASE = `INSERT INTO vault_lease (name, owner, expires_at) VALUES (?, ?, ?)
+  ON CONFLICT (name) DO UPDATE SET owner = excluded.owner, expires_at = excluded.expires_at
+  WHERE vault_lease.expires_at < ? OR vault_lease.owner = excluded.owner
+  RETURNING owner`;
+const RELEASE_LEASE = "DELETE FROM vault_lease WHERE name = ? AND owner = ?";
+const SELECT_META = "SELECT value FROM vault_meta WHERE name = ?";
+const INSERT_META = "INSERT INTO vault_meta (name, value) VALUES (?, ?) ON CONFLICT (name) DO NOTHING";
+const REPLACE_META = "INSERT INTO vault_meta (name, value) VALUES (?, ?) ON CONFLICT (name) DO UPDATE SET value = excluded.value";
+function entryAad(namespace, key) {
+	return `${namespace}\0${key}`;
+}
+function bytesEqual(left, right) {
+	return node_buffer.Buffer.compare(left, right) === 0;
+}
+function boxOf(row) {
+	return {
+		iv: row.iv,
+		tag: row.tag,
+		ciphertext: row.ciphertext
+	};
+}
+function provesKey(key, check) {
+	const box = unpackBox(check);
+	return box !== void 0 && open$1(key, box, "po-vault:check") === "po-vault-v1";
+}
+function isBusy(error) {
+	if (error === null || typeof error !== "object") return false;
+	const code = "errcode" in error ? error.errcode : void 0;
+	if (code === 5 || code === 6) return true;
+	return error instanceof Error && /database (?:table )?is locked|SQLITE_BUSY/u.test(error.message);
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* The vault on po-db: AES-256-GCM rows in `vault_entries` under one data-encryption key kept in
+* the OS keyring or, without one, in an owner-only `key.bin`.
+*
+* Every read and write is a single statement, so nothing here holds the shared connection's
+* write lock across a network call. Cross-process work that must span one goes through
+* `withLock`, a lease row with a TTL.
+*/
+function createVault(options) {
+	const { db, directory, keyFiles, onNotice } = options;
+	const database = db.database;
+	const now = options.now ?? Date.now;
+	const leaseTtlMs = options.leaseTtlMs ?? 3e4;
+	const leaseRenewMs = options.leaseRenewMs ?? 1e4;
+	const leaseWaitMs = options.leaseWaitMs ?? 35e3;
+	const renewals = /* @__PURE__ */ new Set();
+	let migrated;
+	let loaded;
+	let keyringModule;
+	let backend;
+	let closed = false;
+	async function guarded(work) {
+		try {
+			return await work();
+		} catch (error) {
+			throw require_vaultRules.asVaultError(error);
+		}
+	}
+	function ready() {
+		migrated ??= guarded(() => db.migrate(require_vaultRules.VAULT_DB_PREFIX, VAULT_MIGRATIONS)).catch((error) => {
+			migrated = void 0;
+			throw error;
+		});
+		return migrated;
+	}
+	async function readMeta(name) {
+		return (await database.get(SELECT_META, name))?.value;
+	}
+	async function keyringAccount() {
+		await database.run(INSERT_META, require_vaultRules.VAULT_META_ID, (0, node_crypto.randomBytes)(16));
+		const id = await readMeta(require_vaultRules.VAULT_META_ID);
+		if (id === void 0) throw new require_vaultRules.VaultError("unavailable");
+		return `${require_vaultRules.VAULT_KEYRING_ACCOUNT_PREFIX}${node_buffer.Buffer.from(id).toString("hex")}`;
+	}
+	async function gather(account) {
+		keyringModule ??= options.keyring().catch(() => null);
+		const keyring = await keyringModule;
+		const candidates = [];
+		let keyringFailed = false;
+		let fileFailed = false;
+		if (keyring !== null) try {
+			const password = await keyring.getPassword(account);
+			if (password !== null) {
+				const key = node_buffer.Buffer.from(password, "base64");
+				if (key.length === 32) candidates.push({
+					source: "keyring",
+					key
+				});
+				else keyringFailed = true;
+			}
+		} catch {
+			keyringFailed = true;
+		}
+		try {
+			const key = await keyFiles.readKeyFile(directory);
+			if (key !== void 0) candidates.push({
+				source: "file",
+				key
+			});
+		} catch {
+			fileFailed = true;
+		}
+		return {
+			candidates,
+			keyring,
+			keyringFailed,
+			fileFailed
+		};
+	}
+	/** The first candidate that decrypts `dek_check`, seeding the check from the first candidate when there is none. */
+	async function pick(gathered) {
+		let check = await readMeta(require_vaultRules.VAULT_META_CHECK);
+		if (check === void 0) {
+			const first = gathered.candidates[0];
+			if (first === void 0) return void 0;
+			await database.run(INSERT_META, require_vaultRules.VAULT_META_CHECK, packBox(seal(first.key, require_vaultRules.VAULT_CHECK_PLAINTEXT, require_vaultRules.VAULT_CHECK_AAD)));
+			check = await readMeta(require_vaultRules.VAULT_META_CHECK);
+			if (check === void 0) return void 0;
+		}
+		for (const candidate of gathered.candidates) {
+			if (!provesKey(candidate.key, check)) continue;
+			backend = candidate.source;
+			return {
+				key: candidate.key,
+				check
+			};
+		}
+	}
+	/**
+	* A source that failed may still hold the real key, so no new key replaces it. A throwing
+	* keyring only blocks once a check row exists: before that there is nothing to lose, and a
+	* host whose keyring daemon is missing falls back to `key.bin`.
+	*/
+	function blocked(gathered, check) {
+		return gathered.fileFailed || gathered.keyringFailed && check !== void 0;
+	}
+	/** Stores a new key in the keyring, read back to prove it; otherwise in a new `key.bin`. Never both. */
+	async function store(gathered, account, key) {
+		if (gathered.keyring !== null) {
+			const encoded = node_buffer.Buffer.from(key).toString("base64");
+			try {
+				await gathered.keyring.setPassword(account, encoded);
+				if (await gathered.keyring.getPassword(account) === encoded) return "keyring";
+			} catch {}
+		}
+		if (gathered.candidates.some((candidate) => candidate.source === "file")) await keyFiles.removeKeyFile(directory);
+		await keyFiles.createKeyFile(directory, key);
+		return "file";
+	}
+	async function loadKey() {
+		await ready();
+		const account = await keyringAccount();
+		const first = await gather(account);
+		const found = await pick(first);
+		if (found !== void 0) return found;
+		if (blocked(first, await readMeta("dek_check"))) throw new require_vaultRules.VaultError("unavailable");
+		return lease(require_vaultRules.VAULT_INIT_LEASE, async () => {
+			const again = await gather(account);
+			const existing = await pick(again);
+			if (existing !== void 0) return existing;
+			const check = await readMeta(require_vaultRules.VAULT_META_CHECK);
+			if (blocked(again, check)) throw new require_vaultRules.VaultError("unavailable");
+			const key = randomKey();
+			const source = await store(again, account, key);
+			const packed = packBox(seal(key, require_vaultRules.VAULT_CHECK_PLAINTEXT, require_vaultRules.VAULT_CHECK_AAD));
+			if (check === void 0) await database.run(REPLACE_META, require_vaultRules.VAULT_META_CHECK, packed);
+			else {
+				await database.transaction(async (transaction) => {
+					await transaction.run("DELETE FROM vault_entries");
+					await transaction.run(REPLACE_META, require_vaultRules.VAULT_META_CHECK, packed);
+				});
+				onNotice(require_vaultRules.VAULT_KEY_LOST_NOTICE);
+			}
+			backend = source;
+			return {
+				key,
+				check: packed
+			};
+		});
+	}
+	function currentKey() {
+		loaded ??= guarded(loadKey).catch((error) => {
+			loaded = void 0;
+			throw error;
+		});
+		return loaded;
+	}
+	/** The key, reloaded first when another process has replaced `dek_check` since it was loaded. */
+	async function freshKey() {
+		const cached = await currentKey();
+		const check = await guarded(() => readMeta(require_vaultRules.VAULT_META_CHECK));
+		if (check !== void 0 && bytesEqual(check, cached.check)) return cached;
+		if (loaded !== void 0 && await loaded === cached) loaded = void 0;
+		return currentKey();
+	}
+	async function tryAcquire(name, owner) {
+		const at = now();
+		try {
+			return await database.get(ACQUIRE_LEASE, name, owner, at + leaseTtlMs, at) !== void 0;
+		} catch (error) {
+			if (isBusy(error)) return false;
+			throw new require_vaultRules.VaultError("unavailable");
+		}
+	}
+	async function lease(name, op, signal) {
+		if (closed) throw new require_vaultRules.VaultError("unavailable");
+		await ready();
+		const owner = (0, node_crypto.randomUUID)();
+		const deadline = now() + leaseWaitMs;
+		for (;;) {
+			signal?.throwIfAborted();
+			if (await tryAcquire(name, owner)) break;
+			if (now() >= deadline) throw new require_vaultRules.VaultError("unavailable");
+			await sleep(50 + Math.random() * 50, signal);
+		}
+		const controller = new AbortController();
+		const onAbort = () => controller.abort(signal?.reason);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		const timer = setInterval(() => {
+			tryAcquire(name, owner).then((held) => {
+				if (!held) controller.abort(new require_vaultRules.VaultError("unavailable"));
+			}, () => void 0);
+		}, leaseRenewMs);
+		timer.unref?.();
+		renewals.add(timer);
+		try {
+			return await op(controller.signal);
+		} finally {
+			clearInterval(timer);
+			renewals.delete(timer);
+			signal?.removeEventListener("abort", onAbort);
+			try {
+				await database.run(RELEASE_LEASE, name, owner);
+			} catch {}
+		}
+	}
+	async function writeRow(sql, params) {
+		const row = await guarded(() => database.get(sql, ...params));
+		if (row === void 0) throw new require_vaultRules.VaultError("conflict");
+		return row;
+	}
+	return {
+		async get(namespace, key) {
+			require_vaultRules.assertEntryName(namespace, key);
+			await ready();
+			const row = await guarded(() => database.get(SELECT_ENTRY, namespace, key));
+			if (row === void 0) return void 0;
+			const aad = entryAad(namespace, key);
+			let loadedKey = await currentKey();
+			let text = open$1(loadedKey.key, boxOf(row), aad);
+			if (text === void 0) {
+				const check = await guarded(() => readMeta(require_vaultRules.VAULT_META_CHECK));
+				if (check === void 0 || !provesKey(loadedKey.key, check)) {
+					loaded = void 0;
+					loadedKey = await currentKey();
+					text = open$1(loadedKey.key, boxOf(row), aad);
+				}
+			}
+			if (text === void 0) {
+				await guarded(() => database.run("DELETE FROM vault_entries WHERE namespace = ? AND key = ? AND revision = ?", namespace, key, row.revision));
+				return;
+			}
+			return {
+				value: JSON.parse(text),
+				revision: row.revision,
+				updatedAt: row.updated_at
+			};
+		},
+		async put(namespace, key, value, putOptions) {
+			require_vaultRules.assertEntryName(namespace, key);
+			const expectRevision = putOptions?.expectRevision;
+			if (expectRevision !== void 0 && expectRevision !== null) require_vaultRules.assertRevision(expectRevision);
+			const text = require_vaultRules.serializeValue(value);
+			await ready();
+			const box = seal((await freshKey()).key, text, entryAad(namespace, key));
+			const at = now();
+			const row = expectRevision === void 0 ? await writeRow(PUT_LAST_WRITE_WINS, [
+				namespace,
+				key,
+				at,
+				box.iv,
+				box.tag,
+				box.ciphertext
+			]) : expectRevision === null ? await writeRow(PUT_CREATE_ONLY, [
+				namespace,
+				key,
+				at,
+				box.iv,
+				box.tag,
+				box.ciphertext
+			]) : await writeRow(PUT_EXPECT_REVISION, [
+				expectRevision + 1,
+				at,
+				box.iv,
+				box.tag,
+				box.ciphertext,
+				namespace,
+				key,
+				expectRevision
+			]);
+			return {
+				value: JSON.parse(text),
+				revision: row.revision,
+				updatedAt: row.updated_at
+			};
+		},
+		async delete(namespace, key, deleteOptions) {
+			require_vaultRules.assertEntryName(namespace, key);
+			const expectRevision = deleteOptions?.expectRevision;
+			if (expectRevision !== void 0) require_vaultRules.assertRevision(expectRevision);
+			await ready();
+			if (expectRevision === void 0) {
+				await guarded(() => database.run("DELETE FROM vault_entries WHERE namespace = ? AND key = ?", namespace, key));
+				return;
+			}
+			await writeRow("DELETE FROM vault_entries WHERE namespace = ? AND key = ? AND revision = ? RETURNING revision, 0 AS updated_at", [
+				namespace,
+				key,
+				expectRevision
+			]);
+		},
+		withLock(namespace, key, op, signal) {
+			try {
+				require_vaultRules.assertEntryName(namespace, key);
+			} catch (error) {
+				return Promise.reject(error);
+			}
+			if (typeof op !== "function") return Promise.reject(new require_vaultRules.VaultError("invalid"));
+			return lease(entryAad(namespace, key), op, signal);
+		},
+		status() {
+			return { backend };
+		},
+		close() {
+			closed = true;
+			for (const timer of renewals) clearInterval(timer);
+			renewals.clear();
+		}
+	};
+}
+//#endregion
+//#region src/services/vaultDirectory/index.ts
+/** Windows has no O_NOFOLLOW; there a plain open stands in. */
+const NO_FOLLOW = node_fs.constants.O_NOFOLLOW ?? 0;
+const GROUP_OTHER_BITS = 63;
+const POSIX = process.platform !== "win32";
+function currentUid() {
+	return typeof process.getuid === "function" ? process.getuid() : void 0;
+}
+function ownedByUser(uid) {
+	const user = currentUid();
+	return user === void 0 || uid === user;
+}
+function errorCode(error) {
+	return error !== null && typeof error === "object" && "code" in error ? String(error.code) : void 0;
+}
+/**
+* Creates `directory` owner-only, or checks and repairs an existing one.
+*
+* Refuses a symlink, a non-directory and a folder another user owns. Loose permission bits
+* are tightened to 0700.
+*/
+async function preparePrivateDirectory(directory) {
+	try {
+		await (0, node_fs_promises.mkdir)(directory, {
+			recursive: true,
+			mode: 448
+		});
+		const stats = await (0, node_fs_promises.lstat)(directory);
+		if (stats.isSymbolicLink() || !stats.isDirectory() || !ownedByUser(stats.uid)) throw new require_vaultRules.VaultError("unavailable");
+		if (POSIX && (stats.mode & GROUP_OTHER_BITS) !== 0) await (0, node_fs_promises.chmod)(directory, 448);
+	} catch (error) {
+		throw error instanceof require_vaultRules.VaultError ? error : new require_vaultRules.VaultError("unavailable");
+	}
+}
+/**
+* The 32-byte key in `<directory>/key.bin`, or `undefined` when there is none.
+*
+* The file must be a regular, owner-only file with one link, opened without following a
+* symlink; anything else throws `unavailable` so the caller never replaces a key it could not read.
+*/
+async function readKeyFile(directory) {
+	let handle;
+	try {
+		handle = await (0, node_fs_promises.open)(node_path.default.join(directory, require_vaultRules.VAULT_KEY_FILE), node_fs.constants.O_RDONLY | NO_FOLLOW);
+	} catch (error) {
+		if (errorCode(error) === "ENOENT" || errorCode(error) === "ENOTDIR") return void 0;
+		throw new require_vaultRules.VaultError("unavailable");
+	}
+	try {
+		const stats = await handle.stat();
+		if (!stats.isFile() || stats.nlink !== 1 || !ownedByUser(stats.uid) || POSIX && (stats.mode & GROUP_OTHER_BITS) !== 0 || stats.size !== 32) throw new require_vaultRules.VaultError("unavailable");
+		const key = Buffer.alloc(32);
+		const { bytesRead } = await handle.read(key, 0, 32, 0);
+		if (bytesRead !== 32) throw new require_vaultRules.VaultError("unavailable");
+		return key;
+	} catch (error) {
+		throw error instanceof require_vaultRules.VaultError ? error : new require_vaultRules.VaultError("unavailable");
+	} finally {
+		await handle.close();
+	}
+}
+/** Writes a new `key.bin` (0600, exclusive create, no symlink follow) and syncs it to disk. */
+async function createKeyFile(directory, key) {
+	if (key.length !== 32) throw new require_vaultRules.VaultError("invalid");
+	await preparePrivateDirectory(directory);
+	try {
+		const handle = await (0, node_fs_promises.open)(node_path.default.join(directory, require_vaultRules.VAULT_KEY_FILE), node_fs.constants.O_WRONLY | node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | NO_FOLLOW, 384);
+		try {
+			await handle.write(key, 0, key.length, 0);
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+	} catch {
+		throw new require_vaultRules.VaultError("unavailable");
+	}
+}
+/** Removes a `key.bin` the vault proved stale; a missing file is fine. */
+async function removeKeyFile(directory) {
+	try {
+		await (0, node_fs_promises.unlink)(node_path.default.join(directory, require_vaultRules.VAULT_KEY_FILE));
+	} catch (error) {
+		if (errorCode(error) !== "ENOENT") throw new require_vaultRules.VaultError("unavailable");
+	}
+}
+//#endregion
+//#region src/services/vaultKeyring/index.ts
+/**
+* The OS keyring through `@napi-rs/keyring`, loaded on first use, or `null` when this platform
+* has no build of the module.
+*/
+async function loadKeyring() {
+	try {
+		const { AsyncEntry } = await import("@napi-rs/keyring");
+		return {
+			getPassword: (account) => new AsyncEntry(require_vaultRules.VAULT_KEYRING_SERVICE, account).getPassword(),
+			setPassword: (account, password) => new AsyncEntry(require_vaultRules.VAULT_KEYRING_SERVICE, account).setPassword(password)
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/extensions/(backend)/_lib/root.server.ts
+/**
+* The vault, bound as `po/vault` at the global level on top of the shared `po/db`.
+*
+* Only a global host with a home directory builds it. The vault loads its key lazily on first
+* use, so mounting never touches the keyring or `<po home>/vault`.
+*/
+async function createPoVaultGlobalRoot(plugin) {
+	const host = plugin.host;
+	const homeDirectory = host.context.homeDirectory;
+	if (host.scope !== "global" || homeDirectory === void 0) return { value: void 0 };
+	const directory = node_path.default.join((0, _agimon_ai_po_core_piSettings.poHomeDirectory)(homeDirectory, host.context.environment ?? {}), require_vaultRules.VAULT_DIRECTORY);
+	let vault;
+	let boundDb;
+	const provider = plugin.context.inject([_agimon_ai_po_core_serverPlugin.PO_SERVER_SCOPE_SERVICE, _agimon_ai_po_db.PO_DB_SERVICE], (injected) => {
+		const db = (0, _agimon_ai_po_db.requirePoDb)(injected);
+		if (vault === void 0 || boundDb !== db) {
+			vault?.close();
+			boundDb = db;
+			vault = createVault({
+				db,
+				directory,
+				keyring: loadKeyring,
+				keyFiles: {
+					readKeyFile,
+					createKeyFile,
+					removeKeyFile
+				},
+				onNotice: (message) => host.context.onNotice(`Vault: ${message}`)
+			});
+		}
+		return (0, _agimon_ai_po_core_serverPlugin.requirePoServerScope)(injected).provide(require_contracts.PO_VAULT_CONTRACT, vault);
+	});
+	await provider.await();
+	return {
+		value: vault,
+		onDispose: async () => {
+			await provider.dispose();
+			vault?.close();
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/root.server.ts
+var root_server_default = (0, _agimon_ai_po_core_extensionFile.defineRoot)(createPoVaultGlobalRoot, { inject: [_agimon_ai_po_db.PO_DB_CONTRACT] });
+//#endregion
+//#region generated/server.ts
+const serverPlugin = (0, _agimon_ai_po_core_serverPlugin.defineServerPlugin)({
+	name: "@agimon-ai/po-vault",
+	providerOverrides: (0, _agimon_ai_po_core_serverPlugin.composeServerProviderOverrides)(root_server_default),
+	injects: (0, _agimon_ai_po_core_extensionFile.composeRootInjects)({
+		global: [root_server_default],
+		workspace: [root_server_default],
+		session: [root_server_default]
+	}),
+	global: async (context) => {
+		const scopeGlobal = await context.scopeRoot("global", root_server_default, context);
+		return {
+			...(0, _agimon_ai_po_core_extensionFile.composeRootHooks)(scopeGlobal),
+			services: [...scopeGlobal.services ?? []]
+		};
+	},
+	workspace: async (context) => {
+		const scopeGlobal = await context.scopeRoot("global", root_server_default, context);
+		return {
+			...(0, _agimon_ai_po_core_extensionFile.composeRootHooks)(scopeGlobal),
+			services: [...scopeGlobal.services ?? []]
+		};
+	},
+	session: async (context) => {
+		const scopeGlobal = await context.scopeRoot("global", root_server_default, context);
+		return {
+			...(0, _agimon_ai_po_core_extensionFile.composeRootHooks)(scopeGlobal),
+			services: [...scopeGlobal.services ?? []],
+			get activities() {
+				return [...scopeGlobal.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+exports.default = serverPlugin;
+exports.serverPlugin = serverPlugin;
+
+//# sourceMappingURL=server.cjs.map