@openclaw/matrix 2026.5.27 → 2026.5.28-beta.2

package/dist/{sdk-BKBZkPKt.js → sdk-DTo3Hzko.js}

@@ -1,23 +1,22 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { t as isRecord } from "./record-shared-CvzjvHRn.js";
 import { n as formatMatrixErrorReason, r as isMatrixNotFoundError, t as formatMatrixErrorMessage } from "./errors-C47hvAF8.js";
 import { t as claimCurrentTokenStorageState } from "./storage-onzulLbU.js";
+import { c as createMatrixStartupAbortError, d as ConsoleLogger, f as LogService, p as noop, u as throwIfMatrixStartupAborted } from "./shared-CZ622gSf.js";
+import { a as matrixEventToRaw, n as createMatrixGuardedFetch, o as parseMxc, t as MatrixAuthedHttpClient } from "./http-client-DJNugFzO.js";
 import { n as resolveMatrixRoomKeyBackupReadinessError } from "./backup-health-Dm_YMVFT.js";
+import { createMatrixJsSdkClientLogger } from "./logging-BD9Wmviv.js";
 import { t as createAsyncLock } from "./async-lock-BcLS4KOc.js";
-import { a as ConsoleLogger, i as throwIfMatrixStartupAborted, n as createMatrixStartupAbortError, o as LogService, s as noop } from "./startup-abort-Bs0Up_Qx.js";
-import { t as createMatrixJsSdkClientLogger } from "./logging-BR-gcAjp.js";
-import { a as matrixEventToRaw, n as createMatrixGuardedFetch, o as parseMxc, t as MatrixAuthedHttpClient } from "./http-client-DJNugFzO.js";
 import { n as isMatrixReadySyncState, r as isMatrixTerminalSyncState } from "./sync-state-CWbp0QSY.js";
+import { n as isRepairableSecretStorageAccessError, r as MATRIX_IDB_PERSIST_INTERVAL_MS, t as MatrixRecoveryKeyStore } from "./recovery-key-store-B3-wYrMU.js";
 import { normalizeNullableString, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readFileSync } from "node:fs";
 import path from "node:path";
-import { loadJsonFile, saveJsonFile, writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
+import { writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import fs$1 from "node:fs/promises";
 import { EventEmitter } from "node:events";
 import { Category, ClientEvent, Filter, MatrixEventEvent, MemoryStore, Preset, SyncAccumulator, createClient } from "matrix-js-sdk/lib/matrix.js";
 import { VerificationMethod } from "matrix-js-sdk/lib/types.js";
-import fs$1 from "node:fs/promises";
-import { decodeRecoveryKey } from "matrix-js-sdk/lib/crypto-api/recovery-key.js";
 //#region extensions/matrix/src/matrix/client/file-sync-store.ts
 const STORE_VERSION = 1;
 const PERSIST_DEBOUNCE_MS = 250;
@@ -207,302 +206,13 @@ var FileBackedMatrixSyncStore = class extends MemoryStore {
 	}
 };
 //#endregion
-//#region extensions/matrix/src/matrix/sdk/idb-persistence-lock.ts
-const MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
-const IDB_SNAPSHOT_LOCK_STALE_MS = 5 * 6e4;
-const IDB_SNAPSHOT_LOCK_RETRY_BASE = {
-	factor: 2,
-	minTimeout: 50,
-	maxTimeout: 5e3,
-	randomize: true
-};
-function computeRetryDelayMs(retries, attempt) {
-	return Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** attempt));
-}
-function computeMinimumRetryWindowMs(retries) {
-	let total = 0;
-	const attempts = Math.max(1, retries.retries + 1);
-	for (let attempt = 0; attempt < attempts - 1; attempt += 1) total += computeRetryDelayMs(retries, attempt);
-	return total;
-}
-function resolveRetriesForMinimumWindowMs(retries, minimumWindowMs) {
-	const resolved = {
-		...retries,
-		retries: 0
-	};
-	while (computeMinimumRetryWindowMs(resolved) < minimumWindowMs) resolved.retries += 1;
-	return resolved;
-}
-const MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS = {
-	retries: resolveRetriesForMinimumWindowMs(IDB_SNAPSHOT_LOCK_RETRY_BASE, MATRIX_IDB_PERSIST_INTERVAL_MS),
-	stale: IDB_SNAPSHOT_LOCK_STALE_MS
-};
-//#endregion
-//#region extensions/matrix/src/matrix/sdk/recovery-key-store.ts
-function isRepairableSecretStorageAccessError(err) {
-	const message = formatMatrixErrorReason(err);
-	if (!message) return false;
-	if (message.includes("getsecretstoragekey callback returned falsey")) return true;
-	if (message.includes("decrypting secret") && message.includes("bad mac")) return true;
-	return false;
-}
-var MatrixRecoveryKeyStore = class {
-	constructor(recoveryKeyPath) {
-		this.recoveryKeyPath = recoveryKeyPath;
-		this.secretStorageKeyCache = /* @__PURE__ */ new Map();
-		this.stagedRecoveryKey = null;
-		this.stagedRecoveryKeyUsed = false;
-		this.stagedCacheKeyIds = /* @__PURE__ */ new Set();
-	}
-	buildCryptoCallbacks() {
-		return {
-			getSecretStorageKey: async ({ keys }) => {
-				const requestedKeyIds = Object.keys(keys ?? {});
-				if (requestedKeyIds.length === 0) return null;
-				const staged = this.resolveStagedSecretStorageKey(requestedKeyIds);
-				if (staged) return staged;
-				for (const keyId of requestedKeyIds) {
-					const cached = this.secretStorageKeyCache.get(keyId);
-					if (cached) return [keyId, new Uint8Array(cached.key)];
-				}
-				const stored = this.loadStoredRecoveryKey();
-				if (!stored?.privateKeyBase64) return null;
-				const privateKey = new Uint8Array(Buffer.from(stored.privateKeyBase64, "base64"));
-				if (privateKey.length === 0) return null;
-				if (stored.keyId && requestedKeyIds.includes(stored.keyId)) {
-					this.rememberSecretStorageKey(stored.keyId, privateKey, stored.keyInfo);
-					return [stored.keyId, privateKey];
-				}
-				const firstRequestedKeyId = requestedKeyIds[0];
-				if (!firstRequestedKeyId) return null;
-				this.rememberSecretStorageKey(firstRequestedKeyId, privateKey, stored.keyInfo);
-				return [firstRequestedKeyId, privateKey];
-			},
-			cacheSecretStorageKey: (keyId, keyInfo, key) => {
-				const privateKey = new Uint8Array(key);
-				const normalizedKeyInfo = {
-					passphrase: keyInfo?.passphrase,
-					name: typeof keyInfo?.name === "string" ? keyInfo.name : void 0
-				};
-				this.rememberSecretStorageKey(keyId, privateKey, normalizedKeyInfo);
-				const stored = this.loadStoredRecoveryKey();
-				this.saveRecoveryKeyToDisk({
-					keyId,
-					keyInfo: normalizedKeyInfo,
-					privateKey,
-					encodedPrivateKey: stored?.encodedPrivateKey
-				});
-			}
-		};
-	}
-	getRecoveryKeySummary() {
-		const stored = this.loadStoredRecoveryKey();
-		if (!stored) return null;
-		return {
-			encodedPrivateKey: stored.encodedPrivateKey,
-			keyId: stored.keyId,
-			createdAt: stored.createdAt
-		};
-	}
-	resolveEncodedRecoveryKeyInput(params) {
-		const encodedPrivateKey = params.encodedPrivateKey.trim();
-		if (!encodedPrivateKey) throw new Error("Matrix recovery key is required");
-		let privateKey;
-		try {
-			privateKey = decodeRecoveryKey(encodedPrivateKey);
-		} catch (err) {
-			throw new Error(`Invalid Matrix recovery key: ${formatMatrixErrorMessage(err)}`, { cause: err });
-		}
-		const keyId = typeof params.keyId === "string" && params.keyId.trim() ? params.keyId.trim() : null;
-		return {
-			encodedPrivateKey,
-			privateKey,
-			keyId,
-			keyInfo: params.keyInfo ?? this.loadStoredRecoveryKey()?.keyInfo
-		};
-	}
-	storeEncodedRecoveryKey(params) {
-		const prepared = this.resolveEncodedRecoveryKeyInput(params);
-		this.saveRecoveryKeyToDisk({
-			keyId: prepared.keyId,
-			keyInfo: prepared.keyInfo,
-			privateKey: prepared.privateKey,
-			encodedPrivateKey: prepared.encodedPrivateKey
-		});
-		if (prepared.keyId) this.rememberSecretStorageKey(prepared.keyId, prepared.privateKey, prepared.keyInfo);
-		return this.getRecoveryKeySummary() ?? {};
-	}
-	stageEncodedRecoveryKey(params) {
-		const prepared = this.resolveEncodedRecoveryKeyInput(params);
-		this.discardStagedRecoveryKey();
-		this.stagedRecoveryKey = {
-			version: 1,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-			keyId: prepared.keyId,
-			encodedPrivateKey: prepared.encodedPrivateKey,
-			privateKeyBase64: Buffer.from(prepared.privateKey).toString("base64"),
-			keyInfo: prepared.keyInfo
-		};
-	}
-	hasStagedRecoveryKeyBeenUsed() {
-		return this.stagedRecoveryKeyUsed;
-	}
-	commitStagedRecoveryKey(params) {
-		if (!this.stagedRecoveryKey) return this.getRecoveryKeySummary();
-		const staged = this.stagedRecoveryKey;
-		const privateKey = new Uint8Array(Buffer.from(staged.privateKeyBase64, "base64"));
-		const keyId = typeof params?.keyId === "string" && params.keyId.trim() ? params.keyId.trim() : staged.keyId;
-		this.saveRecoveryKeyToDisk({
-			keyId,
-			keyInfo: params?.keyInfo ?? staged.keyInfo,
-			privateKey,
-			encodedPrivateKey: staged.encodedPrivateKey
-		});
-		this.clearStagedRecoveryKeyTracking();
-		return this.getRecoveryKeySummary();
-	}
-	discardStagedRecoveryKey() {
-		for (const keyId of this.stagedCacheKeyIds) this.secretStorageKeyCache.delete(keyId);
-		this.clearStagedRecoveryKeyTracking();
-	}
-	async bootstrapSecretStorageWithRecoveryKey(crypto, options = {}) {
-		let status = null;
-		const getSecretStorageStatus = crypto.getSecretStorageStatus;
-		if (typeof getSecretStorageStatus === "function") try {
-			status = await getSecretStorageStatus.call(crypto);
-		} catch (err) {
-			LogService.warn("MatrixClientLite", "Failed to read secret storage status:", err);
-		}
-		const hasDefaultSecretStorageKey = Boolean(status?.defaultKeyId);
-		const hasKnownInvalidSecrets = Object.values(status?.secretStorageKeyValidityMap ?? {}).some((valid) => !valid);
-		let generatedRecoveryKey = false;
-		const storedRecovery = this.loadStoredRecoveryKey();
-		const stagedRecovery = this.stagedRecoveryKey;
-		const sourceRecovery = options.forceNewRecoveryKey === true ? null : stagedRecovery ?? storedRecovery;
-		let recoveryKey = sourceRecovery ? {
-			keyInfo: sourceRecovery.keyInfo,
-			privateKey: new Uint8Array(Buffer.from(sourceRecovery.privateKeyBase64, "base64")),
-			encodedPrivateKey: sourceRecovery.encodedPrivateKey
-		} : null;
-		if (recoveryKey && status?.defaultKeyId) {
-			const defaultKeyId = status.defaultKeyId;
-			if (!stagedRecovery) {
-				this.rememberSecretStorageKey(defaultKeyId, recoveryKey.privateKey, recoveryKey.keyInfo);
-				if (storedRecovery && storedRecovery.keyId !== defaultKeyId) this.saveRecoveryKeyToDisk({
-					keyId: defaultKeyId,
-					keyInfo: recoveryKey.keyInfo,
-					privateKey: recoveryKey.privateKey,
-					encodedPrivateKey: recoveryKey.encodedPrivateKey
-				});
-			}
-		}
-		const ensureRecoveryKey = async () => {
-			if (recoveryKey) {
-				if (stagedRecovery) this.stagedRecoveryKeyUsed = true;
-				return recoveryKey;
-			}
-			if (typeof crypto.createRecoveryKeyFromPassphrase !== "function") throw new Error("Matrix crypto backend does not support recovery key generation (createRecoveryKeyFromPassphrase missing)");
-			recoveryKey = await crypto.createRecoveryKeyFromPassphrase();
-			this.saveRecoveryKeyToDisk(recoveryKey);
-			generatedRecoveryKey = true;
-			return recoveryKey;
-		};
-		const shouldRecreateSecretStorage = options.forceNewSecretStorage === true || !hasDefaultSecretStorageKey || !recoveryKey && status?.ready === false || hasKnownInvalidSecrets;
-		if (hasKnownInvalidSecrets) recoveryKey = null;
-		const secretStorageOptions = { setupNewKeyBackup: options.setupNewKeyBackup === true };
-		if (shouldRecreateSecretStorage) {
-			secretStorageOptions.setupNewSecretStorage = true;
-			secretStorageOptions.createSecretStorageKey = ensureRecoveryKey;
-		}
-		try {
-			await crypto.bootstrapSecretStorage(secretStorageOptions);
-		} catch (err) {
-			if (!(options.allowSecretStorageRecreateWithoutRecoveryKey === true && hasDefaultSecretStorageKey && isRepairableSecretStorageAccessError(err))) throw err;
-			recoveryKey = null;
-			LogService.warn("MatrixClientLite", "Secret storage exists on the server but local recovery material cannot unlock it; recreating secret storage during explicit bootstrap.");
-			await crypto.bootstrapSecretStorage({
-				setupNewSecretStorage: true,
-				setupNewKeyBackup: options.setupNewKeyBackup === true,
-				createSecretStorageKey: ensureRecoveryKey
-			});
-		}
-		if (generatedRecoveryKey && this.recoveryKeyPath) LogService.warn("MatrixClientLite", `Generated Matrix recovery key and saved it to ${this.recoveryKeyPath}. Keep this file secure.`);
-	}
-	clearStagedRecoveryKeyTracking() {
-		this.stagedRecoveryKey = null;
-		this.stagedRecoveryKeyUsed = false;
-		this.stagedCacheKeyIds.clear();
-	}
-	resolveStagedSecretStorageKey(requestedKeyIds) {
-		const staged = this.stagedRecoveryKey;
-		if (!staged?.privateKeyBase64) return null;
-		const privateKey = new Uint8Array(Buffer.from(staged.privateKeyBase64, "base64"));
-		if (privateKey.length === 0) return null;
-		const keyId = staged.keyId && requestedKeyIds.includes(staged.keyId) ? staged.keyId : requestedKeyIds[0];
-		if (!keyId) return null;
-		this.rememberStagedSecretStorageKey(keyId, privateKey, staged.keyInfo);
-		this.stagedCacheKeyIds.add(keyId);
-		return [keyId, privateKey];
-	}
-	rememberStagedSecretStorageKey(keyId, key, keyInfo) {
-		this.stagedRecoveryKeyUsed = true;
-		this.rememberSecretStorageKey(keyId, key, keyInfo);
-	}
-	rememberSecretStorageKey(keyId, key, keyInfo) {
-		if (!keyId.trim()) return;
-		this.secretStorageKeyCache.set(keyId, {
-			key: new Uint8Array(key),
-			keyInfo
-		});
-	}
-	loadStoredRecoveryKey() {
-		if (!this.recoveryKeyPath) return null;
-		try {
-			const parsed = loadJsonFile(this.recoveryKeyPath);
-			if (parsed?.version !== 1 || typeof parsed.createdAt !== "string" || typeof parsed.privateKeyBase64 !== "string" || !parsed.privateKeyBase64.trim()) return null;
-			return {
-				version: 1,
-				createdAt: parsed.createdAt,
-				keyId: typeof parsed.keyId === "string" ? parsed.keyId : null,
-				encodedPrivateKey: typeof parsed.encodedPrivateKey === "string" ? parsed.encodedPrivateKey : void 0,
-				privateKeyBase64: parsed.privateKeyBase64,
-				keyInfo: parsed.keyInfo && typeof parsed.keyInfo === "object" ? {
-					passphrase: parsed.keyInfo.passphrase,
-					name: typeof parsed.keyInfo.name === "string" ? parsed.keyInfo.name : void 0
-				} : void 0
-			};
-		} catch {
-			return null;
-		}
-	}
-	saveRecoveryKeyToDisk(params) {
-		if (!this.recoveryKeyPath) return;
-		try {
-			const payload = {
-				version: 1,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				keyId: typeof params.keyId === "string" ? params.keyId : null,
-				encodedPrivateKey: params.encodedPrivateKey,
-				privateKeyBase64: Buffer.from(params.privateKey).toString("base64"),
-				keyInfo: params.keyInfo ? {
-					passphrase: params.keyInfo.passphrase,
-					name: params.keyInfo.name
-				} : void 0
-			};
-			saveJsonFile(this.recoveryKeyPath, payload);
-		} catch (err) {
-			LogService.warn("MatrixClientLite", "Failed to persist recovery key:", err);
-		}
-	}
-};
-//#endregion
 //#region extensions/matrix/src/matrix/sdk.ts
-var sdk_exports = /* @__PURE__ */ __exportAll({
-	ConsoleLogger: () => ConsoleLogger,
-	LogService: () => LogService,
-	MatrixClient: () => MatrixClient
-});
 const MATRIX_STATUS_DIAGNOSTIC_TIMEOUT_MS = 1e4;
+const DEFAULT_MATRIX_LOCAL_TIMEOUT_MS = 6e4;
+function resolveMatrixLocalTimeoutMs(raw) {
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return DEFAULT_MATRIX_LOCAL_TIMEOUT_MS;
+	return Math.max(1, Math.floor(raw));
+}
 function unresolvedMatrixRoomKeyBackupStatus() {
 	return {
 		serverVersion: null,
@@ -578,7 +288,7 @@ function createMatrixExplicitBootstrapOptions(params) {
 let loadedMatrixCryptoRuntime = null;
 let matrixCryptoRuntimePromise = null;
 async function loadMatrixCryptoRuntime() {
-	matrixCryptoRuntimePromise ??= import("./crypto-runtime-BcQzS9DV.js").then((runtime) => {
+	matrixCryptoRuntimePromise ??= import("./crypto-runtime-CpQeK8kh.js").then((runtime) => {
 		loadedMatrixCryptoRuntime = runtime;
 		return runtime;
 	});
@@ -616,7 +326,7 @@ var MatrixClient = class {
 			ssrfPolicy: opts.ssrfPolicy,
 			dispatcherPolicy: opts.dispatcherPolicy
 		});
-		this.localTimeoutMs = Math.max(1, opts.localTimeoutMs ?? 6e4);
+		this.localTimeoutMs = resolveMatrixLocalTimeoutMs(opts.localTimeoutMs);
 		this.initialSyncLimit = opts.initialSyncLimit;
 		this.syncFilter = opts.syncFilter;
 		this.encryptionEnabled = opts.encryption === true;
@@ -1701,4 +1411,4 @@ var MatrixClient = class {
 	}
 };
 //#endregion
-export { MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS as i, sdk_exports as n, isRepairableSecretStorageAccessError as r, MatrixClient as t };
+export { ConsoleLogger, LogService, MatrixClient };

package/dist/{send-DivaFHb1.js → send-DX-aOjPW.js}

@@ -229,7 +229,7 @@ function buildPollResponseContent(pollEventId, answerIds) {
 //#region extensions/matrix/src/matrix/send/client.ts
 let matrixSendClientRuntimePromise = null;
 async function loadMatrixSendClientRuntime() {
-	matrixSendClientRuntimePromise ??= import("./client-bootstrap-DK9i3KZ5.js").then((n) => n.t);
+	matrixSendClientRuntimePromise ??= import("./client-bootstrap-BtddaQGi.js").then((n) => n.t);
 	return await matrixSendClientRuntimePromise;
 }
 function resolveMediaMaxBytes(accountId, cfg) {

package/dist/{setup-bootstrap-ClcP-tDQ.js → setup-bootstrap-D9XeWu6O.js}

@@ -1,7 +1,7 @@
 import { a as hasExplicitMatrixAccountConfig, c as resolveMatrixAccountConfig } from "./config-paths-ZBCMwSos.js";
-import "./setup-core-s8s_Qudu.js";
+import "./setup-core-BU4BO6DB.js";
 import { t as formatMatrixErrorMessage } from "./errors-C47hvAF8.js";
-import { n as bootstrapMatrixVerification } from "./verification-Dar6QON4.js";
+import { n as bootstrapMatrixVerification } from "./verification-CUSz9cFP.js";
 //#region extensions/matrix/src/setup-bootstrap.ts
 async function maybeBootstrapNewEncryptedMatrixAccount(params) {
 	const accountConfig = resolveMatrixAccountConfig({

package/dist/{setup-core-s8s_Qudu.js → setup-core-BU4BO6DB.js}

@@ -8,6 +8,7 @@ import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "opencl
 import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input-runtime";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/routing";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, addWildcardAllowFrom, applyAccountNameToChannelSection, normalizeAccountId as normalizeAccountId$2, normalizeAllowFromEntries, normalizeSecretInputString, prepareScopedSetupConfig } from "openclaw/plugin-sdk/setup";
+import { resolveOptionalIntegerOption } from "openclaw/plugin-sdk/number-runtime";
 import { coerceSecretRef as coerceSecretRef$1 } from "openclaw/plugin-sdk/secret-ref-runtime";
 //#region extensions/matrix/src/matrix/accounts.ts
 function clean(value) {
@@ -272,7 +273,11 @@ function updateMatrixAccountConfig(cfg, accountId, patch) {
 		else delete nextAccount.network;
 	}
 	if (patch.initialSyncLimit !== void 0) if (patch.initialSyncLimit === null) delete nextAccount.initialSyncLimit;
-	else nextAccount.initialSyncLimit = Math.max(0, Math.floor(patch.initialSyncLimit));
+	else {
+		const initialSyncLimit = resolveOptionalIntegerOption(patch.initialSyncLimit, { min: 0 });
+		if (initialSyncLimit === void 0) delete nextAccount.initialSyncLimit;
+		else nextAccount.initialSyncLimit = initialSyncLimit;
+	}
 	if (patch.encryption !== void 0) if (patch.encryption === null) delete nextAccount.encryption;
 	else nextAccount.encryption = patch.encryption;
 	if (patch.allowBots !== void 0) if (patch.allowBots === null) delete nextAccount.allowBots;
@@ -664,7 +669,7 @@ const matrixSetupAdapter = {
 		input
 	}),
 	afterAccountConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
-		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-ClcP-tDQ.js");
+		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-D9XeWu6O.js");
 		await runMatrixSetupBootstrapAfterConfigWrite({
 			previousCfg,
 			cfg,

package/dist/setup-plugin-api.js

@@ -1,5 +1,5 @@
-import { g as resolveMatrixAccount, n as matrixSetupAdapter, t as createMatrixSetupWizardProxy } from "./setup-core-s8s_Qudu.js";
-import { r as matrixConfigAdapter, t as MatrixChannelConfigSchema } from "./config-schema-DuSRVdwT.js";
+import { g as resolveMatrixAccount, n as matrixSetupAdapter, t as createMatrixSetupWizardProxy } from "./setup-core-BU4BO6DB.js";
+import { r as matrixConfigAdapter, t as MatrixChannelConfigSchema } from "./config-schema-CRsTmqKY.js";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 const matrixSetupPlugin = {
 	id: "matrix",
@@ -13,7 +13,7 @@ const matrixSetupPlugin = {
 		order: 70,
 		quickstartAllowFrom: true
 	},
-	setupWizard: createMatrixSetupWizardProxy(async () => ({ matrixSetupWizard: (await import("./setup-surface-BOt10HNf.js").then((n) => n.t)).matrixSetupWizard })),
+	setupWizard: createMatrixSetupWizardProxy(async () => ({ matrixSetupWizard: (await import("./setup-surface-BIFSsw6q.js").then((n) => n.t)).matrixSetupWizard })),
 	setup: matrixSetupAdapter,
 	capabilities: {
 		chatTypes: [

package/dist/{setup-surface-BOt10HNf.js → setup-surface-BIFSsw6q.js}

@@ -2,9 +2,9 @@ import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { n as requiresExplicitMatrixDefaultAccount } from "./account-selection-C3arLOhC.js";
 import { c as resolveMatrixAccountConfig, t as resolveMatrixConfigFieldPath } from "./config-paths-ZBCMwSos.js";
 import { r as resolveMatrixEnvAuthReadiness } from "./env-auth-DIzOApj0.js";
-import { g as resolveMatrixAccount, h as resolveDefaultMatrixAccountId, i as moveSingleMatrixAccountConfigToNamedAccount, l as updateMatrixAccountConfig, p as listMatrixAccountIds, r as resolveMatrixSetupDmAllowFrom } from "./setup-core-s8s_Qudu.js";
+import { g as resolveMatrixAccount, h as resolveDefaultMatrixAccountId, i as moveSingleMatrixAccountConfigToNamedAccount, l as updateMatrixAccountConfig, p as listMatrixAccountIds, r as resolveMatrixSetupDmAllowFrom } from "./setup-core-BU4BO6DB.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-CAdiytPJ.js";
+import { n as ensureMatrixSdkInstalled, r as isMatrixSdkAvailable } from "./deps-BVWGd2XS.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringifiedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatDocsLink, hasConfiguredSecretInput, mergeAllowFromEntries, normalizeAccountId as normalizeAccountId$1, promptAccountId, promptChannelAccessConfig, splitSetupEntries } from "openclaw/plugin-sdk/setup";
@@ -104,7 +104,7 @@ async function promptMatrixAllowFrom(params) {
 			pending.push(part);
 		}
 		if (pending.length > 0) {
-			const { resolveMatrixTargets } = await import("./resolve-targets-BPhBqXyj.js").then((n) => n.n);
+			const { resolveMatrixTargets } = await import("./resolve-targets-DaTQqtPq.js").then((n) => n.n);
 			const results = await resolveMatrixTargets({
 				cfg,
 				accountId,
@@ -232,7 +232,7 @@ async function configureMatrixAccessPrompts(params) {
 					resolvedIds.push(cleaned);
 					continue;
 				}
-				const { listMatrixDirectoryGroupsLive } = await import("./directory-live-2-Vb6nss.js").then((n) => n.t);
+				const { listMatrixDirectoryGroupsLive } = await import("./directory-live-kLKfwyDt.js").then((n) => n.t);
 				const matches = await listMatrixDirectoryGroupsLive({
 					cfg: next,
 					accountId: params.accountId,
@@ -507,7 +507,7 @@ const matrixOnboardingAdapter = {
 		});
 	},
 	afterConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
-		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-ClcP-tDQ.js");
+		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-D9XeWu6O.js");
 		await runMatrixSetupBootstrapAfterConfigWrite({
 			previousCfg,
 			cfg,

package/dist/{shared-3K27tl8e.js → shared-CZ622gSf.js}

@@ -3,15 +3,18 @@ import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDe
 import { t as getMatrixScopedEnvVarNames } from "./env-vars-KzaYveuy.js";
 import { i as findMatrixAccountConfig, l as resolveMatrixBaseConfig, o as listNormalizedMatrixAccountIds, t as resolveMatrixConfigFieldPath } from "./config-paths-ZBCMwSos.js";
 import { i as resolveScopedMatrixEnvConfig, n as resolveGlobalMatrixEnvConfig } from "./env-auth-DIzOApj0.js";
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
 import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.js";
 import { r as repairCurrentTokenStorageMetaDeviceId } from "./storage-onzulLbU.js";
-import { o as LogService, t as awaitMatrixStartupWithAbort } from "./startup-abort-Bs0Up_Qx.js";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId as normalizeAccountId$1, normalizeOptionalAccountId, normalizeOptionalAccountId as normalizeOptionalAccountId$1 } from "openclaw/plugin-sdk/account-id";
 import { coerceSecretRef, normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isPrivateNetworkOptInEnabled, ssrfPolicyFromDangerouslyAllowPrivateNetwork as ssrfPolicyFromDangerouslyAllowPrivateNetwork$1 } from "openclaw/plugin-sdk/ssrf-runtime";
+import { resolveOptionalIntegerOption } from "openclaw/plugin-sdk/number-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
+import { format } from "node:util";
+import { redactSensitiveText } from "openclaw/plugin-sdk/logging-core";
 //#region extensions/matrix/src/matrix/client/config.ts
 let matrixAuthClientDepsPromise;
 let matrixCredentialsReadDepsPromise;
@@ -19,7 +22,7 @@ let matrixCredentialsWriteRuntimePromise;
 let matrixSecretInputDepsPromise;
 const MATRIX_AUTH_REQUEST_RETRY_RE = /\b(fetch failed|econnreset|econnrefused|enotfound|etimedout|ehostunreach|enetunreach|eai_again|und_err_|socket hang up|network|headers timeout|body timeout|connect timeout)\b/i;
 async function loadMatrixAuthClientDeps() {
-	matrixAuthClientDepsPromise ??= Promise.all([import("./sdk-BKBZkPKt.js").then((n) => n.n), import("./logging-BR-gcAjp.js").then((n) => n.n)]).then(([sdkModule, loggingModule]) => ({
+	matrixAuthClientDepsPromise ??= Promise.all([import("./sdk-DTo3Hzko.js"), import("./logging-BD9Wmviv.js")]).then(([sdkModule, loggingModule]) => ({
 		MatrixClient: sdkModule.MatrixClient,
 		ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
 	}));
@@ -176,7 +179,7 @@ function readMatrixAccountConfigField(cfg, accountId, account, field, opts) {
 	});
 }
 function clampMatrixInitialSyncLimit(value) {
-	return typeof value === "number" ? Math.max(0, Math.floor(value)) : void 0;
+	return resolveOptionalIntegerOption(value, { min: 0 });
 }
 function buildMatrixNetworkFields(params) {
 	const dispatcherPolicy = params.dispatcherPolicy ?? (params.proxy ? {
@@ -449,6 +452,111 @@ async function backfillMatrixAuthDeviceIdAfterStartup(params) {
 	}, env, params.auth.accountId) === "saved" ? deviceId : void 0;
 }
 //#endregion
+//#region extensions/matrix/src/matrix/sdk/logger.ts
+function noop() {}
+let forceConsoleLogging = false;
+function setMatrixConsoleLogging(enabled) {
+	forceConsoleLogging = enabled;
+}
+function resolveRuntimeLogger(module) {
+	if (forceConsoleLogging) return null;
+	try {
+		return getMatrixRuntime().logging.getChildLogger({ module: `matrix:${module}` });
+	} catch {
+		return null;
+	}
+}
+function formatMessage(module, messageOrObject) {
+	if (messageOrObject.length === 0) return `[${module}]`;
+	return redactSensitiveText(`[${module}] ${format(...messageOrObject)}`);
+}
+var ConsoleLogger = class {
+	emit(level, module, ...messageOrObject) {
+		const runtimeLogger = resolveRuntimeLogger(module);
+		const message = formatMessage(module, messageOrObject);
+		if (runtimeLogger) {
+			if (level === "debug") {
+				runtimeLogger.debug?.(message);
+				return;
+			}
+			runtimeLogger[level](message);
+			return;
+		}
+		if (level === "debug") {
+			console.debug(message);
+			return;
+		}
+		console[level](message);
+	}
+	trace(module, ...messageOrObject) {
+		this.emit("debug", module, ...messageOrObject);
+	}
+	debug(module, ...messageOrObject) {
+		this.emit("debug", module, ...messageOrObject);
+	}
+	info(module, ...messageOrObject) {
+		this.emit("info", module, ...messageOrObject);
+	}
+	warn(module, ...messageOrObject) {
+		this.emit("warn", module, ...messageOrObject);
+	}
+	error(module, ...messageOrObject) {
+		this.emit("error", module, ...messageOrObject);
+	}
+};
+let activeLogger = new ConsoleLogger();
+const LogService = {
+	setLogger(logger) {
+		activeLogger = logger;
+	},
+	trace(module, ...messageOrObject) {
+		activeLogger.trace(module, ...messageOrObject);
+	},
+	debug(module, ...messageOrObject) {
+		activeLogger.debug(module, ...messageOrObject);
+	},
+	info(module, ...messageOrObject) {
+		activeLogger.info(module, ...messageOrObject);
+	},
+	warn(module, ...messageOrObject) {
+		activeLogger.warn(module, ...messageOrObject);
+	},
+	error(module, ...messageOrObject) {
+		activeLogger.error(module, ...messageOrObject);
+	}
+};
+//#endregion
+//#region extensions/matrix/src/matrix/startup-abort.ts
+function createMatrixStartupAbortError() {
+	const error = /* @__PURE__ */ new Error("Matrix startup aborted");
+	error.name = "AbortError";
+	return error;
+}
+function throwIfMatrixStartupAborted(abortSignal) {
+	if (abortSignal?.aborted === true) throw createMatrixStartupAbortError();
+}
+function isMatrixStartupAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+async function awaitMatrixStartupWithAbort(promise, abortSignal) {
+	if (!abortSignal) return await promise;
+	if (abortSignal.aborted) throw createMatrixStartupAbortError();
+	return await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			abortSignal.removeEventListener("abort", onAbort);
+			reject(createMatrixStartupAbortError());
+		};
+		abortSignal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			abortSignal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			abortSignal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+//#endregion
 //#region extensions/matrix/src/matrix/client/shared.ts
 var shared_exports = /* @__PURE__ */ __exportAll({
 	acquireSharedMatrixClient: () => acquireSharedMatrixClient,
@@ -461,7 +569,7 @@ var shared_exports = /* @__PURE__ */ __exportAll({
 });
 let matrixCreateClientDepsPromise;
 async function loadMatrixCreateClientDeps() {
-	matrixCreateClientDepsPromise ??= import("./create-client-hdBEoEIm.js").then((n) => n.n).then((runtime) => ({ createMatrixClient: runtime.createMatrixClient }));
+	matrixCreateClientDepsPromise ??= import("./create-client-D5Ie4y1a.js").then((n) => n.n).then((runtime) => ({ createMatrixClient: runtime.createMatrixClient }));
 	return await matrixCreateClientDepsPromise;
 }
 const sharedClientStates = /* @__PURE__ */ new Map();
@@ -638,4 +746,4 @@ async function releaseSharedClientInstance(client, mode = "stop") {
 	return true;
 }
 //#endregion
-export { shared_exports as a, backfillMatrixAuthDeviceIdAfterStartup as c, resolveMatrixConfigForAccount as d, resolveSharedMatrixClient as i, resolveMatrixAuth as l, releaseSharedClientInstance as n, stopSharedClientForAccount as o, removeSharedClientInstance as r, stopSharedClientInstance as s, acquireSharedMatrixClient as t, resolveMatrixAuthContext as u };
+export { resolveMatrixAuthContext as _, shared_exports as a, createMatrixStartupAbortError as c, ConsoleLogger as d, LogService as f, resolveMatrixAuth as g, backfillMatrixAuthDeviceIdAfterStartup as h, resolveSharedMatrixClient as i, isMatrixStartupAbortError as l, setMatrixConsoleLogging as m, releaseSharedClientInstance as n, stopSharedClientForAccount as o, noop as p, removeSharedClientInstance as r, stopSharedClientInstance as s, acquireSharedMatrixClient as t, throwIfMatrixStartupAborted as u, resolveMatrixConfigForAccount as v };

package/dist/{thread-bindings-CLjJrThw.js → thread-bindings-DjC1mhh_.js}

@@ -1,6 +1,6 @@
 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 { i as resolveMatrixStateFilePath, t as claimCurrentTokenStorageState } from "./storage-onzulLbU.js";
-import { a as sendMessageMatrix } from "./send-DivaFHb1.js";
+import { a as sendMessageMatrix } from "./send-DX-aOjPW.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { registerSessionBindingAdapter, resolveThreadBindingFarewellText, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/thread-bindings-session-runtime";
 import path from "node:path";