@kodelyth/matrix 2026.5.39 → 2026.5.42

package/dist/cli-metadata-Dkwua7CB.js

@@ -0,0 +1,22 @@
+import { definePluginEntry } from "klaw/plugin-sdk/plugin-entry";
+//#region extensions/matrix/src/cli-metadata.ts
+function registerMatrixCliMetadata(api) {
+	api.registerCli(async ({ program }) => {
+		const { registerMatrixCli } = await import("./cli-FtY6Nuzw.js");
+		registerMatrixCli({ program });
+	}, { descriptors: [{
+		name: "matrix",
+		description: "Manage Matrix accounts, verification, devices, and profile state",
+		hasSubcommands: true
+	}] });
+}
+//#endregion
+//#region extensions/matrix/cli-metadata.ts
+var cli_metadata_default = definePluginEntry({
+	id: "matrix",
+	name: "Matrix",
+	description: "Matrix channel plugin (matrix-js-sdk)",
+	register: registerMatrixCliMetadata
+});
+//#endregion
+export { registerMatrixCliMetadata as n, cli_metadata_default as t };

package/dist/cli-metadata.js

@@ -0,0 +1,2 @@
+import { n as registerMatrixCliMetadata, t as cli_metadata_default } from "./cli-metadata-Dkwua7CB.js";
+export { cli_metadata_default as default, registerMatrixCliMetadata };

package/dist/client-BnohYygh.js

@@ -0,0 +1,25 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { u as resolveMatrixRoomId } from "./send-CJunc6QM.js";
+import { n as withResolvedRuntimeMatrixClient } from "./client-bootstrap-Mcj8ChJ5.js";
+//#region extensions/matrix/src/matrix/actions/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({
+	withResolvedActionClient: () => withResolvedActionClient,
+	withResolvedRoomAction: () => withResolvedRoomAction,
+	withStartedActionClient: () => withStartedActionClient
+});
+async function withResolvedActionClient(opts, run, mode = "stop") {
+	return await withResolvedRuntimeMatrixClient(opts, run, mode);
+}
+async function withStartedActionClient(opts, run) {
+	return await withResolvedActionClient({
+		...opts,
+		readiness: "started"
+	}, run, "persist");
+}
+async function withResolvedRoomAction(roomId, opts, run) {
+	return await withResolvedActionClient(opts, async (client) => {
+		return await run(client, await resolveMatrixRoomId(client, roomId));
+	});
+}
+//#endregion
+export { withStartedActionClient as i, withResolvedActionClient as n, withResolvedRoomAction as r, client_exports as t };

package/dist/client-PhrTwuC4.js

@@ -0,0 +1,30 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { t as getMatrixScopedEnvVarNames } from "./env-vars-EQKQv-FE.js";
+import { i as resolveScopedMatrixEnvConfig, r as resolveMatrixEnvAuthReadiness, t as hasReadyMatrixEnvAuth } from "./env-auth-UFiTGkDM.js";
+import { n as validateMatrixHomeserverUrl, t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-DlrXNjAE.js";
+import { t as isBunRuntime } from "./runtime-lwTSy9Yt.js";
+import { c as backfillMatrixAuthDeviceIdAfterStartup, d as resolveMatrixConfigForAccount, i as resolveSharedMatrixClient, l as resolveMatrixAuth, n as releaseSharedClientInstance, o as stopSharedClientForAccount, r as removeSharedClientInstance, s as stopSharedClientInstance, t as acquireSharedMatrixClient, u as resolveMatrixAuthContext } from "./shared-D6MFMnpG.js";
+import { t as createMatrixClient } from "./create-client-J0htTaRj.js";
+//#region extensions/matrix/src/matrix/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({
+	acquireSharedMatrixClient: () => acquireSharedMatrixClient,
+	backfillMatrixAuthDeviceIdAfterStartup: () => backfillMatrixAuthDeviceIdAfterStartup,
+	createMatrixClient: () => createMatrixClient,
+	getMatrixScopedEnvVarNames: () => getMatrixScopedEnvVarNames,
+	hasReadyMatrixEnvAuth: () => hasReadyMatrixEnvAuth,
+	isBunRuntime: () => isBunRuntime,
+	releaseSharedClientInstance: () => releaseSharedClientInstance,
+	removeSharedClientInstance: () => removeSharedClientInstance,
+	resolveMatrixAuth: () => resolveMatrixAuth,
+	resolveMatrixAuthContext: () => resolveMatrixAuthContext,
+	resolveMatrixConfigForAccount: () => resolveMatrixConfigForAccount,
+	resolveMatrixEnvAuthReadiness: () => resolveMatrixEnvAuthReadiness,
+	resolveScopedMatrixEnvConfig: () => resolveScopedMatrixEnvConfig,
+	resolveSharedMatrixClient: () => resolveSharedMatrixClient,
+	resolveValidatedMatrixHomeserverUrl: () => resolveValidatedMatrixHomeserverUrl,
+	stopSharedClientForAccount: () => stopSharedClientForAccount,
+	stopSharedClientInstance: () => stopSharedClientInstance,
+	validateMatrixHomeserverUrl: () => validateMatrixHomeserverUrl
+});
+//#endregion
+export { client_exports as t };

package/dist/client-bootstrap-Mcj8ChJ5.js

@@ -0,0 +1,114 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { t as getActiveMatrixClient } from "./active-client-CmFdvPdO.js";
+import { t as isBunRuntime } from "./runtime-lwTSy9Yt.js";
+import { requireRuntimeConfig } from "klaw/plugin-sdk/plugin-config-runtime";
+//#region extensions/matrix/src/matrix/client-bootstrap.ts
+var client_bootstrap_exports = /* @__PURE__ */ __exportAll({
+	resolveRuntimeMatrixClientWithReadiness: () => resolveRuntimeMatrixClientWithReadiness,
+	stopResolvedRuntimeMatrixClient: () => stopResolvedRuntimeMatrixClient,
+	withResolvedRuntimeMatrixClient: () => withResolvedRuntimeMatrixClient
+});
+let matrixSharedClientRuntimeDepsPromise;
+async function loadMatrixSharedClientRuntimeDeps() {
+	matrixSharedClientRuntimeDepsPromise ??= Promise.all([import("./client-PhrTwuC4.js").then((n) => n.t), import("./shared-D6MFMnpG.js").then((n) => n.a)]).then(([clientModule, sharedModule]) => ({
+		acquireSharedMatrixClient: clientModule.acquireSharedMatrixClient,
+		resolveMatrixAuthContext: clientModule.resolveMatrixAuthContext,
+		releaseSharedClientInstance: sharedModule.releaseSharedClientInstance
+	}));
+	return await matrixSharedClientRuntimeDepsPromise;
+}
+async function ensureResolvedClientReadiness(params) {
+	if (params.readiness === "started") {
+		await params.client.start();
+		return;
+	}
+	if (params.readiness === "prepared" || !params.readiness && params.preparedByDefault) await params.client.prepareForOneOff();
+}
+function ensureMatrixNodeRuntime() {
+	if (isBunRuntime()) throw new Error("Matrix support requires Node (bun runtime not supported)");
+}
+async function resolveRuntimeMatrixClient(opts) {
+	ensureMatrixNodeRuntime();
+	if (opts.client) {
+		await opts.onResolved?.(opts.client, { preparedByDefault: false });
+		return {
+			client: opts.client,
+			stopOnDone: false
+		};
+	}
+	if (!opts.cfg) throw new Error("Matrix runtime client requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
+	const cfg = requireRuntimeConfig(opts.cfg, "Matrix runtime client");
+	const { acquireSharedMatrixClient, releaseSharedClientInstance, resolveMatrixAuthContext } = await loadMatrixSharedClientRuntimeDeps();
+	const authContext = resolveMatrixAuthContext({
+		cfg,
+		accountId: opts.accountId
+	});
+	const active = getActiveMatrixClient(authContext.accountId);
+	if (active) {
+		await opts.onResolved?.(active, { preparedByDefault: false });
+		return {
+			client: active,
+			stopOnDone: false
+		};
+	}
+	const client = await acquireSharedMatrixClient({
+		cfg,
+		timeoutMs: opts.timeoutMs,
+		accountId: authContext.accountId,
+		startClient: false
+	});
+	try {
+		await opts.onResolved?.(client, { preparedByDefault: true });
+	} catch (err) {
+		await releaseSharedClientInstance(client, "stop");
+		throw err;
+	}
+	return {
+		client,
+		stopOnDone: true,
+		cleanup: async (mode) => {
+			await releaseSharedClientInstance(client, mode);
+		}
+	};
+}
+async function resolveRuntimeMatrixClientWithReadiness(opts) {
+	return await resolveRuntimeMatrixClient({
+		client: opts.client,
+		cfg: opts.cfg,
+		timeoutMs: opts.timeoutMs,
+		accountId: opts.accountId,
+		onResolved: async (client, context) => {
+			await ensureResolvedClientReadiness({
+				client,
+				readiness: opts.readiness,
+				preparedByDefault: context.preparedByDefault
+			});
+		}
+	});
+}
+async function stopResolvedRuntimeMatrixClient(resolved, mode = "stop") {
+	if (!resolved.stopOnDone) return;
+	if (resolved.cleanup) {
+		await resolved.cleanup(mode);
+		return;
+	}
+	if (mode === "persist") {
+		await resolved.client.stopAndPersist();
+		return;
+	}
+	if (mode === "discard") {
+		resolved.client.stopWithoutPersist();
+		return;
+	}
+	resolved.client.stop();
+}
+async function withResolvedRuntimeMatrixClient(opts, run, stopMode = "stop") {
+	const resolved = await resolveRuntimeMatrixClientWithReadiness(opts);
+	try {
+		return await run(resolved.client);
+	} finally {
+		await stopResolvedRuntimeMatrixClient(resolved, stopMode);
+	}
+}
+//#endregion
+export { withResolvedRuntimeMatrixClient as n, client_bootstrap_exports as t };

package/dist/config-paths-DVvt6vM3.js

@@ -0,0 +1,114 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
+import { hasConfiguredSecretInput } from "klaw/plugin-sdk/secret-input-runtime";
+import { listConfiguredAccountIds, resolveMergedAccountConfig, resolveNormalizedAccountEntry } from "klaw/plugin-sdk/account-resolution-runtime";
+//#region extensions/matrix/src/matrix/account-config.ts
+function resolveMatrixBaseConfig(cfg) {
+	return cfg.channels?.matrix ?? {};
+}
+function resolveMatrixAccountsMap(cfg) {
+	const accounts = resolveMatrixBaseConfig(cfg).accounts;
+	if (!accounts || typeof accounts !== "object") return {};
+	return accounts;
+}
+function selectInheritedMatrixRoomEntries(params) {
+	const entries = params.entries;
+	if (!entries) return;
+	const selected = Object.fromEntries(Object.entries(entries).filter(([, value]) => {
+		const scopedAccount = typeof value?.account === "string" ? normalizeAccountId(value.account) : void 0;
+		return scopedAccount === void 0 || scopedAccount === params.accountId;
+	}));
+	return Object.keys(selected).length > 0 ? selected : void 0;
+}
+function mergeMatrixRoomEntries(inherited, accountEntries, hasAccountOverride) {
+	if (!inherited && !accountEntries) return;
+	if (hasAccountOverride && Object.keys(accountEntries ?? {}).length === 0) return;
+	const merged = { ...inherited };
+	for (const [key, value] of Object.entries(accountEntries ?? {})) {
+		const inheritedValue = merged[key];
+		merged[key] = inheritedValue && value ? {
+			...inheritedValue,
+			...value
+		} : value ?? inheritedValue;
+	}
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function listNormalizedMatrixAccountIds(cfg) {
+	return listConfiguredAccountIds({
+		accounts: resolveMatrixAccountsMap(cfg),
+		normalizeAccountId
+	});
+}
+function findMatrixAccountConfig(cfg, accountId) {
+	return resolveNormalizedAccountEntry(resolveMatrixAccountsMap(cfg), accountId, normalizeAccountId);
+}
+function hasExplicitMatrixAccountConfig(cfg, accountId) {
+	const normalized = normalizeAccountId(accountId);
+	if (findMatrixAccountConfig(cfg, normalized)) return true;
+	if (normalized !== DEFAULT_ACCOUNT_ID) return false;
+	const matrix = resolveMatrixBaseConfig(cfg);
+	return typeof matrix.enabled === "boolean" || typeof matrix.name === "string" || typeof matrix.homeserver === "string" || typeof matrix.userId === "string" || hasConfiguredSecretInput(matrix.accessToken) || hasConfiguredSecretInput(matrix.password) || typeof matrix.deviceId === "string" || typeof matrix.deviceName === "string" || typeof matrix.avatarUrl === "string";
+}
+function resolveMatrixAccountConfig(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const base = resolveMatrixBaseConfig(params.cfg);
+	const merged = resolveMergedAccountConfig({
+		channelConfig: base,
+		accounts: params.cfg.channels?.matrix?.accounts,
+		accountId,
+		normalizeAccountId,
+		nestedObjectKeys: [
+			"dm",
+			"actions",
+			"execApprovals",
+			"botLoopProtection"
+		]
+	});
+	const accountConfig = findMatrixAccountConfig(params.cfg, accountId);
+	const groups = mergeMatrixRoomEntries(selectInheritedMatrixRoomEntries({
+		entries: base.groups,
+		accountId
+	}), accountConfig?.groups, Boolean(accountConfig && Object.hasOwn(accountConfig, "groups")));
+	const rooms = mergeMatrixRoomEntries(selectInheritedMatrixRoomEntries({
+		entries: base.rooms,
+		accountId
+	}), accountConfig?.rooms, Boolean(accountConfig && Object.hasOwn(accountConfig, "rooms")));
+	const { groups: _ignoredGroups, rooms: _ignoredRooms, ...rest } = merged;
+	return {
+		...rest,
+		...groups ? { groups } : {},
+		...rooms ? { rooms } : {}
+	};
+}
+function resolveMatrixAccountAllowlistConfig(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const base = resolveMatrixBaseConfig(params.cfg);
+	const accountConfig = findMatrixAccountConfig(params.cfg, accountId);
+	const accountDm = accountConfig?.dm;
+	let dmAllowFrom = base.dm?.allowFrom;
+	if (accountDm && Object.hasOwn(accountDm, "allowFrom")) dmAllowFrom = accountDm.allowFrom;
+	let groupAllowFrom = base.groupAllowFrom;
+	if (accountConfig && Object.hasOwn(accountConfig, "groupAllowFrom")) groupAllowFrom = accountConfig.groupAllowFrom;
+	return {
+		dmAllowFrom,
+		groupAllowFrom
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/config-paths.ts
+function shouldStoreMatrixAccountAtTopLevel(cfg, accountId) {
+	if (normalizeAccountId(accountId) !== DEFAULT_ACCOUNT_ID) return false;
+	const accounts = cfg.channels?.matrix?.accounts;
+	return !accounts || Object.keys(accounts).length === 0;
+}
+function resolveMatrixConfigPath(cfg, accountId) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	if (shouldStoreMatrixAccountAtTopLevel(cfg, normalizedAccountId)) return "channels.matrix";
+	return `channels.matrix.accounts.${normalizedAccountId}`;
+}
+function resolveMatrixConfigFieldPath(cfg, accountId, fieldPath) {
+	const suffix = fieldPath.trim().replace(/^\.+/, "");
+	if (!suffix) return resolveMatrixConfigPath(cfg, accountId);
+	return `${resolveMatrixConfigPath(cfg, accountId)}.${suffix}`;
+}
+//#endregion
+export { hasExplicitMatrixAccountConfig as a, resolveMatrixAccountConfig as c, findMatrixAccountConfig as i, resolveMatrixBaseConfig as l, resolveMatrixConfigPath as n, listNormalizedMatrixAccountIds as o, shouldStoreMatrixAccountAtTopLevel as r, resolveMatrixAccountAllowlistConfig as s, resolveMatrixConfigFieldPath as t };

package/dist/config-schema-BMGOlhdI.js

@@ -0,0 +1,308 @@
+import { c as resolveMatrixAccountConfig } from "./config-paths-DVvt6vM3.js";
+import { g as resolveMatrixAccount, h as resolveDefaultMatrixAccountId, p as listMatrixAccountIds } from "./setup-core-BEYoXF3J.js";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "klaw/plugin-sdk/account-id";
+import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "klaw/plugin-sdk/channel-config-helpers";
+import { resolveAllowlistMatchByCandidates } from "klaw/plugin-sdk/allow-from";
+import { normalizeStringEntries } from "klaw/plugin-sdk/string-normalization-runtime";
+import { buildChannelConfigSchema } from "klaw/plugin-sdk/channel-config-primitives";
+import { AllowFromListSchema, ContextVisibilityModeSchema, GroupPolicySchema, MarkdownConfigSchema, ToolPolicySchema, buildNestedDmConfigSchema } from "klaw/plugin-sdk/channel-config-schema";
+import { buildSecretInputSchema } from "klaw/plugin-sdk/secret-input";
+import { z } from "zod";
+//#region extensions/matrix/src/matrix/monitor/allowlist.ts
+function normalizeAllowList(list) {
+	return normalizeStringEntries(list);
+}
+function normalizeMatrixUser(raw) {
+	const value = (raw ?? "").trim();
+	if (!value) return "";
+	if (!value.startsWith("@") || !value.includes(":")) return normalizeLowercaseStringOrEmpty(value);
+	const withoutAt = value.slice(1);
+	const splitIndex = withoutAt.indexOf(":");
+	if (splitIndex === -1) return normalizeLowercaseStringOrEmpty(value);
+	const localpart = normalizeLowercaseStringOrEmpty(withoutAt.slice(0, splitIndex));
+	const server = normalizeLowercaseStringOrEmpty(withoutAt.slice(splitIndex + 1));
+	if (!server) return normalizeLowercaseStringOrEmpty(value);
+	return `@${localpart}:${server}`;
+}
+function normalizeMatrixUserId(raw) {
+	const trimmed = (raw ?? "").trim();
+	if (!trimmed) return "";
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("matrix:")) return normalizeMatrixUser(trimmed.slice(7));
+	if (lowered.startsWith("user:")) return normalizeMatrixUser(trimmed.slice(5));
+	return normalizeMatrixUser(trimmed);
+}
+function normalizeMatrixAllowListEntry(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	if (trimmed === "*") return trimmed;
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("matrix:")) return `matrix:${normalizeMatrixUser(trimmed.slice(7))}`;
+	if (lowered.startsWith("user:")) return `user:${normalizeMatrixUser(trimmed.slice(5))}`;
+	return normalizeMatrixUser(trimmed);
+}
+function normalizeMatrixAllowList(list) {
+	return normalizeAllowList(list).map((entry) => normalizeMatrixAllowListEntry(entry));
+}
+function resolveMatrixAllowListMatch(params) {
+	const allowList = params.allowList;
+	if (allowList.length === 0) return { allowed: false };
+	if (allowList.includes("*")) return {
+		allowed: true,
+		matchKey: "*",
+		matchSource: "wildcard"
+	};
+	const userId = normalizeMatrixUser(params.userId);
+	return resolveAllowlistMatchByCandidates({
+		allowList,
+		candidates: [
+			{
+				value: userId,
+				source: "id"
+			},
+			{
+				value: userId ? `matrix:${userId}` : "",
+				source: "prefixed-id"
+			},
+			{
+				value: userId ? `user:${userId}` : "",
+				source: "prefixed-user"
+			}
+		]
+	});
+}
+//#endregion
+//#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 = {
+	allowBots: {
+		label: "Matrix Allow Bot Messages",
+		help: "Allow messages from other configured Matrix bot accounts to trigger replies (default: false). Set \"mentions\" to require a visible room mention."
+	},
+	botLoopProtection: {
+		label: "Matrix Bot Loop Protection",
+		help: "Sliding-window guard for accepted Matrix configured-bot loops. Default is enabled whenever allowBots lets configured bot messages reach dispatch."
+	},
+	"botLoopProtection.enabled": {
+		label: "Matrix Bot Loop Protection Enabled",
+		help: "Enable the bot-pair loop guard. Defaults to true when allowBots is true or \"mentions\", and false when configured bot messages are ignored."
+	},
+	"botLoopProtection.maxEventsPerWindow": {
+		label: "Matrix Bot Loop Events per Window",
+		help: "Maximum accepted bot-pair messages within the sliding window before suppression starts. Default: 20."
+	},
+	"botLoopProtection.windowSeconds": {
+		label: "Matrix Bot Loop Window Seconds",
+		help: "Sliding window length for counting bot-pair messages. Default: 60."
+	},
+	"botLoopProtection.cooldownSeconds": {
+		label: "Matrix Bot Loop Cooldown Seconds",
+		help: "How long to suppress the bot pair after it exceeds the budget. Default: 60."
+	},
+	dangerouslyAllowNameMatching: {
+		label: "Matrix Display Name Matching",
+		help: "Compatibility opt-in for resolving Matrix display names and joined room names in allowlists. Prefer full @user:server IDs and room IDs or aliases because names are mutable."
+	},
+	"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 Klaw 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.maxLineChars": {
+		label: "Matrix Progress Max Line Chars",
+		help: "Maximum characters per compact progress line before truncation (default: 120). Prose cuts at word boundaries; commands and paths keep useful suffixes."
+	},
+	"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 botLoopProtectionSchema = z.object({
+	enabled: z.boolean().optional(),
+	maxEventsPerWindow: z.number().int().positive().optional(),
+	windowSeconds: z.number().int().positive().optional(),
+	cooldownSeconds: z.number().int().positive().optional()
+}).strict().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(),
+	botLoopProtection: botLoopProtectionSchema,
+	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(),
+		maxLineChars: 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(),
+	dangerouslyAllowNameMatching: z.boolean().optional(),
+	allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
+	botLoopProtection: botLoopProtectionSchema,
+	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 { normalizeMatrixUserId as a, normalizeMatrixAllowList as i, DEFAULT_ACCOUNT_ID$1 as n, resolveMatrixAllowListMatch as o, matrixConfigAdapter as r, MatrixChannelConfigSchema as t };

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

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

package/dist/contract-api.js

@@ -0,0 +1,8 @@
+import { s as resetMatrixThreadBindingsForTests } from "./thread-bindings-shared-fvfP7jVs.js";
+import { r as setMatrixRuntime } from "./runtime-B-Fyrmxo.js";
+import { d as resolveSingleAccountPromotionTarget, f as singleAccountKeysToMove, n as matrixSetupAdapter, u as namedAccountPromotionKeys } from "./setup-core-BEYoXF3J.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BLzYHl_9.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-DEMcDsjl.js";
+import { n as matrixOnboardingAdapter } from "./setup-surface-c28ON6jq.js";
+import { t as createMatrixThreadBindingManager } from "./thread-bindings-FjAZmDUP.js";
+export { collectRuntimeConfigAssignments, createMatrixThreadBindingManager, legacyConfigRules, matrixSetupAdapter, matrixOnboardingAdapter as matrixSetupWizard, namedAccountPromotionKeys, normalizeCompatibilityConfig, resetMatrixThreadBindingsForTests, resolveSingleAccountPromotionTarget, secretTargetRegistryEntries, setMatrixRuntime, singleAccountKeysToMove };