u-foo 3.0.9 → 3.0.11

package/src/code/ucodeSlashDispatch.js

@@ -0,0 +1,241 @@
+"use strict";
+
+/**
+ * Shared ucode slash-command dispatcher for Rust TUI hosts.
+ * (NL foreground streaming stays host-specific.)
+ */
+
+const { applyUcodeModelCommand } = require("./modelCommand");
+const { applyUcodePlanCommand, formatPlanModeStatus } = require("./context/planMode");
+const { summarizeSessionUsage, formatSessionUsageStatus } = require("./usageStore");
+const fmt = require("../ui/format");
+
+/**
+ * @param {object} result - parse result from runSingleCommand
+ * @param {object} ports
+ * @param {object} ports.state
+ * @param {string} ports.workspaceRoot
+ * @param {(text: string, kind?: string) => void} ports.appendLog
+ * @param {() => void} [ports.persist]
+ * @param {() => void} [ports.publishPlan]
+ * @param {(meter: object) => void} [ports.publishUsage]
+ * @param {() => void} [ports.onExit]
+ * @param {(sessionId: string) => object} [ports.resumeSession]
+ * @param {(entries: object[], notice: string) => void} [ports.replaceTranscript]
+ * @param {(tool: string, args: object, payload: object) => void} [ports.onTool]
+ * @param {(task: string) => Promise<void>|void} [ports.onBackground]
+ * @param {(task: string) => Promise<object>|void} [ports.onNaturalLanguage]
+ * @param {(state: object, opts: object) => Promise<object>} [ports.runUbus]
+ * @param {(msg: string) => void} [ports.setBusyStatus]
+ * @param {() => void} [ports.clearBusyStatus]
+ * @param {string[]} [ports.bannerLines]
+ * @returns {Promise<{ handled: boolean, waiting?: boolean }>}
+ */
+async function dispatchUcodeSlashCommand(result, ports = {}) {
+  if (!result || typeof result !== "object") {
+    return { handled: false };
+  }
+
+  const appendLog = typeof ports.appendLog === "function" ? ports.appendLog : () => {};
+  const persist = typeof ports.persist === "function" ? ports.persist : () => {};
+  const publishPlan = typeof ports.publishPlan === "function" ? ports.publishPlan : () => {};
+  const workspaceRoot = String(
+    ports.workspaceRoot
+    || (ports.state && ports.state.workspaceRoot)
+    || process.cwd()
+  );
+  const state = ports.state || {};
+
+  switch (result.kind) {
+    case "empty":
+    case "probe":
+      return { handled: true };
+
+    case "exit":
+      if (typeof ports.onExit === "function") ports.onExit();
+      return { handled: true, exit: true };
+
+    case "help":
+    case "error":
+    case "skills":
+    case "legacy_ufoo_marker":
+      if (result.output) {
+        appendLog(result.output, result.kind === "error" ? "error" : "system");
+      }
+      if (result.error) {
+        appendLog(`Error: ${result.error}`, "error");
+      }
+      return { handled: true };
+
+    case "status": {
+      try {
+        const usageSummary = summarizeSessionUsage({
+          workspaceRoot,
+          sessionId: state.sessionId || "",
+        });
+        appendLog(formatSessionUsageStatus(usageSummary), "system");
+        if (state.executionState) {
+          const planLines = formatPlanModeStatus(state.executionState)
+            .split("\n")
+            .slice(0, 6)
+            .join("\n");
+          if (planLines.trim()) appendLog(planLines, "system");
+        }
+      } catch (err) {
+        appendLog(`Error: ${err && err.message ? err.message : "status failed"}`, "error");
+      }
+      return { handled: true };
+    }
+
+    case "model": {
+      const applied = await applyUcodeModelCommand(state, result, { workspaceRoot });
+      appendLog(applied.output || "", applied.ok ? "system" : "error");
+      if (applied.ok && result.action === "set") {
+        try {
+          const { buildContextMeter } = require("./contextWindow");
+          const prev = state.contextMeter || {};
+          const nextMeter = buildContextMeter({
+            usedTokens: prev.usedTokens || 0,
+            model: state.model || "",
+          });
+          state.contextMeter = nextMeter;
+          if (typeof ports.publishUsage === "function") ports.publishUsage(nextMeter);
+        } catch {
+          // ignore
+        }
+        persist();
+      }
+      return { handled: true };
+    }
+
+    case "plan": {
+      const applied = applyUcodePlanCommand(state, result);
+      appendLog(applied.output || "", applied.ok ? "system" : "error");
+      if (applied.refreshPlanUi || applied.ok) publishPlan();
+      if (applied.ok) persist();
+      return { handled: true };
+    }
+
+    case "ubus": {
+      if (typeof ports.runUbus !== "function") {
+        appendLog("Error: ubus unavailable", "error");
+        return { handled: true };
+      }
+      if (typeof ports.setBusyStatus === "function") {
+        ports.setBusyStatus("Checking bus messages...");
+      }
+      try {
+        const { extractAgentNickname } = require("./agent");
+        const ubusResult = await ports.runUbus(state, {
+          workspaceRoot,
+          onMessageReceived: (msg) => {
+            const nickname = extractAgentNickname(msg && msg.from) || (msg && msg.from) || "bus";
+            appendLog(`${nickname}: ${(msg && msg.task) || ""}`, "bus");
+          },
+        });
+        if (!ubusResult || !ubusResult.ok) {
+          appendLog(`Error: ${(ubusResult && ubusResult.error) || "ubus failed"}`, "error");
+          return { handled: true };
+        }
+        const exchanges = Array.isArray(ubusResult.messageExchanges)
+          ? ubusResult.messageExchanges
+          : [];
+        if (exchanges.length > 0) {
+          for (const exchange of exchanges) {
+            const nickname = extractAgentNickname(exchange && exchange.from)
+              || (exchange && exchange.from)
+              || "bus";
+            appendLog(`@${nickname} ${(exchange && exchange.reply) || ""}`, "bus");
+          }
+        } else if (Number(ubusResult.handled) === 0) {
+          appendLog("ubus: no pending messages.", "system");
+        }
+        persist();
+      } finally {
+        if (typeof ports.clearBusyStatus === "function") ports.clearBusyStatus();
+      }
+      return { handled: true };
+    }
+
+    case "resume": {
+      if (typeof ports.resumeSession !== "function") {
+        appendLog("Error: resume unsupported", "error");
+        return { handled: true };
+      }
+      const resumed = ports.resumeSession(result.sessionId);
+      if (!resumed || !resumed.ok) {
+        appendLog(`Error: ${(resumed && resumed.error) || "resume failed"}`, "error");
+        return { handled: true };
+      }
+      const markdownState = { inCodeBlock: false };
+      const history = fmt.buildUcodeSessionLogEntries(
+        Array.isArray(state.nlMessages) ? state.nlMessages : [],
+        { markdownState, idPrefix: "h", startSeq: 0 },
+      );
+      const banner = Array.isArray(ports.bannerLines) ? ports.bannerLines : [];
+      const bannerEntries = banner.concat([""]).map((line, idx) => ({
+        id: `b-${idx}`,
+        kind: "system",
+        text: String(line || ""),
+        speaker: "",
+      }));
+      const notice = {
+        id: `h-resume-${Date.now().toString(36)}`,
+        kind: "system",
+        text: `Resumed session ${resumed.sessionId} (${resumed.restoredMessages} messages).`,
+        speaker: "",
+      };
+      const entries = bannerEntries.concat(history.entries || []).concat([notice]);
+      if (typeof ports.replaceTranscript === "function") {
+        ports.replaceTranscript(entries, notice.text);
+      } else {
+        for (const entry of entries) {
+          appendLog(entry.text, entry.kind || "system");
+        }
+      }
+      if (state.contextMeter && typeof ports.publishUsage === "function") {
+        ports.publishUsage(state.contextMeter);
+      }
+      publishPlan();
+      return { handled: true };
+    }
+
+    case "tool": {
+      if (typeof ports.onTool === "function") {
+        const payload = result.result && typeof result.result === "object" ? result.result : {};
+        ports.onTool(result.tool, result.args || {}, payload);
+      } else if (result.output) {
+        appendLog(result.output, "system");
+      }
+      return { handled: true };
+    }
+
+    case "nl_bg": {
+      if (typeof ports.onBackground === "function") {
+        await ports.onBackground(result.task);
+      } else {
+        appendLog("Error: background tasks unavailable", "error");
+      }
+      return { handled: true };
+    }
+
+    case "nl": {
+      if (typeof ports.onNaturalLanguage === "function") {
+        const nl = await ports.onNaturalLanguage(result.task);
+        return { handled: true, waiting: Boolean(nl && nl.waiting) };
+      }
+      return { handled: false };
+    }
+
+    default:
+      if (result.output) {
+        appendLog(result.output, result.ok === false ? "error" : "system");
+        return { handled: true };
+      }
+      return { handled: false };
+  }
+}
+
+module.exports = {
+  dispatchUcodeSlashCommand,
+};

package/src/coordination/bus/activate.js

@@ -179,6 +179,9 @@ end tell`;
       if (adapter.capabilities.supportsInternalQueueLoop) {
         throw new Error("Internal mode agents cannot be activated (no terminal window)");
       }
+      if (info.launch_mode === "host") {
+        throw new Error("Host did not expose activate; add \"activate\" to host capabilities/commands");
+      }
       throw new Error("Cannot activate: missing tty or tmux_pane for agent");
     }
 

package/src/runtime/contracts/schemas/ufoo-ui-v1/envelope.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ufoo.dev/schemas/ufoo-ui-v1/envelope.json",
+  "title": "ufoo-ui/1 envelope",
+  "type": "object",
+  "required": ["protocol", "kind", "payload"],
+  "additionalProperties": true,
+  "properties": {
+    "protocol": { "const": "ufoo-ui/1" },
+    "kind": {
+      "type": "string",
+      "enum": ["hello", "welcome", "command", "event", "snapshot", "result", "error"]
+    },
+    "name": { "type": "string" },
+    "request_id": { "type": "string" },
+    "seq": { "type": "integer", "minimum": 1 },
+    "scope": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "surface": { "type": "string" },
+        "project_id": { "type": "string" },
+        "view_id": { "type": "string" }
+      }
+    },
+    "payload": { "type": "object" }
+  }
+}

package/src/runtime/contracts/uiProtocol.js

@@ -0,0 +1,190 @@
+"use strict";
+
+/**
+ * ufoo-ui/1 — Node host ↔ Rust TUI control protocol.
+ *
+ * Daemon IPC stays separate. This protocol never shares the TTY stdout used
+ * for drawing; it rides a dedicated Unix socket (or extra fd).
+ */
+
+const PROTOCOL = "ufoo-ui/1";
+
+// Capability advertised by clients that can render Rust-native /multi
+// and internal "side" activate (same multi.* wire; multi.set.kind =
+// "multi" | "side"). "side" is not a user-facing mode name.
+const MULTI_FRAMES_CAPABILITY = "multi-frames-v1";
+
+const KINDS = Object.freeze([
+  "hello",
+  "welcome",
+  "command",
+  "event",
+  "snapshot",
+  "result",
+  "error",
+]);
+
+const COMMAND_NAMES = Object.freeze([
+  "input.submit",
+  "input.paste",
+  "task.cancel",
+  "agent.select",
+  "agent.open",
+  "agent.close",
+  "agent.view.submit",
+  "agent.view.exit",
+  "project.switch",
+  "project.close",
+  "project.return_controller",
+  "cron.stop",
+  "completion.request",
+  "command.execute",
+  "interaction.respond",
+  "settings.set",
+  "ui.suspend.request",
+  "ui.resync.request",
+  "app.exit",
+  "multi.exit",
+  "multi.focus",
+  "multi.viewport",
+  "multi.raw",
+]);
+
+const EVENT_NAMES = Object.freeze([
+  "app.snapshot",
+  "transcript.reset",
+  "transcript.append",
+  "transcript.patch",
+  "stream.start",
+  "stream.delta",
+  "stream.done",
+  "status.set",
+  "agents.snapshot",
+  "agents.patch",
+  "projects.snapshot",
+  "cron.snapshot",
+  "loop.set",
+  "completions.set",
+  "interaction.request",
+  "interaction.clear",
+  "plan.set",
+  "tool.start",
+  "tool.result",
+  "tool.group",
+  "settings.snapshot",
+  "prompt.apply_paste",
+  "prompt.set_prefix",
+  "attachments.set",
+  "usage.set",
+  "agent.view.open",
+  "agent.view.append",
+  "agent.view.status",
+  "agent.view.close",
+  "ui.suspend.prepare",
+  "ui.resume",
+  "connection.set",
+  "error",
+  "multi.set",
+  "multi.pane.frame",
+]);
+
+function createEnvelope({
+  kind,
+  name = "",
+  requestId = null,
+  seq = null,
+  scope = null,
+  payload = {},
+} = {}) {
+  const envelope = {
+    protocol: PROTOCOL,
+    kind: String(kind || "").trim(),
+    name: String(name || "").trim(),
+    payload: payload && typeof payload === "object" ? payload : {},
+  };
+  if (requestId != null && requestId !== "") {
+    envelope.request_id = String(requestId);
+  }
+  if (Number.isFinite(seq)) {
+    envelope.seq = Math.floor(seq);
+  }
+  if (scope && typeof scope === "object") {
+    envelope.scope = {
+      surface: String(scope.surface || ""),
+      project_id: String(scope.project_id || scope.projectId || ""),
+      view_id: String(scope.view_id || scope.viewId || "main"),
+    };
+  }
+  return envelope;
+}
+
+function validateEnvelope(raw) {
+  const errors = [];
+  if (!raw || typeof raw !== "object") {
+    return { ok: false, errors: ["envelope must be an object"] };
+  }
+  if (raw.protocol !== PROTOCOL) {
+    errors.push(`unsupported protocol "${raw.protocol}"`);
+  }
+  if (!KINDS.includes(String(raw.kind || ""))) {
+    errors.push(`invalid kind "${raw.kind}"`);
+  }
+  if (raw.kind === "command" && raw.name && !COMMAND_NAMES.includes(String(raw.name))) {
+    // Additive: unknown commands are soft-fail for forward compat.
+  }
+  if (raw.payload != null && typeof raw.payload !== "object") {
+    errors.push("payload must be an object");
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+function encodeMessage(envelope) {
+  const check = validateEnvelope(envelope);
+  if (!check.ok) {
+    const err = new Error(`ufoo-ui encode failed: ${check.errors.join("; ")}`);
+    err.code = "UFOO_UI_ENCODE";
+    err.errors = check.errors;
+    throw err;
+  }
+  return `${JSON.stringify(envelope)}\n`;
+}
+
+function decodeMessage(line) {
+  const text = String(line || "").trim();
+  if (!text) return { ok: false, errors: ["empty line"] };
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    return { ok: false, errors: [`invalid json: ${err.message}`] };
+  }
+  const check = validateEnvelope(parsed);
+  if (!check.ok) return check;
+  return { ok: true, envelope: parsed, errors: [] };
+}
+
+function createSeqCounter(start = 0) {
+  let seq = Math.max(0, Math.floor(Number(start) || 0));
+  return {
+    next() {
+      seq += 1;
+      return seq;
+    },
+    peek() {
+      return seq;
+    },
+  };
+}
+
+module.exports = {
+  PROTOCOL,
+  MULTI_FRAMES_CAPABILITY,
+  KINDS,
+  COMMAND_NAMES,
+  EVENT_NAMES,
+  createEnvelope,
+  validateEnvelope,
+  encodeMessage,
+  decodeMessage,
+  createSeqCounter,
+};

package/src/ui/{ink/chatLogModel.js → chatLogModel.js}

@@ -1,9 +1,9 @@
 "use strict";
 
-const { renderMarkdownLinesAnsi } = require("../format/markdownRenderer");
+const { renderMarkdownLinesAnsi } = require("./format/markdownRenderer");
 
 // Match ucode: markdown only for conversational prose. System/user rows stay
-// plain so app-generated prefixes (›, ✓, Error:) keep Ink color control.
+// plain so app-generated prefixes (›, ✓, Error:) keep host color control.
 const MARKDOWN_BODY_KINDS = new Set(["assistant", "agent", "report"]);
 
 function stripBlessedTags(text = "") {

package/src/ui/dashboardBridge.js

@@ -0,0 +1,81 @@
+"use strict";
+
+/**
+ * Shared dashboard snapshot helpers for Rust chat host.
+ */
+
+const { formatLoopSummary } = require("../app/chat/dashboardView");
+
+function loadGlobalProjectRows(activeProjectRoot = "") {
+  const path = require("path");
+  const {
+    listProjectRuntimes,
+    filterVisibleProjectRuntimes,
+    isGlobalControllerProjectRoot,
+    markProjectStopped,
+    canonicalProjectRoot,
+  } = require("../runtime/projects");
+
+  function resolveRoot(row = {}) {
+    const raw = String((row && (row.root || row.project_root || row.projectRoot)) || "").trim();
+    if (!raw) return "";
+    try {
+      return canonicalProjectRoot(raw);
+    } catch {
+      return path.resolve(raw);
+    }
+  }
+
+  let rows = listProjectRuntimes({ validate: true, cleanupTmp: true }) || [];
+  for (const row of rows) {
+    const status = String((row && row.status) || "").trim().toLowerCase();
+    const root = resolveRoot(row);
+    if (status === "stale" && root && !isGlobalControllerProjectRoot(root)) {
+      try {
+        markProjectStopped(root);
+      } catch {
+        // ignore
+      }
+    }
+  }
+  rows = filterVisibleProjectRuntimes(rows);
+  rows = rows.filter((row) => !isGlobalControllerProjectRoot(resolveRoot(row)));
+  return rows.map((row) => ({
+    id: row.project_id || row.project_root || "",
+    label: row.project_name || (row.project_root ? path.basename(row.project_root) : ""),
+    root: row.project_root || "",
+    status: row.status || "",
+    active: resolveRoot(row) === String(activeProjectRoot || ""),
+  }));
+}
+
+function cronTasksFromStatus(data = {}) {
+  const cron = data && data.cron;
+  const tasks = cron && Array.isArray(cron.tasks) ? cron.tasks : [];
+  return tasks.map((task, index) => ({
+    id: String((task && (task.id || task.task_id)) || `cron-${index}`),
+    label: String((task && (task.label || task.name || task.summary || task.id)) || `cron-${index}`),
+    summary: String((task && (task.summary || task.schedule || "")) || ""),
+  }));
+}
+
+function buildDashboardPublishPayload(controller, data = {}) {
+  const agents = controller.getAgentsSnapshot();
+  const cron = cronTasksFromStatus(data);
+  const loop = (data && data.loop) || agents.loop || null;
+  const loopText = formatLoopSummary(loop);
+  return {
+    agents: agents.agents,
+    footer: agents.footer,
+    cron,
+    loop,
+    loop_summary: loopText,
+  };
+}
+
+module.exports = {
+  loadGlobalProjectRows,
+  cronTasksFromStatus,
+  buildDashboardPublishPayload,
+  formatLoopSummary,
+};

package/src/ui/format/index.js

@@ -1,8 +1,8 @@
 "use strict";
 
 /**
- * Pure formatting + input-math helpers for the ink-based TUIs under
- * src/ui/ink/. No terminal widget import is allowed in this module.
+ * Pure formatting helpers shared by hosts and tests.
+ * No terminal widget import is allowed in this module.
  */
 
 const chalk = require("chalk");

package/src/ui/index.js

@@ -1,9 +1,13 @@
 "use strict";
 
-const { runInk } = require("./runInk");
-const { createInkDemo } = require("./ink/InkDemo");
+/**
+ * UI helpers. Terminal rendering is Rust ufoo-tui only.
+ */
+
+const { PROTOCOL, resolveTuiLaunchPlan, resolveUfooTuiBinary } = require("./tuiLauncher");
 
 module.exports = {
-  runInk,
-  createInkDemo,
+  PROTOCOL,
+  resolveTuiLaunchPlan,
+  resolveUfooTuiBinary,
 };