@songsid/agend 2.1.4-beta.30 → 2.1.4-beta.32

package/dist/daemon.js

@@ -776,6 +776,8 @@ export class Daemon extends EventEmitter {
     authFailureUnresolved = false;
     /** One login-screen auth report per spawn — the screen persists across polls. */
     loginScreenReported = false;
+    /** model_error seen mid-turn: notify only if it survives to the idle screen. */
+    pendingModelErrorKey = null;
     /**
      * Let the next pause() proceed from a stuck pane. Set only for the auth-deferred
      * pause — see the pausePending consumption site for why waiting for idle there
@@ -1035,7 +1037,7 @@ export class Daemon extends EventEmitter {
             }
             else if (msg.type === "raw_paste") {
                 // Paste raw text directly to CLI without [user:] wrapping.
-                this.queueRawPaste(msg.content, this.captureDeliveryEpoch(msg.delivery_epoch));
+                this.queueRawPaste(msg.content, this.captureDeliveryEpoch(msg.delivery_epoch), msg.confirm_clear === true);
             }
             else if (msg.type === "config_update") {
                 this.applyConfigUpdate(msg.config);
@@ -1815,6 +1817,19 @@ export class Daemon extends EventEmitter {
             this.logger.warn({ errorType: this.lastDetectedErrorType }, "PTY error recovery deadline expired — resuming error scan");
             this.clearErrorRecoveryGate();
         }
+        // A model_error deferred mid-turn: the turn is over (or the pane left
+        // "working"), so decide now — still on screen means the CLI gave up and
+        // the user must act; gone means a retry got past it and nobody needs to know.
+        if (this.pendingModelErrorKey && this.instanceState !== "working") {
+            const key = this.pendingModelErrorKey;
+            this.pendingModelErrorKey = null;
+            const ep = patterns.find(candidate => Daemon.errorPatternKey(candidate) === key);
+            if (ep && ep.pattern.test(pane)) {
+                this.emitErrorPattern(ep, key, pane, now);
+                return;
+            }
+            this.logger.debug({ errorKey: key }, "Deferred model_error cleared before idle — dropped");
+        }
         // State: monitoring — count-based new-error detection over the full pane.
         for (const ep of patterns) {
             const key = Daemon.errorPatternKey(ep);
@@ -1842,30 +1857,49 @@ export class Daemon extends EventEmitter {
                 continue;
             }
             this.lastErrorCount.set(key, count);
-            // skipRecoveryWait: this error self-recovers (e.g. a timeout — Kiro is
-            // back at its prompt immediately). Keep monitoring so the next occurrence
-            // can fire without waiting for a possibly startup-only ready pattern.
-            if (!ep.skipRecoveryWait) {
-                this.errorWaitingForRecovery = true;
-                this.errorDetectedAt = now;
-                this.errorRecoveryDeadlineAt = now + Daemon.ERROR_RECOVERY_TIMEOUT_MS;
-                this.activeErrorPatternKey = key;
-                this.lastDetectedErrorType = ep.type;
+            // Kiro's `auto` model picks a concrete model per turn and reroutes around
+            // a temporarily unavailable one on its own — telling the user to run
+            // /model would ask them to fix something the CLI is already handling.
+            if (ep.type === "model_error" && ep.action === "notify" && this.config.model === "auto") {
+                this.logger.debug({ errorType: ep.type }, "model_error suppressed — model 'auto' reroutes on its own");
+                continue;
             }
-            this.lastErrorNotifiedAt.set(key, now);
-            if (ep.action === "failover")
-                this.lastFailoverAt = now;
-            const message = this.resolveErrorMessage(pane, ep);
-            // Remember an auth failure for as long as it is unresolved. An auth-broken
-            // CLI cannot finish the turn it is holding, so every other detector in this
-            // scan would otherwise keep reporting the same dead instance forever.
-            if (ep.type === "auth_error")
-                this.authFailureUnresolved = true;
-            this.logger.warn({ errorType: ep.type, action: ep.action }, `PTY error detected: ${message}`);
-            this.emit("pty_error", { name: this.name, ...ep, message });
+            // A mid-turn model error is often a transient the CLI retries past. Hold
+            // the notification until the turn ends and notify only if the error is
+            // still on the idle screen (see the deferred check above).
+            if (ep.type === "model_error" && ep.action === "notify" && this.instanceState === "working") {
+                this.pendingModelErrorKey = key;
+                this.logger.debug({ errorType: ep.type }, "model_error deferred — instance is mid-turn, re-checking at idle");
+                continue;
+            }
+            this.emitErrorPattern(ep, key, pane, now);
             break; // Only handle first unsuppressed new error per scan
         }
     }
+    /** Arm the recovery gates and emit one detected error pattern. */
+    emitErrorPattern(ep, key, pane, now) {
+        // skipRecoveryWait: this error self-recovers (e.g. a timeout — Kiro is
+        // back at its prompt immediately). Keep monitoring so the next occurrence
+        // can fire without waiting for a possibly startup-only ready pattern.
+        if (!ep.skipRecoveryWait) {
+            this.errorWaitingForRecovery = true;
+            this.errorDetectedAt = now;
+            this.errorRecoveryDeadlineAt = now + Daemon.ERROR_RECOVERY_TIMEOUT_MS;
+            this.activeErrorPatternKey = key;
+            this.lastDetectedErrorType = ep.type;
+        }
+        this.lastErrorNotifiedAt.set(key, now);
+        if (ep.action === "failover")
+            this.lastFailoverAt = now;
+        const message = this.resolveErrorMessage(pane, ep);
+        // Remember an auth failure for as long as it is unresolved. An auth-broken
+        // CLI cannot finish the turn it is holding, so every other detector in this
+        // scan would otherwise keep reporting the same dead instance forever.
+        if (ep.type === "auth_error")
+            this.authFailureUnresolved = true;
+        this.logger.warn({ errorType: ep.type, action: ep.action }, `PTY error detected: ${message}`);
+        this.emit("pty_error", { name: this.name, ...ep, message });
+    }
     /**
      * Notification text for a detected pattern. `formatMessage` patterns build it
      * from the match so the user gets the specifics (e.g. which period and what
@@ -1927,7 +1961,7 @@ export class Daemon extends EventEmitter {
     isDeliveryEpochCurrent(epoch) {
         return epoch === this.deliveryEpoch;
     }
-    queueRawPaste(rawText, deliveryEpoch = this.deliveryEpoch) {
+    queueRawPaste(rawText, deliveryEpoch = this.deliveryEpoch, confirmClear = false) {
         if (!this.tmux || !this.isDeliveryEpochCurrent(deliveryEpoch))
             return;
         this.pasteLock = this.pasteLock.then(async () => {
@@ -1939,11 +1973,62 @@ export class Daemon extends EventEmitter {
             if (!this.isDeliveryEpochCurrent(deliveryEpoch))
                 return;
             await this.deliverMessage(rawText, undefined, { deliveryEpoch });
+            if (confirmClear)
+                await this.confirmBackendClearDialog();
             this.logger.debug({ text: rawText.slice(0, 100) }, "Raw paste delivered");
         }).catch(err => {
             this.logger.warn({ err: err.message }, "raw_paste delivery error");
         });
     }
+    /**
+     * Confirm a backend's terminal-level /clear prompt after the channel-level
+     * admin confirmation has already succeeded. Poll instead of pasting `/clear\ny`
+     * as one buffer: Kiro versions that clear immediately interpret that queued
+     * `y` as a brand-new user message.
+     */
+    async confirmBackendClearDialog() {
+        const dialog = this.backend?.getClearConfirmationDialog?.();
+        if (!dialog || !this.tmux)
+            return;
+        const matches = (pane) => {
+            dialog.pattern.lastIndex = 0;
+            return dialog.pattern.test(pane);
+        };
+        const deadline = Date.now() + 3_000;
+        while (Date.now() <= deadline) {
+            const pane = await this.tmux.capturePane().catch(() => "");
+            if (matches(pane)) {
+                const sent = await this.paneWriteLock.run(async () => {
+                    // Re-check under the write lock so a prompt that disappeared between
+                    // capture and lock acquisition never receives a stray literal `y`.
+                    const currentPane = await this.tmux.capturePane().catch(() => "");
+                    if (!matches(currentPane))
+                        return false;
+                    const specialKeys = new Set(["Up", "Down", "Enter", "Escape", "Right", "Left"]);
+                    for (const key of dialog.keys) {
+                        const ok = specialKeys.has(key)
+                            ? await this.tmux.sendSpecialKey(key)
+                            : await this.tmux.sendKeys(key);
+                        if (!ok)
+                            return false;
+                        await new Promise(resolve => setTimeout(resolve, 100));
+                    }
+                    return true;
+                });
+                if (sent) {
+                    this.logger.info({ dialog: dialog.description }, "Auto-confirmed backend clear dialog");
+                }
+                else {
+                    this.logger.warn({ dialog: dialog.description }, "Backend clear dialog disappeared or confirmation keys failed");
+                }
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        // Recent Kiro releases may clear immediately without a second prompt. That
+        // is a successful no-op here, not an error.
+        this.logger.debug({ dialog: dialog.description }, "Backend clear dialog did not appear");
+    }
     /** Send the backend-specific graceful quit command/key sequence. */
     async sendQuitSequence() {
         if (!this.tmux || !this.backend)
@@ -1951,18 +2036,20 @@ export class Daemon extends EventEmitter {
         const quitCmd = this.backend.getQuitCommand();
         const quitKey = this.backend.getQuitKey?.();
         if (quitCmd) {
-            await this.tmux.sendKeys(quitCmd);
+            if (!await this.tmux.sendKeys(quitCmd))
+                return false;
             // Delay before Enter to prevent tmux server races when instances stop in
             // parallel (same pattern as pasteText).
             await new Promise(r => setTimeout(r, 150));
-            await this.tmux.sendSpecialKey("Enter");
-            return true;
+            return this.tmux.sendSpecialKey("Enter");
         }
         if (!quitKey)
             return false;
         const presses = Math.max(1, Math.floor(this.backend.getQuitKeyPresses?.() ?? 1));
         for (let i = 0; i < presses; i++) {
-            await this.tmux.sendSpecialKey(quitKey);
+            const sent = await this.tmux.sendSpecialKey(quitKey);
+            if (!sent)
+                return false;
             if (i + 1 < presses)
                 await new Promise(r => setTimeout(r, 250));
         }
@@ -1995,8 +2082,23 @@ export class Daemon extends EventEmitter {
                     }
                 }
             }
-            if (!killed)
-                this.logger.warn("CLI did not exit gracefully within 3s, force killing window");
+            if (!killed) {
+                this.logger.warn({ quitSent }, "CLI did not exit gracefully within 3s — falling back to SIGTERM");
+                await this.killProcessTree("SIGTERM");
+                for (let i = 0; i < 5; i++) {
+                    await new Promise(r => setTimeout(r, 200));
+                    const status = await this.tmux.getPaneStatus();
+                    if (!status || !status.alive) {
+                        killed = true;
+                        break;
+                    }
+                }
+            }
+            if (!killed) {
+                this.logger.warn("CLI process tree survived SIGTERM — falling back to SIGKILL");
+                await this.killProcessTree("SIGKILL");
+                await new Promise(r => setTimeout(r, 200));
+            }
             // Always kill window — remain-on-exit keeps dead panes around after CLI exits
             const stoppedWindowId = this.tmux.getWindowId();
             await this.tmux.killWindow();