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

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

@@ -81,8 +81,6 @@ public class AnsiInput : InputImpl<char>, ITestableInput<char>
     /// </summary>
     public AnsiInput ()
     {
-        //Logging.Information ($"Creating {nameof (AnsiInput)}");
-
         _platform = AnsiPlatform.Degraded;
 
         try
@@ -226,8 +224,6 @@ public override IEnumerable<char> Read ()
 
             case AnsiPlatform.Degraded:
             default:
-                // Logging.Trace ("IsVTModeEnabled is NOT enabled");
-
                 yield break;
         }
     }
@@ -305,8 +301,6 @@ private void FlushInput ()
                     // can cause ReadFile to block indefinitely.
                     if (_pollMap == null)
                     {
-                        //Logging.Trace ("");
-
                         return;
                     }
 
@@ -364,12 +358,9 @@ private void FlushInput ()
         }
     }
 
+    // Will be called on the main loop thread.
     /// <inheritdoc/>
-    public void InjectInput (char input) =>
-
-        //Logging.Trace ($"Enqueuing input: {input.Key}");
-        // Will be called on the main loop thread.
-        _testInput.Enqueue (input);
+    public void InjectInput (char input) => _testInput.Enqueue (input);
 
     /// <inheritdoc/>
     public override void Dispose ()

Terminal.Gui/Drivers/AnsiDriver/AnsiOutput.cs

@@ -50,8 +50,6 @@ public class AnsiOutput : OutputBase, IOutput
     /// </summary>
     public AnsiOutput ()
     {
-        // Logging.Information ($"Creating {nameof (AnsiOutput)}");
-
         _platform = AnsiPlatform.Degraded;
 
         _lastBuffer = new OutputBufferImpl ();
@@ -171,8 +169,6 @@ protected override void Write (StringBuilder output)
         }
         catch (Exception)
         {
-            //Logging.Warning (e.Message);
-
             // ignore for unit tests
         }
     }
@@ -206,12 +202,46 @@ public void Write (ReadOnlySpan<char> text)
         }
         catch (Exception)
         {
-            //Logging.Warning (e.Message);
-
             // ignore for unit tests
         }
     }
 
+    /// <summary>
+    ///     Gets the kitty keyboard flags currently enabled on the terminal.
+    /// </summary>
+    internal int KittyKeyboardEnabledFlags { get; private set; }
+
+    /// <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 || _platform == AnsiPlatform.Degraded)
+        {
+            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)
     {
@@ -316,6 +346,8 @@ public void Dispose ()
     {
         try
         {
+            DisableKittyKeyboard ();
+
             if (_platform == AnsiPlatform.Degraded)
             {
                 return;
@@ -333,7 +365,7 @@ public void Dispose ()
         }
         finally
         {
-            //Logging.Trace ("Flushing and closing.");
+            Trace.Lifecycle (nameof (AnsiOutput), "Dispose", "Flushing output and releasing resources.");
 
             _windowsVTOutput?.Dispose ();
         }

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;
     }
 }

Terminal.Gui/Drivers/AnsiHandling/EscSeqUtils/EscSeqUtils.cs

@@ -894,6 +894,34 @@ internal static void CSI_AppendTextStyleChange (StringBuilder output, TextStyle
     /// </summary>
     public static readonly AnsiEscapeSequence CSI_RequestCursorPositionReport = new () { Request = CSI + "?6n", Terminator = "R" };
 
+    /// <summary>
+    ///     ESC [ ? u - Query kitty keyboard progressive enhancement flags.
+    ///     The terminal reply to <see cref="CSI_QueryKittyKeyboardFlags"/> is ESC [ ? flags u.
+    /// </summary>
+    public static readonly AnsiEscapeSequence CSI_QueryKittyKeyboardFlags = new () { Request = CSI + "?u", Terminator = "u", Value = "?" };
+
+    /// <summary>
+    ///     Phase 1 enables only kitty's disambiguate escape codes flag.
+    /// </summary>
+    public const int KittyKeyboardDisambiguateEscapeCodes = 1;
+
+    /// <summary>
+    ///     The kitty keyboard flags enabled during phase 1.
+    /// </summary>
+    public const int KittyKeyboardPhase1Flags = KittyKeyboardDisambiguateEscapeCodes;
+
+    /// <summary>
+    ///     ESC [ &gt; flags u - Push current kitty keyboard flags and enable the specified flags.
+    /// </summary>
+    /// <param name="flags">The kitty keyboard progressive enhancement flags to enable.</param>
+    /// <returns>The ANSI request string.</returns>
+    public static string CSI_EnableKittyKeyboardFlags (int flags) => $"{CSI}>{flags}u";
+
+    /// <summary>
+    ///     ESC [ &lt; u - Restore the previously pushed kitty keyboard flag state.
+    /// </summary>
+    public static readonly string CSI_DisableKittyKeyboardFlags = CSI + "<u";
+
     /// <summary>
     ///     The terminal reply to <see cref="CSI_RequestCursorPositionReport"/>. ESC [ ? (y) ; (x) R
     /// </summary>