Implement sidebar navigation and model management features. Refactor App component to utilize a Sidebar for tab navigation, integrating ProfileList, GenerationForm, HistoryTable, and ServerStatus components. Introduce ModelManagement and ModelProgress components for handling AI model downloads and status updates. Enhance CSS for sidebar styling and add progress tracking functionality in the backend for model downloads.

backend/utils/hf_progress.py

@@ -0,0 +1,93 @@
+"""
+HuggingFace Hub download progress tracking.
+"""
+
+from typing import Optional, Callable
+from contextlib import contextmanager
+import threading
+
+
+class HFProgressTracker:
+    """Tracks HuggingFace Hub download progress by intercepting hf_hub_download."""
+    
+    def __init__(self, progress_callback: Optional[Callable] = None):
+        self.progress_callback = progress_callback
+        self._original_hf_hub_download = None
+        self._lock = threading.Lock()
+        self._total_downloaded = 0
+        self._total_size = 0
+    
+    def _tracked_hf_hub_download(self, *args, **kwargs):
+        """Wrapper for hf_hub_download with progress tracking."""
+        import huggingface_hub
+        
+        # Get original callback if present
+        original_resume_callback = kwargs.get("resume_download", None)
+        
+        def combined_callback(downloaded: int, total: int):
+            """Combined callback that tracks progress."""
+            # Update totals
+            with self._lock:
+                # Estimate: assume each file contributes equally
+                # This is a simplification - in reality we'd track per-file
+                if total > 0:
+                    self._total_size = max(self._total_size, total)
+                    self._total_downloaded = downloaded
+            
+            # Call original callback if present
+            if original_resume_callback:
+                original_resume_callback(downloaded, total)
+            
+            # Call our progress callback
+            if self.progress_callback:
+                with self._lock:
+                    self.progress_callback(self._total_downloaded, self._total_size)
+        
+        # Replace callback
+        kwargs["resume_download"] = combined_callback
+        
+        # Call original download
+        return self._original_hf_hub_download(*args, **kwargs)
+    
+    @contextmanager
+    def patch_download(self):
+        """Context manager to patch hf_hub_download for progress tracking."""
+        try:
+            import huggingface_hub
+            self._original_hf_hub_download = huggingface_hub.hf_hub_download
+            
+            # Reset totals
+            with self._lock:
+                self._total_downloaded = 0
+                self._total_size = 0
+            
+            # Patch the function
+            huggingface_hub.hf_hub_download = self._tracked_hf_hub_download
+            
+            yield
+        except ImportError:
+            # If huggingface_hub not available, just yield without patching
+            yield
+        finally:
+            # Restore original
+            if self._original_hf_hub_download:
+                try:
+                    import huggingface_hub
+                    huggingface_hub.hf_hub_download = self._original_hf_hub_download
+                except ImportError:
+                    pass
+
+
+def create_hf_progress_callback(model_name: str, progress_manager):
+    """Create a progress callback for HuggingFace downloads."""
+    def callback(downloaded: int, total: int):
+        """Progress callback."""
+        if total > 0:
+            progress_manager.update_progress(
+                model_name=model_name,
+                current=downloaded,
+                total=total,
+                filename="",
+                status="downloading",
+            )
+    return callback

backend/utils/progress.py

@@ -0,0 +1,164 @@
+"""
+Progress tracking for model downloads using Server-Sent Events.
+"""
+
+from typing import Optional, Callable, Dict
+from fastapi.responses import StreamingResponse
+import asyncio
+import json
+from datetime import datetime
+
+
+class ProgressManager:
+    """Manages download progress for multiple models."""
+    
+    def __init__(self):
+        self._progress: Dict[str, Dict] = {}
+        self._listeners: Dict[str, list] = {}
+    
+    def update_progress(
+        self,
+        model_name: str,
+        current: int,
+        total: int,
+        filename: Optional[str] = None,
+        status: str = "downloading",
+    ):
+        """
+        Update progress for a model download.
+        
+        Args:
+            model_name: Name of the model (e.g., "qwen-tts-1.7B", "whisper-base")
+            current: Current bytes downloaded
+            total: Total bytes to download
+            filename: Current file being downloaded
+            status: Status string (downloading, extracting, complete, error)
+        """
+        progress_pct = (current / total * 100) if total > 0 else 0
+        
+        self._progress[model_name] = {
+            "model_name": model_name,
+            "current": current,
+            "total": total,
+            "progress": progress_pct,
+            "filename": filename,
+            "status": status,
+            "timestamp": datetime.now().isoformat(),
+        }
+        
+        # Notify all listeners
+        if model_name in self._listeners:
+            for queue in self._listeners[model_name]:
+                try:
+                    queue.put_nowait(self._progress[model_name].copy())
+                except asyncio.QueueFull:
+                    pass
+    
+    def get_progress(self, model_name: str) -> Optional[Dict]:
+        """Get current progress for a model."""
+        return self._progress.get(model_name)
+    
+    def create_progress_callback(self, model_name: str, filename: Optional[str] = None):
+        """
+        Create a progress callback function for HuggingFace downloads.
+        
+        Args:
+            model_name: Name of the model
+            filename: Optional filename filter
+            
+        Returns:
+            Callback function
+        """
+        def callback(progress: Dict):
+            """HuggingFace Hub progress callback."""
+            if "total" in progress and "current" in progress:
+                current = progress.get("current", 0)
+                total = progress.get("total", 0)
+                file_name = progress.get("filename", filename)
+                
+                self.update_progress(
+                    model_name=model_name,
+                    current=current,
+                    total=total,
+                    filename=file_name,
+                    status="downloading",
+                )
+        
+        return callback
+    
+    async def subscribe(self, model_name: str):
+        """
+        Subscribe to progress updates for a model.
+        
+        Yields progress updates as Server-Sent Events.
+        """
+        queue = asyncio.Queue(maxsize=10)
+        
+        # Add to listeners
+        if model_name not in self._listeners:
+            self._listeners[model_name] = []
+        self._listeners[model_name].append(queue)
+        
+        try:
+            # Send initial progress if available
+            if model_name in self._progress:
+                yield f"data: {json.dumps(self._progress[model_name])}\n\n"
+            
+            # Stream updates
+            while True:
+                try:
+                    # Wait for update with timeout
+                    progress = await asyncio.wait_for(queue.get(), timeout=1.0)
+                    yield f"data: {json.dumps(progress)}\n\n"
+                    
+                    # Stop if complete or error
+                    if progress.get("status") in ("complete", "error"):
+                        break
+                except asyncio.TimeoutError:
+                    # Send heartbeat
+                    yield ": heartbeat\n\n"
+                    continue
+        finally:
+            # Remove from listeners
+            if model_name in self._listeners:
+                self._listeners[model_name].remove(queue)
+                if not self._listeners[model_name]:
+                    del self._listeners[model_name]
+    
+    def mark_complete(self, model_name: str):
+        """Mark a model download as complete."""
+        if model_name in self._progress:
+            self._progress[model_name]["status"] = "complete"
+            self._progress[model_name]["progress"] = 100.0
+            # Notify listeners
+            if model_name in self._listeners:
+                for queue in self._listeners[model_name]:
+                    try:
+                        queue.put_nowait(self._progress[model_name].copy())
+                    except asyncio.QueueFull:
+                        pass
+    
+    def mark_error(self, model_name: str, error: str):
+        """Mark a model download as failed."""
+        if model_name in self._progress:
+            self._progress[model_name]["status"] = "error"
+            self._progress[model_name]["error"] = error
+            # Notify listeners
+            if model_name in self._listeners:
+                for queue in self._listeners[model_name]:
+                    try:
+                        queue.put_nowait(self._progress[model_name].copy())
+                    except asyncio.QueueFull:
+                        pass
+
+
+# Global progress manager instance
+_progress_manager: Optional[ProgressManager] = None
+
+
+def get_progress_manager() -> ProgressManager:
+    """Get or create the global progress manager."""
+    global _progress_manager
+    if _progress_manager is None:
+        _progress_manager = ProgressManager()
+    return _progress_manager