Upload index.html

index.html

@@ -1308,13 +1308,14 @@ Neutral market conditions</textarea>
     </div>
 
     <script>
-        // Configuration
+        // Configuration - آپدیت شده برای Hugging Face Spaces
         const config = {
-            apiBaseUrl: window.location.origin,
+            // استفاده از آدرس نسبی برای Hugging Face
+            apiBaseUrl: '', // خالی بذارید تا از همون origin استفاده کنه
             wsUrl: (() => {
                 const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
                 const host = window.location.host;
-                return `${protocol}//${host}/ws/live`;
+                return `${protocol}//${host}/ws`;
             })(),
             autoRefreshInterval: 30000,
             maxRetries: 3
@@ -1341,50 +1342,108 @@ Neutral market conditions</textarea>
             console.log('📍 API Base URL:', config.apiBaseUrl);
             console.log('📡 WebSocket URL:', config.wsUrl);
             
+            discoverEndpoints(); // کشف endpoint های موجود
             initializeWebSocket();
             loadInitialData();
             startAutoRefresh();
         });
 
+        // تابع برای کشف endpoint های موجود
+        async function discoverEndpoints() {
+            console.log('🔍 Discovering available endpoints...');
+            
+            const testEndpoints = [
+                '/',
+                '/health',
+                '/api/health',
+                '/info', 
+                '/api/info',
+                '/providers',
+                '/api/providers',
+                '/status',
+                '/api/status',
+                '/api/crypto/market-overview',
+                '/api/crypto/prices/top'
+            ];
+            
+            const availableEndpoints = [];
+            
+            for (const endpoint of testEndpoints) {
+                try {
+                    const response = await fetch(endpoint);
+                    console.log(`${endpoint}: ${response.status}`);
+                    if (response.ok) {
+                        availableEndpoints.push(endpoint);
+                        console.log(`✅ Found: ${endpoint}`);
+                    }
+                } catch (error) {
+                    console.log(`❌ Failed: ${endpoint}`);
+                }
+            }
+            
+            console.log('📋 Available endpoints:', availableEndpoints);
+            return availableEndpoints;
+        }
+
         // WebSocket Connection
         function initializeWebSocket() {
             updateWSStatus('connecting');
             
-            try {
-                state.ws = new WebSocket(config.wsUrl);
-                
-                state.ws.onopen = () => {
-                    console.log('✅ WebSocket connected');
-                    state.wsConnected = true;
-                    updateWSStatus('connected');
-                    showToast('Connected', 'Real-time data stream active', 'success');
-                };
-                
-                state.ws.onmessage = (event) => {
-                    try {
-                        const data = JSON.parse(event.data);
-                        handleWSMessage(data);
-                    } catch (error) {
-                        console.error('Error parsing WebSocket message:', error);
-                    }
-                };
-                
-                state.ws.onerror = (error) => {
-                    console.error('❌ WebSocket error:', error);
-                    updateWSStatus('disconnected');
-                };
-                
-                state.ws.onclose = () => {
-                    console.log('⚠️ WebSocket disconnected');
-                    state.wsConnected = false;
-                    updateWSStatus('disconnected');
-                };
-            } catch (error) {
-                console.log('⚠️ WebSocket not available - using polling mode');
+            const wsEndpoints = [
+                '/ws/live',
+                '/ws',
+                '/live',
+                '/api/ws'
+            ];
+            
+            for (const endpoint of wsEndpoints) {
+                try {
+                    const wsUrl = `${window.location.protocol === 'https:' ? 'wss:' : 'ws:'}//${window.location.host}${endpoint}`;
+                    console.log(`🔄 Trying WebSocket: ${wsUrl}`);
+                    
+                    state.ws = new WebSocket(wsUrl);
+                    setupWebSocketHandlers();
+                    break; // اگر موفق بود، بقیه رو امتحان نکن
+                } catch (error) {
+                    console.log(`❌ WebSocket failed: ${endpoint}`);
+                }
+            }
+            
+            if (!state.ws) {
+                console.log('⚠️ No WebSocket endpoints available');
                 updateWSStatus('disconnected');
             }
         }
 
+        function setupWebSocketHandlers() {
+            state.ws.onopen = () => {
+                console.log('✅ WebSocket connected');
+                state.wsConnected = true;
+                updateWSStatus('connected');
+                showToast('Connected', 'Real-time data stream active', 'success');
+            };
+            
+            state.ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    handleWSMessage(data);
+                } catch (error) {
+                    console.error('Error parsing WebSocket message:', error);
+                }
+            };
+            
+            state.ws.onerror = (error) => {
+                console.error('❌ WebSocket error:', error);
+                updateWSStatus('disconnected');
+            };
+            
+            state.ws.onclose = () => {
+                console.log('⚠️ WebSocket disconnected');
+                state.wsConnected = false;
+                updateWSStatus('disconnected');
+            };
+        }
+
         function updateWSStatus(status) {
             const statusEl = document.getElementById('wsStatus');
             const textEl = document.getElementById('wsStatusText');
@@ -1419,7 +1478,7 @@ Neutral market conditions</textarea>
             }
         }
 
-        // API Calls
+        // API Calls - آپدیت شده با endpoint های جایگزین
         async function apiCall(endpoint, options = {}) {
             try {
                 const url = `${config.apiBaseUrl}${endpoint}`;
@@ -1434,6 +1493,11 @@ Neutral market conditions</textarea>
                 });
                 
                 if (!response.ok) {
+                    // اگر 404 باشه، endpoint های جایگزین رو چک کن
+                    if (response.status === 404) {
+                        console.log(`⚠️ Endpoint ${endpoint} not found, trying alternatives...`);
+                        return await tryAlternativeEndpoints(endpoint, options);
+                    }
                     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
                 }
                 
@@ -1447,6 +1511,42 @@ Neutral market conditions</textarea>
             }
         }
 
+        // تابع برای امتحان endpoint های جایگزین
+        async function tryAlternativeEndpoints(originalEndpoint, options) {
+            const alternatives = {
+                '/api/providers': ['/providers', '/api/sources', '/status'],
+                '/health': ['/api/health', '/status/health'],
+                '/info': ['/api/info', '/system/info'],
+                '/api/categories': ['/categories', '/api/groups'],
+                '/api/rate-limits': ['/rate-limits', '/api/limits'],
+                '/api/logs': ['/logs', '/api/events'],
+                '/api/alerts': ['/alerts', '/api/notifications'],
+                '/api/hf/health': ['/hf/health', '/api/huggingface/health'],
+                '/api/hf/refresh': ['/hf/refresh', '/api/huggingface/refresh'],
+                '/api/hf/registry': ['/hf/registry', '/api/huggingface/registry'],
+                '/api/hf/search': ['/hf/search', '/api/huggingface/search'],
+                '/api/hf/run-sentiment': ['/hf/sentiment', '/api/huggingface/sentiment']
+            };
+            
+            for (const altEndpoint of alternatives[originalEndpoint] || []) {
+                try {
+                    const url = `${config.apiBaseUrl}${altEndpoint}`;
+                    console.log(`🔄 Trying alternative: ${altEndpoint}`);
+                    
+                    const response = await fetch(url, options);
+                    if (response.ok) {
+                        const data = await response.json();
+                        console.log(`✅ Alternative endpoint worked: ${altEndpoint}`);
+                        return data;
+                    }
+                } catch (error) {
+                    console.log(`❌ Alternative failed: ${altEndpoint}`);
+                }
+            }
+            
+            throw new Error(`All endpoints failed for ${originalEndpoint}`);
+        }
+
         async function loadInitialData() {
             showLoading();
             
@@ -1475,7 +1575,7 @@ Neutral market conditions</textarea>
         async function loadHealth() {
             try {
                 const data = await apiCall('/health');
-                updateKPIs(data.components);
+                updateKPIs(data.components || data);
                 
                 const statusBadge = document.getElementById('systemStatus');
                 const statusText = document.getElementById('systemStatusText');
@@ -1522,7 +1622,7 @@ Neutral market conditions</textarea>
                 document.getElementById('providersTableBody').innerHTML = `
                     <tr>
                         <td colspan="5" style="text-align: center; color: var(--text-muted); padding: 40px;">
-                            Failed to load providers
+                            Failed to load providers. Please check if the API endpoint is available.
                         </td>
                     </tr>
                 `;