fix(stdio): exit cleanly when fatal logging hits a dead pipe (#1276)

## Summary
Fixes #1274. When the MCP client dies and closes stderr, the old fatal
handlers could throw while logging, get re-invoked forever, and leave
orphaned processes spinning at 100%+ CPU.

### Key Changes
- One shared exit path for uncaught exceptions, unhandled rejections,
and stdio startup failures
- Catch logging/reporting failures so a dead stderr cannot throw inside
the handler
- Always `process.exit(1)`, including a timeout if Sentry flush hangs

### Breaking Changes
- None

<!-- junior-request-attribution:start -->
Requested by **David Cramer**.
<!-- junior-request-attribution:end -->

<!-- junior-session-footer:start -->
<!-- junior-conversation-id:slack%3AC08J1NSPU6S%3A1787941530.610869 -->

--

[View Junior
Session](https://junior-prod.sentry.dev/conversations/slack%3AC08J1NSPU6S%3A1787941530.610869)
[[Sentry]](https://sentry.sentry.io/explore/conversations/slack%3AC08J1NSPU6S%3A1787941530.610869/?project=4510944073809921)

<!-- junior-session-footer:end -->

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: David Cramer <david@sentry.io>

Author: sentry-junior[bot]

packages/mcp-server/src/index.ts

@@ -324,19 +324,41 @@ async function main() {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 
-  // Uncaught error handlers
-  process.on("uncaughtException", async (error) => {
-    console.error("Uncaught exception:", error);
-    Sentry.captureException(error);
-    await Sentry.flush(SENTRY_TIMEOUT);
-    process.exit(1);
+  // If the client dies and closes all pipes, console.error can throw EPIPE
+  // inside these handlers. Without a guard, that recurses forever and burns CPU.
+  // See getsentry/sentry-mcp#1274.
+  let exiting = false;
+  function exitAfterError(error: unknown, label: string) {
+    if (exiting) {
+      process.exit(1);
+      return;
+    }
+    exiting = true;
+
+    try {
+      console.error(label, error);
+    } catch {
+      // stderr may already be closed
+    }
+
+    try {
+      Sentry.captureException(error);
+    } catch {
+      // reporting must not block exit
+    }
+
+    // Don't depend on flush finishing — exit even if it hangs or rejects.
+    const timer = setTimeout(() => process.exit(1), SENTRY_TIMEOUT);
+    timer.unref();
+    void Sentry.flush(SENTRY_TIMEOUT).finally(() => process.exit(1));
+  }
+
+  process.on("uncaughtException", (error) => {
+    exitAfterError(error, "Uncaught exception:");
   });
 
-  process.on("unhandledRejection", async (reason) => {
-    console.error("Unhandled rejection:", reason);
-    Sentry.captureException(reason);
-    await Sentry.flush(SENTRY_TIMEOUT);
-    process.exit(1);
+  process.on("unhandledRejection", (reason) => {
+    exitAfterError(reason, "Unhandled rejection:");
   });
 
   const context = {
@@ -362,11 +384,8 @@ async function main() {
     experimentalMode: cli.experimental,
   });
 
-  startStdio(server, context).catch(async (err) => {
-    console.error("Server error:", err);
-    Sentry.captureException(err);
-    await Sentry.flush(SENTRY_TIMEOUT);
-    process.exit(1);
+  startStdio(server, context).catch((err) => {
+    exitAfterError(err, "Server error:");
   });
 }