u-foo 3.0.21 → 3.0.23

package/src/app/cli/run.js

@@ -3,7 +3,11 @@ const os = require("os");
 const { spawnSync } = require("child_process");
 const net = require("net");
 const fs = require("fs");
-const { socketPath, isRunning } = require("../../runtime/daemon");
+const { isRunning } = require("../../runtime/daemon");
+const {
+  resolveDaemonEndpoint,
+  routeDaemonRequest,
+} = require("../../runtime/daemon/endpoint");
 const { runBusCoreCommand } = require("./busCoreCommands");
 const { runCtxCommand } = require("./ctxCoreCommands");
 const { runOnlineCommand } = require("./onlineCoreCommands");
@@ -59,10 +63,24 @@ async function connectWithRetry(sockPath, retries, delayMs) {
 }
 
 async function ensureDaemonRunning(projectRoot) {
-  if (isRunning(projectRoot)) return;
+  const endpoint = resolveDaemonEndpoint(projectRoot);
+  const daemonRoot = endpoint.scope === "global"
+    ? endpoint.controllerRoot
+    : endpoint.projectRoot;
+  if (isRunning(daemonRoot)) return;
   const repoRoot = getPackageRoot();
-  run(resolveNodeExecutable(), [path.join(repoRoot, "bin", "ufoo.js"), "daemon", "start"]);
-  const sock = socketPath(projectRoot);
+  run(
+    resolveNodeExecutable(),
+    [path.join(repoRoot, "bin", "ufoo.js"), "daemon", "start"],
+    {
+      cwd: daemonRoot,
+      env: {
+        ...process.env,
+        UFOO_DAEMON_TOPOLOGY: endpoint.topology,
+      },
+    }
+  );
+  const sock = endpoint.socketPath;
   for (let i = 0; i < 30; i += 1) {
     if (fs.existsSync(sock)) {
       return;
@@ -74,7 +92,8 @@ async function ensureDaemonRunning(projectRoot) {
 }
 
 async function sendDaemonRequest(projectRoot, payload) {
-  const sock = socketPath(projectRoot);
+  const endpoint = resolveDaemonEndpoint(projectRoot);
+  const sock = endpoint.socketPath;
   const client = await connectWithRetry(sock, 25, 200);
   if (!client) {
     throw new Error("Failed to connect to ufoo daemon");
@@ -125,7 +144,7 @@ async function sendDaemonRequest(projectRoot, payload) {
       cleanup();
       reject(err);
     });
-    client.write(`${JSON.stringify(payload)}\n`);
+    client.write(`${JSON.stringify(routeDaemonRequest(endpoint, payload))}\n`);
   });
 }
 
@@ -186,6 +205,17 @@ function collectHostLaunchRequestContext(env = process.env) {
   return context;
 }
 
+function collectTmuxLaunchRequestContext(env = process.env) {
+  const tmuxTarget = String(env.UFOO_TMUX_TARGET || "").trim();
+  const tmuxPane = String(env.UFOO_TMUX_PANE || env.TMUX_PANE || "").trim();
+  const tmuxSession = String(env.UFOO_TMUX_SESSION || "").trim();
+  const context = {};
+  if (tmuxTarget) context.tmux_target = tmuxTarget;
+  if (tmuxPane) context.tmux_pane = tmuxPane;
+  if (tmuxSession) context.tmux_session = tmuxSession;
+  return context;
+}
+
 function collectOption(value, previous) {
   const next = Array.isArray(previous) ? previous.slice() : [];
   const parts = String(value || "")
@@ -567,10 +597,12 @@ async function runCli(argv) {
       .option("--start", "Start daemon")
       .option("--stop", "Stop daemon")
       .option("--status", "Check daemon status")
+      .option("--topology <mode>", "Set machine-wide daemon topology: project, hybrid, or global")
       .action((opts) => {
         const repoRoot = getPackageRoot();
         const args = ["daemon"];
-        if (opts.start) args.push("start");
+        if (opts.topology) args.push("topology", opts.topology);
+        else if (opts.start) args.push("start");
         else if (opts.stop) args.push("stop");
         else if (opts.status) args.push("status");
         run(process.execPath, [path.join(repoRoot, "bin", "ufoo.js"), ...args]);
@@ -769,6 +801,7 @@ async function runCli(argv) {
             prompt_profile: opts.profile || "",
             count: 1,
             ...collectHostLaunchRequestContext(),
+            ...collectTmuxLaunchRequestContext(),
           });
           const reply = resp?.data?.reply || `Launching ${normalizedAgent} agent...`;
           console.log(reply);
@@ -832,6 +865,7 @@ async function runCli(argv) {
             count: 1,
             launch_scope: scope,
             ...collectHostLaunchRequestContext(),
+            ...collectTmuxLaunchRequestContext(),
           });
           console.log(resp?.data?.reply || `Launched ${agent} role ${promptProfile}`);
         } catch (err) {
@@ -1200,6 +1234,7 @@ async function runCli(argv) {
             instance: opts.instance || "",
             dry_run: opts.dryRun === true,
             ...collectHostLaunchRequestContext(),
+            ...collectTmuxLaunchRequestContext(),
           });
           if (opts.json) {
             console.log(JSON.stringify(resp?.data || {}, null, 2));
@@ -2175,6 +2210,7 @@ async function runCli(argv) {
             instance,
             dry_run: dryRun,
             ...collectHostLaunchRequestContext(),
+            ...collectTmuxLaunchRequestContext(),
           });
           if (outputJson) {
             console.log(JSON.stringify(resp?.data || {}, null, 2));
@@ -2311,6 +2347,7 @@ async function runCli(argv) {
             count: 1,
             launch_scope: scope,
             ...collectHostLaunchRequestContext(),
+            ...collectTmuxLaunchRequestContext(),
           });
           console.log(resp?.data?.reply || `Launched ${agent} role ${profile}`);
           return;

package/src/config.js

@@ -34,6 +34,7 @@ const SETTINGS_MODEL_DEFAULTS = Object.freeze({
 
 const DEFAULT_CONFIG = {
   launchMode: "auto",
+  daemonTopology: "global",
   agentProvider: "codex-cli",
   controllerMode: "main",
   mcpPort: 47631,
@@ -67,6 +68,14 @@ function normalizeLaunchMode(value) {
   return "auto";
 }
 
+function normalizeDaemonTopology(value) {
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === "project") return "project";
+  if (raw === "hybrid") return "hybrid";
+  if (raw === "global") return "global";
+  return DEFAULT_CONFIG.daemonTopology;
+}
+
 function normalizeAgentProvider(value) {
   if (value === "claude-cli") return "claude-cli";
   if (value === "agy-cli" || value === "agy" || value === "antigravity") return "agy-cli";
@@ -175,6 +184,7 @@ function loadJsonSafe(filePath) {
 function loadConfig(projectRoot) {
   try {
     const raw = loadJsonSafe(configPath(projectRoot));
+    const globalRaw = loadJsonSafe(globalConfigPath());
     const agentProvider = normalizeAgentProvider(raw.agentProvider);
     const routerProvider = normalizeModel(
       raw.routerProvider,
@@ -184,6 +194,11 @@ function loadConfig(projectRoot) {
       ...DEFAULT_CONFIG,
       ...raw,
       launchMode: normalizeLaunchMode(raw.launchMode),
+      daemonTopology: normalizeDaemonTopology(
+        Object.prototype.hasOwnProperty.call(raw, "daemonTopology")
+          ? raw.daemonTopology
+          : globalRaw.daemonTopology
+      ),
       agentProvider,
       agentModel: normalizeModel(raw.agentModel, defaultAgentModelForProvider(agentProvider)),
       routerProvider,
@@ -238,11 +253,22 @@ function saveConfig(projectRoot, config) {
     ...existing,
     ...projectUpdates,
   };
+  const hasProjectDaemonTopology =
+    Object.prototype.hasOwnProperty.call(existing, "daemonTopology")
+    || Object.prototype.hasOwnProperty.call(projectUpdates, "daemonTopology");
   // Remove any stale ucode fields from project config
   for (const f of UCODE_FIELDS) {
     delete merged[f];
   }
   merged.launchMode = normalizeLaunchMode(merged.launchMode);
+  if (hasProjectDaemonTopology) {
+    merged.daemonTopology = normalizeDaemonTopology(merged.daemonTopology);
+  } else {
+    // Topology is a machine-wide rollout setting unless a project explicitly
+    // opts into an override. Do not persist the default and accidentally pin
+    // this project to project-daemon mode forever.
+    delete merged.daemonTopology;
+  }
   merged.agentProvider = normalizeAgentProvider(merged.agentProvider);
   merged.agentModel = typeof merged.agentModel === "string" ? merged.agentModel.trim() : "";
   merged.routerProvider = typeof merged.routerProvider === "string" ? merged.routerProvider.trim() : "";
@@ -286,13 +312,35 @@ function saveGlobalUcodeConfig(updates = {}) {
   return merged;
 }
 
+function loadGlobalDaemonConfig() {
+  const raw = loadJsonSafe(globalConfigPath());
+  return {
+    daemonTopology: normalizeDaemonTopology(raw.daemonTopology),
+  };
+}
+
+function saveGlobalDaemonConfig(updates = {}) {
+  const target = globalConfigPath();
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const existing = loadJsonSafe(target);
+  const merged = { ...existing };
+  if (Object.prototype.hasOwnProperty.call(updates, "daemonTopology")) {
+    merged.daemonTopology = normalizeDaemonTopology(updates.daemonTopology);
+  }
+  fs.writeFileSync(target, JSON.stringify(merged, null, 2));
+  return loadGlobalDaemonConfig();
+}
+
 module.exports = {
   SETTINGS_MODEL_DEFAULTS,
   loadConfig,
   saveConfig,
   loadGlobalUcodeConfig,
   saveGlobalUcodeConfig,
+  loadGlobalDaemonConfig,
+  saveGlobalDaemonConfig,
   normalizeLaunchMode,
+  normalizeDaemonTopology,
   normalizeAgentProvider,
   providerKey,
   sameModelProvider,

package/src/runtime/contracts/eventContract.js

@@ -24,6 +24,7 @@ const IPC_REQUEST_TYPES = {
   CONTROL_PLANE_CANCEL: "control_plane_cancel",
   MCP_STATUS: "mcp_status",
   MCP_RESTART: "mcp_restart",
+  CLOSE_PROJECT_RUNTIME: "close_project_runtime",
 };
 
 const IPC_RESPONSE_TYPES = {

package/src/runtime/daemon/agentProcessManager.js

@@ -5,7 +5,7 @@ const EventBus = require("../../coordination/bus");
 class AgentProcessManager {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.processes = new Map(); // subscriber_id -> child_process
+    this.processes = new Map(); // subscriber_id -> { child, onExit, onError }
   }
 
   /**
@@ -14,9 +14,7 @@ class AgentProcessManager {
   register(subscriberId, childProcess) {
     if (!subscriberId || !childProcess) return;
 
-    this.processes.set(subscriberId, childProcess);
-
-    childProcess.on("exit", (code, signal) => {
+    const onExit = (code, signal) => {
       this.processes.delete(subscriberId);
 
       // 自动清理 bus 状态
@@ -32,19 +30,26 @@ class AgentProcessManager {
       } catch (err) {
         console.error(`[daemon] Failed to cleanup ${subscriberId}:`, err.message);
       }
-    });
+    };
 
-    childProcess.on("error", (err) => {
+    const onError = (err) => {
       console.error(`[daemon] Agent ${subscriberId} error:`, err.message);
       this.processes.delete(subscriberId);
+    };
+    this.processes.set(subscriberId, {
+      child: childProcess,
+      onExit,
+      onError,
     });
+    childProcess.on("exit", onExit);
+    childProcess.on("error", onError);
   }
 
   /**
    * 获取运行中的进程
    */
   get(subscriberId) {
-    return this.processes.get(subscriberId);
+    return this.processes.get(subscriberId)?.child;
   }
 
   /**
@@ -57,13 +62,28 @@ class AgentProcessManager {
   /**
    * 清理所有子进程
    */
-  cleanup() {
-    for (const [subscriberId, child] of this.processes.entries()) {
-      try {
-        child.kill("SIGTERM");
-        console.log(`[daemon] Killed agent ${subscriberId}`);
-      } catch {
-        // ignore
+  cleanup(options = {}) {
+    const terminate = options.terminate !== false;
+    for (const [subscriberId, entry] of this.processes.entries()) {
+      const { child, onExit, onError } = entry;
+      if (terminate) {
+        try {
+          child.kill("SIGTERM");
+          console.log(`[daemon] Killed agent ${subscriberId}`);
+        } catch {
+          // ignore
+        }
+      } else {
+        // Global-daemon ownership is logical, not a parent/child lifetime
+        // contract. Let the runner survive daemon replacement and reconnect
+        // through its durable bus state.
+        try {
+          child.removeListener("exit", onExit);
+          child.removeListener("error", onError);
+          if (typeof child.unref === "function") child.unref();
+        } catch {
+          // best-effort detachment
+        }
       }
     }
     this.processes.clear();

package/src/runtime/daemon/controlPlaneService.js

@@ -11,7 +11,11 @@ const {
 const { subscriberToSafeName } = require("../../coordination/bus/utils");
 const { normalizeReportInput } = require("../../coordination/report/store");
 const { enqueueAgentReport } = require("./reportControlBus");
-const { isRunning, socketPath } = require("./index");
+const { isRunning } = require("./index");
+const {
+  resolveDaemonEndpoint,
+  routeDaemonRequest,
+} = require("./endpoint");
 const { IPC_REQUEST_TYPES } = require("../contracts/eventContract");
 const {
   applyProjectNicknamePrefix,
@@ -128,11 +132,16 @@ function assertAgentHandle(bus, subscriber, args = {}, options = {}) {
 }
 
 function notifyDaemonRefresh(projectRoot) {
-  if (!isRunning(projectRoot)) return;
-  const sock = socketPath(projectRoot);
+  const endpoint = resolveDaemonEndpoint(projectRoot);
+  const daemonRoot = endpoint.scope === "global"
+    ? endpoint.controllerRoot
+    : endpoint.projectRoot;
+  if (!isRunning(daemonRoot)) return;
   try {
-    const client = net.createConnection(sock, () => {
-      client.write(`${JSON.stringify({ type: IPC_REQUEST_TYPES.REFRESH_STATUS })}\n`);
+    const client = net.createConnection(endpoint.socketPath, () => {
+      client.write(`${JSON.stringify(routeDaemonRequest(endpoint, {
+        type: IPC_REQUEST_TYPES.REFRESH_STATUS,
+      }))}\n`);
       client.end();
     });
     client.on("error", () => {});

package/src/runtime/daemon/endpoint.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const fs = require("fs");
+
+const {
+  loadConfig,
+  normalizeDaemonTopology,
+} = require("../../config");
+const { getUfooPaths } = require("../../coordination/state/paths");
+const {
+  normalizeProjectRoot,
+  resolveGlobalControllerProjectRoot,
+} = require("../projects");
+
+function isSocketFile(filePath) {
+  try {
+    return fs.statSync(filePath).isSocket();
+  } catch {
+    return false;
+  }
+}
+
+function resolveEffectiveDaemonTopology(projectRoot, options = {}) {
+  const config = options.config || loadConfig(projectRoot);
+  return normalizeDaemonTopology(
+    options.topology
+    || process.env.UFOO_DAEMON_TOPOLOGY
+    || config.daemonTopology
+  );
+}
+
+function resolveDaemonEndpoint(projectRoot, options = {}) {
+  const canonicalRoot = normalizeProjectRoot(projectRoot);
+  const controllerRoot = normalizeProjectRoot(
+    options.controllerRoot || resolveGlobalControllerProjectRoot()
+  );
+  const topology = resolveEffectiveDaemonTopology(canonicalRoot, options);
+  const projectSocket = getUfooPaths(canonicalRoot).ufooSock;
+  const globalSocket = getUfooPaths(controllerRoot).ufooSock;
+  let scope = "project";
+  let sockPath = projectSocket;
+
+  if (canonicalRoot === controllerRoot || topology === "global") {
+    scope = "global";
+    sockPath = globalSocket;
+  } else if (topology === "hybrid") {
+    const preferCompatibilitySocket = options.preferCompatibilitySocket !== false;
+    if (!preferCompatibilitySocket || !isSocketFile(projectSocket)) {
+      scope = "global";
+      sockPath = globalSocket;
+    }
+  }
+
+  return {
+    topology,
+    scope,
+    socketPath: sockPath,
+    projectRoot: canonicalRoot,
+    controllerRoot,
+    routeProjectRoot: scope === "global" && canonicalRoot !== controllerRoot
+      ? canonicalRoot
+      : "",
+  };
+}
+
+function routeDaemonRequest(endpoint, request = {}) {
+  if (!endpoint || !endpoint.routeProjectRoot) return { ...request };
+  return {
+    ...request,
+    project_root: request.project_root || request.projectRoot || endpoint.routeProjectRoot,
+  };
+}
+
+module.exports = {
+  isSocketFile,
+  resolveEffectiveDaemonTopology,
+  resolveDaemonEndpoint,
+  routeDaemonRequest,
+};