@geminixiang/mikan 0.2.0

package/dist/adapters/slack/bot.js

@@ -0,0 +1,1272 @@
+import { SocketModeClient } from "@slack/socket-mode";
+import { WebClient } from "@slack/web-api";
+import { existsSync, readFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { basename, join } from "path";
+import * as log from "../../log.js";
+import { PRODUCT_NAME, formatForceStopped, formatNothingRunning } from "../../ui-copy.js";
+import { appendBotResponseLog, appendChannelLog, ChannelQueue, resolveOnlyScopedStopTarget, resolveStopTarget, withRetry, } from "../shared.js";
+import { evaluateAutoReplyPolicy } from "../../trigger.js";
+import { createSlackAdapters } from "./context.js";
+import { hasMaterializedSlackBranchSession, registerSlackForkSession } from "./branch-manager.js";
+import { isSlackForkSessionKey, planSlackAdapterSession, planSlackEventForkRun, resolveSlackSessionKey, } from "./session.js";
+import { reportUserFacingError } from "../../sentry.js";
+const SLACK_EVENT_ANCHOR_TEXT = "Working on it...";
+// Slack WebClient errors carry either `code: "rate_limited"` (retry-after) or
+// the legacy `data.error === "rate_limited"` / 429 status shape.
+function slackIsRateLimited(err) {
+    if (err.code === "rate_limited")
+        return true;
+    const data = err.data;
+    return data?.error === "rate_limited" || data?.response?.status === 429;
+}
+const slackRetry = (fn) => withRetry(fn, { isRateLimited: slackIsRateLimited });
+function collectSlackText(value, parts) {
+    if (value === null || value === undefined)
+        return;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed)
+            parts.push(trimmed);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectSlackText(item, parts);
+        return;
+    }
+    if (typeof value !== "object")
+        return;
+    const obj = value;
+    for (const key of ["text", "fallback", "title", "value"]) {
+        collectSlackText(obj[key], parts);
+    }
+    collectSlackText(obj.fields, parts);
+    collectSlackText(obj.elements, parts);
+    collectSlackText(obj.blocks, parts);
+}
+function buildSlackAppMessageText(event) {
+    const parts = [];
+    collectSlackText(event.text, parts);
+    collectSlackText(event.blocks, parts);
+    collectSlackText(event.attachments, parts);
+    const deduped = parts.filter((part, index) => parts.indexOf(part) === index);
+    return deduped.join("\n");
+}
+// ============================================================================
+// SlackBot
+// ============================================================================
+export class SlackBot {
+    constructor(handler, config) {
+        this.botUserId = null;
+        this.botId = null;
+        this.ownMentionRegex = null;
+        this.startupTs = null; // Messages older than this are just logged, not processed
+        this.users = new Map();
+        this.channels = new Map();
+        this.queues = new Map();
+        this.eventsWatcher = null;
+        this.handler = handler;
+        this.workingDir = config.workingDir;
+        this.store = config.store;
+        this.socketClient = new SocketModeClient({
+            appToken: config.appToken,
+            // Default 5s is too tight: brief event-loop stalls (e.g. backfill, sync fs)
+            // cause false pong timeouts; 4 in a row makes Slack drop the socket.
+            clientPingTimeout: 12_000,
+        });
+        this.webClient = new WebClient(config.botToken);
+    }
+    setEventsWatcher(watcher) {
+        this.eventsWatcher = watcher;
+    }
+    // ==========================================================================
+    // Public API
+    // ==========================================================================
+    async start() {
+        const auth = await this.webClient.auth.test();
+        this.botUserId = auth.user_id;
+        this.botId = typeof auth.bot_id === "string" ? auth.bot_id : null;
+        await Promise.all([this.fetchUsers(), this.fetchChannels()]);
+        log.logInfo(`Loaded ${this.channels.size} channels, ${this.users.size} users`);
+        // Record startup time before opening the socket. Slack may replay older events;
+        // those should be logged but not processed. Backfill runs in the background up
+        // to this timestamp so startup is not blocked by one history call per channel.
+        this.startupTs = (Date.now() / 1000).toFixed(6);
+        this.setupEventHandlers();
+        await this.socketClient.start();
+        log.logConnected("Slack");
+        void this.backfillAllChannels(this.startupTs).catch((error) => {
+            log.logWarning("Slack backfill failed", String(error));
+        });
+    }
+    getUser(userId) {
+        return this.users.get(userId);
+    }
+    getChannel(channelId) {
+        return this.channels.get(channelId);
+    }
+    getAllUsers() {
+        return Array.from(this.users.values());
+    }
+    getAllChannels() {
+        return Array.from(this.channels.values());
+    }
+    stripOwnMention(text) {
+        const source = text ?? "";
+        if (!this.botUserId)
+            return source.trim();
+        if (!this.ownMentionRegex || !this.ownMentionRegex.source.includes(this.botUserId)) {
+            this.ownMentionRegex = new RegExp(`<@${this.botUserId}>`, "gi");
+        }
+        return source.replace(this.ownMentionRegex, "").trim();
+    }
+    async postMessage(channel, text) {
+        return slackRetry(async () => {
+            const result = await this.webClient.chat.postMessage({ channel, text });
+            return result.ts;
+        });
+    }
+    async postEphemeral(channel, user, text, threadTs) {
+        return slackRetry(async () => {
+            await this.webClient.chat.postEphemeral({
+                channel,
+                user,
+                text,
+                ...(threadTs ? { thread_ts: threadTs } : {}),
+            });
+        });
+    }
+    async postEphemeralBlocks(channel, user, text, blocks, threadTs) {
+        return slackRetry(async () => {
+            await this.webClient.chat.postEphemeral({
+                channel,
+                user,
+                text,
+                blocks: blocks,
+                ...(threadTs ? { thread_ts: threadTs } : {}),
+            });
+        });
+    }
+    async postMessageBlocks(channel, text, blocks) {
+        return slackRetry(async () => {
+            const result = await this.webClient.chat.postMessage({
+                channel,
+                text,
+                blocks: blocks,
+            });
+            return result.ts;
+        });
+    }
+    async postPrivate(conversationId, userId, text) {
+        await this.postEphemeral(conversationId, userId, text);
+    }
+    async postPrivateDiagnostic(conversationId, userId, text, options) {
+        if (options?.style !== "muted") {
+            await this.postPrivate(conversationId, userId, options?.style === "error" ? `_${text}_` : text);
+            return;
+        }
+        const CONTEXT_TEXT_LIMIT = 3000;
+        const blockText = text.length > CONTEXT_TEXT_LIMIT
+            ? text.substring(0, CONTEXT_TEXT_LIMIT - 20) + "\n_(truncated)_"
+            : text;
+        await this.postEphemeralBlocks(conversationId, userId, text, [
+            { type: "context", elements: [{ type: "mrkdwn", text: blockText }] },
+        ]);
+    }
+    async openDirectMessage(userId) {
+        return slackRetry(async () => {
+            const result = await this.webClient.conversations.open({ users: userId });
+            const channelId = result.channel?.id;
+            if (!channelId) {
+                throw new Error(`Failed to open DM for user ${userId}`);
+            }
+            return channelId;
+        });
+    }
+    async updateMessage(channel, ts, text) {
+        return slackRetry(async () => {
+            await this.webClient.chat.update({ channel, ts, text });
+        });
+    }
+    async deleteMessage(channel, ts) {
+        return slackRetry(async () => {
+            await this.webClient.chat.delete({ channel, ts });
+        });
+    }
+    // ==========================================================================
+    // Slack Assistant API (AI assistant experience)
+    // ==========================================================================
+    /** Set the status for an assistant thread (shows "thinking" state) */
+    async setAssistantStatus(channel, threadTs, status) {
+        return slackRetry(async () => {
+            await this.webClient.assistant.threads.setStatus({
+                channel_id: channel,
+                thread_ts: threadTs,
+                status,
+            });
+        });
+    }
+    async postInThread(channel, threadTs, text) {
+        return slackRetry(async () => {
+            // Use Block Kit section for long messages to trigger Slack's "Show more" collapsing (~700 chars)
+            const SECTION_TEXT_LIMIT = 3000;
+            if (text.length > 500) {
+                const blockText = text.length > SECTION_TEXT_LIMIT
+                    ? text.substring(0, SECTION_TEXT_LIMIT - 20) + "\n_(truncated)_"
+                    : text;
+                const result = await this.webClient.chat.postMessage({
+                    channel,
+                    thread_ts: threadTs,
+                    text, // full text as notification fallback
+                    blocks: [{ type: "section", text: { type: "mrkdwn", text: blockText } }],
+                });
+                return result.ts;
+            }
+            const result = await this.webClient.chat.postMessage({ channel, thread_ts: threadTs, text });
+            return result.ts;
+        });
+    }
+    async postInThreadBlocks(channel, threadTs, text, blocks) {
+        return slackRetry(async () => {
+            const result = await this.webClient.chat.postMessage({
+                channel,
+                thread_ts: threadTs,
+                text, // fallback for notifications
+                blocks: blocks,
+            });
+            return result.ts;
+        });
+    }
+    async uploadFile(channel, filePath, title, threadTs) {
+        return slackRetry(async () => {
+            const fileName = title || basename(filePath);
+            const fileContent = readFileSync(filePath);
+            await this.webClient.files.uploadV2({
+                channel_id: channel,
+                file: fileContent,
+                filename: fileName,
+                title: fileName,
+                ...(threadTs ? { thread_ts: threadTs } : {}),
+            });
+        });
+    }
+    logToFile(channel, entry) {
+        appendChannelLog(this.workingDir, channel, entry);
+    }
+    logBotResponse(channel, text, ts, threadTs) {
+        appendBotResponseLog(this.workingDir, channel, text, ts, threadTs);
+    }
+    getPlatformInfo() {
+        return {
+            name: "slack",
+            formattingGuide: "## Slack Formatting (mrkdwn, NOT Markdown)\nBold: *text*, Italic: _text_, Code: `code`, Block: ```code```, Links: <url|text>\nDo NOT use **double asterisks** or [markdown](links).",
+            channels: this.getAllChannels().map((c) => ({ id: c.id, name: c.name })),
+            users: this.getAllUsers().map((u) => ({
+                id: u.id,
+                userName: u.userName,
+                displayName: u.displayName,
+            })),
+            diagnostics: {
+                showUsageSummary: true,
+            },
+        };
+    }
+    // ==========================================================================
+    // Events Integration
+    // ==========================================================================
+    /**
+     * Enqueue an event for processing. Always queues (no "already working" rejection).
+     * Returns true if enqueued, false if queue is full (max 5).
+     */
+    enqueueEvent(event) {
+        const conversationId = event.conversationId;
+        const queue = this.getQueue(conversationId);
+        if (queue.size() >= 5) {
+            log.logWarning(`Event queue full for ${conversationId}, discarding: ${event.text.substring(0, 50)}`);
+            return false;
+        }
+        log.logInfo(`Enqueueing event for ${conversationId}: ${event.text.substring(0, 50)}`);
+        queue.enqueue(async () => {
+            let anchorTs;
+            if (!event.thread_ts) {
+                try {
+                    anchorTs = await this.postMessage(conversationId, SLACK_EVENT_ANCHOR_TEXT);
+                }
+                catch (err) {
+                    log.logWarning(`Failed to post Slack event anchor for ${conversationId}`, err instanceof Error ? err.message : String(err));
+                    reportUserFacingError(err, {
+                        domain: "events",
+                        surface: "event_delivery",
+                        operation: "slack_anchor_post",
+                        severity: "error",
+                        platform: "slack",
+                        context: {
+                            conversationId,
+                            conversationKind: event.conversationKind,
+                            eventTs: event.ts,
+                            textLength: event.text.length,
+                        },
+                    });
+                    throw err;
+                }
+            }
+            const eventPlan = planSlackEventForkRun(event, anchorTs);
+            const eventForRun = eventPlan.event;
+            if (eventPlan.initialMessageTs && eventForRun.sessionKey) {
+                registerSlackForkSession({
+                    conversationDir: join(this.workingDir, conversationId),
+                    sessionKey: eventForRun.sessionKey,
+                });
+            }
+            const runQueueKey = planSlackAdapterSession(eventForRun, {
+                initialMessageTs: eventPlan.initialMessageTs,
+            }).sessionKey;
+            this.getQueue(runQueueKey).enqueue(async () => {
+                const slackEvent = {
+                    type: eventForRun.type,
+                    conversationId,
+                    conversationKind: eventForRun.conversationKind,
+                    channel: conversationId,
+                    ts: eventForRun.ts,
+                    thread_ts: eventForRun.thread_ts,
+                    user: eventForRun.user,
+                    text: eventForRun.text,
+                    attachments: eventForRun.attachments?.map((attachment) => ({
+                        original: attachment.name,
+                        localPath: attachment.localPath,
+                    })),
+                    sessionKey: eventForRun.sessionKey,
+                };
+                const adapters = createSlackAdapters(slackEvent, this, {
+                    initialMessageTs: eventPlan.initialMessageTs,
+                });
+                return this.handler.handleEvent(eventForRun, this, adapters);
+            });
+        });
+        return true;
+    }
+    // ==========================================================================
+    // Private - Event Handlers
+    // ==========================================================================
+    getQueue(channelId) {
+        let queue = this.queues.get(channelId);
+        if (!queue) {
+            queue = new ChannelQueue("Slack");
+            this.queues.set(channelId, queue);
+        }
+        return queue;
+    }
+    resolveQueueKey(conversationId, sessionKey) {
+        if (!isSlackForkSessionKey(sessionKey))
+            return sessionKey;
+        if (this.handler.isRunning(sessionKey))
+            return sessionKey;
+        return this.hasKnownForkSession(conversationId, sessionKey) ? sessionKey : conversationId;
+    }
+    hasKnownForkSession(conversationId, sessionKey) {
+        return hasMaterializedSlackBranchSession(join(this.workingDir, conversationId), sessionKey);
+    }
+    shouldTriggerSharedThreadReply(channelId, threadTs) {
+        if (!threadTs)
+            return false;
+        const sessionKey = resolveSlackSessionKey(channelId, threadTs);
+        if (this.handler.isRunning(sessionKey))
+            return true;
+        return this.hasKnownForkSession(channelId, sessionKey);
+    }
+    buildHomeView() {
+        const blocks = [
+            {
+                type: "section",
+                text: {
+                    type: "mrkdwn",
+                    text: `*${PRODUCT_NAME}*\nStart a new task or check on running work.`,
+                },
+                accessory: {
+                    type: "image",
+                    image_url: "https://media1.tenor.com/m/lfDATg4Bhc0AAAAC/happy-cat.gif",
+                    alt_text: PRODUCT_NAME,
+                },
+            },
+        ];
+        // --- Running tasks ---
+        const runningSessions = this.handler.getRunningSessions();
+        blocks.push({ type: "divider" }, {
+            type: "header",
+            text: {
+                type: "plain_text",
+                text: `Running Tasks (${runningSessions.length})`,
+                emoji: true,
+            },
+        });
+        if (runningSessions.length === 0) {
+            blocks.push({
+                type: "context",
+                elements: [{ type: "mrkdwn", text: "_No tasks running right now._" }],
+            });
+        }
+        else {
+            // Threshold for "stuck" detection (10 minutes)
+            const STUCK_THRESHOLD_MS = 10 * 60 * 1000;
+            for (const session of runningSessions) {
+                const channelId = session.sessionKey.split(":")[0];
+                const channel = this.channels.get(channelId);
+                const channelName = channel ? `#${channel.name}` : channelId;
+                const elapsed = Math.floor((Date.now() - session.startedAt) / 60000);
+                const elapsedStr = elapsed < 1 ? "<1 min" : `${elapsed} min`;
+                // Check if task might be stuck
+                const lastActivity = session.lastActivityAt ? Date.now() - session.lastActivityAt : 0;
+                const isStuck = lastActivity > STUCK_THRESHOLD_MS;
+                const statusText = isStuck ? "_stuck_" : "_running_";
+                // Build status line: channel · status · time · step
+                let statusLine = `${statusText} · ${elapsedStr}`;
+                if (session.currentTool) {
+                    statusLine += ` · ${session.currentTool}`;
+                }
+                if (isStuck && lastActivity > 0) {
+                    const inactiveMin = Math.floor(lastActivity / 60000);
+                    statusLine += ` · idle ${inactiveMin}m`;
+                }
+                // Use context block for gray small text (like "No scheduled jobs.")
+                blocks.push({
+                    type: "context",
+                    elements: [
+                        {
+                            type: "mrkdwn",
+                            text: `*${channelName}* · ${statusLine}`,
+                        },
+                    ],
+                });
+                // Add Force Stop button as separate element if stuck
+                if (isStuck) {
+                    blocks.push({
+                        type: "context",
+                        elements: [
+                            {
+                                type: "mrkdwn",
+                                text: " ",
+                            },
+                            {
+                                type: "button",
+                                text: { type: "plain_text", text: "Force Stop", emoji: true },
+                                action_id: `force_stop_${session.sessionKey.replace(/:/g, "_")}`,
+                                style: "danger",
+                            },
+                        ],
+                    });
+                }
+            }
+        }
+        // --- Cron jobs ---
+        const periodicEvents = this.eventsWatcher?.getPeriodicEvents() ?? [];
+        blocks.push({ type: "divider" }, {
+            type: "header",
+            text: {
+                type: "plain_text",
+                text: `Scheduled Jobs (${periodicEvents.length})`,
+                emoji: true,
+            },
+        });
+        if (periodicEvents.length === 0) {
+            blocks.push({
+                type: "context",
+                elements: [{ type: "mrkdwn", text: "_No scheduled jobs._" }],
+            });
+        }
+        else {
+            for (const ev of periodicEvents) {
+                const channelLabel = ev.platform === "slack"
+                    ? (() => {
+                        const channel = this.channels.get(ev.conversationId);
+                        const channelName = channel ? `#${channel.name}` : ev.conversationId;
+                        return `${ev.platform}:${channelName}`;
+                    })()
+                    : `${ev.platform}:${ev.conversationId}`;
+                const nextStr = ev.nextRun
+                    ? new Date(ev.nextRun).toLocaleString("en-US", {
+                        month: "short",
+                        day: "numeric",
+                        hour: "2-digit",
+                        minute: "2-digit",
+                    })
+                    : "—";
+                blocks.push({
+                    type: "section",
+                    text: {
+                        type: "mrkdwn",
+                        text: `*${ev.text}*\n└ \`${ev.schedule}\` · ${channelLabel} · Next: ${nextStr}`,
+                    },
+                });
+            }
+        }
+        // --- Footer ---
+        blocks.push({ type: "divider" }, {
+            type: "context",
+            elements: [
+                { type: "mrkdwn", text: "💡 @mention in a channel or send a DM to start a new task" },
+            ],
+        });
+        return { type: "home", blocks: blocks };
+    }
+    resolveStopTarget(channelId, threadTs) {
+        const directTarget = resolveStopTarget({
+            handler: this.handler,
+            conversationId: channelId,
+            sessionKey: resolveSlackSessionKey(channelId, threadTs),
+        });
+        if (directTarget)
+            return directTarget;
+        if (threadTs)
+            return null;
+        return resolveOnlyScopedStopTarget(this.handler, channelId);
+    }
+    isStopText(text) {
+        const normalized = text.trim().toLowerCase();
+        return normalized === "stop" || normalized === "/stop";
+    }
+    createCommandAdapters(conversationId, userId, userName, text, ts, options = {}) {
+        const message = {
+            id: ts,
+            sessionKey: conversationId,
+            conversationKind: options.ephemeralChannelId ? "shared" : "direct",
+            userId,
+            userName,
+            text,
+            attachments: [],
+        };
+        const respond = async (responseText) => {
+            if (options.ephemeralChannelId) {
+                await this.postEphemeral(options.ephemeralChannelId, userId, responseText, options.threadTs);
+                return;
+            }
+            const messageTs = await this.postMessage(conversationId, responseText);
+            this.logBotResponse(conversationId, responseText, messageTs);
+        };
+        const respondMuted = async (responseText) => {
+            const CONTEXT_TEXT_LIMIT = 3000;
+            const blockText = responseText.length > CONTEXT_TEXT_LIMIT
+                ? responseText.substring(0, CONTEXT_TEXT_LIMIT - 20) + "\n_(truncated)_"
+                : responseText;
+            const blocks = [{ type: "context", elements: [{ type: "mrkdwn", text: blockText }] }];
+            if (options.ephemeralChannelId) {
+                await this.postEphemeralBlocks(options.ephemeralChannelId, userId, responseText, blocks, options.threadTs);
+                return;
+            }
+            const messageTs = await this.postMessageBlocks(conversationId, responseText, blocks);
+            this.logBotResponse(conversationId, responseText, messageTs);
+        };
+        const responseCtx = {
+            respond,
+            replaceResponse: respond,
+            respondDiagnostic: async (responseText, responseOptions) => {
+                if (responseOptions?.style === "muted") {
+                    await respondMuted(responseText);
+                    return;
+                }
+                await respond(responseOptions?.style === "error" ? `_${responseText}_` : responseText);
+            },
+            respondToolResult: async (result) => {
+                const duration = (result.durationMs / 1000).toFixed(1);
+                await respond(`${result.isError ? "Error" : "Done"} ${result.toolName} (${duration}s)\n${result.result}`);
+            },
+            setTyping: async () => { },
+            setWorking: async () => { },
+            uploadFile: async (filePath, title) => {
+                await this.uploadFile(conversationId, filePath, title);
+            },
+            deleteResponse: async () => { },
+        };
+        return {
+            message,
+            responseCtx,
+            platform: this.getPlatformInfo(),
+        };
+    }
+    createSlashCommandBot(conversationId, threadTs) {
+        return {
+            start: async () => { },
+            postMessage: async (_channel, text) => {
+                if (threadTs) {
+                    return this.postInThread(conversationId, threadTs, text);
+                }
+                return this.postMessage(conversationId, text);
+            },
+            updateMessage: async (channel, ts, text) => {
+                await this.updateMessage(channel, ts, text);
+            },
+            enqueueEvent: (event) => this.enqueueEvent(event),
+            getPlatformInfo: () => this.getPlatformInfo(),
+        };
+    }
+    async routeSlashLoginCommand(payload) {
+        const commandSuffix = payload.text?.trim();
+        const commandText = commandSuffix ? `${payload.command} ${commandSuffix}` : payload.command;
+        const createdAt = new Date();
+        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
+        const sourceChannelId = payload.channel_id;
+        const isDirectMessage = sourceChannelId.startsWith("D");
+        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
+        this.logToFile(sourceChannelId, {
+            date: createdAt.toISOString(),
+            ts: eventTs,
+            user: payload.user_id,
+            userName,
+            text: commandText,
+            attachments: [],
+            isBot: false,
+        });
+        const event = {
+            type: isDirectMessage ? "dm" : "private_command",
+            conversationId: sourceChannelId,
+            conversationKind: isDirectMessage ? "direct" : "shared",
+            ts: eventTs,
+            user: payload.user_id,
+            text: commandText,
+            attachments: [],
+            sessionKey: sourceChannelId,
+        };
+        const adapters = this.createCommandAdapters(sourceChannelId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? {} : { ephemeralChannelId: sourceChannelId });
+        await this.handler.handleEvent(event, this, adapters);
+    }
+    async routeSlashNewCommand(payload) {
+        const conversationId = payload.channel_id;
+        if (!conversationId.startsWith("D")) {
+            await this.postEphemeral(conversationId, payload.user_id, `為了避免誤清除共享上下文，${payload.command} 目前只能在與 ${PRODUCT_NAME} 的私訊中使用。`);
+            return;
+        }
+        const createdAt = new Date();
+        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
+        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
+        this.logToFile(conversationId, {
+            date: createdAt.toISOString(),
+            ts: eventTs,
+            user: payload.user_id,
+            userName,
+            text: payload.command,
+            attachments: [],
+            isBot: false,
+        });
+        const commandBot = this.createSlashCommandBot(conversationId);
+        await this.handler.handleNewCommand(conversationId, conversationId, commandBot);
+    }
+    async routeSlashModelCommand(payload) {
+        const conversationId = payload.channel_id;
+        const isDirectMessage = conversationId.startsWith("D");
+        const createdAt = new Date();
+        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
+        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
+        const commandSuffix = payload.text?.trim();
+        const commandText = commandSuffix ? `${payload.command} ${commandSuffix}` : payload.command;
+        this.logToFile(conversationId, {
+            date: createdAt.toISOString(),
+            ts: eventTs,
+            user: payload.user_id,
+            userName,
+            text: commandText,
+            attachments: [],
+            isBot: false,
+        });
+        const sessionKey = conversationId;
+        const event = {
+            type: isDirectMessage ? "dm" : "mention",
+            conversationId,
+            conversationKind: isDirectMessage ? "direct" : "shared",
+            ts: eventTs,
+            user: payload.user_id,
+            text: commandText,
+            attachments: [],
+            sessionKey,
+        };
+        const adapters = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? {} : { ephemeralChannelId: conversationId });
+        await this.handler.handleEvent(event, this, adapters);
+    }
+    async routeSlashSandboxCommand(payload) {
+        await this.routeSlashModelCommand(payload);
+    }
+    async routeSlashAutoReplyCommand(payload) {
+        await this.routeSlashModelCommand(payload);
+    }
+    async routeSlashSessionCommand(payload) {
+        const conversationId = payload.channel_id;
+        const isDirectMessage = conversationId.startsWith("D");
+        const createdAt = new Date();
+        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
+        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
+        const commandText = payload.command;
+        this.logToFile(conversationId, {
+            date: createdAt.toISOString(),
+            ts: eventTs,
+            user: payload.user_id,
+            userName,
+            text: commandText,
+            attachments: [],
+            isBot: false,
+            threadTs: payload.thread_ts,
+        });
+        const sessionKey = resolveSlackSessionKey(conversationId, payload.thread_ts);
+        const event = {
+            type: isDirectMessage ? "dm" : "mention",
+            conversationId,
+            conversationKind: isDirectMessage ? "direct" : "shared",
+            ts: eventTs,
+            user: payload.user_id,
+            text: commandText,
+            attachments: [],
+            thread_ts: payload.thread_ts,
+            sessionKey,
+        };
+        const adapters = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage
+            ? { threadTs: payload.thread_ts }
+            : { ephemeralChannelId: conversationId, threadTs: payload.thread_ts });
+        await this.handler.handleEvent(event, this, adapters);
+    }
+    setupEventHandlers() {
+        this.socketClient.on("disconnect", (err) => {
+            log.logWarning("Slack socket disconnect", err ? String(err) : "");
+        });
+        this.socketClient.on("error", (err) => {
+            log.logWarning("Slack socket error", err ? String(err) : "");
+        });
+        this.socketClient.on("unable_to_socket_mode_start", (err) => {
+            log.logWarning("Slack socket unable_to_start", err ? String(err) : "");
+        });
+        // Channel @mentions
+        this.socketClient.on("app_mention", ({ event, ack }) => {
+            const e = event;
+            // Skip DMs (handled by message event)
+            if (e.channel.startsWith("D")) {
+                ack();
+                return;
+            }
+            // Top-level mentions use a persistent channel session.
+            // Thread replies get their own isolated session (channelId:thread_ts).
+            const sessionKey = resolveSlackSessionKey(e.channel, e.thread_ts);
+            const slackEvent = {
+                type: "mention",
+                conversationId: e.channel,
+                conversationKind: "shared",
+                channel: e.channel,
+                ts: e.ts,
+                thread_ts: e.thread_ts,
+                user: e.user,
+                text: this.stripOwnMention(e.text),
+                files: e.files,
+                sessionKey,
+            };
+            const attachmentsPromise = this.logUserMessage(slackEvent);
+            // Only trigger processing for messages AFTER startup (not replayed old messages)
+            if (this.startupTs && e.ts < this.startupTs) {
+                log.logInfo(`[${e.channel}] Logged old message (pre-startup), not triggering: ${slackEvent.text.substring(0, 30)}`);
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
+                ack();
+                return;
+            }
+            // Check for stop command - execute immediately, don't queue!
+            if (this.isStopText(slackEvent.text)) {
+                const stopTarget = this.resolveStopTarget(e.channel, e.thread_ts);
+                if (stopTarget) {
+                    this.handler.handleStop(stopTarget, e.channel, this);
+                }
+                else {
+                    this.postMessage(e.channel, formatNothingRunning("slack"));
+                }
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
+                ack();
+                return;
+            }
+            this.getQueue(this.resolveQueueKey(e.channel, sessionKey)).enqueue(async () => {
+                slackEvent.attachments = await attachmentsPromise;
+                const adapters = createSlackAdapters(slackEvent, this);
+                return this.handler.handleEvent(slackEvent, this, adapters);
+            });
+            ack();
+        });
+        // All messages (for logging) + DMs (for triggering)
+        this.socketClient.on("message", ({ event, ack }) => {
+            const e = event;
+            const hasFiles = !!e.files && e.files.length > 0;
+            const hasSlackContent = !!e.text || hasFiles || !!e.blocks?.length || !!e.attachments?.length;
+            const isOwnBotMessage = (!!e.user && e.user === this.botUserId) || (!!this.botId && e.bot_id === this.botId);
+            if (isOwnBotMessage) {
+                ack();
+                return;
+            }
+            const isExternalBotMessage = !!e.bot_id || e.subtype === "bot_message";
+            if (isExternalBotMessage) {
+                if (e.subtype !== undefined && e.subtype !== "bot_message" && e.subtype !== "file_share") {
+                    ack();
+                    return;
+                }
+                if (!hasSlackContent) {
+                    ack();
+                    return;
+                }
+                void this.logExternalBotMessage(e).catch((err) => {
+                    log.logWarning("Failed to log Slack bot message", String(err));
+                });
+                ack();
+                return;
+            }
+            if (!e.user) {
+                ack();
+                return;
+            }
+            if (e.subtype !== undefined && e.subtype !== "file_share") {
+                ack();
+                return;
+            }
+            if (!hasSlackContent) {
+                ack();
+                return;
+            }
+            const isDM = e.channel_type === "im";
+            const conversationKind = isDM ? "direct" : "shared";
+            const isBotMention = e.text?.includes(`<@${this.botUserId}>`);
+            // Skip channel @mentions - already handled by app_mention event
+            if (!isDM && isBotMention) {
+                ack();
+                return;
+            }
+            const isSharedThreadReply = !isDM && this.shouldTriggerSharedThreadReply(e.channel, e.thread_ts);
+            const sessionKey = isDM || isSharedThreadReply ? resolveSlackSessionKey(e.channel, e.thread_ts) : undefined;
+            const slackEvent = {
+                type: isDM ? "dm" : "mention",
+                conversationId: e.channel,
+                conversationKind,
+                channel: e.channel,
+                ts: e.ts,
+                thread_ts: e.thread_ts,
+                user: e.user,
+                text: this.stripOwnMention(e.text),
+                files: e.files,
+                sessionKey,
+            };
+            const attachmentsPromise = this.logUserMessage(slackEvent);
+            // Only trigger processing for messages AFTER startup (not replayed old messages)
+            if (this.startupTs && e.ts < this.startupTs) {
+                log.logInfo(`[${e.channel}] Skipping old message (pre-startup): ${slackEvent.text.substring(0, 30)}`);
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
+                ack();
+                return;
+            }
+            // Stop command for DM or shared-channel thread reply (app_mention handles "@mikan stop").
+            if ((isDM || (!isDM && e.thread_ts)) && this.isStopText(slackEvent.text)) {
+                const stopTarget = this.resolveStopTarget(e.channel, e.thread_ts);
+                if (stopTarget) {
+                    this.handler.handleStop(stopTarget, e.channel, this);
+                }
+                else {
+                    this.postMessage(e.channel, formatNothingRunning("slack"));
+                }
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
+                ack();
+                return;
+            }
+            const enqueueTriggered = () => {
+                const activeSessionKey = slackEvent.sessionKey ?? resolveSlackSessionKey(e.channel, e.thread_ts);
+                // Auto-reply top-level channel messages start with no sessionKey because
+                // they are only candidates until the policy allows them. Once triggered,
+                // persist the resolved key on the event; otherwise the runtime fallback
+                // treats the message ts as a branch session (`channel:ts`) instead of the
+                // persistent top-level channel session.
+                slackEvent.sessionKey = activeSessionKey;
+                this.getQueue(this.resolveQueueKey(e.channel, activeSessionKey)).enqueue(async () => {
+                    slackEvent.attachments = await attachmentsPromise;
+                    const adapters = createSlackAdapters(slackEvent, this);
+                    return this.handler.handleEvent(slackEvent, this, adapters);
+                });
+            };
+            const logOnly = () => {
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
+            };
+            if (isDM || isSharedThreadReply) {
+                enqueueTriggered();
+                ack();
+                return;
+            }
+            // Shared-channel non-mention, non-thread: gate via auto-reply policy.
+            // evaluateAutoReplyPolicy never throws — judge errors/timeouts surface as
+            // trigger:false with a distinct reason, and the user message has already
+            // been queued for logging via logUserMessage above.
+            evaluateAutoReplyPolicy({
+                event: slackEvent,
+                workingDir: this.workingDir,
+            }).then((triggerResult) => {
+                if (triggerResult.trigger)
+                    enqueueTriggered();
+                else
+                    logOnly();
+            });
+            ack();
+        });
+        this.socketClient.on("slash_commands", async ({ body, ack }) => {
+            const payload = body;
+            await ack();
+            if (!payload.command || !payload.channel_id || !payload.user_id) {
+                return;
+            }
+            const handlerPromise = payload.command === "/pi-login"
+                ? this.routeSlashLoginCommand({
+                    command: payload.command,
+                    text: payload.text,
+                    channel_id: payload.channel_id,
+                    user_id: payload.user_id,
+                    user_name: payload.user_name,
+                })
+                : payload.command === "/pi-new"
+                    ? this.routeSlashNewCommand({
+                        command: payload.command,
+                        channel_id: payload.channel_id,
+                        user_id: payload.user_id,
+                        user_name: payload.user_name,
+                    })
+                    : payload.command === "/pi-session"
+                        ? this.routeSlashSessionCommand({
+                            command: payload.command,
+                            channel_id: payload.channel_id,
+                            user_id: payload.user_id,
+                            user_name: payload.user_name,
+                            thread_ts: payload.thread_ts,
+                        })
+                        : payload.command === "/pi-model"
+                            ? this.routeSlashModelCommand({
+                                command: payload.command,
+                                text: payload.text,
+                                channel_id: payload.channel_id,
+                                user_id: payload.user_id,
+                                user_name: payload.user_name,
+                            })
+                            : payload.command === "/pi-sandbox"
+                                ? this.routeSlashSandboxCommand({
+                                    command: payload.command,
+                                    text: payload.text,
+                                    channel_id: payload.channel_id,
+                                    user_id: payload.user_id,
+                                    user_name: payload.user_name,
+                                })
+                                : payload.command === "/pi-auto-reply"
+                                    ? this.routeSlashAutoReplyCommand({
+                                        command: payload.command,
+                                        text: payload.text,
+                                        channel_id: payload.channel_id,
+                                        user_id: payload.user_id,
+                                        user_name: payload.user_name,
+                                    })
+                                    : null;
+            if (!handlerPromise) {
+                return;
+            }
+            handlerPromise.catch((err) => {
+                log.logWarning("Slack slash command error", err instanceof Error ? err.message : String(err));
+            });
+        });
+        // App Home tab
+        this.socketClient.on("app_home_opened", ({ event, ack }) => {
+            const e = event;
+            ack();
+            if (e.tab !== "home")
+                return;
+            this.webClient.views
+                .publish({
+                user_id: e.user,
+                view: this.buildHomeView(),
+            })
+                .catch((err) => {
+                log.logWarning(`Failed to publish App Home view`, String(err));
+            });
+        });
+        // Handle button clicks (Force Stop)
+        this.socketClient.on("block_actions", async ({ body, ack }) => {
+            const action = body.actions?.[0];
+            if (!action || !action.action_id?.startsWith("force_stop_")) {
+                ack();
+                return;
+            }
+            ack();
+            const sessionKey = action.action_id.replace("force_stop_", "").replace(/_/g, ":");
+            const userId = body.user?.id;
+            const channelId = body.container?.channel_id || sessionKey.split(":")[0];
+            log.logInfo(`[Force Stop] User ${userId} requested force stop for ${sessionKey}`);
+            // Use handler's forceStop method
+            this.handler.forceStop(sessionKey);
+            // Notify in channel
+            await this.postMessage(channelId, formatForceStopped("slack", userId ?? "unknown"));
+            // Refresh home tab
+            if (userId) {
+                this.webClient.views
+                    .publish({
+                    user_id: userId,
+                    view: this.buildHomeView(),
+                })
+                    .catch((err) => {
+                    log.logWarning(`Failed to refresh App Home view`, String(err));
+                });
+            }
+        });
+    }
+    /**
+     * Log a user message to log.jsonl after attachments are ready.
+     */
+    async logUserMessage(event) {
+        const user = this.users.get(event.user);
+        let attachments = [];
+        let attachmentError;
+        if (event.files) {
+            try {
+                attachments = await this.store.processAttachments(event.channel, event.files, event.ts);
+            }
+            catch (err) {
+                attachmentError = err;
+            }
+        }
+        // Always write the text log, even if attachment processing failed — we want
+        // a record of the user message regardless of file-handling errors.
+        this.logToFile(event.channel, {
+            date: new Date(parseFloat(event.ts) * 1000).toISOString(),
+            ts: event.ts,
+            threadTs: event.thread_ts,
+            user: event.user,
+            userName: user?.userName,
+            displayName: user?.displayName,
+            text: event.text,
+            attachments,
+            isBot: false,
+        });
+        if (attachmentError)
+            throw attachmentError;
+        return attachments;
+    }
+    async logExternalBotMessage(event) {
+        const attachments = event.files
+            ? await this.store.processAttachments(event.channel, event.files, event.ts)
+            : [];
+        const botName = event.username ?? event.bot_profile?.name ?? event.bot_profile?.real_name ?? event.bot_id;
+        this.logToFile(event.channel, {
+            date: new Date(parseFloat(event.ts) * 1000).toISOString(),
+            ts: event.ts,
+            threadTs: event.thread_ts,
+            user: event.bot_id ? `bot:${event.bot_id}` : "external-bot",
+            userName: botName,
+            displayName: botName,
+            text: buildSlackAppMessageText(event),
+            attachments,
+            isBot: true,
+            botId: event.bot_id,
+            appId: event.app_id ?? event.bot_profile?.app_id,
+            subtype: event.subtype,
+        });
+        return attachments;
+    }
+    // ==========================================================================
+    // Private - Backfill
+    // ==========================================================================
+    async getExistingTimestamps(channelId) {
+        const logPath = join(this.workingDir, channelId, "log.jsonl");
+        const timestamps = new Set();
+        if (!existsSync(logPath))
+            return timestamps;
+        const content = await readFile(logPath, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        for (let i = 0; i < lines.length; i++) {
+            try {
+                const entry = JSON.parse(lines[i]);
+                if (entry.ts)
+                    timestamps.add(entry.ts);
+            }
+            catch (err) {
+                log.logWarning(`Skipping malformed log entry at ${logPath}:${i + 1}`, err instanceof Error ? err.message : String(err));
+            }
+        }
+        return timestamps;
+    }
+    async backfillChannel(channelId, upperBoundTs) {
+        const existingTs = await this.getExistingTimestamps(channelId);
+        // Find the biggest ts in log.jsonl
+        let lastLoggedTs;
+        for (const ts of existingTs) {
+            if (!lastLoggedTs || parseFloat(ts) > parseFloat(lastLoggedTs))
+                lastLoggedTs = ts;
+        }
+        const allMessages = [];
+        let cursor;
+        let pageCount = 0;
+        const maxPages = 3;
+        do {
+            const result = await this.webClient.conversations.history({
+                channel: channelId,
+                oldest: lastLoggedTs, // Only fetch messages newer than what we have
+                latest: upperBoundTs, // Do not race live socket events after startup
+                inclusive: false,
+                limit: 1000,
+                cursor,
+            });
+            if (result.messages) {
+                allMessages.push(...result.messages);
+            }
+            cursor = result.response_metadata?.next_cursor;
+            pageCount++;
+        } while (cursor && pageCount < maxPages);
+        // Filter: include mikan's messages, external app/bot messages, and user messages.
+        const relevantMessages = allMessages.filter((msg) => {
+            if (!msg.ts || existingTs.has(msg.ts))
+                return false; // Skip duplicates
+            if (msg.user === this.botUserId)
+                return true;
+            const isExternalBotMessage = !!msg.bot_id || msg.subtype === "bot_message";
+            if (isExternalBotMessage) {
+                if (this.botId && msg.bot_id === this.botId)
+                    return false;
+                if (msg.subtype !== undefined &&
+                    msg.subtype !== "bot_message" &&
+                    msg.subtype !== "file_share") {
+                    return false;
+                }
+                return (!!msg.text ||
+                    !!(msg.files && msg.files.length > 0) ||
+                    !!msg.blocks?.length ||
+                    !!msg.attachments?.length);
+            }
+            if (msg.subtype !== undefined && msg.subtype !== "file_share")
+                return false;
+            if (!msg.user)
+                return false;
+            if (!msg.text && (!msg.files || msg.files.length === 0))
+                return false;
+            return true;
+        });
+        // Reverse to chronological order
+        relevantMessages.reverse();
+        // Log each message to log.jsonl
+        for (const msg of relevantMessages) {
+            const isMikanMessage = msg.user === this.botUserId;
+            const isExternalBotMessage = !isMikanMessage && (!!msg.bot_id || msg.subtype === "bot_message");
+            if (isExternalBotMessage) {
+                await this.logExternalBotMessage({ ...msg, channel: channelId, ts: msg.ts });
+                continue;
+            }
+            const user = this.users.get(msg.user);
+            const text = this.stripOwnMention(msg.text);
+            const attachments = msg.files
+                ? await this.store.processAttachments(channelId, msg.files, msg.ts)
+                : [];
+            this.logToFile(channelId, {
+                date: new Date(parseFloat(msg.ts) * 1000).toISOString(),
+                ts: msg.ts,
+                threadTs: msg.thread_ts,
+                user: isMikanMessage ? "bot" : msg.user,
+                userName: isMikanMessage ? undefined : user?.userName,
+                displayName: isMikanMessage ? undefined : user?.displayName,
+                text,
+                attachments,
+                isBot: isMikanMessage,
+            });
+        }
+        return relevantMessages.length;
+    }
+    async backfillAllChannels(upperBoundTs) {
+        const startTime = Date.now();
+        // Only backfill channels that already have a log.jsonl (mikan has interacted with them before)
+        const channelsToBackfill = [];
+        for (const [channelId, channel] of this.channels) {
+            const logPath = join(this.workingDir, channelId, "log.jsonl");
+            if (existsSync(logPath)) {
+                channelsToBackfill.push([channelId, channel]);
+            }
+        }
+        log.logBackfillStart(channelsToBackfill.length);
+        let totalMessages = 0;
+        for (const [channelId, channel] of channelsToBackfill) {
+            try {
+                const count = await this.backfillChannel(channelId, upperBoundTs);
+                if (count > 0)
+                    log.logBackfillChannel(channel.name, count);
+                totalMessages += count;
+            }
+            catch (error) {
+                log.logWarning(`Failed to backfill #${channel.name}`, String(error));
+            }
+            // Add delay between channels to avoid hitting Slack rate limits
+            if (channelId !== channelsToBackfill[channelsToBackfill.length - 1][0]) {
+                await new Promise((resolve) => setTimeout(resolve, 500));
+            }
+        }
+        const durationMs = Date.now() - startTime;
+        log.logBackfillComplete(totalMessages, durationMs);
+    }
+    // ==========================================================================
+    // Private - Fetch Users/Channels
+    // ==========================================================================
+    async fetchUsers() {
+        let cursor;
+        do {
+            const result = await this.webClient.users.list({ limit: 200, cursor });
+            const members = result.members;
+            if (members) {
+                for (const u of members) {
+                    if (u.id && u.name && !u.deleted) {
+                        this.users.set(u.id, {
+                            id: u.id,
+                            userName: u.name,
+                            displayName: u.real_name || u.name,
+                        });
+                    }
+                }
+            }
+            cursor = result.response_metadata?.next_cursor;
+        } while (cursor);
+    }
+    async fetchChannels() {
+        // Fetch public/private channels
+        let cursor;
+        do {
+            const result = await this.webClient.conversations.list({
+                types: "public_channel,private_channel",
+                exclude_archived: true,
+                limit: 200,
+                cursor,
+            });
+            const channels = result.channels;
+            if (channels) {
+                for (const c of channels) {
+                    if (c.id && c.name && c.is_member) {
+                        this.channels.set(c.id, { id: c.id, name: c.name });
+                    }
+                }
+            }
+            cursor = result.response_metadata?.next_cursor;
+        } while (cursor);
+        // Also fetch DM channels (IMs)
+        cursor = undefined;
+        do {
+            const result = await this.webClient.conversations.list({
+                types: "im",
+                limit: 200,
+                cursor,
+            });
+            const ims = result.channels;
+            if (ims) {
+                for (const im of ims) {
+                    if (im.id) {
+                        // Use user's name as channel name for DMs
+                        const user = im.user ? this.users.get(im.user) : undefined;
+                        const name = user ? `DM:${user.userName}` : `DM:${im.id}`;
+                        this.channels.set(im.id, { id: im.id, name });
+                    }
+                }
+            }
+            cursor = result.response_metadata?.next_cursor;
+        } while (cursor);
+    }
+}
+//# sourceMappingURL=bot.js.map