@openclaw/matrix 2026.9.6 → 2026.9.7

package/dist/.setup/directory-live-CxqkcYbT.mjs

@@ -1,153 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { r as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
-import { d as resolveMatrixAuth } from "./client-ChrXpxos.mjs";
-import { t as MatrixAuthedHttpClient } from "./http-client-Bi6uKmzh.mjs";
-import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/matrix/src/directory-live.ts
-var directory_live_exports = /* @__PURE__ */ __exportAll({
-	listMatrixDirectoryGroupsLive: () => listMatrixDirectoryGroupsLive,
-	listMatrixDirectoryPeersLive: () => listMatrixDirectoryPeersLive
-});
-const MATRIX_DIRECTORY_TIMEOUT_MS = 1e4;
-function resolveMatrixDirectoryLimit(limit) {
-	return typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? Math.max(1, Math.floor(limit)) : 20;
-}
-function createMatrixDirectoryClient(auth) {
-	return new MatrixAuthedHttpClient({
-		homeserver: auth.homeserver,
-		accessToken: auth.accessToken,
-		ssrfPolicy: auth.ssrfPolicy,
-		dispatcherPolicy: auth.dispatcherPolicy
-	});
-}
-async function resolveMatrixDirectoryContext(params) {
-	const query = normalizeOptionalString(params.query) ?? "";
-	if (!query) return null;
-	const auth = await resolveMatrixAuth({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	return {
-		auth,
-		client: createMatrixDirectoryClient(auth),
-		query,
-		queryLower: normalizeLowercaseStringOrEmpty(query)
-	};
-}
-function createGroupDirectoryEntry(params) {
-	return {
-		kind: "group",
-		id: params.id,
-		name: params.name,
-		handle: params.handle
-	};
-}
-async function requestMatrixJson(client, params) {
-	const result = await client.requestJson({
-		method: params.method,
-		endpoint: params.endpoint,
-		body: params.body,
-		timeoutMs: MATRIX_DIRECTORY_TIMEOUT_MS
-	});
-	if (!isRecord(result)) throw new Error(`Matrix homeserver returned a non-object JSON response for ${params.endpoint}`);
-	return result;
-}
-async function listMatrixDirectoryPeersLive(params) {
-	const query = normalizeOptionalString(params.query) ?? "";
-	if (!query) return [];
-	const directUserId = normalizeMatrixMessagingTarget(query);
-	if (directUserId && isMatrixQualifiedUserId(directUserId)) return [{
-		kind: "user",
-		id: directUserId
-	}];
-	const context = await resolveMatrixDirectoryContext({
-		...params,
-		query
-	});
-	if (!context) return [];
-	return ((await requestMatrixJson(context.client, {
-		method: "POST",
-		endpoint: "/_matrix/client/v3/user_directory/search",
-		body: {
-			search_term: context.query,
-			limit: resolveMatrixDirectoryLimit(params.limit)
-		}
-	})).results ?? []).map((entry) => {
-		const userId = normalizeOptionalString(entry.user_id);
-		if (!userId) return null;
-		const displayName = normalizeOptionalString(entry.display_name);
-		return {
-			kind: "user",
-			id: userId,
-			name: displayName,
-			handle: displayName ? `@${displayName}` : void 0,
-			raw: entry
-		};
-	}).filter(Boolean);
-}
-async function resolveMatrixRoomAlias(client, alias) {
-	try {
-		const res = await requestMatrixJson(client, {
-			method: "GET",
-			endpoint: `/_matrix/client/v3/directory/room/${encodeURIComponent(alias)}`
-		});
-		return normalizeOptionalString(res.room_id) ?? null;
-	} catch {
-		return null;
-	}
-}
-async function fetchMatrixRoomName(client, roomId) {
-	try {
-		const res = await requestMatrixJson(client, {
-			method: "GET",
-			endpoint: `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state/m.room.name`
-		});
-		return normalizeOptionalString(res.name) ?? null;
-	} catch {
-		return null;
-	}
-}
-async function listMatrixDirectoryGroupsLive(params) {
-	const query = normalizeOptionalString(params.query) ?? "";
-	if (!query) return [];
-	const directTarget = normalizeMatrixMessagingTarget(query);
-	if (directTarget?.startsWith("!")) return [createGroupDirectoryEntry({
-		id: directTarget,
-		name: directTarget
-	})];
-	const context = await resolveMatrixDirectoryContext({
-		...params,
-		query
-	});
-	if (!context) return [];
-	const { client, queryLower } = context;
-	const limit = resolveMatrixDirectoryLimit(params.limit);
-	if (directTarget?.startsWith("#")) {
-		const roomId = await resolveMatrixRoomAlias(client, directTarget);
-		if (!roomId) return [];
-		return [createGroupDirectoryEntry({
-			id: roomId,
-			name: directTarget,
-			handle: directTarget
-		})];
-	}
-	const rooms = ((await requestMatrixJson(client, {
-		method: "GET",
-		endpoint: "/_matrix/client/v3/joined_rooms"
-	})).joined_rooms ?? []).map((roomId) => normalizeOptionalString(roomId)).filter((roomId) => Boolean(roomId));
-	const results = [];
-	for (const roomId of rooms) {
-		const name = await fetchMatrixRoomName(client, roomId);
-		if (!name || !normalizeLowercaseStringOrEmpty(name).includes(queryLower)) continue;
-		results.push({
-			kind: "group",
-			id: roomId,
-			name,
-			handle: `#${name}`
-		});
-		if (results.length >= limit) break;
-	}
-	return results;
-}
-//#endregion
-export { listMatrixDirectoryGroupsLive as n, listMatrixDirectoryPeersLive as r, directory_live_exports as t };

package/dist/.setup/doctor-BLCvdOFo.mjs

@@ -1,64 +0,0 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-HyWFZQVG.mjs";
-import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "openclaw/plugin-sdk/doctor-repair-runtime";
-//#region extensions/matrix/src/doctor.ts
-async function collectMatrixInstallPathWarnings(cfg) {
-	const issue = await detectPluginInstallPathIssue({
-		pluginId: "matrix",
-		install: cfg.plugins?.installs?.matrix
-	});
-	if (!issue) return [];
-	return formatPluginInstallPathIssue({
-		issue,
-		pluginLabel: "Matrix",
-		defaultInstallCommand: "openclaw plugins install @openclaw/matrix"
-	}).map((entry) => `- ${entry}`);
-}
-async function cleanStaleMatrixPluginConfig(cfg) {
-	const issue = await detectPluginInstallPathIssue({
-		pluginId: "matrix",
-		install: cfg.plugins?.installs?.matrix
-	});
-	if (!issue || issue.kind !== "missing-path") return {
-		config: cfg,
-		changes: []
-	};
-	const { config, actions } = removePluginFromConfig(cfg, "matrix");
-	const removed = [];
-	if (actions.install) removed.push("install record");
-	if (actions.loadPath) removed.push("load path");
-	if (actions.entry) removed.push("plugin entry");
-	if (actions.allowlist) removed.push("allowlist entry");
-	if (removed.length === 0) return {
-		config: cfg,
-		changes: []
-	};
-	return {
-		config,
-		changes: [`Removed stale Matrix plugin references (${removed.join(", ")}). The previous install path no longer exists: ${issue.path}`]
-	};
-}
-async function runMatrixDoctorSequence(params) {
-	const warningNotes = [];
-	const installWarnings = await collectMatrixInstallPathWarnings(params.cfg);
-	if (installWarnings.length > 0) warningNotes.push(installWarnings.join("\n"));
-	return {
-		changeNotes: [],
-		warningNotes
-	};
-}
-const matrixDoctor = {
-	dmAllowFromMode: "nestedOnly",
-	groupModel: "sender",
-	groupAllowFromFallbackToAllowFrom: false,
-	warnOnEmptyGroupSenderAllowlist: true,
-	legacyConfigRules,
-	normalizeCompatibilityConfig,
-	runConfigSequence: async ({ cfg, env, shouldRepair }) => await runMatrixDoctorSequence({
-		cfg,
-		env,
-		shouldRepair
-	}),
-	cleanStaleConfig: async ({ cfg }) => await cleanStaleMatrixPluginConfig(cfg)
-};
-//#endregion
-export { cleanStaleMatrixPluginConfig, collectMatrixInstallPathWarnings, matrixDoctor, runMatrixDoctorSequence };

package/dist/.setup/doctor-contract-HyWFZQVG.mjs

@@ -1,167 +0,0 @@
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { defineChannelAliasMigration, defineKeyMoveMigration, hasLegacyAccountStreamingAliases, hasLegacyFlatAllowPrivateNetworkAlias, migrateLegacyFlatAllowPrivateNetworkAlias, normalizeChannelConfigEntries, stripRetiredChannelKeys } from "openclaw/plugin-sdk/runtime-doctor-migrations";
-//#region extensions/matrix/src/doctor-contract.ts
-function parseMatrixStreamingMode(value) {
-	if (typeof value !== "string") return null;
-	const normalized = value.trim().toLowerCase();
-	return normalized === "partial" || normalized === "quiet" || normalized === "progress" || normalized === "off" ? normalized : null;
-}
-const streamingAliasMigration = defineChannelAliasMigration({
-	channelId: "matrix",
-	streaming: {
-		defaultMode: "off",
-		resolveMode: (entry) => {
-			const streaming = isRecord(entry.streaming) ? entry.streaming : null;
-			const parsed = parseMatrixStreamingMode(streaming ? streaming.mode : entry.streaming);
-			if (parsed) return parsed;
-			return entry.streaming === true ? "partial" : "off";
-		}
-	},
-	accountStreamingReplacesRoot: true
-});
-const roomAllowMigration = defineKeyMoveMigration({
-	scope: ["*"],
-	from: ["allow"],
-	to: ["enabled"],
-	sourceOwn: false,
-	match: (value) => typeof value === "boolean",
-	targetIsSet: (value) => typeof value === "boolean",
-	movedMessage: ({ sourcePath, targetPath, mappedValue }) => `Moved ${sourcePath} → ${targetPath} (${String(mappedValue)}).`,
-	existingMessage: ({ sourcePath, targetPath, targetValue }) => `Moved ${sourcePath} → ${targetPath} (${String(targetValue)}).`
-});
-function hasLegacyTrustedDmPolicy(value) {
-	const root = isRecord(value) ? value : null;
-	if (!root) return false;
-	return (isRecord(root.dm) ? root.dm : null)?.policy === "trusted";
-}
-function migrateLegacyTrustedDmPolicy(params) {
-	const dm = isRecord(params.entry.dm) ? params.entry.dm : null;
-	if (!dm || dm.policy !== "trusted") return {
-		entry: params.entry,
-		changed: false
-	};
-	const allowFromRaw = dm.allowFrom;
-	const allowFromEntries = Array.isArray(allowFromRaw) ? allowFromRaw.filter((entry) => typeof entry === "string" && entry.trim().length > 0).length : 0;
-	const nextPolicy = allowFromEntries > 0 ? "allowlist" : "pairing";
-	const nextDm = {
-		...dm,
-		policy: nextPolicy
-	};
-	params.changes.push(`Migrated ${params.pathPrefix}.dm.policy "trusted" → "${nextPolicy}" (legacy alias removed; ${allowFromEntries > 0 ? `preserved ${allowFromEntries} ${params.pathPrefix}.dm.allowFrom ${allowFromEntries === 1 ? "entry" : "entries"}` : "no allowFrom entries present, defaulting to pairing for safety"}).`);
-	return {
-		entry: {
-			...params.entry,
-			dm: nextDm
-		},
-		changed: true
-	};
-}
-const legacyConfigRules = [
-	...streamingAliasMigration.legacyConfigRules,
-	{
-		path: ["channels", "matrix"],
-		message: "channels.matrix.allowPrivateNetwork is legacy; use channels.matrix.network.dangerouslyAllowPrivateNetwork instead. Run \"openclaw doctor --fix\".",
-		match: (value) => hasLegacyFlatAllowPrivateNetworkAlias(isRecord(value) ? value : {})
-	},
-	{
-		path: [
-			"channels",
-			"matrix",
-			"accounts"
-		],
-		message: "channels.matrix.accounts.<id>.allowPrivateNetwork is legacy; use channels.matrix.accounts.<id>.network.dangerouslyAllowPrivateNetwork instead. Run \"openclaw doctor --fix\".",
-		match: (value) => hasLegacyAccountStreamingAliases(value, (account) => hasLegacyFlatAllowPrivateNetworkAlias(isRecord(account) ? account : {}))
-	},
-	{
-		path: [
-			"channels",
-			"matrix",
-			"groups"
-		],
-		message: "channels.matrix.groups.<room>.allow is legacy; use channels.matrix.groups.<room>.enabled instead. Run \"openclaw doctor --fix\".",
-		match: roomAllowMigration.hasLegacy
-	},
-	{
-		path: [
-			"channels",
-			"matrix",
-			"rooms"
-		],
-		message: "channels.matrix.rooms.<room>.allow is legacy; use channels.matrix.rooms.<room>.enabled instead. Run \"openclaw doctor --fix\".",
-		match: roomAllowMigration.hasLegacy
-	},
-	{
-		path: [
-			"channels",
-			"matrix",
-			"accounts"
-		],
-		message: "channels.matrix.accounts.<id>.{groups,rooms}.<room>.allow is legacy; use channels.matrix.accounts.<id>.{groups,rooms}.<room>.enabled instead. Run \"openclaw doctor --fix\".",
-		match: (value) => hasLegacyAccountStreamingAliases(value, (account) => {
-			if (!isRecord(account)) return false;
-			return roomAllowMigration.hasLegacy(account.groups) || roomAllowMigration.hasLegacy(account.rooms);
-		})
-	},
-	{
-		path: ["channels", "matrix"],
-		message: "channels.matrix.dm.policy \"trusted\" is legacy; use \"allowlist\" (with allowFrom entries) or \"pairing\" instead. Run \"openclaw doctor --fix\".",
-		match: hasLegacyTrustedDmPolicy
-	},
-	{
-		path: [
-			"channels",
-			"matrix",
-			"accounts"
-		],
-		message: "channels.matrix.accounts.<id>.dm.policy \"trusted\" is legacy; use \"allowlist\" (with allowFrom entries) or \"pairing\" instead. Run \"openclaw doctor --fix\".",
-		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacyTrustedDmPolicy)
-	}
-];
-function normalizeMatrixEntry(params) {
-	const network = migrateLegacyFlatAllowPrivateNetworkAlias(params);
-	const dmPolicy = migrateLegacyTrustedDmPolicy({
-		...params,
-		entry: network.entry
-	});
-	let entry = dmPolicy.entry;
-	let changed = network.changed || dmPolicy.changed;
-	for (const section of ["groups", "rooms"]) {
-		const roomMap = isRecord(entry[section]) ? entry[section] : null;
-		if (!roomMap) continue;
-		const normalized = roomAllowMigration.normalize({
-			entry: roomMap,
-			pathPrefix: `${params.pathPrefix}.${section}`,
-			changes: params.changes
-		});
-		if (normalized.changed) {
-			entry = Object.assign({}, entry, { [section]: normalized.entry });
-			changed = true;
-		}
-	}
-	return {
-		entry,
-		changed
-	};
-}
-function normalizeCompatibilityConfig({ cfg }) {
-	const changes = [];
-	const withoutJunkStreamMode = stripRetiredChannelKeys({
-		cfg,
-		channelId: "matrix",
-		keys: /* @__PURE__ */ new Set(["streamMode"]),
-		scope: "root-and-accounts",
-		onRemove: ({ key, pathPrefix }) => changes.push(`Removed ${pathPrefix}.${key} (never read by the Matrix runtime).`)
-	}).config;
-	const aliases = streamingAliasMigration.normalizeChannelConfig({
-		cfg: withoutJunkStreamMode,
-		changes
-	});
-	return normalizeChannelConfigEntries({
-		cfg: aliases.config,
-		channelId: "matrix",
-		changes,
-		normalizeEntry: normalizeMatrixEntry
-	});
-}
-//#endregion
-export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/.setup/draft-stream-y0Vq5f38.mjs

@@ -1,175 +0,0 @@
-import { _ as MsgType } from "./direct-management-B2Bno2xL.mjs";
-import { a as sendSingleTextMessageMatrix, m as prepareMatrixSingleText, t as editMessageMatrix } from "./send-aVdC5NJO.mjs";
-import { createFinalizableDraftLifecycle } from "openclaw/plugin-sdk/channel-outbound";
-//#region extensions/matrix/src/matrix/draft-stream.ts
-const DEFAULT_THROTTLE_MS = 1e3;
-function resolveDraftPreviewOptions(mode) {
-	if (mode === "quiet") return {
-		msgtype: MsgType.Notice,
-		includeMentions: false
-	};
-	return {
-		msgtype: MsgType.Text,
-		includeMentions: false
-	};
-}
-function createMatrixDraftStream(params) {
-	const { roomId, client, cfg, threadId, accountId, log } = params;
-	const preview = resolveDraftPreviewOptions(params.mode ?? "partial");
-	const useLive = params.mode !== "quiet";
-	let currentEventId;
-	let lastSentText = "";
-	let lastSentContent = "";
-	const streamState = {
-		stopped: false,
-		final: false
-	};
-	let sendFailed = false;
-	let finalizeInPlaceBlocked = false;
-	let liveFinalized = false;
-	let replyToId = params.replyToId;
-	const sendOrEdit = async (text) => {
-		const trimmed = text.trimEnd();
-		if (!trimmed.trim()) return false;
-		const preparedText = prepareMatrixSingleText(trimmed, {
-			cfg,
-			accountId,
-			preserveWhitespace: true
-		});
-		if (!preparedText.fitsInSingleEvent) {
-			finalizeInPlaceBlocked = true;
-			if (!currentEventId) sendFailed = true;
-			streamState.stopped = true;
-			log?.(`draft-stream: preview exceeded single-event limit (${preparedText.convertedText.length} > ${preparedText.singleEventLimit})`);
-			return false;
-		}
-		if (sendFailed) return false;
-		if (preparedText.trimmedText === lastSentText) return true;
-		try {
-			if (!currentEventId) {
-				currentEventId = (await sendSingleTextMessageMatrix(roomId, preparedText.trimmedText, {
-					client,
-					cfg,
-					replyToId,
-					threadId,
-					accountId,
-					msgtype: preview.msgtype,
-					includeMentions: preview.includeMentions,
-					live: useLive
-				})).messageId;
-				lastSentText = preparedText.trimmedText;
-				lastSentContent = preparedText.convertedText;
-				log?.(`draft-stream: created message ${currentEventId}${useLive ? " (MSC4357 live)" : ""}`);
-			} else {
-				await editMessageMatrix(roomId, currentEventId, preparedText.trimmedText, {
-					client,
-					cfg,
-					threadId,
-					accountId,
-					msgtype: preview.msgtype,
-					includeMentions: preview.includeMentions,
-					live: useLive
-				});
-				lastSentText = preparedText.trimmedText;
-				lastSentContent = preparedText.convertedText;
-			}
-			return true;
-		} catch (err) {
-			log?.(`draft-stream: send/edit failed: ${String(err)}`);
-			if (err instanceof Error && err.message.startsWith("Matrix single-message text exceeds limit")) finalizeInPlaceBlocked = true;
-			if (!currentEventId) sendFailed = true;
-			streamState.stopped = true;
-			return false;
-		}
-	};
-	const { loop, update, stop: stopDraft, discardPending, seal, clear, retire, cleanupPending } = createFinalizableDraftLifecycle({
-		throttleMs: DEFAULT_THROTTLE_MS,
-		state: streamState,
-		sendOrEditStreamMessage: sendOrEdit,
-		readMessageId: () => currentEventId,
-		clearMessageId: () => {
-			currentEventId = void 0;
-			lastSentText = "";
-			lastSentContent = "";
-		},
-		isValidMessageId: (id) => typeof id === "string" && id.length > 0,
-		deleteMessage: async (id) => {
-			await client.redactEvent(roomId, id);
-		},
-		warn: log,
-		warnPrefix: "matrix draft preview cleanup failed"
-	});
-	log?.(`draft-stream: ready (throttleMs=${DEFAULT_THROTTLE_MS})`);
-	const finalizeLive = async () => {
-		if (useLive && !liveFinalized && currentEventId && lastSentText) {
-			liveFinalized = true;
-			try {
-				await editMessageMatrix(roomId, currentEventId, lastSentText, {
-					client,
-					cfg,
-					threadId,
-					accountId,
-					msgtype: preview.msgtype,
-					includeMentions: preview.includeMentions,
-					live: false
-				});
-				log?.(`draft-stream: finalized ${currentEventId} (MSC4357 stream ended)`);
-				return true;
-			} catch (err) {
-				log?.(`draft-stream: finalize edit failed: ${String(err)}`);
-				finalizeInPlaceBlocked = true;
-				return false;
-			}
-		}
-		return true;
-	};
-	const stop = async () => {
-		await stopDraft();
-		return currentEventId;
-	};
-	const resetCurrentMessage = () => {
-		currentEventId = void 0;
-		lastSentText = "";
-		lastSentContent = "";
-		sendFailed = false;
-		finalizeInPlaceBlocked = false;
-		liveFinalized = false;
-		loop.resetPending();
-		loop.resetThrottleWindow();
-	};
-	const reset = () => {
-		replyToId = params.preserveReplyId ? params.replyToId : void 0;
-		streamState.stopped = false;
-		streamState.final = false;
-		resetCurrentMessage();
-	};
-	const deleteCurrentMessage = async () => {
-		loop.resetPending();
-		await loop.waitForInFlight();
-		const retiredEventId = currentEventId;
-		resetCurrentMessage();
-		if (retiredEventId) await retire(retiredEventId);
-	};
-	return {
-		update,
-		flush: loop.flush,
-		stop,
-		discardPending,
-		seal,
-		clear,
-		cleanupPending,
-		deleteCurrentMessage,
-		finalizeLive,
-		reset,
-		eventId: () => currentEventId,
-		content: () => lastSentContent || void 0,
-		matchesPreparedText: (text) => prepareMatrixSingleText(text.trimEnd(), {
-			cfg,
-			accountId,
-			preserveWhitespace: true
-		}).trimmedText === lastSentText,
-		mustDeliverFinalNormally: () => sendFailed || finalizeInPlaceBlocked
-	};
-}
-//#endregion
-export { createMatrixDraftStream };

package/dist/.setup/encryption-guidance-CMWXiBzJ.mjs

@@ -1,16 +0,0 @@
-import { s as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-BHkfU1eC.mjs";
-import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
-import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
-//#region extensions/matrix/src/matrix/encryption-guidance.ts
-function resolveMatrixEncryptionConfigPath(cfg, accountId) {
-	const effectiveAccountId = normalizeOptionalAccountId(accountId) ?? resolveMatrixDefaultOrOnlyAccountId(cfg);
-	return resolveMatrixConfigFieldPath(cfg, effectiveAccountId, "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 };