u-foo 1.0.6 → 1.1.9

package/src/chat/daemonConnection.js

@@ -0,0 +1,166 @@
+const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
+
+function createDaemonConnection(options = {}) {
+  const {
+    connectClient,
+    handleMessage,
+    queueStatusLine,
+    resolveStatusLine,
+    logMessage,
+  } = options;
+
+  let client = null;
+  let reconnectPromise = null;
+  let exitRequested = false;
+  let connectionLostNotified = false;
+  const pendingRequests = [];
+  const MAX_PENDING_REQUESTS = 50;
+
+  function enqueueRequest(req) {
+    if (!req || req.type === IPC_REQUEST_TYPES.STATUS) return;
+    pendingRequests.push(req);
+    if (pendingRequests.length > MAX_PENDING_REQUESTS) {
+      pendingRequests.shift();
+    }
+  }
+
+  function flushPendingRequests() {
+    if (!client || client.destroyed) return;
+    while (pendingRequests.length > 0) {
+      const req = pendingRequests.shift();
+      client.write(`${JSON.stringify(req)}\n`);
+    }
+  }
+
+  function detachClient(target = client) {
+    if (!target) return;
+    target.removeAllListeners("data");
+    target.removeAllListeners("close");
+    target.removeAllListeners("error");
+    if (target === client) {
+      client = null;
+    }
+    try {
+      target.end();
+      target.destroy();
+    } catch {
+      // ignore
+    }
+  }
+
+  function attachClient(newClient) {
+    if (!newClient) return;
+    detachClient();
+    client = newClient;
+    connectionLostNotified = false;
+    let buffer = "";
+    client.on("data", (data) => {
+      buffer += data.toString("utf8");
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines.filter((l) => l.trim())) {
+        try {
+          const msg = JSON.parse(line);
+          const shouldStop = handleMessage(msg);
+          if (shouldStop) {
+            return;
+          }
+        } catch {
+          // ignore
+        }
+      }
+    });
+    const handleDisconnect = () => {
+      if (client === newClient) {
+        client = null;
+      }
+      if (exitRequested) return;
+      if (!connectionLostNotified) {
+        connectionLostNotified = true;
+        logMessage("status", "{white-fg}✗{/white-fg} Daemon disconnected");
+      }
+      void ensureConnected();
+    };
+    client.on("close", handleDisconnect);
+    client.on("error", handleDisconnect);
+    flushPendingRequests();
+  }
+
+  async function ensureConnected() {
+    if (client && !client.destroyed) return true;
+    if (exitRequested) return false;
+    if (reconnectPromise) return reconnectPromise;
+    queueStatusLine("Reconnecting to daemon");
+    logMessage("status", "{white-fg}⚙{/white-fg} Reconnecting to daemon...");
+    reconnectPromise = (async () => {
+      const newClient = await connectClient();
+      if (!newClient) {
+        resolveStatusLine("{gray-fg}✗{/gray-fg} Daemon offline");
+        logMessage("error", "{white-fg}✗{/white-fg} Failed to reconnect to daemon");
+        return false;
+      }
+      attachClient(newClient);
+      connectionLostNotified = false;
+      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon reconnected");
+      requestStatus();
+      return true;
+    })();
+    try {
+      return await reconnectPromise;
+    } finally {
+      reconnectPromise = null;
+    }
+  }
+
+  async function connect() {
+    if (client && !client.destroyed) return true;
+    const newClient = await connectClient();
+    if (!newClient) return false;
+    attachClient(newClient);
+    return true;
+  }
+
+  function send(req) {
+    if (!client || client.destroyed) {
+      enqueueRequest(req);
+      void ensureConnected();
+      return;
+    }
+    client.write(`${JSON.stringify(req)}\n`);
+  }
+
+  function requestStatus() {
+    send({ type: IPC_REQUEST_TYPES.STATUS });
+  }
+
+  function close() {
+    detachClient();
+  }
+
+  function markExit() {
+    exitRequested = true;
+  }
+
+  function getState() {
+    return {
+      client,
+      reconnectPromise,
+      pendingRequestCount: pendingRequests.length,
+      exitRequested,
+      connectionLostNotified,
+    };
+  }
+
+  return {
+    connect,
+    send,
+    requestStatus,
+    close,
+    markExit,
+    getState,
+  };
+}
+
+module.exports = {
+  createDaemonConnection,
+};

package/src/chat/daemonCoordinator.js

@@ -0,0 +1,64 @@
+const { createDaemonConnection } = require("./daemonConnection");
+const { restartDaemonFlow } = require("./daemonReconnect");
+
+function createDaemonCoordinator(options = {}) {
+  const {
+    projectRoot,
+    daemonTransport,
+    connectClient,
+    handleMessage,
+    queueStatusLine,
+    resolveStatusLine,
+    logMessage,
+    stopDaemon,
+    startDaemon,
+    daemonConnection,
+    restartDaemon,
+  } = options;
+
+  const connectClientFn = connectClient
+    || (daemonTransport && typeof daemonTransport.connectClient === "function"
+      ? daemonTransport.connectClient.bind(daemonTransport)
+      : null);
+
+  if (!daemonConnection && !connectClientFn) {
+    throw new Error("createDaemonCoordinator requires connectClient, daemonTransport, or daemonConnection");
+  }
+
+  const connection = daemonConnection || createDaemonConnection({
+    connectClient: connectClientFn,
+    handleMessage,
+    queueStatusLine,
+    resolveStatusLine,
+    logMessage,
+  });
+
+  const restart = restartDaemon || restartDaemonFlow({
+    projectRoot,
+    stopDaemon,
+    startDaemon,
+    daemonConnection: connection,
+    logMessage,
+  });
+
+  function isConnected() {
+    if (!connection || typeof connection.getState !== "function") return false;
+    const state = connection.getState();
+    return Boolean(state && state.client && !state.client.destroyed);
+  }
+
+  return {
+    connect: () => connection.connect(),
+    requestStatus: () => connection.requestStatus(),
+    send: (req) => connection.send(req),
+    restart: () => restart(),
+    close: () => connection.close(),
+    markExit: () => connection.markExit(),
+    isConnected,
+    getState: () => (typeof connection.getState === "function" ? connection.getState() : null),
+  };
+}
+
+module.exports = {
+  createDaemonCoordinator,
+};

package/src/chat/daemonMessageRouter.js

@@ -0,0 +1,257 @@
+const { IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../shared/eventContract");
+
+function createDaemonMessageRouter(options = {}) {
+  const {
+    escapeBlessed = (value) => String(value || ""),
+    stripBlessedTags = (value) => String(value || "").replace(/\{[^}]+\}/g, ""),
+    logMessage = () => {},
+    renderScreen = () => {},
+    updateDashboard = () => {},
+    requestStatus = () => {},
+    resolveStatusLine = () => {},
+    enqueueBusStatus = () => {},
+    resolveBusStatus = () => {},
+    getPending = () => null,
+    setPending = () => {},
+    resolveAgentDisplayName = (value) => value,
+    getCurrentView = () => "main",
+    isAgentViewUsesBus = () => false,
+    getViewingAgent = () => "",
+    writeToAgentTerm = () => {},
+    consumePendingDelivery = () => false,
+    getPendingState = () => null,
+    beginStream = () => null,
+    appendStreamDelta = () => {},
+    finalizeStream = () => {},
+    hasStream = () => false,
+  } = options;
+
+  function normalizeDisplayMessage(raw) {
+    let displayMessage = 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 {
+      // Not JSON, keep original.
+    }
+
+    if (typeof displayMessage === "string") {
+      displayMessage = displayMessage.replace(/\\n/g, "\n");
+    }
+
+    return { displayMessage, streamPayload };
+  }
+
+  function handleStatusMessage(msg) {
+    const data = msg.data || {};
+    if (typeof data.phase === "string") {
+      const text = data.text || "";
+      const item = { key: data.key, text };
+      if (data.phase === BUS_STATUS_PHASES.START) {
+        enqueueBusStatus(item);
+      } else if (data.phase === BUS_STATUS_PHASES.DONE || data.phase === BUS_STATUS_PHASES.ERROR) {
+        resolveBusStatus(item);
+        if (text) {
+          const prefix = data.phase === BUS_STATUS_PHASES.ERROR
+            ? "{white-fg}✗{/white-fg}"
+            : "{white-fg}✓{/white-fg}";
+          logMessage("status", `${prefix} ${escapeBlessed(text)}`, data);
+        }
+      } else {
+        enqueueBusStatus(item);
+      }
+      renderScreen();
+      return false;
+    }
+
+    updateDashboard(data);
+    return false;
+  }
+
+  function handleResponseMessage(msg) {
+    const payload = msg.data || {};
+    if (payload.reply) {
+      resolveStatusLine(`{gray-fg}←{/gray-fg} ${escapeBlessed(payload.reply)}`);
+      logMessage("reply", `{white-fg}←{/white-fg} ${escapeBlessed(payload.reply)}`);
+    }
+
+    if (payload.recoverable && typeof payload.recoverable === "object") {
+      const recoverableList = Array.isArray(payload.recoverable.recoverable)
+        ? payload.recoverable.recoverable
+        : [];
+      const skippedList = Array.isArray(payload.recoverable.skipped)
+        ? payload.recoverable.skipped
+        : [];
+
+      if (recoverableList.length > 0) {
+        logMessage("system", "{cyan-fg}Recoverable agents:{/cyan-fg}");
+        recoverableList.forEach((item) => {
+          const nickname = item.nickname ? ` (${item.nickname})` : "";
+          const meta = item.launchMode ? ` [${item.agent}/${item.launchMode}]` : ` [${item.agent}]`;
+          logMessage("system", `  • ${escapeBlessed(`${item.id}${nickname}${meta}`)}`);
+        });
+      } else {
+        logMessage("system", "{gray-fg}No recoverable agents{/gray-fg}");
+      }
+
+      if (skippedList.length > 0) {
+        logMessage("system", "{gray-fg}Skipped:{/gray-fg}");
+        skippedList.forEach((item) => {
+          const reason = item && item.reason ? item.reason : "skipped";
+          const id = item && item.id ? item.id : "unknown";
+          logMessage("system", `  - ${escapeBlessed(`${id}: ${reason}`)}`);
+        });
+      }
+    }
+
+    if (payload.dispatch && payload.dispatch.length > 0) {
+      const targets = payload.dispatch.map((d) => d.target || d).join(", ");
+      logMessage("dispatch", `{white-fg}→{/white-fg} Dispatched to: ${escapeBlessed(targets)}`);
+    }
+
+    if (
+      payload.disambiguate &&
+      Array.isArray(payload.disambiguate.candidates) &&
+      payload.disambiguate.candidates.length > 0
+    ) {
+      const pending = getPending();
+      setPending({ disambiguate: payload.disambiguate, original: pending && pending.original });
+      const prompt = payload.disambiguate.prompt || "Choose target:";
+      resolveStatusLine(`{gray-fg}?{/gray-fg} ${escapeBlessed(prompt)}`);
+      logMessage("disambiguate", `{white-fg}?{/white-fg} ${escapeBlessed(prompt)}`);
+      payload.disambiguate.candidates.forEach((candidate, index) => {
+        logMessage(
+          "disambiguate",
+          `   {cyan-fg}${index + 1}){/cyan-fg} ${escapeBlessed(candidate.agent_id)} {gray-fg}— ${escapeBlessed(candidate.reason || "")}{/gray-fg}`
+        );
+      });
+    } else {
+      setPending(null);
+    }
+
+    if (!payload.reply && !payload.disambiguate) {
+      resolveStatusLine("{gray-fg}✓{/gray-fg} Done");
+    }
+
+    if (Array.isArray(payload.ops) && payload.ops.length > 0) {
+      const hasStateMutation = payload.ops.some((op) =>
+        op && (op.action === "close" || op.action === "launch" || op.action === "rename" || op.action === "cron")
+      );
+      if (hasStateMutation) {
+        requestStatus();
+      }
+    }
+
+    renderScreen();
+    return false;
+  }
+
+  function handleBusMessage(msg) {
+    const data = msg.data || {};
+    const prefix = data.event === "broadcast" ? "{gray-fg}⇢{/gray-fg}" : "{gray-fg}↔{/gray-fg}";
+    const publisher = data.publisher && data.publisher !== "unknown"
+      ? data.publisher
+      : (data.event === "broadcast" ? "broadcast" : "bus");
+
+    const { displayMessage, streamPayload } = normalizeDisplayMessage(data.message || "");
+
+    const isAgentViewTarget =
+      getCurrentView() === "agent" &&
+      isAgentViewUsesBus() &&
+      getViewingAgent() &&
+      publisher === getViewingAgent();
+
+    const displayName = resolveAgentDisplayName(publisher);
+
+    if (isAgentViewTarget) {
+      if (streamPayload) {
+        const delta = typeof streamPayload.delta === "string"
+          ? streamPayload.delta.replace(/\\n/g, "\n")
+          : "";
+        if (delta) writeToAgentTerm(delta);
+      } else if (displayMessage) {
+        writeToAgentTerm(`${displayMessage}\r\n`);
+      }
+      return true;
+    }
+
+    if (data.event === "delivery" && consumePendingDelivery(publisher, displayName)) {
+      const ok = (data.status || "").toLowerCase() !== "error";
+      const detail = typeof data.message === "string" && data.message
+        ? data.message
+        : (ok ? `Delivered to @${displayName}` : `Delivery failed to @${displayName}`);
+      if (ok) {
+        logMessage("status", `{white-fg}✓{/white-fg} ${escapeBlessed(detail)}`);
+      } else {
+        logMessage("error", `{white-fg}✗{/white-fg} ${escapeBlessed(detail)}`);
+      }
+      requestStatus();
+      renderScreen();
+      return true;
+    }
+
+    const pendingBeforeMessage = getPendingState(publisher, displayName);
+    const prefixLabel = `${prefix} {gray-fg}${escapeBlessed(displayName)}{/gray-fg}: `;
+    const continuationPrefix = " ".repeat(stripBlessedTags(prefixLabel).length);
+
+    if (streamPayload) {
+      const delta = typeof streamPayload.delta === "string"
+        ? streamPayload.delta.replace(/\\n/g, "\n")
+        : "";
+      const state = beginStream(publisher, prefixLabel, continuationPrefix, data);
+      if (delta) appendStreamDelta(state, delta);
+      if (streamPayload.done) {
+        finalizeStream(publisher, data, streamPayload.reason || "");
+        if (data.event === "message" && pendingBeforeMessage) {
+          consumePendingDelivery(publisher, displayName);
+        }
+      }
+    } else {
+      if (hasStream(publisher)) {
+        finalizeStream(publisher, data, "interrupted");
+      }
+      const line = `${prefixLabel}${escapeBlessed(displayMessage)}`;
+      logMessage("bus", line, data);
+      if (data.event === "message" && pendingBeforeMessage) {
+        consumePendingDelivery(publisher, displayName);
+      }
+    }
+
+    if (data.event === "agent_renamed" || data.event === "message") {
+      requestStatus();
+    }
+    renderScreen();
+    return false;
+  }
+
+  function handleErrorMessage(msg) {
+    resolveStatusLine(`{gray-fg}✗{/gray-fg} Error: ${msg.error}`);
+    logMessage("error", `{white-fg}✗{/white-fg} Error: ${msg.error}`);
+    renderScreen();
+    return false;
+  }
+
+  function handleMessage(msg) {
+    if (!msg || typeof msg !== "object") return false;
+
+    if (msg.type === IPC_RESPONSE_TYPES.STATUS) return handleStatusMessage(msg);
+    if (msg.type === IPC_RESPONSE_TYPES.RESPONSE) return handleResponseMessage(msg);
+    if (msg.type === IPC_RESPONSE_TYPES.BUS) return handleBusMessage(msg);
+    if (msg.type === IPC_RESPONSE_TYPES.ERROR) return handleErrorMessage(msg);
+
+    return false;
+  }
+
+  return {
+    handleMessage,
+  };
+}
+
+module.exports = {
+  createDaemonMessageRouter,
+};

package/src/chat/daemonReconnect.js

@@ -0,0 +1,41 @@
+function resolveDaemonConnection(daemonConnection) {
+  return typeof daemonConnection === "function" ? daemonConnection() : daemonConnection;
+}
+
+function restartDaemonFlow(options = {}) {
+  const {
+    projectRoot,
+    stopDaemon,
+    startDaemon,
+    daemonConnection,
+    logMessage,
+  } = options;
+
+  let restartInProgress = false;
+
+  return async function restartDaemon() {
+    if (restartInProgress) return;
+    restartInProgress = true;
+    logMessage("status", "{white-fg}⚙{/white-fg} Restarting daemon...");
+    try {
+      const connection = resolveDaemonConnection(daemonConnection);
+      if (connection) {
+        connection.close();
+      }
+      stopDaemon(projectRoot);
+      startDaemon(projectRoot);
+      const connected = connection ? await connection.connect() : false;
+      if (connected) {
+        logMessage("status", "{white-fg}✓{/white-fg} Daemon reconnected");
+      } else {
+        logMessage("error", "{white-fg}✗{/white-fg} Failed to reconnect to daemon");
+      }
+    } finally {
+      restartInProgress = false;
+    }
+  };
+}
+
+module.exports = {
+  restartDaemonFlow,
+};

package/src/chat/daemonTransport.js

@@ -0,0 +1,36 @@
+const { DAEMON_TRANSPORT_DEFAULTS } = require("./daemonTransportDefaults");
+
+function createDaemonTransport(options = {}) {
+  const {
+    projectRoot,
+    sockPath,
+    isRunning = () => true,
+    startDaemon = () => {},
+    connectWithRetry = async () => null,
+    primaryRetries = DAEMON_TRANSPORT_DEFAULTS.primaryRetries,
+    secondaryRetries = DAEMON_TRANSPORT_DEFAULTS.secondaryRetries,
+    retryDelayMs = DAEMON_TRANSPORT_DEFAULTS.retryDelayMs,
+    restartDelayMs = DAEMON_TRANSPORT_DEFAULTS.restartDelayMs,
+  } = options;
+
+  async function connectClient() {
+    let client = await connectWithRetry(sockPath, primaryRetries, retryDelayMs);
+    if (!client) {
+      // Retry once with a fresh daemon start and longer wait.
+      if (!isRunning(projectRoot)) {
+        startDaemon(projectRoot);
+        await new Promise((resolve) => setTimeout(resolve, restartDelayMs));
+      }
+      client = await connectWithRetry(sockPath, secondaryRetries, retryDelayMs);
+    }
+    return client;
+  }
+
+  return {
+    connectClient,
+  };
+}
+
+module.exports = {
+  createDaemonTransport,
+};

package/src/chat/daemonTransportDefaults.js

@@ -0,0 +1,10 @@
+const DAEMON_TRANSPORT_DEFAULTS = {
+  primaryRetries: 25,
+  secondaryRetries: 50,
+  retryDelayMs: 200,
+  restartDelayMs: 1000,
+};
+
+module.exports = {
+  DAEMON_TRANSPORT_DEFAULTS,
+};