u-foo 1.0.3 → 1.1.9

package/src/bus/utils.js

@@ -0,0 +1,363 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+/**
+ * 获取当前 UTC 时间戳（ISO 8601 格式）
+ */
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+/**
+ * 获取当前日期（YYYY-MM-DD 格式）
+ */
+function getDate() {
+  return new Date().toISOString().split("T")[0];
+}
+
+/**
+ * 生成实例 ID（8 位十六进制）
+ */
+function generateInstanceId() {
+  return crypto.randomBytes(4).toString("hex");
+}
+
+/**
+ * 将订阅者 ID 转换为安全的文件名
+ * 例如：claude-code:abc123 -> claude-code_abc123
+ */
+function subscriberToSafeName(subscriber) {
+  return subscriber.replace(/:/g, "_");
+}
+
+/**
+ * 将安全文件名转换回订阅者 ID
+ * 例如：claude-code_abc123 -> claude-code:abc123
+ */
+function safeNameToSubscriber(safeName) {
+  // 只替换第一个下划线为冒号
+  const match = safeName.match(/^([^_]+)_(.+)$/);
+  if (match) {
+    return `${match[1]}:${match[2]}`;
+  }
+  return safeName;
+}
+
+/**
+ * 检查进程是否存活
+ */
+function isPidAlive(pid) {
+  if (!pid || pid === 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // Sandbox can return EPERM for other processes even if they are alive.
+    if (err && err.code === "EPERM") return true;
+    return false;
+  }
+}
+
+/**
+ * 获取进程命令名（用于校验 PID 是否仍属于 agent 进程）
+ */
+function getPidCommand(pid) {
+  if (!pid || pid === 0) return "";
+  try {
+    const res = spawnSync("ps", ["-p", String(pid), "-o", "comm="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (res.status === 0) {
+      return (res.stdout || "").trim();
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+/**
+ * 判断 PID 是否为可识别的 agent 进程
+ */
+function isAgentPidAlive(pid) {
+  if (!isPidAlive(pid)) return false;
+  const cmd = getPidCommand(pid);
+  if (!cmd) return true;
+  return /(claude|codex|node|pi-mono|ufoo|ucode)/i.test(cmd);
+}
+
+/**
+ * 检查 tty 路径是否有效（用于注入）
+ */
+function isValidTty(ttyPath) {
+  if (!ttyPath) return false;
+  if (ttyPath === "/dev/tty") return false;
+  if (!ttyPath.startsWith("/dev/")) return false;
+  return true;
+}
+
+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 getCurrentTty() {
+  try {
+    const res = spawnSync("tty", {
+      stdio: [0, "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    if (res && res.status === 0) {
+      const tty = normalizeTty(res.stdout || "");
+      return isValidTty(tty) ? tty : "";
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+function parsePsLines(raw) {
+  const lines = String(raw || "").trim().split(/\r?\n/).filter(Boolean);
+  return lines.map((line) => {
+    const match = line.trim().match(/^(\d+)\s+(.+)$/);
+    if (!match) return null;
+    return { pid: parseInt(match[1], 10), comm: match[2].trim() };
+  }).filter(Boolean);
+}
+
+function getTtyProcessInfo(ttyPath) {
+  if (!isValidTty(ttyPath)) {
+    return { alive: false, idle: false, hasAgent: false, shellPid: 0, processes: [] };
+  }
+  const ttyName = ttyPath.replace("/dev/", "");
+  try {
+    const res = spawnSync("ps", ["-t", ttyName, "-o", "pid=,comm="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (res.status !== 0) {
+      return { alive: false, idle: false, hasAgent: false, shellPid: 0, processes: [] };
+    }
+    const processes = parsePsLines(res.stdout || "");
+    if (processes.length === 0) {
+      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|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));
+    return { alive: true, idle, hasAgent, shellPid: shell ? shell.pid : 0, processes };
+  } catch {
+    return { alive: false, idle: false, hasAgent: false, shellPid: 0, processes: [] };
+  }
+}
+
+/**
+ * 确保目录存在
+ */
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * 原子性地追加内容到文件
+ * @param {string} filePath - 文件路径
+ * @param {string} content - 要追加的内容
+ */
+function appendFileAtomic(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.appendFileSync(filePath, content, { encoding: "utf8", flag: "a" });
+}
+
+/**
+ * 原子性地写入文件
+ */
+function writeFileAtomic(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  // 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);
+}
+
+/**
+ * 读取 JSON 文件
+ */
+function readJSON(filePath, defaultValue = null) {
+  try {
+    if (!fs.existsSync(filePath)) return defaultValue;
+    const content = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(content);
+  } catch (err) {
+    return defaultValue;
+  }
+}
+
+/**
+ * 写入 JSON 文件（格式化）
+ */
+function writeJSON(filePath, data) {
+  const content = JSON.stringify(data, null, 2);
+  writeFileAtomic(filePath, content);
+}
+
+/**
+ * 读取 JSONL 文件的所有行
+ */
+function readJSONL(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  const content = fs.readFileSync(filePath, "utf8").trim();
+  if (!content) return [];
+  return content.split("\n").map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+
+/**
+ * 追加一行到 JSONL 文件
+ */
+function appendJSONL(filePath, data) {
+  const line = JSON.stringify(data);
+  appendFileAtomic(filePath, `${line}\n`);
+}
+
+/**
+ * 读取文件的最后一行
+ */
+function readLastLine(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, "utf8").trim();
+  if (!content) return null;
+  const lines = content.split("\n");
+  return lines[lines.length - 1];
+}
+
+/**
+ * 清空文件内容
+ */
+function truncateFile(filePath) {
+  if (fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, "", "utf8");
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * 日志输出（带颜色）
+ */
+const colors = {
+  reset: "\x1b[0m",
+  red: "\x1b[0;31m",
+  green: "\x1b[0;32m",
+  yellow: "\x1b[0;33m",
+  blue: "\x1b[0;34m",
+  cyan: "\x1b[0;36m",
+};
+
+function logInfo(message) {
+  console.log(`${colors.blue}[bus]${colors.reset} ${message}`);
+}
+
+function logOk(message) {
+  console.log(`${colors.green}[bus]${colors.reset} ${message}`);
+}
+
+function logWarn(message) {
+  console.log(`${colors.yellow}[bus]${colors.reset} ${message}`);
+}
+
+function logError(message) {
+  console.error(`${colors.red}[bus]${colors.reset} ${message}`);
+}
+
+/**
+ * 统一的 agent 存活检测逻辑
+ * buildStatus() 和 getActiveSubscribers() 共用此函数
+ *
+ * 检测顺序：
+ * 1. status=inactive → 离线
+ * 2. PID 存活 → 在线
+ * 3. TTY 上有 agent 进程 → 在线
+ * 4. PID 存在但 dead（且 TTY 也没有 agent）→ 离线
+ * 5. 无 PID 时，last_seen 在 30s 内 → 在线（心跳兜底）
+ * 6. 其余 → 离线
+ */
+const HEARTBEAT_TIMEOUT_MS = 30 * 1000; // notifier 每 2s 心跳，15 次余量
+
+function isMetaActive(meta) {
+  if (!meta) return false;
+
+  // 1. 显式标记为 inactive
+  if (meta.status === "inactive") return false;
+
+  // 2. PID 存活（最可靠）
+  if (meta.pid && isAgentPidAlive(meta.pid)) return true;
+
+  // 3. TTY 上有 agent 进程
+  if (meta.tty) {
+    const ttyInfo = getTtyProcessInfo(meta.tty);
+    if (ttyInfo && ttyInfo.hasAgent) return true;
+  }
+
+  // 4. PID 存在但 dead（且 TTY 也没有 agent）→ 离线
+  if (meta.pid) return false;
+
+  // 5. 无 PID，用 last_seen 心跳超时兜底
+  if (meta.status === "active" && meta.last_seen) {
+    const age = Date.now() - new Date(meta.last_seen).getTime();
+    return age <= HEARTBEAT_TIMEOUT_MS;
+  }
+
+  // 6. status=active 但无任何信息
+  if (meta.status === "active") return true;
+
+  return false;
+}
+
+module.exports = {
+  getTimestamp,
+  getDate,
+  generateInstanceId,
+  subscriberToSafeName,
+  safeNameToSubscriber,
+  isPidAlive,
+  getPidCommand,
+  isAgentPidAlive,
+  isMetaActive,
+  HEARTBEAT_TIMEOUT_MS,
+  isValidTty,
+  getCurrentTty,
+  getTtyProcessInfo,
+  ensureDir,
+  appendFileAtomic,
+  writeFileAtomic,
+  readJSON,
+  writeJSON,
+  readJSONL,
+  appendJSONL,
+  readLastLine,
+  truncateFile,
+  sleep,
+  logInfo,
+  logOk,
+  logWarn,
+  logError,
+  colors,
+};

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,
+};