u-foo 1.0.6 → 1.2.0

package/src/agent/internalRunner.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const path = require("path");
 const { getUfooPaths } = require("../ufoo/paths");
 const { spawnSync } = require("child_process");
+const EventBus = require("../bus");
 const { runCliAgent } = require("./cliRunner");
 const { normalizeCliOutput } = require("./normalizeOutput");
 
@@ -37,6 +38,30 @@ function safeSubscriber(subscriber) {
   return subscriber.replace(/:/g, "_");
 }
 
+function createBusSender(projectRoot, subscriber) {
+  const eventBus = new EventBus(projectRoot);
+  let sendQueue = Promise.resolve();
+
+  function enqueue(target, message) {
+    if (!target || !message) return;
+    sendQueue = sendQueue
+      .then(() => eventBus.send(target, message, subscriber))
+      .catch(() => {
+        // ignore per-message bus send errors to keep runner loop alive
+      });
+  }
+
+  async function flush() {
+    try {
+      await sendQueue;
+    } catch {
+      // ignore flush errors
+    }
+  }
+
+  return { enqueue, flush };
+}
+
 function drainQueue(queueFile) {
   if (!fs.existsSync(queueFile)) return [];
   const processingFile = `${queueFile}.processing.${process.pid}.${Date.now()}`;
@@ -70,11 +95,20 @@ function drainQueue(queueFile) {
   return content.split(/\r?\n/).filter(Boolean);
 }
 
-async function handleEvent(projectRoot, agentType, provider, model, subscriber, nickname, evt, cliSessionState) {
+async function handleEvent(projectRoot, agentType, provider, model, subscriber, nickname, evt, cliSessionState, busSender) {
   if (!evt || !evt.data || !evt.data.message) return;
   const prompt = evt.data.message;
   const publisher = evt.publisher || "unknown";
   const sandbox = "workspace-write";
+  const streamState = { emitted: false, lastChar: "" };
+
+  const emitStreamDelta = (delta) => {
+    const text = String(delta || "");
+    if (!text) return;
+    streamState.emitted = true;
+    streamState.lastChar = text.slice(-1);
+    busSender.enqueue(publisher, JSON.stringify({ stream: true, delta: text }));
+  };
 
   let res = await runCliAgent({
     provider,
@@ -83,6 +117,7 @@ async function handleEvent(projectRoot, agentType, provider, model, subscriber,
     sessionId: cliSessionState.cliSessionId,
     sandbox,
     cwd: projectRoot,
+    onStreamDelta: emitStreamDelta,
   });
 
   // Handle session errors with immediate retry (only for claude)
@@ -100,6 +135,7 @@ async function handleEvent(projectRoot, agentType, provider, model, subscriber,
         sessionId: null, // Let runCliAgent generate new session
         sandbox,
         cwd: projectRoot,
+        onStreamDelta: emitStreamDelta,
       });
     }
   }
@@ -117,13 +153,25 @@ async function handleEvent(projectRoot, agentType, provider, model, subscriber,
     reply = `[internal:${agentType}] error: ${res.error || "unknown error"}`;
   }
 
+  if (streamState.emitted) {
+    if (!res.ok) {
+      if (streamState.lastChar !== "\n") {
+        busSender.enqueue(publisher, JSON.stringify({ stream: true, delta: "\n" }));
+      }
+      busSender.enqueue(publisher, JSON.stringify({ stream: true, delta: reply }));
+    }
+    busSender.enqueue(
+      publisher,
+      JSON.stringify({ stream: true, done: true, reason: res.ok ? "complete" : "error" })
+    );
+    await busSender.flush();
+    return;
+  }
+
   if (!reply) return;
 
-  spawnSync("ufoo", ["bus", "send", publisher, reply], {
-    cwd: projectRoot,
-    env: { ...process.env, AI_BUS_PUBLISHER: subscriber },
-    stdio: "ignore",
-  });
+  busSender.enqueue(publisher, reply);
+  await busSender.flush();
 }
 
 async function runInternalRunner({ projectRoot, agentType = "codex" }) {
@@ -133,8 +181,13 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
 
   const queueDir = path.join(getUfooPaths(projectRoot).busQueuesDir, safeSubscriber(subscriber));
   const queueFile = path.join(queueDir, "pending.jsonl");
-  const provider = agentType === "codex" ? "codex-cli" : "claude-cli";
+  const normalizedAgentType = String(agentType || "").trim().toLowerCase();
+  if (normalizedAgentType === "ufoo" || normalizedAgentType === "ucode" || normalizedAgentType === "ufoo-code") {
+    throw new Error("ufoo core is not supported by headless internal runner; use internal-pty");
+  }
+  const provider = normalizedAgentType === "codex" ? "codex-cli" : "claude-cli";
   const model = process.env.UFOO_AGENT_MODEL || "";
+  const busSender = createBusSender(projectRoot, subscriber);
 
   // Session state management for CLI continuity
   // Use stable path based on nickname (if exists) or agent type, NOT subscriber ID
@@ -206,7 +259,17 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
 
           for (const evt of events) {
             // eslint-disable-next-line no-await-in-loop
-            await handleEvent(projectRoot, parsedAgentType, provider, model, subscriber, nickname, evt, cliSessionState);
+            await handleEvent(
+              projectRoot,
+              parsedAgentType,
+              provider,
+              model,
+              subscriber,
+              nickname,
+              evt,
+              cliSessionState,
+              busSender
+            );
           }
 
           // Persist CLI session state after processing (only if changed and for claude)
@@ -236,4 +299,8 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
   }
 }
 
-module.exports = { runInternalRunner };
+module.exports = {
+  runInternalRunner,
+  createBusSender,
+  handleEvent,
+};

package/src/agent/launcher.js

@@ -1,3 +1,5 @@
+const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
+const { PTY_SOCKET_MESSAGE_TYPES } = require("../shared/ptySocketContract");
 const { spawn, spawnSync } = require("child_process");
 const fs = require("fs");
 const net = require("net");
@@ -7,6 +9,7 @@ const { isAgentPidAlive } = require("../bus/utils");
 const { showBanner } = require("../utils/banner");
 const AgentNotifier = require("./notifier");
 const { getUfooPaths } = require("../ufoo/paths");
+const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const PtyWrapper = require("./ptyWrapper");
 const ReadyDetector = require("./readyDetector");
 
@@ -31,6 +34,21 @@ async function connectWithRetry(sockPath, retries, delayMs) {
   return null;
 }
 
+async function probeDaemonSocket(sockPath) {
+  try {
+    const client = await connectSocket(sockPath);
+    try {
+      client.end();
+      client.destroy();
+    } catch {
+      // ignore cleanup errors
+    }
+    return { ok: true, code: "" };
+  } catch (err) {
+    return { ok: false, code: err && err.code ? err.code : "" };
+  }
+}
+
 function normalizeTty(ttyPath) {
   if (!ttyPath) return "";
   const trimmed = String(ttyPath).trim();
@@ -136,6 +154,12 @@ function resolveLaunchMode() {
   return "terminal";
 }
 
+function shouldShowLaunchBanner(agentType = "") {
+  if (process.env.UFOO_SUPPRESS_LAUNCHER_BANNER === "1") return false;
+  void agentType;
+  return true;
+}
+
 /**
  * Agent 启动器
  * 统一处理 agent 启动流程：初始化、daemon 注册、banner、命令执行
@@ -209,19 +233,34 @@ class AgentLauncher {
    * 确保 daemon 正在运行
    */
   async ensureDaemon() {
-    const pidFile = getUfooPaths(this.cwd).ufooDaemonPid;
+    const paths = getUfooPaths(this.cwd);
+    const pidFile = paths.ufooDaemonPid;
+    const sockFile = paths.ufooSock;
+
+    const existingProbe = await probeDaemonSocket(sockFile);
+    if (existingProbe.ok) return "running";
+    if (existingProbe.code === "EPERM" && fs.existsSync(pidFile)) {
+      // Sandbox may deny socket connect probes; keep prior behavior.
+      return "running";
+    }
 
-    if (fs.existsSync(pidFile)) {
-      const pidStr = fs.readFileSync(pidFile, "utf8").trim();
-      if (pidStr) {
-        const pid = parseInt(pidStr, 10);
-        try {
-          process.kill(pid, 0); // Check if alive
-          return "running";
-        } catch {
-          // Dead, start new
-        }
-      }
+    // Stale daemon runtime markers can block restart with false-positive "running".
+    // Clean local runtime markers only when socket probe failed.
+    try {
+      if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile);
+    } catch {
+      // ignore
+    }
+    try {
+      if (fs.existsSync(sockFile)) fs.unlinkSync(sockFile);
+    } catch {
+      // ignore
+    }
+    try {
+      const lockFile = path.join(paths.runDir, "daemon.lock");
+      if (fs.existsSync(lockFile)) fs.unlinkSync(lockFile);
+    } catch {
+      // ignore
     }
 
     // Start daemon using correct command
@@ -231,23 +270,23 @@ class AgentLauncher {
       detached: true,
     });
 
-    // Wait for daemon socket to be ready
-    const sockFile = getUfooPaths(this.cwd).ufooSock;
+    // Wait for daemon socket to be ready and reachable
+    let lastProbeCode = "";
     for (let i = 0; i < 30; i++) {
-      if (fs.existsSync(sockFile)) {
-        try {
-          const stat = fs.statSync(sockFile);
-          if (stat.isSocket()) {
-            break;
-          }
-        } catch {
-          // Continue waiting
-        }
+      const probe = await probeDaemonSocket(sockFile);
+      if (probe.ok) {
+        return "started";
+      }
+      if (probe.code === "EPERM" && fs.existsSync(pidFile)) {
+        return "started";
       }
+      lastProbeCode = probe.code || lastProbeCode;
       await new Promise((resolve) => setTimeout(resolve, 100));
     }
 
-    return "started";
+    throw new Error(
+      `Failed to start ufoo daemon${lastProbeCode ? ` (${lastProbeCode})` : ""}`
+    );
   }
 
   /**
@@ -265,15 +304,17 @@ class AgentLauncher {
     const tmuxPane = process.env.TMUX_PANE || "";
     const launchMode = resolveLaunchMode();
 
-    // 只在 terminal/tmux 模式下查找旧 session（可见终端才需要恢复）
+    // 只在支持 session reuse 的模式下查找旧 session（可见终端才需要恢复）
     // internal 模式由 daemon 管理，不需要自动恢复
-    const shouldReuse = launchMode === "terminal" || launchMode === "tmux";
+    const adapterRouter = createTerminalAdapterRouter();
+    const adapter = adapterRouter.getAdapter({ launchMode, agentId: "" });
+    const shouldReuse = adapter.capabilities.supportsSessionReuse;
     const previousSession = shouldReuse
       ? findPreviousSession(this.cwd, this.agentType, tty, tmuxPane)
       : null;
 
     const req = {
-      type: "register_agent",
+      type: IPC_REQUEST_TYPES.REGISTER_AGENT,
       agentType: this.agentType,
       nickname: nickname || (previousSession?.nickname) || "",
       parentPid: process.pid,
@@ -417,18 +458,24 @@ class AgentLauncher {
       // 4. 更新环境变量（供子进程/后续使用）
       if (subscriberId) process.env.UFOO_SUBSCRIBER_ID = subscriberId;
       if (finalNickname) process.env.UFOO_NICKNAME = finalNickname;
+      process.env.UFOO_AGENT_TYPE = this.agentType;
+
+      // 5. 显示 banner（ucode 自带 TUI banner，这里避免重复）
+      if (shouldShowLaunchBanner(this.agentType)) {
+        showBanner({
+          agentType: this.agentType,
+          sessionId,
+          nickname: finalNickname,
+          daemonStatus,
+        });
+      }
 
-      // 5. 显示 banner
-      showBanner({
-        agentType: this.agentType,
-        sessionId,
-        nickname: finalNickname,
-        daemonStatus,
-      });
-
-      // 6. 启动消息通知监听器
-      const notifier = new AgentNotifier(this.cwd, subscriberId);
-      notifier.start();
+      // 6. 启动消息通知监听器（ufoo-code 改为内部 bus 轮询消费）
+      const shouldStartNotifier = String(this.agentType || "").trim().toLowerCase() !== "ufoo-code";
+      if (shouldStartNotifier) {
+        const notifier = new AgentNotifier(this.cwd, subscriberId);
+        notifier.start();
+      }
 
       // 7. 启动命令（PTY wrapper或直接spawn）
 
@@ -480,7 +527,7 @@ class AgentLauncher {
               const daemonSock = await connectWithRetry(daemonSockPath, 3, 100);
               if (daemonSock) {
                 daemonSock.write(`${JSON.stringify({
-                  type: "agent_ready",
+                  type: IPC_REQUEST_TYPES.AGENT_READY,
                   subscriberId,
                 })}\n`);
                 daemonSock.end();
@@ -571,7 +618,7 @@ class AgentLauncher {
               }
               // Forward to all output subscribers
               if (outputSubscribers.size > 0) {
-                const msg = JSON.stringify({ type: "output", data: text, encoding: "utf8" }) + "\n";
+                const msg = JSON.stringify({ type: PTY_SOCKET_MESSAGE_TYPES.OUTPUT, data: text, encoding: "utf8" }) + "\n";
                 for (const sub of outputSubscribers) {
                   try {
                     sub.write(msg);
@@ -595,6 +642,11 @@ class AgentLauncher {
                 try {
                   const req = JSON.parse(line);
                   if (req.type === "inject" && req.command) {
+                    const normalizedAgentType = String(this.agentType || "").trim().toLowerCase();
+                    if (normalizedAgentType === "ufoo-code" || normalizedAgentType === "ucode" || normalizedAgentType === "ufoo") {
+                      client.write(JSON.stringify({ ok: false, error: "inject disabled for ufoo-code (internal bus loop)" }) + "\n");
+                      continue;
+                    }
                     // 注入命令到PTY（带延迟确保输入完成）
                     wrapper.write(req.command);
                     setTimeout(() => {
@@ -613,23 +665,23 @@ class AgentLauncher {
                       };
                       wrapper.logger.write(JSON.stringify(logEntry) + "\n");
                     }
-                  } else if (req.type === "raw" && req.data) {
+                  } else if (req.type === PTY_SOCKET_MESSAGE_TYPES.RAW && req.data) {
                     // Raw PTY write (no Enter appended) - for TTY view passthrough
                     wrapper.write(req.data);
                     client.write(JSON.stringify({ ok: true }) + "\n");
-                  } else if (req.type === "resize" && req.cols && req.rows) {
+                  } else if (req.type === PTY_SOCKET_MESSAGE_TYPES.RESIZE && req.cols && req.rows) {
                     // Resize PTY - for TTY view viewport adjustment
                     if (wrapper.pty && !wrapper.pty._closed) {
                       wrapper.pty.resize(req.cols, req.rows);
                     }
                     client.write(JSON.stringify({ ok: true }) + "\n");
-                  } else if (req.type === "subscribe") {
+                  } else if (req.type === PTY_SOCKET_MESSAGE_TYPES.SUBSCRIBE) {
                     // Subscribe to PTY output stream for TTY view
                     outputSubscribers.add(client);
-                    client.write(JSON.stringify({ type: "subscribed", ok: true }) + "\n");
+                    client.write(JSON.stringify({ type: PTY_SOCKET_MESSAGE_TYPES.SUBSCRIBED, ok: true }) + "\n");
                     // Replay from in-memory ring buffer
                     if (outputRingBuffer.length > 0) {
-                      client.write(JSON.stringify({ type: "replay", data: outputRingBuffer, encoding: "utf8" }) + "\n");
+                      client.write(JSON.stringify({ type: PTY_SOCKET_MESSAGE_TYPES.REPLAY, data: outputRingBuffer, encoding: "utf8" }) + "\n");
                     }
                   } else {
                     client.write(JSON.stringify({ ok: false, error: "invalid request" }) + "\n");

package/src/agent/normalizeOutput.js

@@ -3,7 +3,7 @@ function extractTextFromObject(obj) {
   if (obj.structured_output && typeof obj.structured_output === "object") {
     return JSON.stringify(obj.structured_output);
   }
-  const candidates = ["output", "text", "message", "content", "output_text", "result"];
+  const candidates = ["reply", "output", "text", "message", "content", "output_text", "result"];
   for (const key of candidates) {
     const val = obj[key];
     if (typeof val === "string") return val;

package/src/agent/notifier.js

@@ -1,5 +1,6 @@
 const fs = require("fs");
 const path = require("path");
+const EventBus = require("../bus");
 const Injector = require("../bus/inject");
 const { getUfooPaths } = require("../ufoo/paths");
 const { shakeTerminalByTty } = require("../bus/shake");
@@ -20,6 +21,7 @@ class AgentNotifier {
     this.stopped = false;
     this.autoTrigger = process.env.UFOO_AUTO_TRIGGER !== "0"; // 默认启用自动触发
     this.lastNickname = "";
+    this.lastUbusWakeCount = -1;
 
     // 计算队列文件路径
     const safeSub = subscriber.replace(/:/g, "_");
@@ -34,6 +36,11 @@ class AgentNotifier {
     // 初始化 injector
     const busDir = paths.busDir;
     this.injector = new Injector(busDir, paths.agentsFile);
+    this.eventBus = new EventBus(projectRoot);
+  }
+
+  isUfooCodeSubscriber() {
+    return String(this.subscriber || "").startsWith("ufoo-code:");
   }
 
   /**
@@ -104,6 +111,116 @@ class AgentNotifier {
     }
   }
 
+  drainPending() {
+    if (!fs.existsSync(this.queueFile)) return [];
+    const processingFile = `${this.queueFile}.processing.${process.pid}.${Date.now()}`;
+    let content = "";
+    let readOk = false;
+    try {
+      fs.renameSync(this.queueFile, processingFile);
+      content = fs.readFileSync(processingFile, "utf8");
+      readOk = true;
+    } catch {
+      try {
+        if (fs.existsSync(processingFile)) {
+          fs.renameSync(processingFile, this.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).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+
+  normalizePublisher(publisher) {
+    if (!publisher) return "";
+    if (typeof publisher === "string") return publisher;
+    if (typeof publisher === "object") {
+      return publisher.subscriber || publisher.nickname || "";
+    }
+    return String(publisher);
+  }
+
+  async emitDelivery(evt, status, errorMessage = "") {
+    const publisher = this.normalizePublisher(evt.publisher);
+    if (!publisher) return;
+    const data = {
+      target: this.subscriber,
+      seq: evt.seq,
+      status,
+    };
+    if (errorMessage) data.error = errorMessage;
+    // Provide a human-readable message for chat UI
+    if (status === "ok") {
+      data.message = `delivered to ${this.lastNickname || this.subscriber}`;
+    } else {
+      data.message = `delivery failed to ${this.lastNickname || this.subscriber}: ${errorMessage || "unknown error"}`;
+    }
+    try {
+      await this.eventBus.send(publisher, "", this.subscriber, { event: "delivery", data });
+    } catch {
+      // ignore delivery emit failures
+    }
+  }
+
+  async deliverPending() {
+    if (this.isUfooCodeSubscriber()) {
+      // ufoo-code consumes bus queue internally; notifier must not inject text/commands.
+      return 0;
+    }
+
+    const events = this.drainPending();
+    if (events.length === 0) return 0;
+    const failed = [];
+    let delivered = 0;
+    for (const evt of events) {
+      if (!evt || evt.event !== "message" || !evt.data || typeof evt.data.message !== "string") {
+        continue;
+      }
+      const message = String(evt.data.message);
+      try {
+        // Inject the actual message text into the terminal/tmux agent
+        // (Bus is the source of truth; inject is the delivery adapter.)
+        // eslint-disable-next-line no-await-in-loop
+        await this.injector.inject(this.subscriber, message);
+        delivered += 1;
+        // eslint-disable-next-line no-await-in-loop
+        await this.emitDelivery(evt, "ok");
+      } catch (err) {
+        failed.push(evt);
+        // eslint-disable-next-line no-await-in-loop
+        await this.emitDelivery(evt, "error", err.message || "inject failed");
+      }
+    }
+    if (failed.length > 0) {
+      try {
+        const content = failed.map((e) => JSON.stringify(e)).join("\n") + "\n";
+        fs.appendFileSync(this.queueFile, content, "utf8");
+      } catch {
+        // ignore requeue failures
+      }
+    }
+    return delivered;
+  }
+
   /**
    * 发送终端通知
    * iTerm2: 使用 OSC 9 原生通知
@@ -126,7 +243,7 @@ class AgentNotifier {
     if (!this.autoTrigger) return;
 
     try {
-      await this.injector.inject(this.subscriber);
+      await this.deliverPending();
     } catch (err) {
       // 自动触发失败时静默忽略，用户仍可手动输入
       // console.error("[notifier] Auto-trigger failed:", err.message);
@@ -136,7 +253,7 @@ class AgentNotifier {
   /**
    * 轮询检查队列
    */
-  poll() {
+  async poll() {
     if (this.stopped) return;
 
     const currentCount = this.getMessageCount();
@@ -152,7 +269,30 @@ class AgentNotifier {
       });
     }
 
-    this.lastCount = currentCount;
+    // Ensure pending delivery happens even if count doesn't change
+    if (this.autoTrigger && currentCount > 0) {
+      if (this.isUfooCodeSubscriber()) {
+        if (this.lastUbusWakeCount !== currentCount) {
+          try {
+            await this.autoTriggerInput();
+            this.lastUbusWakeCount = currentCount;
+          } catch {
+            // ignore delivery errors
+          }
+        }
+      } else {
+        try {
+          await this.deliverPending();
+        } catch {
+          // ignore delivery errors
+        }
+      }
+    }
+    if (currentCount <= 0) {
+      this.lastUbusWakeCount = -1;
+    }
+
+    this.lastCount = this.getMessageCount();
     this.refreshTitle();
     this.updateHeartbeat();
   }
@@ -170,7 +310,7 @@ class AgentNotifier {
 
     // 启动轮询
     this.timer = setInterval(() => {
-      this.poll();
+      this.poll().catch(() => {});
     }, this.interval);
 
     // 注册清理