refactor(mcp): Simplify shutdown and lifecycle code

Remove dead code paths, redundant wrappers, and duplicated type
definitions across the MCP shutdown pipeline for clarity.

Author: cameroncooke

src/mcp/tools/swift-package/active-processes.ts

@@ -1,7 +1,8 @@
 /**
- * Shared process state management for Swift Package tools
- * This module provides a centralized way to manage active processes
- * between swift_package_run and swift_package_stop tools
+ * Shared process state management for Swift Package tools.
+ *
+ * Tracks active child processes so they can be individually stopped
+ * or bulk-terminated during server shutdown.
  */
 
 interface TrackedProcess {
@@ -25,28 +26,28 @@ export interface ProcessInfo {
 
 export const activeProcesses = new Map<number, ProcessInfo>();
 
-export const getProcess = (pid: number): ProcessInfo | undefined => {
+export function getProcess(pid: number): ProcessInfo | undefined {
   return activeProcesses.get(pid);
-};
+}
 
-export const addProcess = (pid: number, processInfo: ProcessInfo): void => {
+export function addProcess(pid: number, processInfo: ProcessInfo): void {
   const existing = activeProcesses.get(pid);
   existing?.releaseActivity?.();
   activeProcesses.set(pid, processInfo);
-};
+}
 
-export const removeProcess = (pid: number): boolean => {
+export function removeProcess(pid: number): boolean {
   const existing = activeProcesses.get(pid);
   existing?.releaseActivity?.();
   return activeProcesses.delete(pid);
-};
+}
 
-export const clearAllProcesses = (): void => {
+export function clearAllProcesses(): void {
   for (const processInfo of activeProcesses.values()) {
     processInfo.releaseActivity?.();
   }
   activeProcesses.clear();
-};
+}
 
 function createTimeoutPromise(timeoutMs: number): Promise<'timed_out'> {
   return new Promise((resolve) => {
@@ -79,7 +80,7 @@ async function terminateProcess(
       return;
     }
     info.process.on('exit', onExit);
-  }).catch(() => 'exited' as const);
+  });
 
   const outcome = await Promise.race([exitPromise, createTimeoutPromise(timeoutMs)]);
   if (outcome === 'timed_out') {

src/server/mcp-lifecycle.ts

@@ -74,20 +74,15 @@ interface PeerProcessSample {
   peers: McpPeerProcessSummary[];
 }
 
-interface LifecycleStdinLike {
-  once(event: string, listener: (...args: unknown[]) => void): this;
-  removeListener(event: string, listener: (...args: unknown[]) => void): this;
-}
-
-interface LifecycleStdoutLike {
+interface LifecycleStreamLike {
   once(event: string, listener: (...args: unknown[]) => void): this;
   removeListener(event: string, listener: (...args: unknown[]) => void): this;
 }
 
 interface LifecycleProcessLike {
-  stdin: LifecycleStdinLike;
-  stdout?: LifecycleStdoutLike;
-  stderr?: LifecycleStdoutLike;
+  stdin: LifecycleStreamLike;
+  stdout?: LifecycleStreamLike;
+  stderr?: LifecycleStreamLike;
   once(event: string, listener: (...args: unknown[]) => void): this;
   removeListener(event: string, listener: (...args: unknown[]) => void): this;
 }
@@ -178,7 +173,7 @@ export function classifyMcpLifecycleAnomalies(
     anomalies.add('long-lived-high-rss');
   }
 
-  return Array.from(anomalies.values()).sort();
+  return [...anomalies].sort();
 }
 
 function isLikelyMcpProcessCommand(command: string): boolean {

src/server/mcp-shutdown.ts

@@ -166,13 +166,8 @@ export async function runMcpShutdown(input: {
   });
   pushStep('server.close', serverCloseOutcome);
 
-  const perItemTimeoutMs = STEP_TIMEOUT_MS;
   const bulkStepTimeoutMs = (itemCount: number): number => {
-    const boundedCount = Math.max(1, itemCount);
-    return Math.max(
-      STEP_TIMEOUT_MS + STEP_TIMEOUT_HEADROOM_MS,
-      boundedCount * perItemTimeoutMs + STEP_TIMEOUT_HEADROOM_MS,
-    );
+    return Math.max(1, itemCount) * STEP_TIMEOUT_MS + STEP_TIMEOUT_HEADROOM_MS;
   };
 
   const debuggerStepTimeoutMs = (debuggerSessionCount: number): number => {
@@ -202,22 +197,22 @@ export async function runMcpShutdown(input: {
     {
       name: 'simulator-logs.stop-all',
       timeoutMs: bulkStepTimeoutMs(input.snapshot.simulatorLogSessionCount),
-      operation: () => stopAllLogCaptures(perItemTimeoutMs),
+      operation: () => stopAllLogCaptures(STEP_TIMEOUT_MS),
     },
     {
       name: 'device-logs.stop-all',
       timeoutMs: bulkStepTimeoutMs(input.snapshot.deviceLogSessionCount),
-      operation: () => stopAllDeviceLogCaptures(perItemTimeoutMs),
+      operation: () => stopAllDeviceLogCaptures(STEP_TIMEOUT_MS),
     },
     {
       name: 'video-capture.stop-all',
       timeoutMs: bulkStepTimeoutMs(input.snapshot.videoCaptureSessionCount),
-      operation: () => stopAllVideoCaptureSessions(perItemTimeoutMs),
+      operation: () => stopAllVideoCaptureSessions(STEP_TIMEOUT_MS),
     },
     {
       name: 'swift-processes.stop-all',
       timeoutMs: bulkStepTimeoutMs(input.snapshot.swiftPackageProcessCount),
-      operation: () => stopAllTrackedProcesses(perItemTimeoutMs),
+      operation: () => stopAllTrackedProcesses(STEP_TIMEOUT_MS),
     },
   ];
 

src/server/start-mcp-server.ts

@@ -18,7 +18,6 @@ import {
 } from '../utils/sentry.ts';
 import { version } from '../version.ts';
 import process from 'node:process';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { bootstrapServer } from './bootstrap.ts';
 import { createStartupProfiler, getStartupProfileNowMs } from './startup-profiler.ts';
 import { getConfig } from '../utils/config-store.ts';
@@ -38,17 +37,13 @@ export async function startMcpServer(): Promise<void> {
       const isCrash = reason === 'uncaught-exception' || reason === 'unhandled-rejection';
       const event = isCrash ? 'crash' : 'shutdown';
 
-      if (reason === 'stdin-end') {
-        log('info', 'MCP stdin ended; shutting down MCP server');
-      } else if (reason === 'stdin-close') {
-        log('info', 'MCP stdin closed; shutting down MCP server');
-      } else if (reason === 'stdout-error') {
-        log('info', 'MCP stdout pipe broke; shutting down MCP server');
-      } else if (reason === 'stderr-error') {
-        log('info', 'MCP stderr pipe broke; shutting down MCP server');
-      } else {
-        log('info', `MCP shutdown requested: ${reason}`);
-      }
+      const transportMessages: Record<string, string> = {
+        'stdin-end': 'MCP stdin ended; shutting down MCP server',
+        'stdin-close': 'MCP stdin closed; shutting down MCP server',
+        'stdout-error': 'MCP stdout pipe broke; shutting down MCP server',
+        'stderr-error': 'MCP stderr pipe broke; shutting down MCP server',
+      };
+      log('info', transportMessages[reason] ?? `MCP shutdown requested: ${reason}`);
 
       if (!isTransportDisconnectReason(reason)) {
         recordMcpLifecycleMetric({
@@ -75,7 +70,7 @@ export async function startMcpServer(): Promise<void> {
         reason,
         error,
         snapshot,
-        server: server ? ({ close: () => server.close() } as Pick<McpServer, 'close'>) : null,
+        server,
       });
 
       lifecycle.detachProcessHandlers();

src/utils/sentry.ts

@@ -7,6 +7,7 @@
 import * as Sentry from '@sentry/node';
 import { version } from '../version.ts';
 import { isSentryCaptureSealed } from './shutdown-state.ts';
+
 const USER_HOME_PATH_PATTERN = /\/Users\/[^/\s]+/g;
 const XCODE_VERSION_PATTERN = /^Xcode\s+(.+)$/m;
 const XCODE_BUILD_PATTERN = /^Build version\s+(.+)$/m;
@@ -400,20 +401,22 @@ export function captureMcpShutdownSummary(summary: McpShutdownSummaryEvent): voi
   }
 
   try {
-    const anomalies =
-      (summary.snapshot as { anomalies?: unknown }).anomalies &&
-      Array.isArray((summary.snapshot as { anomalies?: unknown }).anomalies)
-        ? (summary.snapshot as { anomalies: unknown[] }).anomalies.length
-        : 0;
+    const snapshotAnomalies = (summary.snapshot as { anomalies?: unknown }).anomalies;
+    const anomalyCount = Array.isArray(snapshotAnomalies) ? snapshotAnomalies.length : 0;
 
-    const level =
+    const isCrashReason =
       summary.reason === 'startup-failure' ||
       summary.reason === 'uncaught-exception' ||
-      summary.reason === 'unhandled-rejection'
-        ? 'error'
-        : summary.cleanupFailureCount > 0 || anomalies > 0
-          ? 'warning'
-          : 'info';
+      summary.reason === 'unhandled-rejection';
+
+    let level: 'error' | 'warning' | 'info';
+    if (isCrashReason) {
+      level = 'error';
+    } else if (summary.cleanupFailureCount > 0 || anomalyCount > 0) {
+      level = 'warning';
+    } else {
+      level = 'info';
+    }
 
     Sentry.captureEvent({
       level,

src/utils/shutdown-state.ts

@@ -1,3 +1,5 @@
+import process from 'node:process';
+
 type WritableMethod = (chunk: unknown, encoding?: unknown, callback?: unknown) => boolean;
 
 interface StdioWriteTarget {
@@ -10,20 +12,12 @@ let originalStdoutWrite: WritableMethod | null = null;
 let originalStderrWrite: WritableMethod | null = null;
 
 function createSuppressedWrite(): WritableMethod {
-  return (chunk: unknown, encoding?: unknown, callback?: unknown): boolean => {
-    const maybeEncoding = typeof encoding === 'function' ? undefined : encoding;
-    const maybeCallback =
-      typeof encoding === 'function'
-        ? encoding
-        : typeof callback === 'function'
-          ? callback
-          : undefined;
-
-    void chunk;
-    void maybeEncoding;
-
-    if (typeof maybeCallback === 'function') {
-      queueMicrotask(() => maybeCallback(null));
+  return (_chunk: unknown, encoding?: unknown, callback?: unknown): boolean => {
+    const resolvedCallback =
+      typeof encoding === 'function' ? encoding : typeof callback === 'function' ? callback : null;
+
+    if (typeof resolvedCallback === 'function') {
+      queueMicrotask(() => resolvedCallback(null));
     }
 
     return true;