Handle stdin EOF gracefully in MCP stdio mode (#3428) (#3647)

## Why make this change?

When `dab start --mcp-stdio` was launched by a client (such as MCP
Inspector or VS Code) and the client closed the stdin pipe (EOF), the
process crashed with exit code `4294967295` instead of exiting cleanly.
This caused noisy error signals in any tool or host that expected a
clean `0` exit on shutdown.

## What is this change?

Modified `McpStdioServer.RunAsync` to handle stdin EOF as a normal
shutdown signal:

- Replaced direct `Console.OpenStandardInput()` + `StreamReader` with
`Console.In` (testable, injectable)
- Added explicit `null` check on the return value of `ReadLineAsync` —
`null` means EOF, which now triggers a clean `return` instead of an
unhandled exception
- Blank lines continue to be skipped as before

## How was this tested?

### Unit Tests
Added `McpStdioServerRunAsyncTests`:
- `RunAsync_EofOnStdin_ExitsGracefullyWithoutOutput` — feeds empty
stdin, verifies clean exit with no stdout output
- `RunAsync_BlankLineThenShutdown_IgnoresBlankLineAndHandlesShutdown` —
feeds blank line + shutdown request, verifies single valid response and
clean exit

### Manual Testing
- Reproduced the exact reported scenario: piped an `initialize` request
then closed stdin — verified `EXIT_CODE=0`
  ```
echo '{"jsonrpc":"2.0","method":"initialize",...,"id":1}' | dab start
--config dab-config.json --mcp-stdio
  echo "Exit code: $?"   # was 4294967295, now 0
  ```
- Verified `EXIT_CODE=0` for normal `shutdown` request path
- Verified successful MCP tool calls (`read_records`,
`describe_entities`) continue to work after the change

Author: anushakolan

src/Azure.DataApiBuilder.Mcp/Core/McpStdioServer.cs

@@ -28,6 +28,7 @@ public class McpStdioServer : IMcpStdioServer
         private readonly McpToolRegistry _toolRegistry;
         private readonly IServiceProvider _serviceProvider;
         private readonly McpStdoutWriter _stdoutWriter;
+        private readonly TextReader? _inputReader;
         private readonly string _protocolVersion;
 
         private const int MAX_LINE_LENGTH = 1024 * 1024; // 1 MB limit for incoming JSON-RPC requests
@@ -39,10 +40,11 @@ public class McpStdioServer : IMcpStdioServer
             DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
         };
 
-        public McpStdioServer(McpToolRegistry toolRegistry, IServiceProvider serviceProvider)
+        public McpStdioServer(McpToolRegistry toolRegistry, IServiceProvider serviceProvider, TextReader? inputReader = null)
         {
             _toolRegistry = toolRegistry ?? throw new ArgumentNullException(nameof(toolRegistry));
             _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
+            _inputReader = inputReader;
 
             // Resolve the shared stdout writer so JSON-RPC responses and
             // notifications/message frames are serialized through one lock.
@@ -61,17 +63,20 @@ public McpStdioServer(McpToolRegistry toolRegistry, IServiceProvider serviceProv
         /// <returns>A task representing the asynchronous operation.</returns>
         public async Task RunAsync(CancellationToken cancellationToken)
         {
-            // Use UTF-8 WITHOUT BOM for stdin. Stdout is owned by McpStdoutWriter,
-            // which serializes all writes from McpStdioServer and the MCP logging
-            // pipeline so JSON-RPC frames cannot interleave at the byte level.
-            UTF8Encoding utf8NoBom = new(encoderShouldEmitUTF8Identifier: false);
-
-            using Stream stdin = Console.OpenStandardInput();
-            using StreamReader reader = new(stdin, utf8NoBom);
+            // By default read via Console.In so the loop honors the configured
+            // Console.InputEncoding in stdio mode.
+            TextReader reader = _inputReader ?? Console.In;
 
             while (!cancellationToken.IsCancellationRequested)
             {
                 string? line = await reader.ReadLineAsync(cancellationToken);
+
+                // EOF (stdin pipe closed) is a normal shutdown signal for stdio mode.
+                if (line is null)
+                {
+                    return;
+                }
+
                 if (string.IsNullOrWhiteSpace(line))
                 {
                     continue;

src/Service.Tests/UnitTests/McpStdioServerRunAsyncTests.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#nullable enable
+
+using System;
+using System.IO;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.DataApiBuilder.Mcp.Core;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Azure.DataApiBuilder.Service.Tests.UnitTests
+{
+    [TestClass]
+    public class McpStdioServerRunAsyncTests
+    {
+        [TestMethod]
+        public async Task RunAsync_EofOnStdin_ExitsGracefullyWithoutOutput()
+        {
+            // Empty input immediately yields EOF (ReadLineAsync returns null).
+            (McpStdioServer server, StringWriter stdoutCapture) =
+                CreateServerWithCapturedOutput(new StringReader(string.Empty));
+
+            await server.RunAsync(CancellationToken.None);
+
+            Assert.AreEqual(string.Empty, stdoutCapture.ToString(),
+                "Server should exit cleanly on EOF without emitting protocol output.");
+        }
+
+        [TestMethod]
+        public async Task RunAsync_BlankLineThenShutdown_IgnoresBlankLineAndHandlesShutdown()
+        {
+            (McpStdioServer server, StringWriter stdoutCapture) =
+                CreateServerWithCapturedOutput(new StringReader(Environment.NewLine +
+                    "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"shutdown\"}" +
+                    Environment.NewLine));
+
+            await server.RunAsync(CancellationToken.None);
+
+            string[] lines = stdoutCapture
+                .ToString()
+                .Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+
+            Assert.AreEqual(1, lines.Length,
+                "Expected a single response line for shutdown request.");
+
+            using JsonDocument response = JsonDocument.Parse(lines[0]);
+            JsonElement root = response.RootElement;
+
+            Assert.AreEqual("2.0", root.GetProperty("jsonrpc").GetString(),
+                "Expected jsonrpc version 2.0 in shutdown response.");
+            Assert.AreEqual(1, root.GetProperty("id").GetInt32(),
+                "Expected shutdown response id to match request id.");
+            Assert.IsTrue(root.GetProperty("result").GetProperty("ok").GetBoolean(),
+                "Expected shutdown response result.ok to be true.");
+        }
+
+        private static (McpStdioServer server, StringWriter stdoutCapture) CreateServerWithCapturedOutput(TextReader inputReader)
+        {
+            StringWriter stdoutCapture = new();
+            McpStdoutWriter stdoutWriter = new(stdoutCapture);
+
+            ServiceCollection services = new();
+            services.AddSingleton(stdoutWriter);
+            services.AddSingleton<McpToolRegistry>();
+            IServiceProvider serviceProvider = services.BuildServiceProvider();
+
+            McpStdioServer server = new(
+                serviceProvider.GetRequiredService<McpToolRegistry>(),
+                serviceProvider,
+                inputReader);
+
+            return (server, stdoutCapture);
+        }
+    }
+}