@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/discord/monitor/thread-bindings.manager.js

@@ -0,0 +1,423 @@
+import { Routes } from "discord-api-types/v10";
+import { logVerbose } from "../../globals.js";
+import { registerSessionBindingAdapter, unregisterSessionBindingAdapter, } from "../../infra/outbound/session-binding-service.js";
+import { normalizeAccountId, resolveAgentIdFromSessionKey } from "../../routing/session-key.js";
+import { createDiscordRestClient } from "../client.js";
+import { createThreadForBinding, createWebhookForChannel, findReusableWebhook, isDiscordThreadGoneError, isThreadArchived, maybeSendBindingMessage, resolveChannelIdForBinding, summarizeDiscordError, } from "./thread-bindings.discord-api.js";
+import { resolveThreadBindingFarewellText, resolveThreadBindingThreadName, } from "./thread-bindings.messages.js";
+import { BINDINGS_BY_THREAD_ID, forgetThreadBindingToken, getThreadBindingToken, MANAGERS_BY_ACCOUNT_ID, PERSIST_BY_ACCOUNT_ID, ensureBindingsLoaded, rememberThreadBindingToken, normalizeTargetKind, normalizeThreadBindingTtlMs, normalizeThreadId, rememberRecentUnboundWebhookEcho, removeBindingRecord, resolveBindingIdsForSession, resolveBindingRecordKey, resolveThreadBindingExpiresAt, resolveThreadBindingsPath, saveBindingsToDisk, setBindingRecord, shouldDefaultPersist, resetThreadBindingsForTests, } from "./thread-bindings.state.js";
+import { DEFAULT_THREAD_BINDING_TTL_MS, THREAD_BINDINGS_SWEEP_INTERVAL_MS, } from "./thread-bindings.types.js";
+function registerManager(manager) {
+    MANAGERS_BY_ACCOUNT_ID.set(manager.accountId, manager);
+}
+function unregisterManager(accountId, manager) {
+    const existing = MANAGERS_BY_ACCOUNT_ID.get(accountId);
+    if (existing === manager) {
+        MANAGERS_BY_ACCOUNT_ID.delete(accountId);
+    }
+}
+function createNoopManager(accountIdRaw) {
+    const accountId = normalizeAccountId(accountIdRaw);
+    return {
+        accountId,
+        getSessionTtlMs: () => DEFAULT_THREAD_BINDING_TTL_MS,
+        getByThreadId: () => undefined,
+        getBySessionKey: () => undefined,
+        listBySessionKey: () => [],
+        listBindings: () => [],
+        bindTarget: async () => null,
+        unbindThread: () => null,
+        unbindBySessionKey: () => [],
+        stop: () => { },
+    };
+}
+function toSessionBindingTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "session";
+}
+function toThreadBindingTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "acp";
+}
+function toSessionBindingRecord(record) {
+    const bindingId = resolveBindingRecordKey({
+        accountId: record.accountId,
+        threadId: record.threadId,
+    }) ?? `${record.accountId}:${record.threadId}`;
+    return {
+        bindingId,
+        targetSessionKey: record.targetSessionKey,
+        targetKind: toSessionBindingTargetKind(record.targetKind),
+        conversation: {
+            channel: "discord",
+            accountId: record.accountId,
+            conversationId: record.threadId,
+            parentConversationId: record.channelId,
+        },
+        status: "active",
+        boundAt: record.boundAt,
+        expiresAt: record.expiresAt,
+        metadata: {
+            agentId: record.agentId,
+            label: record.label,
+            webhookId: record.webhookId,
+            webhookToken: record.webhookToken,
+            boundBy: record.boundBy,
+        },
+    };
+}
+function resolveThreadIdFromBindingId(params) {
+    const bindingId = params.bindingId?.trim();
+    if (!bindingId) {
+        return undefined;
+    }
+    const prefix = `${params.accountId}:`;
+    if (!bindingId.startsWith(prefix)) {
+        return undefined;
+    }
+    const threadId = bindingId.slice(prefix.length).trim();
+    return threadId || undefined;
+}
+export function createThreadBindingManager(params = {}) {
+    ensureBindingsLoaded();
+    const accountId = normalizeAccountId(params.accountId);
+    const existing = MANAGERS_BY_ACCOUNT_ID.get(accountId);
+    if (existing) {
+        rememberThreadBindingToken({ accountId, token: params.token });
+        return existing;
+    }
+    rememberThreadBindingToken({ accountId, token: params.token });
+    const persist = params.persist ?? shouldDefaultPersist();
+    PERSIST_BY_ACCOUNT_ID.set(accountId, persist);
+    const sessionTtlMs = normalizeThreadBindingTtlMs(params.sessionTtlMs);
+    const resolveCurrentToken = () => getThreadBindingToken(accountId) ?? params.token;
+    let sweepTimer = null;
+    const manager = {
+        accountId,
+        getSessionTtlMs: () => sessionTtlMs,
+        getByThreadId: (threadId) => {
+            const key = resolveBindingRecordKey({
+                accountId,
+                threadId,
+            });
+            if (!key) {
+                return undefined;
+            }
+            const entry = BINDINGS_BY_THREAD_ID.get(key);
+            if (!entry || entry.accountId !== accountId) {
+                return undefined;
+            }
+            return entry;
+        },
+        getBySessionKey: (targetSessionKey) => {
+            const all = manager.listBySessionKey(targetSessionKey);
+            return all[0];
+        },
+        listBySessionKey: (targetSessionKey) => {
+            const ids = resolveBindingIdsForSession({
+                targetSessionKey,
+                accountId,
+            });
+            return ids
+                .map((bindingKey) => BINDINGS_BY_THREAD_ID.get(bindingKey))
+                .filter((entry) => Boolean(entry));
+        },
+        listBindings: () => [...BINDINGS_BY_THREAD_ID.values()].filter((entry) => entry.accountId === accountId),
+        bindTarget: async (bindParams) => {
+            let threadId = normalizeThreadId(bindParams.threadId);
+            let channelId = bindParams.channelId?.trim() || "";
+            if (!threadId && bindParams.createThread) {
+                if (!channelId) {
+                    return null;
+                }
+                const threadName = resolveThreadBindingThreadName({
+                    agentId: bindParams.agentId,
+                    label: bindParams.label,
+                });
+                threadId =
+                    (await createThreadForBinding({
+                        accountId,
+                        token: resolveCurrentToken(),
+                        channelId,
+                        threadName: bindParams.threadName?.trim() || threadName,
+                    })) ?? undefined;
+            }
+            if (!threadId) {
+                return null;
+            }
+            if (!channelId) {
+                channelId =
+                    (await resolveChannelIdForBinding({
+                        accountId,
+                        token: resolveCurrentToken(),
+                        threadId,
+                        channelId: bindParams.channelId,
+                    })) ?? "";
+            }
+            if (!channelId) {
+                return null;
+            }
+            const targetSessionKey = bindParams.targetSessionKey.trim();
+            if (!targetSessionKey) {
+                return null;
+            }
+            const targetKind = normalizeTargetKind(bindParams.targetKind, targetSessionKey);
+            let webhookId = bindParams.webhookId?.trim() || "";
+            let webhookToken = bindParams.webhookToken?.trim() || "";
+            if (!webhookId || !webhookToken) {
+                const cachedWebhook = findReusableWebhook({ accountId, channelId });
+                webhookId = cachedWebhook.webhookId ?? "";
+                webhookToken = cachedWebhook.webhookToken ?? "";
+            }
+            if (!webhookId || !webhookToken) {
+                const createdWebhook = await createWebhookForChannel({
+                    accountId,
+                    token: resolveCurrentToken(),
+                    channelId,
+                });
+                webhookId = createdWebhook.webhookId ?? "";
+                webhookToken = createdWebhook.webhookToken ?? "";
+            }
+            const boundAt = Date.now();
+            const record = {
+                accountId,
+                channelId,
+                threadId,
+                targetKind,
+                targetSessionKey,
+                agentId: bindParams.agentId?.trim() || resolveAgentIdFromSessionKey(targetSessionKey),
+                label: bindParams.label?.trim() || undefined,
+                webhookId: webhookId || undefined,
+                webhookToken: webhookToken || undefined,
+                boundBy: bindParams.boundBy?.trim() || "system",
+                boundAt,
+                expiresAt: sessionTtlMs > 0 ? boundAt + sessionTtlMs : undefined,
+            };
+            setBindingRecord(record);
+            if (persist) {
+                saveBindingsToDisk();
+            }
+            const introText = bindParams.introText?.trim();
+            if (introText) {
+                void maybeSendBindingMessage({ record, text: introText });
+            }
+            return record;
+        },
+        unbindThread: (unbindParams) => {
+            const bindingKey = resolveBindingRecordKey({
+                accountId,
+                threadId: unbindParams.threadId,
+            });
+            if (!bindingKey) {
+                return null;
+            }
+            const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
+            if (!existing || existing.accountId !== accountId) {
+                return null;
+            }
+            const removed = removeBindingRecord(bindingKey);
+            if (!removed) {
+                return null;
+            }
+            rememberRecentUnboundWebhookEcho(removed);
+            if (persist) {
+                saveBindingsToDisk();
+            }
+            if (unbindParams.sendFarewell !== false) {
+                const farewell = resolveThreadBindingFarewellText({
+                    reason: unbindParams.reason,
+                    farewellText: unbindParams.farewellText,
+                    sessionTtlMs,
+                });
+                // Use bot send path for farewell messages so unbound threads don't process
+                // webhook echoes as fresh inbound turns when allowBots is enabled.
+                void maybeSendBindingMessage({ record: removed, text: farewell, preferWebhook: false });
+            }
+            return removed;
+        },
+        unbindBySessionKey: (unbindParams) => {
+            const ids = resolveBindingIdsForSession({
+                targetSessionKey: unbindParams.targetSessionKey,
+                accountId,
+                targetKind: unbindParams.targetKind,
+            });
+            if (ids.length === 0) {
+                return [];
+            }
+            const removed = [];
+            for (const bindingKey of ids) {
+                const binding = BINDINGS_BY_THREAD_ID.get(bindingKey);
+                if (!binding) {
+                    continue;
+                }
+                const entry = manager.unbindThread({
+                    threadId: binding.threadId,
+                    reason: unbindParams.reason,
+                    sendFarewell: unbindParams.sendFarewell,
+                    farewellText: unbindParams.farewellText,
+                });
+                if (entry) {
+                    removed.push(entry);
+                }
+            }
+            return removed;
+        },
+        stop: () => {
+            if (sweepTimer) {
+                clearInterval(sweepTimer);
+                sweepTimer = null;
+            }
+            unregisterManager(accountId, manager);
+            unregisterSessionBindingAdapter({
+                channel: "discord",
+                accountId,
+            });
+            forgetThreadBindingToken(accountId);
+        },
+    };
+    if (params.enableSweeper !== false) {
+        sweepTimer = setInterval(() => {
+            void (async () => {
+                const bindings = manager.listBindings();
+                if (bindings.length === 0) {
+                    return;
+                }
+                let rest;
+                try {
+                    rest = createDiscordRestClient({
+                        accountId,
+                        token: resolveCurrentToken(),
+                    }).rest;
+                }
+                catch {
+                    return;
+                }
+                for (const binding of bindings) {
+                    const expiresAt = resolveThreadBindingExpiresAt({
+                        record: binding,
+                        sessionTtlMs,
+                    });
+                    if (expiresAt != null && Date.now() >= expiresAt) {
+                        const ttlFromBinding = Math.max(0, expiresAt - binding.boundAt);
+                        manager.unbindThread({
+                            threadId: binding.threadId,
+                            reason: "ttl-expired",
+                            sendFarewell: true,
+                            farewellText: resolveThreadBindingFarewellText({
+                                reason: "ttl-expired",
+                                sessionTtlMs: ttlFromBinding,
+                            }),
+                        });
+                        continue;
+                    }
+                    try {
+                        const channel = await rest.get(Routes.channel(binding.threadId));
+                        if (!channel || typeof channel !== "object") {
+                            logVerbose(`discord thread binding sweep probe returned invalid payload for ${binding.threadId}`);
+                            continue;
+                        }
+                        if (isThreadArchived(channel)) {
+                            manager.unbindThread({
+                                threadId: binding.threadId,
+                                reason: "thread-archived",
+                                sendFarewell: true,
+                            });
+                        }
+                    }
+                    catch (err) {
+                        if (isDiscordThreadGoneError(err)) {
+                            logVerbose(`discord thread binding sweep removing stale binding ${binding.threadId}: ${summarizeDiscordError(err)}`);
+                            manager.unbindThread({
+                                threadId: binding.threadId,
+                                reason: "thread-delete",
+                                sendFarewell: false,
+                            });
+                            continue;
+                        }
+                        logVerbose(`discord thread binding sweep probe failed for ${binding.threadId}: ${summarizeDiscordError(err)}`);
+                    }
+                }
+            })();
+        }, THREAD_BINDINGS_SWEEP_INTERVAL_MS);
+        sweepTimer.unref?.();
+    }
+    registerSessionBindingAdapter({
+        channel: "discord",
+        accountId,
+        bind: async (input) => {
+            if (input.conversation.channel !== "discord") {
+                return null;
+            }
+            const targetSessionKey = input.targetSessionKey.trim();
+            if (!targetSessionKey) {
+                return null;
+            }
+            const conversationId = input.conversation.conversationId.trim();
+            const metadata = input.metadata ?? {};
+            const label = typeof metadata.label === "string" ? metadata.label.trim() || undefined : undefined;
+            const threadName = typeof metadata.threadName === "string"
+                ? metadata.threadName.trim() || undefined
+                : undefined;
+            const introText = typeof metadata.introText === "string" ? metadata.introText.trim() || undefined : undefined;
+            const boundBy = typeof metadata.boundBy === "string" ? metadata.boundBy.trim() || undefined : undefined;
+            const agentId = typeof metadata.agentId === "string" ? metadata.agentId.trim() || undefined : undefined;
+            const bound = await manager.bindTarget({
+                threadId: conversationId || undefined,
+                channelId: input.conversation.parentConversationId?.trim() || undefined,
+                createThread: !conversationId,
+                threadName,
+                targetKind: toThreadBindingTargetKind(input.targetKind),
+                targetSessionKey,
+                agentId,
+                label,
+                boundBy,
+                introText,
+            });
+            return bound ? toSessionBindingRecord(bound) : null;
+        },
+        listBySession: (targetSessionKey) => manager.listBySessionKey(targetSessionKey).map(toSessionBindingRecord),
+        resolveByConversation: (ref) => {
+            if (ref.channel !== "discord") {
+                return null;
+            }
+            const binding = manager.getByThreadId(ref.conversationId);
+            return binding ? toSessionBindingRecord(binding) : null;
+        },
+        touch: () => {
+            // Thread bindings are activity-touched by inbound/outbound message flows.
+        },
+        unbind: async (input) => {
+            if (input.targetSessionKey?.trim()) {
+                const removed = manager.unbindBySessionKey({
+                    targetSessionKey: input.targetSessionKey,
+                    reason: input.reason,
+                });
+                return removed.map(toSessionBindingRecord);
+            }
+            const threadId = resolveThreadIdFromBindingId({
+                accountId,
+                bindingId: input.bindingId,
+            });
+            if (!threadId) {
+                return [];
+            }
+            const removed = manager.unbindThread({
+                threadId,
+                reason: input.reason,
+            });
+            return removed ? [toSessionBindingRecord(removed)] : [];
+        },
+    });
+    registerManager(manager);
+    return manager;
+}
+export function createNoopThreadBindingManager(accountId) {
+    return createNoopManager(accountId);
+}
+export function getThreadBindingManager(accountId) {
+    const normalized = normalizeAccountId(accountId);
+    return MANAGERS_BY_ACCOUNT_ID.get(normalized) ?? null;
+}
+export const __testing = {
+    resolveThreadBindingsPath,
+    resolveThreadBindingThreadName,
+    resetThreadBindingsForTests,
+};

package/dist/discord/monitor/thread-bindings.messages.js

@@ -0,0 +1,55 @@
+import { DEFAULT_FAREWELL_TEXT } from "./thread-bindings.types.js";
+function normalizeThreadBindingMessageTtlMs(raw) {
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
+        return 0;
+    }
+    const ttlMs = Math.floor(raw);
+    if (ttlMs < 0) {
+        return 0;
+    }
+    return ttlMs;
+}
+export function formatThreadBindingTtlLabel(ttlMs) {
+    if (ttlMs <= 0) {
+        return "disabled";
+    }
+    if (ttlMs < 60_000) {
+        return "<1m";
+    }
+    const totalMinutes = Math.floor(ttlMs / 60_000);
+    if (totalMinutes % 60 === 0) {
+        return `${Math.floor(totalMinutes / 60)}h`;
+    }
+    return `${totalMinutes}m`;
+}
+export function resolveThreadBindingThreadName(params) {
+    const label = params.label?.trim();
+    const base = label || params.agentId?.trim() || "agent";
+    const raw = `🤖 ${base}`.replace(/\s+/g, " ").trim();
+    return raw.slice(0, 100);
+}
+export function resolveThreadBindingIntroText(params) {
+    const label = params.label?.trim();
+    const base = label || params.agentId?.trim() || "agent";
+    const normalized = base.replace(/\s+/g, " ").trim().slice(0, 100) || "agent";
+    const ttlMs = normalizeThreadBindingMessageTtlMs(params.sessionTtlMs);
+    if (ttlMs > 0) {
+        return `🤖 ${normalized} session active (auto-unfocus in ${formatThreadBindingTtlLabel(ttlMs)}). Messages here go directly to this session.`;
+    }
+    return `🤖 ${normalized} session active. Messages here go directly to this session.`;
+}
+export function resolveThreadBindingFarewellText(params) {
+    const custom = params.farewellText?.trim();
+    if (custom) {
+        return custom;
+    }
+    if (params.reason === "ttl-expired") {
+        return `Session ended automatically after ${formatThreadBindingTtlLabel(params.sessionTtlMs)}. Messages here will no longer be routed.`;
+    }
+    return DEFAULT_FAREWELL_TEXT;
+}
+export function summarizeBindingPersona(record) {
+    const label = record.label?.trim();
+    const base = label || record.agentId;
+    return (`🤖 ${base}`.trim() || "🤖 agent").slice(0, 80);
+}