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

package/dist/{storage-DSVcH_zM.js → storage-C10h2piS.js}

@@ -1,6 +1,7 @@
-import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-DEMtY2cn.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-Bv_ZuOu4.js";
 import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
 import { n as resolveMatrixAccountStorageRoot, s as resolveMatrixLegacyFlatStoragePaths } from "./storage-paths-BWo_ZEMC.js";
+import { b as scoreMatrixCryptoStateInStore, g as readMatrixIdbSnapshotJson, l as migrateLegacyMatrixRecoveryKeyFileToStore, n as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, r as MATRIX_RECOVERY_KEY_FILENAME, s as migrateLegacyMatrixLegacyCryptoMigrationFileToStore, t as MATRIX_IDB_SNAPSHOT_FILENAME, x as writeMatrixIdbSnapshotJson } from "./crypto-state-store-DK2tcEyP.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import fs from "node:fs";
 import os from "node:os";
@@ -10,15 +11,8 @@ import { loadJsonFile, saveJsonFile } from "openclaw/plugin-sdk/json-store";
 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";
 function resolveLegacyStoragePaths(env = process.env) {
-	const legacy = resolveMatrixLegacyFlatStoragePaths(getMatrixRuntime().state.resolveStateDir(env, os.homedir));
-	return {
-		storagePath: legacy.storagePath,
-		cryptoPath: legacy.cryptoPath
-	};
+	return resolveMatrixLegacyFlatStoragePaths(getMatrixRuntime().state.resolveStateDir(env, os.homedir));
 }
 function assertLegacyMigrationAccountSelection(params) {
 	const cfg = getMatrixRuntime().config.current();
@@ -30,12 +24,13 @@ function assertLegacyMigrationAccountSelection(params) {
 }
 function scoreStorageRoot(rootDir) {
 	let score = 0;
-	if (fs.existsSync(path.join(rootDir, "bot-storage.json"))) score += 8;
+	if (readStoredRootMetadata(rootDir).currentTokenStateClaimed === true) 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, "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);
 	if (fs.existsSync(path.join(rootDir, STORAGE_META_FILENAME))) score += 1;
 	return score;
 }
@@ -145,8 +140,8 @@ function resolveMatrixStoragePaths(params) {
 		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),
+		recoveryKeyPath: path.join(rootDir, MATRIX_RECOVERY_KEY_FILENAME),
+		idbSnapshotPath: path.join(rootDir, MATRIX_IDB_SNAPSHOT_FILENAME),
 		accountKey: canonical.accountKey,
 		tokenHash
 	};
@@ -165,15 +160,20 @@ function resolveMatrixStateFilePath(params) {
 }
 async function maybeMigrateLegacyStorage(params) {
 	const legacy = resolveLegacyStoragePaths(params.env);
-	const hasLegacyStorage = fs.existsSync(legacy.storagePath);
+	const hasFlatLegacyStorageFile = fs.existsSync(legacy.storagePath);
+	const hasAccountScopedLegacyStorageFile = fs.existsSync(params.storagePaths.storagePath);
+	const syncCache = hasFlatLegacyStorageFile || hasAccountScopedLegacyStorageFile ? await import("./file-sync-store-Ni-pkFde.js").then((n) => n.n) : null;
+	const hasFlatLegacyStorage = hasFlatLegacyStorageFile && await syncCache?.readLegacyMatrixSyncCacheState(legacy.rootDir) !== null;
+	const hasAccountScopedLegacyStorage = hasAccountScopedLegacyStorageFile && await syncCache?.readLegacyMatrixSyncCacheState(params.storagePaths.rootDir) !== null;
 	const hasLegacyCrypto = fs.existsSync(legacy.cryptoPath);
-	if (!hasLegacyStorage && !hasLegacyCrypto) return;
-	const hasTargetStorage = fs.existsSync(params.storagePaths.storagePath);
+	const hasAccountScopedRecoveryKey = fs.existsSync(params.storagePaths.recoveryKeyPath);
+	const hasAccountScopedIdbSnapshot = fs.existsSync(params.storagePaths.idbSnapshotPath);
+	const hasAccountScopedLegacyCryptoMigration = fs.existsSync(path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
+	if (!hasFlatLegacyStorage && !hasAccountScopedLegacyStorage && !hasLegacyCrypto && !hasAccountScopedRecoveryKey && !hasAccountScopedIdbSnapshot && !hasAccountScopedLegacyCryptoMigration) return;
 	const hasTargetCrypto = fs.existsSync(params.storagePaths.cryptoPath);
-	const shouldMigrateStorage = hasLegacyStorage && !hasTargetStorage;
 	const shouldMigrateCrypto = hasLegacyCrypto && !hasTargetCrypto;
-	if (!shouldMigrateStorage && !shouldMigrateCrypto) return;
-	assertLegacyMigrationAccountSelection({ accountKey: params.storagePaths.accountKey });
+	if (!hasFlatLegacyStorage && !hasAccountScopedLegacyStorage && !shouldMigrateCrypto && !hasAccountScopedRecoveryKey && !hasAccountScopedIdbSnapshot && !hasAccountScopedLegacyCryptoMigration) return;
+	if (hasFlatLegacyStorage || hasLegacyCrypto) assertLegacyMigrationAccountSelection({ accountKey: params.storagePaths.accountKey });
 	const logger = getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" });
 	const { maybeCreateMatrixMigrationSnapshot } = await import("./migration-snapshot.runtime-VGD4QfeS.js");
 	await maybeCreateMatrixMigrationSnapshot({
@@ -183,15 +183,25 @@ async function maybeMigrateLegacyStorage(params) {
 	});
 	fs.mkdirSync(params.storagePaths.rootDir, { recursive: true });
 	const moved = [];
+	const pendingArchives = [];
 	const skippedExistingTargets = [];
 	try {
-		if (shouldMigrateStorage) moveLegacyStoragePathOrThrow({
+		if (hasAccountScopedLegacyStorage) await migrateLegacySyncCacheToSqlite({
+			sourceRootDir: params.storagePaths.rootDir,
+			sourcePath: params.storagePaths.storagePath,
+			targetRootDir: params.storagePaths.rootDir,
+			label: "account sync cache",
+			moved,
+			pendingArchives
+		});
+		if (hasFlatLegacyStorage) await migrateLegacySyncCacheToSqlite({
+			sourceRootDir: legacy.rootDir,
 			sourcePath: legacy.storagePath,
-			targetPath: params.storagePaths.storagePath,
-			label: "sync store",
-			moved
+			targetRootDir: params.storagePaths.rootDir,
+			label: "flat sync cache",
+			moved,
+			pendingArchives
 		});
-		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,
@@ -199,13 +209,99 @@ async function maybeMigrateLegacyStorage(params) {
 			moved
 		});
 		else if (hasLegacyCrypto) skippedExistingTargets.push(`- crypto store remains at ${legacy.cryptoPath} because ${params.storagePaths.cryptoPath} already exists`);
+		if (hasAccountScopedRecoveryKey) {
+			migrateLegacyMatrixRecoveryKeyFileToStore(params.storagePaths.rootDir);
+			moved.push({
+				sourcePath: params.storagePaths.recoveryKeyPath,
+				targetPath: `${params.storagePaths.rootDir} SQLite recovery key state`,
+				label: "recovery key"
+			});
+		}
+		if (hasAccountScopedLegacyCryptoMigration) {
+			migrateLegacyMatrixLegacyCryptoMigrationFileToStore(params.storagePaths.rootDir);
+			moved.push({
+				sourcePath: path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME),
+				targetPath: `${params.storagePaths.rootDir} SQLite legacy crypto migration state`,
+				label: "legacy crypto migration"
+			});
+		}
+		if (hasAccountScopedIdbSnapshot) await migrateLegacyIdbSnapshotToSqlite({
+			storageRootDir: params.storagePaths.rootDir,
+			snapshotPath: params.storagePaths.idbSnapshotPath,
+			moved,
+			pendingArchives
+		});
 	} 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 });
 	}
+	for (const archive of pendingArchives) archiveLegacyStoragePath({
+		...archive,
+		skippedExistingTargets
+	});
 	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")}`);
 }
+async function migrateLegacyIdbSnapshotToSqlite(params) {
+	if (readMatrixIdbSnapshotJson(params.storageRootDir)) {
+		params.pendingArchives.push({
+			sourcePath: params.snapshotPath,
+			label: "IndexedDB snapshot"
+		});
+		return;
+	}
+	const { readLegacyMatrixIdbSnapshotState } = await import("./idb-persistence-BGY1CJ7J.js").then((n) => n.t);
+	const snapshot = await readLegacyMatrixIdbSnapshotState(params.storageRootDir);
+	if (!snapshot) return;
+	writeMatrixIdbSnapshotJson({
+		storageRootDir: params.storageRootDir,
+		snapshotJson: JSON.stringify(snapshot),
+		databaseCount: snapshot.length
+	});
+	params.moved.push({
+		sourcePath: params.snapshotPath,
+		targetPath: `${params.storageRootDir} SQLite IndexedDB snapshot state`,
+		label: "IndexedDB snapshot"
+	});
+	params.pendingArchives.push({
+		sourcePath: params.snapshotPath,
+		label: "IndexedDB snapshot"
+	});
+}
+async function migrateLegacySyncCacheToSqlite(params) {
+	const syncCache = await import("./file-sync-store-Ni-pkFde.js").then((n) => n.n);
+	const persisted = await syncCache.readLegacyMatrixSyncCacheState(params.sourceRootDir);
+	if (!persisted) return;
+	const store = getMatrixRuntime().state.openKeyedStore(syncCache.openMatrixSyncCacheStoreOptions(params.targetRootDir));
+	if (!await syncCache.hasMatrixSyncCacheStateInStore({
+		storageRootDir: params.targetRootDir,
+		store
+	})) {
+		await syncCache.writeMatrixSyncCacheStateToStore({
+			storageRootDir: params.targetRootDir,
+			payload: persisted,
+			store
+		});
+		claimCurrentTokenStorageState({ rootDir: params.targetRootDir });
+		params.moved.push({
+			sourcePath: params.sourcePath,
+			targetPath: `${params.targetRootDir} SQLite sync cache`,
+			label: params.label
+		});
+	}
+	params.pendingArchives.push({
+		sourcePath: params.sourcePath,
+		label: params.label
+	});
+}
+function archiveLegacyStoragePath(params) {
+	const archivedLegacyStoragePath = `${params.sourcePath}.migrated`;
+	if (fs.existsSync(archivedLegacyStoragePath)) {
+		params.skippedExistingTargets.push(`- ${params.label} remains at ${params.sourcePath} because ${archivedLegacyStoragePath} already exists`);
+		return;
+	}
+	fs.renameSync(params.sourcePath, archivedLegacyStoragePath);
+}
 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`);

package/dist/{thread-bindings-gLQYbsB9.js → thread-bindings-CnviJ9Ff.js}

@@ -1,34 +1,15 @@
 import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
 import { a as listBindingsForAccount, c as resolveBindingKey, f as setMatrixThreadBindingManagerEntry, h as toSessionBindingRecord, l as resolveEffectiveBindingExpiry, m as toMatrixBindingTargetKind, o as removeBindingRecord, r as getMatrixThreadBindingManagerEntry, t as deleteMatrixThreadBindingManagerEntry, u as setBindingRecord } from "./thread-bindings-shared-CKnY4LSd.js";
-import { a as resolveMatrixStateFilePath, t as claimCurrentTokenStorageState } from "./storage-DSVcH_zM.js";
-import { a as sendMessageMatrix } from "./send-DEgWxp1p.js";
+import { O as resolveMatrixSqliteStateEnv, k as resolveMatrixSqliteStateKey } from "./crypto-state-store-DK2tcEyP.js";
+import { a as resolveMatrixStateFilePath, t as claimCurrentTokenStorageState } from "./storage-C10h2piS.js";
+import { a as sendMessageMatrix } from "./send-Bus9xhUh.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import os from "node:os";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { registerSessionBindingAdapter, resolveThreadBindingFarewellText, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/thread-bindings-session-runtime";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
 import fs from "node:fs/promises";
 import { resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
-//#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/thread-bindings.ts
 const STORE_VERSION = 1;
 const THREAD_BINDINGS_NAMESPACE = "thread-bindings";
@@ -452,4 +433,4 @@ async function createMatrixThreadBindingManager(params) {
 	return manager;
 }
 //#endregion
-export { resolveMatrixSqliteStateEnv as n, createMatrixThreadBindingManager as t };
+export { createMatrixThreadBindingManager as t };

package/dist/{tool-actions.runtime-o06m9bgN.js → tool-actions.runtime-dStqVKMT.js}

@@ -1,12 +1,12 @@
 import { c as resolveMatrixAccountConfig } from "./config-paths-ZBCMwSos.js";
-import "./setup-core-DJosJdWt.js";
-import { E as parsePollStart, T as isPollStartType, b as buildPollResponseContent, i as reactMatrixMessage, u as resolveMatrixRoomId } from "./send-DEgWxp1p.js";
+import "./setup-core-CUyFBi5x.js";
+import { E as parsePollStart, T as isPollStartType, b as buildPollResponseContent, i as reactMatrixMessage, u as resolveMatrixRoomId } from "./send-Bus9xhUh.js";
 import { i as buildMatrixReactionRelationsPath, o as selectOwnMatrixReactionEventIds, s as summarizeMatrixReactionEvents } from "./reaction-common-DkrQdBSZ.js";
-import { n as withResolvedActionClient, r as withResolvedRoomAction } from "./client-CdP9vWOu.js";
-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-sk1eTx7H.js";
+import { n as withResolvedActionClient, r as withResolvedRoomAction } from "./client-CPfb6TMG.js";
+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-C00n-MG_.js";
 import { a as jsonResult, c as readStringArrayParam, l as readStringParam, o as readPositiveIntegerParam, r as createActionGate, s as readReactionParams } from "./runtime-api-CsBoesCU.js";
-import { t as applyMatrixProfileUpdate } from "./profile-update-rzynJvpi.js";
-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-BiA5IWPK.js";
+import { t as applyMatrixProfileUpdate } from "./profile-update-CWvjc5i_.js";
+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-jZ1KWtb5.js";
 import { normalizeOptionalLowercaseString, uniqueStrings, uniqueValues } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/matrix/actions/polls.ts
 function normalizeOptionIndexes(indexes) {

package/dist/{verification-BiA5IWPK.js → verification-jZ1KWtb5.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { i as withStartedActionClient, n as withResolvedActionClient } from "./client-CdP9vWOu.js";
-import { n as formatMatrixEncryptionUnavailableError } from "./encryption-guidance-aEUzD940.js";
+import { i as withStartedActionClient, n as withResolvedActionClient } from "./client-CPfb6TMG.js";
+import { n as formatMatrixEncryptionUnavailableError } from "./encryption-guidance-D_KhjprO.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { setTimeout } from "node:timers/promises";

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/matrix",
-  "version": "2026.6.5-beta.1",
+  "version": "2026.6.5-beta.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/matrix",
-      "version": "2026.6.5-beta.1",
+      "version": "2026.6.5-beta.3",
       "dependencies": {
         "@matrix-org/matrix-sdk-crypto-nodejs": "0.6.0",
         "@matrix-org/matrix-sdk-crypto-wasm": "18.3.0",
@@ -18,7 +18,7 @@
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.6.5-beta.1"
+        "openclaw": ">=2026.6.5-beta.3"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/matrix",
-  "version": "2026.6.5-beta.1",
+  "version": "2026.6.5-beta.3",
   "description": "OpenClaw Matrix channel plugin for rooms and direct messages.",
   "repository": {
     "type": "git",
@@ -18,7 +18,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.6.5-beta.1"
+    "openclaw": ">=2026.6.5-beta.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -84,10 +84,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.6.5-beta.1"
+      "pluginApi": ">=2026.6.5-beta.3"
     },
     "build": {
-      "openclawVersion": "2026.6.5-beta.1"
+      "openclawVersion": "2026.6.5-beta.3"
     },
     "release": {
       "publishToClawHub": true,

package/dist/probe.runtime-BO0mNIe8.js

@@ -1,3 +0,0 @@
-import { t as createMatrixClient } from "./create-client-B90Sb7LG.js";
-import "./client-DRRL7Zv5.js";
-export { createMatrixClient };

package/dist/record-shared-CvzjvHRn.js

@@ -1,2 +0,0 @@
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-export { isRecord as t };