u-foo 1.0.3 → 1.0.6

package/src/agent/notifier.js

@@ -0,0 +1,200 @@
+const fs = require("fs");
+const path = require("path");
+const Injector = require("../bus/inject");
+const { getUfooPaths } = require("../ufoo/paths");
+const { shakeTerminalByTty } = require("../bus/shake");
+const { isITerm2 } = require("../terminal/detect");
+const iterm2 = require("../terminal/iterm2");
+
+/**
+ * Agent 消息通知监听器
+ * 监控 pending.jsonl 队列文件，当有新消息时发出通知并自动触发
+ */
+class AgentNotifier {
+  constructor(projectRoot, subscriber) {
+    this.projectRoot = projectRoot;
+    this.subscriber = subscriber;
+    this.interval = 2000; // 2秒轮询一次
+    this.lastCount = 0;
+    this.timer = null;
+    this.stopped = false;
+    this.autoTrigger = process.env.UFOO_AUTO_TRIGGER !== "0"; // 默认启用自动触发
+    this.lastNickname = "";
+
+    // 计算队列文件路径
+    const safeSub = subscriber.replace(/:/g, "_");
+    const paths = getUfooPaths(projectRoot);
+    this.queueFile = path.join(
+      paths.busQueuesDir,
+      safeSub,
+      "pending.jsonl"
+    );
+    this.agentsFile = paths.agentsFile;
+
+    // 初始化 injector
+    const busDir = paths.busDir;
+    this.injector = new Injector(busDir, paths.agentsFile);
+  }
+
+  /**
+   * 读取当前订阅者昵称
+   */
+  getNickname() {
+    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 && meta.nickname) ? String(meta.nickname) : "";
+    } catch {
+      return "";
+    }
+  }
+
+  /**
+   * 设置终端标题为昵称
+   * iTerm2: 同时设置 badge 和 cwd
+   */
+  setTitle(nickname) {
+    if (!nickname) return;
+    if (!process.stdout || !process.stdout.isTTY) return;
+    process.stdout.write(`\x1b]0;${nickname}\x07`);
+    if (isITerm2()) {
+      iterm2.setBadge(nickname);
+      iterm2.setCwd(this.projectRoot);
+    }
+  }
+
+  /**
+   * 检查昵称变化并更新标题
+   */
+  refreshTitle() {
+    const nickname = this.getNickname();
+    if (!nickname || nickname === this.lastNickname) return;
+    this.lastNickname = nickname;
+    this.setTitle(nickname);
+  }
+
+  /**
+   * 更新心跳时间戳（last_seen）
+   */
+  updateHeartbeat() {
+    try {
+      if (!this.agentsFile || !fs.existsSync(this.agentsFile)) return;
+      const data = JSON.parse(fs.readFileSync(this.agentsFile, "utf8"));
+      if (data.agents && data.agents[this.subscriber]) {
+        data.agents[this.subscriber].last_seen = new Date().toISOString();
+        fs.writeFileSync(this.agentsFile, JSON.stringify(data, null, 2));
+      }
+    } catch {
+      // 心跳更新失败时静默忽略
+    }
+  }
+
+  /**
+   * 获取当前队列中的消息数量
+   */
+  getMessageCount() {
+    try {
+      if (!fs.existsSync(this.queueFile)) return 0;
+      const content = fs.readFileSync(this.queueFile, "utf8");
+      if (!content.trim()) return 0;
+      return content.split("\n").filter((line) => line.trim()).length;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * 发送终端通知
+   * iTerm2: 使用 OSC 9 原生通知
+   */
+  notify(newCount) {
+    if (isITerm2()) {
+      const nick = this.lastNickname || this.subscriber;
+      iterm2.notify(`${nick}: ${newCount} new message(s)`);
+    }
+    const tty = this.injector.readTty(this.subscriber);
+    if (tty) {
+      shakeTerminalByTty(tty);
+    }
+  }
+
+  /**
+   * 自动触发终端输入
+   */
+  async autoTriggerInput() {
+    if (!this.autoTrigger) return;
+
+    try {
+      await this.injector.inject(this.subscriber);
+    } catch (err) {
+      // 自动触发失败时静默忽略，用户仍可手动输入
+      // console.error("[notifier] Auto-trigger failed:", err.message);
+    }
+  }
+
+  /**
+   * 轮询检查队列
+   */
+  poll() {
+    if (this.stopped) return;
+
+    const currentCount = this.getMessageCount();
+
+    // 有新消息
+    if (currentCount > this.lastCount) {
+      const newCount = currentCount - this.lastCount;
+      this.notify(newCount);
+
+      // 自动触发终端输入（非阻塞）
+      this.autoTriggerInput().catch(() => {
+        // 忽略触发失败
+      });
+    }
+
+    this.lastCount = currentCount;
+    this.refreshTitle();
+    this.updateHeartbeat();
+  }
+
+  /**
+   * 启动监听
+   */
+  start() {
+    // 获取初始计数
+    this.lastCount = this.getMessageCount();
+    this.lastNickname = this.getNickname();
+    if (this.lastNickname) {
+      this.setTitle(this.lastNickname);
+    }
+
+    // 启动轮询
+    this.timer = setInterval(() => {
+      this.poll();
+    }, this.interval);
+
+    // 注册清理
+    process.on("exit", () => this.stop());
+    process.on("SIGINT", () => {
+      this.stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      this.stop();
+      process.exit(0);
+    });
+  }
+
+  /**
+   * 停止监听
+   */
+  stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}
+
+module.exports = AgentNotifier;

package/src/agent/ptyRunner.js

@@ -0,0 +1,377 @@
+const fs = require("fs");
+const path = require("path");
+const EventBus = require("../bus");
+const { runInternalRunner } = require("./internalRunner");
+const { getUfooPaths } = require("../ufoo/paths");
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parseSubscriberId() {
+  if (process.env.UFOO_SUBSCRIBER_ID) {
+    const parts = process.env.UFOO_SUBSCRIBER_ID.split(":");
+    if (parts.length === 2) {
+      return {
+        subscriber: process.env.UFOO_SUBSCRIBER_ID,
+        agentType: parts[0],
+        sessionId: parts[1],
+      };
+    }
+  }
+  throw new Error("PTY runner requires UFOO_SUBSCRIBER_ID set by daemon");
+}
+
+function safeSubscriber(subscriber) {
+  return subscriber.replace(/:/g, "_");
+}
+
+function drainQueue(queueFile) {
+  if (!fs.existsSync(queueFile)) return [];
+  const processingFile = `${queueFile}.processing.${process.pid}.${Date.now()}`;
+  let content = "";
+  let readOk = false;
+  try {
+    fs.renameSync(queueFile, processingFile);
+    content = fs.readFileSync(processingFile, "utf8");
+    readOk = true;
+  } catch {
+    try {
+      if (fs.existsSync(processingFile)) {
+        fs.renameSync(processingFile, queueFile);
+      }
+    } catch {
+      // ignore rollback errors
+    }
+    return [];
+  } finally {
+    if (readOk) {
+      try {
+        if (fs.existsSync(processingFile)) {
+          fs.rmSync(processingFile, { force: true });
+        }
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+  }
+  if (!content.trim()) return [];
+  return content.split(/\r?\n/).filter(Boolean);
+}
+
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+
+function parseInputMessage(message) {
+  if (!message) return { raw: false, text: "" };
+  try {
+    const parsed = JSON.parse(message);
+    if (parsed && typeof parsed === "object") {
+      if (parsed.raw && typeof parsed.data === "string") {
+        return { raw: true, text: parsed.data };
+      }
+      if (typeof parsed.text === "string") {
+        return { raw: false, text: parsed.text };
+      }
+    }
+  } catch {
+    // ignore json parse errors
+  }
+  return { raw: false, text: message };
+}
+
+function buildPrompt(text, marker) {
+  if (!marker) return text;
+  return `${text}\n\n请在完成后输出以下标记（单独一行）：\n${marker}\n`;
+}
+
+function resolveCommand(agentType) {
+  const rawCmd = String(process.env.UFOO_PTY_CMD || "").trim();
+  if (rawCmd) {
+    const rawArgs = String(process.env.UFOO_PTY_ARGS || "").trim();
+    const args = rawArgs ? rawArgs.split(/\s+/).filter(Boolean) : [];
+    return { command: rawCmd, args };
+  }
+  if (agentType === "claude" || agentType === "claude-code") {
+    return { command: "claude", args: [] };
+  }
+  return { command: "codex", args: ["--no-alt-screen", "--sandbox", "workspace-write"] };
+}
+
+async function runPtyRunner({ projectRoot, agentType = "codex" }) {
+  let pty;
+  try {
+    // eslint-disable-next-line global-require
+    pty = require("node-pty");
+  } catch {
+    throw new Error("node-pty not installed");
+  }
+  const { subscriber } = parseSubscriberId();
+  const queueDir = path.join(getUfooPaths(projectRoot).busQueuesDir, safeSubscriber(subscriber));
+  const queueFile = path.join(queueDir, "pending.jsonl");
+  const runDir = getUfooPaths(projectRoot).runDir;
+  const logFile = path.join(runDir, "pty-runner.log");
+
+  const { command, args } = resolveCommand(agentType);
+  const env = {
+    ...process.env,
+    UFOO_LAUNCH_MODE: "internal-pty",
+    UFOO_INTERNAL_PTY: "1",
+  };
+
+  const eventBus = new EventBus(projectRoot);
+
+  let running = true;
+  let busy = false;
+  let currentPublisher = "";
+  let currentMarker = "";
+  let pendingOutput = [];
+  let outputBuffer = "";
+  let flushTimer = null;
+  let idleTimer = null;
+  let watchdogTimer = null;
+  let fallbackInProgress = false;
+  let ptyProcess = null;
+  const messageQueue = [];
+  const maxChunk = 2000;
+  const idleMs = 2000;
+  const watchdogMs = 120000;
+  const maxQueue = 200;
+  const watchdogAction = String(process.env.UFOO_PTY_WATCHDOG_ACTION || "restart").toLowerCase();
+  let sendQueue = Promise.resolve();
+
+  function enqueueSend(target, message) {
+    if (!target || !message) return;
+    sendQueue = sendQueue.then(() => eventBus.send(target, message, subscriber)).catch(() => {});
+  }
+
+  function flushPending() {
+    if (!currentPublisher || pendingOutput.length === 0) return;
+    const chunks = pendingOutput;
+    pendingOutput = [];
+    for (const chunk of chunks) {
+      enqueueSend(currentPublisher, chunk);
+    }
+  }
+
+  function deliverChunk(chunk) {
+    if (!chunk) return;
+    const payload = JSON.stringify({ stream: true, delta: chunk });
+    if (currentPublisher) {
+      enqueueSend(currentPublisher, payload);
+    } else {
+      pendingOutput.push(payload);
+      if (pendingOutput.length > 50) pendingOutput.shift();
+    }
+  }
+
+  function flushOutput() {
+    if (!outputBuffer) return;
+    const chunk = outputBuffer.slice(0, maxChunk);
+    outputBuffer = outputBuffer.slice(chunk.length);
+    if (chunk) {
+      deliverChunk(chunk);
+    }
+    if (outputBuffer) {
+      scheduleFlush();
+    }
+  }
+
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      flushOutput();
+    }, 120);
+  }
+
+  function logNote(note) {
+    try {
+      fs.mkdirSync(runDir, { recursive: true });
+      fs.appendFileSync(logFile, `[${new Date().toISOString()}] ${note}\n`);
+    } catch {
+      // ignore
+    }
+  }
+
+  function attachPty(proc) {
+    proc.onData((data) => {
+      const clean = stripAnsi(String(data || "")).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      if (!clean) return;
+      outputBuffer += clean;
+      if (currentMarker) {
+        const idx = outputBuffer.indexOf(currentMarker);
+        if (idx !== -1) {
+          const before = outputBuffer.slice(0, idx);
+          outputBuffer = "";
+          if (before) {
+            deliverChunk(before);
+          }
+          currentMarker = "";
+          busy = false;
+          currentPublisher = "";
+          if (watchdogTimer) {
+            clearTimeout(watchdogTimer);
+            watchdogTimer = null;
+          }
+          if (idleTimer) {
+            clearTimeout(idleTimer);
+            idleTimer = null;
+          }
+          processQueue();
+          return;
+        }
+      }
+      scheduleFlush();
+      if (busy) {
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+          idleTimer = null;
+          busy = false;
+          currentPublisher = "";
+          processQueue();
+        }, idleMs);
+      }
+    });
+
+    proc.onExit(({ exitCode, signal }) => {
+      if (outputBuffer) {
+        flushOutput();
+      }
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+      const note = `[internal-pty] process exited code=${exitCode} signal=${signal || ""}`.trim();
+      if (currentPublisher) enqueueSend(currentPublisher, note);
+      logNote(note);
+      running = false;
+    });
+  }
+
+  function spawnPtyProcess() {
+    const proc = pty.spawn(command, args, {
+      name: "xterm-256color",
+      cols: 80,
+      rows: 24,
+      cwd: projectRoot,
+      env,
+    });
+    attachPty(proc);
+    return proc;
+  }
+
+  function restartPty(reason) {
+    if (!running) return;
+    logNote(`Restarting PTY: ${reason}`);
+    if (outputBuffer) {
+      flushOutput();
+    }
+    try {
+      if (ptyProcess) ptyProcess.kill();
+    } catch {
+      // ignore
+    }
+    ptyProcess = spawnPtyProcess();
+  }
+
+  async function fallbackHeadless(reason) {
+    if (fallbackInProgress) return;
+    fallbackInProgress = true;
+    logNote(`Fallback to headless: ${reason}`);
+    if (outputBuffer) {
+      flushOutput();
+    }
+    try {
+      if (ptyProcess) ptyProcess.kill();
+    } catch {
+      // ignore
+    }
+    running = false;
+    await runInternalRunner({ projectRoot, agentType });
+    process.exit(0);
+  }
+
+  const stop = () => {
+    running = false;
+    try {
+      if (ptyProcess) ptyProcess.kill();
+    } catch {
+      // ignore
+    }
+  };
+
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+
+  ptyProcess = spawnPtyProcess();
+
+  function processQueue() {
+    if (busy || messageQueue.length === 0 || !running) return;
+    const next = messageQueue.shift();
+    if (!next) return;
+    busy = true;
+    currentPublisher = next.publisher;
+    currentMarker = next.marker || "";
+    flushPending();
+    if (next.text) {
+      if (next.raw) {
+        ptyProcess.write(next.text);
+      } else {
+        ptyProcess.write(`${buildPrompt(next.text, currentMarker)}\n`);
+      }
+    }
+    if (watchdogTimer) clearTimeout(watchdogTimer);
+    watchdogTimer = setTimeout(() => {
+      watchdogTimer = null;
+      if (!busy) return;
+      const timeoutNote = `[internal-pty] marker timeout; action=${watchdogAction}`;
+      if (currentPublisher) enqueueSend(currentPublisher, timeoutNote);
+      logNote(timeoutNote);
+      if (watchdogAction === "fallback") {
+        void fallbackHeadless("marker timeout");
+        return;
+      }
+      if (watchdogAction === "restart") {
+        restartPty("marker timeout");
+      }
+      currentMarker = "";
+      busy = false;
+      currentPublisher = "";
+      processQueue();
+    }, watchdogMs);
+  }
+
+  while (running) {
+    const lines = drainQueue(queueFile);
+    if (lines.length > 0) {
+      const events = [];
+      for (const line of lines) {
+        try {
+          events.push(JSON.parse(line));
+        } catch {
+          // ignore malformed line
+        }
+      }
+      for (const evt of events) {
+        if (!evt || !evt.data || typeof evt.data.message !== "string") continue;
+        const { raw, text } = parseInputMessage(evt.data.message);
+        if (messageQueue.length >= maxQueue) {
+          messageQueue.shift();
+        }
+        const marker = raw ? "" : `__UFOO_DONE_${Date.now()}_${Math.random().toString(16).slice(2)}__`;
+        messageQueue.push({ publisher: evt.publisher || "unknown", raw, text, marker });
+      }
+    }
+    processQueue();
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(200);
+  }
+}
+
+module.exports = { runPtyRunner };