@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/slack/send.js

@@ -1,18 +1,80 @@
 import { chunkMarkdownTextWithMode, resolveChunkMode, resolveTextChunkLimit, } from "../auto-reply/chunk.js";
 import { loadConfig } from "../config/config.js";
+import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { logVerbose } from "../globals.js";
 import { loadWebMedia } from "../web/media.js";
 import { resolveSlackAccount } from "./accounts.js";
+import { buildSlackBlocksFallbackText } from "./blocks-fallback.js";
+import { validateSlackBlocksArray } from "./blocks-input.js";
 import { createSlackWebClient } from "./client.js";
 import { markdownToSlackMrkdwnChunks } from "./format.js";
-import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { parseSlackTarget } from "./targets.js";
 import { resolveSlackBotToken } from "./token.js";
 const SLACK_TEXT_LIMIT = 4000;
+function hasCustomIdentity(identity) {
+    return Boolean(identity?.username || identity?.iconUrl || identity?.iconEmoji);
+}
+function isSlackCustomizeScopeError(err) {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    const maybeData = err;
+    const code = maybeData.data?.error?.toLowerCase();
+    if (code !== "missing_scope") {
+        return false;
+    }
+    const needed = maybeData.data?.needed?.toLowerCase();
+    if (needed?.includes("chat:write.customize")) {
+        return true;
+    }
+    const scopes = [
+        ...(maybeData.data?.response_metadata?.scopes ?? []),
+        ...(maybeData.data?.response_metadata?.acceptedScopes ?? []),
+    ].map((scope) => scope.toLowerCase());
+    return scopes.includes("chat:write.customize");
+}
+async function postSlackMessageBestEffort(params) {
+    const basePayload = {
+        channel: params.channelId,
+        text: params.text,
+        thread_ts: params.threadTs,
+        ...(params.blocks?.length ? { blocks: params.blocks } : {}),
+    };
+    try {
+        // Slack Web API types model icon_url and icon_emoji as mutually exclusive.
+        // Build payloads in explicit branches so TS and runtime stay aligned.
+        if (params.identity?.iconUrl) {
+            return await params.client.chat.postMessage({
+                ...basePayload,
+                ...(params.identity.username ? { username: params.identity.username } : {}),
+                icon_url: params.identity.iconUrl,
+            });
+        }
+        if (params.identity?.iconEmoji) {
+            return await params.client.chat.postMessage({
+                ...basePayload,
+                ...(params.identity.username ? { username: params.identity.username } : {}),
+                icon_emoji: params.identity.iconEmoji,
+            });
+        }
+        return await params.client.chat.postMessage({
+            ...basePayload,
+            ...(params.identity?.username ? { username: params.identity.username } : {}),
+        });
+    }
+    catch (err) {
+        if (!hasCustomIdentity(params.identity) || !isSlackCustomizeScopeError(err)) {
+            throw err;
+        }
+        logVerbose("slack send: missing chat:write.customize, retrying without custom identity");
+        return params.client.chat.postMessage(basePayload);
+    }
+}
 function resolveToken(params) {
     const explicit = resolveSlackBotToken(params.explicit);
-    if (explicit)
+    if (explicit) {
         return explicit;
+    }
     const fallback = resolveSlackBotToken(params.fallbackToken);
     if (!fallback) {
         logVerbose(`slack send: missing bot token for account=${params.accountId} explicit=${Boolean(params.explicit)} source=${params.fallbackSource ?? "unknown"}`);
@@ -39,7 +101,10 @@ async function resolveChannelId(client, recipient) {
     return { channelId, isDm: true };
 }
 async function uploadSlackFile(params) {
-    const { buffer, contentType: _contentType, fileName, } = await loadWebMedia(params.mediaUrl, params.maxBytes);
+    const { buffer, contentType: _contentType, fileName, } = await loadWebMedia(params.mediaUrl, {
+        maxBytes: params.maxBytes,
+        localRoots: params.mediaLocalRoots,
+    });
     const basePayload = {
         channel_id: params.channelId,
         file: buffer,
@@ -61,8 +126,9 @@ async function uploadSlackFile(params) {
 }
 export async function sendMessageSlack(to, message, opts = {}) {
     const trimmedMessage = message?.trim() ?? "";
-    if (!trimmedMessage && !opts.mediaUrl) {
-        throw new Error("Slack send requires text or media");
+    const blocks = opts.blocks == null ? undefined : validateSlackBlocksArray(opts.blocks);
+    if (!trimmedMessage && !opts.mediaUrl && !blocks) {
+        throw new Error("Slack send requires text, blocks, or media");
     }
     const cfg = loadConfig();
     const account = resolveSlackAccount({
@@ -78,6 +144,24 @@ export async function sendMessageSlack(to, message, opts = {}) {
     const client = opts.client ?? createSlackWebClient(token);
     const recipient = parseRecipient(to);
     const { channelId } = await resolveChannelId(client, recipient);
+    if (blocks) {
+        if (opts.mediaUrl) {
+            throw new Error("Slack send does not support blocks with mediaUrl");
+        }
+        const fallbackText = trimmedMessage || buildSlackBlocksFallbackText(blocks);
+        const response = await postSlackMessageBestEffort({
+            client,
+            channelId,
+            text: fallbackText,
+            threadTs: opts.threadTs,
+            identity: opts.identity,
+            blocks,
+        });
+        return {
+            messageId: response.ts ?? "unknown",
+            channelId,
+        };
+    }
     const textLimit = resolveTextChunkLimit(cfg, "slack", account.accountId);
     const chunkLimit = Math.min(textLimit, SLACK_TEXT_LIMIT);
     const tableMode = resolveMarkdownTableMode({
@@ -90,8 +174,9 @@ export async function sendMessageSlack(to, message, opts = {}) {
         ? chunkMarkdownTextWithMode(trimmedMessage, chunkLimit, chunkMode)
         : [trimmedMessage];
     const chunks = markdownChunks.flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode }));
-    if (!chunks.length && trimmedMessage)
+    if (!chunks.length && trimmedMessage) {
         chunks.push(trimmedMessage);
+    }
     const mediaMaxBytes = typeof account.config.mediaMaxMb === "number"
         ? account.config.mediaMaxMb * 1024 * 1024
         : undefined;
@@ -102,25 +187,30 @@ export async function sendMessageSlack(to, message, opts = {}) {
             client,
             channelId,
             mediaUrl: opts.mediaUrl,
+            mediaLocalRoots: opts.mediaLocalRoots,
             caption: firstChunk,
             threadTs: opts.threadTs,
             maxBytes: mediaMaxBytes,
         });
         for (const chunk of rest) {
-            const response = await client.chat.postMessage({
-                channel: channelId,
+            const response = await postSlackMessageBestEffort({
+                client,
+                channelId,
                 text: chunk,
-                thread_ts: opts.threadTs,
+                threadTs: opts.threadTs,
+                identity: opts.identity,
             });
             lastMessageId = response.ts ?? lastMessageId;
         }
     }
     else {
         for (const chunk of chunks.length ? chunks : [""]) {
-            const response = await client.chat.postMessage({
-                channel: channelId,
+            const response = await postSlackMessageBestEffort({
+                client,
+                channelId,
                 text: chunk,
-                thread_ts: opts.threadTs,
+                threadTs: opts.threadTs,
+                identity: opts.identity,
             });
             lastMessageId = response.ts ?? lastMessageId;
         }

package/dist/slack/stream-mode.js

@@ -1,3 +1,4 @@
+import { mapStreamingModeToSlackLegacyDraftStreamMode, resolveSlackNativeStreaming, resolveSlackStreamingMode, } from "../config/discord-preview-streaming.js";
 const DEFAULT_STREAM_MODE = "replace";
 export function resolveSlackStreamMode(raw) {
     if (typeof raw !== "string") {
@@ -9,6 +10,15 @@ export function resolveSlackStreamMode(raw) {
     }
     return DEFAULT_STREAM_MODE;
 }
+export function resolveSlackStreamingConfig(params) {
+    const mode = resolveSlackStreamingMode(params);
+    const nativeStreaming = resolveSlackNativeStreaming(params);
+    return {
+        mode,
+        nativeStreaming,
+        draftMode: mapStreamingModeToSlackLegacyDraftStreamMode(mode),
+    };
+}
 export function applyAppendOnlyStreamUpdate(params) {
     const incoming = params.incoming.trimEnd();
     if (!incoming) {

package/dist/slack/streaming.js

@@ -23,11 +23,13 @@ import { logVerbose } from "../globals.js";
  * The first chunk of text can optionally be included via `text`.
  */
 export async function startSlackStream(params) {
-    const { client, channel, threadTs, text } = params;
-    logVerbose(`slack-stream: starting stream in ${channel} thread=${threadTs}`);
+    const { client, channel, threadTs, text, teamId, userId } = params;
+    logVerbose(`slack-stream: starting stream in ${channel} thread=${threadTs}${teamId ? ` team=${teamId}` : ""}${userId ? ` user=${userId}` : ""}`);
     const streamer = client.chatStream({
         channel,
         thread_ts: threadTs,
+        ...(teamId ? { recipient_team_id: teamId } : {}),
+        ...(userId ? { recipient_user_id: userId } : {}),
     });
     const session = {
         streamer,

package/dist/telegram/accounts.js

@@ -1,10 +1,24 @@
+import util from "node:util";
+import { createAccountActionGate } from "../channels/plugins/account-action-gate.js";
 import { isTruthyEnvValue } from "../infra/env.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { listBoundAccountIds, resolveDefaultAgentBoundAccountId } from "../routing/bindings.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
 import { resolveTelegramToken } from "./token.js";
+const log = createSubsystemLogger("telegram/accounts");
+function formatDebugArg(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value instanceof Error) {
+        return value.stack ?? value.message;
+    }
+    return util.inspect(value, { colors: false, depth: null, compact: true, breakLength: Infinity });
+}
 const debugAccounts = (...args) => {
     if (isTruthyEnvValue(process.env.POOLBOT_DEBUG_TELEGRAM_ACCOUNTS)) {
-        console.warn("[telegram:accounts]", ...args);
+        const parts = args.map((arg) => formatDebugArg(arg));
+        log.warn(parts.join(" ").trim());
     }
 };
 function listConfiguredAccountIds(cfg) {
@@ -61,19 +75,10 @@ function mergeTelegramAccountConfig(cfg, accountId) {
 }
 export function createTelegramActionGate(params) {
     const accountId = normalizeAccountId(params.accountId);
-    const baseActions = params.cfg.channels?.telegram?.actions;
-    const accountActions = resolveAccountConfig(params.cfg, accountId)?.actions;
-    return (key, defaultValue = true) => {
-        const accountValue = accountActions?.[key];
-        if (accountValue !== undefined) {
-            return accountValue;
-        }
-        const baseValue = baseActions?.[key];
-        if (baseValue !== undefined) {
-            return baseValue;
-        }
-        return defaultValue;
-    };
+    return createAccountActionGate({
+        baseActions: params.cfg.channels?.telegram?.actions,
+        accountActions: resolveAccountConfig(params.cfg, accountId)?.actions,
+    });
 }
 export function resolveTelegramAccount(params) {
     const hasExplicitAccountId = Boolean(params.accountId?.trim());

package/dist/telegram/bot/helpers.js

@@ -1,4 +1,5 @@
 import { formatLocationText } from "../../channels/location.js";
+import { resolveTelegramPreviewStreamMode } from "../../config/discord-preview-streaming.js";
 import { readChannelAllowFromStore } from "../../pairing/pairing-store.js";
 import { firstDefined, normalizeAllowFromWithStore, } from "../bot-access.js";
 const TELEGRAM_GENERAL_TOPIC_ID = 1;
@@ -13,6 +14,7 @@ export async function resolveTelegramGroupAllowFromContext(params) {
     const effectiveGroupAllow = normalizeAllowFromWithStore({
         allowFrom: groupAllowOverride ?? params.groupAllowFrom,
         storeAllowFrom,
+        dmPolicy: params.dmPolicy,
     });
     const hasGroupAllowOverride = typeof groupAllowOverride !== "undefined";
     return {
@@ -100,11 +102,7 @@ export function buildTypingThreadParams(messageThreadId) {
     return { message_thread_id: Math.trunc(messageThreadId) };
 }
 export function resolveTelegramStreamMode(telegramCfg) {
-    const raw = telegramCfg?.streamMode?.trim().toLowerCase();
-    if (raw === "off" || raw === "partial" || raw === "block") {
-        return raw;
-    }
-    return "partial";
+    return resolveTelegramPreviewStreamMode(telegramCfg);
 }
 export function buildTelegramGroupPeerId(chatId, messageThreadId) {
     return messageThreadId != null ? `${chatId}:topic:${messageThreadId}` : String(chatId);

package/dist/telegram/bot-access.js

@@ -1,59 +1,58 @@
+import { firstDefined, isSenderIdAllowed, mergeAllowFromSources } from "../channels/allow-from.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const warnedInvalidEntries = new Set();
+const log = createSubsystemLogger("telegram/bot-access");
+function warnInvalidAllowFromEntries(entries) {
+    if (process.env.VITEST || process.env.NODE_ENV === "test") {
+        return;
+    }
+    for (const entry of entries) {
+        if (warnedInvalidEntries.has(entry)) {
+            continue;
+        }
+        warnedInvalidEntries.add(entry);
+        log.warn([
+            "Invalid allowFrom entry:",
+            JSON.stringify(entry),
+            "- allowFrom/groupAllowFrom authorization requires numeric Telegram sender IDs only.",
+            'If you had "@username" entries, re-run onboarding (it resolves @username to IDs) or replace them manually.',
+        ].join(" "));
+    }
+}
 export const normalizeAllowFrom = (list) => {
     const entries = (list ?? []).map((value) => String(value).trim()).filter(Boolean);
     const hasWildcard = entries.includes("*");
     const normalized = entries
         .filter((value) => value !== "*")
         .map((value) => value.replace(/^(telegram|tg):/i, ""));
-    const normalizedLower = normalized.map((value) => value.toLowerCase());
+    const invalidEntries = normalized.filter((value) => !/^\d+$/.test(value));
+    if (invalidEntries.length > 0) {
+        warnInvalidAllowFromEntries([...new Set(invalidEntries)]);
+    }
+    const ids = normalized.filter((value) => /^\d+$/.test(value));
     return {
-        entries: normalized,
-        entriesLower: normalizedLower,
+        entries: ids,
         hasWildcard,
         hasEntries: entries.length > 0,
+        invalidEntries,
     };
 };
-export const normalizeAllowFromWithStore = (params) => {
-    const combined = [...(params.allowFrom ?? []), ...(params.storeAllowFrom ?? [])]
-        .map((value) => String(value).trim())
-        .filter(Boolean);
-    return normalizeAllowFrom(combined);
-};
-export const firstDefined = (...values) => {
-    for (const value of values) {
-        if (typeof value !== "undefined")
-            return value;
-    }
-    return undefined;
-};
+export const normalizeAllowFromWithStore = (params) => normalizeAllowFrom(mergeAllowFromSources(params));
 export const isSenderAllowed = (params) => {
-    const { allow, senderId, senderUsername } = params;
-    if (!allow.hasEntries)
-        return true;
-    if (allow.hasWildcard)
-        return true;
-    if (senderId && allow.entries.includes(senderId))
-        return true;
-    const username = senderUsername?.toLowerCase();
-    if (!username)
-        return false;
-    return allow.entriesLower.some((entry) => entry === username || entry === `@${username}`);
+    const { allow, senderId } = params;
+    return isSenderIdAllowed(allow, senderId, true);
 };
+export { firstDefined };
 export const resolveSenderAllowMatch = (params) => {
-    const { allow, senderId, senderUsername } = params;
+    const { allow, senderId } = params;
     if (allow.hasWildcard) {
         return { allowed: true, matchKey: "*", matchSource: "wildcard" };
     }
-    if (!allow.hasEntries)
+    if (!allow.hasEntries) {
         return { allowed: false };
+    }
     if (senderId && allow.entries.includes(senderId)) {
         return { allowed: true, matchKey: senderId, matchSource: "id" };
     }
-    const username = senderUsername?.toLowerCase();
-    if (!username)
-        return { allowed: false };
-    const entry = allow.entriesLower.find((candidate) => candidate === username || candidate === `@${username}`);
-    if (entry) {
-        return { allowed: true, matchKey: entry, matchSource: "username" };
-    }
     return { allowed: false };
 };