u-foo 1.0.3 → 1.1.9

package/src/online/tokens.js

@@ -0,0 +1,103 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+
+function defaultTokensPath() {
+  return path.join(os.homedir(), ".ufoo", "online", "tokens.json");
+}
+
+function normalizeTokensData(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { agents: {} };
+  }
+  if (raw.agents && typeof raw.agents === "object") {
+    return { agents: raw.agents };
+  }
+  // Legacy: flat object mapping id -> token
+  return { agents: raw };
+}
+
+function generateToken(bytes = 24) {
+  return crypto.randomBytes(bytes).toString("base64url");
+}
+
+function hashToken(token) {
+  if (!token) return "";
+  return crypto.createHash("sha256").update(String(token)).digest("hex");
+}
+
+function loadTokens(filePath = defaultTokensPath()) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return normalizeTokensData(parsed);
+  } catch {
+    return { agents: {} };
+  }
+}
+
+function saveTokens(filePath = defaultTokensPath(), data = { agents: {} }) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+function setToken(filePath, agentId, token, server = "", extra = {}) {
+  if (!agentId || !token) throw new Error("agentId and token are required");
+  const data = loadTokens(filePath);
+  data.agents[agentId] = {
+    token,
+    token_hash: hashToken(token),
+    server,
+    nickname: extra.nickname || data.agents[agentId]?.nickname || "",
+    updated_at: new Date().toISOString(),
+  };
+  saveTokens(filePath, data);
+  return data.agents[agentId];
+}
+
+function removeToken(filePath, agentId) {
+  const data = loadTokens(filePath);
+  if (data.agents[agentId]) {
+    delete data.agents[agentId];
+    saveTokens(filePath, data);
+  }
+  return data;
+}
+
+function getToken(filePath, agentId) {
+  const data = loadTokens(filePath);
+  return data.agents[agentId] || null;
+}
+
+function getTokenByNickname(filePath, nickname) {
+  const data = loadTokens(filePath);
+  let best = null;
+  for (const entry of Object.values(data.agents)) {
+    if (entry.nickname === nickname) {
+      if (!best || (entry.updated_at || "") > (best.updated_at || "")) {
+        best = entry;
+      }
+    }
+  }
+  return best;
+}
+
+function listTokens(filePath) {
+  const data = loadTokens(filePath);
+  return Object.entries(data.agents).map(([id, entry]) => ({ id, ...entry }));
+}
+
+module.exports = {
+  defaultTokensPath,
+  generateToken,
+  hashToken,
+  loadTokens,
+  saveTokens,
+  setToken,
+  removeToken,
+  getToken,
+  getTokenByNickname,
+  listTokens,
+};

package/src/report/store.js

@@ -0,0 +1,331 @@
+const fs = require("fs");
+const path = require("path");
+const { getUfooPaths } = require("../ufoo/paths");
+
+const REPORT_PHASES = {
+  START: "start",
+  PROGRESS: "progress",
+  DONE: "done",
+  ERROR: "error",
+};
+
+function getReportPaths(projectRoot) {
+  const { agentDir } = getUfooPaths(projectRoot);
+  return {
+    reportsFile: path.join(agentDir, "reports.jsonl"),
+    stateFile: path.join(agentDir, "report-state.json"),
+  };
+}
+
+function ensureReportDir(projectRoot) {
+  const { agentDir } = getUfooPaths(projectRoot);
+  fs.mkdirSync(agentDir, { recursive: true });
+}
+
+function normalizePhase(value = "") {
+  const phase = String(value || "").trim().toLowerCase();
+  if (phase === REPORT_PHASES.START) return REPORT_PHASES.START;
+  if (phase === REPORT_PHASES.PROGRESS) return REPORT_PHASES.PROGRESS;
+  if (phase === REPORT_PHASES.ERROR) return REPORT_PHASES.ERROR;
+  return REPORT_PHASES.DONE;
+}
+
+function normalizeScope(value = "") {
+  const scope = String(value || "").trim().toLowerCase();
+  if (scope === "private") return "private";
+  return "public";
+}
+
+function normalizeReportInput(input = {}, options = {}) {
+  const ts = options.ts || new Date().toISOString();
+  let phase = normalizePhase(input.phase || options.phase);
+  const entryId = String(
+    input.entry_id
+      || input.entryId
+      || options.entry_id
+      || `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
+  ).trim();
+
+  const taskId = String(
+    input.task_id
+      || input.taskId
+      || input.task
+      || options.task_id
+      || options.taskId
+      || `task-${Date.now()}`
+  ).trim();
+  const agentId = String(
+    input.agent_id
+      || input.agentId
+      || options.agent_id
+      || options.agentId
+      || "unknown-agent"
+  ).trim() || "unknown-agent";
+  const message = String(input.message || "").trim();
+  const summary = String(input.summary || "").trim();
+  const error = String(input.error || "").trim();
+  const source = String(input.source || options.source || "cli").trim() || "cli";
+  const scope = normalizeScope(input.scope || options.scope);
+  const controllerId = String(
+    input.controller_id
+      || input.controllerId
+      || options.controller_id
+      || options.controllerId
+      || "ufoo-agent"
+  ).trim() || "ufoo-agent";
+  const ok = input.ok !== false && phase !== REPORT_PHASES.ERROR && !error;
+  if (!ok && phase !== REPORT_PHASES.START && phase !== REPORT_PHASES.PROGRESS) {
+    phase = REPORT_PHASES.ERROR;
+  }
+
+  const meta = input.meta && typeof input.meta === "object" ? input.meta : {};
+
+  return {
+    entry_id: entryId,
+    ts,
+    phase,
+    task_id: taskId,
+    agent_id: agentId,
+    message,
+    summary,
+    error,
+    ok,
+    source,
+    scope,
+    controller_id: controllerId,
+    meta,
+  };
+}
+
+function appendReport(projectRoot, entry) {
+  ensureReportDir(projectRoot);
+  const { reportsFile } = getReportPaths(projectRoot);
+  fs.appendFileSync(reportsFile, `${JSON.stringify(entry)}\n`, "utf8");
+}
+
+function parseJsonLines(file) {
+  if (!fs.existsSync(file)) return [];
+  const raw = fs.readFileSync(file, "utf8");
+  if (!raw.trim()) return [];
+  const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const rows = [];
+  for (const line of lines) {
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+      // ignore malformed lines
+    }
+  }
+  return rows;
+}
+
+function listReports(projectRoot, options = {}) {
+  const { reportsFile } = getReportPaths(projectRoot);
+  const num = Number.isFinite(options.num) && options.num > 0 ? options.num : 20;
+  const filterAgent = String(options.agent || options.agent_id || "").trim();
+  let rows = parseJsonLines(reportsFile);
+  if (filterAgent) {
+    rows = rows.filter((row) => String(row.agent_id || "").trim() === filterAgent);
+  }
+  rows.sort((a, b) => {
+    const left = new Date(a.ts || 0).getTime();
+    const right = new Date(b.ts || 0).getTime();
+    return right - left;
+  });
+  return rows.slice(0, num);
+}
+
+function loadReportState(projectRoot) {
+  const { stateFile } = getReportPaths(projectRoot);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+    if (!parsed || typeof parsed !== "object") return { updated_at: "", agents: {} };
+    if (!parsed.agents || typeof parsed.agents !== "object") parsed.agents = {};
+    if (typeof parsed.updated_at !== "string") parsed.updated_at = "";
+    return parsed;
+  } catch {
+    return { updated_at: "", agents: {} };
+  }
+}
+
+function saveReportState(projectRoot, state) {
+  ensureReportDir(projectRoot);
+  const { stateFile } = getReportPaths(projectRoot);
+  fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+}
+
+function updateReportState(projectRoot, entry) {
+  const state = loadReportState(projectRoot);
+  const current = state.agents[entry.agent_id] && typeof state.agents[entry.agent_id] === "object"
+    ? state.agents[entry.agent_id]
+    : {};
+  const pending = current.pending && typeof current.pending === "object"
+    ? { ...current.pending }
+    : {};
+
+  if (entry.phase === REPORT_PHASES.START || entry.phase === REPORT_PHASES.PROGRESS) {
+    pending[entry.task_id] = entry;
+  } else {
+    delete pending[entry.task_id];
+  }
+
+  state.agents[entry.agent_id] = {
+    ...current,
+    pending,
+    pending_count: Object.keys(pending).length,
+    last: entry,
+    updated_at: entry.ts,
+  };
+  state.updated_at = entry.ts;
+  saveReportState(projectRoot, state);
+  return state;
+}
+
+function isSummaryHiddenEntry(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const scope = normalizeScope(entry.scope);
+  if (scope !== "private") return false;
+  const controllerId = String(entry.controller_id || "").trim();
+  return controllerId === "ufoo-agent";
+}
+
+function controllerToSafeName(controllerId = "") {
+  return String(controllerId || "ufoo-agent")
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+function getControllerInboxFile(projectRoot, controllerId = "ufoo-agent") {
+  const { agentDir } = getUfooPaths(projectRoot);
+  const inboxDir = path.join(agentDir, "private-inbox");
+  const safe = controllerToSafeName(controllerId);
+  return path.join(inboxDir, `${safe}.jsonl`);
+}
+
+function appendControllerInboxEntry(projectRoot, controllerId, entry) {
+  const file = getControllerInboxFile(projectRoot, controllerId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify(entry)}\n`, "utf8");
+}
+
+function listControllerInboxEntries(projectRoot, controllerId = "ufoo-agent", options = {}) {
+  const file = getControllerInboxFile(projectRoot, controllerId);
+  const rows = parseJsonLines(file);
+  const num = Number.isFinite(options.num) && options.num > 0 ? options.num : rows.length;
+  if (rows.length <= num) return rows;
+  return rows.slice(rows.length - num);
+}
+
+function clearControllerInbox(projectRoot, controllerId = "ufoo-agent") {
+  const file = getControllerInboxFile(projectRoot, controllerId);
+  try {
+    if (fs.existsSync(file)) fs.rmSync(file, { force: true });
+  } catch {
+    // ignore clear errors
+  }
+}
+
+function consumeControllerInboxEntries(projectRoot, controllerId = "ufoo-agent", consumed = []) {
+  const file = getControllerInboxFile(projectRoot, controllerId);
+  if (!fs.existsSync(file)) return { removed: 0, remaining: 0 };
+  const list = Array.isArray(consumed) ? consumed : [];
+  if (list.length === 0) {
+    const current = parseJsonLines(file);
+    return { removed: 0, remaining: current.length };
+  }
+
+  const idSet = new Set();
+  const legacySerialized = new Set();
+  for (const item of list) {
+    if (!item) continue;
+    if (typeof item === "string") {
+      idSet.add(item);
+      continue;
+    }
+    if (typeof item === "object") {
+      if (item.entry_id) {
+        idSet.add(String(item.entry_id));
+      } else {
+        legacySerialized.add(JSON.stringify(item));
+      }
+    }
+  }
+
+  const raw = fs.readFileSync(file, "utf8");
+  const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) {
+    return { removed: 0, remaining: 0 };
+  }
+
+  const keptLines = [];
+  let removed = 0;
+  for (const line of lines) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      parsed = null;
+    }
+    if (parsed && typeof parsed === "object") {
+      const id = parsed.entry_id ? String(parsed.entry_id) : "";
+      if (id && idSet.has(id)) {
+        removed += 1;
+        continue;
+      }
+      if (!id && legacySerialized.has(JSON.stringify(parsed))) {
+        removed += 1;
+        continue;
+      }
+    }
+    keptLines.push(line);
+  }
+
+  if (keptLines.length === 0) {
+    fs.rmSync(file, { force: true });
+    return { removed, remaining: 0 };
+  }
+
+  fs.writeFileSync(file, `${keptLines.join("\n")}\n`, "utf8");
+  return { removed, remaining: keptLines.length };
+}
+
+function readReportSummary(projectRoot) {
+  const state = loadReportState(projectRoot);
+  const agents = Object.entries(state.agents || {}).map(([agentId, value]) => {
+    const pending = value && value.pending && typeof value.pending === "object"
+      ? Object.values(value.pending).filter((entry) => !isSummaryHiddenEntry(entry))
+      : [];
+    return {
+      agent_id: agentId,
+      pending_count: pending.length,
+      pending,
+      last: value && value.last ? value.last : null,
+      updated_at: value && value.updated_at ? value.updated_at : "",
+    };
+  });
+  return {
+    updated_at: state.updated_at || "",
+    pending_total: agents.reduce((sum, item) => sum + item.pending_count, 0),
+    agents,
+  };
+}
+
+module.exports = {
+  REPORT_PHASES,
+  getReportPaths,
+  normalizePhase,
+  normalizeScope,
+  normalizeReportInput,
+  appendReport,
+  listReports,
+  loadReportState,
+  saveReportState,
+  updateReportState,
+  readReportSummary,
+  controllerToSafeName,
+  getControllerInboxFile,
+  appendControllerInboxEntry,
+  listControllerInboxEntries,
+  clearControllerInbox,
+  consumeControllerInboxEntries,
+};

package/src/shared/eventContract.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const IPC_REQUEST_TYPES = {
+  STATUS: "status",
+  PROMPT: "prompt",
+  BUS_SEND: "bus_send",
+  CLOSE_AGENT: "close_agent",
+  LAUNCH_AGENT: "launch_agent",
+  RESUME_AGENTS: "resume_agents",
+  LIST_RECOVERABLE_AGENTS: "list_recoverable_agents",
+  REGISTER_AGENT: "register_agent",
+  AGENT_READY: "agent_ready",
+  AGENT_REPORT: "agent_report",
+};
+
+const IPC_RESPONSE_TYPES = {
+  STATUS: "status",
+  RESPONSE: "response",
+  BUS: "bus",
+  ERROR: "error",
+  BUS_SEND_OK: "bus_send_ok",
+  REGISTER_OK: "register_ok",
+};
+
+const BUS_STATUS_PHASES = {
+  START: "start",
+  DONE: "done",
+  ERROR: "error",
+};
+
+module.exports = {
+  IPC_REQUEST_TYPES,
+  IPC_RESPONSE_TYPES,
+  BUS_STATUS_PHASES,
+};

package/src/shared/ptySocketContract.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const PTY_SOCKET_MESSAGE_TYPES = {
+  OUTPUT: "output",
+  REPLAY: "replay",
+  SNAPSHOT: "snapshot",
+  SUBSCRIBED: "subscribed",
+  SUBSCRIBE: "subscribe",
+  RAW: "raw",
+  RESIZE: "resize",
+};
+
+const PTY_SOCKET_SUBSCRIBE_MODES = {
+  FULL: "full",
+  SCREEN: "screen",
+};
+
+module.exports = {
+  PTY_SOCKET_MESSAGE_TYPES,
+  PTY_SOCKET_SUBSCRIBE_MODES,
+};

package/src/skills/index.js

@@ -0,0 +1,159 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * 技能管理
+ */
+class SkillsManager {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+    this.skillRoots = this.findSkillRoots();
+  }
+
+  /**
+   * 查找所有技能根目录
+   */
+  findSkillRoots() {
+    const roots = [];
+
+    // 检查 SKILLS 目录
+    const mainSkills = path.join(this.repoRoot, "SKILLS");
+    if (fs.existsSync(mainSkills)) {
+      roots.push(mainSkills);
+    }
+
+    // 检查 modules 中的 SKILLS
+    const modulesDir = path.join(this.repoRoot, "modules");
+    if (fs.existsSync(modulesDir)) {
+      const modules = fs.readdirSync(modulesDir);
+      for (const module of modules) {
+        const moduleSkills = path.join(modulesDir, module, "SKILLS");
+        if (fs.existsSync(moduleSkills)) {
+          roots.push(moduleSkills);
+        }
+      }
+    }
+
+    return roots;
+  }
+
+  /**
+   * 列出所有技能
+   */
+  list() {
+    const skills = new Set();
+
+    for (const root of this.skillRoots) {
+      if (!fs.existsSync(root)) {
+        continue;
+      }
+
+      const entries = fs.readdirSync(root, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          skills.add(entry.name);
+        }
+      }
+    }
+
+    return Array.from(skills).sort();
+  }
+
+  /**
+   * 查找技能路径
+   */
+  findSkill(name) {
+    for (const root of this.skillRoots) {
+      const skillPath = path.join(root, name);
+      if (fs.existsSync(skillPath)) {
+        return skillPath;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 安装技能
+   */
+  async install(name, options = {}) {
+    // 确定目标目录
+    let target = options.target;
+
+    if (!target) {
+      if (options.codex) {
+        const codexHome = process.env.CODEX_HOME || path.join(process.env.HOME, ".codex");
+        target = path.join(codexHome, "skills");
+      } else if (options.agents) {
+        target = path.join(process.env.HOME, ".agents", "skills");
+      } else {
+        target = path.join(process.env.HOME, ".claude", "skills");
+      }
+    }
+
+    console.log(`Installing to: ${target}`);
+
+    // 确保目标目录存在
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+
+    if (name === "all") {
+      // 安装所有技能
+      const skills = this.list();
+      for (const skill of skills) {
+        await this.installOne(skill, target);
+      }
+      console.log(`\nInstalled ${skills.length} skills to ${target}`);
+    } else {
+      // 安装单个技能
+      await this.installOne(name, target);
+      console.log(`\nInstalled "${name}" to ${target}`);
+    }
+  }
+
+  /**
+   * 安装单个技能
+   */
+  async installOne(name, target) {
+    const sourcePath = this.findSkill(name);
+    if (!sourcePath) {
+      throw new Error(`Skill not found: ${name}`);
+    }
+
+    const targetPath = path.join(target, name);
+
+    // 如果目标已存在，先删除
+    if (fs.existsSync(targetPath)) {
+      fs.rmSync(targetPath, { recursive: true, force: true });
+    }
+
+    // 复制技能目录
+    console.log(`  - ${name}`);
+    this.copyRecursive(sourcePath, targetPath);
+  }
+
+  /**
+   * 递归复制目录
+   */
+  copyRecursive(src, dest) {
+    // 创建目标目录
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this.copyRecursive(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+
+module.exports = SkillsManager;