@xopcai/xopc 0.0.28 → 0.0.29

package/dist/src/tui/tui.js

@@ -1,233 +1,32 @@
+import { appendHistoryToChatLog } from "./chat-history.js";
 import { StreamAssembler } from "./stream-assembler.js";
 import { editorTheme, theme } from "./theme.js";
+import { clearPendingToolCallIds, dispatchAgentSSE } from "./tui-agent-events.js";
+import { createTuiCommandHandler, getSlashCommands } from "./tui-commands.js";
+import { createBackspaceDeduper, drainAndStopTuiSafely, isIgnorableTuiStopError, resolveCtrlCAction, stopTuiSafely } from "./tui-lifecycle.js";
+import { createLocalShellRunner } from "./tui-local-shell.js";
+import { createOverlayHandlers } from "./tui-overlays.js";
+import { openModelPickerOverlay, openSessionPickerOverlay } from "./tui-picker-overlay.js";
+import { installTuiStdioFilter } from "./tui-stdio-filter.js";
+import { createEditorSubmitHandler, createSubmitBurstCoalescer, shouldEnableWindowsGitBashPasteFallback } from "./tui-submit.js";
+import { withTuiSuspended } from "./tui-suspend.js";
 import { createInitialState } from "./tui-types.js";
 import { EmbeddedBackend } from "./backends/embedded-backend.js";
 import { GatewaySseBackend } from "./backends/gateway-sse-backend.js";
 import { ChatLog } from "./components/chat-log.js";
 import { CustomEditor } from "./components/custom-editor.js";
-import { CombinedAutocompleteProvider, Container, Loader, ProcessTerminal, TUI, Text } from "@mariozechner/pi-tui";
+import { CombinedAutocompleteProvider, Container, Key, Loader, ProcessTerminal, TUI, Text, getKeybindings, isKeyRelease, matchesKey, parseKey } from "@mariozechner/pi-tui";
 //#region src/tui/tui.ts
-function getSlashCommands(_isLocal) {
-	return [
-		{
-			name: "help",
-			description: "Show available commands"
-		},
-		{
-			name: "abort",
-			description: "Abort active run (or press Escape)"
-		},
-		{
-			name: "tools",
-			description: "Toggle tool output expanded/collapsed (or Ctrl+O)"
-		},
-		{
-			name: "thinking",
-			description: "Toggle thinking display (or Ctrl+T)"
-		},
-		{
-			name: "exit",
-			description: "Exit the TUI"
-		},
-		{
-			name: "models",
-			description: "List available models"
-		},
-		{
-			name: "switch",
-			description: "Switch model (e.g. /switch openai/gpt-4o)"
-		},
-		{
-			name: "usage",
-			description: "Show token usage statistics"
-		},
-		{
-			name: "new",
-			description: "Start a new session"
-		},
-		{
-			name: "clear",
-			description: "Clear current session"
-		},
-		{
-			name: "list",
-			description: "List sessions"
-		},
-		{
-			name: "compact",
-			description: "Compact session history"
-		},
-		{
-			name: "think",
-			description: "Set thinking level (e.g. /think high)"
-		},
-		{
-			name: "reasoning",
-			description: "Set reasoning visibility (e.g. /reasoning stream)"
-		},
-		{
-			name: "verbose",
-			description: "Toggle verbose mode"
-		},
-		{
-			name: "status",
-			description: "Show agent status"
-		},
-		{
-			name: "config",
-			description: "Show or update configuration"
-		},
-		{
-			name: "context",
-			description: "Show context budget"
-		},
-		{
-			name: "btw",
-			description: "Side question without saving to session"
-		},
-		{
-			name: "export",
-			description: "Export session (markdown/html/json)"
-		},
-		{
-			name: "settings",
-			description: "Show current settings"
-		},
-		{
-			name: "start",
-			description: "Show welcome message"
-		}
-	];
-}
-function helpText(isLocal) {
-	const commands = getSlashCommands(isLocal);
-	const lines = ["Available commands:"];
-	for (const c of commands) lines.push(`  /${c.name} — ${c.description}`);
-	lines.push("", "Keyboard shortcuts:");
-	lines.push("  Escape — Abort active run");
-	lines.push("  Ctrl+O — Toggle tool output");
-	lines.push("  Ctrl+T — Toggle thinking display");
-	lines.push("  Ctrl+C — Clear input / exit");
-	lines.push("  Ctrl+D — Exit");
-	return lines.join("\n");
-}
-function resolveCtrlCAction(hasInput, now, lastCtrlCAt) {
-	if (hasInput) return {
-		action: "clear",
-		nextLastCtrlCAt: now
-	};
-	if (now - lastCtrlCAt <= 1e3) return {
-		action: "exit",
-		nextLastCtrlCAt: lastCtrlCAt
-	};
-	return {
-		action: "warn",
-		nextLastCtrlCAt: now
-	};
-}
-const pendingToolCallIds = /* @__PURE__ */ new Map();
-function dispatchAgentSSE(event, data, state, chatLog, assembler, tui, setActivityStatus) {
-	const runId = state.activeRunId ?? "default";
-	switch (event) {
-		case "status":
-			state.activeRunId = typeof data.runId === "string" ? data.runId : runId;
-			setActivityStatus("waiting");
-			break;
-		case "token": {
-			const content = typeof data.content === "string" ? data.content : typeof data.delta === "string" ? data.delta : typeof data.text === "string" ? data.text : "";
-			if (!content) break;
-			setActivityStatus("streaming");
-			const display = assembler.ingestToken(runId, content, state.showThinking);
-			if (display !== null) {
-				chatLog.updateAssistant(display, runId);
-				tui.requestRender();
-			}
-			break;
-		}
-		case "thinking": {
-			const thinkContent = String(data.content ?? "");
-			const isDelta = Boolean(data.delta);
-			if (data.status === "started") break;
-			setActivityStatus("streaming");
-			const display = assembler.ingestThinking(runId, thinkContent, isDelta, state.showThinking);
-			if (display !== null) {
-				chatLog.updateAssistant(display, runId);
-				tui.requestRender();
-			}
-			break;
-		}
-		case "thinking_end":
-		case "message_end": break;
-		case "tool_start": {
-			const toolName = String(data.toolName ?? "unknown");
-			const toolCallId = String(data.toolCallId || crypto.randomUUID());
-			const stack = pendingToolCallIds.get(toolName) ?? [];
-			stack.push(toolCallId);
-			pendingToolCallIds.set(toolName, stack);
-			setActivityStatus("running");
-			chatLog.startTool(toolCallId, toolName, data.args);
-			tui.requestRender();
-			break;
-		}
-		case "tool_end": {
-			const toolName = String(data.toolName ?? "");
-			let toolCallId = typeof data.toolCallId === "string" && data.toolCallId ? data.toolCallId : "";
-			if (!toolCallId && toolName) {
-				const stack = pendingToolCallIds.get(toolName);
-				if (stack && stack.length > 0) {
-					toolCallId = stack.shift();
-					if (stack.length === 0) pendingToolCallIds.delete(toolName);
-				}
-			}
-			const resultText = String(data.result ?? "");
-			const isError = Boolean(data.isError);
-			if (toolCallId) chatLog.updateToolResult(toolCallId, resultText, isError);
-			setActivityStatus("streaming");
-			tui.requestRender();
-			break;
-		}
-		case "error": {
-			const errorContent = String(data.content ?? "Unknown error");
-			const finalText = assembler.finalize(runId, state.showThinking);
-			if (finalText) chatLog.finalizeAssistant(finalText, runId);
-			chatLog.addSystem(`❌ ${errorContent}`);
-			state.activeRunId = null;
-			setActivityStatus("idle");
-			tui.requestRender();
-			break;
-		}
-		case "result": {
-			const finalText = assembler.finalize(runId, state.showThinking);
-			if (finalText) chatLog.finalizeAssistant(finalText, runId);
-			state.activeRunId = null;
-			setActivityStatus("idle");
-			tui.requestRender();
-			break;
-		}
-		case "progress":
-			setActivityStatus("running");
-			break;
-		default: break;
-	}
+function matchesCtrlCSequence(data) {
+	if (isKeyRelease(data)) return false;
+	if (data === "") return true;
+	if (parseKey(data) === "ctrl+c") return true;
+	const kb = getKeybindings();
+	return matchesKey(data, Key.ctrl("c")) || kb.matches(data, "tui.input.copy");
 }
 async function runTui(opts) {
-	const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-	const originalStderrWrite = process.stderr.write.bind(process.stderr);
-	let suppressLogs = true;
-	const logFilter = (original) => {
-		return function filteredWrite(chunk, ...rest) {
-			if (!suppressLogs) return original(chunk, ...rest);
-			if ((typeof chunk === "string" ? chunk : chunk instanceof Buffer ? chunk.toString() : "").startsWith("{\"level\":")) return true;
-			return original(chunk, ...rest);
-		};
-	};
-	process.stdout.write = logFilter(originalStdoutWrite);
-	process.stderr.write = logFilter(originalStderrWrite);
-	const restoreStdio = () => {
-		suppressLogs = false;
-		process.stdout.write = originalStdoutWrite;
-		process.stderr.write = originalStderrWrite;
-	};
+	const stdioFilter = installTuiStdioFilter();
+	const restoreStdio = () => stdioFilter.restore();
 	const isLocalMode = opts.local === true;
 	const state = createInitialState(opts.session ?? "cli:tui");
 	const assembler = new StreamAssembler();
@@ -236,6 +35,12 @@ async function runTui(opts) {
 		token: opts.token
 	});
 	const tui = new TUI(new ProcessTerminal());
+	const dedupeBackspace = createBackspaceDeduper();
+	tui.addInputListener((data) => {
+		const next = dedupeBackspace(data);
+		if (next.length === 0) return { consume: true };
+		return { data: next };
+	});
 	const header = new Text("", 1, 0);
 	const statusContainer = new Container();
 	const footer = new Text("", 1, 0);
@@ -249,6 +54,7 @@ async function runTui(opts) {
 	root.addChild(editor);
 	tui.addChild(root);
 	tui.setFocus(editor);
+	const { openOverlay, closeOverlay } = createOverlayHandlers(tui, editor);
 	const slashCommands = getSlashCommands(isLocalMode);
 	editor.setAutocompleteProvider(new CombinedAutocompleteProvider(slashCommands.map((c) => ({
 		name: c.name,
@@ -265,6 +71,11 @@ async function runTui(opts) {
 		"streaming",
 		"running"
 	]);
+	let lastStreamActivityAt = Date.now();
+	let streamWatchdogId = null;
+	const touchStreamingActivity = () => {
+		lastStreamActivityAt = Date.now();
+	};
 	const formatElapsed = (startMs) => {
 		const totalSeconds = Math.max(0, Math.floor((Date.now() - startMs) / 1e3));
 		if (totalSeconds < 60) return `${totalSeconds}s`;
@@ -335,6 +146,38 @@ async function runTui(opts) {
 			tui.requestRender();
 		} catch {}
 	};
+	let finishTui = null;
+	let exitResult = { exitReason: "exit" };
+	const requestExit = () => {
+		if (state.exitRequested) return;
+		state.exitRequested = true;
+		if (elapsedTimerId) {
+			clearInterval(elapsedTimerId);
+			elapsedTimerId = null;
+		}
+		if (streamWatchdogId) {
+			clearInterval(streamWatchdogId);
+			streamWatchdogId = null;
+		}
+		client.stop();
+		drainAndStopTuiSafely(tui).then(() => {
+			restoreStdio();
+			finishTui?.();
+		});
+	};
+	const abortActive = async () => {
+		if (!state.activeRunId) return;
+		const runId = state.activeRunId;
+		state.activeRunId = null;
+		assembler.drop(runId);
+		chatLog.dropAssistant(runId);
+		setActivityStatus("idle");
+		tui.requestRender();
+		await client.abortChat({
+			sessionKey: state.currentSessionKey,
+			runId
+		}).catch(() => {});
+	};
 	const sendMessage = (text) => {
 		if (state.activeRunId) {
 			chatLog.addSystem("A response is still in progress. Use /abort or press Escape to cancel.");
@@ -343,6 +186,7 @@ async function runTui(opts) {
 		}
 		chatLog.addUser(text);
 		setActivityStatus("sending");
+		touchStreamingActivity();
 		tui.requestRender();
 		client.sendChat({
 			sessionKey: state.currentSessionKey,
@@ -355,79 +199,78 @@ async function runTui(opts) {
 			tui.requestRender();
 		});
 	};
-	const abortActive = async () => {
-		if (!state.activeRunId) return;
-		const runId = state.activeRunId;
-		state.activeRunId = null;
-		assembler.drop(runId);
-		chatLog.dropAssistant(runId);
-		setActivityStatus("idle");
-		tui.requestRender();
-		await client.abortChat({
-			sessionKey: state.currentSessionKey,
-			runId
-		}).catch(() => {});
-	};
-	const handleCommand = (input) => {
-		const [commandName] = input.replace(/^\//, "").trim().split(/\s+/);
-		const normalizedCommand = (commandName ?? "").toLowerCase();
-		switch (normalizedCommand) {
-			case "help":
-				chatLog.addSystem(helpText(isLocalMode));
-				tui.requestRender();
-				return;
-			case "exit":
-			case "quit":
-				requestExit();
-				return;
-			case "abort":
-			case "stop":
-			case "cancel":
-				abortActive().then(() => {
-					chatLog.addSystem("Aborted.");
-					tui.requestRender();
-				});
-				return;
-			case "tools":
-				state.toolsExpanded = !state.toolsExpanded;
-				chatLog.setToolsExpanded(state.toolsExpanded);
-				chatLog.addSystem(`Tools: ${state.toolsExpanded ? "expanded" : "collapsed"}`);
-				tui.requestRender();
-				return;
-			case "thinking":
-				state.showThinking = !state.showThinking;
-				chatLog.addSystem(`Thinking display: ${state.showThinking ? "on" : "off"}`);
-				updateFooter();
-				tui.requestRender();
-				return;
-			default: break;
+	const handleCommand = createTuiCommandHandler({
+		state,
+		chatLog,
+		tui,
+		assembler,
+		isLocalMode,
+		abortActive,
+		sendMessage,
+		requestExit,
+		updateFooter
+	});
+	const { runLocalShellLine } = createLocalShellRunner({
+		chatLog,
+		tui,
+		editor,
+		openOverlay,
+		closeOverlay,
+		pauseStdioFilter: () => stdioFilter.pause(),
+		resumeStdioFilter: () => stdioFilter.resume(),
+		runWithInheritedStdio: async (work) => {
+			await withTuiSuspended(tui, work);
 		}
-		switch (normalizedCommand) {
-			case "new":
-			case "reset":
-			case "restart":
-			case "clear":
-				abortActive().then(() => {
-					assembler.clear();
-					chatLog.clearAll();
-					tui.requestRender();
-					sendMessage(input);
-				});
-				return;
-			default: break;
+	});
+	editor.onSubmit = createSubmitBurstCoalescer({
+		submit: createEditorSubmitHandler({
+			editor,
+			handleCommand,
+			sendMessage,
+			handleBangLine: runLocalShellLine
+		}),
+		enabled: shouldEnableWindowsGitBashPasteFallback()
+	});
+	const setSessionKey = (key) => {
+		state.currentSessionKey = key;
+	};
+	const clearChatForSessionSwitch = () => {
+		assembler.clear();
+		chatLog.clearAll();
+		clearPendingToolCallIds();
+		state.historyLoaded = false;
+	};
+	const loadSessionHistory = async () => {
+		try {
+			const { messages } = await client.loadHistory({
+				sessionKey: state.currentSessionKey,
+				limit: 200
+			});
+			appendHistoryToChatLog(chatLog, messages, state.toolsExpanded);
+		} catch {} finally {
+			state.historyLoaded = true;
+			tui.requestRender();
 		}
-		sendMessage(input);
 	};
-	editor.onSubmit = (text) => {
-		const value = text.trim();
-		editor.setText("");
-		if (!value) return;
-		editor.addToHistory(value);
-		if (value.startsWith("/")) handleCommand(value);
-		else sendMessage(value);
+	const pickerSvc = {
+		tui,
+		editor,
+		openOverlay,
+		closeOverlay,
+		chatLog,
+		client,
+		sendMessage,
+		refreshSessionInfo,
+		updateHeader,
+		state,
+		setSessionKey,
+		clearChatForSessionSwitch,
+		loadSessionHistory
 	};
 	editor.onEscape = () => void abortActive();
 	editor.onCtrlD = () => requestExit();
+	editor.onCtrlL = () => void openModelPickerOverlay(pickerSvc);
+	editor.onCtrlP = () => void openSessionPickerOverlay(pickerSvc);
 	editor.onCtrlO = () => {
 		state.toolsExpanded = !state.toolsExpanded;
 		chatLog.setToolsExpanded(state.toolsExpanded);
@@ -441,44 +284,54 @@ async function runTui(opts) {
 	};
 	const handleCtrlC = () => {
 		const now = Date.now();
-		const decision = resolveCtrlCAction(editor.getText().trim().length > 0, now, state.lastCtrlCAt);
+		const decision = resolveCtrlCAction({
+			hasInput: editor.getText().trim().length > 0,
+			now,
+			lastCtrlCAt: state.lastCtrlCAt
+		});
 		state.lastCtrlCAt = decision.nextLastCtrlCAt;
 		if (decision.action === "clear") {
 			editor.setText("");
 			setActivityStatus("cleared input; press ctrl+c again to exit");
 			tui.requestRender();
-		} else if (decision.action === "exit") requestExit();
-		else {
-			setActivityStatus("press ctrl+c again to exit");
-			tui.requestRender();
+			return;
 		}
-	};
-	editor.onCtrlC = handleCtrlC;
-	let finishTui = null;
-	let exitResult = { exitReason: "exit" };
-	const requestExit = () => {
-		if (state.exitRequested) return;
-		state.exitRequested = true;
-		if (elapsedTimerId) {
-			clearInterval(elapsedTimerId);
-			elapsedTimerId = null;
+		if (decision.action === "exit") {
+			requestExit();
+			return;
 		}
-		client.stop();
-		try {
-			tui.stop();
-		} catch {}
-		restoreStdio();
-		finishTui?.();
+		setActivityStatus("press ctrl+c again to exit");
+		tui.requestRender();
 	};
+	editor.onCtrlC = handleCtrlC;
+	tui.addInputListener((data) => {
+		if (!matchesCtrlCSequence(data)) return void 0;
+		handleCtrlC();
+		return { consume: true };
+	});
+	streamWatchdogId = setInterval(() => {
+		if (!state.activeRunId) return;
+		if (!busyStates.has(state.activityStatus)) return;
+		if (Date.now() - lastStreamActivityAt < 3e4) return;
+		const rid = state.activeRunId;
+		const finalText = assembler.finalize(rid, state.showThinking);
+		if (finalText) chatLog.finalizeAssistant(finalText, rid);
+		chatLog.addSystem("⚠️ No stream activity for 30s; UI reset (connection may have stalled). Retry or check gateway.");
+		state.activeRunId = null;
+		setActivityStatus("idle");
+		tui.requestRender();
+	}, 5e3);
 	client.onEvent = (evt) => {
 		const data = evt.data ?? {};
-		dispatchAgentSSE(evt.event, data, state, chatLog, assembler, tui, setActivityStatus);
+		dispatchAgentSSE(evt.event, data, state, chatLog, assembler, tui, setActivityStatus, touchStreamingActivity);
 	};
 	client.onConnected = () => {
 		state.isConnected = true;
 		setConnectionStatus(isLocalMode ? "local ready" : "gateway connected");
+		touchStreamingActivity();
 		(async () => {
 			await refreshSessionInfo();
+			await loadSessionHistory();
 			updateHeader();
 			updateFooter();
 			tui.requestRender();
@@ -491,16 +344,22 @@ async function runTui(opts) {
 	client.onDisconnected = (reason) => {
 		const wasConnected = state.isConnected;
 		state.isConnected = false;
+		touchStreamingActivity();
 		if (isLocalMode) setConnectionStatus(`local stopped: ${reason}`);
 		else {
-			setConnectionStatus(`disconnected: ${reason}`);
+			setConnectionStatus(`disconnected${wasConnected || state.historyLoaded ? ` (${reason}). Reconnecting broadcast stream…` : `. Ensure gateway is running (xopc gateway) or use --local.`}`);
 			if (!wasConnected && !state.historyLoaded) {
 				const gatewayUrl = opts.url ?? "http://localhost:3120";
-				chatLog.addSystem(`Cannot reach gateway at ${gatewayUrl}.\nMake sure the gateway is running (xopc gateway), or use --local for embedded mode.`);
+				chatLog.addSystem(`Cannot reach gateway at ${gatewayUrl}.\nStart the gateway (\`xopc gateway\`) or run \`xopc tui --local\` for embedded mode.`);
 			}
 		}
 		tui.requestRender();
 	};
+	client.onGap = (info) => {
+		chatLog.addSystem(`⚠️ Event gap: expected ${info.expected}, received ${info.received}. Some updates may be missing.`);
+		setConnectionStatus(`event gap: expected ${info.expected}, got ${info.received}`);
+		tui.requestRender();
+	};
 	const sigintHandler = () => handleCtrlC();
 	const sigtermHandler = () => requestExit();
 	process.on("SIGINT", sigintHandler);
@@ -514,6 +373,10 @@ async function runTui(opts) {
 		finishTui = () => {
 			process.removeListener("SIGINT", sigintHandler);
 			process.removeListener("SIGTERM", sigtermHandler);
+			if (streamWatchdogId) {
+				clearInterval(streamWatchdogId);
+				streamWatchdogId = null;
+			}
 			finishTui = null;
 			resolve();
 		};
@@ -521,6 +384,6 @@ async function runTui(opts) {
 	return exitResult;
 }
 //#endregion
-export { runTui };
+export { createBackspaceDeduper, drainAndStopTuiSafely, isIgnorableTuiStopError, resolveCtrlCAction, runTui, stopTuiSafely, withTuiSuspended };
 
 //# sourceMappingURL=tui.js.map