u-foo 1.5.0 → 1.6.0

package/src/agent/launcher.js

@@ -8,6 +8,8 @@ const EventBus = require("../bus");
 const { isAgentPidAlive } = require("../bus/utils");
 const { showBanner } = require("../utils/banner");
 const AgentNotifier = require("./notifier");
+const { ActivityDetector } = require("./activityDetector");
+const { createActivityStatePublisher } = require("./activityStatePublisher");
 const { getUfooPaths } = require("../ufoo/paths");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const PtyWrapper = require("./ptyWrapper");
@@ -488,11 +490,10 @@ class AgentLauncher {
       } else if (process.env.UFOO_FORCE_PTY === "1") {
         shouldUsePty = true;   // 强制使用PTY (测试/调试)
       } else {
-        // 自动检测：Terminal模式 + 非tmux + 非internal
+        // 自动检测：Terminal/tmux模式 + 非internal
         shouldUsePty =
           process.stdin.isTTY &&
           process.stdout.isTTY &&
-          !process.env.TMUX &&              // tmux已有PTY，避免套嵌
           !process.env.UFOO_INTERNAL_AGENT; // internal有专用runner（当前阶段）
       }
 
@@ -515,13 +516,32 @@ class AgentLauncher {
 
           // 启用Ready检测（监控agent初始化状态）
           const readyDetector = new ReadyDetector(this.agentType);
+          // 启用ActivityDetector（持续活动状态监控）
+          const launcherActivityDetector = new ActivityDetector(this.agentType, {
+            mode: resolveLaunchMode(),
+            startOnOutput: true,
+          });
+          const launcherPublisher = createActivityStatePublisher({
+            agentsFile: getUfooPaths(this.cwd).agentsFile,
+            subscriber: subscriberId,
+            projectRoot: this.cwd,
+          });
+          const daemonSockPath = getUfooPaths(this.cwd).ufooSock;
+          launcherActivityDetector.onChange((newState, oldState) => {
+            const snap = launcherActivityDetector.getState();
+            launcherPublisher.publish(newState, {
+              since: snap.since,
+              previous: oldState,
+              detail: snap.detail,
+            });
+          });
           wrapper.enableMonitoring((data) => {
             readyDetector.processOutput(data);
+            const text = typeof data === "string" ? data : Buffer.from(data).toString("utf8");
+            launcherActivityDetector.processOutput(text);
           });
-
-          // 当检测到agent ready时，通知daemon可以提前inject probe
-          const daemonSockPath = getUfooPaths(this.cwd).ufooSock;
           readyDetector.onReady(async () => {
+            launcherActivityDetector.markReady();
             // Claude Code's Ink TUI renders ❯ prompt before the input handler
             // is fully mounted. Wait a short period for the TUI to be ready to
             // accept injected text, otherwise only the trailing CR is processed
@@ -563,8 +583,9 @@ class AgentLauncher {
 
           // 设置退出回调（复用清理逻辑）
           wrapper.onExit = async ({ exitCode, signal }) => {
-            // 清理forceReady timer
+            // 清理 timers
             clearTimeout(forceReadyTimer);
+            launcherActivityDetector.destroy();
 
             // 清理 bus 状态
             try {
@@ -613,7 +634,7 @@ class AgentLauncher {
           const originalMonitor = wrapper.monitor;
           wrapper.monitor = {
             onOutput: (data) => {
-              // Call original monitor (ReadyDetector)
+              // Call original monitor (ReadyDetector + ActivityDetector)
               if (originalMonitor && originalMonitor.onOutput) {
                 originalMonitor.onOutput(data);
               }
@@ -755,6 +776,25 @@ class AgentLauncher {
               await originalOnExit(exitInfo);
             }
           };
+
+          // Handle external SIGTERM/SIGINT (e.g. daemon closeAgent)
+          // Without this, the PTY child may survive as an orphan process
+          // and the terminal window stays open.
+          let termSignalHandled = false;
+          const handleTermSignal = (sig) => {
+            if (termSignalHandled) return;
+            termSignalHandled = true;
+            // Save onExit ref before cleanup() nulls it
+            const exitHandler = wrapper.onExit;
+            wrapper.cleanup();
+            if (exitHandler) {
+              exitHandler({ exitCode: null, signal: sig });
+            } else {
+              process.exit(sig === "SIGTERM" ? 143 : 130);
+            }
+          };
+          process.on("SIGTERM", () => handleTermSignal("SIGTERM"));
+          process.on("SIGINT", () => handleTermSignal("SIGINT"));
         } catch (err) {
           console.error(`[PTY] Failed to start, falling back to spawn:`, err.message);
           this._spawnDirect(args, subscriberId);

package/src/agent/notifier.js

@@ -6,6 +6,7 @@ const { getUfooPaths } = require("../ufoo/paths");
 const { shakeTerminalByTty } = require("../bus/shake");
 const { isITerm2 } = require("../terminal/detect");
 const iterm2 = require("../terminal/iterm2");
+const { createActivityStatePublisher } = require("./activityStatePublisher");
 
 /**
  * Agent 消息通知监听器
@@ -16,7 +17,11 @@ class AgentNotifier {
     this.projectRoot = projectRoot;
     this.subscriber = subscriber;
     this.interval = 2000; // 2秒轮询一次
+    this.workingHoldMs = Number.parseInt(process.env.UFOO_ACTIVITY_WORKING_HOLD_MS || "", 10) || 5000;
     this.lastCount = 0;
+    this.lastWorkingAt = 0;
+    this.injectFailCount = 0;
+    this.maxInjectRetries = 5;
     this.timer = null;
     this.stopped = false;
     this.autoTrigger = process.env.UFOO_AUTO_TRIGGER !== "0"; // 默认启用自动触发
@@ -37,6 +42,12 @@ class AgentNotifier {
     const busDir = paths.busDir;
     this.injector = new Injector(busDir, paths.agentsFile);
     this.eventBus = new EventBus(projectRoot);
+    this.activityPublisher = createActivityStatePublisher({
+      agentsFile: paths.agentsFile,
+      subscriber,
+      projectRoot,
+      force: false, // notifier is low-priority; don't overwrite working/waiting_input/blocked
+    });
   }
 
   isUfooCodeSubscriber() {
@@ -97,6 +108,36 @@ class AgentNotifier {
     }
   }
 
+  /**
+   * 更新 activity_state（terminal/tmux agent 基础支持）
+   * 基于消息投递推断 WORKING，无 pending 时推断 IDLE
+   */
+  updateActivityState(state) {
+    return this.activityPublisher.publish(state);
+  }
+
+  getCurrentActivityState() {
+    try {
+      if (!this.agentsFile || !fs.existsSync(this.agentsFile)) return "";
+      const data = JSON.parse(fs.readFileSync(this.agentsFile, "utf8"));
+      const meta = data.agents && data.agents[this.subscriber];
+      return meta && typeof meta.activity_state === "string"
+        ? String(meta.activity_state).trim().toLowerCase()
+        : "";
+    } catch {
+      return "";
+    }
+  }
+
+  isBusyState(state = "") {
+    const value = String(state || "").trim().toLowerCase();
+    return value === "working"
+      || value === "starting"
+      || value === "running"
+      || value === "waiting_input"
+      || value === "blocked";
+  }
+
   /**
    * 获取当前队列中的消息数量
    */
@@ -191,14 +232,29 @@ class AgentNotifier {
       return 0;
     }
 
+    const activityState = this.getCurrentActivityState();
+    if (this.isBusyState(activityState)) {
+      return 0;
+    }
+
+    // Back off on consecutive inject failures to avoid tight retry loop
+    if (this.injectFailCount >= this.maxInjectRetries) {
+      return 0;
+    }
+
     const events = this.drainPending();
     if (events.length === 0) return 0;
-    const failed = [];
+    const requeue = [];
     let delivered = 0;
+    let consumedOne = false;
     for (const evt of events) {
       if (!evt || evt.event !== "message" || !evt.data || typeof evt.data.message !== "string") {
         continue;
       }
+      if (consumedOne) {
+        requeue.push(evt);
+        continue;
+      }
       const message = String(evt.data.message);
       try {
         // Inject the actual message text into the terminal/tmux agent
@@ -206,22 +262,30 @@ class AgentNotifier {
         // eslint-disable-next-line no-await-in-loop
         await this.injector.inject(this.subscriber, message);
         delivered += 1;
+        consumedOne = true;
+        this.injectFailCount = 0;
+        this.updateActivityState("working");
         // eslint-disable-next-line no-await-in-loop
         await this.emitDelivery(evt, "ok");
       } catch (err) {
-        failed.push(evt);
+        consumedOne = true;
+        this.injectFailCount += 1;
+        requeue.push(evt);
         // eslint-disable-next-line no-await-in-loop
         await this.emitDelivery(evt, "error", err.message || "inject failed");
       }
     }
-    if (failed.length > 0) {
+    if (requeue.length > 0) {
       try {
-        const content = failed.map((e) => JSON.stringify(e)).join("\n") + "\n";
+        const content = requeue.map((e) => JSON.stringify(e)).join("\n") + "\n";
         fs.appendFileSync(this.queueFile, content, "utf8");
       } catch {
         // ignore requeue failures
       }
     }
+    if (delivered > 0) {
+      this.lastWorkingAt = Date.now();
+    }
     return delivered;
   }
 
@@ -261,6 +325,7 @@ class AgentNotifier {
     if (this.stopped) return;
 
     const currentCount = this.getMessageCount();
+    const nowMs = Date.now();
 
     // 有新消息
     if (currentCount > this.lastCount) {
@@ -297,6 +362,9 @@ class AgentNotifier {
     }
 
     this.lastCount = this.getMessageCount();
+    if (!this.lastWorkingAt || nowMs - this.lastWorkingAt >= this.workingHoldMs) {
+      this.updateActivityState("idle");
+    }
     this.refreshTitle();
     this.updateHeartbeat();
   }
@@ -311,6 +379,7 @@ class AgentNotifier {
     if (this.lastNickname) {
       this.setTitle(this.lastNickname);
     }
+    this.updateActivityState("ready");
 
     // 启动轮询
     this.timer = setInterval(() => {

package/src/agent/ptyRunner.js

@@ -4,8 +4,9 @@ const net = require("net");
 const { spawnSync } = require("child_process");
 const EventBus = require("../bus");
 const { PTY_SOCKET_MESSAGE_TYPES, PTY_SOCKET_SUBSCRIBE_MODES } = require("../shared/ptySocketContract");
-const { runInternalRunner } = require("./internalRunner");
 const { getUfooPaths } = require("../ufoo/paths");
+const { ActivityDetector } = require("./activityDetector");
+const { createActivityStatePublisher } = require("./activityStatePublisher");
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -140,6 +141,10 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   };
 
   const eventBus = new EventBus(projectRoot);
+  const activityDetector = new ActivityDetector(agentType, {
+    mode: "internal-pty",
+  });
+  const agentsFilePath = getUfooPaths(projectRoot).agentsFile;
 
   let running = true;
   let busy = false;
@@ -156,13 +161,13 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   let suppressEcho = false;
   let echoMarker = "";
   let suppressTimer = null;
-  let fallbackInProgress = false;
   let ptyProcess = null;
   let restartCount = 0;
   let lastSpawnTime = 0;
-  const MAX_RESTARTS = 3;
+  const MAX_RESTARTS = 10;
   const RESTART_STABLE_MS = 30000; // reset counter if process ran > 30s
   const RESTART_DELAY_MS = 2000;
+  const RESTART_BACKOFF_CAP_MS = 30000;
   const READY_QUIET_MS = 3000; // TUI is "ready" after 3s of no output
   const messageQueue = [];
   const injectServer = setupInjectServer();
@@ -171,7 +176,6 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   const idleMs = 30000;
   const watchdogMs = 120000;
   const maxQueue = 200;
-  const watchdogAction = String(process.env.UFOO_PTY_WATCHDOG_ACTION || "restart").toLowerCase();
   let sendQueue = Promise.resolve();
   const DROP_LINE_PATTERNS = [
     /__UFOO_DONE_/,
@@ -503,6 +507,51 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     }
   }
 
+  // Unified activity state publisher (write + broadcast)
+  const activityPublisher = createActivityStatePublisher({
+    agentsFile: agentsFilePath,
+    subscriber,
+    projectRoot,
+  });
+
+  function writeActivityState() {
+    const snap = activityDetector.getState();
+    activityPublisher.publish(snap.state, {
+      since: snap.since,
+      detail: snap.detail,
+    });
+  }
+
+  activityDetector.onChange((newState, oldState) => {
+    const snap = activityDetector.getState();
+    activityPublisher.publish(newState, {
+      since: snap.since,
+      previous: oldState,
+      detail: snap.detail,
+    });
+    // Quiet-window detector may classify IDLE sooner than stream fallback timer.
+    // Release queue only when no explicit marker is being awaited.
+    if (newState === "idle" && busy && !currentMarker && !suppressEcho) {
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+      if (watchdogTimer) {
+        clearTimeout(watchdogTimer);
+        watchdogTimer = null;
+      }
+      if (currentPublisher) {
+        enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "idle" }));
+      }
+      busy = false;
+      currentPublisher = "";
+      processQueue();
+    }
+  });
+  // Ensure daemon/dashboard can read initial state immediately after runner boots,
+  // instead of waiting for the next 30s heartbeat tick.
+  writeActivityState();
+
   function attachPty(proc) {
     proc.onData((data) => {
       const raw = String(data || "");
@@ -516,6 +565,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
       const clean = stripAnsi(raw).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
       if (!clean) return;
       outputBuffer += clean;
+      activityDetector.processOutput(clean);
       if (suppressEcho) {
         if (echoMarker && outputBuffer.includes(echoMarker)) {
           const idx = outputBuffer.indexOf(echoMarker);
@@ -545,6 +595,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
           }
           currentMarker = "";
           busy = false;
+          activityDetector.markIdle();
           currentPublisher = "";
           if (watchdogTimer) {
             clearTimeout(watchdogTimer);
@@ -567,6 +618,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
           readyTimer = null;
           if (!ptyReady) {
             ptyReady = true;
+            activityDetector.markReady();
             // Discard TUI startup noise accumulated before ready
             outputBuffer = "";
             pendingOutput = [];
@@ -583,6 +635,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
             enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "idle" }));
           }
           busy = false;
+          activityDetector.markIdle();
           currentPublisher = "";
           processQueue();
         }, idleMs);
@@ -620,6 +673,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
 
       // Reset busy state
       busy = false;
+      activityDetector.markIdle();
       currentPublisher = "";
       currentMarker = "";
 
@@ -634,7 +688,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
       restartCount++;
 
       if (restartCount <= MAX_RESTARTS) {
-        const delay = Math.min(restartCount * RESTART_DELAY_MS, 10000);
+        const delay = Math.min(restartCount * RESTART_DELAY_MS, RESTART_BACKOFF_CAP_MS);
         logNote(`Auto-restarting PTY in ${delay}ms (attempt ${restartCount}/${MAX_RESTARTS})`);
         setTimeout(() => {
           if (!running) return;
@@ -643,12 +697,26 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
             processQueue();
           } catch (err) {
             logNote(`Restart failed: ${err.message || err}`);
-            void fallbackHeadless(`restart failed: ${err.message || err}`);
+            // Keep retrying instead of falling back
+            restartCount++;
+            if (restartCount <= MAX_RESTARTS) {
+              const retryDelay = Math.min(restartCount * RESTART_DELAY_MS, RESTART_BACKOFF_CAP_MS);
+              setTimeout(() => {
+                if (!running) return;
+                try {
+                  ptyProcess = spawnPtyProcess();
+                  processQueue();
+                } catch {
+                  logNote(`PTY spawn keeps failing after ${restartCount} attempts. Agent is offline.`);
+                }
+              }, retryDelay);
+            } else {
+              logNote(`PTY spawn failed after ${MAX_RESTARTS} attempts. Agent is offline. Fix the issue and re-launch.`);
+            }
           }
         }, delay);
       } else {
-        logNote(`Max PTY restarts (${MAX_RESTARTS}) reached, falling back to headless runner`);
-        void fallbackHeadless("max PTY restarts exceeded");
+        logNote(`PTY crashed ${MAX_RESTARTS} times within ${RESTART_STABLE_MS}ms. Agent is offline. Fix the issue and re-launch.`);
       }
     });
   }
@@ -691,24 +759,6 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     ptyProcess = spawnPtyProcess();
   }
 
-  async function fallbackHeadless(reason) {
-    if (fallbackInProgress) return;
-    fallbackInProgress = true;
-    logNote(`Fallback to headless: ${reason}`);
-    if (outputBuffer) {
-      flushOutput();
-    }
-    cleanupInjectServer(injectServer);
-    try {
-      if (ptyProcess) ptyProcess.kill();
-    } catch {
-      // ignore
-    }
-    running = false;
-    await runInternalRunner({ projectRoot, agentType });
-    process.exit(0);
-  }
-
   const stop = () => {
     running = false;
     cleanupInjectServer(injectServer);
@@ -732,6 +782,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     const next = messageQueue.shift();
     if (!next) return;
     busy = true;
+    activityDetector.markWorking();
     currentPublisher = next.publisher;
     currentMarker = next.marker || "";
     if (suppressTimer) {
@@ -794,21 +845,16 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     watchdogTimer = setTimeout(() => {
       watchdogTimer = null;
       if (!busy) return;
-      const timeoutNote = `[internal-pty] marker timeout; action=${watchdogAction}`;
+      const timeoutNote = `[internal-pty] marker timeout; restarting PTY`;
       if (currentPublisher) enqueueSend(currentPublisher, timeoutNote);
       if (currentPublisher) {
         enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "timeout" }));
       }
       logNote(timeoutNote);
-      if (watchdogAction === "fallback") {
-        void fallbackHeadless("marker timeout");
-        return;
-      }
-      if (watchdogAction === "restart") {
-        restartPty("marker timeout");
-      }
+      restartPty("marker timeout");
       currentMarker = "";
       busy = false;
+      activityDetector.markIdle();
       currentPublisher = "";
       processQueue();
     }, watchdogMs);
@@ -828,6 +874,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     } catch {
       // ignore heartbeat errors
     }
+    writeActivityState();
   };
 
   while (running) {