@songsid/agend 2.0.8-beta.1 → 2.0.8-beta.11

package/dist/fleet-manager.js

@@ -78,6 +78,11 @@ export class FleetManager {
     topicIcons = {};
     lastActivity = new Map();
     lastInboundUser = new Map(); // instanceName → last username
+    // Pending "🛑 Cancel" button per instance — sent after a message is delivered,
+    // retired when the agent replies, when cancelled, or after a timeout.
+    pendingCancelMessages = new Map();
+    // Last user message delivered to each instance — used to react ✅ on completion.
+    lastInboundMsg = new Map();
     topicArchiver;
     controlClient = null;
     classicChannels = null;
@@ -739,6 +744,15 @@ export class FleetManager {
                 }
                 return;
             }
+            if (data.callbackData.startsWith("cancel:")) {
+                const instanceName = data.callbackData.slice("cancel:".length);
+                // Idempotent: a button click only acts while the button is live. A
+                // second click (entry already cleared) is a no-op — don't re-send the
+                // interrupt key. (The /cancel command path calls cancelInstance directly.)
+                if (this.pendingCancelMessages.has(instanceName))
+                    this.cancelInstance(instanceName);
+                return;
+            }
         }, this.logger, "adapter.callback_query"));
         this.adapter.on("topic_closed", safeHandler(async (data) => {
             // Skip unbind if we archived this topic ourselves
@@ -819,48 +833,23 @@ export class FleetManager {
                 const result = await this.topicCommands.sendCompact(target.name);
                 await data.respond(result);
             }
-            else if (data.command === "ctx") {
+            else if (data.command === "cancel") {
                 const target = this.routing.resolve(data.channelId);
                 if (!target) {
                     await data.respond("No active agent in this channel.");
                     return;
                 }
-                const instanceName = target.name;
-                const backend = target.kind === "classic"
-                    ? (this.classicChannels?.getBackendByInstance(instanceName, this.fleetConfig?.defaults?.backend) ?? "claude-code")
-                    : (this.fleetConfig?.instances[instanceName]?.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code");
-                let context = null;
-                // Try statusline.json first
-                try {
-                    const statusFile = join(this.getInstanceDir(instanceName), "statusline.json");
-                    if (existsSync(statusFile)) {
-                        const d = JSON.parse(readFileSync(statusFile, "utf-8"));
-                        context = d.context_window?.used_percentage ?? null;
-                    }
-                }
-                catch { /* ignore */ }
-                // Fallback: capture tmux pane
-                if (context == null) {
-                    try {
-                        const { execFileSync } = await import("node:child_process");
-                        const { getTmuxSocketName } = await import("./paths.js");
-                        const socketName = getTmuxSocketName();
-                        const tmuxArgs = socketName
-                            ? ["-L", socketName, "capture-pane", "-t", `${getTmuxSession()}:${instanceName}`, "-p"]
-                            : ["capture-pane", "-t", `${getTmuxSession()}:${instanceName}`, "-p"];
-                        const pane = execFileSync("tmux", tmuxArgs, { encoding: "utf-8", timeout: 2000, stdio: ["pipe", "pipe", "pipe"] });
-                        const m = pane.match(/(\d+)%.*[!❯>]/m) || pane.match(/◔\s*(\d+)%/) || pane.match(/\[(\d+)%\]/);
-                        if (m)
-                            context = parseInt(m[1], 10);
-                    }
-                    catch { /* ignore */ }
-                }
-                if (context != null) {
-                    await data.respond(`📊 Context: ${context}% used\nBackend: ${backend}\nInstance: ${instanceName}`);
-                }
-                else {
-                    await data.respond(`Context info not available yet.\nBackend: ${backend}\nInstance: ${instanceName}`);
+                const ok = this.cancelInstance(target.name);
+                await data.respond(ok ? `🛑 Sent cancel to ${target.name}.` : `❌ ${target.name} not running.`);
+            }
+            else if (data.command === "ctx") {
+                const target = this.routing.resolve(data.channelId);
+                if (!target) {
+                    await data.respond("No active agent in this channel.");
+                    return;
                 }
+                // Single source of truth (statusline.json + robust tmux pane fallback).
+                await data.respond(await this.topicCommands.getCtxText(target.name));
             }
             else if (data.command === "collab") {
                 const collabTarget = this.routing.resolve(data.channelId);
@@ -1026,6 +1015,14 @@ export class FleetManager {
                 else {
                     adapter.editMessage(data.chatId, data.messageId, `⏳ Continuing to wait for ${instanceName}.`).catch(() => { });
                 }
+                return;
+            }
+            if (data.callbackData.startsWith("cancel:")) {
+                const instanceName = data.callbackData.slice("cancel:".length);
+                // Idempotent: only the first click (while the button is live) acts.
+                if (this.pendingCancelMessages.has(instanceName))
+                    this.cancelInstance(instanceName);
+                return;
             }
         }, this.logger, `adapter[${adapterId}].callback_query`));
         adapter.on("topic_closed", safeHandler(async (data) => {
@@ -1106,6 +1103,15 @@ export class FleetManager {
                 const result = await this.topicCommands.sendCompact(target.name);
                 await data.respond(result);
             }
+            else if (data.command === "cancel") {
+                const target = this.routing.resolve(data.channelId);
+                if (!target) {
+                    await data.respond("No active agent in this channel.");
+                    return;
+                }
+                const ok = this.cancelInstance(target.name);
+                await data.respond(ok ? `🛑 Sent cancel to ${target.name}.` : `❌ ${target.name} not running.`);
+            }
             else if (data.command === "ctx") {
                 const target = this.routing.resolve(data.channelId);
                 if (!target) {
@@ -1567,6 +1573,17 @@ export class FleetManager {
                     await msgAdapter?.sendText(chatId, result);
                     return;
                 }
+                // Handle /cancel command
+                if (text === "/cancel" || text.startsWith("/cancel@")) {
+                    const cancelTarget = this.routing.resolve(chatId);
+                    if (!cancelTarget || cancelTarget.kind !== "classic") {
+                        await msgAdapter?.sendText(chatId, "No active agent. Use /start first.");
+                        return;
+                    }
+                    const ok = this.cancelInstance(cancelTarget.name);
+                    await msgAdapter?.sendText(chatId, ok ? `🛑 已送出取消給 ${cancelTarget.name}。` : `❌ ${cancelTarget.name} 未在執行。`);
+                    return;
+                }
                 // Handle /ctx command
                 if (text === "/ctx" || text.startsWith("/ctx@")) {
                     const ctxTarget = this.routing.resolve(chatId);
@@ -1654,6 +1671,8 @@ export class FleetManager {
                         instance: generalInstance, sender: msg.username,
                         text: (text ?? "").slice(0, 2000), ts: new Date().toISOString(),
                     });
+                    this.trackInboundMsg(generalInstance, msg);
+                    void this.sendCancelButton(generalInstance);
                 }
             }
             return;
@@ -1691,7 +1710,7 @@ export class FleetManager {
         const inboundAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
         // React immediately — before any other Discord API calls
         if (msg.chatId && msg.messageId) {
-            inboundAdapter.react(msg.threadId ?? msg.chatId, msg.messageId, "👀")
+            inboundAdapter.react(this.reactTarget(msg), msg.messageId, "👀")
                 .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
         }
         // These may hit Discord API (topic icon, archive) — do after react
@@ -1730,6 +1749,8 @@ export class FleetManager {
             instance: instanceName, sender: msg.username,
             text: (text ?? "").slice(0, 2000), ts: new Date().toISOString(),
         });
+        this.trackInboundMsg(instanceName, msg);
+        void this.sendCancelButton(instanceName);
     }
     /** Handle outbound tool calls from a daemon instance */
     /** Warn (but don't block) when rate limits are high. 30-min debounce per instance. */
@@ -1803,6 +1824,9 @@ export class FleetManager {
         // Route standard channel tools (reply, react, edit_message, download_attachment)
         if (routeToolCall(outAdapter, tool, args, threadId, respond)) {
             if (tool === "reply") {
+                // Agent answered — retire its pending cancel button and mark ✅ done.
+                this.clearCancelButton(instanceName);
+                this.reactDone(instanceName);
                 const replyTo = this.lastInboundUser.get(instanceName) ?? "user";
                 this.logger.info(`${instanceName} → ${replyTo}: ${(args.text ?? "").slice(0, 100)}`);
                 this.emitSseEvent("message", {
@@ -1887,6 +1911,8 @@ export class FleetManager {
                 payload: { schedule_id: id, message: `[Scheduled] ${message}`, label },
                 meta: { chat_id: reply_chat_id, thread_id: reply_thread_id, user: "scheduler" },
             });
+            // A scheduled trigger also puts the instance to work — show a cancel button.
+            void this.sendCancelButton(target);
             return true;
         };
         if (deliver()) {
@@ -2512,6 +2538,114 @@ export class FleetManager {
                 .catch(e => this.logger.warn({ err: e, instanceName }, "Failed to send notification (no topic)"));
         }
     }
+    // ── Cancel button ────────────────────────────────────────────────────
+    // Sent after delivering a user message to an instance; clicking it (or
+    // /cancel) sends Escape to the instance's pane to interrupt generation.
+    /** Send a "🛑 Cancel" button to the instance's topic/channel after delivery. */
+    async sendCancelButton(instanceName) {
+        // Replace any stale button for this instance first.
+        this.clearCancelButton(instanceName);
+        const adapter = this.getAdapterForInstance(instanceName) ?? this.adapter;
+        if (!adapter)
+            return;
+        const adapterId = this.instanceWorldBinding.get(instanceName);
+        const groupId = this.getChannelConfig(adapterId)?.group_id;
+        const topicId = this.fleetConfig?.instances[instanceName]?.topic_id;
+        let chatId;
+        let threadId;
+        if (topicId != null && groupId) {
+            // Fleet topic instance.
+            chatId = String(groupId);
+            threadId = String(topicId);
+        }
+        else {
+            // Classic instance: chatId from the routing table.
+            for (const [cid, target] of this.routing.entries()) {
+                if (target.kind === "classic" && target.name === instanceName) {
+                    chatId = cid;
+                    break;
+                }
+            }
+            // General / flat fallback: post to the group (no thread).
+            if (!chatId && groupId)
+                chatId = String(groupId);
+        }
+        if (!chatId)
+            return;
+        try {
+            const sent = await adapter.notifyAlert(chatId, {
+                type: "cancel",
+                instanceName,
+                message: "👀 處理中…",
+                choices: [{ id: `cancel:${instanceName}`, label: "🛑 取消" }],
+            }, threadId ? { threadId } : undefined);
+            const timer = setTimeout(() => this.clearCancelButton(instanceName), 30_000);
+            this.pendingCancelMessages.set(instanceName, {
+                adapterId, chatId: sent.chatId, messageId: sent.messageId, threadId: sent.threadId ?? threadId, timer,
+            });
+        }
+        catch (e) {
+            this.logger.debug({ err: e.message, instanceName }, "Failed to send cancel button");
+        }
+    }
+    /** Retire (delete) the pending cancel button — on reply, cancel, or timeout. */
+    clearCancelButton(instanceName) {
+        const pending = this.pendingCancelMessages.get(instanceName);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingCancelMessages.delete(instanceName);
+        const adapter = (pending.adapterId ? this.worlds.get(pending.adapterId)?.adapter : undefined)
+            ?? this.getAdapterForInstance(instanceName) ?? this.adapter;
+        if (!adapter)
+            return;
+        if (adapter.deleteMessage) {
+            adapter.deleteMessage(pending.chatId, pending.messageId)
+                .catch((e) => this.logger.debug({ err: e.message, instanceName }, "Failed to delete cancel button"));
+        }
+        else {
+            // Fallback for adapters without delete: at least drop the button.
+            const remove = adapter.editMessageRemoveButtons?.bind(adapter) ?? adapter.editMessage.bind(adapter);
+            remove(pending.chatId, pending.messageId, "✅").catch(() => { });
+        }
+    }
+    /**
+     * Reaction target chat id. Telegram reactions key on the supergroup chat_id
+     * (the topic thread is NOT a chat_id), so a forum-topic message must react on
+     * msg.chatId — reacting on threadId silently fails. Discord reactions key on
+     * the channel/thread id.
+     */
+    reactTarget(msg) {
+        return msg.source === "telegram" ? msg.chatId : (msg.threadId ?? msg.chatId);
+    }
+    /** Remember the user message just delivered, so we can react ✅ when done. */
+    trackInboundMsg(instanceName, msg) {
+        if (!msg.chatId || !msg.messageId)
+            return;
+        this.lastInboundMsg.set(instanceName, {
+            adapterId: msg.adapterId, chatId: msg.chatId, threadId: msg.threadId ?? undefined, messageId: msg.messageId, source: msg.source,
+        });
+    }
+    /** React ✅ on the last user message after the agent replies. */
+    reactDone(instanceName) {
+        const m = this.lastInboundMsg.get(instanceName);
+        if (!m)
+            return;
+        this.lastInboundMsg.delete(instanceName);
+        const adapter = (m.adapterId ? this.worlds.get(m.adapterId)?.adapter : undefined)
+            ?? this.getAdapterForInstance(instanceName) ?? this.adapter;
+        adapter?.react(this.reactTarget(m), m.messageId, "✅").catch(() => { });
+    }
+    /** Interrupt an instance's current generation (cancel button / /cancel). */
+    cancelInstance(instanceName) {
+        const daemon = this.daemons.get(instanceName);
+        if (!daemon)
+            return false;
+        daemon.sendEscape().catch(e => this.logger.warn({ err: e, instanceName }, "sendEscape failed"));
+        this.lastInboundMsg.delete(instanceName);
+        this.clearCancelButton(instanceName);
+        return true;
+    }
     queueMirrorMessage(text) {
         const mirrorTopicId = this.fleetConfig?.channel?.mirror_topic_id;
         if (mirrorTopicId == null || !this.adapter)
@@ -2850,10 +2984,17 @@ When users create specialized instances, suggest these configurations:
             // Skip empty bot messages (e.g., reactions) — don't pollute chat log
             if (msg.isBotMessage && !text && !msg.attachments?.length)
                 return;
+            // Save attachments FIRST so the chat-log records their inbox paths
+            // (consistent with the /chat path). Otherwise a non-@mention image is
+            // saved to inbox but its path never reaches the agent — the log keeps
+            // only a pathless filename, so later context can't locate the file.
+            const saved = msg.attachments?.length ? await this.saveClassicAttachment(instanceName, msg) : undefined;
             // Log every message (including other bots) to chat-logs
-            const collabAttachTag = msg.attachments?.length
-                ? ` [${msg.attachments.map(a => `${a.kind === "photo" ? "📷" : "📎"} ${a.filename || a.kind}`).join(", ")}]`
-                : "";
+            const collabAttachTag = saved
+                ? ` [${saved.kind === "photo" ? "📷" : "📎"} saved: ${saved.paths.join(", ")}]`
+                : (msg.attachments?.length
+                    ? ` [${msg.attachments.map(a => `${a.kind === "photo" ? "📷" : "📎"} ${a.filename || a.kind}`).join(", ")}]`
+                    : "");
             ClassicChannelManager.logMessage(instanceName, msg.username, text + collabAttachTag, msg.timestamp, msg.replyToText);
             this.logger.info({ instanceName, user: msg.username, textLen: text.length, attachments: msg.attachments?.length ?? 0, source: msg.source }, "Collab mode message");
             // Check for @mention trigger: must be exact <@BOT_USER_ID>, not @everyone/@here
@@ -2861,19 +3002,16 @@ When users create specialized instances, suggest these configurations:
             const mentionTag = adapterBotUserId ? `<@${adapterBotUserId}>` : null;
             const isMentioned = mentionTag && text.includes(mentionTag);
             if (!isMentioned) {
-                // Save bare attachments (stickers, images) even without @mention
-                if (msg.attachments?.length) {
-                    const saved = await this.saveClassicAttachment(instanceName, msg);
-                    if (saved) {
-                        const reactAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
-                        const noMentionReactChatId = msg.threadId ?? msg.chatId;
-                        if (reactAdapter && noMentionReactChatId && msg.messageId) {
-                            const emoji = msg.source === "telegram"
-                                ? (saved.kind === "photo" ? "👌" : "👍")
-                                : (saved.kind === "photo" ? "📸" : "📎");
-                            reactAdapter.react(noMentionReactChatId, msg.messageId, emoji)
-                                .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
-                        }
+                // Bare attachment (no @mention) — already saved above; just acknowledge.
+                if (saved) {
+                    const reactAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
+                    const noMentionReactChatId = msg.threadId ?? msg.chatId;
+                    if (reactAdapter && noMentionReactChatId && msg.messageId) {
+                        const emoji = msg.source === "telegram"
+                            ? (saved.kind === "photo" ? "👌" : "👍")
+                            : (saved.kind === "photo" ? "📸" : "📎");
+                        reactAdapter.react(noMentionReactChatId, msg.messageId, emoji)
+                            .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
                     }
                 }
                 return;
@@ -2891,8 +3029,7 @@ When users create specialized instances, suggest these configurations:
             // Block /raw bypass
             if (cleanText.startsWith("/raw "))
                 return;
-            // Save and process attachments (same as /chat mode)
-            const saved = await this.saveClassicAttachment(instanceName, msg);
+            // Attachments already saved at the top of the collab block.
             if (saved && classicAdapter && collabReactChatId && msg.messageId) {
                 const emoji = msg.source === "telegram"
                     ? (saved.kind === "photo" ? "👌" : "👍")
@@ -3049,24 +3186,37 @@ When users create specialized instances, suggest these configurations:
             this.logger.warn({ instanceName }, "Classic channel instance IPC not connected");
             return;
         }
+        const meta = {
+            chat_id: msg.chatId,
+            message_id: msg.messageId,
+            user: msg.username,
+            user_id: msg.userId,
+            ts: msg.timestamp.toISOString(),
+            thread_id: msg.threadId ?? "",
+            source: msg.source,
+            ...extraMeta,
+            ...(msg.replyToText ? { reply_to_text: msg.replyToText } : {}),
+        };
+        // If the triggering message carried no image of its own, surface the most
+        // recent image saved earlier in this channel (logged as "[📷 saved: <path>]"
+        // by an untriggered collab message) as image_path, so the agent's
+        // read-the-image trigger fires instead of the path sitting inert in context.
+        if (!meta.image_path && logContext) {
+            const saves = [...logContext.matchAll(/\[📷 saved: ([^\]]+)\]/g)];
+            if (saves.length > 0) {
+                meta.image_path = saves[saves.length - 1][1].split(",")[0].trim();
+            }
+        }
         ipc.send({
             type: "fleet_inbound",
             content: fullText,
             targetSession: instanceName,
-            meta: {
-                chat_id: msg.chatId,
-                message_id: msg.messageId,
-                user: msg.username,
-                user_id: msg.userId,
-                ts: msg.timestamp.toISOString(),
-                thread_id: msg.threadId ?? "",
-                source: msg.source,
-                ...extraMeta,
-                ...(msg.replyToText ? { reply_to_text: msg.replyToText } : {}),
-            },
+            meta,
         });
         this.lastInboundUser.set(instanceName, msg.username);
         this.logger.info(`${msg.username} → ${instanceName} (classic): ${text.slice(0, 100)}`);
+        this.trackInboundMsg(instanceName, msg);
+        void this.sendCancelButton(instanceName);
     }
     /** Paste raw text directly to a classic instance's CLI (no [user:] wrapping) */
     pasteRawToClassicInstance(instanceName, text) {
@@ -3186,9 +3336,11 @@ When users create specialized instances, suggest these configurations:
         this.topicArchiver.stop();
         this.scheduler?.shutdown();
         // Stop instances in parallel batches to avoid long sequential waits.
-        // Concurrency limited to avoid overwhelming the tmux server.
-        const STOP_CONCURRENCY = 5;
+        // Concurrency scales with fleet size — larger fleets tolerate more parallel
+        // tmux ops, while small fleets stay conservative to avoid overwhelming the
+        // tmux server.
         const entries = [...this.daemons.entries()];
+        const STOP_CONCURRENCY = entries.length > 30 ? 15 : entries.length >= 10 ? 10 : 5;
         for (const [name] of entries)
             this.ipcStoppingInstances.add(name);
         for (let i = 0; i < entries.length; i += STOP_CONCURRENCY) {
@@ -3203,9 +3355,9 @@ When users create specialized instances, suggest these configurations:
                 this.daemons.delete(name);
             }));
         }
-        for (const [, ipc] of this.instanceIpcClients) {
-            await ipc.close();
-        }
+        // Close IPC clients in parallel — serial close over a large fleet adds
+        // noticeable latency.
+        await Promise.all([...this.instanceIpcClients.values()].map(ipc => Promise.resolve(ipc.close()).catch(() => { })));
         this.instanceIpcClients.clear();
         this.ipcStoppingInstances.clear();
         for (const [, w] of this.worlds) {