u-foo 1.5.0 → 1.6.0

package/src/daemon/index.js

@@ -378,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 || "";
@@ -943,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({

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}`);
       }

package/src/daemon/ops.js

@@ -1,4 +1,4 @@
-const { spawn } = require("child_process");
+const { spawn, spawnSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const { loadConfig } = require("../config");
@@ -827,43 +827,55 @@ async function resumeAgents(projectRoot, target = "", processManager = null) {
 }
 
 async function closeAgent(projectRoot, agentId) {
-  if (process.platform !== "darwin") {
-    return false;
-  }
   const resolvedId = resolveAgentId(projectRoot, agentId);
   const busPath = getUfooPaths(projectRoot).agentsFile;
-  let pid = null;
+  let pid = 0;
   let launchMode = "";
   let tty = "";
   let terminalApp = "";
+  let tmuxPane = "";
+  let found = false;
   try {
     const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
     const entry = bus.agents?.[resolvedId];
     if (entry) {
-      if (entry.pid) pid = entry.pid;
+      found = true;
+      const parsedPid = Number.parseInt(entry.pid, 10);
+      pid = Number.isFinite(parsedPid) && parsedPid > 0 ? parsedPid : 0;
       launchMode = entry.launch_mode || "";
       tty = entry.tty || "";
       terminalApp = entry.terminal_app || "";
+      tmuxPane = entry.tmux_pane || "";
     }
   } catch {
-    pid = null;
+    found = false;
+  }
+
+  if (!found) {
+    return { ok: true, already_stopped: true, resolved_agent_id: resolvedId };
   }
+
   const adapterRouter = createTerminalAdapterRouter();
   const adapter = adapterRouter.getAdapter({ launchMode, agentId: resolvedId });
-  const canCloseWindow = adapter.capabilities.supportsWindowClose && tty;
+  const canCloseWindow = process.platform === "darwin"
+    && Boolean(adapter.capabilities.supportsWindowClose)
+    && Boolean(tty);
 
   // Close process first for faster state transition in chat.
   let sentSignal = false;
-  if (pid) {
+  let killErr = null;
+  if (pid > 0) {
     try {
       process.kill(pid, "SIGTERM");
       sentSignal = true;
-    } catch {
+    } catch (err) {
+      killErr = err || null;
       sentSignal = false;
     }
   }
 
-  if (sentSignal || (!pid && canCloseWindow)) {
+  const pidGone = pid > 0 && !sentSignal && !isAgentPidAlive(pid);
+  if (sentSignal || pid === 0 || pidGone) {
     markAgentInactive(projectRoot, resolvedId);
   }
 
@@ -872,7 +884,29 @@ async function closeAgent(projectRoot, agentId) {
     void closeTerminalWindowByTty(tty, terminalApp).catch(() => false);
   }
 
-  return sentSignal || (!pid && canCloseWindow);
+  // Tmux pane cleanup: kill the pane after sending SIGTERM to the process.
+  if (launchMode === "tmux" && tmuxPane) {
+    try {
+      spawnSync("tmux", ["kill-pane", "-t", tmuxPane], { stdio: "ignore", timeout: 3000 });
+    } catch {
+      // ignore - pane may already be gone
+    }
+  }
+
+  if (sentSignal) {
+    return { ok: true, resolved_agent_id: resolvedId };
+  }
+  if (pid === 0 || pidGone) {
+    return { ok: true, already_stopped: true, resolved_agent_id: resolvedId };
+  }
+  const reason = killErr && killErr.message
+    ? killErr.message
+    : "failed to stop process";
+  return {
+    ok: false,
+    error: reason,
+    resolved_agent_id: resolvedId,
+  };
 }
 
 module.exports = { launchAgent, closeAgent, getRecoverableAgents, resumeAgents };

package/src/daemon/status.js

@@ -147,7 +147,9 @@ function buildStatus(projectRoot, options = {}) {
     const launch_mode = meta?.launch_mode || "unknown";
     const tmux_pane = meta?.tmux_pane || "";
     const tty = meta?.tty || "";
-    return { id, nickname, display, launch_mode, tmux_pane, tty };
+    const activity_state = meta?.activity_state || "";
+    const activity_since = meta?.activity_since || "";
+    return { id, nickname, display, launch_mode, tmux_pane, tty, activity_state, activity_since };
   });
 
   return {

package/src/init/index.js

@@ -180,23 +180,52 @@ class UfooInit {
 
     let content = fs.readFileSync(filePath, "utf8");
     const marker = "<!-- ufoo-template -->";
+    const block = `${marker}\n${template}\n${marker}`;
+
     if (content.includes(marker)) {
+      // Replace existing marker block in-place
       const startIdx = content.indexOf(marker);
       const endIdx = content.indexOf(marker, startIdx + marker.length);
       if (endIdx !== -1) {
         content =
           content.slice(0, startIdx) +
-          `${marker}\n${template}\n${marker}` +
+          block +
           content.slice(endIdx + marker.length);
       } else {
-        content += `\n${marker}\n${template}\n${marker}\n`;
+        content =
+          content.slice(0, startIdx) + block + content.slice(startIdx + marker.length);
       }
     } else {
-      content += `\n${marker}\n${template}\n${marker}\n`;
+      // Insert after first heading line for visibility (not buried at end)
+      const headingEnd = this.findFirstHeadingEnd(content);
+      if (headingEnd !== -1) {
+        content =
+          content.slice(0, headingEnd) +
+          `\n${block}\n\n` +
+          content.slice(headingEnd);
+      } else {
+        content = `${block}\n\n${content}`;
+      }
     }
     fs.writeFileSync(filePath, content, "utf8");
   }
 
+  findFirstHeadingEnd(content) {
+    // ATX heading: # ... (allow leading indentation and EOF without trailing newline)
+    const atxHeading = content.match(/^(?:[ \t]{0,3})#{1,6}[ \t]*[^\n]*(?:\n|$)/m);
+    // Setext heading: text line + underline (=== or ---)
+    const setextHeading = content.match(/^[^\n]+\n(?:=+|-+)[ \t]*(?:\n|$)/m);
+
+    let bestMatch = null;
+    if (atxHeading && setextHeading) {
+      bestMatch = atxHeading.index <= setextHeading.index ? atxHeading : setextHeading;
+    } else {
+      bestMatch = atxHeading || setextHeading;
+    }
+    if (!bestMatch) return -1;
+    return bestMatch.index + bestMatch[0].length;
+  }
+
   /**
    * 初始化 context 模块
    */

package/src/ufoo/agentsStore.js

@@ -94,8 +94,52 @@ function loadAgentsData(filePath) {
   return normalizeAgentsData(data);
 }
 
+function parseTimestampMs(value) {
+  const ms = Date.parse(String(value || ""));
+  return Number.isFinite(ms) ? ms : Number.NaN;
+}
+
+function mergeExternalActivityFields(targetMeta, diskMeta) {
+  if (!targetMeta || !diskMeta) return;
+
+  const diskState = toSafeString(diskMeta.activity_state);
+  if (!diskState) return;
+
+  const memoryState = toSafeString(targetMeta.activity_state);
+  const diskSince = toSafeString(diskMeta.activity_since);
+  const memorySince = toSafeString(targetMeta.activity_since);
+  const diskSinceMs = parseTimestampMs(diskSince);
+  const memorySinceMs = parseTimestampMs(memorySince);
+
+  if (!memoryState) {
+    targetMeta.activity_state = diskState;
+    if (diskSince) targetMeta.activity_since = diskSince;
+    return;
+  }
+
+  const preferDisk = Number.isFinite(diskSinceMs)
+    && (!Number.isFinite(memorySinceMs) || diskSinceMs > memorySinceMs);
+  if (preferDisk) {
+    targetMeta.activity_state = diskState;
+    targetMeta.activity_since = diskSince;
+  }
+}
+
 function saveAgentsData(filePath, data) {
   const normalized = normalizeAgentsData(data);
+
+  // Merge externally-managed fields from disk to avoid daemon in-memory writes
+  // overwriting fresher runner/notifier state updates.
+  const disk = readJSON(filePath, null);
+  if (disk && disk.agents && normalized.agents) {
+    for (const [id, diskMeta] of Object.entries(disk.agents)) {
+      if (!diskMeta || typeof diskMeta !== "object") continue;
+      const targetMeta = normalized.agents[id];
+      if (!targetMeta || typeof targetMeta !== "object") continue;
+      mergeExternalActivityFields(targetMeta, diskMeta);
+    }
+  }
+
   writeJSON(filePath, normalized);
 }