@geminixiang/mama 0.2.0-beta.0 → 0.2.0-beta.10

package/dist/adapters/discord/bot.js

@@ -1,35 +1,24 @@
-import { Client, Events, GatewayIntentBits, Partials, } from "discord.js";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { ApplicationCommandOptionType, Client, Events, GatewayIntentBits, Partials, } from "discord.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { basename, join } from "path";
 import * as log from "../../log.js";
+import { resolveChatSessionKey } from "../../session-policy.js";
+import { evaluateAutoReplyPolicy } from "../../trigger.js";
+import { formatNothingRunning } from "../../ui-copy.js";
+import { appendBotResponseLog, appendChannelLog, ChannelQueue, resolveOnlyScopedStopTarget, resolveStopTarget, withRetry, } from "../shared.js";
 import { createDiscordAdapters } from "./context.js";
-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("Discord queue error", err instanceof Error ? err.message : String(err));
-        }
-        this.processing = false;
-        this.processNext();
-    }
+// discord.js: DiscordAPIError exposes `.status` (HTTP status) and a `.code`.
+// RateLimitError fires when the internal queue gives up. Both should retry.
+function discordIsRateLimited(err) {
+    if (err.status === 429)
+        return true;
+    if (err.httpStatus === 429)
+        return true;
+    if (err.name === "RateLimitError")
+        return true;
+    return false;
 }
+const discordRetry = (fn) => withRetry(fn, { isRateLimited: discordIsRateLimited });
 // ============================================================================
 // DiscordBot
 // ============================================================================
@@ -41,6 +30,7 @@ export class DiscordBot {
         this.channels = new Map();
         this.users = new Map();
         this.handler = handler;
+        this.token = config.token;
         this.workingDir = config.workingDir;
         this.client = new Client({
             intents: [
@@ -57,34 +47,84 @@ export class DiscordBot {
     // ==========================================================================
     async start() {
         await new Promise((resolve, reject) => {
-            this.client.once(Events.ClientReady, (readyClient) => {
+            this.client.once(Events.ClientReady, async (readyClient) => {
                 this.botUserId = readyClient.user.id;
                 this.startupTime = Date.now();
-                log.logConnected();
+                log.logConnected("Discord");
                 log.logInfo(`Discord bot started as ${readyClient.user.tag}`);
                 this.loadCachedGuildData();
                 this.setupEventHandlers();
+                try {
+                    await readyClient.application.commands.set([
+                        {
+                            name: "login",
+                            description: "Store credentials in your private vault",
+                        },
+                        {
+                            name: "session",
+                            description: "Open the current session in the web viewer",
+                        },
+                        {
+                            name: "new",
+                            description: "Reset conversation history and start fresh",
+                        },
+                        {
+                            name: "stop",
+                            description: "Stop the current conversation",
+                        },
+                        {
+                            name: "model",
+                            description: "Switch this conversation's LLM model",
+                            options: [
+                                {
+                                    name: "model",
+                                    description: "provider/model[:thinking], e.g. anthropic/claude-sonnet-4-6:off",
+                                    type: ApplicationCommandOptionType.String,
+                                    required: false,
+                                },
+                            ],
+                        },
+                        {
+                            name: "sandbox",
+                            description: "Show or temporarily boost this conversation's sandbox limits",
+                            options: [
+                                {
+                                    name: "action",
+                                    description: "Use 'boost' to temporarily apply the configured boost limits",
+                                    type: ApplicationCommandOptionType.String,
+                                    required: false,
+                                },
+                            ],
+                        },
+                    ]);
+                }
+                catch (err) {
+                    log.logWarning("Failed to register Discord slash commands", err instanceof Error ? err.message : String(err));
+                }
                 resolve();
             });
             this.client.once(Events.Error, reject);
-            this.client.login(process.env.MOM_DISCORD_BOT_TOKEN).catch(reject);
+            this.client.login(this.token).catch(reject);
         });
     }
     async postMessage(channel, text) {
-        const ch = await this.fetchTextChannel(channel);
-        const msg = await ch.send(text);
-        return msg.id;
+        return discordRetry(async () => {
+            const ch = await this.fetchTextChannel(channel);
+            const msg = await ch.send(text);
+            return msg.id;
+        });
     }
     async updateMessage(channel, ts, text) {
         await this.updateMessageRaw(channel, ts, text);
     }
     enqueueEvent(event) {
-        const queue = this.getQueue(event.channel);
+        const conversationId = event.conversationId;
+        const queue = this.getQueue(conversationId);
         if (queue.size() >= 5) {
-            log.logWarning(`Event queue full for ${event.channel}, discarding: ${event.text.substring(0, 50)}`);
+            log.logWarning(`Event queue full for ${conversationId}, discarding: ${event.text.substring(0, 50)}`);
             return false;
         }
-        log.logInfo(`Enqueueing event for ${event.channel}: ${event.text.substring(0, 50)}`);
+        log.logInfo(`Enqueueing event for ${conversationId}: ${event.text.substring(0, 50)}`);
         queue.enqueue(() => {
             const adapters = createDiscordAdapters(event, this, true);
             return this.handler.handleEvent(event, this, adapters, true);
@@ -97,29 +137,38 @@ export class DiscordBot {
             formattingGuide: "## Discord Formatting (Markdown)\nBold: **text**, Italic: *text*, Code: `code`, Block: ```language\ncode```\nLinks: [text](url)",
             channels: this.getAllChannels(),
             users: this.getAllUsers(),
+            diagnostics: {
+                showUsageSummary: false,
+            },
         };
     }
     // ==========================================================================
     // Internal helpers (used by context.ts)
     // ==========================================================================
     async updateMessageRaw(channelId, messageId, text) {
-        const ch = await this.fetchTextChannel(channelId);
-        const msg = await ch.messages.fetch(messageId);
-        await msg.edit(text);
+        return discordRetry(async () => {
+            const ch = await this.fetchTextChannel(channelId);
+            const msg = await ch.messages.fetch(messageId);
+            await msg.edit(text);
+        });
     }
     async postReply(channelId, replyToId, text) {
-        const ch = await this.fetchTextChannel(channelId);
-        const replyTarget = await ch.messages.fetch(replyToId);
-        const sent = await replyTarget.reply(text);
-        return sent.id;
+        return discordRetry(async () => {
+            const ch = await this.fetchTextChannel(channelId);
+            const replyTarget = await ch.messages.fetch(replyToId);
+            const sent = await replyTarget.reply(text);
+            return sent.id;
+        });
     }
     async postInThread(channelId, threadOrMessageId, text) {
         // Try as a thread channel first, then fall back to posting in the channel
         try {
             const thread = await this.client.channels.fetch(threadOrMessageId);
             if (thread && (thread.isThread() || thread.isTextBased())) {
-                const msg = await thread.send(text);
-                return msg.id;
+                return discordRetry(async () => {
+                    const msg = await thread.send(text);
+                    return msg.id;
+                });
             }
         }
         catch {
@@ -147,10 +196,22 @@ export class DiscordBot {
         }
     }
     async uploadFile(channelId, filePath, title) {
-        const ch = await this.fetchTextChannel(channelId);
-        const fileName = title ?? basename(filePath);
-        const fileContent = readFileSync(filePath);
-        await ch.send({ files: [{ attachment: fileContent, name: fileName }] });
+        return discordRetry(async () => {
+            const ch = await this.fetchTextChannel(channelId);
+            const fileName = title ?? basename(filePath);
+            const fileContent = readFileSync(filePath);
+            await ch.send({ files: [{ attachment: fileContent, name: fileName }] });
+        });
+    }
+    async sendDirectMessage(userId, text) {
+        return discordRetry(async () => {
+            const user = await this.client.users.fetch(userId);
+            const msg = await user.send(text);
+            return msg.id;
+        });
+    }
+    async postPrivate(_conversationId, userId, text) {
+        await this.sendDirectMessage(userId, text);
     }
     getAllChannels() {
         return Array.from(this.channels.values());
@@ -159,50 +220,41 @@ export class DiscordBot {
         return Array.from(this.users.values());
     }
     logToFile(channelId, entry) {
-        const dir = join(this.workingDir, channelId);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        appendFileSync(join(dir, "log.jsonl"), `${JSON.stringify(entry)}\n`);
+        appendChannelLog(this.workingDir, channelId, entry);
     }
     logBotResponse(channelId, text, ts) {
-        this.logToFile(channelId, {
-            date: new Date().toISOString(),
-            ts,
-            user: "bot",
-            text,
-            attachments: [],
-            isBot: true,
-        });
+        appendBotResponseLog(this.workingDir, channelId, text, ts);
     }
     /**
-     * Process attachments from a Discord message
-     * Downloads files in background and returns metadata
-     * Returns format compatible with ChatMessage: { name: string, localPath: string }[]
+     * Process attachments from a Discord message.
+     * Downloads files before returning so the agent can read them immediately.
      */
-    processAttachments(channelId, attachments, _messageId) {
-        const result = [];
+    async processAttachments(channelId, attachments, _messageId) {
+        const downloads = [];
         // Discord attachments Collection - iterate over values
         for (const attachment of attachments.values()) {
             if (!attachment.name) {
                 log.logWarning("Discord attachment missing name, skipping", attachment.url);
                 continue;
             }
-            // Generate local filename
             const ts = Date.now();
             const sanitizedName = attachment.name.replace(/[^a-zA-Z0-9._-]/g, "_");
             const filename = `${ts}_${sanitizedName}`;
             const localPath = `${channelId}/attachments/${filename}`;
             const fullDir = join(this.workingDir, channelId, "attachments");
-            result.push({
+            const result = {
                 name: attachment.name,
-                localPath: localPath,
-            });
-            // Download in background (fire and forget)
-            this.downloadAttachment(fullDir, filename, attachment.url).catch((err) => {
+                localPath,
+            };
+            downloads.push(this.downloadAttachment(fullDir, filename, attachment.url)
+                .then(() => result)
+                .catch((err) => {
                 log.logWarning(`Failed to download Discord attachment`, `${filename}: ${err}`);
-            });
+                return null;
+            }));
         }
-        return result;
+        const results = await Promise.all(downloads);
+        return results.filter((attachment) => attachment !== null);
     }
     /**
      * Download an attachment from URL to local file
@@ -219,7 +271,9 @@ export class DiscordBot {
             writeFileSync(join(dir, filename), Buffer.from(buffer));
         }
         catch (err) {
-            throw new Error(`Download failed: ${err instanceof Error ? err.message : String(err)}`);
+            throw new Error(`Download failed: ${err instanceof Error ? err.message : String(err)}`, {
+                cause: err,
+            });
         }
     }
     // ==========================================================================
@@ -228,11 +282,23 @@ export class DiscordBot {
     getQueue(channelId) {
         let queue = this.queues.get(channelId);
         if (!queue) {
-            queue = new ChannelQueue();
+            queue = new ChannelQueue("Discord");
             this.queues.set(channelId, queue);
         }
         return queue;
     }
+    resolveStopTarget(channelId, sessionKey) {
+        const directTarget = resolveStopTarget({
+            handler: this.handler,
+            conversationId: channelId,
+            sessionKey,
+        });
+        if (directTarget)
+            return directTarget;
+        if (sessionKey !== channelId)
+            return null;
+        return resolveOnlyScopedStopTarget(this.handler, channelId);
+    }
     loadCachedGuildData() {
         for (const guild of this.client.guilds.cache.values()) {
             for (const channel of guild.channels.cache.values()) {
@@ -254,7 +320,162 @@ export class DiscordBot {
             return text;
         return text.replace(new RegExp(`<@!?${this.botUserId}>`, "g"), "").trim();
     }
+    resolveConversationContext(input) {
+        if (!input.inGuild) {
+            return {
+                conversationId: input.channelId,
+                threadTs: input.referencedMsgId,
+            };
+        }
+        if (input.isThread) {
+            return {
+                conversationId: input.parentChannelId ?? input.channelId,
+                threadTs: input.channelId,
+            };
+        }
+        return {
+            conversationId: input.channelId,
+            threadTs: input.referencedMsgId,
+        };
+    }
+    createSlashCommandAdapters(interaction, commandText, sessionKey, conversationId) {
+        const isDM = !interaction.inGuild();
+        const userId = interaction.user.id;
+        const userName = interaction.user.username;
+        const platform = this.getPlatformInfo();
+        const shouldUseEphemeral = !isDM;
+        const message = {
+            id: interaction.id,
+            sessionKey,
+            conversationKind: isDM ? "direct" : "shared",
+            userId,
+            userName,
+            text: commandText,
+            attachments: [],
+        };
+        const respondPrivately = async (text, replace = false) => {
+            if (interaction.replied || interaction.deferred) {
+                if (replace) {
+                    await interaction.editReply({ content: text });
+                }
+                else {
+                    await interaction.followUp({ content: text, ephemeral: shouldUseEphemeral });
+                }
+                return;
+            }
+            await interaction.reply({ content: text, ephemeral: shouldUseEphemeral });
+        };
+        const responseCtx = {
+            respond: async (text) => {
+                await respondPrivately(text);
+            },
+            replaceResponse: async (text) => {
+                await respondPrivately(text, true);
+            },
+            respondDiagnostic: async (text) => {
+                await respondPrivately(text);
+            },
+            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);
+            },
+            setTyping: async () => { },
+            setWorking: async () => { },
+            uploadFile: async (filePath, title) => {
+                await this.uploadFile(conversationId, filePath, title);
+            },
+            deleteResponse: async () => { },
+        };
+        return { message, responseCtx, platform };
+    }
     setupEventHandlers() {
+        this.client.on(Events.InteractionCreate, async (interaction) => {
+            if (!interaction.isChatInputCommand())
+                return;
+            if (interaction.commandName !== "login" &&
+                interaction.commandName !== "session" &&
+                interaction.commandName !== "new" &&
+                interaction.commandName !== "stop" &&
+                interaction.commandName !== "model" &&
+                interaction.commandName !== "sandbox") {
+                return;
+            }
+            const isDM = !interaction.inGuild();
+            const { conversationId, threadTs } = this.resolveConversationContext({
+                channelId: interaction.channelId,
+                inGuild: interaction.inGuild(),
+                isThread: interaction.channel?.isThread() ?? false,
+                parentChannelId: interaction.channel && "parentId" in interaction.channel
+                    ? interaction.channel.parentId
+                    : null,
+            });
+            const sessionKey = resolveChatSessionKey({
+                conversationId,
+                conversationKind: isDM ? "direct" : "shared",
+                messageId: interaction.id,
+                persistentTopLevel: true,
+                threadTs,
+            });
+            const modelOption = interaction.commandName === "model"
+                ? interaction.options.getString("model")?.trim()
+                : undefined;
+            const sandboxAction = interaction.commandName === "sandbox"
+                ? interaction.options.getString("action")?.trim()
+                : undefined;
+            const commandArg = modelOption ?? sandboxAction;
+            const commandText = commandArg
+                ? `/${interaction.commandName} ${commandArg}`
+                : `/${interaction.commandName}`;
+            this.logToFile(conversationId, {
+                date: new Date(interaction.createdTimestamp).toISOString(),
+                ts: interaction.id,
+                ...(threadTs ? { threadTs } : {}),
+                user: interaction.user.id,
+                userName: interaction.user.username,
+                text: commandText,
+                attachments: [],
+                isBot: false,
+            });
+            const adapters = this.createSlashCommandAdapters(interaction, commandText, sessionKey, conversationId);
+            try {
+                if (interaction.commandName === "new") {
+                    await this.handler.handleNewCommand(sessionKey, conversationId, this);
+                    return;
+                }
+                if (interaction.commandName === "stop") {
+                    const stopTarget = this.resolveStopTarget(conversationId, sessionKey);
+                    if (stopTarget) {
+                        await this.handler.handleStop(stopTarget, conversationId, this);
+                    }
+                    else {
+                        await adapters.responseCtx.respond(formatNothingRunning("discord"));
+                    }
+                    return;
+                }
+                const event = {
+                    type: "dm",
+                    conversationId,
+                    conversationKind: isDM ? "direct" : "shared",
+                    ts: interaction.id,
+                    thread_ts: threadTs,
+                    sessionKey,
+                    user: interaction.user.id,
+                    text: commandText,
+                    attachments: [],
+                };
+                await this.handler.handleEvent(event, this, adapters, false);
+            }
+            catch (err) {
+                log.logWarning("Discord slash command error", err instanceof Error ? err.message : String(err));
+                if (!interaction.replied && !interaction.deferred) {
+                    await interaction.reply({
+                        content: `${interaction.commandName} command failed. Please try again later.`,
+                        ephemeral: !isDM,
+                    });
+                }
+            }
+        });
         this.client.on(Events.MessageCreate, async (msg) => {
             // Skip messages from before startup
             if (msg.createdTimestamp < this.startupTime)
@@ -262,12 +483,19 @@ export class DiscordBot {
             // Skip bot messages
             if (msg.author.bot)
                 return;
-            // Skip if bot isn't mentioned and it's not a DM
             const isDM = msg.channel.type === 1; // ChannelType.DM = 1
+            const isInThread = msg.channel.isThread();
+            const referencedMsgId = msg.reference?.messageId;
+            const isThreadReply = isInThread || !!referencedMsgId;
             const isMentioned = msg.mentions.users.has(this.botUserId ?? "");
-            if (!isDM && !isMentioned)
-                return;
-            const channelId = msg.channelId;
+            const isAutoReplyCandidate = !isDM && !isMentioned && !isThreadReply;
+            const { conversationId, threadTs } = this.resolveConversationContext({
+                channelId: msg.channelId,
+                inGuild: !isDM,
+                isThread: isInThread,
+                parentChannelId: "parentId" in msg.channel ? msg.channel.parentId : null,
+                referencedMsgId,
+            });
             const userId = msg.author.id;
             const userName = msg.author.username;
             const msgId = msg.id;
@@ -278,57 +506,64 @@ export class DiscordBot {
                 displayName: msg.member?.displayName ?? userName,
             });
             // Track channel
-            if (!this.channels.has(channelId) && "name" in msg.channel) {
+            if (!this.channels.has(conversationId) && "name" in msg.channel) {
                 const ch = msg.channel;
-                this.channels.set(channelId, { id: channelId, name: ch.name });
+                this.channels.set(conversationId, { id: conversationId, name: ch.name });
             }
-            // Thread: if this message is in a thread (has parentId) or is a reply
-            const isInThread = msg.channel.isThread();
-            const referencedMsgId = msg.reference?.messageId;
-            const threadTs = isInThread ? msg.channelId : referencedMsgId;
-            const sessionKey = `${channelId}:${threadTs ?? msgId}`;
+            const conversationKind = isDM ? "direct" : "shared";
+            const sessionKey = resolveChatSessionKey({
+                conversationId,
+                conversationKind,
+                messageId: msgId,
+                persistentTopLevel: true,
+                threadTs,
+            });
             const cleanedText = this.stripBotMention(msg.content);
-            // Process attachments (download in background)
-            const processedAttachments = this.processAttachments(channelId, msg.attachments, msgId);
-            const event = {
+            const eventBase = {
                 type: isDM ? "dm" : "mention",
-                channel: channelId,
+                conversationId,
+                conversationKind,
                 ts: msgId,
                 thread_ts: threadTs,
+                sessionKey,
                 user: userId,
                 userName,
                 text: cleanedText,
-                attachments: processedAttachments,
             };
-            // Log message
-            this.logToFile(channelId, {
+            // Handle stop before trigger gate — "stop" should never be auto-reply judged.
+            if (cleanedText.toLowerCase() === "stop" || cleanedText.toLowerCase() === "/stop") {
+                const stopTarget = this.resolveStopTarget(conversationId, sessionKey);
+                if (stopTarget) {
+                    this.handler.handleStop(stopTarget, conversationId, this);
+                }
+                else if (!isAutoReplyCandidate) {
+                    await this.postMessage(conversationId, formatNothingRunning("discord"));
+                }
+                return;
+            }
+            const triggerResult = isAutoReplyCandidate
+                ? await evaluateAutoReplyPolicy({ event: eventBase, workingDir: this.workingDir })
+                : { trigger: true, reason: "addressed" };
+            const logEntryBase = {
                 date: msg.createdAt.toISOString(),
                 ts: msgId,
+                ...(!isDM && threadTs ? { threadTs } : {}),
                 user: userId,
                 userName,
                 text: cleanedText,
-                attachments: processedAttachments,
                 isBot: false,
-            });
-            // Handle stop command
-            if (cleanedText.toLowerCase() === "stop" || cleanedText.toLowerCase() === "/stop") {
-                if (this.handler.isRunning(sessionKey)) {
-                    this.handler.handleStop(sessionKey, channelId, this);
-                }
-                else {
-                    await this.postMessage(channelId, "_Nothing running_");
-                }
+            };
+            if (!triggerResult.trigger) {
+                this.logToFile(conversationId, { ...logEntryBase, attachments: [] });
                 return;
             }
-            if (this.handler.isRunning(sessionKey)) {
-                await this.postMessage(channelId, "_Already working. Say `stop` to cancel._");
-            }
-            else {
-                this.getQueue(sessionKey).enqueue(() => {
-                    const adapters = createDiscordAdapters(event, this, false);
-                    return this.handler.handleEvent(event, this, adapters, false);
-                });
-            }
+            const processedAttachments = await this.processAttachments(conversationId, msg.attachments, msgId);
+            const event = { ...eventBase, attachments: processedAttachments };
+            this.logToFile(conversationId, { ...logEntryBase, attachments: processedAttachments });
+            this.getQueue(sessionKey).enqueue(() => {
+                const adapters = createDiscordAdapters(event, this, false);
+                return this.handler.handleEvent(event, this, adapters, false);
+            });
         });
     }
     async fetchTextChannel(channelId) {