u-foo 1.0.6 → 1.1.9

package/src/chat/agentSockets.js

@@ -0,0 +1,225 @@
+const fs = require("fs");
+const net = require("net");
+const { PTY_SOCKET_MESSAGE_TYPES, PTY_SOCKET_SUBSCRIBE_MODES } = require("../shared/ptySocketContract");
+
+function createAgentSockets(options = {}) {
+  const {
+    onTermWrite = () => {},
+    onPlaceCursor = () => {},
+    isAgentView = () => false,
+    isBusMode = () => false,
+    getViewingAgent = () => "",
+    sendBusRaw = () => {},
+  } = options;
+
+  let outputClient = null;
+  let outputBuffer = "";
+  let inputClient = null;
+  let pendingResize = null;
+
+  function requestSnapshot(mode = PTY_SOCKET_SUBSCRIBE_MODES.SCREEN) {
+    if (!outputClient || outputClient.destroyed) return false;
+    const safeMode = mode === PTY_SOCKET_SUBSCRIBE_MODES.FULL
+      ? PTY_SOCKET_SUBSCRIBE_MODES.FULL
+      : PTY_SOCKET_SUBSCRIBE_MODES.SCREEN;
+    try {
+      outputClient.write(JSON.stringify({
+        type: PTY_SOCKET_MESSAGE_TYPES.SUBSCRIBE,
+        mode: safeMode,
+      }) + "\n");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function requestScreenSnapshot() {
+    return requestSnapshot(PTY_SOCKET_SUBSCRIBE_MODES.SCREEN);
+  }
+
+  function connectOutput(sockPath) {
+    if (outputClient) {
+      disconnectOutput();
+    }
+    outputBuffer = "";
+
+    if (!fs.existsSync(sockPath)) {
+      onTermWrite("\x1b[1;31m[Error]\x1b[0m inject.sock not found\r\n");
+      onTermWrite("\x1b[33m[Hint]\x1b[0m Agent may not be running in terminal mode\r\n");
+      onTermWrite("Press Esc to return\r\n");
+      return;
+    }
+
+    try {
+      outputClient = net.createConnection(sockPath, () => {
+        outputClient.write(JSON.stringify({
+          type: PTY_SOCKET_MESSAGE_TYPES.SUBSCRIBE,
+          mode: PTY_SOCKET_SUBSCRIBE_MODES.FULL,
+        }) + "\n");
+      });
+
+      const connectTimeout = setTimeout(() => {
+        if (outputClient && !outputClient.connecting) return;
+        onTermWrite("\x1b[1;31m[Timeout]\x1b[0m Could not connect\r\nPress Esc to return\r\n");
+        disconnectOutput();
+      }, 5000);
+
+      outputClient.on("connect", () => {
+        clearTimeout(connectTimeout);
+      });
+
+      outputClient.on("data", (data) => {
+        outputBuffer += data.toString("utf8");
+        const lines = outputBuffer.split("\n");
+        outputBuffer = lines.pop() || "";
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const msg = JSON.parse(line);
+            if (msg.type === PTY_SOCKET_MESSAGE_TYPES.OUTPUT) {
+              if (msg.data) onTermWrite(msg.data);
+            } else if (msg.type === PTY_SOCKET_MESSAGE_TYPES.REPLAY ||
+              msg.type === PTY_SOCKET_MESSAGE_TYPES.SNAPSHOT) {
+              if (msg.data) onTermWrite(msg.data);
+              if (msg.type === PTY_SOCKET_MESSAGE_TYPES.SNAPSHOT && msg.cursor) {
+                onPlaceCursor(msg.cursor);
+              }
+            }
+          } catch {
+            // ignore malformed messages
+          }
+        }
+      });
+
+      outputClient.on("error", (err) => {
+        if (isAgentView()) {
+          onTermWrite(`\r\n\x1b[1;31m[Connection error]\x1b[0m ${err.message}\r\nPress Esc to return\r\n`);
+        }
+      });
+
+      outputClient.on("close", () => {
+        outputClient = null;
+        if (isAgentView()) {
+          onTermWrite("\r\n\x1b[1;33m[Agent disconnected]\x1b[0m\r\nPress Esc to return\r\n");
+        }
+      });
+    } catch (err) {
+      onTermWrite(`\x1b[1;31m[Error]\x1b[0m ${err.message}\r\nPress Esc to return\r\n`);
+    }
+  }
+
+  function disconnectOutput() {
+    if (outputClient) {
+      try {
+        outputClient.removeAllListeners();
+        outputClient.destroy();
+      } catch {
+        // ignore
+      }
+      outputClient = null;
+    }
+    outputBuffer = "";
+  }
+
+  function connectInput(sockPath) {
+    if (inputClient) {
+      disconnectInput();
+    }
+    try {
+      inputClient = net.createConnection(sockPath);
+      inputClient.on("connect", () => {
+        if (pendingResize) {
+          const { cols, rows } = pendingResize;
+          pendingResize = null;
+          try {
+            inputClient.write(JSON.stringify({
+              type: PTY_SOCKET_MESSAGE_TYPES.RESIZE,
+              cols,
+              rows,
+            }) + "\n");
+          } catch {
+            // ignore write errors
+          }
+        }
+      });
+      inputClient.on("error", () => {
+        inputClient = null;
+      });
+      inputClient.on("close", () => {
+        inputClient = null;
+      });
+    } catch {
+      inputClient = null;
+    }
+  }
+
+  function disconnectInput() {
+    if (inputClient) {
+      try {
+        inputClient.removeAllListeners();
+        inputClient.destroy();
+      } catch {
+        // ignore
+      }
+      inputClient = null;
+    }
+  }
+
+  function sendRaw(data) {
+    if (inputClient && !inputClient.destroyed) {
+      try {
+        inputClient.write(JSON.stringify({
+          type: PTY_SOCKET_MESSAGE_TYPES.RAW,
+          data,
+        }) + "\n");
+        return;
+      } catch {
+        // ignore write errors
+      }
+    }
+    if (isBusMode()) {
+      const viewingAgent = getViewingAgent();
+      if (viewingAgent) {
+        sendBusRaw(viewingAgent, data);
+      }
+    }
+  }
+
+  function sendResize(cols, rows) {
+    if (!inputClient || inputClient.destroyed) {
+      pendingResize = { cols, rows };
+      return;
+    }
+    try {
+      inputClient.write(JSON.stringify({
+        type: PTY_SOCKET_MESSAGE_TYPES.RESIZE,
+        cols,
+        rows,
+      }) + "\n");
+    } catch {
+      // ignore write errors
+    }
+  }
+
+  function disconnectAll() {
+    disconnectOutput();
+    disconnectInput();
+  }
+
+  return {
+    connectOutput,
+    disconnectOutput,
+    connectInput,
+    disconnectInput,
+    disconnectAll,
+    sendRaw,
+    sendResize,
+    requestSnapshot,
+    requestScreenSnapshot,
+  };
+}
+
+module.exports = {
+  createAgentSockets,
+};

package/src/chat/agentViewController.js

@@ -0,0 +1,298 @@
+function createAgentViewController(options = {}) {
+  const {
+    screen,
+    input,
+    processStdout = process.stdout,
+    now = () => Date.now(),
+    setTimeoutFn = setTimeout,
+    computeAgentBar = () => ({ bar: "", windowStart: 0 }),
+    agentBarHints = { normal: "", dashboard: "" },
+    maxAgentWindow = 4,
+    getFocusMode = () => "input",
+    setFocusMode = () => {},
+    getSelectedAgentIndex = () => -1,
+    setSelectedAgentIndex = () => {},
+    getActiveAgents = () => [],
+    getAgentListWindowStart = () => 0,
+    setAgentListWindowStart = () => {},
+    getAgentLabel = (id) => id,
+    setDashboardView = () => {},
+    setScreenGrabKeys = (value) => {
+      if (screen) screen.grabKeys = Boolean(value);
+    },
+    clearTargetAgent = () => {},
+    renderDashboard = () => {},
+    focusInput = () => {},
+    resizeInput = () => {},
+    renderScreen = () => {},
+    getInjectSockPath = () => "",
+    connectAgentOutput = () => {},
+    disconnectAgentOutput = () => {},
+    connectAgentInput = () => {},
+    disconnectAgentInput = () => {},
+    sendRaw = () => {},
+    sendResize = () => {},
+    requestScreenSnapshot = () => {},
+  } = options;
+
+  if (!screen || typeof screen.render !== "function") {
+    throw new Error("createAgentViewController requires screen.render");
+  }
+
+  let currentView = "main";
+  let viewingAgent = null;
+  let agentViewUsesBus = false;
+  let agentOutputSuppressed = false;
+  let agentBarVisible = false;
+  let detachedChildren = null;
+  let agentInputSuppressUntil = 0;
+  const originalRender = screen.render.bind(screen);
+  let renderFrozen = false;
+
+  screen.render = function wrappedRender() {
+    if (renderFrozen) return;
+    return originalRender();
+  };
+
+  function getRows() {
+    return processStdout.rows || 24;
+  }
+
+  function getCols() {
+    return processStdout.columns || 80;
+  }
+
+  function renderAgentDashboard() {
+    if (!agentBarVisible && getFocusMode() !== "dashboard") return;
+    const rows = getRows();
+    const cols = getCols();
+    const hintText = getFocusMode() === "dashboard"
+      ? agentBarHints.dashboard
+      : agentBarHints.normal;
+    const computed = computeAgentBar({
+      cols,
+      hintText,
+      focusMode: getFocusMode(),
+      selectedAgentIndex: getSelectedAgentIndex(),
+      activeAgents: getActiveAgents(),
+      viewingAgent,
+      agentListWindowStart: getAgentListWindowStart(),
+      maxAgentWindow,
+      getAgentLabel,
+    });
+    setAgentListWindowStart(computed.windowStart);
+    processStdout.write(`\x1b7\x1b[${rows};1H${computed.bar}\x1b8`);
+  }
+
+  function setAgentBarVisible(visible) {
+    const next = Boolean(visible);
+    if (agentBarVisible === next) return;
+    agentBarVisible = next;
+    const rows = getRows();
+    if (agentBarVisible) {
+      processStdout.write(`\x1b[1;${rows - 1}r`);
+      renderAgentDashboard();
+    } else {
+      processStdout.write(`\x1b[1;${rows}r`);
+      processStdout.write(`\x1b7\x1b[${rows};1H\x1b[2K\x1b8`);
+    }
+  }
+
+  function enterAgentView(agentId, options = {}) {
+    if (currentView === "agent" && viewingAgent === agentId) return;
+    if (currentView === "agent") {
+      disconnectAgentOutput();
+      disconnectAgentInput();
+    }
+
+    currentView = "agent";
+    viewingAgent = agentId;
+    setFocusMode("input");
+
+    detachedChildren = [...screen.children];
+    for (const child of detachedChildren) screen.remove(child);
+
+    renderFrozen = true;
+
+    const rows = getRows();
+    const cols = getCols();
+    processStdout.write("\x1b[2J\x1b[H");
+    processStdout.write(`\x1b[1;${rows - 1}r`);
+    processStdout.write("\x1b[H");
+    processStdout.write("\x1b[?25h");
+    setAgentBarVisible(true);
+
+    agentInputSuppressUntil = now() + 300;
+    agentViewUsesBus = Boolean(options.useBus);
+    if (!agentViewUsesBus) {
+      const sockPath = getInjectSockPath(agentId);
+      connectAgentOutput(sockPath);
+      connectAgentInput(sockPath);
+    }
+
+    setTimeoutFn(() => {
+      sendResize(cols, Math.max(1, rows - 1));
+      requestScreenSnapshot();
+    }, 120);
+  }
+
+  function exitAgentView() {
+    if (currentView !== "agent") return;
+
+    const rows = getRows();
+    const cols = getCols();
+    sendResize(cols, rows);
+
+    disconnectAgentOutput();
+    disconnectAgentInput();
+    agentViewUsesBus = false;
+    agentOutputSuppressed = false;
+    agentBarVisible = false;
+
+    currentView = "main";
+    viewingAgent = null;
+
+    processStdout.write(`\x1b[1;${rows}r`);
+    processStdout.write("\x1b[2J\x1b[H");
+
+    if (detachedChildren) {
+      for (const child of detachedChildren) screen.append(child);
+      detachedChildren = null;
+    }
+
+    renderFrozen = false;
+    setFocusMode("input");
+    setDashboardView("agents");
+    setSelectedAgentIndex(-1);
+    setScreenGrabKeys(false);
+    if (typeof screen.alloc === "function") {
+      screen.alloc();
+    }
+    clearTargetAgent();
+    renderDashboard();
+    focusInput();
+    resizeInput();
+    try {
+      if (screen.program && typeof screen.program.showCursor === "function") {
+        screen.program.showCursor();
+      }
+    } catch {
+      // Ignore cursor restore errors.
+    }
+    if (input && typeof input._updateCursor === "function") {
+      input._updateCursor();
+    }
+    renderScreen();
+  }
+
+  function enterAgentDashboardMode() {
+    setFocusMode("dashboard");
+    setDashboardView("agents");
+    setSelectedAgentIndex(0);
+    setAgentBarVisible(true);
+    renderAgentDashboard();
+    agentOutputSuppressed = true;
+  }
+
+  function sendRawToAgent(data) {
+    sendRaw(data);
+  }
+
+  function sendResizeToAgent(cols, rows) {
+    sendResize(cols, rows);
+  }
+
+  function requestAgentSnapshot() {
+    requestScreenSnapshot();
+  }
+
+  function writeToAgentTerm(text) {
+    if (!text) return;
+    if (currentView !== "agent") return;
+    if (agentOutputSuppressed) return;
+
+    const cleaned = text
+      .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+      .replace(/\x1b\[(?:[?>=]?[0-9]*c|[?]?6n|5n)/g, "");
+    if (cleaned) processStdout.write(cleaned);
+    if (agentBarVisible) {
+      const rows = getRows();
+      processStdout.write("\x1b7");
+      processStdout.write(`\x1b[1;${rows - 1}r`);
+      processStdout.write("\x1b8");
+      renderAgentDashboard();
+    }
+  }
+
+  function placeAgentCursor(cursor) {
+    if (!cursor || currentView !== "agent") return;
+    const rows = getRows();
+    const cols = getCols();
+    const row = Math.max(1, Math.min(rows - 1, (cursor.y || 0) + 1));
+    const col = Math.max(1, Math.min(cols, (cursor.x || 0) + 1));
+    processStdout.write(`\x1b[${row};${col}H\x1b[?25h`);
+  }
+
+  function handleResizeInAgentView() {
+    if (currentView !== "agent") return false;
+    const rows = getRows();
+    const cols = getCols();
+    processStdout.write(`\x1b[1;${rows - 1}r`);
+    sendResize(cols, Math.max(1, rows - 1));
+    renderAgentDashboard();
+    return true;
+  }
+
+  function getCurrentView() {
+    return currentView;
+  }
+
+  function getViewingAgent() {
+    return viewingAgent || "";
+  }
+
+  function isAgentViewUsesBus() {
+    return agentViewUsesBus;
+  }
+
+  function getAgentInputSuppressUntil() {
+    return agentInputSuppressUntil;
+  }
+
+  function getAgentOutputSuppressed() {
+    return agentOutputSuppressed;
+  }
+
+  function setAgentOutputSuppressed(value) {
+    agentOutputSuppressed = Boolean(value);
+  }
+
+  function isAgentBarVisible() {
+    return agentBarVisible;
+  }
+
+  return {
+    getCurrentView,
+    getViewingAgent,
+    isAgentViewUsesBus,
+    getAgentInputSuppressUntil,
+    getAgentOutputSuppressed,
+    setAgentOutputSuppressed,
+    isAgentBarVisible,
+    renderAgentDashboard,
+    setAgentBarVisible,
+    enterAgentView,
+    exitAgentView,
+    enterAgentDashboardMode,
+    sendRawToAgent,
+    sendResizeToAgent,
+    requestAgentSnapshot,
+    writeToAgentTerm,
+    placeAgentCursor,
+    handleResizeInAgentView,
+  };
+}
+
+module.exports = {
+  createAgentViewController,
+};

package/src/chat/chatLogController.js

@@ -0,0 +1,115 @@
+function createChatLogController(options = {}) {
+  const {
+    logBox,
+    fsModule,
+    historyDir,
+    historyFile,
+    now = () => new Date().toISOString(),
+  } = options;
+
+  if (!logBox || typeof logBox.log !== "function") {
+    throw new Error("createChatLogController requires logBox.log");
+  }
+  if (!fsModule) {
+    throw new Error("createChatLogController requires fsModule");
+  }
+  if (!historyDir || !historyFile) {
+    throw new Error("createChatLogController requires historyDir/historyFile");
+  }
+
+  const SPACED_TYPES = new Set(["user", "reply", "bus", "dispatch", "error"]);
+  let lastLogWasSpacer = false;
+  let hasLoggedAny = false;
+
+  function appendHistory(entry) {
+    fsModule.mkdirSync(historyDir, { recursive: true });
+    fsModule.appendFileSync(historyFile, `${JSON.stringify(entry)}\n`);
+  }
+
+  function shouldSpace(type, text) {
+    if (SPACED_TYPES.has(type)) return true;
+    if (typeof text === "string" && /daemon/i.test(text)) return true;
+    return false;
+  }
+
+  function writeSpacer(writeHistory = true) {
+    if (lastLogWasSpacer || !hasLoggedAny) return;
+    logBox.log(" ");
+    if (writeHistory) {
+      appendHistory({
+        ts: now(),
+        type: "spacer",
+        text: "",
+        meta: {},
+      });
+    }
+    lastLogWasSpacer = true;
+    hasLoggedAny = true;
+  }
+
+  function recordLog(type, text, meta = {}, writeHistory = true) {
+    if (type !== "spacer" && shouldSpace(type, text)) {
+      writeSpacer(writeHistory);
+    }
+    logBox.log(text);
+    if (writeHistory) {
+      appendHistory({
+        ts: now(),
+        type,
+        text,
+        meta,
+      });
+    }
+    lastLogWasSpacer = false;
+    hasLoggedAny = true;
+  }
+
+  function logMessage(type, text, meta = {}) {
+    recordLog(type, text, meta, true);
+  }
+
+  function markStreamStart() {
+    lastLogWasSpacer = false;
+    hasLoggedAny = true;
+  }
+
+  function loadHistory(limit = 2000) {
+    try {
+      const raw = fsModule.readFileSync(historyFile, "utf8").trim();
+      if (!raw) return;
+      const lines = raw.split(/\r?\n/).filter(Boolean);
+      const items = lines.slice(-limit).map((line) => JSON.parse(line));
+      const hasSpacer = items.some((item) => item && item.type === "spacer");
+      for (const item of items) {
+        if (!item) continue;
+        if (item.type === "spacer") {
+          writeSpacer(false);
+          continue;
+        }
+        if (!item.text) continue;
+        if (hasSpacer) {
+          logBox.log(item.text);
+          lastLogWasSpacer = false;
+          hasLoggedAny = true;
+        } else {
+          recordLog(item.type || "unknown", item.text, item.meta || {}, false);
+        }
+      }
+    } catch {
+      // Ignore missing/invalid history.
+    }
+  }
+
+  return {
+    appendHistory,
+    writeSpacer,
+    recordLog,
+    logMessage,
+    markStreamStart,
+    loadHistory,
+  };
+}
+
+module.exports = {
+  createChatLogController,
+};