@sena-ai/connector-slack 1.4.0 → 1.4.2

package/dist/connector.js

@@ -2,108 +2,269 @@ import { WebClient } from '@slack/web-api';
 import { SocketModeClient } from '@slack/socket-mode';
 import { verifySignature } from './verify.js';
 import { markdownToSlack } from './mrkdwn.js';
-import { writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
-export function slackConnector(options) {
-    const { appId, botToken, thinkingMessage } = options;
-    const slack = new WebClient(botToken);
-    const userNameCache = new Map();
-    // Track threads the bot has participated in (channel:thread_ts → true)
-    const activeThreads = new Set();
-    // Deduplicate events — Slack sends both app_mention and message for the same @mention.
-    // Two-phase: processingEvents tracks in-flight events (before we know if they'll be handled),
-    // processedEvents tracks events that were actually processed to completion.
-    const processedEvents = new Set();
-    const processingEvents = new Set();
-    // Resolved bot user ID (lazy, set on first event)
-    let botUserId;
-    // Socket Mode client reference for stop() lifecycle
-    let socketClient;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function readRecord(record, key) {
+    const value = record[key];
+    return isRecord(value) ? value : undefined;
+}
+function readFileList(record, key) {
+    const value = record[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!isRecord(item))
+            return [];
+        const id = readString(item, 'id');
+        const name = readString(item, 'name');
+        const mimetype = readString(item, 'mimetype');
+        if (!id || !name || !mimetype)
+            return [];
+        return [{
+                id,
+                name,
+                mimetype,
+                url_private: readString(item, 'url_private'),
+            }];
+    });
+}
+function toAttachmentMetadata(files) {
+    if (files.length === 0)
+        return undefined;
+    return files.map((file) => ({
+        id: file.id,
+        name: file.name,
+        mimeType: file.mimetype,
+    }));
+}
+function isFunction(value) {
+    return typeof value === 'function';
+}
+function isPromptRule(value) {
+    if (!isRecord(value))
+        return false;
+    const hasText = typeof value.text === 'string';
+    const hasFile = typeof value.file === 'string';
+    if (hasText === hasFile)
+        return false;
+    return value.filter === undefined || isFunction(value.filter);
+}
+function isReactionActionRule(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.action !== 'abort')
+        return false;
+    return value.filter === undefined || isFunction(value.filter);
+}
+function assertMessagePromptTrigger(value, path) {
+    if (typeof value === 'string' || isPromptRule(value))
+        return;
+    throw new Error(`Invalid Slack trigger config at ${path}`);
+}
+function assertReactionRule(value, path) {
+    if (typeof value === 'string' || isPromptRule(value) || isReactionActionRule(value))
+        return;
+    throw new Error(`Invalid Slack reaction rule at ${path}`);
+}
+export function normalizeTriggerConfig(triggers) {
+    if (triggers === undefined) {
+        return {
+            mention: '',
+            thread: '',
+            reactions: {
+                x: { action: 'abort' },
+            },
+        };
+    }
+    const normalized = {
+        reactions: {},
+    };
+    if (triggers.mention !== undefined) {
+        assertMessagePromptTrigger(triggers.mention, 'triggers.mention');
+        normalized.mention = triggers.mention;
+    }
+    if (triggers.thread !== undefined) {
+        assertMessagePromptTrigger(triggers.thread, 'triggers.thread');
+        normalized.thread = triggers.thread;
+    }
+    if (triggers.channel !== undefined) {
+        assertMessagePromptTrigger(triggers.channel, 'triggers.channel');
+        normalized.channel = triggers.channel;
+    }
+    if (triggers.reactions !== undefined) {
+        for (const [emoji, rule] of Object.entries(triggers.reactions)) {
+            assertReactionRule(rule, `triggers.reactions.${emoji}`);
+            normalized.reactions[emoji] = rule;
+        }
+    }
+    return normalized;
+}
+function getMessageFilter(source) {
+    if (typeof source === 'string')
+        return undefined;
+    return source.filter;
+}
+function getReactionFilter(rule) {
+    if (typeof rule === 'string')
+        return undefined;
+    if (isReactionActionRule(rule))
+        return rule.filter;
+    return rule.filter;
+}
+function isReactionAbortRule(rule) {
+    return typeof rule !== 'string' && isReactionActionRule(rule);
+}
+export async function resolvePromptSource(source, baseDir) {
+    if (typeof source === 'string')
+        return source;
+    if ('text' in source)
+        return source.text;
+    return readFile(resolve(baseDir, source.file), 'utf8');
+}
+async function runMessageTriggerFilter(source, event) {
+    const filter = getMessageFilter(source);
+    if (!filter)
+        return true;
+    const result = await filter(event);
+    return result !== false;
+}
+async function runReactionTriggerFilter(rule, event) {
+    const filter = getReactionFilter(rule);
+    if (!filter)
+        return true;
+    const result = await filter(event);
+    return result !== false;
+}
+function containsBotMention(text, botUserId) {
+    if (!botUserId)
+        return false;
+    return text.includes(`<@${botUserId}>`);
+}
+function buildConversationId(channel, threadTs, ts) {
+    return `${channel}:${threadTs ?? ts}`;
+}
+function buildMessageInputText(prompt, messageText) {
+    const sections = [prompt.trim(), messageText].filter((part) => part.length > 0);
+    return sections.join('\n\n');
+}
+function buildReactionInputText(prompt, event) {
+    const lines = [
+        `reaction: :${event.reaction}:`,
+        `actorUserId: ${event.userId}`,
+        event.userName ? `actorUserName: ${event.userName}` : '',
+        `channelId: ${event.channelId}`,
+        `threadTs: ${event.threadTs}`,
+        `messageTs: ${event.ts}`,
+        event.messageUserId ? `messageUserId: ${event.messageUserId}` : '',
+        event.messageUserName ? `messageUserName: ${event.messageUserName}` : '',
+        event.messageBotId ? `messageBotId: ${event.messageBotId}` : '',
+        '',
+        'targetMessage:',
+        event.text || '(empty)',
+    ].filter((line) => line.length > 0);
+    const sections = [prompt.trim(), lines.join('\n')].filter((part) => part.length > 0);
+    return sections.join('\n\n');
+}
+function parseMessageEvent(body) {
+    const event = readRecord(body, 'event');
+    if (!event)
+        return null;
+    const type = readString(event, 'type');
+    if (type !== 'app_mention' && type !== 'message')
+        return null;
+    const channel = readString(event, 'channel');
+    const ts = readString(event, 'ts');
+    if (!channel || !ts)
+        return null;
     return {
-        name: 'slack',
-        registerRoutes(server, engine) {
-            // Lazily resolve bot user ID
-            const resolveBotUserId = async () => {
-                if (botUserId)
-                    return;
-                try {
-                    const auth = await slack.auth.test();
-                    botUserId = auth.user_id;
-                    console.log(`[slack] resolved bot user id: ${botUserId}`);
-                }
-                catch (err) {
-                    console.warn('[slack] failed to resolve bot user id:', err);
-                }
-            };
-            const mode = options.mode ?? 'http';
-            if (mode === 'socket') {
-                const { appToken } = options;
-                socketClient = new SocketModeClient({ appToken });
-                // @slack/socket-mode v2 emits events_api messages using the inner event type
-                // name (e.g. 'app_mention', 'message', 'reaction_added'), NOT 'events_api'.
-                const handleSocketEvent = async ({ body, ack }) => {
-                    // Acknowledge immediately (Socket Mode requires ack within 3 s)
-                    await ack();
-                    await resolveBotUserId();
-                    processSlackEvent(body, engine, appId, slack, botToken, userNameCache, activeThreads, processedEvents, processingEvents, botUserId);
-                };
-                socketClient.on('app_mention', handleSocketEvent);
-                socketClient.on('message', handleSocketEvent);
-                socketClient.on('reaction_added', handleSocketEvent);
-                // Start connection (fire-and-forget; logs errors internally)
-                socketClient.start().then(() => {
-                    console.log('[slack] socket mode connected');
-                }).catch((err) => {
-                    console.error('[slack] socket mode connection failed:', err);
-                });
-            }
-            else {
-                // HTTP Events API mode
-                const { signingSecret } = options;
-                server.post('/api/slack/events', async (req, res) => {
-                    await resolveBotUserId();
-                    const body = req.body;
-                    // URL verification challenge
-                    if (body?.type === 'url_verification') {
-                        res.status(200).json({ challenge: body.challenge });
-                        return;
-                    }
-                    // Verify signature
-                    const timestamp = req.headers['x-slack-request-timestamp'];
-                    const signature = req.headers['x-slack-signature'];
-                    const rawBody = req.rawBody ?? JSON.stringify(body);
-                    if (!verifySignature(signingSecret, timestamp, rawBody, signature)) {
-                        console.warn('[slack] signature verification failed');
-                        res.status(401).send('Invalid signature');
-                        return;
-                    }
-                    // Acknowledge immediately (Slack 3s timeout)
-                    res.status(200).send();
-                    processSlackEvent(body, engine, appId, slack, botToken, userNameCache, activeThreads, processedEvents, processingEvents, botUserId);
-                });
-            }
-        },
-        createOutput(context) {
-            // Mark thread as active when the bot creates output (i.e. responds)
-            activeThreads.add(context.conversationId);
-            return createSlackOutput(slack, context, thinkingMessage);
-        },
-        async stop() {
-            if (socketClient) {
-                try {
-                    socketClient.disconnect();
-                    console.log('[slack] socket mode disconnected');
-                }
-                catch (err) {
-                    console.warn('[slack] socket mode disconnect failed:', err);
-                }
-                socketClient = undefined;
-            }
-        },
+        type,
+        channel,
+        ts,
+        userId: readString(event, 'user') ?? '',
+        text: readString(event, 'text') ?? '',
+        threadTs: readString(event, 'thread_ts'),
+        files: readFileList(event, 'files'),
+        subtype: readString(event, 'subtype'),
+        botId: readString(event, 'bot_id'),
+    };
+}
+function parseReactionEvent(body) {
+    const event = readRecord(body, 'event');
+    if (!event)
+        return null;
+    if (readString(event, 'type') !== 'reaction_added')
+        return null;
+    const item = readRecord(event, 'item');
+    if (!item || readString(item, 'type') !== 'message')
+        return null;
+    const channel = readString(item, 'channel');
+    const messageTs = readString(item, 'ts');
+    const reaction = readString(event, 'reaction');
+    const userId = readString(event, 'user');
+    if (!channel || !messageTs || !reaction || !userId)
+        return null;
+    return {
+        type: 'reaction_added',
+        channel,
+        messageTs,
+        reaction,
+        userId,
+        itemUserId: readString(event, 'item_user'),
+        eventTs: readString(event, 'event_ts'),
+    };
+}
+export function selectMessageCandidates(event, triggerConfig, activeThreads, botUserId) {
+    const candidates = [];
+    const threadKey = buildConversationId(event.channel, event.threadTs, event.ts);
+    const mentionActive = triggerConfig.mention !== undefined
+        && (event.type === 'app_mention' || containsBotMention(event.text, botUserId));
+    if (mentionActive && triggerConfig.mention !== undefined) {
+        candidates.push({ kind: 'mention', source: triggerConfig.mention });
+    }
+    const threadActive = triggerConfig.thread !== undefined
+        && event.threadTs !== undefined
+        && activeThreads.has(threadKey);
+    if (threadActive && triggerConfig.thread !== undefined) {
+        candidates.push({ kind: 'thread', source: triggerConfig.thread });
+    }
+    const channelActive = triggerConfig.channel !== undefined
+        && event.threadTs === undefined;
+    if (channelActive && triggerConfig.channel !== undefined) {
+        candidates.push({ kind: 'channel', source: triggerConfig.channel });
+    }
+    return candidates.sort((a, b) => messageTriggerPriority(a.kind) - messageTriggerPriority(b.kind));
+}
+function messageTriggerPriority(kind) {
+    switch (kind) {
+        case 'mention':
+            return 0;
+        case 'thread':
+            return 1;
+        case 'channel':
+            return 2;
+    }
+}
+function buildMessageTriggerEvent(kind, event, userName, body) {
+    return {
+        kind,
+        channelId: event.channel,
+        userId: event.userId,
+        userName,
+        text: event.text,
+        ts: event.ts,
+        threadTs: event.threadTs,
+        files: toAttachmentMetadata(event.files),
+        raw: body,
     };
 }
-// ─── Shared event processing ────────────────────────────────────────────────
 async function resolveUserName(slack, userId, cache) {
     if (!userId)
         return '';
@@ -119,15 +280,10 @@ async function resolveUserName(slack, userId, cache) {
     }
     catch (err) {
         console.warn(`[slack] failed to resolve username for ${userId}:`, err);
-        cache.set(userId, userId); // cache the fallback to avoid repeated failures
+        cache.set(userId, userId);
         return userId;
     }
 }
-/**
- * Check if the bot participated in the given thread — either mentioned or
- * posted a message.  Used as a fallback when activeThreads (in-memory) doesn't
- * have the thread (e.g. after a restart).
- */
 async function wasBotInThread(slack, channel, threadTs, botUserId) {
     if (!botUserId)
         return false;
@@ -135,193 +291,389 @@ async function wasBotInThread(slack, channel, threadTs, botUserId) {
         const result = await slack.conversations.replies({
             channel,
             ts: threadTs,
-            limit: 50, // check up to 50 messages
+            limit: 50,
         });
         const mentionPattern = `<@${botUserId}>`;
-        return result.messages?.some(m => m.text?.includes(mentionPattern) || m.user === botUserId) ?? false;
+        return result.messages?.some((message) => message.text?.includes(mentionPattern) || message.user === botUserId) ?? false;
     }
     catch (err) {
-        console.warn(`[slack] failed to check thread history for bot participation:`, err);
+        console.warn('[slack] failed to check thread history for bot participation:', err);
         return false;
     }
 }
-/**
- * Shared event processor — works identically for HTTP and Socket Mode payloads.
- * The outer envelope (`body`) has the same shape in both modes.
- */
-/** Download Slack files to a local temp directory and return FileAttachments with localPath. */
 async function downloadSlackFiles(files, botToken) {
     const dir = join(tmpdir(), 'slack-files');
     await mkdir(dir, { recursive: true });
-    return Promise.all(files.map(async (f) => {
+    return Promise.all(files.map(async (file) => {
         const base = {
-            id: f.id,
-            name: f.name,
-            mimeType: f.mimetype,
-            url: f.url_private,
+            id: file.id,
+            name: file.name,
+            mimeType: file.mimetype,
+            url: file.url_private,
         };
-        if (!f.url_private)
+        if (!file.url_private)
             return base;
         try {
-            const response = await fetch(f.url_private, {
+            const response = await fetch(file.url_private, {
                 headers: { Authorization: `Bearer ${botToken}` },
             });
             if (!response.ok) {
-                console.warn(`[slack] file download failed for ${f.id}: ${response.status}`);
+                console.warn(`[slack] file download failed for ${file.id}: ${response.status}`);
                 return base;
             }
-            const buf = Buffer.from(await response.arrayBuffer());
-            const ext = f.name?.includes('.') ? '' : `.${(f.mimetype ?? '').split('/')[1] ?? 'bin'}`;
-            const localPath = join(dir, `${f.id}_${f.name ?? 'file'}${ext}`);
-            await writeFile(localPath, buf);
-            console.log(`[slack] downloaded file ${f.id} → ${localPath} (${buf.length} bytes)`);
+            const buffer = Buffer.from(await response.arrayBuffer());
+            const ext = file.name.includes('.') ? '' : `.${file.mimetype.split('/')[1] ?? 'bin'}`;
+            const localPath = join(dir, `${file.id}_${file.name}${ext}`);
+            await writeFile(localPath, buffer);
             return { ...base, localPath };
         }
         catch (err) {
-            console.warn(`[slack] file download error for ${f.id}:`, err);
+            console.warn(`[slack] file download error for ${file.id}:`, err);
             return base;
         }
     }));
 }
-async function processSlackEvent(body, engine, appId, slack, botToken, userNameCache, activeThreads, processedEvents, processingEvents, botUserId) {
-    const event = body?.event;
-    if (!event) {
-        console.log('[slack] no event in body, type:', body?.type);
-        return;
+async function lookupSlackMessage(slack, channel, ts, userNameCache) {
+    try {
+        const result = await slack.conversations.history({
+            channel,
+            latest: ts,
+            oldest: ts,
+            inclusive: true,
+            limit: 1,
+        });
+        const rawMessage = result.messages?.[0];
+        if (!rawMessage)
+            return null;
+        const userId = typeof rawMessage.user === 'string' ? rawMessage.user : undefined;
+        const userName = userId
+            ? await resolveUserName(slack, userId, userNameCache)
+            : (typeof rawMessage.username === 'string' ? rawMessage.username : undefined);
+        const files = Array.isArray(rawMessage.files)
+            ? rawMessage.files.flatMap((item) => {
+                if (!isRecord(item))
+                    return [];
+                const id = readString(item, 'id');
+                const name = readString(item, 'name');
+                const mimetype = readString(item, 'mimetype');
+                if (!id || !name || !mimetype)
+                    return [];
+                return [{
+                        id,
+                        name,
+                        mimetype,
+                        url_private: readString(item, 'url_private'),
+                    }];
+            })
+            : [];
+        const rawRecord = rawMessage;
+        return {
+            channel,
+            ts: typeof rawMessage.ts === 'string' ? rawMessage.ts : ts,
+            threadTs: typeof rawMessage.thread_ts === 'string' ? rawMessage.thread_ts : undefined,
+            text: typeof rawMessage.text === 'string' ? rawMessage.text : '',
+            userId,
+            userName,
+            botId: readString(rawRecord, 'bot_id'),
+            files,
+            raw: rawRecord,
+        };
+    }
+    catch (err) {
+        console.warn(`[slack] failed to lookup message ${channel}:${ts}:`, err);
+        return null;
+    }
+}
+async function buildReactionContext(body, reaction, slack, botToken, userNameCache) {
+    const targetMessage = await lookupSlackMessage(slack, reaction.channel, reaction.messageTs, userNameCache);
+    if (!targetMessage)
+        return null;
+    const actorUserName = await resolveUserName(slack, reaction.userId, userNameCache);
+    const files = targetMessage.files.length > 0
+        ? await downloadSlackFiles(targetMessage.files, botToken)
+        : undefined;
+    const threadTs = targetMessage.threadTs ?? targetMessage.ts;
+    return {
+        conversationId: `${reaction.channel}:${threadTs}`,
+        files,
+        filterEvent: {
+            kind: 'reaction',
+            channelId: reaction.channel,
+            userId: reaction.userId,
+            userName: actorUserName,
+            messageUserId: targetMessage.userId,
+            messageUserName: targetMessage.userName,
+            messageBotId: targetMessage.botId,
+            text: targetMessage.text,
+            ts: targetMessage.ts,
+            threadTs,
+            reaction: reaction.reaction,
+            files: toAttachmentMetadata(targetMessage.files),
+            raw: {
+                body,
+                message: targetMessage.raw,
+            },
+        },
+    };
+}
+function createReactionEventId(reaction) {
+    return [
+        'reaction',
+        reaction.channel,
+        reaction.messageTs,
+        reaction.userId,
+        reaction.reaction,
+        reaction.eventTs ?? '',
+    ].join(':');
+}
+function createMessageEventId(event) {
+    return `${event.channel}:${event.ts}`;
+}
+function commitProcessedEvent(processedEvents, processingEvents, eventId) {
+    processedEvents.add(eventId);
+    processingEvents.delete(eventId);
+    if (processedEvents.size > 500) {
+        const excess = processedEvents.size - 500;
+        let removed = 0;
+        for (const entry of processedEvents) {
+            if (removed >= excess)
+                break;
+            processedEvents.delete(entry);
+            removed++;
+        }
     }
-    // Handle reaction_added: :x: emoji aborts in-flight turn
-    if (event.type === 'reaction_added' && event.reaction === 'x') {
-        const item = event.item;
-        if (item?.type !== 'message')
+}
+export async function processSlackEvent(body, engine, slack, botToken, userNameCache, activeThreads, processedEvents, processingEvents, triggerConfig, promptBaseDir, botUserId) {
+    const reactionEvent = parseReactionEvent(body);
+    if (reactionEvent) {
+        const rule = triggerConfig.reactions[reactionEvent.reaction];
+        if (!rule)
+            return;
+        const eventId = createReactionEventId(reactionEvent);
+        if (processedEvents.has(eventId) || processingEvents.has(eventId)) {
+            console.log(`[slack] skipping duplicate reaction ${eventId}`);
             return;
-        // Resolve the thread_ts of the reacted-to message
-        const channel = item.channel;
-        const messageTs = item.ts;
+        }
+        processingEvents.add(eventId);
         try {
-            const result = await slack.conversations.replies({
-                channel,
-                ts: messageTs,
-                limit: 1,
-                inclusive: true,
-            });
-            const msg = result.messages?.[0];
-            const threadTs = msg?.thread_ts ?? msg?.ts ?? messageTs;
-            const conversationId = `${channel}:${threadTs}`;
-            const aborted = engine.abortConversation(conversationId);
-            if (aborted) {
-                console.log(`[slack] :x: reaction aborted conversation ${conversationId}`);
-                // React with :x: to confirm abort
-                try {
-                    await slack.reactions.add({ channel, name: 'x', timestamp: messageTs });
-                }
-                catch { /* ignore */ }
+            const context = await buildReactionContext(body, reactionEvent, slack, botToken, userNameCache);
+            if (!context) {
+                processingEvents.delete(eventId);
+                return;
             }
-            else {
-                console.log(`[slack] :x: reaction on ${conversationId} — no active turn to abort`);
+            const passed = await runReactionTriggerFilter(rule, context.filterEvent);
+            if (!passed) {
+                commitProcessedEvent(processedEvents, processingEvents, eventId);
+                return;
+            }
+            if (isReactionAbortRule(rule)) {
+                const aborted = engine.abortConversation(context.conversationId);
+                if (aborted && reactionEvent.reaction === 'x') {
+                    try {
+                        await slack.reactions.add({
+                            channel: reactionEvent.channel,
+                            name: 'x',
+                            timestamp: reactionEvent.messageTs,
+                        });
+                    }
+                    catch {
+                        // ignore confirmation reaction failures
+                    }
+                }
+                commitProcessedEvent(processedEvents, processingEvents, eventId);
+                return;
             }
+            const prompt = await resolvePromptSource(rule, promptBaseDir);
+            const inbound = {
+                connector: 'slack',
+                conversationId: context.conversationId,
+                userId: context.filterEvent.userId,
+                userName: context.filterEvent.userName ?? '',
+                text: buildReactionInputText(prompt, context.filterEvent),
+                files: context.files,
+                raw: context.filterEvent.raw,
+            };
+            activeThreads.add(context.conversationId);
+            commitProcessedEvent(processedEvents, processingEvents, eventId);
+            await engine.submitTurn(inbound);
+            return;
         }
         catch (err) {
-            console.warn('[slack] failed to handle :x: reaction:', err);
+            processingEvents.delete(eventId);
+            console.error('[slack] failed to process reaction event:', err);
+            return;
         }
-        return;
     }
-    // Only handle app_mention and message events
-    if (event.type !== 'app_mention' && event.type !== 'message') {
-        console.log('[slack] ignoring event type:', event.type);
+    const messageEvent = parseMessageEvent(body);
+    if (!messageEvent) {
+        const eventRecord = readRecord(body, 'event');
+        console.log('[slack] ignoring event type:', eventRecord ? readString(eventRecord, 'type') : '(none)');
         return;
     }
-    if (event.bot_id)
-        return; // Ignore bot messages
-    // Ignore message subtypes (edits, deletes, etc.) but allow file_share (image/file attachments)
-    if (event.subtype && event.subtype !== 'file_share')
+    if (messageEvent.botId)
         return;
-    // Deduplicate: Slack sends both app_mention and message for the same @mention.
-    // Two-phase approach:
-    //   1. processingEvents — claimed immediately (before await) to prevent race conditions
-    //   2. processedEvents — committed only after we confirm the event will be handled
-    // This prevents the bug where a `message` event claims the eventId, exits early
-    // (no thread_ts / inactive thread), and then the subsequent `app_mention` is skipped.
-    const eventId = `${event.channel}:${event.ts}`;
+    if (messageEvent.subtype && messageEvent.subtype !== 'file_share')
+        return;
+    const eventId = createMessageEventId(messageEvent);
     if (processedEvents.has(eventId)) {
-        console.log(`[slack] skipping duplicate event ${event.type} ${eventId}`);
+        console.log(`[slack] skipping duplicate event ${messageEvent.type} ${eventId}`);
         return;
     }
-    // app_mention takes priority — if a message event is currently being processed
-    // (in-flight, not yet committed), an app_mention can steal the slot.
-    if (event.type === 'app_mention') {
-        // Always allow app_mention to proceed — remove any in-flight message claim
+    if (messageEvent.type === 'app_mention') {
         processingEvents.delete(eventId);
     }
     else if (processingEvents.has(eventId)) {
-        // Another event (likely app_mention) is already processing this
-        console.log(`[slack] skipping duplicate event ${event.type} ${eventId} (in-flight)`);
+        console.log(`[slack] skipping duplicate event ${messageEvent.type} ${eventId} (in-flight)`);
         return;
     }
-    // Claim the slot immediately (before any await) to prevent concurrent duplicates
     processingEvents.add(eventId);
-    const threadKey = `${event.channel}:${event.thread_ts ?? event.ts}`;
-    // For app_mention: always process and track the thread
-    if (event.type === 'app_mention') {
-        activeThreads.add(threadKey);
-    }
-    // For message events: only process if it's a reply in an active thread
-    if (event.type === 'message') {
-        if (!event.thread_ts) {
-            // Top-level channel message without mention — ignore
-            processingEvents.delete(eventId);
-            return;
-        }
-        if (!activeThreads.has(threadKey)) {
-            // Thread not tracked in memory — check thread history as fallback (e.g. after restart)
-            const participated = await wasBotInThread(slack, event.channel, event.thread_ts, botUserId);
-            if (participated) {
-                console.log(`[slack] recovered active thread from history: ${threadKey}`);
-                activeThreads.add(threadKey);
-            }
-            else {
-                console.log(`[slack] ignoring thread reply in inactive thread ${threadKey}`);
-                processingEvents.delete(eventId);
-                return;
-            }
+    const conversationId = buildConversationId(messageEvent.channel, messageEvent.threadTs, messageEvent.ts);
+    if (messageEvent.threadTs && !activeThreads.has(conversationId) && triggerConfig.thread !== undefined) {
+        const participated = await wasBotInThread(slack, messageEvent.channel, messageEvent.threadTs, botUserId);
+        if (participated) {
+            activeThreads.add(conversationId);
+            console.log(`[slack] recovered active thread from history: ${conversationId}`);
         }
     }
-    // Event will be processed — commit to processedEvents and release processingEvents
-    processedEvents.add(eventId);
-    processingEvents.delete(eventId);
-    // Evict oldest entries when exceeding 500 to prevent unbounded growth
-    if (processedEvents.size > 500) {
-        const excess = processedEvents.size - 500;
-        let removed = 0;
-        for (const entry of processedEvents) {
-            if (removed >= excess)
+    const candidates = selectMessageCandidates(messageEvent, triggerConfig, activeThreads, botUserId);
+    if (candidates.length === 0) {
+        processingEvents.delete(eventId);
+        return;
+    }
+    const userName = await resolveUserName(slack, messageEvent.userId, userNameCache);
+    let selected = null;
+    try {
+        for (const candidate of candidates) {
+            const triggerEvent = buildMessageTriggerEvent(candidate.kind, messageEvent, userName, body);
+            const passed = await runMessageTriggerFilter(candidate.source, triggerEvent);
+            if (passed) {
+                selected = candidate;
                 break;
-            processedEvents.delete(entry);
-            removed++;
+            }
         }
     }
-    const userId = event.user ?? '';
-    const userName = await resolveUserName(slack, userId, userNameCache);
-    console.log(`[slack] ${event.type} from ${userName}(${userId}) in ${event.channel} [thread:${event.thread_ts ?? 'none'}]`);
-    // Download attached files to local temp directory
-    const files = event.files?.length
-        ? await downloadSlackFiles(event.files, botToken)
-        : undefined;
-    const inbound = {
-        connector: 'slack',
-        conversationId: threadKey,
-        userId,
-        userName,
-        text: event.text ?? '',
-        files,
-        raw: body,
-    };
+    catch (err) {
+        processingEvents.delete(eventId);
+        console.error('[slack] message trigger filter failed:', err);
+        return;
+    }
+    if (!selected) {
+        processingEvents.delete(eventId);
+        return;
+    }
     try {
+        const prompt = await resolvePromptSource(selected.source, promptBaseDir);
+        const files = messageEvent.files.length > 0
+            ? await downloadSlackFiles(messageEvent.files, botToken)
+            : undefined;
+        const inbound = {
+            connector: 'slack',
+            conversationId,
+            userId: messageEvent.userId,
+            userName,
+            text: buildMessageInputText(prompt, messageEvent.text),
+            files,
+            raw: {
+                ...body,
+                triggerKind: selected.kind,
+            },
+        };
+        activeThreads.add(conversationId);
+        commitProcessedEvent(processedEvents, processingEvents, eventId);
         await engine.submitTurn(inbound);
     }
     catch (err) {
-        console.error('[slack] submitTurn error:', err);
+        processingEvents.delete(eventId);
+        console.error('[slack] failed to process message event:', err);
     }
 }
+export function slackConnector(options) {
+    const { botToken, thinkingMessage } = options;
+    const slack = new WebClient(botToken);
+    const userNameCache = new Map();
+    const activeThreads = new Set();
+    const processedEvents = new Set();
+    const processingEvents = new Set();
+    const triggerConfig = normalizeTriggerConfig(options.triggers);
+    let botUserId;
+    let socketClient;
+    let promptBaseDir = process.cwd();
+    return {
+        name: 'slack',
+        registerRoutes(server, engine, context) {
+            promptBaseDir = context?.promptBaseDir ?? process.cwd();
+            const resolveBotUserId = async () => {
+                if (botUserId)
+                    return;
+                try {
+                    const auth = await slack.auth.test();
+                    botUserId = auth.user_id ?? undefined;
+                    console.log(`[slack] resolved bot user id: ${botUserId}`);
+                }
+                catch (err) {
+                    console.warn('[slack] failed to resolve bot user id:', err);
+                }
+            };
+            const mode = options.mode ?? 'http';
+            if (mode === 'socket') {
+                const { appToken } = options;
+                socketClient = new SocketModeClient({ appToken });
+                const handleSocketEvent = async ({ body, ack }) => {
+                    await ack();
+                    await resolveBotUserId();
+                    await processSlackEvent(body, engine, slack, botToken, userNameCache, activeThreads, processedEvents, processingEvents, triggerConfig, promptBaseDir, botUserId);
+                };
+                socketClient.on('app_mention', handleSocketEvent);
+                socketClient.on('message', handleSocketEvent);
+                socketClient.on('reaction_added', handleSocketEvent);
+                socketClient.start().then(() => {
+                    console.log('[slack] socket mode connected');
+                }).catch((err) => {
+                    console.error('[slack] socket mode connection failed:', err);
+                });
+                return;
+            }
+            const { signingSecret } = options;
+            server.post('/api/slack/events', async (req, res) => {
+                const request = req;
+                const response = res;
+                const body = isRecord(request.body) ? request.body : {};
+                if (body.type === 'url_verification' && typeof body.challenge === 'string') {
+                    response.status(200).json({ challenge: body.challenge });
+                    return;
+                }
+                const headers = request.headers ?? {};
+                const timestamp = headers['x-slack-request-timestamp'];
+                const signature = headers['x-slack-signature'];
+                const rawBody = request.rawBody ?? JSON.stringify(body);
+                if (!timestamp || !signature || !verifySignature(signingSecret, timestamp, rawBody, signature)) {
+                    console.warn('[slack] signature verification failed');
+                    response.status(401).send('Invalid signature');
+                    return;
+                }
+                response.status(200).send('');
+                await resolveBotUserId();
+                await processSlackEvent(body, engine, slack, botToken, userNameCache, activeThreads, processedEvents, processingEvents, triggerConfig, promptBaseDir, botUserId);
+            });
+        },
+        createOutput(context) {
+            activeThreads.add(context.conversationId);
+            return createSlackOutput(slack, context, thinkingMessage);
+        },
+        async stop() {
+            if (!socketClient)
+                return;
+            try {
+                socketClient.disconnect();
+                console.log('[slack] socket mode disconnected');
+            }
+            catch (err) {
+                console.warn('[slack] socket mode disconnect failed:', err);
+            }
+            socketClient = undefined;
+        },
+    };
+}
 // ─── Output ─────────────────────────────────────────────────────────────────
 /**
  * Slack Output with step accumulation.
@@ -335,7 +687,7 @@ async function processSlackEvent(body, engine, appId, slack, botToken, userNameC
  * start with the previous text, it means a new assistant message has started
  * (= new step). The previous text is flushed to the completed-steps buffer.
  */
-function createSlackOutput(slack, context, thinkingMessage) {
+export function createSlackOutput(slack, context, thinkingMessage) {
     const [channel, threadTs] = context.conversationId.split(':');
     // --- Accumulated state ---
     const completedSteps = []; // Flushed step texts
@@ -344,9 +696,11 @@ function createSlackOutput(slack, context, thinkingMessage) {
     let frozenStepCount = 0; // Steps baked into previous (frozen) messages
     let lastRenderTime = 0;
     let finalized = false; // true after sendResult/sendError
+    let renderPromise = null;
     const THROTTLE_MS = 1500;
     const MAX_BLOCKS = 45; // Leave headroom below Slack's 50-block limit
     const MAX_TEXT_LENGTH = 2800; // Slack text field limit ~3000 chars; leave buffer
+    const FINAL_CHUNK_LENGTH = 2600;
     // --- Serialize all Slack API calls to prevent race conditions ---
     let apiQueue = Promise.resolve();
     function enqueue(fn) {
@@ -397,6 +751,77 @@ function createSlackOutput(slack, context, thinkingMessage) {
         const combined = parts.join('\n');
         return markdownToSlack(combined);
     }
+    function createSafeLivePayload(text) {
+        const suffix = '\n\n_(계속 생성 중...)_';
+        const truncated = text.length + suffix.length > MAX_TEXT_LENGTH
+            ? text.slice(0, MAX_TEXT_LENGTH - suffix.length) + suffix
+            : text;
+        return { text: truncated };
+    }
+    function splitTextForSlack(text, maxLength) {
+        const source = text.trim();
+        if (!source)
+            return [];
+        const chunks = [];
+        let remaining = source;
+        while (remaining.length > maxLength) {
+            const newlineBreak = remaining.lastIndexOf('\n', maxLength);
+            const spaceBreak = remaining.lastIndexOf(' ', maxLength);
+            const preferredBreak = Math.max(newlineBreak, spaceBreak);
+            const splitAt = preferredBreak >= Math.floor(maxLength * 0.6) ? preferredBreak : maxLength;
+            const chunk = remaining.slice(0, splitAt).trimEnd();
+            if (!chunk) {
+                chunks.push(remaining.slice(0, maxLength));
+                remaining = remaining.slice(maxLength).trimStart();
+                continue;
+            }
+            chunks.push(chunk);
+            remaining = remaining.slice(splitAt).trimStart();
+        }
+        if (remaining) {
+            chunks.push(remaining);
+        }
+        return chunks;
+    }
+    async function updateOrCreateMessage(payload) {
+        if (activeTs) {
+            await slack.chat.update({ channel, ts: activeTs, ...payload });
+            return;
+        }
+        const result = await slack.chat.postMessage({ channel, thread_ts: threadTs, ...payload });
+        activeTs = result.ts;
+    }
+    async function renderFinalInChunks(text) {
+        const chunks = splitTextForSlack(text, FINAL_CHUNK_LENGTH);
+        if (chunks.length === 0)
+            return;
+        if (activeTs) {
+            await slack.chat.update({ channel, ts: activeTs, text: chunks[0] });
+        }
+        else {
+            const result = await slack.chat.postMessage({ channel, thread_ts: threadTs, text: chunks[0] });
+            activeTs = result.ts;
+        }
+        for (const chunk of chunks.slice(1)) {
+            await slack.chat.postMessage({ channel, thread_ts: threadTs, text: chunk });
+        }
+    }
+    async function queueRender(options) {
+        if (renderPromise) {
+            if (options?.final) {
+                await renderPromise;
+                return queueRender(options);
+            }
+            return renderPromise;
+        }
+        renderPromise = enqueue(async () => {
+            await renderMessage(options);
+            lastRenderTime = Date.now();
+        }).finally(() => {
+            renderPromise = null;
+        });
+        return renderPromise;
+    }
     /** Update or create the active Slack message. Handles overflow. */
     async function renderMessage(options) {
         // Determine which steps to render in the active message
@@ -406,9 +831,23 @@ function createSlackOutput(slack, context, thinkingMessage) {
         if (!payload.text.trim())
             return;
         const blockCount = payload.blocks?.length ?? 1;
-        // --- Overflow check: block count OR text length ---
         const textLength = payload.text.length;
-        if (activeTs && (blockCount > MAX_BLOCKS || textLength > MAX_TEXT_LENGTH)) {
+        if (options?.final && (blockCount > MAX_BLOCKS || textLength > MAX_TEXT_LENGTH)) {
+            await renderFinalInChunks(payload.text);
+            return;
+        }
+        if (!options?.final && (blockCount > MAX_BLOCKS || textLength > MAX_TEXT_LENGTH)) {
+            const safePayload = createSafeLivePayload(payload.text);
+            try {
+                await updateOrCreateMessage(safePayload);
+            }
+            catch (err) {
+                console.warn('[slack] live preview fallback failed:', err);
+            }
+            return;
+        }
+        // --- Overflow check: block count OR text length ---
+        if (!options?.final && activeTs && (blockCount > MAX_BLOCKS || textLength > MAX_TEXT_LENGTH)) {
             // 1. Freeze the current message with only its completed steps (no live text)
             const frozenPayload = renderSteps(completedSteps.slice(frozenStepCount));
             if (frozenPayload.text.trim()) {
@@ -437,11 +876,7 @@ function createSlackOutput(slack, context, thinkingMessage) {
                 safePayload = overflowPayload;
             }
             try {
-                const result = await slack.chat.postMessage({
-                    channel,
-                    thread_ts: threadTs,
-                    ...safePayload,
-                });
+                const result = await slack.chat.postMessage({ channel, thread_ts: threadTs, ...safePayload });
                 activeTs = result.ts;
                 console.log(`[slack] overflow → new message ts=${result.ts}`);
             }
@@ -456,30 +891,18 @@ function createSlackOutput(slack, context, thinkingMessage) {
                 await slack.chat.update({ channel, ts: activeTs, ...payload });
             }
             catch (err) {
-                // chat.update failed — likely Slack rejected the payload as too large.
-                // Treat this as an overflow: freeze the old message as-is and start a
-                // new message with only recent steps (instead of duplicating everything).
-                console.warn('[slack] chat.update failed, triggering overflow:', err);
-                frozenStepCount = Math.max(0, completedSteps.length - 1);
-                const overflowSteps = completedSteps.slice(frozenStepCount);
-                const liveTextForOverflow = options?.final ? undefined : currentText;
-                const overflowPayload = renderSteps(overflowSteps, liveTextForOverflow);
-                if (overflowPayload.text.trim()) {
-                    // Guard: truncate if even the single-step payload is too large
-                    const obCount = overflowPayload.blocks?.length ?? 1;
-                    const otLen = overflowPayload.text.length;
-                    const safePayload = obCount > MAX_BLOCKS || otLen > MAX_TEXT_LENGTH
-                        ? { text: overflowPayload.text.slice(0, MAX_TEXT_LENGTH - 20) + '\n\n_(truncated)_' }
-                        : overflowPayload;
+                if (!options?.final) {
+                    console.warn('[slack] chat.update failed, switching to live preview fallback:', err);
                     try {
-                        const result = await slack.chat.postMessage({ channel, thread_ts: threadTs, ...safePayload });
-                        activeTs = result.ts;
-                        console.log(`[slack] update-fail overflow → new message ts=${result.ts}`);
+                        await updateOrCreateMessage(createSafeLivePayload(payload.text));
                     }
-                    catch (err2) {
-                        console.warn('[slack] update-fail overflow postMessage also failed:', err2);
+                    catch (fallbackErr) {
+                        console.warn('[slack] live preview fallback failed after update error:', fallbackErr);
                     }
+                    return;
                 }
+                console.warn('[slack] final chat.update failed, switching to chunked fallback:', err);
+                await renderFinalInChunks(payload.text);
             }
         }
         else {
@@ -508,16 +931,19 @@ function createSlackOutput(slack, context, thinkingMessage) {
             const now = Date.now();
             if (now - lastRenderTime < THROTTLE_MS && activeTs)
                 return;
-            await enqueue(async () => {
-                await renderMessage();
-                lastRenderTime = Date.now();
-            });
+            await queueRender();
         },
         async sendResult(text) {
             finalized = true;
             // Flush current progress as a completed step if it differs from the result
-            // Use trimmed comparison to tolerate minor whitespace differences
-            if (currentText && currentText.trim() !== text.trim()) {
+            // When progress text is just a growing preview of the final answer,
+            // the final answer should replace it rather than appear twice.
+            const currentTrimmed = currentText.trim();
+            const finalTrimmed = text.trim();
+            const isGrowingPreview = currentTrimmed.length > 0 &&
+                finalTrimmed.length > 0 &&
+                (finalTrimmed.startsWith(currentTrimmed) || currentTrimmed.startsWith(finalTrimmed));
+            if (currentText && currentTrimmed !== finalTrimmed && !isGrowingPreview) {
                 completedSteps.push(currentText);
             }
             currentText = '';
@@ -535,15 +961,13 @@ function createSlackOutput(slack, context, thinkingMessage) {
                 completedSteps.push(text);
             }
             console.log(`[slack] sendResult: channel=${channel}, thread_ts=${threadTs}, steps=${completedSteps.length}, text.length=${text.length}`);
-            await enqueue(async () => {
-                try {
-                    await renderMessage({ final: true });
-                    console.log(`[slack] sendResult ok: ts=${activeTs}`);
-                }
-                catch (err) {
-                    console.error(`[slack] sendResult render failed:`, err);
-                }
-            });
+            try {
+                await queueRender({ final: true });
+                console.log(`[slack] sendResult ok: ts=${activeTs}`);
+            }
+            catch (err) {
+                console.error(`[slack] sendResult render failed:`, err);
+            }
         },
         async sendError(message) {
             finalized = true;