u-foo 1.4.1 → 1.6.0

package/src/chat/inputHistoryController.js

@@ -2,16 +2,18 @@ const fs = require("fs");
 
 function createInputHistoryController(options = {}) {
   const {
-    inputHistoryFile,
-    historyDir,
+    inputHistoryFile: inputHistoryFileOption,
+    historyDir: historyDirOption,
     setInputValue = () => {},
     getInputValue = () => "",
     fsMod = fs,
   } = options;
 
-  if (!inputHistoryFile || !historyDir) {
+  if (!inputHistoryFileOption || !historyDirOption) {
     throw new Error("createInputHistoryController requires inputHistoryFile and historyDir");
   }
+  let inputHistoryFile = inputHistoryFileOption;
+  let historyDir = historyDirOption;
 
   const inputHistory = [];
   let historyIndex = 0;
@@ -24,6 +26,9 @@ function createInputHistoryController(options = {}) {
   }
 
   function loadInputHistory(limit = 2000) {
+    inputHistory.length = 0;
+    historyIndex = 0;
+    historyDraft = "";
     try {
       const raw = fsMod.readFileSync(inputHistoryFile, "utf8");
       const lines = String(raw || "").trim().split(/\r?\n/).filter(Boolean);
@@ -85,6 +90,28 @@ function createInputHistoryController(options = {}) {
     setIndexToEnd();
   }
 
+  function setHistoryTarget(next = {}) {
+    if (!next.inputHistoryFile || !next.historyDir) {
+      throw new Error("setHistoryTarget requires inputHistoryFile and historyDir");
+    }
+    inputHistoryFile = next.inputHistoryFile;
+    historyDir = next.historyDir;
+  }
+
+  function restoreDraft(draft = "") {
+    const nextDraft = String(draft || "");
+    setInputValue(nextDraft);
+    historyIndex = inputHistory.length;
+    historyDraft = nextDraft;
+  }
+
+  function getDraftForPersistence() {
+    if (historyIndex === inputHistory.length) {
+      return String(getInputValue() || "");
+    }
+    return String(historyDraft || "");
+  }
+
   return {
     loadInputHistory,
     updateDraftFromInput,
@@ -92,6 +119,9 @@ function createInputHistoryController(options = {}) {
     historyDown,
     commitSubmittedText,
     setIndexToEnd,
+    setHistoryTarget,
+    restoreDraft,
+    getDraftForPersistence,
     getState: () => ({
       history: [...inputHistory],
       historyIndex,

package/src/chat/inputListenerController.js

@@ -204,23 +204,33 @@ function createInputListenerController(options = {}) {
 
     if (keyName === "up" || keyName === "down") {
       const innerWidth = getWrapWidth();
-      if (innerWidth > 0) {
-        const cursorPos = getCursorPos();
-        const value = (textarea && textarea.value) || "";
-        const { row, col } = getCursorRowCol(value, cursorPos, innerWidth);
-        if (getPreferredCol() === null) setPreferredCol(col);
-        const totalRows = countLines(value, innerWidth);
-
-        if (keyName === "down" && row >= totalRows - 1) {
+      if (innerWidth <= 0) {
+        if (keyName === "down") {
           enterDashboardMode();
           return;
         }
+        ensureInputCursorVisible();
+        updateCursor(textarea);
+        render(textarea);
+        return;
+      }
 
-        const targetRow = keyName === "up"
-          ? Math.max(0, row - 1)
-          : Math.min(totalRows - 1, row + 1);
-        setCursorPos(getCursorPosForRowCol(value, targetRow, getPreferredCol(), innerWidth));
+      const cursorPos = getCursorPos();
+      const value = (textarea && textarea.value) || "";
+      const { row, col } = getCursorRowCol(value, cursorPos, innerWidth);
+      if (getPreferredCol() === null) setPreferredCol(col);
+      const totalRows = countLines(value, innerWidth);
+
+      if (keyName === "down" && row >= totalRows - 1) {
+        enterDashboardMode();
+        return;
       }
+
+      const targetRow = keyName === "up"
+        ? Math.max(0, row - 1)
+        : Math.min(totalRows - 1, row + 1);
+      setCursorPos(getCursorPosForRowCol(value, targetRow, getPreferredCol(), innerWidth));
+
       ensureInputCursorVisible();
       updateCursor(textarea);
       render(textarea);

package/src/chat/layout.js

@@ -2,8 +2,13 @@ function createChatLayout(options = {}) {
   const {
     blessed,
     currentInputHeight = 4,
+    dashboardHeight = 1,
     version = "unknown",
   } = options;
+  const normalizedDashboardHeight = Number.isFinite(dashboardHeight) && dashboardHeight > 0
+    ? Math.floor(dashboardHeight)
+    : 1;
+  const reservedBottomLines = Math.max(2, currentInputHeight + 1);
 
   const screen = blessed.screen({
     smartCSR: true,
@@ -33,7 +38,7 @@ function createChatLayout(options = {}) {
     top: 0,
     left: 0,
     width: "100%",
-    height: "100%-5", // Will be adjusted dynamically
+    height: `100%-${reservedBottomLines}`, // Will be adjusted dynamically
     tags: true,
     scrollable: true,
     alwaysScroll: true,
@@ -97,7 +102,7 @@ function createChatLayout(options = {}) {
     bottom: 0,
     left: 0,
     width: "100%",
-    height: 1,
+    height: normalizedDashboardHeight,
     style: { fg: "gray" },
     tags: true,
   });
@@ -105,7 +110,7 @@ function createChatLayout(options = {}) {
   // Bottom border line for input area (above dashboard)
   const inputBottomLine = blessed.line({
     parent: screen,
-    bottom: 1,
+    bottom: normalizedDashboardHeight,
     left: 1,
     width: "100%-2",
     orientation: "horizontal",
@@ -115,10 +120,10 @@ function createChatLayout(options = {}) {
   // Prompt indicator
   const promptBox = blessed.box({
     parent: screen,
-    bottom: 2,
+    bottom: normalizedDashboardHeight + 1,
     left: 0,
     width: 2,
-    height: currentInputHeight - 3,
+    height: Math.max(1, currentInputHeight - normalizedDashboardHeight - 2),
     content: ">",
     style: { fg: "cyan" },
   });
@@ -126,10 +131,10 @@ function createChatLayout(options = {}) {
   // Input area without left/right border
   const input = blessed.textarea({
     parent: screen,
-    bottom: 2,
+    bottom: normalizedDashboardHeight + 1,
     left: 2,
     width: "100%-2",
-    height: currentInputHeight - 3,
+    height: Math.max(1, currentInputHeight - normalizedDashboardHeight - 2),
     inputOnFocus: true,
     keys: true,
   });

package/src/chat/projectCloseController.js

@@ -0,0 +1,119 @@
+function normalizeIndex(value, length) {
+  const parsed = Number(value);
+  const nextIndex = Number.isFinite(parsed) ? Math.trunc(parsed) : Number.NaN;
+  if (!Number.isFinite(nextIndex) || nextIndex < 0 || nextIndex >= length) {
+    return -1;
+  }
+  return nextIndex;
+}
+
+function defaultResolveProjectRoot(row = {}) {
+  return String((row && row.project_root) || "");
+}
+
+function createProjectCloseController(options = {}) {
+  const {
+    getProjects = () => [],
+    getActiveProjectRoot = () => "",
+    resolveProjectRoot = defaultResolveProjectRoot,
+    isRunning = () => false,
+    stopDaemon = () => false,
+    switchProject = async () => ({ ok: false, error: "project switching unavailable" }),
+    refreshProjects = () => {},
+    renderDashboard = () => {},
+    renderScreen = () => {},
+    logMessage = () => {},
+    escapeBlessed = (value) => String(value || ""),
+  } = options;
+
+  let closingProject = false;
+
+  function pickFallbackProjectRoot(targetProjectRoot) {
+    const rows = Array.isArray(getProjects()) ? getProjects() : [];
+    for (const row of rows) {
+      const root = resolveProjectRoot(row);
+      if (!root || root === targetProjectRoot) continue;
+      return root;
+    }
+    return "";
+  }
+
+  async function requestCloseProject(index) {
+    if (closingProject) {
+      return { ok: false, error: "project close already in progress" };
+    }
+
+    const rows = Array.isArray(getProjects()) ? getProjects() : [];
+    const nextIndex = normalizeIndex(index, rows.length);
+    if (nextIndex < 0) {
+      return { ok: false, error: "project index out of range" };
+    }
+
+    const target = rows[nextIndex] || {};
+    const projectRoot = resolveProjectRoot(target);
+    if (!projectRoot) {
+      return { ok: false, error: "project root unavailable" };
+    }
+
+    const projectName = String(target.project_name || projectRoot);
+    const escapedName = escapeBlessed(projectName);
+    const activeProjectRoot = String(getActiveProjectRoot() || "");
+
+    closingProject = true;
+    try {
+      logMessage("status", `{white-fg}⚙{/white-fg} Closing project ${escapedName} daemon and agents...`);
+
+      let switchedTo = "";
+      if (activeProjectRoot === projectRoot) {
+        const fallbackRoot = pickFallbackProjectRoot(projectRoot);
+        if (!fallbackRoot) {
+          const error = "Cannot close current project; switch to another project first";
+          logMessage("error", `{white-fg}✗{/white-fg} ${escapeBlessed(error)}`);
+          return { ok: false, error };
+        }
+
+        const switched = await Promise.resolve(switchProject(fallbackRoot));
+        if (!switched || switched.ok !== true) {
+          const reason = String((switched && switched.error) || "switch failed");
+          logMessage("error", `{white-fg}✗{/white-fg} Failed to switch project before close: ${escapeBlessed(reason)}`);
+          return { ok: false, error: reason };
+        }
+        switchedTo = fallbackRoot;
+      }
+
+      const wasRunning = Boolean(isRunning(projectRoot));
+      stopDaemon(projectRoot);
+
+      refreshProjects();
+      renderDashboard();
+      renderScreen();
+
+      if (wasRunning) {
+        logMessage("status", `{white-fg}✓{/white-fg} Closed project ${escapedName} daemon and agents`);
+      } else {
+        logMessage("status", `{white-fg}✓{/white-fg} Project ${escapedName} daemon already stopped`);
+      }
+
+      return {
+        ok: true,
+        project_root: projectRoot,
+        switched_to: switchedTo || undefined,
+      };
+    } catch (err) {
+      const message = err && err.message ? err.message : String(err || "project close failed");
+      logMessage("error", `{white-fg}✗{/white-fg} Failed to close project: ${escapeBlessed(message)}`);
+      return { ok: false, error: message };
+    } finally {
+      closingProject = false;
+    }
+  }
+
+  return {
+    requestCloseProject,
+    pickFallbackProjectRoot,
+  };
+}
+
+module.exports = {
+  createProjectCloseController,
+};

package/src/chat/projectRuntimes.js

@@ -0,0 +1,55 @@
+function parseTimestampMs(value) {
+  const parsed = Date.parse(String(value || ""));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function projectLabel(row = {}) {
+  return String(row.project_name || row.project_root || "");
+}
+
+function normalizeInteractionMs(value) {
+  const num = Number(value);
+  if (!Number.isFinite(num) || num < 0) return 0;
+  return num;
+}
+
+function filterVisibleProjectRuntimes(rows = []) {
+  const sourceRows = Array.isArray(rows) ? rows : [];
+  return sourceRows.filter((row) => {
+    const status = String((row && row.status) || "").trim().toLowerCase();
+    return status !== "stopped";
+  });
+}
+
+function sortProjectRuntimes(options = {}) {
+  const {
+    rows = [],
+    activeProjectRoot = "",
+    resolveProjectRoot = (row) => String((row && row.project_root) || ""),
+    getInteractionMs = () => 0,
+  } = options;
+  const sourceRows = Array.isArray(rows) ? rows.slice() : [];
+  // Keep arg usage for backward compatibility with existing callers/tests.
+  void activeProjectRoot;
+  void resolveProjectRoot;
+
+  sourceRows.sort((a, b) => {
+    const bInteraction = normalizeInteractionMs(getInteractionMs(b));
+    const aInteraction = normalizeInteractionMs(getInteractionMs(a));
+    if (bInteraction !== aInteraction) return bInteraction - aInteraction;
+
+    const bSeen = parseTimestampMs(b && b.last_seen);
+    const aSeen = parseTimestampMs(a && a.last_seen);
+    if (bSeen !== aSeen) return bSeen - aSeen;
+
+    return projectLabel(a).localeCompare(projectLabel(b), "en", { sensitivity: "base" });
+  });
+
+  return sourceRows;
+}
+
+module.exports = {
+  sortProjectRuntimes,
+  parseTimestampMs,
+  filterVisibleProjectRuntimes,
+};

package/src/chat/statusLineController.js

@@ -107,20 +107,66 @@ function createStatusLineController(options = {}) {
     renderStatusLine();
   }
 
-  function queueStatusLine(text) {
-    pendingStatusLines.push(text || "");
+  function normalizePendingItem(text, options = {}) {
+    const key = options && typeof options.key === "string"
+      ? options.key.trim()
+      : "";
+    return {
+      text: text || "",
+      key,
+    };
+  }
+
+  function headPendingText() {
+    if (pendingStatusLines.length === 0) return "";
+    const item = pendingStatusLines[0];
+    return item && typeof item.text === "string" ? item.text : "";
+  }
+
+  function queueStatusLine(text, options = {}) {
+    const item = normalizePendingItem(text, options);
+    if (item.key) {
+      const existingIndex = pendingStatusLines.findIndex((entry) => entry.key === item.key);
+      if (existingIndex >= 0) {
+        pendingStatusLines[existingIndex] = item;
+        if (existingIndex === 0) {
+          setPrimaryStatus(item.text, { pending: true });
+          renderScreen();
+        }
+        return;
+      }
+    }
+
+    pendingStatusLines.push(item);
     if (pendingStatusLines.length === 1) {
-      setPrimaryStatus(pendingStatusLines[0], { pending: true });
+      setPrimaryStatus(item.text, { pending: true });
       renderScreen();
     }
   }
 
-  function resolveStatusLine(text) {
+  function resolveStatusLine(text, options = {}) {
+    const key = options && typeof options.key === "string"
+      ? options.key.trim()
+      : "";
+    let removedHead = false;
+
     if (pendingStatusLines.length > 0) {
-      pendingStatusLines.shift();
+      if (key) {
+        const index = pendingStatusLines.findIndex((entry) => entry.key === key);
+        if (index >= 0) {
+          pendingStatusLines.splice(index, 1);
+          removedHead = index === 0;
+        }
+      } else {
+        pendingStatusLines.shift();
+        removedHead = true;
+      }
     }
+
     if (pendingStatusLines.length > 0) {
-      setPrimaryStatus(pendingStatusLines[0], { pending: true });
+      if (removedHead || !primaryStatusPending) {
+        setPrimaryStatus(headPendingText(), { pending: true });
+      }
     } else {
       setPrimaryStatus(text || "", { pending: false });
     }

package/src/chat/streamTracker.js

@@ -136,11 +136,17 @@ function createStreamTracker(options = {}) {
     return true;
   }
 
+  function discardAll() {
+    streamStates.clear();
+    pendingDeliveries.clear();
+  }
+
   return {
     beginStream,
     appendStreamDelta,
     finalizeStream,
     hasStream,
+    discardAll,
     markPendingDelivery,
     getPendingState,
     consumePendingDelivery,

package/src/chat/transport.js

@@ -3,10 +3,46 @@ const path = require("path");
 const fs = require("fs");
 const { spawn, spawnSync } = require("child_process");
 
-function connectSocket(sockPath) {
+function connectSocket(sockPath, options = {}) {
+  const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+    ? Math.trunc(options.timeoutMs)
+    : 0;
   return new Promise((resolve, reject) => {
-    const client = net.createConnection(sockPath, () => resolve(client));
-    client.on("error", reject);
+    let timeoutHandle = null;
+    const client = net.createConnection(sockPath, () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      resolve(client);
+    });
+
+    const cleanup = () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = null;
+      }
+    };
+
+    client.on("error", (err) => {
+      cleanup();
+      reject(err);
+    });
+
+    if (timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        const err = new Error(`connect timeout after ${timeoutMs}ms`);
+        err.code = "ETIMEDOUT";
+        try {
+          client.destroy(err);
+        } catch {
+          // ignore
+        }
+        reject(err);
+      }, timeoutMs);
+      if (typeof timeoutHandle.unref === "function") {
+        timeoutHandle.unref();
+      }
+    }
   });
 }
 
@@ -38,11 +74,11 @@ function stopDaemon(projectRoot) {
   });
 }
 
-async function connectWithRetry(sockPath, retries, delayMs) {
+async function connectWithRetry(sockPath, retries, delayMs, options = {}) {
   for (let i = 0; i < retries; i += 1) {
     try {
       // eslint-disable-next-line no-await-in-loop
-      const client = await connectSocket(sockPath);
+      const client = await connectSocket(sockPath, options);
       return client;
     } catch {
       // eslint-disable-next-line no-await-in-loop