@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/channels/channels/dock.js

@@ -0,0 +1,436 @@
+import { resolveChannelGroupRequireMention, resolveChannelGroupToolsPolicy, } from "../config/group-policy.js";
+import { resolveDiscordAccount } from "../discord/accounts.js";
+import { resolveIMessageAccount } from "../imessage/accounts.js";
+import { requireActivePluginRegistry } from "../plugins/runtime.js";
+import { normalizeAccountId } from "../routing/session-key.js";
+import { resolveSignalAccount } from "../signal/accounts.js";
+import { resolveSlackAccount, resolveSlackReplyToMode } from "../slack/accounts.js";
+import { buildSlackThreadingToolContext } from "../slack/threading-tool-context.js";
+import { resolveTelegramAccount } from "../telegram/accounts.js";
+import { escapeRegExp, normalizeE164 } from "../utils.js";
+import { resolveWhatsAppAccount } from "../web/accounts.js";
+import { normalizeWhatsAppTarget } from "../whatsapp/normalize.js";
+import { resolveDiscordGroupRequireMention, resolveDiscordGroupToolPolicy, resolveGoogleChatGroupRequireMention, resolveGoogleChatGroupToolPolicy, resolveIMessageGroupRequireMention, resolveIMessageGroupToolPolicy, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveTelegramGroupRequireMention, resolveTelegramGroupToolPolicy, resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, } from "./plugins/group-mentions.js";
+import { normalizeSignalMessagingTarget } from "./plugins/normalize/signal.js";
+import { CHAT_CHANNEL_ORDER, getChatChannelMeta } from "./registry.js";
+const formatLower = (allowFrom) => allowFrom
+    .map((entry) => String(entry).trim())
+    .filter(Boolean)
+    .map((entry) => entry.toLowerCase());
+const formatDiscordAllowFrom = (allowFrom) => allowFrom
+    .map((entry) => String(entry)
+    .trim()
+    .replace(/^<@!?/, "")
+    .replace(/>$/, "")
+    .replace(/^discord:/i, "")
+    .replace(/^user:/i, "")
+    .replace(/^pk:/i, "")
+    .trim()
+    .toLowerCase())
+    .filter(Boolean);
+function resolveDirectOrGroupChannelId(context) {
+    const isDirect = context.ChatType?.toLowerCase() === "direct";
+    return (isDirect ? (context.From ?? context.To) : context.To)?.trim() || undefined;
+}
+function buildSignalThreadToolContext(params) {
+    const currentChannelIdRaw = resolveDirectOrGroupChannelId(params.context);
+    const currentChannelId = currentChannelIdRaw
+        ? (normalizeSignalMessagingTarget(currentChannelIdRaw) ?? currentChannelIdRaw.trim())
+        : undefined;
+    return {
+        currentChannelId,
+        currentThreadTs: params.context.ReplyToId,
+        hasRepliedRef: params.hasRepliedRef,
+    };
+}
+function buildIMessageThreadToolContext(params) {
+    return {
+        currentChannelId: resolveDirectOrGroupChannelId(params.context),
+        currentThreadTs: params.context.ReplyToId,
+        hasRepliedRef: params.hasRepliedRef,
+    };
+}
+// Channel docks: lightweight channel metadata/behavior for shared code paths.
+//
+// Rules:
+// - keep this module *light* (no monitors, probes, puppeteer/web login, etc)
+// - OK: config readers, allowFrom formatting, mention stripping patterns, threading defaults
+// - shared code should import from here (and from `src/channels/registry.ts`), not from the plugins registry
+//
+// Adding a channel:
+// - add a new entry to `DOCKS`
+// - keep it cheap; push heavy logic into `src/channels/plugins/<id>.ts` or channel modules
+const DOCKS = {
+    telegram: {
+        id: "telegram",
+        capabilities: {
+            chatTypes: ["direct", "group", "channel", "thread"],
+            nativeCommands: true,
+            blockStreaming: true,
+        },
+        outbound: { textChunkLimit: 4000 },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => (resolveTelegramAccount({ cfg, accountId }).config.allowFrom ?? []).map((entry) => String(entry)),
+            formatAllowFrom: ({ allowFrom }) => allowFrom
+                .map((entry) => String(entry).trim())
+                .filter(Boolean)
+                .map((entry) => entry.replace(/^(telegram|tg):/i, ""))
+                .map((entry) => entry.toLowerCase()),
+        },
+        groups: {
+            resolveRequireMention: resolveTelegramGroupRequireMention,
+            resolveToolPolicy: resolveTelegramGroupToolPolicy,
+        },
+        threading: {
+            resolveReplyToMode: ({ cfg }) => cfg.channels?.telegram?.replyToMode ?? "off",
+            buildToolContext: ({ context, hasRepliedRef }) => {
+                const threadId = context.MessageThreadId ?? context.ReplyToId;
+                return {
+                    currentChannelId: context.To?.trim() || undefined,
+                    currentThreadTs: threadId != null ? String(threadId) : undefined,
+                    hasRepliedRef,
+                };
+            },
+        },
+    },
+    whatsapp: {
+        id: "whatsapp",
+        capabilities: {
+            chatTypes: ["direct", "group"],
+            polls: true,
+            reactions: true,
+            media: true,
+        },
+        commands: {
+            enforceOwnerForCommands: true,
+            skipWhenConfigEmpty: true,
+        },
+        outbound: { textChunkLimit: 4000 },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => resolveWhatsAppAccount({ cfg, accountId }).allowFrom ?? [],
+            formatAllowFrom: ({ allowFrom }) => allowFrom
+                .map((entry) => String(entry).trim())
+                .filter((entry) => Boolean(entry))
+                .map((entry) => (entry === "*" ? entry : normalizeWhatsAppTarget(entry)))
+                .filter((entry) => Boolean(entry)),
+        },
+        groups: {
+            resolveRequireMention: resolveWhatsAppGroupRequireMention,
+            resolveToolPolicy: resolveWhatsAppGroupToolPolicy,
+            resolveGroupIntroHint: () => "WhatsApp IDs: SenderId is the participant JID (group participant id).",
+        },
+        mentions: {
+            stripPatterns: ({ ctx }) => {
+                const selfE164 = (ctx.To ?? "").replace(/^whatsapp:/, "");
+                if (!selfE164) {
+                    return [];
+                }
+                const escaped = escapeRegExp(selfE164);
+                return [escaped, `@${escaped}`];
+            },
+        },
+        threading: {
+            buildToolContext: ({ context, hasRepliedRef }) => {
+                const channelId = context.From?.trim() || context.To?.trim() || undefined;
+                return {
+                    currentChannelId: channelId,
+                    currentThreadTs: context.ReplyToId,
+                    hasRepliedRef,
+                };
+            },
+        },
+    },
+    discord: {
+        id: "discord",
+        capabilities: {
+            chatTypes: ["direct", "channel", "thread"],
+            polls: true,
+            reactions: true,
+            media: true,
+            nativeCommands: true,
+            threads: true,
+        },
+        outbound: { textChunkLimit: 2000 },
+        streaming: {
+            blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
+        },
+        elevated: {
+            allowFromFallback: ({ cfg }) => cfg.channels?.discord?.allowFrom ?? cfg.channels?.discord?.dm?.allowFrom,
+        },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => {
+                const account = resolveDiscordAccount({ cfg, accountId });
+                return (account.config.allowFrom ?? account.config.dm?.allowFrom ?? []).map((entry) => String(entry));
+            },
+            formatAllowFrom: ({ allowFrom }) => formatDiscordAllowFrom(allowFrom),
+        },
+        groups: {
+            resolveRequireMention: resolveDiscordGroupRequireMention,
+            resolveToolPolicy: resolveDiscordGroupToolPolicy,
+        },
+        mentions: {
+            stripPatterns: () => ["<@!?\\d+>"],
+        },
+        threading: {
+            resolveReplyToMode: ({ cfg }) => cfg.channels?.discord?.replyToMode ?? "off",
+            buildToolContext: ({ context, hasRepliedRef }) => ({
+                currentChannelId: context.To?.trim() || undefined,
+                currentThreadTs: context.ReplyToId,
+                hasRepliedRef,
+            }),
+        },
+    },
+    irc: {
+        id: "irc",
+        capabilities: {
+            chatTypes: ["direct", "group"],
+            media: true,
+            blockStreaming: true,
+        },
+        outbound: { textChunkLimit: 350 },
+        streaming: {
+            blockStreamingCoalesceDefaults: { minChars: 300, idleMs: 1000 },
+        },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => {
+                const channel = cfg.channels?.irc;
+                const normalized = normalizeAccountId(accountId);
+                const account = channel?.accounts?.[normalized] ??
+                    channel?.accounts?.[Object.keys(channel?.accounts ?? {}).find((key) => key.toLowerCase() === normalized.toLowerCase()) ?? ""];
+                return (account?.allowFrom ?? channel?.allowFrom ?? []).map((entry) => String(entry));
+            },
+            formatAllowFrom: ({ allowFrom }) => allowFrom
+                .map((entry) => String(entry).trim())
+                .filter(Boolean)
+                .map((entry) => entry
+                .replace(/^irc:/i, "")
+                .replace(/^user:/i, "")
+                .toLowerCase()),
+        },
+        groups: {
+            resolveRequireMention: ({ cfg, accountId, groupId }) => {
+                if (!groupId) {
+                    return true;
+                }
+                return resolveChannelGroupRequireMention({
+                    cfg,
+                    channel: "irc",
+                    groupId,
+                    accountId,
+                    groupIdCaseInsensitive: true,
+                });
+            },
+            resolveToolPolicy: ({ cfg, accountId, groupId, senderId, senderName, senderUsername }) => {
+                if (!groupId) {
+                    return undefined;
+                }
+                // IRC supports per-channel tool policies. Prefer the shared resolver so
+                // toolsBySender is honored consistently across surfaces.
+                return resolveChannelGroupToolsPolicy({
+                    cfg,
+                    channel: "irc",
+                    groupId,
+                    accountId,
+                    groupIdCaseInsensitive: true,
+                    senderId,
+                    senderName,
+                    senderUsername,
+                });
+            },
+        },
+    },
+    googlechat: {
+        id: "googlechat",
+        capabilities: {
+            chatTypes: ["direct", "group", "thread"],
+            reactions: true,
+            media: true,
+            threads: true,
+            blockStreaming: true,
+        },
+        outbound: { textChunkLimit: 4000 },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => {
+                const channel = cfg.channels?.googlechat;
+                const normalized = normalizeAccountId(accountId);
+                const account = channel?.accounts?.[normalized] ??
+                    channel?.accounts?.[Object.keys(channel?.accounts ?? {}).find((key) => key.toLowerCase() === normalized.toLowerCase()) ?? ""];
+                return (account?.dm?.allowFrom ?? channel?.dm?.allowFrom ?? []).map((entry) => String(entry));
+            },
+            formatAllowFrom: ({ allowFrom }) => allowFrom
+                .map((entry) => String(entry).trim())
+                .filter(Boolean)
+                .map((entry) => entry
+                .replace(/^(googlechat|google-chat|gchat):/i, "")
+                .replace(/^user:/i, "")
+                .replace(/^users\//i, "")
+                .toLowerCase()),
+        },
+        groups: {
+            resolveRequireMention: resolveGoogleChatGroupRequireMention,
+            resolveToolPolicy: resolveGoogleChatGroupToolPolicy,
+        },
+        threading: {
+            resolveReplyToMode: ({ cfg }) => cfg.channels?.googlechat?.replyToMode ?? "off",
+            buildToolContext: ({ context, hasRepliedRef }) => {
+                const threadId = context.MessageThreadId ?? context.ReplyToId;
+                return {
+                    currentChannelId: context.To?.trim() || undefined,
+                    currentThreadTs: threadId != null ? String(threadId) : undefined,
+                    hasRepliedRef,
+                };
+            },
+        },
+    },
+    slack: {
+        id: "slack",
+        capabilities: {
+            chatTypes: ["direct", "channel", "thread"],
+            reactions: true,
+            media: true,
+            nativeCommands: true,
+            threads: true,
+        },
+        outbound: { textChunkLimit: 4000 },
+        streaming: {
+            blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
+        },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => {
+                const account = resolveSlackAccount({ cfg, accountId });
+                return (account.config.allowFrom ?? account.dm?.allowFrom ?? []).map((entry) => String(entry));
+            },
+            formatAllowFrom: ({ allowFrom }) => formatLower(allowFrom),
+        },
+        groups: {
+            resolveRequireMention: resolveSlackGroupRequireMention,
+            resolveToolPolicy: resolveSlackGroupToolPolicy,
+        },
+        mentions: {
+            stripPatterns: () => ["<@[^>]+>"],
+        },
+        threading: {
+            resolveReplyToMode: ({ cfg, accountId, chatType }) => resolveSlackReplyToMode(resolveSlackAccount({ cfg, accountId }), chatType),
+            allowExplicitReplyTagsWhenOff: true,
+            buildToolContext: (params) => buildSlackThreadingToolContext(params),
+        },
+    },
+    signal: {
+        id: "signal",
+        capabilities: {
+            chatTypes: ["direct", "group"],
+            reactions: true,
+            media: true,
+        },
+        outbound: { textChunkLimit: 4000 },
+        streaming: {
+            blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
+        },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => (resolveSignalAccount({ cfg, accountId }).config.allowFrom ?? []).map((entry) => String(entry)),
+            formatAllowFrom: ({ allowFrom }) => allowFrom
+                .map((entry) => String(entry).trim())
+                .filter(Boolean)
+                .map((entry) => (entry === "*" ? "*" : normalizeE164(entry.replace(/^signal:/i, ""))))
+                .filter(Boolean),
+        },
+        threading: {
+            buildToolContext: ({ context, hasRepliedRef }) => buildSignalThreadToolContext({ context, hasRepliedRef }),
+        },
+    },
+    imessage: {
+        id: "imessage",
+        capabilities: {
+            chatTypes: ["direct", "group"],
+            reactions: true,
+            media: true,
+        },
+        outbound: { textChunkLimit: 4000 },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => (resolveIMessageAccount({ cfg, accountId }).config.allowFrom ?? []).map((entry) => String(entry)),
+            formatAllowFrom: ({ allowFrom }) => allowFrom.map((entry) => String(entry).trim()).filter(Boolean),
+        },
+        groups: {
+            resolveRequireMention: resolveIMessageGroupRequireMention,
+            resolveToolPolicy: resolveIMessageGroupToolPolicy,
+        },
+        threading: {
+            buildToolContext: ({ context, hasRepliedRef }) => buildIMessageThreadToolContext({ context, hasRepliedRef }),
+        },
+    },
+};
+function buildDockFromPlugin(plugin) {
+    return {
+        id: plugin.id,
+        capabilities: plugin.capabilities,
+        commands: plugin.commands,
+        outbound: plugin.outbound?.textChunkLimit
+            ? { textChunkLimit: plugin.outbound.textChunkLimit }
+            : undefined,
+        streaming: plugin.streaming
+            ? { blockStreamingCoalesceDefaults: plugin.streaming.blockStreamingCoalesceDefaults }
+            : undefined,
+        elevated: plugin.elevated,
+        config: plugin.config
+            ? {
+                resolveAllowFrom: plugin.config.resolveAllowFrom,
+                formatAllowFrom: plugin.config.formatAllowFrom,
+            }
+            : undefined,
+        groups: plugin.groups,
+        mentions: plugin.mentions,
+        threading: plugin.threading,
+        agentPrompt: plugin.agentPrompt,
+    };
+}
+function listPluginDockEntries() {
+    const registry = requireActivePluginRegistry();
+    const entries = [];
+    const seen = new Set();
+    for (const entry of registry.channels) {
+        const plugin = entry.plugin;
+        const id = String(plugin.id).trim();
+        if (!id || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        if (CHAT_CHANNEL_ORDER.includes(plugin.id)) {
+            continue;
+        }
+        const dock = entry.dock ?? buildDockFromPlugin(plugin);
+        entries.push({ id: plugin.id, dock, order: plugin.meta.order });
+    }
+    return entries;
+}
+export function listChannelDocks() {
+    const baseEntries = CHAT_CHANNEL_ORDER.map((id) => ({
+        id,
+        dock: DOCKS[id],
+        order: getChatChannelMeta(id).order,
+    }));
+    const pluginEntries = listPluginDockEntries();
+    const combined = [...baseEntries, ...pluginEntries];
+    combined.sort((a, b) => {
+        const indexA = CHAT_CHANNEL_ORDER.indexOf(a.id);
+        const indexB = CHAT_CHANNEL_ORDER.indexOf(b.id);
+        const orderA = a.order ?? (indexA === -1 ? 999 : indexA);
+        const orderB = b.order ?? (indexB === -1 ? 999 : indexB);
+        if (orderA !== orderB) {
+            return orderA - orderB;
+        }
+        return String(a.id).localeCompare(String(b.id));
+    });
+    return combined.map((entry) => entry.dock);
+}
+export function getChannelDock(id) {
+    const core = DOCKS[id];
+    if (core) {
+        return core;
+    }
+    const registry = requireActivePluginRegistry();
+    const pluginEntry = registry.channels.find((entry) => entry.plugin.id === id);
+    if (!pluginEntry) {
+        return undefined;
+    }
+    return pluginEntry.dock ?? buildDockFromPlugin(pluginEntry.plugin);
+}

package/dist/channels/channels/index.js

@@ -0,0 +1,51 @@
+import { CHAT_CHANNEL_ORDER, normalizeAnyChannelId } from "../registry.js";
+import { requireActivePluginRegistry } from "../../plugins/runtime.js";
+// Channel plugins registry (runtime).
+//
+// This module is intentionally "heavy" (plugins may import channel monitors, web login, etc).
+// Shared code paths (reply flow, command auth, sandbox explain) should depend on `src/channels/dock.ts`
+// instead, and only call `getChannelPlugin()` at execution boundaries.
+//
+// Channel plugins are registered by the plugin loader (extensions/ or configured paths).
+function listPluginChannels() {
+    const registry = requireActivePluginRegistry();
+    return registry.channels.map((entry) => entry.plugin);
+}
+function dedupeChannels(channels) {
+    const seen = new Set();
+    const resolved = [];
+    for (const plugin of channels) {
+        const id = String(plugin.id).trim();
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        resolved.push(plugin);
+    }
+    return resolved;
+}
+export function listChannelPlugins() {
+    const combined = dedupeChannels(listPluginChannels());
+    return combined.sort((a, b) => {
+        const indexA = CHAT_CHANNEL_ORDER.indexOf(a.id);
+        const indexB = CHAT_CHANNEL_ORDER.indexOf(b.id);
+        const orderA = a.meta.order ?? (indexA === -1 ? 999 : indexA);
+        const orderB = b.meta.order ?? (indexB === -1 ? 999 : indexB);
+        if (orderA !== orderB)
+            return orderA - orderB;
+        return a.id.localeCompare(b.id);
+    });
+}
+export function getChannelPlugin(id) {
+    const resolvedId = String(id).trim();
+    if (!resolvedId)
+        return undefined;
+    return listChannelPlugins().find((plugin) => plugin.id === resolvedId);
+}
+export function normalizeChannelId(raw) {
+    // Channel docking: keep input normalization centralized in src/channels/registry.ts.
+    // Plugin registry must be initialized before calling.
+    return normalizeAnyChannelId(raw);
+}
+export { listDiscordDirectoryGroupsFromConfig, listDiscordDirectoryPeersFromConfig, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listTelegramDirectoryGroupsFromConfig, listTelegramDirectoryPeersFromConfig, listWhatsAppDirectoryGroupsFromConfig, listWhatsAppDirectoryPeersFromConfig, } from "./directory-config.js";
+export { applyChannelMatchMeta, buildChannelKeyCandidates, normalizeChannelSlug, resolveChannelEntryMatch, resolveChannelEntryMatchWithFallback, resolveChannelMatchConfig, resolveNestedAllowlistDecision, } from "./channel-config.js";
+export { formatAllowlistMatchMeta, } from "./allowlist-match.js";

package/dist/channels/channels/plugins/outbound/discord.js

@@ -0,0 +1,101 @@
+import { getThreadBindingManager, } from "../../../discord/monitor/thread-bindings.js";
+import { sendMessageDiscord, sendPollDiscord, sendWebhookMessageDiscord, } from "../../../discord/send.js";
+import { normalizeDiscordOutboundTarget } from "../normalize/discord.js";
+function resolveDiscordOutboundTarget(params) {
+    if (params.threadId == null) {
+        return params.to;
+    }
+    const threadId = String(params.threadId).trim();
+    if (!threadId) {
+        return params.to;
+    }
+    return `channel:${threadId}`;
+}
+function resolveDiscordWebhookIdentity(params) {
+    const usernameRaw = params.identity?.name?.trim();
+    const fallbackUsername = params.binding.label?.trim() || params.binding.agentId;
+    const username = (usernameRaw || fallbackUsername || "").slice(0, 80) || undefined;
+    const avatarUrl = params.identity?.avatarUrl?.trim() || undefined;
+    return { username, avatarUrl };
+}
+async function maybeSendDiscordWebhookText(params) {
+    if (params.threadId == null) {
+        return null;
+    }
+    const threadId = String(params.threadId).trim();
+    if (!threadId) {
+        return null;
+    }
+    const manager = getThreadBindingManager(params.accountId ?? undefined);
+    if (!manager) {
+        return null;
+    }
+    const binding = manager.getByThreadId(threadId);
+    if (!binding?.webhookId || !binding?.webhookToken) {
+        return null;
+    }
+    const persona = resolveDiscordWebhookIdentity({
+        identity: params.identity,
+        binding,
+    });
+    const result = await sendWebhookMessageDiscord(params.text, {
+        webhookId: binding.webhookId,
+        webhookToken: binding.webhookToken,
+        accountId: binding.accountId,
+        threadId: binding.threadId,
+        replyTo: params.replyToId ?? undefined,
+        username: persona.username,
+        avatarUrl: persona.avatarUrl,
+    });
+    return result;
+}
+export const discordOutbound = {
+    deliveryMode: "direct",
+    chunker: null,
+    textChunkLimit: 2000,
+    pollMaxOptions: 10,
+    resolveTarget: ({ to }) => normalizeDiscordOutboundTarget(to),
+    sendText: async ({ to, text, accountId, deps, replyToId, threadId, identity, silent }) => {
+        if (!silent) {
+            const webhookResult = await maybeSendDiscordWebhookText({
+                text,
+                threadId,
+                accountId,
+                identity,
+                replyToId,
+            }).catch(() => null);
+            if (webhookResult) {
+                return { channel: "discord", ...webhookResult };
+            }
+        }
+        const send = deps?.sendDiscord ?? sendMessageDiscord;
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        const result = await send(target, text, {
+            verbose: false,
+            replyTo: replyToId ?? undefined,
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+        });
+        return { channel: "discord", ...result };
+    },
+    sendMedia: async ({ to, text, mediaUrl, mediaLocalRoots, accountId, deps, replyToId, threadId, silent, }) => {
+        const send = deps?.sendDiscord ?? sendMessageDiscord;
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        const result = await send(target, text, {
+            verbose: false,
+            mediaUrl,
+            mediaLocalRoots,
+            replyTo: replyToId ?? undefined,
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+        });
+        return { channel: "discord", ...result };
+    },
+    sendPoll: async ({ to, poll, accountId, threadId, silent }) => {
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        return await sendPollDiscord(target, poll, {
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+        });
+    },
+};

package/dist/channels/channels/whatsapp.js

@@ -0,0 +1,17 @@
+import { normalizeWhatsAppTarget } from "../../../whatsapp/normalize.js";
+export function normalizeWhatsAppMessagingTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    return normalizeWhatsAppTarget(trimmed) ?? undefined;
+}
+export function looksLikeWhatsAppTargetId(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return false;
+    if (/^whatsapp:/i.test(trimmed))
+        return true;
+    if (trimmed.includes("@"))
+        return true;
+    return /^\+?\d{3,}$/.test(trimmed);
+}

package/dist/channels/plugins/types.js

@@ -1 +1 @@
-export { CHANNEL_MESSAGE_ACTION_NAMES } from "./message-action-names.js";
+export {};

package/dist/channels/run-state-machine.js

@@ -0,0 +1,7 @@
+/**
+ * Stub for run-state-machine
+ * TODO: Implement proper state machine
+ */
+export function runStateMachine() {
+    throw new Error("runStateMachine not implemented");
+}

package/dist/commands/models/auth.js

@@ -1,5 +1,5 @@
 import { confirm as clackConfirm, select as clackSelect, text as clackText } from "@clack/prompts";
-import { upsertAuthProfile } from "../../agents/auth-profiles.js";
+import { clearAuthProfileCooldown, loadAuthProfileStore, upsertAuthProfile, } from "../../agents/auth-profiles.js";
 import { normalizeProviderId } from "../../agents/model-selection.js";
 import { resolveAgentDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, } from "../../agents/agent-scope.js";
 import { resolveDefaultAgentWorkspaceDir } from "../../agents/workspace.js";
@@ -275,3 +275,49 @@ export async function modelsAuthLoginCommand(opts, runtime) {
         await prompter.note(result.notes.join("\n"), "Provider notes");
     }
 }
+export async function modelsAuthClearCooldownsCommand(opts, runtime) {
+    const snapshot = await readConfigFileSnapshot();
+    if (!snapshot.valid) {
+        const issues = snapshot.issues.map((issue) => `- ${issue.path}: ${issue.message}`).join("\n");
+        throw new Error(`Invalid config at ${snapshot.path}\n${issues}`);
+    }
+    const config = snapshot.config;
+    const agentId = opts.agent ?? resolveDefaultAgentId(config);
+    const agentDir = resolveAgentDir(config, agentId);
+    const store = loadAuthProfileStore(agentDir);
+    const profileIds = Object.keys(store.profiles);
+    if (profileIds.length === 0) {
+        runtime.log("No auth profiles found.");
+        return;
+    }
+    const profilesWithCooldowns = profileIds.filter((id) => {
+        const stats = store.usageStats?.[id];
+        if (!stats)
+            return false;
+        return stats.cooldownUntil || stats.disabledUntil;
+    });
+    if (profilesWithCooldowns.length === 0) {
+        runtime.log("No profiles currently in cooldown.");
+        return;
+    }
+    if (!opts.yes) {
+        runtime.log(`Found ${profilesWithCooldowns.length} profile(s) with cooldowns:`);
+        for (const id of profilesWithCooldowns) {
+            const stats = store.usageStats?.[id];
+            const until = stats?.cooldownUntil ?? stats?.disabledUntil;
+            const remaining = until ? Math.max(0, until - Date.now()) : 0;
+            const minutes = Math.ceil(remaining / 60000);
+            runtime.log(`  - ${id}: ${minutes}m remaining`);
+        }
+        const proceed = await confirm({
+            message: "Clear cooldowns for these profiles?",
+            initialValue: true,
+        });
+        if (!proceed)
+            return;
+    }
+    for (const profileId of profilesWithCooldowns) {
+        await clearAuthProfileCooldown({ store, profileId, agentDir });
+    }
+    runtime.log(`Cleared cooldowns for ${profilesWithCooldowns.length} profile(s).`);
+}