From ba37225e1b45f7162fde9f9dc1a0f3f2959a97fc Mon Sep 17 00:00:00 2001
From: Broque Thomas <batmanesignal@gmail.com>
Date: Mon, 22 Sep 2025 09:46:30 -0700
Subject: [PATCH] gui navidrome support

---
 config/config.json           |  12 +-
 ui/assets/navidrome_icon.png | Bin 0 -> 13071 bytes
 ui/pages/dashboard.py        |   9 +-
 ui/pages/settings.py         | 420 +++++++++++++++++++++++++++++++++--
 ui/pages/sync.py             |  56 ++++-
 ui/sidebar.py                |  15 +-
 webui/static/script.js       |  22 +-
 7 files changed, 489 insertions(+), 45 deletions(-)
 create mode 100644 ui/assets/navidrome_icon.png

diff --git a/config/config.json b/config/config.json
index 951c7d8..8afd09b 100644
--- a/config/config.json
+++ b/config/config.json
@@ -20,11 +20,17 @@
     "api_key": "JELLYFIN_API_KEY",
     "auto_detect": true
   },
+  "navidrome": {
+    "base_url": "http://localhost:4533",
+    "username": "NAVIDROME_USERNAME",
+    "password": "NAVIDROME_PASSWORD",
+    "auto_detect": true
+  },
   "soulseek": {
-    "slskd_url": "http://localhost:5030",
+    "slskd_url": "http://host.docker.internal:5030",
     "api_key": "SoulseekAPIKey",
-    "download_path": "./Downloads",
-    "transfer_path": "./Transfer"
+    "download_path": "/app/downloads",
+    "transfer_path": "/app/Transfer"
   },
   "logging": {
     "path": "logs/app.log",
diff --git a/ui/assets/navidrome_icon.png b/ui/assets/navidrome_icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..1fa2234e186b06aa955db4e764f57051cd73d43d
GIT binary patch
literal 13071
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
X|L<VBF7EKp0U#+VCsHN!JK(<n0Tq+j

literal 0
HcmV?d00001

diff --git a/ui/pages/dashboard.py b/ui/pages/dashboard.py
index 60741fc..04128ed 100644
--- a/ui/pages/dashboard.py
+++ b/ui/pages/dashboard.py
@@ -1943,6 +1943,7 @@ class DashboardDataProvider(QObject):
             'spotify': ServiceStatus('Spotify', False, datetime.now()),
             'plex': ServiceStatus('Plex', False, datetime.now()),
             'jellyfin': ServiceStatus('Jellyfin', False, datetime.now()),
+            'navidrome': ServiceStatus('Navidrome', False, datetime.now()),
             'soulseek': ServiceStatus('Soulseek', False, datetime.now())
         }
         self.download_stats = DownloadStats()
@@ -2100,6 +2101,7 @@ class DashboardDataProvider(QObject):
             'spotify': 'spotify_client',
             'plex': 'plex_client',
             'jellyfin': None,  # Jellyfin doesn't need a client, tests via config
+            'navidrome': 'navidrome_client',
             'soulseek': 'soulseek_client'
         }
         
@@ -3053,7 +3055,12 @@ class DashboardPage(QWidget):
         # Create service status cards with dynamic media server
         from config.settings import config_manager
         active_server = config_manager.get_active_media_server()
-        server_name = "Plex" if active_server == "plex" else "Jellyfin"
+        server_name_map = {
+            'plex': 'Plex',
+            'jellyfin': 'Jellyfin',
+            'navidrome': 'Navidrome'
+        }
+        server_name = server_name_map.get(active_server, 'Jellyfin')
         services = ['Spotify', server_name, 'Soulseek']
         for service in services:
             card = ServiceStatusCard(service)
diff --git a/ui/pages/settings.py b/ui/pages/settings.py
index a4fac5d..fd61904 100644
--- a/ui/pages/settings.py
+++ b/ui/pages/settings.py
@@ -904,6 +904,125 @@ class JellyfinDetectionThread(QThread):
             
         return False
 
+class NavidromeDetectionThread(QThread):
+    progress_updated = pyqtSignal(int, str)  # progress value, current url
+    detection_completed = pyqtSignal(str)  # found_url (empty if not found)
+
+    def __init__(self):
+        super().__init__()
+        self.cancelled = False
+
+    def cancel(self):
+        self.cancelled = True
+
+    def run(self):
+        import requests
+        import socket
+        import ipaddress
+
+        def get_network_info():
+            """Get comprehensive network information with subnet detection"""
+            try:
+                # Get local IP using socket method
+                s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+                s.connect(("8.8.8.8", 80))
+                local_ip = s.getsockname()[0]
+                s.close()
+
+                # Parse network info
+                network = ipaddress.ip_network(f"{local_ip}/24", strict=False)
+                return {
+                    'local_ip': local_ip,
+                    'network': network,
+                    'subnet': str(network.network_address) + "/24"
+                }
+            except Exception as e:
+                print(f"Error getting network info: {e}")
+                return {'local_ip': '127.0.0.1', 'network': None, 'subnet': '127.0.0.1/32'}
+
+        try:
+            # Test common Navidrome URLs first
+            common_urls = [
+                "http://localhost:4533",
+                "http://127.0.0.1:4533",
+                "http://navidrome:4533"
+            ]
+
+            network_info = get_network_info()
+            local_ip = network_info['local_ip']
+
+            # Add local IP with common ports
+            common_urls.extend([
+                f"http://{local_ip}:4533"
+            ])
+
+            total_hosts = len(common_urls)
+            current_host = 0
+
+            # Test common URLs first
+            for url in common_urls:
+                if self.cancelled:
+                    break
+
+                current_host += 1
+                self.progress_updated.emit(int((current_host / total_hosts) * 100), url)
+
+                if self.test_navidrome_url(url):
+                    self.detection_completed.emit(url)
+                    return
+
+            # If no common URLs worked, signal not found
+            self.detection_completed.emit("")
+
+        except Exception as e:
+            print(f"Navidrome detection error: {e}")
+            self.detection_completed.emit("")
+
+    def test_navidrome_url(self, url, timeout=5):
+        """Test if URL hosts a Navidrome server by checking for ping endpoint"""
+        try:
+            # Test Navidrome ping endpoint
+            ping_url = f"{url.rstrip('/')}/rest/ping"
+            print(f"Testing Navidrome at: {ping_url}")
+
+            response = requests.get(ping_url, params={
+                'u': 'test',
+                't': 'test',
+                's': 'test',
+                'v': '1.16.1',
+                'c': 'SoulSync',
+                'f': 'json'
+            }, timeout=timeout)
+
+            print(f"Response status: {response.status_code}")
+
+            # Navidrome should return status 401 or 403 for invalid credentials, not 404
+            if response.status_code in [200, 401, 403]:
+                try:
+                    data = response.json()
+                    print(f"Response data: {data}")
+                    # Check if it's a valid Subsonic API response
+                    if 'subsonic-response' in data:
+                        print(f"✓ Found Navidrome server at {url}")
+                        return True
+                except Exception as e:
+                    print(f"JSON parse error: {e}")
+
+            # Also try a simple GET to the root to see if it's at least a web server
+            try:
+                root_response = requests.get(url, timeout=timeout)
+                if root_response.status_code == 200 and 'navidrome' in root_response.text.lower():
+                    print(f"✓ Found Navidrome web interface at {url}")
+                    return True
+            except:
+                pass
+
+            return False
+
+        except Exception as e:
+            print(f"Error testing {url}: {e}")
+            return False
+
 class SettingsGroup(QGroupBox):
     def __init__(self, title: str, parent=None):
         super().__init__(title, parent)
@@ -1091,19 +1210,29 @@ class SettingsPage(QWidget):
             jellyfin_config = config_manager.get_jellyfin_config()
             self.jellyfin_url_input.setText(jellyfin_config.get('base_url', ''))
             self.jellyfin_api_key_input.setText(jellyfin_config.get('api_key', ''))
-            
+
+            # Load Navidrome config
+            navidrome_config = config_manager.get_navidrome_config()
+            self.navidrome_url_input.setText(navidrome_config.get('base_url', ''))
+            self.navidrome_username_input.setText(navidrome_config.get('username', ''))
+            self.navidrome_password_input.setText(navidrome_config.get('password', ''))
+
             # Initialize server selection
             active_server = config_manager.get_active_media_server()
             self.pending_server_change = None
             self.update_server_toggle_styles(active_server)
             
             # Show/hide appropriate containers based on active server
+            self.plex_container.hide()
+            self.jellyfin_container.hide()
+            self.navidrome_container.hide()
+
             if active_server == 'plex':
                 self.plex_container.show()
-                self.jellyfin_container.hide()
-            else:
-                self.plex_container.hide()
+            elif active_server == 'jellyfin':
                 self.jellyfin_container.show()
+            elif active_server == 'navidrome':
+                self.navidrome_container.show()
             
             # Load Soulseek config
             soulseek_config = config_manager.get_soulseek_config()
@@ -1178,7 +1307,12 @@ class SettingsPage(QWidget):
             # Save Jellyfin settings
             config_manager.set('jellyfin.base_url', self.jellyfin_url_input.text())
             config_manager.set('jellyfin.api_key', self.jellyfin_api_key_input.text())
-            
+
+            # Save Navidrome settings
+            config_manager.set('navidrome.base_url', self.navidrome_url_input.text())
+            config_manager.set('navidrome.username', self.navidrome_username_input.text())
+            config_manager.set('navidrome.password', self.navidrome_password_input.text())
+
             # Save pending server change if any
             if hasattr(self, 'pending_server_change') and self.pending_server_change:
                 config_manager.set_active_media_server(self.pending_server_change)
@@ -2260,9 +2394,16 @@ class SettingsPage(QWidget):
         self.jellyfin_toggle_button.setFixedHeight(40)
         self.jellyfin_toggle_button.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
         self.jellyfin_toggle_button.clicked.connect(lambda: self.select_media_server('jellyfin'))
-        
+
+        # Navidrome toggle button
+        self.navidrome_toggle_button = QPushButton()
+        self.navidrome_toggle_button.setFixedHeight(40)
+        self.navidrome_toggle_button.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        self.navidrome_toggle_button.clicked.connect(lambda: self.select_media_server('navidrome'))
+
         toggle_container.addWidget(self.plex_toggle_button)
         toggle_container.addWidget(self.jellyfin_toggle_button)
+        toggle_container.addWidget(self.navidrome_toggle_button)
         server_selection_layout.addLayout(toggle_container)
         
         # Restart warning (initially hidden)
@@ -2397,7 +2538,78 @@ class SettingsPage(QWidget):
         
         # Add Jellyfin frame to its container
         jellyfin_container_layout.addWidget(jellyfin_frame)
-        
+
+        # Navidrome Settings Container
+        self.navidrome_container = QWidget()
+        self.navidrome_container.setStyleSheet("background: transparent;")
+        navidrome_container_layout = QVBoxLayout(self.navidrome_container)
+        navidrome_container_layout.setContentsMargins(0, 0, 0, 0)
+        navidrome_container_layout.setSpacing(0)
+
+        # Navidrome settings
+        navidrome_frame = QFrame()
+        navidrome_frame.setStyleSheet("""
+            QFrame {
+                background: #333333;
+                border: 1px solid #444444;
+                border-radius: 8px;
+                padding: 8px;
+            }
+        """)
+        navidrome_layout = QVBoxLayout(navidrome_frame)
+        navidrome_layout.setSpacing(8)
+
+        navidrome_title = QLabel("Navidrome")
+        navidrome_title.setFont(QFont("Arial", 12, QFont.Weight.Bold))
+        navidrome_title.setStyleSheet("color: #ff6b6b;")  # Navidrome red color
+        navidrome_layout.addWidget(navidrome_title)
+
+        # Server URL
+        navidrome_url_label = QLabel("Server URL:")
+        navidrome_url_label.setStyleSheet(self.get_label_style(11))
+        navidrome_layout.addWidget(navidrome_url_label)
+
+        navidrome_url_input_layout = QHBoxLayout()
+        self.navidrome_url_input = QLineEdit()
+        self.navidrome_url_input.setStyleSheet(self.get_input_style())
+        self.navidrome_url_input.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        self.form_inputs['navidrome.base_url'] = self.navidrome_url_input
+
+        navidrome_detect_btn = QPushButton("Auto-detect")
+        navidrome_detect_btn.setFixedSize(80, 30)
+        navidrome_detect_btn.clicked.connect(self.auto_detect_navidrome)
+        navidrome_detect_btn.setStyleSheet(self.get_test_button_style())
+
+        navidrome_url_input_layout.addWidget(self.navidrome_url_input)
+        navidrome_url_input_layout.addWidget(navidrome_detect_btn)
+        navidrome_layout.addLayout(navidrome_url_input_layout)
+
+        # Username
+        navidrome_username_label = QLabel("Username:")
+        navidrome_username_label.setStyleSheet(self.get_label_style(11))
+        navidrome_layout.addWidget(navidrome_username_label)
+
+        self.navidrome_username_input = QLineEdit()
+        self.navidrome_username_input.setStyleSheet(self.get_input_style())
+        self.navidrome_username_input.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        self.form_inputs['navidrome.username'] = self.navidrome_username_input
+        navidrome_layout.addWidget(self.navidrome_username_input)
+
+        # Password
+        navidrome_password_label = QLabel("Password:")
+        navidrome_password_label.setStyleSheet(self.get_label_style(11))
+        navidrome_layout.addWidget(navidrome_password_label)
+
+        self.navidrome_password_input = QLineEdit()
+        self.navidrome_password_input.setEchoMode(QLineEdit.EchoMode.Password)
+        self.navidrome_password_input.setStyleSheet(self.get_input_style())
+        self.navidrome_password_input.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        self.form_inputs['navidrome.password'] = self.navidrome_password_input
+        navidrome_layout.addWidget(self.navidrome_password_input)
+
+        # Add Navidrome frame to its container
+        navidrome_container_layout.addWidget(navidrome_frame)
+
         # Soulseek settings
         soulseek_frame = QFrame()
         soulseek_frame.setStyleSheet("""
@@ -2454,6 +2666,7 @@ class SettingsPage(QWidget):
         api_layout.addWidget(server_selection_container)
         api_layout.addWidget(self.plex_container)
         api_layout.addWidget(self.jellyfin_container)
+        api_layout.addWidget(self.navidrome_container)
         api_layout.addWidget(soulseek_frame)
         
         # Test connections
@@ -2795,12 +3008,16 @@ class SettingsPage(QWidget):
             self.update_server_toggle_styles(server_type)
             
             # Show/hide appropriate containers
+            self.plex_container.hide()
+            self.jellyfin_container.hide()
+            self.navidrome_container.hide()
+
             if server_type == 'plex':
                 self.plex_container.show()
-                self.jellyfin_container.hide()
-            else:
-                self.plex_container.hide()
+            elif server_type == 'jellyfin':
                 self.jellyfin_container.show()
+            elif server_type == 'navidrome':
+                self.navidrome_container.show()
                 
         except Exception as e:
             logger.error(f"Error selecting media server: {e}")
@@ -2870,9 +3087,21 @@ class SettingsPage(QWidget):
                 "jellyfin_icon.png",
                 32
             )
-        
+
+        if not hasattr(self, '_cached_navidrome_icon'):
+            self._cached_navidrome_icon = download_and_cache_logo(
+                "https://raw.githubusercontent.com/navidrome/navidrome/master/resources/logo-192x192.png",
+                "navidrome_icon.png",
+                32
+            )
+            # Fallback to a simple text-based icon if download fails
+            if self._cached_navidrome_icon.isNull():
+                logger.warning("Navidrome icon download failed, creating fallback icon")
+                self._cached_navidrome_icon = self._create_fallback_icon("N", "#ff6b6b")
+
         plex_icon = self._cached_plex_icon
         jellyfin_icon = self._cached_jellyfin_icon
+        navidrome_icon = self._cached_navidrome_icon
         
         # Active button styles with appropriate colors
         active_plex_style = """
@@ -2904,6 +3133,21 @@ class SettingsPage(QWidget):
                     stop:1 rgba(150, 82, 175, 1.0));
             }
         """
+
+        active_navidrome_style = """
+            QPushButton {
+                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
+                    stop:0 rgba(255, 107, 107, 0.8),
+                    stop:1 rgba(235, 87, 87, 0.9));
+                border: 2px solid rgba(255, 107, 107, 1);
+                border-radius: 8px;
+            }
+            QPushButton:hover {
+                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
+                    stop:0 rgba(255, 107, 107, 0.9),
+                    stop:1 rgba(235, 87, 87, 1.0));
+            }
+        """
         
         # Inactive button style
         inactive_style = """
@@ -2918,19 +3162,64 @@ class SettingsPage(QWidget):
             }
         """
         
-        # Set icons and styles
+        # Set icons, text, and styles
         self.plex_toggle_button.setIcon(plex_icon)
         self.plex_toggle_button.setIconSize(QSize(28, 28))
+        self.plex_toggle_button.setText("Plex")
+
         self.jellyfin_toggle_button.setIcon(jellyfin_icon)
         self.jellyfin_toggle_button.setIconSize(QSize(28, 28))
-        
+        self.jellyfin_toggle_button.setText("Jellyfin")
+
+        self.navidrome_toggle_button.setIcon(navidrome_icon)
+        self.navidrome_toggle_button.setIconSize(QSize(28, 28))
+        self.navidrome_toggle_button.setText("Navidrome")
+
+        # Debug: Check if icons are properly loaded
+        if navidrome_icon.isNull():
+            logger.warning("Navidrome icon failed to load!")
+        else:
+            logger.info("Navidrome icon loaded successfully")
+
+        # Reset all buttons to inactive first
+        self.plex_toggle_button.setStyleSheet(inactive_style)
+        self.jellyfin_toggle_button.setStyleSheet(inactive_style)
+        self.navidrome_toggle_button.setStyleSheet(inactive_style)
+
+        # Set the active server button style
         if active_server == 'plex':
             self.plex_toggle_button.setStyleSheet(active_plex_style)
-            self.jellyfin_toggle_button.setStyleSheet(inactive_style)
-        else:
-            self.plex_toggle_button.setStyleSheet(inactive_style)
+        elif active_server == 'jellyfin':
             self.jellyfin_toggle_button.setStyleSheet(active_jellyfin_style)
-    
+        elif active_server == 'navidrome':
+            self.navidrome_toggle_button.setStyleSheet(active_navidrome_style)
+
+    def _create_fallback_icon(self, text, color):
+        """Create a simple text-based fallback icon"""
+        from PyQt6.QtGui import QPixmap, QPainter, QFont, QColor
+        from PyQt6.QtCore import Qt
+
+        # Create a 32x32 pixmap
+        pixmap = QPixmap(32, 32)
+        pixmap.fill(Qt.GlobalColor.transparent)
+
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        # Draw background circle
+        painter.setBrush(QColor(color))
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.drawEllipse(2, 2, 28, 28)
+
+        # Draw text
+        painter.setPen(QColor("white"))
+        font = QFont("Arial", 14, QFont.Weight.Bold)
+        painter.setFont(font)
+        painter.drawText(0, 0, 32, 32, Qt.AlignmentFlag.AlignCenter, text)
+
+        painter.end()
+        return QIcon(pixmap)
+
     def auto_detect_jellyfin(self):
         """Auto-detect Jellyfin server URL using background thread"""
         # Don't start new detection if one is already running
@@ -3034,7 +3323,102 @@ class SettingsPage(QWidget):
         self.detection_thread.start()
         
         self.detection_dialog.show()
-    
+
+    def auto_detect_navidrome(self):
+        """Auto-detect Navidrome server URL using background thread"""
+        # Don't start new detection if one is already running
+        if self.detection_thread and self.detection_thread.isRunning():
+            return
+
+        # Create animated loading dialog
+        from PyQt6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton
+        from PyQt6.QtCore import QTimer, QPropertyAnimation, QRect
+        from PyQt6.QtGui import QPainter, QColor
+
+        self.detection_dialog = QDialog(self)
+        self.detection_dialog.setWindowTitle("Auto-detecting Navidrome Server")
+        self.detection_dialog.setModal(True)
+        self.detection_dialog.setFixedSize(400, 180)
+        self.detection_dialog.setWindowFlags(self.detection_dialog.windowFlags() & ~Qt.WindowType.WindowContextHelpButtonHint)
+
+        # Apply dark theme styling
+        self.detection_dialog.setStyleSheet("""
+            QDialog {
+                background-color: #282828;
+                color: #ffffff;
+                border: 1px solid #404040;
+                border-radius: 8px;
+            }
+            QLabel {
+                color: #ffffff;
+                font-size: 14px;
+            }
+            QPushButton {
+                background-color: #404040;
+                border: 1px solid #606060;
+                border-radius: 4px;
+                color: #ffffff;
+                padding: 8px 16px;
+                font-size: 11px;
+            }
+            QPushButton:hover {
+                background-color: #505050;
+            }
+        """)
+
+        layout = QVBoxLayout(self.detection_dialog)
+        layout.setSpacing(20)
+
+        # Status text
+        status_label = QLabel("Scanning network for Navidrome servers...")
+        status_label.setWordWrap(True)
+        layout.addWidget(status_label)
+
+        # Cancel button
+        button_layout = QHBoxLayout()
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.cancel_detection)
+        button_layout.addStretch()
+        button_layout.addWidget(cancel_btn)
+        layout.addLayout(button_layout)
+
+        # Start Navidrome detection thread
+        self.detection_thread = NavidromeDetectionThread()
+        self.detection_thread.progress_updated.connect(self.on_detection_progress, Qt.ConnectionType.QueuedConnection)
+        self.detection_thread.detection_completed.connect(self.on_navidrome_detection_completed, Qt.ConnectionType.QueuedConnection)
+        self.detection_thread.start()
+
+        self.detection_dialog.show()
+
+    def on_navidrome_detection_completed(self, found_url):
+        """Handle Navidrome detection completion"""
+        # Stop animation and close dialog
+        if hasattr(self, 'loading_animation'):
+            self.loading_animation.stop()
+
+        if hasattr(self, 'detection_dialog') and self.detection_dialog:
+            self.detection_dialog.close()
+            self.detection_dialog = None
+
+        # Properly cleanup thread
+        if self.detection_thread:
+            if self.detection_thread.isRunning():
+                self.detection_thread.quit()
+                self.detection_thread.wait(1000)  # Wait up to 1 second
+            self.detection_thread = None
+
+        if found_url:
+            self.navidrome_url_input.setText(found_url)
+            # Show success toast
+            from ui.components.toast_manager import ToastManager
+            toast_manager = ToastManager(self)
+            toast_manager.show_toast(f"✓ Navidrome server detected: {found_url}", "success", 4000)
+        else:
+            # Show error toast
+            from ui.components.toast_manager import ToastManager
+            toast_manager = ToastManager(self)
+            toast_manager.show_toast("❌ No Navidrome servers found on the network", "error", 4000)
+
     def on_jellyfin_detection_completed(self, found_url):
         """Handle Jellyfin detection completion"""
         # Stop animation and close dialog
diff --git a/ui/pages/sync.py b/ui/pages/sync.py
index 8e3ce64..c54e49e 100644
--- a/ui/pages/sync.py
+++ b/ui/pages/sync.py
@@ -1709,7 +1709,8 @@ class PlaylistDetailsModal(QDialog):
                 self.parent_page.spotify_client,
                 self.parent_page.plex_client,
                 self.parent_page.soulseek_client,
-                getattr(self.parent_page, 'jellyfin_client', None)
+                getattr(self.parent_page, 'jellyfin_client', None),
+                getattr(self.parent_page, 'navidrome_client', None)
             )
         
         # Start sync
@@ -1839,7 +1840,15 @@ class PlaylistDetailsModal(QDialog):
     
     def on_analysis_started(self, total_tracks):
         """Handle analysis started signal"""
-        print(f"Started analyzing {total_tracks} tracks against Plex library")
+        # Get server name for log message
+        try:
+            from config.settings import config_manager
+            active_server = config_manager.get_active_media_server()
+            server_name = active_server.title() if active_server else "Plex"
+        except:
+            server_name = "Plex"
+
+        print(f"Started analyzing {total_tracks} tracks against {server_name} library")
     
     def on_track_analyzed(self, track_index, result):
         """Handle individual track analysis completion"""
@@ -1858,12 +1867,20 @@ class PlaylistDetailsModal(QDialog):
         
         if not missing_tracks:
             QMessageBox.information(self, "Analysis Complete", 
-                                  "All tracks already exist in Plex library!\nNo downloads needed.")
+                                  f"All tracks already exist in {server_name} library!\nNo downloads needed.")
             return
         
         # Show results to user
         message = f"Analysis complete!\n\n"
-        message += f"Tracks already in Plex: {len(existing_tracks)}\n"
+        # Get server name for display
+        try:
+            from config.settings import config_manager
+            active_server = config_manager.get_active_media_server()
+            server_name = active_server.title() if active_server else "Plex"
+        except:
+            server_name = "Plex"
+
+        message += f"Tracks already in {server_name}: {len(existing_tracks)}\n"
         message += f"Tracks to download: {len(missing_tracks)}\n\n"
         message += "Ready to start downloading missing tracks?"
         
@@ -3086,11 +3103,12 @@ class SyncPage(QWidget):
     sync_activity = pyqtSignal(str, str, str, str)  # icon, title, subtitle, time
     database_updated_externally = pyqtSignal()
     
-    def __init__(self, spotify_client=None, plex_client=None, soulseek_client=None, downloads_page=None, jellyfin_client=None, tidal_client=None, parent=None):
+    def __init__(self, spotify_client=None, plex_client=None, soulseek_client=None, downloads_page=None, jellyfin_client=None, navidrome_client=None, tidal_client=None, parent=None):
         super().__init__(parent)
         self.spotify_client = spotify_client
         self.plex_client = plex_client
         self.jellyfin_client = jellyfin_client
+        self.navidrome_client = navidrome_client
         self.soulseek_client = soulseek_client
         self.tidal_client = tidal_client or TidalClient()
         self.downloads_page = downloads_page
@@ -3293,7 +3311,7 @@ class SyncPage(QWidget):
         if playlist.id in self.active_sync_workers:
             # Already syncing
             return False
-        
+
         # Create sync service if not available
         if not hasattr(self, 'sync_service'):
             from services.sync_service import PlaylistSyncService
@@ -3301,7 +3319,8 @@ class SyncPage(QWidget):
                 self.spotify_client,
                 self.plex_client,
                 self.soulseek_client,
-                getattr(self, 'jellyfin_client', None)
+                getattr(self, 'jellyfin_client', None),
+                getattr(self, 'navidrome_client', None)
             )
         
         # Create sync worker
@@ -3355,7 +3374,8 @@ class SyncPage(QWidget):
                 self.spotify_client,
                 self.plex_client,
                 self.soulseek_client,
-                getattr(self, 'jellyfin_client', None)
+                getattr(self, 'jellyfin_client', None),
+                getattr(self, 'navidrome_client', None)
             )
         
         # Create sync worker for sequential sync
@@ -4059,7 +4079,15 @@ class SyncPage(QWidget):
         title_label.setStyleSheet("color: #ffffff;")
         
         # Subtitle
-        subtitle_label = QLabel("Synchronize your Spotify playlists with Plex")
+        # Get active server name for subtitle
+        try:
+            from config.settings import config_manager
+            active_server = config_manager.get_active_media_server()
+            server_name = active_server.title() if active_server else "Plex"
+        except:
+            server_name = "Plex"
+
+        subtitle_label = QLabel(f"Synchronize your Spotify playlists with {server_name}")
         subtitle_label.setFont(QFont("Arial", 14))
         subtitle_label.setStyleSheet("color: #b3b3b3;")
         
@@ -8100,7 +8128,15 @@ class DownloadMissingTracksModal(QDialog):
             # The modal now stays open.
             # The process_finished signal is still emitted to unlock the main UI.
             self.process_finished.emit() 
-            QMessageBox.information(self, "Analysis Complete", "All tracks already exist in Plex! No downloads needed.")
+            # Get server name for message
+            try:
+                from config.settings import config_manager
+                active_server = config_manager.get_active_media_server()
+                server_name = active_server.title() if active_server else "Plex"
+            except:
+                server_name = "Plex"
+
+            QMessageBox.information(self, "Analysis Complete", f"All tracks already exist in {server_name}! No downloads needed.")
             
     def on_analysis_failed(self, error_message):
         print(f"❌ Analysis failed: {error_message}")
diff --git a/ui/sidebar.py b/ui/sidebar.py
index be384e2..a9f2154 100644
--- a/ui/sidebar.py
+++ b/ui/sidebar.py
@@ -1308,7 +1308,12 @@ class ModernSidebar(QWidget):
         # Dynamic media server status - determine which server is active
         from config.settings import config_manager
         active_server = config_manager.get_active_media_server()
-        server_name = "Plex" if active_server == "plex" else "Jellyfin"
+        server_name_map = {
+            'plex': 'Plex',
+            'jellyfin': 'Jellyfin',
+            'navidrome': 'Navidrome'
+        }
+        server_name = server_name_map.get(active_server, 'Jellyfin')
         self.media_server_status = StatusIndicator(server_name)
         
         self.soulseek_status = StatusIndicator("Soulseek")
@@ -1333,6 +1338,7 @@ class ModernSidebar(QWidget):
             "spotify": self.spotify_status,
             "plex": self.media_server_status,
             "jellyfin": self.media_server_status,
+            "navidrome": self.media_server_status,
             "soulseek": self.soulseek_status
         }
         
@@ -1341,7 +1347,12 @@ class ModernSidebar(QWidget):
     
     def update_media_server_name(self, server_type: str):
         """Update the media server status indicator name"""
-        server_name = "Plex" if server_type == "plex" else "Jellyfin"
+        server_name_map = {
+            'plex': 'Plex',
+            'jellyfin': 'Jellyfin',
+            'navidrome': 'Navidrome'
+        }
+        server_name = server_name_map.get(server_type, 'Jellyfin')
         if hasattr(self, 'media_server_status'):
             self.media_server_status.update_name(server_name)
     
diff --git a/webui/static/script.js b/webui/static/script.js
index 15d9afa..e84bc3e 100644
--- a/webui/static/script.js
+++ b/webui/static/script.js
@@ -6967,8 +6967,8 @@ async function loadDashboardData() {
         metadataButton.addEventListener('click', handleMetadataUpdateButtonClick);
     }
     
-    // Check active media server and hide metadata updater if Jellyfin
-    await checkAndHideMetadataUpdaterForJellyfin();
+    // Check active media server and hide metadata updater if not Plex
+    await checkAndHideMetadataUpdaterForNonPlex();
     
     // Check for ongoing metadata update and restore state
     await checkAndRestoreMetadataUpdateState();
@@ -12968,24 +12968,24 @@ function updateMetadataProgressUI(status) {
 }
 
 /**
- * Check active media server and hide metadata updater if Jellyfin
+ * Check active media server and hide metadata updater if not Plex
  */
-async function checkAndHideMetadataUpdaterForJellyfin() {
+async function checkAndHideMetadataUpdaterForNonPlex() {
     try {
         const response = await fetch('/api/active-media-server');
         const data = await response.json();
-        
+
         if (data.success) {
             const metadataCard = document.getElementById('metadata-updater-card');
             if (metadataCard) {
-                if (data.active_server === 'jellyfin') {
-                    // Hide metadata updater for Jellyfin (same as dashboard.py behavior)
-                    metadataCard.style.display = 'none';
-                    console.log('Metadata updater hidden: Jellyfin is active server');
-                } else {
-                    // Show metadata updater for Plex
+                if (data.active_server === 'plex') {
+                    // Show metadata updater only for Plex
                     metadataCard.style.display = 'block';
                     console.log('Metadata updater shown: Plex is active server');
+                } else {
+                    // Hide metadata updater for Jellyfin and Navidrome (same as dashboard.py behavior)
+                    metadataCard.style.display = 'none';
+                    console.log(`Metadata updater hidden: ${data.active_server} is active server`);
                 }
             }
         }