u-foo 1.2.16 → 1.4.0

package/src/chat/daemonMessageRouter.js

@@ -74,6 +74,109 @@ function createDaemonMessageRouter(options = {}) {
     return false;
   }
 
+  function logGroupMembers(members = []) {
+    if (!Array.isArray(members) || members.length === 0) return;
+    members.forEach((member) => {
+      const nickname = member && member.nickname ? member.nickname : (member && member.template_agent_id ? member.template_agent_id : "unknown");
+      const type = member && member.type ? ` [${member.type}]` : "";
+      const status = member && member.status ? ` (${member.status})` : "";
+      const subscriber = member && member.subscriber_id ? ` -> ${member.subscriber_id}` : "";
+      logMessage(
+        "system",
+        `  • ${escapeBlessed(`${nickname}${type}${status}${subscriber}`)}`
+      );
+    });
+  }
+
+  function parseGroupErrorEntry(err) {
+    const errPath = err && (err.path || err.filePath) ? (err.path || err.filePath) : "template";
+    const errMessage = err && (err.message || err.error) ? (err.message || err.error) : "validation error";
+    return { errPath, errMessage };
+  }
+
+  function logGroupPayload(group) {
+    if (!group || typeof group !== "object") return;
+
+    if (typeof group.diagram === "string" && group.diagram) {
+      const mode = group.mode ? ` ${group.mode}` : "";
+      const format = group.format ? ` ${group.format}` : "";
+      logMessage("system", `{cyan-fg}Group diagram:{/cyan-fg} ${escapeBlessed(`${mode}${format}`.trim())}`);
+      group.diagram.split(/\r?\n/).forEach((line) => {
+        logMessage("system", escapeBlessed(line));
+      });
+      return;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(group, "target") && Array.isArray(group.errors)) {
+      if (group.ok) {
+        const alias = group.alias || group.target || "";
+        const source = group.source ? ` (${group.source})` : "";
+        logMessage("system", `{white-fg}✓{/white-fg} Group template valid: ${escapeBlessed(`${alias}${source}`)}`);
+      } else {
+        logMessage("error", `{white-fg}✗{/white-fg} Group template invalid: ${escapeBlessed(group.target || group.alias || "unknown")}`);
+        group.errors.forEach((err) => {
+          const { errPath, errMessage } = parseGroupErrorEntry(err);
+          logMessage("error", `  - ${escapeBlessed(`${errPath}: ${errMessage}`)}`);
+        });
+      }
+      return;
+    }
+
+    if (Array.isArray(group.groups)) {
+      logMessage("system", `{cyan-fg}Groups:{/cyan-fg} ${group.groups.length}`);
+      group.groups.forEach((item) => {
+        const id = item && item.group_id ? item.group_id : "unknown";
+        const status = item && item.status ? item.status : "unknown";
+        const alias = item && item.template_alias ? item.template_alias : "-";
+        const active = Number(item && item.members_active) || 0;
+        const total = Number(item && item.members_total) || 0;
+        logMessage(
+          "system",
+          `  • ${escapeBlessed(id)} [${escapeBlessed(status)}] ${escapeBlessed(alias)} active=${active}/${total}`
+        );
+      });
+      return;
+    }
+
+    if (group.group && typeof group.group === "object") {
+      const runtime = group.group;
+      const id = runtime.group_id || group.group_id || "unknown";
+      const status = runtime.status || group.status || "unknown";
+      const alias = runtime.template_alias || group.template_alias || "-";
+      logMessage(
+        "system",
+        `{cyan-fg}Group:{/cyan-fg} ${escapeBlessed(id)} [${escapeBlessed(status)}] ${escapeBlessed(alias)}`
+      );
+      logGroupMembers(runtime.members);
+      if (Array.isArray(group.stopped_agents) && group.stopped_agents.length > 0) {
+        logMessage("system", `{white-fg}Stopped:{/white-fg} ${group.stopped_agents.length} agent(s)`);
+      }
+      return;
+    }
+
+    if (group.group_id && Array.isArray(group.members)) {
+      const status = group.dry_run ? "dry_run" : (group.status || "unknown");
+      const alias = group.template_alias || "-";
+      logMessage(
+        "system",
+        `{cyan-fg}Group:{/cyan-fg} ${escapeBlessed(group.group_id)} [${escapeBlessed(status)}] ${escapeBlessed(alias)}`
+      );
+      logGroupMembers(group.members);
+      return;
+    }
+
+    if (group.ok === false && group.error) {
+      logMessage("error", `{white-fg}✗{/white-fg} ${escapeBlessed(group.error)}`);
+      const validationErrors = Array.isArray(group.validationErrors)
+        ? group.validationErrors
+        : (Array.isArray(group.errors) ? group.errors : []);
+      validationErrors.forEach((err) => {
+        const { errPath, errMessage } = parseGroupErrorEntry(err);
+        logMessage("error", `  - ${escapeBlessed(`${errPath}: ${errMessage}`)}`);
+      });
+    }
+  }
+
   function handleResponseMessage(msg) {
     const payload = msg.data || {};
     if (payload.reply) {
@@ -150,6 +253,10 @@ function createDaemonMessageRouter(options = {}) {
       }
     }
 
+    if (payload.group && typeof payload.group === "object") {
+      logGroupPayload(payload.group);
+    }
+
     if (payload.dispatch && payload.dispatch.length > 0) {
       const targets = payload.dispatch.map((d) => d.target || d).join(", ");
       logMessage("dispatch", `{white-fg}→{/white-fg} Dispatched to: ${escapeBlessed(targets)}`);

package/src/cli/groupCoreCommands.js

@@ -0,0 +1,246 @@
+"use strict";
+
+const path = require("path");
+const {
+  loadTemplateRegistry,
+  resolveTemplateReference,
+  createTemplateFromBuiltin,
+} = require("../group/templates");
+const { validateTemplate } = require("../group/validateTemplate");
+
+function parseTemplateNewArgs(args = []) {
+  const alias = String(args[0] || "").trim();
+  const options = {
+    from: "",
+    scope: "project",
+    force: false,
+  };
+  let sawGlobal = false;
+  let sawProject = false;
+
+  for (let i = 1; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === "--from") {
+      options.from = String(args[i + 1] || "").trim();
+      i += 1;
+      continue;
+    }
+    if (token === "--global") {
+      sawGlobal = true;
+      options.scope = "global";
+      continue;
+    }
+    if (token === "--project") {
+      sawProject = true;
+      options.scope = "project";
+      continue;
+    }
+    if (token === "--force") {
+      options.force = true;
+      continue;
+    }
+    if (token === "--json") {
+      continue;
+    }
+    throw new Error(`Unknown option for template new: ${token}`);
+  }
+
+  if (!alias) throw new Error("template new requires <alias>");
+  if (!options.from) throw new Error("template new requires --from <builtin-alias>");
+  if (sawGlobal && sawProject) {
+    throw new Error("template new cannot use both --global and --project");
+  }
+
+  return { alias, ...options };
+}
+
+function formatDisplayPath(filePath = "", cwd = "") {
+  const target = String(filePath || "");
+  if (!target) return "";
+  const base = String(cwd || "").trim();
+  if (!base) return target;
+  const relative = path.relative(base, target);
+  if (!relative || relative.startsWith("..")) return target;
+  return relative;
+}
+
+function printList({ templates, errors }, { write, json, cwd }) {
+  if (json) {
+    write(JSON.stringify({ templates, errors }, null, 2));
+    return;
+  }
+
+  if (!templates.length) {
+    write("No group templates found.");
+  } else {
+    for (const item of templates) {
+      const nameLabel = item.templateName || item.alias;
+      const idLabel = item.templateId || "-";
+      const verLabel = Number.isInteger(item.schemaVersion) ? item.schemaVersion : "-";
+      const displayPath = formatDisplayPath(item.filePath, cwd);
+      write(`- ${item.alias} [${item.source}]`);
+      write(`  name: ${nameLabel}`);
+      write(`  id: ${idLabel}  schema: ${verLabel}`);
+      write(`  file: ${displayPath}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    write(`Warnings: ${errors.length} template file(s) failed to load`);
+    for (const err of errors) {
+      const displayPath = formatDisplayPath(err.filePath, cwd);
+      write(`  - ${displayPath}: ${err.error}`);
+    }
+  }
+}
+
+function formatResolveErrors(errors = []) {
+  if (!Array.isArray(errors) || errors.length === 0) return "";
+  return errors
+    .map((item) => `${item.filePath}: ${item.error}`)
+    .join("; ");
+}
+
+function throwResolveFailure(target, resolved = {}) {
+  const details = formatResolveErrors(resolved.errors || []);
+  if (details) {
+    throw new Error(`Failed to load template "${target}": ${details}`);
+  }
+  throw new Error(`Template not found: ${target}`);
+}
+
+function printValidation(result, target, entry, { write, json }) {
+  if (json) {
+    write(
+      JSON.stringify(
+        {
+          target,
+          alias: entry.alias,
+          source: entry.source,
+          filePath: entry.filePath,
+          ok: result.ok,
+          errors: result.errors,
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  if (result.ok) {
+    write(`✓ Template "${entry.alias}" is valid (${entry.source})`);
+    return;
+  }
+
+  write(`✗ Template "${entry.alias}" is invalid (${result.errors.length} error(s))`);
+  for (const err of result.errors) {
+    write(`  - ${err.path}: ${err.message}`);
+  }
+}
+
+async function runGroupCoreCommand(subcmd, cmdArgs = [], options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const write = typeof options.write === "function" ? options.write : console.log;
+  const json = Boolean(options.json);
+  const templatesOptions = options.templatesOptions || {};
+
+  const args = Array.isArray(cmdArgs) ? cmdArgs.filter((item) => item !== undefined) : [];
+  const normalizedSubcmd = String(subcmd || "").trim().toLowerCase();
+
+  if (normalizedSubcmd === "templates") {
+    const action = String(args[0] || "list").trim().toLowerCase();
+    if (action !== "list" && action !== "ls") {
+      throw new Error(`Unknown group templates action: ${action}`);
+    }
+
+    const registry = loadTemplateRegistry(cwd, templatesOptions);
+    const templates = registry.templates.map((item) => ({
+      alias: item.alias,
+      source: item.source,
+      filePath: item.filePath,
+      templateId: item.templateId || "",
+      templateName: item.templateName || "",
+      schemaVersion: item.schemaVersion,
+    }));
+    printList({ templates, errors: registry.errors }, { write, json, cwd });
+    return;
+  }
+
+  if (normalizedSubcmd !== "template") {
+    throw new Error(`Unknown group subcommand: ${subcmd}`);
+  }
+
+  const action = String(args[0] || "list").trim().toLowerCase();
+
+  if (action === "list") {
+    const registry = loadTemplateRegistry(cwd, templatesOptions);
+    const templates = registry.templates.map((item) => ({
+      alias: item.alias,
+      source: item.source,
+      filePath: item.filePath,
+      templateId: item.templateId || "",
+      templateName: item.templateName || "",
+      schemaVersion: item.schemaVersion,
+    }));
+    printList({ templates, errors: registry.errors }, { write, json, cwd });
+    return;
+  }
+
+  if (action === "show") {
+    const target = String(args[1] || "").trim();
+    if (!target) throw new Error("group template show requires <alias>");
+    const resolved = resolveTemplateReference(cwd, target, {
+      allowPath: false,
+      cwd,
+      ...templatesOptions,
+    });
+    if (!resolved.entry) {
+      throwResolveFailure(target, resolved);
+    }
+    write(JSON.stringify(resolved.entry.data, null, 2));
+    return;
+  }
+
+  if (action === "validate") {
+    const target = String(args[1] || "").trim();
+    if (!target) throw new Error("group template validate requires <alias|path>");
+    const resolved = resolveTemplateReference(cwd, target, {
+      allowPath: true,
+      cwd,
+      ...templatesOptions,
+    });
+    if (!resolved.entry) {
+      throwResolveFailure(target, resolved);
+    }
+    const result = validateTemplate(resolved.entry.data);
+    printValidation(result, target, resolved.entry, { write, json });
+    if (!result.ok) {
+      throw new Error(`Template validation failed: ${resolved.entry.alias}`);
+    }
+    return;
+  }
+
+  if (action === "new") {
+    const params = parseTemplateNewArgs(args.slice(1));
+    const created = createTemplateFromBuiltin(cwd, params.alias, params.from, {
+      ...templatesOptions,
+      scope: params.scope,
+      force: params.force,
+    });
+
+    if (json) {
+      write(JSON.stringify(created, null, 2));
+      return;
+    }
+    const relative = path.relative(cwd, created.filePath) || created.filePath;
+    write(`Created template "${created.alias}" from "${created.from}" at ${relative}`);
+    return;
+  }
+
+  throw new Error(`Unknown group template action: ${action}`);
+}
+
+module.exports = {
+  runGroupCoreCommand,
+};

package/src/cli/onlineCoreCommands.js

@@ -95,10 +95,12 @@ async function runOnlineRoom(action, opts = {}, onlineAuthHeaders) {
     return;
   }
   if (action === "create") {
+    const creator = String(opts.createdBy || opts.creator || opts.nickname || opts.subscriber || "").trim();
     const payload = {
       name: opts.name,
       type: opts.type,
       password: opts.password,
+      created_by: creator || undefined,
     };
     if (!payload.type) {
       throw new Error("online room create requires --type");
@@ -132,9 +134,11 @@ async function runOnlineChannel(action, opts = {}, onlineAuthHeaders) {
     return;
   }
   if (action === "create") {
+    const creator = String(opts.createdBy || opts.creator || opts.nickname || opts.subscriber || "").trim();
     const payload = {
       name: opts.name,
       type: opts.type,
+      created_by: creator || undefined,
     };
     if (!payload.name) {
       throw new Error("online channel create requires --name");
@@ -233,6 +237,7 @@ async function runOnlineCommand(subcmd, payload = {}, options = {}) {
           name: opts.name,
           type: opts.type,
           password: opts.password,
+          createdBy: opts.createdBy || "",
         }, onlineAuthHeaders);
       case "channel":
         return runOnlineChannel(payload.action, {
@@ -243,6 +248,7 @@ async function runOnlineCommand(subcmd, payload = {}, options = {}) {
           nickname: opts.nickname || "",
           name: opts.name,
           type: opts.type,
+          createdBy: opts.createdBy || "",
         }, onlineAuthHeaders);
       case "connect":
         return runOnlineConnect({
@@ -312,6 +318,7 @@ async function runOnlineCommand(subcmd, payload = {}, options = {}) {
         name: getFallbackOpt(argv, "--name"),
         type: getFallbackOpt(argv, "--type"),
         password: getFallbackOpt(argv, "--password"),
+        createdBy: getFallbackOpt(argv, "--created-by"),
       }, onlineAuthHeaders);
     }
     case "channel": {
@@ -325,6 +332,7 @@ async function runOnlineCommand(subcmd, payload = {}, options = {}) {
         nickname: getFallbackOpt(argv, "--nickname"),
         name: getFallbackOpt(argv, "--name"),
         type: getFallbackOpt(argv, "--type") || defaultChannelType,
+        createdBy: getFallbackOpt(argv, "--created-by"),
       }, onlineAuthHeaders);
     }
     case "connect": {