Use public InternalHost from origin runspace

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;
+                }
+            }
+        }
     }
 }