Fix disappearing output bug by resetting TranscribeOnly

What a bug! In PowerShell 5.1 our artificial pipeline for event handling
(among other possible PowerShell tasks) could cause the output to just
disappear. Turns out a bug in 5.1 with the transcript was being triggered.
Scripts without `Out-Default` would get it appended with
`-TranscribeOnly True` in order for the transcription to happen...but the
`TranscribeOnly` field could erroneously not be set back to `false`! This
would cause all output to just "disappear." It was fixed in PowerShell 7,
but we still have to work around it for PowerShell 5.1 by resetting it.

Author: andyleejordan

src/PowerShellEditorServices/Services/PowerShell/Host/EditorServicesConsolePSHostUserInterface.cs

@@ -7,21 +7,39 @@
 using System.Collections.ObjectModel;
 using System.Management.Automation;
 using System.Management.Automation.Host;
+using System.Reflection;
 using System.Security;
 using Microsoft.Extensions.Logging;
+using Microsoft.PowerShell.EditorServices.Utility;
 
 namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Host
 {
     internal class EditorServicesConsolePSHostUserInterface : PSHostUserInterface, IHostUISupportsMultipleChoiceSelection
     {
         private readonly PSHostUserInterface _underlyingHostUI;
 
+        private static readonly Action<PSHostUserInterface, bool> s_setTranscribeOnlyDelegate;
+
         /// <summary>
         /// We use a ConcurrentDictionary because ConcurrentHashSet does not exist, hence the value
         /// is never actually used, and `WriteProgress` must be thread-safe.
         /// </summary>
         private readonly ConcurrentDictionary<(long, int), object> _currentProgressRecords = new();
 
+        static EditorServicesConsolePSHostUserInterface()
+        {
+            if (VersionUtils.IsPS5)
+            {
+                PropertyInfo transcribeOnlyProperty = typeof(PSHostUserInterface)
+                    .GetProperty("TranscribeOnly", BindingFlags.NonPublic | BindingFlags.Instance);
+
+                MethodInfo transcribeOnlySetMethod = transcribeOnlyProperty.GetSetMethod(nonPublic: true);
+
+                s_setTranscribeOnlyDelegate = (Action<PSHostUserInterface, bool>)Delegate.CreateDelegate(
+                    typeof(Action<PSHostUserInterface, bool>), transcribeOnlySetMethod);
+            }
+        }
+
         public EditorServicesConsolePSHostUserInterface(
             ILoggerFactory loggerFactory,
             PSHostUserInterface underlyingHostUI)
@@ -70,7 +88,7 @@ public override void WriteProgress(long sourceId, ProgressRecord record)
             _underlyingHostUI.WriteProgress(sourceId, record);
         }
 
-        public void ResetProgress()
+        internal void ResetProgress()
         {
             // Mark all processed progress records as completed.
             foreach ((long sourceId, int activityId) in _currentProgressRecords.Keys)
@@ -87,6 +105,17 @@ public void ResetProgress()
             // TODO: Maybe send the OSC sequence to turn off progress indicator.
         }
 
+        // This works around a bug in PowerShell 5.1 (that was later fixed) where a running
+        // transcription could cause output to disappear since the `TranscribeOnly` property was
+        // accidentally not reset to false.
+        internal void DisableTranscribeOnly()
+        {
+            if (VersionUtils.IsPS5)
+            {
+                s_setTranscribeOnlyDelegate(_underlyingHostUI, false);
+            }
+        }
+
         public override void WriteVerboseLine(string message) => _underlyingHostUI.WriteVerboseLine(message);
 
         public override void WriteWarningLine(string message) => _underlyingHostUI.WriteWarningLine(message);

src/PowerShellEditorServices/Services/PowerShell/Host/PsesInternalHost.cs

@@ -476,7 +476,19 @@ public void InvokeDelegate(string representation, ExecutionOptions executionOpti
         public IReadOnlyList<TResult> InvokePSCommand<TResult>(PSCommand psCommand, PowerShellExecutionOptions executionOptions, CancellationToken cancellationToken)
         {
             SynchronousPowerShellTask<TResult> task = new(_logger, this, psCommand, executionOptions, cancellationToken);
-            return task.ExecuteAndGetResult(cancellationToken);
+            try
+            {
+                return task.ExecuteAndGetResult(cancellationToken);
+            }
+            finally
+            {
+                // At the end of each PowerShell command we need to reset PowerShell 5.1's
+                // `TranscribeOnly` property to avoid a bug where output disappears.
+                if (UI is EditorServicesConsolePSHostUserInterface ui)
+                {
+                    ui.DisableTranscribeOnly();
+                }
+            }
         }
 
         public void InvokePSCommand(PSCommand psCommand, PowerShellExecutionOptions executionOptions, CancellationToken cancellationToken) => InvokePSCommand<PSObject>(psCommand, executionOptions, cancellationToken);