refactor(gateway): streamline device registration during OAuth2 flow

Author: Lasim

services/gateway/src/commands/login.ts

@@ -69,11 +69,21 @@ export function registerLoginCommand(program: Command) {
               // Detect current device information
               const deviceInfo = await detectDeviceInfo();
 
-              // Register or update device with backend
-              const device = await api.registerOrUpdateDevice(deviceInfo);
+              // Device registration already happened during OAuth2 token exchange
+              // No separate device API call needed - just use hardware_id directly
 
-              // Download merged configurations using the new gateway endpoint
-              const gatewayConfig = await mcpService.downloadGatewayMCPConfig(device.id, api, false);
+              // Download merged configurations using the new gateway endpoint with hardware_id
+              const gatewayConfig = await mcpService.downloadGatewayMCPConfig(deviceInfo.hardware_id, api, false);
+              
+              // Convert and store the gateway config in the format expected by local storage
+              const teamMCPConfig = mcpService.convertGatewayConfigToTeamConfig(
+                defaultTeam.id,
+                defaultTeam.name,
+                gatewayConfig
+              );
+              
+              // Store the converted configuration
+              await mcpService.storeMCPConfig(teamMCPConfig);
 
               // Auto-start the gateway server after successful MCP config download
               spinner.text = 'Starting gateway server...';

services/gateway/src/core/auth/api-client.ts

@@ -302,11 +302,14 @@ export class DeployStackAPI {
       }
 
       const contentType = response.headers.get('content-type');
+      let responseData;
       if (contentType && contentType.includes('application/json')) {
-        return await response.json();
+        responseData = await response.json();
       } else {
-        return await response.text();
+        responseData = await response.text();
       }
+      
+      return responseData;
     } catch (error) {
       if (error instanceof AuthenticationError) {
         throw error;

services/gateway/src/core/mcp/config-service.ts

@@ -289,4 +289,104 @@ export class MCPConfigService {
       lastUpdated: config.last_updated
     };
   }
+
+  /**
+   * Convert gateway configuration to team configuration for local storage
+   * @param teamId Team ID
+   * @param teamName Team name 
+   * @param gatewayConfig Gateway configuration from new API
+   * @returns Team MCP configuration for storage
+   */
+  convertGatewayConfigToTeamConfig(
+    teamId: string,
+    teamName: string,
+    gatewayConfig: {
+      servers: Array<{
+        id: string;
+        name: string;
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        status: 'ready' | 'invalid';
+      }>;
+      deviceId: string;
+      lastUpdated: string;
+    }
+  ): TeamMCPConfig {
+    // Convert gateway servers to TeamMCPConfig format
+    const servers = gatewayConfig.servers.map(server => ({
+      id: server.id,
+      name: server.name,
+      installation_name: server.name,
+      command: server.command,
+      args: server.args,
+      env: server.env,
+      runtime: this.detectRuntime(server.command, server.args),
+      installation_type: 'local' as const,
+      transport_type: 'stdio' as const,
+      status: server.status
+    }));
+
+    // Create mock installations for compatibility (since gateway endpoint doesn't return installations)
+    const installations = gatewayConfig.servers.map(server => ({
+      id: server.id,
+      team_id: teamId,
+      server_id: server.id,
+      created_by: 'gateway-endpoint',
+      installation_name: server.name,
+      installation_type: 'local' as const,
+      team_args: server.args,
+      team_env: server.env,
+      created_at: gatewayConfig.lastUpdated,
+      updated_at: gatewayConfig.lastUpdated,
+      last_used_at: null,
+      server: {
+        id: server.id,
+        name: server.name,
+        description: `MCP server: ${server.name}`,
+        github_url: null,
+        runtime: this.detectRuntime(server.command, server.args),
+        installation_methods: [{
+          type: 'command' as const,
+          command: server.command,
+          args: server.args
+        }],
+        environment_variables: [],
+        transport_type: 'stdio' as const
+      }
+    }));
+
+    return {
+      team_id: teamId,
+      team_name: teamName,
+      installations,
+      user_configurations: [], // Empty since gateway endpoint handles user configs internally
+      servers,
+      last_updated: gatewayConfig.lastUpdated
+    };
+  }
+
+  /**
+   * Store MCP configuration (wrapper around storage)
+   * @param config Team MCP configuration to store
+   */
+  async storeMCPConfig(config: TeamMCPConfig): Promise<void> {
+    await this.storage.storeMCPConfig(config);
+  }
+
+  /**
+   * Detect runtime from command and args
+   * @param command Command string
+   * @param _args Command arguments
+   * @returns Detected runtime
+   */
+  private detectRuntime(command: string, _args: string[]): 'nodejs' | 'python' | 'binary' {
+    if (command === 'npx' || command === 'node') {
+      return 'nodejs';
+    }
+    if (command === 'python' || command === 'python3' || command === 'pip') {
+      return 'python';
+    }
+    return 'binary';
+  }
 }

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

@@ -69,6 +69,16 @@ export class RefreshService {
         // Backend will automatically find device by hardware_id
         const gatewayConfig = await this.mcpService.downloadGatewayMCPConfig(deviceInfo.hardware_id, api, false);
 
+        // Convert and store the gateway config in the format expected by local storage
+        const teamMCPConfig = this.mcpService.convertGatewayConfigToTeamConfig(
+          credentials.selectedTeam.id,
+          credentials.selectedTeam.name,
+          gatewayConfig
+        );
+        
+        // Store the converted configuration
+        await this.mcpService.storeMCPConfig(teamMCPConfig);
+        
         const readyServers = gatewayConfig.servers.filter(s => s.status === 'ready');
         const invalidServers = gatewayConfig.servers.filter(s => s.status === 'invalid');
 

services/gateway/src/types/mcp.ts

@@ -63,14 +63,15 @@ export interface MCPUserConfigurationsResponse {
 // Processed MCP Server Config for Gateway
 export interface MCPServerConfig {
   id: string;
-  name: string;
+  name?: string;
   installation_name: string;
   command: string;
   args: string[];
   env: Record<string, string>;
   runtime: string;
-  installation_type: 'local' | 'cloud';
-  transport_type: 'stdio' | 'http' | 'sse';
+  installation_type?: 'local' | 'cloud';
+  transport_type?: 'stdio' | 'http' | 'sse';
+  status?: 'ready' | 'invalid';
 }
 
 // Team MCP Configuration stored securely (Three-tier architecture)