u-foo 1.4.1 → 1.6.0

package/src/cli.js

@@ -7,6 +7,9 @@ const { runBusCoreCommand } = require("./cli/busCoreCommands");
 const { runCtxCommand } = require("./cli/ctxCoreCommands");
 const { runOnlineCommand } = require("./cli/onlineCoreCommands");
 const { runGroupCoreCommand } = require("./cli/groupCoreCommands");
+const { listProjectRuntimes, getCurrentProjectRuntime } = require("./projects/registry");
+const { canonicalProjectRoot, buildProjectId } = require("./projects/projectId");
+const { getUfooPaths } = require("./ufoo/paths");
 
 function getPackageRoot() {
   return path.resolve(__dirname, "..");
@@ -161,6 +164,111 @@ function parseJsonObject(text, fallback = {}) {
   return parsed;
 }
 
+function formatProjectRuntimeLine(row, index = 0) {
+  const idx = String(index + 1).padStart(2, " ");
+  const name = String(row.project_name || "-");
+  const status = String(row.status || "-");
+  const seen = row.last_seen || "-";
+  const projectRoot = String(row.project_root || "-");
+  return `${idx}. ${name}  [${status}]  last_seen=${seen}  ${projectRoot}`;
+}
+
+function printProjectList(rows = [], write = (line) => console.log(line)) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    write("No projects found.");
+    return;
+  }
+  write("=== Projects ===");
+  rows.forEach((row, index) => {
+    write(formatProjectRuntimeLine(row, index));
+  });
+}
+
+function buildCurrentProjectFallback(projectRoot) {
+  let canonical = "";
+  let projectId = "";
+  try {
+    canonical = canonicalProjectRoot(projectRoot);
+  } catch {
+    canonical = path.resolve(projectRoot || process.cwd());
+  }
+  try {
+    projectId = buildProjectId(canonical);
+  } catch {
+    projectId = "";
+  }
+  const paths = getUfooPaths(canonical);
+  return {
+    version: 1,
+    project_id: projectId || null,
+    project_root: canonical,
+    project_name: path.basename(canonical) || canonical,
+    daemon_pid: null,
+    socket_path: paths.ufooSock,
+    status: "untracked",
+    last_seen: null,
+  };
+}
+
+function printCurrentProject(runtime, write = (line) => console.log(line)) {
+  const row = runtime || {};
+  write("=== Current Project ===");
+  write(`name: ${row.project_name || "-"}`);
+  write(`status: ${row.status || "-"}`);
+  write(`path: ${row.project_root || "-"}`);
+  write(`daemon_pid: ${row.daemon_pid || "-"}`);
+  write(`socket: ${row.socket_path || "-"}`);
+  write(`last_seen: ${row.last_seen || "-"}`);
+}
+
+function projectSwitchV1Error() {
+  const err = new Error("project switch is chat-only in v1");
+  err.code = "UFOO_PROJECT_SWITCH_CHAT_ONLY";
+  err.exitCode = 2;
+  return err;
+}
+
+function runProjectCommand({
+  subcommand = "list",
+  outputJson = false,
+  cwd = process.cwd(),
+  write = (line) => console.log(line),
+  writeError = (line) => console.error(line),
+} = {}) {
+  const sub = String(subcommand || "list").trim().toLowerCase();
+  try {
+    if (sub === "list") {
+      const rows = listProjectRuntimes({ validate: true, cleanupTmp: true });
+      if (outputJson) {
+        write(JSON.stringify(rows, null, 2));
+        return 0;
+      }
+      printProjectList(rows, write);
+      return 0;
+    }
+    if (sub === "current") {
+      const current = getCurrentProjectRuntime(cwd, { validate: true })
+        || buildCurrentProjectFallback(cwd);
+      if (outputJson) {
+        write(JSON.stringify(current, null, 2));
+        return 0;
+      }
+      printCurrentProject(current, write);
+      return 0;
+    }
+    if (sub === "switch") {
+      const err = projectSwitchV1Error();
+      writeError(err.message);
+      return err.exitCode || 2;
+    }
+    writeError("project requires list|current|switch subcommand");
+    return 1;
+  } catch (err) {
+    writeError(err.message || String(err));
+    return 1;
+  }
+}
+
 function normalizeReportPhase(action = "") {
   const value = String(action || "").trim().toLowerCase();
   if (value === "start") return "start";
@@ -244,9 +352,46 @@ async function runCli(argv) {
     program
       .command("chat")
       .description("Launch ufoo chat UI")
-      .action(() => {
+      .option("-g, --global", "Launch in global multi-project mode")
+      .action((opts) => {
         const repoRoot = getPackageRoot();
-        run(process.execPath, [path.join(repoRoot, "bin", "ufoo.js"), "chat"]);
+        const args = ["chat"];
+        if (opts.global === true) args.push("-g");
+        run(process.execPath, [path.join(repoRoot, "bin", "ufoo.js"), ...args]);
+      });
+    const project = program.command("project").description("Project runtime commands");
+    project
+      .command("list")
+      .description("List runtime projects discovered from global registry")
+      .option("--json", "Output as JSON")
+      .action((opts) => {
+        process.exitCode = runProjectCommand({
+          subcommand: "list",
+          outputJson: opts.json === true,
+          cwd: process.cwd(),
+        });
+      });
+    project
+      .command("current")
+      .description("Show current project runtime context")
+      .option("--json", "Output as JSON")
+      .action((opts) => {
+        process.exitCode = runProjectCommand({
+          subcommand: "current",
+          outputJson: opts.json === true,
+          cwd: process.cwd(),
+        });
+      });
+    project
+      .command("switch")
+      .description("Switch active project (chat-only in v1)")
+      .argument("<indexOrPath>", "Project index from list output or absolute path")
+      .action(() => {
+        process.exitCode = runProjectCommand({
+          subcommand: "switch",
+          outputJson: false,
+          cwd: process.cwd(),
+        });
       });
     program
       .command("launch")
@@ -1112,7 +1257,11 @@ async function runCli(argv) {
     console.log("  ufoo doctor");
     console.log("  ufoo status");
     console.log("  ufoo daemon --start|--stop|--status");
-    console.log("  ufoo chat");
+    console.log("  ufoo -g");
+    console.log("  ufoo chat [-g]");
+    console.log("  ufoo project list [--json]");
+    console.log("  ufoo project current [--json]");
+    console.log("  ufoo project switch <index|path>");
     console.log("  ufoo resume [nickname]");
     console.log("  ufoo recover [list [target] | run <target>] [--json]");
     console.log("  ufoo report <start|progress|done|error|list> [message] [--task <id>] [--agent <id>]");
@@ -1175,7 +1324,21 @@ async function runCli(argv) {
     return;
   }
   if (cmd === "chat") {
-    run(process.execPath, [path.join(repoRoot, "bin", "ufoo.js"), "chat"]);
+    const chatArgs = ["chat"];
+    if (rest.includes("-g") || rest.includes("--global")) {
+      chatArgs.push("-g");
+    }
+    run(process.execPath, [path.join(repoRoot, "bin", "ufoo.js"), ...chatArgs]);
+    return;
+  }
+  if (cmd === "project") {
+    const sub = String(rest[0] || "list").trim().toLowerCase();
+    const outputJson = rest.includes("--json");
+    process.exitCode = runProjectCommand({
+      subcommand: sub,
+      outputJson,
+      cwd: process.cwd(),
+    });
     return;
   }
   if (cmd === "resume") {

package/src/daemon/index.js

@@ -11,6 +11,7 @@ const { generateInstanceId, subscriberToSafeName } = require("../bus/utils");
 const { createDaemonIpcServer } = require("./ipcServer");
 const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../shared/eventContract");
 const { getUfooPaths } = require("../ufoo/paths");
+const { upsertProjectRuntime, markProjectStopped } = require("../projects/registry");
 const { scheduleProviderSessionProbe, loadProviderSessionCache } = require("./providerSessions");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonCronController } = require("./cronOps");
@@ -25,6 +26,7 @@ let providerSessions = null;
 let probeHandles = new Map();
 let daemonCronController = null;
 let daemonGroupOrchestrator = null;
+const PROJECT_RUNTIME_HEARTBEAT_MS = 10 * 1000;
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -323,7 +325,10 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
           continue;
         }
         // eslint-disable-next-line no-await-in-loop
-        const launchResult = await launchAgent(projectRoot, agent, count, nickname, processManager);
+        const launchResult = await launchAgent(projectRoot, agent, count, nickname, processManager, {
+          launchScope: op.launch_scope || "",
+          terminalApp: op.terminal_app || "",
+        });
         if (launchResult.mode === "internal" && launchResult.subscriberIds && launchResult.subscriberIds.length > 0) {
           const probeAgentType = agent === "codex"
             ? "codex"
@@ -359,6 +364,7 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
           agent,
           count,
           nickname: nickname || undefined,
+          launch_scope: launchResult.launchScope || undefined,
           subscriber_ids: Array.isArray(launchResult.subscriberIds) ? launchResult.subscriberIds.slice() : [],
         });
         if (nickname) {
@@ -372,8 +378,15 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
         results.push({ action: "launch", ok: false, agent, count, error: err.message });
       }
     } else if (op.action === "close") {
-      const ok = await closeAgent(projectRoot, op.agent_id);
-      results.push({ action: "close", ok, agent_id: op.agent_id });
+      const closeResult = await closeAgent(projectRoot, op.agent_id);
+      const normalizedClose = closeResult && typeof closeResult === "object"
+        ? closeResult
+        : { ok: Boolean(closeResult) };
+      results.push({
+        action: "close",
+        agent_id: op.agent_id,
+        ...normalizedClose,
+      });
     } else if (op.action === "rename") {
       const agentId = op.agent_id || "";
       const nickname = op.nickname || "";
@@ -669,6 +682,19 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
   const log = (msg) => {
     logFile.write(`[daemon] ${new Date().toISOString()} ${msg}\n`);
   };
+  const publishProjectRuntime = (status = "running") => {
+    try {
+      upsertProjectRuntime({
+        projectRoot,
+        daemonPid: process.pid,
+        socketPath: socketPath(projectRoot),
+        status,
+        lastSeen: new Date().toISOString(),
+      });
+    } catch (err) {
+      log(`project runtime update failed (${status}): ${err.message || err}`);
+    }
+  };
 
   // 创建进程管理器 - daemon 作为父进程监控所有 internal agents
   const processManager = new AgentProcessManager(projectRoot);
@@ -924,7 +950,9 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         const closeResult = opsResults.find((r) => r.action === "close");
         const ok = closeResult ? closeResult.ok !== false : true;
         const reply = ok
-          ? `Closed ${agent_id}`
+          ? (closeResult && closeResult.already_stopped
+            ? `Closed ${agent_id} (already stopped)`
+            : `Closed ${agent_id}`)
           : `Close failed: ${closeResult?.error || "unknown error"}`;
         socket.write(
           `${JSON.stringify({
@@ -952,7 +980,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     }
     if (req.type === IPC_REQUEST_TYPES.LAUNCH_AGENT) {
       log(`launch_agent received: agent=${req.agent} count=${req.count}`);
-      const { agent, count, nickname } = req;
+      const { agent, count, nickname, launch_scope, terminal_app } = req;
       const normalizedAgent = normalizeLaunchAgent(agent);
       if (!normalizedAgent) {
         socket.write(
@@ -971,6 +999,8 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         agent: normalizedAgent,
         count: finalCount,
         nickname: nickname || "",
+        launch_scope: launch_scope || "",
+        terminal_app: terminal_app || "",
       };
       try {
         const opsResults = await handleOps(projectRoot, [op], processManager);
@@ -1515,6 +1545,10 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
   };
 
   ipcServer.listen(socketPath(projectRoot));
+  publishProjectRuntime("running");
+  const runtimeHeartbeat = setInterval(() => {
+    publishProjectRuntime("running");
+  }, PROJECT_RUNTIME_HEARTBEAT_MS);
 
   log(`Started pid=${process.pid}`);
 
@@ -1619,8 +1653,17 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     }, 1500);
   }
 
+  let cleanedUp = false;
   const cleanup = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
     log(`Shutting down daemon (managed agents: ${processManager.count()})`);
+    clearInterval(runtimeHeartbeat);
+    try {
+      markProjectStopped(projectRoot);
+    } catch {
+      // ignore cleanup errors
+    }
 
     if (daemonCronController) {
       daemonCronController.stopAll();
@@ -1706,6 +1749,12 @@ function stopDaemon(projectRoot) {
     // ignore
   }
 
+  try {
+    markProjectStopped(projectRoot);
+  } catch {
+    // ignore
+  }
+
   return killed;
 }
 

package/src/daemon/ipcServer.js

@@ -28,6 +28,7 @@ function createDaemonIpcServer(options = {}) {
   };
 
   let lastActiveJson = "";
+  let lastMetaJson = "";
   const statusSyncInterval = setInterval(() => {
     if (sockets.size === 0) return;
     try {
@@ -38,8 +39,12 @@ function createDaemonIpcServer(options = {}) {
     try {
       const status = buildStatus(projectRoot);
       const currentActiveJson = JSON.stringify(status.active);
-      if (currentActiveJson !== lastActiveJson) {
+      const currentMetaJson = JSON.stringify(
+        (status.active_meta || []).map((m) => `${m.id}:${m.activity_state || ""}`)
+      );
+      if (currentActiveJson !== lastActiveJson || currentMetaJson !== lastMetaJson) {
         lastActiveJson = currentActiveJson;
+        lastMetaJson = currentMetaJson;
         sendToSockets({ type: IPC_RESPONSE_TYPES.STATUS, data: status });
         log(`status sync: active agents changed to ${status.active.length}`);
       }