@openclaw/discord 2026.7.1 → 2026.7.2-beta.2

package/dist/{runtime-C6rRmQ6l.js → runtime-BsefAQ9q.js}

@@ -1,17 +1,51 @@
-import { qt as resolveDiscordChannelId, r as createReusableDiscordReplyReference } from "./send.receipt-BpBQED_5.js";
-import { a as mergeDiscordAccountConfig, o as resolveDefaultDiscordAccountId, t as createDiscordActionGate } from "./accounts-P19jm1lf.js";
-import { d as readDiscordComponentSpec } from "./components-BIBizbtZ.js";
-import { _ as withNormalizedTimestamp, c as jsonResult, d as readNonNegativeIntegerParam, f as readPositiveIntegerParam, g as resolvePollMaxSelections, h as readStringParam, l as parseAvailableTags, m as readStringArrayParam, p as readReactionParams, r as sendDiscordComponentMessage, s as assertMediaNotDataUrl, u as readBooleanParam } from "./send.components-D0I39utR.js";
+import { f as resolveDiscordChannelId, i as createReusableDiscordReplyReference } from "./chunk-CHpY_lsO.js";
+import { a as mergeDiscordAccountConfig, o as resolveDefaultDiscordAccountId, t as createDiscordActionGate } from "./accounts-CMd4nzLB.js";
+import { m as readDiscordComponentSpec } from "./outbound-session-route-D4QqePZN.js";
+import { a as normalizeDiscordSlug, c as resolveDiscordChannelConfigWithFallback, n as isDiscordGroupAllowedByPolicy, v as resolveGroupDmAllow } from "./allow-list-B7qOH5xu.js";
+import { E as canManageGuildRoleDiscord, I as createDiscordRuntimeAccountContext, M as hasAnyGuildPermissionDiscord, N as isThreadChannelType$1, O as fetchChannelPermissionsDiscord, T as canManageGuildMemberRoleDiscord, V as getGateway, d as resolveDiscordTargetChannelId, j as hasAnyChannelPermissionDiscord } from "./send.shared-XuOTO1dW.js";
+import { a as assertMediaNotDataUrl, c as readBooleanParam, d as readReactionParams, f as readStringArrayParam, h as withNormalizedTimestamp, l as readNonNegativeIntegerParam, m as resolvePollMaxSelections, o as jsonResult, p as readStringParam, r as sendDiscordComponentMessage, s as parseAvailableTags, u as readPositiveIntegerParam } from "./send.components-CCRW54gK.js";
+import { n as sendPollDiscord, r as sendStickerDiscord, t as sendMessageDiscord } from "./send.outbound-Cvulb-k_.js";
 import { n as getPresence } from "./presence-cache-z1N8MbJ3.js";
-import { E as canManageGuildRoleDiscord, L as createDiscordRuntimeAccountContext, M as hasAnyGuildPermissionDiscord, N as isThreadChannelType$1, O as fetchChannelPermissionsDiscord, T as canManageGuildMemberRoleDiscord, W as getGateway, d as resolveDiscordTargetChannelId, j as hasAnyChannelPermissionDiscord } from "./send.shared-wAwMhHDN.js";
-import { a as normalizeDiscordSlug, c as resolveDiscordChannelConfigWithFallback, n as isDiscordGroupAllowedByPolicy } from "./allow-list-C-MqM-B_.js";
-import { A as listScheduledEventsDiscord, B as moveChannelDiscord, C as fetchChannelInfoDiscord, D as fetchVoiceStatusDiscord, E as fetchRoleInfoDiscord, F as uploadEmojiDiscord, H as setChannelPermissionDiscord, I as uploadStickerDiscord, L as createChannelDiscord, M as resolveEventCoverImage, N as timeoutMemberDiscord, O as kickMemberDiscord, P as listGuildEmojisDiscord, R as deleteChannelDiscord, S as createScheduledEventDiscord, T as fetchMemberInfoDiscord, V as removeChannelPermissionDiscord, _ as readMessagesDiscord, a as removeReactionDiscord, b as addRoleDiscord, d as deleteMessageDiscord, f as editMessageDiscord, g as pinMessageDiscord, h as listThreadsDiscord, i as removeOwnReactionsDiscord, j as removeRoleDiscord, k as listGuildChannelsDiscord, l as DiscordThreadInitialMessageError, m as listPinsDiscord, n as fetchReactionsDiscord, p as fetchMessageDiscord, r as reactMessageDiscord, s as sendVoiceMessageDiscord, u as createThreadDiscord, v as searchMessagesDiscord, w as fetchGuildInfoDiscord, x as banMemberDiscord, y as unpinMessageDiscord, z as editChannelDiscord } from "./send-iJ0B4bAX.js";
-import { n as sendPollDiscord, r as sendStickerDiscord, t as sendMessageDiscord } from "./send.outbound-Bj61Q3a0.js";
-import "./targets-69w7c3vU.js";
+import { A as listScheduledEventsDiscord, B as moveChannelDiscord, C as fetchChannelInfoDiscord, D as fetchVoiceStatusDiscord, E as fetchRoleInfoDiscord, F as uploadEmojiDiscord, H as setChannelPermissionDiscord, I as uploadStickerDiscord, L as createChannelDiscord, M as resolveEventCoverImage, N as timeoutMemberDiscord, O as kickMemberDiscord, P as listGuildEmojisDiscord, R as deleteChannelDiscord, S as createScheduledEventDiscord, T as fetchMemberInfoDiscord, V as removeChannelPermissionDiscord, _ as readMessagesDiscord, a as removeReactionDiscord, b as addRoleDiscord, d as deleteMessageDiscord, f as editMessageDiscord, g as pinMessageDiscord, h as listThreadsDiscord, i as removeOwnReactionsDiscord, j as removeRoleDiscord, k as listGuildChannelsDiscord, l as DiscordThreadInitialMessageError, m as listPinsDiscord, n as fetchReactionsDiscord, p as fetchMessageDiscord, r as reactMessageDiscord, s as sendVoiceMessageDiscord, u as createThreadDiscord, v as searchMessagesDiscord, w as fetchGuildInfoDiscord, x as banMemberDiscord, y as unpinMessageDiscord, z as editChannelDiscord } from "./send-JJzVo_sK.js";
+import "./targets-fjJt3PYG.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { ChannelType, PermissionFlagsBits } from "discord-api-types/v10";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
+//#region extensions/discord/src/actions/runtime-deps.ts
+const discordGuildActionRuntime = {
+	addRoleDiscord,
+	canManageGuildRoleDiscord,
+	canManageGuildMemberRoleDiscord,
+	createChannelDiscord,
+	createScheduledEventDiscord,
+	resolveEventCoverImage,
+	deleteChannelDiscord,
+	editChannelDiscord,
+	fetchChannelInfoDiscord,
+	fetchMemberInfoDiscord,
+	hasAnyChannelPermissionDiscord,
+	hasAnyGuildPermissionDiscord,
+	fetchRoleInfoDiscord,
+	fetchVoiceStatusDiscord,
+	listGuildChannelsDiscord,
+	listGuildEmojisDiscord,
+	listScheduledEventsDiscord,
+	moveChannelDiscord,
+	removeChannelPermissionDiscord,
+	removeRoleDiscord,
+	setChannelPermissionDiscord,
+	uploadEmojiDiscord,
+	uploadStickerDiscord
+};
+const discordModerationActionRuntime = {
+	banMemberDiscord,
+	hasAnyGuildPermissionDiscord,
+	kickMemberDiscord,
+	timeoutMemberDiscord
+};
+//#endregion
 //#region extensions/discord/src/actions/runtime.messaging.runtime.ts
 const discordMessagingActionRuntime = {
 	createThreadDiscord,
@@ -53,11 +87,28 @@ async function resolveDiscordReactionTargetChannelId(params) {
 }
 //#endregion
 //#region extensions/discord/src/actions/runtime.shared.ts
+/** Discord REST auto_archive_duration allowlist (minutes). */
+const DISCORD_AUTO_ARCHIVE_MINUTES = /* @__PURE__ */ new Set([
+	60,
+	1440,
+	4320,
+	10080
+]);
 function readDiscordParentIdParam(params) {
 	if (params.clearParent === true) return null;
 	if (params.parentId === null) return null;
 	return readStringParam(params, "parentId");
 }
+/**
+* Reads Discord auto-archive duration minutes and rejects values Discord will
+* not accept, so thread/channel edits fail closed before the REST call.
+*/
+function readDiscordAutoArchiveDurationParam(params, key) {
+	const value = readPositiveIntegerParam(params, key);
+	if (value === void 0) return;
+	if (!DISCORD_AUTO_ARCHIVE_MINUTES.has(value)) throw new Error(`${key} must be one of 60, 1440, 4320, or 10080 minutes`);
+	return value;
+}
 function readDiscordBooleanParam(params, key) {
 	return typeof params[key] === "boolean" ? params[key] : void 0;
 }
@@ -92,7 +143,7 @@ function readDiscordChannelEditParams(params) {
 		rateLimitPerUser: readNonNegativeIntegerParam(params, "rateLimitPerUser") ?? void 0,
 		archived: readDiscordBooleanParam(params, "archived"),
 		locked: readDiscordBooleanParam(params, "locked"),
-		autoArchiveDuration: readPositiveIntegerParam(params, "autoArchiveDuration") ?? void 0,
+		autoArchiveDuration: readDiscordAutoArchiveDurationParam(params, "autoArchiveDuration"),
 		availableTags: parseAvailableTags(params.availableTags)
 	};
 }
@@ -145,6 +196,40 @@ function resolveDiscordActionGuildEntry(params) {
 		id: guildId
 	} : null;
 }
+async function resolveDiscordReadAncestry(params) {
+	const ancestors = [];
+	const visited = /* @__PURE__ */ new Set([params.channelId]);
+	let parentId = params.parentId;
+	for (let depth = 0; parentId && depth < 2; depth++) {
+		if (visited.has(parentId)) return {
+			ancestors,
+			complete: false
+		};
+		visited.add(parentId);
+		const parent = await params.loadChannel(parentId);
+		if (!parent) {
+			ancestors.push({
+				channelId: parentId,
+				channelSlug: normalizeDiscordSlug(parentId) || parentId
+			});
+			return {
+				ancestors,
+				complete: false
+			};
+		}
+		const parentName = readDiscordChannelStringField(parent, "name");
+		ancestors.push({
+			channelId: parentId,
+			...parentName ? { channelName: parentName } : {},
+			channelSlug: parentName ? normalizeDiscordSlug(parentName) : parentId
+		});
+		parentId = readDiscordChannelStringField(parent, "parent_id", "parentId");
+	}
+	return {
+		ancestors,
+		complete: !parentId
+	};
+}
 function readDiscordChannelStringField(value, ...keys) {
 	if (!value || typeof value !== "object") return;
 	const record = value;
@@ -162,7 +247,24 @@ function isDiscordThreadChannel(value) {
 	const type = readDiscordChannelType(value);
 	return type === 10 || type === 11 || type === 12;
 }
+function isDiscordReadAncestryAllowed(params) {
+	for (const ancestor of params.target.ancestors) {
+		const config = resolveDiscordChannelConfigWithFallback({
+			guildInfo: params.guildInfo,
+			channelId: ancestor.channelId,
+			channelName: ancestor.channelName,
+			channelSlug: ancestor.channelSlug
+		});
+		if (config?.matchSource === "direct" && !config.allowed) return false;
+	}
+	return params.target.ancestryComplete || !hasExplicitlyDisabledDiscordChannels(params.guildInfo?.channels);
+}
 function isDiscordReadTargetAllowedInGuild(params) {
+	if (!params.target.metadataKnown) {
+		if (hasExplicitlyDisabledDiscordChannels(params.guildInfo?.channels)) return false;
+		return isDiscordReadTargetExplicitlyAllowedById(params);
+	}
+	if (!isDiscordReadAncestryAllowed(params)) return false;
 	if (resolveDiscordChannelConfigWithFallback({
 		guildInfo: params.guildInfo,
 		channelId: params.target.channelId,
@@ -190,23 +292,41 @@ function isDiscordReadTargetExplicitlyAllowedById(params) {
 		channelAllowed: true
 	});
 }
+function hasExplicitlyDisabledDiscordChannelConfig(guilds) {
+	return Object.values(guilds ?? {}).some((guild) => hasExplicitlyDisabledDiscordChannels(guild?.channels));
+}
+function hasExplicitlyDisabledDiscordChannels(channels) {
+	return Object.values(channels ?? {}).some((channel) => channel.enabled === false);
+}
 function createDiscordMessagingActionContext(params) {
 	const accountId = readStringParam(params.input, "accountId");
 	const cfgOptions = { cfg: params.cfg };
 	const accountConfig = mergeDiscordAccountConfig(params.cfg, accountId ?? resolveDefaultDiscordAccountId(params.cfg));
 	const guilds = accountConfig.guilds;
-	const hasGuildEntries = Object.keys(guilds ?? {}).length > 0;
 	const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
 		providerConfigPresent: params.cfg.channels?.discord !== void 0,
 		groupPolicy: accountConfig.groupPolicy,
 		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
 	});
+	const directOperator = params.options?.conversationReadOrigin === "direct-operator";
+	const currentReadContext = params.options?.readContext;
+	const directDmEnabled = accountConfig.dm?.enabled !== false && (accountConfig.dmPolicy ?? accountConfig.dm?.policy ?? "pairing") !== "disabled";
 	const withOpts = (extra) => createDiscordActionOptions({
 		cfg: params.cfg,
 		accountId,
 		extra
 	});
 	const resolvedReactionAccountId = accountId ?? resolveDefaultDiscordAccountId(params.cfg);
+	const isCurrentReadTarget = (channelId) => {
+		const requesterAccountId = currentReadContext?.requesterAccountId?.trim();
+		const currentChannelId = currentReadContext?.currentChannelId?.trim();
+		if (currentReadContext?.currentChannelProvider?.trim().toLowerCase() !== "discord" || !requesterAccountId || !currentChannelId || normalizeAccountId(requesterAccountId) !== normalizeAccountId(resolvedReactionAccountId)) return false;
+		try {
+			return discordMessagingActionRuntime.resolveDiscordChannelId(currentChannelId) === channelId;
+		} catch {
+			return false;
+		}
+	};
 	const reactionRuntimeOptions = resolvedReactionAccountId ? createDiscordRuntimeAccountContext({
 		cfg: params.cfg,
 		accountId: resolvedReactionAccountId
@@ -246,7 +366,10 @@ function createDiscordMessagingActionContext(params) {
 	const resolveReadTargetContext = async (channelId) => {
 		const fallback = {
 			channelId,
-			channelSlug: normalizeDiscordSlug(channelId) || channelId
+			channelSlug: normalizeDiscordSlug(channelId) || channelId,
+			metadataKnown: false,
+			ancestryComplete: false,
+			ancestors: []
 		};
 		let channelInfo;
 		try {
@@ -257,24 +380,67 @@ function createDiscordMessagingActionContext(params) {
 		const channelName = readDiscordChannelStringField(channelInfo, "name");
 		const target = {
 			channelId,
-			channelSlug: channelName ? normalizeDiscordSlug(channelName) : fallback.channelSlug
+			channelSlug: channelName ? normalizeDiscordSlug(channelName) : fallback.channelSlug,
+			metadataKnown: true,
+			ancestryComplete: true,
+			ancestors: []
 		};
+		const channelType = readDiscordChannelType(channelInfo);
+		if (channelType !== void 0) target.channelType = channelType;
 		const targetGuildId = readDiscordChannelStringField(channelInfo, "guild_id", "guildId");
 		if (targetGuildId) target.guildId = targetGuildId;
 		if (channelName) target.channelName = channelName;
-		if (!isDiscordThreadChannel(channelInfo)) return target;
-		target.scope = "thread";
-		target.parentId = readDiscordChannelStringField(channelInfo, "parent_id", "parentId");
-		if (!target.parentId) return target;
-		try {
-			const parentName = readDiscordChannelStringField(await discordMessagingActionRuntime.fetchChannelInfoDiscord(target.parentId, withOpts()), "name");
-			if (parentName) {
-				target.parentName = parentName;
-				target.parentSlug = normalizeDiscordSlug(parentName);
+		if (isDiscordThreadChannel(channelInfo)) target.scope = "thread";
+		const ancestry = await resolveDiscordReadAncestry({
+			channelId,
+			parentId: readDiscordChannelStringField(channelInfo, "parent_id", "parentId"),
+			loadChannel: async (parentId) => {
+				try {
+					return await discordMessagingActionRuntime.fetchChannelInfoDiscord(parentId, withOpts());
+				} catch {
+					return;
+				}
 			}
-		} catch {}
+		});
+		target.ancestors = ancestry.ancestors;
+		target.ancestryComplete = ancestry.complete;
+		const immediateParent = target.ancestors[0];
+		if (!immediateParent) return target;
+		target.parentId = immediateParent.channelId;
+		if (immediateParent.channelName) target.parentName = immediateParent.channelName;
+		target.parentSlug = immediateParent.channelSlug;
 		return target;
 	};
+	const isExpandedReadTargetEnabled = (guildInfo, target, currentConversation) => {
+		const groupDmEnabled = accountConfig.dm?.groupEnabled === true && (currentConversation || resolveGroupDmAllow({
+			channels: accountConfig.dm?.groupChannels,
+			channelId: target.channelId,
+			channelName: target.channelName,
+			channelSlug: target.channelSlug
+		}));
+		if (!target.metadataKnown) return groupPolicy !== "disabled" && directDmEnabled && groupDmEnabled && !hasExplicitlyDisabledDiscordChannelConfig(guilds);
+		if (!target.guildId) {
+			if (target.channelType === ChannelType.GroupDM) return groupDmEnabled;
+			if (target.channelType === ChannelType.DM) return directDmEnabled;
+			return directDmEnabled && groupDmEnabled;
+		}
+		if (groupPolicy === "disabled") return false;
+		if (!isDiscordReadAncestryAllowed({
+			guildInfo,
+			target
+		})) return false;
+		const channelConfig = resolveDiscordChannelConfigWithFallback({
+			guildInfo,
+			channelId: target.channelId,
+			channelName: target.channelName,
+			channelSlug: target.channelSlug,
+			parentId: target.parentId,
+			parentName: target.parentName,
+			parentSlug: target.parentSlug,
+			scope: target.scope
+		});
+		return !channelConfig?.matchSource || channelConfig.allowed;
+	};
 	return {
 		action: params.action,
 		params: params.input,
@@ -285,11 +451,12 @@ function createDiscordMessagingActionContext(params) {
 		resolveChannelId: () => discordMessagingActionRuntime.resolveDiscordChannelId(readStringParam(params.input, "channelId", { required: true })),
 		assertReadTargetAllowed: async ({ guildId, channelId }) => {
 			const targetChannelId = discordMessagingActionRuntime.resolveDiscordChannelId(channelId);
-			if (!hasGuildEntries && groupPolicy !== "disabled" && groupPolicy !== "allowlist") return;
 			const target = await resolveReadTargetContext(targetChannelId);
+			const currentConversation = isCurrentReadTarget(targetChannelId);
 			if (guildId) {
-				if (target.guildId && target.guildId !== guildId) throw new Error("Discord read target channel is not allowed.");
+				if (target.metadataKnown && target.guildId !== guildId) throw new Error("Discord read target channel is not allowed.");
 				const guildInfo = await resolveReadGuildEntry(guildId);
+				if (directOperator && isExpandedReadTargetEnabled(guildInfo, target, false) || currentConversation && isExpandedReadTargetEnabled(guildInfo, target, true)) return;
 				if (!isDiscordReadTargetAllowedInGuild({
 					groupPolicy,
 					guildInfo,
@@ -299,6 +466,7 @@ function createDiscordMessagingActionContext(params) {
 			}
 			if (target.guildId) {
 				const guildInfo = await resolveReadGuildEntry(target.guildId);
+				if (directOperator && isExpandedReadTargetEnabled(guildInfo, target, false) || currentConversation && isExpandedReadTargetEnabled(guildInfo, target, true)) return;
 				if (!isDiscordReadTargetAllowedInGuild({
 					groupPolicy,
 					guildInfo,
@@ -306,14 +474,17 @@ function createDiscordMessagingActionContext(params) {
 				})) throw new Error("Discord read target channel is not allowed.");
 				return;
 			}
-			if (!Object.values(guilds ?? {}).some((guildInfo) => isDiscordReadTargetExplicitlyAllowedById({
+			const allowed = !target.metadataKnown && Object.values(guilds ?? {}).some((guildInfo) => isDiscordReadTargetAllowedInGuild({
 				groupPolicy,
 				guildInfo: guildInfo ?? null,
 				target
-			}))) throw new Error("Discord read target channel is not allowed.");
+			}));
+			if (directOperator && isExpandedReadTargetEnabled(null, target, false) || currentConversation && isExpandedReadTargetEnabled(null, target, true)) return;
+			if (!allowed) throw new Error("Discord read target channel is not allowed.");
 		},
-		assertGuildReadTargetAllowed: async ({ guildId, channelTargetRequiredMessage }) => {
+		assertGuildReadTargetAllowed: async ({ guildId, channelTargetRequiredMessage, filteredResults }) => {
 			const guildInfo = await resolveReadGuildEntry(guildId);
+			if (directOperator && groupPolicy !== "disabled" && (filteredResults === true || !hasExplicitlyDisabledDiscordChannels(guildInfo?.channels))) return;
 			if (!isDiscordGroupAllowedByPolicy({
 				groupPolicy,
 				guildAllowlisted: Boolean(guildInfo),
@@ -322,6 +493,61 @@ function createDiscordMessagingActionContext(params) {
 			})) throw new Error("Discord read target channel is not allowed.");
 			if (hasDiscordGuildEntries(guildInfo?.channels) && !allowsAllDiscordGuildChannels(guildInfo.channels)) throw new Error(channelTargetRequiredMessage ?? "Discord message search requires channelId or channelIds so each read target can be authorized.");
 		},
+		filterGuildChannelList: async ({ guildId, channels }) => {
+			if (!directOperator) return channels;
+			const guildInfo = await resolveReadGuildEntry(guildId);
+			const channelById = new Map(channels.flatMap((channel) => {
+				const channelId = readDiscordChannelStringField(channel, "id");
+				return channelId ? [[channelId, channel]] : [];
+			}));
+			const visibleChannels = [];
+			for (const channel of channels) {
+				const channelId = readDiscordChannelStringField(channel, "id");
+				if (!channelId) continue;
+				const channelName = readDiscordChannelStringField(channel, "name");
+				const channelType = readDiscordChannelType(channel);
+				const target = {
+					channelId,
+					channelSlug: channelName ? normalizeDiscordSlug(channelName) : channelId,
+					guildId,
+					metadataKnown: true,
+					ancestryComplete: true,
+					ancestors: [],
+					...channelName ? { channelName } : {},
+					...channelType !== void 0 ? { channelType } : {},
+					...isDiscordThreadChannel(channel) ? { scope: "thread" } : {}
+				};
+				const ancestry = await resolveDiscordReadAncestry({
+					channelId,
+					parentId: readDiscordChannelStringField(channel, "parent_id", "parentId"),
+					loadChannel: async (parentId) => channelById.get(parentId)
+				});
+				target.ancestors = ancestry.ancestors;
+				target.ancestryComplete = ancestry.complete;
+				const immediateParent = target.ancestors[0];
+				if (immediateParent) {
+					target.parentId = immediateParent.channelId;
+					if (immediateParent.channelName) target.parentName = immediateParent.channelName;
+					target.parentSlug = immediateParent.channelSlug;
+				}
+				if (!isDiscordReadAncestryAllowed({
+					guildInfo,
+					target
+				})) continue;
+				const channelConfig = resolveDiscordChannelConfigWithFallback({
+					guildInfo,
+					channelId,
+					channelName,
+					channelSlug: target.channelSlug,
+					parentId: target.parentId,
+					parentName: target.parentName,
+					parentSlug: target.parentSlug,
+					scope: target.scope
+				});
+				if (!channelConfig?.matchSource || channelConfig.allowed) visibleChannels.push(channel);
+			}
+			return visibleChannels;
+		},
 		resolveReactionChannelId: async () => {
 			const target = readStringParam(params.input, "channelId") ?? readStringParam(params.input, "to", { required: true });
 			return await discordMessagingActionRuntime.resolveDiscordReactionTargetChannelId({
@@ -343,31 +569,6 @@ function createDiscordMessagingActionContext(params) {
 }
 //#endregion
 //#region extensions/discord/src/actions/runtime.guild.ts
-const discordGuildActionRuntime = {
-	addRoleDiscord,
-	canManageGuildRoleDiscord,
-	canManageGuildMemberRoleDiscord,
-	createChannelDiscord,
-	createScheduledEventDiscord,
-	resolveEventCoverImage,
-	deleteChannelDiscord,
-	editChannelDiscord,
-	fetchChannelInfoDiscord,
-	fetchMemberInfoDiscord,
-	hasAnyChannelPermissionDiscord,
-	hasAnyGuildPermissionDiscord,
-	fetchRoleInfoDiscord,
-	fetchVoiceStatusDiscord,
-	listGuildChannelsDiscord,
-	listGuildEmojisDiscord,
-	listScheduledEventsDiscord,
-	moveChannelDiscord,
-	removeChannelPermissionDiscord,
-	removeRoleDiscord,
-	setChannelPermissionDiscord,
-	uploadEmojiDiscord,
-	uploadStickerDiscord
-};
 const expressionPermissions = [
 	PermissionFlagsBits.ManageGuildExpressions,
 	PermissionFlagsBits.CreateGuildExpressions,
@@ -533,9 +734,10 @@ async function handleDiscordGuildAction(action, params, isActionEnabled, cfg, op
 		accountId,
 		extra
 	});
-	const assertGuildMetadataReadAllowed = async (guildId) => {
+	const assertGuildMetadataReadAllowed = async (guildId, readOptions) => {
 		await readTargetGate.assertGuildReadTargetAllowed({
 			guildId,
+			filteredResults: readOptions?.filteredResults,
 			channelTargetRequiredMessage: "Discord guild metadata reads require a wildcard channel allowlist for this guild."
 		});
 	};
@@ -644,10 +846,14 @@ async function handleDiscordGuildAction(action, params, isActionEnabled, cfg, op
 		case "channelList": {
 			if (!isActionEnabled("channelInfo")) throw new Error("Discord channel info is disabled.");
 			const guildId = readStringParam(params, "guildId", { required: true });
-			await assertGuildMetadataReadAllowed(guildId);
+			await assertGuildMetadataReadAllowed(guildId, { filteredResults: true });
+			const channels = await discordGuildActionRuntime.listGuildChannelsDiscord(guildId, withOpts());
 			return jsonResult({
 				ok: true,
-				channels: await discordGuildActionRuntime.listGuildChannelsDiscord(guildId, withOpts())
+				channels: await readTargetGate.filterGuildChannelList({
+					guildId,
+					channels
+				})
 			});
 		}
 		case "voiceStatus": {
@@ -850,6 +1056,7 @@ async function handleDiscordMessageManagementAction(ctx) {
 			};
 			return jsonResult({
 				ok: true,
+				channelId,
 				messages: assertDiscordMessageListResult(await discordMessagingActionRuntime.readMessagesDiscord(channelId, query, ctx.withOpts())).map((message) => ctx.normalizeMessage(message))
 			});
 		}
@@ -858,6 +1065,7 @@ async function handleDiscordMessageManagementAction(ctx) {
 			const channelId = ctx.resolveChannelId();
 			const messageId = readStringParam(ctx.params, "messageId", { required: true });
 			const content = readStringParam(ctx.params, "content", { required: true });
+			await ctx.assertReadTargetAllowed({ channelId });
 			return jsonResult({
 				ok: true,
 				message: await discordMessagingActionRuntime.editMessageDiscord(channelId, messageId, { content }, ctx.withOpts())
@@ -867,6 +1075,7 @@ async function handleDiscordMessageManagementAction(ctx) {
 			if (!ctx.isActionEnabled("messages")) throw new Error("Discord message deletes are disabled.");
 			const channelId = ctx.resolveChannelId();
 			const messageId = readStringParam(ctx.params, "messageId", { required: true });
+			await ctx.assertReadTargetAllowed({ channelId });
 			await discordMessagingActionRuntime.deleteMessageDiscord(channelId, messageId, ctx.withOpts());
 			return jsonResult({ ok: true });
 		}
@@ -874,6 +1083,7 @@ async function handleDiscordMessageManagementAction(ctx) {
 			if (!ctx.isActionEnabled("pins")) throw new Error("Discord pins are disabled.");
 			const channelId = ctx.resolveChannelId();
 			const messageId = readStringParam(ctx.params, "messageId", { required: true });
+			await ctx.assertReadTargetAllowed({ channelId });
 			await discordMessagingActionRuntime.pinMessageDiscord(channelId, messageId, ctx.withOpts());
 			return jsonResult({ ok: true });
 		}
@@ -881,6 +1091,7 @@ async function handleDiscordMessageManagementAction(ctx) {
 			if (!ctx.isActionEnabled("pins")) throw new Error("Discord pins are disabled.");
 			const channelId = ctx.resolveChannelId();
 			const messageId = readStringParam(ctx.params, "messageId", { required: true });
+			await ctx.assertReadTargetAllowed({ channelId });
 			await discordMessagingActionRuntime.unpinMessageDiscord(channelId, messageId, ctx.withOpts());
 			return jsonResult({ ok: true });
 		}
@@ -957,16 +1168,21 @@ async function handleDiscordReactionMessagingAction(ctx) {
 			const messageId = readStringParam(ctx.params, "messageId", { required: true });
 			const { emoji, remove, isEmpty } = readReactionParams(ctx.params, { removeErrorMessage: "Emoji is required to remove a Discord reaction." });
 			if (remove) {
+				await ctx.assertReadTargetAllowed({ channelId });
 				await discordMessagingActionRuntime.removeReactionDiscord(channelId, messageId, emoji, ctx.withReactionRuntimeOptions());
 				return jsonResult({
 					ok: true,
 					removed: emoji
 				});
 			}
-			if (isEmpty) return jsonResult({
-				ok: true,
-				removed: (await discordMessagingActionRuntime.removeOwnReactionsDiscord(channelId, messageId, ctx.withReactionRuntimeOptions())).removed
-			});
+			if (isEmpty) {
+				await ctx.assertReadTargetAllowed({ channelId });
+				return jsonResult({
+					ok: true,
+					removed: (await discordMessagingActionRuntime.removeOwnReactionsDiscord(channelId, messageId, ctx.withReactionRuntimeOptions())).removed
+				});
+			}
+			await ctx.assertReadTargetAllowed({ channelId });
 			await discordMessagingActionRuntime.reactMessageDiscord(channelId, messageId, emoji, ctx.withReactionRuntimeOptions());
 			return jsonResult({
 				ok: true,
@@ -1194,7 +1410,7 @@ async function handleDiscordMessageSendAction(ctx) {
 			const payload = {
 				name,
 				messageId,
-				autoArchiveMinutes: readPositiveIntegerParam(ctx.params, "autoArchiveMinutes"),
+				autoArchiveMinutes: readDiscordAutoArchiveDurationParam(ctx.params, "autoArchiveMinutes"),
 				content,
 				appliedTags: readStringArrayParam(ctx.params, "appliedTags") ?? void 0
 			};
@@ -1309,12 +1525,6 @@ function readDiscordModerationCommand(action, params) {
 }
 //#endregion
 //#region extensions/discord/src/actions/runtime.moderation.ts
-const discordModerationActionRuntime = {
-	banMemberDiscord,
-	hasAnyGuildPermissionDiscord,
-	kickMemberDiscord,
-	timeoutMemberDiscord
-};
 async function verifySenderModerationPermission(params) {
 	if (!params.senderUserId) return;
 	if (!await discordModerationActionRuntime.hasAnyGuildPermissionDiscord(params.guildId, params.senderUserId, [params.requiredPermission], createDiscordActionOptions({
@@ -1493,4 +1703,4 @@ async function handleDiscordAction(params, cfg, options) {
 	throw new Error(`Unknown action: ${action}`);
 }
 //#endregion
-export { readDiscordChannelCreateParams as a, readDiscordParentIdParam as c, requiredGuildPermissionForModerationAction as i, isDiscordModerationAction as n, readDiscordChannelEditParams as o, readDiscordModerationCommand as r, readDiscordChannelMoveParams as s, handleDiscordAction as t };
+export { readDiscordAutoArchiveDurationParam as a, readDiscordChannelMoveParams as c, requiredGuildPermissionForModerationAction as i, readDiscordParentIdParam as l, isDiscordModerationAction as n, readDiscordChannelCreateParams as o, readDiscordModerationCommand as r, readDiscordChannelEditParams as s, handleDiscordAction as t };

package/dist/runtime-CCf5nkV3.js

@@ -0,0 +1,84 @@
+import { n as isDiscordAccountEnabledForRuntime, r as listDiscordAccountIds, s as resolveDiscordAccount } from "./accounts-CMd4nzLB.js";
+import { G as resolveDiscordProxyFetchForAccount } from "./send.shared-XuOTO1dW.js";
+//#region extensions/discord/src/activities/config.ts
+function readNonEmpty(value) {
+	return value?.trim() || void 0;
+}
+function resolveDiscordActivitiesConfig(account, env = process.env) {
+	if (!account.activities) return {
+		enabled: false,
+		reason: "not-configured"
+	};
+	const clientSecret = readNonEmpty(account.activities.clientSecret) ?? readNonEmpty(env.DISCORD_CLIENT_SECRET);
+	if (!clientSecret) return {
+		enabled: false,
+		reason: "missing-client-secret"
+	};
+	const applicationId = readNonEmpty(account.activities.applicationId);
+	return {
+		enabled: true,
+		clientSecret,
+		...applicationId ? { applicationId } : {}
+	};
+}
+//#endregion
+//#region extensions/discord/src/activities/runtime.ts
+var DiscordActivitiesRuntime = class {
+	constructor(store, startupConfig, getCurrentConfig, env = process.env) {
+		this.store = store;
+		this.startupConfig = startupConfig;
+		this.getCurrentConfig = getCurrentConfig;
+		this.env = env;
+		this.learnedApplicationIds = /* @__PURE__ */ new Map();
+	}
+	currentConfig() {
+		return this.getCurrentConfig?.() ?? this.startupConfig;
+	}
+	registerApplicationId(accountId, applicationId) {
+		const trimmed = applicationId.trim();
+		if (trimmed) this.learnedApplicationIds.set(accountId, trimmed);
+	}
+	resolveAccount(accountId, cfg = this.currentConfig()) {
+		const account = resolveDiscordAccount({
+			cfg,
+			accountId
+		});
+		if (!isDiscordAccountEnabledForRuntime(account, cfg)) return null;
+		const activities = resolveDiscordActivitiesConfig(account.config, this.env);
+		if (!activities.enabled) return null;
+		const applicationId = activities.applicationId ?? this.learnedApplicationIds.get(account.accountId) ?? account.config.applicationId?.trim();
+		if (!applicationId) return null;
+		const { clientSecret } = activities;
+		const bot = account.token.trim();
+		return {
+			accountId: account.accountId,
+			applicationId,
+			botAuth: bot,
+			clientSecret,
+			config: account.config,
+			proxyFetch: resolveDiscordProxyFetchForAccount(account, cfg)
+		};
+	}
+	resolveHttpAccount(applicationId) {
+		const cfg = this.currentConfig();
+		const accounts = listDiscordAccountIds(cfg).map((accountId) => this.resolveAccount(accountId, cfg)).filter((account) => account !== null);
+		if (applicationId) return accounts.find((account) => account.applicationId === applicationId) ?? null;
+		return accounts.length === 1 ? accounts[0] ?? null : null;
+	}
+	isAccountEnabled(accountId, cfg = this.currentConfig()) {
+		const account = resolveDiscordAccount({
+			cfg,
+			accountId
+		});
+		return isDiscordAccountEnabledForRuntime(account, cfg) && resolveDiscordActivitiesConfig(account.config, this.env).enabled;
+	}
+};
+let activeRuntime;
+function setDiscordActivitiesRuntime(runtime) {
+	activeRuntime = runtime;
+}
+function getDiscordActivitiesRuntime() {
+	return activeRuntime;
+}
+//#endregion
+export { resolveDiscordActivitiesConfig as i, getDiscordActivitiesRuntime as n, setDiscordActivitiesRuntime as r, DiscordActivitiesRuntime as t };

package/dist/runtime-api.actions.js

@@ -1,3 +1,3 @@
-import { a as readDiscordChannelCreateParams, c as readDiscordParentIdParam, i as requiredGuildPermissionForModerationAction, n as isDiscordModerationAction, o as readDiscordChannelEditParams, r as readDiscordModerationCommand, s as readDiscordChannelMoveParams, t as handleDiscordAction } from "./runtime-C6rRmQ6l.js";
-import { t as discordMessageActions } from "./channel-actions-D_fjVUZ_.js";
+import { c as readDiscordChannelMoveParams, i as requiredGuildPermissionForModerationAction, l as readDiscordParentIdParam, n as isDiscordModerationAction, o as readDiscordChannelCreateParams, r as readDiscordModerationCommand, s as readDiscordChannelEditParams, t as handleDiscordAction } from "./runtime-BsefAQ9q.js";
+import { t as discordMessageActions } from "./channel-actions-BQct-o4T.js";
 export { discordMessageActions, handleDiscordAction, isDiscordModerationAction, readDiscordChannelCreateParams, readDiscordChannelEditParams, readDiscordChannelMoveParams, readDiscordModerationCommand, readDiscordParentIdParam, requiredGuildPermissionForModerationAction };