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

package/dist/adapters/slack/bot.js

@@ -1,81 +1,24 @@
 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 { 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";
 // ============================================================================
-// 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();
-    }
-}
-// ============================================================================
 // SlackBot
 // ============================================================================
 export class SlackBot {
@@ -123,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) {
@@ -144,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 });
         });
     }
@@ -158,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,
@@ -167,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) {
@@ -187,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,
@@ -198,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({
@@ -210,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 {
@@ -291,7 +216,7 @@ 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;
@@ -303,6 +228,14 @@ export class SlackBot {
             ? 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
@@ -439,76 +372,19 @@ 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.
-     *
-     * For top-level stop requests, fall back to the only running scoped thread session in
-     * this conversation when there is exactly one candidate. This keeps DM/channel stop
-     * useful after thread sessions were introduced without guessing between multiple threads.
-     */
     resolveStopTarget(channelId, threadTs) {
-        if (threadTs) {
-            const threadKey = resolveSlackSessionKey(channelId, threadTs);
-            if (this.handler.isRunning(threadKey))
-                return threadKey;
-            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;
-        }
-        if (this.handler.isRunning(channelId))
-            return channelId;
-        const runningInConversation = this.handler
-            .getRunningSessions()
-            .map((session) => session.sessionKey)
-            .filter((sessionKey) => sessionKey.startsWith(`${channelId}:`));
-        return runningInConversation.length === 1 ? runningInConversation[0] : null;
-    }
-    createDirectCommandAdapters(conversationId, userId, userName, text, ts) {
-        const message = {
-            id: ts,
-            sessionKey: conversationId,
-            conversationKind: "direct",
-            userId,
-            userName,
-            text,
-            attachments: [],
-        };
-        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);
-            },
-            respondDiagnostic: async (responseText) => {
-                const messageTs = await this.postMessage(conversationId, responseText);
-                this.logBotResponse(conversationId, responseText, messageTs);
-            },
-            respondToolResult: async (result) => {
-                const duration = (result.durationMs / 1000).toFixed(1);
-                const text = `${result.isError ? "Error" : "Done"} ${result.toolName} (${duration}s)\n${result.result}`;
-                const messageTs = await this.postMessage(conversationId, text);
-                this.logBotResponse(conversationId, text, messageTs);
-            },
-            setTyping: async () => { },
-            setWorking: async () => { },
-            uploadFile: async (filePath, title) => {
-                await this.uploadFile(conversationId, filePath, title);
-            },
-            deleteResponse: async () => { },
-        };
-        return {
-            message,
-            responseCtx,
-            platform: this.getPlatformInfo(),
-        };
+        return resolveOnlyScopedStopTarget(this.handler, channelId);
     }
-    createPrivateSessionCommandAdapters(conversationId, userId, userName, text, ts, options) {
+    createCommandAdapters(conversationId, userId, userName, text, ts, options = {}) {
         const message = {
             id: ts,
             sessionKey: conversationId,
@@ -518,8 +394,7 @@ export class SlackBot {
             text,
             attachments: [],
         };
-        let hasResponded = false;
-        const respondPrivately = async (responseText) => {
+        const respond = async (responseText) => {
             if (options.ephemeralChannelId) {
                 await this.postEphemeral(options.ephemeralChannelId, userId, responseText);
                 return;
@@ -528,23 +403,12 @@ export class SlackBot {
             this.logBotResponse(conversationId, responseText, messageTs);
         };
         const responseCtx = {
-            respond: async (responseText) => {
-                hasResponded = true;
-                await respondPrivately(responseText);
-            },
-            replaceResponse: async (responseText) => {
-                if (!hasResponded) {
-                    hasResponded = true;
-                }
-                await respondPrivately(responseText);
-            },
-            respondDiagnostic: async (responseText) => {
-                await respondPrivately(responseText);
-            },
+            respond,
+            replaceResponse: respond,
+            respondDiagnostic: respond,
             respondToolResult: async (result) => {
                 const duration = (result.durationMs / 1000).toFixed(1);
-                const formatted = `${result.isError ? "Error" : "Done"} ${result.toolName} (${duration}s)\n${result.result}`;
-                await respondPrivately(formatted);
+                await respond(`${result.isError ? "Error" : "Done"} ${result.toolName} (${duration}s)\n${result.result}`);
             },
             setTyping: async () => { },
             setWorking: async () => { },
@@ -608,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) {
@@ -659,7 +523,7 @@ export class SlackBot {
             attachments: [],
             sessionKey,
         };
-        const adapters = this.createPrivateSessionCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? {} : { ephemeralChannelId: conversationId });
+        const adapters = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? {} : { ephemeralChannelId: conversationId });
         await this.handler.handleEvent(event, this, adapters, false);
     }
     setupEventHandlers() {
@@ -742,7 +606,7 @@ export class SlackBot {
                 ack();
                 return;
             }
-            const isSharedThreadReply = !isDM && !!e.thread_ts;
+            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",