@openclaw/matrix 2026.9.5 → 2026.9.6

package/dist/.setup/{storage-DJ-oUgmX.mjs → storage-BXaFc0S4.mjs}

@@ -1,6 +1,6 @@
 import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
 import { n as isMatrixActiveTokenRootDirectory, r as resolveMatrixAccountStorageRoot } from "./storage-paths-DVCANXTc.mjs";
-import { C as scoreMatrixCryptoStateInStore, c as MATRIX_RECOVERY_KEY_FILENAME, d as migrateLegacyMatrixLegacyCryptoMigrationFileToStore, i as openMatrixStorageMetaStoreOptions, o as MATRIX_IDB_SNAPSHOT_FILENAME, p as migrateLegacyMatrixRecoveryKeyFileToStore, r as normalizeMatrixStorageMetadata, s as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, t as STORAGE_META_STATE_KEY } from "./storage-metadata-BQJjHC_i.mjs";
+import { S as scoreMatrixCryptoStateInStore, c as MATRIX_RECOVERY_KEY_FILENAME, d as migrateLegacyMatrixLegacyCryptoMigrationFileToStore, f as migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync, i as openMatrixStorageMetaStoreOptions, o as MATRIX_IDB_SNAPSHOT_FILENAME, r as normalizeMatrixStorageMetadata, s as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, t as STORAGE_META_STATE_KEY } from "./storage-metadata-fHN6Df2m.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import path from "node:path";
 import fs from "node:fs";
@@ -11,9 +11,9 @@ const DEFAULT_ACCOUNT_KEY = "default";
 const STORAGE_META_FILENAME = "storage-meta.json";
 const THREAD_BINDINGS_FILENAME = "thread-bindings.json";
 function openStorageMetaStore(rootDir) {
-	return getMatrixRuntime().state.openSyncKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
+	return getMatrixRuntime().state.openKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
 }
-function scoreStorageRoot(rootDir, metadata = readStoredRootMetadata(rootDir)) {
+async function scoreStorageRoot(rootDir, metadata) {
 	let score = 0;
 	if (Object.keys(metadata).length > 0) score += 1;
 	if (metadata.currentTokenStateClaimed === true) score += 8;
@@ -22,7 +22,7 @@ function scoreStorageRoot(rootDir, metadata = readStoredRootMetadata(rootDir)) {
 	if (fs.existsSync(path.join(rootDir, "legacy-crypto-migration.json"))) score += 3;
 	if (fs.existsSync(path.join(rootDir, "recovery-key.json"))) score += 2;
 	if (fs.existsSync(path.join(rootDir, "crypto-idb-snapshot.json"))) score += 2;
-	score += scoreMatrixCryptoStateInStore(rootDir);
+	score += await scoreMatrixCryptoStateInStore(rootDir);
 	return score;
 }
 function resolveStorageRootMtimeMs(rootDir) {
@@ -32,15 +32,15 @@ function resolveStorageRootMtimeMs(rootDir) {
 		return 0;
 	}
 }
-function readStoredRootMetadata(rootDir) {
+async function readStoredRootMetadata(rootDir) {
 	if (fs.existsSync(path.join(rootDir, "state", "openclaw.sqlite"))) try {
-		const stored = normalizeMatrixStorageMetadata(openStorageMetaStore(rootDir).lookup(STORAGE_META_STATE_KEY));
+		const stored = normalizeMatrixStorageMetadata(await openStorageMetaStore(rootDir).lookup(STORAGE_META_STATE_KEY));
 		if (stored) return stored;
 	} catch {}
 	return normalizeMatrixStorageMetadata(loadJsonFile(path.join(rootDir, STORAGE_META_FILENAME))) ?? {};
 }
 function isCompatibleStorageRoot(params) {
-	const metadata = readStoredRootMetadata(params.candidateRootDir);
+	const { metadata } = params;
 	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;
@@ -48,17 +48,17 @@ function isCompatibleStorageRoot(params) {
 	if (params.requireExplicitDeviceMatch && params.deviceId && (!metadata.deviceId || metadata.deviceId.trim() !== params.deviceId.trim())) return false;
 	return true;
 }
-function resolvePreferredMatrixStorageRoot(params) {
+async function resolvePreferredMatrixStorageRoot(params) {
 	const canonical = {
 		rootDir: params.canonicalRootDir,
 		tokenHash: params.canonicalTokenHash
 	};
 	const deviceId = params.deviceId?.trim();
 	if (!deviceId) return canonical;
-	const canonicalMetadata = readStoredRootMetadata(params.canonicalRootDir);
+	const canonicalMetadata = await readStoredRootMetadata(params.canonicalRootDir);
 	if (canonicalMetadata.accessTokenHash === params.canonicalTokenHash && canonicalMetadata.deviceId?.trim() === deviceId && canonicalMetadata.currentTokenStateClaimed === true) return canonical;
 	const parentDir = path.dirname(params.canonicalRootDir);
-	const bestCurrentScore = scoreStorageRoot(params.canonicalRootDir, canonicalMetadata);
+	const bestCurrentScore = await scoreStorageRoot(params.canonicalRootDir, canonicalMetadata);
 	const bestCurrentMtimeMs = resolveStorageRootMtimeMs(params.canonicalRootDir);
 	let best = {
 		rootDir: params.canonicalRootDir,
@@ -82,15 +82,16 @@ function resolvePreferredMatrixStorageRoot(params) {
 		if (entry.name === params.canonicalTokenHash) continue;
 		if (!isMatrixActiveTokenRootDirectory(entry.name)) continue;
 		const candidateRootDir = path.join(parentDir, entry.name);
+		const metadata = await readStoredRootMetadata(candidateRootDir);
 		if (!isCompatibleStorageRoot({
-			candidateRootDir,
+			metadata,
 			homeserver: params.homeserver,
 			userId: params.userId,
 			accountKey: params.accountKey,
 			deviceId,
 			requireExplicitDeviceMatch: true
 		})) continue;
-		const candidateScore = scoreStorageRoot(candidateRootDir);
+		const candidateScore = await scoreStorageRoot(candidateRootDir, metadata);
 		if (candidateScore <= 0) continue;
 		populatedTokenHashes.push(entry.name);
 		compatiblePopulatedSiblings.push({
@@ -119,7 +120,7 @@ function resolvePreferredMatrixStorageRoot(params) {
 		tokenHash: best.tokenHash
 	};
 }
-function resolveMatrixStoragePaths(params) {
+async function resolveMatrixStoragePaths(params) {
 	const env = params.env ?? process.env;
 	const stateDir = params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir);
 	const canonical = resolveMatrixAccountStorageRoot({
@@ -129,7 +130,7 @@ function resolveMatrixStoragePaths(params) {
 		accessToken: params.accessToken,
 		accountId: params.accountId
 	});
-	const { rootDir, tokenHash } = resolvePreferredMatrixStorageRoot({
+	const { rootDir, tokenHash } = await resolvePreferredMatrixStorageRoot({
 		canonicalRootDir: canonical.rootDir,
 		canonicalTokenHash: canonical.tokenHash,
 		homeserver: params.homeserver,
@@ -147,8 +148,8 @@ function resolveMatrixStoragePaths(params) {
 		tokenHash
 	};
 }
-function resolveMatrixStateFilePath(params) {
-	const storagePaths = resolveMatrixStoragePaths({
+async function resolveMatrixStateFilePath(params) {
+	const storagePaths = await resolveMatrixStoragePaths({
 		homeserver: params.auth.homeserver,
 		userId: params.auth.userId,
 		accessToken: params.auth.accessToken,
@@ -161,7 +162,7 @@ function resolveMatrixStateFilePath(params) {
 }
 async function maybeMigrateLegacyStorage(params) {
 	const hasAccountScopedLegacyStorageFile = fs.existsSync(params.storagePaths.storagePath);
-	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./sync-cache-state-CFiZIPhA.mjs").then((n) => n.s) : null;
+	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./sync-cache-state-BMtGMxU1.mjs").then((n) => n.s) : null;
 	const hasAccountScopedLegacyStorage = hasAccountScopedLegacyStorageFile && await syncCache?.readLegacyMatrixSyncCacheState(params.storagePaths.rootDir) !== null;
 	const hasAccountScopedRecoveryKey = fs.existsSync(params.storagePaths.recoveryKeyPath);
 	const hasAccountScopedLegacyCryptoMigration = fs.existsSync(path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
@@ -181,7 +182,7 @@ async function maybeMigrateLegacyStorage(params) {
 			pendingArchives
 		});
 		if (hasAccountScopedRecoveryKey) {
-			migrateLegacyMatrixRecoveryKeyFileToStore(params.storagePaths.rootDir);
+			await migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync(params.storagePaths.recoveryKeyPath, getMatrixRuntime().state);
 			migrations.push({
 				sourcePath: params.storagePaths.recoveryKeyPath,
 				targetDescription: `${params.storagePaths.rootDir} SQLite recovery key state`,
@@ -189,7 +190,7 @@ async function maybeMigrateLegacyStorage(params) {
 			});
 		}
 		if (hasAccountScopedLegacyCryptoMigration) {
-			migrateLegacyMatrixLegacyCryptoMigrationFileToStore(params.storagePaths.rootDir);
+			await migrateLegacyMatrixLegacyCryptoMigrationFileToStore(params.storagePaths.rootDir);
 			migrations.push({
 				sourcePath: path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME),
 				targetDescription: `${params.storagePaths.rootDir} SQLite legacy crypto migration state`,
@@ -207,7 +208,7 @@ async function maybeMigrateLegacyStorage(params) {
 	if (skippedExistingTargets.length > 0) logger.warn?.(`matrix: legacy client storage files were left in place because their migrated targets already existed.\n${skippedExistingTargets.join("\n")}`);
 }
 async function migrateLegacySyncCacheToSqlite(params) {
-	const syncCache = await import("./sync-cache-state-CFiZIPhA.mjs").then((n) => n.s);
+	const syncCache = await import("./sync-cache-state-BMtGMxU1.mjs").then((n) => n.s);
 	const persisted = await syncCache.readLegacyMatrixSyncCacheState(params.sourceRootDir);
 	if (!persisted) return;
 	const store = getMatrixRuntime().state.openKeyedStore(syncCache.openMatrixSyncCacheStoreOptions(params.targetRootDir));
@@ -240,45 +241,35 @@ function archiveLegacyStoragePath(params) {
 	}
 	fs.renameSync(params.sourcePath, archivedLegacyStoragePath);
 }
-function writeStoredRootMetadata(rootDir, payload) {
-	try {
-		const normalized = normalizeMatrixStorageMetadata(payload);
-		if (!normalized) return false;
-		openStorageMetaStore(rootDir).register(STORAGE_META_STATE_KEY, normalized);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function writeStorageMeta(params) {
-	const existing = readStoredRootMetadata(params.storagePaths.rootDir);
-	return writeStoredRootMetadata(params.storagePaths.rootDir, {
-		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 prepareStorageMetaMutation(metadata, mutation) {
+	if (mutation.kind !== "initialize" && !metadata.accessTokenHash?.trim()) return null;
+	return normalizeMatrixStorageMetadata({
+		...mutation.kind === "initialize" ? mutation.metadata : metadata,
+		accountId: mutation.kind === "initialize" ? mutation.metadata.accountId : metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
+		deviceId: mutation.kind === "device" ? mutation.deviceId : mutation.kind === "initialize" ? mutation.metadata.deviceId ?? metadata.deviceId : metadata.deviceId,
+		currentTokenStateClaimed: mutation.kind === "claim" || (mutation.kind === "initialize" ? mutation.metadata.currentTokenStateClaimed ?? metadata.currentTokenStateClaimed === true : metadata.currentTokenStateClaimed === true),
+		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
 	});
 }
-async function claimCurrentTokenStorageState(params) {
+async function mutateStorageMeta(rootDir, mutation) {
 	try {
-		const store = getMatrixRuntime().state.openKeyedStore(openMatrixStorageMetaStoreOptions(params.rootDir));
-		if (!store.observe || !store.compareAndApply) return claimCurrentTokenStorageStateSync(params);
+		const store = openStorageMetaStore(rootDir);
+		const decode = (value) => normalizeMatrixStorageMetadata(value) ?? normalizeMatrixStorageMetadata(loadJsonFile(path.join(rootDir, STORAGE_META_FILENAME))) ?? {};
+		if (!store.observe || !store.compareAndApply) {
+			const legacyStore = getMatrixRuntime().state.openSyncKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
+			const next = prepareStorageMetaMutation(decode(legacyStore.lookup(STORAGE_META_STATE_KEY)), mutation);
+			if (!next) return false;
+			legacyStore.register(STORAGE_META_STATE_KEY, next);
+			return true;
+		}
 		let observation = await store.observe(STORAGE_META_STATE_KEY);
 		for (;;) {
-			const metadata = normalizeMatrixStorageMetadata(observation.value) ?? normalizeMatrixStorageMetadata(loadJsonFile(path.join(params.rootDir, STORAGE_META_FILENAME)));
-			if (!metadata?.accessTokenHash?.trim()) return false;
+			const next = prepareStorageMetaMutation(decode(observation.value), mutation);
+			if (!next) return false;
 			const result = await store.compareAndApply(STORAGE_META_STATE_KEY, observation.comparison, {
 				operation: "update",
 				action: "set",
-				value: {
-					...metadata,
-					accountId: metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
-					currentTokenStateClaimed: true,
-					createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-				}
+				value: next
 			});
 			if (result.status !== "conflict") return true;
 			observation = result.current;
@@ -287,48 +278,46 @@ async function claimCurrentTokenStorageState(params) {
 		return false;
 	}
 }
-function claimCurrentTokenStorageStateSync(params) {
-	const metadata = readStoredRootMetadata(params.rootDir);
-	if (!metadata.accessTokenHash?.trim()) return false;
-	return writeStoredRootMetadata(params.rootDir, {
-		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()
+async function writeStorageMeta(params) {
+	return mutateStorageMeta(params.storagePaths.rootDir, {
+		kind: "initialize",
+		metadata: {
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accountId: params.accountId ?? DEFAULT_ACCOUNT_KEY,
+			accessTokenHash: params.storagePaths.tokenHash,
+			deviceId: params.deviceId ?? null,
+			currentTokenStateClaimed: params.currentTokenStateClaimed
+		}
 	});
 }
-function recordCurrentStorageMetaDeviceId(params) {
+async function claimCurrentTokenStorageState(params) {
+	return mutateStorageMeta(params.rootDir, { kind: "claim" });
+}
+async function recordCurrentStorageMetaDeviceId(params) {
+	const rootDir = params.rootDir;
 	const deviceId = params.deviceId.trim();
-	if (!deviceId) return false;
-	const metadata = readStoredRootMetadata(params.rootDir);
-	if (!metadata.accessTokenHash?.trim()) return false;
-	return writeStoredRootMetadata(params.rootDir, {
-		homeserver: metadata.homeserver,
-		userId: metadata.userId,
-		accountId: metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
-		accessTokenHash: metadata.accessTokenHash,
-		deviceId,
-		currentTokenStateClaimed: metadata.currentTokenStateClaimed === true,
-		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	if (!deviceId || !(await readStoredRootMetadata(rootDir)).accessTokenHash?.trim()) return false;
+	return mutateStorageMeta(rootDir, {
+		kind: "device",
+		deviceId
 	});
 }
-function repairCurrentTokenStorageMetaDeviceId(params) {
+async function repairCurrentTokenStorageMetaDeviceId(params) {
+	const { homeserver, userId, accessToken, accountId, deviceId, env, stateDir } = params;
 	return writeStorageMeta({
-		storagePaths: resolveMatrixStoragePaths({
-			homeserver: params.homeserver,
-			userId: params.userId,
-			accessToken: params.accessToken,
-			accountId: params.accountId,
-			env: params.env,
-			stateDir: params.stateDir
+		storagePaths: await resolveMatrixStoragePaths({
+			homeserver,
+			userId,
+			accessToken,
+			accountId,
+			env,
+			stateDir
 		}),
-		homeserver: params.homeserver,
-		userId: params.userId,
-		accountId: params.accountId,
-		deviceId: params.deviceId
+		homeserver,
+		userId,
+		accountId,
+		deviceId
 	});
 }
 //#endregion

package/dist/.setup/{storage-metadata-BQJjHC_i.mjs → storage-metadata-fHN6Df2m.mjs}

@@ -56,15 +56,6 @@ function openMatrixIdbSnapshotStoreOptions(storageRootDir) {
 		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
 	};
 }
-function readMatrixRecoveryKeyState(storageRootDir) {
-	return readMatrixRecoveryKeyStateWithKey({
-		storageRootDir,
-		stateKey: STATE_KEY
-	});
-}
-function readMatrixRecoveryKeyStateWithKey(params) {
-	return normalizeMatrixStoredRecoveryKey(openSyncStore(openMatrixRecoveryKeyStoreOptions(params.storageRootDir)).lookup(params.stateKey));
-}
 async function readMatrixRecoveryKeyStateForPathAsync(recoveryKeyPath, stateRuntime) {
 	return normalizeMatrixStoredRecoveryKey(await stateRuntime.openKeyedStore(openMatrixRecoveryKeyStoreOptions(path.dirname(recoveryKeyPath))).lookup(resolveRecoveryKeyStateKeyForPath(recoveryKeyPath)));
 }
@@ -103,11 +94,6 @@ async function updateMatrixRecoveryKeyState(params, update) {
 		observation = result.current;
 	}
 }
-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;
 }
@@ -116,13 +102,8 @@ async function writeMatrixRecoveryKeyStateToStore(params) {
 	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 readMatrixLegacyCryptoMigrationState(storageRootDir) {
+	return normalizeMatrixLegacyCryptoMigrationState(await getMatrixRuntime().state.openKeyedStore(openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir)).lookup(STATE_KEY));
 }
 async function hasMatrixLegacyCryptoMigrationStateInStore(params) {
 	return normalizeMatrixLegacyCryptoMigrationState(await params.store.lookup(STATE_KEY)) !== null;
@@ -135,8 +116,8 @@ async function writeMatrixLegacyCryptoMigrationStateToStore(params) {
 async function readMatrixIdbSnapshotJson(storageRootDir, stateRuntime = getMatrixRuntime().state) {
 	return await readMatrixIdbSnapshotJsonFromStore({ store: stateRuntime.openKeyedStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)) });
 }
-function hasMatrixIdbSnapshotState(storageRootDir) {
-	return isIdbSnapshotMeta(openSyncStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)).lookup(idbMetaKey()));
+async function hasMatrixIdbSnapshotState(storageRootDir) {
+	return isIdbSnapshotMeta(await getMatrixRuntime().state.openKeyedStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)).lookup(idbMetaKey()));
 }
 async function writeMatrixIdbSnapshotJson(params) {
 	await writeMatrixIdbSnapshotJsonToStore({
@@ -154,17 +135,6 @@ async function writeMatrixIdbSnapshotJsonToStore(params) {
 	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) {
-	const recoveryKeyPath = path.join(storageRootDir, MATRIX_RECOVERY_KEY_FILENAME);
-	const existing = readMatrixRecoveryKeyState(storageRootDir);
-	const legacy = readLegacyMatrixRecoveryKeyFile(recoveryKeyPath);
-	if (!existing && legacy) writeMatrixRecoveryKeyStateWithKey({
-		storageRootDir,
-		stateKey: STATE_KEY,
-		payload: legacy
-	});
-	return archiveLegacyStateFileIfPossible(recoveryKeyPath);
-}
 async function migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync(recoveryKeyPath, stateRuntime) {
 	const legacy = readLegacyMatrixRecoveryKeyFile(recoveryKeyPath);
 	if (legacy) await updateMatrixRecoveryKeyState({
@@ -174,13 +144,27 @@ async function migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync(recoveryKeyPat
 	else await readMatrixRecoveryKeyStateForPathAsync(recoveryKeyPath, stateRuntime);
 	return archiveLegacyStateFileIfPossible(recoveryKeyPath);
 }
-function migrateLegacyMatrixLegacyCryptoMigrationFileToStore(storageRootDir) {
-	const existing = readMatrixLegacyCryptoMigrationState(storageRootDir);
+async function migrateLegacyMatrixLegacyCryptoMigrationFileToStore(storageRootDir) {
+	const options = openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir);
+	const store = getMatrixRuntime().state.openKeyedStore(options);
 	const legacy = readLegacyMatrixLegacyCryptoMigrationState(storageRootDir);
-	if (!existing && legacy) writeMatrixLegacyCryptoMigrationState({
-		storageRootDir,
-		state: legacy
-	});
+	if (!legacy) await store.lookup(STATE_KEY);
+	else if (!store.observe || !store.compareAndApply) {
+		const legacyStore = openSyncStore(options);
+		if (!normalizeMatrixLegacyCryptoMigrationState(legacyStore.lookup(STATE_KEY))) legacyStore.register(STATE_KEY, legacy);
+	} else {
+		let observation = await store.observe(STATE_KEY);
+		for (;;) {
+			if (normalizeMatrixLegacyCryptoMigrationState(observation.value)) break;
+			const result = await store.compareAndApply(STATE_KEY, observation.comparison, {
+				operation: "update",
+				action: "set",
+				value: legacy
+			});
+			if (result.status !== "conflict") break;
+			observation = result.current;
+		}
+	}
 	return archiveLegacyStateFileIfPossible(path.join(storageRootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
 }
 function readLegacyMatrixRecoveryKeyState(storageRootDir) {
@@ -192,17 +176,17 @@ function readLegacyMatrixRecoveryKeyFile(filePath) {
 function readLegacyMatrixLegacyCryptoMigrationState(storageRootDir) {
 	return readJsonFileSync(path.join(storageRootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME), normalizeMatrixLegacyCryptoMigrationState);
 }
-function scoreMatrixCryptoStateInStore(storageRootDir) {
+async function scoreMatrixCryptoStateInStore(storageRootDir) {
 	if (!matrixCryptoStateDatabaseExists(storageRootDir)) return 0;
 	let score = 0;
 	try {
-		if (readMatrixLegacyCryptoMigrationState(storageRootDir)) score += 3;
+		if (await readMatrixLegacyCryptoMigrationState(storageRootDir)) score += 3;
 	} catch {}
 	try {
-		if (readMatrixRecoveryKeyState(storageRootDir)) score += 2;
+		if (await readMatrixRecoveryKeyStateForPathAsync(path.join(storageRootDir, "recovery-key.json"), getMatrixRuntime().state)) score += 2;
 	} catch {}
 	try {
-		if (hasMatrixIdbSnapshotState(storageRootDir)) score += 2;
+		if (await hasMatrixIdbSnapshotState(storageRootDir)) score += 2;
 	} catch {}
 	return score;
 }
@@ -385,4 +369,4 @@ async function writeMatrixStorageMetaStateToStore(params) {
 	await params.store.register(STORAGE_META_STATE_KEY, params.payload);
 }
 //#endregion
-export { resolveMatrixSqliteStateKey as A, scoreMatrixCryptoStateInStore as C, writeMatrixRecoveryKeyStateForPathAsync as D, writeMatrixLegacyCryptoMigrationStateToStore as E, writeMatrixRecoveryKeyStateToStore as O, readMatrixRecoveryKeyStateForPathAsync as S, writeMatrixIdbSnapshotJsonToStore as T, readLegacyMatrixLegacyCryptoMigrationState as _, writeMatrixStorageMetaStateToStore as a, readMatrixIdbSnapshotJson as b, MATRIX_RECOVERY_KEY_FILENAME as c, migrateLegacyMatrixLegacyCryptoMigrationFileToStore as d, migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync as f, openMatrixRecoveryKeyStoreOptions as g, openMatrixLegacyCryptoMigrationStoreOptions as h, openMatrixStorageMetaStoreOptions as i, resolveMatrixSqliteStateEnv as k, hasMatrixLegacyCryptoMigrationStateInStore as l, openMatrixIdbSnapshotStoreOptions as m, hasMatrixStorageMetaStateInStore as n, MATRIX_IDB_SNAPSHOT_FILENAME as o, migrateLegacyMatrixRecoveryKeyFileToStore as p, normalizeMatrixStorageMetadata as r, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME as s, STORAGE_META_STATE_KEY as t, hasMatrixRecoveryKeyStateInStore as u, readLegacyMatrixRecoveryKeyFile as v, writeMatrixIdbSnapshotJson as w, readMatrixIdbSnapshotJsonFromStore as x, readLegacyMatrixRecoveryKeyState as y };
+export { writeMatrixIdbSnapshotJson as C, writeMatrixRecoveryKeyStateToStore as D, writeMatrixRecoveryKeyStateForPathAsync as E, resolveMatrixSqliteStateEnv as O, scoreMatrixCryptoStateInStore as S, writeMatrixLegacyCryptoMigrationStateToStore as T, readLegacyMatrixRecoveryKeyFile as _, writeMatrixStorageMetaStateToStore as a, readMatrixIdbSnapshotJsonFromStore as b, MATRIX_RECOVERY_KEY_FILENAME as c, migrateLegacyMatrixLegacyCryptoMigrationFileToStore as d, migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync as f, readLegacyMatrixLegacyCryptoMigrationState as g, openMatrixRecoveryKeyStoreOptions as h, openMatrixStorageMetaStoreOptions as i, resolveMatrixSqliteStateKey as k, hasMatrixLegacyCryptoMigrationStateInStore as l, openMatrixLegacyCryptoMigrationStoreOptions as m, hasMatrixStorageMetaStateInStore as n, MATRIX_IDB_SNAPSHOT_FILENAME as o, openMatrixIdbSnapshotStoreOptions as p, normalizeMatrixStorageMetadata as r, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME as s, STORAGE_META_STATE_KEY as t, hasMatrixRecoveryKeyStateInStore as u, readLegacyMatrixRecoveryKeyState as v, writeMatrixIdbSnapshotJsonToStore as w, readMatrixRecoveryKeyStateForPathAsync as x, readMatrixIdbSnapshotJson as y };

package/dist/.setup/{sync-cache-state-CFiZIPhA.mjs → sync-cache-state-BMtGMxU1.mjs}

@@ -1,19 +1,19 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { k as resolveMatrixSqliteStateEnv } from "./storage-metadata-BQJjHC_i.mjs";
+import { O as resolveMatrixSqliteStateEnv } from "./storage-metadata-fHN6Df2m.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 //#region extensions/matrix/src/matrix/client/sync-cache-state.ts
 var sync_cache_state_exports = /* @__PURE__ */ __exportAll({
 	MATRIX_SYNC_CACHE_VERSION: () => 1,
-	deleteMatrixSyncCacheStateFromSyncStore: () => deleteMatrixSyncCacheStateFromSyncStore,
+	deleteMatrixSyncCacheStateFromStore: () => deleteMatrixSyncCacheStateFromStore,
 	hasMatrixSyncCacheStateInStore: () => hasMatrixSyncCacheStateInStore,
 	openMatrixSyncCacheStoreOptions: () => openMatrixSyncCacheStoreOptions,
 	readLegacyMatrixSyncCacheState: () => readLegacyMatrixSyncCacheState,
-	readPersistedStoreFromSyncStore: () => readPersistedStoreFromSyncStore,
-	writeMatrixSyncCacheStateToStore: () => writeMatrixSyncCacheStateToStore,
-	writeMatrixSyncCacheStateToSyncStore: () => writeMatrixSyncCacheStateToSyncStore
+	readPersistedStoreFromStore: () => readPersistedStoreFromStore,
+	writeMatrixSyncCacheStateToStore: () => writeMatrixSyncCacheStateToStore
 });
 const MATRIX_SYNC_CACHE_VERSION = 1;
 const SYNC_CACHE_NAMESPACE = "sync-cache";
@@ -21,6 +21,7 @@ const SYNC_CACHE_MAX_ENTRIES = 2e4;
 const SYNC_CACHE_MAX_CHUNKS = Math.floor(19999 / 2);
 const SYNC_CACHE_STATE_KEY = "current";
 const SYNC_CACHE_CHUNK_BYTES = 24e3;
+const syncCacheOperations = new KeyedAsyncQueue();
 function normalizeRoomsData(value) {
 	if (!isRecord(value)) return null;
 	return {
@@ -70,16 +71,20 @@ function normalizeLegacyPersistedStore(value) {
 		cleanShutdown: false
 	};
 }
-function readPersistedStoreFromSyncStore(store) {
+async function readPersistedStoreFromStore(params) {
+	const { storageRootDir, store } = params;
+	return syncCacheOperations.enqueue(path.resolve(storageRootDir), () => readPersistedStore(store));
+}
+async function readPersistedStore(store) {
 	const stateKey = SYNC_CACHE_STATE_KEY;
-	const meta = store.lookup(metaKey(stateKey));
+	const meta = await store.lookup(metaKey(stateKey));
 	if (!isSyncCacheMeta(meta)) return null;
-	const records = store.lookupMany?.(Array.from({ length: meta.chunkCount }, (_, index) => chunkKey(stateKey, meta.generation, index)));
+	const records = await store.lookupMany?.(Array.from({ length: meta.chunkCount }, (_, index) => chunkKey(stateKey, meta.generation, index)));
 	const chunks = [];
 	for (let index = 0; index < meta.chunkCount; index += 1) {
 		const result = records?.[index];
 		if (result && !result.ok) throw result.error;
-		const chunk = records ? result?.value : store.lookup(chunkKey(stateKey, meta.generation, index));
+		const chunk = records ? result?.value : await store.lookup(chunkKey(stateKey, meta.generation, index));
 		if (!isSyncCacheChunk(chunk) || chunk.index !== index) return normalizePersistedStore({
 			version: 1,
 			savedSync: null,
@@ -191,32 +196,17 @@ async function readLegacyMatrixSyncCacheState(storageRootDir) {
 	}
 }
 async function hasMatrixSyncCacheStateInStore(params) {
-	const stateKey = SYNC_CACHE_STATE_KEY;
-	const meta = await params.store.lookup(metaKey(stateKey));
-	if (!isSyncCacheMeta(meta) || meta.chunkCount <= 0) return false;
-	const records = await params.store.lookupMany?.(Array.from({ length: meta.chunkCount }, (_, index) => chunkKey(stateKey, meta.generation, index)));
-	const chunks = [];
-	for (let index = 0; index < meta.chunkCount; index += 1) {
-		const result = records?.[index];
-		if (result && !result.ok) throw result.error;
-		const chunk = records ? result?.value : await params.store.lookup(chunkKey(stateKey, meta.generation, index));
-		if (!isSyncCacheChunk(chunk) || chunk.index !== index) return false;
-		chunks.push(chunk.data);
-	}
-	const syncJson = chunks.join("");
-	if (meta.syncDigest !== digestText(syncJson)) return false;
-	try {
-		return toPersistedSyncData(JSON.parse(syncJson)) !== null;
-	} catch {
-		return false;
-	}
+	return Boolean((await readPersistedStoreFromStore(params))?.savedSync);
 }
 async function writeMatrixSyncCacheStateToStore(params) {
+	const { storageRootDir, store, payload } = params;
 	const stateKey = SYNC_CACHE_STATE_KEY;
-	const rows = buildSyncCacheRows(stateKey, params.payload);
-	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(chunkKeyPrefix(stateKey)) && !rows.nextChunkKeys.has(row.key)) await params.store.delete(row.key);
+	const rows = buildSyncCacheRows(stateKey, payload);
+	return syncCacheOperations.enqueue(path.resolve(storageRootDir), async () => {
+		for (const row of rows.chunks) await store.register(row.key, row.value);
+		await store.register(rows.meta.key, rows.meta.value);
+		for (const row of await store.entries()) if (row.key.startsWith(chunkKeyPrefix(stateKey)) && !rows.nextChunkKeys.has(row.key)) await store.delete(row.key);
+	});
 }
 function openMatrixSyncCacheStoreOptions(storageRootDir) {
 	return {
@@ -225,16 +215,13 @@ function openMatrixSyncCacheStoreOptions(storageRootDir) {
 		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
 	};
 }
-function writeMatrixSyncCacheStateToSyncStore(params) {
-	const rows = buildSyncCacheRows(SYNC_CACHE_STATE_KEY, params.payload);
-	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(chunkKeyPrefix(SYNC_CACHE_STATE_KEY)) && !rows.nextChunkKeys.has(row.key)) params.store.delete(row.key);
-}
-async function deleteMatrixSyncCacheStateFromSyncStore(params) {
-	params.store.delete(metaKey(SYNC_CACHE_STATE_KEY));
-	for (const row of params.store.entries()) if (row.key.startsWith(chunkKeyPrefix(SYNC_CACHE_STATE_KEY))) params.store.delete(row.key);
-	await fs.rm(resolveLegacySyncCachePath(params.storageRootDir), { force: true }).catch(() => void 0);
+async function deleteMatrixSyncCacheStateFromStore(params) {
+	const { storageRootDir, store } = params;
+	return syncCacheOperations.enqueue(path.resolve(storageRootDir), async () => {
+		await store.delete(metaKey(SYNC_CACHE_STATE_KEY));
+		for (const row of await store.entries()) if (row.key.startsWith(chunkKeyPrefix(SYNC_CACHE_STATE_KEY))) await store.delete(row.key);
+		await fs.rm(resolveLegacySyncCachePath(storageRootDir), { force: true }).catch(() => void 0);
+	});
 }
 //#endregion
-export { readLegacyMatrixSyncCacheState as a, writeMatrixSyncCacheStateToStore as c, openMatrixSyncCacheStoreOptions as i, writeMatrixSyncCacheStateToSyncStore as l, deleteMatrixSyncCacheStateFromSyncStore as n, readPersistedStoreFromSyncStore as o, hasMatrixSyncCacheStateInStore as r, sync_cache_state_exports as s, MATRIX_SYNC_CACHE_VERSION as t };
+export { readLegacyMatrixSyncCacheState as a, writeMatrixSyncCacheStateToStore as c, openMatrixSyncCacheStoreOptions as i, deleteMatrixSyncCacheStateFromStore as n, readPersistedStoreFromStore as o, hasMatrixSyncCacheStateInStore as r, sync_cache_state_exports as s, MATRIX_SYNC_CACHE_VERSION as t };

package/dist/.setup/{thread-bindings-Hy96ujd3.mjs → thread-bindings-JlnLDfPM.mjs}

@@ -1,8 +1,8 @@
 import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
 import { a as listBindingsForAccount, c as resolveEffectiveBindingExpiry, d as setMatrixThreadBindingManagerEntry, l as setBindingRecord, m as toSessionBindingRecord, o as removeBindingRecord, p as toMatrixBindingTargetKind, r as getMatrixThreadBindingManagerEntry, s as resolveBindingKey, t as deleteMatrixThreadBindingManagerEntry } from "./thread-bindings-shared-oNPiyMWY.mjs";
-import { A as resolveMatrixSqliteStateKey, k as resolveMatrixSqliteStateEnv } from "./storage-metadata-BQJjHC_i.mjs";
-import { a as resolveMatrixStateFilePath, t as claimCurrentTokenStorageState } from "./storage-DJ-oUgmX.mjs";
-import { r as sendMessageMatrix } from "./send-h0gZ_-qk.mjs";
+import { O as resolveMatrixSqliteStateEnv, k as resolveMatrixSqliteStateKey } from "./storage-metadata-fHN6Df2m.mjs";
+import { a as resolveMatrixStateFilePath, t as claimCurrentTokenStorageState } from "./storage-BXaFc0S4.mjs";
+import { r as sendMessageMatrix } from "./send-aVdC5NJO.mjs";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import path from "node:path";
@@ -18,7 +18,7 @@ const THREAD_BINDINGS_MIGRATIONS_NAMESPACE = "thread-bindings-migrations";
 const THREAD_BINDINGS_MAX_ENTRIES = 1e4;
 const THREAD_BINDINGS_SWEEP_INTERVAL_MS = 6e4;
 const TOUCH_PERSIST_DELAY_MS = 3e4;
-function resolveBindingsPath(params) {
+async function resolveBindingsPath(params) {
 	return resolveMatrixStateFilePath({
 		auth: params.auth,
 		accountId: params.accountId,
@@ -140,7 +140,7 @@ async function sendFarewellMessage(params) {
 }
 async function createMatrixThreadBindingManager(params) {
 	if (params.auth.accountId !== params.accountId) throw new Error(`Matrix thread binding account mismatch: requested ${params.accountId}, auth resolved ${params.auth.accountId}`);
-	const legacyFilePath = resolveBindingsPath({
+	const legacyFilePath = await resolveBindingsPath({
 		auth: params.auth,
 		accountId: params.accountId,
 		env: params.env,

package/dist/.setup/{tool-actions.runtime-Dckttu43.mjs → tool-actions.runtime-REzYTNxm.mjs}

@@ -1,16 +1,16 @@
 import { a as resolveMatrixAccountConfig, o as resolveMatrixBaseConfig } from "./account-config-CRsKoMqJ.mjs";
-import { i as resolveMatrixAccount } from "./accounts-BF5hyc-1.mjs";
-import { a as resolveMatrixRoomConfig } from "./channel-q6TBKEiG.mjs";
+import { i as resolveMatrixAccount } from "./accounts-iThMol10.mjs";
+import { a as resolveMatrixRoomConfig } from "./channel-ConuJfxT.mjs";
 import { i as normalizeMatrixResolvableTarget } from "./target-ids-Nwx7cMVE.mjs";
 import { l as selectOwnMatrixReactionEventIds, s as buildMatrixReactionRelationsPath, u as summarizeMatrixReactionEvents } from "./send-currentness-BrGXL7b8.mjs";
 import { c as isStrictDirectMembership, s as hasDirectMatrixMemberFlag, u as readJoinedMatrixMembers } from "./direct-management-B2Bno2xL.mjs";
-import { E as resolveMatrixRoomId, b as isPollStartType, h as buildPollResponseContent, n as reactMatrixMessage, x as parsePollStart } from "./send-h0gZ_-qk.mjs";
+import { E as resolveMatrixRoomId, b as isPollStartType, h as buildPollResponseContent, n as reactMatrixMessage, x as parsePollStart } from "./send-aVdC5NJO.mjs";
 import { i as parseMxc } from "./event-helpers-CspuhE9k.mjs";
-import { a as fetchEventSummary, c as resolveMatrixActionLimit, i as sendMatrixMessage, n as editMatrixMessage, o as readPinnedEvents, r as readMatrixMessages, s as EventType, t as deleteMatrixMessage } from "./messages-SW0NPYnR.mjs";
-import { n as withResolvedActionClient, r as withResolvedRoomAction } from "./client-By2B3Wz4.mjs";
-import { t as applyMatrixProfileUpdate } from "./profile-update-DPttQz3-.mjs";
-import { _ as scanMatrixVerificationQr, a as confirmMatrixVerificationSas, b as verifyMatrixRecoveryKey, c as getMatrixRoomKeyBackupStatus, d as listMatrixVerifications, f as mismatchMatrixVerificationSas, h as restoreMatrixRoomKeyBackup, i as confirmMatrixVerificationReciprocateQr, l as getMatrixVerificationSas, n as bootstrapMatrixVerification, o as generateMatrixVerificationQr, p as requestMatrixVerification, r as cancelMatrixVerification, s as getMatrixEncryptionStatus, t as acceptMatrixVerification, u as getMatrixVerificationStatus, v as startMatrixVerification } from "./verification-CKqBZ9mI.mjs";
-import { n as getMatrixMemberInfo, r as getMatrixRoomInfo, t as createMatrixRoomInfoResolver } from "./room-info-DHd1j3qM.mjs";
+import { a as sendMatrixMessage, c as EventType, i as readMatrixMessages, l as resolveMatrixActionLimit, n as editMatrixMessage, o as fetchEventSummary, r as readMatrixMessage, s as readPinnedEvents, t as deleteMatrixMessage } from "./messages-COuAcrz-.mjs";
+import { n as withResolvedActionClient, r as withResolvedRoomAction } from "./client-C2yVkVdw.mjs";
+import { t as applyMatrixProfileUpdate } from "./profile-update-DrblJttE.mjs";
+import { _ as scanMatrixVerificationQr, a as confirmMatrixVerificationSas, b as verifyMatrixRecoveryKey, c as getMatrixRoomKeyBackupStatus, d as listMatrixVerifications, f as mismatchMatrixVerificationSas, h as restoreMatrixRoomKeyBackup, i as confirmMatrixVerificationReciprocateQr, l as getMatrixVerificationSas, n as bootstrapMatrixVerification, o as generateMatrixVerificationQr, p as requestMatrixVerification, r as cancelMatrixVerification, s as getMatrixEncryptionStatus, t as acceptMatrixVerification, u as getMatrixVerificationStatus, v as startMatrixVerification } from "./verification-0o8MOW9T.mjs";
+import { n as getMatrixMemberInfo, r as getMatrixRoomInfo, t as createMatrixRoomInfoResolver } from "./room-info-DTyP1k5g.mjs";
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, uniqueStrings, uniqueValues } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { ToolAuthorizationError, createActionGate, jsonResult, readPositiveIntegerParam, readReactionParams, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/channel-actions";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
@@ -479,11 +479,19 @@ async function handleMatrixAction(ctx) {
 		const before = readStringParam(params, "before");
 		const after = readStringParam(params, "after");
 		const threadId = readStringParam(params, "threadId");
+		const messageId = readStringParam(params, "messageId");
 		const { clientOpts, withReadTarget } = prepareAction({
 			name: "messages",
 			disabledMessage: "Matrix messages are disabled."
 		});
 		const result = await withReadTarget(roomId, async (target) => {
+			if (messageId) return {
+				messages: projectMatrixMessagesForDisplay([await readMatrixMessage(target.roomId, messageId, {
+					...clientOpts,
+					client: target.client
+				})]),
+				roomId: target.roomId
+			};
 			const messages = await readMatrixMessages(target.roomId, {
 				limit: limit ?? void 0,
 				before: before ?? void 0,