@songsid/agend 2.1.3 → 2.1.4-beta.2

package/dist/fleet-manager.d.ts

@@ -119,6 +119,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
     private pendingEffortSelects;
     private pendingModelSelects;
+    /** One-shot General assistance buttons for stable interactive terminal prompts. */
+    private pendingInteractivePromptAssists;
     private failoverActive;
     /** instance → when a click with no live button entry last fired a cancel. */
     private staleCancelClickAt;
@@ -216,6 +218,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private isModelAdmin;
     private handlePauseWakeSlash;
+    /** Admin-only full conversation reset for fleet-topic and Classic instances. */
+    private handleClearSlash;
     /** Get the adapter bound to an instance, falling back to primary adapter */
     getAdapterForInstance(name: string): ChannelAdapter | null;
     /** Get the world for an instance */
@@ -426,8 +430,6 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private handleOutboundFromInstance;
     /** Side effects of a routed reply: cancel-button lifecycle, logs, SSE, chat log. */
     private afterReplyRouted;
-    /** Handle tool status update from a daemon instance */
-    private handleToolStatusFromInstance;
     private handleScheduleTrigger;
     private notifySourceTopic;
     private notifyScheduleFailure;
@@ -530,6 +532,19 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private static readonly FLEET_ERROR_THROTTLE_MS;
     private fleetErrorNotices;
     notifyInstanceTopic(instanceName: string, text: string, extraOpts?: import("./channel/types.js").SendOpts): void;
+    private interactivePromptLabel;
+    /**
+     * Surface a stable terminal prompt in both places that matter:
+     * - the blocked instance gets a plain pointer to General;
+     * - General gets one-shot Confirm/Cancel controls on its own bound adapter.
+     *
+     * Only the prompt category crosses channels. The captured terminal line can
+     * contain usernames or secret-adjacent text and stays in daemon.log.
+     */
+    notifyInteractivePrompt(instanceName: string, kind: string): Promise<void>;
+    private retireInteractivePromptButtons;
+    /** Consume a General assist button exactly once. */
+    private handleInteractivePromptAssist;
     /** Send a "🛑 Cancel" button to the instance's topic/channel after delivery. */
     /**
      * Handle the DC `/save` slash command for both classic AND fleet-topic targets.

package/dist/fleet-manager.js

@@ -165,6 +165,8 @@ const CLASSIC_BACKEND_SELECTION_TIMEOUT_MS = 60_000;
 const CLASSIC_BACKEND_CALLBACK_PREFIX = "classic-backend:";
 const MODEL_SELECT_CALLBACK_PREFIX = "model-select:";
 const EFFORT_SELECT_CALLBACK_PREFIX = "effort-select:";
+const INTERACTIVE_ASSIST_CALLBACK_PREFIX = "interactive-assist:";
+const INTERACTIVE_ASSIST_TIMEOUT_MS = 15 * 60_000;
 const CLI_ENV_TTL_MS = 24 * 60 * 60 * 1000; // /model reads cached CLI env within 24h
 export class FleetManager {
     dataDir;
@@ -253,6 +255,8 @@ export class FleetManager {
     /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
     pendingEffortSelects = new Map();
     pendingModelSelects = new Map();
+    /** One-shot General assistance buttons for stable interactive terminal prompts. */
+    pendingInteractivePromptAssists = new Map();
     // Model failover state
     failoverActive = new Map(); // instance → current failover model
     // IPC reconnect: tracks instances being intentionally stopped (skip reconnect)
@@ -553,6 +557,19 @@ export class FleetManager {
         }
         await data.respond(await this.topicCommands.runPauseWake(target, action));
     }
+    /** Admin-only full conversation reset for fleet-topic and Classic instances. */
+    async handleClearSlash(data, adapterId) {
+        if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
+            await data.respond(t("permission.denied"));
+            return;
+        }
+        const name = this.resolveSlashTarget(data.channelId, adapterId);
+        if (!name) {
+            await data.respond(t("classic.no_agent"));
+            return;
+        }
+        await data.respond(await this.topicCommands.sendClear(name));
+    }
     /** Get the adapter bound to an instance, falling back to primary adapter */
     getAdapterForInstance(name) {
         const worldId = this.getInstanceAdapterId(name);
@@ -1980,6 +1997,8 @@ export class FleetManager {
             await this.handleInboundReaction(r);
         }, this.logger, "adapter.reaction"));
         this.adapter.on("callback_query", safeHandler(async (data) => {
+            if (await this.handleInteractivePromptAssist(data, adapterId))
+                return;
             if (await this.handleClassicBackendSelection(data))
                 return;
             if (await this.handleModelSelection(data))
@@ -2083,6 +2102,9 @@ export class FleetManager {
                 const result = await this.topicCommands.sendCompact(name);
                 await data.respond(result);
             }
+            else if (data.command === "clear") {
+                await this.handleClearSlash(data, adapterId);
+            }
             else if (data.command === "model") {
                 await this.handleModelSlash(data, adapterId);
             }
@@ -2290,6 +2312,8 @@ export class FleetManager {
             await this.handleInboundReaction(r);
         }, this.logger, `adapter[${adapterId}].reaction`));
         adapter.on("callback_query", safeHandler(async (data) => {
+            if (await this.handleInteractivePromptAssist(data, adapterId))
+                return;
             if (await this.handleClassicBackendSelection(data))
                 return;
             if (await this.handleModelSelection(data))
@@ -2385,6 +2409,9 @@ export class FleetManager {
             else if (data.command === "model") {
                 await this.handleModelSlash(data, adapterId);
             }
+            else if (data.command === "clear") {
+                await this.handleClearSlash(data, adapterId);
+            }
             else if (data.command === "effort") {
                 await this.handleEffortSlash(data, adapterId);
             }
@@ -2607,9 +2634,6 @@ export class FleetManager {
                     }
                     await this.handleOutboundFromInstance(name, msg);
                 }
-                else if (msg.type === "fleet_tool_status") {
-                    this.handleToolStatusFromInstance(name, msg);
-                }
                 else if (msg.type === "fleet_schedule_create" || msg.type === "fleet_schedule_list" ||
                     msg.type === "fleet_schedule_update" || msg.type === "fleet_schedule_delete") {
                     this.handleScheduleCrud(name, msg);
@@ -3076,6 +3100,21 @@ export class FleetManager {
                     await msgAdapter?.sendText(chatId, result);
                     return;
                 }
+                // Handle /clear command (admin only) — unlike /compact this starts a
+                // fresh conversation and intentionally discards the current history.
+                if (text === "/clear" || text.startsWith("/clear@")) {
+                    if (!this.isModelAdmin(msg.userId, chatId, msg.adapterId)) {
+                        await msgAdapter?.sendText(chatId, t("cmd.admin_required", "/clear"));
+                        return;
+                    }
+                    const clearName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!clearName) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
+                        return;
+                    }
+                    await msgAdapter?.sendText(chatId, await this.topicCommands.sendClear(clearName));
+                    return;
+                }
                 // Handle /cancel command
                 if (text === "/cancel" || text.startsWith("/cancel@")) {
                     const cancelName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
@@ -3482,34 +3521,6 @@ export class FleetManager {
             ClassicChannelManager.logMessage(instanceName, "bot", args.text ?? "", new Date());
         }
     }
-    /** Handle tool status update from a daemon instance */
-    handleToolStatusFromInstance(instanceName, msg) {
-        const statusAdapter = this.getAdapterForInstance(instanceName) ?? this.adapter;
-        if (!statusAdapter)
-            return;
-        const text = msg.text;
-        const editMessageId = msg.editMessageId;
-        const senderSessionName = msg.senderSessionName;
-        const senderInstanceName = senderSessionName && this.fleetConfig?.instances[senderSessionName]
-            ? senderSessionName
-            : null;
-        const routingConfig = senderInstanceName
-            ? this.fleetConfig?.instances[senderInstanceName]
-            : (senderSessionName ? undefined : this.fleetConfig?.instances[instanceName]);
-        const threadId = routingConfig?.topic_id ? String(routingConfig.topic_id) : undefined;
-        const chatId = statusAdapter.getChatId();
-        if (!chatId)
-            return;
-        if (editMessageId) {
-            statusAdapter.editMessage(chatId, editMessageId, text, threadId).catch(e => this.logger.debug({ err: e }, "Failed to edit tool status message"));
-        }
-        else {
-            statusAdapter.sendText(chatId, text, { threadId }).then((sent) => {
-                const ipc = this.instanceIpcClients.get(instanceName);
-                ipc?.send({ type: "fleet_tool_status_ack", messageId: sent.messageId });
-            }).catch(e => this.logger.warn({ err: e }, "Failed to send tool status message"));
-        }
-    }
     // ===================== Scheduler =====================
     async handleScheduleTrigger(schedule) {
         const { target, reply_chat_id, reply_thread_id, message, label, id, source, silent } = schedule;
@@ -4243,7 +4254,13 @@ export class FleetManager {
         }
         catch (err) {
             const e = err;
-            return stripAnsi(e.stdout ?? e.message ?? "Doctor failed");
+            const output = stripAnsi(e.stdout ?? "").trim();
+            if (output)
+                return output;
+            if (e.code === "ENOENT") {
+                return "Backend doctor unavailable — agend CLI not found in PATH";
+            }
+            return stripAnsi(e.message ?? "").trim() || "Doctor failed";
         }
     }
     /** Drop event/activity rows older than the retention window. Best-effort. */
@@ -4395,6 +4412,163 @@ export class FleetManager {
                 .catch(e => this.logger.warn({ err: e, instanceName }, "Failed to send notification (no topic)"));
         }
     }
+    interactivePromptLabel(kind) {
+        const key = `interactive.kind.${kind}`;
+        const translated = t(key);
+        return translated === key ? kind.replaceAll("_", " ") : translated;
+    }
+    /**
+     * Surface a stable terminal prompt in both places that matter:
+     * - the blocked instance gets a plain pointer to General;
+     * - General gets one-shot Confirm/Cancel controls on its own bound adapter.
+     *
+     * Only the prompt category crosses channels. The captured terminal line can
+     * contain usernames or secret-adjacent text and stays in daemon.log.
+     */
+    async notifyInteractivePrompt(instanceName, kind) {
+        this.notifyInstanceTopic(instanceName, t("interactive.instance_notice", instanceName));
+        // Multi-world fleets can have one General per bot/platform. Route the assist
+        // request to the General bound to the same adapter as the blocked instance.
+        const generalName = this.findGeneralInstance(this.getInstanceAdapterId(instanceName));
+        if (!generalName) {
+            this.logger.warn({ instanceName }, "Interactive prompt has no General topic notification target");
+            return;
+        }
+        const adapterId = this.getInstanceAdapterId(generalName);
+        const adapter = this.getAdapterForInstance(generalName);
+        const chatId = this.getGroupIdForInstance(generalName);
+        const topicId = this.fleetConfig?.instances[generalName]?.topic_id;
+        const threadId = topicId != null ? String(topicId) : undefined;
+        if (!adapter || !adapterId || !chatId) {
+            this.logger.warn({ instanceName, generalName, adapterId, chatId }, "Cannot address interactive prompt assistance controls");
+            return;
+        }
+        const nonce = randomBytes(8).toString("hex");
+        const label = this.interactivePromptLabel(kind);
+        const entry = {
+            instanceName,
+            generalName,
+            kind,
+            adapterId,
+            adapter,
+            chatId,
+            threadId,
+        };
+        entry.timer = setTimeout(() => {
+            const pending = this.pendingInteractivePromptAssists.get(nonce);
+            if (pending !== entry)
+                return;
+            this.pendingInteractivePromptAssists.delete(nonce);
+            if (entry.messageId && entry.adapter.editMessageRemoveButtons) {
+                entry.adapter.editMessageRemoveButtons(entry.chatId, entry.messageId, t("interactive.expired", entry.instanceName), entry.threadId).catch(err => this.logger.debug({ err, instanceName }, "Failed to expire interactive prompt controls"));
+            }
+        }, INTERACTIVE_ASSIST_TIMEOUT_MS);
+        entry.timer.unref?.();
+        this.pendingInteractivePromptAssists.set(nonce, entry);
+        try {
+            const sent = await adapter.notifyAlert(chatId, {
+                type: "interactive_prompt",
+                instanceName,
+                message: t("interactive.general_notice", instanceName, label),
+                choices: [
+                    { id: `${INTERACTIVE_ASSIST_CALLBACK_PREFIX}${nonce}:confirm`, label: t("interactive.confirm") },
+                    { id: `${INTERACTIVE_ASSIST_CALLBACK_PREFIX}${nonce}:cancel`, label: t("interactive.cancel") },
+                ],
+            }, threadId ? { threadId } : undefined);
+            entry.messageId = sent.messageId;
+        }
+        catch (err) {
+            this.pendingInteractivePromptAssists.delete(nonce);
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            this.logger.warn({ err, instanceName, generalName }, "Failed to send interactive prompt assistance controls");
+        }
+    }
+    async retireInteractivePromptButtons(pending, messageId, text) {
+        if (!pending.adapter.editMessageRemoveButtons) {
+            this.logger.warn({ instanceName: pending.instanceName, adapterId: pending.adapterId }, "Adapter cannot remove interactive prompt controls");
+            return;
+        }
+        try {
+            await pending.adapter.editMessageRemoveButtons(pending.chatId, messageId, text, pending.threadId);
+        }
+        catch (err) {
+            // The action was already atomically consumed. An edit failure must not
+            // prevent Confirm from reaching General or make Cancel actionable again.
+            this.logger.warn({ err, instanceName: pending.instanceName }, "Failed to retire interactive prompt controls");
+        }
+    }
+    /** Consume a General assist button exactly once. */
+    async handleInteractivePromptAssist(data, callbackAdapterId) {
+        if (!data.callbackData.startsWith(INTERACTIVE_ASSIST_CALLBACK_PREFIX))
+            return false;
+        const match = data.callbackData.match(/^interactive-assist:([0-9a-f]+):(confirm|cancel)$/);
+        if (!match)
+            return true;
+        const pending = this.pendingInteractivePromptAssists.get(match[1]);
+        if (!pending)
+            return true;
+        // Bind the capability to the exact message/world that created it. Telegram
+        // keyboards are visible to everyone, so the click also requires fleet admin.
+        if (pending.adapterId !== callbackAdapterId
+            || data.chatId !== pending.chatId
+            || (pending.threadId != null && data.threadId !== pending.threadId)
+            || (pending.messageId != null && data.messageId !== pending.messageId)
+            || !data.userId
+            || !this.isFleetAdmin(data.userId, callbackAdapterId)) {
+            this.logger.warn({ instanceName: pending.instanceName, userId: data.userId }, "Rejected unauthorized or mismatched interactive prompt callback");
+            return true;
+        }
+        // Claim before any await: double clicks and duplicate callback delivery can
+        // never inject two messages into General.
+        this.pendingInteractivePromptAssists.delete(match[1]);
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        const action = match[2];
+        this.eventLog?.insert(pending.instanceName, "interactive_prompt_assist", {
+            action,
+            userId: data.userId,
+            generalName: pending.generalName,
+        });
+        if (action === "cancel") {
+            await this.retireInteractivePromptButtons(pending, pending.messageId ?? data.messageId, t("interactive.ignored", pending.instanceName));
+            return true;
+        }
+        // Injecting into General while General itself is blocked would type into the
+        // terminal prompt instead of the agent input. Fail safe and require attach.
+        if (pending.instanceName === pending.generalName) {
+            await this.retireInteractivePromptButtons(pending, pending.messageId ?? data.messageId, t("interactive.self_assist", pending.instanceName));
+            return true;
+        }
+        await this.retireInteractivePromptButtons(pending, pending.messageId ?? data.messageId, t("interactive.confirmed", pending.instanceName));
+        try {
+            await this.deliverToInstance(pending.generalName, {
+                type: "fleet_inbound",
+                content: t("interactive.assist_request", pending.instanceName, this.interactivePromptLabel(pending.kind)),
+                targetSession: pending.generalName,
+                meta: {
+                    chat_id: pending.chatId,
+                    message_id: pending.messageId ?? data.messageId,
+                    user: "AgEnD",
+                    user_id: data.userId,
+                    ts: new Date().toISOString(),
+                    thread_id: pending.threadId ?? "",
+                    adapter_id: pending.adapterId,
+                    source: pending.adapter.type,
+                },
+            }, {
+                // This is system-generated work, not a live user message. Queue behind
+                // General's current turn so Kiro/Claude do not lose it while busy.
+                isCrossInstance: true,
+            });
+            this.logger.info({ instanceName: pending.instanceName, generalName: pending.generalName }, "Interactive prompt assistance delivered to General");
+        }
+        catch (err) {
+            this.logger.warn({ err, instanceName: pending.instanceName, generalName: pending.generalName }, "Failed to deliver interactive prompt assistance to General");
+            await pending.adapter.editMessage(pending.chatId, pending.messageId ?? data.messageId, t("interactive.delivery_failed", pending.instanceName), pending.threadId);
+        }
+        return true;
+    }
     // ── 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.
@@ -6432,6 +6606,11 @@ When users create specialized instances, suggest these configurations:
         for (const pending of this.pendingClassicStarts.values())
             clearTimeout(pending.timer);
         this.pendingClassicStarts.clear();
+        for (const pending of this.pendingInteractivePromptAssists.values()) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+        }
+        this.pendingInteractivePromptAssists.clear();
         this.topicArchiver.stop();
         this.scheduler?.shutdown();
         // Stop instances in parallel batches to avoid long sequential waits.