u-foo 1.2.16 → 1.4.0

package/src/daemon/index.js

@@ -14,6 +14,8 @@ const { getUfooPaths } = require("../ufoo/paths");
 const { scheduleProviderSessionProbe, loadProviderSessionCache } = require("./providerSessions");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonCronController } = require("./cronOps");
+const { createGroupOrchestrator } = require("./groupOrchestrator");
+const { normalizeFormat, renderGroupDiagramFromTemplate, renderGroupDiagramFromRuntime } = require("../group/diagram");
 const { runAssistantTask } = require("../assistant/bridge");
 const { runPromptWithAssistant } = require("./promptLoop");
 const { handlePromptRequest } = require("./promptRequest");
@@ -22,6 +24,7 @@ const { recordAgentReport } = require("./reporting");
 let providerSessions = null;
 let probeHandles = new Map();
 let daemonCronController = null;
+let daemonGroupOrchestrator = null;
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -314,6 +317,7 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
             nickname: nickname || undefined,
             agent_id: existing,
             skipped: true,
+            cleaned: Boolean(cleaned),
             message: `Agent '${nickname}' already exists`,
           });
           continue;
@@ -354,7 +358,8 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
           ok: true,
           agent,
           count,
-          nickname: nickname || undefined
+          nickname: nickname || undefined,
+          subscriber_ids: Array.isArray(launchResult.subscriberIds) ? launchResult.subscriberIds.slice() : [],
         });
         if (nickname) {
           // eslint-disable-next-line no-await-in-loop
@@ -680,6 +685,11 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     },
     log,
   });
+  daemonGroupOrchestrator = createGroupOrchestrator({
+    projectRoot,
+    handleOps,
+    processManager,
+  });
 
   const buildRuntimeStatus = () =>
     buildStatus(projectRoot, {
@@ -992,6 +1002,313 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
             type: IPC_RESPONSE_TYPES.ERROR,
             error: err.message || "launch_agent failed",
           })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.LAUNCH_GROUP) {
+      if (!daemonGroupOrchestrator) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "group orchestrator unavailable",
+          })}
+`,
+        );
+        return;
+      }
+      const alias = req.alias || req.template || "";
+      const instance = req.instance || req.group_id || "";
+      const dryRun = req.dry_run === true || req.dryRun === true;
+      try {
+        const result = await daemonGroupOrchestrator.runGroup({
+          alias,
+          instance,
+          dry_run: dryRun,
+        });
+        const ok = result && result.ok !== false;
+        let reply = "";
+        if (!ok) {
+          reply = `Group run failed: ${result?.error || "unknown error"}`;
+        } else if (result.dry_run) {
+          reply = `Group dry-run ${result.group_id}: ${Array.isArray(result.members) ? result.members.length : 0} member(s)`;
+        } else {
+          reply = `Group started ${result.group_id}`;
+        }
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply,
+              group: result,
+            },
+          })}
+`,
+        );
+        if (!dryRun) {
+          cleanupInactiveSubscribers();
+          ipcServer.sendToSockets({
+            type: IPC_RESPONSE_TYPES.STATUS,
+            data: buildRuntimeStatus(),
+          });
+        }
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "launch_group failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.STOP_GROUP) {
+      if (!daemonGroupOrchestrator) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "group orchestrator unavailable",
+          })}
+`,
+        );
+        return;
+      }
+      const groupId = req.group_id || req.groupId || req.instance || "";
+      try {
+        const result = await daemonGroupOrchestrator.stopGroup({ group_id: groupId });
+        const ok = result && result.ok !== false;
+        const reply = ok
+          ? `Stopped group ${result.group_id}`
+          : `Group stop failed: ${result?.error || "unknown error"}`;
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply,
+              group: result,
+            },
+          })}
+`,
+        );
+        cleanupInactiveSubscribers();
+        ipcServer.sendToSockets({
+          type: IPC_RESPONSE_TYPES.STATUS,
+          data: buildRuntimeStatus(),
+        });
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "stop_group failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.GROUP_STATUS) {
+      if (!daemonGroupOrchestrator) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "group orchestrator unavailable",
+          })}
+`,
+        );
+        return;
+      }
+      const groupId = req.group_id || req.groupId || req.instance || "";
+      try {
+        const result = daemonGroupOrchestrator.getStatus({ group_id: groupId });
+        const ok = result && result.ok !== false;
+        const reply = ok
+          ? (groupId
+            ? `Group ${groupId}: ${result.group?.status || "unknown"}`
+            : `Group instances: ${result.count || 0}`)
+          : `Group status failed: ${result?.error || "unknown error"}`;
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply,
+              group: result,
+            },
+          })}
+`,
+        );
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "group_status failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.GROUP_TEMPLATE_VALIDATE) {
+      if (!daemonGroupOrchestrator) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "group orchestrator unavailable",
+          })}
+`,
+        );
+        return;
+      }
+      const target = req.alias || req.path || req.target || "";
+      try {
+        const result = daemonGroupOrchestrator.validateTemplateTarget(target);
+        const reply = result.ok
+          ? `Template valid: ${result.entry?.alias || target}`
+          : `Template invalid: ${result.error || "unknown error"}`;
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply,
+              group: {
+                ok: result.ok,
+                target,
+                alias: result.entry?.alias || "",
+                source: result.entry?.source || "",
+                filePath: result.entry?.filePath || "",
+                errors: result.errors || [],
+              },
+            },
+          })}
+`,
+        );
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "group_template_validate failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.GROUP_DIAGRAM) {
+      if (!daemonGroupOrchestrator) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "group orchestrator unavailable",
+          })}
+`,
+        );
+        return;
+      }
+      const target = req.group_id || req.groupId || req.instance || req.alias || req.target || "";
+      if (!target) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "group diagram requires alias|group_id",
+          })}
+`,
+        );
+        return;
+      }
+      const format = normalizeFormat(req.format || (req.mermaid ? "mermaid" : "ascii"));
+      try {
+        const runtimeState = daemonGroupOrchestrator.getStatus({ group_id: target });
+        if (runtimeState && runtimeState.ok === false && runtimeState.error === "invalid group_id") {
+          socket.write(
+            `${JSON.stringify({
+              type: IPC_RESPONSE_TYPES.RESPONSE,
+              data: {
+                reply: "Group diagram failed: invalid group_id",
+                group: {
+                  ok: false,
+                  mode: "runtime",
+                  target,
+                  format,
+                  error: "invalid group_id",
+                },
+              },
+            })}
+`,
+          );
+          return;
+        }
+        if (runtimeState && runtimeState.ok && runtimeState.group) {
+          const diagram = renderGroupDiagramFromRuntime(runtimeState.group, { format });
+          socket.write(
+            `${JSON.stringify({
+              type: IPC_RESPONSE_TYPES.RESPONSE,
+              data: {
+                reply: `Group diagram (${format}) for runtime ${target}`,
+                group: {
+                  ok: true,
+                  mode: "runtime",
+                  target,
+                  format,
+                  diagram,
+                  group_id: runtimeState.group.group_id || target,
+                  status: runtimeState.group.status || "",
+                },
+              },
+            })}
+`,
+          );
+          return;
+        }
+
+        const templateState = daemonGroupOrchestrator.validateTemplateTarget(target, { allowPath: false });
+        if (!templateState || !templateState.ok || !templateState.entry) {
+          socket.write(
+            `${JSON.stringify({
+              type: IPC_RESPONSE_TYPES.RESPONSE,
+              data: {
+                reply: `Group diagram failed: ${templateState?.error || "template not found"}`,
+                group: {
+                  ok: false,
+                  mode: "template",
+                  target,
+                  format,
+                  error: templateState?.error || "template not found",
+                  errors: templateState?.errors || [],
+                },
+              },
+            })}
+`,
+          );
+          return;
+        }
+
+        const diagram = renderGroupDiagramFromTemplate(templateState.entry.data, { format });
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply: `Group diagram (${format}) for template ${templateState.entry.alias || target}`,
+              group: {
+                ok: true,
+                mode: "template",
+                target,
+                format,
+                diagram,
+                alias: templateState.entry.alias || "",
+                source: templateState.entry.source || "",
+                filePath: templateState.entry.filePath || "",
+              },
+            },
+          })}
+`,
+        );
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "group_diagram failed",
+          })}
 `,
         );
       }
@@ -1309,6 +1626,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
       daemonCronController.stopAll();
       daemonCronController = null;
     }
+    daemonGroupOrchestrator = null;
 
     // 清理所有子进程
     processManager.cleanup();

package/src/daemon/status.js

@@ -79,11 +79,58 @@ function normalizeCronTasks(raw = []) {
   }));
 }
 
+function readGroups(projectRoot) {
+  const groupsDir = getUfooPaths(projectRoot).groupsDir;
+  if (!groupsDir || !fs.existsSync(groupsDir)) {
+    return { count: 0, active: 0, failed: 0, stopped: 0, items: [] };
+  }
+
+  const items = [];
+  try {
+    const files = fs.readdirSync(groupsDir)
+      .filter((name) => name.endsWith(".json"))
+      .sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" }));
+    for (const file of files) {
+      const filePath = path.join(groupsDir, file);
+      try {
+        const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        const members = Array.isArray(raw.members) ? raw.members : [];
+        const membersActive = members.filter((item) => item && (item.status === "active" || item.status === "reused")).length;
+        items.push({
+          group_id: String(raw.group_id || path.basename(file, ".json")),
+          status: String(raw.status || "unknown"),
+          template_alias: String(raw.template_alias || ""),
+          updated_at: String(raw.updated_at || ""),
+          members_total: members.length,
+          members_active: membersActive,
+        });
+      } catch {
+        // ignore malformed group state
+      }
+    }
+  } catch {
+    return { count: 0, active: 0, failed: 0, stopped: 0, items: [] };
+  }
+
+  items.sort((a, b) => String(b.updated_at || "").localeCompare(String(a.updated_at || "")));
+  const active = items.filter((item) => item.status === "active").length;
+  const failed = items.filter((item) => item.status === "failed").length;
+  const stopped = items.filter((item) => item.status === "stopped").length;
+  return {
+    count: items.length,
+    active,
+    failed,
+    stopped,
+    items,
+  };
+}
+
 function buildStatus(projectRoot, options = {}) {
   const bus = readBus(projectRoot);
   const decisions = readDecisions(projectRoot);
   const unread = readUnread(projectRoot);
   const reports = readReportSummary(projectRoot);
+  const groups = readGroups(projectRoot);
   const subscribers = bus ? Object.keys(bus.agents || {}) : [];
   const cronTasks = normalizeCronTasks(options.cronTasks || []);
 
@@ -115,6 +162,7 @@ function buildStatus(projectRoot, options = {}) {
       count: cronTasks.length,
       tasks: cronTasks,
     },
+    groups,
   };
 }
 

package/src/group/diagram.js

@@ -0,0 +1,222 @@
+"use strict";
+
+function asTrimmedString(value) {
+  if (typeof value !== "string") return "";
+  return value.trim();
+}
+
+function normalizeFormat(format = "") {
+  const value = asTrimmedString(format).toLowerCase();
+  return value === "mermaid" ? "mermaid" : "ascii";
+}
+
+function toMemberNickname(member = {}, fallback = "") {
+  return asTrimmedString(member.nickname) || asTrimmedString(member.id) || fallback;
+}
+
+function collectTemplateMembers(templateDoc = {}) {
+  const agents = Array.isArray(templateDoc.agents) ? templateDoc.agents : [];
+  return agents
+    .map((agent, index) => ({
+      nickname: toMemberNickname(agent, `agent_${index + 1}`),
+      id: asTrimmedString(agent.id),
+      type: asTrimmedString(agent.type),
+      startup_order: Number.isInteger(agent.startup_order) ? agent.startup_order : null,
+      depends_on: Array.isArray(agent.depends_on)
+        ? agent.depends_on.map((dep) => asTrimmedString(dep)).filter(Boolean)
+        : [],
+      status: asTrimmedString(agent.status),
+      subscriber_id: asTrimmedString(agent.subscriber_id),
+    }))
+    .filter((item) => item.nickname);
+}
+
+function collectRuntimeMembers(runtime = {}) {
+  const members = Array.isArray(runtime.members) ? runtime.members : [];
+  return members
+    .map((member, index) => ({
+      nickname: toMemberNickname(member, `agent_${index + 1}`),
+      id: asTrimmedString(member.template_agent_id) || asTrimmedString(member.id),
+      type: asTrimmedString(member.type),
+      startup_order: Number.isInteger(member.startup_order) ? member.startup_order : null,
+      depends_on: Array.isArray(member.depends_on)
+        ? member.depends_on.map((dep) => asTrimmedString(dep)).filter(Boolean)
+        : [],
+      status: asTrimmedString(member.status),
+      subscriber_id: asTrimmedString(member.subscriber_id),
+    }))
+    .filter((item) => item.nickname);
+}
+
+function collectTemplateEdges(templateDoc = {}, members = []) {
+  const known = new Set(members.map((member) => member.nickname));
+  const edges = [];
+  const seen = new Set();
+
+  function addEdge(from, to, kind) {
+    const source = asTrimmedString(from);
+    const target = asTrimmedString(to);
+    if (!source || !target) return;
+    if (!known.has(source) || !known.has(target)) return;
+    const edgeKind = asTrimmedString(kind);
+    const key = `${source}->${target}:${edgeKind}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push({ from: source, to: target, kind: edgeKind });
+  }
+
+  const rawEdges = Array.isArray(templateDoc.edges) ? templateDoc.edges : [];
+  rawEdges.forEach((edge) => {
+    if (!edge || typeof edge !== "object") return;
+    addEdge(edge.from, edge.to, edge.kind);
+  });
+
+  members.forEach((member) => {
+    member.depends_on.forEach((dep) => addEdge(dep, member.nickname, "depends_on"));
+  });
+
+  return edges;
+}
+
+function collectRuntimeEdges(members = []) {
+  const known = new Set(members.map((member) => member.nickname));
+  const edges = [];
+  const seen = new Set();
+  members.forEach((member) => {
+    member.depends_on.forEach((dep) => {
+      if (!known.has(dep)) return;
+      const key = `${dep}->${member.nickname}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      edges.push({ from: dep, to: member.nickname, kind: "depends_on" });
+    });
+  });
+  return edges;
+}
+
+function formatMemberLine(member = {}) {
+  const type = member.type || "unknown";
+  const order = Number.isInteger(member.startup_order) ? member.startup_order : "-";
+  const deps = Array.isArray(member.depends_on) && member.depends_on.length > 0
+    ? member.depends_on.join(", ")
+    : "-";
+  const status = member.status ? ` status=${member.status}` : "";
+  const subscriber = member.subscriber_id ? ` sub=${member.subscriber_id}` : "";
+  return `- ${member.nickname} [${type}] order=${order} deps=${deps}${status}${subscriber}`;
+}
+
+function renderAsciiDiagram(metadata = {}, members = [], edges = []) {
+  const mode = metadata.mode || "template";
+  const name = metadata.name || "unknown";
+  const lines = [`Group Diagram (${mode}: ${name})`];
+  if (metadata.status) {
+    lines.push(`Status: ${metadata.status}`);
+  }
+  lines.push(`Members (${members.length}):`);
+  members.forEach((member) => {
+    lines.push(formatMemberLine(member));
+  });
+  if (edges.length === 0) {
+    lines.push("Edges: none");
+  } else {
+    lines.push(`Edges (${edges.length}):`);
+    edges.forEach((edge) => {
+      const suffix = edge.kind ? ` (${edge.kind})` : "";
+      lines.push(`- ${edge.from} -> ${edge.to}${suffix}`);
+    });
+  }
+  return lines.join("\n");
+}
+
+function normalizeMermaidId(value = "", fallback = "node") {
+  const normalized = String(value || "")
+    .replace(/[^A-Za-z0-9_]/g, "_")
+    .replace(/^[^A-Za-z_]+/, "");
+  return normalized || fallback;
+}
+
+function escapeMermaidLabel(value = "") {
+  return String(value || "")
+    .replace(/"/g, "\\\"")
+    .replace(/\n/g, "\\n");
+}
+
+function renderMermaidDiagram(members = [], edges = []) {
+  const lines = ["flowchart LR"];
+  const nodeIdMap = new Map();
+  const taken = new Set();
+
+  members.forEach((member, index) => {
+    const base = normalizeMermaidId(member.nickname, `node_${index + 1}`);
+    let id = base;
+    let suffix = 1;
+    while (taken.has(id)) {
+      id = `${base}_${suffix}`;
+      suffix += 1;
+    }
+    taken.add(id);
+    nodeIdMap.set(member.nickname, id);
+    const labelParts = [member.nickname];
+    if (member.type) labelParts.push(member.type);
+    if (member.status) labelParts.push(member.status);
+    lines.push(`  ${id}["${escapeMermaidLabel(labelParts.join("\n"))}"]`);
+  });
+
+  edges.forEach((edge) => {
+    const fromId = nodeIdMap.get(edge.from);
+    const toId = nodeIdMap.get(edge.to);
+    if (!fromId || !toId) return;
+    const edgeLabel = edge.kind ? `|${escapeMermaidLabel(edge.kind)}|` : "";
+    lines.push(`  ${fromId} -->${edgeLabel} ${toId}`);
+  });
+
+  return lines.join("\n");
+}
+
+function resolveTemplateName(templateDoc = {}, fallback = "") {
+  const templateMeta = templateDoc && templateDoc.template && typeof templateDoc.template === "object"
+    ? templateDoc.template
+    : {};
+  return asTrimmedString(templateMeta.alias) || asTrimmedString(templateMeta.id) || asTrimmedString(templateMeta.name) || fallback;
+}
+
+function renderGroupDiagramFromTemplate(templateDoc = {}, options = {}) {
+  const format = normalizeFormat(options.format);
+  const members = collectTemplateMembers(templateDoc);
+  const edges = collectTemplateEdges(templateDoc, members);
+  if (format === "mermaid") {
+    return renderMermaidDiagram(members, edges);
+  }
+  return renderAsciiDiagram(
+    {
+      mode: "template",
+      name: resolveTemplateName(templateDoc, "template"),
+    },
+    members,
+    edges
+  );
+}
+
+function renderGroupDiagramFromRuntime(runtime = {}, options = {}) {
+  const format = normalizeFormat(options.format);
+  const members = collectRuntimeMembers(runtime);
+  const edges = collectRuntimeEdges(members);
+  if (format === "mermaid") {
+    return renderMermaidDiagram(members, edges);
+  }
+  return renderAsciiDiagram(
+    {
+      mode: "runtime",
+      name: asTrimmedString(runtime.group_id) || "runtime",
+      status: asTrimmedString(runtime.status),
+    },
+    members,
+    edges
+  );
+}
+
+module.exports = {
+  normalizeFormat,
+  renderGroupDiagramFromTemplate,
+  renderGroupDiagramFromRuntime,
+};