@openclaw/discord 2026.10.1-beta.2 → 2026.10.5-beta.1

package/dist/.setup/account-inspect-8cCu6uPG.mjs

@@ -0,0 +1,31 @@
+import { i as listDiscordAccountIds, n as inspectDiscordAccountConfig, v as resolveDiscordAccountAvailability } from "./accounts-ljrzXBJi.mjs";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
+//#region extensions/discord/src/account-inspect.ts
+function inspectDiscordAccountPrimary(params) {
+	return inspectDiscordAccountConfig(params, {
+		includeName: true,
+		resolveFallbackToken: (accountId) => {
+			const envToken = accountId === DEFAULT_ACCOUNT_ID ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN) : void 0;
+			return {
+				token: envToken?.replace(/^Bot\s+/i, "") ?? "",
+				source: envToken ? "env" : "none"
+			};
+		}
+	});
+}
+function inspectDiscordAccount(params) {
+	const account = inspectDiscordAccountPrimary(params);
+	return {
+		...account,
+		...resolveDiscordAccountAvailability({
+			account,
+			resolveAccounts: () => listDiscordAccountIds(params.cfg).map((accountId) => inspectDiscordAccountPrimary({
+				...params,
+				accountId
+			}))
+		})
+	};
+}
+//#endregion
+export { inspectDiscordAccount as t };

package/dist/.setup/{accounts-DXHCL8Zm.mjs → accounts-ljrzXBJi.mjs}

@@ -1,23 +1,18 @@
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createAccountActionGate, createAccountListHelpers } from "openclaw/plugin-sdk/account-helpers";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { hasConfiguredSecretInput, normalizeResolvedSecretInputString, normalizeSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { createAccountActionGate, createAccountListHelpers } from "openclaw/plugin-sdk/account-helpers";
 import { mapAllowFromEntries, normalizeChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-helpers";
 import { resolveConfiguredFromCredentialStatuses } from "openclaw/plugin-sdk/channel-status";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId as normalizeAccountId$1, resolveAccountEntry } from "openclaw/plugin-sdk/routing";
-import { hasConfiguredSecretInput, normalizeResolvedSecretInputString, normalizeSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getRuntimeConfigSnapshot, getRuntimeConfigSourceSnapshot, selectApplicableRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 //#region extensions/discord/src/account-token-inspect.ts
 function inspectDiscordConfiguredToken(value) {
 	const normalized = normalizeSecretInputString(value);
-	if (normalized) return {
-		token: normalized.replace(/^Bot\s+/i, ""),
+	if (normalized || hasConfiguredSecretInput(value)) return {
+		token: normalized ? normalized.replace(/^Bot\s+/i, "") : "",
 		tokenSource: "config",
-		tokenStatus: "available"
-	};
-	if (hasConfiguredSecretInput(value)) return {
-		token: "",
-		tokenSource: "config",
-		tokenStatus: "configured_unavailable"
+		tokenStatus: normalized ? "available" : "configured_unavailable"
 	};
 	return null;
 }
@@ -106,8 +101,7 @@ function normalizeDiscordToken(raw, path) {
 		value: raw,
 		path
 	});
-	if (!trimmed) return;
-	return stripDiscordBotPrefix(trimmed);
+	return trimmed ? stripDiscordBotPrefix(trimmed) : void 0;
 }
 function resolveDiscordTokenValue(params) {
 	const resolved = resolveSecretInputString({
@@ -116,12 +110,19 @@ function resolveDiscordTokenValue(params) {
 		defaults: params.cfg.secrets?.defaults,
 		mode: "inspect"
 	});
-	if (resolved.status === "available") return {
-		status: "available",
-		value: stripDiscordBotPrefix(resolved.value)
+	if (resolved.status === "available") {
+		const token = stripDiscordBotPrefix(resolved.value);
+		return token ? {
+			token,
+			source: "config",
+			tokenStatus: "available"
+		} : void 0;
+	}
+	if (resolved.status === "configured_unavailable") return {
+		token: "",
+		source: "config",
+		tokenStatus: "configured_unavailable"
 	};
-	if (resolved.status === "configured_unavailable") return { status: "configured_unavailable" };
-	return { status: "missing" };
 }
 function resolveDiscordToken(cfg, opts = {}) {
 	const selectedCfg = selectDiscordRuntimeConfig(cfg);
@@ -134,16 +135,7 @@ function resolveDiscordToken(cfg, opts = {}) {
 		value: accountCfg?.token,
 		path: `channels.discord.accounts.${accountId}.token`
 	});
-	if (accountToken.status === "available" && accountToken.value) return {
-		token: accountToken.value,
-		source: "config",
-		tokenStatus: "available"
-	};
-	if (accountToken.status === "configured_unavailable") return {
-		token: "",
-		source: "config",
-		tokenStatus: "configured_unavailable"
-	};
+	if (accountToken) return accountToken;
 	if (hasAccountToken) return {
 		token: "",
 		source: "none",
@@ -154,16 +146,7 @@ function resolveDiscordToken(cfg, opts = {}) {
 		value: discordCfg?.token,
 		path: "channels.discord.token"
 	});
-	if (configToken.status === "available" && configToken.value) return {
-		token: configToken.value,
-		source: "config",
-		tokenStatus: "available"
-	};
-	if (configToken.status === "configured_unavailable") return {
-		token: "",
-		source: "config",
-		tokenStatus: "configured_unavailable"
-	};
+	if (configToken) return configToken;
 	const envToken = accountId === DEFAULT_ACCOUNT_ID$1 ? normalizeDiscordToken(opts.envToken ?? process.env.DISCORD_BOT_TOKEN, "DISCORD_BOT_TOKEN") : void 0;
 	if (envToken) return {
 		token: envToken,
@@ -178,7 +161,7 @@ function resolveDiscordToken(cfg, opts = {}) {
 }
 //#endregion
 //#region extensions/discord/src/accounts.ts
-const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: mergeDiscordAccountConfig } = createAccountListHelpers("discord", {
+const { listAccountIds: listDiscordAccountIds, resolveDefaultAccountId: resolveDefaultDiscordAccountId, resolveAccountConfig: mergeDiscordAccountConfig } = createAccountListHelpers("discord", {
 	implicitDefaultAccount: {
 		channelKeys: ["token"],
 		envVars: ["DISCORD_BOT_TOKEN"]
@@ -189,29 +172,48 @@ const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: mergeDisc
 		"botLoopProtection"
 	]
 });
-const listDiscordAccountIds = listAccountIds;
-const resolveDefaultDiscordAccountId = resolveDefaultAccountId;
 function resolveDiscordAccountConfig(cfg, accountId) {
 	return resolveAccountEntry(cfg.channels?.discord?.accounts, accountId);
 }
-function resolveDiscordAccountAllowFrom(params) {
+function inspectDiscordAccountConfig(params, options) {
 	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const config = mergeDiscordAccountConfig(params.cfg, accountId);
+	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,
+			...options.includeName ? { name: normalizeOptionalString(config.name) } : {}
+		},
+		config,
+		accountToken: accountConfig?.token,
+		hasAccountToken,
+		channelToken: params.cfg.channels?.discord?.token,
+		resolveFallbackToken: () => options.resolveFallbackToken(accountId)
+	});
+}
+function readConfiguredAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	return resolveDiscordAccountConfig(params.cfg, accountId);
+}
+function resolveDiscordAccountAllowFrom(params) {
+	const accountConfig = readConfiguredAccount(params);
 	const rootConfig = params.cfg.channels?.discord;
 	const allowFrom = accountConfig?.allowFrom ?? rootConfig?.allowFrom;
 	return allowFrom ? mapAllowFromEntries(allowFrom) : void 0;
 }
 function resolveDiscordAccountDmPolicy(params) {
-	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
-	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const accountConfig = readConfiguredAccount(params);
 	const rootConfig = params.cfg.channels?.discord;
 	return normalizeChannelDmPolicy(accountConfig?.dmPolicy ?? rootConfig?.dmPolicy ?? "pairing");
 }
 function createDiscordActionGate(params) {
-	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const accountConfig = readConfiguredAccount(params);
 	return createAccountActionGate({
 		baseActions: params.cfg.channels?.discord?.actions,
-		accountActions: resolveDiscordAccountConfig(params.cfg, accountId)?.actions
+		accountActions: accountConfig?.actions
 	});
 }
 function resolveDiscordAccount(params) {
@@ -267,4 +269,4 @@ function listDiscordStartupAccountIds(cfg) {
 	return [defaultAccountId, ...startupAccountIds.filter((candidateId) => candidateId !== defaultAccountId)];
 }
 //#endregion
-export { inspectDiscordAccountTokenState as _, listEnabledDiscordAccounts as a, resolveDiscordAccount as c, resolveDiscordAccountDisabledReason as d, resolveDiscordAccountDmPolicy as f, selectDiscordActivitiesRuntimeConfig as g, resolveDiscordToken as h, listDiscordStartupAccountIds as i, resolveDiscordAccountAllowFrom as l, normalizeDiscordToken as m, isDiscordAccountEnabledForRuntime as n, mergeDiscordAccountConfig as o, resolveDiscordMaxLinesPerMessage as p, listDiscordAccountIds as r, resolveDefaultDiscordAccountId as s, createDiscordActionGate as t, resolveDiscordAccountConfig as u, resolveDiscordAccountAvailability as v };
+export { selectDiscordActivitiesRuntimeConfig as _, listDiscordStartupAccountIds as a, resolveDefaultDiscordAccountId as c, resolveDiscordAccountConfig as d, resolveDiscordAccountDisabledReason as f, resolveDiscordToken as g, normalizeDiscordToken as h, listDiscordAccountIds as i, resolveDiscordAccount as l, resolveDiscordMaxLinesPerMessage as m, inspectDiscordAccountConfig as n, listEnabledDiscordAccounts as o, resolveDiscordAccountDmPolicy as p, isDiscordAccountEnabledForRuntime as r, mergeDiscordAccountConfig as s, createDiscordActionGate as t, resolveDiscordAccountAllowFrom as u, resolveDiscordAccountAvailability as v };

package/dist/.setup/{channel-type-D1_b5UhU.mjs → allow-list-B_ToXtew.mjs}

@@ -5,6 +5,11 @@ import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtim
 import { fetchWithSsrFGuard, isBlockedHostnameOrIp, isLoopbackHost } from "openclaw/plugin-sdk/ssrf-runtime";
 import { buildChannelKeyCandidates, normalizeChannelSlug, resolveChannelEntryMatchWithFallback, resolveChannelMatchConfig } from "openclaw/plugin-sdk/channel-targets";
 import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
+//#region extensions/discord/src/channel-type.ts
+function isDiscordThreadChannelType(channelType) {
+	return channelType === ChannelType.AnnouncementThread || channelType === ChannelType.PublicThread || channelType === ChannelType.PrivateThread;
+}
+//#endregion
 //#region extensions/discord/src/endpoint-runtime.ts
 const DISCORD_ENDPOINT_RESPONSE_MAX_BYTES = 8388608;
 const DISCORD_API_URL_ENV = "DISCORD_API_URL";
@@ -25,27 +30,16 @@ function normalizeRestApiBaseUrl(value) {
 	url.pathname = url.pathname.replace(/\/+$/u, "") || "/";
 	return url;
 }
-function normalizeGatewayOrigin(value) {
-	let url;
-	try {
-		url = new URL(value);
-	} catch {
-		throw new Error("Discord endpoint Gateway origin must be a valid URL");
-	}
-	if (url.protocol !== "wss:" && !(url.protocol === "ws:" && isLoopbackHost(url.hostname))) throw new Error("Discord endpoint Gateway origin must use WSS or loopback WS");
-	if (url.protocol === "wss:" && isBlockedHostnameOrIp(url.hostname)) throw new Error("Discord endpoint Gateway origin must not target a private/internal/special-use hostname or IP address");
-	if (url.username || url.password || url.hash || url.pathname !== "/" || url.search) throw new Error("Discord endpoint Gateway origin must be an origin without credentials, path, query, or fragment");
-	return url.origin;
-}
 function resolveDescriptor(apiUrl) {
 	const restApiBaseUrl = normalizeRestApiBaseUrl(apiUrl);
 	const gatewayBotUrl = new URL(`${restApiBaseUrl.pathname.replace(/\/+$/u, "")}/gateway/bot`, restApiBaseUrl.origin);
 	const gatewayOriginUrl = new URL(restApiBaseUrl.origin);
 	gatewayOriginUrl.protocol = gatewayOriginUrl.protocol === "https:" ? "wss:" : "ws:";
+	if (gatewayOriginUrl.protocol === "wss:" && isBlockedHostnameOrIp(gatewayOriginUrl.hostname)) throw new Error("Discord endpoint Gateway origin must not target a private/internal/special-use hostname or IP address");
 	return Object.freeze({
 		restApiBaseUrl: restApiBaseUrl.toString().replace(/\/$/u, ""),
 		gatewayBotUrl: gatewayBotUrl.toString(),
-		gatewayOrigin: normalizeGatewayOrigin(gatewayOriginUrl.origin)
+		gatewayOrigin: gatewayOriginUrl.origin
 	});
 }
 function isWithinRestApiBase(target, restApiBaseUrl) {
@@ -116,27 +110,22 @@ function getDiscordEndpointRuntime(env = process.env) {
 	});
 }
 function resolveDiscordEndpointMediaGuard(url, retainedRuntime) {
-	if (retainedRuntime === null) return;
-	const runtime = retainedRuntime ?? getDiscordEndpointRuntime();
-	if (!runtime) return;
-	const target = parseHttpAnchor(url, "Discord endpoint media URL");
-	const restOrigin = new URL(runtime.descriptor.restApiBaseUrl).origin;
-	if (target.origin !== restOrigin) throw new Error("Discord endpoint media URL is outside the configured REST origin");
-	return {
-		maxRedirects: 0,
-		ssrfPolicy: {
-			allowedOrigins: [restOrigin],
-			hostnameAllowlist: [target.hostname]
-		}
-	};
+	const guard = resolveEndpointResourceGuard(url, "media", retainedRuntime);
+	return guard ? {
+		maxRedirects: guard.maxRedirects,
+		ssrfPolicy: guard.policy
+	} : void 0;
 }
 function resolveDiscordEndpointAttachmentGuard(url, retainedRuntime) {
+	return resolveEndpointResourceGuard(url, "attachment upload", retainedRuntime);
+}
+function resolveEndpointResourceGuard(url, kind, retainedRuntime) {
 	if (retainedRuntime === null) return;
 	const runtime = retainedRuntime ?? getDiscordEndpointRuntime();
 	if (!runtime) return;
-	const target = parseHttpAnchor(url, "Discord endpoint attachment upload URL");
+	const target = parseHttpAnchor(url, `Discord endpoint ${kind} URL`);
 	const restOrigin = new URL(runtime.descriptor.restApiBaseUrl).origin;
-	if (target.origin !== restOrigin) throw new Error("Discord endpoint attachment upload URL is outside the configured REST origin");
+	if (target.origin !== restOrigin) throw new Error(`Discord endpoint ${kind} URL is outside the configured REST origin`);
 	return {
 		maxRedirects: 0,
 		policy: {
@@ -229,19 +218,6 @@ function normalizeDiscordSlug(value) {
 function normalizeDiscordDisplaySlug(value) {
 	return normalizeLowercaseStringOrEmpty(value).normalize("NFC").replace(/^#/, "").replace(/[\s_]+/g, "-").replace(/[^\p{L}\p{M}\p{N}-]+/gu, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
 }
-function resolveDiscordAllowListNameMatch(list, candidate) {
-	const nameSlug = candidate.name ? normalizeDiscordSlug(candidate.name) : "";
-	if (nameSlug && list.names.has(nameSlug)) return {
-		matchKey: nameSlug,
-		matchSource: "name"
-	};
-	const tagSlug = candidate.tag ? normalizeDiscordSlug(candidate.tag) : "";
-	if (tagSlug && list.names.has(tagSlug)) return {
-		matchKey: tagSlug,
-		matchSource: "tag"
-	};
-	return null;
-}
 function allowListMatches(list, candidate, params) {
 	return resolveDiscordAllowListMatch({
 		allowList: list,
@@ -261,11 +237,13 @@ function resolveDiscordAllowListMatch(params) {
 		matchKey: candidate.id,
 		matchSource: "id"
 	};
-	if (params.allowNameMatching === true) {
-		const namedMatch = resolveDiscordAllowListNameMatch(allowList, candidate);
-		if (namedMatch) return {
+	if (params.allowNameMatching === true) for (const matchSource of ["name", "tag"]) {
+		const value = candidate[matchSource];
+		const matchKey = value ? normalizeDiscordSlug(value) : "";
+		if (matchKey && allowList.names.has(matchKey)) return {
 			allowed: true,
-			...namedMatch
+			matchKey,
+			matchSource
 		};
 	}
 	return { allowed: false };
@@ -283,27 +261,16 @@ function resolveDiscordUserAllowed(params) {
 		tag: params.userTag
 	}, { allowNameMatching: params.allowNameMatching });
 }
-function resolveDiscordRoleAllowed(params) {
-	const allowList = normalizeDiscordAllowList(params.allowList, ["role:"]);
-	if (!allowList) return true;
-	if (allowList.allowAll) return true;
-	return params.memberRoleIds.some((roleId) => allowList.ids.has(roleId));
-}
 function resolveDiscordMemberAllowed(params) {
 	const hasUserRestriction = Array.isArray(params.userAllowList) && params.userAllowList.length > 0;
 	const hasRoleRestriction = Array.isArray(params.roleAllowList) && params.roleAllowList.length > 0;
 	if (!hasUserRestriction && !hasRoleRestriction) return true;
 	const userOk = hasUserRestriction ? resolveDiscordUserAllowed({
-		allowList: params.userAllowList,
-		userId: params.userId,
-		userName: params.userName,
-		userTag: params.userTag,
-		allowNameMatching: params.allowNameMatching
-	}) : false;
-	const roleOk = hasRoleRestriction ? resolveDiscordRoleAllowed({
-		allowList: params.roleAllowList,
-		memberRoleIds: params.memberRoleIds
+		...params,
+		allowList: params.userAllowList
 	}) : false;
+	const roles = hasRoleRestriction ? normalizeDiscordAllowList(params.roleAllowList, ["role:"]) : null;
+	const roleOk = Boolean(roles && (roles.allowAll || params.memberRoleIds.some((roleId) => roles.ids.has(roleId))));
 	return userOk || roleOk;
 }
 function resolveDiscordMemberAccessState(params) {
@@ -335,11 +302,7 @@ function resolveDiscordOwnerAllowFrom(params) {
 	if (!allowList) return;
 	const match = resolveDiscordAllowListMatch({
 		allowList,
-		candidate: {
-			id: params.sender.id,
-			name: params.sender.name,
-			tag: params.sender.tag
-		},
+		candidate: params.sender,
 		allowNameMatching: params.allowNameMatching
 	});
 	if (!match.allowed || !match.matchKey || match.matchKey === "*") return;
@@ -374,33 +337,12 @@ function resolveDiscordGuildEntry(params) {
 	};
 	if (!guild) return null;
 	const slug = normalizeDiscordSlug(guild.name ?? "");
-	const bySlug = entries[slug];
-	if (bySlug) return {
-		...bySlug,
-		id: guildId ?? guild.id,
-		slug: slug || bySlug.slug
-	};
-	const wildcard = entries["*"];
-	if (wildcard) return {
-		...wildcard,
+	const byName = entries[slug] || entries["*"];
+	return byName ? {
+		...byName,
 		id: guildId ?? guild.id,
-		slug: slug || wildcard.slug
-	};
-	return null;
-}
-function buildDiscordChannelKeys(params) {
-	const allowNameMatch = params.allowNameMatch !== false;
-	return buildChannelKeyCandidates(params.id, allowNameMatch ? params.slug : void 0, allowNameMatch ? params.name : void 0);
-}
-function resolveDiscordChannelEntryMatch(channels, params, parentParams) {
-	const keys = buildDiscordChannelKeys(params);
-	const parentKeys = parentParams ? buildDiscordChannelKeys(parentParams) : void 0;
-	return resolveChannelEntryMatchWithFallback({
-		entries: channels,
-		keys,
-		parentKeys,
-		wildcardKey: "*"
-	});
+		slug: slug || byName.slug
+	} : null;
 }
 function hasConfiguredDiscordChannels(channels) {
 	return Boolean(channels && Object.keys(channels).length > 0);
@@ -435,16 +377,12 @@ function resolveDiscordChannelConfigWithFallback(params) {
 	const channels = guildInfo?.channels;
 	if (!hasConfiguredDiscordChannels(channels)) return null;
 	const resolvedParentSlug = parentSlug ?? (parentName ? normalizeDiscordSlug(parentName) : "");
-	const match = resolveDiscordChannelEntryMatch(channels, {
-		id: channelId,
-		name: channelName,
-		slug: channelSlug,
-		allowNameMatch: scope !== "thread"
-	}, parentId || parentName || parentSlug ? {
-		id: parentId ?? "",
-		name: parentName,
-		slug: resolvedParentSlug
-	} : void 0);
+	const match = resolveChannelEntryMatchWithFallback({
+		entries: channels,
+		keys: buildChannelKeyCandidates(channelId, scope === "thread" ? void 0 : channelSlug, scope === "thread" ? void 0 : channelName),
+		parentKeys: parentId || parentName || parentSlug ? buildChannelKeyCandidates(parentId ?? "", resolvedParentSlug, parentName) : void 0,
+		wildcardKey: "*"
+	});
 	return resolveChannelMatchConfig(match, resolveDiscordChannelConfigEntry) ?? { allowed: false };
 }
 /** Boolean runtime API retained for plugins built against OpenClaw 2026.9.6. */
@@ -522,9 +460,4 @@ function shouldEmitDiscordReactionNotification(params) {
 	return false;
 }
 //#endregion
-//#region extensions/discord/src/channel-type.ts
-function isDiscordThreadChannelType(channelType) {
-	return channelType === ChannelType.AnnouncementThread || channelType === ChannelType.PublicThread || channelType === ChannelType.PrivateThread;
-}
-//#endregion
-export { resolveDiscordEndpointMediaGuard as A, formatDiscordUserTag as C, assertDiscordEndpointGatewayUrl as D, parseDiscordRetryAfterBodySeconds as E, getDiscordEndpointRuntime as O, formatDiscordReactionEmoji as S, resolveTimestampMs as T, resolveDiscordOwnerAccess as _, normalizeDiscordAllowList as a, resolveGroupDmAllow as b, resolveDiscordAllowListMatch as c, resolveDiscordChannelPolicyCommandAuthorizer as d, resolveDiscordCommandAuthorized as f, resolveDiscordMentionPolicy as g, resolveDiscordMemberAllowed as h, isDiscordGroupAllowedByPolicy as i, resolveDiscordEndpointAttachmentGuard as k, resolveDiscordChannelConfig as l, resolveDiscordMemberAccessState as m, allowListMatches as n, normalizeDiscordDisplaySlug as o, resolveDiscordGuildEntry as p, hasConfiguredDiscordChannels as r, normalizeDiscordSlug as s, isDiscordThreadChannelType as t, resolveDiscordChannelConfigWithFallback as u, resolveDiscordOwnerAllowFrom as v, resolveDiscordSystemLocation as w, shouldEmitDiscordReactionNotification as x, resolveDiscordShouldRequireMention as y };
+export { isDiscordThreadChannelType as A, resolveDiscordSystemLocation as C, getDiscordEndpointRuntime as D, assertDiscordEndpointGatewayUrl as E, resolveDiscordEndpointAttachmentGuard as O, formatDiscordUserTag as S, parseDiscordRetryAfterBodySeconds as T, resolveDiscordOwnerAllowFrom as _, normalizeDiscordDisplaySlug as a, shouldEmitDiscordReactionNotification as b, resolveDiscordChannelConfig as c, resolveDiscordCommandAuthorized as d, resolveDiscordGuildEntry as f, resolveDiscordOwnerAccess as g, resolveDiscordMentionPolicy as h, normalizeDiscordAllowList as i, resolveDiscordEndpointMediaGuard as k, resolveDiscordChannelConfigWithFallback as l, resolveDiscordMemberAllowed as m, hasConfiguredDiscordChannels as n, normalizeDiscordSlug as o, resolveDiscordMemberAccessState as p, isDiscordGroupAllowedByPolicy as r, resolveDiscordAllowListMatch as s, allowListMatches as t, resolveDiscordChannelPolicyCommandAuthorizer as u, resolveDiscordShouldRequireMention as v, resolveTimestampMs as w, formatDiscordReactionEmoji as x, resolveGroupDmAllow as y };

package/dist/.setup/{api-_oznjffB.mjs → api-CtmE1OUN.mjs}

@@ -1,11 +1,11 @@
-import { E as parseDiscordRetryAfterBodySeconds, O as getDiscordEndpointRuntime } from "./channel-type-D1_b5UhU.mjs";
-import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
+import { D as getDiscordEndpointRuntime, T as parseDiscordRetryAfterBodySeconds } from "./allow-list-B_ToXtew.mjs";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { captureChannelReadAuthority, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
+import { captureChannelReadAuthority, captureEffectAuthority, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
+import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import { parseRetryAfterHeaderSeconds, resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 import { readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
-import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/discord/src/error-body.ts
 const DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS = 240;
@@ -23,11 +23,10 @@ function summarizeDiscordResponseBody(body, opts = {}) {
 	return truncateUtf16Safe(redactToolPayloadText(summary), DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS);
 }
 function isDiscordHtmlResponseBody(body, contentType) {
-	return /\bhtml\b/i.test(contentType ?? "") || /^\s*<!doctype\s+html\b/i.test(body) || /^\s*<html\b/i.test(body);
+	return /\bhtml\b/i.test(contentType ?? "") || /^\s*(?:<!doctype\s+html\b|<html\b)/i.test(body);
 }
 function isDiscordRateLimitResponseBody(body) {
-	const normalized = body.toLowerCase();
-	return normalized.includes("error 1015") || normalized.includes("cloudflare") || normalized.includes("rate limit");
+	return /error 1015|cloudflare|rate limit/i.test(body);
 }
 //#endregion
 //#region extensions/discord/src/api.ts
@@ -46,23 +45,21 @@ function parseDiscordApiErrorPayload(text) {
 	const trimmed = text.trim();
 	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
 	try {
-		const payload = JSON.parse(trimmed);
-		if (payload && typeof payload === "object") return payload;
+		return JSON.parse(trimmed);
 	} catch {
 		return null;
 	}
-	return null;
 }
 function parseRetryAfterSeconds(text, response) {
 	const payload = parseDiscordApiErrorPayload(text);
 	const retryAfter = parseDiscordRetryAfterBodySeconds(payload?.retry_after);
 	if (retryAfter !== void 0) return retryAfter;
 	const header = response.headers.get("Retry-After");
-	if (!header) return;
-	return parseRetryAfterHeaderSeconds(header);
+	return header ? parseRetryAfterHeaderSeconds(header) : void 0;
 }
-function formatRetryAfterSeconds(value) {
-	if (value === void 0 || !Number.isFinite(value) || value < 0) return;
+function formatRetryAfterSeconds(raw) {
+	const value = parseDiscordRetryAfterBodySeconds(raw);
+	if (value === void 0) return;
 	return `${value < 10 ? value.toFixed(1) : Math.round(value).toString()}s`;
 }
 function formatDiscordApiErrorTextUntrusted(text, response) {
@@ -79,13 +76,9 @@ function formatDiscordApiErrorTextUntrusted(text, response) {
 		return summary;
 	}
 	const message = typeof payload.message === "string" && payload.message.trim() ? payload.message.trim() : "unknown error";
-	const retryAfter = formatRetryAfterSeconds(parseDiscordRetryAfterBodySeconds(payload.retry_after));
+	const retryAfter = formatRetryAfterSeconds(payload.retry_after);
 	return retryAfter ? `${message} (retry after ${retryAfter})` : message;
 }
-function formatDiscordApiErrorText(text, response) {
-	const detail = formatDiscordApiErrorTextUntrusted(text, response);
-	return detail ? redactToolPayloadText(detail) : detail;
-}
 var DiscordApiError = class extends Error {
 	constructor(message, status, retryAfter) {
 		super(message);
@@ -93,13 +86,8 @@ var DiscordApiError = class extends Error {
 		this.retryAfter = retryAfter;
 	}
 };
-function getDiscordApiRetryAfterMs(err, retryConfig) {
-	if (!(err instanceof DiscordApiError) || typeof err.retryAfter !== "number") return;
-	return Math.min(Math.max(0, err.retryAfter * 1e3), retryConfig.maxDelayMs);
-}
 function normalizeDiscordRequestBody(body, headers) {
-	if (body === void 0) return;
-	if (typeof body === "string" || body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams || body instanceof ArrayBuffer) return body;
+	if (body === void 0 || typeof body === "string" || body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams || body instanceof ArrayBuffer) return body;
 	headers.set("Content-Type", headers.get("Content-Type") ?? "application/json");
 	return JSON.stringify(body);
 }
@@ -118,6 +106,7 @@ function createDiscordRequestSignal(options) {
 }
 async function requestDiscord(path, token, options) {
 	const assertReadAuthority = captureChannelReadAuthority();
+	const effect = captureEffectAuthority();
 	const endpoint = options?.endpointRuntime === void 0 ? getDiscordEndpointRuntime() : options.endpointRuntime;
 	const fetchImpl = resolveFetch(endpoint ? (input, init) => endpoint.fetch(input, init, assertReadAuthority) : options?.fetcher ?? fetch);
 	if (!fetchImpl) throw new Error("fetch is not available");
@@ -129,15 +118,20 @@ async function requestDiscord(path, token, options) {
 		const requestSignal = createDiscordRequestSignal(options ?? {});
 		try {
 			assertReadAuthority?.();
-			const res = await fetchImpl(`${endpoint?.descriptor.restApiBaseUrl ?? DISCORD_API_BASE}${path}`, {
-				method: options?.method ?? (body === void 0 ? "GET" : "POST"),
-				headers,
-				body,
-				signal: requestSignal.signal
-			});
+			const request = () => {
+				assertReadAuthority?.();
+				return fetchImpl(`${endpoint?.descriptor.restApiBaseUrl ?? DISCORD_API_BASE}${path}`, {
+					method: options?.method ?? (body === void 0 ? "GET" : "POST"),
+					headers,
+					body,
+					signal: requestSignal.signal
+				});
+			};
+			const res = endpoint ? await effect.run(request) : await effect.initiate(request);
 			if (!res.ok) {
 				const text = await readResponseTextLimited(res, DISCORD_API_ERROR_BODY_LIMIT_BYTES).catch(() => "");
-				const detail = formatDiscordApiErrorText(text, res);
+				const untrustedDetail = formatDiscordApiErrorTextUntrusted(text, res);
+				const detail = untrustedDetail ? redactToolPayloadText(untrustedDetail) : untrustedDetail;
 				const suffix = detail ? `: ${detail}` : "";
 				const retryAfter = res.status === 429 ? parseRetryAfterSeconds(text, res) ?? DISCORD_API_429_FALLBACK_RETRY_AFTER_SECONDS : void 0;
 				throw new DiscordApiError(`Discord API ${path} failed (${res.status})${suffix}`, res.status, retryAfter);
@@ -157,7 +151,7 @@ async function requestDiscord(path, token, options) {
 		...retryConfig,
 		label: options?.label ?? path,
 		shouldRetry: (err) => err instanceof DiscordApiError && err.status === 429,
-		retryAfterMs: (err) => getDiscordApiRetryAfterMs(err, retryConfig),
+		retryAfterMs: (err) => err instanceof DiscordApiError && typeof err.retryAfter === "number" ? Math.min(Math.max(0, err.retryAfter * 1e3), retryConfig.maxDelayMs) : void 0,
 		sleep: (ms) => sleepWithAbort(ms, options?.signal)
 	});
 }