EditorServiceHost: allow Tcp/NamedPipe/Stdio listeners

module/PowerShellEditorServices/PowerShellEditorServices.psm1

@@ -31,16 +31,21 @@ function Start-EditorServicesHost {
         [string]
         $HostVersion,
 
-        [Parameter(Mandatory=$true)]
-        [ValidateNotNullOrEmpty()]
         [int]
         $LanguageServicePort,
 
-        [Parameter(Mandatory=$true)]
-        [ValidateNotNullOrEmpty()]
         [int]
         $DebugServicePort,
 
+        [bool]
+        $Stdio,
+
+        [string]
+        $LanguageServiceNamedPipe,
+
+        [string]
+        $DebugServiceNamedPipe,
+
         [ValidateNotNullOrEmpty()]
         [string]
         $BundledModulesPath,
@@ -89,12 +94,39 @@ function Start-EditorServicesHost {
 
     $editorServicesHost.StartLogging($LogPath, $LogLevel);
 
-    if ($DebugServiceOnly.IsPresent) {
-        $editorServicesHost.StartDebugService($DebugServicePort, $profilePaths, $false);
+    $languageServiceConfig = New-Object Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportConfig
+    $debugServiceConfig    = New-Object Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportConfig
+
+    if ($Stdio) {
+        $languageServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Stdio
+        $debugServiceConfig.TransportType    = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Stdio
     }
-    else {
-        $editorServicesHost.StartLanguageService($LanguageServicePort, $profilePaths);
-        $editorServicesHost.StartDebugService($DebugServicePort, $profilePaths, $true);
+
+    if ($LanguageServicePort) {
+        $languageServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Tcp
+        $languageServiceConfig.Endpoint = "$LanguageServicePort"
+    }
+
+    if ($DebugServicePort) {
+        $debugServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Tcp
+        $debugServiceConfig.Endpoint = "$DebugServicePort"
+    }
+
+    if ($LanguageServiceNamedPipe) {
+        $languageServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::NamedPipe
+        $languageServiceConfig.Endpoint = "$LanguageServiceNamedPipe"
+    }
+
+    if ($DebugServiceNamedPipe) {
+        $debugServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::NamedPipe
+        $debugServiceConfig.Endpoint = "$DebugServiceNamedPipe"
+    }
+
+    if ($DebugServiceOnly.IsPresent) {
+        $editorServicesHost.StartDebugService($debugServiceConfig, $profilePaths, $false);
+    } else {
+        $editorServicesHost.StartLanguageService($languageServiceConfig, $profilePaths);
+        $editorServicesHost.StartDebugService($debugServiceConfig, $profilePaths, $true);
     }
 
     return $editorServicesHost

module/Start-EditorServices.ps1

@@ -51,7 +51,19 @@ param(
     $WaitForDebugger,
 
     [switch]
-    $ConfirmInstall
+    $ConfirmInstall,
+
+    [switch]
+    $Stdio,
+
+    [switch]
+    $DebugServiceOnly,
+
+    [string]
+    $LanguageServicePipeName = $null,
+
+    [string]
+    $DebugServicePipeName = $null
 )
 
 # This variable will be assigned later to contain information about
@@ -149,8 +161,9 @@ if ((Test-ModuleAvailable "PowerShellEditorServices" -RequiredVersion $parsedVer
 Import-Module PowerShellEditorServices -RequiredVersion $parsedVersion -ErrorAction Stop
 
 # Locate available port numbers for services
-$languageServicePort = Get-AvailablePort
-$debugServicePort = Get-AvailablePort
+# There could be only one service on Stdio channel
+if (-not (($Stdio.IsPresent -and -not $DebugServiceOnly.IsPresent) -or $LanguageServicePipeName)) { $languageServicePort = Get-AvailablePort }
+if (-not (($Stdio.IsPresent -and $DebugServiceOnly.IsPresent)      -or $DebugServicePipeName))    { $debugServicePort = Get-AvailablePort }
 
 $editorServicesHost =
     Start-EditorServicesHost `
@@ -162,16 +175,22 @@ $editorServicesHost =
         -AdditionalModules @() `
         -LanguageServicePort $languageServicePort `
         -DebugServicePort $debugServicePort `
+        -Stdio $Stdio.IsPresent`
+        -LanguageServiceNamedPipe $LanguageServicePipeName `
+        -DebugServiceNamedPipe $DebugServicePipeName `
         -BundledModulesPath $BundledModulesPath `
+        -DebugServiceOnly:$DebugServiceOnly.IsPresent`
         -WaitForDebugger:$WaitForDebugger.IsPresent
 
 # TODO: Verify that the service is started
 
 $resultDetails = @{
     "status" = "started";
-    "channel" = "tcp";
     "languageServicePort" = $languageServicePort;
     "debugServicePort" = $debugServicePort;
+    "languageServiceNamedPipe" = $LanguageServicePipeName;
+    "debugServiceNamedPipe" = $DebugServicePipeName;
+    "Stdio" = $Stdio.IsPresent;
 };
 
 # Notify the client that the services have started

src/PowerShellEditorServices.Host/EditorServicesHost.cs

@@ -29,6 +29,25 @@ public enum EditorServicesHostStatus
         Ended
     }
 
+    public enum EditorServiceTransportType
+    {
+        Tcp,
+        NamedPipe,
+        Stdio
+    }
+
+    public class EditorServiceTransportConfig
+    {
+        public EditorServiceTransportType TransportType { get; set; }
+        /// <summary>
+        /// Configures the endpoint of the transport.
+        /// For Tcp it's an integer specifying the port.
+        /// For Stdio it's ignored.
+        /// For NamedPipe it's the pipe name.
+        /// </summary>
+        public string Endpoint { get; set; }
+    }
+
     /// <summary>
     /// Provides a simplified interface for hosting the language and debug services
     /// over the named pipe server protocol.
@@ -48,8 +67,8 @@ public class EditorServicesHost
         private HashSet<string> featureFlags;
         private LanguageServer languageServer;
 
-        private TcpSocketServerListener languageServiceListener;
-        private TcpSocketServerListener debugServiceListener;
+        private IServerListener languageServiceListener;
+        private IServerListener debugServiceListener;
 
         private TaskCompletionSource<bool> serverCompletedTask;
 
@@ -164,29 +183,25 @@ public void StartLogging(string logFilePath, LogLevel logLevel)
         /// </summary>
         /// <param name="languageServicePort">The port number for the language service.</param>
         /// <param name="profilePaths">The object containing the profile paths to load for this session.</param>
-        public void StartLanguageService(int languageServicePort, ProfilePaths profilePaths)
+        public void StartLanguageService(EditorServiceTransportConfig config, ProfilePaths profilePaths)
         {
             this.profilePaths = profilePaths;
 
-            this.languageServiceListener =
-                new TcpSocketServerListener(
-                    MessageProtocolType.LanguageServer,
-                    languageServicePort,
-                    this.logger);
+            this.languageServiceListener = CreateServiceListener(MessageProtocolType.LanguageServer, config);
 
             this.languageServiceListener.ClientConnect += this.OnLanguageServiceClientConnect;
             this.languageServiceListener.Start();
 
             this.logger.Write(
                 LogLevel.Normal,
                 string.Format(
-                    "Language service started, listening on port {0}",
-                    languageServicePort));
+                    "Language service started, type = {0}, endpoint = {1}",
+                    config.TransportType, config.Endpoint));
         }
 
         private async void OnLanguageServiceClientConnect(
             object sender,
-            TcpSocketServerChannel serverChannel)
+            ChannelBase serverChannel)
         {
             MessageDispatcher messageDispatcher = new MessageDispatcher(this.logger);
 
@@ -238,27 +253,22 @@ await this.editorSession.PowerShellContext.ImportCommandsModule(
         /// </summary>
         /// <param name="debugServicePort">The port number for the debug service.</param>
         public void StartDebugService(
-            int debugServicePort,
+            EditorServiceTransportConfig config,
             ProfilePaths profilePaths,
             bool useExistingSession)
         {
-            this.debugServiceListener =
-                new TcpSocketServerListener(
-                    MessageProtocolType.DebugAdapter,
-                    debugServicePort,
-                    this.logger);
-
+            this.debugServiceListener = CreateServiceListener(MessageProtocolType.DebugAdapter, config);
             this.debugServiceListener.ClientConnect += OnDebugServiceClientConnect;
             this.debugServiceListener.Start();
 
             this.logger.Write(
                 LogLevel.Normal,
                 string.Format(
-                    "Debug service started, listening on port {0}",
-                    debugServicePort));
+                    "Debug service started, type = {0}, endpoint = {1}",
+                    config.TransportType, config.Endpoint));
         }
 
-        private void OnDebugServiceClientConnect(object sender, TcpSocketServerChannel serverChannel)
+        private void OnDebugServiceClientConnect(object sender, ChannelBase serverChannel)
         {
             MessageDispatcher messageDispatcher = new MessageDispatcher(this.logger);
 
@@ -441,6 +451,31 @@ private void CurrentDomain_UnhandledException(
                     e.ExceptionObject.ToString()));
         }
 #endif
+        private IServerListener CreateServiceListener(MessageProtocolType protocol, EditorServiceTransportConfig config)
+        {
+            switch (config.TransportType)
+            {
+                case EditorServiceTransportType.Tcp:
+                {
+                    return new TcpSocketServerListener(protocol, int.Parse(config.Endpoint), this.logger);
+                }
+
+                case EditorServiceTransportType.Stdio:
+                {
+                    return new StdioServerListener(protocol, this.logger);
+                }
+
+                case EditorServiceTransportType.NamedPipe:
+                {
+                    return new NamedPipeServerListener(protocol, config.Endpoint, this.logger);
+                }
+
+                default:
+                {
+                    throw new NotSupportedException();
+                }
+            }
+        }
 
         #endregion
     }

src/PowerShellEditorServices.Protocol/MessageProtocol/Channel/NamedPipeServerListener.cs

@@ -38,6 +38,7 @@ public override void Start()
                         1,
                         PipeTransmissionMode.Byte,
                         PipeOptions.Asynchronous);
+                ListenForConnection();
             }
             catch (IOException e)
             {

src/PowerShellEditorServices.Protocol/MessageProtocol/Channel/ServerListenerBase.cs

@@ -8,7 +8,7 @@
 
 namespace Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel
 {
-    public abstract class ServerListenerBase<TChannel>
+    public abstract class ServerListenerBase<TChannel> : IServerListener
         where TChannel : ChannelBase
     {
         private MessageProtocolType messageProtocolType;
@@ -22,12 +22,21 @@ public ServerListenerBase(MessageProtocolType messageProtocolType)
 
         public abstract void Stop();
 
-        public event EventHandler<TChannel> ClientConnect;
+        public event EventHandler<ChannelBase> ClientConnect;
 
         protected void OnClientConnect(TChannel channel)
         {
             channel.Start(this.messageProtocolType);
             this.ClientConnect?.Invoke(this, channel);
         }
     }
+
+    public interface IServerListener
+    {
+        void Start();
+
+        void Stop();
+
+        event EventHandler<ChannelBase> ClientConnect;
+    }
 }

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -1348,13 +1348,16 @@ private static FileChange GetFileChangeDetails(Range changeRange, string insertS
         {
             // The protocol's positions are zero-based so add 1 to all offsets
 
+            if (changeRange == null) return new FileChange { InsertString = insertString, Reloaded = true };
+
             return new FileChange
             {
                 InsertString = insertString,
                 Line = changeRange.Start.Line + 1,
                 Offset = changeRange.Start.Character + 1,
                 EndLine = changeRange.End.Line + 1,
-                EndOffset = changeRange.End.Character + 1
+                EndOffset = changeRange.End.Character + 1,
+                Reloaded = false
             };
         }
 

src/PowerShellEditorServices/Workspace/FileChange.cs

@@ -34,5 +34,12 @@ public class FileChange
         /// The 1-based column offset where the change ends.
         /// </summary>
         public int EndOffset { get; set; }
+
+        /// <summary>
+        /// Indicates that the InsertString is an overwrite
+        /// of the content, and all stale content and metadata
+        /// should be discarded.
+        /// </summary>
+        public bool Reloaded { get; set; }
     }
 }