@openclaw/matrix 2026.9.6 → 2026.9.8

package/dist/.setup/crypto-snapshot-doctor.runtime-44FrCPR7.mjs

@@ -0,0 +1,91 @@
+import { b as readMatrixIdbSnapshotJsonFromStore, o as MATRIX_IDB_SNAPSHOT_FILENAME, p as openMatrixIdbSnapshotStoreOptions, w as writeMatrixIdbSnapshotJsonToStore } from "./storage-metadata-BDRZ7vpX.mjs";
+import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-D_mDu4Cf.mjs";
+import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-DBvfre1X.mjs";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import fs from "node:fs";
+import fs$1 from "node:fs/promises";
+import { isDeepStrictEqual } from "node:util";
+import { withFileLock } from "openclaw/plugin-sdk/file-lock";
+//#region extensions/matrix/src/matrix/crypto-snapshot-doctor.runtime.ts
+async function migrateLegacyMatrixIdbSnapshot(params) {
+	const snapshotPath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
+	try {
+		await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, () => migrateLegacyMatrixIdbSnapshotLocked(params));
+	} catch (err) {
+		params.warnings.push(`Failed locking Matrix IndexedDB snapshot for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
+	}
+}
+async function migrateLegacyMatrixIdbSnapshotLocked(params) {
+	const sourcePath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
+	let snapshot;
+	try {
+		snapshot = readLegacyMatrixIdbSnapshotStateUnlocked(params.storageRootDir);
+	} catch (err) {
+		params.warnings.push(`Failed reading Matrix IndexedDB snapshot legacy source for ${params.storageRootDir}: ${String(err)}; left source in place`);
+		return;
+	}
+	if (!snapshot) {
+		if (!fs.existsSync(sourcePath)) return;
+		const archived = await archiveLegacyMatrixIdbSnapshot(params);
+		params.warnings.push(archived ? `Matrix IndexedDB snapshot legacy source is invalid for ${params.storageRootDir}; archived without import` : `Matrix IndexedDB snapshot legacy source is invalid for ${params.storageRootDir}; left active because archival failed`);
+		return;
+	}
+	const snapshotJson = JSON.stringify(snapshot);
+	const store = params.context.openPluginStateKeyedStore(openMatrixIdbSnapshotStoreOptions(params.storageRootDir));
+	let persisted;
+	let hadPartialState;
+	try {
+		persisted = await readMatrixIdbSnapshotJsonFromStore({ store });
+		const persistedIsValid = persisted ? isValidMatrixIdbSnapshotJson(persisted) : false;
+		hadPartialState = !persistedIsValid && (await store.entries()).length > 0;
+		if (!persistedIsValid) persisted = null;
+	} catch (err) {
+		params.warnings.push(`Failed inspecting Matrix IndexedDB snapshot SQLite state for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
+		return;
+	}
+	if (persisted && !snapshotContentMatches(persisted, snapshot)) {
+		if (await archiveLegacyMatrixIdbSnapshot(params)) params.notices.push(`Kept the canonical Matrix IndexedDB snapshot in SQLite and archived a differing legacy source for ${params.storageRootDir}`);
+		return;
+	}
+	if (!persisted) {
+		try {
+			await writeMatrixIdbSnapshotJsonToStore({
+				snapshotJson,
+				databaseCount: snapshot.length,
+				store
+			});
+			persisted = await readMatrixIdbSnapshotJsonFromStore({ store });
+		} catch (err) {
+			params.warnings.push(`Failed importing Matrix IndexedDB snapshot for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
+			return;
+		}
+		if (!persisted || !snapshotContentMatches(persisted, snapshot)) {
+			params.warnings.push(`Failed verifying Matrix IndexedDB snapshot for ${params.storageRootDir}; left legacy source in place`);
+			return;
+		}
+		params.changes.push(hadPartialState ? `Repaired partial or invalid Matrix IndexedDB snapshot SQLite state for ${params.storageRootDir}` : `Migrated Matrix IndexedDB snapshot JSON to SQLite for ${params.storageRootDir}`);
+	}
+	await archiveLegacyMatrixIdbSnapshot(params);
+}
+function snapshotContentMatches(persistedJson, snapshot) {
+	try {
+		return isDeepStrictEqual(JSON.parse(persistedJson), snapshot);
+	} catch {
+		return false;
+	}
+}
+async function archiveLegacyMatrixIdbSnapshot(params) {
+	const sourcePath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
+	const archivePath = `${sourcePath}.migrated-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${randomUUID()}`;
+	try {
+		await fs$1.rename(sourcePath, archivePath);
+		params.changes.push(`Archived Matrix IndexedDB snapshot legacy source -> ${archivePath}`);
+		return true;
+	} catch (err) {
+		params.warnings.push(`Failed archiving Matrix IndexedDB snapshot legacy source: ${String(err)}`);
+		return false;
+	}
+}
+//#endregion
+export { migrateLegacyMatrixIdbSnapshot };

package/dist/.setup/deps-CLQ4EOq7.mjs

@@ -0,0 +1,162 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import fs from "node:fs";
+import { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
+//#region extensions/matrix/src/matrix/deps.ts
+const REQUIRED_MATRIX_PACKAGES = [
+	"matrix-js-sdk",
+	"@matrix-org/matrix-sdk-crypto-nodejs",
+	"@matrix-org/matrix-sdk-crypto-wasm"
+];
+const MIN_MATRIX_CRYPTO_NATIVE_BINDING_BYTES = 1e6;
+const MATRIX_COMMAND_OUTPUT_TAIL_BYTES = 65536;
+function resolveMissingMatrixPackages(resolveFn) {
+	const resolve = resolveFn ?? defaultResolveFn;
+	return REQUIRED_MATRIX_PACKAGES.filter((pkg) => {
+		try {
+			resolve(pkg);
+			return false;
+		} catch {
+			return true;
+		}
+	});
+}
+function isMatrixSdkAvailable() {
+	return resolveMissingMatrixPackages().length === 0;
+}
+let defaultMatrixCryptoRuntimeEnsurePromise = null;
+async function runFixedCommandWithTimeout(params) {
+	if (!params.argv[0]) return {
+		code: 1,
+		stdout: "",
+		stderr: "command is required"
+	};
+	try {
+		const result = await runCommandWithTimeout(params.argv, {
+			cwd: params.cwd,
+			env: params.env,
+			killProcessTree: true,
+			maxOutputBytes: MATRIX_COMMAND_OUTPUT_TAIL_BYTES,
+			outputCapture: "tail",
+			timeoutMs: params.timeoutMs
+		});
+		return {
+			code: result.termination === "timeout" ? 124 : result.code ?? 1,
+			stdout: result.stdout,
+			stderr: result.stderr || (result.termination === "timeout" ? `command timed out after ${params.timeoutMs}ms` : "")
+		};
+	} catch (error) {
+		return {
+			code: 1,
+			stdout: "",
+			stderr: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+const defaultRequireFn = createRequire(import.meta.url);
+const defaultResolveFn = defaultRequireFn.resolve;
+function isMissingMatrixCryptoRuntimeError(error) {
+	const message = formatErrorMessage(error);
+	return message.includes("@matrix-org/matrix-sdk-crypto-nodejs-") || message.includes("matrix-sdk-crypto-nodejs") || message.includes("download-lib.js");
+}
+function isMuslRuntime() {
+	try {
+		return !(process.report?.getReport?.())?.header?.glibcVersionRuntime;
+	} catch {
+		return true;
+	}
+}
+function resolveMatrixCryptoNativeBindingFilename() {
+	switch (process.platform) {
+		case "darwin": return process.arch === "arm64" ? "matrix-sdk-crypto.darwin-arm64.node" : process.arch === "x64" ? "matrix-sdk-crypto.darwin-x64.node" : null;
+		case "linux":
+			if (process.arch === "x64") return isMuslRuntime() ? "matrix-sdk-crypto.linux-x64-musl.node" : "matrix-sdk-crypto.linux-x64-gnu.node";
+			if (process.arch === "arm64" && !isMuslRuntime()) return "matrix-sdk-crypto.linux-arm64-gnu.node";
+			if (process.arch === "arm") return "matrix-sdk-crypto.linux-arm-gnueabihf.node";
+			if (process.arch === "s390x") return "matrix-sdk-crypto.linux-s390x-gnu.node";
+			return null;
+		case "win32": return process.arch === "x64" ? "matrix-sdk-crypto.win32-x64-msvc.node" : process.arch === "ia32" ? "matrix-sdk-crypto.win32-ia32-msvc.node" : process.arch === "arm64" ? "matrix-sdk-crypto.win32-arm64-msvc.node" : null;
+		default: return null;
+	}
+}
+function resolveMatrixCryptoNativeBindingPath(resolveFn) {
+	const filename = resolveMatrixCryptoNativeBindingFilename();
+	if (!filename) return null;
+	try {
+		return path.join(path.dirname(resolveFn("@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js")), filename);
+	} catch {
+		return null;
+	}
+}
+function removeIncompleteMatrixCryptoNativeBinding(params) {
+	const bindingPath = params.bindingPath;
+	if (!bindingPath) return;
+	try {
+		const stat = fs.statSync(bindingPath);
+		if (!stat.isFile() || stat.size >= MIN_MATRIX_CRYPTO_NATIVE_BINDING_BYTES) return;
+		fs.unlinkSync(bindingPath);
+		params.log?.(`matrix: removed incomplete native crypto runtime (${stat.size} bytes); it will be downloaded again`);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+async function ensureMatrixCryptoRuntime(params = {}) {
+	const usesDefaultRuntime = !params.requireFn && !params.resolveFn;
+	if (usesDefaultRuntime && defaultMatrixCryptoRuntimeEnsurePromise) {
+		await defaultMatrixCryptoRuntimeEnsurePromise;
+		return;
+	}
+	const ensurePromise = ensureMatrixCryptoRuntimeOnce(params);
+	if (!usesDefaultRuntime) {
+		await ensurePromise;
+		return;
+	}
+	defaultMatrixCryptoRuntimeEnsurePromise = ensurePromise.catch((error) => {
+		defaultMatrixCryptoRuntimeEnsurePromise = null;
+		throw error;
+	});
+	await defaultMatrixCryptoRuntimeEnsurePromise;
+}
+async function ensureMatrixCryptoRuntimeOnce(params) {
+	const resolveFn = params.resolveFn ?? defaultResolveFn;
+	const nativeBindingPath = resolveMatrixCryptoNativeBindingPath(resolveFn);
+	removeIncompleteMatrixCryptoNativeBinding({
+		bindingPath: nativeBindingPath,
+		log: params.log
+	});
+	const requireFn = params.requireFn ?? defaultRequireFn;
+	try {
+		requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
+		return;
+	} catch (err) {
+		if (!isMissingMatrixCryptoRuntimeError(err)) throw err;
+	}
+	const scriptPath = resolveFn("@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js");
+	params.log?.("matrix: bootstrapping native crypto runtime");
+	const result = await runFixedCommandWithTimeout({
+		argv: [process.execPath, scriptPath],
+		cwd: path.dirname(scriptPath),
+		timeoutMs: 3e5,
+		env: { COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" }
+	});
+	if (result.code !== 0) {
+		removeIncompleteMatrixCryptoNativeBinding({
+			bindingPath: nativeBindingPath,
+			log: params.log
+		});
+		throw new Error(result.stderr.trim() || result.stdout.trim() || "Matrix crypto runtime bootstrap failed.");
+	}
+	removeIncompleteMatrixCryptoNativeBinding({
+		bindingPath: nativeBindingPath,
+		log: params.log
+	});
+	requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
+}
+async function ensureMatrixSdkInstalled(params) {
+	const missing = resolveMissingMatrixPackages(params?.resolveFn);
+	if (missing.length === 0) return;
+	throw new Error(`Matrix plugin dependencies are missing: ${missing.join(", ")}. Repair this plugin with \`openclaw plugins update matrix\` or run \`openclaw doctor --fix\`.`);
+}
+//#endregion
+export { ensureMatrixSdkInstalled as n, isMatrixSdkAvailable as r, ensureMatrixCryptoRuntime as t };

package/dist/.setup/device-health-U-yoVjPw.mjs

@@ -0,0 +1,21 @@
+import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+//#region extensions/matrix/src/matrix/device-health.ts
+var device_health_exports = /* @__PURE__ */ __exportAll({
+	isOpenClawManagedMatrixDevice: () => isOpenClawManagedMatrixDevice,
+	summarizeMatrixDeviceHealth: () => summarizeMatrixDeviceHealth
+});
+const OPENCLAW_DEVICE_NAME_PREFIX = "OpenClaw ";
+function isOpenClawManagedMatrixDevice(displayName) {
+	return displayName?.startsWith(OPENCLAW_DEVICE_NAME_PREFIX) === true;
+}
+function summarizeMatrixDeviceHealth(devices) {
+	const currentDeviceId = devices.find((device) => device.current)?.deviceId ?? null;
+	const openClawDevices = devices.filter((device) => isOpenClawManagedMatrixDevice(device.displayName));
+	return {
+		currentDeviceId,
+		staleOpenClawDevices: openClawDevices.filter((device) => !device.current),
+		currentOpenClawDevices: openClawDevices.filter((device) => device.current)
+	};
+}
+//#endregion
+export { isOpenClawManagedMatrixDevice as n, summarizeMatrixDeviceHealth as r, device_health_exports as t };

package/dist/.setup/direct-management-Cn2t8n1V.mjs

@@ -0,0 +1,300 @@
+import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
+import { a as MATRIX_REACTION_EVENT_TYPE, i as MATRIX_ANNOTATION_RELATION_TYPE } from "./send-currentness-C2rMVVIQ.mjs";
+import { asOptionalRecord, normalizeNullableString, normalizeOptionalString, normalizeTrimmedStringList, normalizeUniqueTrimmedStringList, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+//#region extensions/matrix/src/matrix/send/types.ts
+const MsgType = {
+	Text: "m.text",
+	Image: "m.image",
+	Audio: "m.audio",
+	Video: "m.video",
+	File: "m.file",
+	Notice: "m.notice"
+};
+const RelationType = {
+	Annotation: MATRIX_ANNOTATION_RELATION_TYPE,
+	Replace: "m.replace",
+	Thread: "m.thread"
+};
+const EventType = {
+	Direct: "m.direct",
+	Reaction: MATRIX_REACTION_EVENT_TYPE,
+	RoomMessage: "m.room.message"
+};
+const MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY = "com.openclaw.finalized_preview";
+/**
+* MSC4357 live marker key.
+* When present on event content, signals that the message is still being
+* streamed (e.g. an LLM generating a response). Supporting clients render
+* the message with a streaming animation until an edit without this marker
+* arrives, indicating the stream is complete.
+* @see https://github.com/matrix-org/matrix-spec-proposals/pull/4357
+*/
+const MSC4357_LIVE_KEY = "org.matrix.msc4357.live";
+//#endregion
+//#region extensions/matrix/src/matrix/relations.ts
+function relatedReplyEventId(relation) {
+	const reply = asOptionalRecord(relation?.["m.in_reply_to"]);
+	return typeof reply?.event_id === "string" ? reply.event_id : void 0;
+}
+function buildMatrixMessageRelation(params) {
+	const threadId = params.threadId?.trim();
+	const replyToId = params.replyToId?.trim();
+	const relatedId = replyToId || (threadId ? params.fallbackReplyToId?.trim() : void 0);
+	const reply = relatedId ? { "m.in_reply_to": { event_id: relatedId } } : void 0;
+	if (!threadId) return reply;
+	return {
+		rel_type: RelationType.Thread,
+		event_id: threadId,
+		...reply,
+		...relatedId && !replyToId ? { is_falling_back: true } : {}
+	};
+}
+function resolveMatrixReplyToEventId(content) {
+	const relation = asOptionalRecord(content["m.relates_to"]);
+	return relation?.rel_type === RelationType.Thread && relation.is_falling_back === true ? void 0 : relatedReplyEventId(relation);
+}
+function resolveMatrixThreadRootId(content) {
+	const relation = asOptionalRecord(content["m.relates_to"]);
+	if (relation?.rel_type !== RelationType.Thread) return;
+	return typeof relation.event_id === "string" ? relation.event_id : relatedReplyEventId(relation);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/direct-room.ts
+var direct_room_exports = /* @__PURE__ */ __exportAll({
+	hasDirectMatrixMemberFlag: () => hasDirectMatrixMemberFlag,
+	inspectMatrixDirectRoomEvidence: () => inspectMatrixDirectRoomEvidence,
+	isStrictDirectMembership: () => isStrictDirectMembership,
+	isStrictDirectRoom: () => isStrictDirectRoom,
+	readJoinedMatrixMembers: () => readJoinedMatrixMembers
+});
+function isStrictDirectMembership(params) {
+	const selfUserId = normalizeNullableString(params.selfUserId);
+	const remoteUserId = normalizeNullableString(params.remoteUserId);
+	const joinedMembers = params.joinedMembers ?? [];
+	return Boolean(selfUserId && remoteUserId && joinedMembers.length === 2 && joinedMembers.includes(selfUserId) && joinedMembers.includes(remoteUserId));
+}
+async function readJoinedMatrixMembers(client, roomId) {
+	try {
+		return normalizeTrimmedStringList(await client.getJoinedRoomMembers(roomId));
+	} catch {
+		return null;
+	}
+}
+async function hasDirectMatrixMemberFlag(client, roomId, userId) {
+	const normalizedUserId = normalizeNullableString(userId);
+	if (!normalizedUserId) return null;
+	try {
+		const state = await client.getRoomStateEvent(roomId, "m.room.member", normalizedUserId);
+		return typeof state?.is_direct === "boolean" ? state.is_direct : null;
+	} catch {
+		return null;
+	}
+}
+async function inspectMatrixDirectRoomEvidence(params) {
+	const selfUserId = params.selfUserId !== void 0 ? normalizeNullableString(params.selfUserId) : normalizeNullableString(await params.client.getUserId().catch(() => null));
+	const joinedMembers = await readJoinedMatrixMembers(params.client, params.roomId);
+	const strict = isStrictDirectMembership({
+		selfUserId,
+		remoteUserId: params.remoteUserId,
+		joinedMembers
+	});
+	if (!strict) return {
+		joinedMembers,
+		strict: false,
+		viaMemberState: false,
+		memberStateFlag: null
+	};
+	const memberStateFlag = await hasDirectMatrixMemberFlag(params.client, params.roomId, selfUserId);
+	return {
+		joinedMembers,
+		strict,
+		viaMemberState: memberStateFlag === true,
+		memberStateFlag
+	};
+}
+async function isStrictDirectRoom(params) {
+	return (await inspectMatrixDirectRoomEvidence(params)).strict;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/direct-management.ts
+var direct_management_exports = /* @__PURE__ */ __exportAll({
+	inspectMatrixDirectRooms: () => inspectMatrixDirectRooms,
+	persistMatrixDirectRoomMapping: () => persistMatrixDirectRoomMapping,
+	promoteMatrixDirectRoomCandidate: () => promoteMatrixDirectRoomCandidate,
+	repairMatrixDirectRooms: () => repairMatrixDirectRooms
+});
+const DIRECT_ACCOUNT_DATA_QUEUE_KEY = EventType.Direct;
+const directAccountDataWriteQueues = /* @__PURE__ */ new WeakMap();
+async function readMatrixDirectAccountData(client) {
+	try {
+		const direct = await client.getAccountData(EventType.Direct);
+		return direct && typeof direct === "object" && !Array.isArray(direct) ? direct : {};
+	} catch {
+		return {};
+	}
+}
+function normalizeRemoteUserId(remoteUserId) {
+	const normalized = normalizeOptionalString(remoteUserId) ?? "";
+	if (!isMatrixQualifiedUserId(normalized)) throw new Error(`Matrix user IDs must be fully qualified (got "${remoteUserId}")`);
+	return normalized;
+}
+function normalizeRoomIdList(values) {
+	return uniqueStrings(Array.from(values, (value) => value.trim()).filter(Boolean));
+}
+function resolveDirectAccountDataWriteQueue(client) {
+	const existing = directAccountDataWriteQueues.get(client);
+	if (existing) return existing;
+	const created = new KeyedAsyncQueue();
+	directAccountDataWriteQueues.set(client, created);
+	return created;
+}
+async function writeMatrixDirectRoomMappings(params) {
+	return await resolveDirectAccountDataWriteQueue(params.client).enqueue(DIRECT_ACCOUNT_DATA_QUEUE_KEY, async () => {
+		const directContentBefore = await readMatrixDirectAccountData(params.client);
+		const current = normalizeUniqueTrimmedStringList(directContentBefore[params.remoteUserId]);
+		const next = normalizeRoomIdList([...params.roomIds, ...current]);
+		const directContentAfter = {
+			...directContentBefore,
+			[params.remoteUserId]: next
+		};
+		const changed = current.length !== next.length || current.some((roomId, index) => roomId !== next[index]);
+		if (changed) await params.client.setAccountData(EventType.Direct, directContentAfter);
+		return {
+			changed,
+			directContentBefore,
+			directContentAfter
+		};
+	});
+}
+async function classifyDirectRoomCandidate(params) {
+	const evidence = await inspectMatrixDirectRoomEvidence({
+		client: params.client,
+		roomId: params.roomId,
+		remoteUserId: params.remoteUserId,
+		selfUserId: params.selfUserId
+	});
+	const strict = evidence.strict && (params.source === "account-data" || evidence.memberStateFlag !== false);
+	return {
+		roomId: params.roomId,
+		joinedMembers: evidence.joinedMembers,
+		strict,
+		explicit: strict && (params.source === "account-data" || evidence.viaMemberState),
+		source: params.source
+	};
+}
+async function persistMatrixDirectRoomMapping(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	return (await writeMatrixDirectRoomMappings({
+		client: params.client,
+		remoteUserId,
+		roomIds: [params.roomId]
+	})).changed;
+}
+async function promoteMatrixDirectRoomCandidate(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	const evidence = await inspectMatrixDirectRoomEvidence({
+		client: params.client,
+		roomId: params.roomId,
+		remoteUserId,
+		selfUserId: params.selfUserId
+	});
+	if (!evidence.strict) return {
+		classifyAsDirect: false,
+		repaired: false,
+		reason: "not-strict"
+	};
+	if (evidence.memberStateFlag === false) return {
+		classifyAsDirect: false,
+		repaired: false,
+		reason: "local-explicit-false"
+	};
+	try {
+		const repaired = await persistMatrixDirectRoomMapping({
+			client: params.client,
+			remoteUserId,
+			roomId: params.roomId
+		});
+		return {
+			classifyAsDirect: true,
+			repaired,
+			roomId: params.roomId,
+			reason: repaired ? "promoted" : "already-mapped"
+		};
+	} catch {
+		return {
+			classifyAsDirect: true,
+			repaired: false,
+			roomId: params.roomId,
+			reason: "repair-failed"
+		};
+	}
+}
+async function inspectMatrixDirectRooms(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	const selfUserId = normalizeOptionalString(await params.client.getUserId().catch(() => null)) ?? null;
+	const directContent = await readMatrixDirectAccountData(params.client);
+	const mappedRoomIds = normalizeUniqueTrimmedStringList(directContent[remoteUserId]);
+	const mappedRooms = await Promise.all(mappedRoomIds.map(async (roomId) => await classifyDirectRoomCandidate({
+		client: params.client,
+		roomId,
+		remoteUserId,
+		selfUserId,
+		source: "account-data"
+	})));
+	const mappedStrict = mappedRooms.find((room) => room.strict);
+	let joinedRooms = [];
+	if (typeof params.client.getJoinedRooms === "function") try {
+		const resolved = await params.client.getJoinedRooms();
+		joinedRooms = Array.isArray(resolved) ? resolved : [];
+	} catch {
+		joinedRooms = [];
+	}
+	const discoveredStrictRooms = [];
+	for (const roomId of normalizeRoomIdList(joinedRooms)) {
+		if (mappedRoomIds.includes(roomId)) continue;
+		const candidate = await classifyDirectRoomCandidate({
+			client: params.client,
+			roomId,
+			remoteUserId,
+			selfUserId,
+			source: "joined"
+		});
+		if (candidate.strict) discoveredStrictRooms.push(candidate);
+	}
+	const discoveredStrictRoomIds = discoveredStrictRooms.map((room) => room.roomId);
+	const discoveredExplicit = discoveredStrictRooms.find((room) => room.explicit);
+	return {
+		selfUserId,
+		remoteUserId,
+		mappedRoomIds,
+		mappedRooms,
+		discoveredStrictRoomIds,
+		activeRoomId: mappedStrict?.roomId ?? discoveredExplicit?.roomId ?? discoveredStrictRoomIds[0] ?? null
+	};
+}
+async function repairMatrixDirectRooms(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	const inspected = await inspectMatrixDirectRooms({
+		client: params.client,
+		remoteUserId
+	});
+	const activeRoomId = inspected.activeRoomId ?? await params.client.createDirectRoom(remoteUserId, { encrypted: params.encrypted === true });
+	const createdRoomId = inspected.activeRoomId ? null : activeRoomId;
+	const mappingWrite = await writeMatrixDirectRoomMappings({
+		client: params.client,
+		remoteUserId,
+		roomIds: [activeRoomId, ...inspected.discoveredStrictRoomIds]
+	});
+	return {
+		...inspected,
+		activeRoomId,
+		createdRoomId,
+		changed: mappingWrite.changed,
+		directContentBefore: mappingWrite.directContentBefore,
+		directContentAfter: mappingWrite.directContentAfter
+	};
+}
+//#endregion
+export { MsgType as _, repairMatrixDirectRooms as a, isStrictDirectMembership as c, buildMatrixMessageRelation as d, resolveMatrixReplyToEventId as f, MSC4357_LIVE_KEY as g, MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY as h, promoteMatrixDirectRoomCandidate as i, isStrictDirectRoom as l, EventType as m, inspectMatrixDirectRooms as n, direct_room_exports as o, resolveMatrixThreadRootId as p, persistMatrixDirectRoomMapping as r, hasDirectMatrixMemberFlag as s, direct_management_exports as t, readJoinedMatrixMembers as u, RelationType as v };

package/dist/.setup/directory-live-_sw-Q7KO.mjs

@@ -0,0 +1,118 @@
+import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { r as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
+import { u as resolveMatrixAuth } from "./client-Ccv77kwh.mjs";
+import { t as MatrixAuthedHttpClient } from "./http-client-C1XvVD3K.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;
+}
+async function createMatrixDirectoryClient(params) {
+	const auth = await resolveMatrixAuth({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return new MatrixAuthedHttpClient({
+		homeserver: auth.homeserver,
+		accessToken: auth.accessToken,
+		ssrfPolicy: auth.ssrfPolicy,
+		dispatcherPolicy: auth.dispatcherPolicy
+	});
+}
+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
+	}];
+	return ((await requestMatrixJson(await createMatrixDirectoryClient(params), {
+		method: "POST",
+		endpoint: "/_matrix/client/v3/user_directory/search",
+		body: {
+			search_term: 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 readOptionalMatrixDirectoryString(client, endpoint, field) {
+	try {
+		const res = await requestMatrixJson(client, {
+			method: "GET",
+			endpoint
+		});
+		return normalizeOptionalString(res[field]) ?? null;
+	} catch {
+		return null;
+	}
+}
+async function listMatrixDirectoryGroupsLive(params) {
+	const query = normalizeOptionalString(params.query) ?? "";
+	if (!query) return [];
+	const directTarget = normalizeMatrixMessagingTarget(query);
+	if (directTarget?.startsWith("!")) return [{
+		kind: "group",
+		id: directTarget,
+		name: directTarget,
+		handle: void 0
+	}];
+	const client = await createMatrixDirectoryClient(params);
+	const queryLower = normalizeLowercaseStringOrEmpty(query);
+	const limit = resolveMatrixDirectoryLimit(params.limit);
+	if (directTarget?.startsWith("#")) {
+		const roomId = await readOptionalMatrixDirectoryString(client, `/_matrix/client/v3/directory/room/${encodeURIComponent(directTarget)}`, "room_id");
+		if (!roomId) return [];
+		return [{
+			kind: "group",
+			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 readOptionalMatrixDirectoryString(client, `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state/m.room.name`, "name");
+		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 };