@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/dist/doctor-B2G7WqO0.js

@@ -0,0 +1,244 @@
+import { o as resolveDefaultDiscordAccountId } from "./accounts-BKnkNaoA.js";
+import { t as inspectDiscordAccount } from "./account-inspect-C2UEUhbG.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-D3pSutkb.js";
+import { t as DISCORD_LEGACY_CONFIG_RULES } from "./doctor-shared-DU8RcnF5.js";
+import { t as isDiscordMutableAllowEntry } from "./security-doctor-CzTzpXV8.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import { collectProviderDangerousNameMatchingScopes } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/discord/src/doctor.ts
+function asObjectRecord$1(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function sanitizeForLog(value) {
+	return value.replace(/\p{Cc}+/gu, " ").trim();
+}
+function collectDiscordAccountScopes(cfg) {
+	const scopes = [];
+	const discord = asObjectRecord$1(cfg.channels?.discord);
+	if (!discord) return scopes;
+	scopes.push({
+		prefix: "channels.discord",
+		account: discord
+	});
+	const accounts = asObjectRecord$1(discord.accounts);
+	if (!accounts) return scopes;
+	for (const key of Object.keys(accounts)) {
+		const account = asObjectRecord$1(accounts[key]);
+		if (account) scopes.push({
+			prefix: `channels.discord.accounts.${key}`,
+			account
+		});
+	}
+	return scopes;
+}
+function collectDiscordIdLists(prefix, account) {
+	const refs = [{
+		pathLabel: `${prefix}.allowFrom`,
+		holder: account,
+		key: "allowFrom"
+	}];
+	const dm = asObjectRecord$1(account.dm);
+	if (dm) {
+		refs.push({
+			pathLabel: `${prefix}.dm.allowFrom`,
+			holder: dm,
+			key: "allowFrom"
+		});
+		refs.push({
+			pathLabel: `${prefix}.dm.groupChannels`,
+			holder: dm,
+			key: "groupChannels"
+		});
+	}
+	const execApprovals = asObjectRecord$1(account.execApprovals);
+	if (execApprovals) refs.push({
+		pathLabel: `${prefix}.execApprovals.approvers`,
+		holder: execApprovals,
+		key: "approvers"
+	});
+	const guilds = asObjectRecord$1(account.guilds);
+	if (!guilds) return refs;
+	for (const guildId of Object.keys(guilds)) {
+		const guild = asObjectRecord$1(guilds[guildId]);
+		if (!guild) continue;
+		refs.push({
+			pathLabel: `${prefix}.guilds.${guildId}.users`,
+			holder: guild,
+			key: "users"
+		});
+		refs.push({
+			pathLabel: `${prefix}.guilds.${guildId}.roles`,
+			holder: guild,
+			key: "roles"
+		});
+		const channels = asObjectRecord$1(guild.channels);
+		if (!channels) continue;
+		for (const channelId of Object.keys(channels)) {
+			const channel = asObjectRecord$1(channels[channelId]);
+			if (!channel) continue;
+			refs.push({
+				pathLabel: `${prefix}.guilds.${guildId}.channels.${channelId}.users`,
+				holder: channel,
+				key: "users"
+			});
+			refs.push({
+				pathLabel: `${prefix}.guilds.${guildId}.channels.${channelId}.roles`,
+				holder: channel,
+				key: "roles"
+			});
+		}
+	}
+	return refs;
+}
+function scanDiscordNumericIdEntries(cfg) {
+	const hits = [];
+	const scanList = (pathLabel, list) => {
+		if (!Array.isArray(list)) return;
+		for (const [index, entry] of list.entries()) {
+			if (typeof entry !== "number") continue;
+			hits.push({
+				path: `${pathLabel}[${index}]`,
+				entry,
+				safe: Number.isSafeInteger(entry) && entry >= 0
+			});
+		}
+	};
+	for (const scope of collectDiscordAccountScopes(cfg)) for (const ref of collectDiscordIdLists(scope.prefix, scope.account)) scanList(ref.pathLabel, ref.holder[ref.key]);
+	return hits;
+}
+function collectDiscordNumericIdWarnings(params) {
+	if (params.hits.length === 0) return [];
+	const hitsByListPath = /* @__PURE__ */ new Map();
+	for (const hit of params.hits) {
+		const listPath = hit.path.replace(/\[\d+\]$/, "");
+		const existing = hitsByListPath.get(listPath);
+		if (existing) existing.push(hit);
+		else hitsByListPath.set(listPath, [hit]);
+	}
+	const repairableHits = [];
+	const blockedHits = [];
+	for (const hits of hitsByListPath.values()) if (hits.some((hit) => !hit.safe)) blockedHits.push(...hits);
+	else repairableHits.push(...hits);
+	const lines = [];
+	if (repairableHits.length > 0) {
+		const sample = repairableHits[0];
+		lines.push(`- Discord allowlists contain ${repairableHits.length} numeric ${repairableHits.length === 1 ? "entry" : "entries"} (e.g. ${sanitizeForLog(sample.path)}=${sanitizeForLog(String(sample.entry))}).`, `- Discord IDs must be strings; run "${params.doctorFixCommand}" to convert numeric IDs to quoted strings.`);
+	}
+	if (blockedHits.length > 0) {
+		const sample = blockedHits[0];
+		lines.push(`- Discord allowlists contain ${blockedHits.length} numeric ${blockedHits.length === 1 ? "entry" : "entries"} in lists that cannot be auto-repaired (e.g. ${sanitizeForLog(sample.path)}).`, `- These lists include invalid or precision-losing numeric IDs; manually quote the original values in your config file, then rerun "${params.doctorFixCommand}".`);
+	}
+	return lines;
+}
+function maybeRepairDiscordNumericIds(cfg, doctorFixCommand) {
+	const hits = scanDiscordNumericIdEntries(cfg);
+	if (hits.length === 0) return {
+		config: cfg,
+		changes: []
+	};
+	const next = structuredClone(cfg);
+	const changes = [];
+	const repairList = (pathLabel, holder, key) => {
+		const raw = holder[key];
+		if (!Array.isArray(raw)) return;
+		if (raw.some((entry) => typeof entry === "number" && (!Number.isSafeInteger(entry) || entry < 0))) return;
+		let converted = 0;
+		holder[key] = raw.map((entry) => {
+			if (typeof entry === "number") {
+				converted += 1;
+				return String(entry);
+			}
+			return entry;
+		});
+		if (converted > 0) changes.push(`- ${sanitizeForLog(pathLabel)}: converted ${converted} numeric ${converted === 1 ? "ID" : "IDs"} to strings`);
+	};
+	for (const scope of collectDiscordAccountScopes(next)) for (const ref of collectDiscordIdLists(scope.prefix, scope.account)) repairList(ref.pathLabel, ref.holder, ref.key);
+	if (changes.length === 0) return {
+		config: cfg,
+		changes: [],
+		warnings: collectDiscordNumericIdWarnings({
+			hits,
+			doctorFixCommand
+		})
+	};
+	return {
+		config: next,
+		changes,
+		warnings: collectDiscordNumericIdWarnings({
+			hits: hits.filter((hit) => !hit.safe),
+			doctorFixCommand
+		})
+	};
+}
+function collectDiscordMissingEnvTokenWarnings(params) {
+	if (resolveDefaultDiscordAccountId(params.cfg) !== "default") return [];
+	const account = inspectDiscordAccount({
+		cfg: params.cfg,
+		accountId: "default",
+		envToken: params.env?.DISCORD_BOT_TOKEN ?? ""
+	});
+	if (!account.enabled || account.tokenStatus !== "missing" || account.tokenSource !== "none") return [];
+	return ["- channels.discord: default account has no available bot token, and DISCORD_BOT_TOKEN is absent in this doctor environment. After migration, verify DISCORD_BOT_TOKEN is present in the state-dir .env or configure channels.discord.token / channels.discord.accounts.default.token as a SecretRef."];
+}
+function collectDiscordMutableAllowlistWarnings(cfg) {
+	const hits = [];
+	const addHits = (pathLabel, list) => {
+		if (!Array.isArray(list)) return;
+		for (const entry of list) {
+			const text = normalizeOptionalString(String(entry)) ?? "";
+			if (!text || text === "*" || !isDiscordMutableAllowEntry(text)) continue;
+			hits.push({
+				path: pathLabel,
+				entry: text
+			});
+		}
+	};
+	for (const scope of collectProviderDangerousNameMatchingScopes(cfg, "discord")) {
+		if (scope.dangerousNameMatchingEnabled) continue;
+		addHits(`${scope.prefix}.allowFrom`, scope.account.allowFrom);
+		const dm = asObjectRecord$1(scope.account.dm);
+		if (dm) addHits(`${scope.prefix}.dm.allowFrom`, dm.allowFrom);
+		const guilds = asObjectRecord$1(scope.account.guilds);
+		if (!guilds) continue;
+		for (const [guildId, guildRaw] of Object.entries(guilds)) {
+			const guild = asObjectRecord$1(guildRaw);
+			if (!guild) continue;
+			addHits(`${scope.prefix}.guilds.${guildId}.users`, guild.users);
+			const channels = asObjectRecord$1(guild.channels);
+			if (!channels) continue;
+			for (const [channelId, channelRaw] of Object.entries(channels)) {
+				const channel = asObjectRecord$1(channelRaw);
+				if (channel) addHits(`${scope.prefix}.guilds.${guildId}.channels.${channelId}.users`, channel.users);
+			}
+		}
+	}
+	if (hits.length === 0) return [];
+	const exampleLines = hits.slice(0, 8).map((hit) => `- ${sanitizeForLog(hit.path)}: ${sanitizeForLog(hit.entry)}`);
+	const remaining = hits.length > 8 ? `- +${hits.length - 8} more mutable allowlist entries.` : null;
+	return [
+		`- Found ${hits.length} mutable allowlist ${hits.length === 1 ? "entry" : "entries"} across discord while name matching is disabled by default.`,
+		...exampleLines,
+		...remaining ? [remaining] : [],
+		`- Option A (break-glass): enable channels.discord.dangerousNameMatching=true for the affected scope.`,
+		`- Option B (recommended): resolve names to stable Discord IDs and rewrite the allowlist entries.`
+	];
+}
+const discordDoctor = {
+	dmAllowFromMode: "topOnly",
+	groupModel: "route",
+	groupAllowFromFallbackToAllowFrom: false,
+	warnOnEmptyGroupSenderAllowlist: false,
+	legacyConfigRules: DISCORD_LEGACY_CONFIG_RULES,
+	normalizeCompatibilityConfig,
+	collectPreviewWarnings: ({ cfg, doctorFixCommand, env }) => [...collectDiscordMissingEnvTokenWarnings({
+		cfg,
+		env
+	}), ...collectDiscordNumericIdWarnings({
+		hits: scanDiscordNumericIdEntries(cfg),
+		doctorFixCommand
+	})],
+	collectMutableAllowlistWarnings: ({ cfg }) => collectDiscordMutableAllowlistWarnings(cfg),
+	repairConfig: ({ cfg, doctorFixCommand }) => maybeRepairDiscordNumericIds(cfg, doctorFixCommand)
+};
+//#endregion
+export { collectDiscordMissingEnvTokenWarnings, collectDiscordNumericIdWarnings, discordDoctor, maybeRepairDiscordNumericIds, scanDiscordNumericIdEntries };

package/dist/doctor-contract-D3pSutkb.js

@@ -0,0 +1,383 @@
+import { t as resolveDiscordPreviewStreamMode } from "./preview-streaming-C0O92Qqz.js";
+import { asObjectRecord, normalizeLegacyChannelAliases } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/discord/src/doctor-contract.ts
+const LEGACY_TTS_PROVIDER_KEYS = [
+	"openai",
+	"elevenlabs",
+	"microsoft",
+	"edge"
+];
+function hasLegacyTtsProviderKeys(value) {
+	const tts = asObjectRecord(value);
+	if (!tts) return false;
+	return LEGACY_TTS_PROVIDER_KEYS.some((key) => Object.prototype.hasOwnProperty.call(tts, key));
+}
+function hasLegacyDiscordAccountTtsProviderKeys(value) {
+	const accounts = asObjectRecord(value);
+	if (!accounts) return false;
+	return Object.values(accounts).some((accountValue) => {
+		return hasLegacyTtsProviderKeys(asObjectRecord(asObjectRecord(accountValue)?.voice)?.tts);
+	});
+}
+function hasLegacyDiscordGuildChannelAllowAlias(value) {
+	const guilds = asObjectRecord(asObjectRecord(value)?.guilds);
+	if (!guilds) return false;
+	return Object.values(guilds).some((guildValue) => {
+		const channels = asObjectRecord(asObjectRecord(guildValue)?.channels);
+		if (!channels) return false;
+		return Object.values(channels).some((channel) => Object.prototype.hasOwnProperty.call(asObjectRecord(channel) ?? {}, "allow"));
+	});
+}
+function hasLegacyDiscordGuildChannelAgentId(value) {
+	const guilds = asObjectRecord(asObjectRecord(value)?.guilds);
+	if (!guilds) return false;
+	return Object.values(guilds).some((guildValue) => {
+		const channels = asObjectRecord(asObjectRecord(guildValue)?.channels);
+		if (!channels) return false;
+		return Object.values(channels).some((channel) => Object.prototype.hasOwnProperty.call(asObjectRecord(channel) ?? {}, "agentId"));
+	});
+}
+function hasLegacyDiscordAccountGuildChannelAllowAlias(value) {
+	const accounts = asObjectRecord(value);
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => hasLegacyDiscordGuildChannelAllowAlias(account));
+}
+function hasLegacyDiscordAccountGuildChannelAgentId(value) {
+	const accounts = asObjectRecord(value);
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => hasLegacyDiscordGuildChannelAgentId(account));
+}
+function mergeMissing(target, source) {
+	for (const [key, value] of Object.entries(source)) {
+		if (value === void 0) continue;
+		const existing = target[key];
+		if (existing === void 0) {
+			target[key] = value;
+			continue;
+		}
+		if (existing && typeof existing === "object" && !Array.isArray(existing) && value && typeof value === "object" && !Array.isArray(value)) mergeMissing(existing, value);
+	}
+}
+function getOrCreateTtsProviders(tts) {
+	const providers = asObjectRecord(tts.providers) ?? {};
+	tts.providers = providers;
+	return providers;
+}
+function mergeLegacyTtsProviderConfig(tts, legacyKey, providerId) {
+	const legacyValue = asObjectRecord(tts[legacyKey]);
+	if (!legacyValue) return false;
+	const providers = getOrCreateTtsProviders(tts);
+	const existing = asObjectRecord(providers[providerId]) ?? {};
+	const merged = structuredClone(existing);
+	mergeMissing(merged, legacyValue);
+	providers[providerId] = merged;
+	delete tts[legacyKey];
+	return true;
+}
+function migrateLegacyTtsConfig(tts, pathLabel, changes) {
+	if (!tts) return false;
+	let changed = false;
+	if (mergeLegacyTtsProviderConfig(tts, "openai", "openai")) {
+		changes.push(`Moved ${pathLabel}.openai → ${pathLabel}.providers.openai.`);
+		changed = true;
+	}
+	if (mergeLegacyTtsProviderConfig(tts, "elevenlabs", "elevenlabs")) {
+		changes.push(`Moved ${pathLabel}.elevenlabs → ${pathLabel}.providers.elevenlabs.`);
+		changed = true;
+	}
+	if (mergeLegacyTtsProviderConfig(tts, "microsoft", "microsoft")) {
+		changes.push(`Moved ${pathLabel}.microsoft → ${pathLabel}.providers.microsoft.`);
+		changed = true;
+	}
+	if (mergeLegacyTtsProviderConfig(tts, "edge", "microsoft")) {
+		changes.push(`Moved ${pathLabel}.edge → ${pathLabel}.providers.microsoft.`);
+		changed = true;
+	}
+	return changed;
+}
+function normalizeDiscordGuildChannelAllowAliases(params) {
+	const guilds = asObjectRecord(params.entry.guilds);
+	if (!guilds) return {
+		entry: params.entry,
+		changed: false
+	};
+	let changed = false;
+	const nextGuilds = { ...guilds };
+	for (const [guildId, guildValue] of Object.entries(guilds)) {
+		const guild = asObjectRecord(guildValue);
+		const channels = asObjectRecord(guild?.channels);
+		if (!guild || !channels) continue;
+		let channelsChanged = false;
+		const nextChannels = { ...channels };
+		for (const [channelId, channelValue] of Object.entries(channels)) {
+			const channel = asObjectRecord(channelValue);
+			if (!channel || !Object.prototype.hasOwnProperty.call(channel, "allow")) continue;
+			const nextChannel = { ...channel };
+			if (nextChannel.enabled === void 0) {
+				nextChannel.enabled = channel.allow;
+				params.changes.push(`Moved ${params.pathPrefix}.guilds.${guildId}.channels.${channelId}.allow → ${params.pathPrefix}.guilds.${guildId}.channels.${channelId}.enabled.`);
+			} else params.changes.push(`Removed ${params.pathPrefix}.guilds.${guildId}.channels.${channelId}.allow (${params.pathPrefix}.guilds.${guildId}.channels.${channelId}.enabled already set).`);
+			delete nextChannel.allow;
+			nextChannels[channelId] = nextChannel;
+			channelsChanged = true;
+		}
+		if (!channelsChanged) continue;
+		nextGuilds[guildId] = {
+			...guild,
+			channels: nextChannels
+		};
+		changed = true;
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			guilds: nextGuilds
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
+}
+function isDiscordChannelAgentBinding(value, match) {
+	const binding = asObjectRecord(value);
+	const bindingMatch = asObjectRecord(binding?.match);
+	const peer = asObjectRecord(bindingMatch?.peer);
+	if (!binding || !bindingMatch || !peer) return false;
+	return bindingMatch.channel === "discord" && bindingMatch.guildId === match.guildId && (match.accountId === void 0 || bindingMatch.accountId === match.accountId) && peer.kind === "channel" && peer.id === match.channelId;
+}
+function normalizeDiscordGuildChannelAgentIds(params) {
+	const guilds = asObjectRecord(params.entry.guilds);
+	if (!guilds) return {
+		entry: params.entry,
+		changed: false
+	};
+	const existingBindings = Array.isArray(params.cfg.bindings) ? params.cfg.bindings : [];
+	let changed = false;
+	const nextGuilds = { ...guilds };
+	for (const [guildId, guildValue] of Object.entries(guilds)) {
+		const guild = asObjectRecord(guildValue);
+		const channels = asObjectRecord(guild?.channels);
+		if (!guild || !channels) continue;
+		let channelsChanged = false;
+		const nextChannels = { ...channels };
+		for (const [channelId, channelValue] of Object.entries(channels)) {
+			const channel = asObjectRecord(channelValue);
+			if (!channel || !Object.prototype.hasOwnProperty.call(channel, "agentId")) continue;
+			const nextChannel = { ...channel };
+			const rawAgentId = nextChannel.agentId;
+			delete nextChannel.agentId;
+			nextChannels[channelId] = nextChannel;
+			channelsChanged = true;
+			const path = `${params.pathPrefix}.guilds.${guildId}.channels.${channelId}.agentId`;
+			const agentId = typeof rawAgentId === "string" ? rawAgentId.trim() : "";
+			if (!agentId) {
+				params.changes.push(`Removed ${path}; configure top-level bindings[] for per-channel Discord agent routing.`);
+				continue;
+			}
+			const match = {
+				accountId: params.accountId,
+				guildId,
+				channelId
+			};
+			if (existingBindings.find((binding) => isDiscordChannelAgentBinding(binding, match))) {
+				params.changes.push(`Removed ${path}; a matching top-level bindings[] route already exists for Discord channel ${channelId}.`);
+				continue;
+			}
+			const bindingMatch = {
+				channel: "discord",
+				guildId,
+				peer: {
+					kind: "channel",
+					id: channelId
+				}
+			};
+			if (params.accountId) bindingMatch.accountId = params.accountId;
+			params.bindingsToAdd.push({
+				agentId,
+				match: bindingMatch
+			});
+			params.changes.push(`Moved ${path} → top-level bindings[] route for Discord channel ${channelId}.`);
+		}
+		if (!channelsChanged) continue;
+		nextGuilds[guildId] = {
+			...guild,
+			channels: nextChannels
+		};
+		changed = true;
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			guilds: nextGuilds
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
+}
+const legacyConfigRules = [
+	{
+		path: [
+			"channels",
+			"discord",
+			"voice",
+			"tts"
+		],
+		message: "channels.discord.voice.tts.<provider> keys (openai/elevenlabs/microsoft/edge) are legacy; use channels.discord.voice.tts.providers.<provider>. Run \"openclaw doctor --fix\".",
+		match: hasLegacyTtsProviderKeys
+	},
+	{
+		path: [
+			"channels",
+			"discord",
+			"accounts"
+		],
+		message: "channels.discord.accounts.<id>.voice.tts.<provider> keys (openai/elevenlabs/microsoft/edge) are legacy; use channels.discord.accounts.<id>.voice.tts.providers.<provider>. Run \"openclaw doctor --fix\".",
+		match: hasLegacyDiscordAccountTtsProviderKeys
+	},
+	{
+		path: ["channels", "discord"],
+		message: "channels.discord.guilds.<id>.channels.<id>.allow is legacy; use channels.discord.guilds.<id>.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyDiscordGuildChannelAllowAlias
+	},
+	{
+		path: [
+			"channels",
+			"discord",
+			"accounts"
+		],
+		message: "channels.discord.accounts.<id>.guilds.<id>.channels.<id>.allow is legacy; use channels.discord.accounts.<id>.guilds.<id>.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyDiscordAccountGuildChannelAllowAlias
+	},
+	{
+		path: ["channels", "discord"],
+		message: "channels.discord.guilds.<id>.channels.<id>.agentId is legacy; use top-level bindings[] for per-channel Discord agent routing. Run \"openclaw doctor --fix\".",
+		match: hasLegacyDiscordGuildChannelAgentId
+	},
+	{
+		path: [
+			"channels",
+			"discord",
+			"accounts"
+		],
+		message: "channels.discord.accounts.<id>.guilds.<id>.channels.<id>.agentId is legacy; use top-level bindings[] with match.accountId for per-channel Discord agent routing. Run \"openclaw doctor --fix\".",
+		match: hasLegacyDiscordAccountGuildChannelAgentId
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const rawEntry = asObjectRecord(cfg.channels?.discord);
+	if (!rawEntry) return {
+		config: cfg,
+		changes: []
+	};
+	const changes = [];
+	let updated = rawEntry;
+	let changed = false;
+	const bindingsToAdd = [];
+	const aliases = normalizeLegacyChannelAliases({
+		entry: rawEntry,
+		pathPrefix: "channels.discord",
+		changes,
+		normalizeDm: true,
+		normalizeAccountDm: true,
+		resolveStreamingOptions: (entry) => ({
+			resolvedMode: resolveDiscordPreviewStreamMode(entry),
+			includePreviewChunk: true
+		}),
+		normalizeAccountExtra: ({ account, pathPrefix }) => {
+			const accountVoice = asObjectRecord(account.voice);
+			if (!accountVoice || !migrateLegacyTtsConfig(asObjectRecord(accountVoice.tts), `${pathPrefix}.voice.tts`, changes)) return {
+				entry: account,
+				changed: false
+			};
+			return {
+				entry: {
+					...account,
+					voice: accountVoice
+				},
+				changed: true
+			};
+		}
+	});
+	updated = aliases.entry;
+	changed = aliases.changed;
+	const guildAliases = normalizeDiscordGuildChannelAllowAliases({
+		entry: updated,
+		pathPrefix: "channels.discord",
+		changes
+	});
+	updated = guildAliases.entry;
+	changed = changed || guildAliases.changed;
+	const channelAgentIds = normalizeDiscordGuildChannelAgentIds({
+		cfg,
+		entry: updated,
+		pathPrefix: "channels.discord",
+		changes,
+		bindingsToAdd
+	});
+	updated = channelAgentIds.entry;
+	changed = changed || channelAgentIds.changed;
+	const accounts = asObjectRecord(updated.accounts);
+	if (accounts) {
+		let accountsChanged = false;
+		const nextAccounts = { ...accounts };
+		for (const [accountId, accountValue] of Object.entries(accounts)) {
+			const account = asObjectRecord(accountValue);
+			if (!account) continue;
+			const normalized = normalizeDiscordGuildChannelAllowAliases({
+				entry: account,
+				pathPrefix: `channels.discord.accounts.${accountId}`,
+				changes
+			});
+			let nextAccount = normalized.entry;
+			let accountChanged = normalized.changed;
+			const normalizedAgentIds = normalizeDiscordGuildChannelAgentIds({
+				cfg,
+				entry: nextAccount,
+				pathPrefix: `channels.discord.accounts.${accountId}`,
+				accountId,
+				changes,
+				bindingsToAdd
+			});
+			nextAccount = normalizedAgentIds.entry;
+			accountChanged = accountChanged || normalizedAgentIds.changed;
+			if (!accountChanged) continue;
+			nextAccounts[accountId] = nextAccount;
+			accountsChanged = true;
+		}
+		if (accountsChanged) {
+			updated = {
+				...updated,
+				accounts: nextAccounts
+			};
+			changed = true;
+		}
+	}
+	const voice = asObjectRecord(updated.voice);
+	if (voice && migrateLegacyTtsConfig(asObjectRecord(voice.tts), "channels.discord.voice.tts", changes)) {
+		updated = {
+			...updated,
+			voice
+		};
+		changed = true;
+	}
+	if (!changed) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				discord: updated
+			},
+			bindings: bindingsToAdd.length > 0 ? [...cfg.bindings ?? [], ...bindingsToAdd] : cfg.bindings
+		},
+		changes
+	};
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

@@ -0,0 +1,2 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-D3pSutkb.js";
+export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/doctor-shared-DU8RcnF5.js

@@ -0,0 +1,4 @@
+//#region extensions/discord/src/doctor-shared.ts
+const DISCORD_LEGACY_CONFIG_RULES = [];
+//#endregion
+export { DISCORD_LEGACY_CONFIG_RULES as t };

package/dist/format-D8TsaXxW.js

@@ -0,0 +1,24 @@
+//#region extensions/discord/src/monitor/format.ts
+function resolveDiscordSystemLocation(params) {
+	const { isDirectMessage, isGroupDm, guild, channelName } = params;
+	if (isDirectMessage) return "DM";
+	if (isGroupDm) return `Group DM #${channelName}`;
+	return guild?.name ? `${guild.name} #${channelName}` : `#${channelName}`;
+}
+function formatDiscordReactionEmoji(emoji) {
+	if (emoji.id && emoji.name) return `<:${emoji.name}:${emoji.id}>`;
+	if (emoji.id) return `emoji:${emoji.id}`;
+	return emoji.name ?? "emoji";
+}
+function formatDiscordUserTag(user) {
+	const discriminator = (user.discriminator ?? "").trim();
+	if (discriminator && discriminator !== "0") return `${user.username}#${discriminator}`;
+	return user.username ?? user.id;
+}
+function resolveTimestampMs(timestamp) {
+	if (!timestamp) return;
+	const parsed = Date.parse(timestamp);
+	return Number.isNaN(parsed) ? void 0 : parsed;
+}
+//#endregion
+export { resolveTimestampMs as i, formatDiscordUserTag as n, resolveDiscordSystemLocation as r, formatDiscordReactionEmoji as t };