@geminixiang/mikan 0.3.2 → 0.4.0-beta.0

package/dist/adapters/slack/bot.js

@@ -3,14 +3,15 @@ import { WebClient } from "@slack/web-api";
 import { existsSync, readFileSync } from "fs";
 import { readFile } from "fs/promises";
 import { basename, join } from "path";
+import { resolveConversationSettings } from "../../config.js";
 import * as log from "../../log.js";
-import { PRODUCT_NAME, formatForceStopped, formatNothingRunning } from "../../ui-copy.js";
+import { PRODUCT_NAME, formatForceStopped, formatNothingRunning } from "../../platform-messages.js";
 import { appendBotResponseLog, appendChannelLog, ChannelQueue, resolveOnlyScopedStopTarget, resolveStopTarget, withRetry, } from "../shared.js";
-import { evaluateAutoReplyPolicy } from "../../trigger.js";
+import { processMessageIntake } from "../intake.js";
 import { createSlackAdapters } from "./context.js";
 import { hasMaterializedChatSession, registerThreadSession, } from "../../sessions/chat-session-manager.js";
 import { isSlackThreadSessionKey, planSlackAdapterSession, planSlackEventAnchorRun, resolveSlackSessionKey, } from "./session.js";
-import { reportUserFacingError } from "../../sentry.js";
+import { reportUserFacingError } from "../../observability/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.
@@ -53,10 +54,30 @@ function buildSlackAppMessageText(event) {
     const deduped = parts.filter((part, index) => parts.indexOf(part) === index);
     return deduped.join("\n");
 }
+// ---------------------------------------------------------------------------
+// Shared mrkdwn truncation helper
+// ---------------------------------------------------------------------------
+const MRKDWN_CONTEXT_TEXT_LIMIT = 3000;
+/**
+ * Build a Slack context block whose text is capped at the mrkdwn limit.
+ * Used for muted diagnostics and ephemeral command responses.
+ */
+export function buildMrkdwnContextBlock(text) {
+    const blockText = text.length > MRKDWN_CONTEXT_TEXT_LIMIT
+        ? text.substring(0, MRKDWN_CONTEXT_TEXT_LIMIT - 20) + "\n_(truncated)_"
+        : text;
+    return { type: "context", elements: [{ type: "mrkdwn", text: blockText }] };
+}
 // ============================================================================
 // SlackBot
 // ============================================================================
 export class SlackBot {
+    createAdapters(event) {
+        return createSlackAdapters(event, this, {
+            replyMode: resolveConversationSettings(join(this.workingDir, event.conversationId)).slack?.replyMode ??
+                "top-level",
+        });
+    }
     constructor(handler, config) {
         this.botUserId = null;
         this.botId = null;
@@ -163,16 +184,10 @@ export class SlackBot {
     }
     async postPrivateDiagnostic(conversationId, userId, text, options) {
         if (options?.style !== "muted") {
-            await this.postPrivate(conversationId, userId, options?.style === "error" ? `_${text}_` : text);
+            await this.postEphemeral(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 }] },
-        ]);
+        await this.postEphemeralBlocks(conversationId, userId, text, [buildMrkdwnContextBlock(text)]);
     }
     async openDirectMessage(userId) {
         return slackRetry(async () => {
@@ -189,6 +204,33 @@ export class SlackBot {
             await this.webClient.chat.update({ channel, ts, text });
         });
     }
+    async startMessageStream(channel, text, threadTs) {
+        return slackRetry(async () => {
+            const result = await this.webClient.apiCall("chat.startStream", {
+                channel,
+                markdown_text: text,
+                ...(threadTs ? { thread_ts: threadTs } : {}),
+            });
+            const ts = result.ts;
+            if (!ts)
+                throw new Error("Slack chat.startStream did not return ts");
+            return ts;
+        });
+    }
+    async appendMessageStream(channel, ts, text) {
+        return slackRetry(async () => {
+            await this.webClient.apiCall("chat.appendStream", {
+                channel,
+                ts,
+                markdown_text: text,
+            });
+        });
+    }
+    async stopMessageStream(channel, ts) {
+        return slackRetry(async () => {
+            await this.webClient.apiCall("chat.stopStream", { channel, ts });
+        });
+    }
     async deleteMessage(channel, ts) {
         return slackRetry(async () => {
             await this.webClient.chat.delete({ channel, ts });
@@ -353,6 +395,8 @@ export class SlackBot {
                 };
                 const adapters = createSlackAdapters(slackEvent, this, {
                     initialMessageTs: eventPlan.initialMessageTs,
+                    replyMode: resolveConversationSettings(join(this.workingDir, eventForRun.conversationId)).slack
+                        ?.replyMode ?? "top-level",
                 });
                 return this.handler.handleEvent(eventForRun, this, adapters);
             });
@@ -383,6 +427,22 @@ export class SlackBot {
             sessionKey,
         });
     }
+    processSlackMessageIntake(options) {
+        void processMessageIntake({
+            eventBase: options.event,
+            workingDir: this.workingDir,
+            isAutoReplyCandidate: options.isAutoReplyCandidate,
+            logEntryBase: {},
+            processAttachments: () => options.attachmentsPromise,
+            queueKey: options.queueKey,
+            enqueue: (queueKey, work) => this.getQueue(queueKey).enqueue(work),
+            handler: this.handler,
+            bot: this,
+            createAdapters: (event) => this.createAdapters(event),
+            onNotTriggered: options.onNotTriggered,
+            deferAttachmentsUntilRun: true,
+        });
+    }
     buildHomeView() {
         const blocks = [
             {
@@ -552,11 +612,7 @@ export class SlackBot {
             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 }] }];
+            const blocks = [buildMrkdwnContextBlock(responseText)];
             if (options.ephemeralChannelId) {
                 await this.postEphemeralBlocks(options.ephemeralChannelId, userId, responseText, blocks, options.threadTs);
                 return;
@@ -627,22 +683,6 @@ export class SlackBot {
         const adapters = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? { threadTs } : { ephemeralChannelId: conversationId, threadTs });
         return { event, adapters };
     }
-    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 { event, adapters } = this.buildSlashCommandEvent(payload, {
             type: payload.channel_id.startsWith("D") ? "dm" : "private_command",
@@ -668,19 +708,19 @@ export class SlackBot {
             attachments: [],
             isBot: false,
         });
-        const commandBot = this.createSlashCommandBot(conversationId);
+        const commandBot = {
+            start: async () => { },
+            postMessage: async (_channel, text) => this.postMessage(conversationId, text),
+            updateMessage: async (channel, ts, text) => this.updateMessage(channel, ts, text),
+            enqueueEvent: (event) => this.enqueueEvent(event),
+            getPlatformInfo: () => this.getPlatformInfo(),
+        };
         await this.handler.handleNewCommand(conversationId, conversationId, commandBot);
     }
     async routeSlashModelCommand(payload) {
         const { event, adapters } = this.buildSlashCommandEvent(payload, { includeText: true });
         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 { event, adapters } = this.buildSlashCommandEvent(payload, { thread: true });
         await this.handler.handleEvent(event, this, adapters);
@@ -754,10 +794,11 @@ export class SlackBot {
             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);
+        this.processSlackMessageIntake({
+            event: slackEvent,
+            attachmentsPromise,
+            queueKey: this.resolveQueueKey(e.channel, sessionKey),
+            isAutoReplyCandidate: false,
         });
         ack();
     }
@@ -853,10 +894,11 @@ export class SlackBot {
             // treats the message ts as a thread 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);
+            this.processSlackMessageIntake({
+                event: slackEvent,
+                attachmentsPromise,
+                queueKey: this.resolveQueueKey(e.channel, activeSessionKey),
+                isAutoReplyCandidate: false,
             });
         };
         const logOnly = () => {
@@ -874,18 +916,14 @@ export class SlackBot {
             ack();
             return;
         }
-        // Shared-channel non-mention top-level messages: 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({
+        const activeSessionKey = resolveSlackSessionKey(e.channel, e.thread_ts);
+        slackEvent.sessionKey = activeSessionKey;
+        this.processSlackMessageIntake({
             event: slackEvent,
-            workingDir: this.workingDir,
-        }).then((triggerResult) => {
-            if (triggerResult.trigger)
-                enqueueTriggered();
-            else
-                logOnly();
+            attachmentsPromise,
+            queueKey: this.resolveQueueKey(e.channel, activeSessionKey),
+            isAutoReplyCandidate: true,
+            onNotTriggered: logOnly,
         });
         ack();
     }
@@ -895,62 +933,56 @@ export class SlackBot {
         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,
-                                })
-                                : payload.command === "/pi-admin"
-                                    ? this.routeSlashAdminCommand({
-                                        command: payload.command,
-                                        channel_id: payload.channel_id,
-                                        user_id: payload.user_id,
-                                        user_name: payload.user_name,
-                                        thread_ts: payload.thread_ts,
-                                    })
-                                    : null;
+        const { command, text, channel_id, user_id, user_name, thread_ts } = payload;
+        let handlerPromise = null;
+        if (command === "/pi-login") {
+            handlerPromise = this.routeSlashLoginCommand({
+                command,
+                text,
+                channel_id,
+                user_id,
+                user_name,
+            });
+        }
+        else if (command === "/pi-new") {
+            handlerPromise = this.routeSlashNewCommand({ command, channel_id, user_id, user_name });
+        }
+        else if (command === "/pi-session") {
+            handlerPromise = this.routeSlashSessionCommand({
+                command,
+                channel_id,
+                user_id,
+                user_name,
+                thread_ts,
+            });
+        }
+        else if (command === "/pi-model") {
+            handlerPromise = this.routeSlashModelCommand({
+                command,
+                text,
+                channel_id,
+                user_id,
+                user_name,
+            });
+        }
+        else if (command === "/pi-sandbox" || command === "/pi-auto-reply") {
+            handlerPromise = this.routeSlashModelCommand({
+                command,
+                text,
+                channel_id,
+                user_id,
+                user_name,
+            });
+        }
+        else if (command === "/pi-admin") {
+            handlerPromise = this.routeSlashAdminCommand({
+                command,
+                channel_id,
+                user_id,
+                user_name,
+                thread_ts,
+            });
+        }
         if (!handlerPromise) {
             return;
         }
@@ -972,7 +1004,7 @@ export class SlackBot {
             log.logWarning(`Failed to publish App Home view`, String(err));
         });
     }
-    async handleBlockAction({ body, ack }) {
+    async handleBlockAction({ body, ack, }) {
         const action = body.actions?.[0];
         if (!action) {
             ack();
@@ -1073,7 +1105,7 @@ export class SlackBot {
                 attachments: [],
                 sessionKey,
             };
-            return this.handler.handleEvent(event, this, createSlackAdapters(slackEvent, this));
+            return this.handler.handleEvent(event, this, this.createAdapters(slackEvent));
         });
     }
     /**