Add pwsh cleanup before Named Pipe test to avoid server conflicts

Author: yotsuda

.github/workflows/cross-platform-test.yml

@@ -257,6 +257,21 @@ jobs:
         
         Write-Host "=== Testing Named Pipe Communication ===" -ForegroundColor Cyan
         
+        # Clean up any existing pwsh processes that might have Named Pipe servers
+        Write-Host "Cleaning up existing pwsh processes..."
+        $currentPid = $PID
+        $pwshProcs = Get-Process -Name pwsh -ErrorAction SilentlyContinue | Where-Object { $_.Id -ne $currentPid }
+        if ($pwshProcs) {
+          Write-Host "Found $($pwshProcs.Count) other pwsh process(es), terminating..."
+          $pwshProcs | ForEach-Object { 
+            Write-Host "  Killing PID $($_.Id)"
+            $_ | Stop-Process -Force -ErrorAction SilentlyContinue 
+          }
+          Start-Sleep -Seconds 1
+        } else {
+          Write-Host "No other pwsh processes found"
+        }
+        
         # Start a background pwsh process with PowerShell.MCP imported
         Write-Host "Starting background pwsh with PowerShell.MCP..."
         $bgPsi = [System.Diagnostics.ProcessStartInfo]::new()

PowerShell.MCP.Proxy/Services/NamedPipeClient.cs

@@ -27,7 +27,7 @@ public async Task<string> SendRequestAsync(string arguments)
             try
             {
                 Console.Error.WriteLine("[DEBUG] Connecting to Named Pipe (3s timeout)...");
-                await pipeClient.ConnectAsync(1000 * 3); // 3 second timeout
+                await pipeClient.ConnectAsync(1000 * 3).ConfigureAwait(false); // 3 second timeout
                 Console.Error.WriteLine("[DEBUG] Connected to Named Pipe successfully");
             }
             catch (TimeoutException)
@@ -45,13 +45,13 @@ public async Task<string> SendRequestAsync(string arguments)
             Console.Error.WriteLine($"[DEBUG] Sending length prefix: {messageBytes.Length}");
 
             // Send message length prefix + JSON message body
-            await pipeClient.WriteAsync(lengthBytes, 0, lengthBytes.Length);
-            await pipeClient.WriteAsync(messageBytes, 0, messageBytes.Length);
-            await pipeClient.FlushAsync();
+            await pipeClient.WriteAsync(lengthBytes, 0, lengthBytes.Length).ConfigureAwait(false);
+            await pipeClient.WriteAsync(messageBytes, 0, messageBytes.Length).ConfigureAwait(false);
+            await pipeClient.FlushAsync().ConfigureAwait(false);
             Console.Error.WriteLine("[DEBUG] Message sent, waiting for response...");
 
             // Receive response: proper length prefix handling
-            var response = await ReceiveMessageAsync(pipeClient);
+            var response = await ReceiveMessageAsync(pipeClient).ConfigureAwait(false);
             Console.Error.WriteLine($"[DEBUG] Response received, length: {response.Length}");
             return response;
         }
@@ -74,7 +74,7 @@ private async Task<string> ReceiveMessageAsync(NamedPipeClientStream pipeClient)
 
         // 1. Read message length (4 bytes) reliably
         var lengthBuffer = new byte[4];
-        await ReadExactAsync(pipeClient, lengthBuffer, 4);
+        await ReadExactAsync(pipeClient, lengthBuffer, 4).ConfigureAwait(false);
 
         var messageLength = BitConverter.ToInt32(lengthBuffer, 0);
         Console.Error.WriteLine($"[DEBUG] ReceiveMessageAsync: Message length = {messageLength}");
@@ -88,7 +88,7 @@ private async Task<string> ReceiveMessageAsync(NamedPipeClientStream pipeClient)
         // 3. Read message body reliably
         Console.Error.WriteLine($"[DEBUG] ReceiveMessageAsync: Reading message body...");
         var messageBuffer = new byte[messageLength];
-        await ReadExactAsync(pipeClient, messageBuffer, messageLength);
+        await ReadExactAsync(pipeClient, messageBuffer, messageLength).ConfigureAwait(false);
 
         // 4. UTF-8 decode
         var result = Encoding.UTF8.GetString(messageBuffer);
@@ -102,7 +102,7 @@ private async Task ReadExactAsync(NamedPipeClientStream pipeClient, byte[] buffe
 
         while (totalBytesRead < count)
         {
-            var bytesRead = await pipeClient.ReadAsync(buffer, totalBytesRead, count - totalBytesRead);
+            var bytesRead = await pipeClient.ReadAsync(buffer, totalBytesRead, count - totalBytesRead).ConfigureAwait(false);
 
             if (bytesRead == 0)
             {
@@ -126,10 +126,10 @@ public static async Task<bool> WaitForPipeReadyAsync()
             try
             {
                 using var testClient = new NamedPipeClientStream(".", PipeName, PipeDirection.InOut);
-                await testClient.ConnectAsync(500); // 500ms timeout
+                await testClient.ConnectAsync(500).ConfigureAwait(false); // 500ms timeout
                 Console.Error.WriteLine($"[INFO] Named Pipe ready after {attempt} attempts");
                 // Give the server time to prepare for the next connection
-                await Task.Delay(500);
+                await Task.Delay(500).ConfigureAwait(false);
                 return true;
             }
             catch (TimeoutException)

PowerShell.MCP/Services/NamedPipeServer.cs

@@ -81,12 +81,12 @@ private async Task RunServerInstanceAsync(CancellationToken cancellationToken)
                 // Wait for client connection
                 Console.Error.WriteLine("[DEBUG] Before WaitForConnectionAsync");
                 Console.Error.Flush();
-                await pipeServer.WaitForConnectionAsync(cancellationToken);
+                await pipeServer.WaitForConnectionAsync(cancellationToken).ConfigureAwait(false);
                 Console.Error.WriteLine("[DEBUG] After WaitForConnectionAsync - Client connected to Named Pipe");
                 Console.Error.Flush();
 
                 // Handle communication with connected client
-                await HandleClientAsync(pipeServer, cancellationToken);
+                await HandleClientAsync(pipeServer, cancellationToken).ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
@@ -103,7 +103,7 @@ private async Task RunServerInstanceAsync(CancellationToken cancellationToken)
                 // Wait a moment before retrying on error
                 try
                 {
-                    await Task.Delay(1000, cancellationToken);
+                    await Task.Delay(1000, cancellationToken).ConfigureAwait(false);
                 }
                 catch (OperationCanceledException)
                 {
@@ -149,7 +149,7 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
         {
             // Receive request
             Console.Error.WriteLine("[DEBUG] Calling ReceiveMessageAsync...");
-            var requestJson = await ReceiveMessageAsync(pipeServer, cancellationToken);
+            var requestJson = await ReceiveMessageAsync(pipeServer, cancellationToken).ConfigureAwait(false);
             Console.Error.WriteLine($"[DEBUG] Received request: {requestJson.Substring(0, Math.Min(100, requestJson.Length))}...");
 
             // Parse JSON-RPC request
@@ -180,7 +180,7 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
 
 Please provide how to update the MCP client configuration to the user.";
 
-                await SendMessageAsync(pipeServer, versionErrorResponse, cancellationToken);
+                await SendMessageAsync(pipeServer, versionErrorResponse, cancellationToken).ConfigureAwait(false);
                 return;
             }
 
@@ -194,15 +194,15 @@ 2. Manually terminate console (LLM will then restart automatically)
 
 LLM should prompt user to choose.";
 
-                await SendMessageAsync(pipeServer, busyResponse, cancellationToken);
+                await SendMessageAsync(pipeServer, busyResponse, cancellationToken).ConfigureAwait(false);
                 return;
             }
 
             // Execute tool
-            var result = await Task.Run(() => ExecuteTool(name!, requestRoot));
+            var result = await Task.Run(() => ExecuteTool(name!, requestRoot)).ConfigureAwait(false);
 
             // Send response
-            await SendMessageAsync(pipeServer, result, cancellationToken);
+            await SendMessageAsync(pipeServer, result, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
@@ -226,7 +226,7 @@ 2. Manually terminate console (LLM will then restart automatically)
 
             try
             {
-                await SendMessageAsync(pipeServer, errorJson, cancellationToken);
+                await SendMessageAsync(pipeServer, errorJson, cancellationToken).ConfigureAwait(false);
             }
             catch
             {
@@ -270,7 +270,7 @@ private static async Task<string> ReceiveMessageAsync(NamedPipeServerStream pipe
 
         // Receive message length (4 bytes)
         var lengthBytes = new byte[4];
-        await ReadExactAsync(pipeServer, lengthBytes, cancellationToken);
+        await ReadExactAsync(pipeServer, lengthBytes, cancellationToken).ConfigureAwait(false);
         var messageLength = BitConverter.ToInt32(lengthBytes, 0);
         Console.Error.WriteLine($"[DEBUG] Server ReceiveMessageAsync: Message length = {messageLength}");
 
@@ -282,7 +282,7 @@ private static async Task<string> ReceiveMessageAsync(NamedPipeServerStream pipe
         // Receive message body
         Console.Error.WriteLine("[DEBUG] Server ReceiveMessageAsync: Reading message body...");
         var messageBytes = new byte[messageLength];
-        await ReadExactAsync(pipeServer, messageBytes, cancellationToken);
+        await ReadExactAsync(pipeServer, messageBytes, cancellationToken).ConfigureAwait(false);
         Console.Error.WriteLine("[DEBUG] Server ReceiveMessageAsync: Complete");
 
         return Encoding.UTF8.GetString(messageBytes);
@@ -297,11 +297,11 @@ public static async Task SendMessageAsync(NamedPipeServerStream pipeServer, stri
         var lengthBytes = BitConverter.GetBytes(messageBytes.Length);
 
         // Send message length (4 bytes)
-        await pipeServer.WriteAsync(lengthBytes, 0, 4, cancellationToken);
+        await pipeServer.WriteAsync(lengthBytes, 0, 4, cancellationToken).ConfigureAwait(false);
 
         // Send message body
-        await pipeServer.WriteAsync(messageBytes, 0, messageBytes.Length, cancellationToken);
-        await pipeServer.FlushAsync(cancellationToken);
+        await pipeServer.WriteAsync(messageBytes, 0, messageBytes.Length, cancellationToken).ConfigureAwait(false);
+        await pipeServer.FlushAsync(cancellationToken).ConfigureAwait(false);
     }
 
     /// <summary>
@@ -312,7 +312,7 @@ private static async Task ReadExactAsync(NamedPipeServerStream stream, byte[] bu
         var totalBytesRead = 0;
         while (totalBytesRead < buffer.Length)
         {
-            var bytesRead = await stream.ReadAsync(buffer, totalBytesRead, buffer.Length - totalBytesRead, cancellationToken);
+            var bytesRead = await stream.ReadAsync(buffer, totalBytesRead, buffer.Length - totalBytesRead, cancellationToken).ConfigureAwait(false);
             if (bytesRead == 0)
             {
                 throw new IOException("Connection closed while reading data");