neagen 0.1.1 → 0.1.2

package/lib/eve-chat.mjs

@@ -1,4 +1,9 @@
 import { Client } from "eve/client";
+import {
+  createTurnStatusSpinner,
+  createTurnStreamRenderer,
+  readTurnSseStream,
+} from "./turn-stream.mjs";
 
 export function createEveClient(host, token) {
   return new Client({
@@ -107,19 +112,26 @@ export async function sendEveTurn(session, message, options = {}) {
   return options.settle ? options.settle(result, session) : result;
 }
 
-function parseSseEvents(text) {
-  return text
-    .split(/\n\n+/)
-    .map((chunk) => {
-      const event = chunk.match(/^event: (.+)$/m)?.[1];
-      const data = chunk.match(/^data: (.+)$/m)?.[1];
-      if (!event || !data) return undefined;
-      return { event, data: JSON.parse(data) };
-    })
-    .filter(Boolean);
+function resolveTurnPayload(events) {
+  const finalized = events.find((entry) => entry.event === "neagen.finalized")?.data;
+  const waiting = events.find((entry) => entry.event === "neagen.waiting_saved")?.data;
+  const declined = events.find((entry) => entry.event === "neagen.gate_declined")?.data;
+  const legacyTurn = events.find((entry) => entry.event === "turn")?.data;
+
+  if (waiting) {
+    return {
+      conversationId: waiting.conversationId,
+      runtimeStatus: waiting.runtimeStatus,
+      inputRequests: waiting.inputRequests,
+    };
+  }
+  if (finalized) return finalized;
+  if (declined) return declined;
+  if (legacyTurn) return legacyTurn;
+  throw new Error("Turn stream ended without a Neagen result.");
 }
 
-async function postTurn(host, token, body) {
+async function postTurnStream(host, token, body, { render } = {}) {
   const res = await fetch(`${host.replace(/\/$/, "")}/api/turns`, {
     method: "POST",
     headers: {
@@ -130,41 +142,83 @@ async function postTurn(host, token, body) {
     body: JSON.stringify(body),
     signal: AbortSignal.timeout(120_000),
   });
-  const text = await res.text();
-  if (!res.ok) {
-    let message = `HTTP ${res.status}`;
-    try {
-      message = JSON.parse(text)?.error?.message ?? message;
-    } catch {
-      if (text.trim()) message = text.trim();
-    }
-    throw new Error(message);
+
+  const renderer = render ?? createTurnStreamRenderer();
+  const spinner = createTurnStatusSpinner("thinking");
+  let streamError;
+
+  try {
+    const events = await readTurnSseStream(res, (event, data) => {
+      spinner.stop();
+      if (event === "neagen.error") {
+        streamError = new Error(data?.message ?? "Turn failed.");
+      }
+      renderer.handle(event, data);
+    });
+    renderer.finish();
+
+    if (streamError) throw streamError;
+
+    return {
+      result: resolveTurnPayload(events),
+      assistantTextStreamed: renderer.assistantTextStreamed,
+    };
+  } finally {
+    spinner.stop();
   }
-  return parseSseEvents(text).find((entry) => entry.event === "turn")?.data;
 }
 
-export async function sendWakeSyncTurn({ host, token, event, handlers }) {
+export async function sendWakeSyncTurn({ host, token, event, handlers, render }) {
   return sendTransportTurn({
     host,
     token,
     conversationId: undefined,
     message: wakeSyncPrompt(event),
     handlers,
+    render,
   });
 }
 
-export async function sendTransportTurn({ host, token, conversationId, message, handlers }) {
-  let result = await postTurn(host, token, { conversationId, body: message });
+export async function sendTransportTurn({
+  host,
+  token,
+  conversationId,
+  message,
+  handlers,
+  render,
+}) {
+  const renderer = render ?? createTurnStreamRenderer();
+  renderer.reset();
+  let assistantTextStreamed = false;
+
+  let leg = await postTurnStream(
+    host,
+    token,
+    { conversationId, body: message },
+    { render: renderer },
+  );
+  assistantTextStreamed ||= leg.assistantTextStreamed;
+  let result = leg.result;
+
   while ((result?.inputRequests?.length ?? 0) > 0) {
     const request = result.inputRequests[0];
     const response =
       requestToolName(request) === "ask_question"
         ? questionResponse(request, await handlers.askQuestion(request))
         : approvalResponse(request, await handlers.askApproval(request));
-    result = await postTurn(host, token, {
-      conversationId: result.conversationId,
-      inputResponses: [response],
-    });
+    renderer.reset();
+    leg = await postTurnStream(
+      host,
+      token,
+      {
+        conversationId: result.conversationId,
+        inputResponses: [response],
+      },
+      { render: renderer },
+    );
+    assistantTextStreamed ||= leg.assistantTextStreamed;
+    result = leg.result;
   }
-  return result;
+
+  return { ...result, assistantTextStreamed };
 }

package/lib/eve-product-tui.mjs

@@ -0,0 +1,399 @@
+// Product Neagen TUI: Eve's terminal runner, Neagen's authenticated /api/turns
+// transport. This keeps Eve's TUI/approval/tool rendering while preserving the
+// app's wallet, memory, billing, conversation, and model-selection lifecycle.
+
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { assertTransportSafe, clearCreds, loadToken, resolveHost } from "./creds.mjs";
+import {
+  getSelectedModel,
+  listModels,
+  probeHost,
+  resolveIdentity,
+  selectModel,
+} from "./api.mjs";
+import { runDeviceGrantLogin } from "./device-login.mjs";
+import { parseSseChunk } from "./turn-stream.mjs";
+
+const require = createRequire(import.meta.url);
+
+function eveInternalUrl(relativePath) {
+  const root = dirname(require.resolve("eve/package.json"));
+  return pathToFileURL(join(root, relativePath)).href;
+}
+
+async function loadEveTuiRunner() {
+  const mod = await import(eveInternalUrl("dist/src/cli/dev/tui/runner.js"));
+  return mod.EveTUIRunner;
+}
+
+function normalizeHost(host) {
+  return host.replace(/\/$/, "");
+}
+
+function modelAliases(input) {
+  const value = input.trim();
+  const lower = value.toLowerCase();
+  if (lower === "deepseek" || lower === "flash") return "deepseek/deepseek-v4-flash";
+  if (lower === "sonnet" || lower === "claude" || lower === "claude-sonnet") {
+    return "anthropic/claude-sonnet-4.6";
+  }
+  return value;
+}
+
+function formatModel(model) {
+  if (!model) return "unknown";
+  const label = model.providerLabel && model.name ? `${model.providerLabel} ${model.name}` : model.id;
+  return `${label} (${model.id})`;
+}
+
+function agentInfoForModel(model, identity) {
+  return {
+    agent: {
+      name: identity?.neagenName ?? "Neagen",
+      model: {
+        id: model?.id ?? "unknown",
+        provider: model?.provider ?? model?.providerLabel,
+      },
+    },
+    diagnostics: {
+      discoveryErrors: 0,
+      discoveryWarnings: 0,
+    },
+  };
+}
+
+function inputRequestToolName(request) {
+  return request?.action?.toolName ?? "input";
+}
+
+function isNeagenCommitEvent(eventName) {
+  return eventName === "neagen.finalized" ||
+    eventName === "neagen.waiting_saved" ||
+    eventName === "neagen.gate_declined";
+}
+
+function neagenErrorToSessionFailed(data) {
+  return {
+    type: "session.failed",
+    data: {
+      error: {
+        code: data?.code ?? "turn_failed",
+        message: data?.message ?? "Turn failed.",
+      },
+    },
+  };
+}
+
+function isBoundaryEvent(event) {
+  return event?.type === "session.waiting" ||
+    event?.type === "session.completed" ||
+    event?.type === "session.failed";
+}
+
+async function* readProductTurnEvents(response, onProductEvent) {
+  if (!response.ok) {
+    let message = `HTTP ${response.status}`;
+    const text = await response.text();
+    try {
+      message = JSON.parse(text)?.error?.message ?? message;
+    } catch {
+      if (text.trim()) message = text.trim();
+    }
+    throw new Error(message);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("Turn stream is not readable.");
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let heldBoundary;
+
+  async function* handleEntry(entry) {
+    const { event, data } = entry;
+
+    if (event === "done") {
+      if (heldBoundary) {
+        yield heldBoundary;
+        heldBoundary = undefined;
+      }
+      return;
+    }
+
+    if (event === "neagen.error") {
+      yield neagenErrorToSessionFailed(data);
+      heldBoundary = undefined;
+      return;
+    }
+
+    if (isNeagenCommitEvent(event)) {
+      onProductEvent(event, data);
+      if (heldBoundary) {
+        yield heldBoundary;
+        heldBoundary = undefined;
+      }
+      return;
+    }
+
+    const eveEvent = { type: event, data };
+    if (isBoundaryEvent(eveEvent)) {
+      heldBoundary = eveEvent;
+      return;
+    }
+    yield eveEvent;
+  }
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const parsed = parseSseChunk(buffer);
+    buffer = parsed.trailing;
+    for (const entry of parsed.events) {
+      yield* handleEntry(entry);
+    }
+  }
+
+  if (buffer.trim()) {
+    const parsed = parseSseChunk(`${buffer}\n\n`);
+    for (const entry of parsed.events) {
+      yield* handleEntry(entry);
+    }
+  }
+
+  if (heldBoundary) yield heldBoundary;
+}
+
+class ProductMessageResponse {
+  constructor(events) {
+    this.events = events;
+  }
+
+  [Symbol.asyncIterator]() {
+    return this.events[Symbol.asyncIterator]();
+  }
+}
+
+class ProductSession {
+  constructor(client, state = {}) {
+    this.client = client;
+    this.conversationId = state.conversationId;
+  }
+
+  get state() {
+    return {
+      sessionId: this.conversationId,
+      streamIndex: 0,
+      conversationId: this.conversationId,
+    };
+  }
+
+  async send(input) {
+    const payload = typeof input === "string" ? { message: input } : (input ?? {});
+    const body = payload.inputResponses?.length
+      ? { conversationId: this.conversationId, inputResponses: payload.inputResponses }
+      : { conversationId: this.conversationId, body: payload.message };
+
+    if (!body.body && !body.inputResponses) {
+      throw new Error("Nothing to send.");
+    }
+    if (body.inputResponses && !body.conversationId) {
+      throw new Error("No Neagen conversation is waiting for approval.");
+    }
+
+    const response = await fetch(`${this.client.host}/api/turns`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.client.token}`,
+        "content-type": "application/json",
+        accept: "text/event-stream",
+      },
+      body: JSON.stringify(body),
+      signal: payload.signal,
+    });
+
+    const events = readProductTurnEvents(response, (event, data) => {
+      if (data?.conversationId) this.conversationId = data.conversationId;
+      if (event === "neagen.gate_declined" && data?.conversationId) {
+        this.conversationId = data.conversationId;
+      }
+    });
+    return new ProductMessageResponse(events);
+  }
+}
+
+class ProductClient {
+  constructor({ host, token, identity }) {
+    this.host = normalizeHost(host);
+    this.token = token;
+    this.identity = identity;
+    this.cachedSelection = undefined;
+  }
+
+  session(state) {
+    return new ProductSession(this, state);
+  }
+
+  async selectedModel() {
+    const selection = await getSelectedModel(this.host, this.token);
+    this.cachedSelection = selection;
+    return selection.activeModel;
+  }
+
+  async info() {
+    let model;
+    try {
+      model = await this.selectedModel();
+    } catch {
+      model = this.cachedSelection?.activeModel;
+    }
+    return agentInfoForModel(model, this.identity);
+  }
+}
+
+function modelOptions(models, activeId) {
+  return models.map((model) => ({
+    value: model.id,
+    label: `${model.id === activeId ? "● " : ""}${model.name ?? model.id}`,
+    description: `${model.providerLabel ?? model.provider ?? ""} · ${model.id}`,
+  }));
+}
+
+function createModelCommandHandler({ host, token, productClient, title }) {
+  return {
+    async handle(command, context) {
+      if (command.name !== "model") {
+        return { message: `/${command.name} is not supported in the Neagen TUI.` };
+      }
+
+      const raw = command.argument.trim();
+      if (raw) {
+        const updated = await selectModel(host, token, modelAliases(raw));
+        productClient.cachedSelection = updated;
+        context.renderer.renderAgentHeader?.({
+          name: title,
+          serverUrl: host,
+          info: agentInfoForModel(updated.activeModel, productClient.identity),
+        });
+        return { message: `Switched model to ${formatModel(updated.activeModel)}.` };
+      }
+
+      const [selection, models] = await Promise.all([
+        getSelectedModel(host, token),
+        listModels(host, token),
+      ]);
+      productClient.cachedSelection = selection;
+      const activeId = selection.activeModel?.id;
+      const flow = context.renderer.setupFlow;
+      if (!flow) {
+        return {
+          message: `Current model: ${formatModel(selection.activeModel)}. Use /model provider/model to switch.`,
+        };
+      }
+
+      flow.begin("Choose Neagen model", "pulse");
+      try {
+        const chosen = await flow.readSelect({
+          kind: "search",
+          message: "Pick the model Neagen should use",
+          placeholder: "Filter models",
+          initialValue: activeId,
+          options: modelOptions(models, activeId),
+        });
+        const modelId = chosen?.[0];
+        if (!modelId) return { message: "/model cancelled." };
+        if (modelId === activeId) return { message: `Already using ${formatModel(selection.activeModel)}.` };
+        const updated = await selectModel(host, token, modelId);
+        productClient.cachedSelection = updated;
+        context.renderer.renderAgentHeader?.({
+          name: title,
+          serverUrl: host,
+          info: agentInfoForModel(updated.activeModel, productClient.identity),
+        });
+        return { message: `Switched model to ${formatModel(updated.activeModel)}.` };
+      } finally {
+        flow.end({ preserveDiagnostics: false });
+      }
+    },
+  };
+}
+
+async function ensureReachable(host) {
+  process.stdout.write(`Connecting to ${host}...\n`);
+  await probeHost(host);
+}
+
+async function ensureAuthenticated({ host, profile }) {
+  let token = loadToken(profile, host);
+  if (token) {
+    const identity = await resolveIdentity(host, token);
+    if (identity) return { token, identity };
+    clearCreds(profile);
+    token = null;
+  }
+  token = await runDeviceGrantLogin({ host, profile });
+  const identity = await resolveIdentity(host, token);
+  if (!identity) {
+    clearCreds(profile);
+    throw new Error("Session could not be verified after login.");
+  }
+  return { token, identity };
+}
+
+export async function runProductTui({ profile } = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("neagen requires an interactive terminal.");
+  }
+
+  const host = normalizeHost(resolveHost());
+  assertTransportSafe(host);
+  await ensureReachable(host);
+  const { token, identity } = await ensureAuthenticated({ host, profile });
+  const EveTUIRunner = await loadEveTuiRunner();
+  const client = new ProductClient({ host, token, identity });
+  const title = identity.neagenName ?? "neagen";
+  const session = client.session();
+
+  const selected = await client.selectedModel().catch(() => undefined);
+  process.stdout.write(`Agent online. Model: ${selected?.id ?? "unknown"}.\n`);
+
+  await new EveTUIRunner({
+    session,
+    client,
+    serverUrl: host,
+    name: title,
+    tools: "full",
+    reasoning: "full",
+    assistantResponseStats: "tokensPerSecond",
+    promptCommandHandler: createModelCommandHandler({ host, token, productClient: client, title }),
+    availablePromptCommands: [
+      { name: "help", aliases: [], description: "Show available commands", takesArgument: false },
+      { name: "new", aliases: [], description: "Start a fresh session", takesArgument: false },
+      {
+        name: "model",
+        aliases: [],
+        description: "Pick the Neagen model",
+        argumentHint: "[provider/model]",
+        takesArgument: true,
+      },
+      {
+        name: "loglevel",
+        aliases: [],
+        description: "Show or hide logs",
+        argumentHint: "[all|stderr|sandbox|none]",
+        takesArgument: true,
+      },
+      { name: "exit", aliases: ["quit"], description: "Quit", takesArgument: false },
+    ],
+  }).run();
+}
+
+export {
+  createModelCommandHandler,
+  ProductClient,
+  ProductSession,
+  readProductTurnEvents,
+  inputRequestToolName,
+};

package/lib/tui.mjs

@@ -2,7 +2,6 @@
 // Login happens here (device grant) when no valid session exists.
 
 import readline from "node:readline/promises";
-import { clearLine, cursorTo } from "node:readline";
 import { stdin } from "node:process";
 import { dim, bold } from "./ansi.mjs";
 import { assertTransportSafe, clearCreds, loadToken, resolveHost } from "./creds.mjs";
@@ -21,6 +20,7 @@ import {
   sendWakeSyncTurn,
   summarizeResult,
 } from "./eve-chat.mjs";
+import { createTurnStreamRenderer } from "./turn-stream.mjs";
 import { pickModel, readPromptLine } from "./picker.mjs";
 import { SLASH_COMMANDS, slashHelpLines } from "./slash.mjs";
 import { subscribeInboxWakeAbly } from "./wake.mjs";
@@ -160,31 +160,19 @@ async function askQuestion(rl, request) {
   return rl.question(`\n${request.prompt}\n${options ? `${options}\n` : ""}> `);
 }
 
-function startStatus(label) {
-  if (!process.stdout.isTTY) return { stop() {} };
-
-  let frame = 0;
-  let active = true;
-  const frames = ["", ".", "..", "..."];
-  const render = () => {
-    if (!active) return;
-    cursorTo(process.stdout, 0);
-    process.stdout.write(`${label}${frames[frame % frames.length]}`);
-    clearLine(process.stdout, 1);
-    frame += 1;
-  };
-
-  render();
-  const timer = setInterval(render, 450);
-  return {
-    stop() {
-      if (!active) return;
-      active = false;
-      clearInterval(timer);
-      cursorTo(process.stdout, 0);
-      clearLine(process.stdout, 0);
-    },
-  };
+const turnRenderer = createTurnStreamRenderer();
+
+function printTurnOutcome(result) {
+  if (result?.assistantTextStreamed) {
+    process.stdout.write("\n");
+    return;
+  }
+  const summary = summarizeResult(result);
+  if (summary && summary !== "(no reply)") {
+    process.stdout.write(`\n${summary}\n\n`);
+  } else {
+    process.stdout.write("\n");
+  }
 }
 
 await ensureReachable();
@@ -216,23 +204,17 @@ function runExclusive(fn) {
 }
 
 async function sendTurn(message) {
-  const status = startStatus("thinking");
   const result = await sendTransportTurn({
     host,
     token,
     conversationId,
     message,
+    render: turnRenderer,
     handlers: {
-      askApproval: (request) => {
-        status.stop();
-        return askApproval(rl, request);
-      },
-      askQuestion: (request) => {
-        status.stop();
-        return askQuestion(rl, request);
-      },
+      askApproval: (request) => askApproval(rl, request),
+      askQuestion: (request) => askQuestion(rl, request),
     },
-  }).finally(() => status.stop());
+  });
   conversationId = result?.conversationId ?? conversationId;
   return result;
 }
@@ -247,12 +229,13 @@ try {
         host,
         token,
         event: ev,
+        render: turnRenderer,
         handlers: {
           askApproval: (request) => askApproval(rl, request),
           askQuestion: (request) => askQuestion(rl, request),
         },
       });
-      process.stdout.write(`\n${summarizeResult(result)}\n\n`);
+      printTurnOutcome(result);
     }).catch((e) => {
       process.stderr.write(`! wake sync failed: ${e?.message ?? e}\n`);
     });
@@ -316,7 +299,7 @@ try {
       }
 
       const result = await runExclusive(() => sendTurn(line));
-      process.stdout.write(`\n${summarizeResult(result)}\n\n`);
+      printTurnOutcome(result);
     } catch (e) {
       process.stderr.write(`! ${e?.message ?? e}\n`);
     }

package/lib/turn-stream.mjs

@@ -0,0 +1,219 @@
+import { clearLine, cursorTo } from "node:readline";
+import { stdout } from "node:process";
+import { dim } from "./ansi.mjs";
+
+function sseEvent(event, data) {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+export function parseSseChunk(buffer) {
+  const events = [];
+  const parts = buffer.split(/\n\n+/);
+  const trailing = parts.pop() ?? "";
+
+  for (const part of parts) {
+    const event = part.match(/^event: (.+)$/m)?.[1];
+    const dataLine = part.match(/^data: (.+)$/m)?.[1];
+    if (!event || !dataLine) continue;
+    try {
+      events.push({ event, data: JSON.parse(dataLine) });
+    } catch {
+      /* ignore malformed chunks */
+    }
+  }
+
+  return { events, trailing };
+}
+
+function readReasoningDelta(data) {
+  if (typeof data?.reasoningDelta === "string") return data.reasoningDelta;
+  if (typeof data?.delta === "string") return data.delta;
+  return "";
+}
+
+function readMessageDelta(data) {
+  if (typeof data?.messageDelta === "string") return data.messageDelta;
+  if (typeof data?.delta === "string") return data.delta;
+  return "";
+}
+
+export function createTurnStreamRenderer({ write = (text) => stdout.write(text) } = {}) {
+  let assistantLineOpen = false;
+  let reasoningLineOpen = false;
+  let assistantTextStreamed = false;
+
+  const closeAssistantLine = () => {
+    if (!assistantLineOpen) return;
+    write("\n");
+    assistantLineOpen = false;
+  };
+
+  const closeReasoningLine = () => {
+    if (!reasoningLineOpen) return;
+    write("\n");
+    reasoningLineOpen = false;
+  };
+
+  return {
+    get assistantTextStreamed() {
+      return assistantTextStreamed;
+    },
+    reset() {
+      assistantTextStreamed = false;
+      closeAssistantLine();
+      closeReasoningLine();
+    },
+    handle(eventName, data) {
+      switch (eventName) {
+        case "turn.started":
+          closeAssistantLine();
+          closeReasoningLine();
+          break;
+        case "reasoning.appended": {
+          const delta = readReasoningDelta(data);
+          if (!delta) break;
+          if (!reasoningLineOpen) {
+            closeAssistantLine();
+            write(`${dim("… ")}`);
+            reasoningLineOpen = true;
+          }
+          write(dim(delta));
+          break;
+        }
+        case "reasoning.completed":
+          closeReasoningLine();
+          break;
+        case "message.appended": {
+          const delta = readMessageDelta(data);
+          if (!delta) break;
+          assistantTextStreamed = true;
+          closeReasoningLine();
+          if (!assistantLineOpen) {
+            write("\n");
+            assistantLineOpen = true;
+          }
+          write(delta);
+          break;
+        }
+        case "message.completed":
+          closeAssistantLine();
+          break;
+        case "actions.requested": {
+          closeAssistantLine();
+          closeReasoningLine();
+          const actions = Array.isArray(data?.actions) ? data.actions : [];
+          const labels = actions.map((action) => {
+            if (action?.kind === "tool-call" && typeof action.toolName === "string") {
+              return action.toolName;
+            }
+            return action?.kind ?? "action";
+          });
+          if (labels.length > 0) {
+            write(`${dim(`↳ ${labels.join(", ")}`)}\n`);
+          }
+          break;
+        }
+        case "action.result": {
+          const result = data?.result;
+          const name = result?.toolName ?? result?.kind ?? "tool";
+          const status = data?.status ?? "completed";
+          write(`${dim(`  ${status === "completed" ? "✓" : "×"} ${name}`)}\n`);
+          break;
+        }
+        case "input.requested":
+          closeAssistantLine();
+          closeReasoningLine();
+          write(`${dim("… approval required")}\n`);
+          break;
+        case "neagen.waiting_saved":
+          closeAssistantLine();
+          closeReasoningLine();
+          break;
+        case "neagen.error":
+          closeAssistantLine();
+          closeReasoningLine();
+          write(`\n! ${data?.message ?? "Turn failed."}\n`);
+          break;
+        default:
+          break;
+      }
+    },
+    finish() {
+      closeAssistantLine();
+      closeReasoningLine();
+    },
+  };
+}
+
+export function createTurnStatusSpinner(label = "thinking") {
+  if (!stdout.isTTY) return { stop() {} };
+
+  let frame = 0;
+  let active = true;
+  const frames = ["", ".", "..", "..."];
+  const render = () => {
+    if (!active) return;
+    cursorTo(stdout, 0);
+    stdout.write(`${label}${frames[frame % frames.length]}`);
+    clearLine(stdout, 1);
+    frame += 1;
+  };
+
+  render();
+  const timer = setInterval(render, 450);
+  return {
+    stop() {
+      if (!active) return;
+      active = false;
+      clearInterval(timer);
+      cursorTo(stdout, 0);
+      clearLine(stdout, 0);
+    },
+  };
+}
+
+export async function readTurnSseStream(response, onEvent) {
+  if (!response.ok) {
+    let message = `HTTP ${response.status}`;
+    const text = await response.text();
+    try {
+      message = JSON.parse(text)?.error?.message ?? message;
+    } catch {
+      if (text.trim()) message = text.trim();
+    }
+    throw new Error(message);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Turn stream is not readable.");
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const collected = [];
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const parsed = parseSseChunk(buffer);
+    buffer = parsed.trailing;
+    for (const entry of parsed.events) {
+      collected.push(entry);
+      await onEvent?.(entry.event, entry.data);
+    }
+  }
+
+  if (buffer.trim()) {
+    const parsed = parseSseChunk(`${buffer}\n\n`);
+    for (const entry of parsed.events) {
+      collected.push(entry);
+      await onEvent?.(entry.event, entry.data);
+    }
+  }
+
+  return collected;
+}
+
+export { sseEvent };

package/neagen.mjs

@@ -62,8 +62,8 @@ async function runTui(profile) {
     );
     process.exit(1);
   }
-  if (profile) process.env.NEAGEN_PROFILE = profile;
-  await import("./lib/tui.mjs");
+  const { runProductTui } = await import("./lib/eve-product-tui.mjs");
+  await runProductTui({ profile });
 }
 
 async function runLogin(profile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neagen",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Your personal networking agent, in the terminal. Chat, agent-mail, and files against your Neagen — passkey login, no passwords.",
   "type": "module",
   "bin": {