@geminixiang/mikan 1.0.0-beta.45 → 1.0.0-beta.46

package/dist/adapters/slack/bot.js

@@ -1,6 +1,5 @@
 import { SocketModeClient } from "@slack/socket-mode";
 import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
-import { readEnv } from "../../env-manifest.js";
 import { existsSync, readFileSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
@@ -8,12 +7,12 @@ import { createConversationEvent, createConversationMessage, } from "../../adapt
 import { createOfficeAddress } from "../../office/index.js";
 import { COMMAND_MANIFEST } from "../../commands/manifest.js";
 import { resolveConversationSettings } from "../../config.js";
-import { parseExtActionId } from "../../harness/extensions/registry.js";
 import * as log from "../../log.js";
 import { isRecord, readTextFileIfExists } from "../../utils/file-guards.js";
 import { PRODUCT_NAME, formatForceStopped } from "../../platform-messages.js";
 import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, saveIncomingAttachments, withRetry, } from "../shared.js";
 import { processMessageIntake } from "../intake.js";
+import { recordPlatformChannelKind, } from "../../workspace-projection/index.js";
 import { AssistantThreadRegistry, handleAgentContextChanged, handleAgentDmOpened, handleAssistantThreadStarted, titleAssistantThread, } from "./assistant.js";
 import { createSlackAdapters } from "./context.js";
 import { hasMaterializedChatSession, registerThreadSession, } from "../../sessions/chat-history-sync.js";
@@ -560,7 +559,6 @@ export class SlackMessagingBot {
         return {
             name: "slack",
             trustModel: "membership",
-            bareExtensionCommands: true,
             formattingGuide: "## Slack Formatting\nWrite standard Markdown/GFM: **bold**, _italic_, ~~strike~~, `code`, fenced code blocks, [links](url), lists, and pipe tables (rendered as native Slack tables).\nDo NOT use Slack mrkdwn syntax like *single-asterisk bold* or <url|label> links.",
             channels: this.getAllChannels().map((c) => ({ id: c.id, name: c.name })),
             users: this.getAllUsers().map((u) => ({
@@ -672,7 +670,42 @@ export class SlackMessagingBot {
             sessionKey,
         });
     }
+    /**
+     * Slack's own conversation vocabulary for this channel, from the metadata
+     * fetchChannels() already loads. Externally shared channels report
+     * "external" regardless of privacy — platform-public within one workspace
+     * is the sharing condition, and a channel visible to another organization
+     * does not satisfy it. Unknown channels return undefined (never recorded,
+     * so the projection keeps its isolated default).
+     */
+    channelKindFor(channelId) {
+        if (channelId.startsWith("D"))
+            return "im";
+        const channel = this.channels.get(channelId);
+        if (!channel)
+            return undefined;
+        if (channel.name.startsWith("DM:"))
+            return "im";
+        if (channel.isExternallyShared)
+            return "external";
+        if (channel.isPrivate === true)
+            return "private_channel";
+        if (channel.isPrivate === false)
+            return "public_channel";
+        return undefined;
+    }
     processSlackMessageIntake(options) {
+        const kind = this.channelKindFor(options.event.conversationId);
+        if (kind) {
+            try {
+                recordPlatformChannelKind(this.workspace.office(options.event.address), kind);
+            }
+            catch (err) {
+                // A failed snapshot must not block the message; the projection just
+                // keeps its previous (or isolated default) posture.
+                log.logWarning("Failed to record Slack channel kind", String(err));
+            }
+        }
         const absorbAttachmentFailure = () => {
             void options.attachmentsPromise.catch((err) => {
                 log.logWarning("Failed to log Slack message", String(err));
@@ -702,22 +735,7 @@ export class SlackMessagingBot {
             absorbAttachmentFailure();
         });
     }
-    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 ---
+    appendRunningTasks(blocks) {
         const runningSessions = this.handler.getRunningSessions();
         blocks.push({ type: "divider" }, {
             type: "header",
@@ -732,67 +750,49 @@ export class SlackMessagingBot {
                 type: "context",
                 elements: [{ type: "mrkdwn", text: "_No tasks running right now._" }],
             });
+            return;
         }
-        else {
-            // Threshold for "stuck" detection (10 minutes)
-            const STUCK_THRESHOLD_MS = 10 * 60 * 1000;
-            for (const session of runningSessions) {
-                const channelId = conversationIdOf(session.sessionKey);
-                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.")
+        const stuckThresholdMs = 10 * 60 * 1000;
+        for (const session of runningSessions) {
+            const channelId = conversationIdOf(session.sessionKey);
+            const channelName = this.channels.get(channelId)?.name;
+            const elapsed = Math.floor((Date.now() - session.startedAt) / 60000);
+            const elapsedStr = elapsed < 1 ? "<1 min" : `${elapsed} min`;
+            const lastActivity = session.lastActivityAt ? Date.now() - session.lastActivityAt : 0;
+            const isStuck = lastActivity > stuckThresholdMs;
+            let statusLine = `${isStuck ? "_stuck_" : "_running_"} · ${elapsedStr}`;
+            if (session.currentTool)
+                statusLine += ` · ${session.currentTool}`;
+            if (isStuck)
+                statusLine += ` · idle ${Math.floor(lastActivity / 60000)}m`;
+            blocks.push({
+                type: "context",
+                elements: [
+                    {
+                        type: "mrkdwn",
+                        text: `*${channelName ? `#${channelName}` : channelId}* · ${statusLine}`,
+                    },
+                ],
+            });
+            if (isStuck) {
                 blocks.push({
                     type: "context",
                     elements: [
+                        { type: "mrkdwn", text: " " },
                         {
-                            type: "mrkdwn",
-                            text: `*${channelName}* · ${statusLine}`,
+                            type: "button",
+                            text: { type: "plain_text", text: "Force Stop", emoji: true },
+                            // `value` preserves the raw key; action_id is only a unique route.
+                            action_id: `force_stop_${session.sessionKey.replace(/:/g, "_")}`,
+                            value: session.sessionKey,
+                            style: "danger",
                         },
                     ],
                 });
-                // 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 },
-                                // The raw session key travels in `value` (Slack returns it
-                                // verbatim); the action_id only routes and must be unique per
-                                // view, so it carries a sanitized copy of the key. Never
-                                // decode the key from the action_id — the `:`↔`_` rewrite is
-                                // irreversible for conversation ids that contain `_` (GitHub's
-                                // GH_owner_repo_number do, by design).
-                                action_id: `force_stop_${session.sessionKey.replace(/:/g, "_")}`,
-                                value: session.sessionKey,
-                                style: "danger",
-                            },
-                        ],
-                    });
-                }
             }
         }
-        // --- Cron jobs ---
+    }
+    appendScheduledJobs(blocks) {
         const periodicEvents = this.eventsWatcher?.getPeriodicEvents() ?? [];
         blocks.push({ type: "divider" }, {
             type: "header",
@@ -807,34 +807,46 @@ export class SlackMessagingBot {
                 type: "context",
                 elements: [{ type: "mrkdwn", text: "_No scheduled jobs._" }],
             });
+            return;
         }
-        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}`,
-                    },
-                });
-            }
+        for (const event of periodicEvents) {
+            const channel = event.platform === "slack" ? this.channels.get(event.conversationId) : undefined;
+            const channelId = channel ? `#${channel.name}` : event.conversationId;
+            const channelLabel = `${event.platform}:${channelId}`;
+            const nextRun = event.nextRun
+                ? new Date(event.nextRun).toLocaleString("en-US", {
+                    month: "short",
+                    day: "numeric",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                })
+                : "—";
+            blocks.push({
+                type: "section",
+                text: {
+                    type: "mrkdwn",
+                    text: `*${event.text}*\n└ \`${event.schedule}\` · ${channelLabel} · Next: ${nextRun}`,
+                },
+            });
         }
-        // --- Footer ---
+    }
+    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,
+                },
+            },
+        ];
+        this.appendRunningTasks(blocks);
+        this.appendScheduledJobs(blocks);
         blocks.push({ type: "divider" }, {
             type: "context",
             elements: [
@@ -843,7 +855,8 @@ export class SlackMessagingBot {
         });
         return { type: "home", blocks: blocks };
     }
-    createCommandAdapters(conversationId, userId, userName, text, ts, options = {}) {
+    createCommandAdapters(input) {
+        const { conversationId, userId, userName, text, ts, ...options } = input;
         const message = createConversationMessage({
             platform: "slack",
             conversationId,
@@ -937,9 +950,16 @@ export class SlackMessagingBot {
             ...(threadTs ? { thread_ts: threadTs } : {}),
             sessionKey,
         });
-        const context = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage
-            ? { threadTs, sessionKey }
-            : { ephemeralChannelId: conversationId, threadTs, sessionKey });
+        const context = this.createCommandAdapters({
+            conversationId,
+            userId: payload.user_id,
+            userName,
+            text: commandText,
+            ts: eventTs,
+            ...(isDirectMessage
+                ? { threadTs, sessionKey }
+                : { ephemeralChannelId: conversationId, threadTs, sessionKey }),
+        });
         return { event, context };
     }
     /**
@@ -972,16 +992,6 @@ export class SlackMessagingBot {
         this.socketClient.on("unable_to_socket_mode_start", (err) => {
             log.logWarning("Slack socket unable_to_start", err ? String(err) : "");
         });
-        // Which events Slack actually delivers is otherwise unknowable from here:
-        // a listener that never fires looks the same whether the subscription is
-        // missing, the app needs reinstalling, or the surface never emits it at
-        // all. Off by default — this is one line per event on a busy workspace.
-        if (readEnv("SLACK_TRACE_EVENTS")) {
-            this.socketClient.on("slack_event", ({ type, body }) => {
-                const inner = body?.event;
-                log.logInfo(`Slack socket event: ${type ?? "?"}${inner?.type ? ` → ${inner.type}` : ""}${inner?.tab ? ` (tab: ${inner.tab})` : ""}`);
-            });
-        }
         this.socketClient.on("app_mention", (payload) => this.handleAppMention(payload));
         this.socketClient.on("message", (payload) => this.handleMessageEvent(payload));
         this.socketClient.on("slash_commands", (payload) => void this.handleSlashCommand(payload));
@@ -1039,49 +1049,44 @@ export class SlackMessagingBot {
         });
         ack();
     }
-    handleMessageEvent({ 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 isOwnMessagingBotMessage = (!!e.user && e.user === this.botUserId) || (!!this.botId && e.bot_id === this.botId);
-        if (isOwnMessagingBotMessage) {
+    admitHumanMessage(event, ack) {
+        const hasSlackContent = !!event.text ||
+            !!event.files?.length ||
+            !!event.blocks?.length ||
+            !!event.attachments?.length;
+        const isOwnMessage = event.user === this.botUserId || (!!this.botId && event.bot_id === this.botId);
+        if (isOwnMessage) {
             ack();
-            return;
+            return false;
         }
-        // API posts made with a user token carry the posting app's bot_id/app_id
-        // alongside the human `user` — bot_id alone does not make the author a
-        // bot. Only treat the message as bot-authored when the author is not a
-        // known human user (bot users have is_bot=true; unknown authors stay on
-        // the conservative bot path so loop protection holds).
-        const authorIsKnownHuman = !!e.user && this.users.get(e.user)?.isBot === false;
-        const isExternalMessagingBotMessage = e.subtype === "bot_message" || (!!e.bot_id && !authorIsKnownHuman);
-        if (isExternalMessagingBotMessage) {
-            if (e.subtype !== undefined && e.subtype !== "bot_message" && e.subtype !== "file_share") {
-                ack();
-                return;
-            }
-            if (!hasSlackContent) {
-                ack();
-                return;
+        // User-token posts carry bot_id/app_id beside the human user. Only unknown
+        // authors and known bot users take the external-bot loop-protection path.
+        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";
+            if (supportedSubtype && hasSlackContent) {
+                void this.logExternalMessagingBotMessage(event).catch((err) => {
+                    log.logWarning("Failed to log Slack bot message", String(err));
+                });
             }
-            void this.logExternalMessagingBotMessage(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;
+            return false;
         }
-        if (!hasSlackContent) {
-            ack();
+        const isSupportedUserMessage = !!event.user &&
+            (event.subtype === undefined || event.subtype === "file_share") &&
+            hasSlackContent;
+        if (isSupportedUserMessage)
+            return true;
+        ack();
+        return false;
+    }
+    handleMessageEvent({ event, ack }) {
+        const e = event;
+        if (!this.admitHumanMessage(e, ack))
             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
@@ -1242,36 +1247,6 @@ export class SlackMessagingBot {
             : undefined;
         const threadTs = container.thread_ts;
         const sessionKey = resolveSlackSessionKey(channelId, threadTs);
-        // Extension-owned actions (ext:<slug>: namespaced by api.blockkit.post)
-        // dispatch exclusively to the extension's onAction handler — no agent
-        // run, no chat-history entry. They never fall through to the model: an
-        // unconsumed namespaced action means the extension is gone, and its
-        // routing id would only confuse an agent run.
-        const extAction = parseExtActionId(action.action_id ?? "");
-        if (extAction) {
-            this.getQueue(this.resolveQueueKey(channelId, sessionKey)).enqueue(async () => {
-                const consumed = await this.handler.handleExtensionAction({
-                    address: createOfficeAddress("slack", channelId),
-                    sessionKey,
-                    conversationKind: channelId.startsWith("D") ? "direct" : "shared",
-                    slug: extAction.slug,
-                    action: {
-                        actionId: extAction.actionId,
-                        value: action.value ?? selectedOption?.value ?? selectedOption?.text?.text,
-                        selectedValues: selectedOptions?.map((option) => option.value ?? option.text?.text ?? ""),
-                        userId,
-                        userName: body.user?.username ?? body.user?.name,
-                        conversationId: channelId,
-                        messageTs: container.message_ts,
-                        threadTs,
-                    },
-                });
-                if (!consumed) {
-                    log.logWarning(`[${channelId}] Dropped extension action ${action.action_id}`, `no handler registered by extension "${extAction.slug}"`);
-                }
-            });
-            return;
-        }
         const selectedText = selectedOption?.text?.text ?? selectedOption?.value;
         const selectedTexts = selectedOptions?.map((option) => option.text?.text ?? option.value);
         const valueText = selectedTexts?.length
@@ -1607,7 +1582,12 @@ export class SlackMessagingBot {
             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 });
+                        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 } : {}),
+                        });
                     }
                 }
             }