feat(gateway): add selective restart functionality for MCP servers and enhance configuration change handling

Author: Lasim

services/gateway/src/core/server/proxy.ts

@@ -212,6 +212,19 @@ export class ProxyServer {
       return this.getStatus();
     });
 
+    // MCP Server Management API endpoints for selective restart
+    this.fastify.post('/api/mcp/servers', async (request, reply) => {
+      await this.handleAddServer(request, reply);
+    });
+
+    this.fastify.delete('/api/mcp/servers/:serverName', async (request, reply) => {
+      await this.handleRemoveServer(request, reply);
+    });
+
+    this.fastify.post('/api/mcp/servers/:serverName/restart', async (request, reply) => {
+      await this.handleRestartServer(request, reply);
+    });
+
     // Logs streaming endpoint - real-time log streaming via SSE
     this.fastify.get('/logs/stream', async (request, reply) => {
       await this.handleLogsStream(request, reply);
@@ -1130,4 +1143,181 @@ export class ProxyServer {
       console.error(chalk.red('Failed to load team MCP configuration:'), error);
     }
   }
+
+  /**
+   * Handle adding a new MCP server (selective restart API)
+   */
+  private async handleAddServer(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    try {
+      const body = request.body as any;
+      const config = body.config as MCPServerConfig;
+
+      if (!config || !config.installation_name) {
+        reply.code(400).send({
+          error: 'Invalid request',
+          message: 'Missing server configuration'
+        });
+        return;
+      }
+
+      console.log(chalk.blue(`[API] Adding MCP server: ${config.installation_name}`));
+
+      // Check if server already exists
+      const existingProcess = this.processManager.getProcessByName(config.installation_name);
+      if (existingProcess && existingProcess.status === 'running') {
+        reply.code(409).send({
+          error: 'Server already exists',
+          message: `MCP server ${config.installation_name} is already running`
+        });
+        return;
+      }
+
+      // Spawn the new process
+      const processInfo = await this.processManager.spawnProcess(config);
+      
+      console.log(chalk.green(`[API] Successfully added MCP server: ${config.installation_name}`));
+
+      reply.code(201).send({
+        success: true,
+        message: `MCP server ${config.installation_name} added successfully`,
+        server: {
+          name: config.installation_name,
+          status: processInfo.status,
+          pid: processInfo.process.pid
+        }
+      });
+
+    } catch (error) {
+      console.error(chalk.red(`[API] Error adding server:`), error);
+      
+      reply.code(500).send({
+        error: 'Internal server error',
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+
+  /**
+   * Handle removing an MCP server (selective restart API)
+   */
+  private async handleRemoveServer(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    try {
+      const params = request.params as any;
+      const serverName = params.serverName;
+
+      if (!serverName) {
+        reply.code(400).send({
+          error: 'Invalid request',
+          message: 'Missing server name'
+        });
+        return;
+      }
+
+      console.log(chalk.blue(`[API] Removing MCP server: ${serverName}`));
+
+      // Find the process
+      const processInfo = this.processManager.getProcessByName(serverName);
+      if (!processInfo) {
+        reply.code(404).send({
+          error: 'Server not found',
+          message: `MCP server ${serverName} not found`
+        });
+        return;
+      }
+
+      // Terminate the process
+      await this.processManager.terminateProcess(processInfo, 10000);
+      
+      console.log(chalk.green(`[API] Successfully removed MCP server: ${serverName}`));
+
+      reply.code(200).send({
+        success: true,
+        message: `MCP server ${serverName} removed successfully`
+      });
+
+    } catch (error) {
+      console.error(chalk.red(`[API] Error removing server:`), error);
+      
+      reply.code(500).send({
+        error: 'Internal server error',
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+
+  /**
+   * Handle restarting an MCP server (selective restart API)
+   */
+  private async handleRestartServer(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    try {
+      const params = request.params as any;
+      const body = request.body as any;
+      const serverName = params.serverName;
+      const config = body.config as MCPServerConfig;
+
+      if (!serverName) {
+        reply.code(400).send({
+          error: 'Invalid request',
+          message: 'Missing server name'
+        });
+        return;
+      }
+
+      if (!config || !config.installation_name) {
+        reply.code(400).send({
+          error: 'Invalid request',
+          message: 'Missing server configuration'
+        });
+        return;
+      }
+
+      console.log(chalk.blue(`[API] Restarting MCP server: ${serverName}`));
+
+      // Find the existing process
+      const existingProcess = this.processManager.getProcessByName(serverName);
+      if (!existingProcess) {
+        // Server doesn't exist, just start it
+        const processInfo = await this.processManager.spawnProcess(config);
+        
+        console.log(chalk.green(`[API] Started MCP server: ${serverName} (was not running)`));
+
+        reply.code(200).send({
+          success: true,
+          message: `MCP server ${serverName} started successfully`,
+          server: {
+            name: config.installation_name,
+            status: processInfo.status,
+            pid: processInfo.process.pid
+          }
+        });
+        return;
+      }
+
+      // Restart the existing process
+      const processInfo = await this.processManager.restartServer(serverName, {
+        timeout: 10000,
+        showProgress: false
+      });
+      
+      console.log(chalk.green(`[API] Successfully restarted MCP server: ${serverName}`));
+
+      reply.code(200).send({
+        success: true,
+        message: `MCP server ${serverName} restarted successfully`,
+        server: {
+          name: config.installation_name,
+          status: processInfo.status,
+          pid: processInfo.process.pid
+        }
+      });
+
+    } catch (error) {
+      console.error(chalk.red(`[API] Error restarting server:`), error);
+      
+      reply.code(500).send({
+        error: 'Internal server error',
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
 }

services/gateway/src/services/configuration-change-service.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { TeamMCPConfig, MCPServerConfig } from '../types/mcp';
 import { ServerRestartService } from './server-restart-service';
+import { SelectiveRestartService } from './selective-restart-service';
 
 export interface ConfigurationChangeInfo {
   hasChanges: boolean;
@@ -17,9 +18,11 @@ export interface ConfigurationChangeInfo {
  */
 export class ConfigurationChangeService {
   private restartService: ServerRestartService;
+  private selectiveRestartService: SelectiveRestartService;
 
   constructor() {
     this.restartService = new ServerRestartService();
+    this.selectiveRestartService = new SelectiveRestartService();
   }
 
   /**
@@ -125,13 +128,15 @@ export class ConfigurationChangeService {
 
   /**
    * Handle configuration changes with interactive restart prompt
+   * Uses selective restart when possible, falls back to full restart
    */
-  async handleConfigurationChanges(changeInfo: ConfigurationChangeInfo): Promise<void> {
+  async handleConfigurationChanges(
+    changeInfo: ConfigurationChangeInfo,
+    newServerConfigs?: MCPServerConfig[]
+  ): Promise<void> {
     console.log(chalk.blue('\n🔄 Configuration changes detected:'));
     changeInfo.changes.forEach(change => console.log(`   ${change}`));
 
-    console.log(chalk.yellow('\n⚠️  Gateway restart required for changes to take effect.'));
-
     // Check if gateway is running
     const isRunning = this.restartService.isServerRunning();
 
@@ -140,7 +145,45 @@ export class ConfigurationChangeService {
       return;
     }
 
-    // Prompt user for restart
+    // Try selective restart first if we have server configs
+    if (newServerConfigs && await this.selectiveRestartService.isGatewayRunning()) {
+      console.log(chalk.blue('\nSelective restart available - only affected servers will be restarted.'));
+      
+      const { useSelectiveRestart } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'useSelectiveRestart',
+          message: 'Use selective restart (faster, no interruption to unchanged servers)?',
+          default: true
+        }
+      ]);
+
+      if (useSelectiveRestart) {
+        try {
+          const result = await this.selectiveRestartService.performSelectiveRestart(
+            changeInfo,
+            newServerConfigs,
+            { showProgress: true }
+          );
+
+          if (result.success) {
+            console.log(chalk.green('\n✅ Selective restart completed successfully'));
+            console.log(chalk.gray('All changes applied without full gateway restart'));
+            return;
+          } else {
+            console.log(chalk.yellow('\nSelective restart completed with errors'));
+            console.log(chalk.gray('Falling back to full gateway restart...'));
+          }
+        } catch (error) {
+          console.log(chalk.red(`❌ Selective restart failed: ${error instanceof Error ? error.message : String(error)}`));
+          console.log(chalk.gray('Falling back to full gateway restart...'));
+        }
+      }
+    }
+
+    // Fall back to full gateway restart
+    console.log(chalk.yellow('\nFull gateway restart required for changes to take effect.'));
+
     const { shouldRestart } = await inquirer.prompt([
       {
         type: 'confirm',

services/gateway/src/services/refresh-service.ts

@@ -98,7 +98,7 @@ export class RefreshService {
 
         // Step 2: Handle configuration changes
         if (changeInfo.hasChanges) {
-          await this.changeService.handleConfigurationChanges(changeInfo);
+          await this.changeService.handleConfigurationChanges(changeInfo, teamMCPConfig.servers);
         } else {
           console.log(chalk.green('✅ No configuration changes detected - your MCP servers are up to date'));
           console.log(chalk.gray('💡 All servers are already running with the latest configuration'));