u-foo 3.0.21 → 3.0.22

package/src/runtime/daemon/ops.js

@@ -176,6 +176,13 @@ function resolveConfiguredLaunchMode(configuredMode = "", options = {}) {
   if (mode === "internal" || mode === "tmux" || mode === "terminal" || mode === "host") {
     return mode;
   }
+  if (
+    normalizeOptionalString(options.tmuxTarget)
+    || normalizeOptionalString(options.tmuxPane)
+    || normalizeOptionalString(options.tmuxSession)
+  ) {
+    return "tmux";
+  }
   // Auto mode: defer to the unified detector. Daemon ops differs from the
   // launcher in two ways: host context can also arrive via `options`, and
   // when running under a native terminal app we want to override a stale
@@ -704,7 +711,6 @@ async function spawnInternalAgent(
 
     // Daemon 预先在 bus 中注册
     bus.loadBusData();
-    process.env.UFOO_PARENT_PID = String(originalPid);
     const replaceAgentId = typeof options.replaceAgentId === "string" ? options.replaceAgentId.trim() : "";
     if (replaceAgentId && bus.busData.agents && bus.busData.agents[replaceAgentId]) {
       delete bus.busData.agents[replaceAgentId];
@@ -721,6 +727,7 @@ async function spawnInternalAgent(
       launchMode,
       parentPid: originalPid,
       providerSessionId,
+      scopedNickname: String(extraEnv.UFOO_SCOPED_NICKNAME || "").trim(),
     });
     const finalNickname = joinResult.nickname || requestedNickname || "";
     bus.saveBusData();
@@ -803,7 +810,14 @@ async function spawnInternalAgent(
   return { children, subscriberIds };
 }
 
-function spawnTmuxWindow(projectRoot, agent, nickname = "", extraArgs = [], extraEnv = "") {
+function spawnTmuxWindow(
+  projectRoot,
+  agent,
+  nickname = "",
+  extraArgs = [],
+  extraEnv = "",
+  targetSession = ""
+) {
   return new Promise((resolve, reject) => {
     const normalizedAgent = normalizeLaunchAgent(agent);
     const binary = toTmuxBinary(normalizedAgent);
@@ -826,11 +840,12 @@ function spawnTmuxWindow(projectRoot, agent, nickname = "", extraArgs = [], extr
 
     // Use detached mode (-d) to avoid stealing focus
     // Use -a flag to insert after current window, avoiding index conflicts
-    // Use target session from env or current session
-    const targetSession = process.env.UFOO_TMUX_SESSION || "";
+    // Use the request-scoped target session when available. The daemon may
+    // host multiple projects and must not mutate process.env to select one.
+    const normalizedTargetSession = String(targetSession || "").trim();
     const tmuxArgs = ["new-window", "-a", "-d", "-n", windowName];
-    if (targetSession) {
-      tmuxArgs.push("-t", targetSession);
+    if (normalizedTargetSession) {
+      tmuxArgs.push("-t", normalizedTargetSession);
     }
     tmuxArgs.push(runCmd);
 
@@ -846,10 +861,20 @@ function spawnTmuxWindow(projectRoot, agent, nickname = "", extraArgs = [], extr
   });
 }
 
-function resolveTmuxPaneTarget() {
-  const explicit = String(process.env.UFOO_TMUX_TARGET || "").trim();
+function resolveTmuxPaneTarget(options = {}) {
+  const explicit = String(
+    options.tmuxTarget
+    || options.tmux_target
+    || process.env.UFOO_TMUX_TARGET
+    || ""
+  ).trim();
   if (explicit) return explicit;
-  const preferredPane = String(process.env.UFOO_TMUX_PANE || "").trim();
+  const preferredPane = String(
+    options.tmuxPane
+    || options.tmux_pane
+    || process.env.UFOO_TMUX_PANE
+    || ""
+  ).trim();
   if (preferredPane) return preferredPane;
   const currentPane = String(process.env.TMUX_PANE || "").trim();
   if (currentPane) return currentPane;
@@ -982,15 +1007,21 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
     if (!tmuxAvailable) {
       throw new Error("tmux is not available or no tmux session is running");
     }
-    // If UFOO_TMUX_SESSION not set, use first available session
-    if (!process.env.UFOO_TMUX_SESSION && stdout) {
+    let tmuxSession = String(
+      options.tmuxSession
+      || options.tmux_session
+      || process.env.UFOO_TMUX_SESSION
+      || ""
+    ).trim();
+    // If no request-scoped or inherited session was supplied, use the first
+    // available session locally without changing the daemon environment.
+    if (!tmuxSession && stdout) {
       const sessions = stdout.trim().split("\n");
       if (sessions.length > 0) {
-        const firstSession = sessions[0].split(":")[0];
-        process.env.UFOO_TMUX_SESSION = firstSession;
+        tmuxSession = String(sessions[0].split(":")[0] || "").trim();
       }
     }
-    const paneTarget = resolveTmuxPaneTarget();
+    const paneTarget = resolveTmuxPaneTarget(options);
     const useSeparateWindow = launchScope === "window";
     const tmuxLayoutContext = options.tmuxLayoutContext && typeof options.tmuxLayoutContext === "object"
       ? options.tmuxLayoutContext
@@ -1004,7 +1035,7 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
       const nick = count > 1 ? `${nickname || defaultNick}-${i + 1}` : (nickname || "");
       if (useSeparateWindow) {
         // eslint-disable-next-line no-await-in-loop
-        await spawnTmuxWindow(projectRoot, normalizedAgent, nick, extraArgs, extraEnvPrefix);
+        await spawnTmuxWindow(projectRoot, normalizedAgent, nick, extraArgs, extraEnvPrefix, tmuxSession);
       } else if (useGroupRightColumnLayout && paneTarget) {
         const basePane = String(tmuxLayoutContext.basePane || paneTarget).trim() || paneTarget;
         tmuxLayoutContext.basePane = basePane;
@@ -1021,7 +1052,7 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
         } catch {
           // Fallback to new window when current pane target cannot be resolved.
           // eslint-disable-next-line no-await-in-loop
-          await spawnTmuxWindow(projectRoot, normalizedAgent, nick, extraArgs, extraEnvPrefix);
+          await spawnTmuxWindow(projectRoot, normalizedAgent, nick, extraArgs, extraEnvPrefix, tmuxSession);
           continue;
         }
         if (!rightColumnPane && splitResult && splitResult.paneId) {
@@ -1037,7 +1068,7 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
         } catch {
           // Fallback to new window when current pane target cannot be resolved.
           // eslint-disable-next-line no-await-in-loop
-          await spawnTmuxWindow(projectRoot, normalizedAgent, nick, extraArgs, extraEnvPrefix);
+          await spawnTmuxWindow(projectRoot, normalizedAgent, nick, extraArgs, extraEnvPrefix, tmuxSession);
         }
       }
     }

package/src/runtime/daemon/processLifecycle.js

@@ -0,0 +1,127 @@
+"use strict";
+
+class DaemonProcessLifecycle {
+  constructor(processRef = process) {
+    this.processRef = processRef;
+    this.registrations = new Map();
+    this.installed = false;
+    this.shuttingDown = false;
+    this.boundHandlers = null;
+  }
+
+  register(id, hooks = {}) {
+    const key = String(id || "").trim();
+    if (!key) throw new Error("daemon process lifecycle registration id is required");
+    if (this.registrations.has(key)) {
+      throw new Error(`daemon process lifecycle already registered: ${key}`);
+    }
+    this.registrations.set(key, hooks);
+    this.install();
+    return () => {
+      this.registrations.delete(key);
+    };
+  }
+
+  install() {
+    if (this.installed) return;
+    this.installed = true;
+    const beforeExit = (code) => {
+      this.notify("onBeforeExit", code);
+    };
+    const exit = (code) => {
+      this.shutdown(`exit code=${code}`, { sync: true, notify: "onExit", value: code });
+    };
+    const sigterm = () => {
+      this.shutdown("SIGTERM", { sync: true, notify: "onSignal", value: "SIGTERM" });
+      this.processRef.exit(0);
+    };
+    const sigint = () => {
+      this.shutdown("SIGINT", { sync: true, notify: "onSignal", value: "SIGINT" });
+      this.processRef.exit(0);
+    };
+    const uncaughtException = (err) => {
+      this.shutdown("uncaughtException", {
+        sync: true,
+        notify: "onFatal",
+        value: { kind: "uncaughtException", error: err },
+      });
+      this.processRef.exit(1);
+    };
+    const unhandledRejection = (reason) => {
+      this.shutdown("unhandledRejection", {
+        sync: true,
+        notify: "onFatal",
+        value: { kind: "unhandledRejection", error: reason },
+      });
+      this.processRef.exit(1);
+    };
+    this.boundHandlers = {
+      beforeExit,
+      exit,
+      SIGTERM: sigterm,
+      SIGINT: sigint,
+      uncaughtException,
+      unhandledRejection,
+    };
+    for (const [event, handler] of Object.entries(this.boundHandlers)) {
+      this.processRef.on(event, handler);
+    }
+  }
+
+  notify(method, value) {
+    for (const hooks of Array.from(this.registrations.values())) {
+      const handler = hooks && hooks[method];
+      if (typeof handler !== "function") continue;
+      try {
+        handler(value);
+      } catch {
+        // A lifecycle observer cannot prevent other runtimes from cleaning up.
+      }
+    }
+  }
+
+  shutdown(reason, options = {}) {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    const registrations = Array.from(this.registrations.values());
+    for (const hooks of registrations) {
+      try {
+        const notify = options.notify && hooks && hooks[options.notify];
+        if (typeof notify === "function") notify(options.value);
+      } catch {
+        // Fatal diagnostics for one runtime must not block cleanup of another.
+      }
+      try {
+        if (hooks && typeof hooks.cleanup === "function") {
+          hooks.cleanup(reason, { sync: options.sync === true });
+        }
+      } catch {
+        // Continue draining every registered runtime.
+      }
+    }
+  }
+
+  disposeForTests() {
+    if (this.boundHandlers && typeof this.processRef.removeListener === "function") {
+      for (const [event, handler] of Object.entries(this.boundHandlers)) {
+        this.processRef.removeListener(event, handler);
+      }
+    }
+    this.boundHandlers = null;
+    this.registrations.clear();
+    this.installed = false;
+    this.shuttingDown = false;
+  }
+}
+
+const defaultDaemonProcessLifecycle = new DaemonProcessLifecycle(process);
+
+function registerDaemonRuntimeLifecycle(id, hooks = {}) {
+  return defaultDaemonProcessLifecycle.register(id, hooks);
+}
+
+module.exports = {
+  DaemonProcessLifecycle,
+  defaultDaemonProcessLifecycle,
+  registerDaemonRuntimeLifecycle,
+};

package/src/runtime/daemon/projectContext.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const path = require("path");
+
+const { loadConfig } = require("../../config");
+const { getUfooPaths } = require("../../coordination/state/paths");
+const {
+  buildProjectId,
+  canonicalProjectRoot,
+} = require("../projects");
+
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value == null ? {} : value));
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}
+
+function createProjectContext(options = {}) {
+  const projectRoot = canonicalProjectRoot(options.projectRoot);
+  const configSnapshot = cloneJson(options.config || loadConfig(projectRoot));
+  const runtimeGeneration = Number.isInteger(options.runtimeGeneration)
+    && options.runtimeGeneration > 0
+    ? options.runtimeGeneration
+    : 1;
+  const context = {
+    projectId: options.projectId || buildProjectId(projectRoot),
+    projectRoot,
+    projectName: options.projectName || path.basename(projectRoot),
+    paths: getUfooPaths(projectRoot),
+    config: configSnapshot,
+    provider: String(options.provider || configSnapshot.agentProvider || ""),
+    model: String(options.model || configSnapshot.agentModel || ""),
+    daemonTopology: String(options.daemonTopology || configSnapshot.daemonTopology || "global"),
+    runtimeGeneration,
+  };
+  return deepFreeze(context);
+}
+
+module.exports = {
+  createProjectContext,
+  deepFreeze,
+};

package/src/runtime/daemon/projectRuntime.js

@@ -0,0 +1,221 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+
+const RUNTIME_STATES = Object.freeze({
+  REGISTERED: "registered",
+  DORMANT: "dormant",
+  ACTIVATING: "activating",
+  ACTIVE: "active",
+  DRAINING: "draining",
+  FAILED: "failed",
+  DISPOSED: "disposed",
+});
+
+class ProjectRuntime {
+  constructor(context, options = {}) {
+    if (!context || !context.projectId || !context.projectRoot) {
+      throw new Error("ProjectRuntime requires an immutable ProjectContext");
+    }
+    this.context = context;
+    this.state = RUNTIME_STATES.REGISTERED;
+    this.operations = new Map();
+    this.resources = new Map();
+    this.activeRequests = new Map();
+    this.lastError = null;
+    this.lastActiveAt = null;
+    this.onActivate = typeof options.onActivate === "function" ? options.onActivate : null;
+    this.onSuspend = typeof options.onSuspend === "function" ? options.onSuspend : null;
+    this.onRecover = typeof options.onRecover === "function" ? options.onRecover : null;
+    this.canSuspendHook = typeof options.canSuspend === "function" ? options.canSuspend : null;
+    this.onDispose = typeof options.onDispose === "function" ? options.onDispose : null;
+  }
+
+  registerOperation(name, handler) {
+    const operation = String(name || "").trim();
+    if (!operation || typeof handler !== "function") {
+      throw new Error("registerOperation requires a name and handler");
+    }
+    this.operations.set(operation, handler);
+    return this;
+  }
+
+  own(name, resource) {
+    const key = String(name || "").trim();
+    if (!key) throw new Error("runtime resource name is required");
+    if (this.resources.has(key)) {
+      throw new Error(`runtime resource already exists: ${key}`);
+    }
+    this.resources.set(key, resource);
+    return resource;
+  }
+
+  resource(name) {
+    return this.resources.get(name);
+  }
+
+  async activate() {
+    if (this.state === RUNTIME_STATES.ACTIVE) return this;
+    if (this.state === RUNTIME_STATES.DISPOSED) {
+      throw new Error("disposed runtime cannot be activated");
+    }
+    this.state = RUNTIME_STATES.ACTIVATING;
+    try {
+      if (this.onActivate) await this.onActivate(this);
+      this.state = RUNTIME_STATES.ACTIVE;
+      this.lastActiveAt = new Date().toISOString();
+      this.lastError = null;
+      return this;
+    } catch (err) {
+      this.fail(err);
+      throw err;
+    }
+  }
+
+  async call(operation, args = {}, requestContext = {}) {
+    if (this.state !== RUNTIME_STATES.ACTIVE) {
+      const err = new Error(
+        `project runtime ${this.context.projectId} is not active (${this.state})`
+      );
+      err.code = "PROJECT_RUNTIME_NOT_ACTIVE";
+      throw err;
+    }
+    const handler = this.operations.get(String(operation || ""));
+    if (!handler) {
+      const err = new Error(`unknown project runtime operation: ${operation || ""}`);
+      err.code = "PROJECT_RUNTIME_UNKNOWN_OPERATION";
+      throw err;
+    }
+    const requestId = String(requestContext.requestId || randomUUID());
+    if (this.activeRequests.has(requestId)) {
+      const err = new Error(`duplicate project runtime request: ${requestId}`);
+      err.code = "PROJECT_RUNTIME_DUPLICATE_REQUEST";
+      throw err;
+    }
+    const controller = new AbortController();
+    const externalSignal = requestContext.signal;
+    const abortFromExternal = () => controller.abort(externalSignal.reason);
+    if (externalSignal) {
+      if (externalSignal.aborted) abortFromExternal();
+      else externalSignal.addEventListener("abort", abortFromExternal, { once: true });
+    }
+    this.activeRequests.set(requestId, controller);
+    this.lastActiveAt = new Date().toISOString();
+    try {
+      return await handler(args, {
+        context: this.context,
+        requestContext: {
+          ...requestContext,
+          requestId,
+        },
+        runtime: this,
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err && err.runtimeFatal === true) this.fail(err);
+      throw err;
+    } finally {
+      this.activeRequests.delete(requestId);
+      if (externalSignal) externalSignal.removeEventListener("abort", abortFromExternal);
+    }
+  }
+
+  cancel(requestId, reason = "project runtime request cancelled") {
+    const controller = this.activeRequests.get(String(requestId || ""));
+    if (!controller) return false;
+    controller.abort(new Error(reason));
+    return true;
+  }
+
+  fail(err) {
+    this.lastError = {
+      code: err && err.code ? String(err.code) : "PROJECT_RUNTIME_FAILED",
+      message: err && err.message ? err.message : String(err || "runtime failed"),
+      at: new Date().toISOString(),
+    };
+    this.state = RUNTIME_STATES.FAILED;
+  }
+
+  canSuspend() {
+    if (this.state !== RUNTIME_STATES.ACTIVE || this.activeRequests.size > 0) return false;
+    if (this.canSuspendHook) return this.canSuspendHook(this) === true;
+    return true;
+  }
+
+  async suspend() {
+    if (!this.canSuspend()) {
+      const err = new Error(`project runtime ${this.context.projectId} cannot suspend`);
+      err.code = "PROJECT_RUNTIME_BUSY";
+      throw err;
+    }
+    this.state = RUNTIME_STATES.DRAINING;
+    try {
+      if (this.onSuspend) await this.onSuspend(this);
+      this.state = RUNTIME_STATES.DORMANT;
+    } catch (err) {
+      this.fail(err);
+      throw err;
+    }
+  }
+
+  async recover() {
+    if (this.state !== RUNTIME_STATES.FAILED) return this;
+    this.state = RUNTIME_STATES.ACTIVATING;
+    try {
+      if (this.onRecover) await this.onRecover(this);
+      this.state = RUNTIME_STATES.ACTIVE;
+      this.lastActiveAt = new Date().toISOString();
+      this.lastError = null;
+      return this;
+    } catch (err) {
+      this.fail(err);
+      throw err;
+    }
+  }
+
+  dispose() {
+    if (this.state === RUNTIME_STATES.DISPOSED) return;
+    this.state = RUNTIME_STATES.DRAINING;
+    for (const controller of this.activeRequests.values()) {
+      controller.abort(new Error("project runtime disposed"));
+    }
+    this.activeRequests.clear();
+    if (this.onDispose) {
+      try {
+        this.onDispose(this);
+      } catch (err) {
+        this.lastError = {
+          code: err && err.code ? String(err.code) : "PROJECT_RUNTIME_DISPOSE_FAILED",
+          message: err && err.message ? err.message : String(err || "runtime dispose failed"),
+          at: new Date().toISOString(),
+        };
+      }
+    }
+    this.state = RUNTIME_STATES.DISPOSED;
+  }
+
+  status() {
+    return {
+      project_id: this.context.projectId,
+      project_root: this.context.projectRoot,
+      project_name: this.context.projectName,
+      topology: this.context.daemonTopology,
+      generation: this.context.runtimeGeneration,
+      state: this.state,
+      active_request_count: this.activeRequests.size,
+      resource_count: this.resources.size,
+      last_active_at: this.lastActiveAt,
+      last_error: this.lastError,
+    };
+  }
+}
+
+function createProjectRuntime(context, options = {}) {
+  return new ProjectRuntime(context, options);
+}
+
+module.exports = {
+  ProjectRuntime,
+  RUNTIME_STATES,
+  createProjectRuntime,
+};

package/src/runtime/daemon/projectRuntimeGateway.js

@@ -11,6 +11,7 @@ const {
   assertToolAllowedForCallerTier,
 } = require("../../tools/registry");
 const { CALLER_TIERS } = require("../../tools/types");
+const { ProjectRuntimeManager } = require("./projectRuntimeManager");
 
 const MCP_EXPOSED_SHARED_TOOLS = Object.freeze([
   "read_project_registry",
@@ -140,6 +141,71 @@ class LocalProjectRuntimeGateway {
   }
 }
 
+class ManagedProjectRuntimeGateway {
+  constructor(options = {}) {
+    this.options = options;
+    this.activeRequestProjects = new Map();
+    if (options.manager) {
+      this.manager = options.manager;
+    } else {
+      const managerOptions = options.managerOptions || {};
+      const callerConfigureRuntime = managerOptions.configureRuntime;
+      this.manager = new ProjectRuntimeManager({
+        ...managerOptions,
+        configureRuntime: (runtime, context) => {
+          for (const operation of [
+            ...CONTROL_PLANE_OPERATIONS,
+            ...MCP_EXPOSED_SHARED_TOOLS.filter((name) => name !== "read_project_registry"),
+          ]) {
+            runtime.registerOperation(operation, (args, callContext) =>
+              executeProjectRuntimeOperation(
+                context.projectRoot,
+                operation,
+                args,
+                {
+                  ...callContext.requestContext,
+                  signal: callContext.signal,
+                },
+                this.options
+              ));
+          }
+          if (typeof callerConfigureRuntime === "function") {
+            callerConfigureRuntime(runtime, context);
+          }
+        },
+      });
+    }
+  }
+
+  async call(projectRoot, operation, args = {}, context = {}) {
+    const requestId = String(context.requestId || context.toolCallId || crypto.randomUUID());
+    this.activeRequestProjects.set(requestId, projectRoot);
+    try {
+      return await this.manager.call(projectRoot, operation, args, {
+        ...context,
+        requestId,
+      });
+    } finally {
+      this.activeRequestProjects.delete(requestId);
+    }
+  }
+
+  cancel(requestId) {
+    const id = String(requestId || "");
+    const projectRoot = this.activeRequestProjects.get(id);
+    return projectRoot ? this.manager.cancel(projectRoot, id) : false;
+  }
+
+  status() {
+    return this.manager.status();
+  }
+
+  dispose() {
+    this.manager.dispose();
+    this.activeRequestProjects.clear();
+  }
+}
+
 function projectRuntimeError(code, message) {
   const err = new Error(String(message || "project runtime request failed"));
   err.code = String(code || "project_runtime_error");
@@ -344,14 +410,20 @@ function createSocketProjectRuntimeGateway(options = {}) {
   return new SocketProjectRuntimeGateway(options);
 }
 
+function createManagedProjectRuntimeGateway(options = {}) {
+  return new ManagedProjectRuntimeGateway(options);
+}
+
 module.exports = {
   MCP_EXPOSED_SHARED_TOOLS,
   CONTROL_PLANE_OPERATIONS,
   stripRoutingArgs,
   executeProjectRuntimeOperation,
   LocalProjectRuntimeGateway,
+  ManagedProjectRuntimeGateway,
   SocketProjectRuntimeGateway,
   createLocalProjectRuntimeGateway,
+  createManagedProjectRuntimeGateway,
   createSocketProjectRuntimeGateway,
   connectProjectRuntimeSocket,
   resolveCallTimeoutMs,