u-foo 1.4.1 → 1.5.0

package/src/daemon/ops.js

@@ -37,6 +37,44 @@ function toTmuxBinary(agent = "") {
   return "";
 }
 
+function normalizeLaunchScope(value, fallback = "inplace") {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return fallback;
+  if (raw === "inplace" || raw === "same" || raw === "current" || raw === "tab" || raw === "pane") {
+    return "inplace";
+  }
+  if (
+    raw === "window"
+    || raw === "separate"
+    || raw === "new"
+    || raw === "new-window"
+    || raw === "external"
+    || raw === "1"
+    || raw === "true"
+    || raw === "yes"
+    || raw === "y"
+    || raw === "on"
+  ) {
+    return "window";
+  }
+  if (raw === "0" || raw === "false" || raw === "no" || raw === "n" || raw === "off") {
+    return "inplace";
+  }
+  return fallback;
+}
+
+function normalizeTerminalAppPreference(value = "") {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return "";
+  if (raw === "terminal" || raw === "apple_terminal" || raw === "apple-terminal") {
+    return "terminal";
+  }
+  if (raw === "iterm2" || raw === "iterm" || raw === "iterm.app") {
+    return "iterm2";
+  }
+  return "";
+}
+
 function resolveAgentId(projectRoot, agentId) {
   if (!agentId) return agentId;
   if (agentId.includes(":")) return agentId;
@@ -130,23 +168,40 @@ function runAppleScript(lines) {
   });
 }
 
-async function openTerminalWindow(runCmd) {
+async function openTerminalWindow(runCmd, options = {}) {
   if (process.platform !== "darwin") {
     throw new Error("Terminal mode is only supported on macOS");
   }
 
+  const launchScope = normalizeLaunchScope(options.launchScope, "inplace");
+  const terminalApp = normalizeTerminalAppPreference(options.terminalApp);
+  const preferSeparateWindow = launchScope === "window";
   const escaped = escapeAppleScriptString(runCmd);
+  const shouldTryITerm2 = terminalApp
+    ? terminalApp === "iterm2"
+    : isITerm2();
 
-  if (isITerm2()) {
+  if (shouldTryITerm2) {
     try {
-      const script = [
-        'tell application "iTerm2"',
-        "  tell current window",
-        `    create tab with default profile command "${escaped}"`,
-        "  end tell",
-        "  activate",
-        "end tell",
-      ];
+      const script = preferSeparateWindow
+        ? [
+          'tell application "iTerm2"',
+          `  create window with default profile command "${escaped}"`,
+          "  activate",
+          "end tell",
+        ]
+        : [
+          'tell application "iTerm2"',
+          "  if (count of windows) is 0 then",
+          `    create window with default profile command "${escaped}"`,
+          "  else",
+          "    tell current window",
+          `      create tab with default profile command "${escaped}"`,
+          "    end tell",
+          "  end if",
+          "  activate",
+          "end tell",
+        ];
       await runAppleScript(script);
       return;
     } catch {
@@ -154,13 +209,55 @@ async function openTerminalWindow(runCmd) {
     }
   }
 
-  const script = [
+  if (preferSeparateWindow) {
+    const script = [
+      'tell application "Terminal"',
+      `  do script "${escaped}"`,
+      "  activate",
+      "end tell",
+    ];
+    await runAppleScript(script);
+    return;
+  }
+
+  const preferredScript = [
     'tell application "Terminal"',
-    `do script "${escaped}"`,
-    "activate",
+    "  activate",
+    "  if (count of windows) is 0 then",
+    `    do script "${escaped}"`,
+    "  else",
+    '    tell application "System Events"',
+    '      tell process "Terminal"',
+    '        keystroke "t" using command down',
+    "      end tell",
+    "    end tell",
+    "    delay 0.08",
+    `    do script "${escaped}" in selected tab of front window`,
+    "  end if",
+    "  activate",
     "end tell",
   ];
-  await runAppleScript(script);
+
+  try {
+    await runAppleScript(preferredScript);
+    return;
+  } catch {
+    // Accessibility can block System Events key events; fall back to pure Terminal AppleScript.
+  }
+
+  const fallbackScript = [
+    'tell application "Terminal"',
+    "  activate",
+    "  if (count of windows) is 0 then",
+    `    do script "${escaped}"`,
+    "  else",
+    "    set newTab to (do script \"\" in front window)",
+    `    do script "${escaped}" in newTab`,
+    "  end if",
+    "  activate",
+    "end tell",
+  ];
+  await runAppleScript(fallbackScript);
 }
 
 async function closeTerminalWindowByTty(ttyPath, preferApp = "") {
@@ -262,7 +359,16 @@ async function tryReuseTerminal(projectRoot, subscriberId, meta, agent, sessionI
 /**
  * Spawn managed terminal agent - open a real Terminal session to run the agent
  */
-async function spawnManagedTerminalAgent(projectRoot, agent, nickname = "", processManager = null, extraArgs = [], extraEnv = "") {
+async function spawnManagedTerminalAgent(
+  projectRoot,
+  agent,
+  nickname = "",
+  processManager = null,
+  extraArgs = [],
+  extraEnv = "",
+  launchScope = "window",
+  terminalApp = ""
+) {
   const normalizedAgent = normalizeLaunchAgent(agent);
   const binary = toTerminalBinary(normalizedAgent);
   const agentType = toBusAgentType(normalizedAgent);
@@ -283,7 +389,7 @@ async function spawnManagedTerminalAgent(projectRoot, agent, nickname = "", proc
 
   const runCmd = `cd ${shellEscape(projectRoot)} && ${prefix}${modeEnv}${nickEnv}${envPrefix}${binary}${argText}`;
 
-  await openTerminalWindow(runCmd);
+  await openTerminalWindow(runCmd, { launchScope, terminalApp });
 
   const subscriberId = await waitForNewSubscriber(projectRoot, agentType, existing, 15000);
   return { child: null, subscriberId: subscriberId || null };
@@ -455,9 +561,57 @@ function spawnTmuxWindow(projectRoot, agent, nickname = "", extraArgs = [], extr
   });
 }
 
-async function launchAgent(projectRoot, agent, count = 1, nickname = "", processManager = null) {
+function resolveTmuxPaneTarget() {
+  const explicit = String(process.env.UFOO_TMUX_TARGET || "").trim();
+  if (explicit) return explicit;
+  const preferredPane = String(process.env.UFOO_TMUX_PANE || "").trim();
+  if (preferredPane) return preferredPane;
+  const currentPane = String(process.env.TMUX_PANE || "").trim();
+  if (currentPane) return currentPane;
+  return "";
+}
+
+function spawnTmuxPane(projectRoot, agent, nickname = "", extraArgs = [], extraEnv = "", target = "") {
+  return new Promise((resolve, reject) => {
+    const normalizedAgent = normalizeLaunchAgent(agent);
+    const binary = toTmuxBinary(normalizedAgent);
+    if (!binary) {
+      reject(new Error(`unsupported agent type: ${agent}`));
+      return;
+    }
+    const nickEnv = nickname ? `UFOO_NICKNAME=${shellEscape(nickname)} ` : "";
+    const modeEnv = "UFOO_LAUNCH_MODE=tmux ";
+    const ttyEnv = "UFOO_TTY_OVERRIDE=$(tty) ";
+    const args = Array.isArray(extraArgs) ? extraArgs : [];
+    const envPrefix = extraEnv ? `${String(extraEnv).trim()} ` : "";
+    const argText = args.length > 0 ? ` ${args.map(shellEscape).join(" ")}` : "";
+    const setPaneEnv = `export TMUX_PANE=$(tmux display-message -p '#{pane_id}'); `;
+    const runCmd = `cd ${shellEscape(projectRoot)} && ${setPaneEnv}${modeEnv}${nickEnv}${ttyEnv}${envPrefix}${binary}${argText}`;
+
+    const tmuxArgs = ["split-window", "-d"];
+    const normalizedTarget = String(target || "").trim();
+    if (normalizedTarget) {
+      tmuxArgs.push("-t", normalizedTarget);
+    }
+    tmuxArgs.push(runCmd);
+
+    const proc = spawn("tmux", tmuxArgs);
+    let stderr = "";
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString("utf8");
+    });
+    proc.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || "tmux split-window failed"));
+    });
+  });
+}
+
+async function launchAgent(projectRoot, agent, count = 1, nickname = "", processManager = null, options = {}) {
   const config = loadConfig(projectRoot);
   const mode = config.launchMode || "terminal";
+  const launchScope = normalizeLaunchScope(options.launchScope, "inplace");
+  const terminalApp = normalizeTerminalAppPreference(options.terminalApp);
   const normalizedAgent = normalizeLaunchAgent(agent);
   if (!normalizedAgent) {
     throw new Error(`unsupported agent type: ${agent}`);
@@ -465,7 +619,7 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
 
   if (mode === "internal") {
     const result = await spawnInternalAgent(projectRoot, normalizedAgent, count, nickname, processManager);
-    return { mode: "internal", subscriberIds: result.subscriberIds };
+    return { mode: "internal", launchScope, subscriberIds: result.subscriberIds };
   }
   if (mode === "tmux") {
     // Check if tmux is available
@@ -489,14 +643,27 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
         process.env.UFOO_TMUX_SESSION = firstSession;
       }
     }
+    const paneTarget = resolveTmuxPaneTarget();
+    const useSeparateWindow = launchScope === "window";
     for (let i = 0; i < count; i += 1) {
       // Use "ucode" as default nickname for ufoo/ucode agents
       const defaultNick = normalizedAgent === "ufoo" ? "ucode" : normalizedAgent;
       const nick = count > 1 ? `${nickname || defaultNick}-${i + 1}` : (nickname || "");
-      // eslint-disable-next-line no-await-in-loop
-      await spawnTmuxWindow(projectRoot, normalizedAgent, nick);
+      if (useSeparateWindow) {
+        // eslint-disable-next-line no-await-in-loop
+        await spawnTmuxWindow(projectRoot, normalizedAgent, nick);
+      } else {
+        try {
+          // eslint-disable-next-line no-await-in-loop
+          await spawnTmuxPane(projectRoot, normalizedAgent, nick, [], "", paneTarget);
+        } 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);
+        }
+      }
     }
-    return { mode: "tmux" };
+    return { mode: "tmux", launchScope, subscriberIds: [] };
   }
   // terminal mode - daemon 作为父进程，输出到终端窗口
   if (process.platform !== "darwin") {
@@ -509,11 +676,20 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
     const defaultNick = normalizedAgent === "ufoo" ? "ucode" : normalizedAgent;
     const nick = count > 1 ? `${nickname || defaultNick}-${i + 1}` : (nickname || "");
     // eslint-disable-next-line no-await-in-loop
-    const result = await spawnManagedTerminalAgent(projectRoot, normalizedAgent, nick, processManager);
+    const result = await spawnManagedTerminalAgent(
+      projectRoot,
+      normalizedAgent,
+      nick,
+      processManager,
+      [],
+      "",
+      launchScope,
+      terminalApp
+    );
     if (result.subscriberId) subscriberIds.push(result.subscriberId);
   }
 
-  return { mode: "terminal", subscriberIds };
+  return { mode: "terminal", launchScope, subscriberIds };
 }
 
 function normalizeAgentType(agentType) {

package/src/projects/projectId.js

@@ -0,0 +1,29 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+function trimTrailingSlashes(value) {
+  if (!value) return value;
+  return value.replace(/\/+$/, "") || "/";
+}
+
+function canonicalProjectRoot(projectRoot) {
+  const input = String(projectRoot || "").trim();
+  if (!input) {
+    throw new Error("projectRoot is required");
+  }
+  const resolved = path.resolve(input);
+  const canonical = fs.realpathSync.native ? fs.realpathSync.native(resolved) : fs.realpathSync(resolved);
+  return trimTrailingSlashes(canonical);
+}
+
+function buildProjectId(projectRoot) {
+  const canonical = canonicalProjectRoot(projectRoot);
+  return crypto.createHash("sha1").update(canonical).digest("hex").slice(0, 12);
+}
+
+module.exports = {
+  trimTrailingSlashes,
+  canonicalProjectRoot,
+  buildProjectId,
+};

package/src/projects/registry.js

@@ -0,0 +1,279 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { canonicalProjectRoot, buildProjectId, trimTrailingSlashes } = require("./projectId");
+const { getUfooPaths } = require("../ufoo/paths");
+
+const DEFAULT_STALE_TTL_MS = 30 * 1000;
+const DEFAULT_TMP_CLEANUP_AGE_MS = 5 * 60 * 1000;
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function canonicalizeForRecord(projectRoot) {
+  const input = String(projectRoot || "").trim();
+  if (!input) throw new Error("projectRoot is required");
+  try {
+    return canonicalProjectRoot(input);
+  } catch (err) {
+    if (!err || err.code === "ENOENT") {
+      // Keep stale records readable when project path was deleted or moved.
+      return trimTrailingSlashes(path.resolve(input));
+    }
+    // Unexpected IO errors should be visible, but keep fallback behavior.
+    // eslint-disable-next-line no-console
+    console.warn(`[projects] canonicalize fallback for ${input}: ${err.message || err}`);
+    // Keep stale records readable even when project path no longer exists.
+    return trimTrailingSlashes(path.resolve(input));
+  }
+}
+
+function resolveRuntimeDir(options = {}) {
+  if (options.runtimeDir) return options.runtimeDir;
+  return path.join(os.homedir(), ".ufoo", "projects", "runtime");
+}
+
+function normalizeIsoTimestamp(value, fallback = new Date().toISOString()) {
+  if (!value) return fallback;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return fallback;
+  return parsed.toISOString();
+}
+
+function runtimeFilePathByProjectId(projectId, options = {}) {
+  const runtimeDir = resolveRuntimeDir(options);
+  return path.join(runtimeDir, `${projectId}.json`);
+}
+
+function runtimeFilePathByProjectRoot(projectRoot, options = {}) {
+  return runtimeFilePathByProjectId(buildProjectId(projectRoot), options);
+}
+
+function readJsonFileSafe(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonAtomic(filePath, data) {
+  ensureDir(path.dirname(filePath));
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmpPath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+  fs.renameSync(tmpPath, filePath);
+}
+
+function cleanupRuntimeTmpFiles(runtimeDir, options = {}) {
+  if (!fs.existsSync(runtimeDir)) return;
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const minAgeMs = Number.isFinite(options.tmpCleanupAgeMs)
+    ? options.tmpCleanupAgeMs
+    : DEFAULT_TMP_CLEANUP_AGE_MS;
+  const files = fs.readdirSync(runtimeDir).filter((name) => name.endsWith(".tmp"));
+  for (const file of files) {
+    const target = path.join(runtimeDir, file);
+    try {
+      const stat = fs.statSync(target);
+      const ageMs = Math.max(0, nowMs - stat.mtimeMs);
+      if (ageMs < minAgeMs) continue;
+      fs.unlinkSync(target);
+    } catch {
+      // Ignore temp cleanup failures.
+    }
+  }
+}
+
+function parseDaemonPid(value, fallback = null) {
+  if (value === null || value === undefined || value === "") return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+
+function isPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err && err.code === "EPERM") return true;
+    return false;
+  }
+}
+
+function isSocketAlive(socketPath) {
+  if (!socketPath || typeof socketPath !== "string") return false;
+  if (!fs.existsSync(socketPath)) return false;
+  try {
+    const stat = fs.statSync(socketPath);
+    return stat.isSocket();
+  } catch {
+    return false;
+  }
+}
+
+function normalizeStatus(value, fallback = "running") {
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === "running" || raw === "stale" || raw === "stopped") return raw;
+  return fallback;
+}
+
+function normalizeRuntimeEntry(entry = {}, fallbackProjectRoot = "") {
+  const canonicalRoot = canonicalizeForRecord(entry.project_root || fallbackProjectRoot);
+  const knownProjectId = String(entry.project_id || "").trim();
+  const projectId = /^[a-f0-9]{12}$/.test(knownProjectId)
+    ? knownProjectId
+    : buildProjectId(canonicalRoot);
+  const paths = getUfooPaths(canonicalRoot);
+  return {
+    version: 1,
+    project_id: projectId,
+    project_root: canonicalRoot,
+    project_name: String(entry.project_name || path.basename(canonicalRoot) || canonicalRoot),
+    daemon_pid: parseDaemonPid(entry.daemon_pid, null),
+    socket_path: String(entry.socket_path || paths.ufooSock),
+    status: normalizeStatus(entry.status, "running"),
+    last_seen: normalizeIsoTimestamp(entry.last_seen),
+    last_switch_at: entry.last_switch_at ? normalizeIsoTimestamp(entry.last_switch_at) : undefined,
+  };
+}
+
+function readProjectRuntimeByRoot(projectRoot, options = {}) {
+  const filePath = runtimeFilePathByProjectRoot(projectRoot, options);
+  if (!fs.existsSync(filePath)) return null;
+  const parsed = readJsonFileSafe(filePath);
+  if (!parsed || typeof parsed !== "object") return null;
+  try {
+    return normalizeRuntimeEntry(parsed, projectRoot);
+  } catch {
+    return null;
+  }
+}
+
+function upsertProjectRuntime(entry = {}, options = {}) {
+  const projectRoot = entry.projectRoot || entry.project_root;
+  if (!projectRoot) throw new Error("projectRoot is required");
+
+  const existing = readProjectRuntimeByRoot(projectRoot, options) || {};
+  const normalized = normalizeRuntimeEntry({
+    ...existing,
+    ...entry,
+    project_root: projectRoot,
+    project_name: entry.projectName || entry.project_name || existing.project_name,
+    daemon_pid: parseDaemonPid(entry.daemonPid ?? entry.daemon_pid, existing.daemon_pid),
+    socket_path: entry.socketPath || entry.socket_path || existing.socket_path,
+    status: normalizeStatus(entry.status, existing.status || "running"),
+    last_seen: normalizeIsoTimestamp(entry.lastSeen || entry.last_seen || new Date().toISOString()),
+    last_switch_at: entry.lastSwitchAt || entry.last_switch_at || existing.last_switch_at,
+  }, projectRoot);
+
+  const filePath = runtimeFilePathByProjectId(normalized.project_id, options);
+  writeJsonAtomic(filePath, normalized);
+  return normalized;
+}
+
+function markProjectStopped(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 : null,
+    socketPath: existing ? existing.socket_path : paths.ufooSock,
+    status: "stopped",
+    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;
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const pidAlive = isPidAlive(parseDaemonPid(entry.daemon_pid, null));
+  const socketAlive = isSocketAlive(entry.socket_path);
+  const running = pidAlive && socketAlive;
+
+  const parsedLastSeen = new Date(entry.last_seen);
+  const lastSeenMs = Number.isNaN(parsedLastSeen.getTime()) ? null : parsedLastSeen.getTime();
+  const ageMs = lastSeenMs === null ? null : Math.max(0, nowMs - lastSeenMs);
+
+  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 (ageMs === null || ageMs > staleTtlMs) {
+    status = "stale";
+  }
+
+  return {
+    ...entry,
+    status,
+    validation: {
+      pid_alive: pidAlive,
+      socket_alive: socketAlive,
+      stale_ttl_ms: staleTtlMs,
+      age_ms: ageMs,
+      validated_at: new Date(nowMs).toISOString(),
+    },
+  };
+}
+
+function listProjectRuntimes(options = {}) {
+  const runtimeDir = resolveRuntimeDir(options);
+  if (!fs.existsSync(runtimeDir)) return [];
+  if (options.cleanupTmp === true) {
+    cleanupRuntimeTmpFiles(runtimeDir, options);
+  }
+
+  const files = fs.readdirSync(runtimeDir)
+    .filter((name) => name.endsWith(".json"))
+    .sort();
+
+  const rows = [];
+  for (const file of files) {
+    const parsed = readJsonFileSafe(path.join(runtimeDir, file));
+    if (!parsed || typeof parsed !== "object") continue;
+    try {
+      const normalized = normalizeRuntimeEntry(parsed);
+      rows.push(options.validate === false ? normalized : validateProjectRuntime(normalized, options));
+    } catch {
+      // Ignore malformed runtime entries.
+    }
+  }
+
+  rows.sort((a, b) => {
+    const aSeen = Date.parse(a.last_seen || 0) || 0;
+    const bSeen = Date.parse(b.last_seen || 0) || 0;
+    return bSeen - aSeen;
+  });
+
+  return rows;
+}
+
+function getCurrentProjectRuntime(projectRoot, options = {}) {
+  const runtime = readProjectRuntimeByRoot(projectRoot, options);
+  if (!runtime) return null;
+  if (options.validate === false) return runtime;
+  return validateProjectRuntime(runtime, options);
+}
+
+module.exports = {
+  DEFAULT_STALE_TTL_MS,
+  resolveRuntimeDir,
+  runtimeFilePathByProjectId,
+  runtimeFilePathByProjectRoot,
+  upsertProjectRuntime,
+  markProjectStopped,
+  listProjectRuntimes,
+  getCurrentProjectRuntime,
+  validateProjectRuntime,
+};