Add Kitty Keyboard Protocol support (Phase 1 + Phase 2 start)

.github/workflows/integration-tests.yml

@@ -18,6 +18,8 @@ jobs:
       matrix:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
     timeout-minutes: 15
+    env:
+      DisableRealDriverIO: "1"
 
     steps:
       - name: Checkout code

.github/workflows/stress-tests.yml

@@ -17,6 +17,8 @@ jobs:
         os: [ ubuntu-latest ]
 
     timeout-minutes: 70 # Allow some buffer time beyond the 1-hour test duration
+    env:
+      DisableRealDriverIO: "1"
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -58,6 +60,8 @@ jobs:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
 
     timeout-minutes: 90
+    env:
+      DisableRealDriverIO: "1"
     steps:
       - name: Checkout code
         uses: actions/checkout@v4

.github/workflows/unit-tests.yml

@@ -20,6 +20,8 @@ jobs:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
 
     timeout-minutes: 15
+    env:
+      DisableRealDriverIO: "1"
     steps:
 
     - name: Checkout code
@@ -76,6 +78,8 @@ jobs:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
 
     timeout-minutes: 60
+    env:
+      DisableRealDriverIO: "1"
     steps:
 
     - name: Checkout code

Terminal.Gui/App/MainLoop/MainLoopCoordinator.cs

@@ -180,6 +180,34 @@ private void BuildDriverIfPossible (IApplication? app)
             }
         }
 
+        try
+        {
+            KittyKeyboardProtocolDetector kittyKeyboardDetector = new (_driver);
+            kittyKeyboardDetector.Detect (result =>
+                                         {
+                                             _driver.SetKittyKeyboardProtocol (result);
+                                             Trace.Lifecycle (app?.MainThreadId?.ToString (),
+                                                              "KittyKeyboard",
+                                                              $"Probe complete: Supported={result.IsSupported}, SupportedFlags={result.SupportedFlags}, EnabledFlags={result.EnabledFlags}");
+
+                                             if (!result.IsSupported || result.EnabledFlags <= 0 || _output is not AnsiOutput ansiOutput)
+                                             {
+                                                 Trace.Lifecycle (app?.MainThreadId?.ToString (), "KittyKeyboard", "Kitty keyboard mode not enabled");
+                                                 return;
+                                             }
+
+                                             ansiOutput.EnableKittyKeyboard (result.EnabledFlags);
+                                             _driver.SetKittyKeyboardEnabledFlags (ansiOutput.KittyKeyboardEnabledFlags);
+                                             Trace.Lifecycle (app?.MainThreadId?.ToString (),
+                                                              "KittyKeyboard",
+                                                              $"Enabled kitty keyboard flags {ansiOutput.KittyKeyboardEnabledFlags}");
+                                         });
+        }
+        catch (Exception ex)
+        {
+            Logging.Warning ($"Kitty keyboard protocol detection failed: {ex.Message}");
+        }
+
         _startupSemaphore.Release ();
         Logging.Trace ($"app: {app.MainThreadId} Driver: _input: {_input}, _output: {_output}");
     }

Terminal.Gui/Drivers/AnsiDriver/AnsiInput.cs

@@ -88,9 +88,9 @@ public AnsiInput ()
         try
         {
             // Check if we have a real console first
-            if (!AnsiTerminalHelper.IsAttachedToTerminal (out bool inputAttached, out bool outputAttached))
+            if (!IsAttachedToTerminal)
             {
-                Trace.Lifecycle (nameof (AnsiInput), "Init", $"Console redirected (Output: {outputAttached}, Input: {inputAttached}). Running in degraded mode.");
+                Trace.Lifecycle (nameof (AnsiInput), "Init", $"Console is not attached to a terminal. Running in degraded mode.");
 
                 return;
             }
@@ -105,7 +105,9 @@ public AnsiInput ()
                     _windowsVTInput.Dispose ();
                     _windowsVTInput = null;
 
-                    Trace.Lifecycle (nameof (AnsiInput), "Init", "Failed to enable Windows VT Input mode. Terminal input will not work. Running in degraded mode.");
+                    Trace.Lifecycle (nameof (AnsiInput),
+                                     "Init",
+                                     "Failed to enable Windows VT Input mode. Terminal input will not work. Running in degraded mode.");
 
                     return;
                 }
@@ -121,7 +123,9 @@ public AnsiInput ()
 
                     if (!_unixRawMode.TryEnable ())
                     {
-                        Trace.Lifecycle (nameof (AnsiInput), "Init", "Failed to enable Unix raw input mode. Terminal input will not work. Running in degraded mode.");
+                        Trace.Lifecycle (nameof (AnsiInput),
+                                         "Init",
+                                         "Failed to enable Unix raw input mode. Terminal input will not work. Running in degraded mode.");
                         _pollMap = null;
                         _unixRawMode?.Dispose ();
                         _unixRawMode = null;
@@ -132,7 +136,9 @@ public AnsiInput ()
                 }
                 catch (DllNotFoundException ex)
                 {
-                    Trace.Lifecycle (nameof (AnsiInput), "Init", $"Failed to enable Unix raw input mode. libc not available: {ex.Message}. Running in degraded mode.");
+                    Trace.Lifecycle (nameof (AnsiInput),
+                                     "Init",
+                                     $"Failed to enable Unix raw input mode. libc not available: {ex.Message}. Running in degraded mode.");
                 }
             }
             else
@@ -147,7 +153,9 @@ public AnsiInput ()
         }
         catch (Exception ex)
         {
-            Trace.Lifecycle (nameof (AnsiInput), "Init", $"Failed to initialize terminal: {ex.GetType ().Name}: {ex.Message}. Running in degraded mode. Stack trace: {ex.StackTrace}");
+            Trace.Lifecycle (nameof (AnsiInput),
+                             "Init",
+                             $"Failed to initialize terminal: {ex.GetType ().Name}: {ex.Message}. Running in degraded mode. Stack trace: {ex.StackTrace}");
             _platform = AnsiPlatform.Degraded;
         }
     }

Terminal.Gui/Drivers/AnsiDriver/AnsiOutput.cs

@@ -41,6 +41,7 @@ public class AnsiOutput : OutputBase, IOutput
 
     private Size _consoleSize = new (80, 25);
     private IOutputBuffer? _lastBuffer;
+    private int _kittyKeyboardEnabledFlags;
 
     private readonly WindowsVTOutputHelper? _windowsVTOutput;
 
@@ -61,9 +62,9 @@ public AnsiOutput ()
         try
         {
             // Check if we have a real console first
-            if (!AnsiTerminalHelper.IsAttachedToTerminal (out bool inputAttached, out bool outputAttached))
+            if (!IsAttachedToTerminal)
             {
-                Trace.Lifecycle (nameof (AnsiOutput), "Init", $"Console redirected (Output: {outputAttached}, Input: {inputAttached}). Running in degraded mode.");
+                Trace.Lifecycle (nameof (AnsiOutput), "Init", "No real terminal attached. Running in degraded mode.");
 
                 return;
             }
@@ -78,7 +79,9 @@ public AnsiOutput ()
                     _windowsVTOutput.Dispose ();
                     _windowsVTOutput = null;
 
-                    Trace.Lifecycle (nameof (AnsiOutput), "Init", "Failed to enable Windows VT Input mode. Terminal input will not work. Running in degraded mode.");
+                    Trace.Lifecycle (nameof (AnsiOutput),
+                                     "Init",
+                                     "Failed to enable Windows VT Input mode. Terminal input will not work. Running in degraded mode.");
 
                     return;
                 }
@@ -178,14 +181,16 @@ protected override void Write (StringBuilder output)
     /// <inheritdoc/>
     public void Write (ReadOnlySpan<char> text)
     {
+        StringBuilder capturedOutput = new ();
+        capturedOutput.Append (text);
+        base.Write (capturedOutput);
+
         try
         {
             switch (_platform)
             {
                 case AnsiPlatform.WindowsVT:
-                    StringBuilder sb = new ();
-                    sb.Append (text);
-                    _windowsVTOutput!.Write (sb);
+                    _windowsVTOutput!.Write (capturedOutput);
 
                     break;
 
@@ -208,6 +213,42 @@ public void Write (ReadOnlySpan<char> text)
         }
     }
 
+    /// <summary>
+    ///     Gets the kitty keyboard flags currently enabled on the terminal.
+    /// </summary>
+    internal int KittyKeyboardEnabledFlags => _kittyKeyboardEnabledFlags;
+
+    /// <summary>
+    ///     Enables kitty keyboard progressive enhancement flags for the active terminal.
+    /// </summary>
+    /// <param name="flags">The kitty keyboard flags to enable.</param>
+    internal void EnableKittyKeyboard (int flags)
+    {
+        if (flags <= 0)
+        {
+            return;
+        }
+
+        Trace.Lifecycle (nameof (AnsiOutput), "KittyKeyboard", $"Writing enable sequence for flags {flags}");
+        Write (EscSeqUtils.CSI_EnableKittyKeyboardFlags (flags));
+        _kittyKeyboardEnabledFlags = flags;
+    }
+
+    /// <summary>
+    ///     Restores the previous kitty keyboard flag state if kitty mode was enabled.
+    /// </summary>
+    internal void DisableKittyKeyboard ()
+    {
+        if (_kittyKeyboardEnabledFlags <= 0)
+        {
+            return;
+        }
+
+        Trace.Lifecycle (nameof (AnsiOutput), "KittyKeyboard", $"Writing disable sequence for flags {_kittyKeyboardEnabledFlags}");
+        Write (EscSeqUtils.CSI_DisableKittyKeyboardFlags);
+        _kittyKeyboardEnabledFlags = 0;
+    }
+
     /// <inheritdoc cref="IOutput.Write(IOutputBuffer)"/>
     public override void Write (IOutputBuffer buffer)
     {
@@ -310,13 +351,15 @@ public void HandleSizeQueryResponse (string? response)
     /// <inheritdoc/>
     public void Dispose ()
     {
-        if (_platform == AnsiPlatform.Degraded)
-        {
-            return;
-        }
-
         try
         {
+            DisableKittyKeyboard ();
+
+            if (_platform == AnsiPlatform.Degraded)
+            {
+                return;
+            }
+
             // Restore terminal state: disable mouse, restore buffer, show cursor
             // TODO: Move Input related CSI sequences to AnsiInput
             Write (EscSeqUtils.CSI_DisableMouseEvents);

Terminal.Gui/Drivers/AnsiDriver/AnsiTerminalHelper.cs

@@ -4,30 +4,6 @@ namespace Terminal.Gui.Drivers;
 
 internal static class AnsiTerminalHelper
 {
-    public static bool IsAttachedToTerminal (out bool inputAttached, out bool outputAttached)
-    {
-        inputAttached = outputAttached = false;
-
-        if (RuntimeInformation.IsOSPlatform (OSPlatform.Windows))
-        {
-            const int STD_INPUT_HANDLE = -10;
-            const int STD_OUTPUT_HANDLE = -11;
-            nint inH = GetStdHandle (STD_INPUT_HANDLE);
-            nint outH = GetStdHandle (STD_OUTPUT_HANDLE);
-
-            inputAttached = inH != nint.Zero && GetConsoleMode (inH, out _);
-            outputAttached = outH != nint.Zero && GetConsoleMode (outH, out _);
-
-            return inputAttached && outputAttached;
-        }
-        const int STDIN_FILENO = 0;
-        const int STDOUT_FILENO = 1;
-        inputAttached = isatty (STDIN_FILENO) == 1;
-        outputAttached = isatty (STDOUT_FILENO) == 1;
-
-        return inputAttached && outputAttached;
-    }
-
     public static void FlushNative (AnsiPlatform platform)
     {
         try
@@ -85,9 +61,6 @@ private static void FlushWindows ()
     }
 
     // Unix
-    [DllImport ("libc", SetLastError = true)]
-    private static extern int isatty (int fd);
-
     [DllImport ("libc", SetLastError = true)]
     private static extern int tcdrain (int fd);
 
@@ -98,9 +71,6 @@ private static void FlushWindows ()
     [DllImport ("kernel32.dll", SetLastError = true)]
     private static extern nint GetStdHandle (int nStdHandle);
 
-    [DllImport ("kernel32.dll")]
-    private static extern bool GetConsoleMode (nint hConsoleHandle, out uint lpMode);
-
     [DllImport ("kernel32.dll", SetLastError = true)]
     [return: MarshalAs (UnmanagedType.Bool)]
     private static extern bool FlushFileBuffers (nint hFile);

Terminal.Gui/Drivers/AnsiHandling/AnsiKeyboardParser.cs

@@ -8,6 +8,7 @@ public class AnsiKeyboardParser
     private readonly List<AnsiKeyboardParserPattern> _patterns =
     [
         new Ss3Pattern (),
+        new KittyKeyboardPattern (),
         new CsiKeyPattern (),
         new CsiCursorPattern (),
         new EscAsAltPattern { IsLastMinute = true }

Terminal.Gui/Drivers/AnsiHandling/AnsiResponseExpectation.cs

@@ -1,5 +1,3 @@
-using System.Text.RegularExpressions;
-
 namespace Terminal.Gui.Drivers;
 
 /// <summary>
@@ -26,32 +24,68 @@ public bool Matches (string? cur)
             return true;
         }
 
-        // Remove leading ESC if present to simplify parsing
         string s = cur;
 
         if (s.Length > 0 && s [0] == '\x1B')
         {
             s = s [1..];
         }
 
-        // Extract the first numeric token after '[' (e.g. "[8;..." -> "8", "[6;..." -> "6")
-        // This matches typical CSI reply formats used here.
-        Match m = Regex.Match (s, @"^\[(\d+);");
+        string? csiToken = TryGetLeadingToken (s, '[', Terminator!);
+
+        if (!string.IsNullOrEmpty (csiToken))
+        {
+            return TokenMatchesValue (csiToken, Value);
+        }
+
+        string? oscToken = TryGetLeadingToken (s, ']', Terminator!);
+
+        if (!string.IsNullOrEmpty (oscToken))
+        {
+            return TokenMatchesValue (oscToken, Value);
+        }
+
+        return s.Contains ($"[{Value};", StringComparison.Ordinal)
+               || s.Contains ($"]{Value};", StringComparison.Ordinal)
+               || s.Contains ($"[{Value}", StringComparison.Ordinal)
+               || s.Contains ($"]{Value}", StringComparison.Ordinal);
+    }
+
+    private static string? TryGetLeadingToken (string input, char prefix, string terminator)
+    {
+        if (string.IsNullOrEmpty (input) || input [0] != prefix)
+        {
+            return null;
+        }
+
+        int startIndex = 1;
+        int endIndex = input.IndexOfAny ([ ';', terminator [0] ], startIndex);
+
+        if (endIndex < 0)
+        {
+            endIndex = input.Length;
+        }
 
-        if (m.Success)
+        if (endIndex <= startIndex)
         {
-            return string.Equals (m.Groups [1].Value, Value, StringComparison.Ordinal);
+            return null;
         }
 
-        // Extract the first numeric token after ']' for OSC responses (e.g. "]10;..." -> "10", "]11;..." -> "11")
-        Match oscMatch = Regex.Match (s, @"^\](\d+);");
+        return input [startIndex..endIndex];
+    }
+
+    private static bool TokenMatchesValue (string token, string value)
+    {
+        if (string.Equals (token, value, StringComparison.Ordinal))
+        {
+            return true;
+        }
 
-        if (oscMatch.Success)
+        if (!char.IsDigit (value [0]))
         {
-            return string.Equals (oscMatch.Groups [1].Value, Value, StringComparison.Ordinal);
+            return token.StartsWith (value, StringComparison.Ordinal);
         }
 
-        // Fallback: conservative contains check (rare)
-        return s.Contains ($"[{Value};", StringComparison.Ordinal) || s.Contains ($"]{Value};", StringComparison.Ordinal);
+        return false;
     }
 }