@openclaw/matrix 2026.3.13 → 2026.5.9-beta.1

package/dist/config-schema-nPLpEgHl.js

@@ -0,0 +1,200 @@
+import { a as resolveMatrixAccountConfig } from "./account-config-D2W-V1eQ.js";
+import { i as resolveMatrixAccount, r as resolveDefaultMatrixAccountId, t as listMatrixAccountIds } from "./accounts-Bm90Rzvp.js";
+import { t as normalizeMatrixAllowList } from "./allowlist-sTzpCn5d.js";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/account-id";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
+import { AllowFromListSchema, ContextVisibilityModeSchema, GroupPolicySchema, MarkdownConfigSchema, ToolPolicySchema, buildNestedDmConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { buildSecretInputSchema } from "openclaw/plugin-sdk/secret-input";
+import { z } from "openclaw/plugin-sdk/zod";
+//#region extensions/matrix/src/config-adapter.ts
+const matrixConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: "matrix",
+	listAccountIds: listMatrixAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveMatrixAccount),
+	resolveAccessorAccount: ({ cfg, accountId }) => resolveMatrixAccountConfig({
+		cfg,
+		accountId
+	}),
+	defaultAccountId: resolveDefaultMatrixAccountId,
+	clearBaseFields: [
+		"name",
+		"homeserver",
+		"network",
+		"proxy",
+		"userId",
+		"accessToken",
+		"password",
+		"deviceId",
+		"deviceName",
+		"avatarUrl",
+		"initialSyncLimit"
+	],
+	resolveAllowFrom: (account) => account.dm?.allowFrom,
+	formatAllowFrom: (allowFrom) => normalizeMatrixAllowList(allowFrom)
+});
+//#endregion
+//#region extensions/matrix/src/config-ui-hints.ts
+const matrixChannelConfigUiHints = {
+	"streaming.progress.label": {
+		label: "Matrix Progress Label",
+		help: "Initial progress draft title. Use \"auto\" for built-in single-word labels, a custom string, or false to hide the title."
+	},
+	"streaming.progress.labels": {
+		label: "Matrix Progress Label Pool",
+		help: "Candidate labels for streaming.progress.label=\"auto\". Leave unset to use OpenClaw built-in progress labels."
+	},
+	"streaming.progress.maxLines": {
+		label: "Matrix Progress Max Lines",
+		help: "Maximum number of compact progress lines to keep below the draft label (default: 8)."
+	},
+	"streaming.progress.toolProgress": {
+		label: "Matrix Progress Tool Lines",
+		help: "Show compact tool/progress lines in progress draft mode (default: true). Set false to keep only the label until final delivery."
+	},
+	"streaming.progress.commandText": {
+		label: "Matrix Progress Command Text",
+		help: "Command/exec detail in progress draft lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
+	}
+};
+//#endregion
+//#region extensions/matrix/src/config-schema.ts
+const matrixActionSchema = z.object({
+	reactions: z.boolean().optional(),
+	messages: z.boolean().optional(),
+	pins: z.boolean().optional(),
+	profile: z.boolean().optional(),
+	memberInfo: z.boolean().optional(),
+	channelInfo: z.boolean().optional(),
+	verification: z.boolean().optional()
+}).optional();
+const matrixThreadBindingsSchema = z.object({
+	enabled: z.boolean().optional(),
+	idleHours: z.number().nonnegative().optional(),
+	maxAgeHours: z.number().nonnegative().optional(),
+	spawnSessions: z.boolean().optional(),
+	defaultSpawnContext: z.enum(["isolated", "fork"]).optional(),
+	spawnSubagentSessions: z.boolean().optional(),
+	spawnAcpSessions: z.boolean().optional()
+}).optional();
+const matrixExecApprovalsSchema = z.object({
+	enabled: z.boolean().optional(),
+	approvers: AllowFromListSchema,
+	agentFilter: z.array(z.string()).optional(),
+	sessionFilter: z.array(z.string()).optional(),
+	target: z.enum([
+		"dm",
+		"channel",
+		"both"
+	]).optional()
+}).optional();
+const matrixRoomSchema = z.object({
+	account: z.string().optional(),
+	enabled: z.boolean().optional(),
+	requireMention: z.boolean().optional(),
+	allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
+	tools: ToolPolicySchema,
+	autoReply: z.boolean().optional(),
+	users: AllowFromListSchema,
+	skills: z.array(z.string()).optional(),
+	systemPrompt: z.string().optional()
+}).optional();
+const matrixNetworkSchema = z.object({ dangerouslyAllowPrivateNetwork: z.boolean().optional() }).strict().optional();
+const matrixStreamingSchema = z.object({
+	mode: z.enum([
+		"partial",
+		"quiet",
+		"progress",
+		"off"
+	]).optional(),
+	progress: z.object({
+		label: z.union([z.string(), z.literal(false)]).optional(),
+		labels: z.array(z.string()).optional(),
+		maxLines: z.number().int().positive().optional(),
+		toolProgress: z.boolean().optional()
+	}).strict().optional(),
+	preview: z.object({ toolProgress: z.boolean().optional() }).strict().optional()
+}).strict();
+const MatrixChannelConfigSchema = buildChannelConfigSchema(z.object({
+	name: z.string().optional(),
+	enabled: z.boolean().optional(),
+	defaultAccount: z.string().optional(),
+	accounts: z.record(z.string(), z.unknown()).optional(),
+	markdown: MarkdownConfigSchema,
+	homeserver: z.string().optional(),
+	network: matrixNetworkSchema,
+	proxy: z.string().optional(),
+	userId: z.string().optional(),
+	accessToken: buildSecretInputSchema().optional(),
+	password: buildSecretInputSchema().optional(),
+	deviceId: z.string().optional(),
+	deviceName: z.string().optional(),
+	avatarUrl: z.string().optional(),
+	initialSyncLimit: z.number().optional(),
+	encryption: z.boolean().optional(),
+	allowlistOnly: z.boolean().optional(),
+	allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
+	groupPolicy: GroupPolicySchema.optional(),
+	contextVisibility: ContextVisibilityModeSchema.optional(),
+	blockStreaming: z.boolean().optional(),
+	streaming: z.union([
+		z.enum([
+			"partial",
+			"quiet",
+			"progress",
+			"off"
+		]),
+		z.boolean(),
+		matrixStreamingSchema
+	]).optional(),
+	replyToMode: z.enum([
+		"off",
+		"first",
+		"all",
+		"batched"
+	]).optional(),
+	threadReplies: z.enum([
+		"off",
+		"inbound",
+		"always"
+	]).optional(),
+	textChunkLimit: z.number().optional(),
+	chunkMode: z.enum(["length", "newline"]).optional(),
+	responsePrefix: z.string().optional(),
+	ackReaction: z.string().optional(),
+	ackReactionScope: z.enum([
+		"group-mentions",
+		"group-all",
+		"direct",
+		"all",
+		"none",
+		"off"
+	]).optional(),
+	reactionNotifications: z.enum(["off", "own"]).optional(),
+	threadBindings: matrixThreadBindingsSchema,
+	startupVerification: z.enum(["off", "if-unverified"]).optional(),
+	startupVerificationCooldownHours: z.number().optional(),
+	mediaMaxMb: z.number().optional(),
+	historyLimit: z.number().int().min(0).optional(),
+	autoJoin: z.enum([
+		"always",
+		"allowlist",
+		"off"
+	]).optional(),
+	autoJoinAllowlist: AllowFromListSchema,
+	groupAllowFrom: AllowFromListSchema,
+	dm: buildNestedDmConfigSchema({
+		sessionScope: z.enum(["per-user", "per-room"]).optional(),
+		threadReplies: z.enum([
+			"off",
+			"inbound",
+			"always"
+		]).optional()
+	}),
+	execApprovals: matrixExecApprovalsSchema,
+	groups: z.object({}).catchall(matrixRoomSchema).optional(),
+	rooms: z.object({}).catchall(matrixRoomSchema).optional(),
+	actions: matrixActionSchema
+}), { uiHints: matrixChannelConfigUiHints });
+//#endregion
+export { DEFAULT_ACCOUNT_ID$1 as n, matrixConfigAdapter as r, MatrixChannelConfigSchema as t };

package/dist/config-secret-input.runtime-DiKFehsE.js

@@ -0,0 +1,2 @@
+import { resolveConfiguredSecretInputString } from "openclaw/plugin-sdk/secret-input-runtime";
+export { resolveConfiguredSecretInputString };

package/dist/config-update-wZX-HLMn.js

@@ -0,0 +1,143 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { t as findMatrixAccountConfig } from "./account-config-D2W-V1eQ.js";
+import { n as resolveMatrixConfigPath$1, r as shouldStoreMatrixAccountAtTopLevel, t as resolveMatrixConfigFieldPath } from "./config-paths-nsVaysCu.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { normalizeSecretInputString } from "openclaw/plugin-sdk/setup";
+import { coerceSecretRef } from "openclaw/plugin-sdk/secret-ref-runtime";
+//#region extensions/matrix/src/matrix/config-update.ts
+var config_update_exports = /* @__PURE__ */ __exportAll({
+	resolveMatrixConfigFieldPath: () => resolveMatrixConfigFieldPath,
+	resolveMatrixConfigPath: () => resolveMatrixConfigPath,
+	shouldStoreMatrixAccountAtTopLevel: () => shouldStoreMatrixAccountAtTopLevel,
+	updateMatrixAccountConfig: () => updateMatrixAccountConfig
+});
+const resolveMatrixConfigPath = resolveMatrixConfigPath$1;
+function applyNullableStringField(target, key, value) {
+	if (value === void 0) return;
+	if (value === null) {
+		delete target[key];
+		return;
+	}
+	const trimmed = value.trim();
+	if (!trimmed) {
+		delete target[key];
+		return;
+	}
+	target[key] = trimmed;
+}
+function applyNullableSecretInputField(target, key, value, defaults) {
+	if (value === void 0) return;
+	if (value === null) {
+		delete target[key];
+		return;
+	}
+	if (typeof value === "string") {
+		const normalized = normalizeSecretInputString(value);
+		if (normalized) target[key] = normalized;
+		else delete target[key];
+		return;
+	}
+	const ref = coerceSecretRef(value, defaults);
+	if (!ref) throw new Error(`Invalid Matrix ${key} SecretInput.`);
+	target[key] = ref;
+}
+function cloneMatrixDmConfig(dm) {
+	if (!dm) return dm;
+	return {
+		...dm,
+		...dm.allowFrom ? { allowFrom: [...dm.allowFrom] } : {}
+	};
+}
+function cloneMatrixRoomMap(rooms) {
+	if (!rooms) return rooms;
+	return Object.fromEntries(Object.entries(rooms).map(([roomId, roomCfg]) => [roomId, roomCfg ? { ...roomCfg } : roomCfg]));
+}
+function applyNullableArrayField(target, key, value) {
+	if (value === void 0) return;
+	if (value === null) {
+		delete target[key];
+		return;
+	}
+	target[key] = [...value];
+}
+function updateMatrixAccountConfig(cfg, accountId, patch) {
+	const matrix = cfg.channels?.matrix ?? {};
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const nextAccount = { ...findMatrixAccountConfig(cfg, normalizedAccountId) ?? (normalizedAccountId === DEFAULT_ACCOUNT_ID ? matrix : {}) };
+	if (patch.name !== void 0) if (patch.name === null) delete nextAccount.name;
+	else {
+		const trimmed = patch.name.trim();
+		if (trimmed) nextAccount.name = trimmed;
+		else delete nextAccount.name;
+	}
+	if (typeof patch.enabled === "boolean") nextAccount.enabled = patch.enabled;
+	else if (typeof nextAccount.enabled !== "boolean") nextAccount.enabled = true;
+	applyNullableStringField(nextAccount, "homeserver", patch.homeserver);
+	applyNullableStringField(nextAccount, "proxy", patch.proxy);
+	applyNullableStringField(nextAccount, "userId", patch.userId);
+	applyNullableSecretInputField(nextAccount, "accessToken", patch.accessToken, cfg.secrets?.defaults);
+	applyNullableSecretInputField(nextAccount, "password", patch.password, cfg.secrets?.defaults);
+	applyNullableStringField(nextAccount, "deviceId", patch.deviceId);
+	applyNullableStringField(nextAccount, "deviceName", patch.deviceName);
+	applyNullableStringField(nextAccount, "avatarUrl", patch.avatarUrl);
+	if (patch.allowPrivateNetwork !== void 0) {
+		const nextNetwork = nextAccount.network && typeof nextAccount.network === "object" ? { ...nextAccount.network } : {};
+		if (patch.allowPrivateNetwork === null) delete nextNetwork.dangerouslyAllowPrivateNetwork;
+		else nextNetwork.dangerouslyAllowPrivateNetwork = patch.allowPrivateNetwork;
+		if (Object.keys(nextNetwork).length > 0) nextAccount.network = nextNetwork;
+		else delete nextAccount.network;
+	}
+	if (patch.initialSyncLimit !== void 0) if (patch.initialSyncLimit === null) delete nextAccount.initialSyncLimit;
+	else nextAccount.initialSyncLimit = Math.max(0, Math.floor(patch.initialSyncLimit));
+	if (patch.encryption !== void 0) if (patch.encryption === null) delete nextAccount.encryption;
+	else nextAccount.encryption = patch.encryption;
+	if (patch.allowBots !== void 0) if (patch.allowBots === null) delete nextAccount.allowBots;
+	else nextAccount.allowBots = patch.allowBots;
+	if (patch.autoJoin !== void 0) if (patch.autoJoin === null) delete nextAccount.autoJoin;
+	else nextAccount.autoJoin = patch.autoJoin;
+	applyNullableArrayField(nextAccount, "autoJoinAllowlist", patch.autoJoinAllowlist);
+	if (patch.dm !== void 0) if (patch.dm === null) delete nextAccount.dm;
+	else nextAccount.dm = cloneMatrixDmConfig({
+		...nextAccount.dm,
+		...patch.dm
+	});
+	if (patch.groupPolicy !== void 0) if (patch.groupPolicy === null) delete nextAccount.groupPolicy;
+	else nextAccount.groupPolicy = patch.groupPolicy;
+	applyNullableArrayField(nextAccount, "groupAllowFrom", patch.groupAllowFrom);
+	if (patch.groups !== void 0) if (patch.groups === null) delete nextAccount.groups;
+	else nextAccount.groups = cloneMatrixRoomMap(patch.groups);
+	if (patch.rooms !== void 0) if (patch.rooms === null) delete nextAccount.rooms;
+	else nextAccount.rooms = cloneMatrixRoomMap(patch.rooms);
+	const nextAccounts = Object.fromEntries(Object.entries(matrix.accounts ?? {}).filter(([rawAccountId]) => rawAccountId === normalizedAccountId || normalizeAccountId(rawAccountId) !== normalizedAccountId));
+	if (shouldStoreMatrixAccountAtTopLevel(cfg, normalizedAccountId)) {
+		const { accounts: _ignoredAccounts, defaultAccount } = matrix;
+		const { accounts: _ignoredNextAccounts, defaultAccount: _ignoredNextDefaultAccount, ...topLevelAccount } = nextAccount;
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				matrix: {
+					...defaultAccount ? { defaultAccount } : {},
+					enabled: true,
+					...topLevelAccount
+				}
+			}
+		};
+	}
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			matrix: {
+				...matrix,
+				enabled: true,
+				accounts: {
+					...nextAccounts,
+					[normalizedAccountId]: nextAccount
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { resolveMatrixConfigPath as n, updateMatrixAccountConfig as r, config_update_exports as t };

package/dist/contract-api.js

@@ -0,0 +1,9 @@
+import { s as resetMatrixThreadBindingsForTests } from "./thread-bindings-shared-DK-d-oYX.js";
+import { r as setMatrixRuntime } from "./runtime-Dog86njy.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-D4-64QuJ.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-DcrJWCQI.js";
+import { a as namedAccountPromotionKeys, o as resolveSingleAccountPromotionTarget, s as singleAccountKeysToMove } from "./setup-dm-policy-2-r1FrQh.js";
+import { n as matrixSetupAdapter } from "./setup-core-CfZy05oW.js";
+import { n as matrixOnboardingAdapter } from "./setup-surface-CqT_o61M.js";
+import { t as createMatrixThreadBindingManager } from "./thread-bindings-B9mesxXk.js";
+export { collectRuntimeConfigAssignments, createMatrixThreadBindingManager, legacyConfigRules, matrixSetupAdapter, matrixOnboardingAdapter as matrixSetupWizard, namedAccountPromotionKeys, normalizeCompatibilityConfig, resetMatrixThreadBindingsForTests, resolveSingleAccountPromotionTarget, secretTargetRegistryEntries, setMatrixRuntime, singleAccountKeysToMove };

package/dist/create-client-DCnqDaqd.js

@@ -0,0 +1,64 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-DiK9j7jz.js";
+import { a as resolveMatrixStoragePaths, n as maybeMigrateLegacyStorage, o as writeStorageMeta } from "./storage-tC3ujLiW.js";
+import "./config--5-S2Akv.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import fs from "node:fs";
+import { ssrfPolicyFromDangerouslyAllowPrivateNetwork } from "openclaw/plugin-sdk/ssrf-runtime";
+//#region extensions/matrix/src/matrix/client/create-client.ts
+var create_client_exports = /* @__PURE__ */ __exportAll({ createMatrixClient: () => createMatrixClient });
+let matrixCreateClientRuntimeDepsPromise;
+async function loadMatrixCreateClientRuntimeDeps() {
+	matrixCreateClientRuntimeDepsPromise ??= Promise.all([import("./sdk-B2vZA27-.js").then((n) => n.n), import("./logging-DZHSPP5N.js").then((n) => n.n)]).then(([sdkModule, loggingModule]) => ({
+		MatrixClient: sdkModule.MatrixClient,
+		ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
+	}));
+	return await matrixCreateClientRuntimeDepsPromise;
+}
+async function createMatrixClient(params) {
+	const { MatrixClient, ensureMatrixSdkLoggingConfigured } = await loadMatrixCreateClientRuntimeDeps();
+	ensureMatrixSdkLoggingConfigured();
+	const homeserver = await resolveValidatedMatrixHomeserverUrl(params.homeserver, { dangerouslyAllowPrivateNetwork: params.allowPrivateNetwork });
+	const matrixClientUserId = normalizeOptionalString(params.userId);
+	const userId = matrixClientUserId ?? "unknown";
+	const storagePaths = params.persistStorage !== false ? resolveMatrixStoragePaths({
+		homeserver,
+		userId,
+		accessToken: params.accessToken,
+		accountId: params.accountId,
+		deviceId: params.deviceId,
+		env: process.env
+	}) : null;
+	if (storagePaths) {
+		await maybeMigrateLegacyStorage({
+			storagePaths,
+			env: process.env
+		});
+		fs.mkdirSync(storagePaths.rootDir, { recursive: true });
+		writeStorageMeta({
+			storagePaths,
+			homeserver,
+			userId,
+			accountId: params.accountId,
+			deviceId: params.deviceId
+		});
+	}
+	const cryptoDatabasePrefix = storagePaths ? `openclaw-matrix-${storagePaths.accountKey}-${storagePaths.tokenHash}` : void 0;
+	return new MatrixClient(homeserver, params.accessToken, {
+		userId: matrixClientUserId,
+		password: params.password,
+		deviceId: params.deviceId,
+		encryption: params.encryption,
+		localTimeoutMs: params.localTimeoutMs,
+		initialSyncLimit: params.initialSyncLimit,
+		storagePath: storagePaths?.storagePath,
+		recoveryKeyPath: storagePaths?.recoveryKeyPath,
+		idbSnapshotPath: storagePaths?.idbSnapshotPath,
+		cryptoDatabasePrefix,
+		autoBootstrapCrypto: params.autoBootstrapCrypto,
+		ssrfPolicy: params.ssrfPolicy ?? ssrfPolicyFromDangerouslyAllowPrivateNetwork(params.allowPrivateNetwork),
+		dispatcherPolicy: params.dispatcherPolicy
+	});
+}
+//#endregion
+export { create_client_exports as n, createMatrixClient as t };

package/dist/credentials-DV6fWXhC.js

@@ -0,0 +1,56 @@
+import { a as resolveMatrixCredentialsDir, i as loadMatrixCredentials, n as credentialsMatchConfig, o as resolveMatrixCredentialsPath, t as clearMatrixCredentials } from "./credentials-read-cmHgousK.js";
+import { t as createAsyncLock } from "./async-lock-uQfhfQIY.js";
+import { writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
+//#region extensions/matrix/src/matrix/credentials.ts
+const credentialWriteLocks = /* @__PURE__ */ new Map();
+function withCredentialWriteLock(credPath, fn) {
+	let withLock = credentialWriteLocks.get(credPath);
+	if (!withLock) {
+		withLock = createAsyncLock();
+		credentialWriteLocks.set(credPath, withLock);
+	}
+	return withLock(fn);
+}
+async function writeMatrixCredentialsUnlocked(params) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const toSave = {
+		...params.credentials,
+		createdAt: params.existing?.createdAt ?? now,
+		lastUsedAt: now
+	};
+	await writeJsonFileAtomically(params.credPath, toSave);
+}
+async function saveMatrixCredentials(credentials, env = process.env, accountId) {
+	const credPath = resolveMatrixCredentialsPath(env, accountId);
+	await withCredentialWriteLock(credPath, async () => {
+		await writeMatrixCredentialsUnlocked({
+			credPath,
+			credentials,
+			existing: loadMatrixCredentials(env, accountId)
+		});
+	});
+}
+async function saveBackfilledMatrixDeviceId(credentials, env = process.env, accountId) {
+	const credPath = resolveMatrixCredentialsPath(env, accountId);
+	return await withCredentialWriteLock(credPath, async () => {
+		const existing = loadMatrixCredentials(env, accountId);
+		if (existing && (existing.homeserver !== credentials.homeserver || existing.userId !== credentials.userId || existing.accessToken !== credentials.accessToken)) return "skipped";
+		await writeMatrixCredentialsUnlocked({
+			credPath,
+			credentials,
+			existing
+		});
+		return "saved";
+	});
+}
+async function touchMatrixCredentials(env = process.env, accountId) {
+	const credPath = resolveMatrixCredentialsPath(env, accountId);
+	await withCredentialWriteLock(credPath, async () => {
+		const existing = loadMatrixCredentials(env, accountId);
+		if (!existing) return;
+		existing.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await writeJsonFileAtomically(credPath, existing);
+	});
+}
+//#endregion
+export { clearMatrixCredentials, credentialsMatchConfig, loadMatrixCredentials, resolveMatrixCredentialsDir, resolveMatrixCredentialsPath, saveBackfilledMatrixDeviceId, saveMatrixCredentials, touchMatrixCredentials };

package/dist/credentials-read-cmHgousK.js

@@ -0,0 +1,112 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-BWwIruri.js";
+import { t as getMatrixRuntime } from "./runtime-Dog86njy.js";
+import { a as resolveMatrixCredentialsPath$1, r as resolveMatrixCredentialsDir$1 } from "./storage-paths-BJLdnCjV.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+//#region extensions/matrix/src/matrix/credentials-read.ts
+var credentials_read_exports = /* @__PURE__ */ __exportAll({
+	clearMatrixCredentials: () => clearMatrixCredentials,
+	credentialsMatchConfig: () => credentialsMatchConfig,
+	loadMatrixCredentials: () => loadMatrixCredentials,
+	resolveMatrixCredentialsDir: () => resolveMatrixCredentialsDir,
+	resolveMatrixCredentialsPath: () => resolveMatrixCredentialsPath
+});
+function resolveStateDir(env) {
+	try {
+		return getMatrixRuntime().state.resolveStateDir(env, os.homedir);
+	} catch {
+		const override = env.OPENCLAW_STATE_DIR?.trim();
+		if (override) return path.resolve(override);
+		const homeDir = env.OPENCLAW_HOME?.trim() || env.HOME?.trim() || os.homedir();
+		return path.join(homeDir, ".openclaw");
+	}
+}
+function resolveLegacyMatrixCredentialsPath(env) {
+	return path.join(resolveMatrixCredentialsDir(env), "credentials.json");
+}
+function shouldReadLegacyCredentialsForAccount(accountId) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const cfg = getMatrixRuntime().config.current();
+	if (!cfg.channels?.matrix || typeof cfg.channels.matrix !== "object") return normalizedAccountId === DEFAULT_ACCOUNT_ID;
+	if (requiresExplicitMatrixDefaultAccount(cfg)) return false;
+	return normalizeAccountId(resolveMatrixDefaultOrOnlyAccountId(cfg)) === normalizedAccountId;
+}
+function resolveLegacyMigrationSourcePath(env, accountId) {
+	if (!shouldReadLegacyCredentialsForAccount(accountId)) return null;
+	const legacyPath = resolveLegacyMatrixCredentialsPath(env);
+	return legacyPath === resolveMatrixCredentialsPath(env, accountId) ? null : legacyPath;
+}
+function parseMatrixCredentialsFile(filePath) {
+	const raw = fs.readFileSync(filePath, "utf-8");
+	const parsed = JSON.parse(raw);
+	if (typeof parsed.homeserver !== "string" || typeof parsed.userId !== "string" || typeof parsed.accessToken !== "string") return null;
+	return parsed;
+}
+function loadMatrixCredentialsFile(filePath, source) {
+	try {
+		return {
+			kind: "loaded",
+			source,
+			credentials: parseMatrixCredentialsFile(filePath)
+		};
+	} catch (error) {
+		if (error?.code === "ENOENT") return { kind: "missing" };
+		throw error;
+	}
+}
+function loadLegacyMatrixCredentialsWithCurrentFallback(params) {
+	const legacy = loadMatrixCredentialsFile(params.legacyPath, "legacy");
+	if (legacy.kind === "loaded") return legacy;
+	return loadMatrixCredentialsFile(params.currentPath, "current");
+}
+function resolveMatrixCredentialsDir(env = process.env, stateDir) {
+	return resolveMatrixCredentialsDir$1(stateDir ?? resolveStateDir(env));
+}
+function resolveMatrixCredentialsPath(env = process.env, accountId) {
+	return resolveMatrixCredentialsPath$1({
+		stateDir: resolveStateDir(env),
+		accountId
+	});
+}
+function loadMatrixCredentials(env = process.env, accountId) {
+	const currentPath = resolveMatrixCredentialsPath(env, accountId);
+	try {
+		const current = loadMatrixCredentialsFile(currentPath, "current");
+		if (current.kind === "loaded") return current.credentials;
+		const legacyPath = resolveLegacyMigrationSourcePath(env, accountId);
+		if (!legacyPath) return null;
+		const loaded = loadLegacyMatrixCredentialsWithCurrentFallback({
+			legacyPath,
+			currentPath
+		});
+		if (loaded.kind !== "loaded" || !loaded.credentials) return null;
+		if (loaded.source === "legacy") try {
+			fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+			fs.renameSync(legacyPath, currentPath);
+		} catch {}
+		return loaded.credentials;
+	} catch {
+		return null;
+	}
+}
+function clearMatrixCredentials(env = process.env, accountId) {
+	const paths = [resolveMatrixCredentialsPath(env, accountId), resolveLegacyMigrationSourcePath(env, accountId)];
+	for (const filePath of paths) {
+		if (!filePath) continue;
+		try {
+			fs.unlinkSync(filePath);
+		} catch {}
+	}
+}
+function credentialsMatchConfig(stored, config) {
+	if (!config.userId) {
+		if (!config.accessToken) return false;
+		return stored.homeserver === config.homeserver && stored.accessToken === config.accessToken;
+	}
+	return stored.homeserver === config.homeserver && stored.userId === config.userId;
+}
+//#endregion
+export { resolveMatrixCredentialsDir as a, loadMatrixCredentials as i, credentialsMatchConfig as n, resolveMatrixCredentialsPath as o, credentials_read_exports as r, clearMatrixCredentials as t };

package/dist/credentials-write.runtime-zniTq-Gr.js

@@ -0,0 +1,17 @@
+//#region extensions/matrix/src/matrix/credentials-write.runtime.ts
+let matrixCredentialsRuntimePromise;
+function loadMatrixCredentialsRuntime() {
+	matrixCredentialsRuntimePromise ??= import("./credentials-DV6fWXhC.js");
+	return matrixCredentialsRuntimePromise;
+}
+async function saveMatrixCredentials(...args) {
+	return (await loadMatrixCredentialsRuntime()).saveMatrixCredentials(...args);
+}
+async function saveBackfilledMatrixDeviceId(...args) {
+	return (await loadMatrixCredentialsRuntime()).saveBackfilledMatrixDeviceId(...args);
+}
+async function touchMatrixCredentials(...args) {
+	return (await loadMatrixCredentialsRuntime()).touchMatrixCredentials(...args);
+}
+//#endregion
+export { saveBackfilledMatrixDeviceId, saveMatrixCredentials, touchMatrixCredentials };

package/dist/crypto-node.runtime-pihzdpY7.js

@@ -0,0 +1,12 @@
+import { createRequire } from "node:module";
+//#region extensions/matrix/src/matrix/sdk/crypto-node.runtime.ts
+const require = createRequire(import.meta.url);
+function loadMatrixCryptoNodeBindings() {
+	const { Attachment, EncryptedAttachment } = require("@matrix-org/matrix-sdk-crypto-nodejs");
+	return {
+		Attachment,
+		EncryptedAttachment
+	};
+}
+//#endregion
+export { loadMatrixCryptoNodeBindings };