fix: address review feedback on EPIPE handling

- Make close() idempotent with _closed guard
- Track pending drain reject to prevent hanging promises on EPIPE
- Add test for drain + EPIPE error interaction
- Replace em dash with double dash in comment

Author: kai-agent-free

packages/server/src/server/stdio.ts

@@ -19,6 +19,8 @@ import { process } from '@modelcontextprotocol/server/_shims';
 export class StdioServerTransport implements Transport {
     private _readBuffer: ReadBuffer = new ReadBuffer();
     private _started = false;
+    private _closed = false;
+    private _pendingDrainReject?: (reason: Error) => void;
 
     constructor(
         private _stdin: Readable = process.stdin,
@@ -39,7 +41,7 @@ export class StdioServerTransport implements Transport {
     };
     _onstdouterror = (error: NodeJS.ErrnoException) => {
         if (error.code === 'EPIPE' || error.code === 'ERR_STREAM_DESTROYED') {
-            // Client disconnected — close gracefully instead of crashing.
+            // Client disconnected -- close gracefully instead of crashing.
             void this.close();
         } else {
             this.onerror?.(error);
@@ -78,6 +80,15 @@ export class StdioServerTransport implements Transport {
     }
 
     async close(): Promise<void> {
+        if (this._closed) return;
+        this._closed = true;
+
+        // Reject any pending drain promise so send() does not hang forever
+        if (this._pendingDrainReject) {
+            this._pendingDrainReject(new Error('Transport closed before drain'));
+            this._pendingDrainReject = undefined;
+        }
+
         // Remove our event listeners first
         this._stdin.off('data', this._ondata);
         this._stdin.off('error', this._onerror);
@@ -107,7 +118,13 @@ export class StdioServerTransport implements Transport {
                 if (this._stdout.write(json)) {
                     resolve();
                 } else {
-                    this._stdout.once('drain', resolve);
+                    // Track the reject so close() can settle this promise
+                    // if an error (e.g. EPIPE) fires before drain.
+                    this._pendingDrainReject = reject;
+                    this._stdout.once('drain', () => {
+                        this._pendingDrainReject = undefined;
+                        resolve();
+                    });
                 }
             } catch (error: unknown) {
                 const errno = error as NodeJS.ErrnoException;

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

@@ -186,3 +186,45 @@ test('should remove stdout error listener on close', async () => {
 
     expect(listenersAfter).toBeLessThan(listenersBefore);
 });
+
+test('should reject send and close when EPIPE fires while waiting for drain', async () => {
+    // Create a stream where write() returns false to trigger drain waiting
+    const slowOutput = new Writable({
+        highWaterMark: 1,
+        write(_chunk, _encoding, callback) {
+            // Delay callback to keep backpressure
+            setTimeout(callback, 100);
+        }
+    });
+
+    const server = new StdioServerTransport(input, slowOutput);
+
+    let didClose = false;
+    server.onclose = () => {
+        didClose = true;
+    };
+
+    await server.start();
+
+    // Fill the buffer so write() returns false
+    const message: JSONRPCMessage = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'ping'
+    };
+
+    // Start a send that will wait for drain
+    const sendPromise = server.send(message);
+
+    // Give the event loop a tick so the write() call executes
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    // Emit EPIPE before drain fires
+    const epipeError = new Error('write EPIPE') as NodeJS.ErrnoException;
+    epipeError.code = 'EPIPE';
+    slowOutput.emit('error', epipeError);
+
+    // The send promise should reject (not hang forever)
+    await expect(sendPromise).rejects.toThrow('Transport closed before drain');
+    expect(didClose).toBeTruthy();
+});