u-foo 1.4.1 → 1.6.0

package/src/agent/activityDetector.js

@@ -0,0 +1,328 @@
+/**
+ * Agent Activity State Detector
+ * 持续监控 agent 启动后的活动状态（readyDetector 的补充）
+ *
+ * State machine:
+ *   STARTING → READY → WORKING ↔ IDLE
+ *                         ↓        ↑
+ *                   WAITING_INPUT --+
+ *                         ↓        ↑
+ *                      BLOCKED ----+
+ */
+
+const ACTIVITY_STATES = {
+  starting: "starting",
+  ready: "ready",
+  working: "working",
+  idle: "idle",
+  waiting_input: "waiting_input",
+  blocked: "blocked",
+};
+
+const DEFAULT_BUFFER_SIZE = 4000;
+const DEFAULT_TAIL_LINES = 10;
+const DEFAULT_BLOCKED_TIMEOUT_MS = 300000;
+const DEFAULT_INTERNAL_QUIET_MS = 3500;
+const DEFAULT_EXTERNAL_QUIET_MS = 5000;
+const ANSI_PATTERN = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const OSC_PATTERN = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+
+// Agent-specific patterns that indicate the agent is waiting for user input.
+// Patterns are anchored to prompt/question contexts to reduce false positives.
+const INPUT_PATTERNS = {
+  "claude-code": [
+    /\bAllow\b.*\bDeny\b/,            // Claude Code permission dialog: "Allow | Deny"
+    /\ballow mcp\b/i,                 // MCP tool approval prompt
+    /Enter to select.*\u2191\/\u2193 to navigate/, // Ink TUI interactive prompt navigation bar (permissions, AskUserQuestion, Plan approval)
+  ],
+  codex: [
+    /\[Y\/n\]/,                        // Bracket-style prompt
+    /\by\/n\b/i,                       // y/n prompt (common in confirmation dialogs)
+  ],
+};
+
+const COMMON_PATTERNS = [
+  /Continue\?\s*$/m,                   // Line-ending "Continue?"
+  /Proceed\?\s*$/m,                    // Line-ending "Proceed?"
+  /Press enter/i,                      // "Press enter to continue"
+  /\(y\/n\)\s*:?\s*$/m,               // "(y/n)" at line end
+];
+
+// Deny-list for per-line context around a matched prompt.
+// Prevents false positives from code output while avoiding global-buffer suppression.
+const LINE_DENY_CONTEXT_PATTERNS = [
+  /function\s+\w+/,                   // Function definition context
+  /\/\//,                             // Code comment
+  /import\s+/,                        // Import statement
+  /require\s*\(/,                     // Require statement
+];
+
+function toPositiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value || ""), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+
+function getDefaultQuietWindowMs(mode) {
+  const normalized = String(mode || "").trim().toLowerCase();
+  if (normalized.includes("internal")) return DEFAULT_INTERNAL_QUIET_MS;
+  return DEFAULT_EXTERNAL_QUIET_MS;
+}
+
+class ActivityDetector {
+  /**
+   * @param {string} agentType - e.g. "claude-code", "codex"
+   * @param {object} [options]
+   * @param {string} [options.mode] - launch mode ("internal-pty"/"terminal"/"tmux"/"iterm2")
+   * @param {number} [options.bufferSize=4000] - rolling buffer size in chars
+   * @param {number} [options.tailLines=10] - number of tail lines used for quiet-time prompt detection
+   * @param {boolean} [options.startOnOutput=false] - allow STARTING -> WORKING on first output
+   * @param {number} [options.quietWindowMs] - output quiet window before WAITING_INPUT/IDLE classification
+   * @param {number} [options.blockedTimeoutMs=300000] - 5 min WAITING_INPUT → BLOCKED
+   */
+  constructor(agentType, options = {}) {
+    this.agentType = agentType;
+    this.mode = String(options.mode || "").trim().toLowerCase();
+    this.bufferSize = toPositiveInt(options.bufferSize, DEFAULT_BUFFER_SIZE);
+    this.tailLines = toPositiveInt(options.tailLines, DEFAULT_TAIL_LINES);
+    this.startOnOutput = options.startOnOutput === true;
+    this.blockedTimeoutMs = toPositiveInt(options.blockedTimeoutMs, DEFAULT_BLOCKED_TIMEOUT_MS);
+    const optionQuietMs = toPositiveInt(options.quietWindowMs, 0);
+    const envQuietMs = toPositiveInt(process.env.UFOO_ACTIVITY_QUIET_MS, 0);
+    this.quietWindowMs = optionQuietMs || envQuietMs || getDefaultQuietWindowMs(this.mode);
+
+    this.state = ACTIVITY_STATES.starting;
+    this.since = Date.now();
+    this.detail = "";
+    this.buffer = "";
+    this.callbacks = [];
+    this.blockedTimer = null;
+    this.quietTimer = null;
+    this.quietToken = 0;
+  }
+
+  /**
+   * Register a state-change callback: fn(newState, oldState, detail)
+   */
+  onChange(callback) {
+    this.callbacks.push(callback);
+  }
+
+  /**
+   * Transition to a new state (internal)
+   */
+  _setState(newState, detail = "") {
+    if (newState === this.state) return;
+    const oldState = this.state;
+    this.state = newState;
+    this.since = Date.now();
+    this.detail = detail;
+    for (const cb of this.callbacks) {
+      try {
+        cb(newState, oldState, detail);
+      } catch {
+        // ignore callback errors
+      }
+    }
+  }
+
+  /**
+   * STARTING → READY
+   */
+  markReady() {
+    if (this.state !== ACTIVITY_STATES.starting) return;
+    this._setState(ACTIVITY_STATES.ready);
+  }
+
+  /**
+   * any → WORKING
+   * - clears WAITING/BLOCKED timers
+   * - cancels pending quiet classification
+   * - resets buffer by default when coming from non-WORKING states
+   */
+  markWorking(options = {}) {
+    const hasResetFlag = Object.prototype.hasOwnProperty.call(options, "resetBuffer");
+    const resetBuffer = hasResetFlag ? Boolean(options.resetBuffer) : this.state !== ACTIVITY_STATES.working;
+    this._clearBlockedTimer();
+    this._clearQuietTimer();
+    if (resetBuffer) {
+      this.buffer = "";
+    }
+    this._setState(ACTIVITY_STATES.working);
+  }
+
+  /**
+   * WORKING/WAITING_INPUT/BLOCKED → IDLE
+   * Allows recovery from stuck states when queue drains, marker hits, etc.
+   */
+  markIdle() {
+    if (this.state !== ACTIVITY_STATES.working
+      && this.state !== ACTIVITY_STATES.waiting_input
+      && this.state !== ACTIVITY_STATES.blocked) return;
+    this._clearBlockedTimer();
+    this._clearQuietTimer();
+    this.buffer = "";
+    this._setState(ACTIVITY_STATES.idle);
+  }
+
+  /**
+   * Process PTY output.
+   * Any output (except STARTING) implies WORKING.
+   * WAITING_INPUT/IDLE are only classified after quiet window.
+   * @param {string} text - cleaned (ANSI-stripped) output text
+   */
+  processOutput(text) {
+    const normalized = this._normalizeOutput(text);
+    if (!normalized) return;
+    if (!this._hasMeaningfulOutput(normalized)) return;
+    if (this.state === ACTIVITY_STATES.starting) {
+      if (!this.startOnOutput) return;
+      this._setState(ACTIVITY_STATES.working, "output");
+    }
+
+    this.buffer += normalized;
+    // Rolling buffer: keep last N chars
+    if (this.buffer.length > this.bufferSize) {
+      this.buffer = this.buffer.slice(-this.bufferSize);
+    }
+
+    if (this.state !== ACTIVITY_STATES.working) {
+      this._clearBlockedTimer();
+      this._setState(ACTIVITY_STATES.working);
+    }
+    this._scheduleQuietClassification();
+  }
+
+  _normalizeOutput(text) {
+    if (!text) return "";
+    return String(text)
+      .replace(OSC_PATTERN, "")
+      .replace(/\r\n/g, "\n")
+      .replace(/\r/g, "\n")
+      .replace(ANSI_PATTERN, "");
+  }
+
+  _hasMeaningfulOutput(text) {
+    if (!text) return false;
+    const visible = String(text).replace(/[\s\u0000-\u001F\u007F]+/g, "");
+    return visible.length > 0;
+  }
+
+  _scheduleQuietClassification() {
+    this.quietToken += 1;
+    const quietToken = this.quietToken;
+    this._clearQuietTimer();
+    this.quietTimer = setTimeout(() => {
+      if (quietToken !== this.quietToken) return;
+      this.quietTimer = null;
+      this._classifyAfterQuietWindow();
+    }, this.quietWindowMs);
+    if (this.quietTimer && typeof this.quietTimer.unref === "function") {
+      this.quietTimer.unref();
+    }
+  }
+
+  _classifyAfterQuietWindow() {
+    if (this.state !== ACTIVITY_STATES.working) return;
+    const tailBuffer = this._tailWindow();
+
+    // Check agent-specific patterns only after output has stabilized.
+    const agentPatterns = INPUT_PATTERNS[this.agentType] || [];
+    const allPatterns = [...agentPatterns, ...COMMON_PATTERNS];
+    for (const pattern of allPatterns) {
+      const match = pattern.exec(tailBuffer);
+      if (!match) continue;
+      const matchedText = String(match[0] || "");
+      const matchIndex = Number.isFinite(match.index)
+        ? match.index
+        : Math.max(0, tailBuffer.length - matchedText.length);
+      if (this._hasDeniedContext(tailBuffer, matchIndex, matchedText.length)) continue;
+      this._setState(ACTIVITY_STATES.waiting_input, pattern.source);
+      this._startBlockedTimer();
+      return;
+    }
+
+    this._setState(ACTIVITY_STATES.idle);
+  }
+
+  _tailWindow() {
+    if (!this.buffer) return "";
+    const lines = this.buffer.split("\n");
+    if (lines.length <= this.tailLines) return this.buffer;
+    return lines.slice(-this.tailLines).join("\n");
+  }
+
+  _lineAt(haystack, index) {
+    const safeIndex = Math.max(0, Math.min(index, haystack.length));
+    const lineStart = haystack.lastIndexOf("\n", safeIndex - 1) + 1;
+    const lineEndCandidate = haystack.indexOf("\n", safeIndex);
+    const lineEnd = lineEndCandidate >= 0 ? lineEndCandidate : haystack.length;
+    return haystack.slice(lineStart, lineEnd);
+  }
+
+  _isInsideCodeFence(haystack, index) {
+    const before = haystack.slice(0, Math.max(0, index));
+    const fences = before.match(/```/g);
+    return (fences ? fences.length : 0) % 2 === 1;
+  }
+
+  _hasDeniedContext(haystack, matchIndex, matchLength = 0) {
+    if (this._isInsideCodeFence(haystack, matchIndex)) return true;
+    const centerIndex = Math.max(0, matchIndex + Math.max(0, Math.trunc(matchLength / 2)));
+    const line = this._lineAt(haystack, centerIndex);
+    return LINE_DENY_CONTEXT_PATTERNS.some((deny) => deny.test(line));
+  }
+
+  /**
+   * Start the WAITING_INPUT → BLOCKED timer
+   */
+  _startBlockedTimer() {
+    this._clearBlockedTimer();
+    this.blockedTimer = setTimeout(() => {
+      this.blockedTimer = null;
+      if (this.state === ACTIVITY_STATES.waiting_input) {
+        this._setState(ACTIVITY_STATES.blocked, `waiting_input for ${this.blockedTimeoutMs}ms`);
+      }
+    }, this.blockedTimeoutMs);
+    // Allow process to exit even if timer is pending
+    if (this.blockedTimer && typeof this.blockedTimer.unref === "function") {
+      this.blockedTimer.unref();
+    }
+  }
+
+  _clearBlockedTimer() {
+    if (this.blockedTimer) {
+      clearTimeout(this.blockedTimer);
+      this.blockedTimer = null;
+    }
+  }
+
+  _clearQuietTimer() {
+    if (this.quietTimer) {
+      clearTimeout(this.quietTimer);
+      this.quietTimer = null;
+    }
+  }
+
+  /**
+   * Get current state snapshot
+   */
+  getState() {
+    return {
+      state: this.state,
+      since: this.since,
+      detail: this.detail,
+    };
+  }
+
+  /**
+   * Clean up timers
+   */
+  destroy() {
+    this._clearBlockedTimer();
+    this._clearQuietTimer();
+    this.callbacks = [];
+  }
+}
+
+module.exports = { ACTIVITY_STATES, ActivityDetector };

package/src/agent/activityStatePublisher.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+const { writeActivityState } = require("./activityStateWriter");
+
+/**
+ * Unified activity state publisher.
+ * Encapsulates the "write to disk + broadcast event" pattern used by
+ * ptyRunner, launcher, notifier, and internalRunner.
+ *
+ * @param {object} options
+ * @param {string} options.agentsFile  - Path to all-agents.json
+ * @param {string} options.subscriber  - Subscriber ID (e.g. "claude-code:abc123")
+ * @param {string} options.projectRoot - Project root (unused, kept for API compat)
+ * @param {boolean} [options.force=true] - Force overwrite priority-protected states
+ */
+function createActivityStatePublisher(options = {}) {
+  const {
+    agentsFile,
+    subscriber,
+    force = true,
+  } = options;
+
+  let lastState = "";
+
+  function publish(state, extra = {}) {
+    if (state === lastState) return false;
+    const since = extra.since || undefined;
+    const changed = writeActivityState(agentsFile, subscriber, state, { since, force });
+    if (!changed) return false;
+    lastState = state;
+    // Write to bus events directory for daemon bridge to pick up.
+    // Writes directly to events dir to avoid queueing into subscriber pending files.
+    try {
+      const eventsDir = path.join(
+        path.dirname(path.dirname(agentsFile)),
+        "bus", "events"
+      );
+      const date = new Date().toISOString().slice(0, 10);
+      const eventFile = path.join(eventsDir, `${date}.jsonl`);
+      const entry = {
+        timestamp: new Date().toISOString(),
+        type: "status/agent",
+        event: "activity_state_changed",
+        publisher: subscriber,
+        target: "*",
+        data: {
+          subscriber,
+          state,
+          previous: extra.previous || "",
+          ...extra.detail ? { detail: extra.detail } : {},
+        },
+      };
+      fs.appendFileSync(eventFile, JSON.stringify(entry) + "\n");
+    } catch {
+      // ignore event write errors — dashboard polling is the fallback
+    }
+    return true;
+  }
+
+  function getLastState() {
+    return lastState;
+  }
+
+  return { publish, getLastState };
+}
+
+module.exports = { createActivityStatePublisher };

package/src/agent/activityStateWriter.js

@@ -0,0 +1,40 @@
+const fs = require("fs");
+
+/**
+ * Centralized helper for writing activity_state to all-agents.json.
+ * Used by both ptyRunner and notifier to avoid duplicated read-modify-write logic.
+ *
+ * - Only writes when state actually changes (monotonic activity_since).
+ * - Respects priority: won't overwrite working/waiting_input/blocked with idle
+ *   unless explicitly requested via `force` option.
+ */
+function writeActivityState(agentsFilePath, subscriber, state, options = {}) {
+  const { since, force = false } = options;
+  try {
+    if (!agentsFilePath || !fs.existsSync(agentsFilePath)) return false;
+    const data = JSON.parse(fs.readFileSync(agentsFilePath, "utf8"));
+    if (!data.agents || !data.agents[subscriber]) return false;
+
+    const current = data.agents[subscriber].activity_state;
+
+    // Skip if state unchanged (monotonic update)
+    if (current === state) return false;
+
+    // Don't overwrite higher-priority states with lower-priority states
+    // unless force is set (e.g. explicit markIdle from ptyRunner/launcher)
+    if (!force && (current === "working" || current === "waiting_input" || current === "blocked")) {
+      if (state === "idle" || state === "ready") return false;
+    }
+
+    data.agents[subscriber].activity_state = state;
+    data.agents[subscriber].activity_since = since
+      ? new Date(since).toISOString()
+      : new Date().toISOString();
+    fs.writeFileSync(agentsFilePath, JSON.stringify(data, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { writeActivityState };

package/src/agent/internalRunner.js

@@ -5,6 +5,7 @@ const { spawnSync } = require("child_process");
 const EventBus = require("../bus");
 const { runCliAgent } = require("./cliRunner");
 const { normalizeCliOutput } = require("./normalizeOutput");
+const { createActivityStatePublisher } = require("./activityStatePublisher");
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -220,6 +221,16 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
   process.on("SIGINT", stop);
 
   const cliSessionState = { cliSessionId, needsSave: false };
+  const agentsFile = getUfooPaths(projectRoot).agentsFile;
+  const activityPublisher = createActivityStatePublisher({
+    agentsFile, subscriber, projectRoot,
+  });
+
+  function setActivityState(state) {
+    activityPublisher.publish(state);
+  }
+
+  setActivityState("ready");
 
   // 心跳更新函数
   const updateHeartbeat = () => {
@@ -248,6 +259,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
       try {
         const lines = drainQueue(queueFile);
         if (lines.length > 0) {
+          setActivityState("working");
           const events = [];
           for (const line of lines) {
             try {
@@ -289,6 +301,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
           // 处理消息后更新心跳
           updateHeartbeat();
           lastHeartbeat = now;
+          setActivityState("idle");
         }
       } finally {
         processing = false;

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);