u-foo 1.0.3 → 1.1.9

package/src/daemon/providerSessions.js

@@ -0,0 +1,306 @@
+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:
+ * - claude-code: /ufoo <nickname>
+ * - codex: $ufoo <nickname>
+ */
+function buildProbeCommand(agentType, nickname) {
+  const marker = String(nickname || "").trim();
+  if (agentType === "claude-code") {
+    return `/ufoo ${marker}`;
+  }
+  return `$ufoo ${marker}`;
+}
+
+function readLines(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return raw.split(/\r?\n/).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function escapeRegExp(value = "") {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function containsProbeCommand(text, marker) {
+  if (!text || !marker) return false;
+  const escapedMarker = escapeRegExp(marker);
+  const pattern = `(?:^|[\\s"'\\\`])(?:\\/ufoo|\\$ufoo|ufoo)\\s+${escapedMarker}(?=$|[\\s"'\\\`.,:;!?\\]\\)\\}])`;
+  const re = new RegExp(pattern);
+  return re.test(String(text));
+}
+
+/**
+ * Check if a history record contains our probe marker
+ * Searches for probe marker command patterns:
+ * - "/ufoo <marker>" (claude)
+ * - "$ufoo <marker>" (codex)
+ * - "ufoo <marker>" (legacy compatibility)
+ */
+function recordContainsMarker(record, marker, rawLine) {
+  if (!marker) return false;
+
+  // Check raw line first (fastest)
+  if (containsProbeCommand(rawLine, marker)) 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 (containsProbeCommand(field, marker)) 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,
+  __private: {
+    buildProbeCommand,
+    recordContainsMarker,
+    containsProbeCommand,
+    escapeRegExp,
+  },
+};

package/src/daemon/reporting.js

@@ -0,0 +1,90 @@
+const fs = require("fs");
+const { BUS_STATUS_PHASES } = require("../shared/eventContract");
+const {
+  REPORT_PHASES,
+  normalizeReportInput,
+  appendReport,
+  updateReportState,
+  appendControllerInboxEntry,
+} = require("../report/store");
+const { getUfooPaths } = require("../ufoo/paths");
+
+function resolveAgentDisplayName(projectRoot, agentId) {
+  if (!agentId) return "unknown-agent";
+  try {
+    const busPath = getUfooPaths(projectRoot).agentsFile;
+    const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
+    const meta = bus && bus.agents ? bus.agents[agentId] : null;
+    if (meta && typeof meta.nickname === "string" && meta.nickname.trim()) {
+      return meta.nickname.trim();
+    }
+  } catch {
+    // ignore
+  }
+  return agentId;
+}
+
+function toStatusPhase(reportPhase) {
+  if (reportPhase === REPORT_PHASES.START || reportPhase === REPORT_PHASES.PROGRESS) {
+    return BUS_STATUS_PHASES.START;
+  }
+  if (reportPhase === REPORT_PHASES.ERROR) return BUS_STATUS_PHASES.ERROR;
+  return BUS_STATUS_PHASES.DONE;
+}
+
+function formatStatusText(displayName, entry) {
+  if (entry.phase === REPORT_PHASES.START) {
+    const detail = entry.message || entry.summary || entry.task_id;
+    return `${displayName} ${detail}`;
+  }
+  if (entry.phase === REPORT_PHASES.PROGRESS) {
+    const detail = entry.message || entry.summary || entry.task_id;
+    return `${displayName} progress: ${detail}`;
+  }
+  if (entry.phase === REPORT_PHASES.ERROR) {
+    const detail = entry.error || entry.summary || entry.message || entry.task_id;
+    return `${displayName} failed: ${detail}`;
+  }
+  const detail = entry.summary || entry.message || entry.task_id;
+  return `${displayName} done: ${detail}`;
+}
+
+function buildReportStatus(entry, displayName) {
+  return {
+    phase: toStatusPhase(entry.phase),
+    key: `report:${entry.agent_id}:${entry.task_id}`,
+    text: formatStatusText(displayName, entry),
+  };
+}
+
+function publishToPrivateController(projectRoot, entry) {
+  if (!entry || !entry.controller_id) return;
+  appendControllerInboxEntry(projectRoot, entry.controller_id, entry);
+}
+
+async function recordAgentReport({
+  projectRoot,
+  report,
+  onStatus = () => {},
+  log = () => {},
+}) {
+  const entry = normalizeReportInput(report);
+  appendReport(projectRoot, entry);
+  const state = updateReportState(projectRoot, entry);
+  publishToPrivateController(projectRoot, entry);
+  const displayName = resolveAgentDisplayName(projectRoot, entry.agent_id);
+  if (entry.scope !== "private") {
+    onStatus(buildReportStatus(entry, displayName));
+  }
+  log(`report ${entry.phase} scope=${entry.scope} agent=${entry.agent_id} task=${entry.task_id}`);
+  return { entry, state };
+}
+
+module.exports = {
+  recordAgentReport,
+  resolveAgentDisplayName,
+  toStatusPhase,
+  formatStatusText,
+  buildReportStatus,
+  publishToPrivateController,
+};

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,41 @@ 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 childEnv = { ...process.env, UFOO_DAEMON_CHILD: "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;
+    }
+    // Manual restart does not auto-resume; crash-recovery is handled on next auto start with stale lock detection.
+    startDaemon({ projectRoot, provider, model, resumeMode: "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,11 @@
 const fs = require("fs");
 const path = require("path");
+const { getUfooPaths } = require("../ufoo/paths");
+const { isMetaActive } = require("../bus/utils");
+const { readReportSummary } = require("../report/store");
 
 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 +14,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 +33,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 +53,51 @@ function readUnread(projectRoot) {
   return { total, perSubscriber };
 }
 
-function buildStatus(projectRoot) {
+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 normalizeCronTasks(raw = []) {
+  const items = Array.isArray(raw) ? raw : [];
+  return items.map((task) => ({
+    id: String(task && task.id ? task.id : ""),
+    intervalMs: Number(task && task.intervalMs ? task.intervalMs : 0) || 0,
+    interval: String(task && task.interval ? task.interval : ""),
+    targets: Array.isArray(task && task.targets) ? task.targets.slice() : [],
+    prompt: String(task && task.prompt ? task.prompt : ""),
+    summary: String(task && task.summary ? task.summary : ""),
+    createdAt: Number(task && task.createdAt ? task.createdAt : 0) || 0,
+    lastRunAt: Number(task && task.lastRunAt ? task.lastRunAt : 0) || 0,
+    tickCount: Number(task && task.tickCount ? task.tickCount : 0) || 0,
+  }));
+}
+
+function buildStatus(projectRoot, options = {}) {
   const bus = readBus(projectRoot);
   const decisions = readDecisions(projectRoot);
   const unread = readUnread(projectRoot);
-  const subscribers = bus ? Object.keys(bus.subscribers || {}) : [];
+  const reports = readReportSummary(projectRoot);
+  const subscribers = bus ? Object.keys(bus.agents || {}) : [];
+  const cronTasks = normalizeCronTasks(options.cronTasks || []);
+
   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 {
@@ -72,6 +107,11 @@ function buildStatus(projectRoot) {
     active_meta: activeMeta,
     unread,
     decisions,
+    reports,
+    cron: {
+      count: cronTasks.length,
+      tasks: cronTasks,
+    },
   };
 }
 

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;