u-foo 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/chat/index.js

@@ -3,7 +3,7 @@ const path = require("path");
 const blessed = require("blessed");
 const { spawn, spawnSync } = require("child_process");
 const fs = require("fs");
-const { loadConfig, saveConfig, normalizeLaunchMode } = require("../config");
+const { loadConfig, saveConfig, normalizeLaunchMode, normalizeAgentProvider } = require("../config");
 const { socketPath, isRunning } = require("../daemon");
 
 function connectSocket(sockPath) {
@@ -29,6 +29,14 @@ function startDaemon(projectRoot) {
   child.unref();
 }
 
+function stopDaemon(projectRoot) {
+  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
+  spawnSync(process.execPath, [daemonBin, "daemon", "--stop"], {
+    stdio: "ignore",
+    cwd: projectRoot,
+  });
+}
+
 async function connectWithRetry(sockPath, retries, delayMs) {
   for (let i = 0; i < retries; i += 1) {
     try {
@@ -54,15 +62,23 @@ async function runChat(projectRoot) {
     startDaemon(projectRoot);
   }
 
+  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
   const sock = socketPath(projectRoot);
-  let client = await connectWithRetry(sock, 25, 200);
-  if (!client) {
-    // Retry once with a fresh daemon start and longer wait.
-    if (!isRunning(projectRoot)) {
-      startDaemon(projectRoot);
+  let client = null;
+
+  const connectClient = async () => {
+    let newClient = await connectWithRetry(sock, 25, 200);
+    if (!newClient) {
+      // Retry once with a fresh daemon start and longer wait.
+      if (!isRunning(projectRoot)) {
+        startDaemon(projectRoot);
+      }
+      newClient = await connectWithRetry(sock, 50, 200);
     }
-    client = await connectWithRetry(sock, 50, 200);
-  }
+    return newClient;
+  };
+
+  client = await connectClient();
   if (!client) {
     // Check if daemon failed to start
     if (!isRunning(projectRoot)) {
@@ -88,6 +104,7 @@ async function runChat(projectRoot) {
 
   const config = loadConfig(projectRoot);
   let launchMode = config.launchMode;
+  let agentProvider = config.agentProvider;
 
   // Dynamic input height settings
   // Layout: topLine(1) + content + bottomLine(1) + dashboard(1)
@@ -1107,6 +1124,12 @@ async function runChat(projectRoot) {
   let focusMode = "input";      // "input" or "dashboard"
   let dashboardView = "agents"; // "agents" or "mode"
   let selectedModeIndex = launchMode === "internal" ? 1 : 0;
+  const providerOptions = [
+    { label: "codex", value: "codex-cli" },
+    { label: "claude", value: "claude-cli" },
+  ];
+  let selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
+  let restartInProgress = false;
 
   function getAgentLabel(agentId) {
     return activeAgentLabelMap.get(agentId) || agentId;
@@ -1131,6 +1154,7 @@ async function runChat(projectRoot) {
   }
 
   function send(req) {
+    if (!client || client.destroyed) return;
     client.write(`${JSON.stringify(req)}\n`);
   }
 
@@ -1177,6 +1201,49 @@ async function runChat(projectRoot) {
     screen.render();
   }
 
+  function providerLabel(value) {
+    return value === "claude-cli" ? "claude" : "codex";
+  }
+
+  function setAgentProvider(provider) {
+    const next = normalizeAgentProvider(provider);
+    if (next === agentProvider) return;
+    agentProvider = next;
+    selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
+    saveConfig(projectRoot, { agentProvider });
+    logMessage("status", `{magenta-fg}⚙{/magenta-fg} ufoo-agent: ${providerLabel(agentProvider)}`);
+    renderDashboard();
+    screen.render();
+    void restartDaemon();
+  }
+
+  async function restartDaemon() {
+    if (restartInProgress) return;
+    restartInProgress = true;
+    logMessage("status", "{magenta-fg}⚙{/magenta-fg} Restarting daemon...");
+    try {
+      if (client) {
+        client.removeAllListeners();
+        try {
+          client.end();
+        } catch {
+          // ignore
+        }
+      }
+      stopDaemon(projectRoot);
+      startDaemon(projectRoot);
+      const newClient = await connectClient();
+      if (newClient) {
+        attachClient(newClient);
+        logMessage("status", "{green-fg}✓{/green-fg} Daemon reconnected");
+      } else {
+        logMessage("error", "{red-fg}✗{/red-fg} Failed to reconnect to daemon");
+      }
+    } finally {
+      restartInProgress = false;
+    }
+  }
+
   function clearLog() {
     logBox.setContent("");
     if (typeof logBox.scrollTo === "function") {
@@ -1197,6 +1264,15 @@ async function runChat(projectRoot) {
           return `{cyan-fg}${mode}{/cyan-fg}`;
         });
         content += `{gray-fg}Mode:{/gray-fg} ${modeParts.join("  ")}`;
+        content += "  {gray-fg}│ ←/→ select, Enter confirm, ↓ agent, ↑ back{/gray-fg}";
+      } else if (dashboardView === "provider") {
+        const providerParts = providerOptions.map((opt, i) => {
+          if (i === selectedProviderIndex) {
+            return `{inverse}${opt.label}{/inverse}`;
+          }
+          return `{cyan-fg}${opt.label}{/cyan-fg}`;
+        });
+        content += `{gray-fg}Agent:{/gray-fg} ${providerParts.join("  ")}`;
         content += "  {gray-fg}│ ←/→ select, Enter confirm, ↑ back{/gray-fg}";
       } else {
         if (activeAgents.length > 0) {
@@ -1230,6 +1306,7 @@ async function runChat(projectRoot) {
         : "none";
       content += `{gray-fg}Agents:{/gray-fg} {cyan-fg}${agents}{/cyan-fg}`;
       content += `  {gray-fg}Mode:{/gray-fg} {cyan-fg}${launchMode}{/cyan-fg}`;
+      content += `  {gray-fg}Agent:{/gray-fg} {cyan-fg}${providerLabel(agentProvider)}{/cyan-fg}`;
     }
     dashboard.setContent(content);
   }
@@ -1280,6 +1357,7 @@ async function runChat(projectRoot) {
     agentListWindowStart = 0;
     clampAgentWindow();
     selectedModeIndex = launchMode === "internal" ? 1 : 0;
+    selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
     screen.grabKeys = true;
     renderDashboard();
     screen.program.hideCursor();
@@ -1301,6 +1379,13 @@ async function runChat(projectRoot) {
         screen.render();
         return true;
       }
+      if (key.name === "down") {
+        dashboardView = "provider";
+        selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
+        renderDashboard();
+        screen.render();
+        return true;
+      }
       if (key.name === "up") {
         dashboardView = "agents";
         renderDashboard();
@@ -1319,6 +1404,37 @@ async function runChat(projectRoot) {
       }
       return true;
     }
+    if (dashboardView === "provider") {
+      if (key.name === "left") {
+        selectedProviderIndex = selectedProviderIndex <= 0 ? providerOptions.length - 1 : selectedProviderIndex - 1;
+        renderDashboard();
+        screen.render();
+        return true;
+      }
+      if (key.name === "right") {
+        selectedProviderIndex = selectedProviderIndex >= providerOptions.length - 1 ? 0 : selectedProviderIndex + 1;
+        renderDashboard();
+        screen.render();
+        return true;
+      }
+      if (key.name === "up") {
+        dashboardView = "mode";
+        renderDashboard();
+        screen.render();
+        return true;
+      }
+      if (key.name === "enter" || key.name === "return") {
+        const selected = providerOptions[selectedProviderIndex];
+        if (selected) setAgentProvider(selected.value);
+        exitDashboardMode(false);
+        return true;
+      }
+      if (key.name === "escape") {
+        exitDashboardMode(false);
+        return true;
+      }
+      return true;
+    }
 
     if (key.name === "left") {
       if (activeAgents.length > 0 && selectedAgentIndex > 0) {
@@ -1380,13 +1496,29 @@ async function runChat(projectRoot) {
     send({ type: "status" });
   }
 
-  let buffer = "";
-  client.on("data", (data) => {
-    buffer += data.toString("utf8");
-    const lines = buffer.split(/\r?\n/);
-    buffer = lines.pop() || "";
-    for (const line of lines.filter((l) => l.trim())) {
-      try {
+  const detachClient = () => {
+    if (!client) return;
+    client.removeAllListeners("data");
+    client.removeAllListeners("close");
+    try {
+      client.end();
+      client.destroy();
+    } catch {
+      // ignore
+    }
+  };
+
+  const attachClient = (newClient) => {
+    if (!newClient) return;
+    detachClient();
+    client = newClient;
+    let buffer = "";
+    client.on("data", (data) => {
+      buffer += data.toString("utf8");
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines.filter((l) => l.trim())) {
+        try {
         const msg = JSON.parse(line);
         if (msg.type === "status") {
           const data = msg.data || {};
@@ -1491,6 +1623,12 @@ async function runChat(projectRoot) {
       }
     }
   });
+    client.on("close", () => {
+      client = null;
+    });
+  };
+
+  attachClient(client);
 
   input.on("submit", (value) => {
     const text = value.trim();
@@ -1618,6 +1756,7 @@ async function runChat(projectRoot) {
   }
   loadHistory();
   loadInputHistory();
+  renderDashboard();
   resizeInput();
   requestStatus();
   setInterval(requestStatus, 2000);

package/src/config.js

@@ -3,12 +3,18 @@ const path = require("path");
 
 const DEFAULT_CONFIG = {
   launchMode: "terminal",
+  agentProvider: "codex-cli",
+  agentModel: "",
 };
 
 function normalizeLaunchMode(value) {
   return value === "internal" ? "internal" : "terminal";
 }
 
+function normalizeAgentProvider(value) {
+  return value === "claude-cli" ? "claude-cli" : "codex-cli";
+}
+
 function configPath(projectRoot) {
   return path.join(projectRoot, ".ufoo", "config.json");
 }
@@ -16,7 +22,12 @@ function configPath(projectRoot) {
 function loadConfig(projectRoot) {
   try {
     const raw = JSON.parse(fs.readFileSync(configPath(projectRoot), "utf8"));
-    return { ...DEFAULT_CONFIG, ...raw, launchMode: normalizeLaunchMode(raw.launchMode) };
+    return {
+      ...DEFAULT_CONFIG,
+      ...raw,
+      launchMode: normalizeLaunchMode(raw.launchMode),
+      agentProvider: normalizeAgentProvider(raw.agentProvider),
+    };
   } catch {
     return { ...DEFAULT_CONFIG };
   }
@@ -30,8 +41,9 @@ function saveConfig(projectRoot, config) {
     ...config,
   };
   merged.launchMode = normalizeLaunchMode(merged.launchMode);
+  merged.agentProvider = normalizeAgentProvider(merged.agentProvider);
   fs.writeFileSync(target, JSON.stringify(merged, null, 2));
   return merged;
 }
 
-module.exports = { loadConfig, saveConfig, normalizeLaunchMode };
+module.exports = { loadConfig, saveConfig, normalizeLaunchMode, normalizeAgentProvider };

package/src/daemon/run.js

@@ -1,12 +1,14 @@
 const path = require("path");
 const { startDaemon, stopDaemon, isRunning } = require("./index");
+const { loadConfig } = require("../config");
 
 function runDaemonCli(argv) {
   const cmd = argv[1] || "start";
   const projectRoot = process.cwd();
-  const provider = process.env.UFOO_AGENT_PROVIDER || "codex-cli";
+  const config = loadConfig(projectRoot);
+  const provider = process.env.UFOO_AGENT_PROVIDER || config.agentProvider || "codex-cli";
   const model =
-    process.env.UFOO_AGENT_MODEL || (provider === "claude-cli" ? "opus" : "");
+    process.env.UFOO_AGENT_MODEL || config.agentModel || (provider === "claude-cli" ? "opus" : "");
 
   if (cmd === "start" || cmd === "--start") {
     if (isRunning(projectRoot)) return;