@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/slack/monitor/channel-type.js

@@ -0,0 +1,31 @@
+export function inferSlackChannelType(channelId) {
+    const trimmed = channelId?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed.startsWith("D")) {
+        return "im";
+    }
+    if (trimmed.startsWith("C")) {
+        return "channel";
+    }
+    if (trimmed.startsWith("G")) {
+        return "group";
+    }
+    return undefined;
+}
+export function normalizeSlackChannelType(channelType, channelId) {
+    const normalized = channelType?.trim().toLowerCase();
+    const inferred = inferSlackChannelType(channelId);
+    if (normalized === "im" ||
+        normalized === "mpim" ||
+        normalized === "channel" ||
+        normalized === "group") {
+        // D-prefix channel IDs are always DMs — override a contradicting channel_type.
+        if (inferred === "im" && normalized !== "im") {
+            return "im";
+        }
+        return normalized;
+    }
+    return inferred ?? "channel";
+}

package/dist/slack/monitor/dm-auth.js

@@ -0,0 +1,49 @@
+import { formatAllowlistMatchMeta } from "../../../../src/channels/allowlist-match.js";
+import { issuePairingChallenge } from "../../../../src/pairing/pairing-challenge.js";
+import { upsertChannelPairingRequest } from "../../../../src/pairing/pairing-store.js";
+import { resolveSlackAllowListMatch } from "./allow-list.js";
+export async function authorizeSlackDirectMessage(params) {
+    if (!params.ctx.dmEnabled || params.ctx.dmPolicy === "disabled") {
+        await params.onDisabled();
+        return false;
+    }
+    if (params.ctx.dmPolicy === "open") {
+        return true;
+    }
+    const sender = await params.resolveSenderName(params.senderId);
+    const senderName = sender?.name ?? undefined;
+    const allowMatch = resolveSlackAllowListMatch({
+        allowList: params.allowFromLower,
+        id: params.senderId,
+        name: senderName,
+        allowNameMatching: params.ctx.allowNameMatching,
+    });
+    const allowMatchMeta = formatAllowlistMatchMeta(allowMatch);
+    if (allowMatch.allowed) {
+        return true;
+    }
+    if (params.ctx.dmPolicy === "pairing") {
+        await issuePairingChallenge({
+            channel: "slack",
+            senderId: params.senderId,
+            senderIdLine: `Your Slack user id: ${params.senderId}`,
+            meta: { name: senderName },
+            upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
+                channel: "slack",
+                id,
+                accountId: params.accountId,
+                meta,
+            }),
+            sendPairingReply: params.sendPairingReply,
+            onCreated: () => {
+                params.log(`slack pairing request sender=${params.senderId} name=${senderName ?? "unknown"} (${allowMatchMeta})`);
+            },
+            onReplyError: (err) => {
+                params.log(`slack pairing reply failed for ${params.senderId}: ${String(err)}`);
+            },
+        });
+        return false;
+    }
+    await params.onUnauthorized({ allowMatchMeta, senderName });
+    return false;
+}

package/dist/slack/monitor/events/interactions.modal.js

@@ -0,0 +1,137 @@
+import { enqueueSystemEvent } from "../../../../../src/infra/system-events.js";
+import { parseSlackModalPrivateMetadata } from "../../modal-metadata.js";
+import { authorizeSlackSystemEventSender } from "../auth.js";
+function resolveModalSessionRouting(params) {
+    const metadata = params.metadata;
+    if (metadata.sessionKey) {
+        return {
+            sessionKey: metadata.sessionKey,
+            channelId: metadata.channelId,
+            channelType: metadata.channelType,
+        };
+    }
+    if (metadata.channelId) {
+        return {
+            sessionKey: params.ctx.resolveSlackSystemEventSessionKey({
+                channelId: metadata.channelId,
+                channelType: metadata.channelType,
+                senderId: params.userId,
+            }),
+            channelId: metadata.channelId,
+            channelType: metadata.channelType,
+        };
+    }
+    return {
+        sessionKey: params.ctx.resolveSlackSystemEventSessionKey({}),
+    };
+}
+function summarizeSlackViewLifecycleContext(view) {
+    const rootViewId = view.root_view_id;
+    const previousViewId = view.previous_view_id;
+    const externalId = view.external_id;
+    const viewHash = view.hash;
+    return {
+        rootViewId,
+        previousViewId,
+        externalId,
+        viewHash,
+        isStackedView: Boolean(previousViewId),
+    };
+}
+function resolveSlackModalEventBase(params) {
+    const metadata = parseSlackModalPrivateMetadata(params.body.view?.private_metadata);
+    const callbackId = params.body.view?.callback_id ?? "unknown";
+    const userId = params.body.user?.id ?? "unknown";
+    const viewId = params.body.view?.id;
+    const inputs = params.summarizeViewState(params.body.view?.state?.values);
+    const sessionRouting = resolveModalSessionRouting({
+        ctx: params.ctx,
+        metadata,
+        userId,
+    });
+    return {
+        callbackId,
+        userId,
+        expectedUserId: metadata.userId,
+        viewId,
+        sessionRouting,
+        payload: {
+            actionId: `view:${callbackId}`,
+            callbackId,
+            viewId,
+            userId,
+            teamId: params.body.team?.id,
+            ...summarizeSlackViewLifecycleContext({
+                root_view_id: params.body.view?.root_view_id,
+                previous_view_id: params.body.view?.previous_view_id,
+                external_id: params.body.view?.external_id,
+                hash: params.body.view?.hash,
+            }),
+            privateMetadata: params.body.view?.private_metadata,
+            routedChannelId: sessionRouting.channelId,
+            routedChannelType: sessionRouting.channelType,
+            inputs,
+        },
+    };
+}
+export async function emitSlackModalLifecycleEvent(params) {
+    const { callbackId, userId, expectedUserId, viewId, sessionRouting, payload } = resolveSlackModalEventBase({
+        ctx: params.ctx,
+        body: params.body,
+        summarizeViewState: params.summarizeViewState,
+    });
+    const isViewClosed = params.interactionType === "view_closed";
+    const isCleared = params.body.is_cleared === true;
+    const eventPayload = isViewClosed
+        ? {
+            interactionType: params.interactionType,
+            ...payload,
+            isCleared,
+        }
+        : {
+            interactionType: params.interactionType,
+            ...payload,
+        };
+    if (isViewClosed) {
+        params.ctx.runtime.log?.(`slack:interaction view_closed callback=${callbackId} user=${userId} cleared=${isCleared}`);
+    }
+    else {
+        params.ctx.runtime.log?.(`slack:interaction view_submission callback=${callbackId} user=${userId} inputs=${payload.inputs.length}`);
+    }
+    if (!expectedUserId) {
+        params.ctx.runtime.log?.(`slack:interaction drop modal callback=${callbackId} user=${userId} reason=missing-expected-user`);
+        return;
+    }
+    const auth = await authorizeSlackSystemEventSender({
+        ctx: params.ctx,
+        senderId: userId,
+        channelId: sessionRouting.channelId,
+        channelType: sessionRouting.channelType,
+        expectedSenderId: expectedUserId,
+    });
+    if (!auth.allowed) {
+        params.ctx.runtime.log?.(`slack:interaction drop modal callback=${callbackId} user=${userId} reason=${auth.reason ?? "unauthorized"}`);
+        return;
+    }
+    enqueueSystemEvent(params.formatSystemEvent(eventPayload), {
+        sessionKey: sessionRouting.sessionKey,
+        contextKey: [params.contextPrefix, callbackId, viewId, userId].filter(Boolean).join(":"),
+    });
+}
+export function registerModalLifecycleHandler(params) {
+    params.register(params.matcher, async ({ ack, body }) => {
+        await ack();
+        if (params.ctx.shouldDropMismatchedSlackEvent?.(body)) {
+            params.ctx.runtime.log?.(`slack:interaction drop ${params.interactionType} payload (mismatched app/team)`);
+            return;
+        }
+        await emitSlackModalLifecycleEvent({
+            ctx: params.ctx,
+            body: body,
+            interactionType: params.interactionType,
+            contextPrefix: params.contextPrefix,
+            summarizeViewState: params.summarizeViewState,
+            formatSystemEvent: params.formatSystemEvent,
+        });
+    });
+}

package/dist/slack/monitor/events/message-subtype-handlers.js

@@ -0,0 +1,68 @@
+const changedHandler = {
+    subtype: "message_changed",
+    eventKind: "message_changed",
+    describe: (channelLabel) => `Slack message edited in ${channelLabel}.`,
+    contextKey: (event) => {
+        const changed = event;
+        const channelId = changed.channel ?? "unknown";
+        const messageId = changed.message?.ts ?? changed.previous_message?.ts ?? changed.event_ts ?? "unknown";
+        return `slack:message:changed:${channelId}:${messageId}`;
+    },
+    resolveSenderId: (event) => {
+        const changed = event;
+        return (changed.message?.user ??
+            changed.previous_message?.user ??
+            changed.message?.bot_id ??
+            changed.previous_message?.bot_id);
+    },
+    resolveChannelId: (event) => event.channel,
+    resolveChannelType: () => undefined,
+};
+const deletedHandler = {
+    subtype: "message_deleted",
+    eventKind: "message_deleted",
+    describe: (channelLabel) => `Slack message deleted in ${channelLabel}.`,
+    contextKey: (event) => {
+        const deleted = event;
+        const channelId = deleted.channel ?? "unknown";
+        const messageId = deleted.deleted_ts ?? deleted.event_ts ?? "unknown";
+        return `slack:message:deleted:${channelId}:${messageId}`;
+    },
+    resolveSenderId: (event) => {
+        const deleted = event;
+        return deleted.previous_message?.user ?? deleted.previous_message?.bot_id;
+    },
+    resolveChannelId: (event) => event.channel,
+    resolveChannelType: () => undefined,
+};
+const threadBroadcastHandler = {
+    subtype: "thread_broadcast",
+    eventKind: "thread_broadcast",
+    describe: (channelLabel) => `Slack thread reply broadcast in ${channelLabel}.`,
+    contextKey: (event) => {
+        const thread = event;
+        const channelId = thread.channel ?? "unknown";
+        const messageId = thread.message?.ts ?? thread.event_ts ?? "unknown";
+        return `slack:thread:broadcast:${channelId}:${messageId}`;
+    },
+    resolveSenderId: (event) => {
+        const thread = event;
+        return thread.user ?? thread.message?.user ?? thread.message?.bot_id;
+    },
+    resolveChannelId: (event) => event.channel,
+    resolveChannelType: () => undefined,
+};
+const SUBTYPE_HANDLER_REGISTRY = {
+    message_changed: changedHandler,
+    message_deleted: deletedHandler,
+    thread_broadcast: threadBroadcastHandler,
+};
+export function resolveSlackMessageSubtypeHandler(event) {
+    const subtype = event.subtype;
+    if (subtype !== "message_changed" &&
+        subtype !== "message_deleted" &&
+        subtype !== "thread_broadcast") {
+        return undefined;
+    }
+    return SUBTYPE_HANDLER_REGISTRY[subtype];
+}

package/dist/slack/monitor/events/system-event-context.js

@@ -0,0 +1,29 @@
+import { logVerbose } from "../../../../../src/globals.js";
+import { authorizeSlackSystemEventSender } from "../auth.js";
+import { resolveSlackChannelLabel } from "../channel-config.js";
+export async function authorizeAndResolveSlackSystemEventContext(params) {
+    const { ctx, senderId, channelId, channelType, eventKind } = params;
+    const auth = await authorizeSlackSystemEventSender({
+        ctx,
+        senderId,
+        channelId,
+        channelType,
+    });
+    if (!auth.allowed) {
+        logVerbose(`slack: drop ${eventKind} sender ${senderId ?? "unknown"} channel=${channelId ?? "unknown"} reason=${auth.reason ?? "unauthorized"}`);
+        return undefined;
+    }
+    const channelLabel = resolveSlackChannelLabel({
+        channelId,
+        channelName: auth.channelName,
+    });
+    const sessionKey = ctx.resolveSlackSystemEventSessionKey({
+        channelId,
+        channelType: auth.channelType,
+        senderId,
+    });
+    return {
+        channelLabel,
+        sessionKey,
+    };
+}

package/dist/slack/monitor/events/system-event-test-harness.js

@@ -0,0 +1,41 @@
+export function createSlackSystemEventTestHarness(overrides) {
+    const handlers = {};
+    const channelType = overrides?.channelType ?? "im";
+    const app = {
+        event: (name, handler) => {
+            handlers[name] = handler;
+        },
+    };
+    const ctx = {
+        app,
+        runtime: { error: () => { } },
+        dmEnabled: true,
+        dmPolicy: overrides?.dmPolicy ?? "open",
+        defaultRequireMention: true,
+        channelsConfig: overrides?.channelUsers
+            ? {
+                C1: {
+                    users: overrides.channelUsers,
+                    allow: true,
+                },
+            }
+            : undefined,
+        groupPolicy: "open",
+        allowFrom: overrides?.allowFrom ?? [],
+        allowNameMatching: false,
+        shouldDropMismatchedSlackEvent: () => false,
+        isChannelAllowed: () => true,
+        resolveChannelName: async () => ({
+            name: channelType === "im" ? "direct" : "general",
+            type: channelType,
+        }),
+        resolveUserName: async () => ({ name: "alice" }),
+        resolveSlackSystemEventSessionKey: () => "agent:main:main",
+    };
+    return {
+        ctx,
+        getHandler(name) {
+            return handlers[name] ?? null;
+        },
+    };
+}

package/dist/slack/monitor/external-arg-menu-store.js

@@ -0,0 +1,46 @@
+import { generateSecureToken } from "../../../../src/infra/secure-random.js";
+const SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES = 18;
+const SLACK_EXTERNAL_ARG_MENU_TOKEN_LENGTH = Math.ceil((SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES * 8) / 6);
+const SLACK_EXTERNAL_ARG_MENU_TOKEN_PATTERN = new RegExp(`^[A-Za-z0-9_-]{${SLACK_EXTERNAL_ARG_MENU_TOKEN_LENGTH}}$`);
+const SLACK_EXTERNAL_ARG_MENU_TTL_MS = 10 * 60 * 1000;
+export const SLACK_EXTERNAL_ARG_MENU_PREFIX = "openclaw_cmdarg_ext:";
+function pruneSlackExternalArgMenuStore(store, now) {
+    for (const [token, entry] of store.entries()) {
+        if (entry.expiresAt <= now) {
+            store.delete(token);
+        }
+    }
+}
+function createSlackExternalArgMenuToken(store) {
+    let token = "";
+    do {
+        token = generateSecureToken(SLACK_EXTERNAL_ARG_MENU_TOKEN_BYTES);
+    } while (store.has(token));
+    return token;
+}
+export function createSlackExternalArgMenuStore() {
+    const store = new Map();
+    return {
+        create(params, now = Date.now()) {
+            pruneSlackExternalArgMenuStore(store, now);
+            const token = createSlackExternalArgMenuToken(store);
+            store.set(token, {
+                choices: params.choices,
+                userId: params.userId,
+                expiresAt: now + SLACK_EXTERNAL_ARG_MENU_TTL_MS,
+            });
+            return token;
+        },
+        readToken(raw) {
+            if (typeof raw !== "string" || !raw.startsWith(SLACK_EXTERNAL_ARG_MENU_PREFIX)) {
+                return undefined;
+            }
+            const token = raw.slice(SLACK_EXTERNAL_ARG_MENU_PREFIX.length).trim();
+            return SLACK_EXTERNAL_ARG_MENU_TOKEN_PATTERN.test(token) ? token : undefined;
+        },
+        get(token, now = Date.now()) {
+            pruneSlackExternalArgMenuStore(store, now);
+            return store.get(token);
+        },
+    };
+}

package/dist/slack/monitor/message-handler/prepare-content.js

@@ -0,0 +1,69 @@
+import { logVerbose } from "../../../../../src/globals.js";
+import { MAX_SLACK_MEDIA_FILES, resolveSlackAttachmentContent, resolveSlackMedia, } from "../media.js";
+function filterInheritedParentFiles(params) {
+    const { files, isThreadReply, threadStarter } = params;
+    if (!isThreadReply || !files?.length) {
+        return files;
+    }
+    if (!threadStarter?.files?.length) {
+        return files;
+    }
+    const starterFileIds = new Set(threadStarter.files.map((file) => file.id));
+    const filtered = files.filter((file) => !file.id || !starterFileIds.has(file.id));
+    if (filtered.length < files.length) {
+        logVerbose(`slack: filtered ${files.length - filtered.length} inherited parent file(s) from thread reply`);
+    }
+    return filtered.length > 0 ? filtered : undefined;
+}
+export async function resolveSlackMessageContent(params) {
+    const ownFiles = filterInheritedParentFiles({
+        files: params.message.files,
+        isThreadReply: params.isThreadReply,
+        threadStarter: params.threadStarter,
+    });
+    const media = await resolveSlackMedia({
+        files: ownFiles,
+        token: params.botToken,
+        maxBytes: params.mediaMaxBytes,
+    });
+    const attachmentContent = await resolveSlackAttachmentContent({
+        attachments: params.message.attachments,
+        token: params.botToken,
+        maxBytes: params.mediaMaxBytes,
+    });
+    const mergedMedia = [...(media ?? []), ...(attachmentContent?.media ?? [])];
+    const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
+    const mediaPlaceholder = effectiveDirectMedia
+        ? effectiveDirectMedia.map((item) => item.placeholder).join(" ")
+        : undefined;
+    const fallbackFiles = ownFiles ?? [];
+    const fileOnlyFallback = !mediaPlaceholder && fallbackFiles.length > 0
+        ? fallbackFiles
+            .slice(0, MAX_SLACK_MEDIA_FILES)
+            .map((file) => file.name?.trim() || "file")
+            .join(", ")
+        : undefined;
+    const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : undefined;
+    const botAttachmentText = params.isBotMessage && !attachmentContent?.text
+        ? (params.message.attachments ?? [])
+            .map((attachment) => attachment.text?.trim() || attachment.fallback?.trim())
+            .filter(Boolean)
+            .join("\n")
+        : undefined;
+    const rawBody = [
+        (params.message.text ?? "").trim(),
+        attachmentContent?.text,
+        botAttachmentText,
+        mediaPlaceholder,
+        fileOnlyPlaceholder,
+    ]
+        .filter(Boolean)
+        .join("\n") || "";
+    if (!rawBody) {
+        return null;
+    }
+    return {
+        rawBody,
+        effectiveDirectMedia,
+    };
+}

package/dist/slack/monitor/message-handler/prepare-thread-context.js

@@ -0,0 +1,91 @@
+import { formatInboundEnvelope } from "../../../../../src/auto-reply/envelope.js";
+import { readSessionUpdatedAt } from "../../../../../src/config/sessions.js";
+import { logVerbose } from "../../../../../src/globals.js";
+import { resolveSlackMedia, resolveSlackThreadHistory, } from "../media.js";
+export async function resolveSlackThreadContextData(params) {
+    let threadStarterBody;
+    let threadHistoryBody;
+    let threadSessionPreviousTimestamp;
+    let threadLabel;
+    let threadStarterMedia = null;
+    if (!params.isThreadReply || !params.threadTs) {
+        return {
+            threadStarterBody,
+            threadHistoryBody,
+            threadSessionPreviousTimestamp,
+            threadLabel,
+            threadStarterMedia,
+        };
+    }
+    const starter = params.threadStarter;
+    if (starter?.text) {
+        threadStarterBody = starter.text;
+        const snippet = starter.text.replace(/\s+/g, " ").slice(0, 80);
+        threadLabel = `Slack thread ${params.roomLabel}${snippet ? `: ${snippet}` : ""}`;
+        if (!params.effectiveDirectMedia && starter.files && starter.files.length > 0) {
+            threadStarterMedia = await resolveSlackMedia({
+                files: starter.files,
+                token: params.ctx.botToken,
+                maxBytes: params.ctx.mediaMaxBytes,
+            });
+            if (threadStarterMedia) {
+                const starterPlaceholders = threadStarterMedia.map((item) => item.placeholder).join(", ");
+                logVerbose(`slack: hydrated thread starter file ${starterPlaceholders} from root message`);
+            }
+        }
+    }
+    else {
+        threadLabel = `Slack thread ${params.roomLabel}`;
+    }
+    const threadInitialHistoryLimit = params.account.config?.thread?.initialHistoryLimit ?? 20;
+    threadSessionPreviousTimestamp = readSessionUpdatedAt({
+        storePath: params.storePath,
+        sessionKey: params.sessionKey,
+    });
+    if (threadInitialHistoryLimit > 0 && !threadSessionPreviousTimestamp) {
+        const threadHistory = await resolveSlackThreadHistory({
+            channelId: params.message.channel,
+            threadTs: params.threadTs,
+            client: params.ctx.app.client,
+            currentMessageTs: params.message.ts,
+            limit: threadInitialHistoryLimit,
+        });
+        if (threadHistory.length > 0) {
+            const uniqueUserIds = [
+                ...new Set(threadHistory.map((item) => item.userId).filter((id) => Boolean(id))),
+            ];
+            const userMap = new Map();
+            await Promise.all(uniqueUserIds.map(async (id) => {
+                const user = await params.ctx.resolveUserName(id);
+                if (user) {
+                    userMap.set(id, user);
+                }
+            }));
+            const historyParts = [];
+            for (const historyMsg of threadHistory) {
+                const msgUser = historyMsg.userId ? userMap.get(historyMsg.userId) : null;
+                const msgSenderName = msgUser?.name ?? (historyMsg.botId ? `Bot (${historyMsg.botId})` : "Unknown");
+                const isBot = Boolean(historyMsg.botId);
+                const role = isBot ? "assistant" : "user";
+                const msgWithId = `${historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
+                historyParts.push(formatInboundEnvelope({
+                    channel: "Slack",
+                    from: `${msgSenderName} (${role})`,
+                    timestamp: historyMsg.ts ? Math.round(Number(historyMsg.ts) * 1000) : undefined,
+                    body: msgWithId,
+                    chatType: "channel",
+                    envelope: params.envelopeOptions,
+                }));
+            }
+            threadHistoryBody = historyParts.join("\n\n");
+            logVerbose(`slack: populated thread history with ${threadHistory.length} messages for new session`);
+        }
+    }
+    return {
+        threadStarterBody,
+        threadHistoryBody,
+        threadSessionPreviousTimestamp,
+        threadLabel,
+        threadStarterMedia,
+    };
+}

package/dist/slack/monitor/message-handler/prepare.test-helpers.js

@@ -0,0 +1,55 @@
+import { createSlackMonitorContext } from "../context.js";
+export function createInboundSlackTestContext(params) {
+    return createSlackMonitorContext({
+        cfg: params.cfg,
+        accountId: "default",
+        botToken: "token",
+        app: { client: params.appClient ?? {} },
+        runtime: {},
+        botUserId: "B1",
+        teamId: "T1",
+        apiAppId: "A1",
+        historyLimit: 0,
+        sessionScope: "per-sender",
+        mainKey: "main",
+        dmEnabled: true,
+        dmPolicy: "open",
+        allowFrom: [],
+        allowNameMatching: false,
+        groupDmEnabled: true,
+        groupDmChannels: [],
+        defaultRequireMention: params.defaultRequireMention ?? true,
+        channelsConfig: params.channelsConfig,
+        groupPolicy: "open",
+        useAccessGroups: false,
+        reactionMode: "off",
+        reactionAllowlist: [],
+        replyToMode: params.replyToMode ?? "off",
+        threadHistoryScope: "thread",
+        threadInheritParent: false,
+        slashCommand: {
+            enabled: false,
+            name: "openclaw",
+            sessionPrefix: "slack:slash",
+            ephemeral: true,
+        },
+        textLimit: 4000,
+        ackReactionScope: "group-mentions",
+        typingReaction: "",
+        mediaMaxBytes: 1024,
+        removeAckAfterReply: false,
+    });
+}
+export function createSlackTestAccount(config = {}) {
+    return {
+        accountId: "default",
+        enabled: true,
+        botTokenSource: "config",
+        appTokenSource: "config",
+        userTokenSource: "none",
+        config,
+        replyToMode: config.replyToMode,
+        replyToModeByChatType: config.replyToModeByChatType,
+        dm: config.dm,
+    };
+}