@songsid/agend 2.1.2-beta.40 → 2.1.2-beta.42

package/dist/daemon.js

@@ -412,6 +412,68 @@ export function sanitizePaneTail(pane, lineCount = 5) {
         .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "")
         .slice(0, 200));
 }
+const INTERACTIVE_PROMPT_PATTERNS = [
+    { kind: "sudo_password", pattern: /^\s*\[sudo\]\s+password\s+for\s+[^:\n]+:\s*$/im },
+    // macOS sudo and several package installers use this exact no-echo prompt.
+    // Tail-only + stability gating is what makes the otherwise-generic word safe.
+    { kind: "password", pattern: /^\s*(?:Password|Passphrase):\s*$/im },
+    { kind: "confirmation", pattern: /^[^\n]{0,180}(?:\([Yy]\/[Nn]\)|\[[Yy]\/[Nn]\]|\((?:yes|no)\/(?:yes|no)\))\s*:?\s*$/im },
+    { kind: "confirmation", pattern: /^\s*Are you sure[^\n]{0,160}\((?:yes\/no)(?:\/\[[^\]]+\])?\)\??\s*$/im },
+    { kind: "press_enter", pattern: /^\s*(?:Please\s+)?Press (?:the )?Enter(?: key)?(?: to [^\n]{0,120})?[.:…]?\s*$/im },
+];
+/**
+ * Detect terminal prompts that require a human, but only after the pane tail is
+ * unchanged and no control-mode output has arrived for the full grace period.
+ * This prevents prose such as "the installer asks [Y/n]" from notifying while
+ * an agent is still writing it.
+ */
+export class InteractivePromptDetector {
+    stableMs;
+    signature = null;
+    stableSince = 0;
+    lastOutputAt = 0;
+    notifiedSignature = null;
+    constructor(stableMs = 10_000) {
+        this.stableMs = stableMs;
+    }
+    observe(pane, now = Date.now(), outputAt = 0) {
+        const tail = sanitizePaneTail(pane, 5);
+        const tailText = tail.join("\n");
+        let matched = null;
+        for (const candidate of INTERACTIVE_PROMPT_PATTERNS) {
+            const match = tailText.match(candidate.pattern);
+            if (!match)
+                continue;
+            matched = { kind: candidate.kind, prompt: match[0].trim().slice(0, 200) };
+            break;
+        }
+        if (!matched) {
+            this.reset();
+            this.lastOutputAt = outputAt;
+            return null;
+        }
+        const signature = `${matched.kind}:${tailText}`;
+        const outputMoved = outputAt > this.lastOutputAt;
+        if (signature !== this.signature || outputMoved) {
+            this.signature = signature;
+            this.stableSince = now;
+            this.lastOutputAt = outputAt;
+            if (signature !== this.notifiedSignature)
+                this.notifiedSignature = null;
+            return null;
+        }
+        this.lastOutputAt = outputAt;
+        if (this.notifiedSignature === signature || now - this.stableSince < this.stableMs)
+            return null;
+        this.notifiedSignature = signature;
+        return matched;
+    }
+    reset() {
+        this.signature = null;
+        this.stableSince = 0;
+        this.notifiedSignature = null;
+    }
+}
 export class Daemon extends EventEmitter {
     name;
     config;
@@ -528,6 +590,7 @@ export class Daemon extends EventEmitter {
     firstDeliveryDelay = new FirstDeliveryDelay();
     // PTY error pattern monitoring
     errorMonitorTimer = null;
+    interactivePromptDetector = new InteractivePromptDetector();
     /** Same 5-min gate the error monitor uses, so a dead MCP server alerts once. */
     static MCP_DEATH_COOLDOWN_MS = 5 * 60_000;
     lastMcpDeathNotifiedAt = 0;
@@ -1289,8 +1352,6 @@ export class Daemon extends EventEmitter {
             return;
         const patterns = this.backend?.getErrorPatterns?.() ?? [];
         const dialogs = this.backend?.getRuntimeDialogs?.() ?? [];
-        if (!patterns.length && !dialogs.length)
-            return;
         if (!this.tmux)
             return;
         if (!this.backend)
@@ -1305,6 +1366,13 @@ export class Daemon extends EventEmitter {
                 if (!alive)
                     return;
                 const pane = await this.tmux.capturePane();
+                const interactivePrompt = this.interactivePromptDetector.observe(pane, Date.now(), this.instanceStateLastOutputAt);
+                if (interactivePrompt) {
+                    this.logger.warn(interactivePrompt, "Interactive terminal prompt is waiting for human input");
+                    this.emit("interactive_prompt", { name: this.name, ...interactivePrompt });
+                    // A prompt is not an error and must not enter the PTY recovery gate.
+                    // Continue scanning real errors in this same snapshot.
+                }
                 // Auto-dismiss runtime dialogs (e.g. Codex rate limit model switch)
                 for (const dialog of dialogs) {
                     if (!dialog.pattern.test(pane))
@@ -1955,6 +2023,7 @@ export class Daemon extends EventEmitter {
             clearInterval(this.errorMonitorTimer);
             this.errorMonitorTimer = null;
         }
+        this.interactivePromptDetector.reset();
         this.stopInstanceStateMonitor();
         this.transcriptMonitor?.stop();
         this.guardian?.stop();
@@ -2269,8 +2338,20 @@ export class Daemon extends EventEmitter {
                 this.logger.debug({ enterSettleMs }, "First delivery after ready — extending Enter settle delay");
             }
             await new Promise(r => setTimeout(r, enterSettleMs));
-            const enterAt = Date.now();
+            let enterAt = Date.now();
             await this.tmux.sendSpecialKey("Enter");
+            // Kiro may expose its ready prompt before its final startup redraw. If
+            // that redraw swallows Enter, the redraw's own output makes the normal
+            // busy confirmation return true and suppresses the conditional retry.
+            // Kiro has no native input queue, so one defensive retry on the first
+            // post-ready delivery is safe and cannot mutate a queued turn.
+            if (enterSettleMs > NORMAL_ENTER_SETTLE_MS
+                && this.backend?.requiresFirstDeliveryEnterRetry?.() === true) {
+                await new Promise(r => setTimeout(r, 1_000));
+                enterAt = Date.now();
+                await this.tmux.sendSpecialKey("Enter");
+                this.logger.debug("First delivery after ready — sent defensive Enter retry");
+            }
             if (status)
                 this.emit("message_delivered", status); // 👀
             // Busy queue-capable CLIs (codex) may accept paste without an idle→busy
@@ -2616,7 +2697,11 @@ export class Daemon extends EventEmitter {
             }
             if (this.lastChatId) {
                 args.chat_id = this.lastChatId;
-                if (tool === "reply")
+                // Discord messages live in the channel/thread id, not the guild id in
+                // chat_id. This is required for react/edit as well as reply. In
+                // particular, general_topic deliberately has no configured reply thread,
+                // so FleetManager cannot reconstruct this address from fleet.yaml.
+                if (this.lastThreadId)
                     args.thread_id = this.lastThreadId;
             }
         }
@@ -2629,7 +2714,16 @@ export class Daemon extends EventEmitter {
             // from prematurely resolving their pending requests when they receive the broadcast.
             const fleetReqId = `tool_${requestId}`;
             const outboundKey = fleetReqId;
-            this.ipcServer?.broadcast({ type: "fleet_outbound", tool, args, fleetRequestId: fleetReqId });
+            this.ipcServer?.broadcast({
+                type: "fleet_outbound",
+                tool,
+                args,
+                fleetRequestId: fleetReqId,
+                // Preserve the exact adapter world that supplied the chat context. An
+                // instance binding is only a fallback: persisted/runtime context can be
+                // from a secondary world, and message ids are not portable across bots.
+                adapterId: this.lastAdapterId,
+            });
             const timeout = setTimeout(() => {
                 this.pendingIpcRequests.delete(outboundKey);
                 respond(null, `Fleet outbound timed out after ${daemonBudgetMs(tool) / 1000}s`);