@gaodefa/daocore 2026.5.54 → 2026.5.56

package/dist/thread-bindings-nJ5yQbn5.js

@@ -0,0 +1,232 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DyL154ka.js";
+import { n as normalizeAccountId } from "./account-id-B32J-iNN.js";
+import { n as readAcpSessionEntry } from "./session-meta-D0EJkrLy.js";
+import { a as resolveThreadBindingIdleTimeoutMs, s as resolveThreadBindingMaxAgeMs } from "./thread-bindings-policy-BZBsdp3j.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import "./routing-AC-P99jg.js";
+import "./conversation-runtime-DtEjS-G-.js";
+import { i as resolveThreadBindingThreadName, r as resolveThreadBindingIntroText } from "./thread-bindings-messages-D73K8IGt.js";
+import "./acp-runtime-BK9aeb-F.js";
+import { t as parseDiscordTarget } from "./target-parsing-D1FhMbX6.js";
+import "./targets-BoRwMAy3.js";
+import { O as shouldPersistBindingMutations, T as saveBindingsToDisk, c as getThreadBindingToken, f as normalizeThreadId, g as removeBindingRecord, n as MANAGERS_BY_ACCOUNT_ID, p as rememberRecentUnboundWebhookEcho, t as BINDINGS_BY_THREAD_ID } from "./thread-bindings.state-BOeDs7d_.js";
+import { r as resolveBindingIdsForTargetSession } from "./thread-bindings.session-updates-DQDLDktu.js";
+import { s as resolveChannelIdForBinding } from "./thread-bindings.discord-api-Cy9zlCKJ.js";
+import { r as getThreadBindingManager } from "./thread-bindings.manager-BN6EeBr_.js";
+//#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
+export { unbindThreadBindingsBySessionKey as a, reconcileAcpThreadBindingsOnStartup as i, listThreadBindingsBySessionKey as n, resolveDiscordThreadBindingIdleTimeoutMs as o, listThreadBindingsForAccount as r, resolveDiscordThreadBindingMaxAgeMs as s, autoBindSpawnedDiscordSubagent as t };

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

@@ -0,0 +1,187 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { r as logVerbose } from "./globals-DhGeOA1P.js";
+import "./runtime-env-BSECk1Nm.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { t as SYSTEM_MARK } from "./system-message-DcYqWFJX.js";
+import "./conversation-runtime-DtEjS-G-.js";
+import "./text-chunking-ObhJDe8L.js";
+import { n as resolveDiscordChannelId } from "./target-parsing-D1FhMbX6.js";
+import { It as ChannelType, at as getChannel, q as createChannelWebhook } from "./discord-DLn5dEWC.js";
+import { N as createDiscordRestClient } from "./send.shared-DkEjcqxQ.js";
+import { l as createThreadDiscord, s as sendWebhookMessageDiscord } from "./send-BZbyJL0A.js";
+import { t as sendMessageDiscord } from "./send.outbound-C2EaQ1Hx.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-BOeDs7d_.js";
+import { n as resolveDiscordChannelInfoSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-C12aDZ0p.js";
+//#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: "DaoCore 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, isDiscordThreadGoneError as i, resolveThreadBindingPersona as l, createWebhookForChannel as n, maybeSendBindingMessage as o, findReusableWebhook as r, resolveChannelIdForBinding as s, createThreadForBinding as t, resolveThreadBindingPersonaFromRecord as u };