u-foo 2.3.15 → 2.3.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "2.3.15",
+  "version": "2.3.17",
   "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

@@ -77,30 +77,95 @@ 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 boxTop(title = "", width = 80) {
-    const inner = Math.max(1, width - 2);
-    const label = title ? ` ${title} ` : "";
-    const safe = stripAnsi(label).slice(0, inner);
-    return `┌${safe}${"─".repeat(Math.max(0, inner - safe.length))}┐`;
+  function horizontalLine(width = 80) {
+    return "─".repeat(Math.max(1, width));
   }
 
-  function boxBottom(width = 80) {
-    return `└${"─".repeat(Math.max(1, width - 2))}┘`;
+  function plainLine(text = "", width = 80) {
+    return fitText(text, Math.max(1, width));
   }
 
-  function boxMiddle(text = "", width = 80) {
-    const inner = Math.max(1, width - 2);
-    return `│${fitText(text, inner)}│`;
+  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) {
@@ -108,17 +173,24 @@ function createAgentViewController(options = {}) {
     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;
   }
 
   function getWrappedBusLogLines(width = 80) {
-    const inner = Math.max(1, width - 2);
+    const inner = Math.max(1, width);
     const wrapped = [];
     for (const line of busLogLines) {
       wrapped.push(...wrapTextLine(line, inner));
@@ -130,15 +202,31 @@ function createAgentViewController(options = {}) {
     processStdout.write(`\x1b[${row};1H\x1b[2K${content}`);
   }
 
+  function buildInternalStartupLines(agentLabel = "", width = 80) {
+    const label = String(agentLabel || "").trim();
+    if (width < 48) {
+      return [
+        `Welcome to ufoo internal`,
+        label ? `agent ${label}` : "agent internal",
+        "",
+      ];
+    }
+    return [
+      "Welcome to ufoo internal",
+      "································",
+      "      ░░░░░░                 ██╗   ██╗",
+      "  ░░░   ░░░░░░░░░░           ██║   ██║",
+      "   ░░░░░░░░░░░░░░░░          ╚██████╔╝",
+      label ? `agent  ${label}` : "agent  internal",
+      "",
+    ];
+  }
+
   function resetBusView(agentId) {
     busInputValue = "";
     busInputCursor = 0;
     const label = getAgentLabel(agentId);
-    busLogLines = [
-      `ufoo internal · ${label}`,
-      "Enter 发送 · Esc 返回 · ↓ agent bar",
-      "",
-    ];
+    busLogLines = buildInternalStartupLines(label, getCols());
   }
 
   function appendBusLog(text = "") {
@@ -157,15 +245,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),
     };
   }
 
@@ -175,28 +266,23 @@ function createAgentViewController(options = {}) {
     const cols = getCols();
     const width = Math.max(20, cols);
     const inputTop = Math.max(4, rows - 3);
-    const logTop = 1;
-    const logBottom = Math.max(logTop + 1, inputTop - 1);
-    const logContentTop = logTop + 1;
-    const logContentBottom = logBottom - 1;
+    const logContentTop = 1;
+    const logContentBottom = Math.max(logContentTop, inputTop - 1);
     const logContentHeight = Math.max(1, logContentBottom - logContentTop + 1);
-    const label = getAgentLabel(viewingAgent);
 
     processStdout.write("\x1b[?25l");
-    writeAt(logTop, boxTop(`ufoo internal · ${label}`, width));
     const visibleLines = getWrappedBusLogLines(width).slice(-logContentHeight);
     for (let i = 0; i < logContentHeight; i += 1) {
-      writeAt(logContentTop + i, boxMiddle(visibleLines[i] || "", width));
+      writeAt(logContentTop + i, plainLine(visibleLines[i] || "", width));
     }
-    writeAt(logBottom, boxBottom(width));
 
-    writeAt(inputTop, boxTop("message", width));
+    writeAt(inputTop, horizontalLine(width));
     const viewport = getBusInputViewport(width);
-    writeAt(inputTop + 1, boxMiddle(`> ${viewport.text}`, width));
-    writeAt(inputTop + 2, boxBottom(width));
+    writeAt(inputTop + 1, plainLine(`> ${viewport.text}`, width));
+    writeAt(inputTop + 2, horizontalLine(width));
 
     renderAgentDashboard();
-    const cursorCol = clamp(4 + viewport.cursorCol, 1, width);
+    const cursorCol = clamp(3 + viewport.cursorCol, 1, width);
     processStdout.write(`\x1b[${inputTop + 1};${cursorCol}H\x1b[?25h`);
   }
 
@@ -347,10 +433,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();
   }
 
@@ -406,12 +548,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;
     }
@@ -431,7 +573,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 });
   }
 

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);
 }