Add Prowlarr status monitoring and UI integration

- Implemented Prowlarr status polling in the frontend, refreshing every 30 seconds when the home section is active.
- Added a new Prowlarr status card in the UI, displaying connection status, active indexers, total API calls, throttled indexers, and failed indexers.
- Created backend API route to fetch Prowlarr statistics, including connection health and indexer status.
- Enhanced error handling for Prowlarr data retrieval and updated UI elements for better user feedback.

Author: Admin9705

frontend/static/js/new-main.js

@@ -151,6 +151,9 @@ let huntarrUI = {
         // Setup Swaparr status polling (refresh every 30 seconds)
         this.setupSwaparrStatusPolling();
 
+        // Setup Prowlarr status polling (refresh every 30 seconds)
+        this.setupProwlarrStatusPolling();
+        
         // Make dashboard visible after initialization to prevent FOUC
         setTimeout(() => {
             this.showDashboard();
@@ -2300,7 +2303,178 @@ let huntarrUI = {
             }
         }, 30000);
     },
-    
+
+    // Setup Prowlarr status polling  
+    setupProwlarrStatusPolling: function() {
+        // Load initial status
+        this.loadProwlarrStatus();
+        
+        // Set up polling to refresh Prowlarr status every 30 seconds
+        // Only poll when home section is active to reduce unnecessary requests
+        setInterval(() => {
+            if (this.currentSection === 'home') {
+                this.loadProwlarrStatus();
+            }
+        }, 30000);
+    },
+
+    // Load and update Prowlarr status card
+    loadProwlarrStatus: function() {
+        HuntarrUtils.fetchWithTimeout('./api/prowlarr/status')
+            .then(response => response.json())
+            .then(statusData => {
+                const prowlarrCard = document.getElementById('prowlarrStatusCard');
+                if (!prowlarrCard) return;
+
+                // Show/hide card based on whether Prowlarr is configured and enabled
+                if (statusData.configured && statusData.enabled) {
+                    prowlarrCard.style.display = 'block';
+                    
+                    // Update connection status
+                    const statusElement = document.getElementById('prowlarrConnectionStatus');
+                    if (statusElement) {
+                        if (statusData.connected) {
+                            statusElement.textContent = '🟢 Connected';
+                            statusElement.className = 'status-badge success';
+                        } else {
+                            statusElement.textContent = '🔴 Disconnected';
+                            statusElement.className = 'status-badge error';
+                        }
+                    }
+                    
+                    // Load detailed stats if connected
+                    if (statusData.connected) {
+                        this.loadProwlarrStats();
+                    } else {
+                        // Show disconnected state
+                        this.updateProwlarrStatsDisplay({
+                            active_indexers: '--',
+                            total_api_calls: '--',
+                            throttled_indexers: '--',
+                            failed_indexers: '--',
+                            health_status: 'Disconnected'
+                        });
+                    }
+                    
+                    // Setup refresh button
+                    this.setupProwlarrRefreshButton();
+                    
+                } else {
+                    prowlarrCard.style.display = 'none';
+                }
+            })
+            .catch(error => {
+                console.error('Error loading Prowlarr status:', error);
+                const prowlarrCard = document.getElementById('prowlarrStatusCard');
+                if (prowlarrCard) {
+                    prowlarrCard.style.display = 'none';
+                }
+            });
+    },
+
+    // Load detailed Prowlarr statistics
+    loadProwlarrStats: function() {
+        HuntarrUtils.fetchWithTimeout('./api/prowlarr/stats')
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    this.updateProwlarrStatsDisplay(data.stats);
+                } else {
+                    console.error('Failed to load Prowlarr stats:', data.error);
+                    this.updateProwlarrStatsDisplay({
+                        active_indexers: '--',
+                        total_api_calls: '--',
+                        throttled_indexers: '--',
+                        failed_indexers: '--',
+                        health_status: 'Error loading stats'
+                    });
+                }
+            })
+            .catch(error => {
+                console.error('Error loading Prowlarr stats:', error);
+                this.updateProwlarrStatsDisplay({
+                    active_indexers: '--',
+                    total_api_calls: '--',
+                    throttled_indexers: '--',
+                    failed_indexers: '--',
+                    health_status: 'Connection error'
+                });
+            });
+    },
+
+    // Update Prowlarr stats display
+    updateProwlarrStatsDisplay: function(stats) {
+        // Update stat numbers
+        const activeElement = document.getElementById('prowlarr-active-indexers');
+        if (activeElement) activeElement.textContent = stats.active_indexers;
+        
+        const callsElement = document.getElementById('prowlarr-total-calls');
+        if (callsElement) callsElement.textContent = this.formatLargeNumber(stats.total_api_calls);
+        
+        const throttledElement = document.getElementById('prowlarr-throttled');
+        if (throttledElement) throttledElement.textContent = stats.throttled_indexers;
+        
+        const failedElement = document.getElementById('prowlarr-failed');
+        if (failedElement) failedElement.textContent = stats.failed_indexers;
+        
+        // Update health status
+        const healthElement = document.getElementById('prowlarr-health-status');
+        if (healthElement) {
+            healthElement.textContent = stats.health_status || 'Unknown';
+            
+            // Add color coding based on health
+            if (stats.health_status && stats.health_status.includes('throttled')) {
+                healthElement.style.color = '#f59e0b'; // amber
+            } else if (stats.health_status && (stats.health_status.includes('failed') || stats.health_status.includes('disabled'))) {
+                healthElement.style.color = '#ef4444'; // red
+            } else if (stats.health_status && stats.health_status.includes('healthy')) {
+                healthElement.style.color = '#10b981'; // green
+            } else {
+                healthElement.style.color = '#9ca3af'; // gray
+            }
+        }
+    },
+
+    // Setup Prowlarr refresh button
+    setupProwlarrRefreshButton: function() {
+        const refreshButton = document.getElementById('refresh-prowlarr-data');
+        if (refreshButton) {
+            refreshButton.addEventListener('click', () => {
+                this.refreshProwlarrData();
+            });
+        }
+    },
+
+    // Refresh Prowlarr data
+    refreshProwlarrData: function() {
+        // Prevent multiple refreshes
+        if (this.prowlarrRefreshInProgress) {
+            return;
+        }
+        
+        this.prowlarrRefreshInProgress = true;
+        
+        // Update button to show refreshing state
+        const refreshButton = document.getElementById('refresh-prowlarr-data');
+        if (refreshButton) {
+            const originalText = refreshButton.innerHTML;
+            refreshButton.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Refreshing...';
+            refreshButton.disabled = true;
+            
+            // Restore button after refresh
+            setTimeout(() => {
+                refreshButton.innerHTML = originalText;
+                refreshButton.disabled = false;
+                this.prowlarrRefreshInProgress = false;
+            }, 2000);
+        }
+        
+        // Reload Prowlarr status and stats
+        this.loadProwlarrStatus();
+        
+        // Show notification
+        this.showNotification('Prowlarr data refreshed', 'success');
+    },
 
 
     // User

frontend/templates/components/home_section.html

@@ -580,6 +580,75 @@ <h3><i class="fas fa-download"></i> Swaparr Status</h3>
             </div>
         </div>
 
+        <!-- Additional CSS for Prowlarr Status Card -->
+        <style>
+            .prowlarr-stats-grid {
+                display: grid;
+                grid-template-columns: 1fr;
+                gap: 15px;
+                width: 100%;
+            }
+            
+            .prowlarr-health-indicator {
+                margin-top: 10px;
+                padding: 8px 12px;
+                background-color: rgba(32, 38, 50, 0.6);
+                border-radius: 6px;
+                border-left: 3px solid #6366f1;
+            }
+            
+            .health-status-text {
+                font-size: 0.9em;
+                font-weight: 500;
+                color: #9ca3af;
+            }
+        </style>
+
+        <!-- Prowlarr Status Card -->
+        <div class="card stats-card" id="prowlarrStatusCard" style="display: none;">
+            <div class="card-header">
+                <h3><i class="fas fa-search"></i> Prowlarr Monitor</h3>
+                <button id="refresh-prowlarr-data" class="action-button success"><i class="fas fa-sync-alt"></i> Refresh</button>
+            </div>
+            <div class="media-stats-container">
+                <div class="prowlarr-stats-grid">
+                    <!-- Prowlarr Stats Card -->
+                    <div class="app-stats-card prowlarr">
+                        <div class="status-container">
+                            <span id="prowlarrConnectionStatus" class="status-badge">⚫ Disconnected</span>
+                        </div>
+                        <div class="app-content">
+                            <div class="app-icon-wrapper">
+                                <img src="./static/images/app-icons/sonarr.png" alt="Prowlarr Logo" class="app-logo" style="filter: hue-rotate(60deg);">
+                            </div>
+                            <h4>Prowlarr</h4>
+                        </div>
+                        <div class="stats-numbers">
+                            <div class="stat-box">
+                                <div class="stat-number" id="prowlarr-active-indexers">--</div>
+                                <div class="stat-label">Active Indexers</div>
+                            </div>
+                            <div class="stat-box">
+                                <div class="stat-number" id="prowlarr-total-calls">--</div>
+                                <div class="stat-label">Total API Calls</div>
+                            </div>
+                            <div class="stat-box">
+                                <div class="stat-number" id="prowlarr-throttled">--</div>
+                                <div class="stat-label">Throttled Indexers</div>
+                            </div>
+                            <div class="stat-box">
+                                <div class="stat-number" id="prowlarr-failed">--</div>
+                                <div class="stat-label">Failed Indexers</div>
+                            </div>
+                        </div>
+                        <div class="prowlarr-health-indicator">
+                            <div id="prowlarr-health-status" class="health-status-text">Checking connection...</div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
     </div>
 </section>
 

src/primary/apps/prowlarr_routes.py

@@ -151,6 +151,130 @@ def get_status():
         prowlarr_logger.error(f"Error getting Prowlarr status: {str(e)}")
         return jsonify({"configured": False, "connected": False, "error": str(e)})
 
+@prowlarr_bp.route('/stats', methods=['GET'])
+def get_prowlarr_stats():
+    """Get Prowlarr statistics for homepage monitoring"""
+    try:
+        settings = load_settings("prowlarr")
+        
+        api_url = settings.get("api_url", "").strip()
+        api_key = settings.get("api_key", "").strip()
+        enabled = settings.get("enabled", True)
+        
+        if not api_url or not api_key or not enabled:
+            return jsonify({
+                'success': False,
+                'error': 'Prowlarr is not configured or enabled'
+            }), 400
+        
+        # Clean URL
+        if not api_url.startswith(('http://', 'https://')):
+            api_url = f'http://{api_url}'
+        
+        headers = {'X-Api-Key': api_key}
+        
+        # Initialize stats
+        stats = {
+            'connected': False,
+            'active_indexers': 0,
+            'total_indexers': 0,
+            'throttled_indexers': 0,
+            'failed_indexers': 0,
+            'total_api_calls': 0,
+            'version': 'Unknown',
+            'health_status': 'Disconnected'
+        }
+        
+        try:
+            # Get system status
+            status_url = f"{api_url.rstrip('/')}/api/v1/system/status"
+            status_response = requests.get(status_url, headers=headers, timeout=10)
+            
+            if status_response.status_code == 200:
+                status_data = status_response.json()
+                stats['connected'] = True
+                stats['version'] = status_data.get('version', 'Unknown')
+                stats['health_status'] = 'Connected'
+                
+                # Get indexers information
+                try:
+                    indexers_url = f"{api_url.rstrip('/')}/api/v1/indexer"
+                    indexers_response = requests.get(indexers_url, headers=headers, timeout=10)
+                    
+                    if indexers_response.status_code == 200:
+                        indexers = indexers_response.json()
+                        stats['total_indexers'] = len(indexers)
+                        
+                        # Count active, throttled, and failed indexers
+                        active_count = 0
+                        throttled_count = 0
+                        failed_count = 0
+                        
+                        for indexer in indexers:
+                            if indexer.get('enable', False):
+                                active_count += 1
+                                
+                            # Check for throttling/rate limiting
+                            capabilities = indexer.get('capabilities', {})
+                            if capabilities.get('limitsexceeded', False):
+                                throttled_count += 1
+                                
+                            # Check for failures - look for disabled indexers or low priority
+                            if not indexer.get('enable', False):
+                                failed_count += 1
+                        
+                        stats['active_indexers'] = active_count
+                        stats['throttled_indexers'] = throttled_count
+                        stats['failed_indexers'] = failed_count
+                        
+                        # Update health status based on indexer health
+                        if throttled_count > 0:
+                            stats['health_status'] = f'{throttled_count} indexer(s) throttled'
+                        elif failed_count > 0:
+                            stats['health_status'] = f'{failed_count} indexer(s) disabled'
+                        else:
+                            stats['health_status'] = 'All indexers healthy'
+                            
+                except Exception:
+                    # Indexer endpoint failed but system is connected
+                    stats['health_status'] = 'Indexer data unavailable'
+                
+                # Get API history/usage statistics
+                try:
+                    history_url = f"{api_url.rstrip('/')}/api/v1/history"
+                    history_response = requests.get(history_url, headers=headers, timeout=10, params={'pageSize': 1})
+                    
+                    if history_response.status_code == 200:
+                        history_data = history_response.json()
+                        # Total records gives us approximate API call count
+                        stats['total_api_calls'] = history_data.get('totalRecords', 0)
+                        
+                except Exception:
+                    # History endpoint failed, keep default value
+                    pass
+                    
+            else:
+                stats['health_status'] = f'Connection failed (HTTP {status_response.status_code})'
+                
+        except requests.exceptions.Timeout:
+            stats['health_status'] = 'Connection timeout'
+        except requests.exceptions.ConnectionError:
+            stats['health_status'] = 'Connection refused'
+        except Exception as e:
+            stats['health_status'] = f'Error: {str(e)[:50]}'
+        
+        return jsonify({
+            'success': True,
+            'stats': stats
+        })
+        
+    except Exception as e:
+        prowlarr_logger.error(f"Failed to get Prowlarr stats: {str(e)}")
+        return jsonify({
+            'success': False,
+            'error': f'Failed to get Prowlarr stats: {str(e)}'
+        }), 500
+
 @prowlarr_bp.route('/test-connection', methods=['POST'])
 def test_connection_endpoint():
     """Test connection to Prowlarr API instance"""