Add integrated console support via custom host implementation

This change enables a true integrated terminal experience for editors like
VS Code which have an embedded terminal UI.  The change centers primarily
around the new ConsoleReadLine class which provides a "good enough"
terminal editing and tab completion experience until we can find a way to
make PSReadLine work inside of our custom host.

The debugging experience has also been updated to share the language
service's runspace.  In a later change an independent debugging mode will
be added.

Author: daviwil

module/PowerShellEditorServices/PowerShellEditorServices.psm1

@@ -46,6 +46,9 @@ function Start-EditorServicesHost {
         [ValidateSet("Normal", "Verbose", "Error")]
         $LogLevel = "Normal",
 
+        [string]
+        $DebugServiceOnly,
+
         [switch]
         $WaitForDebugger
     )
@@ -67,8 +70,14 @@ function Start-EditorServicesHost {
             [System.IO.Path]::GetDirectoryName($profile.CurrentUserAllHosts));
 
         $editorServicesHost.StartLogging($LogPath, $LogLevel);
-        $editorServicesHost.StartLanguageService($LanguageServicePort, $profilePaths);
-        $editorServicesHost.StartDebugService($DebugServicePort, $profilePaths);
+
+        if ($DebugServiceOnly.IsPresent) {
+            $editorServicesHost.StartDebugService($DebugServicePort, $profilePaths, $false);
+        }
+        else {
+            $editorServicesHost.StartLanguageService($LanguageServicePort, $profilePaths);
+            $editorServicesHost.StartDebugService($DebugServicePort, $profilePaths, $true);
+        }
     }
     catch {
         Write-Error "PowerShell Editor Services host initialization failed, terminating."

src/PowerShellEditorServices.Host/EditorServicesHost.cs

@@ -158,23 +158,41 @@ public void StartLanguageService(int languageServicePort, ProfilePaths profilePa
         /// Starts the debug service with the specified TCP socket port.
         /// </summary>
         /// <param name="debugServicePort">The port number for the debug service.</param>
-        public void StartDebugService(int debugServicePort, ProfilePaths profilePaths)
+        public void StartDebugService(
+            int debugServicePort,
+            ProfilePaths profilePaths,
+            bool useExistingSession)
         {
-            this.debugAdapter =
-                new DebugAdapter(
-                    hostDetails,
-                    profilePaths,
-                    new TcpSocketServerChannel(debugServicePort),
-                    this.languageServer?.EditorOperations);
+            if (useExistingSession)
+            {
+                this.debugAdapter =
+                    new DebugAdapter(
+                        this.languageServer.EditorSession,
+                        new TcpSocketServerChannel(debugServicePort));
+            }
+            else
+            {
+                this.debugAdapter =
+                    new DebugAdapter(
+                        hostDetails,
+                        profilePaths,
+                        new TcpSocketServerChannel(debugServicePort),
+                        this.languageServer?.EditorOperations);
+            }
 
             this.debugAdapter.SessionEnded +=
                 (obj, args) =>
                 {
-                    Logger.Write(
-                        LogLevel.Normal,
-                        "Previous debug session ended, restarting debug service...");
-
-                    this.StartDebugService(debugServicePort, profilePaths);
+                    // Only restart if we're reusing the existing session,
+                    // otherwise the process should terminate
+                    if (useExistingSession)
+                    {
+                        Logger.Write(
+                            LogLevel.Normal,
+                            "Previous debug session ended, restarting debug service...");
+
+                        this.StartDebugService(debugServicePort, profilePaths, true);
+                    }
                 };
 
             this.debugAdapter.Start().Wait();

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -23,33 +23,38 @@ namespace Microsoft.PowerShell.EditorServices.Protocol.Server
     public class DebugAdapter : DebugAdapterBase
     {
         private EditorSession editorSession;
-        private OutputDebouncer outputDebouncer;
 
         private bool noDebug;
         private bool waitingForAttach;
         private string scriptToLaunch;
+        private bool ownsEditorSession;
         private string arguments;
 
         public DebugAdapter(HostDetails hostDetails, ProfilePaths profilePaths)
             : this(hostDetails, profilePaths, new StdioServerChannel(), null)
         {
         }
 
+        public DebugAdapter(EditorSession editorSession, ChannelBase serverChannel)
+            : base(serverChannel)
+        {
+            this.editorSession = editorSession;
+            this.editorSession.PowerShellContext.RunspaceChanged += this.powerShellContext_RunspaceChanged;
+            this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
+        }
+
         public DebugAdapter(
             HostDetails hostDetails,
             ProfilePaths profilePaths,
             ChannelBase serverChannel,
             IEditorOperations editorOperations)
             : base(serverChannel)
         {
+            this.ownsEditorSession = true;
             this.editorSession = new EditorSession();
             this.editorSession.StartDebugSession(hostDetails, profilePaths, editorOperations);
             this.editorSession.PowerShellContext.RunspaceChanged += this.powerShellContext_RunspaceChanged;
             this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
-            this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
-
-            // Set up the output debouncer to throttle output event writes
-            this.outputDebouncer = new OutputDebouncer(this);
         }
 
         protected override void Initialize()
@@ -88,9 +93,6 @@ protected Task LaunchScript(RequestContext<object> requestContext)
                         async (t) => {
                             Logger.Write(LogLevel.Verbose, "Execution completed, flushing output then terminating...");
 
-                            // Make sure remaining output is flushed before exiting
-                            await this.outputDebouncer.Flush();
-
                             await this.SendEvent(
                                 TerminatedEvent.Type,
                                 new TerminatedEvent());
@@ -102,14 +104,18 @@ await this.SendEvent(
 
         protected override void Shutdown()
         {
-            // Make sure remaining output is flushed before exiting
-            this.outputDebouncer.Flush().Wait();
-
             Logger.Write(LogLevel.Normal, "Debug adapter is shutting down...");
 
             if (this.editorSession != null)
             {
-                this.editorSession.Dispose();
+                this.editorSession.PowerShellContext.RunspaceChanged -= this.powerShellContext_RunspaceChanged;
+                this.editorSession.DebugService.DebuggerStopped -= this.DebugService_DebuggerStopped;
+
+                if (this.ownsEditorSession)
+                {
+                    this.editorSession.Dispose();
+                }
+
                 this.editorSession = null;
             }
         }
@@ -657,26 +663,7 @@ protected async Task HandleEvaluateRequest(
                     "repl",
                     StringComparison.CurrentCultureIgnoreCase);
 
-            if (isFromRepl)
-            {
-                // Check for special commands
-                if (string.Equals("!ctrlc", evaluateParams.Expression, StringComparison.CurrentCultureIgnoreCase))
-                {
-                    editorSession.PowerShellContext.AbortExecution();
-                }
-                else if (string.Equals("!break", evaluateParams.Expression, StringComparison.CurrentCultureIgnoreCase))
-                {
-                    editorSession.DebugService.Break();
-                }
-                else
-                {
-                    // Send the input through the console service
-                    editorSession.ConsoleService.ExecuteCommand(
-                        evaluateParams.Expression,
-                        false);
-                }
-            }
-            else
+            if (!isFromRepl)
             {
                 VariableDetails result =
                     await editorSession.DebugService.EvaluateExpression(
@@ -692,6 +679,12 @@ await editorSession.DebugService.EvaluateExpression(
                             result.Id : 0;
                 }
             }
+            else
+            {
+                Logger.Write(
+                    LogLevel.Verbose,
+                    $"Debug adapter client attempted to evaluate command in REPL: {evaluateParams.Expression}");
+            }
 
             await requestContext.SendResult(
                 new EvaluateResponseBody
@@ -707,9 +700,6 @@ await requestContext.SendResult(
 
         async void DebugService_DebuggerStopped(object sender, DebuggerStoppedEventArgs e)
         {
-            // Flush pending output before sending the event
-            await this.outputDebouncer.Flush();
-
             // Provide the reason for why the debugger has stopped script execution.
             // See https://github.com/Microsoft/vscode/issues/3648
             // The reason is displayed in the breakpoints viewlet.  Some recommended reasons are:
@@ -766,12 +756,6 @@ await this.SendEvent<ContinuedEvent>(
             }
         }
 
-        async void powerShellContext_OutputWritten(object sender, OutputWrittenEventArgs e)
-        {
-            // Queue the output for writing
-            await this.outputDebouncer.Invoke(e);
-        }
-
         #endregion
     }
 }

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -29,6 +29,7 @@ public class LanguageServer : LanguageServerBase
         private readonly static string DiagnosticSourceName = "PowerShellEditorServices";
 
         private bool profilesLoaded;
+        private bool consoleReplStarted;
         private EditorSession editorSession;
         private OutputDebouncer outputDebouncer;
         private LanguageServerEditorOperations editorOperations;
@@ -42,6 +43,11 @@ public IEditorOperations EditorOperations
             get { return this.editorOperations; }
         }
 
+        public EditorSession EditorSession
+        {
+            get { return this.editorSession; }
+        }
+
         /// <param name="hostDetails">
         /// Provides details about the host application.
         /// </param>
@@ -58,7 +64,7 @@ public LanguageServer(HostDetails hostDetails, ProfilePaths profilePaths, Channe
         {
             this.editorSession = new EditorSession();
             this.editorSession.StartSession(hostDetails, profilePaths);
-            this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
+            //this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
             this.editorSession.PowerShellContext.RunspaceChanged += PowerShellContext_RunspaceChanged;
 
             // Attach to ExtensionService events
@@ -137,6 +143,9 @@ protected override void Initialize()
 
         protected override async Task Shutdown()
         {
+            // Stop the interactive terminal
+            this.editorSession.ConsoleService.StopInteractiveConsole();
+
             // Make sure remaining output is flushed before exiting
             await this.outputDebouncer.Flush();
 
@@ -546,6 +555,15 @@ protected async Task HandleDidChangeConfigurationNotification(
                 this.profilesLoaded = true;
             }
 
+            // Wait until after profiles are loaded (or not, if that's the
+            // case) before starting the interactive console.
+            if (!this.consoleReplStarted)
+            {
+                // Start the interactive terminal
+                this.editorSession.ConsoleService.StartReadLoop();
+                this.consoleReplStarted = true;
+            }
+
             // If there is a new settings file path, restart the analyzer with the new settigs.
             bool settingsPathChanged = false;
             string newSettingsPath = this.currentSettings.ScriptAnalysis.SettingsPath;