@openclaw/matrix 2026.3.13 → 2026.5.10-beta.1

package/dist/plugin-entry.handlers.runtime.js

@@ -0,0 +1,51 @@
+import { t as formatMatrixErrorMessage } from "./errors-CTcpEDq-.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/plugin-entry.runtime.ts
+let matrixVerificationRuntimePromise;
+function loadMatrixVerificationRuntime() {
+	matrixVerificationRuntimePromise ??= import("./verification-CZ2rDeHL.js").then((n) => n.y);
+	return matrixVerificationRuntimePromise;
+}
+function sendError(respond, err) {
+	respond(false, { error: formatMatrixErrorMessage(err) });
+}
+async function handleVerifyRecoveryKey({ params, respond }) {
+	try {
+		const { verifyMatrixRecoveryKey } = await loadMatrixVerificationRuntime();
+		const key = normalizeOptionalString(params?.key);
+		if (!key) {
+			respond(false, { error: "key required" });
+			return;
+		}
+		const result = await verifyMatrixRecoveryKey(key, { accountId: normalizeOptionalString(params?.accountId) });
+		respond(result.success, result);
+	} catch (err) {
+		sendError(respond, err);
+	}
+}
+async function handleVerificationBootstrap({ params, respond }) {
+	try {
+		const { bootstrapMatrixVerification } = await loadMatrixVerificationRuntime();
+		const result = await bootstrapMatrixVerification({
+			accountId: normalizeOptionalString(params?.accountId),
+			recoveryKey: typeof params?.recoveryKey === "string" ? params.recoveryKey : void 0,
+			forceResetCrossSigning: params?.forceResetCrossSigning === true
+		});
+		respond(result.success, result);
+	} catch (err) {
+		sendError(respond, err);
+	}
+}
+async function handleVerificationStatus({ params, respond }) {
+	try {
+		const { getMatrixVerificationStatus } = await loadMatrixVerificationRuntime();
+		respond(true, await getMatrixVerificationStatus({
+			accountId: normalizeOptionalString(params?.accountId),
+			includeRecoveryKey: params?.includeRecoveryKey === true
+		}));
+	} catch (err) {
+		sendError(respond, err);
+	}
+}
+//#endregion
+export { handleVerificationBootstrap, handleVerificationStatus, handleVerifyRecoveryKey };

package/dist/probe.runtime-BvAzYAIe.js

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

package/dist/profile-BlHu0wDX.js

@@ -0,0 +1,111 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/profile.ts
+var profile_exports = /* @__PURE__ */ __exportAll({
+	MATRIX_PROFILE_AVATAR_MAX_BYTES: () => MATRIX_PROFILE_AVATAR_MAX_BYTES,
+	isMatrixHttpAvatarUri: () => isMatrixHttpAvatarUri,
+	isMatrixMxcUri: () => isMatrixMxcUri,
+	isSupportedMatrixAvatarSource: () => isSupportedMatrixAvatarSource,
+	syncMatrixOwnProfile: () => syncMatrixOwnProfile
+});
+const MATRIX_PROFILE_AVATAR_MAX_BYTES = 10 * 1024 * 1024;
+function isMatrixMxcUri(value) {
+	return normalizeLowercaseStringOrEmpty(normalizeOptionalString(value)).startsWith("mxc://");
+}
+function isMatrixHttpAvatarUri(value) {
+	const normalized = normalizeLowercaseStringOrEmpty(normalizeOptionalString(value));
+	return normalized.startsWith("https://") || normalized.startsWith("http://");
+}
+function isSupportedMatrixAvatarSource(value) {
+	return isMatrixMxcUri(value) || isMatrixHttpAvatarUri(value);
+}
+async function uploadAvatarMedia(params) {
+	const media = await params.loadAvatar(params.avatarSource, params.avatarMaxBytes);
+	return await params.client.uploadContent(media.buffer, media.contentType, media.fileName || "avatar");
+}
+async function resolveAvatarUrl(params) {
+	const avatarPath = normalizeOptionalString(params.avatarPath) ?? null;
+	if (avatarPath) {
+		if (!params.loadAvatarFromPath) throw new Error("Matrix avatar path upload requires a media loader.");
+		return {
+			resolvedAvatarUrl: await uploadAvatarMedia({
+				client: params.client,
+				avatarSource: avatarPath,
+				avatarMaxBytes: params.avatarMaxBytes,
+				loadAvatar: params.loadAvatarFromPath
+			}),
+			uploadedAvatarSource: "path",
+			convertedAvatarFromHttp: false
+		};
+	}
+	const avatarUrl = normalizeOptionalString(params.avatarUrl) ?? null;
+	if (!avatarUrl) return {
+		resolvedAvatarUrl: null,
+		uploadedAvatarSource: null,
+		convertedAvatarFromHttp: false
+	};
+	if (isMatrixMxcUri(avatarUrl)) return {
+		resolvedAvatarUrl: avatarUrl,
+		uploadedAvatarSource: null,
+		convertedAvatarFromHttp: false
+	};
+	if (!isMatrixHttpAvatarUri(avatarUrl)) throw new Error("Matrix avatar URL must be an mxc:// URI or an http(s) URL.");
+	if (!params.loadAvatarFromUrl) throw new Error("Matrix avatar URL conversion requires a media loader.");
+	return {
+		resolvedAvatarUrl: await uploadAvatarMedia({
+			client: params.client,
+			avatarSource: avatarUrl,
+			avatarMaxBytes: params.avatarMaxBytes,
+			loadAvatar: params.loadAvatarFromUrl
+		}),
+		uploadedAvatarSource: "http",
+		convertedAvatarFromHttp: true
+	};
+}
+async function syncMatrixOwnProfile(params) {
+	const desiredDisplayName = normalizeOptionalString(params.displayName) ?? null;
+	const avatar = await resolveAvatarUrl({
+		client: params.client,
+		avatarUrl: params.avatarUrl ?? null,
+		avatarPath: params.avatarPath ?? null,
+		avatarMaxBytes: params.avatarMaxBytes ?? 10485760,
+		loadAvatarFromUrl: params.loadAvatarFromUrl,
+		loadAvatarFromPath: params.loadAvatarFromPath
+	});
+	const desiredAvatarUrl = avatar.resolvedAvatarUrl;
+	if (!desiredDisplayName && !desiredAvatarUrl) return {
+		skipped: true,
+		displayNameUpdated: false,
+		avatarUpdated: false,
+		resolvedAvatarUrl: null,
+		uploadedAvatarSource: avatar.uploadedAvatarSource,
+		convertedAvatarFromHttp: avatar.convertedAvatarFromHttp
+	};
+	let currentDisplayName;
+	let currentAvatarUrl;
+	try {
+		const currentProfile = await params.client.getUserProfile(params.userId);
+		currentDisplayName = normalizeOptionalString(currentProfile.displayname);
+		currentAvatarUrl = normalizeOptionalString(currentProfile.avatar_url);
+	} catch {}
+	let displayNameUpdated = false;
+	let avatarUpdated = false;
+	if (desiredDisplayName && currentDisplayName !== desiredDisplayName) {
+		await params.client.setDisplayName(desiredDisplayName);
+		displayNameUpdated = true;
+	}
+	if (desiredAvatarUrl && currentAvatarUrl !== desiredAvatarUrl) {
+		await params.client.setAvatarUrl(desiredAvatarUrl);
+		avatarUpdated = true;
+	}
+	return {
+		skipped: false,
+		displayNameUpdated,
+		avatarUpdated,
+		resolvedAvatarUrl: desiredAvatarUrl,
+		uploadedAvatarSource: avatar.uploadedAvatarSource,
+		convertedAvatarFromHttp: avatar.convertedAvatarFromHttp
+	};
+}
+//#endregion
+export { profile_exports as n, syncMatrixOwnProfile as r, isSupportedMatrixAvatarSource as t };

package/dist/profile-update-DjeBNgIV.js

@@ -0,0 +1,69 @@
+import { t as getMatrixRuntime } from "./runtime-Dog86njy.js";
+import { n as resolveMatrixConfigPath, r as updateMatrixAccountConfig } from "./config-update-wZX-HLMn.js";
+import { r as syncMatrixOwnProfile } from "./profile-BlHu0wDX.js";
+import { n as withResolvedActionClient } from "./client-DkcXnm0X.js";
+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) => {
+		return await syncMatrixOwnProfile({
+			client,
+			userId: await client.getUserId(),
+			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/reaction-common-ejrL19w-.js

@@ -0,0 +1,71 @@
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/reaction-common.ts
+const MATRIX_ANNOTATION_RELATION_TYPE = "m.annotation";
+const MATRIX_REACTION_EVENT_TYPE = "m.reaction";
+function normalizeMatrixReactionMessageId(messageId) {
+	const normalized = messageId.trim();
+	if (!normalized) throw new Error("Matrix reaction requires a messageId");
+	return normalized;
+}
+function normalizeMatrixReactionEmoji(emoji) {
+	const normalized = emoji.trim();
+	if (!normalized) throw new Error("Matrix reaction requires an emoji");
+	return normalized;
+}
+function buildMatrixReactionContent(messageId, emoji) {
+	return { "m.relates_to": {
+		rel_type: MATRIX_ANNOTATION_RELATION_TYPE,
+		event_id: normalizeMatrixReactionMessageId(messageId),
+		key: normalizeMatrixReactionEmoji(emoji)
+	} };
+}
+function buildMatrixReactionRelationsPath(roomId, messageId) {
+	return `/_matrix/client/v1/rooms/${encodeURIComponent(roomId)}/relations/${encodeURIComponent(normalizeMatrixReactionMessageId(messageId))}/${MATRIX_ANNOTATION_RELATION_TYPE}/${MATRIX_REACTION_EVENT_TYPE}`;
+}
+function extractMatrixReactionAnnotation(content) {
+	if (!content || typeof content !== "object") return;
+	const relatesTo = content["m.relates_to"];
+	if (!relatesTo || typeof relatesTo !== "object") return;
+	if (typeof relatesTo.rel_type === "string" && relatesTo.rel_type !== "m.annotation") return;
+	const key = normalizeOptionalString(relatesTo.key) ?? "";
+	if (!key) return;
+	return {
+		key,
+		eventId: (normalizeOptionalString(relatesTo.event_id) ?? "") || void 0
+	};
+}
+function extractMatrixReactionKey(content) {
+	return extractMatrixReactionAnnotation(content)?.key;
+}
+function summarizeMatrixReactionEvents(events) {
+	const summaries = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const key = extractMatrixReactionKey(event.content);
+		if (!key) continue;
+		const sender = normalizeOptionalString(event.sender) ?? "";
+		const entry = summaries.get(key) ?? {
+			key,
+			count: 0,
+			users: []
+		};
+		entry.count += 1;
+		if (sender && !entry.users.includes(sender)) entry.users.push(sender);
+		summaries.set(key, entry);
+	}
+	return Array.from(summaries.values());
+}
+function selectOwnMatrixReactionEventIds(events, userId, emoji) {
+	const senderId = normalizeOptionalString(userId) ?? "";
+	if (!senderId) return [];
+	const targetEmoji = normalizeOptionalString(emoji);
+	const ids = [];
+	for (const event of events) {
+		if ((normalizeOptionalString(event.sender) ?? "") !== senderId) continue;
+		if (targetEmoji && extractMatrixReactionKey(event.content) !== targetEmoji) continue;
+		const eventId = normalizeOptionalString(event.event_id);
+		if (eventId) ids.push(eventId);
+	}
+	return ids;
+}
+//#endregion
+export { extractMatrixReactionAnnotation as a, buildMatrixReactionRelationsPath as i, MATRIX_REACTION_EVENT_TYPE as n, selectOwnMatrixReactionEventIds as o, buildMatrixReactionContent as r, summarizeMatrixReactionEvents as s, MATRIX_ANNOTATION_RELATION_TYPE as t };

package/dist/reaction-events-CiARZfjk.js

@@ -0,0 +1,121 @@
+import { a as resolveMatrixAccountConfig } from "./account-config-D2W-V1eQ.js";
+import { a as extractMatrixReactionAnnotation } from "./reaction-common-ejrL19w-.js";
+import { a as unregisterMatrixApprovalReactionTarget, i as resolveMatrixApprovalReactionTargetWithPersistence } from "./approval-reactions-o2_tuH8D.js";
+import { i as resolveMatrixThreadRouting, r as resolveMatrixThreadRootId, t as resolveMatrixInboundRoute } from "./route-D6rg-iXN.js";
+import { getSessionBindingService } from "openclaw/plugin-sdk/session-binding-runtime";
+//#region extensions/matrix/src/matrix/monitor/reaction-events.ts
+let approvalReactionAuthPromise;
+let execApprovalResolverPromise;
+function loadApprovalReactionAuth() {
+	approvalReactionAuthPromise ??= import("./approval-reaction-auth-DbcA1gGd.js");
+	return approvalReactionAuthPromise;
+}
+function loadExecApprovalResolver() {
+	execApprovalResolverPromise ??= import("./exec-approval-resolver-Bza9Dhlm.js");
+	return execApprovalResolverPromise;
+}
+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)}`);
+		return true;
+	}
+}
+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, resolveMatrixReactionNotificationMode };

package/dist/record-shared-CHWJCTWf.js

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