u-foo 1.0.3 → 1.0.6

package/src/agent/ptyWrapper.js

@@ -0,0 +1,354 @@
+const pty = require("node-pty");
+const fs = require("fs");
+const { isITerm2 } = require("../terminal/detect");
+
+/**
+ * PTY Wrapper - 包装原始agent命令，提供IO控制和监控
+ *
+ * 特性：
+ * - 透明的PTY包装（保持用户体验一致）
+ * - JSONL格式日志记录（utf8优先编码）
+ * - 可插拔的IO适配器（未来扩展）
+ * - 完善的资源清理（防止泄漏）
+ *
+ * 参考：
+ * - ptyRunner.js - PTY实现参考
+ * - codex-44 review反馈 (2026-02-05)
+ */
+class PtyWrapper {
+  constructor(command, args, options = {}) {
+    this.command = command;
+    this.args = args;
+    this.options = options;
+
+    // PTY实例
+    this.pty = null;
+
+    // IO流引用（用于cleanup）
+    this.stdin = null;
+    this.stdout = null;
+
+    // 日志记录
+    this.logger = null;
+
+    // 监控回调
+    this.monitor = null;
+
+    // 退出回调（不直接调用process.exit）
+    this.onExit = null;
+
+    // 可插拔的IO适配器（未来扩展）
+    this.ioAdapter = options.ioAdapter || null;
+
+    // 事件处理器引用（用于cleanup）
+    this._stdinHandler = null;
+    this._ptyDataHandler = null;
+    this._ptyExitHandler = null;
+    this._resizeHandler = null;
+
+    // 清理标志（防止重复清理）
+    this._cleaned = false;
+  }
+
+  /**
+   * 启动PTY进程
+   */
+  spawn() {
+    if (this.pty) {
+      throw new Error("PTY already spawned");
+    }
+
+    // Preserve iTerm2 env vars so child processes can detect the terminal
+    const termEnv = {};
+    if (isITerm2()) {
+      if (process.env.ITERM_SESSION_ID) termEnv.ITERM_SESSION_ID = process.env.ITERM_SESSION_ID;
+      if (process.env.TERM_PROGRAM) termEnv.TERM_PROGRAM = process.env.TERM_PROGRAM;
+      if (process.env.TERM_PROGRAM_VERSION) termEnv.TERM_PROGRAM_VERSION = process.env.TERM_PROGRAM_VERSION;
+    }
+
+    this.pty = pty.spawn(this.command, this.args, {
+      name: "xterm-256color",
+      cols: this.stdout?.columns || process.stdout.columns || 80,
+      rows: this.stdout?.rows || process.stdout.rows || 24,
+      cwd: this.options.cwd || process.cwd(),
+      env: { ...process.env, ...termEnv, ...(this.options.env || {}) },
+    });
+
+    return this.pty;
+  }
+
+  /**
+   * 连接输入输出流
+   *
+   * @param {Stream} stdin - 标准输入流
+   * @param {Stream} stdout - 标准输出流
+   * @param {Stream} stderr - 标准错误流（PTY会合流，此参数保留用于兼容）
+   */
+  attachStreams(stdin, stdout, stderr) {
+    if (!this.pty) {
+      throw new Error("PTY not spawned yet. Call spawn() first.");
+    }
+
+    // 保存引用（用于cleanup）
+    this.stdin = stdin;
+    this.stdout = stdout;
+
+    if (this.ioAdapter) {
+      // 使用IO适配器（未来扩展）
+      this.ioAdapter.attach(this.pty, stdin, stdout, stderr);
+    } else {
+      // 当前：直接连接streams
+      this._attachDirectStreams(stdin, stdout);
+    }
+  }
+
+  /**
+   * 直接连接streams（当前实现）
+   * @private
+   */
+  _attachDirectStreams(stdin, stdout) {
+    // PTY输出 -> stdout
+    this._ptyDataHandler = (data) => {
+      // 1. 输出到terminal
+      stdout.write(data);
+
+      // 2. 可选：日志记录（JSONL格式）
+      if (this.logger) {
+        const logEntry = {
+          ts: Date.now(),
+          dir: "out",
+          data: this._serializeData(data),
+        };
+        this.logger.write(JSON.stringify(logEntry) + "\n");
+      }
+
+      // 3. 可选：监控回调
+      if (this.monitor) {
+        try {
+          this.monitor.onOutput(data);
+        } catch (err) {
+          // 监控失败不应影响IO通路
+          if (process.env.UFOO_DEBUG) {
+            console.error("[PtyWrapper] Monitor error:", err);
+          }
+        }
+      }
+    };
+    this.pty.onData(this._ptyDataHandler);
+
+    // stdin -> PTY（支持raw mode和控制字符）
+    if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+
+    this._stdinHandler = (data) => {
+      this.pty.write(data);
+
+      // 可选：日志记录
+      if (this.logger) {
+        const logEntry = {
+          ts: Date.now(),
+          dir: "in",
+          data: this._serializeData(data),
+          source: "terminal",
+        };
+        this.logger.write(JSON.stringify(logEntry) + "\n");
+      }
+    };
+    stdin.on("data", this._stdinHandler);
+
+    // 终端大小变化（codex-44：判断isTTY）
+    if (stdout.isTTY) {
+      this._resizeHandler = () => {
+        if (this.pty && !this.pty._closed) {
+          // codex-45：默认值兜底（极端环境可能undefined）
+          const cols = stdout.columns || 80;
+          const rows = stdout.rows || 24;
+          this.pty.resize(cols, rows);
+        }
+      };
+      stdout.on("resize", this._resizeHandler);
+    }
+
+    // 进程退出
+    this._ptyExitHandler = ({ exitCode, signal }) => {
+      this.cleanup();
+
+      // 回调给launcher处理退出（不直接process.exit）
+      if (this.onExit) {
+        this.onExit({ exitCode, signal });
+      }
+    };
+    this.pty.onExit(this._ptyExitHandler);
+  }
+
+  /**
+   * 写入数据到PTY（用于外部inject）
+   *
+   * @param {string|Buffer} data - 要写入的数据
+   * @returns {boolean} 是否成功
+   */
+  write(data) {
+    if (!this.pty || this.pty._closed) {
+      return false;
+    }
+    try {
+      this.pty.write(data);
+      return true;
+    } catch (err) {
+      if (process.env.UFOO_DEBUG) {
+        console.error(`[PtyWrapper] write error: ${err.message}`);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * 数据序列化（智能编码）
+   *
+   * codex-44建议：utf8优先，失败才base64
+   *
+   * @private
+   * @param {Buffer|String} data - 原始数据
+   * @returns {Object} 序列化后的数据对象
+   */
+  _serializeData(data) {
+    const buf = Buffer.from(data);
+
+    // 尝试utf8解码
+    try {
+      const str = buf.toString("utf8");
+      // 验证解码结果（检测replacement character \uFFFD）
+      if (!str.includes("\uFFFD")) {
+        return {
+          text: str,
+          encoding: "utf8",
+          size: buf.length
+        };
+      }
+    } catch (err) {
+      // utf8解码失败，使用base64
+    }
+
+    // 二进制数据使用base64
+    return {
+      text: buf.toString("base64"),
+      encoding: "base64",
+      size: buf.length
+    };
+  }
+
+  /**
+   * 启用日志记录
+   *
+   * @param {String} logFile - 日志文件路径（JSONL格式）
+   */
+  enableLogging(logFile) {
+    if (this.logger) {
+      throw new Error("Logging already enabled");
+    }
+    this.logger = fs.createWriteStream(logFile, { flags: "a" });
+  }
+
+  /**
+   * 启用监控
+   *
+   * @param {Function} monitorCallback - 监控回调函数
+   */
+  enableMonitoring(monitorCallback) {
+    this.monitor = {
+      onOutput: monitorCallback,
+    };
+  }
+
+  /**
+   * 清理资源（codex-44：完善的清理逻辑，codex-45：幂等性）
+   *
+   * 注意：
+   * - 处理异常路径（try-catch）
+   * - 移除所有监听器（防止泄漏）
+   * - 检查PTY状态（已退出则跳过kill）
+   * - 恢复terminal状态（raw mode）
+   * - 幂等性（可以安全重复调用）
+   */
+  cleanup() {
+    // codex-45：防止重复清理
+    if (this._cleaned) {
+      return;
+    }
+    this._cleaned = true;
+
+    // 1. 关闭日志流
+    if (this.logger) {
+      try {
+        this.logger.end();
+      } catch (err) {
+        // 忽略错误
+      }
+      this.logger = null;
+    }
+
+    // 2. 清理PTY（codex-44：已退出则跳过，codex-45：移除监听器）
+    if (this.pty) {
+      // 移除PTY监听器
+      try {
+        if (this._ptyDataHandler) {
+          this.pty.removeListener("data", this._ptyDataHandler);
+          this._ptyDataHandler = null;
+        }
+        if (this._ptyExitHandler) {
+          this.pty.removeListener("exit", this._ptyExitHandler);
+          this._ptyExitHandler = null;
+        }
+      } catch (err) {
+        // 忽略移除监听器的错误
+      }
+
+      // Kill PTY进程（已退出则跳过）
+      if (!this.pty._closed) {
+        try {
+          this.pty.kill();
+        } catch (err) {
+          // PTY可能已经退出，忽略错误
+        }
+      }
+      this.pty = null;
+    }
+
+    // 3. 清理stdin（codex-45：使用保存的handler引用）
+    if (this.stdin) {
+      // 移除data监听器
+      if (this._stdinHandler) {
+        this.stdin.removeListener("data", this._stdinHandler);
+        this._stdinHandler = null;
+      }
+
+      // 恢复terminal状态（codex-44：异常路径也要恢复）
+      if (this.stdin.isTTY && typeof this.stdin.setRawMode === "function") {
+        try {
+          this.stdin.setRawMode(false);
+        } catch (err) {
+          // 恢复失败不阻塞退出
+        }
+      }
+
+      this.stdin = null;
+    }
+
+    // 4. 清理stdout（codex-44：移除resize监听器）
+    if (this.stdout) {
+      if (this.stdout.isTTY && this._resizeHandler) {
+        this.stdout.removeListener("resize", this._resizeHandler);
+        this._resizeHandler = null;
+      }
+      this.stdout = null;
+    }
+
+    // 5. 清理监控回调
+    this.monitor = null;
+    this.onExit = null;
+  }
+}
+
+module.exports = PtyWrapper;

package/src/agent/readyDetector.js

@@ -0,0 +1,159 @@
+/**
+ * Agent Ready检测器
+ * 通过分析PTY输出判断agent是否初始化完成并ready接收命令
+ */
+class ReadyDetector {
+  constructor(agentType) {
+    this.agentType = agentType;
+    this.ready = false;
+    this.buffer = ""; // 缓存最近的输出（用于多行匹配）
+    this.maxBufferSize = 2000; // 限制buffer大小
+    this.callbacks = [];
+    this.createdAt = Date.now(); // 用于性能指标
+    this.readyAt = null; // 记录ready的时间
+  }
+
+  /**
+   * 注册ready回调
+   */
+  onReady(callback) {
+    if (this.ready) {
+      // 已经ready，立即执行
+      callback();
+    } else {
+      this.callbacks.push(callback);
+    }
+  }
+
+  /**
+   * 触发ready状态
+   */
+  _triggerReady() {
+    if (this.ready) return;
+    this.ready = true;
+    this.readyAt = Date.now();
+
+    // 计算检测耗时
+    const detectionTime = this.readyAt - this.createdAt;
+
+    if (process.env.UFOO_DEBUG) {
+      console.error(`[ReadyDetector] ${this.agentType} ready detected in ${detectionTime}ms`);
+    }
+
+    this.callbacks.forEach((cb) => {
+      try {
+        cb();
+      } catch (err) {
+        // 忽略回调错误，但在debug模式下记录
+        if (process.env.UFOO_DEBUG) {
+          console.error(`[ReadyDetector] callback error:`, err);
+        }
+      }
+    });
+    this.callbacks = [];
+  }
+
+  /**
+   * 检测claude-code的ready标记
+   * 特征：prompt "❯" 或分隔线 "────────"
+   */
+  _detectClaudeCodeReady(text) {
+    // 1. 检测prompt标记（更可靠）
+    if (text.includes("❯")) {
+      return true;
+    }
+
+    // 2. 检测分隔线（banner完成后的标记）
+    if (text.includes("────────") && text.includes("Try")) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * 检测codex的ready标记
+   */
+  _detectCodexReady(text) {
+    // Codex的prompt检测（更严格，避免误报）
+    // 1. 明确的 "codex>" prompt
+    if (text.includes("codex>")) {
+      return true;
+    }
+    // 2. 行首或行尾的单独 ">" prompt（避免匹配JSON/HTML中的>）
+    if (/(?:^|\n)>\s*$/.test(text)) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 处理PTY输出数据
+   * @param {Buffer|string} data - PTY输出数据
+   */
+  processOutput(data) {
+    if (this.ready) return; // 已经ready，跳过后续检测
+
+    // 跳过null/undefined
+    if (data == null) return;
+
+    // 转换为字符串
+    const text = Buffer.isBuffer(data) ? data.toString("utf8") : String(data);
+
+    if (!text) return; // 跳过空输入
+
+    // 追加到buffer
+    this.buffer += text;
+
+    // 限制buffer大小（防止内存泄漏）
+    if (this.buffer.length > this.maxBufferSize) {
+      const keepSize = Math.floor(this.maxBufferSize * 0.5); // 保留50%
+      this.buffer = this.buffer.slice(-keepSize);
+
+      if (process.env.UFOO_DEBUG) {
+        console.error(`[ReadyDetector] buffer trimmed, keeping last ${keepSize} bytes`);
+      }
+    }
+
+    // 根据agentType检测ready标记
+    let isReady = false;
+    if (this.agentType === "claude-code") {
+      isReady = this._detectClaudeCodeReady(this.buffer);
+    } else if (this.agentType === "codex") {
+      isReady = this._detectCodexReady(this.buffer);
+    }
+
+    if (isReady) {
+      if (process.env.UFOO_DEBUG) {
+        console.error(`[ReadyDetector] prompt detected in buffer (${this.buffer.length} bytes)`);
+      }
+      this._triggerReady();
+    }
+  }
+
+  /**
+   * 强制标记为ready（用于fallback超时）
+   */
+  forceReady() {
+    if (process.env.UFOO_DEBUG && !this.ready) {
+      console.error(`[ReadyDetector] force ready triggered after ${Date.now() - this.createdAt}ms`);
+    }
+    this._triggerReady();
+  }
+
+  /**
+   * 获取性能指标
+   */
+  getMetrics() {
+    return {
+      agentType: this.agentType,
+      ready: this.ready,
+      createdAt: this.createdAt,
+      readyAt: this.readyAt,
+      detectionTimeMs: this.readyAt ? this.readyAt - this.createdAt : null,
+      bufferSize: this.buffer.length,
+    };
+  }
+}
+
+module.exports = ReadyDetector;

package/src/agent/ufooAgent.js

@@ -2,9 +2,11 @@ const fs = require("fs");
 const path = require("path");
 const { runCliAgent } = require("./cliRunner");
 const { normalizeCliOutput } = require("./normalizeOutput");
+const { buildStatus } = require("../daemon/status");
+const { getUfooPaths } = require("../ufoo/paths");
 
 function loadSessionState(projectRoot) {
-  const dir = path.join(projectRoot, ".ufoo", "agent");
+  const dir = getUfooPaths(projectRoot).agentDir;
   const file = path.join(dir, "ufoo-agent.json");
   try {
     const data = JSON.parse(fs.readFileSync(file, "utf8"));
@@ -15,52 +17,38 @@ function loadSessionState(projectRoot) {
 }
 
 function saveSessionState(projectRoot, state) {
-  const dir = path.join(projectRoot, ".ufoo", "agent");
+  const dir = getUfooPaths(projectRoot).agentDir;
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(path.join(dir, "ufoo-agent.json"), JSON.stringify(state, null, 2));
 }
 
-function isPidAlive(pid) {
-  if (!pid || typeof pid !== "number") return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return Boolean(err && err.code === "EPERM");
-  }
-}
-
 function loadBusSummary(projectRoot, maxLines = 20) {
-  const busPath = path.join(projectRoot, ".ufoo", "bus", "bus.json");
-  let subscribers = [];
+  // Use daemon's buildStatus as the single source of truth
+  let agents = [];
   let nicknames = {};
   try {
-    const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
-    subscribers = Object.entries(bus.subscribers || {})
-      .map(([id, meta]) => {
-        const pid = typeof meta.pid === "number" ? meta.pid : Number(meta.pid || 0);
-        const status = meta.status || "unknown";
-        const online = status === "active" && isPidAlive(pid);
-        const nickname = meta.nickname || "";
-        if (nickname) {
-          nicknames[nickname] = id;
-        }
-        return {
-          id,
-          status,
-          online,
-          agent_type: meta.agent_type || "",
-          nickname,
-          last_heartbeat: meta.last_heartbeat || "",
-        };
-      })
-      .filter((item) => item.online);
+    const status = buildStatus(projectRoot);
+    const activeMeta = status.active_meta || [];
+    agents = activeMeta.map((item) => {
+      const nickname = item.nickname || "";
+      if (nickname) {
+        nicknames[nickname] = item.id;
+      }
+      return {
+        id: item.id,
+        status: "active",
+        online: true,
+        agent_type: "", // Not included in active_meta, but not needed
+        nickname,
+        last_heartbeat: "",
+      };
+    });
   } catch {
-    subscribers = [];
+    agents = [];
     nicknames = {};
   }
 
-  const eventsDir = path.join(projectRoot, ".ufoo", "bus", "events");
+  const eventsDir = getUfooPaths(projectRoot).busEventsDir;
   let recent = [];
   try {
     const files = fs
@@ -80,10 +68,15 @@ function loadBusSummary(projectRoot, maxLines = 20) {
     recent = [];
   }
 
-  return { subscribers, nicknames, recent };
+  return { agents, nicknames, recent };
 }
 
 function buildSystemPrompt(context) {
+  const hasAgents = context.agents && context.agents.length > 0;
+  const agentGuidance = hasAgents
+    ? ""
+    : "\n- IMPORTANT: No agents are currently online. To execute tasks, you MUST launch agents using ops.launch.\n- Example: {\"reply\":\"Creating agent\",\"ops\":[{\"action\":\"launch\",\"agent\":\"claude\",\"count\":1}]}";
+
   return [
     "You are ufoo-agent, a headless routing controller.",
     "Return ONLY valid JSON. No extra text.",
@@ -91,14 +84,16 @@ function buildSystemPrompt(context) {
     "{",
     '  "reply": "string",',
     '  "dispatch": [{"target":"broadcast|<agent-id>|<nickname>","message":"string"}],',
-    '  "ops": [{"action":"spawn|close","agent":"codex|claude","count":1,"agent_id":"id","nickname":"optional"}],',
+    '  "ops": [{"action":"launch|close|rename","agent":"codex|claude","count":1,"agent_id":"id","nickname":"optional"}],',
     '  "disambiguate": {"prompt":"string","candidates":[{"agent_id":"id","reason":"string"}]}',
     "}",
     "Rules:",
     "- target must be 'broadcast', concrete agent-id, or a known nickname",
     "- If multiple possible agents, use disambiguate with candidates and no dispatch.",
-    "- If user specifies a nickname for a new agent, include ops.spawn with nickname so daemon can rename.",
+    "- If user specifies a nickname for a new agent, include ops.launch with nickname so daemon can rename.",
+    "- If user requests rename, use ops.rename with agent_id and nickname (do NOT launch).",
     "- If no action needed, return reply with empty dispatch/ops.",
+    agentGuidance,
     "",
     "Context: online agents and recent bus events:",
     JSON.stringify(context),
@@ -106,7 +101,7 @@ function buildSystemPrompt(context) {
 }
 
 function loadHistory(projectRoot, maxTurns = 6) {
-  const file = path.join(projectRoot, ".ufoo", "agent", "ufoo-agent.history.jsonl");
+  const file = path.join(getUfooPaths(projectRoot).agentDir, "ufoo-agent.history.jsonl");
   try {
     const lines = fs.readFileSync(file, "utf8").trim().split(/\r?\n/).filter(Boolean);
     const items = lines.map((l) => JSON.parse(l));
@@ -117,7 +112,7 @@ function loadHistory(projectRoot, maxTurns = 6) {
 }
 
 function appendHistory(projectRoot, item) {
-  const dir = path.join(projectRoot, ".ufoo", "agent");
+  const dir = getUfooPaths(projectRoot).agentDir;
   fs.mkdirSync(dir, { recursive: true });
   const file = path.join(dir, "ufoo-agent.history.jsonl");
   fs.appendFileSync(file, `${JSON.stringify(item)}\n`);
@@ -200,7 +195,7 @@ async function runUfooAgent({ projectRoot, prompt, provider, model }) {
   const fallbackNickname = extractNickname(prompt);
   if (fallbackNickname && payload && Array.isArray(payload.ops)) {
     for (const op of payload.ops) {
-      if (op && op.action === "spawn" && !op.nickname) {
+      if (op && (op.action === "launch" || op.action === "rename") && !op.nickname) {
         op.nickname = fallbackNickname;
         break;
       }