@openclaw/matrix 2026.7.2-beta.7 → 2026.7.33

package/README.md

@@ -5,7 +5,7 @@ Official OpenClaw channel plugin for Matrix rooms and direct messages.
 Install from OpenClaw:
 
 ```bash
-openclaw plugins install @openclaw/matrix
+openclaw plugin add @openclaw/matrix
 ```
 
 Configure the Matrix homeserver and bot credentials in OpenClaw. The plugin lets agents join configured rooms, receive messages, and reply through Matrix.

package/dist/{account-selection-kqquRzCf.js → .setup/account-selection-BOQeTqax.mjs}

@@ -1,6 +1,5 @@
-import { n as listMatrixEnvAccountIds, t as getMatrixScopedEnvVarNames } from "./env-vars-B0NxQnPk.js";
-import { t as isRecord$1 } from "./record-shared-CWWx6fvI.js";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { n as listMatrixEnvAccountIds, t as getMatrixScopedEnvVarNames } from "./env-vars-KzaYveuy.mjs";
+import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { listCombinedAccountIds, listConfiguredAccountIds, resolveListedDefaultAccountId, resolveNormalizedAccountEntry } from "openclaw/plugin-sdk/account-core";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
 import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input-runtime";
@@ -102,36 +101,37 @@ function hasConfiguredDefaultMatrixAccountSource(params) {
 	});
 }
 function resolveMatrixChannelConfig(cfg) {
-	return isRecord$1(cfg.channels?.matrix) ? cfg.channels.matrix : null;
+	return isRecord(cfg.channels?.matrix) ? cfg.channels.matrix : null;
 }
 function findMatrixAccountEntry(cfg, accountId) {
 	const channel = resolveMatrixChannelConfig(cfg);
 	if (!channel) return null;
-	const accounts = isRecord$1(channel.accounts) ? channel.accounts : null;
+	const accounts = isRecord(channel.accounts) ? channel.accounts : null;
 	if (!accounts) return null;
 	const entry = resolveNormalizedAccountEntry(accounts, accountId, normalizeAccountId);
-	return isRecord$1(entry) ? entry : null;
+	return isRecord(entry) ? entry : null;
 }
 function resolveConfiguredMatrixAccountIds(cfg, env = process.env) {
 	const channel = resolveMatrixChannelConfig(cfg);
 	const configuredAccountIds = listConfiguredAccountIds({
-		accounts: channel && isRecord$1(channel.accounts) ? channel.accounts : void 0,
+		accounts: channel && isRecord(channel.accounts) ? channel.accounts : void 0,
 		normalizeAccountId
 	});
 	if (hasConfiguredDefaultMatrixAccountSource({
 		channel,
 		env
 	})) configuredAccountIds.push(DEFAULT_ACCOUNT_ID);
+	const readyEnvAccountIds = listMatrixEnvAccountIds(env).filter((accountId) => normalizeAccountId(accountId) === DEFAULT_ACCOUNT_ID ? hasConfiguredDefaultMatrixAccountSource({
+		channel,
+		env
+	}) : hasUsableEffectiveMatrixAccountSource({
+		channel,
+		accountId,
+		env
+	}));
 	return listCombinedAccountIds({
 		configuredAccountIds,
-		additionalAccountIds: listMatrixEnvAccountIds(env).filter((accountId) => normalizeAccountId(accountId) === DEFAULT_ACCOUNT_ID ? hasConfiguredDefaultMatrixAccountSource({
-			channel,
-			env
-		}) : hasUsableEffectiveMatrixAccountSource({
-			channel,
-			accountId,
-			env
-		})),
+		additionalAccountIds: readyEnvAccountIds,
 		fallbackAccountIdWhenEmpty: channel ? DEFAULT_ACCOUNT_ID : void 0
 	});
 }
@@ -139,8 +139,9 @@ function resolveMatrixDefaultOrOnlyAccountId(cfg, env = process.env) {
 	const channel = resolveMatrixChannelConfig(cfg);
 	if (!channel) return DEFAULT_ACCOUNT_ID;
 	const configuredDefault = normalizeOptionalAccountId(typeof channel.defaultAccount === "string" ? channel.defaultAccount : void 0);
+	const configuredAccountIds = resolveConfiguredMatrixAccountIds(cfg, env);
 	return resolveListedDefaultAccountId({
-		accountIds: resolveConfiguredMatrixAccountIds(cfg, env),
+		accountIds: configuredAccountIds,
 		configuredDefaultAccountId: configuredDefault,
 		ambiguousFallbackAccountId: DEFAULT_ACCOUNT_ID
 	});
@@ -155,4 +156,4 @@ function requiresExplicitMatrixDefaultAccount(cfg, env = process.env) {
 	return !(configuredDefault && configuredAccountIds.includes(configuredDefault));
 }
 //#endregion
-export { resolveMatrixDefaultOrOnlyAccountId as a, resolveMatrixChannelConfig as i, requiresExplicitMatrixDefaultAccount as n, resolveMatrixAccountStringValues as o, resolveConfiguredMatrixAccountIds as r, findMatrixAccountEntry as t };
+export { resolveMatrixDefaultOrOnlyAccountId as a, resolveMatrixChannelConfig as i, requiresExplicitMatrixDefaultAccount as n, isRecord as o, resolveConfiguredMatrixAccountIds as r, resolveMatrixAccountStringValues as s, findMatrixAccountEntry as t };

package/dist/{approval-handler.runtime-DSeaIsGa.js → .setup/approval-handler.runtime-CEXm9_-p.mjs}

@@ -1,17 +1,16 @@
-import { i as resolveMatrixAccount } from "./accounts-DfngqebB.js";
-import { _ as shouldHandleMatrixApprovalRequest, g as isMatrixAnyApprovalClientEnabled } from "./channel-vj788dNZ.js";
-import { a as resolveMatrixTargetIdentity } from "./target-ids-B-5aQxwn.js";
-import { a as sendSingleTextMessageMatrix, d as repairMatrixDirectRooms, n as reactMatrixMessage, r as sendMessageMatrix } from "./send-BldGYG8g.js";
-import { a as unregisterMatrixApprovalReactionTarget, n as listMatrixApprovalReactionBindings, r as registerMatrixApprovalReactionTarget, t as buildMatrixApprovalReactionHint } from "./approval-reactions-D-BxBK_L.js";
-import { n as editMatrixMessage, t as deleteMatrixMessage } from "./messages-DxQJkhxs.js";
+import { g as resolveMatrixAccount } from "./setup-core-bhdcEo7v.mjs";
+import { _ as shouldHandleMatrixApprovalRequest, g as isMatrixAnyApprovalClientEnabled } from "./channel-an4umty1.mjs";
+import { a as resolveMatrixTargetIdentity } from "./target-ids-B-5aQxwn.mjs";
+import { a as sendMessageMatrix, i as reactMatrixMessage, p as repairMatrixDirectRooms, s as sendSingleTextMessageMatrix } from "./send-CGgl0uTn.mjs";
+import { a as unregisterMatrixApprovalReactionTarget, n as listMatrixApprovalReactionBindings, r as registerMatrixApprovalReactionTarget, t as buildMatrixApprovalReactionHint } from "./approval-reactions-Cltyp8nL.mjs";
+import { n as editMatrixMessage, t as deleteMatrixMessage } from "./messages-D4DYGHYX.mjs";
 import { listMessageReceiptPlatformIds, resolveMessageReceiptPrimaryId } from "openclaw/plugin-sdk/channel-outbound";
 import { normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
-import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { setTimeout } from "node:timers/promises";
 import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
 import { buildExecApprovalPendingReplyPayload, buildPluginApprovalPendingReplyPayload } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { buildPluginApprovalResolvedReplyPayload } from "openclaw/plugin-sdk/approval-runtime";
-import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 //#region extensions/matrix/src/approval-handler.runtime.ts
 const MATRIX_APPROVAL_METADATA_KEY = "com.openclaw.approval";
 const MATRIX_APPROVAL_DELIVERY_ATTEMPTS = 3;
@@ -29,12 +28,10 @@ function normalizePendingMessageIds(entry) {
 	return normalizeUniqueStringEntries(entry.platformMessageIds);
 }
 function normalizeReactionTargetRef(params) {
-	const accountId = normalizeAccountId(params.accountId);
 	const roomId = params.roomId.trim();
 	const eventId = params.eventId.trim();
-	if (!accountId || !roomId || !eventId) return null;
+	if (!roomId || !eventId) return null;
 	return {
-		accountId,
 		roomId,
 		eventId
 	};
@@ -46,11 +43,15 @@ function isSingleMatrixMessageLimitError(error) {
 	return error instanceof Error && error.message.includes("Matrix single-message text exceeds limit");
 }
 async function retryMatrixApprovalDelivery(operation, params = {}) {
-	return await retryAsync(operation, {
-		attempts: MATRIX_APPROVAL_DELIVERY_ATTEMPTS,
-		minDelayMs: MATRIX_APPROVAL_DELIVERY_RETRY_DELAY_MS,
-		shouldRetry: (error) => params.shouldRetry?.(error) !== false
-	});
+	let lastError;
+	for (let attempt = 1; attempt <= MATRIX_APPROVAL_DELIVERY_ATTEMPTS; attempt += 1) try {
+		return await operation();
+	} catch (error) {
+		lastError = error;
+		if (attempt === MATRIX_APPROVAL_DELIVERY_ATTEMPTS || params.shouldRetry?.(error) === false) break;
+		await setTimeout(MATRIX_APPROVAL_DELIVERY_RETRY_DELAY_MS * attempt);
+	}
+	throw lastError;
 }
 async function prepareTarget(params) {
 	const resolved = resolveHandlerContext(params);
@@ -207,7 +208,7 @@ const matrixApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 				accountId: resolved.accountId
 			});
 		},
-		shouldHandle: ({ cfg, accountId, approvalKind, request, context }) => {
+		shouldHandle: ({ cfg, accountId, request, context }) => {
 			const resolved = resolveHandlerContext({
 				cfg,
 				accountId,
@@ -217,7 +218,6 @@ const matrixApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 			return shouldHandleMatrixApprovalRequest({
 				cfg,
 				accountId: resolved.accountId,
-				approvalKind,
 				request
 			});
 		}
@@ -281,11 +281,9 @@ const matrixApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 			const platformMessageIds = receiptMessageIds.length ? receiptMessageIds : [result.messageId.trim()].filter(Boolean);
 			const reactionEventId = resolveMessageReceiptPrimaryId(result.receipt) || result.primaryMessageId?.trim() || platformMessageIds[0] || result.messageId.trim();
 			registerMatrixApprovalReactionTarget({
-				accountId: resolved.accountId,
 				roomId: result.roomId,
 				eventId: reactionEventId,
 				approvalId: pendingPayload.approvalId,
-				approvalKind: view.approvalKind,
 				allowedDecisions: pendingPayload.allowedDecisions,
 				ttlMs: view.expiresAtMs - Date.now()
 			});
@@ -347,20 +345,15 @@ const matrixApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 	},
 	interactions: {
 		bindPending: (params) => {
-			const accountId = params.accountId?.trim();
-			if (!accountId) return null;
 			const target = normalizeReactionTargetRef({
-				accountId,
 				roomId: params.entry.roomId,
 				eventId: params.entry.reactionEventId
 			});
 			if (!target) return null;
 			registerMatrixApprovalReactionTarget({
-				accountId: target.accountId,
 				roomId: target.roomId,
 				eventId: target.eventId,
 				approvalId: params.pendingPayload.approvalId,
-				approvalKind: params.view.approvalKind,
 				allowedDecisions: params.pendingPayload.allowedDecisions,
 				ttlMs: params.view.expiresAtMs - Date.now()
 			});
@@ -372,10 +365,7 @@ const matrixApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 			unregisterMatrixApprovalReactionTarget(target);
 		},
 		cancelDelivered: (params) => {
-			const accountId = params.accountId?.trim();
-			if (!accountId) return;
 			const target = normalizeReactionTargetRef({
-				accountId,
 				roomId: params.entry.roomId,
 				eventId: params.entry.reactionEventId
 			});

package/dist/{approval-ids-BdJGPAJT.js → .setup/approval-ids-DdFnDB3h.mjs}

@@ -1,4 +1,4 @@
-import { a as normalizeMatrixUserId } from "./config-schema-Djxw3C6b.js";
+import { a as normalizeMatrixUserId } from "./config-schema-D9J_vUF6.mjs";
 //#region extensions/matrix/src/approval-ids.ts
 function normalizeMatrixApproverId(value) {
 	return normalizeMatrixUserId(String(value)) || void 0;

package/dist/{approval-reaction-auth-BjOpELxu.js → .setup/approval-reaction-auth-CREvd7S7.mjs}

@@ -1,5 +1,5 @@
-import { i as resolveMatrixAccount } from "./accounts-DfngqebB.js";
-import { t as normalizeMatrixApproverId } from "./approval-ids-BdJGPAJT.js";
+import { g as resolveMatrixAccount } from "./setup-core-bhdcEo7v.mjs";
+import { t as normalizeMatrixApproverId } from "./approval-ids-DdFnDB3h.mjs";
 import { resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
 //#region extensions/matrix/src/approval-reaction-auth.ts
 function normalizeMatrixExecApproverId(value) {

package/dist/.setup/approval-reactions-Cltyp8nL.mjs

@@ -0,0 +1,113 @@
+import { n as getOptionalMatrixRuntime } from "./runtime-6S3DNFNv.mjs";
+import { createApprovalReactionTargetStore } from "openclaw/plugin-sdk/approval-reaction-runtime";
+//#region extensions/matrix/src/approval-reactions.ts
+const MATRIX_APPROVAL_REACTION_META = {
+	"allow-once": {
+		emoji: "✅",
+		label: "Allow once"
+	},
+	"allow-always": {
+		emoji: "♾️",
+		label: "Allow always"
+	},
+	deny: {
+		emoji: "❌",
+		label: "Deny"
+	}
+};
+const MATRIX_APPROVAL_REACTION_ORDER = [
+	"allow-once",
+	"allow-always",
+	"deny"
+];
+const PERSISTENT_NAMESPACE = "matrix.approval-reactions";
+const PERSISTENT_MAX_ENTRIES = 1e3;
+const DEFAULT_REACTION_TARGET_TTL_MS = 864e5;
+function reportPersistentApprovalReactionError(error) {
+	try {
+		getOptionalMatrixRuntime()?.logging.getChildLogger({
+			plugin: "matrix",
+			feature: "approval-reaction-state"
+		}).warn("Matrix persistent approval reaction state failed", { error: String(error) });
+	} catch {}
+}
+function readPersistedTarget(target) {
+	const value = target;
+	if (!value || typeof value.approvalId !== "string" || !Array.isArray(value.allowedDecisions)) return null;
+	return {
+		approvalId: value.approvalId,
+		allowedDecisions: value.allowedDecisions
+	};
+}
+const matrixApprovalReactionTargets = createApprovalReactionTargetStore({
+	namespace: PERSISTENT_NAMESPACE,
+	maxEntries: PERSISTENT_MAX_ENTRIES,
+	defaultTtlMs: DEFAULT_REACTION_TARGET_TTL_MS,
+	openStore: (storeParams) => getOptionalMatrixRuntime()?.state.openKeyedStore(storeParams),
+	logPersistentError: reportPersistentApprovalReactionError,
+	readPersistedTarget
+});
+function buildReactionTargetKey(roomId, eventId) {
+	const normalizedRoomId = roomId.trim();
+	const normalizedEventId = eventId.trim();
+	if (!normalizedRoomId || !normalizedEventId) return null;
+	return `${normalizedRoomId}:${normalizedEventId}`;
+}
+function listMatrixApprovalReactionBindings(allowedDecisions) {
+	const allowed = new Set(allowedDecisions);
+	return MATRIX_APPROVAL_REACTION_ORDER.filter((decision) => allowed.has(decision)).map((decision) => ({
+		decision,
+		emoji: MATRIX_APPROVAL_REACTION_META[decision].emoji,
+		label: MATRIX_APPROVAL_REACTION_META[decision].label
+	}));
+}
+function buildMatrixApprovalReactionHint(allowedDecisions) {
+	const bindings = listMatrixApprovalReactionBindings(allowedDecisions);
+	if (bindings.length === 0) return null;
+	return `React here: ${bindings.map((binding) => `${binding.emoji} ${binding.label}`).join(", ")}`;
+}
+function resolveMatrixApprovalReactionDecision(reactionKey, allowedDecisions) {
+	const normalizedReaction = reactionKey.trim();
+	if (!normalizedReaction) return null;
+	const allowed = new Set(allowedDecisions);
+	for (const decision of MATRIX_APPROVAL_REACTION_ORDER) {
+		if (!allowed.has(decision)) continue;
+		if (MATRIX_APPROVAL_REACTION_META[decision].emoji === normalizedReaction) return decision;
+	}
+	return null;
+}
+function registerMatrixApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params.roomId, params.eventId);
+	const approvalId = params.approvalId.trim();
+	const allowedDecisions = Array.from(new Set(params.allowedDecisions.filter((decision) => decision === "allow-once" || decision === "allow-always" || decision === "deny")));
+	if (!key || !approvalId || allowedDecisions.length === 0) return;
+	matrixApprovalReactionTargets.register(key, {
+		approvalId,
+		allowedDecisions
+	}, { ttlMs: params.ttlMs });
+}
+function unregisterMatrixApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params.roomId, params.eventId);
+	if (!key) return;
+	matrixApprovalReactionTargets.delete(key);
+}
+function resolveTarget(params) {
+	const target = params.target;
+	if (!target) return null;
+	const decision = resolveMatrixApprovalReactionDecision(params.reactionKey, target.allowedDecisions);
+	if (!decision) return null;
+	return {
+		approvalId: target.approvalId,
+		decision
+	};
+}
+async function resolveMatrixApprovalReactionTargetWithPersistence(params) {
+	const key = buildReactionTargetKey(params.roomId, params.eventId);
+	if (!key) return null;
+	return resolveTarget({
+		target: await matrixApprovalReactionTargets.lookup(key),
+		reactionKey: params.reactionKey
+	});
+}
+//#endregion
+export { unregisterMatrixApprovalReactionTarget as a, resolveMatrixApprovalReactionTargetWithPersistence as i, listMatrixApprovalReactionBindings as n, registerMatrixApprovalReactionTarget as r, buildMatrixApprovalReactionHint as t };

package/dist/.setup/async-lock-BcLS4KOc.mjs

@@ -0,0 +1,19 @@
+//#region extensions/matrix/src/matrix/async-lock.ts
+function createAsyncLock() {
+	let lock = Promise.resolve();
+	return async function withLock(fn) {
+		const previous = lock;
+		let release;
+		lock = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			return await fn();
+		} finally {
+			release?.();
+		}
+	};
+}
+//#endregion
+export { createAsyncLock as t };