@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/signal/monitor/access-policy.js

@@ -0,0 +1,60 @@
+import { issuePairingChallenge } from "../../../../src/pairing/pairing-challenge.js";
+import { upsertChannelPairingRequest } from "../../../../src/pairing/pairing-store.js";
+import { readStoreAllowFromForDmPolicy, resolveDmGroupAccessWithLists, } from "../../../../src/security/dm-policy-shared.js";
+import { isSignalSenderAllowed } from "../identity.js";
+export async function resolveSignalAccessState(params) {
+    const storeAllowFrom = await readStoreAllowFromForDmPolicy({
+        provider: "signal",
+        accountId: params.accountId,
+        dmPolicy: params.dmPolicy,
+    });
+    const resolveAccessDecision = (isGroup) => resolveDmGroupAccessWithLists({
+        isGroup,
+        dmPolicy: params.dmPolicy,
+        groupPolicy: params.groupPolicy,
+        allowFrom: params.allowFrom,
+        groupAllowFrom: params.groupAllowFrom,
+        storeAllowFrom,
+        isSenderAllowed: (allowEntries) => isSignalSenderAllowed(params.sender, allowEntries),
+    });
+    const dmAccess = resolveAccessDecision(false);
+    return {
+        resolveAccessDecision,
+        dmAccess,
+        effectiveDmAllow: dmAccess.effectiveAllowFrom,
+        effectiveGroupAllow: dmAccess.effectiveGroupAllowFrom,
+    };
+}
+export async function handleSignalDirectMessageAccess(params) {
+    if (params.dmAccessDecision === "allow") {
+        return true;
+    }
+    if (params.dmAccessDecision === "block") {
+        if (params.dmPolicy !== "disabled") {
+            params.log(`Blocked signal sender ${params.senderDisplay} (dmPolicy=${params.dmPolicy})`);
+        }
+        return false;
+    }
+    if (params.dmPolicy === "pairing") {
+        await issuePairingChallenge({
+            channel: "signal",
+            senderId: params.senderId,
+            senderIdLine: params.senderIdLine,
+            meta: { name: params.senderName },
+            upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
+                channel: "signal",
+                id,
+                accountId: params.accountId,
+                meta,
+            }),
+            sendPairingReply: params.sendPairingReply,
+            onCreated: () => {
+                params.log(`signal pairing request sender=${params.senderId}`);
+            },
+            onReplyError: (err) => {
+                params.log(`signal pairing reply failed for ${params.senderId}: ${String(err)}`);
+            },
+        });
+    }
+    return false;
+}

package/dist/signal/runtime.js

@@ -0,0 +1,3 @@
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/compat";
+const { setRuntime: setSignalRuntime, getRuntime: getSignalRuntime } = createPluginRuntimeStore("Signal runtime not initialized");
+export { getSignalRuntime, setSignalRuntime };

package/dist/slack/account-inspect.js

@@ -0,0 +1,135 @@
+import { hasConfiguredSecretInput, normalizeSecretInputString, } from "../../../src/config/types.secrets.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../../../src/routing/session-key.js";
+import { mergeSlackAccountConfig, resolveDefaultSlackAccountId, } from "./accounts.js";
+function inspectSlackToken(value) {
+    const token = normalizeSecretInputString(value);
+    if (token) {
+        return {
+            token,
+            source: "config",
+            status: "available",
+        };
+    }
+    if (hasConfiguredSecretInput(value)) {
+        return {
+            source: "config",
+            status: "configured_unavailable",
+        };
+    }
+    return {
+        source: "none",
+        status: "missing",
+    };
+}
+export function inspectSlackAccount(params) {
+    const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+    const merged = mergeSlackAccountConfig(params.cfg, accountId);
+    const enabled = params.cfg.channels?.slack?.enabled !== false && merged.enabled !== false;
+    const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+    const mode = merged.mode ?? "socket";
+    const isHttpMode = mode === "http";
+    const configBot = inspectSlackToken(merged.botToken);
+    const configApp = inspectSlackToken(merged.appToken);
+    const configSigningSecret = inspectSlackToken(merged.signingSecret);
+    const configUser = inspectSlackToken(merged.userToken);
+    const envBot = allowEnv
+        ? normalizeSecretInputString(params.envBotToken ?? process.env.SLACK_BOT_TOKEN)
+        : undefined;
+    const envApp = allowEnv
+        ? normalizeSecretInputString(params.envAppToken ?? process.env.SLACK_APP_TOKEN)
+        : undefined;
+    const envUser = allowEnv
+        ? normalizeSecretInputString(params.envUserToken ?? process.env.SLACK_USER_TOKEN)
+        : undefined;
+    const botToken = configBot.token ?? envBot;
+    const appToken = configApp.token ?? envApp;
+    const signingSecret = configSigningSecret.token;
+    const userToken = configUser.token ?? envUser;
+    const botTokenSource = configBot.token
+        ? "config"
+        : configBot.status === "configured_unavailable"
+            ? "config"
+            : envBot
+                ? "env"
+                : "none";
+    const appTokenSource = configApp.token
+        ? "config"
+        : configApp.status === "configured_unavailable"
+            ? "config"
+            : envApp
+                ? "env"
+                : "none";
+    const signingSecretSource = configSigningSecret.token
+        ? "config"
+        : configSigningSecret.status === "configured_unavailable"
+            ? "config"
+            : "none";
+    const userTokenSource = configUser.token
+        ? "config"
+        : configUser.status === "configured_unavailable"
+            ? "config"
+            : envUser
+                ? "env"
+                : "none";
+    return {
+        accountId,
+        enabled,
+        name: merged.name?.trim() || undefined,
+        mode,
+        botToken,
+        appToken,
+        ...(isHttpMode ? { signingSecret } : {}),
+        userToken,
+        botTokenSource,
+        appTokenSource,
+        ...(isHttpMode ? { signingSecretSource } : {}),
+        userTokenSource,
+        botTokenStatus: configBot.token
+            ? "available"
+            : configBot.status === "configured_unavailable"
+                ? "configured_unavailable"
+                : envBot
+                    ? "available"
+                    : "missing",
+        appTokenStatus: configApp.token
+            ? "available"
+            : configApp.status === "configured_unavailable"
+                ? "configured_unavailable"
+                : envApp
+                    ? "available"
+                    : "missing",
+        ...(isHttpMode
+            ? {
+                signingSecretStatus: configSigningSecret.token
+                    ? "available"
+                    : configSigningSecret.status === "configured_unavailable"
+                        ? "configured_unavailable"
+                        : "missing",
+            }
+            : {}),
+        userTokenStatus: configUser.token
+            ? "available"
+            : configUser.status === "configured_unavailable"
+                ? "configured_unavailable"
+                : envUser
+                    ? "available"
+                    : "missing",
+        configured: isHttpMode
+            ? (configBot.status !== "missing" || Boolean(envBot)) &&
+                configSigningSecret.status !== "missing"
+            : (configBot.status !== "missing" || Boolean(envBot)) &&
+                (configApp.status !== "missing" || Boolean(envApp)),
+        config: merged,
+        groupPolicy: merged.groupPolicy,
+        textChunkLimit: merged.textChunkLimit,
+        mediaMaxMb: merged.mediaMaxMb,
+        reactionNotifications: merged.reactionNotifications,
+        reactionAllowlist: merged.reactionAllowlist,
+        replyToMode: merged.replyToMode,
+        replyToModeByChatType: merged.replyToModeByChatType,
+        actions: merged.actions,
+        slashCommand: merged.slashCommand,
+        dm: merged.dm,
+        channels: merged.channels,
+    };
+}

package/dist/slack/blocks-input.js

@@ -1,40 +1,9 @@
-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) {
+// Stub for slack/blocks-input.js
+export function parseSlackBlocksInput(blocks) {
+    if (!Array.isArray(blocks))
         return undefined;
-    }
-    const parsed = typeof raw === "string" ? parseBlocksJson(raw) : raw;
-    return validateSlackBlocksArray(parsed);
+    return blocks;
+}
+export function extractSlackToolSend(_blocks) {
+    return null;
 }

package/dist/slack/channel.js

@@ -0,0 +1,394 @@
+import { createScopedChannelConfigBase } from "openclaw/plugin-sdk/compat";
+import { buildAccountScopedDmSecurityPolicy, collectOpenProviderGroupPolicyWarnings, collectOpenGroupPolicyConfiguredRouteWarnings, createScopedAccountConfigAccessors, formatAllowFromLowercase, } from "openclaw/plugin-sdk/compat";
+import { applyAccountNameToChannelSection, buildComputedAccountStatusSnapshot, buildChannelConfigSchema, DEFAULT_ACCOUNT_ID, extractSlackToolSend, getChatChannelMeta, handleSlackMessageAction, inspectSlackAccount, listSlackMessageActions, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, looksLikeSlackTargetId, migrateBaseNameToDefaultAccount, normalizeAccountId, normalizeSlackMessagingTarget, PAIRING_APPROVED_MESSAGE, projectCredentialSnapshotFields, resolveConfiguredFromRequiredCredentialStatuses, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackReplyToMode, isSlackInteractiveRepliesEnabled, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, buildSlackThreadingToolContext, slackOnboardingAdapter, SlackConfigSchema, } from "openclaw/plugin-sdk/slack";
+import { resolveOutboundSendDep } from "../../../src/infra/outbound/send-deps.js";
+import { buildPassiveProbedChannelStatusSummary } from "../../shared/channel-status-summary.js";
+import { getSlackRuntime } from "./runtime.js";
+const meta = getChatChannelMeta("slack");
+// Select the appropriate Slack token for read/write operations.
+function getTokenForOperation(account, operation) {
+    const userToken = account.config.userToken?.trim() || undefined;
+    const botToken = account.botToken?.trim();
+    const allowUserWrites = account.config.userTokenReadOnly === false;
+    if (operation === "read") {
+        return userToken ?? botToken;
+    }
+    if (!allowUserWrites) {
+        return botToken;
+    }
+    return botToken ?? userToken;
+}
+function isSlackAccountConfigured(account) {
+    const mode = account.config.mode ?? "socket";
+    const hasBotToken = Boolean(account.botToken?.trim());
+    if (!hasBotToken) {
+        return false;
+    }
+    if (mode === "http") {
+        return Boolean(account.config.signingSecret?.trim());
+    }
+    return Boolean(account.appToken?.trim());
+}
+function resolveSlackSendContext(params) {
+    const send = resolveOutboundSendDep(params.deps, "slack") ??
+        getSlackRuntime().channel.slack.sendMessageSlack;
+    const account = resolveSlackAccount({ cfg: params.cfg, accountId: params.accountId });
+    const token = getTokenForOperation(account, "write");
+    const botToken = account.botToken?.trim();
+    const tokenOverride = token && token !== botToken ? token : undefined;
+    const threadTsValue = params.replyToId ?? params.threadId;
+    return { send, threadTsValue, tokenOverride };
+}
+const slackConfigAccessors = createScopedAccountConfigAccessors({
+    resolveAccount: ({ cfg, accountId }) => resolveSlackAccount({ cfg, accountId }),
+    resolveAllowFrom: (account) => account.dm?.allowFrom,
+    formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
+    resolveDefaultTo: (account) => account.config.defaultTo,
+});
+const slackConfigBase = createScopedChannelConfigBase({
+    sectionKey: "slack",
+    listAccountIds: listSlackAccountIds,
+    resolveAccount: (cfg, accountId) => resolveSlackAccount({ cfg, accountId }),
+    inspectAccount: (cfg, accountId) => inspectSlackAccount({ cfg, accountId }),
+    defaultAccountId: resolveDefaultSlackAccountId,
+    clearBaseFields: ["botToken", "appToken", "name"],
+});
+export const slackPlugin = {
+    id: "slack",
+    meta: {
+        ...meta,
+        preferSessionLookupForAnnounceTarget: true,
+    },
+    onboarding: slackOnboardingAdapter,
+    pairing: {
+        idLabel: "slackUserId",
+        normalizeAllowEntry: (entry) => entry.replace(/^(slack|user):/i, ""),
+        notifyApproval: async ({ id }) => {
+            const cfg = getSlackRuntime().config.loadConfig();
+            const account = resolveSlackAccount({
+                cfg,
+                accountId: DEFAULT_ACCOUNT_ID,
+            });
+            const token = getTokenForOperation(account, "write");
+            const botToken = account.botToken?.trim();
+            const tokenOverride = token && token !== botToken ? token : undefined;
+            if (tokenOverride) {
+                await getSlackRuntime().channel.slack.sendMessageSlack(`user:${id}`, PAIRING_APPROVED_MESSAGE, {
+                    token: tokenOverride,
+                });
+            }
+            else {
+                await getSlackRuntime().channel.slack.sendMessageSlack(`user:${id}`, PAIRING_APPROVED_MESSAGE);
+            }
+        },
+    },
+    capabilities: {
+        chatTypes: ["direct", "channel", "thread"],
+        reactions: true,
+        threads: true,
+        media: true,
+        nativeCommands: true,
+    },
+    agentPrompt: {
+        messageToolHints: ({ cfg, accountId }) => isSlackInteractiveRepliesEnabled({ cfg, accountId })
+            ? [
+                "- Slack interactive replies: use `[[slack_buttons: Label:value, Other:other]]` to add action buttons that route clicks back as Slack interaction system events.",
+                "- Slack selects: use `[[slack_select: Placeholder | Label:value, Other:other]]` to add a static select menu that routes the chosen value back as a Slack interaction system event.",
+            ]
+            : [
+                "- Slack interactive replies are disabled. If needed, ask to set `channels.slack.capabilities.interactiveReplies=true` (or the same under `channels.slack.accounts.<account>.capabilities`).",
+            ],
+    },
+    streaming: {
+        blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
+    },
+    reload: { configPrefixes: ["channels.slack"] },
+    configSchema: buildChannelConfigSchema(SlackConfigSchema),
+    config: {
+        ...slackConfigBase,
+        isConfigured: (account) => isSlackAccountConfigured(account),
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: isSlackAccountConfigured(account),
+            botTokenSource: account.botTokenSource,
+            appTokenSource: account.appTokenSource,
+        }),
+        ...slackConfigAccessors,
+    },
+    security: {
+        resolveDmPolicy: ({ cfg, accountId, account }) => {
+            return buildAccountScopedDmSecurityPolicy({
+                cfg,
+                channelKey: "slack",
+                accountId,
+                fallbackAccountId: account.accountId ?? DEFAULT_ACCOUNT_ID,
+                policy: account.dm?.policy,
+                allowFrom: account.dm?.allowFrom ?? [],
+                allowFromPathSuffix: "dm.",
+                normalizeEntry: (raw) => raw.replace(/^(slack|user):/i, ""),
+            });
+        },
+        collectWarnings: ({ account, cfg }) => {
+            const channelAllowlistConfigured = Boolean(account.config.channels) && Object.keys(account.config.channels ?? {}).length > 0;
+            return collectOpenProviderGroupPolicyWarnings({
+                cfg,
+                providerConfigPresent: cfg.channels?.slack !== undefined,
+                configuredGroupPolicy: account.config.groupPolicy,
+                collect: (groupPolicy) => collectOpenGroupPolicyConfiguredRouteWarnings({
+                    groupPolicy,
+                    routeAllowlistConfigured: channelAllowlistConfigured,
+                    configureRouteAllowlist: {
+                        surface: "Slack channels",
+                        openScope: "any channel not explicitly denied",
+                        groupPolicyPath: "channels.slack.groupPolicy",
+                        routeAllowlistPath: "channels.slack.channels",
+                    },
+                    missingRouteAllowlist: {
+                        surface: "Slack channels",
+                        openBehavior: "with no channel allowlist; any channel can trigger (mention-gated)",
+                        remediation: 'Set channels.slack.groupPolicy="allowlist" and configure channels.slack.channels',
+                    },
+                }),
+            });
+        },
+    },
+    groups: {
+        resolveRequireMention: resolveSlackGroupRequireMention,
+        resolveToolPolicy: resolveSlackGroupToolPolicy,
+    },
+    threading: {
+        resolveReplyToMode: ({ cfg, accountId, chatType }) => resolveSlackReplyToMode(resolveSlackAccount({ cfg, accountId }), chatType),
+        allowExplicitReplyTagsWhenOff: false,
+        buildToolContext: (params) => buildSlackThreadingToolContext(params),
+    },
+    messaging: {
+        normalizeTarget: normalizeSlackMessagingTarget,
+        targetResolver: {
+            looksLikeId: looksLikeSlackTargetId,
+            hint: "<channelId|user:ID|channel:ID>",
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async (params) => listSlackDirectoryPeersFromConfig(params),
+        listGroups: async (params) => listSlackDirectoryGroupsFromConfig(params),
+        listPeersLive: async (params) => getSlackRuntime().channel.slack.listDirectoryPeersLive(params),
+        listGroupsLive: async (params) => getSlackRuntime().channel.slack.listDirectoryGroupsLive(params),
+    },
+    resolver: {
+        resolveTargets: async ({ cfg, accountId, inputs, kind }) => {
+            const toResolvedTarget = (entry, note) => ({
+                input: entry.input,
+                resolved: entry.resolved,
+                id: entry.id,
+                name: entry.name,
+                note,
+            });
+            const account = resolveSlackAccount({ cfg, accountId });
+            const token = account.config.userToken?.trim() || account.botToken?.trim();
+            if (!token) {
+                return inputs.map((input) => ({
+                    input,
+                    resolved: false,
+                    note: "missing Slack token",
+                }));
+            }
+            if (kind === "group") {
+                const resolved = await getSlackRuntime().channel.slack.resolveChannelAllowlist({
+                    token,
+                    entries: inputs,
+                });
+                return resolved.map((entry) => toResolvedTarget(entry, entry.archived ? "archived" : undefined));
+            }
+            const resolved = await getSlackRuntime().channel.slack.resolveUserAllowlist({
+                token,
+                entries: inputs,
+            });
+            return resolved.map((entry) => toResolvedTarget(entry, entry.note));
+        },
+    },
+    actions: {
+        listActions: ({ cfg }) => listSlackMessageActions(cfg),
+        extractToolSend: ({ args }) => extractSlackToolSend(args),
+        handleAction: async (ctx) => await handleSlackMessageAction({
+            providerId: meta.id,
+            ctx,
+            includeReadThreadId: true,
+            invoke: async (action, cfg, toolContext) => await getSlackRuntime().channel.slack.handleSlackAction(action, cfg, toolContext),
+        }),
+    },
+    setup: {
+        resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+        applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+            cfg,
+            channelKey: "slack",
+            accountId,
+            name,
+        }),
+        validateInput: ({ accountId, input }) => {
+            if (input.useEnv && accountId !== DEFAULT_ACCOUNT_ID) {
+                return "Slack env tokens can only be used for the default account.";
+            }
+            if (!input.useEnv && (!input.botToken || !input.appToken)) {
+                return "Slack requires --bot-token and --app-token (or --use-env).";
+            }
+            return null;
+        },
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            const namedConfig = applyAccountNameToChannelSection({
+                cfg,
+                channelKey: "slack",
+                accountId,
+                name: input.name,
+            });
+            const next = accountId !== DEFAULT_ACCOUNT_ID
+                ? migrateBaseNameToDefaultAccount({
+                    cfg: namedConfig,
+                    channelKey: "slack",
+                })
+                : namedConfig;
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                return {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        slack: {
+                            ...next.channels?.slack,
+                            enabled: true,
+                            ...(input.useEnv
+                                ? {}
+                                : {
+                                    ...(input.botToken ? { botToken: input.botToken } : {}),
+                                    ...(input.appToken ? { appToken: input.appToken } : {}),
+                                }),
+                        },
+                    },
+                };
+            }
+            return {
+                ...next,
+                channels: {
+                    ...next.channels,
+                    slack: {
+                        ...next.channels?.slack,
+                        enabled: true,
+                        accounts: {
+                            ...next.channels?.slack?.accounts,
+                            [accountId]: {
+                                ...next.channels?.slack?.accounts?.[accountId],
+                                enabled: true,
+                                ...(input.botToken ? { botToken: input.botToken } : {}),
+                                ...(input.appToken ? { appToken: input.appToken } : {}),
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: null,
+        textChunkLimit: 4000,
+        sendText: async ({ to, text, accountId, deps, replyToId, threadId, cfg }) => {
+            const { send, threadTsValue, tokenOverride } = resolveSlackSendContext({
+                cfg,
+                accountId: accountId ?? undefined,
+                deps,
+                replyToId,
+                threadId,
+            });
+            const result = await send(to, text, {
+                cfg,
+                threadTs: threadTsValue != null ? String(threadTsValue) : undefined,
+                accountId: accountId ?? undefined,
+                ...(tokenOverride ? { token: tokenOverride } : {}),
+            });
+            return { channel: "slack", ...result };
+        },
+        sendMedia: async ({ to, text, mediaUrl, mediaLocalRoots, accountId, deps, replyToId, threadId, cfg, }) => {
+            const { send, threadTsValue, tokenOverride } = resolveSlackSendContext({
+                cfg,
+                accountId: accountId ?? undefined,
+                deps,
+                replyToId,
+                threadId,
+            });
+            const result = await send(to, text, {
+                cfg,
+                mediaUrl,
+                mediaLocalRoots,
+                threadTs: threadTsValue != null ? String(threadTsValue) : undefined,
+                accountId: accountId ?? undefined,
+                ...(tokenOverride ? { token: tokenOverride } : {}),
+            });
+            return { channel: "slack", ...result };
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
+            botTokenSource: snapshot.botTokenSource ?? "none",
+            appTokenSource: snapshot.appTokenSource ?? "none",
+        }),
+        probeAccount: async ({ account, timeoutMs }) => {
+            const token = account.botToken?.trim();
+            if (!token) {
+                return { ok: false, error: "missing token" };
+            }
+            return await getSlackRuntime().channel.slack.probeSlack(token, timeoutMs);
+        },
+        buildAccountSnapshot: ({ account, runtime, probe }) => {
+            const mode = account.config.mode ?? "socket";
+            const configured = (mode === "http"
+                ? resolveConfiguredFromRequiredCredentialStatuses(account, [
+                    "botTokenStatus",
+                    "signingSecretStatus",
+                ])
+                : resolveConfiguredFromRequiredCredentialStatuses(account, [
+                    "botTokenStatus",
+                    "appTokenStatus",
+                ])) ?? isSlackAccountConfigured(account);
+            const base = buildComputedAccountStatusSnapshot({
+                accountId: account.accountId,
+                name: account.name,
+                enabled: account.enabled,
+                configured,
+                runtime,
+                probe,
+            });
+            return {
+                ...base,
+                ...projectCredentialSnapshotFields(account),
+            };
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            const botToken = account.botToken?.trim();
+            const appToken = account.appToken?.trim();
+            ctx.log?.info(`[${account.accountId}] starting provider`);
+            return getSlackRuntime().channel.slack.monitorSlackProvider({
+                botToken: botToken ?? "",
+                appToken: appToken ?? "",
+                accountId: account.accountId,
+                config: ctx.cfg,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+                mediaMaxMb: account.config.mediaMaxMb,
+                slashCommand: account.config.slashCommand,
+                setStatus: ctx.setStatus,
+                getStatus: ctx.getStatus,
+            });
+        },
+    },
+};

package/dist/slack/interactive-replies.js

@@ -0,0 +1,28 @@
+import { listSlackAccountIds, resolveSlackAccount } from "./accounts.js";
+function resolveInteractiveRepliesFromCapabilities(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    if (Array.isArray(capabilities)) {
+        return capabilities.some((entry) => String(entry).trim().toLowerCase() === "interactivereplies");
+    }
+    if (typeof capabilities === "object") {
+        return capabilities.interactiveReplies === true;
+    }
+    return false;
+}
+export function isSlackInteractiveRepliesEnabled(params) {
+    if (params.accountId) {
+        const account = resolveSlackAccount({ cfg: params.cfg, accountId: params.accountId });
+        return resolveInteractiveRepliesFromCapabilities(account.config.capabilities);
+    }
+    const accountIds = listSlackAccountIds(params.cfg);
+    if (accountIds.length === 0) {
+        return resolveInteractiveRepliesFromCapabilities(params.cfg.channels?.slack?.capabilities);
+    }
+    if (accountIds.length > 1) {
+        return false;
+    }
+    const account = resolveSlackAccount({ cfg: params.cfg, accountId: accountIds[0] });
+    return resolveInteractiveRepliesFromCapabilities(account.config.capabilities);
+}