HttpListener based SSE Server Support (#73)

src/mcpdotnet/Configuration/McpServerBuilderExtensions.Transports.cs

@@ -21,4 +21,19 @@ public static partial class McpServerBuilderExtensions
         builder.Services.AddSingleton<IServerTransport, StdioServerTransport>();
         return builder;
     }
+
+    /// <summary>
+    /// Adds a server transport that uses SSE via a HttpListener for communication.
+    /// </summary>
+    /// <param name="builder">The builder instance.</param>
+    public static IMcpServerBuilder WithHttpListenerSseServerTransport(this IMcpServerBuilder builder)
+    {
+        if (builder is null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        builder.Services.AddSingleton<IServerTransport, HttpListenerSseServerTransport>();
+        return builder;
+    }
 }

src/mcpdotnet/Protocol/Transport/HttpListenerServerProvider.cs

@@ -0,0 +1,267 @@
+using McpDotNet.Server;
+using System.Diagnostics.CodeAnalysis;
+using System.Net;
+using System.Text;
+
+namespace McpDotNet.Protocol.Transport;
+
+/// <summary>
+/// HTTP server provider using HttpListener.
+/// </summary>
+[ExcludeFromCodeCoverage]
+internal class HttpListenerServerProvider : IDisposable
+{
+    private readonly int _port;
+    private readonly string _sseEndpoint = "/sse";
+    private readonly string _messageEndpoint = "/message";
+    private HttpListener? _listener;
+    private CancellationTokenSource? _cts;
+    private Func<string, CancellationToken, bool>? _messageHandler;
+    private StreamWriter? _streamWriter;
+    private bool _isRunning;
+
+    /// <summary>
+    /// Creates a new instance of the HTTP server provider.
+    /// </summary>
+    /// <param name="port">The port to listen on</param>
+    public HttpListenerServerProvider(int port)
+    {
+        _port = port;
+    }
+
+    public Task<string> GetSseEndpointUri()
+    {
+        return Task.FromResult($"http://localhost:{_port}{_sseEndpoint}");
+    }
+
+    public Task InitializeMessageHandler(Func<string, CancellationToken, bool> messageHandler)
+    {
+        _messageHandler = messageHandler;
+        return Task.CompletedTask;
+    }
+
+    public async Task SendEvent(string data, string eventId)
+    {
+        if (_streamWriter == null)
+        {
+            throw new McpServerException("Stream writer not initialized");
+        }
+        if (eventId != null)
+        {
+            await _streamWriter.WriteLineAsync($"id: {eventId}").ConfigureAwait(false);
+        }
+        await _streamWriter.WriteLineAsync($"data: {data}").ConfigureAwait(false);
+        await _streamWriter.WriteLineAsync().ConfigureAwait(false); // Empty line to finish the event
+        await _streamWriter.FlushAsync().ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public Task StartAsync(CancellationToken cancellationToken = default)
+    {
+        if (_isRunning)
+            return Task.CompletedTask;
+
+        _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        _listener = new HttpListener();
+        _listener.Prefixes.Add($"http://localhost:{_port}/");
+        _listener.Start();
+        _isRunning = true;
+
+        // Start listening for connections
+        _ = Task.Run(() => ListenForConnectionsAsync(_cts.Token), cancellationToken).ConfigureAwait(false);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc/>
+    public Task StopAsync(CancellationToken cancellationToken = default)
+    {
+        if (!_isRunning)
+            return Task.CompletedTask;
+
+        _cts?.Cancel();
+        _listener?.Stop();
+
+        _streamWriter?.Close();
+
+        _isRunning = false;
+        return Task.CompletedTask;
+    }
+
+    private async Task ListenForConnectionsAsync(CancellationToken cancellationToken)
+    {
+        if (_listener == null)
+        {
+            throw new McpServerException("Listener not initialized");
+        }
+
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            try
+            {
+                var context = await _listener.GetContextAsync().ConfigureAwait(false);
+
+                // Process the request in a separate task
+                _ = Task.Run(() => ProcessRequestAsync(context, cancellationToken), cancellationToken);
+            }
+            catch (Exception) when (cancellationToken.IsCancellationRequested)
+            {
+                // Shutdown requested, exit gracefully
+                break;
+            }
+            catch (Exception)
+            {
+                // Log error but continue listening
+                if (!cancellationToken.IsCancellationRequested)
+                {
+                    // Continue listening if not shutting down
+                    continue;
+                }
+            }
+        }
+    }
+
+    private async Task ProcessRequestAsync(HttpListenerContext context, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var request = context.Request;
+            var response = context.Response;
+
+            if (request == null)
+                throw new McpServerException("Request is null");
+
+            // Handle SSE connection
+            if (request.HttpMethod == "GET" && request.Url?.LocalPath == _sseEndpoint)
+            {
+                await HandleSseConnectionAsync(context, cancellationToken).ConfigureAwait(false);
+            }
+            // Handle message POST
+            else if (request.HttpMethod == "POST" && request.Url?.LocalPath == _messageEndpoint)
+            {
+                await HandleMessageAsync(context, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                // Not found
+                response.StatusCode = 404;
+                response.Close();
+            }
+        }
+        catch (Exception)
+        {
+            try
+            {
+                context.Response.StatusCode = 500;
+                context.Response.Close();
+            }
+            catch { /* Ignore errors during error handling */ }
+        }
+    }
+
+    private async Task HandleSseConnectionAsync(HttpListenerContext context, CancellationToken cancellationToken)
+    {
+        var response = context.Response;
+
+        // Set SSE headers
+        response.ContentType = "text/event-stream";
+        response.Headers.Add("Cache-Control", "no-cache");
+        response.Headers.Add("Connection", "keep-alive");
+
+        // Create a unique ID for this client
+        var clientId = Guid.NewGuid().ToString();
+
+        // Get the output stream and create a StreamWriter
+        var outputStream = response.OutputStream;
+        _streamWriter = new StreamWriter(outputStream, Encoding.UTF8) { AutoFlush = true };
+
+        // Keep the connection open until cancelled
+        try
+        {
+            // Immediately send the "endpoint" event with the POST URL
+            await _streamWriter.WriteLineAsync("event: endpoint").ConfigureAwait(false);
+            await _streamWriter.WriteLineAsync($"data: {_messageEndpoint}").ConfigureAwait(false);
+            await _streamWriter.WriteLineAsync().ConfigureAwait(false); // blank line to end an SSE message
+            await _streamWriter.FlushAsync(cancellationToken).ConfigureAwait(false);
+
+            // Keep the connection open by "pinging" or just waiting
+            // until the client disconnects or the server is canceled.
+            while (!cancellationToken.IsCancellationRequested && response.OutputStream.CanWrite)
+            {
+                // Do a periodic no-op to keep connection alive:
+                await _streamWriter.WriteLineAsync(": keep-alive").ConfigureAwait(false);
+                await _streamWriter.FlushAsync(cancellationToken).ConfigureAwait(false);
+                await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken).ConfigureAwait(false);
+            }
+        }
+        catch (TaskCanceledException)
+        {
+            // Normal shutdown
+        }
+        catch (Exception)
+        {
+            // Client disconnected or other error
+        }
+        finally
+        {
+            // Remove client on disconnect
+            try
+            {
+                _streamWriter.Close();
+                response.Close();
+            }
+            catch { /* Ignore errors during cleanup */ }
+        }
+    }
+
+    private async Task HandleMessageAsync(HttpListenerContext context, CancellationToken cancellationToken)
+    {
+        var request = context.Request;
+        var response = context.Response;
+
+        // Read the request body
+        string requestBody;
+        using (var reader = new StreamReader(request.InputStream, request.ContentEncoding))
+        {
+            // TODO: Add cancellation token and netstandard2.0 support (polyfill?)
+#pragma warning disable CA2016 // Forward the 'CancellationToken' parameter to methods
+            requestBody = await reader.ReadToEndAsync().ConfigureAwait(false);
+#pragma warning restore CA2016 // Forward the 'CancellationToken' parameter to methods
+        }
+
+        // Process the message asynchronously
+        if (_messageHandler != null && _messageHandler(requestBody, cancellationToken))
+        {
+            // Return 202 Accepted
+            response.StatusCode = 202;
+            // Write "accepted" response
+            // TODO: Use WriteAsync, add cancellation token and netstandard2.0 support (polyfill?)
+#pragma warning disable CA2016 // Forward the 'CancellationToken' parameter to methods
+            byte[] buffer = Encoding.UTF8.GetBytes("Accepted");
+            response.OutputStream.Write(buffer, 0, buffer.Length);
+#pragma warning restore CA2016 // Forward the 'CancellationToken' parameter to methods
+        }
+        else
+        {
+            // Return 400 Bad Request
+            response.StatusCode = 400;
+        }
+
+        response.Close();
+    }
+
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <inheritdoc/>
+    protected virtual void Dispose(bool disposing)
+    {
+        StopAsync().GetAwaiter().GetResult();
+        _cts?.Dispose();
+        _listener?.Close();
+    }
+}

src/mcpdotnet/Protocol/Transport/HttpListenerSseServerTransport.cs

@@ -0,0 +1,175 @@
+using System.Text.Json;
+using Microsoft.Extensions.Logging;
+using McpDotNet.Protocol.Messages;
+using McpDotNet.Utils.Json;
+using McpDotNet.Logging;
+using McpDotNet.Server;
+
+namespace McpDotNet.Protocol.Transport;
+
+/// <summary>
+/// Implements the MCP transport protocol over standard input/output streams.
+/// </summary>
+public sealed class HttpListenerSseServerTransport : TransportBase, IServerTransport
+{
+    private readonly string _serverName;
+    private readonly HttpListenerServerProvider _httpServerProvider;
+    private readonly ILogger<HttpListenerSseServerTransport> _logger;
+    private readonly JsonSerializerOptions _jsonOptions;
+    private CancellationTokenSource? _shutdownCts;
+    
+    private string EndpointName => $"Server (SSE) ({_serverName})";
+
+    /// <summary>
+    /// Initializes a new instance of the SseServerTransport class.
+    /// </summary>
+    /// <param name="serverOptions">The server options.</param>
+    /// <param name="port">The port to listen on.</param>
+    /// <param name="loggerFactory">A logger factory for creating loggers.</param>
+    public HttpListenerSseServerTransport(McpServerOptions serverOptions, int port, ILoggerFactory loggerFactory)
+        : this(GetServerName(serverOptions), port, loggerFactory)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the SseServerTransport class.
+    /// </summary>
+    /// <param name="serverName">The name of the server.</param>
+    /// <param name="port">The port to listen on.</param>
+    /// <param name="loggerFactory">A logger factory for creating loggers.</param>
+    public HttpListenerSseServerTransport(string serverName, int port, ILoggerFactory loggerFactory)
+        : base(loggerFactory)
+    {
+        _serverName = serverName;
+        _logger = loggerFactory.CreateLogger<HttpListenerSseServerTransport>();
+        _jsonOptions = JsonSerializerOptionsExtensions.DefaultOptions;
+        _httpServerProvider = new HttpListenerServerProvider(port);
+    }
+
+    /// <inheritdoc/>
+    public Task StartListeningAsync(CancellationToken cancellationToken = default)
+    {
+        _shutdownCts = new CancellationTokenSource();
+
+        _httpServerProvider.InitializeMessageHandler(HttpMessageHandler);
+        _httpServerProvider.StartAsync(cancellationToken);
+
+        SetConnected(true);
+
+        return Task.CompletedTask;
+    }
+
+
+    /// <inheritdoc/>
+    public override async Task SendMessageAsync(IJsonRpcMessage message, CancellationToken cancellationToken = default)
+    {
+        if (!IsConnected)
+        {
+            _logger.TransportNotConnected(EndpointName);
+            throw new McpTransportException("Transport is not connected");
+        }
+
+        string id = "(no id)";
+        if (message is IJsonRpcMessageWithId messageWithId)
+        {
+            id = messageWithId.Id.ToString();
+        }
+
+        try
+        {
+            var json = JsonSerializer.Serialize(message, _jsonOptions);
+            _logger.TransportSendingMessage(EndpointName, id, json);
+
+            await _httpServerProvider.SendEvent(json, "message").ConfigureAwait(false);
+
+            _logger.TransportSentMessage(EndpointName, id);
+        }
+        catch (Exception ex)
+        {
+            _logger.TransportSendFailed(EndpointName, id, ex);
+            throw new McpTransportException("Failed to send message", ex);
+        }
+    }
+
+    /// <inheritdoc/>
+    public override async ValueTask DisposeAsync()
+    {
+        await CleanupAsync(CancellationToken.None).ConfigureAwait(false);
+        GC.SuppressFinalize(this);
+    }
+
+    private async Task CleanupAsync(CancellationToken cancellationToken)
+    {
+        _logger.TransportCleaningUp(EndpointName);
+
+        if (_shutdownCts != null)
+        {
+            await _shutdownCts.CancelAsync().ConfigureAwait(false);
+            _shutdownCts.Dispose();
+            _shutdownCts = null;
+        }
+
+        _httpServerProvider.Dispose();
+
+        SetConnected(false);
+        _logger.TransportCleanedUp(EndpointName);
+    }
+
+    /// <summary>
+    /// Handles HTTP messages received by the HTTP server provider.
+    /// </summary>
+    /// <returns>true if the message was accepted (return 202), false otherwise (return 400)</returns>
+    private bool HttpMessageHandler(string request, CancellationToken cancellationToken)
+    {
+        _logger.TransportReceivedMessage(EndpointName, request);
+
+        try
+        {
+            var message = JsonSerializer.Deserialize<IJsonRpcMessage>(request, _jsonOptions);
+            if (message != null)
+            {
+                // Fire-and-forget the message to the message channel
+                Task.Run(async () =>
+                {
+                    string messageId = "(no id)";
+                    if (message is IJsonRpcMessageWithId messageWithId)
+                    {
+                        messageId = messageWithId.Id.ToString();
+                    }
+
+                    _logger.TransportReceivedMessageParsed(EndpointName, messageId);
+                    await WriteMessageAsync(message, cancellationToken).ConfigureAwait(false);
+                    _logger.TransportMessageWritten(EndpointName, messageId);
+                }, cancellationToken);
+
+                return true;
+            }
+            else
+            {
+                _logger.TransportMessageParseUnexpectedType(EndpointName, request);
+                return false;
+            }
+        }
+        catch (JsonException ex)
+        {
+            _logger.TransportMessageParseFailed(EndpointName, request, ex);
+            return false;
+        }
+    }
+
+    /// <summary>Validates the <paramref name="serverOptions"/> and extracts from it the server name to use.</summary>
+    private static string GetServerName(McpServerOptions serverOptions)
+    {
+        if (serverOptions is null)
+        {
+            throw new ArgumentNullException(nameof(serverOptions));
+        }
+
+        if (serverOptions.ServerInfo is null)
+        {
+            throw new ArgumentNullException($"{nameof(serverOptions)}.{nameof(serverOptions.ServerInfo)}");
+        }
+
+        return serverOptions.ServerInfo.Name;
+    }
+}

src/mcpdotnet/Protocol/Transport/SseClientTransport.cs

@@ -21,7 +21,7 @@ public sealed class SseClientTransport : TransportBase, IClientTransport
     private readonly SseClientTransportOptions _options;
     private readonly Uri _sseEndpoint;
     private Uri? _messageEndpoint;
-    private readonly CancellationTokenSource _connectionCts;
+    private CancellationTokenSource? _connectionCts;
     private Task? _receiveTask;
     private readonly ILogger _logger;
     private readonly McpServerConfig _serverConfig;
@@ -82,7 +82,7 @@ public sealed class SseClientTransport : TransportBase, IClientTransport
             }
 
             // Start message receiving loop
-            _receiveTask = ReceiveMessagesAsync(_connectionCts.Token);
+            _receiveTask = ReceiveMessagesAsync(_connectionCts!.Token);
 
             _logger.TransportReadingMessages(EndpointName);
 
@@ -168,7 +168,12 @@ public sealed class SseClientTransport : TransportBase, IClientTransport
     /// <inheritdoc/>
     public async Task CloseAsync()
     {
-        await _connectionCts.CancelAsync().ConfigureAwait(false);
+        if (_connectionCts != null)
+        {
+            await _connectionCts.CancelAsync().ConfigureAwait(false);
+            _connectionCts.Dispose();
+            _connectionCts = null;
+        }
         if (_receiveTask != null)
             await _receiveTask.ConfigureAwait(false);