@openclaw/discord 2026.9.2 → 2026.9.4

package/dist/doctor-DgKMH6N7.js

@@ -0,0 +1,253 @@
+import { s as resolveDefaultDiscordAccountId } from "./accounts-CwJQoLjM.js";
+import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-VkgenQv-.js";
+import { t as inspectDiscordAccount } from "./account-inspect-BY-ve3yH.js";
+import { r as DISCORD_LEGACY_CONFIG_RULES } from "./shared-CPPR0Xo4.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-Co5vRCZ6.js";
+import { t as isDiscordMutableAllowEntry } from "./security-doctor-nGgPm65L.js";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asObjectRecord, collectChannelAccountScopes, collectProviderDangerousNameMatchingScopes } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+//#region extensions/discord/src/doctor.ts
+function sanitizeForLog(value) {
+	return value.replace(/\p{Cc}+/gu, " ").trim();
+}
+function collectDiscordIdLists(prefix, account) {
+	const refs = [{
+		pathLabel: `${prefix}.allowFrom`,
+		holder: account,
+		key: "allowFrom"
+	}];
+	const dm = asObjectRecord(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(account.execApprovals);
+	if (execApprovals) refs.push({
+		pathLabel: `${prefix}.execApprovals.approvers`,
+		holder: execApprovals,
+		key: "approvers"
+	});
+	const guilds = asObjectRecord(account.guilds);
+	if (!guilds) return refs;
+	for (const guildId of Object.keys(guilds)) {
+		const guild = asObjectRecord(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(guild.channels);
+		if (!channels) continue;
+		for (const channelId of Object.keys(channels)) {
+			const channel = asObjectRecord(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 collectChannelAccountScopes({
+		cfg,
+		channelId: "discord"
+	})) 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 = expectDefined(repairableHits.at(0), "non-empty repairable Discord ID hits");
+		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 = expectDefined(blockedHits.at(0), "non-empty blocked Discord ID hits");
+		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 collectChannelAccountScopes({
+		cfg: next,
+		channelId: "discord"
+	})) 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 collectDiscordTranscriptsAutoStartWarnings(cfg) {
+	if (cfg.transcripts?.enabled === false || !Array.isArray(cfg.transcripts?.autoStart)) return [];
+	const ownership = discordVoiceTranscriptsSourceProvider.accessControl;
+	if (!ownership) return [];
+	return cfg.transcripts.autoStart.flatMap((entry, index) => {
+		const providerId = normalizeOptionalString(entry.providerId)?.toLowerCase();
+		if (providerId !== discordVoiceTranscriptsSourceProvider.id && !discordVoiceTranscriptsSourceProvider.aliases?.includes(providerId ?? "") || normalizeOptionalString(entry.accountId)) return [];
+		const resolution = ownership.resolveAccountId({
+			cfg,
+			source: {
+				providerId: entry.providerId,
+				accountId: entry.accountId
+			}
+		});
+		if (resolution.ok) return [];
+		const path = `transcripts.autoStart[${index}]`;
+		return [`- ${path} cannot select a Discord voice account: ${resolution.error} Set ${path}.accountId to the intended enabled voice account, or set channels.discord.defaultAccount when one account should be the global default.`];
+	});
+}
+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(scope.account.dm);
+		if (dm) addHits(`${scope.prefix}.dm.allowFrom`, dm.allowFrom);
+		const guilds = asObjectRecord(scope.account.guilds);
+		if (!guilds) continue;
+		for (const [guildId, guildRaw] of Object.entries(guilds)) {
+			const guild = asObjectRecord(guildRaw);
+			if (!guild) continue;
+			addHits(`${scope.prefix}.guilds.${guildId}.users`, guild.users);
+			const channels = asObjectRecord(guild.channels);
+			if (!channels) continue;
+			for (const [channelId, channelRaw] of Object.entries(channels)) {
+				const channel = asObjectRecord(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
+		}),
+		...collectDiscordTranscriptsAutoStartWarnings(cfg)
+	],
+	collectMutableAllowlistWarnings: ({ cfg }) => collectDiscordMutableAllowlistWarnings(cfg),
+	repairConfig: ({ cfg, doctorFixCommand }) => maybeRepairDiscordNumericIds(cfg, doctorFixCommand)
+};
+//#endregion
+export { collectDiscordMissingEnvTokenWarnings, collectDiscordNumericIdWarnings, discordDoctor, maybeRepairDiscordNumericIds, scanDiscordNumericIdEntries };

package/dist/doctor-contract-api.js

@@ -75,6 +75,7 @@ const detectDiscordLegacyStateMigrations = async ({ stateDir }) => {
 		scopeKey: "",
 		cleanupSource: "remove",
 		cleanupWhenEmpty: true,
+		cleanupWarningDisposition: "recoverable",
 		readEntries: () => []
 	});
 	const modelPickerSourcePath = path.join(stateDir, "discord", "model-picker-preferences.json");
@@ -110,7 +111,7 @@ const detectDiscordLegacyStateMigrations = async ({ stateDir }) => {
 	});
 	const threadBindingsSourcePath = path.join(stateDir, "discord", "thread-bindings.json");
 	if (fileExists(threadBindingsSourcePath)) {
-		const { normalizePersistedBinding, THREAD_BINDINGS_MAX_ENTRIES, THREAD_BINDINGS_NAMESPACE, toBindingRecordKey } = await import("./thread-bindings.state-DtgOqsbX.js").then((n) => n.E);
+		const { normalizePersistedBinding, THREAD_BINDINGS_MAX_ENTRIES, THREAD_BINDINGS_NAMESPACE, toBindingRecordKey } = await import("./thread-bindings.state-dDn-dwBw.js").then((n) => n.D);
 		plans.push({
 			kind: "plugin-state-import",
 			label: "Discord thread bindings",

package/dist/handle-action.guild-admin-CpEwox_X.js

@@ -0,0 +1,316 @@
+import { c as readDiscordChannelMoveParams, n as isDiscordModerationAction, o as readDiscordChannelCreateParams, r as readDiscordModerationCommand, s as readDiscordChannelEditParams, t as handleDiscordAction } from "./runtime-Dxl-ZOvg.js";
+import "./action-runtime-api.js";
+import { m as isTrustedRequesterGuildAdminAction } from "./outbound-session-route-B0N6os97.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
+import { readNonNegativeIntegerParam, readPositiveIntegerParam, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/agent-runtime";
+//#region extensions/discord/src/actions/handle-action.guild-admin.ts
+function readDiscordRequesterSenderId(ctx) {
+	const currentProvider = normalizeOptionalString(ctx.toolContext?.currentChannelProvider);
+	if (currentProvider?.toLowerCase() === "discord") return normalizeOptionalString(ctx.requesterSenderId);
+	if (isTrustedRequesterGuildAdminAction(ctx.action) && (currentProvider || ctx.senderIsOwner !== true)) throw new Error("Discord guild admin actions require a trusted Discord sender identity.");
+}
+function senderParam(senderUserId) {
+	return senderUserId ? { senderUserId } : {};
+}
+async function tryHandleDiscordMessageActionGuildAdmin(params) {
+	const { ctx, resolveChannelId, readPolicyOptions, actionOptions } = params;
+	const { action, params: actionParams, cfg } = ctx;
+	const accountId = ctx.accountId ?? readStringParam(actionParams, "accountId");
+	const senderUserId = readDiscordRequesterSenderId(ctx);
+	if (action === "member-info") {
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "memberInfo",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId
+		}, cfg, readPolicyOptions);
+	}
+	if (action === "role-info") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "roleInfo",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg, readPolicyOptions);
+	}
+	if (action === "emoji-list") {
+		const guildId = readStringParam(actionParams, "guildId");
+		const limit = readPositiveIntegerParam(actionParams, "limit");
+		return await handleDiscordAction({
+			action: "emojiList",
+			accountId: accountId ?? void 0,
+			...guildId ? { guildId } : { channelId: resolveChannelId() },
+			...limit ? { limit } : {}
+		}, cfg, readPolicyOptions);
+	}
+	if (action === "emoji-upload") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "emojiName", { required: true });
+		const mediaUrl = readStringParam(actionParams, "media", {
+			required: true,
+			trim: false
+		});
+		const roleIds = readStringArrayParam(actionParams, "roleIds");
+		return await handleDiscordAction({
+			action: "emojiUpload",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			mediaUrl,
+			roleIds,
+			...senderParam(senderUserId)
+		}, cfg, actionOptions);
+	}
+	if (action === "sticker-upload") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "stickerName", { required: true });
+		const description = readStringParam(actionParams, "stickerDesc", { required: true });
+		const tags = readStringParam(actionParams, "stickerTags", { required: true });
+		const mediaUrl = readStringParam(actionParams, "media", {
+			required: true,
+			trim: false
+		});
+		return await handleDiscordAction({
+			action: "stickerUpload",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			description,
+			tags,
+			mediaUrl,
+			...senderParam(senderUserId)
+		}, cfg, actionOptions);
+	}
+	if (action === "role-add" || action === "role-remove") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		const roleId = readStringParam(actionParams, "roleId", { required: true });
+		return await handleDiscordAction({
+			action: action === "role-add" ? "roleAdd" : "roleRemove",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId,
+			roleId,
+			...senderParam(senderUserId)
+		}, cfg);
+	}
+	if (action === "channel-info") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelInfo",
+			accountId: accountId ?? void 0,
+			channelId
+		}, cfg, readPolicyOptions);
+	}
+	if (action === "channel-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "channelList",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg, readPolicyOptions);
+	}
+	if (action === "channel-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "channelCreate",
+			accountId: accountId ?? void 0,
+			...readDiscordChannelCreateParams({
+				...actionParams,
+				guildId
+			}),
+			...senderParam(senderUserId)
+		}, cfg);
+	}
+	if (action === "channel-edit") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelEdit",
+			accountId: accountId ?? void 0,
+			...readDiscordChannelEditParams({
+				...actionParams,
+				channelId
+			}),
+			...senderParam(senderUserId)
+		}, cfg);
+	}
+	if (action === "channel-delete") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelDelete",
+			accountId: accountId ?? void 0,
+			channelId,
+			...senderParam(senderUserId)
+		}, cfg);
+	}
+	if (action === "channel-move") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelMove",
+			accountId: accountId ?? void 0,
+			...readDiscordChannelMoveParams({
+				...actionParams,
+				guildId,
+				channelId
+			}),
+			...senderParam(senderUserId)
+		}, cfg);
+	}
+	if (action === "category-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "name", { required: true });
+		const position = readNonNegativeIntegerParam(actionParams, "position");
+		return await handleDiscordAction({
+			action: "categoryCreate",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			position: position ?? void 0,
+			...senderParam(senderUserId)
+		}, cfg);
+	}
+	if (action === "category-edit") {
+		const categoryId = readStringParam(actionParams, "categoryId", { required: true });
+		const name = readStringParam(actionParams, "name");
+		const position = readNonNegativeIntegerParam(actionParams, "position");
+		return await handleDiscordAction({
+			action: "categoryEdit",
+			accountId: accountId ?? void 0,
+			categoryId,
+			name: name ?? void 0,
+			position: position ?? void 0,
+			...senderParam(senderUserId)
+		}, cfg);
+	}
+	if (action === "category-delete") {
+		const categoryId = readStringParam(actionParams, "categoryId", { required: true });
+		return await handleDiscordAction({
+			action: "categoryDelete",
+			accountId: accountId ?? void 0,
+			categoryId,
+			...senderParam(senderUserId)
+		}, cfg);
+	}
+	if (action === "voice-status") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		return await handleDiscordAction({
+			action: "voiceStatus",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId
+		}, cfg, readPolicyOptions);
+	}
+	if (action === "event-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "eventList",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg, readPolicyOptions);
+	}
+	if (action === "event-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "eventName", { required: true });
+		const startTime = readStringParam(actionParams, "startTime", { required: true });
+		const endTime = readStringParam(actionParams, "endTime");
+		const description = readStringParam(actionParams, "desc");
+		const channelId = readStringParam(actionParams, "channelId");
+		const location = readStringParam(actionParams, "location");
+		const entityType = readStringParam(actionParams, "eventType");
+		const image = readStringParam(actionParams, "image", { trim: false });
+		return await handleDiscordAction({
+			action: "eventCreate",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			startTime,
+			endTime,
+			description,
+			channelId,
+			location,
+			entityType,
+			image,
+			...senderParam(senderUserId)
+		}, cfg, actionOptions);
+	}
+	if (isDiscordModerationAction(action)) {
+		const moderation = readDiscordModerationCommand(action, {
+			...actionParams,
+			durationMinutes: readNonNegativeIntegerParam(actionParams, "durationMin"),
+			deleteMessageDays: readNonNegativeIntegerParam(actionParams, "deleteDays", {
+				max: 7,
+				message: "deleteDays must be an integer from 0 to 7"
+			})
+		});
+		return await handleDiscordAction({
+			action: moderation.action,
+			accountId: accountId ?? void 0,
+			guildId: moderation.guildId,
+			userId: moderation.userId,
+			durationMinutes: moderation.durationMinutes,
+			until: moderation.until,
+			reason: moderation.reason,
+			deleteMessageDays: moderation.deleteMessageDays,
+			senderUserId
+		}, cfg);
+	}
+	if (action === "thread-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const channelId = readStringParam(actionParams, "channelId");
+		const includeArchived = typeof actionParams.includeArchived === "boolean" ? actionParams.includeArchived : void 0;
+		const before = readStringParam(actionParams, "before");
+		const limit = readPositiveIntegerParam(actionParams, "limit");
+		return await handleDiscordAction({
+			action: "threadList",
+			accountId: accountId ?? void 0,
+			guildId,
+			channelId,
+			includeArchived,
+			before,
+			limit
+		}, cfg, readPolicyOptions);
+	}
+	if (action === "thread-reply") {
+		const content = readStringParam(actionParams, "message", {
+			required: true,
+			trim: false
+		});
+		const mediaUrl = readStringParam(actionParams, "media", { trim: false }) ?? readStringParam(actionParams, "path", { trim: false }) ?? readStringParam(actionParams, "filePath", { trim: false });
+		const replyTo = readStringParam(actionParams, "replyTo");
+		const channelId = readStringParam(actionParams, "threadId") ?? resolveChannelId();
+		return await handleDiscordAction({
+			action: "threadReply",
+			accountId: accountId ?? void 0,
+			channelId,
+			content,
+			mediaUrl: mediaUrl ?? void 0,
+			replyTo: replyTo ?? void 0,
+			...readBooleanParam(actionParams, "silent") === true ? { silent: true } : {}
+		}, cfg, actionOptions);
+	}
+	if (action === "search") {
+		const guildId = readStringParam(actionParams, "guildId");
+		const query = readStringParam(actionParams, "query") ?? readStringParam(actionParams, "content");
+		if (!query) throw new Error("Discord search requires query text. Provide query or content.");
+		const explicitChannelIds = readStringArrayParam(actionParams, "channelIds");
+		const channelId = readStringParam(actionParams, "channelId") ?? (!guildId && !explicitChannelIds?.length && ctx.toolContext?.currentChannelProvider?.trim().toLowerCase() === "discord" ? ctx.toolContext?.currentChannelId?.trim() || void 0 : void 0);
+		return await handleDiscordAction({
+			action: "searchMessages",
+			accountId: accountId ?? void 0,
+			...guildId ? { guildId } : {},
+			content: query,
+			channelId,
+			channelIds: explicitChannelIds,
+			authorId: readStringParam(actionParams, "authorId"),
+			authorIds: readStringArrayParam(actionParams, "authorIds"),
+			limit: readPositiveIntegerParam(actionParams, "limit")
+		}, cfg, readPolicyOptions);
+	}
+}
+//#endregion
+export { tryHandleDiscordMessageActionGuildAdmin as t };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as registerDiscordActivities } from "./activities-api-CTcGq3Hf.js";
+import { t as registerDiscordActivities } from "./activities-api-w8j7Elou.js";
 import { registerDiscordSubagentHooks } from "./subagent-hooks-api.js";
 import { registerDiscordTranscriptSourceProvider } from "./transcripts-source-api.js";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";

package/dist/live-policy-config-BblutQAq.js

@@ -0,0 +1,74 @@
+import { r as normalizeDiscordAllowList } from "./allow-list-DWEio925.js";
+import { defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
+//#region extensions/discord/src/monitor/ingress-identity.ts
+const DISCORD_ALLOW_LIST_PREFIXES = [
+	"discord:",
+	"user:",
+	"pk:"
+];
+const DISCORD_USER_ID_KIND = "stable-id";
+const DISCORD_USER_NAME_KIND = "username";
+function normalizeDiscordIdEntry(entry) {
+	const text = entry.trim();
+	if (!text) return null;
+	const maybeId = text.replace(/^<@!?/, "").replace(/>$/, "");
+	if (/^\d+$/.test(maybeId)) return maybeId;
+	const prefix = DISCORD_ALLOW_LIST_PREFIXES.find((entryPrefix) => text.startsWith(entryPrefix));
+	if (prefix) return text.slice(prefix.length).trim() || null;
+	return null;
+}
+function normalizeDiscordNameEntry(entry) {
+	const text = entry.trim();
+	if (!text || text === "*" || normalizeDiscordIdEntry(text) || /#\d{4}$/.test(text)) return null;
+	const nameSlug = normalizeDiscordAllowList([text], DISCORD_ALLOW_LIST_PREFIXES)?.names.values().next().value;
+	return typeof nameSlug === "string" && nameSlug ? nameSlug : null;
+}
+function normalizeDiscordTagEntry(entry) {
+	const text = entry.trim();
+	return /#\d{4}$/.test(text) ? normalizeDiscordNameSubject(text) : null;
+}
+function normalizeDiscordNameSubject(value) {
+	const nameSlug = normalizeDiscordAllowList([value], DISCORD_ALLOW_LIST_PREFIXES)?.names.values().next().value;
+	return typeof nameSlug === "string" && nameSlug ? nameSlug : null;
+}
+const discordIngressIdentity = defineStableChannelIngressIdentity({
+	resolveParticipant: (subject) => {
+		const kind = subject.aliases?.participantKind;
+		const id = subject.stableId;
+		return typeof id === "string" && id && (kind === "user" || kind === "bot" || kind === "pluralkit-member") ? {
+			domain: kind === "pluralkit-member" ? "pluralkit" : "discord",
+			idKind: kind,
+			id
+		} : void 0;
+	},
+	key: "discordUserId",
+	kind: DISCORD_USER_ID_KIND,
+	authentication: "verified",
+	normalizeEntry: normalizeDiscordIdEntry,
+	normalizeSubject: (value) => value.trim() || null,
+	sensitivity: "pii",
+	aliases: [["discordUserName", normalizeDiscordNameEntry], ["discordUserTag", normalizeDiscordTagEntry]].map(([key, normalizeEntry]) => ({
+		key,
+		kind: DISCORD_USER_NAME_KIND,
+		normalizeEntry,
+		normalizeSubject: normalizeDiscordNameSubject,
+		authentication: "mutable",
+		sensitivity: "pii"
+	}))
+});
+//#endregion
+//#region extensions/discord/src/live-policy-config.ts
+/** Account policy consumed at inbound admission, without replacing the transport. */
+function selectDiscordLivePolicyConfig(config) {
+	return {
+		groupPolicy: config.groupPolicy,
+		dmPolicy: config.dmPolicy,
+		allowFrom: config.allowFrom,
+		dm: config.dm,
+		guilds: config.guilds,
+		allowBots: config.allowBots,
+		dangerouslyAllowNameMatching: config.dangerouslyAllowNameMatching
+	};
+}
+//#endregion
+export { discordIngressIdentity as n, selectDiscordLivePolicyConfig as t };