u-foo 3.0.20 → 3.0.22

package/README.md

@@ -18,8 +18,8 @@ Package: [u-foo on npm](https://www.npmjs.com/package/u-foo)
 ## Highlights
 
 - One TUI dashboard for launching, watching, messaging, and resuming agents.
-- Project daemon over `.ufoo/run/ufoo.sock` for launch/resume, reports, groups,
-  cron, and controller routing.
+- One user-scoped daemon over `~/.ufoo/run/ufoo.sock`, hosting isolated project
+  runtimes for launch/resume, reports, groups, cron, and controller routing.
 - Project-local event bus for agent-to-agent messages, wakeups, queue checks,
   and activation.
 - Shared context primitives: decisions, durable memory, prompt history, reports,
@@ -127,8 +127,9 @@ singleton listener with `ufoo mcp status` and `ufoo mcp restart`.
 ```text
 ufoo / ufoo chat
   -> src/app/chat + src/ui/rustChatHost + crates/ufoo-tui
-  -> project daemon over .ufoo/run/ufoo.sock
-  -> runtime daemon launch/resume/recover/reports/cron/groups
+  -> global daemon over ~/.ufoo/run/ufoo.sock
+  -> isolated ProjectRuntime selected by project_root
+  -> runtime launch/resume/recover/reports/cron/groups
   -> orchestration router, group templates, solo roles
   -> agents launch/providers/internal/controller/activity
   -> coordination bus/context/memory/history/report/state/status
@@ -139,10 +140,14 @@ ufoo mcp stdio proxy ----------------------+
                                            -> home-scoped global controller daemon
                                               (one MCP listener and tool router)
   -> ~/.ufoo/projects/runtime
-  -> ProjectRuntimeGateway
-  -> selected project daemon for bus/report/activity/wait state
+  -> managed ProjectRuntimeGateway
+  -> selected in-process ProjectRuntime for bus/report/activity/wait state
 ```
 
+Global topology is the default. `ufoo daemon --topology hybrid` temporarily
+enables project compatibility sockets, and `--topology project` selects the
+legacy per-project daemon rollback path.
+
 ### Agent Delivery Modes
 
 ufoo supports two Agent delivery modes, selected only from the host Agent's
@@ -182,7 +187,8 @@ ufoo -g
 ```
 
 `ufoo` opens the current project chat. `ufoo -g` opens global chat for switching
-between registered projects. The project daemon is started as needed.
+between registered projects. The global daemon starts once and project runtimes
+activate lazily.
 
 ### Chat Commands
 

package/README.zh-CN.md

@@ -17,8 +17,8 @@ npm 包：[u-foo](https://www.npmjs.com/package/u-foo)
 ## 亮点
 
 - 一个 TUI 仪表盘，用来启动、观察、消息通知和恢复多个 Agent。
-- 项目 daemon 通过 `.ufoo/run/ufoo.sock` 管理启动/恢复、report、group、
-  cron 和 controller 路由。
+- 唯一的用户级 daemon 通过 `~/.ufoo/run/ufoo.sock` 托管隔离的项目
+  runtime，管理启动/恢复、report、group、cron 和 controller 路由。
 - 项目内事件总线支持 Agent 间消息、唤醒、队列检查和终端激活。
 - 共享上下文能力：decision、durable memory、prompt history、report 和
   agent registry state。
@@ -116,8 +116,9 @@ Agent 注册或项目状态。用 `ufoo mcp status` 检查唯一 listener，用
 ```text
 ufoo / ufoo chat
   -> src/app/chat + src/ui/rustChatHost + crates/ufoo-tui
-  -> project daemon over .ufoo/run/ufoo.sock
-  -> runtime daemon launch/resume/recover/reports/cron/groups
+  -> global daemon over ~/.ufoo/run/ufoo.sock
+  -> isolated ProjectRuntime selected by project_root
+  -> runtime launch/resume/recover/reports/cron/groups
   -> orchestration router, group templates, solo roles
   -> agents launch/providers/internal/controller/activity
   -> coordination bus/context/memory/history/report/state/status
@@ -128,10 +129,13 @@ ufoo mcp stdio proxy ----------------------+
                                            -> home-scoped global controller daemon
   -> one MCP listener and tool router
   -> ~/.ufoo/projects/runtime
-  -> ProjectRuntimeGateway
-  -> selected project daemon for bus/report/activity/wait state
+  -> managed ProjectRuntimeGateway
+  -> selected in-process ProjectRuntime for bus/report/activity/wait state
 ```
 
+默认使用 global topology。`ufoo daemon --topology hybrid` 可临时启用项目
+兼容 socket，`--topology project` 则切回旧的逐项目 daemon 回滚路径。
+
 ### Agent 消息投递模式
 
 ufoo 支持两种 Agent 投递模式，只根据启动辅助 terminal 之前，宿主 Agent
@@ -166,7 +170,7 @@ ufoo -g
 ```
 
 `ufoo` 打开当前项目 chat。`ufoo -g` 打开全局 chat，用于在已注册项目之间
-切换。项目 daemon 会按需启动。
+切换。全局 daemon 只启动一次，各项目 runtime 按需激活。
 
 ### Chat 内命令
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "3.0.20",
+  "version": "3.0.22",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/agents/launch/launcher.js

@@ -13,6 +13,10 @@ const { createActivityStatePublisher } = require("../activity/activityStatePubli
 const { reconcileDetectorOwnedActivity } = require("../activity/activityReconcile");
 const { detectLaunchEnvironment } = require("./launchEnvironment");
 const { getUfooPaths } = require("../../coordination/state/paths");
+const {
+  resolveDaemonEndpoint,
+  routeDaemonRequest,
+} = require("../../runtime/daemon/endpoint");
 const { createTerminalAdapterRouter } = require("../../runtime/terminal/adapterRouter");
 const { probeHostCapabilities } = require("../../runtime/terminal/adapters/hostAdapter");
 const PtyWrapper = require("./ptyWrapper");
@@ -43,7 +47,10 @@ async function connectWithRetry(sockPath, retries, delayMs) {
   return null;
 }
 
-async function notifyDaemonAgentReady(daemonSockPath, subscriberId, agentPid) {
+async function notifyDaemonAgentReady(daemonEndpoint, subscriberId, agentPid) {
+  const daemonSockPath = typeof daemonEndpoint === "string"
+    ? daemonEndpoint
+    : daemonEndpoint && daemonEndpoint.socketPath;
   if (!daemonSockPath || !subscriberId) return false;
   const parsedAgentPid = Number.parseInt(agentPid, 10);
   if (!Number.isFinite(parsedAgentPid) || parsedAgentPid <= 0) return false;
@@ -58,11 +65,16 @@ async function notifyDaemonAgentReady(daemonSockPath, subscriberId, agentPid) {
       return false;
     }
 
-    daemonSock.write(`${JSON.stringify({
+    const request = {
       type: IPC_REQUEST_TYPES.AGENT_READY,
       subscriberId,
       agentPid: parsedAgentPid,
-    })}\n`);
+    };
+    daemonSock.write(`${JSON.stringify(
+      typeof daemonEndpoint === "string"
+        ? request
+        : routeDaemonRequest(daemonEndpoint, request)
+    )}\n`);
     daemonSock.end();
 
     if (process.env.UFOO_DEBUG) {
@@ -366,9 +378,13 @@ class AgentLauncher {
    * 确保 daemon 正在运行
    */
   async ensureDaemon() {
-    const paths = getUfooPaths(this.cwd);
+    const endpoint = resolveDaemonEndpoint(this.cwd);
+    const daemonRoot = endpoint.scope === "global"
+      ? endpoint.controllerRoot
+      : endpoint.projectRoot;
+    const paths = getUfooPaths(daemonRoot);
     const pidFile = paths.ufooDaemonPid;
-    const sockFile = paths.ufooSock;
+    const sockFile = endpoint.socketPath;
 
     const existingProbe = await probeDaemonSocket(sockFile);
     if (existingProbe.ok) return "running";
@@ -377,30 +393,36 @@ class AgentLauncher {
       return "running";
     }
 
-    // Stale daemon runtime markers can block restart with false-positive "running".
-    // Clean local runtime markers only when socket probe failed.
-    try {
-      if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile);
-    } catch {
-      // ignore
-    }
-    try {
-      if (fs.existsSync(sockFile)) fs.unlinkSync(sockFile);
-    } catch {
-      // ignore
-    }
-    try {
-      const lockFile = path.join(paths.runDir, "daemon.lock");
-      if (fs.existsSync(lockFile)) fs.unlinkSync(lockFile);
-    } catch {
-      // ignore
+    if (endpoint.scope === "project") {
+      // Stale project-daemon markers can block the legacy fallback. A wrapper
+      // must never unlink the machine-wide global daemon's control files.
+      try {
+        if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile);
+      } catch {
+        // ignore
+      }
+      try {
+        if (fs.existsSync(sockFile)) fs.unlinkSync(sockFile);
+      } catch {
+        // ignore
+      }
+      try {
+        const lockFile = path.join(paths.runDir, "daemon.lock");
+        if (fs.existsSync(lockFile)) fs.unlinkSync(lockFile);
+      } catch {
+        // ignore
+      }
     }
 
     // Start daemon using correct command
     spawnSync("ufoo", ["daemon", "start"], {
-      cwd: this.cwd,
+      cwd: daemonRoot,
       stdio: "ignore",
       detached: true,
+      env: {
+        ...process.env,
+        UFOO_DAEMON_TOPOLOGY: endpoint.topology,
+      },
     });
 
     // Wait for daemon socket to be ready and reachable
@@ -426,7 +448,8 @@ class AgentLauncher {
    * 通过 daemon socket 注册 agent
    */
   async registerWithDaemon(nickname) {
-    const sockFile = getUfooPaths(this.cwd).ufooSock;
+    const endpoint = resolveDaemonEndpoint(this.cwd);
+    const sockFile = endpoint.socketPath;
     const client = await connectWithRetry(sockFile, 25, 200);
     if (!client) {
       throw new Error("Failed to connect to ufoo daemon");
@@ -541,7 +564,7 @@ class AgentLauncher {
         }
       });
 
-      client.write(`${JSON.stringify(req)}\n`);
+      client.write(`${JSON.stringify(routeDaemonRequest(endpoint, req))}\n`);
     });
   }
 
@@ -560,8 +583,8 @@ class AgentLauncher {
     });
 
     if (resolveLaunchMode() === "host" && child.pid) {
-      const daemonSockPath = getUfooPaths(this.cwd).ufooSock;
-      notifyDaemonAgentReady(daemonSockPath, subscriberId, child.pid).catch(() => {});
+      const daemonEndpoint = resolveDaemonEndpoint(this.cwd);
+      notifyDaemonAgentReady(daemonEndpoint, subscriberId, child.pid).catch(() => {});
     }
 
     child.on("error", (err) => {
@@ -689,7 +712,7 @@ class AgentLauncher {
             subscriber: subscriberId,
             projectRoot: this.cwd,
           });
-          const daemonSockPath = getUfooPaths(this.cwd).ufooSock;
+          const daemonEndpoint = resolveDaemonEndpoint(this.cwd);
           launcherActivityDetector.onChange((newState, oldState) => {
             const snap = launcherActivityDetector.getState();
             launcherPublisher.publish(newState, {
@@ -769,7 +792,7 @@ class AgentLauncher {
               await injectPtyCommand(wrapper, this.agentType, startupBootstrapText, "startup-bootstrap");
             }
 
-            await notifyDaemonAgentReady(daemonSockPath, subscriberId, wrapper.pty ? wrapper.pty.pid : 0);
+            await notifyDaemonAgentReady(daemonEndpoint, subscriberId, wrapper.pty ? wrapper.pty.pid : 0);
           });
 
           // Fallback：如果10秒后还没检测到ready，强制标记为ready

package/src/app/chat/commandExecutor.js

@@ -110,6 +110,17 @@ function collectTerminalLaunchRequestContext(resolveTerminalApp = defaultResolve
   return {};
 }
 
+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;
+}
+
 async function withCapturedConsole(capture, fn) {
   const originalLog = console.log;
   const originalError = console.error;
@@ -707,6 +718,7 @@ function createCommandExecutor(options = {}) {
         launch_scope: launchScope,
         ...collectHostLaunchRequestContext(),
         ...collectTerminalLaunchRequestContext(resolveTerminalApp),
+        ...collectTmuxLaunchRequestContext(),
       };
       send(request);
       schedule(requestStatus, 1000);
@@ -849,6 +861,7 @@ function createCommandExecutor(options = {}) {
         launch_scope: launchScope,
         ...collectHostLaunchRequestContext(),
         ...collectTerminalLaunchRequestContext(resolveTerminalApp),
+        ...collectTmuxLaunchRequestContext(),
       });
       schedule(requestStatus, 1000);
     } catch (err) {
@@ -1350,6 +1363,7 @@ function createCommandExecutor(options = {}) {
         dry_run: dryRun,
         ...collectHostLaunchRequestContext(),
         ...collectTerminalLaunchRequestContext(resolveTerminalApp),
+        ...collectTmuxLaunchRequestContext(),
       });
       schedule(requestStatus, 1000);
       return;
@@ -2018,4 +2032,5 @@ module.exports = {
   createCommandExecutor,
   collectHostLaunchRequestContext,
   collectTerminalLaunchRequestContext,
+  collectTmuxLaunchRequestContext,
 };

package/src/app/chat/daemonConnection.js

@@ -7,10 +7,12 @@ function createDaemonConnection(options = {}) {
     queueStatusLine,
     resolveStatusLine,
     logMessage,
+    transformRequest: transformRequestOption = (request) => request,
     switchConnectionTimeoutMs = 18000,
   } = options;
 
   let connectClient = connectClientOption;
+  let transformRequest = transformRequestOption;
   let client = null;
   let reconnectPromise = null;
   let exitRequested = false;
@@ -59,7 +61,7 @@ function createDaemonConnection(options = {}) {
     if (!client || client.destroyed) return;
     while (pendingRequests.length > 0) {
       const req = pendingRequests.shift();
-      client.write(`${JSON.stringify(req)}\n`);
+      client.write(`${JSON.stringify(transformRequest(req))}\n`);
     }
   }
 
@@ -172,6 +174,9 @@ function createDaemonConnection(options = {}) {
         return { ok: false, error: "Failed to connect target daemon" };
       }
       connectClient = nextConnectClient;
+      if (typeof next.transformRequest === "function") {
+        transformRequest = next.transformRequest;
+      }
       attachClient(nextClient);
       if (next.callRequestStatus !== false) {
         requestStatus();
@@ -196,7 +201,7 @@ function createDaemonConnection(options = {}) {
       void ensureConnected();
       return;
     }
-    client.write(`${JSON.stringify(req)}\n`);
+    client.write(`${JSON.stringify(transformRequest(req))}\n`);
   }
 
   function requestStatus() {

package/src/app/chat/daemonCoordinator.js

@@ -62,6 +62,7 @@ function createDaemonCoordinator(options = {}) {
       const result = await connection.switchConnection({
         connectClient: () => daemonTransport.connectClientForTarget(target),
         callRequestStatus: false,
+        transformRequest: target.transformRequest,
       });
       if (!result || result.ok !== true) {
         return {

package/src/app/chat/daemonTransport.js

@@ -19,11 +19,14 @@ function createDaemonTransport(options = {}) {
 
   let activeProjectRoot = projectRoot;
   let activeSockPath = sockPath;
+  let activeDaemonRoot = options.daemonRoot || projectRoot;
+  let daemonRootFollowsProject = !options.daemonRoot;
 
   function resolveTarget(override = {}) {
     return {
       projectRoot: override.projectRoot || activeProjectRoot,
       sockPath: override.sockPath || activeSockPath,
+      daemonRoot: override.daemonRoot || activeDaemonRoot,
     };
   }
 
@@ -39,9 +42,9 @@ function createDaemonTransport(options = {}) {
     if (!client) {
       // Retry once with a fresh daemon start and longer wait.
       // Check if a restart is already in progress via the explicit restart flow.
-      const isExplicitRestartInProgress = restartLocks.get(target.projectRoot);
-      if (autoStart && !isExplicitRestartInProgress && !isRunning(target.projectRoot)) {
-        startDaemon(target.projectRoot);
+      const isExplicitRestartInProgress = restartLocks.get(target.daemonRoot);
+      if (autoStart && !isExplicitRestartInProgress && !isRunning(target.daemonRoot)) {
+        startDaemon(target.daemonRoot);
         await new Promise((resolve) => setTimeout(resolve, restartDelayMs));
       }
       client = await connectWithRetry(
@@ -59,16 +62,29 @@ function createDaemonTransport(options = {}) {
   }
 
   function setTarget(next = {}) {
-    if (next.projectRoot) activeProjectRoot = next.projectRoot;
+    if (next.projectRoot) {
+      activeProjectRoot = next.projectRoot;
+      if (daemonRootFollowsProject && !next.daemonRoot) {
+        activeDaemonRoot = next.projectRoot;
+      }
+    }
     if (next.sockPath) activeSockPath = next.sockPath;
+    if (next.daemonRoot) {
+      activeDaemonRoot = next.daemonRoot;
+      daemonRootFollowsProject = false;
+    }
     return getTarget();
   }
 
   function getTarget() {
-    return {
+    const target = {
       projectRoot: activeProjectRoot,
       sockPath: activeSockPath,
     };
+    if (activeDaemonRoot !== activeProjectRoot) {
+      target.daemonRoot = activeDaemonRoot;
+    }
+    return target;
   }
 
   return {

package/src/app/chat/projectCloseController.js

@@ -18,6 +18,7 @@ function createProjectCloseController(options = {}) {
     resolveProjectRoot = defaultResolveProjectRoot,
     isRunning = () => false,
     stopDaemon = () => false,
+    closeProject = null,
     switchProject = async () => ({ ok: false, error: "project switching unavailable" }),
     refreshProjects = () => {},
     renderDashboard = () => {},
@@ -86,7 +87,11 @@ function createProjectCloseController(options = {}) {
       }
 
       const wasRunning = Boolean(isRunning(projectRoot));
-      stopDaemon(projectRoot, { source: `project-close:${projectRoot}` });
+      if (typeof closeProject === "function") {
+        await Promise.resolve(closeProject(projectRoot));
+      } else {
+        stopDaemon(projectRoot, { source: `project-close:${projectRoot}` });
+      }
 
       refreshProjects();
       renderDashboard();

package/src/app/chat/transport.js

@@ -3,6 +3,8 @@ const path = require("path");
 const fs = require("fs");
 const { spawn, spawnSync } = require("child_process");
 const { resolveNodeExecutable } = require("../../runtime/process/nodeExecutable");
+const { resolveDaemonEndpoint } = require("../../runtime/daemon/endpoint");
+const { routeDaemonRequest } = require("../../runtime/daemon/endpoint");
 
 function connectSocket(sockPath, options = {}) {
   const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
@@ -54,14 +56,20 @@ function resolveProjectFile(projectRoot, relativePath, fallbackRelativePath) {
 }
 
 function startDaemon(projectRoot, options = {}) {
-  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
-  const env = options.forceResume
-    ? { ...process.env, UFOO_FORCE_RESUME: "1" }
-    : process.env;
+  const endpoint = resolveDaemonEndpoint(projectRoot, options);
+  const daemonRoot = endpoint.scope === "global"
+    ? endpoint.controllerRoot
+    : endpoint.projectRoot;
+  const daemonBin = resolveProjectFile(daemonRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
+  const env = {
+    ...process.env,
+    UFOO_DAEMON_TOPOLOGY: endpoint.topology,
+    ...(options.forceResume ? { UFOO_FORCE_RESUME: "1" } : {}),
+  };
   const child = spawn(resolveNodeExecutable(), [daemonBin, "daemon", "--start"], {
     detached: true,
     stdio: "ignore",
-    cwd: projectRoot,
+    cwd: daemonRoot,
     env,
   });
   child.on("error", (err) => {
@@ -74,15 +82,23 @@ function startDaemon(projectRoot, options = {}) {
 }
 
 function stopDaemon(projectRoot, options = {}) {
-  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
+  const endpoint = resolveDaemonEndpoint(projectRoot, options);
+  const daemonRoot = endpoint.scope === "global"
+    ? endpoint.controllerRoot
+    : endpoint.projectRoot;
+  const daemonBin = resolveProjectFile(daemonRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
   const source = String(
     options.source
       || `chat-transport pid=${process.pid} cwd=${process.cwd()} argv=${process.argv.join(" ")}`
   );
   const result = spawnSync(resolveNodeExecutable(), [daemonBin, "daemon", "--stop"], {
     stdio: "ignore",
-    cwd: projectRoot,
-    env: { ...process.env, UFOO_DAEMON_STOP_SOURCE: source },
+    cwd: daemonRoot,
+    env: {
+      ...process.env,
+      UFOO_DAEMON_STOP_SOURCE: source,
+      UFOO_DAEMON_TOPOLOGY: endpoint.topology,
+    },
   });
   return Boolean(result && !result.error && result.status === 0);
 }
@@ -101,10 +117,70 @@ async function connectWithRetry(sockPath, retries, delayMs, options = {}) {
   return null;
 }
 
+async function requestDaemon(projectRoot, payload, options = {}) {
+  const endpoint = resolveDaemonEndpoint(projectRoot, options);
+  const client = await connectWithRetry(
+    endpoint.socketPath,
+    Number(options.retries) || 25,
+    Number(options.retryDelayMs) || 200,
+    { timeoutMs: Number(options.connectTimeoutMs) || 2000 }
+  );
+  if (!client) throw new Error("Failed to connect to ufoo daemon");
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    let settled = false;
+    const finish = (err, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      client.removeAllListeners();
+      try {
+        client.end();
+      } catch {
+        // ignore
+      }
+      if (err) reject(err);
+      else resolve(value);
+    };
+    const timer = setTimeout(() => {
+      finish(new Error("Daemon request timeout"));
+    }, Number(options.timeoutMs) || 10000);
+    if (typeof timer.unref === "function") timer.unref();
+    client.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let response;
+        try {
+          response = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (response.type === "error") {
+          const err = new Error(response.error || "Daemon request failed");
+          err.code = response.code || "daemon_request_failed";
+          finish(err);
+          return;
+        }
+        if (response.type === "response") {
+          finish(null, response.data || {});
+          return;
+        }
+      }
+    });
+    client.once("error", (err) => finish(err));
+    client.once("close", () => finish(new Error("Daemon request connection closed")));
+    client.write(`${JSON.stringify(routeDaemonRequest(endpoint, payload))}\n`);
+  });
+}
+
 module.exports = {
   connectSocket,
   connectWithRetry,
   resolveProjectFile,
   startDaemon,
   stopDaemon,
+  requestDaemon,
 };