feat: add modrinth search, version selection, and GUI enhancements

Author: devsker

README.md

@@ -25,7 +25,11 @@ python server_pack_builder.py --source /path/to/mods --destination /path/to/serv
 Download and filter a Modrinth modpack directly from a URL or slug:
 
 ```bash
+# Download latest version
 python server_pack_builder.py --modrinth-url https://modrinth.com/modpack/fabric-boosted
+
+# Download specific version
+python server_pack_builder.py --modrinth-url fabric-boosted --pack-version "1.2.3"
 ```
 
 ### GUI Mode
@@ -47,12 +51,15 @@ python server_pack_builder.py --gui
 
 #### Modrinth Mode
 - `--modrinth-url`, `-m`: Modrinth Modpack URL or Slug.
+- `--pack-version`: Specific version ID or Number to download (overrides latest).
 - `--output-file`, `-o`: Output path for the generated `.mrpack` (optional, defaults to `{PackName}-server.mrpack`).
 
 ## Features
 
 - **Client-Side Filtering**: Automatically detects and removes client-only mods by inspecting JAR metadata.
 - **Modrinth Integration**: Downloads, filters, and repacks `.mrpack` files.
+- **Modrinth Search**: Search for modpacks and view their details/logos within the GUI.
+- **Version Selection**: Choose between the latest release or specific versions of a modpack.
 - **Multi-Loader Support**: Works with Fabric and Forge mod loaders.
 - **Overrides Preservation**: Keeps configuration and other data from the modpack's `overrides` folder.
 
@@ -64,4 +71,3 @@ For linting and testing:
 python -m black . && python -m isort . && python -m flake8 . && python -m mypy .
 python -m pytest
 ```
-

gui.py

@@ -1,9 +1,10 @@
 import logging
 import sys
 import os
+import requests
 from typing import Optional
 
-from PyQt6.QtCore import QObject, QThread, pyqtSignal, Qt
+from PyQt6.QtCore import QObject, QThread, pyqtSignal, Qt, QSize
 from PyQt6.QtWidgets import (
     QApplication,
     QMainWindow,
@@ -21,8 +22,12 @@
     QGroupBox,
     QStatusBar,
     QMessageBox,
+    QDialog,
+    QListWidget,
+    QListWidgetItem,
+    QComboBox,
 )
-from PyQt6.QtGui import QFont, QIcon, QPalette, QColor
+from PyQt6.QtGui import QFont, QIcon, QPalette, QColor, QImage, QPixmap
 
 import server_pack_builder
 
@@ -41,6 +46,182 @@ def emit(self, record):
 
 # --- Worker Thread ---
 
+class SearchWorker(QThread):
+    results_found = pyqtSignal(list)
+    error_occurred = pyqtSignal(str)
+
+    def __init__(self, query: str):
+        super().__init__()
+        self.query = query
+
+    def run(self):
+        try:
+            results = server_pack_builder.search_modrinth_modpacks(self.query)
+            self.results_found.emit(results)
+        except Exception as e:
+            self.error_occurred.emit(str(e))
+
+class VersionsWorker(QThread):
+    versions_found = pyqtSignal(list)
+    
+    def __init__(self, slug: str):
+        super().__init__()
+        self.slug = slug
+
+    def run(self):
+        try:
+            versions = server_pack_builder.get_modrinth_versions(self.slug)
+            self.versions_found.emit(versions)
+        except Exception:
+            self.versions_found.emit([])
+
+class ImageLoader(QThread):
+    image_loaded = pyqtSignal(str, QImage)  # url, image
+
+    def __init__(self, url: str):
+        super().__init__()
+        self.url = url
+
+    def run(self):
+        try:
+            # Use a session or simple get
+            response = requests.get(self.url, timeout=5)
+            if response.status_code == 200:
+                image = QImage()
+                image.loadFromData(response.content)
+                self.image_loaded.emit(self.url, image)
+        except Exception:
+            pass  # Fail silently for icons
+
+class ModrinthSearchDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Search Modrinth Modpacks")
+        self.resize(700, 500)
+        self.selected_slug = None
+        self.image_threads = {}  # Keep references to prevent GC
+
+        # UI Setup
+        layout = QVBoxLayout(self)
+
+        # Search Bar
+        search_layout = QHBoxLayout()
+        self.search_input = QLineEdit()
+        self.search_input.setPlaceholderText("Search for modpacks (e.g., 'Better MC')...")
+        self.search_input.returnPressed.connect(self.do_search)
+        
+        self.btn_search = QPushButton("Search")
+        self.btn_search.clicked.connect(self.do_search)
+        
+        search_layout.addWidget(self.search_input)
+        search_layout.addWidget(self.btn_search)
+        layout.addLayout(search_layout)
+
+        # Results List
+        self.list_widget = QListWidget()
+        self.list_widget.setIconSize(QSize(64, 64))
+        self.list_widget.itemDoubleClicked.connect(self.accept_selection)
+        layout.addWidget(self.list_widget)
+
+        # Buttons
+        btn_layout = QHBoxLayout()
+        self.btn_select = QPushButton("Select")
+        self.btn_select.clicked.connect(self.accept_selection)
+        self.btn_cancel = QPushButton("Cancel")
+        self.btn_cancel.clicked.connect(self.reject)
+        
+        btn_layout.addStretch()
+        btn_layout.addWidget(self.btn_select)
+        btn_layout.addWidget(self.btn_cancel)
+        layout.addLayout(btn_layout)
+
+        self.worker = None
+
+    def do_search(self):
+        query = self.search_input.text().strip()
+        if not query:
+            return
+
+        self.list_widget.clear()
+        self.btn_search.setEnabled(False)
+        self.list_widget.addItem("Searching...")
+        
+        # Cancel previous worker if any
+        if self.worker and self.worker.isRunning():
+            self.worker.terminate()
+            self.worker.wait()
+
+        self.worker = SearchWorker(query)
+        self.worker.results_found.connect(self.populate_results)
+        self.worker.error_occurred.connect(self.handle_error)
+        self.worker.finished.connect(lambda: self.btn_search.setEnabled(True))
+        self.worker.start()
+
+    def handle_error(self, error_msg):
+        self.list_widget.clear()
+        self.list_widget.addItem(f"Error: {error_msg}")
+
+    def populate_results(self, hits):
+        self.list_widget.clear()
+        if not hits:
+            self.list_widget.addItem("No results found.")
+            return
+
+        for hit in hits:
+            title = hit.get("title", "Unknown")
+            author = hit.get("author", "Unknown")
+            slug = hit.get("slug", "")
+            desc = hit.get("description", "")
+            icon_url = hit.get("icon_url", "")
+
+            # Format text
+            item_text = f"{title} ({author})\n{desc}"
+            item = QListWidgetItem(item_text)
+            item.setData(Qt.ItemDataRole.UserRole, slug)
+            item.setToolTip(f"Slug: {slug}\n{desc}")
+            
+            # Placeholder icon
+            placeholder = QPixmap(64, 64)
+            placeholder.fill(QColor("gray"))
+            item.setIcon(QIcon(placeholder))
+
+            self.list_widget.addItem(item)
+            
+            # Load icon if available
+            if icon_url:
+                loader = ImageLoader(icon_url)
+                # Use a closure or default arg to capture 'item' correctly?
+                # Actually, ImageLoader emits url, we can map url back to item, 
+                # OR we can pass item to ImageLoader (but QThread shouldn't touch UI directly).
+                # Safer: connect signal to a slot that updates the item.
+                # Since we loop, we need to know WHICH item to update.
+                # I'll just store the item in a map keyed by URL? No, multiple packs might share icon? Unlikely.
+                # Better: Make a custom slot or lambda.
+                
+                # We need to be careful with lambdas in loops.
+                loader.image_loaded.connect(lambda u, i, it=item: self.update_icon(it, i))
+                
+                # Keep reference
+                self.image_threads[icon_url] = loader
+                loader.finished.connect(lambda u=icon_url: self.cleanup_thread(u))
+                loader.start()
+
+    def update_icon(self, item, image):
+        if not image.isNull():
+            item.setIcon(QIcon(QPixmap.fromImage(image)))
+
+    def cleanup_thread(self, url):
+        if url in self.image_threads:
+            del self.image_threads[url]
+
+    def accept_selection(self):
+        item = self.list_widget.currentItem()
+        if item:
+            slug = item.data(Qt.ItemDataRole.UserRole)
+            if slug:
+                self.selected_slug = slug
+                self.accept()
+
 class WorkerThread(QThread):
     """Runs the long-running CLI tasks in a background thread."""
 
@@ -80,6 +261,7 @@ def run(self):
                     modrinth_url=self.kwargs["url"],
                     output_file=self.kwargs["output"],
                     dry_run=self.kwargs["dry_run"],
+                    pack_version_id=self.kwargs.get("version_id"),
                     progress_callback=self.update_progress,
                     download_callback=self.update_download
                 )
@@ -165,10 +347,24 @@ def init_ui(self):
         url_layout = QHBoxLayout()
         self.edit_url = QLineEdit()
         self.edit_url.setPlaceholderText("Modrinth URL or Slug (e.g., 'my-pack')")
+        self.edit_url.editingFinished.connect(self.fetch_versions)
+        self.btn_search_modrinth = QPushButton("Search...")
+        self.btn_search_modrinth.clicked.connect(self.open_search_dialog)
+        
         url_layout.addWidget(QLabel("URL/Slug:"))
         url_layout.addWidget(self.edit_url)
+        url_layout.addWidget(self.btn_search_modrinth)
         mod_layout.addLayout(url_layout)
 
+        # Version Selection
+        version_layout = QHBoxLayout()
+        self.combo_version = QComboBox()
+        self.combo_version.addItem("Latest", None)
+        self.combo_version.setEnabled(False)
+        version_layout.addWidget(QLabel("Version:"))
+        version_layout.addWidget(self.combo_version)
+        mod_layout.addLayout(version_layout)
+
         # Output File
         out_layout = QHBoxLayout()
         self.edit_output = QLineEdit()
@@ -213,7 +409,7 @@ def init_ui(self):
 
         # Progress Section
         progress_layout = QVBoxLayout()
-        self.lbl_progress = QLabel("Ready")
+        self.lbl_progress = QLabel("")
         self.progress_bar = QProgressBar()
         self.progress_bar.setTextVisible(True)
         self.progress_bar.setFormat("%p%") # Show percentage
@@ -371,8 +567,10 @@ def start_process(self):
                 QMessageBox.warning(self, "Invalid Input", "Please enter a Modrinth URL or Slug.")
                 return
 
+            version_id = self.combo_version.currentData()
+            
             mode = "modrinth"
-            kwargs = {"url": url, "output": output, "dry_run": dry_run}
+            kwargs = {"url": url, "output": output, "dry_run": dry_run, "version_id": version_id}
 
         # Start Thread
         self.text_logs.clear()
@@ -412,10 +610,63 @@ def cancel_process(self):
                 self.progress_bar.setValue(0)
                 self.progress_bar.setRange(0, 100)
                 self.progress_bar.setFormat("%p%")
-                self.lbl_progress.setText("Ready")
+                self.lbl_progress.setText("")
 
                 self.process_finished(False, "Process cancelled.")
 
+    def open_search_dialog(self):
+        dialog = ModrinthSearchDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            if dialog.selected_slug:
+                self.edit_url.setText(dialog.selected_slug)
+                self.fetch_versions()
+
+    def fetch_versions(self):
+        slug_or_url = self.edit_url.text().strip()
+        if not slug_or_url:
+            return
+
+        # Simple check if it looks like a slug/url
+        if "modrinth.com" in slug_or_url:
+             # Extract slug from URL if possible, otherwise let backend handle it?
+             # get_modrinth_project_version is in backend.
+             # We can't easily call it here without importing or duplicating.
+             # We can just try to search versions for the slug/ID extracted.
+             # For now, let's just pass the text. If it's a URL, the backend might fail to find versions 
+             # unless we extract the slug first.
+             pass
+
+        # Use backend helper to extract slug if needed?
+        slug, _ = server_pack_builder.get_modrinth_project_version(slug_or_url)
+        
+        self.combo_version.clear()
+        self.combo_version.addItem("Loading...", None)
+        self.combo_version.setEnabled(False)
+        
+        # We need a worker for this so GUI doesn't freeze
+        self.version_worker = VersionsWorker(slug)
+        self.version_worker.versions_found.connect(self.populate_versions)
+        self.version_worker.start()
+
+    def populate_versions(self, versions):
+        self.combo_version.clear()
+        self.combo_version.addItem("Latest", None)
+        
+        if versions:
+            for v in versions:
+                name = v.get("name", "Unknown")
+                vid = v.get("id")
+                game_versions = v.get("game_versions", [])
+                loaders = v.get("loaders", [])
+                
+                display = f"{name} ({', '.join(game_versions)}) - {', '.join(loaders)}"
+                self.combo_version.addItem(display, vid)
+            
+            self.combo_version.setEnabled(True)
+        else:
+             self.combo_version.addItem("No versions found or invalid slug", None)
+             self.combo_version.setEnabled(True) # Allow user to still try "Latest" if they think it's right
+
 def run_gui():
     app = QApplication(sys.argv)
     window = MainWindow()