feat(server): close StdioServerTransport on stdin EOF

Listen for the stdin `end` event to detect when the host process exits
or is killed, and close the transport accordingly. This prevents
orphaned server processes when the host terminates without cleanly
shutting down the server.

Replaces the previous watchdog approach with the simpler stdin EOF
pattern used by the Python and Kotlin SDKs.

Co-Authored-By: Tadao <tadao@travisfixes.com>

Author: travisbreaks

.changeset/server-host-watchdog.md

@@ -0,0 +1,5 @@
+---
+'@modelcontextprotocol/server': patch
+---
+
+Close StdioServerTransport when stdin reaches EOF. When the host process exits or is killed, the stdin pipe closes and the transport now detects this via the `end` event, preventing orphaned server processes. Aligns with the behavior of the Python and Kotlin SDKs.

packages/server/src/server/stdio.ts

@@ -38,10 +38,13 @@ export class StdioServerTransport implements Transport {
     _onerror = (error: Error) => {
         this.onerror?.(error);
     };
+    _onend = () => {
+        void this.close().catch(error => this.onerror?.(error));
+    };
     _onstdouterror = (error: Error) => {
         this.onerror?.(error);
         this.close().catch(() => {
-            // Ignore errors during close — we're already in an error path
+            // Ignore errors during close -- we're already in an error path
         });
     };
 
@@ -58,6 +61,7 @@ export class StdioServerTransport implements Transport {
         this._started = true;
         this._stdin.on('data', this._ondata);
         this._stdin.on('error', this._onerror);
+        this._stdin.on('end', this._onend);
         this._stdout.on('error', this._onstdouterror);
     }
 
@@ -85,6 +89,7 @@ export class StdioServerTransport implements Transport {
         // Remove our event listeners first
         this._stdin.off('data', this._ondata);
         this._stdin.off('error', this._onerror);
+        this._stdin.off('end', this._onend);
         this._stdout.off('error', this._onstdouterror);
 
         // Check if we were the only data listener

packages/server/test/server/stdio.test.ts

@@ -179,3 +179,51 @@ test('should fire onerror before onclose on stdout error', async () => {
 
     expect(events).toEqual(['error', 'close']);
 });
+
+describe('stdin EOF', () => {
+    test('should close transport when stdin emits end', async () => {
+        const server = new StdioServerTransport(input, output);
+
+        const closed = new Promise<void>(resolve => {
+            server.onclose = () => resolve();
+        });
+
+        await server.start();
+
+        // Simulate the host process closing stdin (pipe EOF)
+        input.push(null);
+
+        await closed;
+    });
+
+    test('should not fire onclose twice when close() is called after stdin end', async () => {
+        const server = new StdioServerTransport(input, output);
+
+        let closeCount = 0;
+        server.onclose = () => {
+            closeCount++;
+        };
+
+        await server.start();
+        input.push(null);
+
+        // Give the end event time to propagate
+        await new Promise(resolve => setTimeout(resolve, 50));
+
+        await server.close();
+        expect(closeCount).toBe(1);
+    });
+
+    test('should remove end listener on close', async () => {
+        const server = new StdioServerTransport(input, output);
+        await server.start();
+
+        const endListenersBefore = input.listenerCount('end');
+        expect(endListenersBefore).toBeGreaterThan(0);
+
+        await server.close();
+
+        const endListenersAfter = input.listenerCount('end');
+        expect(endListenersAfter).toBe(0);
+    });
+});