@gakr-gakr/matrix 0.1.0 → 0.1.1

package/dist/approval-reactions-C7FrzFhD.js

@@ -0,0 +1,162 @@
+import { n as getOptionalMatrixRuntime } from "./runtime-BfjP-NST.js";
+//#region extensions/matrix/src/approval-reactions.ts
+const MATRIX_APPROVAL_REACTION_META = {
+	"allow-once": {
+		emoji: "✅",
+		label: "Allow once"
+	},
+	"allow-always": {
+		emoji: "♾️",
+		label: "Allow always"
+	},
+	deny: {
+		emoji: "❌",
+		label: "Deny"
+	}
+};
+const MATRIX_APPROVAL_REACTION_ORDER = [
+	"allow-once",
+	"allow-always",
+	"deny"
+];
+const PERSISTENT_NAMESPACE = "matrix.approval-reactions";
+const PERSISTENT_MAX_ENTRIES = 1e3;
+const DEFAULT_REACTION_TARGET_TTL_MS = 1440 * 60 * 1e3;
+const matrixApprovalReactionTargets = /* @__PURE__ */ new Map();
+let persistentStore;
+let persistentStoreDisabled = false;
+function buildReactionTargetKey(roomId, eventId) {
+	const normalizedRoomId = roomId.trim();
+	const normalizedEventId = eventId.trim();
+	if (!normalizedRoomId || !normalizedEventId) return null;
+	return `${normalizedRoomId}:${normalizedEventId}`;
+}
+function reportPersistentApprovalReactionError(error) {
+	try {
+		getOptionalMatrixRuntime()?.logging.getChildLogger({
+			plugin: "matrix",
+			feature: "approval-reaction-state"
+		}).warn("Matrix persistent approval reaction state failed", { error: String(error) });
+	} catch {}
+}
+function disablePersistentApprovalReactionStore(error) {
+	persistentStoreDisabled = true;
+	persistentStore = void 0;
+	reportPersistentApprovalReactionError(error);
+}
+function getPersistentApprovalReactionStore() {
+	if (persistentStoreDisabled) return;
+	if (persistentStore) return persistentStore;
+	const runtime = getOptionalMatrixRuntime();
+	if (!runtime) return;
+	try {
+		persistentStore = runtime.state.openKeyedStore({
+			namespace: PERSISTENT_NAMESPACE,
+			maxEntries: PERSISTENT_MAX_ENTRIES,
+			defaultTtlMs: DEFAULT_REACTION_TARGET_TTL_MS
+		});
+		return persistentStore;
+	} catch (error) {
+		disablePersistentApprovalReactionStore(error);
+		return;
+	}
+}
+function readPersistedTarget(value) {
+	const persisted = value;
+	if (persisted?.version !== 1 || !persisted.target || typeof persisted.target.approvalId !== "string" || !Array.isArray(persisted.target.allowedDecisions)) return null;
+	return persisted.target;
+}
+function rememberPersistentApprovalReactionTarget(params) {
+	const ttlMs = params.ttlMs == null ? DEFAULT_REACTION_TARGET_TTL_MS : Math.max(1, params.ttlMs);
+	const store = getPersistentApprovalReactionStore();
+	if (!store) return;
+	store.register(params.key, {
+		version: 1,
+		target: params.target
+	}, { ttlMs }).catch(disablePersistentApprovalReactionStore);
+}
+function forgetPersistentApprovalReactionTarget(key) {
+	const store = getPersistentApprovalReactionStore();
+	if (!store) return;
+	store.delete(key).catch(disablePersistentApprovalReactionStore);
+}
+async function lookupPersistentApprovalReactionTarget(key) {
+	const store = getPersistentApprovalReactionStore();
+	if (!store) return null;
+	try {
+		return readPersistedTarget(await store.lookup(key));
+	} catch (error) {
+		disablePersistentApprovalReactionStore(error);
+		return null;
+	}
+}
+function listMatrixApprovalReactionBindings(allowedDecisions) {
+	const allowed = new Set(allowedDecisions);
+	return MATRIX_APPROVAL_REACTION_ORDER.filter((decision) => allowed.has(decision)).map((decision) => ({
+		decision,
+		emoji: MATRIX_APPROVAL_REACTION_META[decision].emoji,
+		label: MATRIX_APPROVAL_REACTION_META[decision].label
+	}));
+}
+function buildMatrixApprovalReactionHint(allowedDecisions) {
+	const bindings = listMatrixApprovalReactionBindings(allowedDecisions);
+	if (bindings.length === 0) return null;
+	return `React here: ${bindings.map((binding) => `${binding.emoji} ${binding.label}`).join(", ")}`;
+}
+function resolveMatrixApprovalReactionDecision(reactionKey, allowedDecisions) {
+	const normalizedReaction = reactionKey.trim();
+	if (!normalizedReaction) return null;
+	const allowed = new Set(allowedDecisions);
+	for (const decision of MATRIX_APPROVAL_REACTION_ORDER) {
+		if (!allowed.has(decision)) continue;
+		if (MATRIX_APPROVAL_REACTION_META[decision].emoji === normalizedReaction) return decision;
+	}
+	return null;
+}
+function registerMatrixApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params.roomId, params.eventId);
+	const approvalId = params.approvalId.trim();
+	const allowedDecisions = Array.from(new Set(params.allowedDecisions.filter((decision) => decision === "allow-once" || decision === "allow-always" || decision === "deny")));
+	if (!key || !approvalId || allowedDecisions.length === 0) return;
+	const target = {
+		approvalId,
+		allowedDecisions
+	};
+	matrixApprovalReactionTargets.set(key, target);
+	rememberPersistentApprovalReactionTarget({
+		key,
+		target,
+		ttlMs: params.ttlMs
+	});
+}
+function unregisterMatrixApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params.roomId, params.eventId);
+	if (!key) return;
+	matrixApprovalReactionTargets.delete(key);
+	forgetPersistentApprovalReactionTarget(key);
+}
+function resolveTarget(params) {
+	const target = params.target;
+	if (!target) return null;
+	const decision = resolveMatrixApprovalReactionDecision(params.reactionKey, target.allowedDecisions);
+	if (!decision) return null;
+	return {
+		approvalId: target.approvalId,
+		decision
+	};
+}
+async function resolveMatrixApprovalReactionTargetWithPersistence(params) {
+	const key = buildReactionTargetKey(params.roomId, params.eventId);
+	if (!key) return null;
+	const inMemory = resolveTarget({
+		target: matrixApprovalReactionTargets.get(key),
+		reactionKey: params.reactionKey
+	});
+	if (inMemory) return inMemory;
+	return resolveTarget({
+		target: await lookupPersistentApprovalReactionTarget(key),
+		reactionKey: params.reactionKey
+	});
+}
+//#endregion
+export { unregisterMatrixApprovalReactionTarget as a, resolveMatrixApprovalReactionTargetWithPersistence as i, listMatrixApprovalReactionBindings as n, registerMatrixApprovalReactionTarget as r, buildMatrixApprovalReactionHint as t };

package/dist/async-lock-SsmtFXtt.js

@@ -0,0 +1,19 @@
+//#region extensions/matrix/src/matrix/async-lock.ts
+function createAsyncLock() {
+	let lock = Promise.resolve();
+	return async function withLock(fn) {
+		const previous = lock;
+		let release;
+		lock = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			return await fn();
+		} finally {
+			release?.();
+		}
+	};
+}
+//#endregion
+export { createAsyncLock as t };

package/dist/auth-presence.js

@@ -0,0 +1,26 @@
+import { i as resolveMatrixCredentialsFilename, r as resolveMatrixCredentialsDir } from "./storage-paths-BcLg30GH.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveStateDir } from "autobot/plugin-sdk/state-paths";
+//#region extensions/matrix/auth-presence.ts
+function listMatrixCredentialPaths(_cfg, env = process.env) {
+	const credentialsDir = resolveMatrixCredentialsDir(resolveStateDir(env, os.homedir));
+	const paths = new Set([resolveMatrixCredentialsFilename(), resolveMatrixCredentialsFilename("default")]);
+	try {
+		const entries = fs.readdirSync(credentialsDir, { withFileTypes: true });
+		for (const entry of entries) if (entry.isFile() && /^credentials(?:-[a-z0-9._-]+)?\.json$/i.test(entry.name)) paths.add(entry.name);
+	} catch {}
+	return [...paths].map((filename) => path.join(credentialsDir, filename));
+}
+function hasAnyMatrixAuth(params, env = process.env) {
+	return listMatrixCredentialPaths(params && typeof params === "object" && "cfg" in params ? params.cfg : params, params && typeof params === "object" && "cfg" in params ? params.env ?? env : env).some((filePath) => {
+		try {
+			return fs.existsSync(filePath);
+		} catch {
+			return false;
+		}
+	});
+}
+//#endregion
+export { hasAnyMatrixAuth };

package/dist/backup-health-3BHbHxyd.js

@@ -0,0 +1,60 @@
+//#region extensions/matrix/src/matrix/backup-health.ts
+function resolveMatrixRoomKeyBackupIssue(backup) {
+	if (!backup.serverVersion) return {
+		code: "missing-server-backup",
+		summary: "missing on server",
+		message: "no room-key backup exists on the homeserver"
+	};
+	if (backup.decryptionKeyCached === false) {
+		if (backup.keyLoadError) return {
+			code: "key-load-failed",
+			summary: "present but backup key unavailable on this device",
+			message: `backup decryption key could not be loaded from secret storage (${backup.keyLoadError})`
+		};
+		if (backup.keyLoadAttempted) return {
+			code: "key-not-loaded",
+			summary: "present but backup key unavailable on this device",
+			message: "backup decryption key is not loaded on this device (secret storage did not return a key)"
+		};
+		return {
+			code: "key-not-loaded",
+			summary: "present but backup key unavailable on this device",
+			message: "backup decryption key is not loaded on this device"
+		};
+	}
+	if (backup.matchesDecryptionKey === false) return {
+		code: "key-mismatch",
+		summary: "present but backup key mismatch on this device",
+		message: "backup key mismatch (this device does not have the matching backup decryption key)"
+	};
+	if (backup.trusted === false) return {
+		code: "untrusted-signature",
+		summary: "present but not trusted on this device",
+		message: "backup signature chain is not trusted by this device"
+	};
+	if (!backup.activeVersion) return {
+		code: "inactive",
+		summary: "present on server but inactive on this device",
+		message: "backup exists but is not active on this device"
+	};
+	if (backup.trusted === null || backup.matchesDecryptionKey === null || backup.decryptionKeyCached === null) return {
+		code: "indeterminate",
+		summary: "present but trust state unknown",
+		message: "backup trust state could not be fully determined"
+	};
+	return {
+		code: "ok",
+		summary: "active and trusted on this device",
+		message: null
+	};
+}
+function resolveMatrixRoomKeyBackupReadinessError(backup, opts) {
+	const issue = resolveMatrixRoomKeyBackupIssue(backup);
+	if (issue.code === "missing-server-backup") return opts.requireServerBackup ? "Matrix room key backup is missing on the homeserver." : null;
+	if (issue.code === "ok") return null;
+	if (issue.code === "untrusted-signature" && opts.allowUntrustedMatchingKey === true && backup.matchesDecryptionKey === true && backup.decryptionKeyCached === true) return null;
+	if (issue.message) return `Matrix room key backup is not usable: ${issue.message}.`;
+	return "Matrix room key backup is not usable on this device.";
+}
+//#endregion
+export { resolveMatrixRoomKeyBackupReadinessError as n, resolveMatrixRoomKeyBackupIssue as t };