u-foo 2.4.5 → 2.4.6

package/src/runtime/daemon/restart.js

@@ -0,0 +1,293 @@
+"use strict";
+
+const DEFAULT_STOP_TIMEOUT_MS = 5000;
+const DEFAULT_START_TIMEOUT_MS = 5000;
+const DEFAULT_POLL_MS = 100;
+
+function normalizePositiveInt(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.trunc(n);
+}
+
+function waitAttempts(timeoutMs, pollMs) {
+  return Math.max(1, Math.ceil(timeoutMs / pollMs));
+}
+
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function daemonState(isRunning, projectRoot) {
+  if (typeof isRunning !== "function") return null;
+  return Boolean(isRunning(projectRoot));
+}
+
+async function waitForDaemonState({
+  projectRoot,
+  isRunning,
+  desired,
+  timeoutMs,
+  pollMs,
+  sleep = defaultSleep,
+}) {
+  if (typeof isRunning !== "function") return true;
+  const attempts = waitAttempts(timeoutMs, pollMs);
+  for (let i = 0; i <= attempts; i += 1) {
+    if (daemonState(isRunning, projectRoot) === desired) return true;
+    if (i >= attempts) break;
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(pollMs);
+  }
+  return daemonState(isRunning, projectRoot) === desired;
+}
+
+function waitForDaemonStateSync({
+  projectRoot,
+  isRunning,
+  desired,
+  timeoutMs,
+  pollMs,
+  sleepSync,
+}) {
+  if (typeof isRunning !== "function") return true;
+  const attempts = waitAttempts(timeoutMs, pollMs);
+  for (let i = 0; i <= attempts; i += 1) {
+    if (daemonState(isRunning, projectRoot) === desired) return true;
+    if (i >= attempts) break;
+    if (typeof sleepSync === "function") sleepSync(pollMs);
+  }
+  return daemonState(isRunning, projectRoot) === desired;
+}
+
+function createResult(overrides = {}) {
+  return {
+    ok: false,
+    stopped: false,
+    started: false,
+    connected: false,
+    stopOk: false,
+    startOk: false,
+    error: null,
+    ...overrides,
+  };
+}
+
+async function restartDaemonLifecycle(options = {}) {
+  const {
+    projectRoot,
+    isRunning,
+    stopDaemon,
+    startDaemon,
+    stopOptions,
+    startOptions,
+    connect,
+    requestStatus,
+    stopTimeoutMs = DEFAULT_STOP_TIMEOUT_MS,
+    startTimeoutMs = DEFAULT_START_TIMEOUT_MS,
+    pollMs = DEFAULT_POLL_MS,
+    sleep = defaultSleep,
+  } = options;
+
+  if (!projectRoot) return createResult({ error: "missing_project_root" });
+  if (typeof startDaemon !== "function") return createResult({ error: "missing_start_daemon" });
+
+  let stopOk = true;
+  let stopError = null;
+  if (typeof stopDaemon === "function") {
+    try {
+      stopOk = Boolean(stopOptions === undefined
+        ? await stopDaemon(projectRoot)
+        : await stopDaemon(projectRoot, stopOptions));
+    } catch (err) {
+      stopOk = false;
+      stopError = err;
+    }
+  }
+
+  const stopped = await waitForDaemonState({
+    projectRoot,
+    isRunning,
+    desired: false,
+    timeoutMs: normalizePositiveInt(stopTimeoutMs, DEFAULT_STOP_TIMEOUT_MS),
+    pollMs: normalizePositiveInt(pollMs, DEFAULT_POLL_MS),
+    sleep,
+  });
+
+  if (!stopped) {
+    return createResult({
+      stopped: false,
+      stopOk,
+      error: "failed_to_stop",
+      stopError,
+    });
+  }
+
+  let startOk = true;
+  let startError = null;
+  try {
+    if (startOptions === undefined) {
+      await startDaemon(projectRoot);
+    } else {
+      await startDaemon(projectRoot, startOptions);
+    }
+  } catch (err) {
+    startOk = false;
+    startError = err;
+  }
+
+  if (!startOk) {
+    return createResult({
+      stopped: true,
+      stopOk,
+      startOk: false,
+      error: "failed_to_start",
+      stopError,
+      startError,
+    });
+  }
+
+  const started = await waitForDaemonState({
+    projectRoot,
+    isRunning,
+    desired: true,
+    timeoutMs: normalizePositiveInt(startTimeoutMs, DEFAULT_START_TIMEOUT_MS),
+    pollMs: normalizePositiveInt(pollMs, DEFAULT_POLL_MS),
+    sleep,
+  });
+
+  let connected = started;
+  let connectError = null;
+  if (typeof connect === "function") {
+    try {
+      connected = Boolean(await connect(projectRoot));
+    } catch (err) {
+      connected = false;
+      connectError = err;
+    }
+  }
+
+  if (connected && typeof requestStatus === "function") {
+    try {
+      requestStatus(projectRoot);
+    } catch {
+      // Status refresh is best-effort after the lifecycle itself succeeds.
+    }
+  }
+
+  const ok = typeof connect === "function" ? connected : started;
+  return createResult({
+    ok,
+    stopped: true,
+    started,
+    connected,
+    stopOk,
+    startOk: true,
+    error: ok ? null : (started ? "failed_to_connect" : "failed_to_start"),
+    stopError,
+    startError,
+    connectError,
+  });
+}
+
+function restartDaemonLifecycleSync(options = {}) {
+  const {
+    projectRoot,
+    isRunning,
+    stopDaemon,
+    startDaemon,
+    stopOptions,
+    startOptions,
+    stopTimeoutMs = DEFAULT_STOP_TIMEOUT_MS,
+    startTimeoutMs = DEFAULT_START_TIMEOUT_MS,
+    pollMs = DEFAULT_POLL_MS,
+    sleepSync,
+  } = options;
+
+  if (!projectRoot) return createResult({ error: "missing_project_root" });
+  if (typeof startDaemon !== "function") return createResult({ error: "missing_start_daemon" });
+
+  let stopOk = true;
+  let stopError = null;
+  if (typeof stopDaemon === "function") {
+    try {
+      stopOk = Boolean(stopOptions === undefined
+        ? stopDaemon(projectRoot)
+        : stopDaemon(projectRoot, stopOptions));
+    } catch (err) {
+      stopOk = false;
+      stopError = err;
+    }
+  }
+
+  const stopped = waitForDaemonStateSync({
+    projectRoot,
+    isRunning,
+    desired: false,
+    timeoutMs: normalizePositiveInt(stopTimeoutMs, DEFAULT_STOP_TIMEOUT_MS),
+    pollMs: normalizePositiveInt(pollMs, DEFAULT_POLL_MS),
+    sleepSync,
+  });
+
+  if (!stopped) {
+    return createResult({
+      stopped: false,
+      stopOk,
+      error: "failed_to_stop",
+      stopError,
+    });
+  }
+
+  let startOk = true;
+  let startError = null;
+  try {
+    if (startOptions === undefined) {
+      startDaemon(projectRoot);
+    } else {
+      startDaemon(projectRoot, startOptions);
+    }
+  } catch (err) {
+    startOk = false;
+    startError = err;
+  }
+
+  if (!startOk) {
+    return createResult({
+      stopped: true,
+      stopOk,
+      startOk: false,
+      error: "failed_to_start",
+      stopError,
+      startError,
+    });
+  }
+
+  const started = waitForDaemonStateSync({
+    projectRoot,
+    isRunning,
+    desired: true,
+    timeoutMs: normalizePositiveInt(startTimeoutMs, DEFAULT_START_TIMEOUT_MS),
+    pollMs: normalizePositiveInt(pollMs, DEFAULT_POLL_MS),
+    sleepSync,
+  });
+
+  return createResult({
+    ok: started,
+    stopped: true,
+    started,
+    connected: false,
+    stopOk,
+    startOk: true,
+    error: started ? null : "failed_to_start",
+    stopError,
+    startError,
+  });
+}
+
+module.exports = {
+  DEFAULT_STOP_TIMEOUT_MS,
+  DEFAULT_START_TIMEOUT_MS,
+  DEFAULT_POLL_MS,
+  restartDaemonLifecycle,
+  restartDaemonLifecycleSync,
+};

package/src/runtime/daemon/run.js

@@ -1,8 +1,25 @@
 const path = require("path");
 const { startDaemon, stopDaemon, isRunning } = require("./index");
+const { restartDaemonLifecycleSync } = require("./restart");
 const { loadConfig, defaultAgentModelForProvider } = require("../../config");
 const { resolveNodeExecutable } = require("../process/nodeExecutable");
 
+function spawnDaemonStart(projectRoot) {
+  const { spawn } = require("child_process");
+  const child = spawn(resolveNodeExecutable(), [path.join(__dirname, "..", "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, UFOO_DAEMON_CHILD: "1" },
+    cwd: projectRoot,
+  });
+  child.unref();
+  return child;
+}
+
+function sleepSync(ms) {
+  require("child_process").spawnSync("sleep", [String(ms / 1000)]);
+}
+
 function runDaemonCli(argv) {
   const cmd = argv[1] || "start";
   const projectRoot = process.cwd();
@@ -19,14 +36,7 @@ function runDaemonCli(argv) {
   if (cmd === "start" || cmd === "--start") {
     if (isRunning(projectRoot)) return;
     if (!process.env.UFOO_DAEMON_CHILD) {
-      const { spawn } = require("child_process");
-      const child = spawn(resolveNodeExecutable(), [path.join(__dirname, "..", "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
-        detached: true,
-        stdio: "ignore",
-        env: { ...process.env, UFOO_DAEMON_CHILD: "1" },
-        cwd: projectRoot,
-      });
-      child.unref();
+      spawnDaemonStart(projectRoot);
       return;
     }
     startDaemon({ projectRoot, provider, model, resumeMode });
@@ -39,35 +49,19 @@ function runDaemonCli(argv) {
     return;
   }
   if (cmd === "restart" || cmd === "--restart") {
-    // Stop if running
-    if (isRunning(projectRoot)) {
-      const stopped = stopDaemon(projectRoot, { source: process.env.UFOO_DAEMON_STOP_SOURCE || `daemon-cli:${cmd} pid=${process.pid}` });
-      // Wait for clean shutdown
-      let attempts = 0;
-      while (isRunning(projectRoot) && attempts < 50) {
-        attempts++;
-        require("child_process").spawnSync("sleep", ["0.1"]);
-      }
-      if (!stopped && isRunning(projectRoot)) {
-        process.exitCode = 1;
-        return;
-      }
-    }
-    // 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(resolveNodeExecutable(), [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" });
+    const result = restartDaemonLifecycleSync({
+      projectRoot,
+      isRunning,
+      stopDaemon,
+      startDaemon: () => {
+        if (!process.env.UFOO_DAEMON_CHILD) return spawnDaemonStart(projectRoot);
+        // Manual restart does not auto-resume; crash-recovery is handled on next auto start with stale lock detection.
+        return startDaemon({ projectRoot, provider, model, resumeMode: "none" });
+      },
+      stopOptions: { source: process.env.UFOO_DAEMON_STOP_SOURCE || `daemon-cli:${cmd} pid=${process.pid}` },
+      sleepSync,
+    });
+    if (!result.ok) process.exitCode = 1;
     return;
   }
   if (cmd === "status" || cmd === "--status") {

package/src/ui/MIGRATION.md

@@ -105,9 +105,8 @@ layout, hooks, and proper isolation of pure logic from rendering.
 
 ### Smoke
 
-- [ ] `node scripts/ucode-app-smoke.js` exits 0.
-- [ ] `npx jest --silent` shows the pre-existing 5 OAuth failures only;
-  every ink suite passes.
+- [ ] `npx jest --runTestsByPath test/unit/ui/UcodeApp.test.js test/unit/code/ucodeTui.test.js --runInBand` passes.
+- [ ] `npx jest --silent` passes; every ink suite stays green.
 
 ## Decision log
 
@@ -118,9 +117,9 @@ layout, hooks, and proper isolation of pure logic from rendering.
   avoids a build step. We can revisit if any single component grows
   past ~600 lines and readability suffers.
 - **Don't enable `--experimental-vm-modules` for jest.** The risk of
-  surprise ESM behaviour across the existing 1800-test suite is too
-  high. Render coverage stays in `scripts/*-smoke.js`; component logic
-  is exercised by pure-function tests.
+  surprise ESM behaviour across the existing test suite is too high.
+  Component logic is exercised by pure-function tests; real TTY render
+  coverage remains a manual smoke step.
 - **Codex isn't a useful reference.** Its TUI is a Rust ratatui app
   (`codex-rs/tui`), not React-based. The architectural principle worth
   borrowing is its hard split between TUI and core protocol.
@@ -307,10 +306,9 @@ and `shouldEchoCommandInChat(text)` are pure.
   the same as ucode.
 
 ### Smoke
-- [ ] `node scripts/chat-app-smoke.js` exits 0.
-- [ ] `node scripts/ucode-app-smoke.js` exits 0.
-- [ ] `npx jest --silent` shows the pre-existing 5 OAuth failures
-  only; every ink suite passes.
+- [ ] `npx jest --runTestsByPath test/unit/ui/ChatApp.test.js test/unit/ui/chatReducer.test.js --runInBand` passes.
+- [ ] `npx jest --runTestsByPath test/unit/ui/UcodeApp.test.js test/unit/code/ucodeTui.test.js --runInBand` passes.
+- [ ] `npx jest --silent` passes; every ink suite stays green.
 
 ## P4 close-out
 

package/src/ui/ink/ChatApp.js

@@ -23,6 +23,7 @@ const fmt = require("../format");
 const { createMultilineInput } = require("./MultilineInput");
 const { createDashboardBar } = require("./DashboardBar");
 const { reducer, createInitialState } = require("./chatReducer");
+const { restartDaemonLifecycle } = require("../../runtime/daemon/restart");
 
 function bootstrapEnvironment(projectRoot, options = {}) {
   // Ensure ufoo dirs exist and that we have a stable subscriber ID.
@@ -1813,11 +1814,15 @@ function createChatApp({ React, ink, props, interactive = true }) {
               return;
             }
             try { if (conn && typeof conn.close === "function") conn.close(); } catch { /* ignore */ }
-            transportStopDaemon(targetRoot, { source: "ink-command:/daemon restart" });
-            transportStartDaemon(targetRoot);
-            if (targetRoot === (currentProjectRootRef.current || props.projectRoot) && conn && typeof conn.connect === "function") {
-              await conn.connect();
-            }
+            await restartDaemonLifecycle({
+              projectRoot: targetRoot,
+              isRunning: props.env && typeof props.env.isRunning === "function" ? props.env.isRunning : null,
+              stopDaemon: (daemonRoot) => transportStopDaemon(daemonRoot, { source: "ink-command:/daemon restart" }),
+              startDaemon: (daemonRoot) => transportStartDaemon(daemonRoot),
+              connect: targetRoot === (currentProjectRootRef.current || props.projectRoot) && conn && typeof conn.connect === "function"
+                ? () => conn.connect()
+                : null,
+            });
           },
           send: (req) => { try { if (conn && typeof conn.send === "function") conn.send(req); } catch { /* ignore */ } },
           requestStatus: requestDaemonStatus,
@@ -3591,6 +3596,7 @@ async function runChatInk(projectRoot, options = {}) {
     daemonConnection,
     stopDaemon,
     startDaemon,
+    isDaemonRunning: env.isRunning,
     logMessage: () => {},
     queueStatusLine: () => {},
     resolveStatusLine: () => {},

package/bin/ucode-core.js

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-
-const { runUcodeCoreCli } = require("../src/code/cli");
-
-(async () => {
-  const argv = process.argv.slice(2);
-  const result = await runUcodeCoreCli({ argv, projectRoot: process.cwd() });
-  if (result && typeof result.output === "string" && result.output) {
-    process.stdout.write(result.output);
-  }
-  process.exit(typeof result.exitCode === "number" ? result.exitCode : 0);
-})().catch((err) => {
-  process.stderr.write(`${err && err.message ? err.message : "ucode-core failed"}\n`);
-  process.exit(1);
-});

package/bin/ufoo

@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-usage() {
-  cat <<'USAGE'
-ufoo
-
-Monorepo layout:
-  ~/.ufoo/                   (clone of ufoo)
-    modules/ai-context/              (protocol module)
-    modules/ai-resources/            (optional resources)
-
-Usage:
-  ufoo doctor
-  ufoo status
-  ufoo daemon --start|--stop|--status
-  ufoo chat
-  ufoo init [--modules context[,resources]] [--project <dir>]
-  ufoo bus <...>            # JS bus implementation (project-local data)
-  ufoo ctx <...>            # JS context commands (doctor|lint|decisions)
-  ufoo skills list
-  ufoo skills install <name|all> [--codex|--agents|--target <dir>]
-
-Notes:
-  - `init` creates/updates <project>/.ai-context and injects CLAUDE.md/AGENTS.md blocks.
-  - For Codex notifications, prefer `ufoo bus alert` / `ufoo bus listen` (no IME issues).
-USAGE
-}
-
-cmd="${1:-}"
-shift || true
-
-case "$cmd" in
-  ""|--help|-h)
-    exec node "$repo_root/bin/ufoo.js" chat
-    ;;
-  doctor)
-    exec node "$repo_root/bin/ufoo.js" doctor "$@"
-    ;;
-  status)
-    exec node "$repo_root/bin/ufoo.js" status "$@"
-    ;;
-  daemon)
-    exec node "$repo_root/bin/ufoo.js" daemon "$@"
-    ;;
-  chat)
-    exec node "$repo_root/bin/ufoo.js" chat
-    ;;
-  init)
-    exec node "$repo_root/bin/ufoo.js" init "$@"
-    ;;
-  bus)
-    # Project-local bus commands. Must be run from within the target project.
-    exec node "$repo_root/bin/ufoo.js" bus "$@"
-    ;;
-  ctx)
-    exec node "$repo_root/bin/ufoo.js" ctx "$@"
-    ;;
-  skills)
-    sub="${1:-}"
-    shift || true
-    exec node "$repo_root/bin/ufoo.js" skills "$sub" "$@"
-    ;;
-  *)
-    echo "Unknown command: $cmd" >&2
-    usage >&2
-    exit 1
-    ;;
-esac

package/scripts/chat-app-smoke.js

@@ -1,30 +0,0 @@
-"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/ink/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);
-});