u-foo 1.2.14 → 1.3.0

package/src/cli.js

@@ -6,6 +6,7 @@ const { socketPath, isRunning } = require("./daemon");
 const { runBusCoreCommand } = require("./cli/busCoreCommands");
 const { runCtxCommand } = require("./cli/ctxCoreCommands");
 const { runOnlineCommand } = require("./cli/onlineCoreCommands");
+const { runGroupCoreCommand } = require("./cli/groupCoreCommands");
 
 function getPackageRoot() {
   return path.resolve(__dirname, "..");
@@ -561,6 +562,189 @@ async function runCli(argv) {
         }
       });
 
+    const group = program.command("group").description("Agent group template commands");
+    group
+      .command("templates")
+      .description("List available group templates")
+      .argument("[action]", "list", "list")
+      .option("--json", "Output as JSON")
+      .action(async (action, opts) => {
+        const normalizedAction = String(action || "list").trim().toLowerCase();
+        if (normalizedAction !== "list" && normalizedAction !== "ls") {
+          console.error(`Unknown group templates action: ${normalizedAction}`);
+          process.exitCode = 1;
+          return;
+        }
+        try {
+          await runGroupCoreCommand("templates", [normalizedAction], {
+            cwd: process.cwd(),
+            json: opts.json,
+          });
+        } catch (err) {
+          console.error(err.message || String(err));
+          process.exitCode = 1;
+        }
+      });
+
+    group
+      .command("template")
+      .description("Group template operations")
+      .argument("<action>", "list|show|validate|new")
+      .argument("[target]", "Template alias (or path for validate)")
+      .option("--from <alias>", "Builtin template alias (for template new)")
+      .option("--global", "Create template in ~/.ufoo/templates/groups")
+      .option("--project", "Create template in .ufoo/templates/groups (default)")
+      .option("--force", "Overwrite existing file (for template new)")
+      .option("--json", "Output as JSON")
+      .action(async (action, target, opts) => {
+        const args = [action];
+        if (target) args.push(target);
+        if (opts.from) args.push("--from", opts.from);
+        if (opts.global) args.push("--global");
+        if (opts.project) args.push("--project");
+        if (opts.force) args.push("--force");
+        if (opts.json) args.push("--json");
+
+        try {
+          await runGroupCoreCommand("template", args, {
+            cwd: process.cwd(),
+            json: opts.json,
+          });
+        } catch (err) {
+          console.error(err.message || String(err));
+          process.exitCode = 1;
+        }
+      });
+
+    group
+      .command("run")
+      .description("Launch an agent group from template")
+      .argument("<alias>", "Template alias")
+      .option("--instance <name>", "Group instance ID")
+      .option("--dry-run", "Validate and compile launch plan without starting agents")
+      .option("--json", "Output daemon response as JSON")
+      .action(async (alias, opts) => {
+        try {
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "launch_group",
+            alias,
+            instance: opts.instance || "",
+            dry_run: opts.dryRun === true,
+          });
+          if (opts.json) {
+            console.log(JSON.stringify(resp?.data || {}, null, 2));
+            return;
+          }
+          const reply = resp?.data?.reply || "Group run requested";
+          console.log(reply);
+          if (resp?.data?.group?.ok === false) {
+            process.exitCode = 1;
+          }
+        } catch (err) {
+          console.error(err.message || String(err));
+          process.exitCode = 1;
+        }
+      });
+
+    group
+      .command("status")
+      .description("Show group runtime status (single group or list)")
+      .argument("[groupId]", "Group ID (optional)")
+      .option("--json", "Output daemon response as JSON")
+      .action(async (groupId, opts) => {
+        try {
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "group_status",
+            group_id: groupId || "",
+          });
+          if (opts.json) {
+            console.log(JSON.stringify(resp?.data || {}, null, 2));
+            return;
+          }
+          const reply = resp?.data?.reply || "Group status requested";
+          console.log(reply);
+          const group = resp?.data?.group || {};
+          if (groupId && group?.group) {
+            console.log(JSON.stringify(group.group, null, 2));
+          } else if (!groupId && Array.isArray(group?.groups)) {
+            group.groups.forEach((item) => {
+              console.log(`- ${item.group_id} [${item.status}] ${item.template_alias} active=${item.members_active}/${item.members_total}`);
+            });
+          }
+        } catch (err) {
+          console.error(err.message || String(err));
+          process.exitCode = 1;
+        }
+      });
+
+    group
+      .command("diagram")
+      .description("Render group diagram from template alias or group runtime ID")
+      .argument("<target>", "Template alias or group ID")
+      .option("--ascii", "Render ASCII diagram (default)")
+      .option("--mermaid", "Render Mermaid flowchart")
+      .option("--json", "Output daemon response as JSON")
+      .action(async (target, opts) => {
+        try {
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const format = opts.mermaid ? "mermaid" : "ascii";
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "group_diagram",
+            alias: target,
+            group_id: target,
+            format,
+          });
+          if (opts.json) {
+            console.log(JSON.stringify(resp?.data || {}, null, 2));
+            return;
+          }
+          const reply = resp?.data?.reply || "Group diagram requested";
+          console.log(reply);
+          if (resp?.data?.group?.diagram) {
+            console.log(resp.data.group.diagram);
+          }
+          if (resp?.data?.group?.ok === false) {
+            process.exitCode = 1;
+          }
+        } catch (err) {
+          console.error(err.message || String(err));
+          process.exitCode = 1;
+        }
+      });
+
+    group
+      .command("stop")
+      .description("Stop a running group instance")
+      .argument("<groupId>", "Group ID")
+      .option("--json", "Output daemon response as JSON")
+      .action(async (groupId, opts) => {
+        try {
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "stop_group",
+            group_id: groupId,
+          });
+          if (opts.json) {
+            console.log(JSON.stringify(resp?.data || {}, null, 2));
+            return;
+          }
+          const reply = resp?.data?.reply || "Group stop requested";
+          console.log(reply);
+          if (resp?.data?.group?.ok === false) {
+            process.exitCode = 1;
+          }
+        } catch (err) {
+          console.error(err.message || String(err));
+          process.exitCode = 1;
+        }
+      });
+
     const online = program.command("online").description("ufoo online helpers");
     online
       .command("server")
@@ -616,6 +800,7 @@ async function runCli(argv) {
       .option("--name <room>", "Room name (optional)")
       .option("--type <type>", "Room type (public|private)")
       .option("--password <pwd>", "Room password (private only)")
+      .option("--created-by <name>", "Room creator nickname metadata")
       .action(async (action, opts) => {
         try {
           await runOnlineCommand("room", { action, opts }, {
@@ -640,6 +825,7 @@ async function runCli(argv) {
       .option("--nickname <name>", "Nickname to resolve token")
       .option("--name <name>", "Channel name (unique)")
       .option("--type <type>", "Channel type (world|public)")
+      .option("--created-by <name>", "Channel creator nickname metadata")
       .action(async (action, opts) => {
         try {
           await runOnlineCommand("channel", { action, opts }, {
@@ -934,11 +1120,17 @@ async function runCli(argv) {
     console.log("  ufoo init [--modules <list>] [--project <dir>]");
     console.log("  ufoo skills list");
     console.log("  ufoo skills install <name|all> [--target <dir> | --codex | --agents]");
+    console.log("  ufoo group templates [list|ls] [--json]");
+    console.log("  ufoo group template <list|show|validate|new> [target] [--from <builtin>] [--global] [--force] [--json]");
+    console.log("  ufoo group run <alias> [--instance <name>] [--dry-run] [--json]");
+    console.log("  ufoo group status [groupId] [--json]");
+    console.log("  ufoo group diagram <alias|groupId> [--ascii|--mermaid] [--json]");
+    console.log("  ufoo group stop <groupId> [--json]");
     console.log("  ufoo online server [--port 8787] [--host 127.0.0.1] [--token-file <path>]");
     console.log("  ufoo online token <subscriber> [--nickname <name>] [--server <url>] [--file <path>]");
-    console.log("  ufoo online room create [--name <room>] --type public|private [--password <pwd>] [--server <url>]");
+    console.log("  ufoo online room create [--name <room>] --type public|private [--password <pwd>] [--created-by <name>] [--server <url>]");
     console.log("  ufoo online room list [--server <url>]");
-    console.log("  ufoo online channel create --name <name> [--type world|public] [--server <url>]");
+    console.log("  ufoo online channel create --name <name> [--type world|public] [--created-by <name>] [--server <url>]");
     console.log("  ufoo online channel list [--server <url>]");
     console.log("  ufoo online connect --nickname <name> [--join <ch>] [--room <id> --room-password <pwd>] [...]");
     console.log("  ufoo online send --nickname <name> --text <msg> [--channel <ch>] [--room <id>]");
@@ -1271,6 +1463,137 @@ async function runCli(argv) {
     process.exitCode = 1;
     return;
   }
+  if (cmd === "group") {
+    const sub = String(rest[0] || "").trim().toLowerCase();
+
+    (async () => {
+      try {
+        if (sub === "templates") {
+          const action = String(rest[1] || "list").trim().toLowerCase();
+          if (action !== "list" && action !== "ls") {
+            throw new Error(`Unknown group templates action: ${action}`);
+          }
+          const json = rest.includes("--json");
+          await runGroupCoreCommand("templates", [action], {
+            cwd: process.cwd(),
+            json,
+          });
+          return;
+        }
+
+        if (sub === "template") {
+          const action = String(rest[1] || "list").trim().toLowerCase();
+          const args = [action, ...rest.slice(2)];
+          const json = rest.includes("--json");
+          await runGroupCoreCommand("template", args, {
+            cwd: process.cwd(),
+            json,
+          });
+          return;
+        }
+
+        if (sub === "run") {
+          const alias = String(rest[1] || "").trim();
+          if (!alias) throw new Error("group run requires <alias>");
+          const instanceIdx = rest.indexOf("--instance");
+          const instance = instanceIdx !== -1 ? String(rest[instanceIdx + 1] || "").trim() : "";
+          const dryRun = rest.includes("--dry-run");
+          const outputJson = rest.includes("--json");
+
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "launch_group",
+            alias,
+            instance,
+            dry_run: dryRun,
+          });
+          if (outputJson) {
+            console.log(JSON.stringify(resp?.data || {}, null, 2));
+            return;
+          }
+          console.log(resp?.data?.reply || "Group run requested");
+          if (resp?.data?.group?.ok === false) process.exitCode = 1;
+          return;
+        }
+
+        if (sub === "status") {
+          const groupId = rest[1] && !rest[1].startsWith("--") ? rest[1] : "";
+          const outputJson = rest.includes("--json");
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "group_status",
+            group_id: groupId,
+          });
+          if (outputJson) {
+            console.log(JSON.stringify(resp?.data || {}, null, 2));
+            return;
+          }
+          console.log(resp?.data?.reply || "Group status requested");
+          const group = resp?.data?.group || {};
+          if (groupId && group?.group) {
+            console.log(JSON.stringify(group.group, null, 2));
+          } else if (!groupId && Array.isArray(group?.groups)) {
+            group.groups.forEach((item) => {
+              console.log(`- ${item.group_id} [${item.status}] ${item.template_alias} active=${item.members_active}/${item.members_total}`);
+            });
+          }
+          return;
+        }
+
+        if (sub === "stop") {
+          const groupId = String(rest[1] || "").trim();
+          if (!groupId) throw new Error("group stop requires <groupId>");
+          const outputJson = rest.includes("--json");
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "stop_group",
+            group_id: groupId,
+          });
+          if (outputJson) {
+            console.log(JSON.stringify(resp?.data || {}, null, 2));
+            return;
+          }
+          console.log(resp?.data?.reply || "Group stop requested");
+          if (resp?.data?.group?.ok === false) process.exitCode = 1;
+          return;
+        }
+
+        if (sub === "diagram") {
+          const target = String(rest[1] || "").trim();
+          if (!target) throw new Error("group diagram requires <alias|groupId>");
+          const outputJson = rest.includes("--json");
+          const format = rest.includes("--mermaid") ? "mermaid" : "ascii";
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "group_diagram",
+            alias: target,
+            group_id: target,
+            format,
+          });
+          if (outputJson) {
+            console.log(JSON.stringify(resp?.data || {}, null, 2));
+            return;
+          }
+          console.log(resp?.data?.reply || "Group diagram requested");
+          if (resp?.data?.group?.diagram) {
+            console.log(resp.data.group.diagram);
+          }
+          if (resp?.data?.group?.ok === false) process.exitCode = 1;
+          return;
+        }
+
+        throw new Error("group requires templates|template|run|status|diagram|stop subcommand");
+      } catch (err) {
+        console.error(err.message || String(err));
+        process.exitCode = 1;
+      }
+    })();
+    return;
+  }
   if (cmd === "online") {
     const sub = rest[0] || "";
     if (!sub) {

package/src/code/agent.js

@@ -43,6 +43,14 @@ function normalizeLine(input = "") {
   return String(input || "").trim();
 }
 
+function parseProbeMarkerCommand(input = "") {
+  const text = String(input || "").trim();
+  if (!text) return "";
+  // Accept only strict probe markers: "<prefix> <single-marker-token>".
+  const match = text.match(/^(?:\$ufoo|\/ufoo|ufoo)\s+([A-Za-z0-9][A-Za-z0-9._:-]{0,63})$/);
+  return match ? String(match[1] || "").trim() : "";
+}
+
 function parseJson(text = "") {
   const raw = String(text || "").trim();
   if (!raw) return {};
@@ -1209,16 +1217,18 @@ function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
         "  help",
         "  exit|quit",
         "  ubus|/ubus",
+        "  bg|/bg <task>",
         "  resume <session-id>",
         "  tool <read|write|edit|bash> <args-json>",
         "  run <read|write|edit|bash> <args-json>",
       ].join("\n"),
     };
   }
-  if (text.startsWith("$ufoo ") || text.startsWith("/ufoo ") || text.startsWith("ufoo ")) {
+  const probeMarker = parseProbeMarkerCommand(text);
+  if (probeMarker) {
     return {
       kind: "probe",
-      output: text.split(/\s+/).slice(1).join(" ").trim(),
+      marker: probeMarker,
     };
   }
   if (text === "ubus" || text === "/ubus") {
@@ -1226,6 +1236,26 @@ function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
       kind: "ubus",
     };
   }
+  if (text === "bg" || text === "/bg") {
+    return {
+      kind: "error",
+      output: "usage: bg <task>",
+    };
+  }
+  const bgMatch = text.match(/^(?:\/bg|bg)\s+(.+)$/i);
+  if (bgMatch) {
+    const task = String(bgMatch[1] || "").trim();
+    if (!task) {
+      return {
+        kind: "error",
+        output: "usage: bg <task>",
+      };
+    }
+    return {
+      kind: "nl_bg",
+      task,
+    };
+  }
   const resumeMatch = text.match(/^resume(?:\s+(.+))?$/i);
   if (resumeMatch) {
     const session = String(resumeMatch[1] || "").trim();
@@ -1345,6 +1375,8 @@ async function runUcodeCoreAgent({
   });
   return new Promise((resolve) => {
     let chain = Promise.resolve();
+    let backgroundSeq = 0;
+    const backgroundRuns = new Map();
     const subscriberId = String(process.env.UFOO_SUBSCRIBER_ID || "").trim();
     const autoBusEnabled = shouldAutoConsumeBus(subscriberId);
     let autoBusTimer = null;
@@ -1400,6 +1432,38 @@ async function runUcodeCoreAgent({
       scheduleAutoBus();
     }
 
+    const startBackgroundTask = (task = "") => {
+      backgroundSeq += 1;
+      const jobId = `bg-${Date.now().toString(36)}-${backgroundSeq.toString(36)}`;
+      const bgState = {
+        workspaceRoot: state.workspaceRoot,
+        provider: state.provider,
+        model: state.model,
+        engine: state.engine,
+        context: state.context,
+        nlMessages: Array.isArray(state.nlMessages) ? state.nlMessages.slice() : [],
+        sessionId: "",
+        timeoutMs: state.timeoutMs,
+        jsonOutput: false,
+      };
+      const run = runNaturalLanguageTask(task, bgState)
+        .then((nlResult) => {
+          const summary = String(formatNlResult(nlResult, false) || "").trim();
+          const title = nlResult && nlResult.ok ? "done" : "failed";
+          stdout.write(`[${jobId}] ${title}: ${summary || "no summary"}\n`);
+          printPrompt();
+        })
+        .catch((err) => {
+          stdout.write(`[${jobId}] failed: ${err && err.message ? err.message : "background task failed"}\n`);
+          printPrompt();
+        })
+        .finally(() => {
+          backgroundRuns.delete(jobId);
+        });
+      backgroundRuns.set(jobId, run);
+      return jobId;
+    };
+
     const handleLine = async (line) => {
       const runtimeWorkspace = String(state.workspaceRoot || workspaceRoot || process.cwd());
       const result = runSingleCommand(line, runtimeWorkspace);
@@ -1407,7 +1471,10 @@ async function runUcodeCoreAgent({
         rl.close();
         return;
       }
-      if (result.kind === "help" || result.kind === "probe" || result.kind === "tool" || result.kind === "error") {
+      if (result.kind === "probe") {
+        return;
+      }
+      if (result.kind === "help" || result.kind === "tool" || result.kind === "error") {
         stdout.write(`${result.output}\n`);
       }
       if (result.kind === "ubus") {
@@ -1442,6 +1509,10 @@ async function runUcodeCoreAgent({
           stdout.write(`Resumed session ${resumed.sessionId} (${resumed.restoredMessages} messages).\n`);
         }
       }
+      if (result.kind === "nl_bg") {
+        const jobId = startBackgroundTask(result.task);
+        stdout.write(`[${jobId}] started in background.\n`);
+      }
       if (result.kind === "nl") {
         let streamBuffer = null;
         let streamedVisible = false;

package/src/code/tui.js

@@ -468,7 +468,7 @@ function runUcodeTui({
 } = {}) {
   return new Promise((resolve) => {
     const blessed = require("blessed");
-    const { execSync } = require("child_process");
+    const { execFileSync } = require("child_process");
     const { createChatLayout } = require("../chat/layout");
     const { computeDashboardContent } = require("../chat/dashboardView");
     const { escapeBlessed, stripBlessedTags } = require("../chat/text");
@@ -490,6 +490,8 @@ function runUcodeTui({
     let agentListWindowStart = 0;
     let agentSelectionMode = false;
     let pendingTask = null;
+    const backgroundTasks = new Map();
+    let backgroundSeq = 0;
     const logRenderState = { inCodeBlock: false };
     const inputHistory = [];
     let historyIndex = -1;
@@ -900,12 +902,27 @@ function runUcodeTui({
     };
 
     const updateStatus = (message = "", type = "thinking", options = {}) => {
+      const getBackgroundSuffix = () => {
+        if (!backgroundTasks || backgroundTasks.size === 0) return "";
+        let running = 0;
+        let done = 0;
+        let failed = 0;
+        for (const task of backgroundTasks.values()) {
+          const status = String(task && task.status || "").trim().toLowerCase();
+          if (status === "running") running += 1;
+          else if (status === "done") done += 1;
+          else if (status === "failed") failed += 1;
+        }
+        const total = running + done + failed;
+        if (total <= 0) return "";
+        return ` · BG ${running}/${done}/${failed}`;
+      };
       if (statusInterval) {
         clearInterval(statusInterval);
         statusInterval = null;
       }
       if (!message) {
-        statusLine.setContent("{bold}UCODE{/bold} · Ready");
+        statusLine.setContent(escapeBlessed(`UCODE · Ready${getBackgroundSuffix()}`));
         screen.render();
         return;
       }
@@ -918,7 +935,7 @@ function runUcodeTui({
         const timerText = showTimer
           ? ` (${formatPendingElapsed(Date.now() - startedAt)}，esc cancel)`
           : "";
-        statusLine.setContent(escapeBlessed(`${indicator} ${message}${timerText}`));
+        statusLine.setContent(escapeBlessed(`${indicator} ${message}${timerText}${getBackgroundSuffix()}`));
         statusIndex += 1;
         screen.render();
       };
@@ -1082,7 +1099,7 @@ function runUcodeTui({
       if (isBusMessage && targetAgent) {
         updateStatus("Sending message...", "typing");
         try {
-          execSync(`ufoo bus send "${targetAgent}" "${actualLine.replace(/"/g, '\\"')}"`, {
+          execFileSync("ufoo", ["bus", "send", targetAgent, actualLine], {
             cwd: workspaceRoot,
             encoding: "utf8",
           });
@@ -1118,7 +1135,10 @@ function runUcodeTui({
         }, payload);
         return;
       }
-      if (result.kind === "help" || result.kind === "probe" || result.kind === "error") {
+      if (result.kind === "probe") {
+        return;
+      }
+      if (result.kind === "help" || result.kind === "error") {
         logText(result.output || "");
         return;
       }
@@ -1166,6 +1186,54 @@ function runUcodeTui({
         return;
       }
 
+      if (result.kind === "nl_bg") {
+        backgroundSeq += 1;
+        const jobId = `bg-${Date.now().toString(36)}-${backgroundSeq.toString(36)}`;
+        const taskRecord = {
+          id: jobId,
+          task: result.task,
+          status: "running",
+          startedAt: Date.now(),
+          summary: "",
+        };
+        backgroundTasks.set(jobId, taskRecord);
+        updateStatus("", "none");
+        logText(`[${jobId}] started in background.`);
+
+        const bgState = {
+          workspaceRoot: state.workspaceRoot,
+          provider: state.provider,
+          model: state.model,
+          engine: state.engine,
+          context: state.context,
+          nlMessages: Array.isArray(state.nlMessages) ? state.nlMessages.slice() : [],
+          sessionId: "",
+          timeoutMs: state.timeoutMs,
+          jsonOutput: false,
+        };
+
+        Promise.resolve()
+          .then(() => runNaturalLanguageTask(result.task, bgState))
+          .then((nlResult) => {
+            taskRecord.status = nlResult && nlResult.ok ? "done" : "failed";
+            taskRecord.finishedAt = Date.now();
+            taskRecord.summary = String(formatNlResult(nlResult, false) || "").trim();
+            const title = taskRecord.status === "done" ? "done" : "failed";
+            logText(`[${jobId}] ${title}: ${taskRecord.summary || "no summary"}`);
+          })
+          .catch((err) => {
+            taskRecord.status = "failed";
+            taskRecord.finishedAt = Date.now();
+            taskRecord.summary = err && err.message ? String(err.message) : "background task failed";
+            logText(`[${jobId}] failed: ${taskRecord.summary}`);
+          })
+          .finally(() => {
+            updateStatus("", "none");
+            screen.render();
+          });
+        return;
+      }
+
       if (result.kind === "nl") {
         const statusMessages = [
           "Thinking...",