u-foo 3.0.21 → 3.0.23

package/src/runtime/daemon/projectRuntimeManager.js

@@ -0,0 +1,268 @@
+"use strict";
+
+const {
+  canonicalProjectRoot,
+} = require("../projects");
+const { createProjectContext } = require("./projectContext");
+const {
+  createProjectRuntime,
+  RUNTIME_STATES,
+} = require("./projectRuntime");
+
+const DEFAULT_IDLE_GRACE_MS = 5 * 60 * 1000;
+const DEFAULT_SWEEP_INTERVAL_MS = 30 * 1000;
+
+class ProjectRuntimeManager {
+  constructor(options = {}) {
+    this.contextFactory = options.contextFactory || createProjectContext;
+    this.runtimeFactory = options.runtimeFactory || createProjectRuntime;
+    this.configureRuntime = typeof options.configureRuntime === "function"
+      ? options.configureRuntime
+      : null;
+    this.authorizeProjectRoot = typeof options.authorizeProjectRoot === "function"
+      ? options.authorizeProjectRoot
+      : (() => true);
+    this.idleGraceMs = Number.isFinite(options.idleGraceMs)
+      ? Math.max(0, Number(options.idleGraceMs))
+      : DEFAULT_IDLE_GRACE_MS;
+    this.maxActiveRuntimes = Number.isFinite(options.maxActiveRuntimes)
+      ? Math.max(1, Number(options.maxActiveRuntimes))
+      : 32;
+    this.maxConcurrentRequests = Number.isFinite(options.maxConcurrentRequests)
+      ? Math.max(1, Number(options.maxConcurrentRequests))
+      : 256;
+    this.now = typeof options.now === "function" ? options.now : Date.now;
+    this.runtimes = new Map();
+    this.activationPromises = new Map();
+    this.activeRequestCount = 0;
+    this.disposed = false;
+    const sweepIntervalMs = Number.isFinite(options.sweepIntervalMs)
+      ? Math.max(0, Number(options.sweepIntervalMs))
+      : DEFAULT_SWEEP_INTERVAL_MS;
+    this.sweepTimer = sweepIntervalMs > 0
+      ? setInterval(() => {
+        void this.sweepIdle();
+      }, sweepIntervalMs)
+      : null;
+    if (this.sweepTimer && typeof this.sweepTimer.unref === "function") {
+      this.sweepTimer.unref();
+    }
+  }
+
+  resolveProject(projectRoot, options = {}) {
+    const canonicalRoot = canonicalProjectRoot(projectRoot);
+    if (this.authorizeProjectRoot(canonicalRoot, options) !== true) {
+      const err = new Error(`project runtime access denied: ${canonicalRoot}`);
+      err.code = "PROJECT_RUNTIME_ACCESS_DENIED";
+      throw err;
+    }
+    return canonicalRoot;
+  }
+
+  createEntry(projectRoot, options = {}) {
+    const previousGeneration = Number(options.previousGeneration) || 0;
+    const context = this.contextFactory({
+      ...options,
+      projectRoot,
+      runtimeGeneration: previousGeneration + 1,
+    });
+    const runtime = this.runtimeFactory(context, options.runtimeOptions || {});
+    if (this.configureRuntime) this.configureRuntime(runtime, context);
+    const entry = {
+      context,
+      runtime,
+      lastUsedAtMs: this.now(),
+      createdAt: new Date(this.now()).toISOString(),
+    };
+    this.runtimes.set(context.projectId, entry);
+    return entry;
+  }
+
+  entryForRoot(projectRoot) {
+    const canonicalRoot = canonicalProjectRoot(projectRoot);
+    for (const entry of this.runtimes.values()) {
+      if (entry.context.projectRoot === canonicalRoot) return entry;
+    }
+    return null;
+  }
+
+  activeRuntimeCount() {
+    let count = 0;
+    for (const entry of this.runtimes.values()) {
+      if (entry.runtime.state === RUNTIME_STATES.ACTIVE) count += 1;
+    }
+    return count;
+  }
+
+  async activate(projectRoot, options = {}) {
+    if (this.disposed) {
+      const err = new Error("project runtime manager is disposed");
+      err.code = "PROJECT_RUNTIME_MANAGER_DISPOSED";
+      throw err;
+    }
+    const canonicalRoot = this.resolveProject(projectRoot, options);
+    let entry = this.entryForRoot(canonicalRoot);
+    if (entry && entry.runtime.state === RUNTIME_STATES.ACTIVE) {
+      entry.lastUsedAtMs = this.now();
+      return entry.runtime;
+    }
+    const projectId = entry
+      ? entry.context.projectId
+      : this.contextFactory({
+        ...options,
+        projectRoot: canonicalRoot,
+        runtimeGeneration: 1,
+      }).projectId;
+    if (this.activationPromises.has(projectId)) {
+      return this.activationPromises.get(projectId);
+    }
+    const activation = (async () => {
+      if (!entry) {
+        entry = this.createEntry(canonicalRoot, options);
+      } else if (
+        entry.runtime.state === RUNTIME_STATES.FAILED
+        || entry.runtime.state === RUNTIME_STATES.DISPOSED
+      ) {
+        entry = await this.recycle(canonicalRoot, options);
+      }
+      if (
+        entry.runtime.state !== RUNTIME_STATES.ACTIVE
+        && this.activeRuntimeCount() >= this.maxActiveRuntimes
+      ) {
+        await this.sweepIdle({ forcePressure: true });
+      }
+      if (
+        entry.runtime.state !== RUNTIME_STATES.ACTIVE
+        && this.activeRuntimeCount() >= this.maxActiveRuntimes
+      ) {
+        const err = new Error(
+          `active project runtime limit reached (${this.maxActiveRuntimes})`
+        );
+        err.code = "PROJECT_RUNTIME_LIMIT";
+        throw err;
+      }
+      await entry.runtime.activate();
+      entry.lastUsedAtMs = this.now();
+      return entry.runtime;
+    })();
+    this.activationPromises.set(projectId, activation);
+    try {
+      return await activation;
+    } finally {
+      this.activationPromises.delete(projectId);
+    }
+  }
+
+  async call(projectRoot, operation, args = {}, requestContext = {}) {
+    if (this.activeRequestCount >= this.maxConcurrentRequests) {
+      const err = new Error(
+        `global project runtime request limit reached (${this.maxConcurrentRequests})`
+      );
+      err.code = "PROJECT_RUNTIME_REQUEST_LIMIT";
+      throw err;
+    }
+    const runtime = await this.activate(projectRoot, requestContext);
+    const entry = this.runtimes.get(runtime.context.projectId);
+    this.activeRequestCount += 1;
+    if (entry) entry.lastUsedAtMs = this.now();
+    try {
+      return await runtime.call(operation, args, requestContext);
+    } finally {
+      this.activeRequestCount -= 1;
+      if (entry) entry.lastUsedAtMs = this.now();
+    }
+  }
+
+  cancel(projectRoot, requestId) {
+    const entry = this.entryForRoot(projectRoot);
+    return entry ? entry.runtime.cancel(requestId) : false;
+  }
+
+  async suspend(projectRoot) {
+    const entry = this.entryForRoot(projectRoot);
+    if (!entry) return false;
+    if (entry.runtime.state === RUNTIME_STATES.DORMANT) return true;
+    await entry.runtime.suspend();
+    return true;
+  }
+
+  async recycle(projectRoot, options = {}) {
+    const canonicalRoot = this.resolveProject(projectRoot, options);
+    const existing = this.entryForRoot(canonicalRoot);
+    const generation = existing ? existing.context.runtimeGeneration : 0;
+    if (existing) {
+      existing.runtime.dispose();
+      this.runtimes.delete(existing.context.projectId);
+    }
+    return this.createEntry(canonicalRoot, {
+      ...options,
+      previousGeneration: generation,
+    });
+  }
+
+  remove(projectRoot) {
+    const entry = this.entryForRoot(projectRoot);
+    if (!entry) return false;
+    entry.runtime.dispose();
+    this.runtimes.delete(entry.context.projectId);
+    this.activationPromises.delete(entry.context.projectId);
+    return true;
+  }
+
+  async sweepIdle(options = {}) {
+    const nowMs = this.now();
+    const candidates = Array.from(this.runtimes.values())
+      .filter((entry) => entry.runtime.state === RUNTIME_STATES.ACTIVE)
+      .sort((a, b) => a.lastUsedAtMs - b.lastUsedAtMs);
+    let suspended = 0;
+    for (const entry of candidates) {
+      const idleForMs = nowMs - entry.lastUsedAtMs;
+      const underPressure = options.forcePressure === true
+        && this.activeRuntimeCount() >= this.maxActiveRuntimes;
+      if (!underPressure && idleForMs < this.idleGraceMs) continue;
+      if (!entry.runtime.canSuspend()) continue;
+      try {
+        await entry.runtime.suspend();
+        suspended += 1;
+      } catch {
+        // A busy/failing runtime is reported by its own status and skipped.
+      }
+    }
+    return suspended;
+  }
+
+  status() {
+    return {
+      disposed: this.disposed,
+      runtime_count: this.runtimes.size,
+      active_runtime_count: this.activeRuntimeCount(),
+      active_request_count: this.activeRequestCount,
+      max_active_runtimes: this.maxActiveRuntimes,
+      max_concurrent_requests: this.maxConcurrentRequests,
+      runtimes: Array.from(this.runtimes.values())
+        .map((entry) => ({
+          ...entry.runtime.status(),
+          manager_last_used_at: new Date(entry.lastUsedAtMs).toISOString(),
+        }))
+        .sort((a, b) => a.project_root.localeCompare(b.project_root)),
+    };
+  }
+
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    if (this.sweepTimer) clearInterval(this.sweepTimer);
+    this.sweepTimer = null;
+    for (const entry of this.runtimes.values()) {
+      entry.runtime.dispose();
+    }
+    this.runtimes.clear();
+    this.activationPromises.clear();
+  }
+}
+
+module.exports = {
+  DEFAULT_IDLE_GRACE_MS,
+  DEFAULT_SWEEP_INTERVAL_MS,
+  ProjectRuntimeManager,
+};

package/src/runtime/daemon/run.js

@@ -1,15 +1,31 @@
 const path = require("path");
+const fs = require("fs");
 const { startDaemon, stopDaemon, isRunning } = require("./index");
+const { startGlobalDaemon } = require("./globalDaemon");
 const { restartDaemonLifecycleSync } = require("./restart");
-const { loadConfig, defaultAgentModelForProvider } = require("../../config");
+const {
+  loadConfig,
+  defaultAgentModelForProvider,
+  normalizeDaemonTopology,
+  saveGlobalDaemonConfig,
+} = require("../../config");
 const { resolveNodeExecutable } = require("../process/nodeExecutable");
+const {
+  isGlobalControllerProjectRoot,
+  resolveGlobalControllerProjectRoot,
+} = require("../projects");
+const { getUfooPaths } = require("../../coordination/state/paths");
 
-function spawnDaemonStart(projectRoot) {
+function spawnDaemonStart(projectRoot, daemonTopology = "") {
   const { spawn } = require("child_process");
   const child = spawn(resolveNodeExecutable(), [path.join(__dirname, "..", "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
     detached: true,
     stdio: "ignore",
-    env: { ...process.env, UFOO_DAEMON_CHILD: "1" },
+    env: {
+      ...process.env,
+      UFOO_DAEMON_CHILD: "1",
+      ...(daemonTopology ? { UFOO_DAEMON_TOPOLOGY: daemonTopology } : {}),
+    },
     cwd: projectRoot,
   });
   child.unref();
@@ -22,8 +38,27 @@ function sleepSync(ms) {
 
 function runDaemonCli(argv) {
   const cmd = argv[1] || "start";
+  if (cmd === "topology" || cmd === "--topology") {
+    const requested = String(argv[2] || "").trim().toLowerCase();
+    if (!["project", "hybrid", "global"].includes(requested)) {
+      throw new Error("daemon topology requires project|hybrid|global");
+    }
+    const saved = saveGlobalDaemonConfig({ daemonTopology: requested });
+    // eslint-disable-next-line no-console
+    console.log(saved.daemonTopology);
+    return;
+  }
   const projectRoot = process.cwd();
   const config = loadConfig(projectRoot);
+  const daemonTopology = normalizeDaemonTopology(
+    process.env.UFOO_DAEMON_TOPOLOGY || config.daemonTopology
+  );
+  const daemonRoot = daemonTopology === "project"
+    ? projectRoot
+    : resolveGlobalControllerProjectRoot();
+  if (daemonTopology !== "project") {
+    fs.mkdirSync(getUfooPaths(daemonRoot).ufooDir, { recursive: true });
+  }
   const envProvider = process.env.UFOO_AGENT_PROVIDER;
   const provider = envProvider || config.agentProvider || "codex-cli";
   const model =
@@ -31,32 +66,51 @@ function runDaemonCli(argv) {
     || (envProvider && envProvider !== config.agentProvider ? "" : config.agentModel)
     || defaultAgentModelForProvider(provider);
   const resumeMode = process.env.UFOO_FORCE_RESUME === "1" ? "force" : "auto";
-  const launchMode = config.launchMode || "terminal";
+  const useGlobalRuntimeHost =
+    isGlobalControllerProjectRoot(daemonRoot)
+    && daemonTopology !== "project";
+  const startSelectedDaemon = (selectedResumeMode) => {
+    if (useGlobalRuntimeHost) {
+      return startGlobalDaemon({
+        controllerRoot: daemonRoot,
+        provider,
+        model,
+        resumeMode: selectedResumeMode,
+        topology: daemonTopology,
+      });
+    }
+    return startDaemon({
+      projectRoot: daemonRoot,
+      provider,
+      model,
+      resumeMode: selectedResumeMode,
+    });
+  };
 
   if (cmd === "start" || cmd === "--start") {
-    if (isRunning(projectRoot)) return;
+    if (isRunning(daemonRoot)) return;
     if (!process.env.UFOO_DAEMON_CHILD) {
-      spawnDaemonStart(projectRoot);
+      spawnDaemonStart(daemonRoot, daemonTopology);
       return;
     }
-    startDaemon({ projectRoot, provider, model, resumeMode });
+    startSelectedDaemon(resumeMode);
     return;
   }
   if (cmd === "stop" || cmd === "--stop") {
-    if (!stopDaemon(projectRoot, { source: process.env.UFOO_DAEMON_STOP_SOURCE || `daemon-cli:${cmd} pid=${process.pid}` })) {
+    if (!stopDaemon(daemonRoot, { source: process.env.UFOO_DAEMON_STOP_SOURCE || `daemon-cli:${cmd} pid=${process.pid}` })) {
       process.exitCode = 1;
     }
     return;
   }
   if (cmd === "restart" || cmd === "--restart") {
     const result = restartDaemonLifecycleSync({
-      projectRoot,
+      projectRoot: daemonRoot,
       isRunning,
       stopDaemon,
       startDaemon: () => {
-        if (!process.env.UFOO_DAEMON_CHILD) return spawnDaemonStart(projectRoot);
+        if (!process.env.UFOO_DAEMON_CHILD) return spawnDaemonStart(daemonRoot, daemonTopology);
         // Manual restart does not auto-resume; crash-recovery is handled on next auto start with stale lock detection.
-        return startDaemon({ projectRoot, provider, model, resumeMode: "none" });
+        return startSelectedDaemon("none");
       },
       stopOptions: { source: process.env.UFOO_DAEMON_STOP_SOURCE || `daemon-cli:${cmd} pid=${process.pid}` },
       sleepSync,
@@ -65,7 +119,7 @@ function runDaemonCli(argv) {
     return;
   }
   if (cmd === "status" || cmd === "--status") {
-    const running = isRunning(projectRoot);
+    const running = isRunning(daemonRoot);
     // eslint-disable-next-line no-console
     console.log(running ? "running" : "stopped");
     return;

package/src/runtime/projects/registry.js

@@ -119,7 +119,13 @@ function isSocketAlive(socketPath) {
 
 function normalizeStatus(value, fallback = "running") {
   const raw = String(value || "").trim().toLowerCase();
-  if (raw === "running" || raw === "stale" || raw === "stopped") return raw;
+  if (
+    raw === "running"
+    || raw === "dormant"
+    || raw === "failed"
+    || raw === "stale"
+    || raw === "stopped"
+  ) return raw;
   return fallback;
 }
 
@@ -192,6 +198,21 @@ function markProjectStopped(projectRoot, options = {}) {
   }, options);
 }
 
+function markProjectDormant(projectRoot, options = {}) {
+  if (!projectRoot) return null;
+  const existing = readProjectRuntimeByRoot(projectRoot, options);
+  const paths = getUfooPaths(canonicalizeForRecord(projectRoot));
+  return upsertProjectRuntime({
+    projectRoot,
+    projectName: existing ? existing.project_name : path.basename(projectRoot),
+    daemonPid: existing ? existing.daemon_pid : process.pid,
+    socketPath: existing ? existing.socket_path : paths.ufooSock,
+    status: "dormant",
+    lastSeen: new Date().toISOString(),
+    lastSwitchAt: existing ? existing.last_switch_at : undefined,
+  }, options);
+}
+
 function validateProjectRuntime(entry = {}, options = {}) {
   if (!entry || typeof entry !== "object") return null;
   const staleTtlMs = Number.isFinite(options.staleTtlMs) ? options.staleTtlMs : DEFAULT_STALE_TTL_MS;
@@ -207,9 +228,9 @@ function validateProjectRuntime(entry = {}, options = {}) {
   let status = normalizeStatus(entry.status, "running");
   if (running) {
     status = "running";
-  } else if (status === "stopped") {
-    // Respect explicit stop state even if pid/socket checks are unavailable.
-    status = "stopped";
+  } else if (status === "stopped" || status === "dormant" || status === "failed") {
+    // Respect explicit lifecycle state even when the compatibility project
+    // socket is intentionally absent.
   } else if (ageMs === null || ageMs > staleTtlMs) {
     status = "stale";
   }
@@ -273,6 +294,7 @@ module.exports = {
   runtimeFilePathByProjectRoot,
   upsertProjectRuntime,
   markProjectStopped,
+  markProjectDormant,
   listProjectRuntimes,
   getCurrentProjectRuntime,
   validateProjectRuntime,

package/src/runtime/projects/runtimes.js

@@ -17,7 +17,7 @@ function filterVisibleProjectRuntimes(rows = []) {
   const sourceRows = Array.isArray(rows) ? rows : [];
   return sourceRows.filter((row) => {
     const status = String((row && row.status) || "").trim().toLowerCase();
-    return status === "running";
+    return status === "running" || status === "dormant";
   });
 }
 

package/src/ui/rustChatHost.js

@@ -35,6 +35,10 @@ const {
 } = require("../runtime/contracts/uiProtocol");
 const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES } = require("../runtime/contracts/eventContract");
 const { createDaemonMessageRouter } = require("../app/chat/daemonMessageRouter");
+const {
+  resolveDaemonEndpoint,
+  routeDaemonRequest,
+} = require("../runtime/daemon/endpoint");
 
 function stripTags(value) {
   return String(value || "").replace(/\{[^}]+\}/g, "");
@@ -145,19 +149,23 @@ async function runChatRust(projectRoot, options = {}) {
     });
   }
   await ensureSubscriberId(projectRoot);
-  if (!env.isRunning(projectRoot)) {
+  const initialDaemonEndpoint = resolveDaemonEndpoint(projectRoot);
+  const initialDaemonRoot = initialDaemonEndpoint.scope === "global"
+    ? initialDaemonEndpoint.controllerRoot
+    : initialDaemonEndpoint.projectRoot;
+  if (!env.isRunning(initialDaemonRoot)) {
     env.startDaemon(projectRoot);
   }
 
-  const { socketPath } = require("../runtime/daemon");
   const { connectWithRetry } = require("../app/chat/transport");
   const { createDaemonTransport } = require("../app/chat/daemonTransport");
   const { createDaemonConnection } = require("../app/chat/daemonConnection");
 
-  const sock = socketPath(projectRoot);
+  const sock = initialDaemonEndpoint.socketPath;
   const daemonTransport = createDaemonTransport({
     projectRoot,
     sockPath: sock,
+    daemonRoot: initialDaemonRoot,
     isRunning: env.isRunning,
     startDaemon: env.startDaemon,
     connectWithRetry,
@@ -336,7 +344,16 @@ async function runChatRust(projectRoot, options = {}) {
         multiSession.stop();
       }
 
-      if (env.globalMode && typeof env.isRunning === "function" && !env.isRunning(root)) {
+      const targetEndpoint = resolveDaemonEndpoint(root);
+      const targetDaemonRoot = targetEndpoint.scope === "global"
+        ? targetEndpoint.controllerRoot
+        : targetEndpoint.projectRoot;
+      if (
+        env.globalMode
+        && targetEndpoint.scope === "project"
+        && typeof env.isRunning === "function"
+        && !env.isRunning(targetDaemonRoot)
+      ) {
         try {
           const { markProjectStopped } = require("../runtime/projects");
           markProjectStopped(root);
@@ -365,7 +382,9 @@ async function runChatRust(projectRoot, options = {}) {
       if (daemonCoordinator && typeof daemonCoordinator.switchProject === "function") {
         const res = await daemonCoordinator.switchProject({
           projectRoot: root,
-          sockPath: socketPath(root),
+          sockPath: targetEndpoint.socketPath,
+          daemonRoot: targetDaemonRoot,
+          transformRequest: (request) => routeDaemonRequest(targetEndpoint, request),
           autoStart: options.autoStart === true,
         });
         if (!res || res.ok !== true) {
@@ -399,9 +418,14 @@ async function runChatRust(projectRoot, options = {}) {
         return { ok: true, project_root: projectRoot, root: projectRoot };
       }
       if (daemonCoordinator && typeof daemonCoordinator.switchProject === "function") {
+        const controllerEndpoint = resolveDaemonEndpoint(projectRoot);
         const res = await daemonCoordinator.switchProject({
           projectRoot,
-          sockPath: socketPath(projectRoot),
+          sockPath: controllerEndpoint.socketPath,
+          daemonRoot: controllerEndpoint.scope === "global"
+            ? controllerEndpoint.controllerRoot
+            : controllerEndpoint.projectRoot,
+          transformRequest: (request) => routeDaemonRequest(controllerEndpoint, request),
         });
         if (!res || res.ok !== true) {
           appendLocal("error", `Switch to global failed: ${(res && res.error) || "switch failed"}`);
@@ -1151,7 +1175,7 @@ async function runChatRust(projectRoot, options = {}) {
         if (!root) return { ok: false, error: "missing project root" };
         try {
           const { createProjectCloseController } = require("../app/chat/projectCloseController");
-          const { stopDaemon } = require("../app/chat/transport");
+          const { requestDaemon, stopDaemon } = require("../app/chat/transport");
           const { isRunning } = require("../runtime/daemon");
           const projects = loadGlobalProjectRows(activeProjectRoot);
           const index = projects.findIndex((row) => String(row.root || "") === root);
@@ -1166,8 +1190,21 @@ async function runChatRust(projectRoot, options = {}) {
             })),
             getActiveProjectRoot: () => activeProjectRoot,
             resolveProjectRoot: (row) => String((row && (row.root || row.project_root)) || ""),
-            isRunning,
+            isRunning: (targetRoot) => {
+              const endpoint = resolveDaemonEndpoint(targetRoot);
+              return endpoint.scope === "global" ? true : isRunning(targetRoot);
+            },
             stopDaemon,
+            closeProject: async (targetRoot) => {
+              const endpoint = resolveDaemonEndpoint(targetRoot);
+              if (endpoint.scope === "global") {
+                return requestDaemon(targetRoot, {
+                  type: IPC_REQUEST_TYPES.CLOSE_PROJECT_RUNTIME,
+                  terminate_agents: true,
+                });
+              }
+              return stopDaemon(targetRoot, { source: `project-close:${targetRoot}` });
+            },
             switchProject: async (fallbackRoot) => hostApi.switchToProjectRoot(fallbackRoot),
             refreshProjects: () => publishProjects(),
             logMessage: (kind, text) => {
@@ -1408,6 +1445,7 @@ async function runChatRust(projectRoot, options = {}) {
 
   const daemonConnection = createDaemonConnection({
     connectClient: daemonTransport.connectClient.bind(daemonTransport),
+    transformRequest: (request) => routeDaemonRequest(initialDaemonEndpoint, request),
     handleMessage: (msg) => {
       if (typeof routedMessageHandler === "function" && routedMessageHandler(msg)) {
         return;