Interrupt integrated console command prompt when commands are executed

This change fixes a general class of problems in the integrated console
experience where commands that were executed internally (like extension
commands or running Plaster templates) do not interrupt the command
prompt, causing future input to be written over previous output lines.

The fix is to have the command prompt be interrupted by any commands
which write output or errors to the host.

Fixes #411.

Author: daviwil

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -100,9 +100,6 @@ protected override void Initialize()
 
         protected Task LaunchScript(RequestContext<object> requestContext)
         {
-            // Ensure the read loop is stopped
-            this.editorSession.ConsoleService.CancelReadLoop();
-
             // Is this an untitled script?
             Task launchTask = null;
 
@@ -144,9 +141,6 @@ private async Task OnExecutionCompleted(Task executeTask)
 
             if (this.isAttachSession)
             {
-                // Ensure the read loop is stopped
-                this.editorSession.ConsoleService.CancelReadLoop();
-
                 // Pop the sessions
                 if (this.editorSession.PowerShellContext.CurrentRunspace.Context == RunspaceContext.EnteredProcess)
                 {
@@ -165,12 +159,6 @@ private async Task OnExecutionCompleted(Task executeTask)
                         Logger.WriteException("Caught exception while popping attached process after debugging", e);
                     }
                 }
-
-            }
-
-            if (!this.ownsEditorSession)
-            {
-                this.editorSession.ConsoleService.StartReadLoop();
             }
 
             if (this.disconnectRequestContext != null)

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -1108,9 +1108,6 @@ protected Task HandleEvaluateRequest(
             DebugAdapterMessages.EvaluateRequestArguments evaluateParams,
             RequestContext<DebugAdapterMessages.EvaluateResponseBody> requestContext)
         {
-            // Cancel the read loop before executing
-            this.editorSession.ConsoleService.CancelReadLoop();
-
             // We don't await the result of the execution here because we want
             // to be able to receive further messages while the current script
             // is executing.  This important in cases where the pipeline thread

src/PowerShellEditorServices/Console/ConsoleService.cs

@@ -79,6 +79,7 @@ public ConsoleService(
             this.powerShellContext.ConsoleHost = this;
             this.powerShellContext.DebuggerStop += PowerShellContext_DebuggerStop;
             this.powerShellContext.DebuggerResumed += PowerShellContext_DebuggerResumed;
+            this.powerShellContext.ExecutionStatusChanged += PowerShellContext_ExecutionStatusChanged;
 
             // Set the default prompt handler factory or create
             // a default if one is not provided
@@ -140,31 +141,6 @@ public void CancelReadLoop()
             }
         }
 
-        /// <summary>
-        /// Called when a command string is received from the user.
-        /// If a prompt is currently active, the prompt handler is
-        /// asked to handle the string.  Otherwise the string is
-        /// executed in the PowerShellContext.
-        /// </summary>
-        /// <param name="inputString">The input string to evaluate.</param>
-        /// <param name="echoToConsole">If true, the input will be echoed to the console.</param>
-        public void ExecuteCommand(string inputString, bool echoToConsole)
-        {
-            this.CancelReadLoop();
-
-            if (this.activePromptHandler == null)
-            {
-                // Execute the script string but don't wait for completion
-                var executeTask =
-                    this.powerShellContext
-                        .ExecuteScriptString(
-                            inputString,
-                            echoToConsole,
-                            true)
-                        .ConfigureAwait(false);
-            }
-        }
-
         /// <summary>
         /// Executes a script file at the specified path.
         /// </summary>
@@ -338,11 +314,16 @@ await this.consoleReadLine.ReadCommandLine(
                 {
                     Console.Write(Environment.NewLine);
 
-                    await this.powerShellContext.ExecuteScriptString(
-                        commandString,
-                        false,
-                        true,
-                        true);
+                    var unusedTask =
+                        this.powerShellContext
+                            .ExecuteScriptString(
+                                commandString,
+                                false,
+                                true,
+                                true)
+                            .ConfigureAwait(false);
+
+                    break;
                 }
             }
             while (!cancellationToken.IsCancellationRequested);
@@ -459,6 +440,37 @@ private void PowerShellContext_DebuggerResumed(object sender, System.Management.
             this.CancelReadLoop();
         }
 
+        private void PowerShellContext_ExecutionStatusChanged(object sender, ExecutionStatusChangedEventArgs eventArgs)
+        {
+            if (this.EnableConsoleRepl)
+            {
+                // Any command which writes output to the host will affect
+                // the display of the prompt
+                if (eventArgs.ExecutionOptions.WriteOutputToHost ||
+                    eventArgs.ExecutionOptions.InterruptCommandPrompt)
+                {
+                    if (eventArgs.ExecutionStatus != ExecutionStatus.Running)
+                    {
+                        // Execution has completed, start the input prompt
+                        this.StartReadLoop();
+                    }
+                    else
+                    {
+                        // A new command was started, cancel the input prompt
+                        this.CancelReadLoop();
+                    }
+                }
+                else if (
+                    eventArgs.ExecutionOptions.WriteErrorsToHost &&
+                    (eventArgs.ExecutionStatus == ExecutionStatus.Failed ||
+                     eventArgs.HadErrors))
+                {
+                    this.CancelReadLoop();
+                    this.StartReadLoop();
+                }
+            }
+        }
+
         #endregion
     }
 }

src/PowerShellEditorServices/Session/ExecutionOptions.cs

@@ -0,0 +1,59 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.PowerShell.EditorServices
+{
+    /// <summary>
+    /// Defines options for the execution of a command.
+    /// </summary>
+    public class ExecutionOptions
+    {
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets a boolean that determines whether command output
+        /// should be written to the host.
+        /// </summary>
+        public bool WriteOutputToHost { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean that determines whether command errors
+        /// should be written to the host.
+        /// </summary>
+        public bool WriteErrorsToHost { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean that determines whether the executed
+        /// command should be added to the command history.
+        /// </summary>
+        public bool AddToHistory { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean that determines whether the execution
+        /// of the command should interrupt the command prompt.  Should
+        /// only be set if WriteOutputToHost is false but the command
+        /// should still interrupt the command prompt.
+        /// </summary>
+        public bool InterruptCommandPrompt { get; set; }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates an instance of the ExecutionOptions class with
+        /// default settings configured.
+        /// </summary>
+        public ExecutionOptions()
+        {
+            this.WriteOutputToHost = true;
+            this.WriteErrorsToHost = true;
+            this.AddToHistory = false;
+            this.InterruptCommandPrompt = false;
+        }
+
+        #endregion
+    }
+}

src/PowerShellEditorServices/Session/ExecutionStatus.cs

@@ -0,0 +1,39 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.PowerShell.EditorServices
+{
+    /// <summary>
+    /// Enumerates the possible execution results that can occur after
+    /// executing a command or script.
+    /// </summary>
+    public enum ExecutionStatus
+    {
+        /// <summary>
+        /// Indicates that execution has not yet started.
+        /// </summary>
+        Pending,
+
+        /// <summary>
+        /// Indicates that the command is executing.
+        /// </summary>
+        Running,
+
+        /// <summary>
+        /// Indicates that execution has failed.
+        /// </summary>
+        Failed,
+
+        /// <summary>
+        /// Indicates that execution was aborted by the user.
+        /// </summary>
+        Aborted,
+
+        /// <summary>
+        /// Indicates that execution completed successfully.
+        /// </summary>
+        Completed
+    }
+}

src/PowerShellEditorServices/Session/ExecutionStatusChangedEventArgs.cs

@@ -0,0 +1,52 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.PowerShell.EditorServices
+{
+    /// <summary>
+    /// Contains details about an executed 
+    /// </summary>
+    public class ExecutionStatusChangedEventArgs
+    {
+        #region Properties
+
+        /// <summary>
+        /// Gets the options used when the command was executed.
+        /// </summary>
+        public ExecutionOptions ExecutionOptions { get; private set; }
+
+        /// <summary>
+        /// Gets the command execution's current status.
+        /// </summary>
+        public ExecutionStatus ExecutionStatus { get; private set; }
+
+        /// <summary>
+        /// If true, the command execution had errors.
+        /// </summary>
+        public bool HadErrors { get; private set; }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates an instance of the ExecutionStatusChangedEventArgs class.
+        /// </summary>
+        /// <param name="executionStatus">The command execution's current status.</param>
+        /// <param name="executionOptions">The options used when the command was executed.</param>
+        /// <param name="hadErrors">If execution has completed, indicates whether there were errors.</param>
+        public ExecutionStatusChangedEventArgs(
+            ExecutionStatus executionStatus,
+            ExecutionOptions executionOptions,
+            bool hadErrors)
+        {
+            this.ExecutionStatus = executionStatus;
+            this.ExecutionOptions = executionOptions;
+            this.HadErrors = hadErrors || (executionStatus == ExecutionStatus.Failed);
+        }
+
+        #endregion
+    }
+}