u-foo 2.3.30 → 2.3.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "2.3.30",
+  "version": "2.3.32",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",
@@ -42,6 +42,8 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
+    "ink:demo": "node scripts/ink-demo.js",
+    "ink:smoke": "node scripts/ink-smoke.js",
     "bench:global-switch": "node scripts/global-chat-switch-benchmark.js"
   },
   "dependencies": {
@@ -51,7 +53,9 @@
     "chalk": "^4.1.2",
     "commander": "^13.1.0",
     "gray-matter": "^4.0.3",
+    "ink": "^5.2.1",
     "node-pty": "^1.1.0",
+    "react": "^18.3.1",
     "ws": "^8.19.0",
     "xterm-addon-serialize": "^0.11.0",
     "xterm-headless": "^5.3.0"

package/scripts/chat-app-smoke.js

@@ -0,0 +1,30 @@
+"use strict";
+
+/**
+ * Headless mount test for the ChatApp shell. Boots the ink TUI with stub
+ * props (no daemon, no real bootstrap) and checks the component tree
+ * renders without throwing. Used for CI parity with ucode-app-smoke.js.
+ */
+
+const { runInk } = require("../src/ui/runInk");
+const { createChatApp } = require("../src/ui/components/ChatApp");
+
+(async () => {
+  const props = {
+    activeProjectRoot: process.cwd(),
+    globalMode: false,
+    globalScope: "project",
+  };
+  const handle = await runInk((React, ink) => {
+    const ChatApp = createChatApp({ React, ink, props, interactive: false });
+    return React.createElement(ChatApp);
+  }, { stdout: process.stdout, stderr: process.stderr });
+  await new Promise((r) => setTimeout(r, 80));
+  handle.unmount();
+  await handle.waitUntilExit().catch(() => undefined);
+  process.stdout.write("\nchat-app-smoke: ok\n");
+  process.exit(0);
+})().catch((err) => {
+  process.stderr.write(`chat-app-smoke: failed: ${err && err.stack || err}\n`);
+  process.exit(1);
+});

package/scripts/ink-demo.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Interactive ink demo. Run from a real TTY:
+ *   npm run ink:demo
+ * or
+ *   node scripts/ink-demo.js
+ */
+
+const { runInk } = require("../src/ui/runInk");
+const { createInkDemo } = require("../src/ui/components/InkDemo");
+
+(async () => {
+  const handle = await runInk((React, ink) => {
+    const InkDemo = createInkDemo({ React, ink, interactive: true });
+    return React.createElement(InkDemo);
+  });
+  await handle.waitUntilExit();
+})().catch((err) => {
+  process.stderr.write(`ink-demo: ${err && err.stack || err}\n`);
+  process.exit(1);
+});

package/scripts/ink-smoke.js

@@ -0,0 +1,30 @@
+"use strict";
+
+/**
+ * Headless smoke test for the ink demo: mounts the component, lets it tick
+ * once, then unmounts. Exits with non-zero on any error. Used to confirm
+ * the CJS->ESM bridge and component tree work without occupying the TTY.
+ */
+
+const { runInk } = require("../src/ui/runInk");
+const { createInkDemo } = require("../src/ui/components/InkDemo");
+
+(async () => {
+  const handle = await runInk((React, ink) => {
+    const InkDemo = createInkDemo({ React, ink, interactive: false });
+    return React.createElement(InkDemo);
+  }, {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    stdin: process.stdin,
+    exitOnCtrlC: false,
+  });
+  await new Promise((r) => setTimeout(r, 100));
+  handle.unmount();
+  await handle.waitUntilExit().catch(() => undefined);
+  process.stdout.write("\nink-smoke: ok\n");
+  process.exit(0);
+})().catch((err) => {
+  process.stderr.write(`ink-smoke: failed: ${err && err.stack || err}\n`);
+  process.exit(1);
+});

package/scripts/ucode-app-smoke.js

@@ -0,0 +1,36 @@
+"use strict";
+
+/**
+ * Headless mount test for the UcodeApp shell. Boots the ink TUI with stub
+ * runner props, lets it render once, then unmounts. Used to confirm the ink
+ * code path stays compilable as P1 evolves.
+ */
+
+const { runInk } = require("../src/ui/runInk");
+const { createUcodeApp } = require("../src/ui/components/UcodeApp");
+
+(async () => {
+  const props = {
+    stdin: process.stdin,
+    stdout: process.stdout,
+    runSingleCommand: () => ({ kind: "empty" }),
+    runNaturalLanguageTask: async () => ({ ok: true, summary: "ok" }),
+    runUbusCommand: async () => ({ ok: false, error: "ubus unsupported", summary: "" }),
+    formatNlResult: () => "ok",
+    workspaceRoot: process.cwd(),
+    state: { model: "test-model", sessionId: "smoke", engine: "ufoo-core" },
+    autoBus: { enabled: false, getPendingCount: () => 0, subscriberId: "" },
+  };
+  const handle = await runInk((React, ink) => {
+    const UcodeApp = createUcodeApp({ React, ink, props, interactive: false });
+    return React.createElement(UcodeApp);
+  }, { stdout: process.stdout, stderr: process.stderr });
+  await new Promise((r) => setTimeout(r, 80));
+  handle.unmount();
+  await handle.waitUntilExit().catch(() => undefined);
+  process.stdout.write("\nucode-app-smoke: ok\n");
+  process.exit(0);
+})().catch((err) => {
+  process.stderr.write(`ucode-app-smoke: failed: ${err && err.stack || err}\n`);
+  process.exit(1);
+});

package/src/chat/commandExecutor.js

@@ -237,7 +237,7 @@ function createCommandExecutor(options = {}) {
 
     if (subcommand === "stop") {
       statusMsg("{gray-fg}⚙{/gray-fg} Stopping daemon...");
-      stopDaemon(targetRoot);
+      stopDaemon(targetRoot, { source: "chat-command:/daemon stop" });
       await sleep(1000);
       if (!isDaemonRunning(targetRoot)) {
         statusMsg("{gray-fg}✓{/gray-fg} Daemon stopped");
@@ -249,8 +249,12 @@ function createCommandExecutor(options = {}) {
 
     if (subcommand === "restart") {
       statusMsg("{gray-fg}⚙{/gray-fg} Restarting daemon...");
-      stopDaemon(targetRoot);
+      stopDaemon(targetRoot, { source: "chat-command:/daemon restart" });
       await sleep(500);
+      if (isDaemonRunning(targetRoot)) {
+        statusMsg("{gray-fg}✗{/gray-fg} Failed to stop daemon");
+        return;
+      }
       startDaemon(targetRoot);
       await sleep(1000);
       if (isDaemonRunning(targetRoot)) {

package/src/chat/daemonMessageRouter.js

@@ -415,7 +415,15 @@ function createDaemonMessageRouter(options = {}) {
         const delta = typeof streamPayload.delta === "string"
           ? decodeEscapedNewlines(streamPayload.delta)
           : "";
-        if (delta) writeToAgentTerm(delta);
+        if (delta || streamPayload.done) {
+          writeToAgentTerm(delta, {
+            data,
+            publisher,
+            streamPayload,
+            done: Boolean(streamPayload.done),
+            reason: streamPayload.reason || "",
+          });
+        }
       } else if (displayMessage) {
         writeToAgentTerm(`${displayMessage}\r\n`);
       }

package/src/chat/daemonTransport.js

@@ -29,6 +29,7 @@ function createDaemonTransport(options = {}) {
 
   async function connectClientForTarget(override = {}) {
     const target = resolveTarget(override);
+    const autoStart = override.autoStart !== false;
     let client = await connectWithRetry(
       target.sockPath,
       primaryRetries,
@@ -39,7 +40,7 @@ function createDaemonTransport(options = {}) {
       // Retry once with a fresh daemon start and longer wait.
       // Check if a restart is already in progress via the explicit restart flow.
       const isExplicitRestartInProgress = restartLocks.get(target.projectRoot);
-      if (!isExplicitRestartInProgress && !isRunning(target.projectRoot)) {
+      if (autoStart && !isExplicitRestartInProgress && !isRunning(target.projectRoot)) {
         startDaemon(target.projectRoot);
         await new Promise((resolve) => setTimeout(resolve, restartDelayMs));
       }

package/src/chat/dashboardKeyController.js

@@ -18,7 +18,6 @@ function createDashboardKeyController(options = {}) {
     exitDashboardMode = () => {},
     setLaunchMode = () => {},
     setAgentProvider = () => {},
-    setAutoResume = () => {},
     clampAgentWindow = () => {},
     clampAgentWindowWithSelection = () => {},
     requestProjectSwitch = () => {},
@@ -314,44 +313,6 @@ function createDashboardKeyController(options = {}) {
     return true;
   }
 
-  function handleResumeKey(key) {
-    if (key.name === "left") {
-      state.selectedResumeIndex = state.selectedResumeIndex <= 0
-        ? state.resumeOptions.length - 1
-        : state.selectedResumeIndex - 1;
-      renderDashboardAndScreen();
-      return true;
-    }
-
-    if (key.name === "right") {
-      state.selectedResumeIndex = state.selectedResumeIndex >= state.resumeOptions.length - 1
-        ? 0
-        : state.selectedResumeIndex + 1;
-      renderDashboardAndScreen();
-      return true;
-    }
-
-    if (key.name === "up") {
-      state.dashboardView = "provider";
-      renderDashboardAndScreen();
-      return true;
-    }
-
-    if (key.name === "enter" || key.name === "return") {
-      const selected = state.resumeOptions[state.selectedResumeIndex];
-      if (selected) setAutoResume(selected.value);
-      exitDashboardMode(false);
-      return true;
-    }
-
-    if (key.name === "escape") {
-      exitDashboardMode(false);
-      return true;
-    }
-
-    return true;
-  }
-
   function handleProjectsKey(key) {
     const projects = Array.isArray(state.projects) ? state.projects : [];
     if (projects.length === 0) {
@@ -557,7 +518,6 @@ function createDashboardKeyController(options = {}) {
 
     if (state.dashboardView === "mode") return handleModeKey(key);
     if (state.dashboardView === "provider") return handleProviderKey(key);
-    if (state.dashboardView === "resume") return handleResumeKey(key);
     if (state.dashboardView === "cron") return handleCronKey(key);
 
     return handleAgentsKey(key);

package/src/chat/dashboardView.js

@@ -174,11 +174,9 @@ function buildDashboardDetailLine(options = {}) {
     getAgentState = () => "",
     selectedModeIndex = 0,
     selectedProviderIndex = 0,
-    selectedResumeIndex = 0,
     selectedCronIndex = -1,
     cronTasks = [],
     providerOptions = [],
-    resumeOptions = [],
     dashHints = {},
     modeOptions = DEFAULT_MODE_OPTIONS,
   } = options;
@@ -210,18 +208,6 @@ function buildDashboardDetailLine(options = {}) {
     return { content, windowStart };
   }
 
-  if (dashboardView === "resume") {
-    const resumeParts = resumeOptions.map((opt, i) => {
-      if (i === selectedResumeIndex) {
-        return `{inverse}${opt.label}{/inverse}`;
-      }
-      return `{cyan-fg}${opt.label}{/cyan-fg}`;
-    });
-    content += `{gray-fg}Resume:{/gray-fg} ${resumeParts.join("  ")}`;
-    content += `  {gray-fg}│ ${dashHints.resume || ""}{/gray-fg}`;
-    return { content, windowStart };
-  }
-
   if (dashboardView === "cron") {
     const items = Array.isArray(cronTasks) ? cronTasks : [];
     const summary = items.length > 0
@@ -295,13 +281,11 @@ function computeDashboardContent(options = {}) {
     agentProvider = "codex-cli",
     selectedModeIndex = 0,
     selectedProviderIndex = 0,
-    selectedResumeIndex = 0,
     selectedCronIndex = -1,
     cronTasks = [],
     loopSummary = null,
     pendingReports = 0,
     providerOptions = [],
-    resumeOptions = [],
     dashHints = {},
     modeOptions = DEFAULT_MODE_OPTIONS,
   } = options;
@@ -357,11 +341,9 @@ function computeDashboardContent(options = {}) {
       getAgentState,
       selectedModeIndex,
       selectedProviderIndex,
-      selectedResumeIndex,
       selectedCronIndex,
       cronTasks,
       providerOptions,
-      resumeOptions,
       dashHints,
       modeOptions,
     });
@@ -383,11 +365,9 @@ function computeDashboardContent(options = {}) {
       getAgentState,
       selectedModeIndex,
       selectedProviderIndex,
-      selectedResumeIndex,
       selectedCronIndex,
       cronTasks,
       providerOptions,
-      resumeOptions,
       dashHints,
       modeOptions,
     });

package/src/chat/index.js

@@ -69,7 +69,7 @@ const {
 
 const MODE_OPTIONS = ["auto", "host", "terminal", "tmux", "internal-pty", "internal"];
 
-async function runChat(projectRoot, options = {}) {
+async function runChatBlessed(projectRoot, options = {}) {
   const globalMode = options && options.globalMode === true;
   const DASHBOARD_HEIGHT = globalMode ? 2 : 1;
   let activeProjectRoot = projectRoot;
@@ -2211,4 +2211,12 @@ async function runChat(projectRoot, options = {}) {
   screen.render();
 }
 
+async function runChat(projectRoot, options = {}) {
+  if (String(process.env.UFOO_TUI || "").trim().toLowerCase() === "blessed") {
+    return runChatBlessed(projectRoot, options);
+  }
+  const { runChatInk } = require("../ui/components/ChatApp");
+  return runChatInk(projectRoot, options);
+}
+
 module.exports = { runChat };

package/src/chat/inputSubmitHandler.js

@@ -1,6 +1,7 @@
 const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
 const { decodeEscapedNewlines } = require("./text");
 const { shouldEchoCommandInChat } = require("./commands");
+const { parseShellCommand, runShellCommand: defaultRunShellCommand } = require("./shellCommand");
 
 function createInputSubmitHandler(options = {}) {
   const {
@@ -24,6 +25,8 @@ function createInputSubmitHandler(options = {}) {
     commitInputHistory = () => {},
     focusInput = () => {},
     renderScreen = () => {},  // Add renderScreen callback
+    runShellCommand = defaultRunShellCommand,
+    getShellCwd = () => process.cwd(),
   } = options;
 
   if (!state || typeof state !== "object") {
@@ -90,6 +93,37 @@ function createInputSubmitHandler(options = {}) {
 
     commitInputHistory(text);
 
+    const shellCommand = parseShellCommand(text);
+    if (shellCommand) {
+      logMessage("user", `{gray-fg}!{/gray-fg} ${escapeBlessed(shellCommand)}`);
+      queueStatusLine(`Running: ${escapeBlessed(shellCommand)}`);
+      renderScreen();
+      try {
+        const result = await runShellCommand(shellCommand, { cwd: getShellCwd() });
+        const stdout = String(result && result.stdout ? result.stdout : "").trimEnd();
+        const stderr = String(result && result.stderr ? result.stderr : "").trimEnd();
+        if (stdout) {
+          stdout.split(/\r?\n/).forEach((line) => logMessage("system", escapeBlessed(line)));
+        }
+        if (stderr) {
+          stderr.split(/\r?\n/).forEach((line) => logMessage(result && result.ok ? "system" : "error", escapeBlessed(line)));
+        }
+        if (!stdout && !stderr) {
+          logMessage("system", "{gray-fg}(no output){/gray-fg}");
+        }
+        if (result && result.ok) {
+          queueStatusLine(`Done: ${escapeBlessed(shellCommand)}`);
+        } else {
+          const suffix = result && result.signal ? ` signal ${result.signal}` : ` exit ${result && result.code != null ? result.code : 1}`;
+          logMessage("error", `{white-fg}✗{/white-fg} Command failed:${escapeBlessed(suffix)}`);
+        }
+      } catch (err) {
+        logMessage("error", `{white-fg}✗{/white-fg} Command error: ${escapeBlessed(err && err.message ? err.message : err)}`);
+      }
+      focusInput();
+      return;
+    }
+
     if (state.targetAgent) {
       const label = getAgentLabel(state.targetAgent);
       logMessage(

package/src/chat/projectCloseController.js

@@ -86,7 +86,7 @@ function createProjectCloseController(options = {}) {
       }
 
       const wasRunning = Boolean(isRunning(projectRoot));
-      stopDaemon(projectRoot);
+      stopDaemon(projectRoot, { source: `project-close:${projectRoot}` });
 
       refreshProjects();
       renderDashboard();

package/src/chat/shellCommand.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const { exec } = require("child_process");
+
+function parseShellCommand(text) {
+  const value = String(text || "").trim();
+  if (!value.startsWith("!")) return null;
+  const command = value.slice(1).trim();
+  if (!command) return null;
+  return command;
+}
+
+function runShellCommand(command, options = {}) {
+  const cmd = String(command || "").trim();
+  if (!cmd) return Promise.resolve({ ok: false, code: null, stdout: "", stderr: "empty command" });
+  const cwd = options.cwd || process.cwd();
+  const timeout = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 120000;
+  const maxBuffer = Number.isFinite(options.maxBuffer) ? options.maxBuffer : 1024 * 1024;
+  return new Promise((resolve) => {
+    exec(cmd, {
+      cwd,
+      env: process.env,
+      timeout,
+      maxBuffer,
+      shell: process.env.SHELL || "/bin/sh",
+    }, (error, stdout, stderr) => {
+      resolve({
+        ok: !error,
+        code: error && Number.isFinite(error.code) ? error.code : 0,
+        signal: error && error.signal ? error.signal : null,
+        stdout: String(stdout || ""),
+        stderr: String(stderr || ""),
+        error: error && error.message ? error.message : "",
+      });
+    });
+  });
+}
+
+module.exports = {
+  parseShellCommand,
+  runShellCommand,
+};

package/src/chat/transport.js

@@ -2,6 +2,7 @@ const net = require("net");
 const path = require("path");
 const fs = require("fs");
 const { spawn, spawnSync } = require("child_process");
+const { resolveNodeExecutable } = require("../utils/nodeExecutable");
 
 function connectSocket(sockPath, options = {}) {
   const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
@@ -57,21 +58,33 @@ function startDaemon(projectRoot, options = {}) {
   const env = options.forceResume
     ? { ...process.env, UFOO_FORCE_RESUME: "1" }
     : process.env;
-  const child = spawn(process.execPath, [daemonBin, "daemon", "--start"], {
+  const child = spawn(resolveNodeExecutable(), [daemonBin, "daemon", "--start"], {
     detached: true,
     stdio: "ignore",
     cwd: projectRoot,
     env,
   });
+  child.on("error", (err) => {
+    if (typeof options.onError === "function") {
+      options.onError(err);
+    }
+  });
   child.unref();
+  return child;
 }
 
-function stopDaemon(projectRoot) {
+function stopDaemon(projectRoot, options = {}) {
   const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
-  spawnSync(process.execPath, [daemonBin, "daemon", "--stop"], {
+  const source = String(
+    options.source
+      || `chat-transport pid=${process.pid} cwd=${process.cwd()} argv=${process.argv.join(" ")}`
+  );
+  const result = spawnSync(resolveNodeExecutable(), [daemonBin, "daemon", "--stop"], {
     stdio: "ignore",
     cwd: projectRoot,
+    env: { ...process.env, UFOO_DAEMON_STOP_SOURCE: source },
   });
+  return Boolean(result && !result.error && result.status === 0);
 }
 
 async function connectWithRetry(sockPath, retries, delayMs, options = {}) {

package/src/cli.js

@@ -14,6 +14,7 @@ const { resolveSoloAgentType } = require("./solo/commands");
 const { listProjectRuntimes, getCurrentProjectRuntime } = require("./projects/registry");
 const { canonicalProjectRoot, buildProjectId } = require("./projects/projectId");
 const { getUfooPaths } = require("./ufoo/paths");
+const { resolveNodeExecutable } = require("./utils/nodeExecutable");
 
 function getPackageRoot() {
   return path.resolve(__dirname, "..");
@@ -60,7 +61,7 @@ async function connectWithRetry(sockPath, retries, delayMs) {
 async function ensureDaemonRunning(projectRoot) {
   if (isRunning(projectRoot)) return;
   const repoRoot = getPackageRoot();
-  run(process.execPath, [path.join(repoRoot, "bin", "ufoo.js"), "daemon", "start"]);
+  run(resolveNodeExecutable(), [path.join(repoRoot, "bin", "ufoo.js"), "daemon", "start"]);
   const sock = socketPath(projectRoot);
   for (let i = 0; i < 30; i += 1) {
     if (fs.existsSync(sock)) {
@@ -1733,7 +1734,7 @@ async function runCli(argv) {
     return;
   }
   if (cmd === "daemon") {
-    run(process.execPath, [path.join(repoRoot, "bin", "ufoo.js"), "daemon", ...rest]);
+    run(resolveNodeExecutable(), [path.join(repoRoot, "bin", "ufoo.js"), "daemon", ...rest]);
     return;
   }
   if (cmd === "chat") {
@@ -1741,7 +1742,7 @@ async function runCli(argv) {
     if (rest.includes("-g") || rest.includes("--global")) {
       chatArgs.push("-g");
     }
-    run(process.execPath, [path.join(repoRoot, "bin", "ufoo.js"), ...chatArgs]);
+    run(resolveNodeExecutable(), [path.join(repoRoot, "bin", "ufoo.js"), ...chatArgs]);
     return;
   }
   if (cmd === "project") {

package/src/code/agent.js

@@ -491,6 +491,8 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
   const runNativeAgentImpl = typeof options.runNativeAgentImpl === "function"
     ? options.runNativeAgentImpl
     : runNativeAgentTask;
+  const onPhase = typeof options.onPhase === "function" ? options.onPhase : null;
+  const onThinkingDelta = typeof options.onThinkingDelta === "function" ? options.onThinkingDelta : null;
   const invokeNative = (sessionIdValue = "", timeoutOverrideMs = timeoutMs) => runNativeAgentImpl({
     workspaceRoot,
     provider,
@@ -501,6 +503,8 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
     sessionId: String(sessionIdValue || ""),
     timeoutMs: timeoutOverrideMs,
     onStreamDelta: onStream,
+    onThinkingDelta,
+    onPhase,
     onToolEvent: (event) => {
       pushToolLog(event);
     },