u-foo 1.0.3 → 1.0.6

package/src/bus/queue.js

@@ -0,0 +1,131 @@
+const fs = require("fs");
+const path = require("path");
+const {
+  subscriberToSafeName,
+  ensureDir,
+  readJSONL,
+  appendJSONL,
+  truncateFile,
+} = require("./utils");
+
+/**
+ * 队列管理器
+ */
+class QueueManager {
+  constructor(busDir) {
+    this.busDir = busDir;
+    this.queuesDir = path.join(busDir, "queues");
+  }
+
+  /**
+   * 获取订阅者的队列目录
+   */
+  getQueueDir(subscriber) {
+    const safeName = subscriberToSafeName(subscriber);
+    return path.join(this.queuesDir, safeName);
+  }
+
+  /**
+   * 确保队列目录存在
+   */
+  ensureQueueDir(subscriber) {
+    const queueDir = this.getQueueDir(subscriber);
+    ensureDir(queueDir);
+    return queueDir;
+  }
+
+  /**
+   * 获取 offset 文件路径
+   */
+  getOffsetPath(subscriber) {
+    return path.join(this.queuesDir, `${subscriberToSafeName(subscriber)}.offset`);
+  }
+
+  /**
+   * 获取 pending 文件路径
+   */
+  getPendingPath(subscriber) {
+    return path.join(this.getQueueDir(subscriber), "pending.jsonl");
+  }
+
+  /**
+   * 获取 tty 文件路径
+   */
+  getTtyPath(subscriber) {
+    return path.join(this.getQueueDir(subscriber), "tty");
+  }
+
+  /**
+   * 读取 offset
+   */
+  async getOffset(subscriber) {
+    const offsetPath = this.getOffsetPath(subscriber);
+    if (!fs.existsSync(offsetPath)) {
+      return 0;
+    }
+    const content = fs.readFileSync(offsetPath, "utf8").trim();
+    return parseInt(content, 10) || 0;
+  }
+
+  /**
+   * 设置 offset
+   */
+  async setOffset(subscriber, seq) {
+    const offsetPath = this.getOffsetPath(subscriber);
+    ensureDir(path.dirname(offsetPath));
+    fs.writeFileSync(offsetPath, `${seq}\n`, "utf8");
+  }
+
+  /**
+   * 读取待处理消息
+   */
+  async readPending(subscriber) {
+    const pendingPath = this.getPendingPath(subscriber);
+    return readJSONL(pendingPath);
+  }
+
+  /**
+   * 追加待处理消息
+   */
+  async appendPending(subscriber, event) {
+    this.ensureQueueDir(subscriber);
+    const pendingPath = this.getPendingPath(subscriber);
+    appendJSONL(pendingPath, event);
+  }
+
+  /**
+   * 清空待处理消息
+   */
+  async clearPending(subscriber) {
+    const pendingPath = this.getPendingPath(subscriber);
+    truncateFile(pendingPath);
+  }
+
+  /**
+   * 检查是否有待处理消息
+   */
+  async hasPending(subscriber) {
+    const pending = await this.readPending(subscriber);
+    return pending.length > 0;
+  }
+
+  /**
+   * 保存 tty 设备路径
+   */
+  async saveTty(subscriber, tty) {
+    this.ensureQueueDir(subscriber);
+    const ttyPath = this.getTtyPath(subscriber);
+    fs.writeFileSync(ttyPath, tty, "utf8");
+  }
+
+  /**
+   * 读取 tty 设备路径
+   */
+  async readTty(subscriber) {
+    const ttyPath = this.getTtyPath(subscriber);
+    if (!fs.existsSync(ttyPath)) return null;
+    return fs.readFileSync(ttyPath, "utf8").trim();
+  }
+}
+
+module.exports = QueueManager;

package/src/bus/shake.js

@@ -0,0 +1,26 @@
+/**
+ * Terminal notification - sends visual alert to a terminal by TTY path.
+ *
+ * Supports:
+ * - iTerm2: OSC 9 notification (native macOS notification)
+ * - All terminals: terminal bell (\x07)
+ */
+
+const fs = require("fs");
+const { isITerm2 } = require("../terminal/detect");
+
+function shakeTerminalByTty(ttyPath, options = {}) {
+  if (!ttyPath) return false;
+
+  try {
+    const fd = fs.openSync(ttyPath, "w");
+    // Terminal bell works universally
+    fs.writeSync(fd, "\x07");
+    fs.closeSync(fd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { shakeTerminalByTty };

package/src/bus/subscriber.js

@@ -0,0 +1,296 @@
+const fs = require("fs");
+const { getTimestamp, isAgentPidAlive, isMetaActive, isValidTty, getTtyProcessInfo } = require("./utils");
+const NicknameManager = require("./nickname");
+const { spawnSync } = require("child_process");
+
+/**
+ * 获取当前终端的 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() {
+  // 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);
+    }
+
+    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,
+    };
+
+    // 如果传入了 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") continue;
+      // PID 已死则直接标记 inactive（不依赖 tty 检测，因为 tty 可能被新 agent 复用）
+      if (meta.pid && !isAgentPidAlive(meta.pid)) {
+        meta.status = "inactive";
+      }
+    }
+  }
+}
+
+module.exports = SubscriberManager;