@songsid/agend 2.1.1 → 2.1.2-beta.10

package/dist/daemon.js

@@ -3,6 +3,7 @@ import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmSync,
 import { fileURLToPath } from "node:url";
 import { createHash, randomBytes } from "node:crypto";
 import { EventEmitter } from "node:events";
+import { rotateLogIfNeeded } from "./logger.js";
 import { clearPausedMarker, writePausedMarker } from "./pause-marker.js";
 import { TmuxManager, resolveTmuxLogicalSize } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
@@ -244,6 +245,7 @@ export class Daemon extends EventEmitter {
     topicMode;
     backend;
     controlClient;
+    runtimeIdentity;
     logger;
     tmuxSessionName;
     tmux = null;
@@ -371,7 +373,7 @@ export class Daemon extends EventEmitter {
         this.errorRecoveryDeadlineAt = 0;
         this.activeErrorPatternKey = null;
     }
-    constructor(name, config, instanceDir, topicMode = false, backend, controlClient, rootLogger) {
+    constructor(name, config, instanceDir, topicMode = false, backend, controlClient, rootLogger, runtimeIdentity) {
         super();
         this.name = name;
         this.config = config;
@@ -379,8 +381,14 @@ export class Daemon extends EventEmitter {
         this.topicMode = topicMode;
         this.backend = backend;
         this.controlClient = controlClient;
+        this.runtimeIdentity = runtimeIdentity;
         if (!rootLogger)
             throw new Error("Daemon requires a shared root logger");
+        this.runtimeIdentity ??= {
+            kind: "fleet-topic",
+            backend: config.backend ?? backend?.binaryName ?? "unknown",
+            model: config.model ?? "default",
+        };
         this.logger = rootLogger.child({ instance: name }, { level: config.log_level });
         this.tmuxSessionName = getTmuxSession();
         this.messageBus = new MessageBus();
@@ -612,8 +620,12 @@ export class Daemon extends EventEmitter {
             catch { /* non-fatal */ }
         })();
         if (!this.config.lightweight) {
-            // 3. Pipe-pane for prompt detection
+            // 3. Pipe-pane for prompt detection. Rotate first so a ballooned log from a
+            // previous stuck splash (hundreds of MB of ANSI frames) is truncated before
+            // we attach — pipe-pane uses `cat >>` on the same inode, so copytruncate
+            // keeps the writer attached after size resets.
             const outputLog = join(this.instanceDir, "output.log");
+            rotateLogIfNeeded(outputLog);
             await this.tmux.pipeOutput(outputLog).catch(() => { });
             // 4. Transcript monitor
             this.transcriptMonitor = new TranscriptMonitor(this.instanceDir, this.logger);
@@ -716,6 +728,11 @@ export class Daemon extends EventEmitter {
                     return;
                 }
                 if (paneStatus?.alive) {
+                    // Instance output.log is fed by tmux pipe-pane and was previously never
+                    // rotated (only fleet.log / daemon.log were). Cap growth every tick.
+                    if (!this.config.lightweight) {
+                        rotateLogIfNeeded(join(this.instanceDir, "output.log"));
+                    }
                     scheduleNext();
                     return;
                 }
@@ -1755,18 +1772,19 @@ export class Daemon extends EventEmitter {
     }
     /**
      * Deliver a single message and drive its status reactions:
-     *   ⏳ message_queued    — CLI busy; queued, waiting for idle
+     *   ⏳ message_queued    — CLI busy; queued locally or by the backend
      *   👀 message_delivered — pasted + Enter sent; agent now has it
-     *   ✅ message_confirmed — idle→busy transition observed; agent is processing
+     *   ✅ message_confirmed — processing observed, or native queue handoff succeeded
      *   ❌ message_failed    — tmux window gone, paste retries exhausted
      * Returns true once the message is in the CLI, false only on real delivery failure.
      *
      * Bug A (silent message loss): paste failures retry with backoff (window recovery)
      * and emit `message_failed` if all attempts fail.
-     * Busy handling (UX): we never force-paste into a busy CLI and never give up on a
-     * busy one — we show ⏳ and wait for idle indefinitely (a genuinely hung CLI is the
-     * hang detector's job; a user who can't wait presses Cancel → Escape → idle). The
-     * pasteLock is serial, so later messages naturally queue behind this wait.
+     * Busy handling (UX): backends without a native input queue show ⏳ and wait for
+     * idle indefinitely (a genuinely hung CLI is the hang detector's job). Backends
+     * that explicitly support queued input receive one complete paste+Enter transaction
+     * immediately and own the application-level queue themselves. The pasteLock remains
+     * serial in both cases so separate PTY writes can never overlap.
      */
     async deliverMessage(formatted, status) {
         // Sanitize unclosed code fences — they cause CLI to wait for closure on Enter
@@ -1776,12 +1794,22 @@ export class Daemon extends EventEmitter {
             formatted = formatted.replace(/```/g, "");
         }
         let windowId = this.getWindowId();
-        // If the CLI is busy, show ⏳ and wait for it to go idle — no timeout, no force.
+        const supportsQueuedInput = this.backend?.supportsQueuedInput?.() === true;
+        let handingOffToNativeQueue = false;
+        // If the CLI is busy, either hand the complete submission to its native input
+        // queue or wait for idle. Native queue support is an explicit backend capability:
+        // normal Enter input has steering/interrupt semantics in several other CLIs.
         if (windowId && this.controlClient && !this.controlClient.isIdle(windowId)) {
             if (status)
                 this.emit("message_queued", status);
-            this.logger.debug("CLI busy — queuing message until idle");
-            await this.controlClient.waitUntilIdle(windowId);
+            if (supportsQueuedInput) {
+                handingOffToNativeQueue = true;
+                this.logger.debug("CLI busy — handing message to backend-native input queue");
+            }
+            else {
+                this.logger.debug("CLI busy — queuing message until idle");
+                await this.controlClient.waitUntilIdle(windowId);
+            }
         }
         // Bug A: paste with backoff. Transient failures are usually a stale window id
         // after a crash/respawn — recover by name and retry (max 3 attempts, 2s apart).
@@ -1807,10 +1835,15 @@ export class Daemon extends EventEmitter {
             await this.tmux.sendSpecialKey("Enter");
             if (status)
                 this.emit("message_delivered", status); // 👀
-            // Confirm the CLI accepted the message by transitioning idle→busy (new output
-            // after Enter). If still idle after ~2s the Enter was likely swallowed while
-            // the TUI was redrawing — re-send Enter once and re-check.
-            if (windowId && this.controlClient) {
+            // A busy queue-capable CLI does not necessarily emit output when it accepts
+            // queued input. Treat the successful paste+Enter as the handoff confirmation;
+            // probing for idle→busy would time out and a second bare Enter could mutate
+            // the queue/TUI state. Idle submissions retain the swallowed-Enter safeguard.
+            if (handingOffToNativeQueue) {
+                if (status)
+                    this.emit("message_confirmed", status); // ✅ native queue accepted
+            }
+            else if (windowId && this.controlClient) {
                 let becameBusy = await this.confirmBusyAfterEnter(windowId, enterAt);
                 if (!becameBusy) {
                     this.logger.warn("No idle→busy transition after Enter — re-sending Enter once");
@@ -2124,6 +2157,9 @@ export class Daemon extends EventEmitter {
             AGEND_SOCKET_PATH: sockPath,
             AGEND_INSTANCE_NAME: this.name,
             AGEND_WORKING_DIR: this.config.working_directory,
+            AGEND_INSTANCE_KIND: this.runtimeIdentity?.kind ?? "fleet-topic",
+            AGEND_BACKEND: this.runtimeIdentity?.backend ?? this.config.backend ?? this.backend?.binaryName ?? "unknown",
+            AGEND_MODEL: this.runtimeIdentity?.model ?? this.config.model ?? "default",
         };
         if (this.config.tool_set)
             mcpEnv.AGEND_TOOL_SET = this.config.tool_set;
@@ -2159,6 +2195,7 @@ export class Daemon extends EventEmitter {
             instructions = buildFleetInstructions({
                 instanceName: this.name,
                 workingDirectory: this.config.working_directory,
+                runtimeIdentity: this.runtimeIdentity,
                 displayName: this.config.display_name,
                 description: this.config.description,
                 customPrompt: resolvedCustomPrompt,
@@ -2171,6 +2208,7 @@ export class Daemon extends EventEmitter {
             instructions = buildFleetInstructions({
                 instanceName: this.name,
                 workingDirectory: this.config.working_directory,
+                runtimeIdentity: this.runtimeIdentity,
                 displayName: this.config.display_name,
                 description: this.config.description,
                 customPrompt: resolvedCustomPrompt,
@@ -2366,7 +2404,9 @@ export class Daemon extends EventEmitter {
             this.logger.warn({ err }, "Failed to set remain-on-exit — exit codes will not be captured");
         });
         if (reuseWindow && !this.config.lightweight) {
-            await this.tmux.pipeOutput(join(this.instanceDir, "output.log")).catch(err => {
+            const outputLog = join(this.instanceDir, "output.log");
+            rotateLogIfNeeded(outputLog);
+            await this.tmux.pipeOutput(outputLog).catch(err => {
                 this.logger.warn({ err }, "Failed to restore pipe-pane after wake");
             });
         }