feat(gateway): add 'restart' command to gracefully restart the gateway server

Lasim · Lasim · commit a65d849539d2 · 2025-08-16T23:01:08.000+02:00
diff --git a/services/gateway/README.md b/services/gateway/README.md
@@ -198,12 +198,18 @@ deploystack teams --switch 2
 
 ### `deploystack refresh`
 
-Refresh MCP server configurations from cloud control plane.
+Refresh MCP server configurations from cloud control plane with automatic change detection and restart prompting.
 
 **Options:**
 
 - `--url <url>` - DeployStack backend URL (override stored URL)
 
+**Features:**
+
+- **Change Detection**: Automatically detects configuration changes (added/removed/modified servers)
+- **Interactive Restart**: Prompts to restart gateway when changes require it
+- **Smart Behavior**: Only prompts for restart if gateway is running and changes detected
+
 **Examples:**
 
 ```bash
@@ -214,6 +220,21 @@ deploystack refresh
 deploystack refresh --url http://localhost:3000
 ```
 
+**Sample Output with Changes:**
+
+```text
+🔄 Refreshing MCP configuration for team: My Team
+✅ MCP configuration refreshed (4 servers)
+
+🔄 Configuration changes detected:
+   • brightdata: Environment variables updated
+   • github-server: Arguments changed
+   • new-server: Added to team configuration
+
+⚠️  Gateway restart required for changes to take effect.
+? Do you want to restart the DeployStack Gateway now? (Y/n)
+```
+
 ### `deploystack mcp`
 
 Manage MCP server configurations and discover tools.
@@ -276,6 +297,35 @@ deploystack start --foreground
 🤖 Ready to serve 2 MCP servers for team: kaka
 ```
 
+### `deploystack restart`
+
+Restart the gateway server with graceful shutdown and startup sequence.
+
+**Options:**
+
+- `-p, --port <port>` - Port to run the gateway on (default: 9095)
+- `-h, --host <host>` - Host to bind the gateway to (default: localhost)
+- `-f, --foreground` - Run in foreground instead of daemon mode
+
+**Features:**
+
+- **Graceful Shutdown**: Properly stops all MCP server processes before restart
+- **Smart Behavior**: If gateway isn't running, performs a start operation instead
+- **Configuration Reload**: Picks up any configuration changes after restart
+
+**Examples:**
+
+```bash
+# Restart gateway with current configuration
+deploystack restart
+
+# Restart on custom port
+deploystack restart --port 8080
+
+# Restart in foreground for debugging
+deploystack restart --foreground
+```
+
 ### `deploystack stop`
 
 Stop the running gateway server.
diff --git a/services/gateway/src/commands/index.ts b/services/gateway/src/commands/index.ts
@@ -5,6 +5,7 @@ export { registerTeamsCommand } from './teams';
 export { registerMCPCommand } from './mcp';
 export { registerRefreshCommand } from './refresh';
 export { registerStartCommand } from './start';
+export { registerRestartCommand } from './restart';
 export { registerStopCommand } from './stop';
 export { registerStatusCommand } from './status';
 export { registerConfigCommand } from './config';
diff --git a/services/gateway/src/commands/restart.ts b/services/gateway/src/commands/restart.ts
@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { ServerRestartService } from '../services/server-restart-service';
+
+export function registerRestartCommand(program: Command) {
+  program
+    .command('restart')
+    .description('Restart the gateway server')
+    .option('-p, --port <port>', 'Port to run the gateway on', '9095')
+    .option('-h, --host <host>', 'Host to bind the gateway to', 'localhost')
+    .option('-f, --foreground', 'Run in foreground (default is daemon mode)')
+    .action(async (options) => {
+      const restartService = new ServerRestartService();
+
+      try {
+        const port = parseInt(options.port, 10);
+        const host = options.host;
+        const foreground = options.foreground || false;
+
+        const result = await restartService.restartGatewayServer({
+          port,
+          host,
+          foreground
+        });
+
+        if (result.restarted) {
+          console.log(chalk.green('✅ Gateway restarted successfully'));
+        } else {
+          console.log(chalk.green('✅ Gateway started successfully'));
+        }
+
+        if (foreground) {
+          console.log(chalk.gray('   Press Ctrl+C to stop the server'));
+        } else {
+          console.log(chalk.gray(`   PID: ${result.pid}`));
+          console.log(chalk.gray(`   SSE endpoint: ${result.endpoints?.sse}`));
+          console.log(chalk.gray(`   Messages: ${result.endpoints?.messages}`));
+          console.log(chalk.gray('   Use "deploystack status" to check status'));
+          console.log(chalk.gray('   Use "deploystack stop" to stop the server'));
+          
+          if (result.mcpServersStarted !== undefined) {
+            console.log(chalk.blue(`🤖 Ready to serve ${result.mcpServersStarted} MCP server${result.mcpServersStarted === 1 ? '' : 's'} for team: ${result.teamName}`));
+          }
+        }
+
+      } catch (error) {
+        console.error(chalk.red('❌ Failed to restart gateway:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+}
diff --git a/services/gateway/src/index.ts b/services/gateway/src/index.ts
@@ -10,6 +10,7 @@ import {
   registerMCPCommand,
   registerRefreshCommand,
   registerStartCommand,
+  registerRestartCommand,
   registerStopCommand,
   registerStatusCommand,
   registerConfigCommand,
@@ -32,6 +33,7 @@ registerTeamsCommand(program);
 registerMCPCommand(program);
 registerRefreshCommand(program);
 registerStartCommand(program);
+registerRestartCommand(program);
 registerStopCommand(program);
 registerStatusCommand(program);
 registerConfigCommand(program);
diff --git a/services/gateway/src/services/refresh-service.ts b/services/gateway/src/services/refresh-service.ts
@@ -1,9 +1,12 @@
 import chalk from 'chalk';
 import ora from 'ora';
+import inquirer from 'inquirer';
 import { CredentialStorage } from '../core/auth/storage';
 import { DeployStackAPI } from '../core/auth/api-client';
 import { MCPConfigService } from '../core/mcp';
+import { ServerRestartService } from './server-restart-service';
 import { AuthenticationError } from '../types/auth';
+import { TeamMCPConfig, MCPServerConfig } from '../types/mcp';
 
 export interface RefreshOptions {
   url?: string;
@@ -12,10 +15,12 @@ export interface RefreshOptions {
 export class RefreshService {
   private storage: CredentialStorage;
   private mcpService: MCPConfigService;
+  private restartService: ServerRestartService;
 
   constructor() {
     this.storage = new CredentialStorage();
     this.mcpService = new MCPConfigService();
+    this.restartService = new ServerRestartService();
   }
 
   /**
@@ -51,25 +56,39 @@ export class RefreshService {
       const api = new DeployStackAPI(credentials, backendUrl);
 
       console.log(chalk.blue(`🔄 Refreshing MCP configuration for team: ${chalk.cyan(credentials.selectedTeam.name)}`));
+      
+      // Step 1: Get current configuration for comparison
+      const oldConfig = await this.mcpService.getMCPConfig(credentials.selectedTeam.id);
+      
+      // Step 2: Download new configuration
       spinner = ora('Downloading latest MCP configuration...').start();
       
       try {
-        const config = await this.mcpService.downloadAndStoreMCPConfig(
+        const newConfig = await this.mcpService.downloadAndStoreMCPConfig(
           credentials.selectedTeam.id,
           credentials.selectedTeam.name,
           api,
           false
         );
         
-        spinner.succeed(`MCP configuration refreshed (${config.servers.length} server${config.servers.length === 1 ? '' : 's'})`);
+        spinner.succeed(`MCP configuration refreshed (${newConfig.servers.length} server${newConfig.servers.length === 1 ? '' : 's'})`);
         console.log(chalk.green('✅ MCP configuration has been refreshed'));
         
+        // Step 3: Detect changes and prompt for restart if needed
+        const changes = this.detectConfigurationChanges(oldConfig, newConfig);
+        
+        if (changes.hasChanges) {
+          await this.handleConfigurationChanges(changes);
+        } else {
+          console.log(chalk.gray('📋 No configuration changes detected'));
+        }
+        
         // Show summary
         console.log(chalk.gray(`\n📊 Configuration Summary:`));
-        console.log(chalk.gray(`   Team: ${config.team_name}`));
-        console.log(chalk.gray(`   Installations: ${config.installations.length}`));
-        console.log(chalk.gray(`   Servers: ${config.servers.length}`));
-        console.log(chalk.gray(`   Last Updated: ${new Date(config.last_updated).toLocaleString()}`));
+        console.log(chalk.gray(`   Team: ${newConfig.team_name}`));
+        console.log(chalk.gray(`   Installations: ${newConfig.installations.length}`));
+        console.log(chalk.gray(`   Servers: ${newConfig.servers.length}`));
+        console.log(chalk.gray(`   Last Updated: ${new Date(newConfig.last_updated).toLocaleString()}`));
         
       } catch (error) {
         spinner.fail('Failed to refresh MCP configuration');
@@ -96,4 +115,166 @@ export class RefreshService {
       process.exit(1);
     }
   }
+
+  /**
+   * Detect changes between old and new MCP configurations
+   */
+  private detectConfigurationChanges(oldConfig: TeamMCPConfig | null, newConfig: TeamMCPConfig): {
+    hasChanges: boolean;
+    changes: string[];
+    addedServers: string[];
+    removedServers: string[];
+    modifiedServers: string[];
+  } {
+    const changes: string[] = [];
+    const addedServers: string[] = [];
+    const removedServers: string[] = [];
+    const modifiedServers: string[] = [];
+
+    // If no old config, everything is new
+    if (!oldConfig) {
+      return {
+        hasChanges: false, // Don't prompt for restart on first-time config
+        changes: ['Initial configuration downloaded'],
+        addedServers: newConfig.servers.map(s => s.installation_name),
+        removedServers: [],
+        modifiedServers: []
+      };
+    }
+
+    // Create maps for easier comparison
+    const oldServers = new Map(oldConfig.servers.map(s => [s.installation_name, s]));
+    const newServers = new Map(newConfig.servers.map(s => [s.installation_name, s]));
+
+    // Check for added servers
+    for (const [name] of newServers) {
+      if (!oldServers.has(name)) {
+        addedServers.push(name);
+        changes.push(`• ${chalk.green(name)}: Added to team configuration`);
+      }
+    }
+
+    // Check for removed servers
+    for (const [name] of oldServers) {
+      if (!newServers.has(name)) {
+        removedServers.push(name);
+        changes.push(`• ${chalk.red(name)}: Removed from team configuration`);
+      }
+    }
+
+    // Check for modified servers
+    for (const [name, newServer] of newServers) {
+      const oldServer = oldServers.get(name);
+      if (oldServer && this.hasServerConfigChanged(oldServer, newServer)) {
+        modifiedServers.push(name);
+        const serverChanges = this.getServerChanges(oldServer, newServer);
+        changes.push(`• ${chalk.yellow(name)}: ${serverChanges.join(', ')}`);
+      }
+    }
+
+    return {
+      hasChanges: changes.length > 0,
+      changes,
+      addedServers,
+      removedServers,
+      modifiedServers
+    };
+  }
+
+  /**
+   * Check if a server configuration has changed
+   */
+  private hasServerConfigChanged(oldServer: MCPServerConfig, newServer: MCPServerConfig): boolean {
+    // Check command and args
+    if (oldServer.command !== newServer.command) return true;
+    if (JSON.stringify(oldServer.args) !== JSON.stringify(newServer.args)) return true;
+    
+    // Check environment variables
+    if (JSON.stringify(oldServer.env) !== JSON.stringify(newServer.env)) return true;
+    
+    // Check runtime
+    if (oldServer.runtime !== newServer.runtime) return true;
+    
+    return false;
+  }
+
+  /**
+   * Get specific changes for a server
+   */
+  private getServerChanges(oldServer: MCPServerConfig, newServer: MCPServerConfig): string[] {
+    const changes: string[] = [];
+    
+    if (oldServer.command !== newServer.command) {
+      changes.push('command updated');
+    }
+    
+    if (JSON.stringify(oldServer.args) !== JSON.stringify(newServer.args)) {
+      changes.push('arguments changed');
+    }
+    
+    if (JSON.stringify(oldServer.env) !== JSON.stringify(newServer.env)) {
+      changes.push('environment variables updated');
+    }
+    
+    if (oldServer.runtime !== newServer.runtime) {
+      changes.push('runtime changed');
+    }
+    
+    return changes;
+  }
+
+  /**
+   * Handle configuration changes with interactive restart prompt
+   */
+  private async handleConfigurationChanges(changeInfo: {
+    hasChanges: boolean;
+    changes: string[];
+    addedServers: string[];
+    removedServers: string[];
+    modifiedServers: string[];
+  }): 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();
+    
+    if (!isRunning) {
+      console.log(chalk.gray('💡 Gateway is not currently running. Changes will take effect when you start it.'));
+      return;
+    }
+
+    // Prompt user for restart
+    const { shouldRestart } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'shouldRestart',
+        message: 'Do you want to restart the DeployStack Gateway now?',
+        default: true
+      }
+    ]);
+
+    if (shouldRestart) {
+      console.log(chalk.blue('\n🔄 Restarting gateway with updated configuration...'));
+      
+      try {
+        const result = await this.restartService.restartGatewayServer();
+        
+        if (result.restarted) {
+          console.log(chalk.green('✅ Gateway restarted successfully with new configuration'));
+          
+          if (result.mcpServersStarted !== undefined) {
+            console.log(chalk.blue(`🤖 Ready to serve ${result.mcpServersStarted} MCP server${result.mcpServersStarted === 1 ? '' : 's'}`));
+          }
+        }
+      } catch (error) {
+        console.log(chalk.red(`❌ Failed to restart gateway: ${error instanceof Error ? error.message : String(error)}`));
+        console.log(chalk.gray('💡 You can restart manually with "deploystack restart"'));
+      }
+    } else {
+      console.log(chalk.gray('💡 Configuration updated. Restart gateway manually with "deploystack restart" when ready.'));
+    }
+  }
 }
diff --git a/services/gateway/src/services/server-restart-service.ts b/services/gateway/src/services/server-restart-service.ts
