@openclaw/matrix 2026.3.12 → 2026.5.9-beta.1

package/dist/encryption-guidance-BPi3A_m3.js

@@ -0,0 +1,15 @@
+import { a as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-BWwIruri.js";
+import { t as resolveMatrixConfigFieldPath } from "./config-paths-nsVaysCu.js";
+import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/encryption-guidance.ts
+function resolveMatrixEncryptionConfigPath(cfg, accountId) {
+	return resolveMatrixConfigFieldPath(cfg, normalizeOptionalAccountId(accountId) ?? resolveMatrixDefaultOrOnlyAccountId(cfg), "encryption");
+}
+function formatMatrixEncryptionUnavailableError(cfg, accountId) {
+	return `Matrix encryption is not available (enable ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true)`;
+}
+function formatMatrixEncryptedEventDisabledWarning(cfg, accountId) {
+	return `matrix: encrypted event received without encryption enabled; set ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true and verify the device to decrypt`;
+}
+//#endregion
+export { formatMatrixEncryptionUnavailableError as n, formatMatrixEncryptedEventDisabledWarning as t };

package/dist/env-auth-BJqGI8M6.js

@@ -0,0 +1,63 @@
+import { t as getMatrixScopedEnvVarNames } from "./env-vars-C7uQCTKn.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/client/env-auth.ts
+function cleanEnv(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function resolveGlobalMatrixEnvConfig(env) {
+	return {
+		homeserver: cleanEnv(env.MATRIX_HOMESERVER),
+		userId: cleanEnv(env.MATRIX_USER_ID),
+		accessToken: cleanEnv(env.MATRIX_ACCESS_TOKEN) || void 0,
+		password: cleanEnv(env.MATRIX_PASSWORD) || void 0,
+		deviceId: cleanEnv(env.MATRIX_DEVICE_ID) || void 0,
+		deviceName: cleanEnv(env.MATRIX_DEVICE_NAME) || void 0
+	};
+}
+function hasReadyMatrixEnvAuth(config) {
+	const homeserver = cleanEnv(config.homeserver);
+	const userId = cleanEnv(config.userId);
+	const accessToken = cleanEnv(config.accessToken);
+	const password = cleanEnv(config.password);
+	return Boolean(homeserver && (accessToken || userId && password));
+}
+function resolveScopedMatrixEnvConfig(accountId, env = process.env) {
+	const keys = getMatrixScopedEnvVarNames(accountId);
+	return {
+		homeserver: cleanEnv(env[keys.homeserver]),
+		userId: cleanEnv(env[keys.userId]),
+		accessToken: cleanEnv(env[keys.accessToken]) || void 0,
+		password: cleanEnv(env[keys.password]) || void 0,
+		deviceId: cleanEnv(env[keys.deviceId]) || void 0,
+		deviceName: cleanEnv(env[keys.deviceName]) || void 0
+	};
+}
+function resolveMatrixEnvAuthReadiness(accountId, env = process.env) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const scoped = resolveScopedMatrixEnvConfig(normalizedAccountId, env);
+	const scopedReady = hasReadyMatrixEnvAuth(scoped);
+	if (normalizedAccountId !== DEFAULT_ACCOUNT_ID) {
+		const keys = getMatrixScopedEnvVarNames(normalizedAccountId);
+		return {
+			ready: scopedReady,
+			homeserver: scoped.homeserver || void 0,
+			userId: scoped.userId || void 0,
+			sourceHint: `${keys.homeserver} (+ auth vars)`,
+			missingMessage: `Set per-account env vars for "${normalizedAccountId}" (for example ${keys.homeserver} + ${keys.accessToken} or ${keys.userId} + ${keys.password}).`
+		};
+	}
+	const defaultScoped = resolveScopedMatrixEnvConfig(DEFAULT_ACCOUNT_ID, env);
+	const global = resolveGlobalMatrixEnvConfig(env);
+	const defaultScopedReady = hasReadyMatrixEnvAuth(defaultScoped);
+	const globalReady = hasReadyMatrixEnvAuth(global);
+	const defaultKeys = getMatrixScopedEnvVarNames(DEFAULT_ACCOUNT_ID);
+	return {
+		ready: defaultScopedReady || globalReady,
+		homeserver: defaultScoped.homeserver || global.homeserver || void 0,
+		userId: defaultScoped.userId || global.userId || void 0,
+		sourceHint: "MATRIX_* or MATRIX_DEFAULT_*",
+		missingMessage: `Set Matrix env vars for the default account (for example MATRIX_HOMESERVER + MATRIX_ACCESS_TOKEN, MATRIX_USER_ID + MATRIX_PASSWORD, or ${defaultKeys.homeserver} + ${defaultKeys.accessToken}).`
+	};
+}
+//#endregion
+export { resolveScopedMatrixEnvConfig as i, resolveGlobalMatrixEnvConfig as n, resolveMatrixEnvAuthReadiness as r, hasReadyMatrixEnvAuth as t };

package/dist/env-vars-C7uQCTKn.js

@@ -0,0 +1,63 @@
+import { normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/env-vars.ts
+const MATRIX_SCOPED_ENV_SUFFIXES = [
+	"HOMESERVER",
+	"USER_ID",
+	"ACCESS_TOKEN",
+	"PASSWORD",
+	"DEVICE_ID",
+	"DEVICE_NAME"
+];
+const MATRIX_GLOBAL_ENV_KEYS = MATRIX_SCOPED_ENV_SUFFIXES.map((suffix) => `MATRIX_${suffix}`);
+const MATRIX_SCOPED_ENV_RE = new RegExp(`^MATRIX_(.+)_(${MATRIX_SCOPED_ENV_SUFFIXES.join("|")})$`);
+function resolveMatrixEnvAccountToken(accountId) {
+	return Array.from(normalizeAccountId(accountId)).map((char) => /[a-z0-9]/.test(char) ? char.toUpperCase() : `_X${char.codePointAt(0)?.toString(16).toUpperCase() ?? "00"}_`).join("");
+}
+function getMatrixScopedEnvVarNames(accountId) {
+	const token = resolveMatrixEnvAccountToken(accountId);
+	return {
+		homeserver: `MATRIX_${token}_HOMESERVER`,
+		userId: `MATRIX_${token}_USER_ID`,
+		accessToken: `MATRIX_${token}_ACCESS_TOKEN`,
+		password: `MATRIX_${token}_PASSWORD`,
+		deviceId: `MATRIX_${token}_DEVICE_ID`,
+		deviceName: `MATRIX_${token}_DEVICE_NAME`
+	};
+}
+function decodeMatrixEnvAccountToken(token) {
+	let decoded = "";
+	for (let index = 0; index < token.length;) {
+		const hexEscape = /^_X([0-9A-F]+)_/.exec(token.slice(index));
+		if (hexEscape) {
+			const hex = hexEscape[1];
+			const codePoint = hex ? Number.parseInt(hex, 16) : NaN;
+			if (!Number.isFinite(codePoint)) return;
+			decoded += String.fromCodePoint(codePoint);
+			index += hexEscape[0].length;
+			continue;
+		}
+		const char = token[index];
+		if (!char || !/[A-Z0-9]/.test(char)) return;
+		decoded += char.toLowerCase();
+		index += 1;
+	}
+	const normalized = normalizeOptionalAccountId(decoded);
+	if (!normalized) return;
+	return resolveMatrixEnvAccountToken(normalized) === token ? normalized : void 0;
+}
+function listMatrixEnvAccountIds(env = process.env) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const key of MATRIX_GLOBAL_ENV_KEYS) if (typeof env[key] === "string" && env[key]?.trim()) {
+		ids.add(normalizeAccountId("default"));
+		break;
+	}
+	for (const key of Object.keys(env)) {
+		const match = MATRIX_SCOPED_ENV_RE.exec(key);
+		if (!match) continue;
+		const accountId = decodeMatrixEnvAccountToken(match[1]);
+		if (accountId) ids.add(accountId);
+	}
+	return Array.from(ids).toSorted((a, b) => a.localeCompare(b));
+}
+//#endregion
+export { listMatrixEnvAccountIds as n, resolveMatrixEnvAccountToken as r, getMatrixScopedEnvVarNames as t };

package/dist/errors-CTcpEDq-.js

@@ -0,0 +1,17 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+//#region extensions/matrix/src/matrix/errors.ts
+function formatMatrixErrorMessage(err) {
+	return formatErrorMessage(err);
+}
+function formatMatrixErrorReason(err) {
+	return normalizeLowercaseStringOrEmpty(formatMatrixErrorMessage(err));
+}
+function isMatrixNotFoundError(err) {
+	const errObj = err;
+	if (errObj?.statusCode === 404 || errObj?.body?.errcode === "M_NOT_FOUND") return true;
+	const message = formatMatrixErrorReason(err);
+	return message.includes("m_not_found") || message.includes("[404]") || message.includes("not found");
+}
+//#endregion
+export { formatMatrixErrorReason as n, isMatrixNotFoundError as r, formatMatrixErrorMessage as t };

package/dist/exec-approval-resolver-Bza9Dhlm.js

@@ -0,0 +1,15 @@
+import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
+import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
+//#region extensions/matrix/src/exec-approval-resolver.ts
+async function resolveMatrixApproval(params) {
+	await resolveApprovalOverGateway({
+		cfg: params.cfg,
+		approvalId: params.approvalId,
+		decision: params.decision,
+		senderId: params.senderId,
+		gatewayUrl: params.gatewayUrl,
+		clientDisplayName: `Matrix approval (${params.senderId?.trim() || "unknown"})`
+	});
+}
+//#endregion
+export { isApprovalNotFoundError, resolveMatrixApproval };

package/dist/exec-approvals-Crnh543m.js

@@ -0,0 +1,196 @@
+import { i as resolveMatrixAccount, t as listMatrixAccountIds } from "./accounts-Bm90Rzvp.js";
+import { t as normalizeMatrixApproverId } from "./approval-ids-DoC2z7tR.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveApprovalRequestChannelAccountId } from "openclaw/plugin-sdk/approval-native-runtime";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { createChannelExecApprovalProfile, getExecApprovalReplyMetadata, isChannelExecApprovalClientEnabledFromConfig, isChannelExecApprovalTargetRecipient, matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+//#region extensions/matrix/src/approval-auth.ts
+function getMatrixApprovalAuthApprovers(params) {
+	return resolveApprovalApprovers({
+		allowFrom: resolveMatrixAccount(params).config.dm?.allowFrom,
+		normalizeApprover: normalizeMatrixApproverId
+	});
+}
+const matrixApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Matrix",
+	resolveApprovers: ({ cfg, accountId }) => getMatrixApprovalAuthApprovers({
+		cfg,
+		accountId
+	}),
+	normalizeSenderId: (value) => normalizeMatrixApproverId(value)
+});
+//#endregion
+//#region extensions/matrix/src/exec-approvals.ts
+function normalizeMatrixExecApproverId(value) {
+	const normalized = normalizeMatrixApproverId(value);
+	return normalized === "*" ? void 0 : normalized;
+}
+function resolveMatrixExecApprovalConfig(params) {
+	const account = resolveMatrixAccount(params);
+	const config = account.config.execApprovals;
+	if (!config) return;
+	return {
+		...config,
+		enabled: account.enabled && account.configured ? config.enabled : false
+	};
+}
+function countMatrixExecApprovalEligibleAccounts(params) {
+	return listMatrixAccountIds(params.cfg).filter((accountId) => {
+		const account = resolveMatrixAccount({
+			cfg: params.cfg,
+			accountId
+		});
+		if (!account.enabled || !account.configured) return false;
+		const config = resolveMatrixExecApprovalConfig({
+			cfg: params.cfg,
+			accountId
+		});
+		const filters = config?.enabled ? {
+			agentFilter: config.agentFilter,
+			sessionFilter: config.sessionFilter
+		} : {
+			agentFilter: void 0,
+			sessionFilter: void 0
+		};
+		return isChannelExecApprovalClientEnabledFromConfig({
+			enabled: config?.enabled,
+			approverCount: getMatrixApprovalApprovers({
+				cfg: params.cfg,
+				accountId,
+				approvalKind: params.approvalKind
+			}).length
+		}) && matchesApprovalRequestFilters({
+			request: params.request.request,
+			agentFilter: filters.agentFilter,
+			sessionFilter: filters.sessionFilter
+		});
+	}).length;
+}
+function matchesMatrixRequestAccount(params) {
+	const turnSourceChannel = normalizeLowercaseStringOrEmpty(params.request.request.turnSourceChannel);
+	const boundAccountId = resolveApprovalRequestChannelAccountId({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "matrix"
+	});
+	if (turnSourceChannel && turnSourceChannel !== "matrix" && !boundAccountId) return countMatrixExecApprovalEligibleAccounts({
+		cfg: params.cfg,
+		request: params.request,
+		approvalKind: params.approvalKind
+	}) <= 1;
+	return !boundAccountId || !params.accountId || normalizeAccountId(boundAccountId) === normalizeAccountId(params.accountId);
+}
+function getMatrixExecApprovalApprovers(params) {
+	const account = resolveMatrixAccount(params).config;
+	return resolveApprovalApprovers({
+		explicit: account.execApprovals?.approvers,
+		allowFrom: account.dm?.allowFrom,
+		normalizeApprover: normalizeMatrixExecApproverId
+	});
+}
+function resolveMatrixApprovalKind(request) {
+	return request.id.startsWith("plugin:") ? "plugin" : "exec";
+}
+function getMatrixApprovalApprovers(params) {
+	if (params.approvalKind === "plugin") return getMatrixApprovalAuthApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return getMatrixExecApprovalApprovers(params);
+}
+function isMatrixExecApprovalTargetRecipient(params) {
+	return isChannelExecApprovalTargetRecipient({
+		...params,
+		channel: "matrix",
+		normalizeSenderId: normalizeMatrixApproverId,
+		matchTarget: ({ target, normalizedSenderId }) => normalizeMatrixApproverId(target.to) === normalizedSenderId
+	});
+}
+const matrixExecApprovalProfile = createChannelExecApprovalProfile({
+	resolveConfig: resolveMatrixExecApprovalConfig,
+	resolveApprovers: getMatrixExecApprovalApprovers,
+	normalizeSenderId: normalizeMatrixApproverId,
+	isTargetRecipient: isMatrixExecApprovalTargetRecipient,
+	matchesRequestAccount: (params) => matchesMatrixRequestAccount({
+		...params,
+		approvalKind: "exec"
+	})
+});
+const isMatrixExecApprovalClientEnabled = matrixExecApprovalProfile.isClientEnabled;
+matrixExecApprovalProfile.isApprover;
+const isMatrixExecApprovalAuthorizedSender = matrixExecApprovalProfile.isAuthorizedSender;
+const resolveMatrixExecApprovalTarget = matrixExecApprovalProfile.resolveTarget;
+matrixExecApprovalProfile.shouldHandleRequest;
+function isMatrixApprovalClientEnabled(params) {
+	if (params.approvalKind === "exec") return isMatrixExecApprovalClientEnabled(params);
+	return isChannelExecApprovalClientEnabledFromConfig({
+		enabled: resolveMatrixExecApprovalConfig(params)?.enabled,
+		approverCount: getMatrixApprovalApprovers(params).length
+	});
+}
+function isMatrixAnyApprovalClientEnabled(params) {
+	return isMatrixApprovalClientEnabled({
+		...params,
+		approvalKind: "exec"
+	}) || isMatrixApprovalClientEnabled({
+		...params,
+		approvalKind: "plugin"
+	});
+}
+function shouldHandleMatrixApprovalRequest(params) {
+	const approvalKind = resolveMatrixApprovalKind(params.request);
+	if (!matchesMatrixRequestAccount({
+		...params,
+		approvalKind
+	})) return false;
+	const config = resolveMatrixExecApprovalConfig(params);
+	if (!isChannelExecApprovalClientEnabledFromConfig({
+		enabled: config?.enabled,
+		approverCount: getMatrixApprovalApprovers({
+			...params,
+			approvalKind
+		}).length
+	})) return false;
+	return matchesApprovalRequestFilters({
+		request: params.request.request,
+		agentFilter: config?.agentFilter,
+		sessionFilter: config?.sessionFilter
+	});
+}
+function buildFilterCheckRequest(params) {
+	if (params.metadata.approvalKind === "plugin") return {
+		id: params.metadata.approvalId,
+		request: {
+			title: "Plugin Approval Required",
+			description: "",
+			agentId: params.metadata.agentId ?? null,
+			sessionKey: params.metadata.sessionKey ?? null
+		},
+		createdAtMs: 0,
+		expiresAtMs: 0
+	};
+	return {
+		id: params.metadata.approvalId,
+		request: {
+			command: "",
+			agentId: params.metadata.agentId ?? null,
+			sessionKey: params.metadata.sessionKey ?? null
+		},
+		createdAtMs: 0,
+		expiresAtMs: 0
+	};
+}
+function shouldSuppressLocalMatrixExecApprovalPrompt(params) {
+	if (!matrixExecApprovalProfile.shouldSuppressLocalPrompt(params)) return false;
+	const metadata = getExecApprovalReplyMetadata(params.payload);
+	if (!metadata) return false;
+	const request = buildFilterCheckRequest({ metadata });
+	return shouldHandleMatrixApprovalRequest({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		request
+	});
+}
+//#endregion
+export { isMatrixExecApprovalAuthorizedSender as a, shouldHandleMatrixApprovalRequest as c, matrixApprovalAuth as d, isMatrixApprovalClientEnabled as i, shouldSuppressLocalMatrixExecApprovalPrompt as l, getMatrixExecApprovalApprovers as n, isMatrixExecApprovalClientEnabled as o, isMatrixAnyApprovalClientEnabled as r, resolveMatrixExecApprovalTarget as s, getMatrixApprovalApprovers as t, getMatrixApprovalAuthApprovers as u };

package/dist/helper-api.js

@@ -0,0 +1,4 @@
+import { a as resolveMatrixDefaultOrOnlyAccountId, i as resolveMatrixChannelConfig, n as requiresExplicitMatrixDefaultAccount, r as resolveConfiguredMatrixAccountIds, t as findMatrixAccountEntry } from "./account-selection-BWwIruri.js";
+import { n as listMatrixEnvAccountIds, r as resolveMatrixEnvAccountToken, t as getMatrixScopedEnvVarNames } from "./env-vars-C7uQCTKn.js";
+import { a as resolveMatrixCredentialsPath, c as resolveMatrixLegacyFlatStoreRoot, i as resolveMatrixCredentialsFilename, l as sanitizeMatrixPathSegment, n as resolveMatrixAccountStorageRoot, o as resolveMatrixHomeserverKey, r as resolveMatrixCredentialsDir, s as resolveMatrixLegacyFlatStoragePaths, t as hashMatrixAccessToken } from "./storage-paths-BJLdnCjV.js";
+export { findMatrixAccountEntry, getMatrixScopedEnvVarNames, hashMatrixAccessToken, listMatrixEnvAccountIds, requiresExplicitMatrixDefaultAccount, resolveConfiguredMatrixAccountIds, resolveMatrixAccountStorageRoot, resolveMatrixChannelConfig, resolveMatrixCredentialsDir, resolveMatrixCredentialsFilename, resolveMatrixCredentialsPath, resolveMatrixDefaultOrOnlyAccountId, resolveMatrixEnvAccountToken, resolveMatrixHomeserverKey, resolveMatrixLegacyFlatStoragePaths, resolveMatrixLegacyFlatStoreRoot, sanitizeMatrixPathSegment };