u-foo 3.0.9 → 3.0.11

package/src/ui/multiPaneBusMirror.js

@@ -0,0 +1,137 @@
+"use strict";
+
+/**
+ * Mirror inbound bus events into multi/side internal panes.
+ * Rust host uses this so pane VT stays live while the main transcript
+ * router still runs.
+ */
+
+function parseInternalBusPayload(raw = "") {
+  let displayMessage = String(raw || "");
+  let streamPayload = null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.reply) {
+      displayMessage = parsed.reply;
+    } else if (parsed && typeof parsed === "object" && parsed.stream) {
+      streamPayload = parsed;
+    }
+  } catch {
+    // Plain text.
+  }
+  return {
+    displayMessage: String(displayMessage || "")
+      .replace(/\\r\\n/g, "\n")
+      .replace(/\\n/g, "\n")
+      .replace(/\\r/g, "\n"),
+    streamPayload,
+  };
+}
+
+function internalStatusLabel(value = "") {
+  const state = String(value || "").trim().toLowerCase();
+  if (state === "waiting" || state === "waiting_input") return "waiting";
+  if (state === "blocked" || state === "error") return "blocked";
+  if (state === "busy" || state === "processing" || state === "working") return "working";
+  if (state === "idle" || state === "ready") return "ready";
+  return state || "ready";
+}
+
+function buildAgentAliases(agentId, getMeta = () => ({})) {
+  const meta = (() => {
+    try { return getMeta(agentId) || {}; } catch { return {}; }
+  })();
+  return new Set([
+    agentId,
+    meta.nickname,
+    meta.scoped_nickname,
+    meta.display_nickname,
+    meta.fullId,
+    meta.id,
+  ].filter(Boolean).map(String));
+}
+
+/**
+ * @param {object} data — bus event payload (msg.data)
+ * @param {object} options
+ * @param {Iterable<string>|Set<string>} options.agentIds — internal pane agents to mirror
+ * @param {(agentId: string) => object} [options.getMeta]
+ * @param {(agentId: string, text: string) => boolean|void} options.writeToPane
+ * @returns {boolean} true if at least one pane consumed the event
+ */
+function writeMultiPaneBusEvent(data = {}, options = {}) {
+  const {
+    agentIds = [],
+    getMeta = () => ({}),
+    writeToPane = () => false,
+  } = options;
+
+  const watched = agentIds instanceof Set
+    ? agentIds
+    : new Set([...agentIds].map((id) => String(id || "").trim()).filter(Boolean));
+  if (!watched.size || typeof writeToPane !== "function") return false;
+
+  let handled = false;
+  for (const agentId of watched) {
+    const aliases = buildAgentAliases(agentId, getMeta);
+    const publisher = String(data.publisher || (data.event === "broadcast" ? "broadcast" : "bus"));
+    const target = String(data.target || data.subscriber || "");
+    const fromAgent = aliases.has(publisher);
+    const toAgent = aliases.has(target) || aliases.has(String(data.subscriber || ""));
+    if (!fromAgent && !toAgent) continue;
+
+    if (data.silent) {
+      handled = true;
+      continue;
+    }
+    // Echo of chat→agent sends already shown as local "> " input.
+    if ((data.source === "chat-internal-agent-view" || data.source === "rust-multi-window"
+      || data.source === "chat-direct") && toAgent && !fromAgent) {
+      handled = true;
+      continue;
+    }
+    if (data.event === "activity_state_changed") {
+      const state = internalStatusLabel(data.state || data.activity_state || "");
+      const detail = String(data.detail || (data.data && data.data.detail) || data.message || "").trim();
+      try {
+        writeToPane(agentId, `\r\n[${state}${detail ? ` · ${detail}` : ""}]\r\n`);
+      } catch { /* ignore */ }
+      handled = true;
+      continue;
+    }
+
+    const { displayMessage, streamPayload } = parseInternalBusPayload(data.message || "");
+    if (streamPayload) {
+      if (!fromAgent) {
+        handled = true;
+        continue;
+      }
+      const delta = typeof streamPayload.delta === "string"
+        ? streamPayload.delta.replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n").replace(/\\r/g, "\n")
+        : "";
+      try {
+        if (delta) writeToPane(agentId, delta);
+        if (streamPayload.done) writeToPane(agentId, "\r\n");
+      } catch { /* ignore */ }
+      handled = true;
+      continue;
+    }
+    if (!displayMessage) {
+      handled = true;
+      continue;
+    }
+    const prefix = fromAgent ? "* " : "> ";
+    try {
+      writeToPane(agentId, `${prefix}${displayMessage.replace(/\n/g, "\r\n  ")}\r\n`);
+    } catch { /* ignore */ }
+    handled = true;
+  }
+  return handled;
+}
+
+module.exports = {
+  parseInternalBusPayload,
+  internalStatusLabel,
+  buildAgentAliases,
+  writeMultiPaneBusEvent,
+};

package/src/ui/multiWindowHandoff.js

@@ -0,0 +1,232 @@
+"use strict";
+
+/**
+ * Multi-window handoff after Rust TUI suspend (exit 75, reason=multi).
+ * Reuses createMultiWindowController (same VT/pane code as Ink).
+ */
+
+const { createMultiWindowController } = require("../app/chat/multiWindow");
+const { resolveAgentEnterRequest, resolveInjectSockPathForAgent } = require("../app/chat/agentEnter");
+const { restoreStdinAfterHandoff } = require("./ptyHandoff");
+
+function agentIdsFromMeta(activeAgentMeta) {
+  if (activeAgentMeta instanceof Map) {
+    return Array.from(activeAgentMeta.keys()).map(String).filter(Boolean);
+  }
+  if (activeAgentMeta && typeof activeAgentMeta === "object") {
+    return Object.keys(activeAgentMeta);
+  }
+  return [];
+}
+
+function labelForAgent(activeAgentMeta, agentId) {
+  const meta = activeAgentMeta instanceof Map
+    ? activeAgentMeta.get(agentId)
+    : (activeAgentMeta && activeAgentMeta[agentId]);
+  if (!meta || typeof meta !== "object") return agentId;
+  return String(meta.display_nickname || meta.nickname || meta.scoped_nickname || agentId);
+}
+
+/**
+ * @returns {Promise<{ ok: boolean, error?: string }>}
+ */
+async function runMultiWindowHandoff({
+  projectRoot = process.cwd(),
+  activeAgentMeta = new Map(),
+  settings = {},
+  getChatLogLines = () => [],
+  getStatusText = () => "",
+  getDashboardLines = () => [],
+  onInternalSubmit = null,
+  stdin = process.stdin,
+  stdout = process.stdout,
+} = {}) {
+  const agents = agentIdsFromMeta(activeAgentMeta);
+  if (agents.length === 0) {
+    return { ok: false, error: "No active agents for multi-window mode" };
+  }
+
+  let terminalFocused = false;
+  let done = false;
+  let resolveDone = null;
+  const finished = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+
+  const originalWrite = stdout.write.bind(stdout);
+  const controller = createMultiWindowController({
+    processStdout: {
+      write: originalWrite,
+      rows: stdout.rows,
+      columns: stdout.columns,
+    },
+    getRows: () => stdout.rows || 24,
+    getCols: () => stdout.columns || 80,
+    getInjectSockPath: (agentId) => resolveInjectSockPathForAgent(projectRoot, agentId),
+    getActiveAgents: () => agentIdsFromMeta(activeAgentMeta),
+    getAgentPaneOptions: (agentId) => {
+      const enterRequest = resolveAgentEnterRequest({
+        agentId,
+        projectRoot,
+        activeAgentMeta,
+        settings,
+      });
+      if (!enterRequest || !enterRequest.useBus) return { mode: "socket" };
+      let initialLines = [];
+      try {
+        const { loadInternalAgentLogHistory } = require("../app/chat/internalAgentLogHistory");
+        initialLines = loadInternalAgentLogHistory(projectRoot, agentId, {
+          maxEvents: 200,
+          maxLines: 200,
+        });
+      } catch {
+        initialLines = [];
+      }
+      return {
+        mode: "internal",
+        initialLines: [
+          `ufoo internal agent · ${labelForAgent(activeAgentMeta, agentId)}`,
+          `agent: ${agentId}`,
+          "",
+          ...initialLines,
+        ],
+      };
+    },
+    getChatLogLines,
+    getStatusText,
+    getPromptPrefix: () => "› ",
+    getCurrentDraft: () => "",
+    getCursorPos: () => 0,
+    getCompletions: () => ({ items: [], index: -1, windowStart: 0, pageSize: 8 }),
+    getAgentLabel: (id) => labelForAgent(activeAgentMeta, id),
+    getInternalPaneInfo: (id) => {
+      const meta = activeAgentMeta instanceof Map
+        ? activeAgentMeta.get(id)
+        : (activeAgentMeta && activeAgentMeta[id]);
+      return {
+        status: String((meta && meta.activity_state) || ""),
+        detail: String((meta && meta.activity_detail) || ""),
+        input: "",
+        cursor: 0,
+      };
+    },
+    getDashboardLines,
+    getTerminalFocused: () => terminalFocused,
+    freezeScreen: (frozen) => {
+      if (frozen) stdout.write = () => true;
+      else stdout.write = originalWrite;
+    },
+    restoreTerminal: () => {
+      const rows = stdout.rows || 24;
+      originalWrite(`\x1b[1;${rows}r`);
+      originalWrite("\x1b[2J\x1b[H");
+    },
+    onInternalSubmit: (agentId, message) => {
+      if (typeof onInternalSubmit === "function") {
+        onInternalSubmit(agentId, message);
+      }
+    },
+    onExit: () => {
+      done = true;
+      if (typeof resolveDone === "function") resolveDone();
+    },
+  });
+
+  if (!controller.enter()) {
+    return { ok: false, error: "No active agents for multi-window mode" };
+  }
+
+  const wasRaw = typeof stdin.isRaw === "boolean" ? stdin.isRaw : false;
+  try {
+    if (typeof stdin.setRawMode === "function" && stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    if (typeof stdin.resume === "function") stdin.resume();
+  } catch {
+    // ignore
+  }
+
+  const onResize = () => {
+    try {
+      controller.handleResize();
+    } catch {
+      // ignore
+    }
+  };
+  if (stdout && typeof stdout.on === "function") {
+    stdout.on("resize", onResize);
+  }
+
+  const onData = (chunk) => {
+    if (done) return;
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk || ""), "utf8");
+    if (buf.length === 0) return;
+
+    // Ctrl+C → exit multi
+    if (buf.includes(0x03)) {
+      controller.exit();
+      return;
+    }
+    // Ctrl+Q → exit multi
+    if (buf.includes(0x11)) {
+      controller.handleKey({ name: "q", ctrl: true, sequence: "" });
+      terminalFocused = false;
+      return;
+    }
+    // Ctrl+W → cycle focus (chat chrome ↔ agent panes)
+    if (buf.includes(0x17)) {
+      const ids = controller.getAgentIds();
+      if (ids.length === 0) return;
+      if (!terminalFocused) {
+        controller.focusAgent(ids[0]);
+        terminalFocused = true;
+      } else {
+        const current = controller.getFocused();
+        const idx = current ? ids.indexOf(current) : -1;
+        if (idx >= 0 && idx < ids.length - 1) {
+          controller.focusAgent(ids[idx + 1]);
+        } else {
+          terminalFocused = false;
+          controller.focusAgent(ids[0]);
+        }
+      }
+      controller.renderAll();
+      return;
+    }
+
+    if (terminalFocused) {
+      controller.sendInput(buf.toString("utf8"));
+    }
+  };
+
+  stdin.on("data", onData);
+
+  try {
+    await finished;
+    return { ok: true };
+  } finally {
+    stdin.removeListener("data", onData);
+    if (stdout && typeof stdout.off === "function") {
+      stdout.off("resize", onResize);
+    } else if (stdout && typeof stdout.removeListener === "function") {
+      stdout.removeListener("resize", onResize);
+    }
+    try {
+      if (controller.isActive()) controller.exit();
+    } catch {
+      // ignore
+    }
+    try {
+      if (typeof stdin.setRawMode === "function" && stdin.isTTY) {
+        stdin.setRawMode(wasRaw);
+      }
+    } catch {
+      // ignore
+    }
+    restoreStdinAfterHandoff(stdin);
+  }
+}
+
+module.exports = {
+  runMultiWindowHandoff,
+};

package/src/ui/ptyHandoff.js

@@ -0,0 +1,23 @@
+"use strict";
+
+/**
+ * Stdin restore helpers after any fullscreen handoff (e.g. legacy multi).
+ * Agent PTY mirror handoff has been removed — activate / side / multi only.
+ */
+
+function restoreStdinAfterHandoff(stdin = process.stdin) {
+  try {
+    if (stdin && typeof stdin.setRawMode === "function" && stdin.isTTY) {
+      stdin.setRawMode(false);
+    }
+    if (stdin && typeof stdin.resume === "function") {
+      stdin.resume();
+    }
+  } catch {
+    // ignore — next TUI will reconfigure
+  }
+}
+
+module.exports = {
+  restoreStdinAfterHandoff,
+};