u-foo 1.0.3 → 1.1.9

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

@@ -0,0 +1,312 @@
+const fs = require("fs");
+const { getTimestamp, isAgentPidAlive, isMetaActive, isValidTty, getTtyProcessInfo } = require("./utils");
+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 路径
+ */
+function resolveTtyFromPath(fdPath) {
+  try {
+    const real = fs.realpathSync(fdPath);
+    if (real && real.startsWith("/dev/")) {
+      return real;
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+function normalizeTty(ttyPath) {
+  if (!ttyPath) return "";
+  const trimmed = String(ttyPath).trim();
+  if (!trimmed || trimmed === "not a tty") return "";
+  if (trimmed === "/dev/tty") return "";
+  return trimmed;
+}
+
+function tryTtyWithStdin(fd) {
+  try {
+    const res = spawnSync("tty", {
+      stdio: [fd, "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    if (res && res.status === 0) {
+      const out = normalizeTty(res.stdout || "");
+      if (out) return out;
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+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;
+
+  // 2) Try controlling tty explicitly (works even if stdin is detached)
+  try {
+    const fd = fs.openSync("/dev/tty", "r");
+    ttyPath = tryTtyWithStdin(fd);
+    fs.closeSync(fd);
+    if (ttyPath) return ttyPath;
+  } catch {
+    // ignore
+  }
+
+  // 3) Fallback to stdout/stderr device paths
+  if (process.stdout.isTTY) {
+    ttyPath = normalizeTty(resolveTtyFromPath("/dev/stdout"));
+    if (ttyPath) return ttyPath;
+  }
+  if (process.stderr.isTTY) {
+    ttyPath = normalizeTty(resolveTtyFromPath("/dev/stderr"));
+    if (ttyPath) return ttyPath;
+  }
+
+  // Final fallback to controlling tty path (may be /dev/tty)
+  return normalizeTty(resolveTtyFromPath("/dev/tty"));
+}
+
+function getJoinedPid() {
+  const raw = process.env.UFOO_PARENT_PID || "";
+  const parsed = parseInt(raw, 10);
+  if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  return process.pid;
+}
+
+/**
+ * 订阅者管理
+ */
+class SubscriberManager {
+  constructor(busData, queueManager) {
+    this.busData = busData;
+    this.queueManager = queueManager;
+  }
+
+  async cleanupDuplicateTty(currentSubscriber, ttyPath) {
+    if (!ttyPath) return;
+    if (!this.busData.agents) return;
+
+    const entries = Object.entries(this.busData.agents);
+    for (const [id, meta] of entries) {
+      if (id === currentSubscriber) continue;
+      const metaTtyRaw = meta?.tty || "";
+      const metaTty = isValidTty(metaTtyRaw)
+        ? metaTtyRaw
+        : (await this.queueManager.readTty(id));
+      if (!metaTty) continue;
+      if (metaTty === ttyPath) {
+        // Remove stale subscriber using same tty
+        delete this.busData.agents[id];
+        try {
+          const queueDir = this.queueManager.getQueueDir(id);
+          if (queueDir) {
+            fs.rmSync(queueDir, { recursive: true, force: true });
+          }
+          const offsetPath = this.queueManager.getOffsetPath(id);
+          if (offsetPath) fs.rmSync(offsetPath, { force: true });
+        } catch {
+          // ignore cleanup errors
+        }
+      }
+    }
+  }
+
+  /**
+   * 加入总线
+   */
+  async join(sessionId, agentType, nickname = null, options = {}) {
+    // Special case: ufoo-agent uses fixed ID without suffix
+    const subscriber = (sessionId === "ufoo-agent")
+      ? "ufoo-agent"
+      : `${agentType}:${sessionId}`;
+
+    if (!this.busData.agents) {
+      this.busData.agents = {};
+    }
+
+    const nicknameManager = new NicknameManager(this.busData);
+
+    // 检查是否是重新加入（rejoin）
+    const existingMeta = this.busData.agents[subscriber];
+    let finalNickname = nickname;
+
+    if (existingMeta && existingMeta.nickname) {
+      // 重新加入，保留原昵称
+      finalNickname = existingMeta.nickname;
+    } else if (nickname) {
+      // 新昵称，检查冲突
+      if (nicknameManager.nicknameExists(nickname, subscriber)) {
+        throw new Error(`Nickname "${nickname}" already exists`);
+      }
+      finalNickname = nickname;
+    } else {
+      // 自动生成昵称（并标记占用，避免并发重复）
+      finalNickname = nicknameManager.generateAutoNickname(agentType);
+      nicknameManager.setNickname(subscriber, finalNickname);
+    }
+
+    const launchMode = options.launchMode || process.env.UFOO_LAUNCH_MODE || "";
+    const overridePid = Number.isFinite(options.parentPid) && options.parentPid > 0
+      ? options.parentPid
+      : null;
+    const hasOverrideTty = Object.prototype.hasOwnProperty.call(options, "tty");
+    const overrideTty = (typeof options.tty === "string" && isValidTty(options.tty.trim()))
+      ? options.tty.trim()
+      : "";
+    const detectedTty = hasOverrideTty ? overrideTty : getTtyPath();
+    const tty = overrideTty || (isValidTty(detectedTty) ? detectedTty : "");
+    const preservedTty = !tty && launchMode !== "internal" && isValidTty(existingMeta?.tty)
+      ? existingMeta.tty
+      : "";
+    const finalTty = tty || preservedTty;
+    const ttyInfo = finalTty ? getTtyProcessInfo(finalTty) : null;
+
+    // 清理同一 tty 的旧订阅者（避免重复启动污染）
+    await this.cleanupDuplicateTty(subscriber, finalTty);
+
+    // 更新订阅者信息（保留已有字段，如 provider_session_*）
+    const preserved = existingMeta && typeof existingMeta === "object"
+      ? { ...existingMeta }
+      : {};
+    this.busData.agents[subscriber] = {
+      ...preserved,
+      agent_type: agentType,
+      nickname: finalNickname,
+      status: "active",
+      joined_at: existingMeta?.joined_at || getTimestamp(),
+      last_seen: getTimestamp(),
+      pid: overridePid || getJoinedPid(),
+      tty: finalTty,
+      tty_shell_pid: ttyInfo?.shellPid || 0,
+      tmux_pane: options.tmuxPane || process.env.TMUX_PANE || "",
+      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;
+    }
+
+    // 保存 tty 信息
+    if (this.busData.agents[subscriber].tty) {
+      await this.queueManager.saveTty(
+        subscriber,
+        this.busData.agents[subscriber].tty
+      );
+    } else {
+      // 清理旧 tty 文件，避免错误注入
+      try {
+        const ttyPath = this.queueManager.getTtyPath(subscriber);
+        if (ttyPath && fs.existsSync(ttyPath)) {
+          fs.rmSync(ttyPath, { force: true });
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    // 创建队列目录
+    this.queueManager.ensureQueueDir(subscriber);
+
+    return { subscriber, nickname: finalNickname };
+  }
+
+  /**
+   * 离开总线
+   */
+  async leave(subscriber) {
+    if (!this.busData.agents || !this.busData.agents[subscriber]) {
+      return false;
+    }
+
+    this.busData.agents[subscriber].status = "inactive";
+    this.busData.agents[subscriber].last_seen = getTimestamp();
+
+    return true;
+  }
+
+  /**
+   * 重命名订阅者
+   */
+  async rename(subscriber, newNickname) {
+    if (!this.busData.agents || !this.busData.agents[subscriber]) {
+      throw new Error(`Subscriber "${subscriber}" not found`);
+    }
+
+    const nicknameManager = new NicknameManager(this.busData);
+
+    // 检查昵称冲突
+    if (nicknameManager.nicknameExists(newNickname, subscriber)) {
+      throw new Error(`Nickname "${newNickname}" already exists`);
+    }
+
+    const oldNickname = this.busData.agents[subscriber].nickname;
+    this.busData.agents[subscriber].nickname = newNickname;
+
+    return { subscriber, oldNickname, newNickname };
+  }
+
+  /**
+   * 获取所有在线订阅者
+   */
+  getActiveSubscribers() {
+    if (!this.busData.agents) return [];
+
+    return Object.entries(this.busData.agents)
+      .filter(([, meta]) => isMetaActive(meta))
+      .map(([id, meta]) => ({ id, ...meta }));
+  }
+
+  /**
+   * 获取订阅者信息
+   */
+  getSubscriber(subscriber) {
+    return this.busData.agents?.[subscriber] || null;
+  }
+
+  /**
+   * 更新订阅者的最后活动时间
+   */
+  updateLastSeen(subscriber) {
+    if (this.busData.agents && this.busData.agents[subscriber]) {
+      this.busData.agents[subscriber].last_seen = getTimestamp();
+    }
+  }
+
+  /**
+   * 清理不活跃的订阅者
+   */
+  cleanupInactive() {
+    if (!this.busData.agents) return;
+
+    for (const [id, meta] of Object.entries(this.busData.agents)) {
+      if (meta.status === "active" && !isMetaActive(meta)) {
+        meta.status = "inactive";
+        meta.last_seen = getTimestamp();
+      }
+    }
+  }
+}
+
+module.exports = SubscriberManager;