@openclaw/discord 2026.8.2 → 2026.8.33

package/dist/.setup/sender-identity-DirkiBy8.mjs

@@ -0,0 +1,43 @@
+import { x as formatDiscordUserTag } from "./allow-list-C2JuH-R0.mjs";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/discord/src/monitor/sender-identity.ts
+function resolveDiscordWebhookId(message) {
+	const candidate = message.webhookId ?? message.webhook_id;
+	return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+function resolveDiscordSenderIdentity(params) {
+	const pkInfo = params.pluralkitInfo ?? null;
+	const pkMember = pkInfo?.member ?? void 0;
+	const pkSystem = pkInfo?.system ?? void 0;
+	const memberId = pkMember?.id?.trim();
+	const memberName = (pkMember?.display_name ?? pkMember?.name ?? "")?.trim();
+	if (memberId && memberName) {
+		const systemName = pkSystem?.name?.trim();
+		const label = systemName ? `${memberName} (PK:${systemName})` : `${memberName} (PK)`;
+		return {
+			id: memberId,
+			name: memberName,
+			tag: normalizeOptionalString(pkMember?.name),
+			label,
+			isPluralKit: true,
+			pluralkit: {
+				memberId,
+				memberName,
+				systemId: normalizeOptionalString(pkSystem?.id),
+				systemName
+			}
+		};
+	}
+	const senderTag = formatDiscordUserTag(params.author);
+	const senderDisplay = params.member?.nickname ?? params.member?.nick ?? params.author.globalName ?? params.author.username;
+	const senderLabel = senderDisplay && senderTag && senderDisplay !== senderTag ? `${senderDisplay} (${senderTag})` : senderDisplay ?? senderTag ?? params.author.id;
+	return {
+		id: params.author.id,
+		name: params.author.username ?? void 0,
+		tag: senderTag,
+		label: senderLabel,
+		isPluralKit: false
+	};
+}
+//#endregion
+export { resolveDiscordWebhookId as n, resolveDiscordSenderIdentity as t };

package/dist/.setup/setup-plugin-api-FH_1XPpk.mjs

@@ -0,0 +1,3 @@
+import { t as discordSetupPlugin } from "./channel.setup-0Wxa3OWc.mjs";
+import "../setup-plugin-api.js";
+export { discordSetupPlugin };

package/dist/.setup/shared-BatfFi3a.mjs

@@ -0,0 +1,215 @@
+import { c as resolveDiscordAccount, d as resolveDiscordAccountDisabledReason, f as resolveDiscordAccountDmPolicy, l as resolveDiscordAccountAllowFrom, n as isDiscordAccountEnabledForRuntime, o as mergeDiscordAccountConfig, r as listDiscordAccountIds, s as resolveDefaultDiscordAccountId } from "./accounts-CwJQoLjM.mjs";
+import { t as inspectDiscordAccount } from "./account-inspect-BwQj24ht.mjs";
+import { t as discordIngressIdentity } from "./ingress-identity-BwX7d_Gh.mjs";
+import { t as DiscordChannelConfigSchema } from "./config-schema-B797-Spt.mjs";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-Co5vRCZ6.mjs";
+import { r as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-DFu9hfU8.mjs";
+import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-DSHk7I2w.mjs";
+import { t as deriveLegacySessionChatType } from "./session-contract-BO5tlIdl.mjs";
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
+import { PAIRING_APPROVED_MESSAGE, buildTokenChannelStatusSummary, projectCredentialSnapshotFields, resolveConfiguredFromCredentialStatuses as resolveConfiguredFromCredentialStatuses$1 } from "openclaw/plugin-sdk/channel-status";
+import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { createConditionalWarningCollector, createOpenProviderConfiguredRouteWarningCollector } from "openclaw/plugin-sdk/channel-policy";
+import { identityEntryAuthenticationClassifier } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
+import { createEnvPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup-runtime";
+//#region extensions/discord/src/channel-api.ts
+const DISCORD_CHANNEL_META = {
+	id: "discord",
+	label: "Discord",
+	selectionLabel: "Discord (Bot API)",
+	detailLabel: "Discord Bot",
+	docsPath: "/channels/discord",
+	docsLabel: "discord",
+	blurb: "very well supported right now.",
+	systemImage: "bubble.left.and.bubble.right",
+	markdownCapable: true,
+	preferSessionLookupForAnnounceTarget: true
+};
+function getChatChannelMeta(id) {
+	if (id !== DISCORD_CHANNEL_META.id) throw new Error(`Unsupported Discord channel meta lookup: ${id}`);
+	return DISCORD_CHANNEL_META;
+}
+//#endregion
+//#region extensions/discord/src/security.ts
+const resolveDiscordDmPolicy = createScopedDmSecurityResolver({
+	channelKey: "discord",
+	resolvePolicy: (account) => account.config.dmPolicy,
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	resolveAccess: ({ cfg, account }) => ({
+		dmPolicy: resolveDiscordAccountDmPolicy({
+			cfg,
+			accountId: account.accountId
+		}),
+		allowFrom: resolveDiscordAccountAllowFrom({
+			cfg,
+			accountId: account.accountId
+		})
+	}),
+	policyPathSuffix: "dmPolicy",
+	classifyEntryAuthentication: identityEntryAuthenticationClassifier(discordIngressIdentity),
+	normalizeEntry: (raw) => raw.trim().replace(/^(discord|user):/i, "").replace(/^<@!?(\d+)>$/, "$1")
+});
+const collectDiscordSecurityWarnings = createOpenProviderConfiguredRouteWarningCollector({
+	providerConfigPresent: (cfg) => cfg.channels?.discord !== void 0,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	resolveRouteAllowlistConfigured: (account) => Object.keys(account.config.guilds ?? {}).length > 0,
+	configureRouteAllowlist: {
+		surface: "Discord guilds",
+		openScope: "any channel not explicitly denied",
+		groupPolicyPath: "channels.discord.groupPolicy",
+		routeAllowlistPath: "channels.discord.guilds.<id>.channels"
+	},
+	missingRouteAllowlist: {
+		surface: "Discord guilds",
+		openBehavior: "with no guild/channel allowlist; any channel can trigger (mention-gated)",
+		remediation: "Set channels.discord.groupPolicy=\"allowlist\" and configure channels.discord.guilds.<id>.channels"
+	}
+});
+const collectDiscordSecurityFindings = createConditionalWarningCollector.findings({
+	collectWarnings: collectDiscordSecurityWarnings,
+	checkId: "channels.discord.groups.open",
+	severity: "critical",
+	title: "Discord security warning"
+});
+const loadDiscordSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit.runtime-DHtYenx9.mjs"));
+const discordSecurityAdapter = {
+	resolveDmPolicy: resolveDiscordDmPolicy,
+	collectWarnings: collectDiscordSecurityFindings,
+	collectAuditFindings: async (params) => (await loadDiscordSecurityAuditModule()).collectDiscordSecurityAuditFindings(params)
+};
+//#endregion
+//#region extensions/discord/src/setup-adapter.ts
+const discordSetupAdapter = createEnvPatchedAccountSetupAdapter({
+	channelKey: "discord",
+	defaultAccountOnlyEnvError: "DISCORD_BOT_TOKEN can only be used for the default account.",
+	missingCredentialError: "Discord requires token (or --use-env).",
+	hasCredentials: (input) => Boolean(input.token),
+	buildPatch: (input) => input.token ? { token: input.token } : {}
+});
+const discordSetupContract = defineChannelSetupContract({
+	fields: {
+		token: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--token <token>",
+				description: "Discord bot token"
+			}
+		},
+		useEnv: {
+			kind: "boolean",
+			cli: {
+				flags: "--use-env",
+				description: "Use DISCORD_BOT_TOKEN"
+			},
+			envVars: ["DISCORD_BOT_TOKEN"]
+		}
+	},
+	legacyAdapter: discordSetupAdapter
+});
+//#endregion
+//#region extensions/discord/src/doctor-shared.ts
+const DISCORD_LEGACY_CONFIG_RULES = [];
+//#endregion
+//#region extensions/discord/src/shared.ts
+const DISCORD_CHANNEL = "discord";
+const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-BHWMlh0v.mjs"));
+const discordDoctor = {
+	dmAllowFromMode: "topOnly",
+	groupModel: "route",
+	groupAllowFromFallbackToAllowFrom: false,
+	warnOnEmptyGroupSenderAllowlist: false,
+	legacyConfigRules: DISCORD_LEGACY_CONFIG_RULES,
+	normalizeCompatibilityConfig,
+	collectPreviewWarnings: async (params) => (await loadDiscordDoctorModule()).discordDoctor.collectPreviewWarnings?.(params) ?? [],
+	collectMutableAllowlistWarnings: async (params) => (await loadDiscordDoctorModule()).discordDoctor.collectMutableAllowlistWarnings?.(params) ?? [],
+	repairConfig: async (params) => (await loadDiscordDoctorModule()).discordDoctor.repairConfig?.(params) ?? {
+		config: params.cfg,
+		changes: []
+	}
+};
+function resolveDiscordConfigAccessorAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const config = mergeDiscordAccountConfig(params.cfg, accountId);
+	return {
+		allowFrom: resolveDiscordAccountAllowFrom({
+			cfg: params.cfg,
+			accountId
+		}),
+		defaultTo: config.defaultTo
+	};
+}
+const discordConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: DISCORD_CHANNEL,
+	listAccountIds: listDiscordAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveDiscordAccount),
+	resolveAccessorAccount: resolveDiscordConfigAccessorAccount,
+	inspectAccount: adaptScopedAccountAccessor(inspectDiscordAccount),
+	defaultAccountId: resolveDefaultDiscordAccountId,
+	clearBaseFields: ["token", "name"],
+	resolveAllowFrom: (account) => account.allowFrom,
+	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
+	resolveDefaultTo: (account) => account.defaultTo
+});
+function createDiscordPluginBase(params) {
+	return {
+		id: DISCORD_CHANNEL,
+		setupContract: params.setupContract,
+		...params.setupWizard ? { setupWizard: params.setupWizard } : {},
+		meta: { ...getChatChannelMeta(DISCORD_CHANNEL) },
+		capabilities: {
+			chatTypes: [
+				"direct",
+				"channel",
+				"thread"
+			],
+			polls: true,
+			reactions: true,
+			threads: true,
+			media: true,
+			tts: { voice: { synthesisTarget: "voice-note" } },
+			nativeCommands: true
+		},
+		commands: {
+			nativeCommandsAutoEnabled: true,
+			nativeSkillsAutoEnabled: true,
+			resolveNativeCommandName: ({ commandKey, defaultName }) => commandKey === "tts" ? "voice" : defaultName
+		},
+		doctor: discordDoctor,
+		streaming: { blockStreamingCoalesceDefaults: {
+			minChars: 1500,
+			idleMs: 1e3
+		} },
+		reload: { configPrefixes: ["channels.discord"] },
+		configSchema: DiscordChannelConfigSchema,
+		config: {
+			...discordConfigAdapter,
+			hasConfiguredState: ({ env }) => typeof env?.DISCORD_BOT_TOKEN === "string" && env.DISCORD_BOT_TOKEN.trim().length > 0,
+			isEnabled: (account, cfg) => isDiscordAccountEnabledForRuntime(account, cfg),
+			disabledReason: (account, cfg) => resolveDiscordAccountDisabledReason(account, cfg),
+			isConfigured: (account) => resolveConfiguredFromCredentialStatuses$1(account) ?? Boolean(account.token?.trim()),
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: resolveConfiguredFromCredentialStatuses$1(account) ?? Boolean(account.token?.trim()),
+				extra: {
+					tokenSource: account.tokenSource,
+					tokenStatus: account.tokenStatus
+				}
+			})
+		},
+		messaging: { deriveLegacySessionChatType },
+		security: discordSecurityAdapter,
+		secrets: {
+			secretTargetRegistryEntries,
+			unsupportedSecretRefSurfacePatterns,
+			collectUnsupportedSecretRefConfigCandidates,
+			collectRuntimeConfigAssignments
+		}
+	};
+}
+//#endregion
+export { discordSecurityAdapter as a, buildTokenChannelStatusSummary as c, discordSetupContract as i, projectCredentialSnapshotFields as l, discordConfigAdapter as n, DEFAULT_ACCOUNT_ID$1 as o, DISCORD_LEGACY_CONFIG_RULES as r, PAIRING_APPROVED_MESSAGE as s, createDiscordPluginBase as t, resolveConfiguredFromCredentialStatuses$1 as u };

package/dist/.setup/subagent-hooks-D78_6mH2.mjs

@@ -0,0 +1,49 @@
+import { on as __exportAll } from "./retry-B_XP5NOZ.mjs";
+import { o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-DB2lxpj7.mjs";
+import { normalizeOptionalLowercaseString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/discord/src/subagent-hooks.ts
+var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
+	handleDiscordSubagentDeliveryTarget: () => handleDiscordSubagentDeliveryTarget,
+	handleDiscordSubagentEnded: () => handleDiscordSubagentEnded
+});
+function normalizeThreadBindingTargetKind(raw) {
+	const normalized = normalizeOptionalLowercaseString(raw);
+	if (normalized === "subagent" || normalized === "acp") return normalized;
+}
+function handleDiscordSubagentEnded(event) {
+	unbindThreadBindingsBySessionKey({
+		targetSessionKey: event.targetSessionKey,
+		accountId: event.accountId,
+		targetKind: normalizeThreadBindingTargetKind(event.targetKind),
+		reason: event.reason,
+		sendFarewell: event.sendFarewell
+	});
+}
+function handleDiscordSubagentDeliveryTarget(event) {
+	if (!event.expectsCompletionMessage) return;
+	if (normalizeOptionalLowercaseString(event.requesterOrigin?.channel) !== "discord") return;
+	const requesterAccountId = event.requesterOrigin?.accountId?.trim();
+	const requesterThreadId = event.requesterOrigin?.threadId != null && event.requesterOrigin.threadId !== "" ? normalizeOptionalStringifiedId(event.requesterOrigin.threadId) ?? "" : "";
+	const bindings = listThreadBindingsBySessionKey({
+		targetSessionKey: event.childSessionKey,
+		...requesterAccountId ? { accountId: requesterAccountId } : {},
+		targetKind: "subagent"
+	});
+	if (bindings.length === 0) return;
+	let binding;
+	if (requesterThreadId) binding = bindings.find((entry) => {
+		if (entry.threadId !== requesterThreadId) return false;
+		if (requesterAccountId && entry.accountId !== requesterAccountId) return false;
+		return true;
+	});
+	if (!binding && bindings.length === 1) binding = bindings[0];
+	if (!binding) return;
+	return { origin: {
+		channel: "discord",
+		accountId: binding.accountId,
+		to: `channel:${binding.threadId}`,
+		threadId: binding.threadId
+	} };
+}
+//#endregion
+export { handleDiscordSubagentEnded as n, subagent_hooks_exports as r, handleDiscordSubagentDeliveryTarget as t };

package/dist/.setup/system-events-CpvWZtoY.mjs

@@ -0,0 +1,34 @@
+import { y as discord_exports } from "./retry-B_XP5NOZ.mjs";
+import { x as formatDiscordUserTag } from "./allow-list-C2JuH-R0.mjs";
+//#region extensions/discord/src/monitor/system-events.ts
+function resolveDiscordSystemEvent(message, location) {
+	switch (message.type) {
+		case discord_exports.MessageType.ChannelPinnedMessage: return buildDiscordSystemEvent(message, location, "pinned a message");
+		case discord_exports.MessageType.RecipientAdd: return buildDiscordSystemEvent(message, location, "added a recipient");
+		case discord_exports.MessageType.RecipientRemove: return buildDiscordSystemEvent(message, location, "removed a recipient");
+		case discord_exports.MessageType.UserJoin: return buildDiscordSystemEvent(message, location, "user joined");
+		case discord_exports.MessageType.GuildBoost: return buildDiscordSystemEvent(message, location, "boosted the server");
+		case discord_exports.MessageType.GuildBoostTier1: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 1 reached)");
+		case discord_exports.MessageType.GuildBoostTier2: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 2 reached)");
+		case discord_exports.MessageType.GuildBoostTier3: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 3 reached)");
+		case discord_exports.MessageType.ThreadCreated: return buildDiscordSystemEvent(message, location, "created a thread");
+		case discord_exports.MessageType.AutoModerationAction: return buildDiscordSystemEvent(message, location, "auto moderation action");
+		case discord_exports.MessageType.GuildIncidentAlertModeEnabled: return buildDiscordSystemEvent(message, location, "raid protection enabled");
+		case discord_exports.MessageType.GuildIncidentAlertModeDisabled: return buildDiscordSystemEvent(message, location, "raid protection disabled");
+		case discord_exports.MessageType.GuildIncidentReportRaid: return buildDiscordSystemEvent(message, location, "raid reported");
+		case discord_exports.MessageType.GuildIncidentReportFalseAlarm: return buildDiscordSystemEvent(message, location, "raid report marked false alarm");
+		case discord_exports.MessageType.StageStart: return buildDiscordSystemEvent(message, location, "stage started");
+		case discord_exports.MessageType.StageEnd: return buildDiscordSystemEvent(message, location, "stage ended");
+		case discord_exports.MessageType.StageSpeaker: return buildDiscordSystemEvent(message, location, "stage speaker updated");
+		case discord_exports.MessageType.StageTopic: return buildDiscordSystemEvent(message, location, "stage topic updated");
+		case discord_exports.MessageType.PollResult: return buildDiscordSystemEvent(message, location, "poll results posted");
+		case discord_exports.MessageType.PurchaseNotification: return buildDiscordSystemEvent(message, location, "purchase notification");
+		default: return null;
+	}
+}
+function buildDiscordSystemEvent(message, location, action) {
+	const authorLabel = message.author ? formatDiscordUserTag(message.author) : "";
+	return `Discord system: ${authorLabel ? `${authorLabel} ` : ""}${action} in ${location}`;
+}
+//#endregion
+export { resolveDiscordSystemEvent };

package/dist/.setup/target-resolver-C1JWPpuA.mjs

@@ -0,0 +1,83 @@
+import { _ as parseDiscordTarget, on as __exportAll, p as allowFromContainsDiscordUserId } from "./retry-B_XP5NOZ.mjs";
+import { c as resolveDiscordAccount, l as resolveDiscordAccountAllowFrom } from "./accounts-CwJQoLjM.mjs";
+import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-N2I3Zs-M.mjs";
+import { buildMessagingTarget } from "openclaw/plugin-sdk/channel-targets";
+//#region extensions/discord/src/send-target-parsing.ts
+const parseDiscordSendTarget = (raw, options = {}) => parseDiscordTarget(raw, options);
+//#endregion
+//#region extensions/discord/src/target-resolver.ts
+var target_resolver_exports = /* @__PURE__ */ __exportAll({
+	parseAndResolveDiscordTarget: () => parseAndResolveDiscordTarget,
+	resolveDiscordTarget: () => resolveDiscordTarget
+});
+/**
+* Resolve a Discord username to user ID using the directory lookup.
+* This enables sending DMs by username instead of requiring explicit user IDs.
+*/
+async function resolveDiscordTarget(raw, options, parseOptions = {}) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	const likelyUsername = isLikelyUsername(trimmed);
+	const shouldLookup = isExplicitUserLookup(trimmed, parseOptions) || likelyUsername;
+	if (/^\d+$/.test(trimmed) && parseOptions.defaultKind !== "user" && isConfiguredAllowedDiscordDmUser(trimmed, options)) return buildMessagingTarget("user", trimmed, trimmed);
+	const directParse = safeParseDiscordTarget(trimmed, parseOptions);
+	if (directParse && directParse.kind !== "channel" && !likelyUsername) return directParse;
+	if (!shouldLookup) return directParse ?? parseDiscordSendTarget(trimmed, parseOptions);
+	try {
+		const match = (await listDiscordDirectoryPeersLive({
+			...options,
+			query: trimmed,
+			limit: 1
+		}))[0];
+		if (match && match.kind === "user") {
+			const userId = match.id.replace(/^user:/, "");
+			const resolvedAccountId = resolveDiscordAccount({
+				cfg: options.cfg,
+				accountId: options.accountId
+			}).accountId;
+			rememberDiscordDirectoryUser({
+				accountId: resolvedAccountId,
+				userId,
+				handles: [
+					trimmed,
+					match.name,
+					match.handle
+				]
+			});
+			return buildMessagingTarget("user", userId, trimmed);
+		}
+	} catch {}
+	return parseDiscordSendTarget(trimmed, parseOptions);
+}
+async function parseAndResolveDiscordTarget(raw, options, parseOptions = {}) {
+	const resolved = await resolveDiscordTarget(raw, options, parseOptions) ?? parseDiscordSendTarget(raw, parseOptions);
+	if (!resolved) throw new Error("Recipient is required for Discord sends");
+	return resolved;
+}
+function safeParseDiscordTarget(input, options) {
+	try {
+		return parseDiscordSendTarget(input, options);
+	} catch {
+		return;
+	}
+}
+function isConfiguredAllowedDiscordDmUser(input, options) {
+	const allowFrom = resolveDiscordAccountAllowFrom({
+		cfg: options.cfg,
+		accountId: options.accountId
+	}) ?? [];
+	return allowFromContainsDiscordUserId(allowFrom, input);
+}
+function isExplicitUserLookup(input, options) {
+	if (/^<@!?(\d+)>$/.test(input)) return true;
+	if (/^(user:|discord:)/.test(input)) return true;
+	if (input.startsWith("@")) return true;
+	if (/^\d+$/.test(input)) return options.defaultKind === "user";
+	return false;
+}
+function isLikelyUsername(input) {
+	if (/^(user:|channel:|discord:|@|<@!?)|[\d]+$/.test(input)) return false;
+	return true;
+}
+//#endregion
+export { parseDiscordSendTarget as i, resolveDiscordTarget as n, target_resolver_exports as r, parseAndResolveDiscordTarget as t };

package/dist/.setup/targets-BdyllneU.mjs

@@ -0,0 +1,3 @@
+import "./retry-B_XP5NOZ.mjs";
+import "./target-resolver-C1JWPpuA.mjs";
+export {};

package/dist/.setup/thread-bindings-DB2lxpj7.mjs

@@ -0,0 +1,238 @@
+import { _ as parseDiscordTarget, on as __exportAll } from "./retry-B_XP5NOZ.mjs";
+import "./targets-BdyllneU.mjs";
+import { C as resolveThreadBindingMaxAgeExpiresAt, O as shouldPersistBindingMutations, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, h as refreshUnboundThreadWebhookIdentity, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1 } from "./thread-bindings.state-CIba-55B.mjs";
+import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-D04Avc2y.mjs";
+import { _ as resolveThreadBindingThreadName, g as resolveThreadBindingIntroText, h as formatThreadBindingDurationLabel, m as resolveThreadBindingPersonaFromRecord, n as createThreadBindingManager, o as resolveChannelIdForBinding, p as resolveThreadBindingPersona, r as getThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-BgOMPrjG.mjs";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalLowercaseString, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
+import { readAcpSessionEntry } from "openclaw/plugin-sdk/acp-runtime";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
+//#region extensions/discord/src/monitor/thread-bindings.config.ts
+function resolveDiscordThreadBindingIdleTimeoutMs(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const root = params.cfg.channels?.discord?.threadBindings;
+	const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
+	return resolveThreadBindingIdleTimeoutMs({
+		channelIdleHoursRaw: account?.idleHours ?? root?.idleHours,
+		sessionIdleHoursRaw: params.cfg.session?.threadBindings?.idleHours
+	});
+}
+function resolveDiscordThreadBindingMaxAgeMs(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const root = params.cfg.channels?.discord?.threadBindings;
+	const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
+	return resolveThreadBindingMaxAgeMs({
+		channelMaxAgeHoursRaw: account?.maxAgeHours ?? root?.maxAgeHours,
+		sessionMaxAgeHoursRaw: params.cfg.session?.threadBindings?.maxAgeHours
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.lifecycle.ts
+const ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT = 8;
+function listThreadBindingsForAccount(accountId) {
+	const manager = getThreadBindingManager(accountId);
+	if (!manager) return [];
+	return manager.listBindings();
+}
+function listThreadBindingsBySessionKey(params) {
+	return resolveBindingIdsForTargetSession(params).map((bindingKey) => BINDINGS_BY_THREAD_ID.get(bindingKey)).filter((entry) => Boolean(entry));
+}
+async function autoBindSpawnedDiscordSubagent(params) {
+	if (normalizeOptionalLowercaseString(params.channel) !== "discord") return null;
+	const manager = getThreadBindingManager(params.accountId);
+	if (!manager) return null;
+	const managerToken = getThreadBindingToken(manager.accountId);
+	const requesterThreadId = normalizeThreadId(params.threadId);
+	let channelId = "";
+	if (requesterThreadId) {
+		const existing = manager.getByThreadId(requesterThreadId);
+		if (existing?.channelId?.trim()) channelId = existing.channelId.trim();
+		else channelId = await resolveChannelIdForBinding({
+			cfg: params.cfg,
+			accountId: manager.accountId,
+			token: managerToken,
+			threadId: requesterThreadId
+		}) ?? "";
+	}
+	if (!channelId) {
+		const to = normalizeOptionalString(params.to) ?? "";
+		if (!to) return null;
+		try {
+			const target = parseDiscordTarget(to, { defaultKind: "channel" });
+			if (!target || target.kind !== "channel") return null;
+			channelId = await resolveChannelIdForBinding({
+				cfg: params.cfg,
+				accountId: manager.accountId,
+				token: managerToken,
+				threadId: target.id
+			}) ?? "";
+		} catch {
+			return null;
+		}
+	}
+	return await manager.bindTarget({
+		threadId: void 0,
+		channelId,
+		createThread: true,
+		threadName: resolveThreadBindingThreadName({
+			agentId: params.agentId,
+			label: params.label
+		}),
+		targetKind: "subagent",
+		targetSessionKey: params.childSessionKey,
+		agentId: params.agentId,
+		label: params.label,
+		boundBy: params.boundBy ?? "system",
+		introText: resolveThreadBindingIntroText({
+			agentId: params.agentId,
+			label: params.label,
+			idleTimeoutMs: manager.getIdleTimeoutMs(),
+			maxAgeMs: manager.getMaxAgeMs()
+		})
+	});
+}
+function unbindThreadBindingsBySessionKey(params) {
+	const ids = resolveBindingIdsForTargetSession(params);
+	if (ids.length === 0) return [];
+	const removed = [];
+	for (const bindingKey of ids) {
+		const record = BINDINGS_BY_THREAD_ID.get(bindingKey);
+		if (!record) continue;
+		const manager = MANAGERS_BY_ACCOUNT_ID.get(record.accountId);
+		if (manager) {
+			const unbound = manager.unbindThread({
+				threadId: record.threadId,
+				reason: params.reason,
+				sendFarewell: params.sendFarewell,
+				farewellText: params.farewellText
+			});
+			if (unbound) removed.push(unbound);
+			continue;
+		}
+		const unbound = removeBindingRecord(bindingKey);
+		if (unbound) {
+			refreshUnboundThreadWebhookIdentity(unbound);
+			removed.push(unbound);
+		}
+	}
+	if (removed.length > 0 && shouldPersistBindingMutations()) saveBindingsToDisk({ force: true });
+	return removed;
+}
+function resolveStoredAcpBindingHealth(params) {
+	if (!params.session.acp) return "stale";
+	return "healthy";
+}
+async function reconcileAcpThreadBindingsOnStartup(params) {
+	const manager = getThreadBindingManager(params.accountId);
+	if (!manager) return {
+		checked: 0,
+		removed: 0,
+		staleSessionKeys: []
+	};
+	const acpBindings = manager.listBindings().filter((binding) => binding.targetKind === "acp" && binding.metadata?.pluginBindingOwner !== "plugin");
+	const staleBindings = [];
+	const probeTargets = [];
+	for (const binding of acpBindings) {
+		const sessionKey = binding.targetSessionKey.trim();
+		if (!sessionKey) {
+			staleBindings.push(binding);
+			continue;
+		}
+		const session = readAcpSessionEntry({
+			cfg: params.cfg,
+			sessionKey,
+			agentId: binding.agentId
+		});
+		if (!session) {
+			staleBindings.push(binding);
+			continue;
+		}
+		if (session.storeReadFailed) continue;
+		if (resolveStoredAcpBindingHealth({ session }) === "stale") {
+			staleBindings.push(binding);
+			continue;
+		}
+		if (!params.healthProbe) continue;
+		probeTargets.push({
+			binding,
+			sessionKey,
+			session
+		});
+	}
+	if (params.healthProbe && probeTargets.length > 0) {
+		const { results: probeResults } = await runTasksWithConcurrency({
+			tasks: probeTargets.map(({ binding, sessionKey, session }) => async () => {
+				try {
+					return {
+						binding,
+						status: (await params.healthProbe?.({
+							cfg: params.cfg,
+							accountId: manager.accountId,
+							sessionKey,
+							binding,
+							session
+						}))?.status ?? "uncertain"
+					};
+				} catch {
+					return {
+						binding,
+						status: "uncertain"
+					};
+				}
+			}),
+			limit: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
+			errorMode: "stop",
+			throwOnError: true
+		});
+		for (const probeResult of probeResults) if (probeResult.status === "stale") staleBindings.push(probeResult.binding);
+	}
+	if (staleBindings.length === 0) return {
+		checked: acpBindings.length,
+		removed: 0,
+		staleSessionKeys: []
+	};
+	const staleSessionKeys = [];
+	let removed = 0;
+	for (const binding of staleBindings) {
+		staleSessionKeys.push(binding.targetSessionKey);
+		if (manager.unbindThread({
+			threadId: binding.threadId,
+			reason: "stale-session",
+			sendFarewell: params.sendFarewell ?? false
+		})) removed += 1;
+	}
+	return {
+		checked: acpBindings.length,
+		removed,
+		staleSessionKeys: uniqueStrings(staleSessionKeys)
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.ts
+var thread_bindings_exports = /* @__PURE__ */ __exportAll({
+	autoBindSpawnedDiscordSubagent: () => autoBindSpawnedDiscordSubagent,
+	createNoopThreadBindingManager: () => createNoopThreadBindingManager,
+	createThreadBindingManager: () => createThreadBindingManager,
+	formatThreadBindingDurationLabel: () => formatThreadBindingDurationLabel,
+	getThreadBindingManager: () => getThreadBindingManager,
+	listThreadBindingsBySessionKey: () => listThreadBindingsBySessionKey,
+	listThreadBindingsForAccount: () => listThreadBindingsForAccount,
+	reconcileAcpThreadBindingsOnStartup: () => reconcileAcpThreadBindingsOnStartup,
+	resolveDiscordThreadBindingIdleTimeoutMs: () => resolveDiscordThreadBindingIdleTimeoutMs,
+	resolveDiscordThreadBindingMaxAgeMs: () => resolveDiscordThreadBindingMaxAgeMs,
+	resolveThreadBindingIdleTimeoutMs: () => resolveThreadBindingIdleTimeoutMs$1,
+	resolveThreadBindingInactivityExpiresAt: () => resolveThreadBindingInactivityExpiresAt,
+	resolveThreadBindingIntroText: () => resolveThreadBindingIntroText,
+	resolveThreadBindingMaxAgeExpiresAt: () => resolveThreadBindingMaxAgeExpiresAt,
+	resolveThreadBindingMaxAgeMs: () => resolveThreadBindingMaxAgeMs$1,
+	resolveThreadBindingPersona: () => resolveThreadBindingPersona,
+	resolveThreadBindingPersonaFromRecord: () => resolveThreadBindingPersonaFromRecord,
+	resolveThreadBindingThreadName: () => resolveThreadBindingThreadName,
+	resolveThreadBindingsEnabled: () => resolveThreadBindingsEnabled,
+	setThreadBindingIdleTimeoutBySessionKey: () => setThreadBindingIdleTimeoutBySessionKey,
+	setThreadBindingMaxAgeBySessionKey: () => setThreadBindingMaxAgeBySessionKey,
+	unbindThreadBindingsBySessionKey: () => unbindThreadBindingsBySessionKey
+});
+//#endregion
+export { reconcileAcpThreadBindingsOnStartup as a, resolveDiscordThreadBindingMaxAgeMs as c, listThreadBindingsForAccount as i, resolveThreadBindingsEnabled as l, autoBindSpawnedDiscordSubagent as n, unbindThreadBindingsBySessionKey as o, listThreadBindingsBySessionKey as r, resolveDiscordThreadBindingIdleTimeoutMs as s, thread_bindings_exports as t };