Removed new parameter and switched instead on whether Stdio is in use determine whether or not to use the NullPSHostUI

Author: andyleejordan

src/PowerShellEditorServices.Hosting/Commands/StartEditorServicesCommand.cs

@@ -351,6 +351,7 @@ private EditorServicesConfig CreateConfigObject()
                 FeatureFlags = FeatureFlags,
                 LogLevel = LogLevel,
                 ConsoleRepl = GetReplKind(),
+                UseNullPSHostUI = Stdio,
                 AdditionalModules = AdditionalModules,
                 LanguageServiceTransport = GetLanguageServiceTransport(),
                 DebugServiceTransport = GetDebugServiceTransport(),

src/PowerShellEditorServices.Hosting/Configuration/EditorServicesConfig.cs

@@ -89,6 +89,11 @@ public EditorServicesConfig(
         /// </summary>
         public ConsoleReplKind ConsoleRepl { get; set; } = ConsoleReplKind.None;
 
+        /// <summary>
+        /// Will suppress messages to PSHost (to prevent Stdio clobbering)        
+        /// </summary>
+        public bool UseNullPSHostUI { get; set; }
+
         /// <summary>
         /// The minimum log level to log events with.
         /// </summary>

src/PowerShellEditorServices.Hosting/Internal/EditorServicesRunner.cs

@@ -1,11 +1,11 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using Microsoft.PowerShell.EditorServices.Server;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
-using Microsoft.PowerShell.EditorServices.Server;
 
 namespace Microsoft.PowerShell.EditorServices.Hosting
 {
@@ -289,6 +289,7 @@ private HostStartupInfo CreateHostStartupInfo()
                 _config.LogPath,
                 (int)_config.LogLevel,
                 consoleReplEnabled: _config.ConsoleRepl != ConsoleReplKind.None,
+                useNullPSHostUI: _config.UseNullPSHostUI,
                 usesLegacyReadLine: _config.ConsoleRepl == ConsoleReplKind.LegacyReadLine,
                 bundledModulePath: _config.BundledModulePath);
         }

src/PowerShellEditorServices/Hosting/HostStartupInfo.cs

@@ -76,6 +76,11 @@ public sealed class HostStartupInfo
         /// </summary>
         public bool ConsoleReplEnabled { get; }
 
+        /// <summary>
+        /// True if we want to suppress messages to PSHost (to prevent Stdio clobbering)
+        /// </summary>
+        public bool UseNullPSHostUI { get; }
+
         /// <summary>
         /// If true, the legacy PSES readline implementation will be used. Otherwise PSReadLine will be used.
         /// If the console REPL is not enabled, this setting will be ignored.
@@ -154,7 +159,8 @@ public HostStartupInfo(
             int logLevel,
             bool consoleReplEnabled,
             bool usesLegacyReadLine,
-            string bundledModulePath)
+            string bundledModulePath,
+            bool useNullPSHostUI)
         {
             Name = name ?? DefaultHostName;
             ProfileId = profileId ?? DefaultHostProfileId;
@@ -177,6 +183,7 @@ public HostStartupInfo(
                     "..",
                     "..",
                     ".."));
+            UseNullPSHostUI = useNullPSHostUI;
         }
 
         #endregion

src/PowerShellEditorServices/Services/Analysis/PssaCmdletAnalysisEngine.cs

@@ -292,10 +292,17 @@ private PowerShellResult InvokePowerShell(PSCommand command)
             catch (CmdletInvocationException ex)
             {
                 // We do not want to crash EditorServices for exceptions caused by cmdlet invocation.
-                // Two main reasons that cause the exception are:
+                // The main reasons that cause the exception are:
                 // * PSCmdlet.WriteOutput being called from another thread than Begin/Process
                 // * CompositionContainer.ComposeParts complaining that "...Only one batch can be composed at a time"
-                _logger.LogError(ex.Message);
+                // * PSScriptAnalyzer not being able to find its PSScriptAnalyzer.psd1 because we are hosted by an Assembly other than pwsh.exe
+                string message = ex.Message;
+                if (!string.IsNullOrEmpty(ex.ErrorRecord.FullyQualifiedErrorId))
+                {
+                    // Microsoft.PowerShell.EditorServices.Services.Analysis.PssaCmdletAnalysisEngine: Exception of type 'System.Exception' was thrown. |
+                    message += $" | {ex.ErrorRecord.FullyQualifiedErrorId}";
+                }
+                _logger.LogError(message);
             }
 
             return result;

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

@@ -193,9 +193,9 @@ public PsesInternalHost(
             Version = hostInfo.Version;
 
             DebugContext = new PowerShellDebugContext(loggerFactory, this);
-            UI = hostInfo.ConsoleReplEnabled
-                ? new EditorServicesConsolePSHostUserInterface(loggerFactory, hostInfo.PSHost.UI)
-                : new NullPSHostUI();
+            UI = hostInfo.UseNullPSHostUI
+                ? new NullPSHostUI()
+                : new EditorServicesConsolePSHostUserInterface(loggerFactory, hostInfo.PSHost.UI);
         }
 
         public override CultureInfo CurrentCulture => _hostInfo.PSHost.CurrentCulture;
@@ -583,7 +583,7 @@ internal Task LoadHostProfilesAsync(CancellationToken cancellationToken)
 
         private Task EnableShellIntegrationAsync(CancellationToken cancellationToken)
         {
-            // Imported on 01/03/23 from
+            // Imported on 01/03/24 from
             // https://github.com/microsoft/vscode/blob/main/src/vs/workbench/contrib/terminal/browser/media/shellIntegration.ps1
             // with quotes escaped, `__VSCodeOriginalPSConsoleHostReadLine` removed (as it's done
             // in our own ReadLine function), and `[Console]::Write` replaced with `Write-Host`.
@@ -602,42 +602,74 @@ private Task EnableShellIntegrationAsync(CancellationToken cancellationToken)
 
 $Global:__LastHistoryId = -1
 
+# Store the nonce in script scope and unset the global
+$Nonce = $env:VSCODE_NONCE
+$env:VSCODE_NONCE = $null
+
+if ($env:VSCODE_ENV_REPLACE) {
+	$Split = $env:VSCODE_ENV_REPLACE.Split("":"")
+	foreach ($Item in $Split) {
+		$Inner = $Item.Split('=')
+		[Environment]::SetEnvironmentVariable($Inner[0], $Inner[1].Replace('\x3a', ':'))
+	}
+	$env:VSCODE_ENV_REPLACE = $null
+}
+if ($env:VSCODE_ENV_PREPEND) {
+	$Split = $env:VSCODE_ENV_PREPEND.Split("":"")
+	foreach ($Item in $Split) {
+		$Inner = $Item.Split('=')
+		[Environment]::SetEnvironmentVariable($Inner[0], $Inner[1].Replace('\x3a', ':') + [Environment]::GetEnvironmentVariable($Inner[0]))
+	}
+	$env:VSCODE_ENV_PREPEND = $null
+}
+if ($env:VSCODE_ENV_APPEND) {
+	$Split = $env:VSCODE_ENV_APPEND.Split("":"")
+	foreach ($Item in $Split) {
+		$Inner = $Item.Split('=')
+		[Environment]::SetEnvironmentVariable($Inner[0], [Environment]::GetEnvironmentVariable($Inner[0]) + $Inner[1].Replace('\x3a', ':'))
+	}
+	$env:VSCODE_ENV_APPEND = $null
+}
+
 function Global:__VSCode-Escape-Value([string]$value) {
 	# NOTE: In PowerShell v6.1+, this can be written `$value -replace '…', { … }` instead of `[regex]::Replace`.
 	# Replace any non-alphanumeric characters.
 	[regex]::Replace($value, '[\\\n;]', { param($match)
-		# Encode the (ascii) matches as `\x<hex>`
-		-Join (
-			[System.Text.Encoding]::UTF8.GetBytes($match.Value) | ForEach-Object { '\x{0:x2}' -f $_ }
-		)
-	})
+			# Encode the (ascii) matches as `\x<hex>`
+			-Join (
+				[System.Text.Encoding]::UTF8.GetBytes($match.Value) | ForEach-Object { '\x{0:x2}' -f $_ }
+			)
+		})
 }
 
 function Global:Prompt() {
+	$FakeCode = [int]!$global:?
 	# NOTE: We disable strict mode for the scope of this function because it unhelpfully throws an
 	# error when $LastHistoryEntry is null, and is not otherwise useful.
 	Set-StrictMode -Off
-	$FakeCode = [int]!$global:?
 	$LastHistoryEntry = Get-History -Count 1
 	# Skip finishing the command if the first command has not yet started
 	if ($Global:__LastHistoryId -ne -1) {
 		if ($LastHistoryEntry.Id -eq $Global:__LastHistoryId) {
 			# Don't provide a command line or exit code if there was no history entry (eg. ctrl+c, enter on no command)
-			$Result  = ""$([char]0x1b)]633;E`a""
+			$Result = ""$([char]0x1b)]633;E`a""
 			$Result += ""$([char]0x1b)]633;D`a""
-		} else {
+		}
+		else {
 			# Command finished command line
-			# OSC 633 ; A ; <CommandLine?> ST
-			$Result  = ""$([char]0x1b)]633;E;""
+			# OSC 633 ; E ; <CommandLine?> ; <Nonce?> ST
+			$Result = ""$([char]0x1b)]633;E;""
 			# Sanitize the command line to ensure it can get transferred to the terminal and can be parsed
 			# correctly. This isn't entirely safe but good for most cases, it's important for the Pt parameter
 			# to only be composed of _printable_ characters as per the spec.
 			if ($LastHistoryEntry.CommandLine) {
 				$CommandLine = $LastHistoryEntry.CommandLine
-			} else {
+			}
+			else {
 				$CommandLine = """"
 			}
 			$Result += $(__VSCode-Escape-Value $CommandLine)
+			$Result += "";$Nonce""
 			$Result += ""`a""
 			# Command finished exit code
 			# OSC 633 ; D [; <ExitCode>] ST
@@ -649,7 +681,7 @@ private Task EnableShellIntegrationAsync(CancellationToken cancellationToken)
 	$Result += ""$([char]0x1b)]633;A`a""
 	# Current working directory
 	# OSC 633 ; <Property>=<Value> ST
-	$Result += if($pwd.Provider.Name -eq 'FileSystem'){""$([char]0x1b)]633;P;Cwd=$(__VSCode-Escape-Value $pwd.ProviderPath)`a""}
+	$Result += if ($pwd.Provider.Name -eq 'FileSystem') { ""$([char]0x1b)]633;P;Cwd=$(__VSCode-Escape-Value $pwd.ProviderPath)`a"" }
 	# Before running the original prompt, put $? back to what it was:
 	if ($FakeCode -ne 0) {
 		Write-Error ""failure"" -ea ignore
@@ -664,28 +696,91 @@ private Task EnableShellIntegrationAsync(CancellationToken cancellationToken)
 
 # Set IsWindows property
 if ($PSVersionTable.PSVersion -lt ""6.0"") {
-	[Console]::Write(""$([char]0x1b)]633;P;IsWindows=$true`a"")
-} else {
-	[Console]::Write(""$([char]0x1b)]633;P;IsWindows=$IsWindows`a"")
+	# Windows PowerShell is only available on Windows
+	Write-Host -NoNewLine ""$([char]0x1b)]633;P;IsWindows=$true`a""
+}
+else {
+	Write-Host -NoNewLine ""$([char]0x1b)]633;P;IsWindows=$IsWindows`a""
 }
 
 # Set always on key handlers which map to default VS Code keybindings
 function Set-MappedKeyHandler {
 	param ([string[]] $Chord, [string[]]$Sequence)
-	$Handler = $(Get-PSReadLineKeyHandler -Chord $Chord | Select-Object -First 1)
+	try {
+		$Handler = Get-PSReadLineKeyHandler -Chord $Chord | Select-Object -First 1
+	}
+ catch [System.Management.Automation.ParameterBindingException] {
+		# PowerShell 5.1 ships with PSReadLine 2.0.0 which does not have -Chord,
+		# so we check what's bound and filter it.
+		$Handler = Get-PSReadLineKeyHandler -Bound | Where-Object -FilterScript { $_.Key -eq $Chord } | Select-Object -First 1
+	}
 	if ($Handler) {
 		Set-PSReadLineKeyHandler -Chord $Sequence -Function $Handler.Function
 	}
 }
 
+$Global:__VSCodeHaltCompletions = $false
 function Set-MappedKeyHandlers {
 	Set-MappedKeyHandler -Chord Ctrl+Spacebar -Sequence 'F12,a'
 	Set-MappedKeyHandler -Chord Alt+Spacebar -Sequence 'F12,b'
 	Set-MappedKeyHandler -Chord Shift+Enter -Sequence 'F12,c'
 	Set-MappedKeyHandler -Chord Shift+End -Sequence 'F12,d'
+
+	# Conditionally enable suggestions
+	if ($env:VSCODE_SUGGEST -eq '1') {
+		Remove-Item Env:VSCODE_SUGGEST
+
+		# VS Code send completions request (may override Ctrl+Spacebar)
+		Set-PSReadLineKeyHandler -Chord 'F12,e' -ScriptBlock {
+			Send-Completions
+		}
+
+		# Suggest trigger characters
+		Set-PSReadLineKeyHandler -Chord ""-"" -ScriptBlock {
+			[Microsoft.PowerShell.PSConsoleReadLine]::Insert(""-"")
+			if (!$Global:__VSCodeHaltCompletions) {
+				Send-Completions
+			}
+		}
+
+		Set-PSReadLineKeyHandler -Chord 'F12,y' -ScriptBlock {
+			$Global:__VSCodeHaltCompletions = $true
+		}
+
+		Set-PSReadLineKeyHandler -Chord 'F12,z' -ScriptBlock {
+			$Global:__VSCodeHaltCompletions = $false
+		}
+	}
+}
+
+function Send-Completions {
+	$commandLine = """"
+	$cursorIndex = 0
+	# TODO: Since fuzzy matching exists, should completions be provided only for character after the
+	#       last space and then filter on the client side? That would let you trigger ctrl+space
+	#       anywhere on a word and have full completions available
+	[Microsoft.PowerShell.PSConsoleReadLine]::GetBufferState([ref]$commandLine, [ref]$cursorIndex)
+	$completionPrefix = $commandLine
+
+	# Get completions
+	$result = ""`e]633;Completions""
+	if ($completionPrefix.Length -gt 0) {
+		# Get and send completions
+		$completions = TabExpansion2 -inputScript $completionPrefix -cursorColumn $cursorIndex
+		if ($null -ne $completions.CompletionMatches) {
+			$result += "";$($completions.ReplacementIndex);$($completions.ReplacementLength);$($cursorIndex);""
+			$result += $completions.CompletionMatches | ConvertTo-Json -Compress
+		}
+	}
+	$result += ""`a""
+
+	Write-Host -NoNewLine $result
 }
 
-Set-MappedKeyHandlers
+# Register key handlers if PSReadLine is available
+if (Get-Module -Name PSReadLine) {
+	Set-MappedKeyHandlers
+}
             ";
 
             return ExecutePSCommandAsync(new PSCommand().AddScript(shellIntegrationScript), cancellationToken);

src/PowerShellEditorServices/Services/PowerShell/Utility/PowerShellExtensions.cs

@@ -12,6 +12,7 @@
 
 namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Utility
 {
+    using System.Collections;
     using System.Management.Automation;
 
     internal static class PowerShellExtensions
@@ -73,6 +74,10 @@ public static Collection<TResult> InvokeAndClear<TResult>(this PowerShell pwsh,
         {
             try
             {
+                if (pwsh.Runspace.SessionStateProxy.PSVariable.GetValue("error") is ArrayList errors)
+                {
+                    errors.Clear();
+                }
                 return pwsh.Invoke<TResult>(input: null, invocationSettings);
             }
             finally

test/PowerShellEditorServices.Test/PsesHostFactory.cs

@@ -57,6 +57,7 @@ public static PsesInternalHost Create(ILoggerFactory loggerFactory, bool loadPro
                 logLevel: (int)LogLevel.None,
                 consoleReplEnabled: false,
                 usesLegacyReadLine: false,
+                useNullPSHostUI: true, // Preserve previous functionality
                 bundledModulePath: BundledModulePath);
 
             PsesInternalHost psesHost = new(loggerFactory, null, testHostDetails);