@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/shared/entry-status.js

@@ -23,3 +23,9 @@ export function evaluateEntryMetadataRequirements(params) {
         configChecks,
     };
 }
+export function evaluateEntryMetadataRequirementsForCurrentPlatform(params) {
+    return evaluateEntryMetadataRequirements({
+        ...params,
+        localPlatform: process.platform,
+    });
+}

package/dist/shared/frontmatter.js

@@ -24,7 +24,7 @@ export function parseFrontmatterBool(value, fallback) {
     const parsed = parseBooleanValue(value);
     return parsed === undefined ? fallback : parsed;
 }
-export function resolvePoolbotManifestBlock(params) {
+export function resolvePoolBotManifestBlock(params) {
     const raw = getFrontmatterString(params.frontmatter, params.key ?? "metadata");
     if (!raw) {
         return undefined;
@@ -47,7 +47,7 @@ export function resolvePoolbotManifestBlock(params) {
         return undefined;
     }
 }
-export function resolvePoolbotManifestRequires(metadataObj) {
+export function resolvePoolBotManifestRequires(metadataObj) {
     const requiresRaw = typeof metadataObj.requires === "object" && metadataObj.requires !== null
         ? metadataObj.requires
         : undefined;
@@ -61,16 +61,16 @@ export function resolvePoolbotManifestRequires(metadataObj) {
         config: normalizeStringList(requiresRaw.config),
     };
 }
-export function resolvePoolbotManifestInstall(metadataObj, parseInstallSpec) {
+export function resolvePoolBotManifestInstall(metadataObj, parseInstallSpec) {
     const installRaw = Array.isArray(metadataObj.install) ? metadataObj.install : [];
     return installRaw
         .map((entry) => parseInstallSpec(entry))
         .filter((entry) => Boolean(entry));
 }
-export function resolvePoolbotManifestOs(metadataObj) {
+export function resolvePoolBotManifestOs(metadataObj) {
     return normalizeStringList(metadataObj.os);
 }
-export function parsePoolbotManifestInstallBase(input, allowedKinds) {
+export function parsePoolBotManifestInstallBase(input, allowedKinds) {
     if (!input || typeof input !== "object") {
         return undefined;
     }

package/dist/shared/node-match.js

@@ -39,14 +39,21 @@ export function resolveNodeIdFromCandidates(nodes, query) {
     if (!q) {
         throw new Error("node required");
     }
-    const matches = resolveNodeMatches(nodes, q);
-    if (matches.length === 1) {
-        return matches[0]?.nodeId ?? "";
+    const rawMatches = resolveNodeMatches(nodes, q);
+    if (rawMatches.length === 1) {
+        return rawMatches[0]?.nodeId ?? "";
     }
-    if (matches.length === 0) {
+    if (rawMatches.length === 0) {
         const known = listKnownNodes(nodes);
         throw new Error(`unknown node: ${q}${known ? ` (known: ${known})` : ""}`);
     }
+    // Re-pair/reinstall flows can leave multiple nodes with the same display name.
+    // Prefer a unique connected match when available.
+    const connectedMatches = rawMatches.filter((match) => match.connected === true);
+    const matches = connectedMatches.length > 0 ? connectedMatches : rawMatches;
+    if (matches.length === 1) {
+        return matches[0]?.nodeId ?? "";
+    }
     throw new Error(`ambiguous node: ${q} (matches: ${matches
         .map((n) => n.displayName || n.remoteIp || n.nodeId)
         .join(", ")})`);

package/dist/shared/operator-scope-compat.js

@@ -2,6 +2,7 @@ const OPERATOR_ROLE = "operator";
 const OPERATOR_ADMIN_SCOPE = "operator.admin";
 const OPERATOR_READ_SCOPE = "operator.read";
 const OPERATOR_WRITE_SCOPE = "operator.write";
+const OPERATOR_SCOPE_PREFIX = "operator.";
 function normalizeScopeList(scopes) {
     const out = new Set();
     for (const scope of scopes) {
@@ -13,10 +14,14 @@ function normalizeScopeList(scopes) {
     return [...out];
 }
 function operatorScopeSatisfied(requestedScope, granted) {
+    if (granted.has(OPERATOR_ADMIN_SCOPE) && requestedScope.startsWith(OPERATOR_SCOPE_PREFIX)) {
+        return true;
+    }
     if (requestedScope === OPERATOR_READ_SCOPE) {
-        return (granted.has(OPERATOR_READ_SCOPE) ||
-            granted.has(OPERATOR_WRITE_SCOPE) ||
-            granted.has(OPERATOR_ADMIN_SCOPE));
+        return granted.has(OPERATOR_READ_SCOPE) || granted.has(OPERATOR_WRITE_SCOPE);
+    }
+    if (requestedScope === OPERATOR_WRITE_SCOPE) {
+        return granted.has(OPERATOR_WRITE_SCOPE);
     }
     return granted.has(requestedScope);
 }

package/dist/signal/accounts.js

@@ -1,26 +1,13 @@
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
-function listConfiguredAccountIds(cfg) {
-    const accounts = cfg.channels?.signal?.accounts;
-    if (!accounts || typeof accounts !== "object")
-        return [];
-    return Object.keys(accounts).filter(Boolean);
-}
-export function listSignalAccountIds(cfg) {
-    const ids = listConfiguredAccountIds(cfg);
-    if (ids.length === 0)
-        return [DEFAULT_ACCOUNT_ID];
-    return ids.sort((a, b) => a.localeCompare(b));
-}
-export function resolveDefaultSignalAccountId(cfg) {
-    const ids = listSignalAccountIds(cfg);
-    if (ids.includes(DEFAULT_ACCOUNT_ID))
-        return DEFAULT_ACCOUNT_ID;
-    return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
+import { createAccountListHelpers } from "../channels/plugins/account-helpers.js";
+import { normalizeAccountId } from "../routing/session-key.js";
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("signal");
+export const listSignalAccountIds = listAccountIds;
+export const resolveDefaultSignalAccountId = resolveDefaultAccountId;
 function resolveAccountConfig(cfg, accountId) {
     const accounts = cfg.channels?.signal?.accounts;
-    if (!accounts || typeof accounts !== "object")
+    if (!accounts || typeof accounts !== "object") {
         return undefined;
+    }
     return accounts[accountId];
 }
 function mergeSignalAccountConfig(cfg, accountId) {

package/dist/signal/monitor/event-handler.js

@@ -379,7 +379,9 @@ export function createSignalEventHandler(deps) {
         const groupId = dataMessage.groupInfo?.groupId ?? undefined;
         const groupName = dataMessage.groupInfo?.groupName ?? undefined;
         const isGroup = Boolean(groupId);
-        const storeAllowFrom = await readChannelAllowFromStore("signal").catch(() => []);
+        const storeAllowFrom = deps.dmPolicy === "allowlist"
+            ? []
+            : await readChannelAllowFromStore("signal").catch(() => []);
         const effectiveDmAllow = [...deps.allowFrom, ...storeAllowFrom];
         const effectiveGroupAllow = [...deps.groupAllowFrom, ...storeAllowFrom];
         const dmAllowed = deps.dmPolicy === "open" ? true : isSignalSenderAllowed(sender, effectiveDmAllow);

package/dist/slack/accounts.js

@@ -1,28 +1,15 @@
 import { normalizeChatType } from "../channels/chat-type.js";
+import { createAccountListHelpers } from "../channels/plugins/account-helpers.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
 import { resolveSlackAppToken, resolveSlackBotToken } from "./token.js";
-function listConfiguredAccountIds(cfg) {
-    const accounts = cfg.channels?.slack?.accounts;
-    if (!accounts || typeof accounts !== "object")
-        return [];
-    return Object.keys(accounts).filter(Boolean);
-}
-export function listSlackAccountIds(cfg) {
-    const ids = listConfiguredAccountIds(cfg);
-    if (ids.length === 0)
-        return [DEFAULT_ACCOUNT_ID];
-    return ids.sort((a, b) => a.localeCompare(b));
-}
-export function resolveDefaultSlackAccountId(cfg) {
-    const ids = listSlackAccountIds(cfg);
-    if (ids.includes(DEFAULT_ACCOUNT_ID))
-        return DEFAULT_ACCOUNT_ID;
-    return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("slack");
+export const listSlackAccountIds = listAccountIds;
+export const resolveDefaultSlackAccountId = resolveDefaultAccountId;
 function resolveAccountConfig(cfg, accountId) {
     const accounts = cfg.channels?.slack?.accounts;
-    if (!accounts || typeof accounts !== "object")
+    if (!accounts || typeof accounts !== "object") {
         return undefined;
+    }
     return accounts[accountId];
 }
 function mergeSlackAccountConfig(cfg, accountId) {

package/dist/slack/actions.js

@@ -1,6 +1,8 @@
 import { loadConfig } from "../config/config.js";
 import { logVerbose } from "../globals.js";
 import { resolveSlackAccount } from "./accounts.js";
+import { buildSlackBlocksFallbackText } from "./blocks-fallback.js";
+import { validateSlackBlocksArray } from "./blocks-input.js";
 import { createSlackWebClient } from "./client.js";
 import { sendMessageSlack } from "./send.js";
 import { resolveSlackBotToken } from "./token.js";
@@ -55,15 +57,17 @@ export async function removeOwnSlackReactions(channelId, messageId, opts = {}) {
     const toRemove = new Set();
     for (const reaction of reactions ?? []) {
         const name = reaction?.name;
-        if (!name)
+        if (!name) {
             continue;
+        }
         const users = reaction?.users ?? [];
         if (users.includes(userId)) {
             toRemove.add(name);
         }
     }
-    if (toRemove.size === 0)
+    if (toRemove.size === 0) {
         return [];
+    }
     await Promise.all(Array.from(toRemove, (name) => client.reactions.remove({
         channel: channelId,
         timestamp: messageId,
@@ -88,14 +92,18 @@ export async function sendSlackMessage(to, content, opts = {}) {
         mediaUrl: opts.mediaUrl,
         client: opts.client,
         threadTs: opts.threadTs,
+        blocks: opts.blocks,
     });
 }
 export async function editSlackMessage(channelId, messageId, content, opts = {}) {
     const client = await getClient(opts);
+    const blocks = opts.blocks == null ? undefined : validateSlackBlocksArray(opts.blocks);
+    const trimmedContent = content.trim();
     await client.chat.update({
         channel: channelId,
         ts: messageId,
-        text: content,
+        text: trimmedContent || (blocks ? buildSlackBlocksFallbackText(blocks) : " "),
+        ...(blocks ? { blocks } : {}),
     });
 }
 export async function deleteSlackMessage(channelId, messageId, opts = {}) {

package/dist/slack/monitor/auth.js

@@ -1,7 +1,7 @@
 import { readChannelAllowFromStore } from "../../pairing/pairing-store.js";
 import { allowListMatches, normalizeAllowList, normalizeAllowListLower } from "./allow-list.js";
 export async function resolveSlackEffectiveAllowFrom(ctx) {
-    const storeAllowFrom = await readChannelAllowFromStore("slack").catch(() => []);
+    const storeAllowFrom = ctx.dmPolicy === "allowlist" ? [] : await readChannelAllowFromStore("slack").catch(() => []);
     const allowFrom = normalizeAllowList([...ctx.allowFrom, ...storeAllowFrom]);
     const allowFromLower = normalizeAllowListLower(allowFrom);
     return { allowFrom, allowFromLower };

package/dist/slack/monitor/message-handler/dispatch.js

@@ -10,15 +10,18 @@ import { resolveStorePath, updateLastRoute } from "../../../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../../../globals.js";
 import { removeSlackReaction } from "../../actions.js";
 import { createSlackDraftStream } from "../../draft-stream.js";
-import { applyAppendOnlyStreamUpdate, buildStatusFinalPreviewText, resolveSlackStreamMode, } from "../../stream-mode.js";
+import { applyAppendOnlyStreamUpdate, buildStatusFinalPreviewText, resolveSlackStreamingConfig, } from "../../stream-mode.js";
 import { appendSlackStream, startSlackStream, stopSlackStream } from "../../streaming.js";
 import { resolveSlackThreadTargets } from "../../threading.js";
 import { createSlackReplyDeliveryPlan, deliverReplies, resolveSlackThreadTs } from "../replies.js";
 function hasMedia(payload) {
     return Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
 }
-export function isSlackStreamingEnabled(streaming) {
-    return streaming !== false;
+export function isSlackStreamingEnabled(params) {
+    if (params.mode !== "partial") {
+        return false;
+    }
+    return params.nativeStreaming;
 }
 export function resolveSlackStreamingThreadHint(params) {
     return resolveSlackThreadTs({
@@ -120,7 +123,16 @@ export async function dispatchPreparedSlackMessage(prepared) {
         channel: "slack",
         accountId: route.accountId,
     });
-    const streamingEnabled = isSlackStreamingEnabled(account.config.streaming);
+    const slackStreaming = resolveSlackStreamingConfig({
+        streaming: account.config.streaming,
+        streamMode: account.config.streamMode,
+        nativeStreaming: account.config.nativeStreaming,
+    });
+    const previewStreamingEnabled = slackStreaming.mode !== "off";
+    const streamingEnabled = isSlackStreamingEnabled({
+        mode: slackStreaming.mode,
+        nativeStreaming: slackStreaming.nativeStreaming,
+    });
     const streamThreadHint = resolveSlackStreamingThreadHint({
         replyToMode: ctx.replyToMode,
         incomingThreadTs,
@@ -167,6 +179,8 @@ export async function dispatchPreparedSlackMessage(prepared) {
                     channel: message.channel,
                     threadTs: streamThreadTs,
                     text,
+                    teamId: ctx.teamId,
+                    userId: message.user,
                 });
                 replyPlan.markSent();
                 return;
@@ -194,7 +208,8 @@ export async function dispatchPreparedSlackMessage(prepared) {
             const draftMessageId = draftStream?.messageId();
             const draftChannelId = draftStream?.channelId();
             const finalText = payload.text;
-            const canFinalizeViaPreviewEdit = streamMode !== "status_final" &&
+            const canFinalizeViaPreviewEdit = previewStreamingEnabled &&
+                streamMode !== "status_final" &&
                 mediaCount === 0 &&
                 !payload.isError &&
                 typeof finalText === "string" &&
@@ -216,7 +231,7 @@ export async function dispatchPreparedSlackMessage(prepared) {
                     logVerbose(`slack: preview final edit failed; falling back to standard send (${String(err)})`);
                 }
             }
-            else if (streamMode === "status_final" && hasStreamedMessage) {
+            else if (previewStreamingEnabled && streamMode === "status_final" && hasStreamedMessage) {
                 try {
                     const statusChannelId = draftStream?.channelId();
                     const statusMessageId = draftStream?.messageId();
@@ -267,7 +282,7 @@ export async function dispatchPreparedSlackMessage(prepared) {
         warn: logVerbose,
     });
     let hasStreamedMessage = false;
-    const streamMode = resolveSlackStreamMode(account.config.streamMode);
+    const streamMode = slackStreaming.draftMode;
     let appendRenderedText = "";
     let appendSourceText = "";
     let statusUpdateCount = 0;
@@ -312,38 +327,44 @@ export async function dispatchPreparedSlackMessage(prepared) {
             skillFilter: prepared.channelConfig?.skills,
             hasRepliedRef,
             disableBlockStreaming: useStreaming
-                ? false
+                ? true
                 : typeof account.config.blockStreaming === "boolean"
                     ? !account.config.blockStreaming
                     : undefined,
             onModelSelected,
             onPartialReply: useStreaming
                 ? undefined
-                : async (payload) => {
-                    updateDraftFromPartial(payload.text);
-                },
+                : !previewStreamingEnabled
+                    ? undefined
+                    : async (payload) => {
+                        updateDraftFromPartial(payload.text);
+                    },
             onAssistantMessageStart: useStreaming
                 ? undefined
-                : async () => {
-                    if (hasStreamedMessage) {
-                        draftStream.forceNewMessage();
-                        hasStreamedMessage = false;
-                        appendRenderedText = "";
-                        appendSourceText = "";
-                        statusUpdateCount = 0;
-                    }
-                },
+                : !previewStreamingEnabled
+                    ? undefined
+                    : async () => {
+                        if (hasStreamedMessage) {
+                            draftStream.forceNewMessage();
+                            hasStreamedMessage = false;
+                            appendRenderedText = "";
+                            appendSourceText = "";
+                            statusUpdateCount = 0;
+                        }
+                    },
             onReasoningEnd: useStreaming
                 ? undefined
-                : async () => {
-                    if (hasStreamedMessage) {
-                        draftStream.forceNewMessage();
-                        hasStreamedMessage = false;
-                        appendRenderedText = "";
-                        appendSourceText = "";
-                        statusUpdateCount = 0;
-                    }
-                },
+                : !previewStreamingEnabled
+                    ? undefined
+                    : async () => {
+                        if (hasStreamedMessage) {
+                            draftStream.forceNewMessage();
+                            hasStreamedMessage = false;
+                            appendRenderedText = "";
+                            appendSourceText = "";
+                            statusUpdateCount = 0;
+                        }
+                    },
         },
     });
     await draftStream.flush();

package/dist/slack/monitor/replies.js

@@ -1,6 +1,6 @@
+import { chunkMarkdownTextWithMode } from "../../auto-reply/chunk.js";
 import { createReplyReferencePlanner } from "../../auto-reply/reply/reply-reference.js";
 import { isSilentReplyText, SILENT_REPLY_TOKEN } from "../../auto-reply/tokens.js";
-import { chunkMarkdownTextWithMode } from "../../auto-reply/chunk.js";
 import { markdownToSlackMrkdwnChunks } from "../format.js";
 import { sendMessageSlack } from "../send.js";
 export async function deliverReplies(params) {
@@ -8,12 +8,14 @@ export async function deliverReplies(params) {
         const threadTs = payload.replyToId ?? params.replyThreadTs;
         const mediaList = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
         const text = payload.text ?? "";
-        if (!text && mediaList.length === 0)
+        if (!text && mediaList.length === 0) {
             continue;
+        }
         if (mediaList.length === 0) {
             const trimmed = text.trim();
-            if (!trimmed || isSilentReplyText(trimmed, SILENT_REPLY_TOKEN))
+            if (!trimmed || isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) {
                 continue;
+            }
             await sendMessageSlack(params.target, trimmed, {
                 token: params.token,
                 threadTs,
@@ -52,8 +54,11 @@ export function resolveSlackThreadTs(params) {
     return planner.use();
 }
 function createSlackReplyReferencePlanner(params) {
+    // When already inside a Slack thread, always stay in it regardless of
+    // replyToMode — thread_ts is required to keep messages in the thread.
+    const effectiveMode = params.incomingThreadTs ? "all" : params.replyToMode;
     return createReplyReferencePlanner({
-        replyToMode: params.replyToMode,
+        replyToMode: effectiveMode,
         existingId: params.incomingThreadTs,
         startId: params.messageTs,
         hasReplied: params.hasReplied,
@@ -84,21 +89,24 @@ export async function deliverSlackSlashReplies(params) {
         const combined = [text ?? "", ...mediaList.map((url) => url.trim()).filter(Boolean)]
             .filter(Boolean)
             .join("\n");
-        if (!combined)
+        if (!combined) {
             continue;
+        }
         const chunkMode = params.chunkMode ?? "length";
         const markdownChunks = chunkMode === "newline"
             ? chunkMarkdownTextWithMode(combined, chunkLimit, chunkMode)
             : [combined];
         const chunks = markdownChunks.flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode: params.tableMode }));
-        if (!chunks.length && combined)
+        if (!chunks.length && combined) {
             chunks.push(combined);
+        }
         for (const chunk of chunks) {
             messages.push(chunk);
         }
     }
-    if (messages.length === 0)
+    if (messages.length === 0) {
         return;
+    }
     // Slack slash command responses can be multi-part by sending follow-ups via response_url.
     const responseType = params.ephemeral ? "ephemeral" : "in_channel";
     for (const text of messages) {

package/dist/slack/monitor/slash.js

@@ -9,6 +9,7 @@ import { normalizeAllowList, normalizeAllowListLower, resolveSlackAllowListMatch
 import { resolveSlackChannelConfig } from "./channel-config.js";
 import { buildSlackSlashCommandMatcher, resolveSlackSlashCommandConfig } from "./commands.js";
 import { normalizeSlackChannelType } from "./context.js";
+import { escapeSlackMrkdwn } from "./mrkdwn.js";
 import { isSlackChannelAllowedByPolicy } from "./policy.js";
 import { resolveSlackRoomContextHints } from "./room-context.js";
 const SLACK_COMMAND_ARG_ACTION_ID = "poolbot_cmdarg";
@@ -32,14 +33,6 @@ function truncatePlainText(value, max) {
     }
     return `${trimmed.slice(0, max - 1)}…`;
 }
-function escapeSlackMrkdwn(value) {
-    return value
-        .replaceAll("\\", "\\\\")
-        .replaceAll("&", "&")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;")
-        .replace(/([*_`~])/g, "\\$1");
-}
 function buildSlackArgMenuConfirm(params) {
     const command = escapeSlackMrkdwn(params.command);
     const arg = escapeSlackMrkdwn(params.arg);
@@ -267,7 +260,9 @@ export async function registerSlackMonitorSlashCommands(params) {
                 });
                 return;
             }
-            const storeAllowFrom = await readChannelAllowFromStore("slack").catch(() => []);
+            const storeAllowFrom = ctx.dmPolicy === "allowlist"
+                ? []
+                : await readChannelAllowFromStore("slack").catch(() => []);
             const effectiveAllowFrom = normalizeAllowList([...ctx.allowFrom, ...storeAllowFrom]);
             const effectiveAllowFromLower = normalizeAllowListLower(effectiveAllowFrom);
             // Privileged command surface: compute CommandAuthorized, don't assume true.
@@ -435,9 +430,10 @@ export async function registerSlackMonitorSlashCommands(params) {
                 import("../../auto-reply/reply/inbound-context.js"),
                 import("../../auto-reply/reply/provider-dispatcher.js"),
             ]);
-            const [{ resolveConversationLabel }, { createReplyPrefixOptions }] = await Promise.all([
+            const [{ resolveConversationLabel }, { createReplyPrefixOptions }, { recordSessionMetaFromInbound, resolveStorePath },] = await Promise.all([
                 import("../../channels/conversation-label.js"),
                 import("../../channels/reply-prefix.js"),
+                import("../../config/sessions.js"),
             ]);
             const route = resolveAgentRoute({
                 cfg,
@@ -495,6 +491,19 @@ export async function registerSlackMonitorSlashCommands(params) {
                 OriginatingChannel: "slack",
                 OriginatingTo: `user:${command.user_id}`,
             });
+            const storePath = resolveStorePath(cfg.session?.store, {
+                agentId: route.agentId,
+            });
+            try {
+                await recordSessionMetaFromInbound({
+                    storePath,
+                    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+                    ctx: ctxPayload,
+                });
+            }
+            catch (err) {
+                runtime.error?.(danger(`slack slash: failed updating session meta: ${String(err)}`));
+            }
             const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
                 cfg,
                 agentId: route.agentId,
@@ -613,11 +622,11 @@ export async function registerSlackMonitorSlashCommands(params) {
         return;
     }
     const registerArgOptions = () => {
-        const optionsHandler = ctx.app.options;
-        if (typeof optionsHandler !== "function") {
+        const appWithOptions = ctx.app;
+        if (typeof appWithOptions.options !== "function") {
             return;
         }
-        optionsHandler(SLACK_COMMAND_ARG_ACTION_ID, async ({ ack, body }) => {
+        appWithOptions.options(SLACK_COMMAND_ARG_ACTION_ID, async ({ ack, body }) => {
             const typedBody = body;
             pruneSlackExternalArgMenuStore();
             const blockId = typedBody.actions?.[0]?.block_id ?? typedBody.block_id;

package/dist/slack/resolve-channels.js

@@ -1,8 +1,9 @@
 import { createSlackWebClient } from "./client.js";
 function parseSlackChannelMention(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return {};
+    }
     const mention = trimmed.match(/^<#([A-Z0-9]+)(?:\|([^>]+))?>$/i);
     if (mention) {
         const id = mention[1]?.toUpperCase();
@@ -10,8 +11,9 @@ function parseSlackChannelMention(raw) {
         return { id, name };
     }
     const prefixed = trimmed.replace(/^(slack:|channel:)/i, "");
-    if (/^[CG][A-Z0-9]+$/i.test(prefixed))
+    if (/^[CG][A-Z0-9]+$/i.test(prefixed)) {
         return { id: prefixed.toUpperCase() };
+    }
     const name = prefixed.replace(/^#/, "").trim();
     return name ? { name } : {};
 }
@@ -28,8 +30,9 @@ async function listSlackChannels(client) {
         for (const channel of res.channels ?? []) {
             const id = channel.id?.trim();
             const name = channel.name?.trim();
-            if (!id || !name)
+            if (!id || !name) {
                 continue;
+            }
             channels.push({
                 id,
                 name,
@@ -44,11 +47,13 @@ async function listSlackChannels(client) {
 }
 function resolveByName(name, channels) {
     const target = name.trim().toLowerCase();
-    if (!target)
+    if (!target) {
         return undefined;
+    }
     const matches = channels.filter((channel) => channel.name.toLowerCase() === target);
-    if (matches.length === 0)
+    if (matches.length === 0) {
         return undefined;
+    }
     const active = matches.find((channel) => !channel.archived);
     return active ?? matches[0];
 }