@openclaw/matrix 2026.9.2 → 2026.9.4

package/dist/{setup-surface-B2yZ8KGc.js → setup-surface-bcluelBI.js}

@@ -1,15 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as requiresExplicitMatrixDefaultAccount, s as resolveMatrixEnvAuthReadiness } from "./account-selection-DA-jfx22.js";
+import { c as resolveMatrixEnvAuthReadiness, r as requiresExplicitMatrixDefaultAccount } from "./account-selection-Bbtc483D.js";
 import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.js";
-import { i as resolveMatrixAccount, r as resolveDefaultMatrixAccountId, t as listMatrixAccountIds } from "./accounts-DR1c4xF_.js";
+import { i as resolveMatrixAccount, r as resolveDefaultMatrixAccountId, t as listMatrixAccountIds } from "./accounts-GwSAk9vY.js";
 import { n as isMatrixRoomId } from "./target-ids-Nwx7cMVE.js";
 import { r as updateMatrixAccountConfig } from "./config-update-BnX26jCO.js";
-import { a as moveSingleMatrixAccountConfigToNamedAccount, i as createMatrixSetupDmPolicy } from "./setup-core-XkIfQ65J.js";
+import { a as moveSingleMatrixAccountConfigToNamedAccount, i as createMatrixSetupDmPolicy } from "./setup-core-8keb-Yre.js";
 import { n as validateMatrixHomeserverUrl, r as isPrivateOrLoopbackHost, t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.js";
 import { n as ensureMatrixSdkInstalled, r as isMatrixSdkAvailable } from "./deps-mtxF2mHI.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringifiedOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
-import { formatDocsLink, hasConfiguredSecretInput, mergeAllowFromEntries, normalizeAccountId as normalizeAccountId$1, promptAccountId, promptChannelAccessConfig, splitSetupEntries } from "openclaw/plugin-sdk/setup";
+import { formatDocsLink, hasConfiguredSecretInput, mergeAllowFromEntries, normalizeAccountId as normalizeAccountId$1, promptAccountId, promptChannelAccessConfig, setSetupChannelEnabled, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 import { isPrivateNetworkOptInEnabled } from "openclaw/plugin-sdk/ssrf-policy";
 //#region extensions/matrix/src/onboarding.ts
 const channel = "matrix";
@@ -91,7 +91,7 @@ async function promptMatrixAllowFrom(params) {
 			pending.push(part);
 		}
 		if (pending.length > 0) {
-			const { resolveMatrixTargets } = await import("./resolve-targets-B64O69Nd.js").then((n) => n.n);
+			const { resolveMatrixTargets } = await import("./resolve-targets-K8D0HWPX.js").then((n) => n.n);
 			const results = await resolveMatrixTargets({
 				cfg,
 				accountId,
@@ -211,7 +211,7 @@ async function configureMatrixAccessPrompts(params) {
 						resolvedIds.push(cleaned);
 						continue;
 					}
-					const { listMatrixDirectoryGroupsLive } = await import("./directory-live-DLUgWBhA.js").then((n) => n.t);
+					const { listMatrixDirectoryGroupsLive } = await import("./directory-live-B8-GAVcc.js").then((n) => n.t);
 					const matches = await listMatrixDirectoryGroupsLive({
 						cfg: next,
 						accountId: params.accountId,
@@ -464,7 +464,7 @@ const matrixOnboardingAdapter = {
 		});
 	},
 	afterConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
-		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-S_loyUyM.js");
+		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-sVqkwtSY.js");
 		await runMatrixSetupBootstrapAfterConfigWrite({
 			previousCfg,
 			cfg,
@@ -473,16 +473,7 @@ const matrixOnboardingAdapter = {
 		});
 	},
 	dmPolicy,
-	disable: (cfg) => ({
-		...cfg,
-		channels: {
-			...cfg.channels,
-			matrix: {
-				...cfg.channels?.["matrix"],
-				enabled: false
-			}
-		}
-	})
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
 };
 //#endregion
 //#region extensions/matrix/src/setup-surface.ts

package/dist/{startup-verification-1Ney1mmI.js → startup-verification-BTSf31hS.js}

@@ -1,5 +1,6 @@
 import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { M as resolveMatrixSqliteStateEnv, l as resolveMatrixStoragePaths, o as recordCurrentStorageMetaDeviceId } from "./storage-BVf4uucD.js";
+import { k as resolveMatrixSqliteStateEnv } from "./storage-metadata-DYArLcq1.js";
+import { o as resolveMatrixStoragePaths, r as recordCurrentStorageMetaDeviceId } from "./storage-CV-pfV_2.js";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";

package/dist/storage-CV-pfV_2.js

@@ -0,0 +1,320 @@
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
+import { n as isMatrixActiveTokenRootDirectory, r as resolveMatrixAccountStorageRoot } from "./storage-paths-DVCANXTc.js";
+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-DYArLcq1.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import path from "node:path";
+import fs from "node:fs";
+import { loadJsonFile } from "openclaw/plugin-sdk/json-store";
+import os from "node:os";
+//#region extensions/matrix/src/matrix/client/storage.ts
+const DEFAULT_ACCOUNT_KEY = "default";
+const STORAGE_META_FILENAME = "storage-meta.json";
+const THREAD_BINDINGS_FILENAME = "thread-bindings.json";
+function openStorageMetaStore(rootDir) {
+	return getMatrixRuntime().state.openSyncKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
+}
+function scoreStorageRoot(rootDir, metadata = readStoredRootMetadata(rootDir)) {
+	let score = 0;
+	if (Object.keys(metadata).length > 0) score += 1;
+	if (metadata.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.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);
+	return score;
+}
+function resolveStorageRootMtimeMs(rootDir) {
+	try {
+		return fs.statSync(rootDir).mtimeMs;
+	} catch {
+		return 0;
+	}
+}
+function readStoredRootMetadata(rootDir) {
+	if (fs.existsSync(path.join(rootDir, "state", "openclaw.sqlite"))) try {
+		const stored = normalizeMatrixStorageMetadata(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);
+	if (metadata.homeserver && metadata.homeserver !== params.homeserver) return false;
+	if (metadata.userId && metadata.userId !== params.userId) return false;
+	if (metadata.accountId && normalizeAccountId(metadata.accountId) !== normalizeAccountId(params.accountKey)) return false;
+	if (params.deviceId && metadata.deviceId && metadata.deviceId.trim() && metadata.deviceId.trim() !== params.deviceId.trim()) return false;
+	if (params.requireExplicitDeviceMatch && params.deviceId && (!metadata.deviceId || metadata.deviceId.trim() !== params.deviceId.trim())) return false;
+	return true;
+}
+function resolvePreferredMatrixStorageRoot(params) {
+	const canonical = {
+		rootDir: params.canonicalRootDir,
+		tokenHash: params.canonicalTokenHash
+	};
+	const deviceId = params.deviceId?.trim();
+	if (!deviceId) return canonical;
+	const canonicalMetadata = 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 bestCurrentMtimeMs = resolveStorageRootMtimeMs(params.canonicalRootDir);
+	let best = {
+		rootDir: params.canonicalRootDir,
+		tokenHash: params.canonicalTokenHash,
+		score: bestCurrentScore,
+		mtimeMs: bestCurrentMtimeMs
+	};
+	let siblingEntries;
+	try {
+		siblingEntries = fs.readdirSync(parentDir, { withFileTypes: true });
+	} catch {
+		return {
+			rootDir: best.rootDir,
+			tokenHash: best.tokenHash
+		};
+	}
+	const compatiblePopulatedSiblings = [];
+	const populatedTokenHashes = bestCurrentScore > 0 ? [params.canonicalTokenHash] : [];
+	for (const entry of siblingEntries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === params.canonicalTokenHash) continue;
+		if (!isMatrixActiveTokenRootDirectory(entry.name)) continue;
+		const candidateRootDir = path.join(parentDir, entry.name);
+		if (!isCompatibleStorageRoot({
+			candidateRootDir,
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accountKey: params.accountKey,
+			deviceId,
+			requireExplicitDeviceMatch: true
+		})) continue;
+		const candidateScore = scoreStorageRoot(candidateRootDir);
+		if (candidateScore <= 0) continue;
+		populatedTokenHashes.push(entry.name);
+		compatiblePopulatedSiblings.push({
+			rootDir: candidateRootDir,
+			tokenHash: entry.name,
+			score: candidateScore,
+			mtimeMs: resolveStorageRootMtimeMs(candidateRootDir)
+		});
+	}
+	for (const candidate of compatiblePopulatedSiblings) if (candidate.score > best.score || best.rootDir !== params.canonicalRootDir && candidate.score === best.score && candidate.mtimeMs > best.mtimeMs) best = {
+		rootDir: candidate.rootDir,
+		tokenHash: candidate.tokenHash,
+		score: candidate.score,
+		mtimeMs: candidate.mtimeMs
+	};
+	if (populatedTokenHashes.length > 1) getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" }).warn("matrix: multiple populated token-hash storage roots detected", {
+		parentDir,
+		canonicalTokenHash: params.canonicalTokenHash,
+		selectedTokenHash: best.tokenHash,
+		populatedTokenHashes,
+		populatedSiblingTokenHashes: compatiblePopulatedSiblings.map((root) => root.tokenHash),
+		populatedRootCount: populatedTokenHashes.length
+	});
+	return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+}
+function resolveMatrixStoragePaths(params) {
+	const env = params.env ?? process.env;
+	const stateDir = params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir);
+	const canonical = resolveMatrixAccountStorageRoot({
+		stateDir,
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accessToken: params.accessToken,
+		accountId: params.accountId
+	});
+	const { rootDir, tokenHash } = resolvePreferredMatrixStorageRoot({
+		canonicalRootDir: canonical.rootDir,
+		canonicalTokenHash: canonical.tokenHash,
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountKey: canonical.accountKey,
+		deviceId: params.deviceId
+	});
+	return {
+		rootDir,
+		storagePath: path.join(rootDir, "bot-storage.json"),
+		cryptoPath: path.join(rootDir, "crypto"),
+		recoveryKeyPath: path.join(rootDir, MATRIX_RECOVERY_KEY_FILENAME),
+		idbSnapshotPath: path.join(rootDir, MATRIX_IDB_SNAPSHOT_FILENAME),
+		accountKey: canonical.accountKey,
+		tokenHash
+	};
+}
+function resolveMatrixStateFilePath(params) {
+	const storagePaths = resolveMatrixStoragePaths({
+		homeserver: params.auth.homeserver,
+		userId: params.auth.userId,
+		accessToken: params.auth.accessToken,
+		accountId: params.accountId ?? params.auth.accountId,
+		deviceId: params.auth.deviceId,
+		env: params.env,
+		stateDir: params.stateDir
+	});
+	return path.join(storagePaths.rootDir, params.filename);
+}
+async function maybeMigrateLegacyStorage(params) {
+	const hasAccountScopedLegacyStorageFile = fs.existsSync(params.storagePaths.storagePath);
+	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./sync-cache-state-C-mhj3xb.js").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));
+	if (!hasAccountScopedLegacyStorage && !hasAccountScopedRecoveryKey && !hasAccountScopedLegacyCryptoMigration) return;
+	const logger = getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" });
+	fs.mkdirSync(params.storagePaths.rootDir, { recursive: true });
+	const moved = [];
+	const pendingArchives = [];
+	const skippedExistingTargets = [];
+	try {
+		if (hasAccountScopedLegacyStorage) await migrateLegacySyncCacheToSqlite({
+			sourceRootDir: params.storagePaths.rootDir,
+			sourcePath: params.storagePaths.storagePath,
+			targetRootDir: params.storagePaths.rootDir,
+			label: "account sync cache",
+			moved,
+			pendingArchives
+		});
+		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"
+			});
+		}
+	} 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 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-C-mhj3xb.js").then((n) => n.s);
+	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 rollbackLegacyMoves(moved) {
+	for (const entry of moved.toReversed()) try {
+		if (!fs.existsSync(entry.targetPath) || fs.existsSync(entry.sourcePath)) continue;
+		fs.renameSync(entry.targetPath, entry.sourcePath);
+	} catch (err) {
+		return `${entry.label} (${entry.targetPath} -> ${entry.sourcePath}): ${String(err)}`;
+	}
+	return null;
+}
+function writeStoredRootMetadata(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 claimCurrentTokenStorageState(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()
+	});
+}
+function recordCurrentStorageMetaDeviceId(params) {
+	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()
+	});
+}
+function repairCurrentTokenStorageMetaDeviceId(params) {
+	return writeStorageMeta({
+		storagePaths: resolveMatrixStoragePaths({
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accessToken: params.accessToken,
+			accountId: params.accountId,
+			env: params.env,
+			stateDir: params.stateDir
+		}),
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountId: params.accountId,
+		deviceId: params.deviceId
+	});
+}
+//#endregion
+export { resolveMatrixStateFilePath as a, repairCurrentTokenStorageMetaDeviceId as i, maybeMigrateLegacyStorage as n, resolveMatrixStoragePaths as o, recordCurrentStorageMetaDeviceId as r, writeStorageMeta as s, claimCurrentTokenStorageState as t };