@openclaw/matrix 2026.7.2-beta.5 → 2026.7.33

package/dist/.setup/probe.runtime-CMPh0mFk.mjs

@@ -0,0 +1,2 @@
+import { s as createMatrixClient } from "./client-DFBQtzCe.mjs";
+export { createMatrixClient };

package/dist/.setup/profile-update-DzOL3Wiw.mjs

@@ -0,0 +1,69 @@
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.mjs";
+import { c as resolveMatrixConfigPath, l as updateMatrixAccountConfig, o as syncMatrixOwnProfile } from "./setup-core-bhdcEo7v.mjs";
+import { n as withResolvedActionClient } from "./client-Ct0bUHCo.mjs";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/actions/profile.ts
+async function updateMatrixOwnProfile(opts = {}) {
+	const displayName = opts.displayName?.trim();
+	const avatarUrl = opts.avatarUrl?.trim();
+	const avatarPath = opts.avatarPath?.trim();
+	const runtime = getMatrixRuntime();
+	return await withResolvedActionClient(opts, async (client) => {
+		const userId = await client.getUserId();
+		return await syncMatrixOwnProfile({
+			client,
+			userId,
+			displayName: displayName || void 0,
+			avatarUrl: avatarUrl || void 0,
+			avatarPath: avatarPath || void 0,
+			loadAvatarFromUrl: async (url, maxBytes) => await runtime.media.loadWebMedia(url, maxBytes),
+			loadAvatarFromPath: async (path, maxBytes) => await runtime.media.loadWebMedia(path, {
+				maxBytes,
+				localRoots: opts.mediaLocalRoots
+			})
+		});
+	}, "persist");
+}
+//#endregion
+//#region extensions/matrix/src/profile-update.ts
+async function applyMatrixProfileUpdate(params) {
+	const runtime = getMatrixRuntime();
+	const persistedCfg = runtime.config.current();
+	const accountId = normalizeAccountId(params.account);
+	const displayName = params.displayName?.trim() || null;
+	const avatarUrl = params.avatarUrl?.trim() || null;
+	const avatarPath = params.avatarPath?.trim() || null;
+	if (!displayName && !avatarUrl && !avatarPath) throw new Error("Provide name/displayName and/or avatarUrl/avatarPath.");
+	const synced = await updateMatrixOwnProfile({
+		cfg: params.cfg,
+		accountId,
+		displayName: displayName ?? void 0,
+		avatarUrl: avatarUrl ?? void 0,
+		avatarPath: avatarPath ?? void 0,
+		mediaLocalRoots: params.mediaLocalRoots
+	});
+	const persistedAvatarUrl = synced.uploadedAvatarSource && synced.resolvedAvatarUrl ? synced.resolvedAvatarUrl : avatarUrl;
+	const updated = updateMatrixAccountConfig(persistedCfg, accountId, {
+		name: displayName ?? void 0,
+		avatarUrl: persistedAvatarUrl ?? void 0
+	});
+	await runtime.config.replaceConfigFile({
+		nextConfig: updated,
+		afterWrite: { mode: "auto" }
+	});
+	return {
+		accountId,
+		displayName,
+		avatarUrl: persistedAvatarUrl ?? null,
+		profile: {
+			displayNameUpdated: synced.displayNameUpdated,
+			avatarUpdated: synced.avatarUpdated,
+			resolvedAvatarUrl: synced.resolvedAvatarUrl,
+			uploadedAvatarSource: synced.uploadedAvatarSource,
+			convertedAvatarFromHttp: synced.convertedAvatarFromHttp
+		},
+		configPath: resolveMatrixConfigPath(updated, accountId)
+	};
+}
+//#endregion
+export { updateMatrixOwnProfile as n, applyMatrixProfileUpdate as t };

package/dist/.setup/reaction-events-BcvgXxHb.mjs

@@ -0,0 +1,114 @@
+import { a as resolveMatrixAccountConfig } from "./account-config-BZWN9tGS.mjs";
+import { a as extractMatrixReactionAnnotation } from "./reaction-common-DkrQdBSZ.mjs";
+import { a as unregisterMatrixApprovalReactionTarget, i as resolveMatrixApprovalReactionTargetWithPersistence } from "./approval-reactions-Cltyp8nL.mjs";
+import { n as resolveMatrixThreadRootId, r as resolveMatrixThreadRouting, t as resolveMatrixInboundRoute } from "./monitor-DNcW_oAN.mjs";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { getSessionBindingService } from "openclaw/plugin-sdk/session-binding-runtime";
+//#region extensions/matrix/src/matrix/monitor/reaction-events.ts
+const loadApprovalReactionAuth = createLazyRuntimeModule(() => import("./approval-reaction-auth-CREvd7S7.mjs"));
+const loadExecApprovalResolver = createLazyRuntimeModule(() => import("./exec-approval-resolver-f9j6staN.mjs"));
+function resolveMatrixReactionNotificationMode(params) {
+	const matrixConfig = params.cfg.channels?.matrix;
+	return resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).reactionNotifications ?? matrixConfig?.reactionNotifications ?? "own";
+}
+async function maybeResolveMatrixApprovalReaction(params) {
+	if (!params.target) return false;
+	const approvalKind = params.target.approvalId.startsWith("plugin:") ? "plugin" : "exec";
+	const { isMatrixApprovalReactionAuthorizedSender } = await loadApprovalReactionAuth();
+	if (!isMatrixApprovalReactionAuthorizedSender({
+		...params,
+		approvalKind
+	})) return false;
+	const { isApprovalNotFoundError, resolveMatrixApproval } = await loadExecApprovalResolver();
+	try {
+		await resolveMatrixApproval({
+			cfg: params.cfg,
+			approvalId: params.target.approvalId,
+			decision: params.target.decision,
+			senderId: params.senderId
+		});
+		params.logVerboseMessage(`matrix: approval reaction resolved id=${params.target.approvalId} sender=${params.senderId} decision=${params.target.decision}`);
+		return true;
+	} catch (err) {
+		if (isApprovalNotFoundError(err)) {
+			unregisterMatrixApprovalReactionTarget({
+				roomId: params.roomId,
+				eventId: params.targetEventId
+			});
+			params.logVerboseMessage(`matrix: approval reaction ignored for expired approval id=${params.target.approvalId} sender=${params.senderId}`);
+			return true;
+		}
+		params.logVerboseMessage(`matrix: approval reaction failed id=${params.target.approvalId} sender=${params.senderId}: ${String(err)}`);
+		throw err;
+	}
+}
+async function handleInboundMatrixReaction(params) {
+	const reaction = extractMatrixReactionAnnotation(params.event.content);
+	if (!reaction?.eventId) return;
+	if (params.senderId === params.selfUserId) return;
+	const approvalTarget = await resolveMatrixApprovalReactionTargetWithPersistence({
+		roomId: params.roomId,
+		eventId: reaction.eventId,
+		reactionKey: reaction.key
+	});
+	if (await maybeResolveMatrixApprovalReaction({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		senderId: params.senderId,
+		target: approvalTarget,
+		targetEventId: reaction.eventId,
+		roomId: params.roomId,
+		logVerboseMessage: params.logVerboseMessage
+	})) return;
+	const notificationMode = resolveMatrixReactionNotificationMode({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (notificationMode === "off") return;
+	const targetEvent = await params.client.getEvent(params.roomId, reaction.eventId).catch((err) => {
+		params.logVerboseMessage(`matrix: failed resolving reaction target room=${params.roomId} id=${reaction.eventId}: ${String(err)}`);
+		return null;
+	});
+	const targetSender = targetEvent && typeof targetEvent.sender === "string" ? targetEvent.sender.trim() : "";
+	if (!targetSender) return;
+	if (notificationMode === "own" && targetSender !== params.selfUserId) return;
+	const targetContent = targetEvent && targetEvent.content && typeof targetEvent.content === "object" ? targetEvent.content : void 0;
+	const threadRootId = targetContent ? resolveMatrixThreadRootId({
+		event: targetEvent,
+		content: targetContent
+	}) : void 0;
+	const accountConfig = resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const thread = resolveMatrixThreadRouting({
+		isDirectMessage: params.isDirectMessage,
+		threadReplies: accountConfig.threadReplies ?? "inbound",
+		dmThreadReplies: accountConfig.dm?.threadReplies,
+		messageId: reaction.eventId,
+		threadRootId
+	});
+	const { route, runtimeBindingId } = resolveMatrixInboundRoute({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		roomId: params.roomId,
+		senderId: params.senderId,
+		isDirectMessage: params.isDirectMessage,
+		dmSessionScope: accountConfig.dm?.sessionScope ?? "per-user",
+		threadId: thread.threadId,
+		eventTs: params.event.origin_server_ts,
+		resolveAgentRoute: params.core.channel.routing.resolveAgentRoute
+	});
+	if (runtimeBindingId) getSessionBindingService().touch(runtimeBindingId, params.event.origin_server_ts);
+	const text = `Matrix reaction added: ${reaction.key} by ${params.senderLabel} on msg ${reaction.eventId}`;
+	params.core.system.enqueueSystemEvent(text, {
+		sessionKey: route.sessionKey,
+		contextKey: `matrix:reaction:add:${params.roomId}:${reaction.eventId}:${params.senderId}:${reaction.key}`
+	});
+	params.logVerboseMessage(`matrix: reaction event enqueued room=${params.roomId} target=${reaction.eventId} sender=${params.senderId} emoji=${reaction.key}`);
+}
+//#endregion
+export { handleInboundMatrixReaction };

package/dist/.setup/resolve-targets-Bq80X9Sn.mjs

@@ -0,0 +1,140 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-B-5aQxwn.mjs";
+import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-BTEYxMwy.mjs";
+import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/resolve-targets.ts
+var resolve_targets_exports = /* @__PURE__ */ __exportAll({ resolveMatrixTargets: () => resolveMatrixTargets });
+function normalizeLookupQuery(query) {
+	return normalizeOptionalLowercaseString(query) ?? "";
+}
+function findExactDirectoryMatches(matches, query) {
+	const normalized = normalizeLookupQuery(query);
+	if (!normalized) return [];
+	return matches.filter((match) => {
+		const id = normalizeOptionalLowercaseString(match.id);
+		const name = normalizeOptionalLowercaseString(match.name);
+		const handle = normalizeOptionalLowercaseString(match.handle);
+		return normalized === id || normalized === name || normalized === handle;
+	});
+}
+function pickBestGroupMatch(matches, query) {
+	if (matches.length === 0) return {};
+	const exact = findExactDirectoryMatches(matches, query);
+	if (exact.length > 1) return {
+		best: exact[0],
+		note: "multiple exact matches; chose first"
+	};
+	if (exact.length === 1) return { best: exact[0] };
+	return {
+		best: matches[0],
+		note: matches.length > 1 ? "multiple matches; chose first" : void 0
+	};
+}
+function pickBestUserMatch(matches, query) {
+	if (matches.length === 0) return;
+	const exact = findExactDirectoryMatches(matches, query);
+	if (exact.length === 1) return exact[0];
+}
+function describeUserMatchFailure(matches, query) {
+	if (matches.length === 0) return "no matches";
+	const normalized = normalizeLookupQuery(query);
+	if (!normalized) return "empty input";
+	const exact = findExactDirectoryMatches(matches, normalized);
+	if (exact.length === 0) return "no exact match; use full Matrix ID";
+	if (exact.length > 1) return "multiple exact matches; use full Matrix ID";
+	return "no exact match; use full Matrix ID";
+}
+async function readCachedMatches(cache, query, lookup) {
+	const key = normalizeLookupQuery(query);
+	if (!key) return [];
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const matches = await lookup(query.trim());
+	cache.set(key, matches);
+	return matches;
+}
+async function resolveMatrixTargets(params) {
+	const results = [];
+	const userLookupCache = /* @__PURE__ */ new Map();
+	const groupLookupCache = /* @__PURE__ */ new Map();
+	for (const input of params.inputs) {
+		const trimmed = input.trim();
+		if (!trimmed) {
+			results.push({
+				input,
+				resolved: false,
+				note: "empty input"
+			});
+			continue;
+		}
+		if (params.kind === "user") {
+			const normalizedTarget = normalizeMatrixMessagingTarget(trimmed);
+			if (normalizedTarget && isMatrixQualifiedUserId(normalizedTarget)) {
+				results.push({
+					input,
+					resolved: true,
+					id: normalizedTarget
+				});
+				continue;
+			}
+			try {
+				const matches = await readCachedMatches(userLookupCache, trimmed, (query) => listMatrixDirectoryPeersLive({
+					cfg: params.cfg,
+					accountId: params.accountId,
+					query,
+					limit: 5
+				}));
+				const best = pickBestUserMatch(matches, trimmed);
+				results.push({
+					input,
+					resolved: Boolean(best?.id),
+					id: best?.id,
+					name: best?.name,
+					note: best ? void 0 : describeUserMatchFailure(matches, trimmed)
+				});
+			} catch (err) {
+				params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
+				results.push({
+					input,
+					resolved: false,
+					note: "lookup failed"
+				});
+			}
+			continue;
+		}
+		const normalizedTarget = normalizeMatrixMessagingTarget(trimmed);
+		if (normalizedTarget?.startsWith("!")) {
+			results.push({
+				input,
+				resolved: true,
+				id: normalizedTarget
+			});
+			continue;
+		}
+		try {
+			const { best, note } = pickBestGroupMatch(await readCachedMatches(groupLookupCache, trimmed, (query) => listMatrixDirectoryGroupsLive({
+				cfg: params.cfg,
+				accountId: params.accountId,
+				query,
+				limit: 5
+			})), trimmed);
+			results.push({
+				input,
+				resolved: Boolean(best?.id),
+				id: best?.id,
+				name: best?.name,
+				note
+			});
+		} catch (err) {
+			params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
+			results.push({
+				input,
+				resolved: false,
+				note: "lookup failed"
+			});
+		}
+	}
+	return results;
+}
+//#endregion
+export { resolve_targets_exports as n, resolveMatrixTargets as t };

package/dist/.setup/resolver.runtime-CeBHR9-T.mjs

@@ -0,0 +1,5 @@
+import { t as resolveMatrixTargets } from "./resolve-targets-Bq80X9Sn.mjs";
+//#region extensions/matrix/src/resolver.runtime.ts
+const matrixResolverRuntime = { resolveMatrixTargets };
+//#endregion
+export { matrixResolverRuntime };

package/dist/.setup/runtime-api-CEsWNdil.mjs

@@ -0,0 +1,21 @@
+import "./timeout-abort-signal-DMrgRFIy.mjs";
+import { resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel } from "openclaw/plugin-sdk/conversation-runtime";
+import { chunkTextForOutbound as chunkTextForOutbound$1 } from "openclaw/plugin-sdk/text-chunking";
+import { createActionGate as createActionGate$1, jsonResult, readPositiveIntegerParam as readPositiveIntegerParam$1, readReactionParams, readStringArrayParam, readStringParam as readStringParam$1 } from "openclaw/plugin-sdk/channel-actions";
+import "openclaw/plugin-sdk/account-id";
+import "openclaw/plugin-sdk/routing";
+import "openclaw/plugin-sdk/channel-status";
+import "openclaw/plugin-sdk/channel-config-primitives";
+import "openclaw/plugin-sdk/ssrf-runtime";
+import "openclaw/plugin-sdk/channel-inbound";
+import "openclaw/plugin-sdk/channel-targets";
+import "openclaw/plugin-sdk/setup";
+import "openclaw/plugin-sdk/json-store";
+import "openclaw/plugin-sdk/outbound-media";
+import "openclaw/plugin-sdk/poll-runtime";
+import { formatZonedTimestamp } from "openclaw/plugin-sdk/time-runtime";
+import "openclaw/plugin-sdk/channel-feedback";
+import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import "openclaw/plugin-sdk/acp-binding-runtime";
+export { jsonResult as a, readStringArrayParam as c, resolveDefaultGroupPolicy as d, resolveOutboundSendDep as f, warnMissingProviderGroupPolicyFallbackOnce as h, formatZonedTimestamp as i, readStringParam$1 as l, resolveThreadBindingMaxAgeMsForChannel as m, chunkTextForOutbound$1 as n, readPositiveIntegerParam$1 as o, resolveThreadBindingIdleTimeoutMsForChannel as p, createActionGate$1 as r, readReactionParams as s, GROUP_POLICY_BLOCKED_LABEL as t, resolveAllowlistProviderRuntimeGroupPolicy as u };

package/dist/.setup/runtime-setter-api-DGMubGUq.mjs

@@ -0,0 +1,3 @@
+import { r as setMatrixRuntime } from "./runtime-6S3DNFNv.mjs";
+import "../runtime-setter-api.js";
+export { setMatrixRuntime };