@geminixiang/mikan 1.0.0-beta.60 → 1.0.0-beta.62

package/dist/adapters/slack/bot.js

@@ -11,7 +11,7 @@ import * as log from "../../log.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 { matchMagicWord, processMessageIntake } from "../intake.js";
 import { recordPlatformChannelKind } from "../../office/projection.js";
 import { AssistantThreadRegistry, handleAgentContextChanged, handleAgentDmOpened, handleAssistantThreadStarted, titleAssistantThread, } from "./assistant.js";
 import { createSlackAdapters } from "./context.js";
@@ -21,6 +21,7 @@ import { isSlackThreadSessionKey, planSlackAdapterSession, planSlackEventAnchorR
 import { reportUserFacingError } from "../../observability/index.js";
 import { recordSlackUpdate } from "./update-diagnostics.js";
 import { renderSlackBlocks, resolveSlackMentions } from "./blocks.js";
+import { querySlackTasks, isTaskStatusQuestion, formatTaskStatus, readTaskRoots, } from "./task-status.js";
 import { StreamStartLimiter } from "./stream-limits.js";
 const SLACK_EVENT_ANCHOR_TEXT = "Working on it...";
 function hasMessageContent(message, includeBlocks = true) {
@@ -130,9 +131,87 @@ export class SlackMessagingBot {
         return (resolveConversationSettings(this.workspace.office(address)).slack?.replyMode ?? "top-level");
     }
     createContext(event) {
-        return createSlackAdapters(event, this, {
+        const context = createSlackAdapters(event, this, {
             replyMode: this.resolveReplyMode(event.address),
         });
+        if (event.conversationKind === "direct") {
+            context.responder.getTaskStatus = (key) => querySlackTasks(this.conversationDir(event.channel), event.channel, this.handler
+                .getRunningSessions()
+                .filter((s) => s.address.platform === "slack" && s.address.conversationId === event.channel), key);
+        }
+        if (event.conversationKind === "direct" &&
+            event.thread_ts &&
+            this.isTaskThread(event.channel, event.thread_ts)) {
+            let notified = false;
+            context.responder.notifyCompletion = async () => {
+                if (notified)
+                    return;
+                const text = `<@${event.user}> 這一輪處理已結束，請查看上方結果。`;
+                const ts = await this.postInThread(event.channel, event.thread_ts, text);
+                notified = true;
+                this.logBotResponse(event.channel, text, ts, event.thread_ts);
+            };
+        }
+        if (event.conversationKind === "direct" && !event.thread_ts) {
+            context.responder.startTask = async (message, task) => {
+                if (this.stopped)
+                    throw new Error("Slack is shutting down; task was not started.");
+                await context.responder.deleteResponse();
+                const root = await this.postMessage(event.channel, message);
+                this.logToFile(event.channel, {
+                    date: new Date().toISOString(),
+                    ts: root,
+                    user: "bot",
+                    text: message,
+                    isMessagingBot: true,
+                    taskRoot: true,
+                });
+                const sessionKey = resolveSlackSessionKey(event.channel, root);
+                try {
+                    registerThreadSession({
+                        conversationDir: this.conversationDir(event.channel),
+                        sessionKey,
+                    });
+                    const child = {
+                        ...event,
+                        ts: `task:${root}`,
+                        thread_ts: root,
+                        sessionKey,
+                        text: task,
+                    };
+                    if (!this.getQueue(sessionKey).enqueue(async () => {
+                        try {
+                            await this.handler.handleEvent({
+                                ...child,
+                                attachments: child.attachments?.map((a) => ({
+                                    name: a.original,
+                                    localPath: a.localPath,
+                                })),
+                            }, this, this.createContext(child));
+                        }
+                        catch (error) {
+                            reportUserFacingError(error, {
+                                domain: "mikan",
+                                surface: "task_handoff",
+                                operation: "start_task_run",
+                                severity: "error",
+                                platform: "slack",
+                                context: { conversationId: event.channel, sessionKey, threadTs: root },
+                            });
+                            await this.postInThread(event.channel, root, "Task could not start. Please reply here to try again.");
+                            throw error;
+                        }
+                    }))
+                        throw new Error("Task queue is closed.");
+                }
+                catch (error) {
+                    await this.updateMessage(event.channel, root, `${message}\n\nTask could not start.`);
+                    throw error;
+                }
+                return sessionKey;
+            };
+        }
+        return context;
     }
     constructor(handler, config) {
         this.statusUpdates = new Map();
@@ -155,7 +234,7 @@ export class SlackMessagingBot {
         this.stopped = false;
         this.queues = new Map();
         this.intake = new MessagingIntakeTracker("Slack");
-        this.eventsWatcher = null;
+        this.eventScheduler = null;
         this.handler = handler;
         this.workspace = config.workspace;
         this.botToken = config.botToken;
@@ -172,8 +251,8 @@ export class SlackMessagingBot {
             rejectRateLimitedCalls: true,
         });
     }
-    setEventsWatcher(watcher) {
-        this.eventsWatcher = watcher;
+    setEventScheduler(scheduler) {
+        this.eventScheduler = scheduler;
     }
     // ==========================================================================
     // Public API
@@ -710,6 +789,9 @@ export class SlackMessagingBot {
         }
         return this.hasKnownThreadSession(conversationId, sessionKey) ? sessionKey : conversationId;
     }
+    isTaskThread(channel, root) {
+        return readTaskRoots(this.conversationDir(channel)).has(root);
+    }
     hasKnownThreadSession(conversationId, sessionKey) {
         return hasMaterializedChatSession({
             conversationDir: this.conversationDir(conversationId),
@@ -840,8 +922,14 @@ export class SlackMessagingBot {
             }
         }
     }
-    appendScheduledJobs(blocks) {
-        const periodicEvents = this.eventsWatcher?.getPeriodicEvents() ?? [];
+    /**
+     * Scheduled jobs of the opener's own DM office only: the App Home is a
+     * personal surface, so other offices' schedules are not listed here.
+     */
+    appendScheduledJobs(blocks, dmChannelId) {
+        const periodicEvents = dmChannelId && this.eventScheduler
+            ? this.eventScheduler.periodicEvents(createOfficeAddress("slack", dmChannelId))
+            : [];
         blocks.push({ type: "divider" }, {
             type: "header",
             text: {
@@ -878,7 +966,7 @@ export class SlackMessagingBot {
             });
         }
     }
-    buildHomeView() {
+    buildHomeView(dmChannelId) {
         const blocks = [
             {
                 type: "section",
@@ -894,7 +982,7 @@ export class SlackMessagingBot {
             },
         ];
         this.appendRunningTasks(blocks);
-        this.appendScheduledJobs(blocks);
+        this.appendScheduledJobs(blocks, dmChannelId);
         blocks.push({ type: "divider" }, {
             type: "context",
             elements: [
@@ -1135,6 +1223,39 @@ export class SlackMessagingBot {
         ack();
         return false;
     }
+    async deliverTaskUpdate(event, attachmentsPromise) {
+        if (matchMagicWord(event.text) === "stop" || event.text.startsWith("/"))
+            return false;
+        event.attachments = await attachmentsPromise;
+        const context = this.createContext(event);
+        const post = (text) => event.thread_ts
+            ? this.postInThread(event.channel, event.thread_ts, text)
+            : this.postMessage(event.channel, text);
+        try {
+            if (!event.attachments?.length && isTaskStatusQuestion(event.text)) {
+                const tasks = await context.responder.getTaskStatus(event.thread_ts ? event.sessionKey : undefined);
+                if (!tasks.length)
+                    return false;
+                const active = tasks.filter((t) => t.status === "running" || t.status === "stopping");
+                const selection = event.thread_ts ? tasks : active.length ? active : tasks.slice(0, 1);
+                const text = selection.length > 1
+                    ? "目前有多個任務在處理，請到你想查詢的任務對話串詢問，避免弄錯。"
+                    : formatTaskStatus(selection);
+                const ts = await post(text);
+                this.logBotResponse(event.channel, text, ts, event.thread_ts);
+                return true;
+            }
+            if (event.thread_ts && (await this.handler.steer?.(context.message))) {
+                await post("收到補充，會在下一個處理步驟納入；目前的操作不會立即中斷。");
+                return true;
+            }
+        }
+        catch (error) {
+            await post(error instanceof Error ? error.message : "Could not deliver task update.");
+            return true;
+        }
+        return false;
+    }
     async handleMessageEvent({ event, ack, }) {
         const e = event;
         if (!this.admitHumanMessage(e, ack))
@@ -1182,7 +1303,7 @@ export class SlackMessagingBot {
             ack();
             return;
         }
-        if (!isDM && isThreadReply) {
+        if (!isDM && isThreadReply && matchMagicWord(slackEvent.text) !== "stop") {
             void attachmentsPromise.catch((err) => {
                 log.logWarning("Failed to log Slack message", String(err));
             });
@@ -1191,6 +1312,13 @@ export class SlackMessagingBot {
         }
         const activeSessionKey = slackEvent.sessionKey ?? resolveSlackSessionKey(e.channel, e.thread_ts);
         slackEvent.sessionKey = activeSessionKey;
+        const taskThread = isDM && !!e.thread_ts && this.isTaskThread(e.channel, e.thread_ts);
+        const taskControl = taskThread || (isDM && !e.thread_ts && isTaskStatusQuestion(slackEvent.text));
+        if (taskControl) {
+            ack();
+            if (await this.deliverTaskUpdate(slackEvent, attachmentsPromise))
+                return;
+        }
         const autoReply = !isDM && slackConversationAutoReplyEnabled(this.workspace.office(slackEvent.address));
         const intake = this.processSlackMessageIntake({
             event: slackEvent,
@@ -1199,7 +1327,8 @@ export class SlackMessagingBot {
             addressed: isDM || autoReply,
             magicWordAddressed: isDM,
         });
-        ack();
+        if (!taskControl)
+            ack();
         await intake;
     }
     async handleSlashCommand({ body, ack, }) {
@@ -1246,7 +1375,7 @@ export class SlackMessagingBot {
         this.webClient.views
             .publish({
             user_id: e.user,
-            view: this.buildHomeView(),
+            view: this.buildHomeView(e.channel),
         })
             .catch((err) => {
             log.logWarning(`Failed to publish App Home view`, String(err));
@@ -1277,11 +1406,11 @@ export class SlackMessagingBot {
         await this.postMessage(channelId, formatForceStopped("slack", userId ?? "unknown"));
         // Refresh home tab
         if (userId) {
-            this.webClient.views
-                .publish({
+            this.openDirectConversation(userId)
+                .then((dmChannelId) => this.webClient.views.publish({
                 user_id: userId,
-                view: this.buildHomeView(),
-            })
+                view: this.buildHomeView(dmChannelId),
+            }))
                 .catch((err) => {
                 log.logWarning(`Failed to refresh App Home view`, String(err));
             });