@geminixiang/mikan 1.0.0-beta.53 → 1.0.0-beta.55

package/dist/adapters/slack/bot.js

@@ -5,24 +5,35 @@ import { readFile, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { createConversationEvent, createConversationMessage, } from "../../adapter.js";
 import { createOfficeAddress } from "../../office/index.js";
-import { COMMAND_MANIFEST } from "../../commands/manifest.js";
+import { COMMAND_MANIFEST } from "../commands/manifest.js";
 import { resolveConversationSettings } from "../../config.js";
 import * as log from "../../log.js";
-import { isRecord, readTextFileIfExists } from "../../utils/file-guards.js";
+import { isRecord, readTextFileIfExists } from "../../file-guards.js";
 import { PRODUCT_NAME, formatForceStopped } from "../../platform-messages.js";
 import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, MessagingIntakeTracker, saveIncomingAttachments, withRetry, } from "../shared.js";
 import { processMessageIntake } from "../intake.js";
-import { recordPlatformChannelKind, } from "../../workspace-projection/index.js";
+import { recordPlatformChannelKind } from "../../office/projection.js";
 import { AssistantThreadRegistry, handleAgentContextChanged, handleAgentDmOpened, handleAssistantThreadStarted, titleAssistantThread, } from "./assistant.js";
 import { createSlackAdapters } from "./context.js";
 import { hasMaterializedChatSession, registerThreadSession, } from "../../sessions/chat-history-sync.js";
 import { conversationIdOf } from "../../sessions/session-key.js";
 import { isSlackThreadSessionKey, planSlackAdapterSession, planSlackEventAnchorRun, resolveSlackSessionKey, } from "./session.js";
-import { reportUserFacingError } from "../../observability/sentry.js";
+import { reportUserFacingError } from "../../observability/index.js";
 import { recordSlackUpdate } from "./update-diagnostics.js";
 import { renderSlackBlocks, resolveSlackMentions } from "./blocks.js";
 import { StreamStartLimiter } from "./stream-limits.js";
 const SLACK_EVENT_ANCHOR_TEXT = "Working on it...";
+function hasMessageContent(message, includeBlocks = true) {
+    const content = [message.text, message.files];
+    if (includeBlocks)
+        content.push(message.blocks, message.attachments);
+    return content.some((part) => !!part?.length);
+}
+function hasBotIdentity(message) {
+    return !!message.bot_id || message.subtype === "bot_message";
+}
+const USER_MESSAGE_SUBTYPES = new Set([undefined, "file_share"]);
+const BOT_MESSAGE_SUBTYPES = new Set([...USER_MESSAGE_SUBTYPES, "bot_message"]);
 /**
  * Slack's per-call limit on `markdown_text`: "Limit this field to 12,000
  * characters." mikan allows far more in a message, so streamed text is split
@@ -124,6 +135,7 @@ export class SlackMessagingBot {
         });
     }
     constructor(handler, config) {
+        this.statusUpdates = new Map();
         this.botUserId = null;
         this.botId = null;
         this.teamId = null;
@@ -154,6 +166,11 @@ export class SlackMessagingBot {
             clientPingTimeout: 12_000,
         });
         this.webClient = new WebClient(config.botToken);
+        this.statusClient = new WebClient(config.botToken, {
+            timeout: 3000,
+            retryConfig: { retries: 0 },
+            rejectRateLimitedCalls: true,
+        });
     }
     setEventsWatcher(watcher) {
         this.eventsWatcher = watcher;
@@ -221,9 +238,13 @@ export class SlackMessagingBot {
     resolveMentions(text) {
         return resolveSlackMentions(text, this.users.values());
     }
-    async postMessage(channel, text) {
+    async postMessage(channel, text, threadTs) {
         return slackRetry(async () => {
-            const payload = { channel, ...renderSlackBlocks(this.resolveMentions(text)) };
+            const payload = {
+                channel,
+                ...(threadTs !== undefined ? { thread_ts: threadTs } : {}),
+                ...renderSlackBlocks(this.resolveMentions(text)),
+            };
             const result = await this.webClient.chat.postMessage(payload);
             return result.ts;
         });
@@ -243,30 +264,28 @@ export class SlackMessagingBot {
             }
         });
     }
-    async postEphemeral(channel, user, text, threadTs) {
+    async postEphemeral(channel, user, text, threadTs, blocks) {
         return slackRetry(async () => {
             await this.webClient.chat.postEphemeral({
                 channel,
                 user,
                 text,
+                ...(blocks !== undefined ? { blocks: blocks } : {}),
                 ...(threadTs ? { thread_ts: threadTs } : {}),
             });
         });
     }
     async postEphemeralBlocks(channel, user, text, blocks, threadTs) {
+        return this.postEphemeral(channel, user, text, threadTs, blocks);
+    }
+    async postMessageBlocks(channel, text, blocks, threadTs) {
         return slackRetry(async () => {
-            await this.webClient.chat.postEphemeral({
+            const payload = {
                 channel,
-                user,
                 text,
                 blocks: blocks,
-                ...(threadTs ? { thread_ts: threadTs } : {}),
-            });
-        });
-    }
-    async postMessageBlocks(channel, text, blocks) {
-        return slackRetry(async () => {
-            const payload = { channel, text, blocks: blocks };
+                ...(threadTs !== undefined ? { thread_ts: threadTs } : {}),
+            };
             const result = await this.webClient.chat.postMessage(payload);
             return result.ts;
         });
@@ -442,13 +461,25 @@ export class SlackMessagingBot {
     // ==========================================================================
     /** Set the status for an assistant thread (shows "thinking" state) */
     async setAssistantStatus(channel, threadTs, status) {
-        return slackRetry(async () => {
-            await this.webClient.assistant.threads.setStatus({
+        const key = `${channel}:${threadTs}`;
+        const previous = this.statusUpdates.get(key) ?? Promise.resolve();
+        const update = previous
+            .catch(() => undefined)
+            .then(async () => {
+            await this.statusClient.assistant.threads.setStatus({
                 channel_id: channel,
                 thread_ts: threadTs,
                 status,
             });
         });
+        this.statusUpdates.set(key, update);
+        try {
+            await update;
+        }
+        finally {
+            if (this.statusUpdates.get(key) === update)
+                this.statusUpdates.delete(key);
+        }
     }
     /** Offer starting points in a new assistant thread. */
     async setAssistantSuggestedPrompts(channel, threadTs, prompts) {
@@ -514,27 +545,10 @@ export class SlackMessagingBot {
         }
     }
     async postInThread(channel, threadTs, text) {
-        return slackRetry(async () => {
-            const payload = {
-                channel,
-                thread_ts: threadTs,
-                ...renderSlackBlocks(this.resolveMentions(text)),
-            };
-            const result = await this.webClient.chat.postMessage(payload);
-            return result.ts;
-        });
+        return this.postMessage(channel, text, threadTs);
     }
     async postInThreadBlocks(channel, threadTs, text, blocks) {
-        return slackRetry(async () => {
-            const payload = {
-                channel,
-                thread_ts: threadTs,
-                text, // fallback for notifications
-                blocks: blocks,
-            };
-            const result = await this.webClient.chat.postMessage(payload);
-            return result.ts;
-        });
+        return this.postMessageBlocks(channel, text, blocks, threadTs);
     }
     async uploadFile(channel, filePath, title, threadTs) {
         return slackRetry(async () => {
@@ -745,8 +759,7 @@ export class SlackMessagingBot {
         };
         return processMessageIntake({
             eventBase: options.event,
-            office: this.workspace.office(options.event.address),
-            isAutoReplyCandidate: options.isAutoReplyCandidate,
+            addressed: options.addressed,
             magicWord: { addressed: options.addressed, scopeFallback: "top-level" },
             busyPolicy: "queue",
             logEntryBase: {},
@@ -903,29 +916,22 @@ export class SlackMessagingBot {
             text,
             attachments: [],
         });
-        const respond = async (responseText) => {
+        const respond = async (responseText, blocks) => {
             if (options.ephemeralChannelId) {
-                await this.postEphemeral(options.ephemeralChannelId, userId, responseText, options.threadTs);
+                await this.postEphemeral(options.ephemeralChannelId, userId, responseText, options.threadTs, blocks);
                 return;
             }
-            const messageTs = await this.postMessage(conversationId, responseText);
-            this.logBotResponse(conversationId, responseText, messageTs);
-        };
-        const respondMuted = async (responseText) => {
-            const blocks = [buildMrkdwnContextBlock(responseText)];
-            if (options.ephemeralChannelId) {
-                await this.postEphemeralBlocks(options.ephemeralChannelId, userId, responseText, blocks, options.threadTs);
-                return;
-            }
-            const messageTs = await this.postMessageBlocks(conversationId, responseText, blocks);
+            const messageTs = blocks
+                ? await this.postMessageBlocks(conversationId, responseText, blocks)
+                : await this.postMessage(conversationId, responseText);
             this.logBotResponse(conversationId, responseText, messageTs);
         };
         const responder = {
             respond,
-            replaceResponse: respond,
+            replaceResponse: (responseText) => respond(responseText),
             respondDiagnostic: async (responseText, responseOptions) => {
                 if (responseOptions?.style === "muted") {
-                    await respondMuted(responseText);
+                    await respond(responseText, [buildMrkdwnContextBlock(responseText)]);
                     return;
                 }
                 await respond(responseOptions?.style === "error" ? `_${responseText}_` : responseText);
@@ -1094,17 +1100,13 @@ export class SlackMessagingBot {
             event: slackEvent,
             attachmentsPromise,
             queueKey: this.resolveQueueKey(e.channel, sessionKey),
-            isAutoReplyCandidate: false,
             addressed: true,
         });
         ack();
         await intake;
     }
     admitHumanMessage(event, ack) {
-        const hasSlackContent = !!event.text ||
-            !!event.files?.length ||
-            !!event.blocks?.length ||
-            !!event.attachments?.length;
+        const hasSlackContent = hasMessageContent(event);
         const isOwnMessage = event.user === this.botUserId || (!!this.botId && event.bot_id === this.botId);
         if (isOwnMessage) {
             ack();
@@ -1115,9 +1117,7 @@ export class SlackMessagingBot {
         const authorIsKnownHuman = !!event.user && this.users.get(event.user)?.isBot === false;
         const isExternalMessage = event.subtype === "bot_message" || (!!event.bot_id && !authorIsKnownHuman);
         if (isExternalMessage) {
-            const supportedSubtype = event.subtype === undefined ||
-                event.subtype === "bot_message" ||
-                event.subtype === "file_share";
+            const supportedSubtype = BOT_MESSAGE_SUBTYPES.has(event.subtype);
             if (supportedSubtype && hasSlackContent) {
                 void this.logExternalMessagingBotMessage(event).catch((err) => {
                     log.logWarning("Failed to log Slack bot message", String(err));
@@ -1126,9 +1126,7 @@ export class SlackMessagingBot {
             ack();
             return false;
         }
-        const isSupportedUserMessage = !!event.user &&
-            (event.subtype === undefined || event.subtype === "file_share") &&
-            hasSlackContent;
+        const isSupportedUserMessage = !!event.user && USER_MESSAGE_SUBTYPES.has(event.subtype) && hasSlackContent;
         if (isSupportedUserMessage)
             return true;
         ack();
@@ -1140,8 +1138,8 @@ export class SlackMessagingBot {
             return;
         // message.im normally carries channel_type "im", but fall back to the
         // D-prefix convention (used by handleAppMention and session keys) so a
-        // missing channel_type cannot silently demote a DM to an auto-reply
-        // candidate that never triggers.
+        // missing channel_type cannot silently classify a DM as an unaddressed
+        // channel message that never triggers.
         const isDM = e.channel_type === "im" || e.channel.startsWith("D");
         const conversationKind = isDM ? "direct" : "shared";
         const isMessagingBotMention = e.text?.includes(`<@${this.botUserId}>`);
@@ -1199,7 +1197,6 @@ export class SlackMessagingBot {
             event: slackEvent,
             attachmentsPromise,
             queueKey: this.resolveQueueKey(e.channel, activeSessionKey),
-            isAutoReplyCandidate: !isDM,
             addressed: isDM,
         });
         ack();
@@ -1486,6 +1483,19 @@ export class SlackMessagingBot {
         }
         return timestamps;
     }
+    isBackfillableMessage(message) {
+        if (message.user === this.botUserId)
+            return true;
+        if (hasBotIdentity(message)) {
+            if (this.botId && message.bot_id === this.botId)
+                return false;
+            return BOT_MESSAGE_SUBTYPES.has(message.subtype) && hasMessageContent(message);
+        }
+        // Unlike live intake, historical human posts need text or files, not just blocks.
+        return (!!message.user &&
+            USER_MESSAGE_SUBTYPES.has(message.subtype) &&
+            hasMessageContent(message, false));
+    }
     async backfillChannel(channelId, upperBoundTs) {
         const existingTs = await this.getExistingTimestamps(channelId);
         // Find the biggest ts in log.jsonl
@@ -1517,36 +1527,14 @@ export class SlackMessagingBot {
         const relevantMessages = allMessages.filter((msg) => {
             if (!msg.ts || existingTs.has(msg.ts))
                 return false; // Skip duplicates
-            if (msg.user === this.botUserId)
-                return true;
-            const isExternalMessagingBotMessage = !!msg.bot_id || msg.subtype === "bot_message";
-            if (isExternalMessagingBotMessage) {
-                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;
+            return this.isBackfillableMessage(msg);
         });
         // Reverse to chronological order
         relevantMessages.reverse();
         // Log each message to log.jsonl
         for (const msg of relevantMessages) {
             const isMikanMessage = msg.user === this.botUserId;
-            const isExternalMessagingBotMessage = !isMikanMessage && (!!msg.bot_id || msg.subtype === "bot_message");
+            const isExternalMessagingBotMessage = !isMikanMessage && hasBotIdentity(msg);
             if (isExternalMessagingBotMessage) {
                 await this.logExternalMessagingBotMessage({ ...msg, channel: channelId, ts: msg.ts });
                 continue;
@@ -1608,17 +1596,15 @@ export class SlackMessagingBot {
         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,
-                            isBot: !!u.is_bot,
-                        });
-                    }
-                }
+            for (const u of members ?? []) {
+                if (!u.id || !u.name || u.deleted)
+                    continue;
+                this.users.set(u.id, {
+                    id: u.id,
+                    userName: u.name,
+                    displayName: u.real_name || u.name,
+                    isBot: !!u.is_bot,
+                });
             }
             cursor = result.response_metadata?.next_cursor;
         } while (cursor);
@@ -1634,17 +1620,15 @@ export class SlackMessagingBot {
                 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,
-                            ...(typeof c.is_private === "boolean" ? { isPrivate: c.is_private } : {}),
-                            ...(c.is_shared || c.is_ext_shared ? { isExternallyShared: true } : {}),
-                        });
-                    }
-                }
+            for (const c of channels ?? []) {
+                if (!c.id || !c.name || !c.is_member)
+                    continue;
+                this.channels.set(c.id, {
+                    id: c.id,
+                    name: c.name,
+                    ...(typeof c.is_private === "boolean" ? { isPrivate: c.is_private } : {}),
+                    ...(c.is_shared || c.is_ext_shared ? { isExternallyShared: true } : {}),
+                });
             }
             cursor = result.response_metadata?.next_cursor;
         } while (cursor);
@@ -1657,15 +1641,13 @@ export class SlackMessagingBot {
                 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 });
-                    }
-                }
+            for (const im of ims ?? []) {
+                if (!im.id)
+                    continue;
+                // 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);