@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/dist/thread-bindings-Bj1R-6QH.js

@@ -0,0 +1,256 @@
+import { t as __exportAll } from "./rolldown-runtime-C3SqQTfK.js";
+import { o as parseDiscordTarget } from "./normalize-B-ktw-T_.js";
+import "./targets-kKlbZ4ai.js";
+import { C as resolveThreadBindingMaxAgeMs$1, O as shouldPersistBindingMutations, S as resolveThreadBindingMaxAgeExpiresAt, T as saveBindingsToDisk, b as resolveThreadBindingIdleTimeoutMs$1, c as getThreadBindingToken, f as normalizeThreadId, g as removeBindingRecord, l as isRecentlyUnboundThreadWebhookMessage, n as MANAGERS_BY_ACCOUNT_ID, p as rememberRecentUnboundWebhookEcho, t as BINDINGS_BY_THREAD_ID, x as resolveThreadBindingInactivityExpiresAt } from "./thread-bindings.state-Dzu1gCE7.js";
+import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-TTP020qQ.js";
+import { d as formatThreadBindingDurationLabel, l as resolveThreadBindingPersona, m as resolveThreadBindingThreadName, p as resolveThreadBindingIntroText, s as resolveChannelIdForBinding, u as resolveThreadBindingPersonaFromRecord } from "./thread-bindings.discord-api-ClPMuIr8.js";
+import { i as getThreadBindingManager, n as createNoopThreadBindingManager, r as createThreadBindingManager, t as __testing } from "./thread-bindings.manager-BaN0l4y8.js";
+import { normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
+import { readAcpSessionEntry } from "openclaw/plugin-sdk/acp-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;
+async function mapWithConcurrency(params) {
+	if (params.items.length === 0) return [];
+	const limit = Math.max(1, Math.floor(params.limit));
+	const resultsByIndex = /* @__PURE__ */ new Map();
+	let nextIndex = 0;
+	const runWorker = async () => {
+		for (;;) {
+			const index = nextIndex;
+			nextIndex += 1;
+			if (index >= params.items.length) return;
+			resultsByIndex.set(index, await params.worker(params.items[index], index));
+		}
+	};
+	const workers = Array.from({ length: Math.min(limit, params.items.length) }, () => runWorker());
+	await Promise.all(workers);
+	return params.items.map((_item, index) => resultsByIndex.get(index));
+}
+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) {
+			rememberRecentUnboundWebhookEcho(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
+		});
+		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 probeResults = await mapWithConcurrency({
+			items: probeTargets,
+			limit: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
+			worker: async ({ binding, sessionKey, session }) => {
+				try {
+					return {
+						binding,
+						status: (await params.healthProbe?.({
+							cfg: params.cfg,
+							accountId: manager.accountId,
+							sessionKey,
+							binding,
+							session
+						}))?.status ?? "uncertain"
+					};
+				} catch {
+					return {
+						binding,
+						status: "uncertain"
+					};
+				}
+			}
+		});
+		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: [...new Set(staleSessionKeys)]
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.ts
+var thread_bindings_exports = /* @__PURE__ */ __exportAll({
+	__testing: () => __testing,
+	autoBindSpawnedDiscordSubagent: () => autoBindSpawnedDiscordSubagent,
+	createNoopThreadBindingManager: () => createNoopThreadBindingManager,
+	createThreadBindingManager: () => createThreadBindingManager,
+	formatThreadBindingDurationLabel: () => formatThreadBindingDurationLabel,
+	getThreadBindingManager: () => getThreadBindingManager,
+	isRecentlyUnboundThreadWebhookMessage: () => isRecentlyUnboundThreadWebhookMessage,
+	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 };

package/dist/thread-bindings.discord-api-ClPMuIr8.js

@@ -0,0 +1,184 @@
+import { s as resolveDiscordChannelId } from "./normalize-B-ktw-T_.js";
+import { at as getChannel, q as createChannelWebhook } from "./discord-D1kDh0X_.js";
+import { N as createDiscordRestClient } from "./send.shared-Db0opnak.js";
+import { c as sendWebhookMessageDiscord, u as createThreadDiscord } from "./send-B_frVn_Q.js";
+import { t as sendMessageDiscord } from "./send.outbound-DlBAuW7y.js";
+import { i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, k as toReusableWebhookKey, m as rememberReusableWebhook, t as BINDINGS_BY_THREAD_ID } from "./thread-bindings.state-Dzu1gCE7.js";
+import { n as resolveDiscordChannelInfoSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-ewDxhd9q.js";
+import { SYSTEM_MARK, normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import { ChannelType } from "discord-api-types/v10";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { formatThreadBindingDurationLabel, resolveThreadBindingFarewellText, resolveThreadBindingIntroText, resolveThreadBindingThreadName } from "openclaw/plugin-sdk/conversation-runtime";
+//#region extensions/discord/src/monitor/thread-bindings.persona.ts
+const THREAD_BINDING_PERSONA_MAX_CHARS = 80;
+function normalizePersonaLabel(value) {
+	if (!value) return;
+	return value.replace(/\s+/g, " ").trim() || void 0;
+}
+function resolveThreadBindingPersona(params) {
+	return `${SYSTEM_MARK} ${normalizePersonaLabel(params.label) || normalizePersonaLabel(params.agentId) || "agent"}`.slice(0, THREAD_BINDING_PERSONA_MAX_CHARS);
+}
+function resolveThreadBindingPersonaFromRecord(record) {
+	return resolveThreadBindingPersona({
+		label: record.label,
+		agentId: record.agentId
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.discord-api.ts
+function buildThreadTarget(threadId) {
+	return /^(channel:|user:)/i.test(threadId) ? threadId : `channel:${threadId}`;
+}
+function isThreadArchived(raw) {
+	if (!raw || typeof raw !== "object") return false;
+	const asRecord = raw;
+	if (asRecord.archived === true) return true;
+	if (asRecord.thread_metadata?.archived === true) return true;
+	if (asRecord.threadMetadata?.archived === true) return true;
+	return false;
+}
+function isThreadChannelType(type) {
+	return type === ChannelType.PublicThread || type === ChannelType.PrivateThread || type === ChannelType.AnnouncementThread;
+}
+function normalizeDiscordBindingChannelId(raw) {
+	const trimmed = normalizeOptionalString(raw) ?? "";
+	if (!trimmed) return null;
+	try {
+		return resolveDiscordChannelId(trimmed);
+	} catch {
+		return null;
+	}
+}
+function summarizeDiscordError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint" || typeof err === "symbol") return String(err);
+	return "error";
+}
+function extractNumericDiscordErrorValue(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
+	if (typeof value === "string" && /^\d+$/.test(value.trim())) return Number(value);
+}
+function extractDiscordErrorStatus(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = err;
+	return extractNumericDiscordErrorValue(candidate.status) ?? extractNumericDiscordErrorValue(candidate.statusCode) ?? extractNumericDiscordErrorValue(candidate.response?.status);
+}
+function extractDiscordErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = err;
+	return extractNumericDiscordErrorValue(candidate.code) ?? extractNumericDiscordErrorValue(candidate.rawError?.code) ?? extractNumericDiscordErrorValue(candidate.body?.code) ?? extractNumericDiscordErrorValue(candidate.response?.body?.code) ?? extractNumericDiscordErrorValue(candidate.response?.data?.code);
+}
+function isDiscordThreadGoneError(err) {
+	if (extractDiscordErrorCode(err) === 10003) return true;
+	const status = extractDiscordErrorStatus(err);
+	return status === 404 || status === 403;
+}
+async function maybeSendBindingMessage(params) {
+	const text = params.text.trim();
+	if (!text) return;
+	const record = params.record;
+	if (params.preferWebhook !== false && record.webhookId && record.webhookToken) try {
+		await sendWebhookMessageDiscord(text, {
+			cfg: params.cfg,
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken,
+			accountId: record.accountId,
+			threadId: record.threadId,
+			username: resolveThreadBindingPersonaFromRecord(record)
+		});
+		return;
+	} catch (err) {
+		logVerbose(`discord thread binding webhook send failed: ${summarizeDiscordError(err)}`);
+	}
+	try {
+		await sendMessageDiscord(buildThreadTarget(record.threadId), text, {
+			cfg: params.cfg,
+			accountId: record.accountId
+		});
+	} catch (err) {
+		logVerbose(`discord thread binding fallback send failed: ${summarizeDiscordError(err)}`);
+	}
+}
+async function createWebhookForChannel(params) {
+	try {
+		const rest = createDiscordRestClient({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}).rest;
+		const created = await createChannelWebhook(rest, params.channelId, { body: { name: "OpenClaw Agents" } });
+		const webhookId = normalizeOptionalString(created?.id) ?? "";
+		const webhookToken = normalizeOptionalString(created?.token) ?? "";
+		if (!webhookId || !webhookToken) return {};
+		return {
+			webhookId,
+			webhookToken
+		};
+	} catch (err) {
+		logVerbose(`discord thread binding webhook create failed for ${params.channelId}: ${summarizeDiscordError(err)}`);
+		return {};
+	}
+}
+function findReusableWebhook(params) {
+	const reusableKey = toReusableWebhookKey({
+		accountId: params.accountId,
+		channelId: params.channelId
+	});
+	const cached = REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.get(reusableKey);
+	if (cached) return {
+		webhookId: cached.webhookId,
+		webhookToken: cached.webhookToken
+	};
+	for (const record of BINDINGS_BY_THREAD_ID.values()) {
+		if (record.accountId !== params.accountId) continue;
+		if (record.channelId !== params.channelId) continue;
+		if (!record.webhookId || !record.webhookToken) continue;
+		rememberReusableWebhook(record);
+		return {
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken
+		};
+	}
+	return {};
+}
+async function resolveChannelIdForBinding(params) {
+	const explicit = normalizeDiscordBindingChannelId(params.channelId);
+	if (explicit) return explicit;
+	const lookupThreadId = normalizeDiscordBindingChannelId(params.threadId);
+	if (!lookupThreadId) return null;
+	try {
+		const rest = createDiscordRestClient({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}).rest;
+		const channel = await getChannel(rest, lookupThreadId);
+		const channelInfo = resolveDiscordChannelInfoSafe(channel);
+		const channelId = normalizeOptionalString(resolveDiscordChannelIdSafe(channel)) ?? "";
+		const type = channelInfo.type;
+		const parentId = normalizeOptionalString(channelInfo.parentId) ?? "";
+		if (parentId && isThreadChannelType(type)) return parentId;
+		return channelId || null;
+	} catch (err) {
+		logVerbose(`discord thread binding channel resolve failed for ${lookupThreadId}: ${summarizeDiscordError(err)}`);
+		return null;
+	}
+}
+async function createThreadForBinding(params) {
+	try {
+		return (normalizeOptionalString((await createThreadDiscord(params.channelId, {
+			name: params.threadName,
+			autoArchiveMinutes: 60
+		}, {
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}))?.id) ?? "") || null;
+	} catch (err) {
+		logVerbose(`discord thread binding auto-thread create failed for ${params.channelId}: ${summarizeDiscordError(err)}`);
+		return null;
+	}
+}
+//#endregion
+export { isThreadArchived as a, summarizeDiscordError as c, formatThreadBindingDurationLabel as d, resolveThreadBindingFarewellText as f, isDiscordThreadGoneError as i, resolveThreadBindingPersona as l, resolveThreadBindingThreadName as m, createWebhookForChannel as n, maybeSendBindingMessage as o, resolveThreadBindingIntroText as p, findReusableWebhook as r, resolveChannelIdForBinding as s, createThreadForBinding as t, resolveThreadBindingPersonaFromRecord as u };