@anusornneal/chat-relay 0.10.2 → 0.11.1

package/agent/connection-state.mjs

@@ -30,7 +30,7 @@ export class AgentConnectionState {
   constructor(options = {}) {
     this.baseReconnectMs = boundedInteger(options.baseReconnectMs, 2000, 100, 60_000);
     this.maxReconnectMs = boundedInteger(options.maxReconnectMs, 30_000, this.baseReconnectMs, 120_000);
-    this.heartbeatMs = boundedInteger(options.heartbeatMs, 15_000, 5_000, 60_000);
+    this.heartbeatMs = boundedInteger(options.heartbeatMs, 30_000, 5_000, 60_000);
     this.processStartedAt = new Date().toISOString();
     this.state = "starting";
     this.connectedAt = null;

package/agent/local-agent.mjs

@@ -7,6 +7,7 @@ import { CapabilityScheduler } from "./capability-scheduler.mjs";
 import { AgentConnectionState } from "./connection-state.mjs";
 import { buildAgentHello } from "./protocol.mjs";
 import { AgentLifecycle, AGENT_RESTART_EXIT_CODE } from "./lifecycle.mjs";
+import { humanizeToolCall } from "./toolcall-summary.mjs";
 import {
   HeartbeatAckWatchdog,
   HEARTBEAT_ACK_TIMEOUT_REASON,
@@ -19,6 +20,24 @@ const agentName = process.env.AGENT_NAME || agentId;
 const reconnectMs = Number(process.env.RECONNECT_MS ?? 2000);
 const terminalEnabled = process.env.TERMINAL_ENABLED === "1";
 const desktopEnabled = process.env.DESKTOP_ENABLED === "1";
+const ipcUiEnabled = process.env.CHAT_RELAY_UI === "ipc";
+
+function emitUi(event, payload = {}) {
+  if (!ipcUiEnabled || typeof process.send !== "function") return;
+  try { process.send({ type: "chat-relay-ui", event, at: new Date().toISOString(), ...payload }); } catch {}
+}
+
+function plainLog(...args) {
+  if (!ipcUiEnabled) console.log(...args);
+}
+
+function plainError(...args) {
+  if (!ipcUiEnabled) {
+    console.error(...args);
+    return;
+  }
+  emitUi("system", { level: "error", message: args.map((item) => String(item)).join(" ") });
+}
 const desktopAdapter = createDesktopPlatformAdapter({ platform: process.platform });
 const agentHello = buildAgentHello({
   platform: desktopAdapter.platform,
@@ -78,7 +97,7 @@ const TRANSPORT_PING_MS = Math.max(5000, Math.min(Number(process.env.AGENT_TRANS
 const TRANSPORT_PONG_TIMEOUT_MS = Math.max(3000, Math.min(Number(process.env.AGENT_TRANSPORT_PONG_TIMEOUT_MS) || 8000, 30000));
 const FAST_RECONNECT_MS = Math.max(100, Math.min(Number(process.env.AGENT_FAST_RECONNECT_MS) || 250, 5000));
 const FAST_RECONNECT_STABLE_MS = Math.max(5000, Math.min(Number(process.env.AGENT_FAST_RECONNECT_STABLE_MS) || 30000, 300000));
-const HEARTBEAT_ACK_TIMEOUT_MS = Math.max(15000, Math.min(Number(process.env.AGENT_HEARTBEAT_ACK_TIMEOUT_MS) || 45000, 180000));
+const HEARTBEAT_ACK_TIMEOUT_MS = Math.max(15000, Math.min(Number(process.env.AGENT_HEARTBEAT_ACK_TIMEOUT_MS) || 90000, 180000));
 const heartbeatAckWatchdog = new HeartbeatAckWatchdog({
   timeoutMs: HEARTBEAT_ACK_TIMEOUT_MS,
   onTimeout: () => {
@@ -104,7 +123,7 @@ function currentWorkSummary() {
 const lifecycle = new AgentLifecycle({ workSummary: currentWorkSummary });
 
 if (!relayUrl || !agentToken) {
-  console.error("RELAY_URL and AGENT_TOKEN are required");
+  plainError("RELAY_URL and AGENT_TOKEN are required");
   process.exit(1);
 }
 
@@ -358,8 +377,15 @@ function scheduleReconnect(code, reason) {
   const isTransientAbnormalClose = Number(code) === 1006 && stableConnectionMs >= FAST_RECONNECT_STABLE_MS;
   const delay = isTransientAbnormalClose ? FAST_RECONNECT_MS : connectionState.nextDelay();
   connectionState.scheduleReconnect(delay);
+  emitUi("connection", {
+    state: "reconnecting",
+    reconnects: connectionState.snapshot().reconnectCount,
+    delayMs: delay,
+    closeCode: code ?? null,
+    reason: reason || "socket_closed",
+  });
   clearReconnectTimer();
-  console.log(`Reconnect scheduled in ${delay}ms`);
+  plainLog(`Reconnect scheduled in ${delay}ms`);
   reconnectTimer = setTimeout(() => {
     reconnectTimer = null;
     connect();
@@ -380,7 +406,7 @@ function requireProtocolUpdate(details = {}) {
   desktop.close();
   const expected = details.expectedProtocolVersion ?? "current";
   const received = details.receivedProtocolVersion ?? agentHello.protocolVersion;
-  console.error(`Agent protocol is incompatible (local=${received}, relay=${expected}). Update Chat Relay, then reconnect.`);
+  plainError(`Agent protocol is incompatible (local=${received}, relay=${expected}). Update Chat Relay, then reconnect.`);
   setImmediate(() => process.exit(3));
 }
 
@@ -395,8 +421,8 @@ function requireReauthorization(reason = "credential_revoked") {
   try { socket?.terminate(); } catch {}
   terminals.close();
   desktop.close();
-  console.error("Agent credential was revoked or rejected.");
-  console.error('Recovery: run "chat-relay login --force", then "chat-relay remote".');
+  plainError("Agent credential was revoked or rejected.");
+  plainError('Recovery: run "chat-relay login --force", then "chat-relay remote".');
   setImmediate(() => process.exit(2));
 }
 
@@ -404,10 +430,14 @@ function connect() {
   if (stopping || reauthorizationRequired) return;
   clearReconnectTimer();
   connectionState.markConnecting();
-  console.log(`Connecting to ${wsUrl}`);
-  console.log(`Terminal access: ${terminalEnabled ? "enabled" : "disabled"}`);
+  emitUi("connection", {
+    state: connectionState.snapshot().reconnectCount > 0 ? "reconnecting" : "connecting",
+    reconnects: connectionState.snapshot().reconnectCount,
+  });
+  plainLog(`Connecting to ${wsUrl}`);
+  plainLog(`Terminal access: ${terminalEnabled ? "enabled" : "disabled"}`);
   const desktopConfig = desktop.getConfig();
-  console.log("Desktop access: " + (!desktopEnabled ? "disabled" : desktopConfig.supported ? "enabled" : `unsupported (${desktopConfig.platform})`));
+  plainLog("Desktop access: " + (!desktopEnabled ? "disabled" : desktopConfig.supported ? "enabled" : `unsupported (${desktopConfig.platform})`));
 
   const socket = new WebSocket(wsUrl, {
     headers: { Authorization: `Bearer ${agentToken}` },
@@ -418,8 +448,9 @@ function connect() {
     if (socket !== activeSocket) return;
     socket.send(JSON.stringify(agentHello));
     connectionState.markConnected();
+    emitUi("connection", { state: "connected", reconnects: connectionState.snapshot().reconnectCount });
     startHeartbeat(socket);
-    console.log("Agent connected");
+    plainLog("Agent connected");
   });
 
   socket.on("pong", () => {
@@ -458,6 +489,8 @@ function connect() {
     const action = message.payload && typeof message.payload === "object"
       ? String(message.payload.action ?? "unknown")
       : "unknown";
+    const callSummary = humanizeToolCall(message.payload);
+    emitUi("tool:start", { requestId: message.requestId, action, summary: callSummary });
     let scheduleMeta = { lane: "unknown", queueWaitMs: 0, queueDepthAtStart: 0, activeAtStart: 0 };
     let handlerDurationMs = 0;
     try {
@@ -474,6 +507,7 @@ function connect() {
       recentCalls.push({
         at: new Date().toISOString(),
         action,
+        summary: callSummary,
         durationMs: Date.now() - startedAt,
         queueWaitMs: scheduleMeta.queueWaitMs,
         handlerDurationMs,
@@ -483,6 +517,14 @@ function connect() {
         ok: !(result && typeof result === "object" && result.ok === false),
       });
       if (recentCalls.length > 100) recentCalls.shift();
+      emitUi("tool:end", {
+        requestId: message.requestId,
+        action,
+        summary: callSummary,
+        ok: !(result && typeof result === "object" && result.ok === false),
+        durationMs: Date.now() - startedAt,
+        ...(result && typeof result === "object" && result.ok === false && result.error ? { error: String(result.error) } : {}),
+      });
       sendSocketResponse(socket, message.requestId, result, {
         agentQueueWaitMs: scheduleMeta.queueWaitMs,
         agentHandlerMs: handlerDurationMs,
@@ -492,6 +534,7 @@ function connect() {
       recentCalls.push({
         at: new Date().toISOString(),
         action,
+        summary: callSummary,
         durationMs: Date.now() - startedAt,
         queueWaitMs: scheduleMeta.queueWaitMs,
         handlerDurationMs,
@@ -500,6 +543,14 @@ function connect() {
         error: error instanceof Error ? error.message : "agent_error",
       });
       if (recentCalls.length > 100) recentCalls.shift();
+      emitUi("tool:end", {
+        requestId: message.requestId,
+        action,
+        summary: callSummary,
+        ok: false,
+        durationMs: Date.now() - startedAt,
+        error: error instanceof Error ? error.message : "agent_error",
+      });
       sendSocketResponse(socket, message.requestId, {
         ok: false,
         error: error instanceof Error ? error.message : "agent_error",
@@ -527,7 +578,7 @@ function connect() {
     activeSocket = null;
     stopHeartbeat();
     const reasonText = reason.toString();
-    console.log("Agent disconnected (" + code + ") " + reasonText);
+    plainLog("Agent disconnected (" + code + ") " + reasonText);
     if (code === 4001 || reasonText === "credential_revoked") {
       requireReauthorization("credential_revoked");
       return;
@@ -542,7 +593,7 @@ function connect() {
   socket.on("error", (error) => {
     if (socket === activeSocket && !stopping && !reauthorizationRequired) {
       connectionState.markSocketError(error.message);
-      console.error("WebSocket error:", error.message);
+      plainError("WebSocket error:", error.message);
     }
   });
 }

package/agent/toolcall-summary.mjs

@@ -0,0 +1,148 @@
+const MAX_TEXT = 96;
+
+function cleanText(value, max = MAX_TEXT) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (text.length <= max) return text;
+  return text.slice(0, Math.max(0, max - 1)) + "…";
+}
+
+function compactPath(value) {
+  const normalized = cleanText(value, 120).replace(/\\/g, "/");
+  if (normalized.length <= 72) return normalized || "-";
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length <= 2) return "…" + normalized.slice(-68);
+  return "…/" + parts.slice(-3).join("/");
+}
+
+function redactCommand(value) {
+  let text = cleanText(value, 220);
+  const patterns = [
+    /(authorization\s*[:=]\s*bearer\s+)[^\s"']+/ig,
+    /((?:token|password|passwd|secret|api[_-]?key|access[_-]?key)\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s;]+)/ig,
+    /(--(?:token|password|secret|api-key|access-key)(?:=|\s+))("[^"]*"|'[^']*'|[^\s;]+)/ig,
+  ];
+  for (const pattern of patterns) text = text.replace(pattern, "$1[redacted]");
+  return text;
+}
+
+function number(value, fallback = 0) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function lineRange(payload) {
+  const offset = Math.max(0, number(payload.offset));
+  const length = Math.max(1, number(payload.length, 200));
+  return `lines ${offset + 1}–${offset + length}`;
+}
+
+function countKeyboardInput(payload) {
+  if (Array.isArray(payload.actions)) return payload.actions.length + " action" + (payload.actions.length === 1 ? "" : "s");
+  if (typeof payload.text === "string") return payload.text.length + " chars";
+  if (typeof payload.input === "string") return payload.input.length + " chars";
+  return "input";
+}
+
+export function humanizeToolCall(payload = {}) {
+  const action = String(payload?.action || "unknown");
+
+  switch (action) {
+    case "ping":
+      return "Ping agent";
+    case "agent.config":
+      return "Get agent config";
+    case "agent.recentCalls":
+      return `Get recent tool calls · limit ${number(payload.limit, 50)}`;
+    case "agent.lifecycle.status":
+      return "Get lifecycle status";
+    case "agent.lifecycle.drain":
+      return "Drain agent";
+    case "agent.lifecycle.resume":
+      return "Resume agent";
+    case "agent.lifecycle.restart":
+      return "Restart agent";
+
+    case "fs.stat":
+      return `Stat ${compactPath(payload.path)}`;
+    case "fs.list":
+      return `List ${compactPath(payload.path)} · depth ${number(payload.depth)} · limit ${number(payload.limit, 100)}`;
+    case "fs.read":
+      return `Read ${compactPath(payload.path)} · ${lineRange(payload)}`;
+    case "fs.readMany":
+      return `Read ${Array.isArray(payload.paths) ? payload.paths.length : 0} files`;
+    case "fs.batch":
+      return `Filesystem batch · ${Array.isArray(payload.operations) ? payload.operations.length : 0} ops`;
+    case "fs.artifact":
+      return `Export ${compactPath(payload.path)}`;
+    case "fs.write": {
+      const bytes = Buffer.byteLength(String(payload.content ?? ""), "utf8");
+      return `Write ${compactPath(payload.path)} · ${payload.mode || "rewrite"} · ${bytes} B`;
+    }
+    case "fs.edit":
+      return `Edit ${compactPath(payload.path)} · replace ×${number(payload.expectedReplacements, 1)}`;
+    case "fs.mkdir":
+      return `Create folder ${compactPath(payload.path)}`;
+    case "fs.move":
+      return `Move ${compactPath(payload.source)} → ${compactPath(payload.destination)}`;
+    case "fs.delete":
+      return `Delete ${compactPath(payload.path)}${payload.recursive ? " · recursive" : ""}`;
+    case "fs.search.start":
+      return `Search "${cleanText(payload.pattern, 56)}" in ${compactPath(payload.path)}`;
+    case "fs.search.results":
+      return `Read search results · offset ${number(payload.offset)} · ${number(payload.length, 50)} rows`;
+
+    case "process.list":
+      return `List processes${payload.filter ? ` · "${cleanText(payload.filter, 52)}"` : ""}`;
+    case "process.kill":
+      return `Kill process ${number(payload.pid)}`;
+
+    case "terminal.exec":
+      return `Run ${redactCommand(payload.command)}${payload.cwd ? ` · in ${compactPath(payload.cwd)}` : ""}`;
+    case "terminal.start":
+      return `Start ${redactCommand(payload.command)}${payload.cwd ? ` · in ${compactPath(payload.cwd)}` : ""}`;
+    case "terminal.shell.start":
+      return `Start shell${payload.cwd ? ` · in ${compactPath(payload.cwd)}` : ""}`;
+    case "terminal.read":
+      return `Read terminal ${cleanText(payload.sessionId, 32)} · after #${number(payload.afterSeq)}`;
+    case "terminal.write":
+      return `Write terminal ${cleanText(payload.sessionId, 32)} · ${String(payload.input ?? "").length} chars`;
+    case "terminal.kill":
+      return `Stop terminal ${cleanText(payload.sessionId, 32)}`;
+    case "terminal.list":
+      return "List terminal sessions";
+    case "terminal.observability":
+      return "Get terminal status";
+    case "terminal.batch.start":
+      return `Run terminal batch · ${Array.isArray(payload.jobs) ? payload.jobs.length : 0} jobs · concurrency ${number(payload.concurrency, 1)}`;
+    case "terminal.batch.status":
+      return `Get batch status ${cleanText(payload.batchId, 32)}`;
+    case "terminal.batch.read":
+      return `Read batch ${cleanText(payload.batchId, 32)}`;
+    case "terminal.batch.cancel":
+      return `Cancel batch ${cleanText(payload.batchId, 32)}`;
+
+    case "desktop.screenshot":
+      return "Capture screen";
+    case "desktop.clipboard.read":
+      return "Read clipboard";
+    case "desktop.clipboard.write":
+      return `Write clipboard · ${String(payload.text ?? payload.content ?? "").length} chars`;
+    case "desktop.window.list":
+      return "List windows";
+    case "desktop.window.focus":
+      return `Focus window ${cleanText(payload.title ?? payload.windowId ?? payload.handle ?? "", 64)}`;
+    case "desktop.mouse.click": {
+      const button = cleanText(payload.button || "left", 12);
+      const x = number(payload.x);
+      const y = number(payload.y);
+      return `${button[0]?.toUpperCase() || "L"}${button.slice(1)} click · ${x},${y}`;
+    }
+    case "desktop.keyboard.input":
+      return `Keyboard input · ${countKeyboardInput(payload)}`;
+    case "desktop.step":
+      return `Desktop step · ${Array.isArray(payload.actions) ? payload.actions.length : 0} actions`;
+
+    default:
+      return cleanText(action.replace(/[._]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase()), 100) || "Tool call";
+  }
+}

package/cli/index.mjs

@@ -11,6 +11,8 @@ function parseOptions(args) {
     else if (arg === "--force") options.force = true;
     else if (arg === "--desktop") options.desktopEnabled = true;
     else if (arg === "--no-desktop") options.desktopEnabled = false;
+    else if (arg === "--plain") options.tuiEnabled = false;
+    else if (arg === "--tui") options.tuiEnabled = true;
     else if (arg === "--relay") options.relayUrl = args[++index];
     else if (arg.startsWith("--relay=")) options.relayUrl = arg.slice(8);
     else if (arg === "--root") options.allowedRoot = args[++index];
@@ -44,6 +46,8 @@ Options:
   --agent-id <id>               Stable agent identifier
   --desktop                     Enable Windows desktop screenshot/input access
   --no-desktop                  Disable desktop access (default)
+  --plain                       Use legacy line-by-line logs
+  --tui                         Force interactive terminal UI
   --no-open                     Do not open the browser automatically
   --force                       Force a new login
 

package/cli/remote.mjs

@@ -4,6 +4,8 @@ import path from "node:path";
 import { loadConfig, saveConfig } from "./config.mjs";
 import { login, requestJson } from "./device-login.mjs";
 import { acquireRunnerOwnership, RunnerAlreadyActiveError } from "./runner-ownership.mjs";
+import { getAgentVersion } from "../agent/protocol.mjs";
+import { RemoteTui, shouldUseTui } from "./tui.mjs";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 let stopping = false;
@@ -55,10 +57,11 @@ function printSummary(config) {
   console.log("");
 }
 
-function spawnAgent(config) {
+function spawnAgent(config, { tui = null } = {}) {
   const agentPath = path.join(packageRoot, "agent", "local-agent.mjs");
   const cwd = String(config.allowedRoots || process.cwd()).split(";")[0] || process.cwd();
-  return spawn(process.execPath, [agentPath], {
+  const useTui = Boolean(tui);
+  const child = spawn(process.execPath, [agentPath], {
     cwd,
     env: {
       ...process.env,
@@ -69,10 +72,13 @@ function spawnAgent(config) {
       TERMINAL_ENABLED: config.terminalEnabled === false ? "0" : "1",
       DESKTOP_ENABLED: config.desktopEnabled === true ? "1" : "0",
       ALLOWED_ROOTS: config.allowedRoots,
+      CHAT_RELAY_UI: useTui ? "ipc" : "plain",
     },
-    stdio: "inherit",
+    stdio: useTui ? ["inherit", "inherit", "inherit", "ipc"] : "inherit",
     windowsHide: false,
   });
+  if (useTui) child.on("message", (message) => tui.handleMessage(message));
+  return child;
 }
 
 export async function remote(options = {}) {
@@ -91,6 +97,7 @@ export async function remote(options = {}) {
     console.error(error.message);
     return 1;
   }
+  let tui = null;
   try {
     if (options.allowedRoot && options.allowedRoot !== config.allowedRoots) {
       config = { ...config, allowedRoots: options.allowedRoot };
@@ -101,10 +108,13 @@ export async function remote(options = {}) {
       saveConfig(config);
     }
 
-    printSummary(config);
+    const useTui = shouldUseTui(options);
+    tui = useTui ? new RemoteTui({ config, version: getAgentVersion() }) : null;
+    if (tui) tui.start();
+    else printSummary(config);
 
     while (!stopping) {
-      const child = spawnAgent(config);
+      const child = spawnAgent(config, { tui });
 
       const stop = () => {
         stopping = true;
@@ -145,6 +155,7 @@ export async function remote(options = {}) {
       }
     }
   } finally {
+    try { tui?.stop?.(); } catch {}
     await ownership.release();
   }
 }

package/cli/tui.mjs

@@ -0,0 +1,215 @@
+import { humanizeToolCall } from "../agent/toolcall-summary.mjs";
+
+const ESC = "\x1b[";
+const LABEL_WIDTH = 12;
+const GAP = 3;
+const MIN_FRAME_WIDTH = 60;
+const MAX_FRAME_WIDTH = 179;
+const FRAME_FIXED_ROWS = 11;
+const FRAME_BOTTOM_MARGIN = 1;
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function truncate(value, width) {
+  const text = String(value ?? "");
+  if (width <= 0) return "";
+  if (text.length <= width) return text;
+  if (width === 1) return "…";
+  return text.slice(0, width - 1) + "…";
+}
+
+function field(label, value, width) {
+  const valueWidth = Math.max(1, width - LABEL_WIDTH);
+  return truncate(String(label).padEnd(LABEL_WIDTH) + truncate(value, valueWidth), width).padEnd(width);
+}
+
+export function formatTwoColumnHeader(state, width = 110) {
+  const usable = clamp(Number(width) || 110, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
+  const leftWidth = Math.floor((usable - GAP) / 2);
+  const rightWidth = usable - GAP - leftWidth;
+  const rows = [
+    ["Account", state.account || "-", "Agent", state.agent || "-"],
+    ["Status", statusText(state.status), "Relay", state.relay || "-"],
+    ["Uptime", formatUptime(state.uptimeMs), "Reconnects", String(state.reconnects ?? 0)],
+    ["Terminal", state.terminal ? "enabled" : "disabled", "Desktop", state.desktop ? "enabled" : "disabled"],
+  ];
+  return rows
+    .map(([leftLabel, leftValue, rightLabel, rightValue]) =>
+      field(leftLabel, leftValue, leftWidth) + " ".repeat(GAP) + field(rightLabel, rightValue, rightWidth).trimEnd(),
+    )
+    .join("\n");
+}
+
+function statusText(value) {
+  switch (String(value || "").toLowerCase()) {
+    case "connected": return "● Connected";
+    case "connecting": return "◐ Connecting";
+    case "reconnecting": return "◐ Reconnecting";
+    case "stopping": return "○ Stopping";
+    case "offline": return "○ Offline";
+    default: return "○ Starting";
+  }
+}
+
+function formatUptime(ms) {
+  const totalSeconds = Math.max(0, Math.floor(Number(ms || 0) / 1000));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  return [hours, minutes, seconds].map((value) => String(value).padStart(2, "0")).join(":");
+}
+
+function formatDuration(ms, status) {
+  if (status === "running") return "running";
+  const value = Math.max(0, Number(ms) || 0);
+  if (value < 1000) return Math.round(value) + "ms";
+  return (value / 1000).toFixed(value < 10000 ? 1 : 0) + "s";
+}
+
+function clock(value) {
+  const date = value ? new Date(value) : new Date();
+  if (Number.isNaN(date.getTime())) return "--:--:--";
+  return date.toLocaleTimeString("en-GB", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+
+export function formatTransactionRow(item, width = 110) {
+  const usable = clamp(Number(width) || 110, 60, 180);
+  const status = item.status === "running" ? "●" : item.ok === false ? "✕" : "✓";
+  const prefix = `${clock(item.at)}  ${status}  `;
+  const duration = formatDuration(item.durationMs, item.status);
+  const suffix = "  " + duration.padStart(8);
+  const summaryWidth = Math.max(12, usable - prefix.length - suffix.length);
+  return prefix + truncate(item.summary || item.action || "Tool call", summaryWidth).padEnd(summaryWidth) + suffix;
+}
+
+function normalizeRelay(value) {
+  try {
+    const url = new URL(String(value));
+    return url.host + (url.pathname && url.pathname !== "/" ? url.pathname : "");
+  } catch {
+    return String(value || "-").replace(/^https?:\/\//, "").replace(/\/$/, "");
+  }
+}
+
+export function shouldUseTui(options = {}, stdout = process.stdout) {
+  if (options.tuiEnabled === false) return false;
+  if (options.tuiEnabled === true) return true;
+  return Boolean(stdout?.isTTY);
+}
+
+export class RemoteTui {
+  constructor({ config, version, output = process.stdout }) {
+    this.output = output;
+    this.startedAt = Date.now();
+    this.state = {
+      account: config.user?.name || config.user?.login || "signed in",
+      agent: config.agentName || config.agentId || "-",
+      relay: normalizeRelay(config.relayUrl),
+      status: "starting",
+      reconnects: 0,
+      terminal: config.terminalEnabled !== false,
+      desktop: config.desktopEnabled === true,
+    };
+    this.version = version || "-";
+    this.transactions = [];
+    this.timer = null;
+    this.closed = false;
+    this.renderPending = false;
+  }
+
+  start() {
+    if (this.closed) return;
+    // Use the terminal's alternate screen so periodic redraws never accumulate
+    // in scrollback. Keep one column unused to avoid automatic line wrapping.
+    this.output.write(ESC + "?1049h" + ESC + "?25l" + ESC + "2J" + ESC + "H");
+    this.render();
+    this.timer = setInterval(() => this.render(), 1000);
+    this.timer.unref?.();
+  }
+
+  stop() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    this.output.write(ESC + "?25h" + ESC + "?1049l");
+  }
+
+  handleMessage(message) {
+    if (!message || message.type !== "chat-relay-ui") return;
+    if (message.event === "connection") {
+      this.state.status = message.state || this.state.status;
+      if (Number.isFinite(Number(message.reconnects))) this.state.reconnects = Number(message.reconnects);
+    } else if (message.event === "tool:start") {
+      this.transactions.push({
+        requestId: message.requestId,
+        at: message.at || new Date().toISOString(),
+        action: message.action,
+        summary: message.summary || humanizeToolCall({ action: message.action }),
+        status: "running",
+        ok: null,
+      });
+      if (this.transactions.length > 100) this.transactions.splice(0, this.transactions.length - 100);
+    } else if (message.event === "tool:end") {
+      const item = [...this.transactions].reverse().find((entry) => entry.requestId === message.requestId);
+      if (item) {
+        item.status = "done";
+        item.ok = message.ok !== false;
+        item.durationMs = message.durationMs;
+        if (message.error && message.ok === false) item.summary += ` · ${truncate(message.error, 48)}`;
+      }
+    } else if (message.event === "system") {
+      this.transactions.push({
+        requestId: "system-" + Date.now() + "-" + Math.random(),
+        at: message.at || new Date().toISOString(),
+        summary: message.message || "Agent event",
+        status: "done",
+        ok: message.level !== "error",
+      });
+      if (this.transactions.length > 100) this.transactions.splice(0, this.transactions.length - 100);
+    }
+    this.scheduleRender();
+  }
+
+  scheduleRender() {
+    if (this.closed || this.renderPending) return;
+    this.renderPending = true;
+    setImmediate(() => {
+      this.renderPending = false;
+      this.render();
+    });
+  }
+
+  render() {
+    if (this.closed) return;
+    const terminalWidth = Number(this.output.columns) || 110;
+    const width = clamp(terminalWidth - 1, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
+    const height = Math.max(16, Number(this.output.rows) || 30);
+    const separator = "─".repeat(width);
+    const header = formatTwoColumnHeader({
+      ...this.state,
+      uptimeMs: Date.now() - this.startedAt,
+    }, width);
+    // Fixed frame content occupies 11 rows. Leave one spare row at the
+    // bottom so Windows Terminal never scrolls the screen while repainting.
+    const availableRows = Math.max(1, height - FRAME_FIXED_ROWS - FRAME_BOTTOM_MARGIN);
+    const rows = this.transactions.slice(-availableRows).map((item) => formatTransactionRow(item, width));
+    while (rows.length < Math.min(availableRows, 4)) rows.unshift("");
+
+    const screen = [
+      `Chat Relay  v${this.version}`,
+      separator,
+      "",
+      header,
+      "",
+      separator,
+      "Transactions",
+      "",
+      ...rows,
+    ].join("\n");
+
+    this.output.write(ESC + "2J" + ESC + "H" + screen);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@anusornneal/chat-relay",
-    "version": "0.10.2",
+    "version": "0.11.1",
     "description": "Zero-checkout remote MCP agent for ChatGPT with terminal, filesystem, process, multi-user, and multi-agent support.",
     "type": "module",
     "bin": {