MCP-198 Immediately start up the MCP and dynamically load tools

Author: nquinquenel

src/main/java/org/sonarsource/sonarqube/mcp/SonarQubeMcpServer.java

@@ -17,6 +17,7 @@
 package org.sonarsource.sonarqube.mcp;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
 import io.modelcontextprotocol.server.McpServer;
 import io.modelcontextprotocol.server.McpServerFeatures;
 import io.modelcontextprotocol.server.McpSyncServer;
@@ -28,6 +29,9 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import java.util.function.Function;
 import javax.annotation.Nullable;
 import org.sonarsource.sonarqube.mcp.bridge.SonarQubeIdeBridgeClient;
@@ -96,6 +100,7 @@ public class SonarQubeMcpServer implements ServerApiProvider {
   private McpSyncServer syncServer;
   private volatile boolean isShutdown = false;
   private boolean logFileLocationLogged;
+  private final CompletableFuture<Void> initializationFuture = new CompletableFuture<>();
 
   public static void main(String[] args) {
     new SonarQubeMcpServer(System.getenv()).start();
@@ -124,31 +129,122 @@ public SonarQubeMcpServer(Map<String, String> environment) {
       this.transportProvider = new StdioServerTransportProvider(new ObjectMapper());
     }
 
-    initializeServices();
+    initializeBasicServices();
   }
 
-  private void initializeServices() {
+
+
+  public void start() {
+    // Start HTTP server if enabled
+    if (httpServerManager != null) {
+      LOG.info("Starting HTTP server on " + mcpConfiguration.getHttpHost() + ":" + mcpConfiguration.getHttpPort() + "...");
+      httpServerManager.startServer().join();
+      LOG.info("HTTP server started");
+    }
+
+    // Build and start MCP server immediately with NO tools
+    // Tools will be added dynamically once background initialization completes
+    Function<Object, McpSyncServer> serverBuilder = provider -> {
+      var builder = switch (provider) {
+        case McpServerTransportProvider p -> McpServer.sync(p);
+        case McpStreamableServerTransportProvider p -> McpServer.sync(p);
+        default -> throw new IllegalArgumentException("Unsupported transport provider type: " + provider.getClass().getName());
+      };
+      return builder
+        .serverInfo(new McpSchema.Implementation(SONARQUBE_MCP_SERVER_NAME, mcpConfiguration.getAppVersion()))
+        .instructions("Transform your code quality workflow with SonarQube integration. " +
+          "Analyze code, monitor project health, investigate issues, and understand quality gates. " +
+          "Note: Tools are being loaded in the background and will be available shortly.")
+        .capabilities(McpSchema.ServerCapabilities.builder().tools(true).logging().build())
+        // Start with no tools - they will be added dynamically after initialization
+        .build();
+    };
+
+    syncServer = serverBuilder.apply(transportProvider);
+
+    Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown));
+
+    logInitialization();
+
+    // Start background initialization in a separate thread
+    CompletableFuture.runAsync(this::initializeBackgroundServices)
+      .exceptionally(ex -> {
+        LOG.error("Fatal error during background initialization", ex);
+        return null;
+      });
+  }
+
+  /**
+   * Quick initialization - only creates basic services needed for configuration validation.
+   * Heavy operations (version check, plugin download, backend init) are deferred to background.
+   */
+  private void initializeBasicServices() {
     this.backendService = new BackendService(mcpConfiguration);
     this.httpClientProvider = new HttpClientProvider(mcpConfiguration.getUserAgent());
-    this.toolExecutor = new ToolExecutor(backendService);
+    this.toolExecutor = new ToolExecutor(backendService, initializationFuture);
 
-    PluginsSynchronizer pluginsSynchronizer;
+    // Create ServerApi and SonarQubeVersionChecker early (doesn't make network calls yet)
+    // This allows initTools() to reference sonarQubeVersionChecker before background init completes
     if (mcpConfiguration.isHttpEnabled()) {
       var initServerApi = createServerApiWithToken(mcpConfiguration.getSonarQubeToken());
       this.sonarQubeVersionChecker = new SonarQubeVersionChecker(initServerApi);
-      pluginsSynchronizer = new PluginsSynchronizer(initServerApi, mcpConfiguration.getStoragePath());
     } else {
       this.serverApi = initializeServerApi(mcpConfiguration);
       this.sonarQubeVersionChecker = new SonarQubeVersionChecker(serverApi);
-      pluginsSynchronizer = new PluginsSynchronizer(serverApi, mcpConfiguration.getStoragePath());
     }
-    sonarQubeVersionChecker.failIfSonarQubeServerVersionIsNotSupported();
-    var analyzers = pluginsSynchronizer.synchronizeAnalyzers();
-    backendService.initialize(analyzers);
-    backendService.notifyTransportModeUsed();
+  }
+
+  /**
+   * Heavy initialization that runs in background after the server has started.
+   * Downloads analyzers, checks version, initializes the backend, and dynamically loads tools.
+   */
+  private void initializeBackgroundServices() {
+    try {
+      sonarQubeVersionChecker.failIfSonarQubeServerVersionIsNotSupported();
+
+      PluginsSynchronizer pluginsSynchronizer;
+      if (mcpConfiguration.isHttpEnabled()) {
+        var initServerApi = createServerApiWithToken(mcpConfiguration.getSonarQubeToken());
+        pluginsSynchronizer = new PluginsSynchronizer(initServerApi, mcpConfiguration.getStoragePath());
+      } else {
+        pluginsSynchronizer = new PluginsSynchronizer(Objects.requireNonNull(serverApi), mcpConfiguration.getStoragePath());
+      }
+      var analyzers = pluginsSynchronizer.synchronizeAnalyzers();
+
+      backendService.initialize(analyzers);
+      backendService.notifyTransportModeUsed();
+
+      // Load and register tools dynamically
+      LOG.info("Loading tools...");
+      initTools();
+      notifyToolsLoaded();
 
-    LOG.info("Startup initialization completed");
+      initializationFuture.complete(null);
+      LOG.info("Background initialization completed successfully");
+    } catch (Exception e) {
+      LOG.error("Background initialization failed", e);
+      initializationFuture.completeExceptionally(e);
+      throw e;
+    }
   }
+
+  /**
+   * Notifies connected clients about newly loaded tools.
+   * This may fail if no client is connected yet (common during startup or in tests).
+   * Failure is acceptable as clients will discover tools via listTools() when they connect.
+   */
+  private void notifyToolsLoaded() {
+    try {
+      for (var tool : supportedTools) {
+        syncServer.addTool(toSpec(tool));
+      }
+      syncServer.notifyToolsListChanged();
+      LOG.info(supportedTools.size() + " tools loaded and registered");
+    } catch (Exception e) {
+      LOG.info(supportedTools.size() + " tools loaded (client notification deferred)");
+    }
+  }
+
   private void initTools() {
     var allTools = new ArrayList<Tool>();
 
@@ -213,37 +309,6 @@ private void initTools() {
     LOG.info("Loaded " + this.supportedTools.size() + " tools after " + filterReason);
   }
 
-  public void start() {
-    initTools();
-
-    if (httpServerManager != null) {
-      LOG.info("Starting HTTP server on " + mcpConfiguration.getHttpHost() + ":" + mcpConfiguration.getHttpPort() + "...");
-      httpServerManager.startServer().join();
-      LOG.info("HTTP server started");
-    }
-
-    Function<Object, McpSyncServer> serverBuilder = provider -> {
-      var builder = switch (provider) {
-        case McpServerTransportProvider p -> McpServer.sync(p);
-        case McpStreamableServerTransportProvider p -> McpServer.sync(p);
-        default -> throw new IllegalArgumentException("Unsupported transport provider type: " + provider.getClass().getName());
-      };
-      return builder
-        .serverInfo(new McpSchema.Implementation(SONARQUBE_MCP_SERVER_NAME, mcpConfiguration.getAppVersion()))
-        .instructions("Transform your code quality workflow with SonarQube integration. " +
-          "Analyze code, monitor project health, investigate issues, and understand quality gates.")
-        .capabilities(McpSchema.ServerCapabilities.builder().tools(true).logging().build())
-        .tools(supportedTools.stream().map(this::toSpec).toArray(McpServerFeatures.SyncToolSpecification[]::new))
-        .build();
-    };
-
-    syncServer = serverBuilder.apply(transportProvider);
-
-    Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown));
-
-    logInitialization();
-  }
-
   private McpServerFeatures.SyncToolSpecification toSpec(Tool tool) {
     return new McpServerFeatures.SyncToolSpecification.Builder()
       .tool(tool.definition())
@@ -259,7 +324,7 @@ private void logInitialization() {
     var sonarQubeType = mcpConfiguration.isSonarCloud() ? "SonarQube Cloud" : "SonarQube Server";
 
     LOG.info("========================================");
-    LOG.info("SonarQube MCP Server Startup Configuration:");
+    LOG.info("SonarQube MCP Server Started:");
     LOG.info("Transport: " + transportType +
       (mcpConfiguration.isHttpEnabled() ? (" (" + mcpConfiguration.getHttpHost() + ":" + mcpConfiguration.getHttpPort() + ")") : ""));
     LOG.info("Instance: " + sonarQubeType);
@@ -270,7 +335,7 @@ private void logInitialization() {
     if (mcpConfiguration.isReadOnlyMode()) {
       LOG.info("Mode: READ-ONLY (write operations disabled)");
     }
-    LOG.info("Tools loaded: " + supportedTools.size());
+    LOG.info("Status: Server ready - tools loading in background");
     LOG.info("========================================");
   }
 
@@ -365,7 +430,7 @@ public SonarQubeMcpServer(McpServerTransportProviderBase transportProvider, @Nul
     this.mcpConfiguration = new McpServerLaunchConfiguration(environment);
     this.transportProvider = transportProvider;
     this.httpServerManager = httpServerManager;
-    initializeServices();
+    initializeBasicServices();
   }
 
   // Package-private getters for testing
@@ -377,4 +442,13 @@ public List<Tool> getSupportedTools() {
     return List.copyOf(supportedTools);
   }
 
+  /**
+   * For testing: wait for background initialization to complete.
+   * This ensures tools are fully loaded before tests proceed.
+   */
+  @VisibleForTesting
+  public void waitForInitialization() throws ExecutionException, InterruptedException {
+    initializationFuture.get();
+  }
+
 }

src/main/java/org/sonarsource/sonarqube/mcp/tools/ToolExecutor.java

@@ -17,6 +17,10 @@
 package org.sonarsource.sonarqube.mcp.tools;
 
 import io.modelcontextprotocol.spec.McpSchema;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import org.eclipse.lsp4j.jsonrpc.ResponseErrorException;
 import org.sonarsource.sonarqube.mcp.log.McpLogger;
 import org.sonarsource.sonarqube.mcp.serverapi.exception.ForbiddenException;
@@ -26,10 +30,13 @@
 
 public class ToolExecutor {
   private static final McpLogger LOG = McpLogger.getInstance();
+  private static final int INITIALIZATION_TIMEOUT_SECONDS = 300; // 5 minutes
   private final BackendService backendService;
+  private final CompletableFuture<Void> initializationFuture;
 
-  public ToolExecutor(BackendService backendService) {
+  public ToolExecutor(BackendService backendService, CompletableFuture<Void> initializationFuture) {
     this.backendService = backendService;
+    this.initializationFuture = initializationFuture;
   }
 
   public McpSchema.CallToolResult execute(Tool tool, McpSchema.CallToolRequest toolRequest) {
@@ -39,9 +46,24 @@ public McpSchema.CallToolResult execute(Tool tool, McpSchema.CallToolRequest too
     var startTime = System.currentTimeMillis();
     Tool.Result result;
     try {
+      // Wait for initialization to complete before executing the tool
+      if (!initializationFuture.isDone()) {
+        LOG.info("Waiting for server initialization to complete before executing tool: " + toolName);
+      }
+      initializationFuture.get(INITIALIZATION_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+      
       result = tool.execute(new Tool.Arguments(toolRequest.arguments()));
       var executionTime = System.currentTimeMillis() - startTime;
       LOG.info("Tool completed: " + toolName + " (execution time: " + executionTime + "ms)");
+    } catch (TimeoutException e) {
+      var executionTime = System.currentTimeMillis() - startTime;
+      result = Tool.Result.failure("Server initialization is taking longer than expected. Please try again in a moment.");
+      LOG.error("Tool failed due to initialization timeout: " + toolName + " (execution time: " + executionTime + "ms)", e);
+    } catch (ExecutionException e) {
+      var executionTime = System.currentTimeMillis() - startTime;
+      result = Tool.Result.failure("Server initialization failed: " + e.getCause().getMessage() + 
+        ". Please check the server logs for more details.");
+      LOG.error("Tool failed due to initialization error: " + toolName + " (execution time: " + executionTime + "ms)", e);
     } catch (Exception e) {
       var executionTime = System.currentTimeMillis() - startTime;
       var message = switch (e) {

src/test/java/org/sonarsource/sonarqube/mcp/SonarQubeMcpServerHttpTest.java

@@ -72,13 +72,14 @@ void should_use_custom_http_configuration(SonarQubeMcpServerTestHarness harness)
   }
 
   @SonarQubeMcpServerTest
-  void should_have_same_tools_regardless_of_transport(SonarQubeMcpServerTestHarness harness) {
+  void should_have_same_tools_regardless_of_transport(SonarQubeMcpServerTestHarness harness) throws Exception {
     var environment = createTestEnvironment(harness.getMockSonarQubeServer().baseUrl());
 
     harness.prepareMockWebServer(environment);
 
     var stdioServer = new SonarQubeMcpServer(environment);
     stdioServer.start();
+    stdioServer.waitForInitialization(); // Wait for tools to load
     var stdioTools = stdioServer.getSupportedTools().stream()
         .map(tool -> tool.definition().name())
         .sorted()
@@ -87,6 +88,7 @@ void should_have_same_tools_regardless_of_transport(SonarQubeMcpServerTestHarnes
     environment.put("SONARQUBE_TRANSPORT", "http");
     var httpServer = new SonarQubeMcpServer(environment);
     httpServer.start();
+    httpServer.waitForInitialization(); // Wait for tools to load
     var httpTools = httpServer.getSupportedTools().stream()
         .map(tool -> tool.definition().name())
         .sorted()

src/test/java/org/sonarsource/sonarqube/mcp/SonarQubeMcpServerIdeBridgeTest.java

@@ -50,7 +50,7 @@ void cleanup() {
   }
 
   @SonarQubeMcpServerTest
-  void should_add_bridge_related_tools_when_ide_bridge_is_available(SonarQubeMcpServerTestHarness harness) {
+  void should_add_bridge_related_tools_when_ide_bridge_is_available(SonarQubeMcpServerTestHarness harness) throws Exception {
     var environment = new HashMap<String, String>();
     environment.put("SONARQUBE_URL", harness.getMockSonarQubeServer().baseUrl());
     environment.put("SONARQUBE_TOKEN", "test-token");
@@ -61,6 +61,7 @@ void should_add_bridge_related_tools_when_ide_bridge_is_available(SonarQubeMcpSe
 
     var server = new SonarQubeMcpServer(new StdioServerTransportProvider(new ObjectMapper()), null, environment);
     server.start();
+    server.waitForInitialization();
 
     var supportedTools = server.getSupportedTools();
     assertThat(supportedTools)
@@ -70,7 +71,7 @@ void should_add_bridge_related_tools_when_ide_bridge_is_available(SonarQubeMcpSe
   }
 
   @SonarQubeMcpServerTest
-  void should_add_analysis_tool_when_ide_bridge_is_not_available(SonarQubeMcpServerTestHarness harness) {
+  void should_add_analysis_tool_when_ide_bridge_is_not_available(SonarQubeMcpServerTestHarness harness) throws Exception {
     var environment = new HashMap<String, String>();
     environment.put("SONARQUBE_URL", harness.getMockSonarQubeServer().baseUrl());
     environment.put("SONARQUBE_TOKEN", "test-token");
@@ -80,6 +81,7 @@ void should_add_analysis_tool_when_ide_bridge_is_not_available(SonarQubeMcpServe
 
     var server = new SonarQubeMcpServer(new StdioServerTransportProvider(new ObjectMapper()), null, environment);
     server.start();
+    server.waitForInitialization();
 
     var supportedTools = server.getSupportedTools();
     assertThat(supportedTools)

src/test/java/org/sonarsource/sonarqube/mcp/harness/SonarQubeMcpServerTestHarness.java

@@ -143,6 +143,15 @@ public SonarQubeMcpTestClient newClient(Map<String, String> overriddenEnv) {
     client.initialize();
     this.clients.add(client);
     this.servers.add(server);
+    
+    // Wait for background initialization to complete before returning
+    // This ensures tools are fully loaded and available for tests
+    try {
+      server.waitForInitialization();
+    } catch (Exception e) {
+      throw new RuntimeException("Server initialization failed", e);
+    }
+    
     return new SonarQubeMcpTestClient(client);
   }
 

src/test/java/org/sonarsource/sonarqube/mcp/tools/ToolExecutorTest.java

@@ -20,6 +20,7 @@
 import io.modelcontextprotocol.spec.McpSchema;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.sonarsource.sonarqube.mcp.slcore.BackendService;
@@ -35,7 +36,9 @@ class ToolExecutorTest {
   @BeforeEach
   void prepare() {
     mockBackendService = mock(BackendService.class);
-    toolExecutor = new ToolExecutor(mockBackendService);
+    // Create a completed future for tests (simulating completed initialization)
+    CompletableFuture<Void> initializationFuture = CompletableFuture.completedFuture(null);
+    toolExecutor = new ToolExecutor(mockBackendService, initializationFuture);
   }
 
   @Test