@kodelyth/matrix 2026.5.39 → 2026.5.42

package/dist/startup-abort-B2J3MU_h.js

@@ -0,0 +1,109 @@
+import { t as getMatrixRuntime } from "./runtime-B-Fyrmxo.js";
+import { format } from "node:util";
+import { redactSensitiveText } from "klaw/plugin-sdk/logging-core";
+//#region extensions/matrix/src/matrix/sdk/logger.ts
+function noop() {}
+let forceConsoleLogging = false;
+function setMatrixConsoleLogging(enabled) {
+	forceConsoleLogging = enabled;
+}
+function resolveRuntimeLogger(module) {
+	if (forceConsoleLogging) return null;
+	try {
+		return getMatrixRuntime().logging.getChildLogger({ module: `matrix:${module}` });
+	} catch {
+		return null;
+	}
+}
+function formatMessage(module, messageOrObject) {
+	if (messageOrObject.length === 0) return `[${module}]`;
+	return redactSensitiveText(`[${module}] ${format(...messageOrObject)}`);
+}
+var ConsoleLogger = class {
+	emit(level, module, ...messageOrObject) {
+		const runtimeLogger = resolveRuntimeLogger(module);
+		const message = formatMessage(module, messageOrObject);
+		if (runtimeLogger) {
+			if (level === "debug") {
+				runtimeLogger.debug?.(message);
+				return;
+			}
+			runtimeLogger[level](message);
+			return;
+		}
+		if (level === "debug") {
+			console.debug(message);
+			return;
+		}
+		console[level](message);
+	}
+	trace(module, ...messageOrObject) {
+		this.emit("debug", module, ...messageOrObject);
+	}
+	debug(module, ...messageOrObject) {
+		this.emit("debug", module, ...messageOrObject);
+	}
+	info(module, ...messageOrObject) {
+		this.emit("info", module, ...messageOrObject);
+	}
+	warn(module, ...messageOrObject) {
+		this.emit("warn", module, ...messageOrObject);
+	}
+	error(module, ...messageOrObject) {
+		this.emit("error", module, ...messageOrObject);
+	}
+};
+let activeLogger = new ConsoleLogger();
+const LogService = {
+	setLogger(logger) {
+		activeLogger = logger;
+	},
+	trace(module, ...messageOrObject) {
+		activeLogger.trace(module, ...messageOrObject);
+	},
+	debug(module, ...messageOrObject) {
+		activeLogger.debug(module, ...messageOrObject);
+	},
+	info(module, ...messageOrObject) {
+		activeLogger.info(module, ...messageOrObject);
+	},
+	warn(module, ...messageOrObject) {
+		activeLogger.warn(module, ...messageOrObject);
+	},
+	error(module, ...messageOrObject) {
+		activeLogger.error(module, ...messageOrObject);
+	}
+};
+//#endregion
+//#region extensions/matrix/src/matrix/startup-abort.ts
+function createMatrixStartupAbortError() {
+	const error = /* @__PURE__ */ new Error("Matrix startup aborted");
+	error.name = "AbortError";
+	return error;
+}
+function throwIfMatrixStartupAborted(abortSignal) {
+	if (abortSignal?.aborted === true) throw createMatrixStartupAbortError();
+}
+function isMatrixStartupAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+async function awaitMatrixStartupWithAbort(promise, abortSignal) {
+	if (!abortSignal) return await promise;
+	if (abortSignal.aborted) throw createMatrixStartupAbortError();
+	return await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			abortSignal.removeEventListener("abort", onAbort);
+			reject(createMatrixStartupAbortError());
+		};
+		abortSignal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			abortSignal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			abortSignal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+//#endregion
+export { ConsoleLogger as a, setMatrixConsoleLogging as c, throwIfMatrixStartupAborted as i, createMatrixStartupAbortError as n, LogService as o, isMatrixStartupAbortError as r, noop as s, awaitMatrixStartupWithAbort as t };

package/dist/startup-verification-CkD4Cwce.js

@@ -0,0 +1,132 @@
+import { t as formatMatrixErrorMessage } from "./errors-BETj3zr9.js";
+import { a as resolveMatrixStoragePaths } from "./storage-nyO0DOFE.js";
+import path from "node:path";
+import { readJsonFileWithFallback, writeJsonFileAtomically } from "klaw/plugin-sdk/json-store";
+import fs from "node:fs/promises";
+//#region extensions/matrix/src/matrix/monitor/startup-verification.ts
+const STARTUP_VERIFICATION_STATE_FILENAME = "startup-verification.json";
+const DEFAULT_STARTUP_VERIFICATION_MODE = "if-unverified";
+const DEFAULT_STARTUP_VERIFICATION_COOLDOWN_HOURS = 24;
+const DEFAULT_STARTUP_VERIFICATION_FAILURE_COOLDOWN_MS = 3600 * 1e3;
+function normalizeCooldownHours(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_STARTUP_VERIFICATION_COOLDOWN_HOURS;
+	return Math.max(0, value);
+}
+function resolveStartupVerificationStatePath(params) {
+	const storagePaths = resolveMatrixStoragePaths({
+		homeserver: params.auth.homeserver,
+		userId: params.auth.userId,
+		accessToken: params.auth.accessToken,
+		accountId: params.auth.accountId,
+		deviceId: params.auth.deviceId,
+		env: params.env
+	});
+	return path.join(storagePaths.rootDir, STARTUP_VERIFICATION_STATE_FILENAME);
+}
+async function readStartupVerificationState(filePath) {
+	const { value } = await readJsonFileWithFallback(filePath, null);
+	return value && typeof value === "object" ? value : null;
+}
+async function clearStartupVerificationState(filePath) {
+	await fs.rm(filePath, { force: true }).catch(() => {});
+}
+function resolveStateCooldownMs(state, cooldownMs) {
+	if (state?.outcome === "failed") return Math.min(cooldownMs, DEFAULT_STARTUP_VERIFICATION_FAILURE_COOLDOWN_MS);
+	return cooldownMs;
+}
+function resolveRetryAfterMs(params) {
+	const attemptedAtMs = Date.parse(params.attemptedAt ?? "");
+	if (!Number.isFinite(attemptedAtMs)) return;
+	const remaining = attemptedAtMs + params.cooldownMs - params.nowMs;
+	return remaining > 0 ? remaining : void 0;
+}
+function shouldHonorCooldown(params) {
+	if (!params.state || params.stateCooldownMs <= 0) return false;
+	if (params.state.userId && params.verification.userId && params.state.userId !== params.verification.userId) return false;
+	if (params.state.deviceId && params.verification.deviceId && params.state.deviceId !== params.verification.deviceId) return false;
+	return resolveRetryAfterMs({
+		attemptedAt: params.state.attemptedAt,
+		cooldownMs: params.stateCooldownMs,
+		nowMs: params.nowMs
+	}) !== void 0;
+}
+function hasPendingSelfVerification(verifications) {
+	return verifications.some((entry) => entry.isSelfVerification && !entry.completed && entry.pending);
+}
+async function ensureMatrixStartupVerification(params) {
+	if (params.auth.encryption !== true || !params.client.crypto) return { kind: "unsupported" };
+	const verification = await params.client.getOwnDeviceVerificationStatus();
+	const statePath = params.stateFilePath ?? resolveStartupVerificationStatePath({
+		auth: params.auth,
+		env: params.env
+	});
+	if (verification.verified) {
+		await clearStartupVerificationState(statePath);
+		return {
+			kind: "verified",
+			verification
+		};
+	}
+	if ((params.accountConfig.startupVerification ?? DEFAULT_STARTUP_VERIFICATION_MODE) === "off") {
+		await clearStartupVerificationState(statePath);
+		return {
+			kind: "disabled",
+			verification
+		};
+	}
+	if (hasPendingSelfVerification(await params.client.crypto.listVerifications().catch(() => []))) return {
+		kind: "pending",
+		verification
+	};
+	const cooldownMs = normalizeCooldownHours(params.accountConfig.startupVerificationCooldownHours) * 60 * 60 * 1e3;
+	const nowMs = params.nowMs ?? Date.now();
+	const state = await readStartupVerificationState(statePath);
+	const stateCooldownMs = resolveStateCooldownMs(state, cooldownMs);
+	if (shouldHonorCooldown({
+		state,
+		verification,
+		stateCooldownMs,
+		nowMs
+	})) return {
+		kind: "cooldown",
+		verification,
+		retryAfterMs: resolveRetryAfterMs({
+			attemptedAt: state?.attemptedAt,
+			cooldownMs: stateCooldownMs,
+			nowMs
+		})
+	};
+	try {
+		const request = await params.client.crypto.requestVerification({ ownUser: true });
+		await writeJsonFileAtomically(statePath, {
+			userId: verification.userId,
+			deviceId: verification.deviceId,
+			attemptedAt: new Date(nowMs).toISOString(),
+			outcome: "requested",
+			requestId: request.id,
+			transactionId: request.transactionId
+		});
+		return {
+			kind: "requested",
+			verification,
+			requestId: request.id,
+			transactionId: request.transactionId ?? void 0
+		};
+	} catch (err) {
+		const error = formatMatrixErrorMessage(err);
+		await writeJsonFileAtomically(statePath, {
+			userId: verification.userId,
+			deviceId: verification.deviceId,
+			attemptedAt: new Date(nowMs).toISOString(),
+			outcome: "failed",
+			error
+		}).catch(() => {});
+		return {
+			kind: "request-failed",
+			verification,
+			error
+		};
+	}
+}
+//#endregion
+export { ensureMatrixStartupVerification };

package/dist/storage-nyO0DOFE.js

@@ -0,0 +1,281 @@
+import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-Y50DNJ2l.js";
+import { t as getMatrixRuntime } from "./runtime-B-Fyrmxo.js";
+import { n as resolveMatrixAccountStorageRoot, s as resolveMatrixLegacyFlatStoragePaths } from "./storage-paths-BTAketfg.js";
+import { normalizeAccountId } from "klaw/plugin-sdk/account-id";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadJsonFile, saveJsonFile } from "klaw/plugin-sdk/json-store";
+//#region extensions/matrix/src/matrix/client/storage.ts
+const DEFAULT_ACCOUNT_KEY = "default";
+const STORAGE_META_FILENAME = "storage-meta.json";
+const THREAD_BINDINGS_FILENAME = "thread-bindings.json";
+const LEGACY_CRYPTO_MIGRATION_FILENAME = "legacy-crypto-migration.json";
+const RECOVERY_KEY_FILENAME = "recovery-key.json";
+const IDB_SNAPSHOT_FILENAME = "crypto-idb-snapshot.json";
+const STARTUP_VERIFICATION_FILENAME = "startup-verification.json";
+function resolveLegacyStoragePaths(env = process.env) {
+	const legacy = resolveMatrixLegacyFlatStoragePaths(getMatrixRuntime().state.resolveStateDir(env, os.homedir));
+	return {
+		storagePath: legacy.storagePath,
+		cryptoPath: legacy.cryptoPath
+	};
+}
+function assertLegacyMigrationAccountSelection(params) {
+	const cfg = getMatrixRuntime().config.current();
+	if (!cfg.channels?.matrix || typeof cfg.channels.matrix !== "object") return;
+	if (requiresExplicitMatrixDefaultAccount(cfg)) throw new Error("Legacy Matrix client storage cannot be migrated automatically because multiple Matrix accounts are configured and channels.matrix.defaultAccount is not set.");
+	const selectedAccountId = normalizeAccountId(resolveMatrixDefaultOrOnlyAccountId(cfg));
+	const currentAccountId = normalizeAccountId(params.accountKey);
+	if (selectedAccountId !== currentAccountId) throw new Error(`Legacy Matrix client storage targets account "${selectedAccountId}", but the current client is starting account "${currentAccountId}". Start the selected account first so flat legacy storage is not migrated into the wrong account directory.`);
+}
+function scoreStorageRoot(rootDir) {
+	let score = 0;
+	if (fs.existsSync(path.join(rootDir, "bot-storage.json"))) score += 8;
+	if (fs.existsSync(path.join(rootDir, "crypto"))) score += 8;
+	if (fs.existsSync(path.join(rootDir, THREAD_BINDINGS_FILENAME))) score += 4;
+	if (fs.existsSync(path.join(rootDir, LEGACY_CRYPTO_MIGRATION_FILENAME))) score += 3;
+	if (fs.existsSync(path.join(rootDir, RECOVERY_KEY_FILENAME))) score += 2;
+	if (fs.existsSync(path.join(rootDir, IDB_SNAPSHOT_FILENAME))) score += 2;
+	if (fs.existsSync(path.join(rootDir, STORAGE_META_FILENAME))) score += 1;
+	return score;
+}
+function resolveStorageRootMtimeMs(rootDir) {
+	try {
+		return fs.statSync(rootDir).mtimeMs;
+	} catch {
+		return 0;
+	}
+}
+function readStoredRootMetadata(rootDir) {
+	const metadata = {};
+	const parsed = loadJsonFile(path.join(rootDir, STORAGE_META_FILENAME));
+	if (parsed) {
+		if (typeof parsed.homeserver === "string" && parsed.homeserver.trim()) metadata.homeserver = parsed.homeserver.trim();
+		if (typeof parsed.userId === "string" && parsed.userId.trim()) metadata.userId = parsed.userId.trim();
+		if (typeof parsed.accountId === "string" && parsed.accountId.trim()) metadata.accountId = parsed.accountId.trim();
+		if (typeof parsed.accessTokenHash === "string" && parsed.accessTokenHash.trim()) metadata.accessTokenHash = parsed.accessTokenHash.trim();
+		if (typeof parsed.deviceId === "string" && parsed.deviceId.trim()) metadata.deviceId = parsed.deviceId.trim();
+		if (parsed.currentTokenStateClaimed === true) metadata.currentTokenStateClaimed = true;
+		if (typeof parsed.createdAt === "string" && parsed.createdAt.trim()) metadata.createdAt = parsed.createdAt.trim();
+	}
+	const verification = loadJsonFile(path.join(rootDir, STARTUP_VERIFICATION_FILENAME));
+	if (!metadata.deviceId && typeof verification?.deviceId === "string" && verification.deviceId.trim()) metadata.deviceId = verification.deviceId.trim();
+	return metadata;
+}
+function isCompatibleStorageRoot(params) {
+	const metadata = readStoredRootMetadata(params.candidateRootDir);
+	if (metadata.homeserver && metadata.homeserver !== params.homeserver) return false;
+	if (metadata.userId && metadata.userId !== params.userId) return false;
+	if (metadata.accountId && normalizeAccountId(metadata.accountId) !== normalizeAccountId(params.accountKey)) return false;
+	if (params.deviceId && metadata.deviceId && metadata.deviceId.trim() && metadata.deviceId.trim() !== params.deviceId.trim()) return false;
+	if (params.requireExplicitDeviceMatch && params.deviceId && (!metadata.deviceId || metadata.deviceId.trim() !== params.deviceId.trim())) return false;
+	return true;
+}
+function resolvePreferredMatrixStorageRoot(params) {
+	const parentDir = path.dirname(params.canonicalRootDir);
+	const bestCurrentScore = scoreStorageRoot(params.canonicalRootDir);
+	let best = {
+		rootDir: params.canonicalRootDir,
+		tokenHash: params.canonicalTokenHash,
+		score: bestCurrentScore,
+		mtimeMs: resolveStorageRootMtimeMs(params.canonicalRootDir)
+	};
+	if (!params.deviceId?.trim()) return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+	const canonicalMetadata = readStoredRootMetadata(params.canonicalRootDir);
+	if (canonicalMetadata.accessTokenHash === params.canonicalTokenHash && canonicalMetadata.deviceId?.trim() === params.deviceId.trim() && canonicalMetadata.currentTokenStateClaimed === true) return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+	let siblingEntries = [];
+	try {
+		siblingEntries = fs.readdirSync(parentDir, { withFileTypes: true });
+	} catch {
+		return {
+			rootDir: best.rootDir,
+			tokenHash: best.tokenHash
+		};
+	}
+	for (const entry of siblingEntries) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === params.canonicalTokenHash) continue;
+		const candidateRootDir = path.join(parentDir, entry.name);
+		if (!isCompatibleStorageRoot({
+			candidateRootDir,
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accountKey: params.accountKey,
+			deviceId: params.deviceId,
+			requireExplicitDeviceMatch: Boolean(params.deviceId)
+		})) continue;
+		const candidateScore = scoreStorageRoot(candidateRootDir);
+		if (candidateScore <= 0) continue;
+		const candidateMtimeMs = resolveStorageRootMtimeMs(candidateRootDir);
+		if (candidateScore > best.score || best.rootDir !== params.canonicalRootDir && candidateScore === best.score && candidateMtimeMs > best.mtimeMs) best = {
+			rootDir: candidateRootDir,
+			tokenHash: entry.name,
+			score: candidateScore,
+			mtimeMs: candidateMtimeMs
+		};
+	}
+	return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+}
+function resolveMatrixStoragePaths(params) {
+	const env = params.env ?? process.env;
+	const canonical = resolveMatrixAccountStorageRoot({
+		stateDir: params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir),
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accessToken: params.accessToken,
+		accountId: params.accountId
+	});
+	const { rootDir, tokenHash } = resolvePreferredMatrixStorageRoot({
+		canonicalRootDir: canonical.rootDir,
+		canonicalTokenHash: canonical.tokenHash,
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountKey: canonical.accountKey,
+		deviceId: params.deviceId
+	});
+	return {
+		rootDir,
+		storagePath: path.join(rootDir, "bot-storage.json"),
+		cryptoPath: path.join(rootDir, "crypto"),
+		metaPath: path.join(rootDir, STORAGE_META_FILENAME),
+		recoveryKeyPath: path.join(rootDir, "recovery-key.json"),
+		idbSnapshotPath: path.join(rootDir, IDB_SNAPSHOT_FILENAME),
+		accountKey: canonical.accountKey,
+		tokenHash
+	};
+}
+function resolveMatrixStateFilePath(params) {
+	const storagePaths = resolveMatrixStoragePaths({
+		homeserver: params.auth.homeserver,
+		userId: params.auth.userId,
+		accessToken: params.auth.accessToken,
+		accountId: params.accountId ?? params.auth.accountId,
+		deviceId: params.auth.deviceId,
+		env: params.env,
+		stateDir: params.stateDir
+	});
+	return path.join(storagePaths.rootDir, params.filename);
+}
+async function maybeMigrateLegacyStorage(params) {
+	const legacy = resolveLegacyStoragePaths(params.env);
+	const hasLegacyStorage = fs.existsSync(legacy.storagePath);
+	const hasLegacyCrypto = fs.existsSync(legacy.cryptoPath);
+	if (!hasLegacyStorage && !hasLegacyCrypto) return;
+	const hasTargetStorage = fs.existsSync(params.storagePaths.storagePath);
+	const hasTargetCrypto = fs.existsSync(params.storagePaths.cryptoPath);
+	const shouldMigrateStorage = hasLegacyStorage && !hasTargetStorage;
+	const shouldMigrateCrypto = hasLegacyCrypto && !hasTargetCrypto;
+	if (!shouldMigrateStorage && !shouldMigrateCrypto) return;
+	assertLegacyMigrationAccountSelection({ accountKey: params.storagePaths.accountKey });
+	const logger = getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" });
+	const { maybeCreateMatrixMigrationSnapshot } = await import("./migration-snapshot.runtime-BLcy_Nvw.js");
+	await maybeCreateMatrixMigrationSnapshot({
+		trigger: "matrix-client-fallback",
+		env: params.env,
+		log: logger
+	});
+	fs.mkdirSync(params.storagePaths.rootDir, { recursive: true });
+	const moved = [];
+	const skippedExistingTargets = [];
+	try {
+		if (shouldMigrateStorage) moveLegacyStoragePathOrThrow({
+			sourcePath: legacy.storagePath,
+			targetPath: params.storagePaths.storagePath,
+			label: "sync store",
+			moved
+		});
+		else if (hasLegacyStorage) skippedExistingTargets.push(`- sync store remains at ${legacy.storagePath} because ${params.storagePaths.storagePath} already exists`);
+		if (shouldMigrateCrypto) moveLegacyStoragePathOrThrow({
+			sourcePath: legacy.cryptoPath,
+			targetPath: params.storagePaths.cryptoPath,
+			label: "crypto store",
+			moved
+		});
+		else if (hasLegacyCrypto) skippedExistingTargets.push(`- crypto store remains at ${legacy.cryptoPath} because ${params.storagePaths.cryptoPath} already exists`);
+	} catch (err) {
+		const rollbackError = rollbackLegacyMoves(moved);
+		throw new Error(rollbackError ? `Failed migrating legacy Matrix client storage: ${String(err)}. Rollback also failed: ${rollbackError}` : `Failed migrating legacy Matrix client storage: ${String(err)}`, { cause: err });
+	}
+	if (moved.length > 0) logger.info(`matrix: migrated legacy client storage into ${params.storagePaths.rootDir}\n${moved.map((entry) => `- ${entry.label}: ${entry.sourcePath} -> ${entry.targetPath}`).join("\n")}`);
+	if (skippedExistingTargets.length > 0) logger.warn?.(`matrix: legacy client storage still exists in the flat path because some account-scoped targets already existed.\n${skippedExistingTargets.join("\n")}`);
+}
+function moveLegacyStoragePathOrThrow(params) {
+	if (!fs.existsSync(params.sourcePath)) return;
+	if (fs.existsSync(params.targetPath)) throw new Error(`legacy Matrix ${params.label} target already exists (${params.targetPath}); refusing to overwrite it automatically`);
+	fs.renameSync(params.sourcePath, params.targetPath);
+	params.moved.push({
+		sourcePath: params.sourcePath,
+		targetPath: params.targetPath,
+		label: params.label
+	});
+}
+function rollbackLegacyMoves(moved) {
+	for (const entry of moved.toReversed()) try {
+		if (!fs.existsSync(entry.targetPath) || fs.existsSync(entry.sourcePath)) continue;
+		fs.renameSync(entry.targetPath, entry.sourcePath);
+	} catch (err) {
+		return `${entry.label} (${entry.targetPath} -> ${entry.sourcePath}): ${String(err)}`;
+	}
+	return null;
+}
+function writeStoredRootMetadata(metaPath, payload) {
+	try {
+		saveJsonFile(metaPath, payload);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function writeStorageMeta(params) {
+	const existing = readStoredRootMetadata(params.storagePaths.rootDir);
+	return writeStoredRootMetadata(params.storagePaths.metaPath, {
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountId: params.accountId ?? DEFAULT_ACCOUNT_KEY,
+		accessTokenHash: params.storagePaths.tokenHash,
+		deviceId: params.deviceId ?? null,
+		currentTokenStateClaimed: params.currentTokenStateClaimed ?? existing.currentTokenStateClaimed === true,
+		createdAt: existing.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function claimCurrentTokenStorageState(params) {
+	const metadata = readStoredRootMetadata(params.rootDir);
+	if (!metadata.accessTokenHash?.trim()) return false;
+	return writeStoredRootMetadata(path.join(params.rootDir, STORAGE_META_FILENAME), {
+		homeserver: metadata.homeserver,
+		userId: metadata.userId,
+		accountId: metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
+		accessTokenHash: metadata.accessTokenHash,
+		deviceId: metadata.deviceId ?? null,
+		currentTokenStateClaimed: true,
+		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function repairCurrentTokenStorageMetaDeviceId(params) {
+	return writeStorageMeta({
+		storagePaths: resolveMatrixStoragePaths({
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accessToken: params.accessToken,
+			accountId: params.accountId,
+			env: params.env,
+			stateDir: params.stateDir
+		}),
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountId: params.accountId,
+		deviceId: params.deviceId
+	});
+}
+//#endregion
+export { resolveMatrixStoragePaths as a, resolveMatrixStateFilePath as i, maybeMigrateLegacyStorage as n, writeStorageMeta as o, repairCurrentTokenStorageMetaDeviceId as r, claimCurrentTokenStorageState as t };

package/dist/storage-paths-BTAketfg.js

@@ -0,0 +1,52 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
+import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region extensions/matrix/src/storage-paths.ts
+function sanitizeMatrixPathSegment(value) {
+	return normalizeLowercaseStringOrEmpty(value).replace(/[^a-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "unknown";
+}
+function resolveMatrixHomeserverKey(homeserver) {
+	try {
+		const url = new URL(homeserver);
+		if (url.host) return sanitizeMatrixPathSegment(url.host);
+	} catch {}
+	return sanitizeMatrixPathSegment(homeserver);
+}
+function hashMatrixAccessToken(accessToken) {
+	return crypto.createHash("sha256").update(accessToken).digest("hex").slice(0, 16);
+}
+function resolveMatrixCredentialsFilename(accountId) {
+	const normalized = normalizeAccountId(accountId);
+	return normalized === DEFAULT_ACCOUNT_ID ? "credentials.json" : `credentials-${normalized}.json`;
+}
+function resolveMatrixCredentialsDir(stateDir) {
+	return path.join(stateDir, "credentials", "matrix");
+}
+function resolveMatrixCredentialsPath(params) {
+	return path.join(resolveMatrixCredentialsDir(params.stateDir), resolveMatrixCredentialsFilename(params.accountId));
+}
+function resolveMatrixLegacyFlatStoreRoot(stateDir) {
+	return path.join(stateDir, "matrix");
+}
+function resolveMatrixLegacyFlatStoragePaths(stateDir) {
+	const rootDir = resolveMatrixLegacyFlatStoreRoot(stateDir);
+	return {
+		rootDir,
+		storagePath: path.join(rootDir, "bot-storage.json"),
+		cryptoPath: path.join(rootDir, "crypto")
+	};
+}
+function resolveMatrixAccountStorageRoot(params) {
+	const accountKey = sanitizeMatrixPathSegment(params.accountId ?? DEFAULT_ACCOUNT_ID);
+	const userKey = sanitizeMatrixPathSegment(params.userId);
+	const serverKey = resolveMatrixHomeserverKey(params.homeserver);
+	const tokenHash = hashMatrixAccessToken(params.accessToken);
+	return {
+		rootDir: path.join(params.stateDir, "matrix", "accounts", accountKey, `${serverKey}__${userKey}`, tokenHash),
+		accountKey,
+		tokenHash
+	};
+}
+//#endregion
+export { resolveMatrixCredentialsPath as a, resolveMatrixLegacyFlatStoreRoot as c, resolveMatrixCredentialsFilename as i, sanitizeMatrixPathSegment as l, resolveMatrixAccountStorageRoot as n, resolveMatrixHomeserverKey as o, resolveMatrixCredentialsDir as r, resolveMatrixLegacyFlatStoragePaths as s, hashMatrixAccessToken as t };