u-foo 2.3.16 → 2.3.18

package/package.json

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

package/src/agent/internalRunner.js

@@ -184,6 +184,16 @@ function createBusSender(projectRoot, subscriber) {
   return { enqueue, flush };
 }
 
+function isChatUiSource(source = "") {
+  const value = String(source || "").trim();
+  return value === "chat-direct" || value === "chat-internal-agent-view";
+}
+
+function shouldStreamReplyToPublisher(projectRoot, publisher, evt = {}) {
+  if (isChatUiSource(evt && evt.data ? evt.data.source : "")) return true;
+  return shouldForwardStreamToPublisher(projectRoot, publisher);
+}
+
 function drainQueue(queueFile) {
   if (!fs.existsSync(queueFile)) return [];
   const processingFile = `${queueFile}.processing.${process.pid}.${Date.now()}`;
@@ -304,7 +314,7 @@ async function handleEvent(
     .filter(Boolean)
     .join("\n\n");
   const publisher = evt.publisher || "unknown";
-  const streamToPublisher = shouldForwardStreamToPublisher(projectRoot, publisher);
+  const streamToPublisher = shouldStreamReplyToPublisher(projectRoot, publisher, evt);
 
   const emitStreamDelta = (delta) => {
     const text = String(delta || "");

package/src/chat/agentViewController.js

@@ -1,3 +1,6 @@
+const os = require("os");
+const { version: packageVersion } = require("../../package.json");
+
 function createAgentViewController(options = {}) {
   const {
     screen,
@@ -17,6 +20,7 @@ function createAgentViewController(options = {}) {
     setAgentListWindowStart = () => {},
     getAgentLabel = (id) => id,
     getAgentStates = () => ({}),
+    getProjectRoot = () => process.cwd(),
     setDashboardView = () => {},
     setScreenGrabKeys = (value) => {
       if (screen) screen.grabKeys = Boolean(value);
@@ -77,14 +81,64 @@ function createAgentViewController(options = {}) {
     return Math.max(min, Math.min(max, normalized));
   }
 
+  function charDisplayWidth(char = "") {
+    if (!char) return 0;
+    const code = char.codePointAt(0) || 0;
+    if (code === 0) return 0;
+    if (code < 32 || (code >= 0x7f && code < 0xa0)) return 0;
+    if ((code >= 0x0300 && code <= 0x036f) ||
+      (code >= 0x1ab0 && code <= 0x1aff) ||
+      (code >= 0x1dc0 && code <= 0x1dff) ||
+      (code >= 0x20d0 && code <= 0x20ff) ||
+      (code >= 0xfe20 && code <= 0xfe2f)) {
+      return 0;
+    }
+    if ((code >= 0x1100 && code <= 0x115f) ||
+      code === 0x2329 ||
+      code === 0x232a ||
+      (code >= 0x2e80 && code <= 0xa4cf) ||
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe10 && code <= 0xfe19) ||
+      (code >= 0xfe30 && code <= 0xfe6f) ||
+      (code >= 0xff00 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6) ||
+      (code >= 0x1f300 && code <= 0x1faff)) {
+      return 2;
+    }
+    return 1;
+  }
+
+  function displayWidth(text = "") {
+    return Array.from(stripAnsi(String(text || ""))).reduce((sum, char) => sum + charDisplayWidth(char), 0);
+  }
+
+  function padToWidth(text = "", width = 1) {
+    const cells = displayWidth(text);
+    return String(text || "") + " ".repeat(Math.max(0, width - cells));
+  }
+
+  function truncateToWidth(text = "", width = 1) {
+    const target = Math.max(1, width);
+    let out = "";
+    let cells = 0;
+    for (const char of Array.from(stripAnsi(String(text || "")))) {
+      const charWidth = charDisplayWidth(char);
+      if (cells + charWidth > target) break;
+      out += char;
+      cells += charWidth;
+    }
+    return padToWidth(out, target);
+  }
+
   function fitText(text = "", width = 1) {
     const normalizedWidth = Math.max(1, width);
     const clean = stripAnsi(String(text || "")).replace(/\r/g, "");
-    if (clean.length <= normalizedWidth) {
-      return clean + " ".repeat(normalizedWidth - clean.length);
+    if (displayWidth(clean) <= normalizedWidth) {
+      return padToWidth(clean, normalizedWidth);
     }
-    if (normalizedWidth <= 1) return clean.slice(0, normalizedWidth);
-    return clean.slice(0, normalizedWidth - 1) + "…";
+    if (normalizedWidth <= 1) return truncateToWidth(clean, normalizedWidth);
+    return `${truncateToWidth(clean, normalizedWidth - 1).trimEnd()}…`;
   }
 
   function horizontalLine(width = 80) {
@@ -95,17 +149,47 @@ function createAgentViewController(options = {}) {
     return fitText(text, Math.max(1, width));
   }
 
+  function sliceDisplayCells(text = "", startCell = 0, maxCells = 1) {
+    const targetStart = Math.max(0, startCell);
+    const targetWidth = Math.max(1, maxCells);
+    let out = "";
+    let cells = 0;
+    let started = false;
+    for (const char of Array.from(String(text || ""))) {
+      const charWidth = charDisplayWidth(char);
+      const nextCells = cells + charWidth;
+      if (!started) {
+        if (nextCells <= targetStart) {
+          cells = nextCells;
+          continue;
+        }
+        started = true;
+      }
+      if (displayWidth(out) + charWidth > targetWidth) break;
+      out += char;
+      cells = nextCells;
+    }
+    return out;
+  }
+
   function wrapTextLine(text = "", width = 80) {
     const inner = Math.max(1, width);
     const clean = stripAnsi(String(text || ""));
     if (!clean) return [""];
     const lines = [];
-    let rest = clean;
-    while (rest.length > inner) {
-      lines.push(rest.slice(0, inner));
-      rest = rest.slice(inner);
+    let current = "";
+    let cells = 0;
+    for (const char of Array.from(clean)) {
+      const charWidth = charDisplayWidth(char);
+      if (cells > 0 && cells + charWidth > inner) {
+        lines.push(current);
+        current = "";
+        cells = 0;
+      }
+      current += char;
+      cells += charWidth;
     }
-    lines.push(rest);
+    lines.push(current);
     return lines;
   }
 
@@ -122,14 +206,93 @@ function createAgentViewController(options = {}) {
     processStdout.write(`\x1b[${row};1H\x1b[2K${content}`);
   }
 
+  function forceScreenRepaint() {
+    if (typeof screen.realloc === "function") {
+      screen.realloc();
+      return;
+    }
+    if (typeof screen.alloc === "function") {
+      screen.alloc(true);
+    }
+  }
+
+  function compactProjectPath(projectRoot = "") {
+    const raw = String(projectRoot || process.cwd() || "").trim();
+    const home = os.homedir();
+    if (home && (raw === home || raw.startsWith(`${home}/`))) {
+      return `~${raw.slice(home.length)}`;
+    }
+    return raw || ".";
+  }
+
+  function borderedLines(lines = [], innerWidth = 56) {
+    const contentWidth = Math.max(1, innerWidth);
+    const out = [`╭${"─".repeat(contentWidth + 2)}╮`];
+    for (const line of lines) {
+      out.push(`│ ${fitText(line, contentWidth)} │`);
+    }
+    out.push(`╰${"─".repeat(contentWidth + 2)}╯`);
+    return out;
+  }
+
+  function normalizeAgentKind(agentId = "") {
+    const text = String(agentId || "").trim().toLowerCase();
+    if (text.startsWith("codex:") || text === "codex") return "codex";
+    if (text.startsWith("claude:") || text.startsWith("claude-code:") || text === "claude" || text === "claude-code") {
+      return "claude";
+    }
+    return "internal";
+  }
+
+  function buildClaudeStartupLines(agentLabel = "", width = 80) {
+    const label = String(agentLabel || "").trim();
+    const projectPath = compactProjectPath(getProjectRoot());
+    const product = "Claude Code";
+    const detail = label ? `${label} · managed headless` : "managed headless";
+    const lines = [
+      ` ▐▛███▜▌${product} v${packageVersion}`,
+      `▝▜█████▛▘${detail}`,
+      ` ▘▘▝▝${projectPath}`,
+      "",
+    ];
+    if (width < 44) return lines;
+    return lines.map((line) => padToWidth(line, Math.min(58, Math.max(1, width))));
+  }
+
+  function buildCodexStartupLines(agentLabel = "", width = 80) {
+    const label = String(agentLabel || "").trim();
+    const projectPath = compactProjectPath(getProjectRoot());
+    if (width < 36) {
+      return [
+        `>_ OpenAI Codex`,
+        label ? `model: ${label}` : "model: managed headless",
+        `directory: ${projectPath}`,
+        "",
+      ];
+    }
+    const innerWidth = Math.min(56, Math.max(24, width - 4));
+    return [
+      ...borderedLines([
+        `>_ OpenAI Codex (ufoo v${packageVersion})`,
+        "",
+        `model:     ${label ? `${label} · managed headless` : "managed headless"}`,
+        `directory: ${projectPath}`,
+      ], innerWidth),
+      "",
+    ];
+  }
+
+  function buildInternalStartupLines(agentId = "", agentLabel = "", width = 80) {
+    const kind = normalizeAgentKind(agentId);
+    if (kind === "codex") return buildCodexStartupLines(agentLabel || agentId, width);
+    return buildClaudeStartupLines(agentLabel || agentId, width);
+  }
+
   function resetBusView(agentId) {
     busInputValue = "";
     busInputCursor = 0;
     const label = getAgentLabel(agentId);
-    busLogLines = [
-      `ufoo internal · ${label}`,
-      "",
-    ];
+    busLogLines = buildInternalStartupLines(agentId, label, getCols());
   }
 
   function appendBusLog(text = "") {
@@ -148,15 +311,18 @@ function createAgentViewController(options = {}) {
   }
 
   function getBusInputViewport(width) {
-    const inner = Math.max(1, width - 4);
+    const inner = Math.max(1, width - 2);
     const value = String(busInputValue || "").replace(/\n/g, "⏎");
-    let start = 0;
-    if (busInputCursor >= inner) {
-      start = busInputCursor - inner + 1;
+    const beforeCursor = String(busInputValue || "").slice(0, busInputCursor).replace(/\n/g, "⏎");
+    const cursorCells = displayWidth(beforeCursor);
+    let startCell = 0;
+    if (cursorCells >= inner) {
+      startCell = cursorCells - inner + 1;
     }
+    const text = sliceDisplayCells(value, startCell, inner);
     return {
-      text: value.slice(start, start + inner),
-      cursorCol: Math.max(0, busInputCursor - start),
+      text,
+      cursorCol: Math.max(0, cursorCells - startCell),
     };
   }
 
@@ -284,7 +450,7 @@ function createAgentViewController(options = {}) {
     viewingAgent = null;
 
     processStdout.write(`\x1b[1;${rows}r`);
-    processStdout.write("\x1b[2J\x1b[H");
+    processStdout.write("\x1b[?25h");
 
     if (detachedChildren) {
       for (const child of detachedChildren) screen.append(child);
@@ -296,9 +462,7 @@ function createAgentViewController(options = {}) {
     setDashboardView("agents");
     setSelectedAgentIndex(-1);
     setScreenGrabKeys(false);
-    if (typeof screen.alloc === "function") {
-      screen.alloc();
-    }
+    forceScreenRepaint();
     clearTargetAgent();
     renderDashboard();
     focusInput();
@@ -333,10 +497,66 @@ function createAgentViewController(options = {}) {
     renderBusView();
   }
 
+  function inputBoundaries(text = "") {
+    const source = String(text || "");
+    if (!source) return [0];
+    try {
+      if (typeof Intl !== "undefined" && typeof Intl.Segmenter === "function") {
+        const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+        const boundaries = [0];
+        for (const part of segmenter.segment(source)) {
+          boundaries.push(part.index + part.segment.length);
+        }
+        return Array.from(new Set(boundaries)).sort((a, b) => a - b);
+      }
+    } catch {
+      // Fall through to code point boundaries.
+    }
+    const boundaries = [0];
+    let offset = 0;
+    for (const char of Array.from(source)) {
+      offset += char.length;
+      boundaries.push(offset);
+    }
+    return boundaries;
+  }
+
+  function clampInputCursor(pos = busInputCursor) {
+    const boundaries = inputBoundaries(busInputValue);
+    const target = clamp(pos, 0, busInputValue.length);
+    let best = 0;
+    for (const boundary of boundaries) {
+      if (boundary <= target) best = boundary;
+      else break;
+    }
+    return best;
+  }
+
+  function previousInputBoundary(pos = busInputCursor) {
+    const boundaries = inputBoundaries(busInputValue);
+    const target = clamp(pos, 0, busInputValue.length);
+    let prev = 0;
+    for (const boundary of boundaries) {
+      if (boundary < target) prev = boundary;
+      else break;
+    }
+    return prev;
+  }
+
+  function nextInputBoundary(pos = busInputCursor) {
+    const boundaries = inputBoundaries(busInputValue);
+    const target = clamp(pos, 0, busInputValue.length);
+    for (const boundary of boundaries) {
+      if (boundary > target) return boundary;
+    }
+    return busInputValue.length;
+  }
+
   function deleteBusInputBeforeCursor() {
     if (busInputCursor <= 0) return;
-    busInputValue = busInputValue.slice(0, busInputCursor - 1) + busInputValue.slice(busInputCursor);
-    busInputCursor -= 1;
+    const previous = previousInputBoundary();
+    busInputValue = busInputValue.slice(0, previous) + busInputValue.slice(busInputCursor);
+    busInputCursor = previous;
     renderBusView();
   }
 
@@ -392,12 +612,12 @@ function createAgentViewController(options = {}) {
       return true;
     }
     if (keyName === "left") {
-      busInputCursor = Math.max(0, busInputCursor - 1);
+      busInputCursor = previousInputBoundary();
       renderBusView();
       return true;
     }
     if (keyName === "right") {
-      busInputCursor = Math.min(busInputValue.length, busInputCursor + 1);
+      busInputCursor = nextInputBoundary();
       renderBusView();
       return true;
     }
@@ -417,7 +637,9 @@ function createAgentViewController(options = {}) {
     }
     if (keyName === "delete") {
       if (busInputCursor < busInputValue.length) {
-        busInputValue = busInputValue.slice(0, busInputCursor) + busInputValue.slice(busInputCursor + 1);
+        const next = nextInputBoundary();
+        busInputValue = busInputValue.slice(0, busInputCursor) + busInputValue.slice(next);
+        busInputCursor = clampInputCursor();
         renderBusView();
       }
       return true;

package/src/chat/index.js

@@ -355,7 +355,12 @@ async function runChat(projectRoot, options = {}) {
   let preferredCol = null;
 
   function getInnerWidth() {
-    const promptWidth = promptBox && typeof promptBox.width === "number" ? promptBox.width : 2;
+    let promptWidth = 2;
+    try {
+      if (promptBox && typeof promptBox.width === "number") promptWidth = promptBox.width;
+    } catch {
+      promptWidth = 2;
+    }
     return inputMath.getInnerWidth({ input, screen, promptWidth });
   }
 
@@ -1538,6 +1543,7 @@ async function runChat(projectRoot, options = {}) {
       }
       return states;
     },
+    getProjectRoot: () => activeProjectRoot,
     setDashboardView: (value) => {
       dashboardView = value;
     },

package/src/chat/inputMath.js

@@ -50,10 +50,18 @@ function safeStrWidth(strWidth, value) {
   return Array.from(expanded).length;
 }
 
+function safeRead(getter, fallback = undefined) {
+  try {
+    return getter();
+  } catch {
+    return fallback;
+  }
+}
+
 function getInnerWidth({ input, screen, promptWidth = 2 }) {
   const targetInput = input && typeof input === "object" ? input : {};
   const targetScreen = screen && typeof screen === "object" ? screen : {};
-  let lpos = targetInput.lpos || null;
+  let lpos = safeRead(() => targetInput.lpos, null) || null;
   if (!lpos && typeof targetInput._getCoords === "function") {
     try {
       lpos = targetInput._getCoords();
@@ -64,21 +72,27 @@ function getInnerWidth({ input, screen, promptWidth = 2 }) {
   if (lpos && Number.isFinite(lpos.xl) && Number.isFinite(lpos.xi)) {
     return Math.max(1, lpos.xl - lpos.xi);
   }
-  if (typeof targetInput.width === "number") return Math.max(1, targetInput.width);
-  if (typeof targetInput.width === "string") {
-    const match = targetInput.width.match(/^100%-([0-9]+)$/);
-    if (match && typeof targetScreen.width === "number") {
-      return Math.max(1, targetScreen.width - parseInt(match[1], 10));
+  const inputWidth = safeRead(() => targetInput.width);
+  if (typeof inputWidth === "number") return Math.max(1, inputWidth);
+  if (typeof inputWidth === "string") {
+    const match = inputWidth.match(/^100%-([0-9]+)$/);
+    const screenWidth = safeRead(() => targetScreen.width);
+    if (match && typeof screenWidth === "number") {
+      return Math.max(1, screenWidth - parseInt(match[1], 10));
     }
   }
-  if (typeof targetScreen.width === "number") return Math.max(1, targetScreen.width - promptWidth);
-  if (typeof targetScreen.cols === "number") return Math.max(1, targetScreen.cols - promptWidth);
+  const screenWidth = safeRead(() => targetScreen.width);
+  if (typeof screenWidth === "number") return Math.max(1, screenWidth - promptWidth);
+  const screenCols = safeRead(() => targetScreen.cols);
+  if (typeof screenCols === "number") return Math.max(1, screenCols - promptWidth);
   return 1;
 }
 
 function getWrapWidth(input, fallbackWidth) {
-  if (input && input._clines && typeof input._clines.width === "number") {
-    return Math.max(1, input._clines.width);
+  const clines = safeRead(() => input && input._clines, null);
+  const clinesWidth = safeRead(() => clines && clines.width);
+  if (typeof clinesWidth === "number") {
+    return Math.max(1, clinesWidth);
   }
   return Math.max(1, fallbackWidth || 1);
 }