"Cancel" Console.ReadKey() via sendKeyPress() notification to client

This "rewrite" uses the `console.sendText()` API in VS Code to respond
to a notification and send a fake key press, allowing us to "cancel"
`ReadKey` by getting it to return. Since we know we requested the
cancellation, we just drop the fake key press. This means we no longer
have to poll on macOS/Linux, and no longer have the ghost "double
key-press" issue on Windows. This fixes a myriad of problems and opens
up a lot of simplification.

Author: andyleejordan

src/PowerShellEditorServices/Services/PowerShell/Console/ConsoleProxy.cs

@@ -4,16 +4,23 @@
 using System;
 using System.Runtime.InteropServices;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console
 {
     /// <summary>
     /// Provides asynchronous implementations of the <see cref="Console" /> API's as well as
     /// synchronous implementations that work around platform specific issues.
+    /// NOTE: We're missing GetCursorPosition.
     /// </summary>
     internal static class ConsoleProxy
     {
+        internal static readonly ConsoleKeyInfo s_nullKeyInfo = new(
+            keyChar: ' ',
+            ConsoleKey.DownArrow,
+            shift: false,
+            alt: false,
+            control: false);
+
         private static readonly IConsoleOperations s_consoleProxy;
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1810:Initialize reference type static fields inline", Justification = "Platform specific initialization")]
@@ -100,12 +107,7 @@ internal static ConsoleKeyInfo SafeReadKey(bool intercept, CancellationToken can
             }
             catch (OperationCanceledException)
             {
-                return new ConsoleKeyInfo(
-                    keyChar: ' ',
-                    ConsoleKey.DownArrow,
-                    shift: false,
-                    alt: false,
-                    control: false);
+                return s_nullKeyInfo;
             }
         }
     }

src/PowerShellEditorServices/Services/PowerShell/Console/LegacyReadLine.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Utility;
 using System.Collections.Generic;

src/PowerShellEditorServices/Services/PowerShell/Console/UnixConsoleOperations.cs

@@ -9,55 +9,25 @@ namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console
 {
     internal class UnixConsoleOperations : IConsoleOperations
     {
-        private const int LongWaitForKeySleepTime = 300;
-
-        private const int ShortWaitForKeyTimeout = 5000;
-
-        private const int ShortWaitForKeySpinUntilSleepTime = 30;
-
-        private static readonly ManualResetEventSlim s_waitHandle = new();
-
         private static readonly SemaphoreSlim s_readKeyHandle = AsyncUtils.CreateSimpleLockingSemaphore();
 
         private static readonly SemaphoreSlim s_stdInHandle = AsyncUtils.CreateSimpleLockingSemaphore();
 
-        private Func<CancellationToken, bool> WaitForKeyAvailable;
-
-        /// <summary>
-        /// Switch between long and short wait periods depending on if the user has recently (last 5
-        /// seconds) pressed a key to avoid preventing the CPU from entering low power mode.
-        /// </summary>
-        internal UnixConsoleOperations() => WaitForKeyAvailable = LongWaitForKey;
-
         public ConsoleKeyInfo ReadKey(bool intercept, CancellationToken cancellationToken)
         {
-            s_readKeyHandle.Wait(cancellationToken);
-
-            // On Unix platforms System.Console.ReadKey has an internal lock on stdin.  Because
-            // of this, if a ReadKey call is pending in one thread and in another thread
-            // Console.CursorLeft is called, both threads block until a key is pressed.
-            try
-            {
-                // The WaitForKeyAvailable delegate switches between a long delay between waits and
-                // a short timeout depending on how recently a key has been pressed. This allows us
-                // to let the CPU enter low power mode without compromising responsiveness.
-                while (!WaitForKeyAvailable(cancellationToken)) { }
-            }
-            finally
-            {
-                s_readKeyHandle.Release();
-            }
-
             // A key has been pressed, so acquire a lock on our internal stdin handle. This is done
             // so any of our calls to cursor position API's do not release ReadKey.
             s_stdInHandle.Wait(cancellationToken);
+            s_readKeyHandle.Wait(cancellationToken);
             try
             {
                 return System.Console.ReadKey(intercept);
             }
             finally
             {
+                s_readKeyHandle.Release();
                 s_stdInHandle.Release();
+                cancellationToken.ThrowIfCancellationRequested();
             }
         }
 
@@ -90,60 +60,5 @@ public int GetCursorTop(CancellationToken cancellationToken)
                 s_stdInHandle.Release();
             }
         }
-
-        private bool LongWaitForKey(CancellationToken cancellationToken)
-        {
-            // Wait for a key to be buffered (in other words, wait for Console.KeyAvailable to become
-            // true) with a long delay between checks.
-            while (!IsKeyAvailable(cancellationToken))
-            {
-                s_waitHandle.Wait(LongWaitForKeySleepTime, cancellationToken);
-            }
-
-            // As soon as a key is buffered, return true and switch the wait logic to be more
-            // responsive, but also more expensive.
-            WaitForKeyAvailable = ShortWaitForKey;
-            return true;
-        }
-
-        private bool ShortWaitForKey(CancellationToken cancellationToken)
-        {
-            // Check frequently for a new key to be buffered.
-            if (SpinUntilKeyAvailable(ShortWaitForKeyTimeout, cancellationToken))
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-                return true;
-            }
-
-            // If the user has not pressed a key before the end of the SpinUntil timeout then
-            // the user is idle and we can switch back to long delays between KeyAvailable checks.
-            cancellationToken.ThrowIfCancellationRequested();
-            WaitForKeyAvailable = LongWaitForKey;
-            return false;
-        }
-
-        private static bool SpinUntilKeyAvailable(int millisecondsTimeout, CancellationToken cancellationToken)
-        {
-            return SpinWait.SpinUntil(
-                () =>
-                {
-                    s_waitHandle.Wait(ShortWaitForKeySpinUntilSleepTime, cancellationToken);
-                    return IsKeyAvailable(cancellationToken);
-                },
-                millisecondsTimeout);
-        }
-
-        private static bool IsKeyAvailable(CancellationToken cancellationToken)
-        {
-            s_stdInHandle.Wait(cancellationToken);
-            try
-            {
-                return System.Console.KeyAvailable;
-            }
-            finally
-            {
-                s_stdInHandle.Release();
-            }
-        }
     }
 }

src/PowerShellEditorServices/Services/PowerShell/Host/EditorServicesConsolePSHostUserInterface.cs

@@ -48,9 +48,9 @@ public EditorServicesConsolePSHostUserInterface(
 
         public override PSCredential PromptForCredential(string caption, string message, string userName, string targetName) => _underlyingHostUI.PromptForCredential(caption, message, userName, targetName);
 
-        public override string ReadLine() => _readLineProvider.ReadLine.ReadLine(CancellationToken.None);
+        public override string ReadLine() => _underlyingHostUI.ReadLine();
 
-        public override SecureString ReadLineAsSecureString() => _readLineProvider.ReadLine.ReadSecureLine(CancellationToken.None);
+        public override SecureString ReadLineAsSecureString() => _underlyingHostUI.ReadLineAsSecureString();
 
         public override void Write(ConsoleColor foregroundColor, ConsoleColor backgroundColor, string value) => _underlyingHostUI.Write(foregroundColor, backgroundColor, value);
 

src/PowerShellEditorServices/Services/PowerShell/Host/PsesInternalHost.cs

@@ -73,6 +73,8 @@ internal class PsesInternalHost : PSHost, IHostSupportsInteractiveSession, IRuns
 
         private bool _skipNextPrompt;
 
+        private CancellationToken _readKeyCancellationToken;
+
         private bool _resettingRunspace;
 
         public PsesInternalHost(
@@ -690,7 +692,18 @@ public void WriteWithPrompt(PSCommand command, CancellationToken cancellationTok
             UI.WriteLine(command.GetInvocationText());
         }
 
-        private string InvokeReadLine(CancellationToken cancellationToken) => _readLineProvider.ReadLine.ReadLine(cancellationToken);
+        private string InvokeReadLine(CancellationToken cancellationToken)
+        {
+            try
+            {
+                _readKeyCancellationToken = cancellationToken;
+                return _readLineProvider.ReadLine.ReadLine(cancellationToken);
+            }
+            finally
+            {
+                _readKeyCancellationToken = CancellationToken.None;
+            }
+        }
 
         private void InvokeInput(string input, CancellationToken cancellationToken)
         {
@@ -869,7 +882,16 @@ private ConsoleKeyInfo ReadKey(bool intercept)
             // This isn't functionally required,
             // but helps us determine when the prompt needs a newline added
 
-            _lastKey = ConsoleProxy.SafeReadKey(intercept, CancellationToken.None);
+            // NOTE: This requests that the client (the Code extension) send a non-printing key back
+            // to the terminal on stdin, emulating a user pressing a button. This allows
+            // PSReadLine's thread waiting on Console.ReadKey to return. Normally we'd just cancel
+            // this call, but the .NET API ReadKey is not cancellable, and is stuck until we send
+            // input. This leads to a myriad of problems, but we circumvent them by pretending to
+            // press a key.
+            using CancellationTokenRegistration registration = _readKeyCancellationToken.Register(
+                () => _languageServer?.SendNotification("powerShell/sendKeyPress")
+            );
+            _lastKey = ConsoleProxy.SafeReadKey(intercept, _readKeyCancellationToken);
             return _lastKey.Value;
         }