@openclaw/discord 2026.8.2 → 2026.8.34

package/dist/.setup/channel-actions.runtime-BN2Bo6so.mjs

@@ -0,0 +1,322 @@
+import { _ as parseDiscordTarget, v as resolveDiscordChannelId } from "./retry-BtpfSmcV.mjs";
+import { i as buildDiscordPresentationComponents, m as coerceDiscordComponentParam, r as buildDiscordInteractiveComponents } from "./components-CoCQebYz.mjs";
+import { a as readDiscordAutoArchiveDurationParam, t as handleDiscordAction } from "./runtime-BYnanhCN.mjs";
+import "./targets-ueZDqOW4.mjs";
+import "../action-runtime-api.js";
+import { h as discordInboundEventDelivery } from "./outbound-session-route-0ulhwPFj.mjs";
+import { r as isDiscordComponentSpecWithinMessageLimit, t as DISCORD_PRESENTATION_CAPABILITIES } from "./outbound-components-BBZ6nUHC.mjs";
+import { t as tryHandleDiscordMessageActionGuildAdmin } from "./handle-action.guild-admin-DlRmtY7d.mjs";
+import { n as notifyDiscordActiveTurnThreadCreated, r as notifyDiscordActiveTurnThreadReplyDelivered } from "./active-turn-thread-route-fmHl1HNd.mjs";
+import { normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { adaptMessagePresentationForChannel, normalizeLegacyInteractiveReply, normalizeMessagePresentation, renderMessagePresentationFallbackText } from "openclaw/plugin-sdk/interactive-runtime";
+import { resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
+import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
+import { readPositiveIntegerParam as readPositiveIntegerParam$1, readStringArrayParam as readStringArrayParam$1, readStringParam as readStringParam$1 } from "openclaw/plugin-sdk/agent-runtime";
+//#region extensions/discord/src/actions/handle-action.ts
+const providerId = "discord";
+function withCurrentSourceReplyRoute(result) {
+	const details = result.details && typeof result.details === "object" && !Array.isArray(result.details) ? result.details : {};
+	return {
+		...result,
+		details: {
+			...details,
+			sourceReplyRoute: "current-source"
+		}
+	};
+}
+function readCurrentDiscordTarget(toolContext) {
+	const provider = toolContext?.currentChannelProvider?.trim().toLowerCase();
+	if (provider && provider !== providerId) return;
+	return toolContext?.currentChannelId?.trim() || void 0;
+}
+async function handleDiscordMessageAction(ctx) {
+	const { action, params, cfg } = ctx;
+	const accountId = ctx.accountId ?? readStringParam$1(params, "accountId");
+	const readContext = ctx.requesterAccountId && ctx.toolContext?.currentChannelProvider && ctx.toolContext.currentChannelId ? {
+		requesterAccountId: ctx.requesterAccountId,
+		currentChannelProvider: ctx.toolContext.currentChannelProvider,
+		currentChannelId: ctx.toolContext.currentChannelId
+	} : void 0;
+	const readPolicyOptions = ctx.conversationReadOrigin || readContext ? {
+		...ctx.conversationReadOrigin ? { conversationReadOrigin: ctx.conversationReadOrigin } : {},
+		...readContext ? { readContext } : {}
+	} : void 0;
+	const actionOptions = {
+		mediaAccess: ctx.mediaAccess,
+		mediaLocalRoots: ctx.mediaLocalRoots,
+		mediaReadFile: ctx.mediaReadFile,
+		...ctx.reply ? { reply: ctx.reply } : {},
+		...readPolicyOptions
+	};
+	const notifyVisibleOutbound = (result, to, fallbackSessionKey) => {
+		if ((result.details && typeof result.details === "object" && !Array.isArray(result.details) ? result.details : void 0)?.ok !== true) return;
+		discordInboundEventDelivery.notify({
+			sessionKey: ctx.sessionKey ?? fallbackSessionKey ?? void 0,
+			to,
+			accountId,
+			inboundEventKind: ctx.inboundEventKind
+		});
+	};
+	const withAdoptedThreadReplyRoute = (result, to, fallbackSessionKey) => {
+		if ((result.details && typeof result.details === "object" && !Array.isArray(result.details) ? result.details : void 0)?.ok !== true) return result;
+		let target;
+		try {
+			target = parseDiscordTarget(to, { defaultKind: "channel" });
+		} catch {
+			return result;
+		}
+		if (target?.kind === "channel" && notifyDiscordActiveTurnThreadReplyDelivered({
+			sessionKey: ctx.sessionKey ?? fallbackSessionKey,
+			accountId,
+			threadId: target.id
+		})) return withCurrentSourceReplyRoute(result);
+		return result;
+	};
+	const readTarget = () => {
+		const target = readStringParam$1(params, "channelId") ?? readStringParam$1(params, "to") ?? readCurrentDiscordTarget(ctx.toolContext);
+		if (!target) throw new Error("Discord channel target is required (use channel:<id>).");
+		return target;
+	};
+	const resolveChannelId = () => resolveDiscordChannelId(readTarget());
+	const readSendTarget = () => {
+		const target = readStringParam$1(params, "to") ?? readStringParam$1(params, "target") ?? readCurrentDiscordTarget(ctx.toolContext);
+		if (!target) throw new Error("Discord channel target is required (use channel:<id>).");
+		return target;
+	};
+	if (action === "send") {
+		const to = readSendTarget();
+		const asVoice = readBooleanParam(params, "asVoice") === true;
+		const mediaUrl = readStringParam$1(params, "media", { trim: false }) ?? readStringParam$1(params, "path", { trim: false }) ?? readStringParam$1(params, "filePath", { trim: false });
+		const requestedContent = readStringParam$1(params, "message", { allowEmpty: true });
+		const explicitComponents = coerceDiscordComponentParam(params.components);
+		const presentation = explicitComponents == null ? normalizeMessagePresentation(params.presentation) : void 0;
+		const adaptedPresentation = presentation ? adaptMessagePresentationForChannel({
+			presentation,
+			capabilities: DISCORD_PRESENTATION_CAPABILITIES
+		}) : void 0;
+		const generatedPresentationComponents = buildDiscordPresentationComponents(adaptedPresentation);
+		const presentationComponents = generatedPresentationComponents && isDiscordComponentSpecWithinMessageLimit({
+			spec: generatedPresentationComponents,
+			fallbackText: requestedContent,
+			includesMedia: Boolean(mediaUrl)
+		}) ? generatedPresentationComponents : void 0;
+		const presentationFellBack = Boolean(generatedPresentationComponents && !presentationComponents);
+		const rawComponents = presentationFellBack ? void 0 : explicitComponents ?? presentationComponents ?? buildDiscordInteractiveComponents(normalizeLegacyInteractiveReply(params.interactive));
+		const hasComponents = Boolean(rawComponents) && (typeof rawComponents === "function" || typeof rawComponents === "object");
+		const components = hasComponents ? rawComponents : void 0;
+		const rawEmbeds = params.embeds;
+		const embeds = Array.isArray(rawEmbeds) ? rawEmbeds : void 0;
+		const content = readStringParam$1(params, "message", {
+			required: !asVoice && !hasComponents && !embeds?.length && !mediaUrl && !presentationFellBack,
+			allowEmpty: true
+		});
+		const deliveryContent = presentationFellBack && presentation ? renderMessagePresentationFallbackText({
+			text: content,
+			presentation
+		}) : content;
+		const filename = readStringParam$1(params, "filename");
+		const replyTo = readStringParam$1(params, "replyTo");
+		const silent = readBooleanParam(params, "silent") === true;
+		const suppressEmbeds = readBooleanParam(params, "suppressEmbeds");
+		const sessionKey = readStringParam$1(params, "__sessionKey");
+		const agentId = readStringParam$1(params, "__agentId");
+		const threadName = readStringParam$1(params, "threadName");
+		const result = await handleDiscordAction({
+			action: "sendMessage",
+			accountId: accountId ?? void 0,
+			to,
+			content: deliveryContent ?? "",
+			...threadName ? { threadName } : {},
+			mediaUrl: mediaUrl ?? void 0,
+			filename: filename ?? void 0,
+			replyTo: replyTo ?? void 0,
+			components,
+			embeds,
+			asVoice,
+			silent,
+			...suppressEmbeds === void 0 ? {} : { suppressEmbeds },
+			__sessionKey: sessionKey ?? void 0,
+			__agentId: agentId ?? void 0
+		}, cfg, actionOptions);
+		notifyVisibleOutbound(result, to, sessionKey);
+		return withAdoptedThreadReplyRoute(result, to, sessionKey);
+	}
+	if (action === "upload-file") {
+		const to = readSendTarget();
+		const mediaUrl = readStringParam$1(params, "filePath", { trim: false }) ?? readStringParam$1(params, "path", { trim: false }) ?? readStringParam$1(params, "media", { trim: false });
+		if (!mediaUrl) {
+			if (readStringParam$1(params, "buffer", { trim: false })) throw new Error("Use action: \"send\" for base64 buffer attachments; upload-file requires filePath, path, or media.");
+			throw new Error("upload-file requires filePath, path, or media.");
+		}
+		const content = readStringParam$1(params, "message", { allowEmpty: true }) ?? readStringParam$1(params, "content", { allowEmpty: true }) ?? readStringParam$1(params, "caption", { allowEmpty: true });
+		const filename = readStringParam$1(params, "filename");
+		const replyTo = readStringParam$1(params, "replyTo");
+		const silent = readBooleanParam(params, "silent") === true;
+		const suppressEmbeds = readBooleanParam(params, "suppressEmbeds");
+		const sessionKey = readStringParam$1(params, "__sessionKey");
+		const agentId = readStringParam$1(params, "__agentId");
+		const result = await handleDiscordAction({
+			action: "sendMessage",
+			accountId: accountId ?? void 0,
+			to,
+			content: content ?? "",
+			mediaUrl,
+			filename: filename ?? void 0,
+			replyTo: replyTo ?? void 0,
+			silent,
+			...suppressEmbeds === void 0 ? {} : { suppressEmbeds },
+			__sessionKey: sessionKey ?? void 0,
+			__agentId: agentId ?? void 0
+		}, cfg, actionOptions);
+		notifyVisibleOutbound(result, to, sessionKey);
+		return withAdoptedThreadReplyRoute(result, to, sessionKey);
+	}
+	if (action === "react") {
+		const messageIdRaw = resolveReactionMessageId({
+			args: params,
+			toolContext: ctx.toolContext
+		});
+		const messageId = normalizeOptionalStringifiedId(messageIdRaw) ?? "";
+		if (!messageId) throw new Error("messageId required. Provide messageId explicitly or react to the current inbound message.");
+		const emoji = readStringParam$1(params, "emoji", { allowEmpty: true });
+		const remove = readBooleanParam(params, "remove");
+		return await handleDiscordAction({
+			action: "react",
+			accountId: accountId ?? void 0,
+			channelId: readTarget(),
+			messageId,
+			emoji,
+			remove
+		}, cfg, actionOptions);
+	}
+	if (action === "reactions") {
+		const messageId = readStringParam$1(params, "messageId", { required: true });
+		const limit = readPositiveIntegerParam$1(params, "limit");
+		return await handleDiscordAction({
+			action: "reactions",
+			accountId: accountId ?? void 0,
+			channelId: readTarget(),
+			messageId,
+			limit
+		}, cfg, actionOptions);
+	}
+	if (action === "read") {
+		const limit = readPositiveIntegerParam$1(params, "limit");
+		return await handleDiscordAction({
+			action: "readMessages",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			limit,
+			before: readStringParam$1(params, "before"),
+			after: readStringParam$1(params, "after"),
+			around: readStringParam$1(params, "around")
+		}, cfg, actionOptions);
+	}
+	if (action === "edit") {
+		const messageId = readStringParam$1(params, "messageId", { required: true });
+		const content = readStringParam$1(params, "message", { required: true });
+		return await handleDiscordAction({
+			action: "editMessage",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId,
+			content
+		}, cfg, actionOptions);
+	}
+	if (action === "delete") {
+		const messageId = readStringParam$1(params, "messageId", { required: true });
+		return await handleDiscordAction({
+			action: "deleteMessage",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId
+		}, cfg, actionOptions);
+	}
+	if (action === "pin" || action === "unpin" || action === "list-pins") {
+		const messageId = action === "list-pins" ? void 0 : readStringParam$1(params, "messageId", { required: true });
+		return await handleDiscordAction({
+			action: action === "pin" ? "pinMessage" : action === "unpin" ? "unpinMessage" : "listPins",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId
+		}, cfg, actionOptions);
+	}
+	if (action === "permissions") return await handleDiscordAction({
+		action: "permissions",
+		accountId: accountId ?? void 0,
+		channelId: resolveChannelId()
+	}, cfg, actionOptions);
+	if (action === "thread-create") {
+		const name = readStringParam$1(params, "threadName", { required: true });
+		const messageId = readStringParam$1(params, "messageId");
+		const content = readStringParam$1(params, "message");
+		const autoArchiveMinutes = readDiscordAutoArchiveDurationParam(params, "autoArchiveMin");
+		const appliedTags = readStringArrayParam$1(params, "appliedTags");
+		const result = await handleDiscordAction({
+			action: "threadCreate",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			name,
+			messageId,
+			content,
+			autoArchiveMinutes,
+			appliedTags: appliedTags ?? void 0
+		}, cfg, actionOptions);
+		const details = result.details && typeof result.details === "object" && !Array.isArray(result.details) ? result.details : void 0;
+		if (details?.ok === true) {
+			const threadId = typeof details.thread?.id === "string" ? details.thread.id : void 0;
+			await notifyDiscordActiveTurnThreadCreated({
+				sessionKey: ctx.sessionKey,
+				accountId,
+				sourceChannelId: resolveChannelId(),
+				sourceMessageId: messageId,
+				threadId
+			});
+		}
+		notifyVisibleOutbound(result, resolveChannelId());
+		return result;
+	}
+	if (action === "sticker") {
+		const to = readStringParam$1(params, "to", { required: true });
+		const stickerIds = readStringArrayParam$1(params, "stickerId", {
+			required: true,
+			label: "sticker-id"
+		}) ?? [];
+		const result = await handleDiscordAction({
+			action: "sticker",
+			accountId: accountId ?? void 0,
+			to,
+			stickerIds,
+			content: readStringParam$1(params, "message"),
+			...readBooleanParam(params, "silent") === true ? { silent: true } : {}
+		}, cfg, actionOptions);
+		notifyVisibleOutbound(result, to);
+		return result;
+	}
+	if (action === "set-presence") return await handleDiscordAction({
+		action: "setPresence",
+		accountId: accountId ?? void 0,
+		status: readStringParam$1(params, "status"),
+		activityType: readStringParam$1(params, "activityType"),
+		activityName: readStringParam$1(params, "activityName"),
+		activityUrl: readStringParam$1(params, "activityUrl"),
+		activityState: readStringParam$1(params, "activityState")
+	}, cfg, actionOptions);
+	const adminResult = await tryHandleDiscordMessageActionGuildAdmin({
+		ctx,
+		resolveChannelId,
+		readPolicyOptions,
+		actionOptions
+	});
+	if (adminResult !== void 0) {
+		if (action === "thread-reply") {
+			const threadId = readStringParam$1(params, "threadId") ?? readTarget();
+			notifyVisibleOutbound(adminResult, threadId);
+			return withAdoptedThreadReplyRoute(adminResult, threadId);
+		}
+		return adminResult;
+	}
+	throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
+}
+//#endregion
+export { handleDiscordMessageAction };

package/dist/.setup/channel-type-CGDUPxwc.mjs

@@ -0,0 +1,19 @@
+import { ChannelType } from "discord-api-types/v10";
+import { asFiniteNumberInRange, parseStrictFiniteNumber } from "openclaw/plugin-sdk/number-runtime";
+//#region extensions/discord/src/retry-after.ts
+const RETRY_AFTER_BODY_SECONDS_RE = /^(?:\d+\.?\d*|\.\d+)$/;
+const MAX_SAFE_RETRY_AFTER_SECONDS = Number.MAX_SAFE_INTEGER / 1e3;
+function parseDiscordRetryAfterBodySeconds(value) {
+	const seconds = typeof value === "number" ? value : typeof value === "string" && RETRY_AFTER_BODY_SECONDS_RE.test(value.trim()) ? parseStrictFiniteNumber(value.trim()) : void 0;
+	return asFiniteNumberInRange(seconds, {
+		min: 0,
+		max: MAX_SAFE_RETRY_AFTER_SECONDS
+	});
+}
+//#endregion
+//#region extensions/discord/src/channel-type.ts
+function isDiscordThreadChannelType(channelType) {
+	return channelType === ChannelType.AnnouncementThread || channelType === ChannelType.PublicThread || channelType === ChannelType.PrivateThread;
+}
+//#endregion
+export { parseDiscordRetryAfterBodySeconds as n, isDiscordThreadChannelType as t };

package/dist/.setup/channel.setup-Bur0l9L5.mjs

@@ -0,0 +1,301 @@
+import { _ as inspectDiscordAccountTokenState, h as resolveDiscordToken, l as resolveDiscordAccountAllowFrom, o as mergeDiscordAccountConfig, s as resolveDefaultDiscordAccountId, u as resolveDiscordAccountConfig } from "./accounts-CwJQoLjM.mjs";
+import { i as discordSetupContract, t as createDiscordPluginBase } from "./shared-DZqXK-Da.mjs";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-BKEOjdaq.mjs";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-4wQGN81h.mjs";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveBasicAllowFromEntries } from "openclaw/plugin-sdk/allow-from";
+import { createAccountScopedAllowFromSection, createAccountScopedGroupAccessSection, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, parseMentionOrPrefixedId, patchChannelConfigForAccount, promptResolvedAllowFrom, resolveEntriesWithOptionalToken, resolveSetupAccountId, setSetupChannelEnabled, splitSetupEntries } from "openclaw/plugin-sdk/setup-runtime";
+import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { createChannelDmPolicy } from "openclaw/plugin-sdk/channel-dm-policy";
+//#region extensions/discord/src/setup-account-state.ts
+function resolveDefaultDiscordSetupAccountId(cfg) {
+	return resolveDefaultDiscordAccountId(cfg);
+}
+function resolveDiscordSetupAccountConfig(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordSetupAccountId(params.cfg));
+	return {
+		accountId,
+		config: mergeDiscordAccountConfig(params.cfg, accountId)
+	};
+}
+function inspectDiscordSetupAccount(params) {
+	const { accountId, config } = resolveDiscordSetupAccountConfig(params);
+	const enabled = params.cfg.channels?.discord?.enabled !== false && config.enabled !== false;
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const hasAccountToken = Boolean(accountConfig && Object.hasOwn(accountConfig, "token"));
+	return inspectDiscordAccountTokenState({
+		base: {
+			accountId,
+			enabled
+		},
+		config,
+		accountToken: accountConfig?.token,
+		hasAccountToken,
+		channelToken: params.cfg.channels?.discord?.token,
+		resolveFallbackToken: () => resolveDiscordToken(params.cfg, { accountId })
+	});
+}
+//#endregion
+//#region extensions/discord/src/setup-core.ts
+const t$1 = createSetupTranslator();
+const channel$1 = "discord";
+const DISCORD_TOKEN_HELP_LINES = [
+	t$1("wizard.discord.tokenHelpCreateApplication"),
+	t$1("wizard.discord.tokenHelpCopyToken"),
+	t$1("wizard.discord.tokenHelpInviteBot"),
+	t$1("wizard.discord.tokenHelpMessageContentIntent"),
+	t$1("wizard.channels.docs", { link: formatDocsLink("/discord", "discord") })
+];
+function mapDiscordSetupAllowlistEntries(resolved) {
+	if (!Array.isArray(resolved)) return [];
+	return resolved.flatMap((entry) => {
+		if (!entry || typeof entry !== "object") return [];
+		const row = entry;
+		if (row.resolved === false) return [];
+		const guildKey = normalizeOptionalString(row.guildId ?? row.guildKey);
+		if (!guildKey) return [];
+		const channelKey = normalizeOptionalString(row.channelId ?? row.channelKey);
+		return channelKey ? [{
+			guildKey,
+			channelKey
+		}] : [{ guildKey }];
+	});
+}
+function setDiscordGuildChannelAllowlist(cfg, accountId, entries) {
+	const guilds = { ...accountId === DEFAULT_ACCOUNT_ID ? cfg.channels?.discord?.guilds ?? {} : cfg.channels?.discord?.accounts?.[accountId]?.guilds ?? {} };
+	for (const entry of entries) {
+		const guildKey = entry.guildKey || "*";
+		const existing = guilds[guildKey] ?? {};
+		if (entry.channelKey) {
+			const channels = { ...existing.channels };
+			channels[entry.channelKey] = { enabled: true };
+			guilds[guildKey] = {
+				...existing,
+				channels
+			};
+		} else guilds[guildKey] = existing;
+	}
+	return patchChannelConfigForAccount({
+		cfg,
+		channel: channel$1,
+		accountId,
+		patch: { guilds }
+	});
+}
+function parseDiscordAllowFromId(value) {
+	return parseMentionOrPrefixedId({
+		value,
+		mentionPattern: /^<@!?(\d+)>$/,
+		prefixPattern: /^(user:|discord:)/i,
+		idPattern: /^\d+$/
+	});
+}
+function createDiscordSetupWizardBase(handlers) {
+	const discordDmPolicy = createChannelDmPolicy({
+		label: "Discord",
+		channel: channel$1,
+		resolveAccount: (cfg, accountId) => resolveDiscordSetupAccountConfig({
+			cfg,
+			accountId
+		}),
+		buildPatch: ({ account, policy, allowFrom }) => ({
+			dmPolicy: policy,
+			...allowFrom === void 0 ? {} : { allowFrom },
+			dm: {
+				...account.config.dm,
+				enabled: typeof account.config.dm?.enabled === "boolean" ? account.config.dm.enabled : true
+			}
+		}),
+		promptAllowFrom: handlers.promptAllowFrom
+	});
+	return {
+		channel: channel$1,
+		status: createStandardChannelSetupStatus({
+			channelLabel: "Discord",
+			configuredLabel: t$1("wizard.channels.statusConfigured"),
+			unconfiguredLabel: t$1("wizard.channels.statusNeedsToken"),
+			configuredHint: t$1("wizard.channels.statusConfigured"),
+			unconfiguredHint: t$1("wizard.channels.statusNeedsToken"),
+			configuredScore: 2,
+			unconfiguredScore: 1,
+			resolveConfigured: ({ cfg, accountId }) => inspectDiscordSetupAccount({
+				cfg,
+				accountId
+			}).configured
+		}),
+		credentials: [defineTokenCredential({
+			inputKey: "token",
+			configKey: "token",
+			providerHint: channel$1,
+			credentialLabel: t$1("wizard.discord.botToken"),
+			preferredEnvVar: "DISCORD_BOT_TOKEN",
+			helpTitle: t$1("wizard.discord.botToken"),
+			helpLines: DISCORD_TOKEN_HELP_LINES,
+			envPrompt: t$1("wizard.discord.tokenEnvPrompt"),
+			keepPrompt: t$1("wizard.discord.tokenKeepPrompt"),
+			inputPrompt: t$1("wizard.discord.tokenInputPrompt"),
+			allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+			resolveAccount: ({ cfg, accountId }) => inspectDiscordSetupAccount({
+				cfg,
+				accountId
+			}),
+			accountConfigured: (account) => account.configured,
+			hasConfiguredValue: (account) => account.tokenStatus !== "missing",
+			resolvedValue: (account) => normalizeOptionalString(account.token),
+			envValue: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID ? normalizeOptionalString(process.env.DISCORD_BOT_TOKEN) : void 0
+		})],
+		groupAccess: createAccountScopedGroupAccessSection({
+			channel: channel$1,
+			label: t$1("wizard.discord.channelsLabel"),
+			placeholder: "My Server/#general, guildId/channelId, #support",
+			currentPolicy: ({ cfg, accountId }) => resolveDiscordSetupAccountConfig({
+				cfg,
+				accountId
+			}).config.groupPolicy ?? "allowlist",
+			currentEntries: ({ cfg, accountId }) => Object.entries(resolveDiscordSetupAccountConfig({
+				cfg,
+				accountId
+			}).config.guilds ?? {}).flatMap(([guildKey, value]) => {
+				const channels = value?.channels ?? {};
+				const channelKeys = Object.keys(channels);
+				if (channelKeys.length === 0) return [/^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey];
+				return channelKeys.map((channelKey) => `${guildKey}/${channelKey}`);
+			}),
+			updatePrompt: ({ cfg, accountId }) => Boolean(resolveDiscordSetupAccountConfig({
+				cfg,
+				accountId
+			}).config.guilds),
+			resolveAllowlist: handlers.resolveGroupAllowlist,
+			fallbackResolved: (entries) => entries.map((input) => ({
+				input,
+				resolved: false
+			})),
+			applyAllowlist: ({ cfg, accountId, resolved }) => setDiscordGuildChannelAllowlist(cfg, accountId, mapDiscordSetupAllowlistEntries(resolved))
+		}),
+		allowFrom: createAccountScopedAllowFromSection({
+			channel: channel$1,
+			credentialInputKey: "token",
+			helpTitle: "Discord allowlist",
+			helpLines: [
+				t$1("wizard.discord.allowlistIntro"),
+				t$1("wizard.discord.examples"),
+				"- 123456789012345678",
+				"- @alice",
+				"- alice#1234",
+				t$1("wizard.discord.multipleEntries"),
+				t$1("wizard.channels.docs", { link: formatDocsLink("/discord", "discord") })
+			],
+			message: t$1("wizard.discord.allowFromPrompt"),
+			placeholder: "@alice, 123456789012345678",
+			invalidWithoutCredentialNote: t$1("wizard.discord.allowFromInvalidWithoutToken"),
+			parseId: parseDiscordAllowFromId,
+			resolveEntries: handlers.resolveAllowFromEntries
+		}),
+		dmPolicy: discordDmPolicy,
+		disable: (cfg) => setSetupChannelEnabled(cfg, channel$1, false)
+	};
+}
+//#endregion
+//#region extensions/discord/src/setup-surface.ts
+const t = createSetupTranslator();
+const channel = "discord";
+async function resolveDiscordAllowFromEntries(params) {
+	return await resolveBasicAllowFromEntries({
+		token: params.token,
+		entries: params.entries,
+		resolveEntries: async ({ token, entries }) => await resolveDiscordUserAllowlist({
+			token,
+			entries
+		})
+	});
+}
+async function promptDiscordAllowFrom(params) {
+	const accountId = resolveSetupAccountId({
+		accountId: params.accountId,
+		defaultAccountId: resolveDefaultDiscordSetupAccountId(params.cfg)
+	});
+	const account = resolveDiscordSetupAccountConfig({
+		cfg: params.cfg,
+		accountId
+	});
+	const noteTitle = t("wizard.discord.allowlistTitle");
+	await params.prompter.note([
+		t("wizard.discord.allowlistIntro"),
+		t("wizard.discord.examples"),
+		"- 123456789012345678",
+		"- @alice",
+		"- alice#1234",
+		t("wizard.discord.multipleEntries"),
+		t("wizard.channels.docs", { link: formatDocsLink("/discord", "discord") })
+	].join("\n"), noteTitle);
+	const allowFrom = await promptResolvedAllowFrom({
+		prompter: params.prompter,
+		existing: resolveDiscordAccountAllowFrom({
+			cfg: params.cfg,
+			accountId
+		}) ?? [],
+		token: resolveDiscordToken(params.cfg, { accountId }).token,
+		message: t("wizard.discord.allowFromPrompt"),
+		placeholder: "@alice, 123456789012345678",
+		label: noteTitle,
+		parseInputs: splitSetupEntries,
+		parseId: parseDiscordAllowFromId,
+		invalidWithoutTokenNote: t("wizard.discord.allowFromInvalidWithoutToken"),
+		resolveEntries: async ({ token, entries }) => (await resolveDiscordUserAllowlist({
+			token,
+			entries
+		})).map((entry) => ({
+			input: entry.input,
+			resolved: entry.resolved,
+			id: entry.id ?? null
+		}))
+	});
+	return patchChannelConfigForAccount({
+		cfg: params.cfg,
+		channel,
+		accountId: account.accountId,
+		patch: {
+			allowFrom,
+			dm: {
+				...account.config.dm,
+				enabled: typeof account.config.dm?.enabled === "boolean" ? account.config.dm.enabled : true
+			}
+		}
+	});
+}
+async function resolveDiscordGroupAllowlist(params) {
+	return await resolveEntriesWithOptionalToken({
+		token: resolveDiscordToken(params.cfg, { accountId: params.accountId }).token || (typeof params.credentialValues.token === "string" ? params.credentialValues.token : ""),
+		entries: params.entries,
+		buildWithoutToken: (input) => ({
+			input,
+			resolved: false
+		}),
+		resolveEntries: async ({ token, entries }) => await resolveDiscordChannelAllowlist({
+			token,
+			entries
+		})
+	});
+}
+const discordSetupWizard = createDiscordSetupWizardBase({
+	promptAllowFrom: promptDiscordAllowFrom,
+	resolveAllowFromEntries: async ({ cfg, accountId, credentialValues, entries }) => await resolveDiscordAllowFromEntries({
+		token: resolveDiscordToken(cfg, { accountId }).token || (typeof credentialValues.token === "string" ? credentialValues.token : ""),
+		entries
+	}),
+	resolveGroupAllowlist: async ({ cfg, accountId, credentialValues, entries }) => await resolveDiscordGroupAllowlist({
+		cfg,
+		accountId,
+		credentialValues,
+		entries
+	})
+});
+//#endregion
+//#region extensions/discord/src/channel.setup.ts
+const discordSetupPlugin = { ...createDiscordPluginBase({
+	setupWizard: discordSetupWizard,
+	setupContract: discordSetupContract
+}) };
+//#endregion
+export { discordSetupPlugin as t };