Fix Linux input echo leak by bypassing .NET Console entirely on Unix

Replace all hot-path Console.* calls with raw libc I/O to eliminate
the 9-month-old echo leak caused by .NET's ConsolePal toggling termios.

- Add raw terminal mode via tcgetattr/tcsetattr (cfmakeraw equivalent)
- Add raw libc write() for stdout, bypassing .NET's StreamWriter
- Add raw stdin fd 0 reader with ANSI input parser and mouse state machine
- Add ioctl TIOCGWINSZ for window size instead of Console.WindowWidth/Height
- Redirect Console.Out to /dev/null to prevent .NET runtime stdout writes
- Use alternate screen buffer for clean display
- Suppress SIGINT/SIGTSTP via signal() instead of Console.TreatControlCAsInput
- Skip FIX24/25/27 workarounds when raw mode is active
- Expose UseDirectAnsi option in ConsoleWindowSystemOptions (default: true)
- Windows behavior unchanged (continues using Console.*)

Author: nickprotop

SharpConsoleUI/Configuration/ConsoleWindowSystemOptions.cs

@@ -90,6 +90,11 @@ public record ConsoleWindowSystemOptions(
     bool Fix27_PeriodicFullRedraw = true,
     double Fix27_RedrawIntervalSeconds = 1.0,
 
+    // ===== PLATFORM-SPECIFIC =====
+    // When true on Unix, bypasses .NET Console entirely using raw libc I/O
+    // to eliminate the input echo leak. Has no effect on Windows.
+    bool UseDirectAnsi = true,
+
     // ===== DIAGNOSTICS & TESTING =====
     // Rendering diagnostics for testing and debugging (default: false, zero overhead when disabled)
     bool EnableDiagnostics = false,

SharpConsoleUI/ConsoleWindowSystem.cs

@@ -120,6 +120,27 @@ public class ConsoleWindowSystem
 
 		#region Constructors
 
+		/// <summary>
+		/// Initializes a new instance with a render mode. UseDirectAnsi is read from options.
+		/// </summary>
+		/// <param name="renderMode">The rendering mode to use.</param>
+		/// <param name="pluginConfiguration">Optional plugin configuration for auto-loading plugins.</param>
+		/// <param name="options">Optional configuration options for system behavior.</param>
+		public ConsoleWindowSystem(RenderMode renderMode, PluginConfiguration? pluginConfiguration = null, ConsoleWindowSystemOptions? options = null)
+			: this(CreateDriver(renderMode, options), pluginConfiguration, options)
+		{
+		}
+
+		private static NetConsoleDriver CreateDriver(RenderMode renderMode, ConsoleWindowSystemOptions? options)
+		{
+			var opts = options ?? ConsoleWindowSystemOptions.Default;
+			return new NetConsoleDriver(new NetConsoleDriverOptions
+			{
+				RenderMode = renderMode,
+				UseDirectAnsi = opts.UseDirectAnsi
+			});
+		}
+
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ConsoleWindowSystem"/> class with the default theme.
 		/// </summary>

SharpConsoleUI/Drivers/ConsoleBuffer.cs

@@ -6,6 +6,7 @@
 // License: MIT
 // -----------------------------------------------------------------------
 
+using SharpConsoleUI.Drivers.Input;
 using SharpConsoleUI.Helpers;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -119,7 +120,7 @@ public void AddContent(int x, int y, string content)
 
 			// Single-pass state machine parser for ANSI sequences
 		// FIX6: Also limit width in AddContent to prevent writing beyond console
-		int maxBufferX = _options.Fix6_WidthLimit ? Math.Min(_width, Console.WindowWidth) : _width;
+		int maxBufferX = _options.Fix6_WidthLimit ? Math.Min(_width, GetCurrentWindowWidth()) : _width;
 			while (contentPos < content.Length && bufferX < maxBufferX)
 			{
 				// State machine: detect ESC character
@@ -267,12 +268,13 @@ public void Render()
 				CaptureConsoleBufferSnapshot();
 			}
 
-			Console.CursorVisible = false;
+			// Hide cursor during render — use raw write on Unix to bypass .NET entirely
+			WriteOutput("\x1b[?25l");
 
 			// FIX24: Drain input buffer to prevent mouse sequences from being echoed during rendering
-			// Race condition: If mouse events arrive while we're outputting cursor positioning,
-			// they get echoed at our current cursor position, mixing with our content
-			if (_options.Fix24_DrainInputBeforeRender)
+			// Skip when raw mode active — no echo means nothing to drain, and Console.ReadKey/KeyAvailable
+			// would go through ConsolePal which we're trying to avoid
+			if (_options.Fix24_DrainInputBeforeRender && !TerminalRawMode.IsRawModeActive)
 			{
 				int drained = 0;
 				while (Console.KeyAvailable)
@@ -291,19 +293,19 @@ public void Render()
 			// FIX25: Temporarily disable mouse tracking during rendering
 			// Problem: .NET Console.ReadKey() toggles echo on/off, creating windows where mouse sequences get echoed
 			// Solution: Disable mouse tracking entirely during render to prevent new events from arriving
-			if (_options.Fix25_DisableMouseDuringRender)
+			// FIX25: Disable mouse tracking during render — skip in raw mode (unnecessary)
+			if (_options.Fix25_DisableMouseDuringRender && !TerminalRawMode.IsRawModeActive)
 			{
-				// Disable all mouse tracking modes (reverse order of enable)
-				Console.Out.Write("\x1b[?1003l");  // Disable any event mouse
-				Console.Out.Write("\x1b[?1002l");  // Disable button event tracking
-				Console.Out.Write("\x1b[?1000l");  // Disable basic mouse reporting
-				Console.Out.Flush();
+				WriteOutput("\x1b[?1003l");  // Disable any event mouse
+				WriteOutput("\x1b[?1002l");  // Disable button event tracking
+				WriteOutput("\x1b[?1000l");  // Disable basic mouse reporting
+				FlushOutput();
 			}
 
 
 		// FIX27: Periodic redraw of clean cells to clear terminal echo leaks (Linux/macOS only)
-		// Check if 1 second has elapsed since last full redraw (time-based, not frame-based)
-		if (_options.Fix27_PeriodicFullRedraw && !RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+		// Keep active even in raw mode as a visual cleanup backstop
+		if (_options.Fix27_PeriodicFullRedraw && !RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && !TerminalRawMode.IsRawModeActive)
 		{
 			var elapsed = (DateTime.Now - _lastFullRedraw).TotalSeconds;
 			if (elapsed >= _options.Fix27_RedrawIntervalSeconds)
@@ -417,11 +419,12 @@ public void Render()
 		}
 
 
-			// Single atomic write of entire screen - no cursor jumps, no flicker!
+			// Single atomic write of entire screen via raw libc write() on Unix
+			// Completely bypasses .NET's Console/StreamWriter/SyncTextWriter
 			var output = screenBuilder.ToString();
 			if (output.Length > 0)
 			{
-				Console.Write(output);
+				WriteOutput(output);
 			}
 
 			// Diagnostics: Capture output metrics
@@ -445,13 +448,12 @@ public void Render()
 			}
 
 			// FIX25: Re-enable mouse tracking after rendering completes
-			if (_options.Fix25_DisableMouseDuringRender)
+			if (_options.Fix25_DisableMouseDuringRender && !TerminalRawMode.IsRawModeActive)
 			{
-				// Re-enable mouse tracking in same order as NetConsoleDriver initialization
-				Console.Out.Write("\x1b[?1000h");  // Enable basic mouse reporting
-				Console.Out.Write("\x1b[?1002h");  // Enable button event tracking
-				Console.Out.Write("\x1b[?1003h");  // Enable any event mouse
-				Console.Out.Flush();
+				WriteOutput("\x1b[?1000h");  // Enable basic mouse reporting
+				WriteOutput("\x1b[?1002h");  // Enable button event tracking
+				WriteOutput("\x1b[?1003h");  // Enable any event mouse
+				FlushOutput();
 			}
 		}
 	}
@@ -619,6 +621,37 @@ private bool IsLineDirty(int y)
 		return (true, false, regions);
 	}
 
+	/// <summary>
+	/// Writes output using raw libc write() when raw mode is active, or Console.Out.Write as fallback.
+	/// Raw write completely bypasses .NET's Console/StreamWriter/SyncTextWriter infrastructure,
+	/// eliminating any possibility of .NET runtime code touching termios during output.
+	/// </summary>
+	private static void WriteOutput(string text)
+	{
+		if (TerminalRawMode.IsRawModeActive)
+			TerminalRawMode.WriteStdout(text);
+		else
+			Console.Out.Write(text);
+	}
+
+	/// <summary>
+	/// Flushes stdout. No-op when raw mode is active (raw write is unbuffered).
+	/// </summary>
+	private static void FlushOutput()
+	{
+		if (!TerminalRawMode.IsRawModeActive)
+			Console.Out.Flush();
+	}
+
+	/// <summary>
+	/// Gets current window width using ioctl when raw mode is active, avoiding ConsolePal.
+	/// </summary>
+	private int GetCurrentWindowWidth()
+	{
+		var (w, _) = TerminalRawMode.GetWindowSize();
+		return w;
+	}
+
 	private bool IsValidPosition(int x, int y)
 		=> x >= 0 && x < _width && y >= 0 && y < _height;
 
@@ -668,7 +701,7 @@ private void AppendLineToBuilder(int y, StringBuilder builder)
 			int cellsWritten = 0;  // Count cells written
 
 			// FIX6: Limit to console window width to prevent writing beyond visible area
-			int maxWidth = _options.Fix6_WidthLimit ? Math.Min(_width, Console.WindowWidth) : _width;
+			int maxWidth = _options.Fix6_WidthLimit ? Math.Min(_width, GetCurrentWindowWidth()) : _width;
 			for (int x = 0; x < maxWidth; x++)
 			{
 				ref var frontCell = ref _frontBuffer[x, y];