u-foo 1.0.3 → 1.0.6

package/src/bus/inject.js

@@ -0,0 +1,285 @@
+const { spawn } = require("child_process");
+const fs = require("fs");
+const net = require("net");
+const path = require("path");
+const { subscriberToSafeName, isValidTty } = require("./utils");
+
+const SHOULD_LOG_INJECT = process.env.UFOO_INJECT_DEBUG === "1";
+const logInject = (message) => {
+  if (SHOULD_LOG_INJECT) {
+    console.log(message);
+  }
+};
+
+/**
+ * 命令注入器 - 将命令注入到终端
+ *
+ * 支持的方式：
+ * 1. PTY socket（直接写入，无需macOS权限）
+ * 2. tmux send-keys（无需权限）
+ */
+class Injector {
+  constructor(busDir, agentsFile) {
+    this.busDir = busDir;
+    this.agentsFile = agentsFile;
+  }
+
+  /**
+   * 获取订阅者的 tty 文件路径
+   */
+  getTtyPath(subscriber) {
+    const safeName = subscriberToSafeName(subscriber);
+    return path.join(this.busDir, "queues", safeName, "tty");
+  }
+
+  /**
+   * 获取订阅者的 tmux pane ID（从 all-agents.json）
+   */
+  getTmuxPane(subscriber) {
+    const agentsFile = this.agentsFile;
+    if (!agentsFile || !fs.existsSync(agentsFile)) return null;
+
+    try {
+      const busData = JSON.parse(fs.readFileSync(agentsFile, "utf8"));
+      return busData.agents?.[subscriber]?.tmux_pane || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 读取 tty 设备路径
+   */
+  readTty(subscriber) {
+    const ttyPath = this.getTtyPath(subscriber);
+    if (!fs.existsSync(ttyPath)) {
+      return null;
+    }
+    return fs.readFileSync(ttyPath, "utf8").trim();
+  }
+
+  /**
+   * 检查 tmux pane 是否存在
+   */
+  async checkTmuxPane(paneId) {
+    return new Promise((resolve) => {
+      const proc = spawn("tmux", ["list-panes", "-a", "-F", "#{pane_id}"]);
+      let output = "";
+
+      proc.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          resolve(false);
+          return;
+        }
+        const panes = output.trim().split("\n");
+        resolve(panes.includes(paneId));
+      });
+
+      proc.on("error", () => resolve(false));
+    });
+  }
+
+  /**
+   * 根据 tty 查找 tmux pane
+   */
+  async findTmuxPaneByTty(tty) {
+    return new Promise((resolve) => {
+      const proc = spawn("tmux", ["list-panes", "-a", "-F", "#{pane_id} #{pane_tty}"]);
+      let output = "";
+
+      proc.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          resolve(null);
+          return;
+        }
+        const lines = output.trim().split("\n");
+        for (const line of lines) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length >= 2 && parts[1] === tty) {
+            resolve(parts[0]);
+            return;
+          }
+        }
+        resolve(null);
+      });
+
+      proc.on("error", () => resolve(null));
+    });
+  }
+
+  /**
+   * 使用 tmux send-keys 注入命令
+   */
+  async injectTmux(paneId, command) {
+    return new Promise((resolve, reject) => {
+      // 检查是否需要发送中断信号
+      if (process.env.UFOO_INJECT_INTERRUPT === "1") {
+        spawn("tmux", ["send-keys", "-t", paneId, "C-c"]);
+        setTimeout(() => {
+          this.sendTmuxKeys(paneId, command, resolve, reject);
+        }, 100);
+      } else {
+        this.sendTmuxKeys(paneId, command, resolve, reject);
+      }
+    });
+  }
+
+  /**
+   * 发送 tmux 按键（先发文本，延迟后发 Enter）
+   */
+  sendTmuxKeys(paneId, command, resolve, reject) {
+    const textProc = spawn("tmux", ["send-keys", "-t", paneId, command]);
+    let stderr = "";
+
+    textProc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    textProc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr || "tmux send-keys failed"));
+        return;
+      }
+      // Delay before sending Enter — gives the target app time to process input
+      setTimeout(() => {
+        const enterProc = spawn("tmux", ["send-keys", "-t", paneId, "Enter"]);
+        enterProc.on("close", (enterCode) => {
+          if (enterCode === 0) resolve();
+          else reject(new Error("tmux send-keys Enter failed"));
+        });
+        enterProc.on("error", reject);
+      }, 150);
+    });
+
+    textProc.on("error", reject);
+  }
+
+  /**
+   * 获取订阅者的 inject socket 路径
+   */
+  getInjectSockPath(subscriber) {
+    const safeName = subscriberToSafeName(subscriber);
+    return path.join(this.busDir, "queues", safeName, "inject.sock");
+  }
+
+  /**
+   * 使用 PTY socket 直接注入命令（无需macOS权限）
+   */
+  async injectPty(subscriber, command) {
+    const sockPath = this.getInjectSockPath(subscriber);
+
+    if (!fs.existsSync(sockPath)) {
+      throw new Error(`Inject socket not found: ${sockPath}`);
+    }
+
+    return new Promise((resolve, reject) => {
+      const client = net.createConnection(sockPath, () => {
+        // 发送inject请求
+        client.write(JSON.stringify({ type: "inject", command }) + "\n");
+      });
+
+      let buffer = "";
+      const timeout = setTimeout(() => {
+        client.destroy();
+        reject(new Error("PTY inject timeout"));
+      }, 5000);
+
+      client.on("data", (data) => {
+        buffer += data.toString("utf8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          clearTimeout(timeout);
+          try {
+            const res = JSON.parse(line);
+            client.end();
+            if (res.ok) {
+              resolve();
+            } else {
+              reject(new Error(res.error || "PTY inject failed"));
+            }
+          } catch (err) {
+            client.end();
+            reject(err);
+          }
+          return;
+        }
+      });
+
+      client.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+
+      client.on("close", () => {
+        clearTimeout(timeout);
+      });
+    });
+  }
+
+  /**
+   * 注入命令到订阅者的终端
+   *
+   * 优先级：
+   * 1. PTY socket（直接写入，无需macOS权限）
+   * 2. tmux send-keys（无需权限）
+   */
+  async inject(subscriber, commandOverride = "") {
+    // 确定注入命令（codex 用 "ubus"，claude-code 用 "/ubus"）
+    const command = commandOverride
+      ? String(commandOverride)
+      : (subscriber.startsWith("codex:") ? "ubus" : "/ubus");
+
+    // 1. 优先尝试 PTY socket（无需任何macOS权限）
+    const injectSockPath = this.getInjectSockPath(subscriber);
+    if (fs.existsSync(injectSockPath)) {
+      try {
+        logInject(`[inject] Using PTY socket: ${injectSockPath}`);
+        await this.injectPty(subscriber, command);
+        logInject("[inject] PTY inject success");
+        return;
+      } catch (err) {
+        logInject(`[inject] PTY socket failed: ${err.message}, trying tmux`);
+      }
+    }
+
+    // 读取 tty（tmux 需要）
+    const tty = this.readTty(subscriber);
+
+    // 2. 尝试 tmux（无需权限）
+    const tmuxPane = this.getTmuxPane(subscriber);
+    if (tmuxPane) {
+      const paneExists = await this.checkTmuxPane(tmuxPane);
+      if (paneExists) {
+        logInject(`[inject] Using tmux send-keys for pane: ${tmuxPane}`);
+        await this.injectTmux(tmuxPane, command);
+        return;
+      }
+    }
+
+    // 尝试通过 tty 查找 tmux pane
+    if (tty && isValidTty(tty)) {
+      const fallbackPane = await this.findTmuxPaneByTty(tty);
+      if (fallbackPane) {
+        logInject(`[inject] Using tmux send-keys for pane: ${fallbackPane}`);
+        await this.injectTmux(fallbackPane, command);
+        return;
+      }
+    }
+
+    // 没有可用的注入方式
+    throw new Error(`No inject method available for ${subscriber}. PTY socket or tmux required.`);
+  }
+}
+
+module.exports = Injector;

package/src/bus/message.js

@@ -0,0 +1,302 @@
+const fs = require("fs");
+const path = require("path");
+const {
+  getTimestamp,
+  getDate,
+  readJSONL,
+  appendJSONL,
+  readLastLine,
+  readJSON,
+  isMetaActive,
+} = require("./utils");
+const NicknameManager = require("./nickname");
+
+/**
+ * 消息管理器
+ */
+class MessageManager {
+  constructor(busDir, busData, queueManager) {
+    this.busDir = busDir;
+    this.busData = busData;
+    this.queueManager = queueManager;
+    this.eventsDir = path.join(busDir, "events");
+  }
+
+  /**
+   * 获取下一个全局序号
+   */
+  async getNextSeq() {
+    // 读取所有 events/*.jsonl 文件，找到最大的 seq
+    let maxSeq = 0;
+
+    if (!fs.existsSync(this.eventsDir)) {
+      return 1;
+    }
+
+    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 + 1;
+  }
+
+  /**
+   * 解析目标（支持昵称、代理类型、订阅者 ID）
+   */
+  resolveTarget(target) {
+    const nicknameManager = new NicknameManager(this.busData);
+
+    // 1. 尝试作为订阅者 ID
+    if (target.includes(":")) {
+      return [target];
+    }
+
+    // 2. 尝试作为昵称
+    const byNickname = nicknameManager.resolveNickname(target);
+    if (byNickname) {
+      return [byNickname];
+    }
+
+    // 3. 尝试作为代理类型（匹配所有该类型的活跃订阅者）
+    const subscribers = this.busData.agents || {};
+    const byType = Object.entries(subscribers)
+      .filter(([, meta]) => meta.agent_type === target && isMetaActive(meta))
+      .map(([id]) => id);
+
+    if (byType.length > 0) {
+      return byType;
+    }
+
+    // 4. 通配符（所有活跃订阅者）
+    if (target === "*") {
+      return Object.entries(subscribers)
+        .filter(([, meta]) => isMetaActive(meta))
+        .map(([id]) => id);
+    }
+
+    // 未找到目标
+    return [];
+  }
+
+  /**
+   * 检查目标是否匹配订阅者
+   */
+  targetMatches(target, subscriber) {
+    // 精确匹配
+    if (target === subscriber) return true;
+
+    // 代理类型匹配
+    const meta = this.busData.agents?.[subscriber];
+    if (meta && target === 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 subscribers = this.busData.agents || {};
+    const candidates = Object.entries(subscribers)
+      .filter(([id, meta]) => {
+        if (id === myId) return false; // 排除自己
+        if (meta.status !== "active") return false;
+
+        // 匹配代理类型
+        if (targetType === "codex" && meta.agent_type === "codex") return true;
+        if (targetType === "claude" && meta.agent_type === "claude-code") return true;
+        if (targetType === meta.agent_type) 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,86 @@
+/**
+ * 昵称管理和解析
+ */
+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;
+
+    // 找出所有相同前缀的昵称
+    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;