MCP-197 Terminate the JVM properly

Author: nquinquenel

src/main/java/org/sonarsource/sonarqube/mcp/transport/StdioServerTransportProvider.java

@@ -72,29 +72,53 @@ public class StdioServerTransportProvider implements McpServerTransportProvider
   private final Sinks.One<Void> inboundReady = Sinks.one();
 
   /**
-   * Creates a new StdioServerTransportProvider with the specified ObjectMapper and
-   * System streams. Will call System.exit(0) when stdin closes (for Docker containers).
+   * Flag to indicate if we should call System.exit(0) on stdin EOF.
+   * False during tests.
+   */
+  private final boolean shouldExitOnEof;
+
+  /**
+   * Creates a new StdioServerTransportProvider with the specified ObjectMapper and system streams.
+   * Will call System.exit(0) when stdin closes, unless running in test mode.
    */
   public StdioServerTransportProvider(ObjectMapper objectMapper) {
-    this(new JacksonMcpJsonMapper(objectMapper), System.in, System.out);
+    this(new JacksonMcpJsonMapper(objectMapper), System.in, System.out, shouldExitOnStdinEof());
+  }
+
+  private static boolean shouldExitOnStdinEof() {
+    return shouldExitOnStdinEof(Thread.currentThread().getStackTrace());
+  }
+
+  static boolean shouldExitOnStdinEof(StackTraceElement[] stackTrace) {
+    // Check if we're running in test mode
+    for (var element : stackTrace) {
+      if (element.getClassName().startsWith("org.junit.")) {
+        return false;
+      }
+    }
+    return true;
   }
 
   /**
    * Creates a new StdioServerTransportProvider with the specified ObjectMapper and
-   * streams. Automatically detects if custom streams are used (tests) to disable System.exit().
-   *
-   * @param jsonMapper   The JsonMapper to use for JSON serialization/deserialization
-   * @param inputStream  The input stream to read from
-   * @param outputStream The output stream to write to
+   * streams. Custom streams disable System.exit() behavior (used for testing).
    */
   public StdioServerTransportProvider(McpJsonMapper jsonMapper, InputStream inputStream, OutputStream outputStream) {
+    this(jsonMapper, inputStream, outputStream, false);
+  }
+
+  /**
+   * Private constructor with explicit control over System.exit behavior.
+   */
+  private StdioServerTransportProvider(McpJsonMapper jsonMapper, InputStream inputStream, OutputStream outputStream, boolean shouldExitOnEof) {
     Assert.notNull(jsonMapper, "The JsonMapper can not be null");
     Assert.notNull(inputStream, "The InputStream can not be null");
     Assert.notNull(outputStream, "The OutputStream can not be null");
 
     this.jsonMapper = jsonMapper;
     this.inputStream = inputStream;
     this.outputStream = outputStream;
+    this.shouldExitOnEof = shouldExitOnEof;
   }
 
   @Override
@@ -267,6 +291,13 @@ private void startInboundProcessing() {
               session.close();
             }
             inboundSink.tryEmitComplete();
+            
+            // When stdin closes (EOF detected) in production, terminate the JVM to ensure we exit properly.
+            // In test mode, this is disabled to avoid terminating the test runner.
+            if (shouldExitOnEof) {
+              logger.info("stdin closed (EOF detected) - terminating process");
+              System.exit(0);
+            }
           }
         });
       }

src/test/java/org/sonarsource/sonarqube/mcp/transport/StdioServerTransportProviderTest.java

@@ -23,6 +23,7 @@
 import org.mockito.Mockito;
 import reactor.core.publisher.Mono;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -123,5 +124,41 @@ void closeGracefully_should_complete_immediately_if_session_closes_in_5_seconds(
     verify(mockSession, never()).close();
   }
 
+  @Test
+  void shouldExitOnStdinEof_should_return_true_for_production_stack_trace() {
+    // Simulate a production stack trace with no test frameworks
+    var stackTrace = new StackTraceElement[] {
+      new StackTraceElement("com.example.MyApp", "main", "MyApp.java", 10),
+      new StackTraceElement("com.example.MyService", "start", "MyService.java", 20),
+      new StackTraceElement("java.lang.Thread", "run", "Thread.java", 100)
+    };
+
+    boolean result = StdioServerTransportProvider.shouldExitOnStdinEof(stackTrace);
+
+    assertThat(result).isTrue();
+  }
+
+  @Test
+  void shouldExitOnStdinEof_should_return_false_when_junit_in_stack_trace() {
+    // Simulate a test stack trace with JUnit
+    var stackTrace = new StackTraceElement[] {
+      new StackTraceElement("org.junit.jupiter.engine.execution.ExecutableInvoker", "invoke", "ExecutableInvoker.java", 20)
+    };
+
+    boolean result = StdioServerTransportProvider.shouldExitOnStdinEof(stackTrace);
+
+    assertThat(result).isFalse();
+  }
+
+  @Test
+  void shouldExitOnStdinEof_should_return_true_for_empty_stack_trace() {
+    // Edge case: empty stack trace
+    var stackTrace = new StackTraceElement[] {};
+
+    boolean result = StdioServerTransportProvider.shouldExitOnStdinEof(stackTrace);
+
+    assertThat(result).isTrue();
+  }
+
 }