u-foo 1.0.3 → 1.1.9

package/src/agent/ptyWrapper.js

@@ -0,0 +1,379 @@
+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._loggerBroken = false;
+    this._loggerErrorHandler = 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.writeLogEntry(logEntry);
+      }
+
+      // 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.writeLogEntry(logEntry);
+      }
+    };
+    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._loggerBroken = false;
+    const logger = fs.createWriteStream(logFile, { flags: "a" });
+    this._loggerErrorHandler = (err) => {
+      this._loggerBroken = true;
+      if (process.env.UFOO_DEBUG) {
+        console.error(`[PtyWrapper] logger error: ${err.message}`);
+      }
+    };
+    logger.on("error", this._loggerErrorHandler);
+    this.logger = logger;
+  }
+
+  writeLogEntry(logEntry) {
+    if (!this.logger || this._loggerBroken) return;
+    try {
+      this.logger.write(JSON.stringify(logEntry) + "\n");
+    } catch (err) {
+      this._loggerBroken = true;
+      if (process.env.UFOO_DEBUG) {
+        console.error(`[PtyWrapper] logger write failed: ${err.message}`);
+      }
+    }
+  }
+
+  /**
+   * 启用监控
+   *
+   * @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;
+      this._loggerErrorHandler = null;
+      this._loggerBroken = false;
+    }
+
+    // 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,175 @@
+/**
+ * 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;
+  }
+
+  /**
+   * 检测ufoo-code/ucode的ready标记
+   */
+  _detectUfooCodeReady(text) {
+    if (/(?:^|\n)(?:ufoo|ucode|pi-mono)>\s*$/m.test(text)) {
+      return true;
+    }
+    // 与 codex 路径保持一致的兜底：行首/行尾的单独 ">"
+    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);
+    } else if (this.agentType === "ufoo" || this.agentType === "ucode" || this.agentType === "ufoo-code") {
+      isReady = this._detectUfooCodeReady(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;