Use public InternalHost from origin runspace

`ConsoleHost` from `powershell.exe`/`pwsh` still exists within the
runspace created at process start. This change grabs the public
reference to that host while initializing EditorServicesHost. We
can then leverage that host so we can have a much closer to
"default" experience.

This change adds support for the following host members

## $Host.UI

- WriteProgress (including `Write-Progress`)

## $Host.UI.RawUI

- CursorSize (still doesn't work in xterm.js though)
- WindowTitle
- MaxPhysicalWindowSize
- MaxWindowSize
- ReadKey
- GetBufferContents
- ScrollBufferContents
- SetBufferContents

## TODO

[ ] Test RawUI members
[ ] Maybe write sync verison of ReadKey
[ ] Maybe avoid TerminalPSHost* breaking changes (constructors)

Author: SeeminglyScience

src/PowerShellEditorServices.Host/EditorServicesHost.cs

@@ -20,6 +20,9 @@
 using System.Reflection;
 using System.Threading.Tasks;
 using System.Runtime.InteropServices;
+using System.Management.Automation;
+using System.Management.Automation.Host;
+using System.Linq;
 
 namespace Microsoft.PowerShell.EditorServices.Host
 {
@@ -61,6 +64,7 @@ public class EditorServicesHost
     {
         #region Private Fields
 
+        private readonly PSHost internalHost;
         private string[] additionalModules;
         private string bundledModulesPath;
         private DebugAdapter debugAdapter;
@@ -103,6 +107,11 @@ public EditorServicesHost(
         {
             Validate.IsNotNull(nameof(hostDetails), hostDetails);
 
+            using (var pwsh = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace))
+            {
+                this.internalHost = pwsh.AddScript("$Host").Invoke<PSHost>().First();
+            }
+
             this.hostDetails = hostDetails;
             this.enableConsoleRepl = enableConsoleRepl;
             this.bundledModulesPath = bundledModulesPath;
@@ -113,13 +122,13 @@ public EditorServicesHost(
 #if DEBUG
             if (waitForDebugger)
             {
-                if (Debugger.IsAttached)
+                if (System.Diagnostics.Debugger.IsAttached)
                 {
-                    Debugger.Break();
+                    System.Diagnostics.Debugger.Break();
                 }
                 else
                 {
-                    Debugger.Launch();
+                    System.Diagnostics.Debugger.Launch();
                 }
             }
 #endif
@@ -377,7 +386,7 @@ private EditorSession CreateSession(
 
             EditorServicesPSHostUserInterface hostUserInterface =
                 enableConsoleRepl
-                    ? (EditorServicesPSHostUserInterface) new TerminalPSHostUserInterface(powerShellContext, this.logger)
+                    ? (EditorServicesPSHostUserInterface) new TerminalPSHostUserInterface(powerShellContext, this.logger, this.internalHost)
                     : new ProtocolPSHostUserInterface(powerShellContext, messageSender, this.logger);
 
             EditorServicesPSHost psHost =
@@ -419,7 +428,7 @@ private EditorSession CreateDebugSession(
 
             EditorServicesPSHostUserInterface hostUserInterface =
                 enableConsoleRepl
-                    ? (EditorServicesPSHostUserInterface) new TerminalPSHostUserInterface(powerShellContext, this.logger)
+                    ? (EditorServicesPSHostUserInterface) new TerminalPSHostUserInterface(powerShellContext, this.logger, this.internalHost)
                     : new ProtocolPSHostUserInterface(powerShellContext, messageSender, this.logger);
 
             EditorServicesPSHost psHost =

src/PowerShellEditorServices/PowerShellEditorServices.csproj

@@ -5,6 +5,7 @@
     <Description>Provides common PowerShell editor capabilities as a .NET library.</Description>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
     <AssemblyName>Microsoft.PowerShell.EditorServices</AssemblyName>
+    <LangVersion>Latest</LangVersion>
   </PropertyGroup>
   <!-- Fail the release build if there are missing public API documentation comments -->
   <PropertyGroup>

src/PowerShellEditorServices/Session/Host/EditorServicesPSHostUserInterface.cs

@@ -32,6 +32,7 @@ public abstract class EditorServicesPSHostUserInterface :
     {
         #region Private Fields
 
+        private readonly HashSet<ProgressKey> currentProgressMessages = new HashSet<ProgressKey>();
         private PromptHandler activePromptHandler;
         private PSHostRawUserInterface rawUserInterface;
         private CancellationTokenSource commandLoopCancellationToken;
@@ -83,6 +84,11 @@ public abstract class EditorServicesPSHostUserInterface :
         /// </summary>
         protected ILogger Logger { get; private set; }
 
+        /// <summary>
+        /// Gets a value indicating whether writing progress is supported.
+        /// </summary>
+        internal protected virtual bool SupportsWriteProgress => false;
+
         #endregion
 
         #region Constructors
@@ -582,17 +588,74 @@ public override void WriteErrorLine(string value)
         }
 
         /// <summary>
-        ///
+        /// Invoked by <see cref="Cmdlet.WriteProgress(ProgressRecord)" /> to display a progress record.
         /// </summary>
-        /// <param name="sourceId"></param>
-        /// <param name="record"></param>
-        public override void WriteProgress(
+        /// <param name="sourceId">
+        /// Unique identifier of the source of the record. An int64 is used because typically,
+        /// the 'this' pointer of the command from whence the record is originating is used, and
+        /// that may be from a remote Runspace on a 64-bit machine.
+        /// </param>
+        /// <param name="record">
+        /// The record being reported to the host.
+        /// </param>
+        public sealed override void WriteProgress(
             long sourceId,
             ProgressRecord record)
         {
-            this.UpdateProgress(
-                sourceId,
-                ProgressDetails.Create(record));
+            // Maintain old behavior if this isn't overridden.
+            if (!this.SupportsWriteProgress)
+            {
+                this.UpdateProgress(sourceId, ProgressDetails.Create(record));
+                return;
+            }
+
+            // Keep a list of progress records we write so we can automatically
+            // clean them up after the pipeline ends.
+            if (record.RecordType == ProgressRecordType.Completed)
+            {
+                this.currentProgressMessages.Remove(new ProgressKey(sourceId, record));
+            }
+            else
+            {
+                this.currentProgressMessages.Add(new ProgressKey(sourceId, record));
+            }
+
+            this.WriteProgressImpl(sourceId, record);
+        }
+
+        /// <summary>
+        /// Invoked by <see cref="Cmdlet.WriteProgress(ProgressRecord)" /> to display a progress record.
+        /// </summary>
+        /// <param name="sourceId">
+        /// Unique identifier of the source of the record. An int64 is used because typically,
+        /// the 'this' pointer of the command from whence the record is originating is used, and
+        /// that may be from a remote Runspace on a 64-bit machine.
+        /// </param>
+        /// <param name="record">
+        /// The record being reported to the host.
+        /// </param>
+        protected virtual void WriteProgressImpl(long sourceId, ProgressRecord record)
+        {
+        }
+
+        internal void ClearProgress()
+        {
+            const string nonEmptyString = "noop";
+            if (!this.SupportsWriteProgress)
+            {
+                return;
+            }
+
+            foreach (ProgressKey key in this.currentProgressMessages)
+            {
+                // This constructor throws if the activity description is empty even
+                // with completed records.
+                var record = new ProgressRecord(key.ActivityId, nonEmptyString, nonEmptyString);
+                record.RecordType = ProgressRecordType.Completed;
+                this.WriteProgressImpl(key.SourceId, record);
+            }
+
+            this.currentProgressMessages.Clear();
         }
 
         #endregion
@@ -917,6 +980,8 @@ private void PowerShellContext_ExecutionStatusChanged(object sender, ExecutionSt
             // The command loop should only be manipulated if it's already started
             if (eventArgs.ExecutionStatus == ExecutionStatus.Aborted)
             {
+                this.ClearProgress();
+
                 // When aborted, cancel any lingering prompts
                 if (this.activePromptHandler != null)
                 {
@@ -932,6 +997,8 @@ private void PowerShellContext_ExecutionStatusChanged(object sender, ExecutionSt
                 // the display of the prompt
                 if (eventArgs.ExecutionStatus != ExecutionStatus.Running)
                 {
+                    this.ClearProgress();
+
                     // Execution has completed, start the input prompt
                     this.ShowCommandPrompt();
                     StartCommandLoop();
@@ -948,11 +1015,48 @@ private void PowerShellContext_ExecutionStatusChanged(object sender, ExecutionSt
                 (eventArgs.ExecutionStatus == ExecutionStatus.Failed ||
                     eventArgs.HadErrors))
             {
+                this.ClearProgress();
                 this.WriteOutput(string.Empty, true);
                 var unusedTask = this.WritePromptStringToHostAsync(CancellationToken.None);
             }
         }
 
         #endregion
+
+        private readonly struct ProgressKey : IEquatable<ProgressKey>
+        {
+            internal readonly long SourceId;
+
+            internal readonly int ActivityId;
+
+            internal readonly int ParentActivityId;
+
+            internal ProgressKey(long sourceId, ProgressRecord record)
+            {
+                SourceId = sourceId;
+                ActivityId = record.ActivityId;
+                ParentActivityId = record.ParentActivityId;
+            }
+
+            public bool Equals(ProgressKey other)
+            {
+                return SourceId == other.SourceId
+                    && ActivityId == other.ActivityId
+                    && ParentActivityId == other.ParentActivityId;
+            }
+
+            public override int GetHashCode()
+            {
+                // Algorithm from https://stackoverflow.com/questions/1646807/quick-and-simple-hash-code-combinations
+                unchecked
+                {
+                    int hash = 17;
+                    hash = hash * 31 + SourceId.GetHashCode();
+                    hash = hash * 31 + ActivityId.GetHashCode();
+                    hash = hash * 31 + ParentActivityId.GetHashCode();
+                    return hash;
+                }
+            }
+        }
     }
 }