u-foo 1.0.6 → 1.1.9

package/src/bus/queue.js

@@ -15,6 +15,7 @@ class QueueManager {
   constructor(busDir) {
     this.busDir = busDir;
     this.queuesDir = path.join(busDir, "queues");
+    this.offsetsDir = path.join(busDir, "offsets");
   }
 
   /**
@@ -38,7 +39,7 @@ class QueueManager {
    * 获取 offset 文件路径
    */
   getOffsetPath(subscriber) {
-    return path.join(this.queuesDir, `${subscriberToSafeName(subscriber)}.offset`);
+    return path.join(this.offsetsDir, `${subscriberToSafeName(subscriber)}.offset`);
   }
 
   /**
@@ -91,6 +92,10 @@ class QueueManager {
     this.ensureQueueDir(subscriber);
     const pendingPath = this.getPendingPath(subscriber);
     appendJSONL(pendingPath, event);
+    if (event && event.event === "wake") {
+      const wakePath = path.join(this.getQueueDir(subscriber), "wake");
+      fs.writeFileSync(wakePath, String(event.seq || Date.now()), "utf8");
+    }
   }
 
   /**

package/src/bus/store.js

@@ -0,0 +1,189 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { getTimestamp, ensureDir, safeNameToSubscriber, getTtyProcessInfo } = require("./utils");
+const { getUfooPaths } = require("../ufoo/paths");
+const { loadAgentsData, saveAgentsData } = require("../ufoo/agentsStore");
+
+function readQueueTty(queueDir) {
+  try {
+    const value = fs.readFileSync(path.join(queueDir, "tty"), "utf8").trim();
+    return value || "";
+  } catch {
+    return "";
+  }
+}
+
+function nicknamePrefixForType(agentType = "") {
+  return agentType === "claude-code" ? "claude"
+       : agentType === "ufoo-code" ? "ucode"
+       : String(agentType || "agent");
+}
+
+function isRecoverableSessionId(sessionId = "") {
+  const text = String(sessionId || "").trim();
+  if (!text) return false;
+  if (text.includes(":") || text.includes("_")) return false;
+  return true;
+}
+
+function buildUsedNicknameSet(agents = {}) {
+  const set = new Set();
+  for (const meta of Object.values(agents || {})) {
+    if (!meta || meta.status !== "active") continue;
+    const nick = meta && typeof meta.nickname === "string" ? meta.nickname : "";
+    if (nick) set.add(nick);
+  }
+  return set;
+}
+
+function allocateRecoveredNickname(agentType, used) {
+  const prefix = nicknamePrefixForType(agentType);
+  let idx = 1;
+  while (used.has(`${prefix}-${idx}`)) idx += 1;
+  const nick = `${prefix}-${idx}`;
+  used.add(nick);
+  return nick;
+}
+
+class BusStore {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.paths = getUfooPaths(projectRoot);
+    this.busDir = this.paths.busDir;
+    this.agentsFile = this.paths.agentsFile;
+    this.eventsDir = this.paths.busEventsDir;
+    this.logsDir = this.paths.busLogsDir;
+  }
+
+  ensure() {
+    if (!fs.existsSync(this.busDir) || !fs.existsSync(this.paths.agentDir)) {
+      throw new Error(
+        "Event bus not initialized. Please run: ufoo bus init or /uinit"
+      );
+    }
+  }
+
+  load() {
+    const data = loadAgentsData(this.agentsFile);
+    if (!data.agents || typeof data.agents !== "object") {
+      data.agents = {};
+    }
+
+    const queueRoot = path.join(this.busDir, "queues");
+    if (!fs.existsSync(queueRoot)) return data;
+
+    const usedNicknames = buildUsedNicknameSet(data.agents);
+    const now = getTimestamp();
+    let recovered = false;
+
+    for (const entry of fs.readdirSync(queueRoot)) {
+      const queueDir = path.join(queueRoot, entry);
+      let stat;
+      try {
+        stat = fs.statSync(queueDir);
+      } catch {
+        continue;
+      }
+      if (!stat.isDirectory()) continue;
+
+      const subscriber = safeNameToSubscriber(entry);
+      const parts = subscriber.split(":");
+      if (parts.length !== 2) continue;
+      const [agentType, sessionId] = parts;
+      if (!agentType || !sessionId) continue;
+      if (!isRecoverableSessionId(sessionId)) continue;
+      if (data.agents[subscriber]) continue;
+
+      const tty = readQueueTty(queueDir);
+      const ttyInfo = tty ? getTtyProcessInfo(tty) : null;
+      const activeByTty = Boolean(ttyInfo && ttyInfo.alive && ttyInfo.hasAgent);
+      const nickname = activeByTty ? allocateRecoveredNickname(agentType, usedNicknames) : "";
+
+      data.agents[subscriber] = {
+        agent_type: agentType,
+        nickname,
+        status: activeByTty ? "active" : "inactive",
+        joined_at: now,
+        last_seen: now,
+        pid: 0,
+        tty,
+        tty_shell_pid: ttyInfo && ttyInfo.shellPid ? ttyInfo.shellPid : 0,
+        tmux_pane: "",
+        launch_mode: "",
+      };
+      recovered = true;
+    }
+
+    if (recovered) {
+      saveAgentsData(this.agentsFile, data);
+    }
+    return data;
+  }
+
+  save(busData) {
+    if (busData) {
+      saveAgentsData(this.agentsFile, busData);
+    }
+  }
+
+  init() {
+    ensureDir(this.busDir);
+    ensureDir(this.paths.agentDir);
+    ensureDir(this.eventsDir);
+    ensureDir(path.join(this.busDir, "queues"));
+    ensureDir(this.logsDir);
+    ensureDir(path.join(this.busDir, "offsets"));
+    ensureDir(this.paths.busDaemonDir);
+    ensureDir(this.paths.busDaemonCountsDir);
+
+    if (!fs.existsSync(this.agentsFile)) {
+      const busData = {
+        created_at: getTimestamp(),
+        agents: {},
+      };
+      saveAgentsData(this.agentsFile, busData);
+    }
+  }
+
+  getCurrentSubscriber(busData) {
+    if (process.env.UFOO_SUBSCRIBER_ID) {
+      return process.env.UFOO_SUBSCRIBER_ID;
+    }
+
+    if (!fs.existsSync(this.agentsFile)) {
+      return null;
+    }
+
+    const sessionFile = path.join(this.paths.agentDir, "session.txt");
+    if (fs.existsSync(sessionFile)) {
+      const sessionId = fs.readFileSync(sessionFile, "utf8").trim();
+      if (sessionId) {
+        return sessionId;
+      }
+    }
+
+    let currentTty = null;
+    try {
+      const ttyPath = fs.realpathSync("/dev/tty");
+      if (ttyPath && ttyPath.startsWith("/dev/")) {
+        currentTty = ttyPath;
+      }
+    } catch {
+      // tty not available
+    }
+
+    if (currentTty && busData && busData.agents) {
+      for (const [id, meta] of Object.entries(busData.agents)) {
+        if (meta.tty === currentTty) {
+          return id;
+        }
+      }
+    }
+
+    return null;
+  }
+}
+
+module.exports = { BusStore };

package/src/bus/subscriber.js

@@ -3,6 +3,13 @@ const { getTimestamp, isAgentPidAlive, isMetaActive, isValidTty, getTtyProcessIn
 const NicknameManager = require("./nickname");
 const { spawnSync } = require("child_process");
 
+function detectTerminalAppFromEnv() {
+  const termProgram = process.env.TERM_PROGRAM || "";
+  if (process.env.ITERM_SESSION_ID || termProgram === "iTerm.app") return "iterm2";
+  if (termProgram === "Apple_Terminal") return "terminal";
+  return termProgram || "";
+}
+
 /**
  * 获取当前终端的 tty 路径
  */
@@ -43,6 +50,10 @@ function tryTtyWithStdin(fd) {
 }
 
 function getTtyPath() {
+  // 0) Honor explicit ttyPath from node stdio if present (useful for tests)
+  const stdinTtyPath = normalizeTty(process.stdin?.ttyPath || "");
+  if (stdinTtyPath) return stdinTtyPath;
+
   // 1) Try stdin directly (inherits real tty if present)
   let ttyPath = tryTtyWithStdin(0);
   if (ttyPath) return ttyPath;
@@ -145,8 +156,9 @@ class SubscriberManager {
       }
       finalNickname = nickname;
     } else {
-      // 自动生成昵称
+      // 自动生成昵称（并标记占用，避免并发重复）
       finalNickname = nicknameManager.generateAutoNickname(agentType);
+      nicknameManager.setNickname(subscriber, finalNickname);
     }
 
     const launchMode = options.launchMode || process.env.UFOO_LAUNCH_MODE || "";
@@ -186,6 +198,11 @@ class SubscriberManager {
       launch_mode: launchMode,
     };
 
+    const terminalApp = options.terminalApp || detectTerminalAppFromEnv();
+    if (terminalApp) {
+      this.busData.agents[subscriber].terminal_app = terminalApp;
+    }
+
     // 如果传入了 providerSessionId（从旧 session 恢复），设置它
     if (options.providerSessionId) {
       this.busData.agents[subscriber].provider_session_id = options.providerSessionId;
@@ -284,10 +301,9 @@ class SubscriberManager {
     if (!this.busData.agents) return;
 
     for (const [id, meta] of Object.entries(this.busData.agents)) {
-      if (meta.status !== "active") continue;
-      // PID 已死则直接标记 inactive（不依赖 tty 检测，因为 tty 可能被新 agent 复用）
-      if (meta.pid && !isAgentPidAlive(meta.pid)) {
+      if (meta.status === "active" && !isMetaActive(meta)) {
         meta.status = "inactive";
+        meta.last_seen = getTimestamp();
       }
     }
   }

package/src/bus/utils.js

@@ -86,7 +86,7 @@ function isAgentPidAlive(pid) {
   if (!isPidAlive(pid)) return false;
   const cmd = getPidCommand(pid);
   if (!cmd) return true;
-  return /(claude|codex|node)/i.test(cmd);
+  return /(claude|codex|node|pi-mono|ufoo|ucode)/i.test(cmd);
 }
 
 /**
@@ -150,7 +150,7 @@ function getTtyProcessInfo(ttyPath) {
       return { alive: false, idle: false, hasAgent: false, shellPid: 0, processes: [] };
     }
     const shellNames = new Set(["zsh", "bash", "fish", "sh", "login"]);
-    const hasAgent = processes.some((p) => /(codex|claude|node)/i.test(p.comm));
+    const hasAgent = processes.some((p) => /(codex|claude|node|pi-mono|ufoo|ucode)/i.test(p.comm));
     const nonShell = processes.filter((p) => !shellNames.has(p.comm));
     const idle = !hasAgent && nonShell.length === 0;
     const shell = processes.find((p) => shellNames.has(p.comm));
@@ -184,7 +184,8 @@ function appendFileAtomic(filePath, content) {
  */
 function writeFileAtomic(filePath, content) {
   ensureDir(path.dirname(filePath));
-  const tmpFile = `${filePath}.tmp.${Date.now()}`;
+  // Include pid + random suffix to avoid collisions across concurrent writers in the same millisecond.
+  const tmpFile = `${filePath}.tmp.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString("hex")}`;
   fs.writeFileSync(tmpFile, content, "utf8");
   fs.renameSync(tmpFile, filePath);
 }
@@ -254,6 +255,10 @@ function truncateFile(filePath) {
   }
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 /**
  * 日志输出（带颜色）
  */
@@ -349,6 +354,7 @@ module.exports = {
   appendJSONL,
   readLastLine,
   truncateFile,
+  sleep,
   logInfo,
   logOk,
   logWarn,

package/src/chat/agentBar.js

@@ -0,0 +1,117 @@
+const { stripAnsi, truncateAnsi } = require("./text");
+
+function computeAgentBar(options = {}) {
+  const {
+    cols = 80,
+    hintText = "",
+    focusMode = "input",
+    selectedAgentIndex = -1,
+    activeAgents = [],
+    viewingAgent = null,
+    agentListWindowStart = 0,
+    maxAgentWindow = 4,
+    getAgentLabel = (id) => id,
+  } = options;
+
+  const hintAnsi = `\x1b[90m│ ${hintText}\x1b[0m`;
+  const selectionIndex = focusMode === "dashboard"
+    ? (selectedAgentIndex > 0 ? selectedAgentIndex - 1 : -1)
+    : activeAgents.indexOf(viewingAgent);
+  const maxAgentLen = Math.max(0, cols - 1 - 2 - stripAnsi(hintAnsi).length);
+  let windowItems = Math.max(1, Math.min(maxAgentWindow, activeAgents.length));
+  let start = agentListWindowStart;
+  const ufooItem = focusMode === "dashboard" && selectedAgentIndex === 0
+    ? "\x1b[90;7mufoo\x1b[0m"
+    : "\x1b[36mufoo\x1b[0m";
+  const ufooLen = stripAnsi(ufooItem).length;
+
+  const computeStart = (items) => {
+    if (activeAgents.length === 0) return 0;
+    let s = start;
+    if (selectionIndex >= 0) {
+      if (selectionIndex < s) {
+        s = selectionIndex;
+      } else if (selectionIndex >= s + items) {
+        s = selectionIndex - items + 1;
+      }
+    }
+    const maxStart = Math.max(0, activeAgents.length - items);
+    if (s > maxStart) s = maxStart;
+    if (s < 0) s = 0;
+    return s;
+  };
+
+  const truncateLabel = (label, maxLen) => {
+    const text = String(label || "");
+    if (maxLen <= 0) return "";
+    if (text.length <= maxLen) return text;
+    if (maxLen <= 3) return text.slice(0, maxLen);
+    return `${text.slice(0, maxLen - 3)}...`;
+  };
+
+  const buildAgentSegment = (items, maxLabelLen) => {
+    const s = computeStart(items);
+    const e = s + items;
+    const visible = activeAgents.slice(s, e);
+    const leftMore = s > 0 ? "\x1b[90m<\x1b[0m " : "";
+    const rightMore = e < activeAgents.length ? " \x1b[90m>\x1b[0m" : "";
+    let agentParts = [];
+    if (activeAgents.length > 0) {
+      agentParts = visible.map((agent, i) => {
+        const rawLabel = getAgentLabel(agent);
+        const label = maxLabelLen ? truncateLabel(rawLabel, maxLabelLen) : rawLabel;
+        const idx = s + i + 1; // +1 for ufoo at index 0
+        if (focusMode === "dashboard" && idx === selectedAgentIndex) {
+          return `\x1b[90;7m${label}\x1b[0m`;
+        }
+        if (agent === viewingAgent) return `\x1b[1;36m${label}\x1b[0m`;
+        return `\x1b[36m${label}\x1b[0m`;
+      });
+    }
+    const agentsText = activeAgents.length > 0
+      ? `${leftMore}${agentParts.join("  ")}${rightMore}`
+      : "\x1b[36mnone\x1b[0m";
+    return { segment: `${ufooItem}  ${agentsText}`, start: s };
+  };
+
+  let segmentInfo = buildAgentSegment(windowItems, 0);
+  while (windowItems > 0) {
+    const s = computeStart(windowItems);
+    const e = s + windowItems;
+    const hasLeft = s > 0;
+    const hasRight = e < activeAgents.length;
+    const spacingLen = windowItems > 1 ? (windowItems - 1) * 2 : 0;
+    const overhead = ufooLen + 2 + (hasLeft ? 2 : 0) + (hasRight ? 2 : 0) + spacingLen;
+    const available = maxAgentLen - overhead;
+    let maxLabelLen = windowItems > 0 ? Math.floor(available / windowItems) : 0;
+    if (windowItems > 1 && maxLabelLen < 3) {
+      windowItems -= 1;
+      segmentInfo = buildAgentSegment(windowItems, 0);
+      continue;
+    }
+    if (maxLabelLen < 1) maxLabelLen = 1;
+    segmentInfo = buildAgentSegment(windowItems, maxLabelLen);
+    if (stripAnsi(segmentInfo.segment).length <= maxAgentLen || windowItems === 1) break;
+    windowItems -= 1;
+    segmentInfo = buildAgentSegment(windowItems, 0);
+  }
+  start = segmentInfo.start;
+  const agentSegment = segmentInfo.segment;
+
+  let bar = ` ${agentSegment}  ${hintAnsi}`;
+  let barLen = stripAnsi(bar).length;
+  if (barLen > cols) {
+    bar = truncateAnsi(bar, cols);
+    barLen = stripAnsi(bar).length;
+  }
+  const pad = Math.max(0, cols - barLen);
+
+  return {
+    bar: `${bar}${" ".repeat(pad)}`,
+    windowStart: start,
+  };
+}
+
+module.exports = {
+  computeAgentBar,
+};

package/src/chat/agentDirectory.js

@@ -0,0 +1,88 @@
+function buildAgentMaps(activeAgents = [], metaList = [], fallbackMap = null) {
+  const labelMap = new Map();
+  const metaMap = new Map();
+  const metaById = new Map();
+
+  for (const meta of metaList) {
+    if (!meta || !meta.id) continue;
+    metaById.set(meta.id, meta);
+  }
+
+  for (const id of activeAgents) {
+    const meta = metaById.get(id);
+    const label = meta && meta.nickname
+      ? meta.nickname
+      : (fallbackMap && fallbackMap.get(id)) || id;
+    labelMap.set(id, label);
+    if (meta) {
+      metaMap.set(id, meta);
+    }
+  }
+
+  return { labelMap, metaMap };
+}
+
+function getAgentLabel(labelMap, agentId) {
+  return labelMap.get(agentId) || agentId;
+}
+
+function resolveAgentId({ label, activeAgents = [], labelMap = new Map(), lookupNickname = null }) {
+  if (!label) return null;
+  if (activeAgents.includes(label)) return label;
+
+  for (const [id, name] of labelMap.entries()) {
+    if (name === label) return id;
+  }
+
+  if (typeof lookupNickname === "function") {
+    const resolved = lookupNickname(label);
+    if (resolved) return resolved;
+  }
+
+  return null;
+}
+
+function resolveAgentDisplayName({ publisher, labelMap = new Map(), lookupNicknameById = null }) {
+  let displayName = publisher;
+  if (publisher && publisher.includes(":")) {
+    if (labelMap && labelMap.has(publisher)) {
+      displayName = labelMap.get(publisher);
+    } else if (typeof lookupNicknameById === "function") {
+      const resolved = lookupNicknameById(publisher);
+      if (resolved) displayName = resolved;
+    }
+  }
+  return displayName;
+}
+
+function clampAgentWindowWithSelection({
+  activeCount = 0,
+  maxWindow = 4,
+  windowStart = 0,
+  selectionIndex = -1,
+}) {
+  if (activeCount <= 0) {
+    return 0;
+  }
+  const maxItems = Math.max(1, Math.min(maxWindow, activeCount));
+  let nextStart = windowStart;
+  if (selectionIndex >= 0) {
+    if (selectionIndex < nextStart) {
+      nextStart = selectionIndex;
+    } else if (selectionIndex >= nextStart + maxItems) {
+      nextStart = selectionIndex - maxItems + 1;
+    }
+  }
+  const maxStart = Math.max(0, activeCount - maxItems);
+  if (nextStart > maxStart) nextStart = maxStart;
+  if (nextStart < 0) nextStart = 0;
+  return nextStart;
+}
+
+module.exports = {
+  buildAgentMaps,
+  getAgentLabel,
+  resolveAgentId,
+  resolveAgentDisplayName,
+  clampAgentWindowWithSelection,
+};