Reintroduce simple host interface to fix existing tests

This change reintroduces the old host interface so that we can maintain
our current functional tests until we find a good way to test the new
terminal-based UI.  This also enables consumers of the old host protocol
(like Xamarin Studio) to continue using it.

Author: daviwil

module/PowerShellEditorServices/PowerShellEditorServices.psm1

@@ -46,6 +46,9 @@ function Start-EditorServicesHost {
         [ValidateSet("Normal", "Verbose", "Error")]
         $LogLevel = "Normal",
 
+        [switch]
+        $EnableConsoleRepl,
+
         [string]
         $DebugServiceOnly,
 
@@ -61,6 +64,7 @@ function Start-EditorServicesHost {
             New-Object Microsoft.PowerShell.EditorServices.Host.EditorServicesHost @(
                 $hostDetails,
                 $BundledModulesPath,
+                $EnableConsoleRepl.IsPresent,
                 $WaitForDebugger.IsPresent)
 
         # Build the profile paths using the root paths of the current $profile variable

src/PowerShellEditorServices.Host/EditorServicesHost.cs

@@ -29,6 +29,7 @@ public class EditorServicesHost
     {
         #region Private Fields
 
+        private bool enableConsoleRepl;
         private HostDetails hostDetails;
         private string bundledModulesPath;
         private DebugAdapter debugAdapter;
@@ -58,11 +59,13 @@ public class EditorServicesHost
         public EditorServicesHost(
             HostDetails hostDetails,
             string bundledModulesPath,
+            bool enableConsoleRepl,
             bool waitForDebugger)
         {
             Validate.IsNotNull(nameof(hostDetails), hostDetails);
 
             this.hostDetails = hostDetails;
+            this.enableConsoleRepl = enableConsoleRepl;
             this.bundledModulesPath = bundledModulesPath;
 
 #if DEBUG
@@ -143,6 +146,7 @@ public void StartLanguageService(int languageServicePort, ProfilePaths profilePa
                 new LanguageServer(
                     hostDetails,
                     profilePaths,
+                    this.enableConsoleRepl,
                     new TcpSocketServerChannel(languageServicePort));
 
             this.languageServer.Start().Wait();
@@ -163,7 +167,7 @@ public void StartDebugService(
             ProfilePaths profilePaths,
             bool useExistingSession)
         {
-            if (useExistingSession)
+            if (this.enableConsoleRepl && useExistingSession)
             {
                 this.debugAdapter =
                     new DebugAdapter(
@@ -183,8 +187,9 @@ public void StartDebugService(
             this.debugAdapter.SessionEnded +=
                 (obj, args) =>
                 {
-                    // Only restart if we're reusing the existing session,
-                    // otherwise the process should terminate
+                    // Only restart if we're reusing the existing session
+                    // or if we're not using the console REPL, otherwise
+                    // the process should terminate
                     if (useExistingSession)
                     {
                         Logger.Write(
@@ -193,6 +198,10 @@ public void StartDebugService(
 
                         this.StartDebugService(debugServicePort, profilePaths, true);
                     }
+                    else if (!this.enableConsoleRepl)
+                    {
+                        this.StartDebugService(debugServicePort, profilePaths, false);
+                    }
                 };
 
             this.debugAdapter.Start().Wait();
@@ -240,7 +249,7 @@ public void WaitForCompletion()
 
 #if !CoreCLR
         static void CurrentDomain_UnhandledException(
-            object sender, 
+            object sender,
             UnhandledExceptionEventArgs e)
         {
             // Log the exception

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -23,6 +23,7 @@ namespace Microsoft.PowerShell.EditorServices.Protocol.Server
     public class DebugAdapter : DebugAdapterBase
     {
         private EditorSession editorSession;
+        private OutputDebouncer outputDebouncer;
 
         private bool noDebug;
         private bool isRemoteAttach;
@@ -59,7 +60,12 @@ public DebugAdapter(
             this.editorSession.StartDebugSession(hostDetails, profilePaths, editorOperations);
             this.editorSession.PowerShellContext.RunspaceChanged += this.powerShellContext_RunspaceChanged;
             this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
-        }
+
+            // The assumption in this overload is that the debugger
+            // is running in UI-hosted mode, no terminal interface
+            this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
+            this.outputDebouncer = new OutputDebouncer(this);
+       }
 
         protected override void Initialize()
         {
@@ -103,6 +109,12 @@ private async Task OnExecutionCompleted(Task executeTask)
 
             this.executionCompleted = true;
 
+            // Make sure remaining output is flushed before exiting
+            if (this.outputDebouncer != null)
+            {
+                await this.outputDebouncer.Flush();
+            }
+
             if (this.isAttachSession)
             {
                 // Ensure the read loop is stopped
@@ -151,6 +163,12 @@ protected override void Shutdown()
         {
             Logger.Write(LogLevel.Normal, "Debug adapter is shutting down...");
 
+            // Make sure remaining output is flushed before exiting
+            if (this.outputDebouncer != null)
+            {
+                this.outputDebouncer.Flush().Wait();
+            }
+
             if (this.editorSession != null)
             {
                 this.editorSession.PowerShellContext.RunspaceChanged -= this.powerShellContext_RunspaceChanged;
@@ -195,8 +213,8 @@ protected async Task HandleLaunchRequest(
             LaunchRequestArguments launchParams,
             RequestContext<object> requestContext)
         {
-            // Set the working directory for the PowerShell runspace to the cwd passed in via launch.json. 
-            // In case that is null, use the the folder of the script to be executed.  If the resulting 
+            // Set the working directory for the PowerShell runspace to the cwd passed in via launch.json.
+            // In case that is null, use the the folder of the script to be executed.  If the resulting
             // working dir path is a file path then extract the directory and use that.
             string workingDir =
                 launchParams.Cwd ??
@@ -289,7 +307,7 @@ protected async Task HandleAttachRequest(
 
             // If there are no host processes to attach to or the user cancels selection, we get a null for the process id.
             // This is not an error, just a request to stop the original "attach to" request.
-            // Testing against "undefined" is a HACK because I don't know how to make "Cancel" on quick pick loading 
+            // Testing against "undefined" is a HACK because I don't know how to make "Cancel" on quick pick loading
             // to cancel on the VSCode side without sending an attachRequest with processId set to "undefined".
             if (string.IsNullOrEmpty(attachParams.ProcessId) || (attachParams.ProcessId == "undefined"))
             {
@@ -427,7 +445,7 @@ protected async Task HandleSetBreakpointsRequest(
             catch (Exception e) when (e is FileNotFoundException || e is DirectoryNotFoundException)
             {
                 Logger.Write(
-                    LogLevel.Warning, 
+                    LogLevel.Warning,
                     $"Attempted to set breakpoints on a non-existing file: {setBreakpointsParams.Source.Path}");
 
                 string message = this.noDebug ? string.Empty : "Source does not exist, breakpoint not set.";
@@ -450,9 +468,9 @@ await requestContext.SendResult(
             {
                 SourceBreakpoint srcBreakpoint = setBreakpointsParams.Breakpoints[i];
                 breakpointDetails[i] = BreakpointDetails.Create(
-                    scriptFile.FilePath, 
-                    srcBreakpoint.Line, 
-                    srcBreakpoint.Column, 
+                    scriptFile.FilePath,
+                    srcBreakpoint.Line,
+                    srcBreakpoint.Column,
                     srcBreakpoint.Condition,
                     srcBreakpoint.HitCondition);
             }
@@ -604,7 +622,7 @@ protected async Task HandleStackTraceRequest(
                 // be referenced back to the current list of stack frames
                 newStackFrames.Add(
                     StackFrame.Create(
-                        stackFrames[i], 
+                        stackFrames[i],
                         i));
             }
 
@@ -720,13 +738,34 @@ protected async Task HandleEvaluateRequest(
                     "repl",
                     StringComparison.CurrentCultureIgnoreCase);
 
-            if (!isFromRepl)
+            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
+                    var notAwaited =
+                        this.editorSession
+                            .PowerShellContext
+                            .ExecuteScriptString(evaluateParams.Expression, false, true)
+                            .ConfigureAwait(false);
+                }
+            }
+            else
             {
                 VariableDetails result =
-                    await editorSession.DebugService.EvaluateExpression(
-                        evaluateParams.Expression,
-                        evaluateParams.FrameId,
-                        isFromRepl);
+                await editorSession.DebugService.EvaluateExpression(
+                    evaluateParams.Expression,
+                    evaluateParams.FrameId,
+                    isFromRepl);
 
                 if (result != null)
                 {
@@ -736,12 +775,6 @@ 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
@@ -755,13 +788,22 @@ await requestContext.SendResult(
 
         #region Event Handlers
 
+        private async void powerShellContext_OutputWritten(object sender, OutputWrittenEventArgs e)
+        {
+            if (this.outputDebouncer != null)
+            {
+                // Queue the output for writing
+                await this.outputDebouncer.Invoke(e);
+            }
+        }
+
         async void DebugService_DebuggerStopped(object sender, DebuggerStoppedEventArgs e)
         {
             // 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: 
+            // The reason is displayed in the breakpoints viewlet.  Some recommended reasons are:
             // "step", "breakpoint", "function breakpoint", "exception" and "pause".
-            // We don't support exception breakpoints and for "pause", we can't distinguish 
+            // We don't support exception breakpoints and for "pause", we can't distinguish
             // between stepping and the user pressing the pause/break button in the debug toolbar.
             string debuggerStoppedReason = "step";
             if (e.OriginalEvent.Breakpoints.Count > 0)
@@ -799,7 +841,7 @@ async void powerShellContext_RunspaceChanged(object sender, RunspaceChangedEvent
                 await this.SendEvent(InitializedEvent.Type, null);
             }
             else if (
-                e.ChangeAction == RunspaceChangeAction.Exit && 
+                e.ChangeAction == RunspaceChangeAction.Exit &&
                 (this.editorSession == null ||
                  this.editorSession.PowerShellContext.IsDebuggerStopped))
             {

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -52,19 +52,22 @@ public EditorSession EditorSession
         /// Provides details about the host application.
         /// </param>
         public LanguageServer(HostDetails hostDetails, ProfilePaths profilePaths)
-            : this(hostDetails, profilePaths, new StdioServerChannel())
+            : this(hostDetails, profilePaths, false, new StdioServerChannel())
         {
         }
 
         /// <param name="hostDetails">
         /// Provides details about the host application.
         /// </param>
-        public LanguageServer(HostDetails hostDetails, ProfilePaths profilePaths, ChannelBase serverChannel)
+        public LanguageServer(
+            HostDetails hostDetails,
+            ProfilePaths profilePaths,
+            bool enableConsoleRepl,
+            ChannelBase serverChannel)
             : base(serverChannel)
         {
             this.editorSession = new EditorSession();
-            this.editorSession.StartSession(hostDetails, profilePaths);
-            //this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
+            this.editorSession.StartSession(hostDetails, profilePaths, enableConsoleRepl);
             this.editorSession.PowerShellContext.RunspaceChanged += PowerShellContext_RunspaceChanged;
 
             // Attach to ExtensionService events
@@ -80,13 +83,20 @@ public LanguageServer(HostDetails hostDetails, ProfilePaths profilePaths, Channe
 
             this.editorSession.StartDebugService(this.editorOperations);
 
-            // Always send console prompts through the UI in the language service
-            // TODO: This will change later once we have a general REPL available
-            // in VS Code.
-            this.editorSession.ConsoleService.PushPromptHandlerContext(
-                new ProtocolPromptHandlerContext(
-                    this,
-                    this.editorSession.ConsoleService));
+            if (enableConsoleRepl)
+            {
+                this.editorSession.ConsoleService.EnableConsoleRepl = true;
+            }
+            else
+            {
+                this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
+
+                // Always send console prompts through the UI in the language service
+                this.editorSession.ConsoleService.PushPromptHandlerContext(
+                    new ProtocolPromptHandlerContext(
+                        this,
+                        this.editorSession.ConsoleService));
+            }
 
             // Set up the output debouncer to throttle output event writes
             this.outputDebouncer = new OutputDebouncer(this);