@geminixiang/mama 0.2.0-beta.2 → 0.2.0-beta.4

package/dist/adapters/slack/bot.js

@@ -1,78 +1,23 @@
 import { SocketModeClient } from "@slack/socket-mode";
 import { WebClient } from "@slack/web-api";
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+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 { createSlackAdapters } from "./context.js";
-// ============================================================================
-// Exponential backoff utility for Slack API calls
-// ============================================================================
-/**
- * Retry a function with exponential backoff on rate limit errors.
- */
-async function withRetry(fn, maxRetries = 3, baseDelayMs = 1000) {
-    let lastError;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (err) {
-            lastError = err instanceof Error ? err : new Error(String(err));
-            // Check for rate limit errors
-            let isRateLimited = false;
-            // Check for rate_limited error code (Slack SDK)
-            if ("code" in lastError && lastError.code === "rate_limited") {
-                isRateLimited = true;
-            }
-            // Check for rate_limited in error response
-            if ("data" in lastError) {
-                const data = lastError
-                    .data;
-                if (data?.error === "rate_limited" || data?.response?.status === 429) {
-                    isRateLimited = true;
-                }
-            }
-            if (isRateLimited) {
-                const delay = baseDelayMs * Math.pow(2, attempt);
-                log.logWarning(`Rate limited, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                continue;
-            }
-            // Non-retryable error
-            throw lastError;
-        }
-    }
-    throw lastError;
-}
-class ChannelQueue {
-    constructor() {
-        this.queue = [];
-        this.processing = false;
-    }
-    enqueue(work) {
-        this.queue.push(work);
-        this.processNext();
-    }
-    size() {
-        return this.queue.length;
-    }
-    async processNext() {
-        if (this.processing || this.queue.length === 0)
-            return;
-        this.processing = true;
-        const work = this.queue.shift();
-        try {
-            await work();
-        }
-        catch (err) {
-            log.logWarning("Queue error", err instanceof Error ? err.message : String(err));
-        }
-        this.processing = false;
-        this.processNext();
-    }
+import { appendBotResponseLog, appendChannelLog, ChannelQueue, resolveOnlyScopedStopTarget, resolveStopTarget, withRetry, } from "../shared.js";
+// 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 });
+import { createSlackAdapters } from "./context.js";
+import { hasMaterializedSlackBranchSession } from "./branch-manager.js";
+import { resolveSlackSessionKey } from "./session.js";
 // ============================================================================
 // SlackBot
 // ============================================================================
@@ -121,18 +66,18 @@ export class SlackBot {
         return Array.from(this.channels.values());
     }
     async postMessage(channel, text) {
-        return withRetry(async () => {
+        return slackRetry(async () => {
             const result = await this.webClient.chat.postMessage({ channel, text });
             return result.ts;
         });
     }
     async postEphemeral(channel, user, text) {
-        return withRetry(async () => {
+        return slackRetry(async () => {
             await this.webClient.chat.postEphemeral({ channel, user, text });
         });
     }
     async openDirectMessage(userId) {
-        return withRetry(async () => {
+        return slackRetry(async () => {
             const result = await this.webClient.conversations.open({ users: userId });
             const channelId = result.channel?.id;
             if (!channelId) {
@@ -142,12 +87,12 @@ export class SlackBot {
         });
     }
     async updateMessage(channel, ts, text) {
-        return withRetry(async () => {
+        return slackRetry(async () => {
             await this.webClient.chat.update({ channel, ts, text });
         });
     }
     async deleteMessage(channel, ts) {
-        return withRetry(async () => {
+        return slackRetry(async () => {
             await this.webClient.chat.delete({ channel, ts });
         });
     }
@@ -156,7 +101,7 @@ export class SlackBot {
     // ==========================================================================
     /** Set the status for an assistant thread (shows "thinking" state) */
     async setAssistantStatus(channel, threadTs, status) {
-        return withRetry(async () => {
+        return slackRetry(async () => {
             await this.webClient.assistant.threads.setStatus({
                 channel_id: channel,
                 thread_ts: threadTs,
@@ -165,7 +110,7 @@ export class SlackBot {
         });
     }
     async postInThread(channel, threadTs, text) {
-        return withRetry(async () => {
+        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) {
@@ -185,7 +130,7 @@ export class SlackBot {
         });
     }
     async postInThreadBlocks(channel, threadTs, text, blocks) {
-        return withRetry(async () => {
+        return slackRetry(async () => {
             const result = await this.webClient.chat.postMessage({
                 channel,
                 thread_ts: threadTs,
@@ -196,7 +141,7 @@ export class SlackBot {
         });
     }
     async uploadFile(channel, filePath, title, threadTs) {
-        return withRetry(async () => {
+        return slackRetry(async () => {
             const fileName = title || basename(filePath);
             const fileContent = readFileSync(filePath);
             await this.webClient.files.uploadV2({
@@ -208,29 +153,11 @@ export class SlackBot {
             });
         });
     }
-    /**
-     * Log a message to log.jsonl (SYNC)
-     * This is the ONLY place messages are written to log.jsonl
-     */
     logToFile(channel, entry) {
-        const dir = join(this.workingDir, channel);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        appendFileSync(join(dir, "log.jsonl"), `${JSON.stringify(entry)}\n`);
+        appendChannelLog(this.workingDir, channel, entry);
     }
-    /**
-     * Log a bot response to log.jsonl
-     */
     logBotResponse(channel, text, ts, threadTs) {
-        this.logToFile(channel, {
-            date: new Date().toISOString(),
-            ts,
-            threadTs,
-            user: "bot",
-            text,
-            attachments: [],
-            isBot: true,
-        });
+        appendBotResponseLog(this.workingDir, channel, text, ts, threadTs);
     }
     getPlatformInfo() {
         return {
@@ -242,6 +169,9 @@ export class SlackBot {
                 userName: u.userName,
                 displayName: u.displayName,
             })),
+            diagnostics: {
+                showUsageSummary: true,
+            },
         };
     }
     // ==========================================================================
@@ -286,11 +216,26 @@ export class SlackBot {
     getQueue(channelId) {
         let queue = this.queues.get(channelId);
         if (!queue) {
-            queue = new ChannelQueue();
+            queue = new ChannelQueue("Slack");
             this.queues.set(channelId, queue);
         }
         return queue;
     }
+    resolveQueueKey(conversationId, sessionKey) {
+        if (!sessionKey.includes(":"))
+            return sessionKey;
+        return hasMaterializedSlackBranchSession(join(this.workingDir, conversationId), sessionKey)
+            ? sessionKey
+            : conversationId;
+    }
+    shouldTriggerSharedThreadReply(channelId, threadTs) {
+        if (!threadTs)
+            return false;
+        const sessionKey = resolveSlackSessionKey(channelId, threadTs);
+        if (this.handler.isRunning(sessionKey))
+            return true;
+        return hasMaterializedSlackBranchSession(join(this.workingDir, channelId), sessionKey);
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     buildHomeView() {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -427,46 +372,43 @@ export class SlackBot {
         });
         return { type: "home", blocks };
     }
-    /**
-     * Resolve which session key to stop.
-     * When stop is called from a thread, the thread session (channelId:thread_ts) might
-     * not be running — but the channel session (channelId) might be, because the bot's
-     * reply to a top-level mention creates a thread. Check both, prefer thread first.
-     */
     resolveStopTarget(channelId, threadTs) {
-        if (threadTs) {
-            const threadKey = `${channelId}:${threadTs}`;
-            if (this.handler.isRunning(threadKey))
-                return threadKey;
-            // Fall back to channel session — the thread may have been spawned by a top-level run
-            if (this.handler.isRunning(channelId))
-                return channelId;
+        const directTarget = resolveStopTarget({
+            handler: this.handler,
+            conversationId: channelId,
+            sessionKey: threadTs ? resolveSlackSessionKey(channelId, threadTs) : undefined,
+        });
+        if (directTarget)
+            return directTarget;
+        if (threadTs)
             return null;
-        }
-        return this.handler.isRunning(channelId) ? channelId : null;
+        return resolveOnlyScopedStopTarget(this.handler, channelId);
     }
-    createDirectCommandAdapters(conversationId, userId, userName, text, ts) {
+    createCommandAdapters(conversationId, userId, userName, text, ts, options = {}) {
         const message = {
             id: ts,
             sessionKey: conversationId,
-            conversationKind: "direct",
+            conversationKind: options.ephemeralChannelId ? "shared" : "direct",
             userId,
             userName,
             text,
             attachments: [],
         };
+        const respond = async (responseText) => {
+            if (options.ephemeralChannelId) {
+                await this.postEphemeral(options.ephemeralChannelId, userId, responseText);
+                return;
+            }
+            const messageTs = await this.postMessage(conversationId, responseText);
+            this.logBotResponse(conversationId, responseText, messageTs);
+        };
         const responseCtx = {
-            respond: async (responseText) => {
-                const messageTs = await this.postMessage(conversationId, responseText);
-                this.logBotResponse(conversationId, responseText, messageTs);
-            },
-            replaceResponse: async (responseText) => {
-                const messageTs = await this.postMessage(conversationId, responseText);
-                this.logBotResponse(conversationId, responseText, messageTs);
-            },
-            respondInThread: async (responseText) => {
-                const messageTs = await this.postMessage(conversationId, responseText);
-                this.logBotResponse(conversationId, responseText, messageTs);
+            respond,
+            replaceResponse: respond,
+            respondDiagnostic: respond,
+            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 () => { },
@@ -530,7 +472,7 @@ export class SlackBot {
             attachments: [],
             sessionKey: targetChannelId,
         };
-        const adapters = this.createDirectCommandAdapters(targetChannelId, payload.user_id, userName, commandText, eventTs);
+        const adapters = this.createCommandAdapters(targetChannelId, payload.user_id, userName, commandText, eventTs);
         await this.handler.handleEvent(event, this, adapters, false);
     }
     async routeSlashNewCommand(payload) {
@@ -554,6 +496,36 @@ export class SlackBot {
         const commandBot = this.createSlashCommandBot(conversationId);
         await this.handler.handleNew(conversationId, conversationId, commandBot);
     }
+    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,
+        });
+        const sessionKey = conversationId;
+        const event = {
+            type: "dm",
+            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, false);
+    }
     setupEventHandlers() {
         // Channel @mentions
         this.socketClient.on("app_mention", ({ event, ack }) => {
@@ -565,7 +537,7 @@ export class SlackBot {
             }
             // Top-level mentions use a persistent channel session.
             // Thread replies get their own isolated session (channelId:thread_ts).
-            const sessionKey = e.thread_ts ? `${e.channel}:${e.thread_ts}` : e.channel;
+            const sessionKey = resolveSlackSessionKey(e.channel, e.thread_ts);
             const slackEvent = {
                 type: "mention",
                 conversationId: e.channel,
@@ -578,12 +550,13 @@ export class SlackBot {
                 files: e.files,
                 sessionKey,
             };
-            // SYNC: Log to log.jsonl (ALWAYS, even for old messages)
-            // Also downloads attachments in background and stores local paths
-            slackEvent.attachments = this.logUserMessage(slackEvent);
+            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;
             }
@@ -596,10 +569,14 @@ export class SlackBot {
                 else {
                     this.postMessage(e.channel, formatNothingRunning("slack"));
                 }
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
                 ack();
                 return;
             }
-            this.getQueue(sessionKey).enqueue(() => {
+            this.getQueue(this.resolveQueueKey(e.channel, sessionKey)).enqueue(async () => {
+                slackEvent.attachments = await attachmentsPromise;
                 const adapters = createSlackAdapters(slackEvent, this, false);
                 return this.handler.handleEvent(slackEvent, this, adapters, false);
             });
@@ -629,6 +606,8 @@ export class SlackBot {
                 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,
@@ -639,14 +618,15 @@ export class SlackBot {
                 user: e.user,
                 text: (e.text || "").replace(/<@[A-Z0-9]+>/gi, "").trim(),
                 files: e.files,
-                sessionKey: isDM ? e.channel : undefined,
+                sessionKey,
             };
-            // SYNC: Log to log.jsonl (ALL messages - channel chatter and DMs)
-            // Also downloads attachments in background and stores local paths
-            slackEvent.attachments = this.logUserMessage(slackEvent);
+            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;
             }
@@ -660,28 +640,41 @@ export class SlackBot {
                 else {
                     this.postMessage(e.channel, formatNothingRunning("slack"));
                 }
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
                 ack();
                 return;
             }
-            // Only trigger handler for DMs
-            if (isDM) {
-                const dmSessionKey = slackEvent.sessionKey;
+            // Trigger handler for DMs and bare replies inside shared-channel threads.
+            if (isDM || isSharedThreadReply) {
+                const activeSessionKey = slackEvent.sessionKey ?? resolveSlackSessionKey(e.channel, e.thread_ts);
                 // Check for stop command - execute immediately, don't queue!
                 if (slackEvent.text.toLowerCase().trim() === "stop") {
-                    if (this.handler.isRunning(dmSessionKey)) {
-                        this.handler.handleStop(dmSessionKey, e.channel, this); // Don't await, don't queue
+                    const stopTarget = this.resolveStopTarget(e.channel, e.thread_ts);
+                    if (stopTarget) {
+                        this.handler.handleStop(stopTarget, e.channel, this); // Don't await, don't queue
                     }
                     else {
                         this.postMessage(e.channel, formatNothingRunning("slack"));
                     }
+                    void attachmentsPromise.catch((err) => {
+                        log.logWarning("Failed to log Slack message", String(err));
+                    });
                     ack();
                     return;
                 }
-                this.getQueue(dmSessionKey).enqueue(() => {
+                this.getQueue(this.resolveQueueKey(e.channel, activeSessionKey)).enqueue(async () => {
+                    slackEvent.attachments = await attachmentsPromise;
                     const adapters = createSlackAdapters(slackEvent, this, false);
                     return this.handler.handleEvent(slackEvent, this, adapters, false);
                 });
             }
+            else {
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
+            }
             ack();
         });
         this.socketClient.on("slash_commands", async ({ body, ack }) => {
@@ -705,7 +698,14 @@ export class SlackBot {
                         user_id: payload.user_id,
                         user_name: payload.user_name,
                     })
-                    : null;
+                    : payload.command === "/pi-session"
+                        ? this.routeSlashSessionCommand({
+                            command: payload.command,
+                            channel_id: payload.channel_id,
+                            user_id: payload.user_id,
+                            user_name: payload.user_name,
+                        })
+                        : null;
             if (!handlerPromise) {
                 return;
             }
@@ -758,14 +758,12 @@ export class SlackBot {
         });
     }
     /**
-     * Log a user message to log.jsonl (SYNC)
-     * Downloads attachments in background via store
+     * Log a user message to log.jsonl after attachments are ready.
      */
-    logUserMessage(event) {
+    async logUserMessage(event) {
         const user = this.users.get(event.user);
-        // Process attachments - queues downloads in background
         const attachments = event.files
-            ? this.store.processAttachments(event.channel, event.files, event.ts)
+            ? await this.store.processAttachments(event.channel, event.files, event.ts)
             : [];
         this.logToFile(event.channel, {
             date: new Date(parseFloat(event.ts) * 1000).toISOString(),
@@ -850,13 +848,13 @@ export class SlackBot {
             const user = this.users.get(msg.user);
             // Strip @mentions from text (same as live messages)
             const text = (msg.text || "").replace(/<@[A-Z0-9]+>/gi, "").trim();
-            // Process attachments - queues downloads in background
             const attachments = msg.files
-                ? this.store.processAttachments(channelId, msg.files, msg.ts)
+                ? 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: isMamaMessage ? "bot" : msg.user,
                 userName: isMamaMessage ? undefined : user?.userName,
                 displayName: isMamaMessage ? undefined : user?.displayName,