@openclaw/matrix 2026.3.12 → 2026.5.9-beta.1

package/dist/session-store-metadata-DI5SCofx.js

@@ -0,0 +1,77 @@
+import { a as resolveMatrixTargetIdentity, i as resolveMatrixDirectUserId } from "./target-ids-80nQ2gql.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, formatAllowlistMatchMeta, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
+import { createReplyPrefixOptions, createTypingCallbacks } from "openclaw/plugin-sdk/channel-reply-options-runtime";
+import { formatLocationText, toLocationContext } from "openclaw/plugin-sdk/channel-location";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/agent-media-payload";
+import { logInboundDrop, logTypingFailure } from "openclaw/plugin-sdk/channel-logging";
+import { buildChannelKeyCandidates, resolveChannelEntryMatch } from "openclaw/plugin-sdk/channel-targets";
+//#region extensions/matrix/src/matrix/monitor/rooms.ts
+function readLegacyRoomAllowAlias(room) {
+	const rawRoom = room;
+	return typeof rawRoom?.allow === "boolean" ? rawRoom.allow : void 0;
+}
+function resolveMatrixRoomConfig(params) {
+	const rooms = params.rooms ?? {};
+	const allowlistConfigured = Object.keys(rooms).length > 0;
+	const { entry: matched, key: matchedKey, wildcardEntry, wildcardKey } = resolveChannelEntryMatch({
+		entries: rooms,
+		keys: buildChannelKeyCandidates(params.roomId, `room:${params.roomId}`, ...params.aliases),
+		wildcardKey: "*"
+	});
+	const resolved = matched ?? wildcardEntry;
+	const legacyAllow = readLegacyRoomAllowAlias(resolved);
+	return {
+		allowed: resolved ? resolved.enabled !== false && legacyAllow !== false : false,
+		allowlistConfigured,
+		config: resolved,
+		matchKey: matchedKey ?? wildcardKey,
+		matchSource: matched ? "direct" : wildcardEntry ? "wildcard" : void 0
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/session-store-metadata.ts
+function trimMaybeString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveMatrixRoomTargetId(value) {
+	const trimmed = trimMaybeString(value);
+	if (!trimmed) return;
+	const target = resolveMatrixTargetIdentity(trimmed);
+	return target?.kind === "room" && target.id.startsWith("!") ? target.id : void 0;
+}
+function resolveMatrixSessionAccountId(value) {
+	const trimmed = trimMaybeString(value);
+	return trimmed ? normalizeAccountId(trimmed) : void 0;
+}
+function resolveMatrixStoredRoomId(params) {
+	return resolveMatrixRoomTargetId(params.deliveryTo) ?? resolveMatrixRoomTargetId(params.lastTo) ?? resolveMatrixRoomTargetId(params.originNativeChannelId) ?? resolveMatrixRoomTargetId(params.originTo);
+}
+function resolveMatrixStoredSessionMeta(entry) {
+	if (!entry) return null;
+	const channel = trimMaybeString(entry.deliveryContext?.channel) ?? trimMaybeString(entry.lastChannel) ?? trimMaybeString(entry.origin?.provider);
+	const accountId = resolveMatrixSessionAccountId(entry.deliveryContext?.accountId ?? entry.lastAccountId ?? entry.origin?.accountId) ?? void 0;
+	const roomId = resolveMatrixStoredRoomId({
+		deliveryTo: entry.deliveryContext?.to,
+		lastTo: entry.lastTo,
+		originNativeChannelId: entry.origin?.nativeChannelId,
+		originTo: entry.origin?.to
+	});
+	const chatType = trimMaybeString(entry.origin?.chatType) ?? trimMaybeString(entry.chatType) ?? void 0;
+	const directUserId = chatType === "direct" ? trimMaybeString(entry.origin?.nativeDirectUserId) ?? resolveMatrixDirectUserId({
+		from: trimMaybeString(entry.origin?.from),
+		to: (roomId ? `room:${roomId}` : void 0) ?? trimMaybeString(entry.deliveryContext?.to) ?? trimMaybeString(entry.lastTo) ?? trimMaybeString(entry.origin?.to),
+		chatType
+	}) : void 0;
+	if (!channel && !accountId && !roomId && !directUserId) return null;
+	return {
+		...channel ? { channel } : {},
+		...accountId ? { accountId } : {},
+		...roomId ? { roomId } : {},
+		...directUserId ? { directUserId } : {}
+	};
+}
+//#endregion
+export { canonicalizeAllowlistWithResolvedIds as a, formatAllowlistMatchMeta as c, logInboundDrop as d, logTypingFailure as f, toLocationContext as h, buildAllowlistResolutionSummary as i, formatLocationText as l, summarizeMapping as m, resolveMatrixRoomConfig as n, createReplyPrefixOptions as o, patchAllowlistUsersInConfigEntries as p, addAllowlistUserEntriesFromConfigEntry as r, createTypingCallbacks as s, resolveMatrixStoredSessionMeta as t, getAgentScopedMediaLocalRoots as u };

package/dist/setup-bootstrap-ImenBsMt.js

@@ -0,0 +1,62 @@
+import { a as resolveMatrixAccountConfig, n as hasExplicitMatrixAccountConfig } from "./account-config-D2W-V1eQ.js";
+import "./accounts-Bm90Rzvp.js";
+import { t as formatMatrixErrorMessage } from "./errors-CTcpEDq-.js";
+import { n as bootstrapMatrixVerification } from "./verification-CZ2rDeHL.js";
+//#region extensions/matrix/src/setup-bootstrap.ts
+async function maybeBootstrapNewEncryptedMatrixAccount(params) {
+	const accountConfig = resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const previousAccountConfig = resolveMatrixAccountConfig({
+		cfg: params.previousCfg,
+		accountId: params.accountId
+	});
+	if (accountConfig.encryption !== true || hasExplicitMatrixAccountConfig(params.previousCfg, params.accountId) && previousAccountConfig.encryption === true) return {
+		attempted: false,
+		success: false,
+		recoveryKeyCreatedAt: null,
+		backupVersion: null
+	};
+	try {
+		const bootstrap = await bootstrapMatrixVerification({
+			accountId: params.accountId,
+			cfg: params.cfg
+		});
+		return {
+			attempted: true,
+			success: bootstrap.success,
+			recoveryKeyCreatedAt: bootstrap.verification.recoveryKeyCreatedAt,
+			backupVersion: bootstrap.verification.backupVersion,
+			...bootstrap.success ? {} : { error: bootstrap.error ?? "Matrix verification bootstrap failed" }
+		};
+	} catch (err) {
+		return {
+			attempted: true,
+			success: false,
+			recoveryKeyCreatedAt: null,
+			backupVersion: null,
+			error: formatMatrixErrorMessage(err)
+		};
+	}
+}
+async function runMatrixSetupBootstrapAfterConfigWrite(params) {
+	if (resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).encryption !== true) return;
+	const bootstrap = await maybeBootstrapNewEncryptedMatrixAccount({
+		previousCfg: params.previousCfg,
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!bootstrap.attempted) return;
+	if (bootstrap.success) {
+		params.runtime.log(`Matrix verification bootstrap: complete for "${params.accountId}".`);
+		if (bootstrap.backupVersion) params.runtime.log(`Matrix backup version for "${params.accountId}": ${bootstrap.backupVersion}`);
+		return;
+	}
+	params.runtime.error(`Matrix verification bootstrap warning for "${params.accountId}": ${bootstrap.error ?? "unknown bootstrap failure"}`);
+}
+//#endregion
+export { maybeBootstrapNewEncryptedMatrixAccount, runMatrixSetupBootstrapAfterConfigWrite };

package/dist/setup-core-CfZy05oW.js

@@ -0,0 +1,116 @@
+import { a as resolveMatrixAccountConfig } from "./account-config-D2W-V1eQ.js";
+import { r as resolveDefaultMatrixAccountId } from "./accounts-Bm90Rzvp.js";
+import { i as validateMatrixSetupInput, n as applyMatrixSetupAccountConfig, t as resolveMatrixSetupDmAllowFrom } from "./setup-dm-policy-2-r1FrQh.js";
+import { t as resolveMatrixConfigFieldPath } from "./config-paths-nsVaysCu.js";
+import { r as updateMatrixAccountConfig } from "./config-update-wZX-HLMn.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, prepareScopedSetupConfig } from "openclaw/plugin-sdk/setup";
+//#region extensions/matrix/src/setup-core.ts
+const channel = "matrix";
+function resolveMatrixSetupAccountId(params) {
+	return normalizeAccountId(params.accountId?.trim() || params.name?.trim() || DEFAULT_ACCOUNT_ID);
+}
+function resolveMatrixSetupWizardAccountId(cfg, accountId) {
+	return normalizeAccountId(accountId?.trim() || resolveDefaultMatrixAccountId(cfg) || DEFAULT_ACCOUNT_ID);
+}
+function setMatrixDmPolicy(cfg, policy, accountId) {
+	const resolvedAccountId = resolveMatrixSetupWizardAccountId(cfg, accountId);
+	const existing = resolveMatrixAccountConfig({
+		cfg,
+		accountId: resolvedAccountId
+	});
+	const allowFrom = resolveMatrixSetupDmAllowFrom(policy, existing.dm?.allowFrom);
+	return updateMatrixAccountConfig(cfg, resolvedAccountId, { dm: {
+		...existing.dm,
+		policy,
+		allowFrom
+	} });
+}
+function createMatrixSetupWizardProxy(loadWizardModule) {
+	let wizardPromise = null;
+	const loadWizard = () => {
+		wizardPromise ??= loadWizardModule().then((module) => module.matrixSetupWizard);
+		return wizardPromise;
+	};
+	return {
+		channel,
+		getStatus: async (ctx) => await (await loadWizard()).getStatus(ctx),
+		configure: async (ctx) => await (await loadWizard()).configure(ctx),
+		configureInteractive: async (ctx) => {
+			const wizard = await loadWizard();
+			return await (wizard.configureInteractive ?? wizard.configure)(ctx);
+		},
+		configureWhenConfigured: async (ctx) => {
+			const wizard = await loadWizard();
+			return await (wizard.configureWhenConfigured ?? wizard.configureInteractive ?? wizard.configure)(ctx);
+		},
+		afterConfigWritten: async (ctx) => await (await loadWizard()).afterConfigWritten?.(ctx),
+		dmPolicy: {
+			label: "Matrix",
+			channel,
+			policyKey: "channels.matrix.dm.policy",
+			allowFromKey: "channels.matrix.dm.allowFrom",
+			resolveConfigKeys: (cfg, accountId) => {
+				const resolvedAccountId = resolveMatrixSetupWizardAccountId(cfg, accountId);
+				return {
+					policyKey: resolveMatrixConfigFieldPath(cfg, resolvedAccountId, "dm.policy"),
+					allowFromKey: resolveMatrixConfigFieldPath(cfg, resolvedAccountId, "dm.allowFrom")
+				};
+			},
+			getCurrent: (cfg, accountId) => resolveMatrixAccountConfig({
+				cfg,
+				accountId: resolveMatrixSetupWizardAccountId(cfg, accountId)
+			}).dm?.policy ?? "pairing",
+			setPolicy: (cfg, policy, accountId) => setMatrixDmPolicy(cfg, policy, accountId),
+			promptAllowFrom: async (params) => {
+				const promptAllowFrom = (await loadWizard()).dmPolicy?.promptAllowFrom;
+				return promptAllowFrom ? await promptAllowFrom(params) : params.cfg;
+			}
+		},
+		disable: (cfg) => ({
+			...cfg,
+			channels: {
+				...cfg.channels,
+				matrix: {
+					...cfg.channels?.matrix,
+					enabled: false
+				}
+			}
+		})
+	};
+}
+const matrixSetupAdapter = {
+	resolveAccountId: ({ accountId, input }) => resolveMatrixSetupAccountId({
+		accountId,
+		name: input?.name
+	}),
+	resolveBindingAccountId: ({ accountId, agentId }) => resolveMatrixSetupAccountId({
+		accountId,
+		name: agentId
+	}),
+	applyAccountName: ({ cfg, accountId, name }) => prepareScopedSetupConfig({
+		cfg,
+		channelKey: channel,
+		accountId,
+		name
+	}),
+	validateInput: ({ accountId, input }) => validateMatrixSetupInput({
+		accountId,
+		input
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => applyMatrixSetupAccountConfig({
+		cfg,
+		accountId,
+		input
+	}),
+	afterAccountConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
+		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-ImenBsMt.js");
+		await runMatrixSetupBootstrapAfterConfigWrite({
+			previousCfg,
+			cfg,
+			accountId,
+			runtime
+		});
+	}
+};
+//#endregion
+export { matrixSetupAdapter as n, createMatrixSetupWizardProxy as t };

package/dist/setup-dm-policy-2-r1FrQh.js

@@ -0,0 +1,194 @@
+import { r as resolveMatrixEnvAuthReadiness } from "./env-auth-BJqGI8M6.js";
+import { r as updateMatrixAccountConfig } from "./config-update-wZX-HLMn.js";
+import { t as isSupportedMatrixAvatarSource } from "./profile-BlHu0wDX.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, addWildcardAllowFrom, applyAccountNameToChannelSection, normalizeAccountId as normalizeAccountId$1, normalizeAllowFromEntries, normalizeSecretInputString } from "openclaw/plugin-sdk/setup";
+//#region extensions/matrix/src/setup-contract.ts
+const matrixSingleAccountKeysToMove = [
+	"deviceId",
+	"avatarUrl",
+	"initialSyncLimit",
+	"encryption",
+	"allowlistOnly",
+	"allowBots",
+	"blockStreaming",
+	"replyToMode",
+	"threadReplies",
+	"textChunkLimit",
+	"chunkMode",
+	"responsePrefix",
+	"ackReaction",
+	"ackReactionScope",
+	"reactionNotifications",
+	"threadBindings",
+	"startupVerification",
+	"startupVerificationCooldownHours",
+	"mediaMaxMb",
+	"autoJoin",
+	"autoJoinAllowlist",
+	"dm",
+	"groups",
+	"rooms",
+	"actions"
+];
+const matrixNamedAccountPromotionKeys = [
+	"name",
+	"homeserver",
+	"userId",
+	"accessToken",
+	"password",
+	"deviceId",
+	"deviceName",
+	"avatarUrl",
+	"initialSyncLimit",
+	"encryption"
+];
+const singleAccountKeysToMove = [...matrixSingleAccountKeysToMove];
+const namedAccountPromotionKeys = [...matrixNamedAccountPromotionKeys];
+function resolveSingleAccountPromotionTarget(params) {
+	const accounts = typeof params.channel.accounts === "object" && params.channel.accounts ? params.channel.accounts : {};
+	const normalizedDefaultAccount = typeof params.channel.defaultAccount === "string" && params.channel.defaultAccount.trim() ? normalizeAccountId(params.channel.defaultAccount) : void 0;
+	const matchedAccountId = normalizedDefaultAccount ? Object.entries(accounts).find(([accountId, value]) => accountId && value && typeof value === "object" && normalizeAccountId(accountId) === normalizedDefaultAccount)?.[0] : void 0;
+	if (matchedAccountId) return matchedAccountId;
+	if (normalizedDefaultAccount) return DEFAULT_ACCOUNT_ID;
+	const namedAccounts = Object.entries(accounts).filter(([accountId, value]) => accountId && typeof value === "object" && value);
+	if (namedAccounts.length === 1) return namedAccounts[0][0];
+	if (namedAccounts.length > 1 && accounts[DEFAULT_ACCOUNT_ID] && typeof accounts[DEFAULT_ACCOUNT_ID] === "object") return DEFAULT_ACCOUNT_ID;
+	return DEFAULT_ACCOUNT_ID;
+}
+//#endregion
+//#region extensions/matrix/src/setup-config.ts
+const channel = "matrix";
+const COMMON_SINGLE_ACCOUNT_KEYS_TO_MOVE = new Set([
+	"name",
+	"enabled",
+	"httpPort",
+	"webhookPath",
+	"webhookUrl",
+	"webhookSecret",
+	"service",
+	"region",
+	"homeserver",
+	"userId",
+	"accessToken",
+	"password",
+	"deviceName",
+	"url",
+	"code",
+	"dmPolicy",
+	"allowFrom",
+	"groupPolicy",
+	"groupAllowFrom",
+	"defaultTo"
+]);
+const MATRIX_SINGLE_ACCOUNT_KEYS_TO_MOVE = new Set(matrixSingleAccountKeysToMove);
+const MATRIX_NAMED_ACCOUNT_PROMOTION_KEYS = new Set(matrixNamedAccountPromotionKeys);
+function cloneIfObject(value) {
+	if (value && typeof value === "object") return structuredClone(value);
+	return value;
+}
+function resolveSetupAvatarUrl(input) {
+	const avatarUrl = input.avatarUrl;
+	if (typeof avatarUrl !== "string") return;
+	return avatarUrl.trim() || void 0;
+}
+function resolveExistingMatrixAccountKey(accounts, targetAccountId) {
+	const normalizedTargetAccountId = normalizeAccountId$1(targetAccountId);
+	return Object.keys(accounts).find((accountId) => normalizeAccountId$1(accountId) === normalizedTargetAccountId) ?? targetAccountId;
+}
+function moveSingleMatrixAccountConfigToNamedAccount(cfg) {
+	const baseConfig = cfg.channels?.[channel];
+	const base = typeof baseConfig === "object" && baseConfig ? baseConfig : void 0;
+	if (!base) return cfg;
+	const accounts = typeof base.accounts === "object" && base.accounts ? base.accounts : {};
+	const hasNamedAccounts = Object.keys(accounts).some(Boolean);
+	const keysToMove = Object.entries(base).filter(([key, value]) => {
+		if (key === "accounts" || key === "enabled" || value === void 0) return false;
+		if (!COMMON_SINGLE_ACCOUNT_KEYS_TO_MOVE.has(key) && !MATRIX_SINGLE_ACCOUNT_KEYS_TO_MOVE.has(key)) return false;
+		if (hasNamedAccounts && !MATRIX_NAMED_ACCOUNT_PROMOTION_KEYS.has(key)) return false;
+		return true;
+	}).map(([key]) => key);
+	if (keysToMove.length === 0) return cfg;
+	const resolvedTargetAccountId = resolveExistingMatrixAccountKey(accounts, resolveSingleAccountPromotionTarget({ channel: base }));
+	const nextAccount = { ...accounts[resolvedTargetAccountId] };
+	for (const key of keysToMove) nextAccount[key] = cloneIfObject(base[key]);
+	const nextChannel = { ...base };
+	for (const key of keysToMove) delete nextChannel[key];
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			[channel]: {
+				...nextChannel,
+				accounts: {
+					...accounts,
+					[resolvedTargetAccountId]: nextAccount
+				}
+			}
+		}
+	};
+}
+function validateMatrixSetupInput(params) {
+	const avatarUrl = resolveSetupAvatarUrl(params.input);
+	if (avatarUrl && !isSupportedMatrixAvatarSource(avatarUrl)) return "Matrix avatar URL must be an mxc:// URI or an http(s) URL.";
+	if (params.input.useEnv) {
+		const envReadiness = resolveMatrixEnvAuthReadiness(params.accountId, process.env);
+		return envReadiness.ready ? null : envReadiness.missingMessage;
+	}
+	if (!params.input.homeserver?.trim()) return "Matrix requires --homeserver";
+	const accessToken = params.input.accessToken?.trim();
+	const password = normalizeSecretInputString(params.input.password);
+	const userId = params.input.userId?.trim();
+	if (!accessToken && !password) return "Matrix requires --access-token or --password";
+	if (!accessToken) {
+		if (!userId) return "Matrix requires --user-id when using --password";
+		if (!password) return "Matrix requires --password when using --user-id";
+	}
+	return null;
+}
+function applyMatrixSetupAccountConfig(params) {
+	const normalizedAccountId = normalizeAccountId$1(params.accountId);
+	const next = applyAccountNameToChannelSection({
+		cfg: normalizedAccountId !== DEFAULT_ACCOUNT_ID$1 ? moveSingleMatrixAccountConfigToNamedAccount(params.cfg) : params.cfg,
+		channelKey: channel,
+		accountId: normalizedAccountId,
+		name: params.input.name
+	});
+	const avatarUrl = resolveSetupAvatarUrl(params.input);
+	if (params.input.useEnv) return updateMatrixAccountConfig(next, normalizedAccountId, {
+		enabled: true,
+		homeserver: null,
+		allowPrivateNetwork: null,
+		proxy: null,
+		userId: null,
+		accessToken: null,
+		password: null,
+		deviceId: null,
+		deviceName: null,
+		avatarUrl
+	});
+	const accessToken = params.input.accessToken?.trim();
+	const password = normalizeSecretInputString(params.input.password);
+	const userId = params.input.userId?.trim();
+	return updateMatrixAccountConfig(next, normalizedAccountId, {
+		enabled: true,
+		homeserver: params.input.homeserver?.trim(),
+		allowPrivateNetwork: typeof params.input.dangerouslyAllowPrivateNetwork === "boolean" ? params.input.dangerouslyAllowPrivateNetwork : typeof params.input.allowPrivateNetwork === "boolean" ? params.input.allowPrivateNetwork : void 0,
+		proxy: normalizeOptionalString(params.input.proxy),
+		userId: password && !userId ? null : userId,
+		accessToken: accessToken || (password ? null : void 0),
+		password: password || (accessToken ? null : void 0),
+		deviceName: params.input.deviceName?.trim(),
+		avatarUrl,
+		initialSyncLimit: params.input.initialSyncLimit
+	});
+}
+//#endregion
+//#region extensions/matrix/src/setup-dm-policy.ts
+function resolveMatrixSetupDmAllowFrom(policy, allowFrom) {
+	if (policy === "open") return addWildcardAllowFrom(allowFrom);
+	return normalizeAllowFromEntries(allowFrom ?? []).filter((entry) => entry !== "*");
+}
+//#endregion
+export { namedAccountPromotionKeys as a, validateMatrixSetupInput as i, applyMatrixSetupAccountConfig as n, resolveSingleAccountPromotionTarget as o, moveSingleMatrixAccountConfigToNamedAccount as r, singleAccountKeysToMove as s, resolveMatrixSetupDmAllowFrom as t };

package/dist/setup-entry.js

@@ -0,0 +1,19 @@
+import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/matrix/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./setup-plugin-api.js",
+		exportName: "matrixSetupPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	},
+	runtime: {
+		specifier: "./runtime-setter-api.js",
+		exportName: "setMatrixRuntime"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-plugin-api.js

@@ -0,0 +1,44 @@
+import { i as resolveMatrixAccount } from "./accounts-Bm90Rzvp.js";
+import { r as matrixConfigAdapter, t as MatrixChannelConfigSchema } from "./config-schema-nPLpEgHl.js";
+import { n as matrixSetupAdapter, t as createMatrixSetupWizardProxy } from "./setup-core-CfZy05oW.js";
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+const matrixSetupPlugin = {
+	id: "matrix",
+	meta: {
+		id: "matrix",
+		label: "Matrix",
+		selectionLabel: "Matrix (plugin)",
+		docsPath: "/channels/matrix",
+		docsLabel: "matrix",
+		blurb: "open protocol; configure a homeserver + access token.",
+		order: 70,
+		quickstartAllowFrom: true
+	},
+	setupWizard: createMatrixSetupWizardProxy(async () => ({ matrixSetupWizard: (await import("./setup-surface-CqT_o61M.js").then((n) => n.t)).matrixSetupWizard })),
+	setup: matrixSetupAdapter,
+	capabilities: {
+		chatTypes: [
+			"direct",
+			"group",
+			"thread"
+		],
+		polls: true,
+		reactions: true,
+		threads: true,
+		media: true
+	},
+	reload: { configPrefixes: ["channels.matrix"] },
+	configSchema: MatrixChannelConfigSchema,
+	config: {
+		...matrixConfigAdapter,
+		isConfigured: (account) => account.configured,
+		describeAccount: (account) => describeAccountSnapshot({
+			account,
+			configured: account.configured,
+			extra: { baseUrl: account.homeserver }
+		}),
+		hasConfiguredState: ({ cfg }) => resolveMatrixAccount({ cfg }).configured
+	}
+};
+//#endregion
+export { matrixSetupPlugin };