From e6a591bf5119e3303123d3afe1270ffb26043978 Mon Sep 17 00:00:00 2001
From: Stephen Halter <halter73@gmail.com>
Date: Mon, 7 Apr 2025 20:50:25 -0700
Subject: [PATCH 1/6] Fix StdioServerTransport.DisposeAsync hang

- It's not just Unix, it's all platforms that can hang
- Windows doesn't hang on Ctrl-C because that triggers
  the end of the Stream, but that doesn't help in IHostApplicationLifetime.StopAsync() scenarios

https://github.com/dotnet/runtime/blob/4e9627e311806330be72b7f7d3660be699878ebd/src/libraries/System.Console/src/System/ConsolePal.Unix.ConsoleStream.cs#L13
https://github.com/dotnet/runtime/blob/4e9627e311806330be72b7f7d3660be699878ebd/src/libraries/System.Console/src/System/ConsolePal.Windows.cs#L1149
---
 .../TestServerWithHosting.csproj              |  2 +-
 .../Transport/StdioServerTransport.cs         | 30 ++++++++++++-
 .../ModelContextProtocol.Tests.csproj         |  7 +++
 .../StdioServerIntegrationTests.cs            | 44 +++++++++++++++++++
 4 files changed, 81 insertions(+), 2 deletions(-)
 create mode 100644 tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs

diff --git a/samples/TestServerWithHosting/TestServerWithHosting.csproj b/samples/TestServerWithHosting/TestServerWithHosting.csproj
index 0f3918d9..d12277e2 100644
--- a/samples/TestServerWithHosting/TestServerWithHosting.csproj
+++ b/samples/TestServerWithHosting/TestServerWithHosting.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <!--
diff --git a/src/ModelContextProtocol/Protocol/Transport/StdioServerTransport.cs b/src/ModelContextProtocol/Protocol/Transport/StdioServerTransport.cs
index b3ae2e41..1d18be90 100644
--- a/src/ModelContextProtocol/Protocol/Transport/StdioServerTransport.cs
+++ b/src/ModelContextProtocol/Protocol/Transport/StdioServerTransport.cs
@@ -60,7 +60,7 @@ public StdioServerTransport(McpServerOptions serverOptions, ILoggerFactory? logg
     /// </para>
     /// </remarks>
     public StdioServerTransport(string serverName, ILoggerFactory? loggerFactory = null)
-        : base(Console.OpenStandardInput(),
+        : base(new CancellableStdinStream(Console.OpenStandardInput()),
                new BufferedStream(Console.OpenStandardOutput()),
                serverName ?? throw new ArgumentNullException(nameof(serverName)),
                loggerFactory)
@@ -73,4 +73,32 @@ private static string GetServerName(McpServerOptions serverOptions)
 
         return serverOptions.ServerInfo?.Name ?? McpServer.DefaultImplementation.Name;
     }
+
+    // Neither WindowsConsoleStream nor UnixConsoleStream respect CancellationTokens or cancel any I/O on Dispose.
+    // WindowsConsoleStream will return an EOS on Ctrl-C, but that is not the only reason the shutdownToken may fire.
+    private sealed class CancellableStdinStream(Stream stdinStream) : Stream
+    {
+        public override bool CanRead => true;
+        public override bool CanSeek => false;
+        public override bool CanWrite => false;
+
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+            => stdinStream.ReadAsync(buffer, offset, count, cancellationToken).WaitAsync(cancellationToken);
+
+#if NET
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+            => new(stdinStream.ReadAsync(buffer, cancellationToken).AsTask().WaitAsync(cancellationToken));
+#endif
+
+        public override long Length => throw new NotSupportedException();
+
+        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
+
+        public override void Flush() => throw new NotSupportedException();
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+
+        public override void SetLength(long value) => throw new NotSupportedException();
+        public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+    }
 }
diff --git a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj b/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj
index 16e6a891..a72caf55 100644
--- a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj
+++ b/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj
@@ -47,6 +47,7 @@
     <ProjectReference Include="..\..\src\ModelContextProtocol\ModelContextProtocol.csproj" />
     <ProjectReference Include="..\ModelContextProtocol.TestServer\ModelContextProtocol.TestServer.csproj" />
     <ProjectReference Include="..\ModelContextProtocol.TestSseServer\ModelContextProtocol.TestSseServer.csproj" />
+    <ProjectReference Include="..\..\samples\TestServerWithHosting\TestServerWithHosting.csproj" />
   </ItemGroup>
 
   <ItemGroup>
@@ -56,6 +57,12 @@
     <Content Condition="$([MSBuild]::IsOSPlatform('Linux'))" Include="$([System.IO.Path]::GetFullPath('$(ArtifactsBinDir)ModelContextProtocol.TestServer\$(Configuration)'))\$(TargetFramework)\TestServer.dll">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Condition="$([MSBuild]::IsOSPlatform('Windows'))" Include="$([System.IO.Path]::GetFullPath('$(ArtifactsBinDir)TestServerWithHosting\$(Configuration)'))\$(TargetFramework)\TestServerWithHosting.exe">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Condition="$([MSBuild]::IsOSPlatform('Linux'))" Include="$([System.IO.Path]::GetFullPath('$(ArtifactsBinDir)TestServerWithHosting\$(Configuration)'))\$(TargetFramework)\TestServerWithHosting.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
 
 </Project>
diff --git a/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs b/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
new file mode 100644
index 00000000..72a01329
--- /dev/null
+++ b/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
@@ -0,0 +1,44 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace ModelContextProtocol.Tests;
+
+public class StdioServerIntegrationTests
+{
+    public static bool CanSendSigInt { get; } = RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+    internal const int SIGINT = 2;
+
+    [Fact(Skip = "Platform not supported by this test.", SkipUnless = nameof(CanSendSigInt))]
+    public async Task SigInt_DisposesTestServerWithHosting_Gracefully()
+    {
+        using var process = new Process
+        {
+            StartInfo = new ProcessStartInfo
+            {
+                FileName = "dotnet",
+                Arguments = "TestServerWithHosting.dll",
+                RedirectStandardInput = true,
+                RedirectStandardOutput = true,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+            }
+        };
+
+        process.Start();
+
+        // I considered writing a similar test for windows using Ctrl-C, then saw that dotnet watch doesn't even send a Ctrl-C
+        // signal because it's such a pain without support CREATE_NEW_PROCESS_GROUP in System.Diagnostics.Process.
+        // https://github.com/dotnet/sdk/blob/43b1c12e3362098a23ca1018503eb56516840b6a/src/BuiltInTools/dotnet-watch/Internal/ProcessRunner.cs#L277-L303
+        // https://github.com/dotnet/runtime/issues/109432, https://github.com/dotnet/runtime/issues/44944
+        Assert.Equal(0, kill(process.Id, SIGINT));
+
+        using var shutdownCts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        await process.WaitForExitAsync(shutdownCts.Token);
+
+        Assert.True(process.HasExited);
+        Assert.Equal(130, process.ExitCode);
+    }
+
+    [DllImport("libc", SetLastError = true)]
+    internal static extern int kill(int pid, int sig);
+}

From 98b3879e5da7845742f0ce2e59fd206cef92b7fa Mon Sep 17 00:00:00 2001
From: Stephen Halter <halter73@gmail.com>
Date: Tue, 8 Apr 2025 01:26:23 -0700
Subject: [PATCH 2/6] Connect client before sending SIGINT in test

---
 .../StdioServerIntegrationTests.cs            | 33 +++++++++++++++++--
 1 file changed, 30 insertions(+), 3 deletions(-)

diff --git a/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs b/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
index 72a01329..b1952900 100644
--- a/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
+++ b/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
@@ -1,4 +1,6 @@
-using System.Diagnostics;
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Protocol.Transport;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 
 namespace ModelContextProtocol.Tests;
@@ -26,19 +28,44 @@ public async Task SigInt_DisposesTestServerWithHosting_Gracefully()
 
         process.Start();
 
+        await using var streamServerTransport = new StreamServerTransport(
+            process.StandardOutput.BaseStream,
+            process.StandardInput.BaseStream,
+            serverName: "TestServerWithHosting");
+
+        var serverConfig = new McpServerConfig()
+        {
+            Id = "test-server-with-hosting",
+            Name = "TestServerWithHosting",
+            TransportType = TransportTypes.StdIo,
+        };
+
+        await using var client = await McpClientFactory.CreateAsync(serverConfig,
+            createTransportFunc: (_, _) => new TestClientTransport(streamServerTransport),
+            cancellationToken: TestContext.Current.CancellationToken);
+
         // I considered writing a similar test for windows using Ctrl-C, then saw that dotnet watch doesn't even send a Ctrl-C
         // signal because it's such a pain without support CREATE_NEW_PROCESS_GROUP in System.Diagnostics.Process.
         // https://github.com/dotnet/sdk/blob/43b1c12e3362098a23ca1018503eb56516840b6a/src/BuiltInTools/dotnet-watch/Internal/ProcessRunner.cs#L277-L303
         // https://github.com/dotnet/runtime/issues/109432, https://github.com/dotnet/runtime/issues/44944
         Assert.Equal(0, kill(process.Id, SIGINT));
 
-        using var shutdownCts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        using var shutdownCts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        shutdownCts.CancelAfter(TimeSpan.FromSeconds(10));
         await process.WaitForExitAsync(shutdownCts.Token);
 
         Assert.True(process.HasExited);
-        Assert.Equal(130, process.ExitCode);
+        Assert.Equal(0, process.ExitCode);
     }
 
     [DllImport("libc", SetLastError = true)]
     internal static extern int kill(int pid, int sig);
+
+    private sealed class TestClientTransport(ITransport sessionTransport) : IClientTransport
+    {
+        public Task<ITransport> ConnectAsync(CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(sessionTransport);
+        }
+    }
 }

From f675320d64f688f57101e46316382e515f4a3e2f Mon Sep 17 00:00:00 2001
From: Stephen Halter <halter73@gmail.com>
Date: Tue, 8 Apr 2025 02:28:22 -0700
Subject: [PATCH 3/6] Use LoggedTest

---
 .../StdioServerIntegrationTests.cs               | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs b/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
index b1952900..1c4e38e8 100644
--- a/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
+++ b/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
@@ -1,14 +1,15 @@
 using ModelContextProtocol.Client;
 using ModelContextProtocol.Protocol.Transport;
+using ModelContextProtocol.Tests.Utils;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 
 namespace ModelContextProtocol.Tests;
 
-public class StdioServerIntegrationTests
+public class StdioServerIntegrationTests(ITestOutputHelper testOutputHelper) : LoggedTest(testOutputHelper)
 {
     public static bool CanSendSigInt { get; } = RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
-    internal const int SIGINT = 2;
+    private const int SIGINT = 2;
 
     [Fact(Skip = "Platform not supported by this test.", SkipUnless = nameof(CanSendSigInt))]
     public async Task SigInt_DisposesTestServerWithHosting_Gracefully()
@@ -42,10 +43,11 @@ public async Task SigInt_DisposesTestServerWithHosting_Gracefully()
 
         await using var client = await McpClientFactory.CreateAsync(serverConfig,
             createTransportFunc: (_, _) => new TestClientTransport(streamServerTransport),
+            loggerFactory: LoggerFactory,
             cancellationToken: TestContext.Current.CancellationToken);
 
-        // I considered writing a similar test for windows using Ctrl-C, then saw that dotnet watch doesn't even send a Ctrl-C
-        // signal because it's such a pain without support CREATE_NEW_PROCESS_GROUP in System.Diagnostics.Process.
+        // I considered writing a similar test for Windows using Ctrl-C, then saw that dotnet watch doesn't even send a Ctrl-C
+        // signal because it's such a pain without support for CREATE_NEW_PROCESS_GROUP in System.Diagnostics.Process.
         // https://github.com/dotnet/sdk/blob/43b1c12e3362098a23ca1018503eb56516840b6a/src/BuiltInTools/dotnet-watch/Internal/ProcessRunner.cs#L277-L303
         // https://github.com/dotnet/runtime/issues/109432, https://github.com/dotnet/runtime/issues/44944
         Assert.Equal(0, kill(process.Id, SIGINT));
@@ -59,13 +61,11 @@ public async Task SigInt_DisposesTestServerWithHosting_Gracefully()
     }
 
     [DllImport("libc", SetLastError = true)]
-    internal static extern int kill(int pid, int sig);
+    private static extern int kill(int pid, int sig);
 
     private sealed class TestClientTransport(ITransport sessionTransport) : IClientTransport
     {
         public Task<ITransport> ConnectAsync(CancellationToken cancellationToken = default)
-        {
-            return Task.FromResult(sessionTransport);
-        }
+            => Task.FromResult(sessionTransport);
     }
 }

From d3a54d7d08d7df318d50f6ad005e8d7c53b2ce9f Mon Sep 17 00:00:00 2001
From: Stephen Halter <halter73@gmail.com>
Date: Tue, 8 Apr 2025 09:11:26 -0700
Subject: [PATCH 4/6] Address PR feedback

---
 .../Protocol/Transport/StdioServerTransport.cs           | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/ModelContextProtocol/Protocol/Transport/StdioServerTransport.cs b/src/ModelContextProtocol/Protocol/Transport/StdioServerTransport.cs
index 1d18be90..4fa79125 100644
--- a/src/ModelContextProtocol/Protocol/Transport/StdioServerTransport.cs
+++ b/src/ModelContextProtocol/Protocol/Transport/StdioServerTransport.cs
@@ -87,14 +87,19 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
 
 #if NET
         public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
-            => new(stdinStream.ReadAsync(buffer, cancellationToken).AsTask().WaitAsync(cancellationToken));
+        {
+            ValueTask<int> vt = stdinStream.ReadAsync(buffer, cancellationToken);
+            return vt.IsCompletedSuccessfully ? vt : new(vt.AsTask().WaitAsync(cancellationToken));
+        }
 #endif
 
+        // The McpServer shouldn't call flush on the stdin Stream, but it doesn't need to throw just in case.
+        public override void Flush() { }
+
         public override long Length => throw new NotSupportedException();
 
         public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
 
-        public override void Flush() => throw new NotSupportedException();
         public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
         public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
 

From b9e2ef6c866892798342dda3b50c452a4356d771 Mon Sep 17 00:00:00 2001
From: Stephen Halter <halter73@gmail.com>
Date: Tue, 8 Apr 2025 10:06:03 -0700
Subject: [PATCH 5/6] React to IClientTransport and McpClientFactoryChanges

---
 .../StdioServerIntegrationTests.cs                  | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs b/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
index 1c4e38e8..a28821fb 100644
--- a/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
+++ b/tests/ModelContextProtocol.Tests/StdioServerIntegrationTests.cs
@@ -34,15 +34,8 @@ public async Task SigInt_DisposesTestServerWithHosting_Gracefully()
             process.StandardInput.BaseStream,
             serverName: "TestServerWithHosting");
 
-        var serverConfig = new McpServerConfig()
-        {
-            Id = "test-server-with-hosting",
-            Name = "TestServerWithHosting",
-            TransportType = TransportTypes.StdIo,
-        };
-
-        await using var client = await McpClientFactory.CreateAsync(serverConfig,
-            createTransportFunc: (_, _) => new TestClientTransport(streamServerTransport),
+        await using var client = await McpClientFactory.CreateAsync(
+            new TestClientTransport(streamServerTransport),
             loggerFactory: LoggerFactory,
             cancellationToken: TestContext.Current.CancellationToken);
 
@@ -65,6 +58,8 @@ public async Task SigInt_DisposesTestServerWithHosting_Gracefully()
 
     private sealed class TestClientTransport(ITransport sessionTransport) : IClientTransport
     {
+        public string Name => nameof(TestClientTransport);
+
         public Task<ITransport> ConnectAsync(CancellationToken cancellationToken = default)
             => Task.FromResult(sessionTransport);
     }

From a8666128dffcda98ab50e1587bec4b80a1bdef61 Mon Sep 17 00:00:00 2001
From: Stephen Halter <halter73@gmail.com>
Date: Mon, 7 Apr 2025 15:12:02 -0700
Subject: [PATCH 6/6] More KestrelInMemoryConnection cleanup

---
 .../Utils/KestrelInMemoryConnection.cs               | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/ModelContextProtocol.Tests/Utils/KestrelInMemoryConnection.cs b/tests/ModelContextProtocol.Tests/Utils/KestrelInMemoryConnection.cs
index d0f1036d..c823261c 100644
--- a/tests/ModelContextProtocol.Tests/Utils/KestrelInMemoryConnection.cs
+++ b/tests/ModelContextProtocol.Tests/Utils/KestrelInMemoryConnection.cs
@@ -8,8 +8,8 @@ public sealed class KestrelInMemoryConnection : ConnectionContext
 {
     private readonly Pipe _clientToServerPipe = new();
     private readonly Pipe _serverToClientPipe = new();
-    private readonly CancellationTokenSource _connectionClosedCts = new CancellationTokenSource();
-    private readonly IFeatureCollection _features = new FeatureCollection();
+    private readonly CancellationTokenSource _connectionClosedCts = new();
+    private readonly FeatureCollection _features = new();
 
     public KestrelInMemoryConnection()
     {
@@ -37,17 +37,17 @@ public KestrelInMemoryConnection()
 
     public override IDictionary<object, object?> Items { get; set; } = new Dictionary<object, object?>();
 
-    public override ValueTask DisposeAsync()
+    public override async ValueTask DisposeAsync()
     {
         // This is called by Kestrel. The client should dispose the DuplexStream which
         // completes the other half of these pipes.
-        _serverToClientPipe.Writer.Complete();
-        _serverToClientPipe.Reader.Complete();
+        await _serverToClientPipe.Writer.CompleteAsync();
+        await _serverToClientPipe.Reader.CompleteAsync();
 
         // Don't bother disposing the _connectionClosedCts, since this is just for testing,
         // and it's annoying to synchronize with DuplexStream.
 
-        return base.DisposeAsync();
+        await base.DisposeAsync();
     }
 
     private class DuplexPipe : IDuplexPipe