feat(gateway): implement device detection and new MCP config endpoint

Lasim · Lasim · commit e5367c3b24c3 · 2025-08-24T17:37:39.000+02:00
diff --git a/services/gateway/src/commands/login.ts b/services/gateway/src/commands/login.ts
@@ -7,6 +7,7 @@ import { DeployStackAPI } from '../core/auth/api-client';
 import { MCPConfigService } from '../core/mcp';
 import { AuthenticationError } from '../types/auth';
 import { ServerStartService } from '../services/server-start-service';
+import { detectDeviceInfo } from '../utils/device-detection';
 
 export function registerLoginCommand(program: Command) {
   program
@@ -61,11 +62,18 @@ export function registerLoginCommand(program: Command) {
           if (defaultTeam) {
             await storage.updateSelectedTeam(defaultTeam.id, defaultTeam.name);
             
-            // Download MCP configuration for the default team
-            spinner.text = 'Downloading MCP server configurations...';
+            // Detect device and download merged MCP configurations using new gateway endpoint
+            spinner.text = 'Detecting device and downloading MCP configurations...';
             const mcpService = new MCPConfigService();
             try {
-              await mcpService.downloadAndStoreMCPConfig(defaultTeam.id, defaultTeam.name, api, false);
+              // Detect current device information
+              const deviceInfo = await detectDeviceInfo();
+              
+              // Register or update device with backend
+              const device = await api.registerOrUpdateDevice(deviceInfo);
+              
+              // Download merged configurations using the new gateway endpoint
+              const gatewayConfig = await mcpService.downloadGatewayMCPConfig(device.id, api, false);
               
               // Auto-start the gateway server after successful MCP config download
               spinner.text = 'Starting gateway server...';
diff --git a/services/gateway/src/core/auth/api-client.ts b/services/gateway/src/core/auth/api-client.ts
@@ -99,6 +99,30 @@ export class DeployStackAPI {
     return response;
   }
 
+  /**
+   * Get merged MCP configurations for gateway (NEW THREE-TIER ENDPOINT)
+   * This endpoint merges Template + Team + User configurations and returns ready-to-use server configs
+   * @param deviceId Device ID for device-specific user configurations
+   * @returns Gateway MCP configurations response
+   */
+  async getGatewayMCPConfigurations(hardwareId: string): Promise<{
+    success: boolean;
+    data: {
+      servers: Array<{
+        id: string;
+        name: string;
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        status: 'ready' | 'invalid';
+      }>;
+    };
+  }> {
+    const endpoint = `${this.baseUrl}/api/gateway/me/mcp-configurations?hardware_id=${encodeURIComponent(hardwareId)}`;
+    const response = await this.makeRequest(endpoint);
+    return response;
+  }
+
   /**
    * Get device by hardware ID
    * @param hardwareId Hardware fingerprint
diff --git a/services/gateway/src/core/mcp/config-service.ts b/services/gateway/src/core/mcp/config-service.ts
@@ -14,7 +14,90 @@ export class MCPConfigService {
   }
 
   /**
-   * Download and store MCP configuration for a team
+   * Download merged MCP configurations using the new gateway endpoint (THREE-TIER ARCHITECTURE)
+   * This method uses the new /api/gateway/me/mcp-configurations endpoint that merges
+   * Template + Team + User configurations and returns ready-to-use server configs
+   * @param deviceId Device ID for device-specific user configurations
+   * @param api DeployStack API client
+   * @param showSpinner Whether to show progress spinner
+   * @returns Gateway MCP configuration with ready-to-use servers
+   */
+  async downloadGatewayMCPConfig(
+    hardwareId: string,
+    api?: DeployStackAPI,
+    showSpinner: boolean = true
+  ): Promise<{
+    servers: Array<{
+      id: string;
+      name: string;
+      command: string;
+      args: string[];
+      env: Record<string, string>;
+      status: 'ready' | 'invalid';
+    }>;
+    deviceId: string;
+    lastUpdated: string;
+  }> {
+    let spinner: ReturnType<typeof ora> | null = null;
+    
+    try {
+      if (showSpinner) {
+        spinner = ora('Downloading merged MCP configurations from gateway endpoint...').start();
+      }
+
+      // Use provided API client or create one
+      let apiClient = api;
+      if (!apiClient) {
+        const credentials = await this.storage.getCredentials();
+        if (!credentials) {
+          throw new AuthenticationError(
+            AuthError.STORAGE_ERROR,
+            'No authentication found - cannot download MCP config'
+          );
+        }
+        apiClient = new DeployStackAPI(credentials, credentials.baseUrl);
+      }
+
+      // Call the new gateway endpoint that merges all three tiers
+      const response = await apiClient.getGatewayMCPConfigurations(hardwareId);
+      
+      if (!response.success) {
+        throw new AuthenticationError(
+          AuthError.NETWORK_ERROR,
+          'Failed to download merged MCP configurations from gateway endpoint'
+        );
+      }
+
+      const servers = response.data.servers || [];
+      const readyServers = servers.filter(s => s.status === 'ready');
+      const invalidServers = servers.filter(s => s.status === 'invalid');
+      
+      if (showSpinner && spinner) {
+        spinner.succeed(`Gateway MCP configurations downloaded (${readyServers.length} ready, ${invalidServers.length} invalid)`);
+      }
+
+      if (invalidServers.length > 0) {
+        console.log(chalk.yellow(`⚠️  ${invalidServers.length} server${invalidServers.length === 1 ? '' : 's'} marked as invalid (missing required user configurations)`));
+        invalidServers.forEach(server => {
+          console.log(chalk.gray(`   • ${server.name} (${server.id})`));
+        });
+      }
+
+      return {
+        servers,
+        deviceId: hardwareId,
+        lastUpdated: new Date().toISOString()
+      };
+    } catch (error) {
+      if (spinner) {
+        spinner.fail('Failed to download gateway MCP configurations');
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Download and store MCP configuration for a team (LEGACY METHOD)
    * @param teamId Team ID
    * @param teamName Team name (optional, will be set from API if not provided)
    * @param api DeployStack API client
diff --git a/services/gateway/src/services/refresh-service.ts b/services/gateway/src/services/refresh-service.ts
@@ -7,6 +7,7 @@ import { MCPConfigService } from '../core/mcp';
 import { ServerRestartService } from './server-restart-service';
 import { AuthenticationError } from '../types/auth';
 import { TeamMCPConfig, MCPServerConfig } from '../types/mcp';
+import { detectDeviceInfo } from '../utils/device-detection';
 
 export interface RefreshOptions {
   url?: string;
@@ -55,40 +56,79 @@ export class RefreshService {
       const backendUrl = options.url || credentials.baseUrl || 'https://cloud.deploystack.io';
       const api = new DeployStackAPI(credentials, backendUrl);
 
-      console.log(chalk.blue(`🔄 Refreshing MCP configuration for team: ${chalk.cyan(credentials.selectedTeam.name)}`));
+      console.log(chalk.blue(`🔄 Refreshing MCP configuration using new gateway endpoint`));
       
-      // 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();
+      // Step 1: Detect device and get device ID
+      spinner = ora('Detecting device and downloading latest MCP configurations...').start();
       
       try {
-        const newConfig = await this.mcpService.downloadAndStoreMCPConfig(
-          credentials.selectedTeam.id,
-          credentials.selectedTeam.name,
-          api,
-          false
-        );
+        // Detect current device information
+        const deviceInfo = await detectDeviceInfo();
+        
+        // Download merged configurations using the new gateway endpoint
+        // Backend will automatically find device by hardware_id
+        const gatewayConfig = await this.mcpService.downloadGatewayMCPConfig(deviceInfo.hardware_id, api, false);
+        
+        const readyServers = gatewayConfig.servers.filter(s => s.status === 'ready');
+        const invalidServers = gatewayConfig.servers.filter(s => s.status === 'invalid');
+        
+        spinner.succeed(`Gateway MCP configurations refreshed (${readyServers.length} ready, ${invalidServers.length} invalid)`);
+        console.log(chalk.green('✅ MCP configuration has been refreshed using new three-tier system'));
         
-        spinner.succeed(`MCP configuration refreshed (${newConfig.servers.length} server${newConfig.servers.length === 1 ? '' : 's'})`);
-        console.log(chalk.green('✅ MCP configuration has been refreshed'));
+        if (invalidServers.length > 0) {
+          console.log(chalk.yellow(`\n⚠️  ${invalidServers.length} server${invalidServers.length === 1 ? '' : 's'} marked as invalid:`));
+          invalidServers.forEach(server => {
+            console.log(chalk.gray(`   • ${server.name} - Missing required user configurations`));
+          });
+          console.log(chalk.gray(`💡 Configure these servers in the web UI to make them available`));
+        }
         
-        // Step 3: Detect changes and prompt for restart if needed
-        const changes = this.detectConfigurationChanges(oldConfig, newConfig);
+        // Step 2: Check if gateway restart is needed
+        const isRunning = this.restartService.isServerRunning();
         
-        if (changes.hasChanges) {
-          await this.handleConfigurationChanges(changes);
+        if (isRunning) {
+          console.log(chalk.yellow('\n⚠️  Gateway restart required for changes to take effect.'));
+          
+          // 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.'));
+          }
         } else {
-          console.log(chalk.gray('📋 No configuration changes detected'));
+          console.log(chalk.gray('💡 Gateway is not currently running. Changes will take effect when you start it.'));
         }
         
         // Show summary
         console.log(chalk.gray(`\n📊 Configuration Summary:`));
-        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()}`));
+        console.log(chalk.gray(`   Hardware ID: ${deviceInfo.hardware_id}`));
+        console.log(chalk.gray(`   Ready Servers: ${readyServers.length}`));
+        console.log(chalk.gray(`   Invalid Servers: ${invalidServers.length}`));
+        console.log(chalk.gray(`   Last Updated: ${new Date(gatewayConfig.lastUpdated).toLocaleString()}`));
         
       } catch (error) {
         spinner.fail('Failed to refresh MCP configuration');
diff --git a/services/gateway/src/utils/device-detection.ts b/services/gateway/src/utils/device-detection.ts
@@ -59,44 +59,42 @@ export async function generateHardwareFingerprint(): Promise<string> {
       .filter(iface => !iface?.internal && iface?.mac !== '00:00:00:00:00:00')
       .map(iface => iface?.mac)
       .filter(Boolean)
-      .sort();
+      .sort(); // Sort to ensure consistent ordering
 
     // Get CPU information
     const cpus = os.cpus();
     const cpuModel = cpus.length > 0 ? cpus[0].model : 'unknown';
 
-    // Create fingerprint data
+    // Create fingerprint data with consistent ordering
     const fingerprintData = {
-      macs: macAddresses,
-      hostname: os.hostname(),
-      platform: os.platform(),
       arch: os.arch(),
       cpuModel: cpuModel,
-      // Add some entropy from system info
-      totalmem: os.totalmem(),
-      homedir: os.homedir()
+      homedir: os.homedir(),
+      hostname: os.hostname(),
+      macs: macAddresses,
+      platform: os.platform(),
+      totalmem: os.totalmem()
     };
 
-    // Generate SHA256 hash
+    // Generate SHA256 hash with deterministic JSON serialization
     const fingerprint = crypto
       .createHash('sha256')
-      .update(JSON.stringify(fingerprintData))
+      .update(JSON.stringify(fingerprintData, Object.keys(fingerprintData).sort()))
       .digest('hex');
 
     // Return first 32 characters for consistency
     return fingerprint.substring(0, 32);
   } catch {
-    // Fallback fingerprint if hardware detection fails
+    // Fallback fingerprint if hardware detection fails (deterministic)
     const fallbackData = {
-      hostname: os.hostname(),
-      platform: os.platform(),
       arch: os.arch(),
-      timestamp: Date.now()
+      hostname: os.hostname(),
+      platform: os.platform()
     };
 
     const fallbackFingerprint = crypto
       .createHash('sha256')
-      .update(JSON.stringify(fallbackData))
+      .update(JSON.stringify(fallbackData, Object.keys(fallbackData).sort()))
       .digest('hex');
 
     return fallbackFingerprint.substring(0, 32);
