u-foo 1.0.3 → 1.0.6

package/src/daemon/providerSessions.js

@@ -0,0 +1,291 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const EventBus = require("../bus");
+const { loadAgentsData, saveAgentsData } = require("../ufoo/agentsStore");
+const { getUfooPaths } = require("../ufoo/paths");
+
+/**
+ * Build probe marker using nickname (e.g., "claude-47")
+ * Simpler than the old token format, easier to search
+ */
+function buildProbeMarker(nickname) {
+  return nickname || "";
+}
+
+/**
+ * Build probe command: /ufoo <nickname> for claude-code, ufoo <nickname> for codex
+ */
+function buildProbeCommand(agentType, nickname) {
+  const base = `ufoo ${nickname}`;
+  return agentType === "claude-code" ? `/${base}` : base;
+}
+
+function readLines(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return raw.split(/\r?\n/).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if a history record contains our probe marker
+ * Searches for "/ufoo <marker>" or "ufoo <marker>" pattern
+ */
+function recordContainsMarker(record, marker, rawLine) {
+  if (!marker) return false;
+
+  // Build both possible patterns
+  const patterns = [`/ufoo ${marker}`, `ufoo ${marker}`];
+
+  // Check raw line first (fastest)
+  if (rawLine) {
+    for (const pattern of patterns) {
+      if (rawLine.includes(pattern)) return true;
+    }
+  }
+
+  if (!record || typeof record !== "object") return false;
+
+  // Check common fields where user input might appear
+  const fields = [
+    record.display,     // history.jsonl uses "display" for user input
+    record.text,
+    record.prompt,
+    record.input,
+    record.message,
+    record.query,
+    record.content,
+  ];
+
+  for (const field of fields) {
+    if (typeof field === "string") {
+      for (const pattern of patterns) {
+        if (field.includes(pattern)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+function extractSessionId(record, rawLine) {
+  if (record && typeof record === "object") {
+    return record.session_id || record.sessionId || record.session || "";
+  }
+  if (typeof rawLine === "string") {
+    const match = rawLine.match(/"session(?:_id|Id)"\s*:\s*"([^"]+)"/);
+    if (match && match[1]) return match[1];
+  }
+  return "";
+}
+
+/**
+ * Find session ID in a history file by searching for the probe marker
+ */
+function findSessionInFile(filePath, marker) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  const lines = readLines(filePath);
+
+  // Search from end (most recent first)
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i];
+
+    // Quick check: line must contain the marker string
+    if (!line.includes(marker)) continue;
+
+    let record = null;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      record = null;
+    }
+
+    if (!recordContainsMarker(record, marker, line)) continue;
+
+    const sessionId = extractSessionId(record, line);
+    if (sessionId) {
+      return { sessionId, source: filePath };
+    }
+  }
+  return null;
+}
+
+function getClaudeHistoryPath() {
+  return path.join(os.homedir(), ".claude", "history.jsonl");
+}
+
+function getCodexHistoryPath() {
+  return path.join(os.homedir(), ".codex", "history.jsonl");
+}
+
+/**
+ * Search provider history for the probe marker and return session ID
+ */
+function resolveProviderSession(agentType, marker) {
+  if (agentType === "codex") {
+    return findSessionInFile(getCodexHistoryPath(), marker);
+  }
+  if (agentType === "claude-code") {
+    return findSessionInFile(getClaudeHistoryPath(), marker);
+  }
+  return null;
+}
+
+/**
+ * Save probe marker to agents data (for debugging/tracking)
+ */
+function persistProbeMarker(projectRoot, subscriberId, marker) {
+  const filePath = getUfooPaths(projectRoot).agentsFile;
+  const data = loadAgentsData(filePath);
+  const meta = data.agents[subscriberId] || {};
+  data.agents[subscriberId] = {
+    ...meta,
+    provider_session_probe: marker,
+    provider_session_updated_at: new Date().toISOString(),
+  };
+  saveAgentsData(filePath, data);
+}
+
+function persistProviderSession(projectRoot, subscriberId, payload) {
+  const filePath = getUfooPaths(projectRoot).agentsFile;
+  const data = loadAgentsData(filePath);
+  const meta = data.agents[subscriberId] || {};
+  data.agents[subscriberId] = {
+    ...meta,
+    provider_session_id: payload.sessionId || "",
+    provider_session_source: payload.source || "",
+    provider_session_updated_at: new Date().toISOString(),
+  };
+  saveAgentsData(filePath, data);
+}
+
+/**
+ * Retry searching for session ID with the given marker
+ */
+async function resolveWithRetries(agentType, marker, attempts = 12, intervalMs = 2000) {
+  for (let i = 0; i < attempts; i += 1) {
+    const resolved = resolveProviderSession(agentType, marker);
+    if (resolved && resolved.sessionId) return resolved;
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return null;
+}
+
+
+function loadProviderSessionCache(projectRoot) {
+  const filePath = getUfooPaths(projectRoot).agentsFile;
+  const data = loadAgentsData(filePath);
+  const cache = new Map();
+  for (const [id, meta] of Object.entries(data.agents || {})) {
+    if (meta && meta.provider_session_id) {
+      cache.set(id, {
+        sessionId: meta.provider_session_id,
+        source: meta.provider_session_source || "",
+        updated_at: meta.provider_session_updated_at || "",
+      });
+    }
+  }
+  return cache;
+}
+
+/**
+ * Execute probe: inject command and search for session ID
+ */
+async function executeProbe({
+  projectRoot,
+  subscriberId,
+  agentType,
+  nickname,
+  attempts = 15,
+  intervalMs = 2000,
+  onResolved = null,
+}) {
+  const marker = buildProbeMarker(nickname);
+
+  try {
+    const command = buildProbeCommand(agentType, nickname);
+    const bus = new EventBus(projectRoot);
+    bus.ensureBus();
+    await bus.inject(subscriberId, command);
+  } catch {
+    // ignore injection failures
+  }
+
+  const resolved = await resolveWithRetries(agentType, marker, attempts, intervalMs);
+  if (resolved && resolved.sessionId) {
+    persistProviderSession(projectRoot, subscriberId, resolved);
+    if (typeof onResolved === "function") {
+      onResolved(subscriberId, resolved);
+    }
+  }
+}
+
+/**
+ * Schedule a provider session probe
+ *
+ * @param {Object} options
+ * @param {string} options.projectRoot - Project root directory
+ * @param {string} options.subscriberId - Subscriber ID (e.g., "claude-code:abc123")
+ * @param {string} options.agentType - Agent type ("claude-code" or "codex")
+ * @param {string} options.nickname - Agent nickname (e.g., "claude-47")
+ * @param {number} options.delayMs - Delay before injection
+ * @param {number} options.attempts - Number of search attempts
+ * @param {number} options.intervalMs - Interval between attempts
+ * @param {Function} options.onResolved - Callback when session ID is found
+ */
+function scheduleProviderSessionProbe({
+  projectRoot,
+  subscriberId,
+  agentType,
+  nickname,
+  delayMs = 8000,
+  attempts = 15,
+  intervalMs = 2000,
+  onResolved = null,
+}) {
+  if (!subscriberId || !agentType) return null;
+  if (agentType !== "codex" && agentType !== "claude-code") return null;
+  if (!nickname) return null;
+
+  const marker = buildProbeMarker(nickname);
+  persistProbeMarker(projectRoot, subscriberId, marker);
+
+  let executed = false;
+  let timer = null;
+
+  const execute = async () => {
+    if (executed) return;
+    executed = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    await executeProbe({
+      projectRoot,
+      subscriberId,
+      agentType,
+      nickname,
+      attempts,
+      intervalMs,
+      onResolved,
+    });
+  };
+
+  // Schedule delayed execution (fallback)
+  timer = setTimeout(execute, delayMs);
+
+  // Return handle for early trigger
+  return {
+    subscriberId,
+    marker,
+    triggerNow: execute,
+  };
+}
+
+module.exports = {
+  scheduleProviderSessionProbe,
+  loadProviderSessionCache,
+};

package/src/daemon/run.js

@@ -9,6 +9,8 @@ function runDaemonCli(argv) {
   const provider = process.env.UFOO_AGENT_PROVIDER || config.agentProvider || "codex-cli";
   const model =
     process.env.UFOO_AGENT_MODEL || config.agentModel || (provider === "claude-cli" ? "opus" : "");
+  const resumeMode = process.env.UFOO_FORCE_RESUME === "1" ? "force" : "auto";
+  const launchMode = config.launchMode || "terminal";
 
   if (cmd === "start" || cmd === "--start") {
     if (isRunning(projectRoot)) return;
@@ -23,13 +25,44 @@ function runDaemonCli(argv) {
       child.unref();
       return;
     }
-    startDaemon({ projectRoot, provider, model });
+    startDaemon({ projectRoot, provider, model, resumeMode });
     return;
   }
   if (cmd === "stop" || cmd === "--stop") {
     stopDaemon(projectRoot);
     return;
   }
+  if (cmd === "restart" || cmd === "--restart") {
+    // Stop if running
+    if (isRunning(projectRoot)) {
+      stopDaemon(projectRoot);
+      // Wait for clean shutdown
+      let attempts = 0;
+      while (isRunning(projectRoot) && attempts < 50) {
+        attempts++;
+        require("child_process").spawnSync("sleep", ["0.1"]);
+      }
+    }
+    // Start fresh daemon
+    if (!process.env.UFOO_DAEMON_CHILD) {
+      const { spawn } = require("child_process");
+      const forceResume = launchMode !== "terminal";
+      const childEnv = { ...process.env, UFOO_DAEMON_CHILD: "1" };
+      if (forceResume) childEnv.UFOO_FORCE_RESUME = "1";
+      const child = spawn(process.execPath, [path.join(__dirname, "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
+        detached: true,
+        stdio: "ignore",
+        env: childEnv,
+        cwd: projectRoot,
+      });
+      child.unref();
+      return;
+    }
+    // Skip auto-resume on restart in terminal mode to avoid reopening stale terminals.
+    const forceResume = launchMode !== "terminal";
+    startDaemon({ projectRoot, provider, model, resumeMode: forceResume ? "force" : "none" });
+    return;
+  }
   if (cmd === "status" || cmd === "--status") {
     const running = isRunning(projectRoot);
     // eslint-disable-next-line no-console

package/src/daemon/status.js

@@ -1,8 +1,10 @@
 const fs = require("fs");
 const path = require("path");
+const { getUfooPaths } = require("../ufoo/paths");
+const { isMetaActive } = require("../bus/utils");
 
 function readBus(projectRoot) {
-  const busPath = path.join(projectRoot, ".ufoo", "bus", "bus.json");
+  const busPath = getUfooPaths(projectRoot).agentsFile;
   try {
     return JSON.parse(fs.readFileSync(busPath, "utf8"));
   } catch {
@@ -11,7 +13,9 @@ function readBus(projectRoot) {
 }
 
 function readDecisions(projectRoot) {
-  const dir = path.join(projectRoot, ".ufoo", "context", "DECISIONS");
+  const DecisionsManager = require("../context/decisions");
+  const manager = new DecisionsManager(projectRoot);
+  const dir = manager.decisionsDir;
   let open = 0;
   try {
     const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
@@ -28,7 +32,7 @@ function readDecisions(projectRoot) {
 }
 
 function readUnread(projectRoot) {
-  const queuesDir = path.join(projectRoot, ".ufoo", "bus", "queues");
+  const queuesDir = getUfooPaths(projectRoot).busQueuesDir;
   let total = 0;
   const perSubscriber = {};
   try {
@@ -48,21 +52,34 @@ function readUnread(projectRoot) {
   return { total, perSubscriber };
 }
 
+function isHiddenSubscriber(id, meta) {
+  if (!id) return false;
+  if (id === "ufoo-agent") return true;
+  if (meta && meta.nickname === "ufoo-agent") return true;
+  if (meta && meta.agent_type === "ufoo-agent") return true;
+  return false;
+}
+
 function buildStatus(projectRoot) {
   const bus = readBus(projectRoot);
   const decisions = readDecisions(projectRoot);
   const unread = readUnread(projectRoot);
-  const subscribers = bus ? Object.keys(bus.subscribers || {}) : [];
+  const subscribers = bus ? Object.keys(bus.agents || {}) : [];
+
   const activeEntries = bus
-    ? Object.entries(bus.subscribers || {})
-        .filter(([, meta]) => meta.status === "active")
+    ? Object.entries(bus.agents || {})
+        .filter(([, meta]) => isMetaActive(meta))
+        .filter(([id, meta]) => !isHiddenSubscriber(id, meta))
         .map(([id, meta]) => ({ id, meta }))
     : [];
   const active = activeEntries.map(({ id }) => id);
   const activeMeta = activeEntries.map(({ id, meta }) => {
     const nickname = meta?.nickname || "";
     const display = nickname ? nickname : id;
-    return { id, nickname, display };
+    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 };
   });
 
   return {

package/src/doctor/index.js

@@ -0,0 +1,50 @@
+const fs = require("fs");
+const path = require("path");
+const ContextDoctor = require("../context/doctor");
+
+class RepoDoctor {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+    this.failed = false;
+  }
+
+  fail(message) {
+    console.error(`FAIL: ${message}`);
+    this.failed = true;
+  }
+
+  run() {
+    const contextMod = path.join(this.repoRoot, "modules", "context");
+
+    const contextExists = fs.existsSync(contextMod);
+    if (!contextExists) {
+      this.fail(`missing ${contextMod}`);
+    }
+
+    if (contextExists) {
+      const contextDoctor = new ContextDoctor(this.repoRoot);
+      const ok = contextDoctor.lintProtocol();
+      if (!ok) this.failed = true;
+    }
+
+    console.log("=== ufoo doctor ===");
+    console.log(`Monorepo: ${this.repoRoot}`);
+    console.log("Modules:");
+    if (contextExists) {
+      console.log(`- context: ${contextMod}`);
+    }
+    const resources = path.join(this.repoRoot, "modules", "resources");
+    if (fs.existsSync(resources)) {
+      console.log(`- resources: ${resources}`);
+    }
+
+    if (this.failed) {
+      console.log("Status: FAILED");
+      return false;
+    }
+    console.log("Status: OK");
+    return true;
+  }
+}
+
+module.exports = RepoDoctor;