@kodelyth/discord 2026.5.39 → 2026.5.42

package/account-inspect-api.ts

@@ -0,0 +1,6 @@
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { inspectDiscordAccount } from "./src/account-inspect.js";
+
+export function inspectDiscordReadOnlyAccount(cfg: KlawConfig, accountId?: string | null) {
+  return inspectDiscordAccount({ cfg, accountId });
+}

package/action-runtime-api.ts

@@ -0,0 +1 @@
+export { handleDiscordAction } from "./src/actions/runtime.js";

package/api.ts

@@ -0,0 +1,130 @@
+export { discordPlugin } from "./src/channel.js";
+export { discordSetupPlugin } from "./src/channel.setup.js";
+export {
+  handleDiscordSubagentDeliveryTarget,
+  handleDiscordSubagentEnded,
+  handleDiscordSubagentSpawning,
+} from "./src/subagent-hooks.js";
+export { inspectDiscordAccount, type InspectedDiscordAccount } from "./src/account-inspect.js";
+export { type DiscordCredentialStatus } from "./src/token.js";
+export {
+  createDiscordActionGate,
+  listDiscordAccountIds,
+  listEnabledDiscordAccounts,
+  mergeDiscordAccountConfig,
+  type ResolvedDiscordAccount,
+  resolveDefaultDiscordAccountId,
+  resolveDiscordAccount,
+  resolveDiscordAccountConfig,
+  resolveDiscordMaxLinesPerMessage,
+} from "./src/accounts.js";
+export { tryHandleDiscordMessageActionGuildAdmin } from "./src/actions/handle-action.guild-admin.js";
+export { DiscordApiError, fetchDiscord, requestDiscord } from "./src/api.js";
+export { buildDiscordComponentMessage } from "./src/components.js";
+type DiscordMessageActionHandler =
+  typeof import("./src/channel-actions.runtime.js").handleDiscordMessageAction;
+
+// Deprecated compatibility surface for existing @kodelyth/discord/api.js consumers.
+export const handleDiscordMessageAction: DiscordMessageActionHandler = async (...args) =>
+  (await import("./src/channel-actions.runtime.js")).handleDiscordMessageAction(...args);
+export {
+  listDiscordDirectoryGroupsFromConfig,
+  listDiscordDirectoryPeersFromConfig,
+} from "./src/directory-config.js";
+export {
+  resolveDiscordGroupRequireMention,
+  resolveDiscordGroupToolPolicy,
+} from "./src/group-policy.js";
+export {
+  looksLikeDiscordTargetId,
+  normalizeDiscordMessagingTarget,
+  normalizeDiscordOutboundTarget,
+} from "./src/normalize.js";
+export { resolveOpenProviderRuntimeGroupPolicy as resolveDiscordRuntimeGroupPolicy } from "klaw/plugin-sdk/runtime-group-policy";
+export { collectDiscordStatusIssues } from "./src/status-issues.js";
+
+export {
+  buildDiscordComponentCustomId,
+  buildDiscordComponentMessageFlags,
+  buildDiscordInteractiveComponents,
+  buildDiscordModalCustomId,
+  createDiscordFormModal,
+  DISCORD_COMPONENT_ATTACHMENT_PREFIX,
+  DISCORD_COMPONENT_CUSTOM_ID_KEY,
+  DISCORD_MODAL_CUSTOM_ID_KEY,
+  DiscordFormModal,
+  formatDiscordComponentEventText,
+  parseDiscordComponentCustomId,
+  parseDiscordComponentCustomIdForInteraction,
+  parseDiscordComponentCustomIdForInteraction as parseDiscordComponentCustomIdForCarbon,
+  parseDiscordModalCustomId,
+  parseDiscordModalCustomIdForInteraction,
+  parseDiscordModalCustomIdForInteraction as parseDiscordModalCustomIdForCarbon,
+  readDiscordComponentSpec,
+  resolveDiscordComponentAttachmentName,
+  type ComponentData,
+  type DiscordComponentBlock,
+  type DiscordComponentBuildResult,
+  type DiscordComponentButtonSpec,
+  type DiscordComponentButtonStyle,
+  type DiscordComponentEntry,
+  type DiscordComponentMessageSpec,
+  type DiscordComponentModalFieldType,
+  type DiscordComponentSectionAccessory,
+  type DiscordComponentSelectOption,
+  type DiscordComponentSelectSpec,
+  type DiscordComponentSelectType,
+  type DiscordModalEntry,
+  type DiscordModalFieldDefinition,
+  type DiscordModalFieldSpec,
+  type DiscordModalSpec,
+} from "./src/components.js";
+export {
+  getDiscordExecApprovalApprovers,
+  isDiscordExecApprovalApprover,
+  isDiscordExecApprovalClientEnabled,
+  shouldSuppressLocalDiscordExecApprovalPrompt,
+} from "./src/exec-approvals.js";
+export type {
+  DiscordInteractiveHandlerContext,
+  DiscordInteractiveHandlerRegistration,
+} from "./src/interactive-dispatch.js";
+export {
+  type DiscordPluralKitConfig,
+  fetchPluralKitMessageInfo,
+  type PluralKitMemberInfo,
+  type PluralKitMessageInfo,
+  type PluralKitSystemInfo,
+} from "./src/pluralkit.js";
+export {
+  fetchDiscordApplicationId,
+  fetchDiscordApplicationSummary,
+  parseApplicationIdFromToken,
+  probeDiscord,
+  resolveDiscordPrivilegedIntentsFromFlags,
+  type DiscordApplicationSummary,
+  type DiscordPrivilegedIntentsSummary,
+  type DiscordPrivilegedIntentStatus,
+  type DiscordProbe,
+} from "./src/probe.js";
+export { normalizeExplicitDiscordSessionKey } from "./src/session-key-normalization.js";
+export { parseDiscordSendTarget, type SendDiscordTarget } from "./src/send-target-parsing.js";
+export {
+  parseDiscordTarget,
+  resolveDiscordChannelId,
+  resolveDiscordTarget,
+  type DiscordTarget,
+  type DiscordTargetKind,
+  type DiscordTargetParseOptions,
+} from "./src/targets.js";
+export { collectDiscordSecurityAuditFindings } from "./src/security-audit.js";
+export {
+  DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS,
+  DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS,
+  DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS,
+  DISCORD_DEFAULT_LISTENER_TIMEOUT_MS,
+  mergeAbortSignals,
+} from "./src/monitor/timeouts.js";
+export type { DiscordSendComponents, DiscordSendEmbeds } from "./src/send.shared.js";
+export type { DiscordSendResult } from "./src/send.types.js";
+export type { DiscordTokenResolution } from "./src/token.js";

package/channel-config-api.ts

@@ -0,0 +1 @@
+export { DiscordChannelConfigSchema } from "./src/config-schema.js";

package/channel-plugin-api.ts

@@ -0,0 +1,3 @@
+// Keep bundled channel entry imports narrow so bootstrap/discovery paths do
+// not drag setup-only surfaces into lightweight channel plugin loads.
+export { discordPlugin } from "./src/channel.js";

package/config-api.ts

@@ -0,0 +1,4 @@
+export {
+  buildChannelConfigSchema,
+  DiscordConfigSchema,
+} from "klaw/plugin-sdk/bundled-channel-config-schema";

package/configured-state.ts

@@ -0,0 +1,6 @@
+export function hasDiscordConfiguredState(params: { env?: NodeJS.ProcessEnv }): boolean {
+  return (
+    typeof params.env?.DISCORD_BOT_TOKEN === "string" &&
+    params.env.DISCORD_BOT_TOKEN.trim().length > 0
+  );
+}

package/contract-api.ts

@@ -0,0 +1,21 @@
+export { createThreadBindingManager } from "./src/monitor/thread-bindings.manager.js";
+export { testing as discordThreadBindingTesting } from "./src/monitor/thread-bindings.manager.js";
+export {
+  listDiscordDirectoryGroupsFromConfig,
+  listDiscordDirectoryPeersFromConfig,
+} from "./src/directory-config.js";
+export { normalizeCompatibilityConfig, legacyConfigRules } from "./src/doctor-contract.js";
+export {
+  collectRuntimeConfigAssignments,
+  secretTargetRegistryEntries,
+} from "./src/secret-config-contract.js";
+export {
+  unsupportedSecretRefSurfacePatterns,
+  collectUnsupportedSecretRefConfigCandidates,
+} from "./src/security-contract.js";
+export { deriveLegacySessionChatType } from "./src/session-contract.js";
+export type {
+  DiscordInteractiveHandlerContext,
+  DiscordInteractiveHandlerRegistration,
+} from "./src/interactive-dispatch.js";
+export { collectDiscordSecurityAuditFindings } from "./src/security-audit.js";

package/directory-contract-api.ts

@@ -0,0 +1,4 @@
+export {
+  listDiscordDirectoryGroupsFromConfig,
+  listDiscordDirectoryPeersFromConfig,
+} from "./src/directory-config.js";

package/dist/account-inspect-Dqw-enky.js

@@ -0,0 +1,81 @@
+import { a as mergeDiscordAccountConfig, l as resolveDiscordAccountConfig, o as resolveDefaultDiscordAccountId } from "./accounts-B7OBFePq.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
+import { hasConfiguredSecretInput, normalizeSecretInputString } from "klaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/discord/src/account-inspect.ts
+function inspectDiscordTokenValue(value) {
+	const normalized = normalizeSecretInputString(value);
+	if (normalized) return {
+		token: normalized.replace(/^Bot\s+/i, ""),
+		tokenSource: "config",
+		tokenStatus: "available"
+	};
+	if (hasConfiguredSecretInput(value)) return {
+		token: "",
+		tokenSource: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	return null;
+}
+function inspectDiscordAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const merged = mergeDiscordAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.discord?.enabled !== false && merged.enabled !== false;
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const hasAccountToken = Boolean(accountConfig && Object.prototype.hasOwnProperty.call(accountConfig, "token"));
+	const accountToken = inspectDiscordTokenValue(accountConfig?.token);
+	if (accountToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: accountToken.token,
+		tokenSource: accountToken.tokenSource,
+		tokenStatus: accountToken.tokenStatus,
+		configured: true,
+		config: merged
+	};
+	if (hasAccountToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		configured: false,
+		config: merged
+	};
+	const channelToken = inspectDiscordTokenValue(params.cfg.channels?.discord?.token);
+	if (channelToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: channelToken.token,
+		tokenSource: channelToken.tokenSource,
+		tokenStatus: channelToken.tokenStatus,
+		configured: true,
+		config: merged
+	};
+	const envToken = accountId === DEFAULT_ACCOUNT_ID ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN) : void 0;
+	if (envToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: envToken.replace(/^Bot\s+/i, ""),
+		tokenSource: "env",
+		tokenStatus: "available",
+		configured: true,
+		config: merged
+	};
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		configured: false,
+		config: merged
+	};
+}
+//#endregion
+export { inspectDiscordAccount as t };

package/dist/account-inspect-api.js

@@ -0,0 +1,10 @@
+import { t as inspectDiscordAccount } from "./account-inspect-Dqw-enky.js";
+//#region extensions/discord/account-inspect-api.ts
+function inspectDiscordReadOnlyAccount(cfg, accountId) {
+	return inspectDiscordAccount({
+		cfg,
+		accountId
+	});
+}
+//#endregion
+export { inspectDiscordReadOnlyAccount };

package/dist/accounts-B7OBFePq.js

@@ -0,0 +1,224 @@
+import { normalizeAccountId } from "klaw/plugin-sdk/account-id";
+import { normalizeResolvedSecretInputString, resolveSecretInputString } from "klaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { createAccountActionGate, createAccountListHelpers, resolveMergedAccountConfig } from "klaw/plugin-sdk/account-helpers";
+import { mapAllowFromEntries, normalizeChannelDmPolicy, resolveChannelDmAllowFrom, resolveChannelDmPolicy } from "klaw/plugin-sdk/channel-config-helpers";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId as normalizeAccountId$1, resolveAccountEntry } from "klaw/plugin-sdk/routing";
+import { getRuntimeConfigSnapshot, getRuntimeConfigSourceSnapshot, selectApplicableRuntimeConfig } from "klaw/plugin-sdk/runtime-config-snapshot";
+//#region extensions/discord/src/runtime-config.ts
+function selectDiscordRuntimeConfig(inputConfig) {
+	return selectApplicableRuntimeConfig({
+		inputConfig,
+		runtimeConfig: getRuntimeConfigSnapshot(),
+		runtimeSourceConfig: getRuntimeConfigSourceSnapshot()
+	}) ?? inputConfig;
+}
+//#endregion
+//#region extensions/discord/src/token.ts
+function stripDiscordBotPrefix(token) {
+	return token.replace(/^Bot\s+/i, "");
+}
+function normalizeDiscordToken(raw, path) {
+	const trimmed = normalizeResolvedSecretInputString({
+		value: raw,
+		path
+	});
+	if (!trimmed) return;
+	return stripDiscordBotPrefix(trimmed);
+}
+function resolveDiscordTokenValue(params) {
+	const resolved = resolveSecretInputString({
+		value: params.value,
+		path: params.path,
+		defaults: params.cfg.secrets?.defaults,
+		mode: "inspect"
+	});
+	if (resolved.status === "available") return {
+		status: "available",
+		value: stripDiscordBotPrefix(resolved.value)
+	};
+	if (resolved.status === "configured_unavailable") return { status: "configured_unavailable" };
+	return { status: "missing" };
+}
+function resolveDiscordToken(cfg, opts = {}) {
+	const selectedCfg = selectDiscordRuntimeConfig(cfg);
+	const accountId = normalizeAccountId$1(opts.accountId);
+	const discordCfg = selectedCfg?.channels?.discord;
+	const accountCfg = resolveAccountEntry(discordCfg?.accounts, accountId);
+	const hasAccountToken = Boolean(accountCfg && Object.prototype.hasOwnProperty.call(accountCfg, "token"));
+	const accountToken = resolveDiscordTokenValue({
+		cfg: selectedCfg,
+		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 (hasAccountToken) return {
+		token: "",
+		source: "none",
+		tokenStatus: "missing"
+	};
+	const configToken = resolveDiscordTokenValue({
+		cfg: selectedCfg,
+		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"
+	};
+	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,
+		source: "env",
+		tokenStatus: "available"
+	};
+	return {
+		token: "",
+		source: "none",
+		tokenStatus: "missing"
+	};
+}
+//#endregion
+//#region extensions/discord/src/accounts.ts
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("discord", { implicitDefaultAccount: {
+	channelKeys: ["token"],
+	envVars: ["DISCORD_BOT_TOKEN"]
+} });
+const listDiscordAccountIds = listAccountIds;
+const resolveDefaultDiscordAccountId = resolveDefaultAccountId;
+function resolveDiscordAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.discord?.accounts, accountId);
+}
+function mergeDiscordAccountConfig(cfg, accountId) {
+	return resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.discord,
+		accounts: cfg.channels?.discord?.accounts,
+		accountId,
+		nestedObjectKeys: ["botLoopProtection"]
+	});
+}
+function resolveDiscordAccountAllowFrom(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const rootConfig = params.cfg.channels?.discord;
+	const allowFrom = resolveChannelDmAllowFrom({
+		account: accountConfig,
+		parent: rootConfig
+	});
+	return allowFrom ? mapAllowFromEntries(allowFrom) : void 0;
+}
+function resolveDiscordAccountDmPolicy(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const rootConfig = params.cfg.channels?.discord;
+	return normalizeChannelDmPolicy(resolveChannelDmPolicy({
+		account: accountConfig,
+		parent: rootConfig,
+		defaultPolicy: "pairing"
+	}));
+}
+function createDiscordActionGate(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	return createAccountActionGate({
+		baseActions: params.cfg.channels?.discord?.actions,
+		accountActions: resolveDiscordAccountConfig(params.cfg, accountId)?.actions
+	});
+}
+function resolveDiscordAccount(params) {
+	const cfg = selectDiscordRuntimeConfig(params.cfg);
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(cfg));
+	const baseEnabled = cfg.channels?.discord?.enabled !== false;
+	const merged = mergeDiscordAccountConfig(cfg, accountId);
+	const accountEnabled = merged.enabled !== false;
+	const enabled = baseEnabled && accountEnabled;
+	const tokenResolution = resolveDiscordToken(cfg, { accountId });
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: tokenResolution.token,
+		tokenSource: tokenResolution.source,
+		tokenStatus: tokenResolution.tokenStatus,
+		config: merged
+	};
+}
+function resolveDiscordMaxLinesPerMessage(params) {
+	if (typeof params.discordConfig?.maxLinesPerMessage === "number") return params.discordConfig.maxLinesPerMessage;
+	return resolveDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).config.maxLinesPerMessage;
+}
+function resolveDiscordAccountTokenOwner(params) {
+	const token = params.token.trim();
+	if (!token) return;
+	let owner;
+	const accountIds = listDiscordAccountIds(params.cfg);
+	for (const [index, accountId] of accountIds.entries()) {
+		const account = resolveDiscordAccount({
+			cfg: params.cfg,
+			accountId
+		});
+		const accountToken = account.token.trim();
+		if (!account.enabled || accountToken !== token) continue;
+		const priority = account.tokenSource === "config" ? 2 : account.tokenSource === "env" ? 1 : 0;
+		if (!owner || priority > owner.priority) {
+			owner = {
+				accountId: account.accountId,
+				priority,
+				index
+			};
+			continue;
+		}
+		if (priority === owner.priority && index < owner.index) owner = {
+			accountId: account.accountId,
+			priority,
+			index
+		};
+	}
+	return owner?.accountId;
+}
+function resolveDiscordDuplicateTokenOwner(params) {
+	const owner = resolveDiscordAccountTokenOwner({
+		cfg: params.cfg,
+		token: params.account.token
+	});
+	return owner && owner !== params.account.accountId ? owner : void 0;
+}
+function isDiscordAccountEnabledForRuntime(account, cfg) {
+	return account.enabled && !resolveDiscordDuplicateTokenOwner({
+		cfg,
+		account
+	});
+}
+function resolveDiscordAccountDisabledReason(account, cfg) {
+	if (!account.enabled) return "disabled";
+	const owner = resolveDiscordDuplicateTokenOwner({
+		cfg,
+		account
+	});
+	return owner ? `duplicate bot token; using account "${owner}"` : "disabled";
+}
+function listEnabledDiscordAccounts(cfg) {
+	return listDiscordAccountIds(cfg).map((accountId) => resolveDiscordAccount({
+		cfg,
+		accountId
+	})).filter((account) => isDiscordAccountEnabledForRuntime(account, cfg));
+}
+//#endregion
+export { mergeDiscordAccountConfig as a, resolveDiscordAccountAllowFrom as c, resolveDiscordAccountDmPolicy as d, resolveDiscordMaxLinesPerMessage as f, listEnabledDiscordAccounts as i, resolveDiscordAccountConfig as l, resolveDiscordToken as m, isDiscordAccountEnabledForRuntime as n, resolveDefaultDiscordAccountId as o, normalizeDiscordToken as p, listDiscordAccountIds as r, resolveDiscordAccount as s, createDiscordActionGate as t, resolveDiscordAccountDisabledReason as u };

package/dist/action-runtime-api.js

@@ -0,0 +1,2 @@
+import { t as handleDiscordAction } from "./runtime-DUaw66V_.js";
+export { handleDiscordAction };

package/dist/agent-components.runtime-DVY_1VB4.js

@@ -0,0 +1,4 @@
+import { buildPluginBindingResolvedText, parsePluginBindingApprovalCustomId, recordInboundSession, resolvePluginConversationBindingApproval } from "klaw/plugin-sdk/conversation-runtime";
+import { dispatchPluginInteractiveHandler } from "klaw/plugin-sdk/plugin-runtime";
+import { createReplyReferencePlanner, dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } from "klaw/plugin-sdk/reply-runtime";
+export { buildPluginBindingResolvedText, createReplyReferencePlanner, dispatchPluginInteractiveHandler, dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, parsePluginBindingApprovalCustomId, recordInboundSession, resolveChunkMode, resolvePluginConversationBindingApproval, resolveTextChunkLimit };