@poolzin/pool-bot 2026.2.17 → 2026.2.18

package/dist/slack/blocks-fallback.js

@@ -0,0 +1,76 @@
+function cleanCandidate(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function readSectionText(block) {
+    return cleanCandidate(block.text?.text);
+}
+function readHeaderText(block) {
+    return cleanCandidate(block.text?.text);
+}
+function readImageText(block) {
+    return cleanCandidate(block.alt_text) ?? cleanCandidate(block.title?.text);
+}
+function readVideoText(block) {
+    return cleanCandidate(block.title?.text) ?? cleanCandidate(block.alt_text);
+}
+function readContextText(block) {
+    if (!Array.isArray(block.elements)) {
+        return undefined;
+    }
+    const textParts = block.elements
+        .map((element) => cleanCandidate(element.text))
+        .filter((value) => Boolean(value));
+    return textParts.length > 0 ? textParts.join(" ") : undefined;
+}
+export function buildSlackBlocksFallbackText(blocks) {
+    for (const raw of blocks) {
+        const block = raw;
+        switch (block.type) {
+            case "header": {
+                const text = readHeaderText(block);
+                if (text) {
+                    return text;
+                }
+                break;
+            }
+            case "section": {
+                const text = readSectionText(block);
+                if (text) {
+                    return text;
+                }
+                break;
+            }
+            case "image": {
+                const text = readImageText(block);
+                if (text) {
+                    return text;
+                }
+                return "Shared an image";
+            }
+            case "video": {
+                const text = readVideoText(block);
+                if (text) {
+                    return text;
+                }
+                return "Shared a video";
+            }
+            case "file": {
+                return "Shared a file";
+            }
+            case "context": {
+                const text = readContextText(block);
+                if (text) {
+                    return text;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return "Shared a Block Kit message";
+}

package/dist/slack/blocks-input.js

@@ -0,0 +1,40 @@
+const SLACK_MAX_BLOCKS = 50;
+function parseBlocksJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error("blocks must be valid JSON");
+    }
+}
+function assertBlocksArray(raw) {
+    if (!Array.isArray(raw)) {
+        throw new Error("blocks must be an array");
+    }
+    if (raw.length === 0) {
+        throw new Error("blocks must contain at least one block");
+    }
+    if (raw.length > SLACK_MAX_BLOCKS) {
+        throw new Error(`blocks cannot exceed ${SLACK_MAX_BLOCKS} items`);
+    }
+    for (const block of raw) {
+        if (!block || typeof block !== "object" || Array.isArray(block)) {
+            throw new Error("each block must be an object");
+        }
+        const type = block.type;
+        if (typeof type !== "string" || type.trim().length === 0) {
+            throw new Error("each block must include a non-empty string type");
+        }
+    }
+}
+export function validateSlackBlocksArray(raw) {
+    assertBlocksArray(raw);
+    return raw;
+}
+export function parseSlackBlocksInput(raw) {
+    if (raw == null) {
+        return undefined;
+    }
+    const parsed = typeof raw === "string" ? parseBlocksJson(raw) : raw;
+    return validateSlackBlocksArray(parsed);
+}

package/dist/slack/draft-stream.js

@@ -0,0 +1,106 @@
+import { createDraftStreamLoop } from "../channels/draft-stream-loop.js";
+import { deleteSlackMessage, editSlackMessage } from "./actions.js";
+import { sendMessageSlack } from "./send.js";
+const SLACK_STREAM_MAX_CHARS = 4000;
+const DEFAULT_THROTTLE_MS = 1000;
+export function createSlackDraftStream(params) {
+    const maxChars = Math.min(params.maxChars ?? SLACK_STREAM_MAX_CHARS, SLACK_STREAM_MAX_CHARS);
+    const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
+    const send = params.send ?? sendMessageSlack;
+    const edit = params.edit ?? editSlackMessage;
+    const remove = params.remove ?? deleteSlackMessage;
+    let streamMessageId;
+    let streamChannelId;
+    let lastSentText = "";
+    let stopped = false;
+    const sendOrEditStreamMessage = async (text) => {
+        if (stopped) {
+            return;
+        }
+        const trimmed = text.trimEnd();
+        if (!trimmed) {
+            return;
+        }
+        if (trimmed.length > maxChars) {
+            stopped = true;
+            params.warn?.(`slack stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
+            return;
+        }
+        if (trimmed === lastSentText) {
+            return;
+        }
+        lastSentText = trimmed;
+        try {
+            if (streamChannelId && streamMessageId) {
+                await edit(streamChannelId, streamMessageId, trimmed, {
+                    token: params.token,
+                    accountId: params.accountId,
+                });
+                return;
+            }
+            const sent = await send(params.target, trimmed, {
+                token: params.token,
+                accountId: params.accountId,
+                threadTs: params.resolveThreadTs?.(),
+            });
+            streamChannelId = sent.channelId || streamChannelId;
+            streamMessageId = sent.messageId || streamMessageId;
+            if (!streamChannelId || !streamMessageId) {
+                stopped = true;
+                params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
+                return;
+            }
+            params.onMessageSent?.();
+        }
+        catch (err) {
+            stopped = true;
+            params.warn?.(`slack stream preview failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    const loop = createDraftStreamLoop({
+        throttleMs,
+        isStopped: () => stopped,
+        sendOrEditStreamMessage,
+    });
+    const stop = () => {
+        stopped = true;
+        loop.stop();
+    };
+    const clear = async () => {
+        stop();
+        await loop.waitForInFlight();
+        const channelId = streamChannelId;
+        const messageId = streamMessageId;
+        streamChannelId = undefined;
+        streamMessageId = undefined;
+        lastSentText = "";
+        if (!channelId || !messageId) {
+            return;
+        }
+        try {
+            await remove(channelId, messageId, {
+                token: params.token,
+                accountId: params.accountId,
+            });
+        }
+        catch (err) {
+            params.warn?.(`slack stream preview cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    const forceNewMessage = () => {
+        streamMessageId = undefined;
+        streamChannelId = undefined;
+        lastSentText = "";
+        loop.resetPending();
+    };
+    params.log?.(`slack stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
+    return {
+        update: loop.update,
+        flush: loop.flush,
+        clear,
+        stop,
+        forceNewMessage,
+        messageId: () => streamMessageId,
+        channelId: () => streamChannelId,
+    };
+}

package/dist/slack/message-actions.js

@@ -0,0 +1,51 @@
+import { createActionGate } from "../agents/tools/common.js";
+import { listEnabledSlackAccounts } from "./accounts.js";
+export function listSlackMessageActions(cfg) {
+    const accounts = listEnabledSlackAccounts(cfg).filter((account) => account.botTokenSource !== "none");
+    if (accounts.length === 0) {
+        return [];
+    }
+    const isActionEnabled = (key, defaultValue = true) => {
+        for (const account of accounts) {
+            const gate = createActionGate((account.actions ?? cfg.channels?.slack?.actions));
+            if (gate(key, defaultValue)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const actions = new Set(["send"]);
+    if (isActionEnabled("reactions")) {
+        actions.add("react");
+        actions.add("reactions");
+    }
+    if (isActionEnabled("messages")) {
+        actions.add("read");
+        actions.add("edit");
+        actions.add("delete");
+    }
+    if (isActionEnabled("pins")) {
+        actions.add("pin");
+        actions.add("unpin");
+        actions.add("list-pins");
+    }
+    if (isActionEnabled("memberInfo")) {
+        actions.add("member-info");
+    }
+    if (isActionEnabled("emojiList")) {
+        actions.add("emoji-list");
+    }
+    return Array.from(actions);
+}
+export function extractSlackToolSend(args) {
+    const action = typeof args.action === "string" ? args.action.trim() : "";
+    if (action !== "sendMessage") {
+        return null;
+    }
+    const to = typeof args.to === "string" ? args.to : undefined;
+    if (!to) {
+        return null;
+    }
+    const accountId = typeof args.accountId === "string" ? args.accountId.trim() : undefined;
+    return { to, accountId };
+}

package/dist/slack/modal-metadata.js

@@ -0,0 +1,32 @@
+const SLACK_PRIVATE_METADATA_MAX = 3000;
+function normalizeString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+export function parseSlackModalPrivateMetadata(raw) {
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            sessionKey: normalizeString(parsed.sessionKey),
+            channelId: normalizeString(parsed.channelId),
+            channelType: normalizeString(parsed.channelType),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+export function encodeSlackModalPrivateMetadata(input) {
+    const payload = {
+        ...(input.sessionKey ? { sessionKey: input.sessionKey } : {}),
+        ...(input.channelId ? { channelId: input.channelId } : {}),
+        ...(input.channelType ? { channelType: input.channelType } : {}),
+    };
+    const encoded = JSON.stringify(payload);
+    if (encoded.length > SLACK_PRIVATE_METADATA_MAX) {
+        throw new Error(`Slack modal private_metadata cannot exceed ${SLACK_PRIVATE_METADATA_MAX} chars`);
+    }
+    return encoded;
+}