@openclaw/matrix 2026.6.5-beta.2 → 2026.6.5-beta.3

package/dist/crypto-state-store-DK2tcEyP.js

@@ -0,0 +1,352 @@
+import { o as isRecord } from "./account-selection-Bv_ZuOu4.js";
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+//#region extensions/matrix/src/matrix/sqlite-state.ts
+function resolveStateDirOverride(options) {
+	if (!options) return;
+	if (options.stateDir) return options.stateDir;
+	if (options.stateRootDir) return options.stateRootDir;
+	return getMatrixRuntime().state.resolveStateDir(options.env ?? process.env, os.homedir);
+}
+function resolveMatrixSqliteStateKey(options) {
+	return resolveStateDirOverride(options) ?? "";
+}
+function resolveMatrixSqliteStateEnv(options) {
+	const stateDir = resolveStateDirOverride(options);
+	if (!stateDir) return options?.env;
+	return {
+		...options?.env ?? process.env,
+		OPENCLAW_STATE_DIR: stateDir
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/crypto-state-store.ts
+const STATE_KEY = "current";
+const RECOVERY_KEY_NAMESPACE = "recovery-key";
+const LEGACY_CRYPTO_MIGRATION_NAMESPACE = "legacy-crypto-migration";
+const IDB_SNAPSHOT_NAMESPACE = "idb-snapshot";
+const SMALL_STATE_MAX_ENTRIES = 10;
+const IDB_SNAPSHOT_MAX_ENTRIES = 2e4;
+const IDB_SNAPSHOT_MAX_CHUNKS = Math.floor((IDB_SNAPSHOT_MAX_ENTRIES - 1) / 2);
+const IDB_SNAPSHOT_CHUNK_BYTES = 24e3;
+const MATRIX_RECOVERY_KEY_FILENAME = "recovery-key.json";
+const MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME = "legacy-crypto-migration.json";
+const MATRIX_IDB_SNAPSHOT_FILENAME = "crypto-idb-snapshot.json";
+function openMatrixRecoveryKeyStoreOptions(storageRootDir) {
+	return {
+		namespace: RECOVERY_KEY_NAMESPACE,
+		maxEntries: SMALL_STATE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir) {
+	return {
+		namespace: LEGACY_CRYPTO_MIGRATION_NAMESPACE,
+		maxEntries: SMALL_STATE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function openMatrixIdbSnapshotStoreOptions(storageRootDir) {
+	return {
+		namespace: IDB_SNAPSHOT_NAMESPACE,
+		maxEntries: IDB_SNAPSHOT_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function readMatrixRecoveryKeyState(storageRootDir) {
+	return readMatrixRecoveryKeyStateWithKey({
+		storageRootDir,
+		stateKey: STATE_KEY
+	});
+}
+function readMatrixRecoveryKeyStateForPath(recoveryKeyPath) {
+	return readMatrixRecoveryKeyStateWithKey({
+		storageRootDir: path.dirname(recoveryKeyPath),
+		stateKey: resolveRecoveryKeyStateKeyForPath(recoveryKeyPath)
+	});
+}
+function readMatrixRecoveryKeyStateWithKey(params) {
+	return normalizeMatrixStoredRecoveryKey(openSyncStore(openMatrixRecoveryKeyStoreOptions(params.storageRootDir)).lookup(params.stateKey));
+}
+function writeMatrixRecoveryKeyState(params) {
+	writeMatrixRecoveryKeyStateWithKey({
+		storageRootDir: params.storageRootDir,
+		stateKey: STATE_KEY,
+		payload: params.payload
+	});
+}
+function writeMatrixRecoveryKeyStateForPath(params) {
+	writeMatrixRecoveryKeyStateWithKey({
+		storageRootDir: path.dirname(params.recoveryKeyPath),
+		stateKey: resolveRecoveryKeyStateKeyForPath(params.recoveryKeyPath),
+		payload: params.payload
+	});
+}
+function writeMatrixRecoveryKeyStateWithKey(params) {
+	const payload = normalizeMatrixStoredRecoveryKey(params.payload);
+	if (!payload) throw new Error("Invalid Matrix recovery key state");
+	openSyncStore(openMatrixRecoveryKeyStoreOptions(params.storageRootDir)).register(params.stateKey, payload);
+}
+async function hasMatrixRecoveryKeyStateInStore(params) {
+	return normalizeMatrixStoredRecoveryKey(await params.store.lookup(STATE_KEY)) !== null;
+}
+async function writeMatrixRecoveryKeyStateToStore(params) {
+	const payload = normalizeMatrixStoredRecoveryKey(params.payload);
+	if (!payload) throw new Error("Invalid Matrix recovery key state");
+	await params.store.register(STATE_KEY, payload);
+}
+function readMatrixLegacyCryptoMigrationState(storageRootDir) {
+	return normalizeMatrixLegacyCryptoMigrationState(openSyncStore(openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir)).lookup(STATE_KEY));
+}
+function writeMatrixLegacyCryptoMigrationState(params) {
+	const state = normalizeMatrixLegacyCryptoMigrationState(params.state);
+	if (!state) throw new Error("Invalid Matrix legacy crypto migration state");
+	openSyncStore(openMatrixLegacyCryptoMigrationStoreOptions(params.storageRootDir)).register(STATE_KEY, state);
+}
+async function hasMatrixLegacyCryptoMigrationStateInStore(params) {
+	return normalizeMatrixLegacyCryptoMigrationState(await params.store.lookup(STATE_KEY)) !== null;
+}
+async function writeMatrixLegacyCryptoMigrationStateToStore(params) {
+	const state = normalizeMatrixLegacyCryptoMigrationState(params.state);
+	if (!state) throw new Error("Invalid Matrix legacy crypto migration state");
+	await params.store.register(STATE_KEY, state);
+}
+function readMatrixIdbSnapshotJson(storageRootDir) {
+	return readIdbSnapshotJsonFromStore(openSyncStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)));
+}
+function hasMatrixIdbSnapshotState(storageRootDir) {
+	return isIdbSnapshotMeta(openSyncStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)).lookup(idbMetaKey()));
+}
+function writeMatrixIdbSnapshotJson(params) {
+	writeIdbSnapshotJsonToStore({
+		snapshotJson: params.snapshotJson,
+		databaseCount: params.databaseCount,
+		store: openSyncStore(openMatrixIdbSnapshotStoreOptions(params.storageRootDir))
+	});
+}
+async function hasMatrixIdbSnapshotStateInStore(params) {
+	return await readIdbSnapshotJsonFromAsyncStore(params.store) !== null;
+}
+async function writeMatrixIdbSnapshotJsonToStore(params) {
+	const rows = buildIdbSnapshotRows(params.snapshotJson, params.databaseCount);
+	for (const row of rows.chunks) await params.store.register(row.key, row.value);
+	await params.store.register(rows.meta.key, rows.meta.value);
+	for (const row of await params.store.entries()) if (row.key.startsWith(idbChunkKeyPrefix()) && !rows.nextChunkKeys.has(row.key)) await params.store.delete(row.key);
+}
+function migrateLegacyMatrixRecoveryKeyFileToStore(storageRootDir) {
+	return migrateLegacyMatrixRecoveryKeyFilePathToStore(path.join(storageRootDir, MATRIX_RECOVERY_KEY_FILENAME));
+}
+function migrateLegacyMatrixRecoveryKeyFilePathToStore(recoveryKeyPath) {
+	const existing = readMatrixRecoveryKeyStateForPath(recoveryKeyPath);
+	const legacy = readLegacyMatrixRecoveryKeyFile(recoveryKeyPath);
+	if (!existing && legacy) writeMatrixRecoveryKeyStateForPath({
+		recoveryKeyPath,
+		payload: legacy
+	});
+	return archiveLegacyStateFileIfPossible(recoveryKeyPath);
+}
+function migrateLegacyMatrixLegacyCryptoMigrationFileToStore(storageRootDir) {
+	const existing = readMatrixLegacyCryptoMigrationState(storageRootDir);
+	const legacy = readLegacyMatrixLegacyCryptoMigrationState(storageRootDir);
+	if (!existing && legacy) writeMatrixLegacyCryptoMigrationState({
+		storageRootDir,
+		state: legacy
+	});
+	return archiveLegacyStateFileIfPossible(path.join(storageRootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
+}
+function readLegacyMatrixRecoveryKeyState(storageRootDir) {
+	return readLegacyMatrixRecoveryKeyFile(path.join(storageRootDir, MATRIX_RECOVERY_KEY_FILENAME));
+}
+function readLegacyMatrixRecoveryKeyFile(filePath) {
+	return readJsonFileSync(filePath, normalizeMatrixStoredRecoveryKey);
+}
+function readLegacyMatrixLegacyCryptoMigrationState(storageRootDir) {
+	return readJsonFileSync(path.join(storageRootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME), normalizeMatrixLegacyCryptoMigrationState);
+}
+function scoreMatrixCryptoStateInStore(storageRootDir) {
+	if (!matrixCryptoStateDatabaseExists(storageRootDir)) return 0;
+	let score = 0;
+	try {
+		if (readMatrixLegacyCryptoMigrationState(storageRootDir)) score += 3;
+	} catch {}
+	try {
+		if (readMatrixRecoveryKeyState(storageRootDir)) score += 2;
+	} catch {}
+	try {
+		if (hasMatrixIdbSnapshotState(storageRootDir)) score += 2;
+	} catch {}
+	return score;
+}
+function matrixCryptoStateDatabaseExists(storageRootDir) {
+	return fs.existsSync(path.join(storageRootDir, "state", "openclaw.sqlite"));
+}
+function resolveRecoveryKeyStateKeyForPath(recoveryKeyPath) {
+	const basename = path.basename(recoveryKeyPath);
+	if (basename === "recovery-key.json") return STATE_KEY;
+	return `file:${createHash("sha256").update(basename, "utf8").digest("hex").slice(0, 32)}`;
+}
+function normalizeMatrixStoredRecoveryKey(value) {
+	if (!isRecord(value) || value.version !== 1 || typeof value.createdAt !== "string" || typeof value.privateKeyBase64 !== "string" || !value.privateKeyBase64.trim()) return null;
+	return {
+		version: 1,
+		createdAt: value.createdAt,
+		keyId: typeof value.keyId === "string" ? value.keyId : null,
+		...typeof value.encodedPrivateKey === "string" ? { encodedPrivateKey: value.encodedPrivateKey } : {},
+		privateKeyBase64: value.privateKeyBase64,
+		...isRecord(value.keyInfo) ? { keyInfo: {
+			...value.keyInfo.passphrase !== void 0 ? { passphrase: value.keyInfo.passphrase } : {},
+			...typeof value.keyInfo.name === "string" ? { name: value.keyInfo.name } : {}
+		} } : {}
+	};
+}
+function normalizeMatrixLegacyCryptoMigrationState(value) {
+	if (!isRecord(value) || value.version !== 1 || typeof value.accountId !== "string") return null;
+	if (value.restoreStatus !== "pending" && value.restoreStatus !== "completed" && value.restoreStatus !== "manual-action-required") return null;
+	const roomKeyCounts = isRecord(value.roomKeyCounts) && typeof value.roomKeyCounts.total === "number" && typeof value.roomKeyCounts.backedUp === "number" ? {
+		total: value.roomKeyCounts.total,
+		backedUp: value.roomKeyCounts.backedUp
+	} : null;
+	return {
+		version: 1,
+		...value.source === "matrix-bot-sdk-rust" ? { source: value.source } : {},
+		accountId: value.accountId,
+		...typeof value.deviceId === "string" || value.deviceId === null ? { deviceId: value.deviceId } : {},
+		roomKeyCounts,
+		...typeof value.backupVersion === "string" || value.backupVersion === null ? { backupVersion: value.backupVersion } : {},
+		...typeof value.decryptionKeyImported === "boolean" ? { decryptionKeyImported: value.decryptionKeyImported } : {},
+		restoreStatus: value.restoreStatus,
+		...typeof value.detectedAt === "string" ? { detectedAt: value.detectedAt } : {},
+		...typeof value.restoredAt === "string" ? { restoredAt: value.restoredAt } : {},
+		...typeof value.importedCount === "number" ? { importedCount: value.importedCount } : {},
+		...typeof value.totalCount === "number" ? { totalCount: value.totalCount } : {},
+		...typeof value.lastError === "string" || value.lastError === null ? { lastError: value.lastError } : {}
+	};
+}
+function openSyncStore(options) {
+	return getMatrixRuntime().state.openSyncKeyedStore(options);
+}
+function readJsonFileSync(filePath, normalize) {
+	try {
+		return normalize(JSON.parse(fs.readFileSync(filePath, "utf8")));
+	} catch {
+		return null;
+	}
+}
+function archiveLegacyStateFileIfPossible(filePath) {
+	if (!fs.existsSync(filePath)) return false;
+	const archivedPath = `${filePath}.migrated`;
+	if (fs.existsSync(archivedPath)) return false;
+	fs.renameSync(filePath, archivedPath);
+	return true;
+}
+function readIdbSnapshotJsonFromStore(store) {
+	const meta = store.lookup(idbMetaKey());
+	if (!isIdbSnapshotMeta(meta)) return null;
+	const chunks = readIdbSnapshotChunks(meta, (key) => store.lookup(key));
+	return chunks ? chunks.join("") : null;
+}
+async function readIdbSnapshotJsonFromAsyncStore(store) {
+	const meta = await store.lookup(idbMetaKey());
+	if (!isIdbSnapshotMeta(meta)) return null;
+	const chunks = await readIdbSnapshotChunksAsync(meta, (key) => store.lookup(key));
+	return chunks ? chunks.join("") : null;
+}
+function readIdbSnapshotChunks(meta, lookup) {
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = lookup(idbChunkKey(meta.generation, index));
+		if (!isIdbSnapshotChunk(chunk) || chunk.index !== index) return null;
+		chunks.push(chunk.data);
+	}
+	const snapshotJson = chunks.join("");
+	if (meta.digest !== digestText(snapshotJson)) return null;
+	return chunks;
+}
+async function readIdbSnapshotChunksAsync(meta, lookup) {
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = await lookup(idbChunkKey(meta.generation, index));
+		if (!isIdbSnapshotChunk(chunk) || chunk.index !== index) return null;
+		chunks.push(chunk.data);
+	}
+	const snapshotJson = chunks.join("");
+	if (meta.digest !== digestText(snapshotJson)) return null;
+	return chunks;
+}
+function writeIdbSnapshotJsonToStore(params) {
+	const rows = buildIdbSnapshotRows(params.snapshotJson, params.databaseCount);
+	for (const row of rows.chunks) params.store.register(row.key, row.value);
+	params.store.register(rows.meta.key, rows.meta.value);
+	for (const row of params.store.entries()) if (row.key.startsWith(idbChunkKeyPrefix()) && !rows.nextChunkKeys.has(row.key)) params.store.delete(row.key);
+}
+function buildIdbSnapshotRows(snapshotJson, databaseCount) {
+	const generation = randomUUID().replaceAll("-", "");
+	const chunks = chunkText(snapshotJson).map((data, index) => ({
+		key: idbChunkKey(generation, index),
+		value: {
+			kind: "snapshot-chunk",
+			index,
+			data
+		}
+	}));
+	return {
+		chunks,
+		nextChunkKeys: new Set(chunks.map((chunk) => chunk.key)),
+		meta: {
+			key: idbMetaKey(),
+			value: {
+				kind: "meta",
+				version: 1,
+				generation,
+				chunkCount: chunks.length,
+				digest: digestText(snapshotJson),
+				databaseCount,
+				persistedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		}
+	};
+}
+function idbMetaKey() {
+	return `${STATE_KEY}:meta`;
+}
+function idbChunkKeyPrefix() {
+	return `${STATE_KEY}:snapshot:`;
+}
+function idbChunkKey(generation, index) {
+	return `${idbChunkKeyPrefix()}${generation}:${index}`;
+}
+function chunkText(value) {
+	const chunks = [];
+	let current = "";
+	let currentBytes = 0;
+	for (const char of value) {
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (current && currentBytes + charBytes > IDB_SNAPSHOT_CHUNK_BYTES) {
+			pushChunk(chunks, current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += char;
+		currentBytes += charBytes;
+	}
+	if (current) pushChunk(chunks, current);
+	return chunks;
+}
+function pushChunk(chunks, chunk) {
+	if (chunks.length >= IDB_SNAPSHOT_MAX_CHUNKS) throw new Error("Matrix IndexedDB snapshot exceeds SQLite chunk limit");
+	chunks.push(chunk);
+}
+function digestText(value) {
+	return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function isIdbSnapshotMeta(value) {
+	return isRecord(value) && value.kind === "meta" && value.version === 1 && typeof value.generation === "string" && value.generation.trim() !== "" && typeof value.chunkCount === "number" && Number.isSafeInteger(value.chunkCount) && value.chunkCount >= 0 && value.chunkCount <= IDB_SNAPSHOT_MAX_CHUNKS && typeof value.digest === "string" && typeof value.databaseCount === "number" && Number.isSafeInteger(value.databaseCount) && value.databaseCount >= 0 && typeof value.persistedAt === "string";
+}
+function isIdbSnapshotChunk(value) {
+	return isRecord(value) && value.kind === "snapshot-chunk" && typeof value.index === "number" && Number.isSafeInteger(value.index) && value.index >= 0 && typeof value.data === "string";
+}
+//#endregion
+export { writeMatrixLegacyCryptoMigrationState as C, writeMatrixRecoveryKeyStateToStore as D, writeMatrixRecoveryKeyStateForPath as E, resolveMatrixSqliteStateEnv as O, writeMatrixIdbSnapshotJsonToStore as S, writeMatrixRecoveryKeyState as T, readMatrixLegacyCryptoMigrationState as _, hasMatrixLegacyCryptoMigrationStateInStore as a, scoreMatrixCryptoStateInStore as b, migrateLegacyMatrixRecoveryKeyFilePathToStore as c, openMatrixLegacyCryptoMigrationStoreOptions as d, openMatrixRecoveryKeyStoreOptions as f, readMatrixIdbSnapshotJson as g, readLegacyMatrixRecoveryKeyState as h, hasMatrixIdbSnapshotStateInStore as i, resolveMatrixSqliteStateKey as k, migrateLegacyMatrixRecoveryKeyFileToStore as l, readLegacyMatrixRecoveryKeyFile as m, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME as n, hasMatrixRecoveryKeyStateInStore as o, readLegacyMatrixLegacyCryptoMigrationState as p, MATRIX_RECOVERY_KEY_FILENAME as r, migrateLegacyMatrixLegacyCryptoMigrationFileToStore as s, MATRIX_IDB_SNAPSHOT_FILENAME as t, openMatrixIdbSnapshotStoreOptions as u, readMatrixRecoveryKeyState as v, writeMatrixLegacyCryptoMigrationStateToStore as w, writeMatrixIdbSnapshotJson as x, readMatrixRecoveryKeyStateForPath as y };

package/dist/{directory-live-5uWtLQ41.js → directory-live-C7aYHtRU.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-B-5aQxwn.js";
-import { g as resolveMatrixAuth } from "./shared-BbT5LdPp.js";
-import "./client-DRRL7Zv5.js";
+import { f as resolveMatrixAuth } from "./shared-Bk7pOHMb.js";
+import "./client-dLfa0qNk.js";
 import { t as MatrixAuthedHttpClient } from "./http-client-nipb5tk1.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/directory-live.ts

package/dist/{doctor-BKjr6uua.js → doctor-BwpkOBwr.js}

@@ -1,6 +1,6 @@
-import { t as isRecord } from "./record-shared-CvzjvHRn.js";
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-D9oKDvsJ.js";
-import { i as autoPrepareLegacyMatrixCrypto, o as autoMigrateLegacyMatrixState, r as resolveMatrixMigrationStatus } from "./matrix-migration.runtime-RzIEp7RP.js";
+import { o as isRecord } from "./account-selection-Bv_ZuOu4.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-Dq8OZWHF.js";
+import { i as autoPrepareLegacyMatrixCrypto, o as autoMigrateLegacyMatrixState, r as resolveMatrixMigrationStatus } from "./matrix-migration.runtime-dvxE3e5l.js";
 import { t as maybeCreateMatrixMigrationSnapshot } from "./migration-snapshot-backup-YcCrSjbE.js";
 import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "openclaw/plugin-sdk/runtime-doctor";
 //#region extensions/matrix/src/doctor.ts
@@ -32,8 +32,8 @@ function formatMatrixLegacyCryptoPreview(detection) {
 	for (const plan of detection.plans) notes.push([
 		`- Matrix encrypted-state migration is pending for account "${plan.accountId}".`,
 		`- Legacy crypto store: ${plan.legacyCryptoPath}`,
-		`- New recovery key file: ${plan.recoveryKeyPath}`,
-		`- Migration state file: ${plan.statePath}`,
+		`- Recovery key state: Matrix SQLite state (imports ${plan.recoveryKeyPath} if present)`,
+		`- Migration state: Matrix SQLite state (imports ${plan.statePath} if present)`,
 		"- Run \"openclaw doctor --fix\" to extract any saved backup key now. Backed-up room keys will restore automatically on next gateway start."
 	].join("\n"));
 	return notes;

package/dist/{doctor-contract-D9oKDvsJ.js → doctor-contract-Dq8OZWHF.js}

@@ -1,4 +1,4 @@
-import { t as isRecord } from "./record-shared-CvzjvHRn.js";
+import { o as isRecord } from "./account-selection-Bv_ZuOu4.js";
 import { hasLegacyFlatAllowPrivateNetworkAlias, migrateLegacyFlatAllowPrivateNetworkAlias } from "openclaw/plugin-sdk/ssrf-runtime";
 //#region extensions/matrix/src/doctor-contract.ts
 function hasLegacyMatrixRoomAllowAlias(value) {

package/dist/doctor-contract-api.js

@@ -1,2 +1,265 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-D9oKDvsJ.js";
-export { legacyConfigRules, normalizeCompatibilityConfig };
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-Dq8OZWHF.js";
+import { D as writeMatrixRecoveryKeyStateToStore, S as writeMatrixIdbSnapshotJsonToStore, a as hasMatrixLegacyCryptoMigrationStateInStore, d as openMatrixLegacyCryptoMigrationStoreOptions, f as openMatrixRecoveryKeyStoreOptions, h as readLegacyMatrixRecoveryKeyState, i as hasMatrixIdbSnapshotStateInStore, n as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, o as hasMatrixRecoveryKeyStateInStore, p as readLegacyMatrixLegacyCryptoMigrationState, r as MATRIX_RECOVERY_KEY_FILENAME, t as MATRIX_IDB_SNAPSHOT_FILENAME, u as openMatrixIdbSnapshotStoreOptions, w as writeMatrixLegacyCryptoMigrationStateToStore } from "./crypto-state-store-DK2tcEyP.js";
+import { a as readLegacyMatrixSyncCacheState, i as openMatrixSyncCacheStoreOptions, o as writeMatrixSyncCacheStateToStore, r as hasMatrixSyncCacheStateInStore } from "./file-sync-store-Ni-pkFde.js";
+import { r as readLegacyMatrixIdbSnapshotState } from "./idb-persistence-BGY1CJ7J.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region extensions/matrix/doctor-contract-api.ts
+const MATRIX_SYNC_CACHE_FILENAME = "bot-storage.json";
+async function fileExists(filePath) {
+	try {
+		return (await fs.stat(filePath)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function collectLegacyMatrixStateRoots(stateDir, filename) {
+	const matrixRoot = path.join(stateDir, "matrix");
+	const roots = [];
+	async function visit(dir) {
+		let entries;
+		try {
+			entries = await fs.readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const entryPath = path.join(dir, entry.name);
+			if (entry.isFile() && entry.name === filename) {
+				roots.push(dir);
+				continue;
+			}
+			if (entry.isDirectory()) await visit(entryPath);
+		}
+	}
+	await visit(matrixRoot);
+	return roots.filter((root) => path.resolve(root) !== path.resolve(matrixRoot)).toSorted();
+}
+async function collectLegacySyncCacheRoots(stateDir) {
+	return collectLegacyMatrixStateRoots(stateDir, MATRIX_SYNC_CACHE_FILENAME);
+}
+async function archiveLegacySyncCache(params) {
+	const sourcePath = path.join(params.storageRootDir, MATRIX_SYNC_CACHE_FILENAME);
+	const archivedPath = `${sourcePath}.migrated`;
+	if (await fileExists(archivedPath)) {
+		params.warnings.push(`Left migrated Matrix sync cache in place because ${archivedPath} already exists`);
+		return;
+	}
+	try {
+		await fs.rename(sourcePath, archivedPath);
+		params.changes.push(`Archived Matrix sync cache legacy source -> ${archivedPath}`);
+	} catch (err) {
+		params.warnings.push(`Failed archiving Matrix sync cache legacy source: ${String(err)}`);
+	}
+}
+async function archiveLegacyMatrixStateFile(params) {
+	const sourcePath = path.join(params.storageRootDir, params.filename);
+	const archivedPath = `${sourcePath}.migrated`;
+	if (await fileExists(archivedPath)) {
+		params.warnings.push(`Left migrated ${params.label} in place because ${archivedPath} already exists`);
+		return;
+	}
+	try {
+		await fs.rename(sourcePath, archivedPath);
+		params.changes.push(`Archived ${params.label} legacy source -> ${archivedPath}`);
+	} catch (err) {
+		params.warnings.push(`Failed archiving ${params.label} legacy source: ${String(err)}`);
+	}
+}
+const stateMigrations = [
+	{
+		id: "matrix-sync-cache-json-to-plugin-state",
+		label: "Matrix sync cache",
+		async detectLegacyState(params) {
+			const previews = [];
+			for (const storageRootDir of await collectLegacySyncCacheRoots(params.stateDir)) {
+				if (!await readLegacyMatrixSyncCacheState(storageRootDir)) continue;
+				previews.push(`Matrix sync cache JSON can migrate to SQLite: ${storageRootDir}`);
+			}
+			return previews.length > 0 ? { preview: previews } : null;
+		},
+		async migrateLegacyState(params) {
+			const changes = [];
+			const warnings = [];
+			for (const storageRootDir of await collectLegacySyncCacheRoots(params.stateDir)) {
+				const persisted = await readLegacyMatrixSyncCacheState(storageRootDir);
+				if (!persisted) continue;
+				const store = params.context.openPluginStateKeyedStore(openMatrixSyncCacheStoreOptions(storageRootDir));
+				if (await hasMatrixSyncCacheStateInStore({
+					storageRootDir,
+					store
+				})) {
+					warnings.push(`Skipped Matrix sync cache import for ${storageRootDir} because SQLite already has sync cache state`);
+					await archiveLegacySyncCache({
+						storageRootDir,
+						changes,
+						warnings
+					});
+					continue;
+				}
+				await writeMatrixSyncCacheStateToStore({
+					storageRootDir,
+					payload: persisted,
+					store
+				});
+				changes.push(`Migrated Matrix sync cache JSON to SQLite for ${storageRootDir}`);
+				await archiveLegacySyncCache({
+					storageRootDir,
+					changes,
+					warnings
+				});
+			}
+			return {
+				changes,
+				warnings
+			};
+		}
+	},
+	{
+		id: "matrix-recovery-key-json-to-plugin-state",
+		label: "Matrix recovery key",
+		async detectLegacyState(params) {
+			const previews = [];
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_RECOVERY_KEY_FILENAME)) {
+				if (!readLegacyMatrixRecoveryKeyState(storageRootDir)) continue;
+				previews.push(`Matrix recovery-key JSON can migrate to SQLite: ${storageRootDir}`);
+			}
+			return previews.length > 0 ? { preview: previews } : null;
+		},
+		async migrateLegacyState(params) {
+			const changes = [];
+			const warnings = [];
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_RECOVERY_KEY_FILENAME)) {
+				const payload = readLegacyMatrixRecoveryKeyState(storageRootDir);
+				if (!payload) continue;
+				const store = params.context.openPluginStateKeyedStore(openMatrixRecoveryKeyStoreOptions(storageRootDir));
+				if (await hasMatrixRecoveryKeyStateInStore({ store })) {
+					warnings.push(`Skipped Matrix recovery-key import for ${storageRootDir} because SQLite already has recovery-key state`);
+					await archiveLegacyMatrixStateFile({
+						storageRootDir,
+						filename: MATRIX_RECOVERY_KEY_FILENAME,
+						label: "Matrix recovery key",
+						changes,
+						warnings
+					});
+					continue;
+				}
+				await writeMatrixRecoveryKeyStateToStore({
+					payload,
+					store
+				});
+				changes.push(`Migrated Matrix recovery-key JSON to SQLite for ${storageRootDir}`);
+				await archiveLegacyMatrixStateFile({
+					storageRootDir,
+					filename: MATRIX_RECOVERY_KEY_FILENAME,
+					label: "Matrix recovery key",
+					changes,
+					warnings
+				});
+			}
+			return {
+				changes,
+				warnings
+			};
+		}
+	},
+	{
+		id: "matrix-idb-snapshot-json-to-plugin-state",
+		label: "Matrix IndexedDB snapshot",
+		async detectLegacyState(params) {
+			const previews = [];
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME)) {
+				if (!await readLegacyMatrixIdbSnapshotState(storageRootDir)) continue;
+				previews.push(`Matrix IndexedDB snapshot JSON can migrate to SQLite: ${storageRootDir}`);
+			}
+			return previews.length > 0 ? { preview: previews } : null;
+		},
+		async migrateLegacyState(params) {
+			const changes = [];
+			const warnings = [];
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME)) {
+				const snapshot = await readLegacyMatrixIdbSnapshotState(storageRootDir);
+				if (!snapshot) continue;
+				const store = params.context.openPluginStateKeyedStore(openMatrixIdbSnapshotStoreOptions(storageRootDir));
+				if (await hasMatrixIdbSnapshotStateInStore({ store })) {
+					warnings.push(`Skipped Matrix IndexedDB snapshot import for ${storageRootDir} because SQLite already has snapshot state`);
+					await archiveLegacyMatrixStateFile({
+						storageRootDir,
+						filename: MATRIX_IDB_SNAPSHOT_FILENAME,
+						label: "Matrix IndexedDB snapshot",
+						changes,
+						warnings
+					});
+					continue;
+				}
+				await writeMatrixIdbSnapshotJsonToStore({
+					snapshotJson: JSON.stringify(snapshot),
+					databaseCount: snapshot.length,
+					store
+				});
+				changes.push(`Migrated Matrix IndexedDB snapshot JSON to SQLite for ${storageRootDir}`);
+				await archiveLegacyMatrixStateFile({
+					storageRootDir,
+					filename: MATRIX_IDB_SNAPSHOT_FILENAME,
+					label: "Matrix IndexedDB snapshot",
+					changes,
+					warnings
+				});
+			}
+			return {
+				changes,
+				warnings
+			};
+		}
+	},
+	{
+		id: "matrix-legacy-crypto-migration-json-to-plugin-state",
+		label: "Matrix legacy crypto migration",
+		async detectLegacyState(params) {
+			const previews = [];
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME)) {
+				if (!readLegacyMatrixLegacyCryptoMigrationState(storageRootDir)) continue;
+				previews.push(`Matrix legacy crypto migration JSON can migrate to SQLite: ${storageRootDir}`);
+			}
+			return previews.length > 0 ? { preview: previews } : null;
+		},
+		async migrateLegacyState(params) {
+			const changes = [];
+			const warnings = [];
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME)) {
+				const state = readLegacyMatrixLegacyCryptoMigrationState(storageRootDir);
+				if (!state) continue;
+				const store = params.context.openPluginStateKeyedStore(openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir));
+				if (await hasMatrixLegacyCryptoMigrationStateInStore({ store })) {
+					warnings.push(`Skipped Matrix legacy crypto migration import for ${storageRootDir} because SQLite already has migration state`);
+					await archiveLegacyMatrixStateFile({
+						storageRootDir,
+						filename: MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME,
+						label: "Matrix legacy crypto migration",
+						changes,
+						warnings
+					});
+					continue;
+				}
+				await writeMatrixLegacyCryptoMigrationStateToStore({
+					state,
+					store
+				});
+				changes.push(`Migrated Matrix legacy crypto migration JSON to SQLite for ${storageRootDir}`);
+				await archiveLegacyMatrixStateFile({
+					storageRootDir,
+					filename: MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME,
+					label: "Matrix legacy crypto migration",
+					changes,
+					warnings
+				});
+			}
+			return {
+				changes,
+				warnings
+			};
+		}
+	}
+];
+//#endregion
+export { legacyConfigRules, normalizeCompatibilityConfig, stateMigrations };

package/dist/{draft-stream-DZ2X1RHP.js → draft-stream-PqFfvyV9.js}

@@ -1,4 +1,4 @@
-import { n as editMessageMatrix, r as prepareMatrixSingleText, s as sendSingleTextMessageMatrix, y as MsgType } from "./send-DEgWxp1p.js";
+import { n as editMessageMatrix, r as prepareMatrixSingleText, s as sendSingleTextMessageMatrix, y as MsgType } from "./send-Bus9xhUh.js";
 import { createDraftStreamLoop } from "openclaw/plugin-sdk/channel-outbound";
 //#region extensions/matrix/src/matrix/draft-stream.ts
 const DEFAULT_THROTTLE_MS = 1e3;

package/dist/{encryption-guidance-aEUzD940.js → encryption-guidance-D_KhjprO.js}

@@ -1,4 +1,4 @@
-import { a as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-DEMtY2cn.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-Bv_ZuOu4.js";
 import { t as resolveMatrixConfigFieldPath } from "./config-paths-ZBCMwSos.js";
 import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/encryption-guidance.ts