u-foo 1.0.3 → 1.1.9

package/src/bus/message.js

@@ -0,0 +1,430 @@
+const fs = require("fs");
+const path = require("path");
+const {
+  getTimestamp,
+  getDate,
+  readJSONL,
+  appendJSONL,
+  readLastLine,
+  isPidAlive,
+} = require("./utils");
+const NicknameManager = require("./nickname");
+
+const SEQ_LOCK_TIMEOUT_MS = 5000;
+const SEQ_LOCK_POLL_MS = 25;
+const SEQ_LOCK_STALE_MS = 30000;
+
+function normalizeAgentTypeAlias(value = "") {
+  const text = String(value || "").trim().toLowerCase();
+  if (!text) return "";
+  if (text === "codex") return "codex";
+  if (text === "claude" || text === "claude-code") return "claude-code";
+  if (text === "ufoo" || text === "ucode" || text === "ufoo-code") return "ufoo-code";
+  return text;
+}
+
+/**
+ * 消息管理器
+ */
+class MessageManager {
+  constructor(busDir, busData, queueManager) {
+    this.busDir = busDir;
+    this.busData = busData;
+    this.queueManager = queueManager;
+    this.eventsDir = path.join(busDir, "events");
+    this.seqFile = path.join(busDir, "seq.counter");
+    this.seqLockFile = path.join(busDir, "seq.counter.lock");
+  }
+
+  /**
+   * 从 events 日志中恢复最大序号（仅用于 counter 缺失时）
+   */
+  readMaxSeqFromEvents() {
+    let maxSeq = 0;
+    if (!fs.existsSync(this.eventsDir)) {
+      return maxSeq;
+    }
+
+    const files = fs.readdirSync(this.eventsDir)
+      .filter((f) => f.endsWith(".jsonl"))
+      .sort()
+      .reverse(); // 从最新的文件开始读
+
+    for (const file of files) {
+      const filePath = path.join(this.eventsDir, file);
+      const lastLine = readLastLine(filePath);
+
+      if (lastLine) {
+        try {
+          const event = JSON.parse(lastLine);
+          if (event.seq && event.seq > maxSeq) {
+            maxSeq = event.seq;
+            break; // 找到最大 seq 后立即退出
+          }
+        } catch {
+          // 忽略解析错误
+        }
+      }
+    }
+
+    return maxSeq;
+  }
+
+  readSeqCounter() {
+    try {
+      const raw = fs.readFileSync(this.seqFile, "utf8").trim();
+      const parsed = parseInt(raw, 10);
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+      }
+    } catch {
+      // ignore
+    }
+    return 0;
+  }
+
+  writeSeqCounter(seq) {
+    fs.mkdirSync(path.dirname(this.seqFile), { recursive: true });
+    fs.writeFileSync(this.seqFile, `${seq}\n`, "utf8");
+  }
+
+  cleanupStaleSeqLock() {
+    if (!fs.existsSync(this.seqLockFile)) return;
+    let shouldRemove = false;
+
+    try {
+      const raw = fs.readFileSync(this.seqLockFile, "utf8").trim();
+      const pid = parseInt(raw, 10);
+      if (!Number.isFinite(pid) || pid <= 0) {
+        shouldRemove = true;
+      } else if (!isPidAlive(pid)) {
+        shouldRemove = true;
+      }
+    } catch {
+      shouldRemove = true;
+    }
+
+    if (!shouldRemove) {
+      try {
+        const stat = fs.statSync(this.seqLockFile);
+        if (Date.now() - stat.mtimeMs > SEQ_LOCK_STALE_MS) {
+          shouldRemove = true;
+        }
+      } catch {
+        shouldRemove = true;
+      }
+    }
+
+    if (shouldRemove) {
+      try {
+        fs.unlinkSync(this.seqLockFile);
+      } catch {
+        // ignore stale lock cleanup errors
+      }
+    }
+  }
+
+  async acquireSeqLock() {
+    const deadline = Date.now() + SEQ_LOCK_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      try {
+        const fd = fs.openSync(this.seqLockFile, "wx");
+        fs.writeSync(fd, `${process.pid}\n`);
+        return fd;
+      } catch (err) {
+        if (err && err.code === "EEXIST") {
+          this.cleanupStaleSeqLock();
+          // eslint-disable-next-line no-await-in-loop
+          await new Promise((resolve) => setTimeout(resolve, SEQ_LOCK_POLL_MS));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw new Error("Failed to acquire sequence lock");
+  }
+
+  releaseSeqLock(lockFd) {
+    try {
+      if (typeof lockFd === "number") {
+        fs.closeSync(lockFd);
+      }
+    } catch {
+      // ignore
+    }
+    try {
+      if (fs.existsSync(this.seqLockFile)) {
+        fs.unlinkSync(this.seqLockFile);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  /**
+   * 获取下一个全局序号（文件锁保证跨进程原子递增）
+   */
+  async getNextSeq() {
+    const lockFd = await this.acquireSeqLock();
+    try {
+      let current = this.readSeqCounter();
+      if (current === 0) {
+        current = this.readMaxSeqFromEvents();
+      }
+      const next = current + 1;
+      this.writeSeqCounter(next);
+      return next;
+    } finally {
+      this.releaseSeqLock(lockFd);
+    }
+  }
+
+  /**
+   * 解析目标（支持昵称、代理类型、订阅者 ID）
+   */
+  resolveTarget(target) {
+    const nicknameManager = new NicknameManager(this.busData);
+    const normalizedTarget = normalizeAgentTypeAlias(target);
+
+    // 0. Exact subscriber ID match (allows ids without ":" e.g. "ufoo-agent")
+    const subscribers = this.busData.agents || {};
+    if (target && typeof target === "string" && subscribers[target]) {
+      return [target];
+    }
+
+    // 1. 尝试作为订阅者 ID
+    if (target.includes(":")) {
+      return [target];
+    }
+
+    // 2. 尝试作为昵称
+    const byNickname = nicknameManager.resolveNickname(target);
+    if (byNickname) {
+      return [byNickname];
+    }
+
+    // 3. 尝试作为代理类型（匹配所有该类型的订阅者）
+    const isActive = (meta) => !meta || meta.status === "active";
+
+    const byType = Object.entries(subscribers)
+      .filter(([, meta]) => normalizeAgentTypeAlias(meta.agent_type) === normalizedTarget && isActive(meta))
+      .map(([id]) => id);
+
+    if (byType.length > 0) {
+      return byType;
+    }
+
+    // 4. 通配符（所有活跃订阅者）
+    if (target === "*") {
+      return Object.entries(subscribers)
+        .filter(([, meta]) => isActive(meta))
+        .map(([id]) => id);
+    }
+
+    // 未找到目标
+    return [];
+  }
+
+  /**
+   * 检查目标是否匹配订阅者
+   */
+  targetMatches(target, subscriber) {
+    const normalizedTarget = normalizeAgentTypeAlias(target);
+    // 精确匹配
+    if (target === subscriber) return true;
+
+    // 代理类型匹配
+    const meta = this.busData.agents?.[subscriber];
+    if (meta && normalizedTarget === normalizeAgentTypeAlias(meta.agent_type)) return true;
+
+    // 昵称匹配
+    if (meta && target === meta.nickname) return true;
+
+    // 通配符
+    if (target === "*") return true;
+
+    return false;
+  }
+
+  /**
+   * 发送消息
+   */
+  async send(target, message, publisher = "unknown") {
+    const seq = await this.getNextSeq();
+    const timestamp = getTimestamp();
+    const date = getDate();
+
+    // 解析目标
+    const targets = this.resolveTarget(target);
+    if (targets.length === 0) {
+      throw new Error(`Target "${target}" not found`);
+    }
+
+    // 构建事件
+    const event = {
+      seq,
+      timestamp,
+      type: "message/targeted",
+      event: "message",
+      publisher,
+      target,
+      data: { message },
+    };
+
+    // 写入事件日志
+    const eventFile = path.join(this.eventsDir, `${date}.jsonl`);
+    appendJSONL(eventFile, event);
+
+    // 为每个目标订阅者添加到待处理队列
+    for (const targetSubscriber of targets) {
+      // 检查订阅者的 offset，如果已经消费过这个 seq，不再添加
+      const offset = await this.queueManager.getOffset(targetSubscriber);
+      if (seq > offset) {
+        await this.queueManager.appendPending(targetSubscriber, event);
+      }
+    }
+
+    return { seq, targets };
+  }
+
+  /**
+   * 广播消息
+   */
+  async broadcast(message, publisher = "unknown") {
+    return this.send("*", message, publisher);
+  }
+
+  /**
+   * 发送系统事件（非消息）
+   */
+  async emit(target, eventName, data = {}, publisher = "unknown", type = "status/agent") {
+    const seq = await this.getNextSeq();
+    const timestamp = getTimestamp();
+    const date = getDate();
+
+    // 解析目标
+    const targets = this.resolveTarget(target);
+    if (targets.length === 0) {
+      throw new Error(`Target "${target}" not found`);
+    }
+
+    const event = {
+      seq,
+      timestamp,
+      type,
+      event: eventName,
+      publisher,
+      target,
+      data,
+    };
+
+    const eventFile = path.join(this.eventsDir, `${date}.jsonl`);
+    appendJSONL(eventFile, event);
+
+    for (const targetSubscriber of targets) {
+      const offset = await this.queueManager.getOffset(targetSubscriber);
+      if (seq > offset) {
+        await this.queueManager.appendPending(targetSubscriber, event);
+      }
+    }
+
+    return { seq, targets };
+  }
+
+  /**
+   * 检查待处理消息
+   */
+  async check(subscriber) {
+    const pending = await this.queueManager.readPending(subscriber);
+    return pending;
+  }
+
+  /**
+   * 确认消息（清空待处理队列）
+   */
+  async ack(subscriber) {
+    const pending = await this.queueManager.readPending(subscriber);
+    const count = pending.length;
+
+    if (count > 0) {
+      await this.queueManager.clearPending(subscriber);
+    }
+
+    return count;
+  }
+
+  /**
+   * 消费事件（从 offset 开始）
+   */
+  async consume(subscriber, fromBeginning = false) {
+    let offset = fromBeginning ? 0 : await this.queueManager.getOffset(subscriber);
+    const consumed = [];
+
+    // 读取所有事件文件
+    if (!fs.existsSync(this.eventsDir)) {
+      return { consumed, newOffset: offset };
+    }
+
+    const files = fs.readdirSync(this.eventsDir)
+      .filter((f) => f.endsWith(".jsonl"))
+      .sort(); // 按日期排序
+
+    for (const file of files) {
+      const filePath = path.join(this.eventsDir, file);
+      const events = readJSONL(filePath);
+
+      for (const event of events) {
+        if (event.seq <= offset) continue;
+
+        // 检查是否针对此订阅者
+        if (
+          this.targetMatches(event.target, subscriber) ||
+          event.target === "*"
+        ) {
+          consumed.push(event);
+          offset = Math.max(offset, event.seq);
+        }
+      }
+    }
+
+    // 更新 offset
+    if (consumed.length > 0) {
+      await this.queueManager.setOffset(subscriber, offset);
+    }
+
+    return { consumed, newOffset: offset };
+  }
+
+  /**
+   * 智能路由解析（找出所有匹配的候选者）
+   */
+  async resolve(myId, targetType) {
+    const normalizedTargetType = normalizeAgentTypeAlias(targetType);
+    const subscribers = this.busData.agents || {};
+    const candidates = Object.entries(subscribers)
+      .filter(([id, meta]) => {
+        if (id === myId) return false; // 排除自己
+        if (meta.status !== "active") return false;
+
+        if (normalizeAgentTypeAlias(meta.agent_type) === normalizedTargetType) return true;
+
+        return false;
+      })
+      .map(([id, meta]) => ({
+        id,
+        nickname: meta.nickname,
+        agent_type: meta.agent_type,
+        last_seen: meta.last_seen,
+      }));
+
+    // 如果只有一个候选者，直接返回
+    if (candidates.length === 1) {
+      return { single: candidates[0].id, candidates };
+    }
+
+    // 多个候选者，返回列表供调用者选择
+    return { single: null, candidates };
+  }
+}
+
+module.exports = MessageManager;

package/src/bus/nickname.js

@@ -0,0 +1,88 @@
+/**
+ * 昵称管理和解析
+ */
+class NicknameManager {
+  constructor(busData) {
+    this.busData = busData;
+  }
+
+  /**
+   * 解析昵称到订阅者 ID
+   * @param {string} nickname - 昵称
+   * @returns {string|null} - 订阅者 ID 或 null
+   */
+  resolveNickname(nickname) {
+    const subscribers = this.busData.agents || {};
+    for (const [id, meta] of Object.entries(subscribers)) {
+      if (meta.nickname === nickname) {
+        return id;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 检查昵称是否已存在
+   * @param {string} nickname - 昵称
+   * @param {string} excludeSubscriber - 排除的订阅者 ID（用于重命名时）
+   * @returns {boolean} - 是否已存在
+   */
+  nicknameExists(nickname, excludeSubscriber = null) {
+    const subscribers = this.busData.agents || {};
+    for (const [id, meta] of Object.entries(subscribers)) {
+      if (id !== excludeSubscriber && meta.nickname === nickname) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * 生成自动昵称
+   * @param {string} agentType - 代理类型（codex, claude-code）
+   * @returns {string} - 自动生成的昵称（如 codex-1, claude-1）
+   */
+  generateAutoNickname(agentType) {
+    const subscribers = this.busData.agents || {};
+    const prefix = agentType === "claude-code" ? "claude"
+                 : agentType === "ufoo-code" ? "ucode"
+                 : agentType;
+
+    // 找出所有相同前缀的昵称
+    const existing = Object.values(subscribers)
+      .map((meta) => meta.nickname)
+      .filter((nick) => nick && nick.startsWith(`${prefix}-`))
+      .map((nick) => {
+        const match = nick.match(/^[^-]+-(\d+)$/);
+        return match ? parseInt(match[1], 10) : 0;
+      })
+      .filter((n) => !isNaN(n));
+
+    // 找到下一个可用的编号
+    const maxNumber = existing.length > 0 ? Math.max(...existing) : 0;
+    return `${prefix}-${maxNumber + 1}`;
+  }
+
+  /**
+   * 获取订阅者的昵称
+   */
+  getNickname(subscriber) {
+    const meta = this.busData.agents?.[subscriber];
+    return meta?.nickname || null;
+  }
+
+  /**
+   * 设置订阅者的昵称
+   */
+  setNickname(subscriber, nickname) {
+    if (!this.busData.agents) {
+      this.busData.agents = {};
+    }
+    if (!this.busData.agents[subscriber]) {
+      this.busData.agents[subscriber] = {};
+    }
+    this.busData.agents[subscriber].nickname = nickname;
+  }
+}
+
+module.exports = NicknameManager;

package/src/bus/queue.js

@@ -0,0 +1,136 @@
+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");
+    this.offsetsDir = path.join(busDir, "offsets");
+  }
+
+  /**
+   * 获取订阅者的队列目录
+   */
+  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.offsetsDir, `${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);
+    if (event && event.event === "wake") {
+      const wakePath = path.join(this.getQueueDir(subscriber), "wake");
+      fs.writeFileSync(wakePath, String(event.seq || Date.now()), "utf8");
+    }
+  }
+
+  /**
+   * 清空待处理消息
+   */
+  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 };