Unbundle covers: fetch psppt-covers.zip from repo on demand with user prompt

app/gui.py

@@ -1143,6 +1143,7 @@ class ScrapeDialog(QDialog):
 
 class SettingsPage(QWidget):
     saved = Signal()
+    download_covers = Signal()
 
     def __init__(self, games_dir, videos_dir, store_dir, ppsspp_dir, cloud_dir, ppsspp_exe,
                  store_server_url, store_token, store_archive_id, store_archive_sig, store_archive_user,
@@ -1310,6 +1311,9 @@ class SettingsPage(QWidget):
         self.clear_covers_btn = QPushButton("Clear cover cache (re-fetch all covers)")
         self.clear_covers_btn.clicked.connect(self._clear_cover_cache)
         form.addRow(self.clear_covers_btn)
+        self.download_bundle_btn = QPushButton("Download offline cover bundle…")
+        self.download_bundle_btn.clicked.connect(self.download_covers.emit)
+        form.addRow(self.download_bundle_btn)
         col.addWidget(box)
 
         # -- Storage ---------------------------------------------------------- #
@@ -3757,6 +3761,35 @@ class LibraryWorker(QObject):
         self.finished.emit()
 
 
+class CoversBundleWorker(QObject):
+    """Download + extract the offline cover bundle off the GUI thread."""
+    progress = Signal(int, int)   # done bytes, total bytes (0 = unknown)
+    succeeded = Signal()
+    failed = Signal(str)
+    finished = Signal()
+
+    def __init__(self):
+        super().__init__()
+        self._cancel = threading.Event()
+
+    def cancel(self):
+        self._cancel.set()
+
+    def run(self):
+        try:
+            covers.download_covers_bundle(
+                progress_cb=lambda d, t: self.progress.emit(d, t),
+                cancel_event=self._cancel)
+        except InterruptedError:
+            pass
+        except Exception as exc:  # noqa: BLE001
+            self.failed.emit(str(exc))
+        else:
+            self.succeeded.emit()
+        finally:
+            self.finished.emit()
+
+
 class SaveSyncPlanWorker(QObject):
     """Compute the save-sync plan off the GUI thread (content hashing is I/O-heavy)."""
     plan = Signal(list, bool)  # plan, switch_to_queue
@@ -4615,6 +4648,7 @@ class MainWindow(QMainWindow):
                                           self._ps1_dir, self._ps1_output_dir, self._ps1_base_pbp,
                                           self._nps_dir)
         self.settings_page.saved.connect(self._on_settings_saved)
+        self.settings_page.download_covers.connect(self._download_covers_bundle)
         return self.settings_page
 
     def _on_settings_saved(self):
@@ -5687,6 +5721,79 @@ class MainWindow(QMainWindow):
         QMessageBox.information(self, "Done", f"Renamed {renamed} file(s).")
         self.load_library()
 
+    def maybe_offer_covers_bundle(self):
+        """Offer to download the offline cover bundle once, if it's missing."""
+        if self._closing or covers.covers_bundle_present():
+            return
+        s = QSettings("psppt", "psppt")
+        if str(s.value("covers_bundle_skip", "false")).lower() == "true":
+            return
+        box = QMessageBox(self)
+        box.setWindowTitle("Offline covers")
+        box.setIcon(QMessageBox.Question)
+        box.setText(
+            "The offline cover bundle (~843 MB) isn't installed.\n\n"
+            "Download it now from the project repo? Covers keep working online "
+            "without it — the bundle just makes them instant and offline."
+        )
+        download = box.addButton("Download", QMessageBox.AcceptRole)
+        box.addButton("Not now", QMessageBox.RejectRole)
+        never = box.addButton("Don't ask again", QMessageBox.DestructiveRole)
+        box.setDefaultButton(download)
+        box.exec()
+        clicked = box.clickedButton()
+        if clicked is never:
+            s.setValue("covers_bundle_skip", "true")
+        elif clicked is download:
+            self._download_covers_bundle()
+
+    def _download_covers_bundle(self):
+        """Download + extract the offline cover bundle with a progress dialog."""
+        if self._closing or getattr(self, "_bundle_worker", None) is not None:
+            return
+        prog = QProgressDialog("Downloading cover bundle…", "Cancel", 0, 0, self)
+        prog.setWindowTitle("Offline covers")
+        prog.setWindowModality(Qt.WindowModal)
+        prog.setMinimumDuration(0)
+        prog.setAutoClose(False)
+        prog.setAutoReset(False)
+
+        result = {"ok": False, "err": ""}
+        thread = QThread(self)
+        worker = CoversBundleWorker()
+        worker.moveToThread(thread)
+        thread.started.connect(worker.run)
+        worker.progress.connect(lambda d, t: self._on_bundle_progress(prog, d, t))
+        worker.succeeded.connect(lambda: result.update(ok=True))
+        worker.failed.connect(lambda e: result.update(err=str(e)))
+        prog.canceled.connect(worker.cancel)
+        worker.finished.connect(thread.quit)
+        thread.finished.connect(lambda: self._on_bundle_done(prog, result, worker, thread))
+        self._bundle_worker = worker
+        self._bundle_thread = thread
+        thread.start()
+
+    @staticmethod
+    def _on_bundle_progress(prog, done, total):
+        if total > 0:
+            prog.setRange(0, total)
+            prog.setValue(done)
+            prog.setLabelText(
+                f"Downloading cover bundle… {done / (1 << 20):.0f} / {total / (1 << 20):.0f} MB")
+        else:
+            prog.setRange(0, 0)
+
+    def _on_bundle_done(self, prog, result, worker, thread):
+        prog.close()
+        self._bundle_worker = None
+        self._bundle_thread = None
+        if result["ok"]:
+            QMessageBox.information(self, "Offline covers", "Cover bundle installed.")
+            covers.clear_miss_cache()
+            self.load_library()
+        elif result["err"]:
+            QMessageBox.warning(self, "Offline covers", f"Download failed:\n{result['err']}")
+
     def closeEvent(self, event):
         self._closing = True
         self.settings.setValue("window_geometry", self.saveGeometry())
@@ -5695,6 +5802,11 @@ class MainWindow(QMainWindow):
                 self.worker.choose(None)
             self.worker.cancel()
         self._thread_cleanup()
+        if getattr(self, "_bundle_worker", None) is not None:
+            self._bundle_worker.cancel()
+            if getattr(self, "_bundle_thread", None) is not None and _thread_running(self._bundle_thread):
+                self._bundle_thread.quit()
+                self._bundle_thread.wait()
         self.cover_grid.shutdown()
         for t in self._meta_threads:
             if _thread_running(t):
@@ -5717,15 +5829,6 @@ class MainWindow(QMainWindow):
         event.accept()
 
 
-def _start_bundle_check(window):
-    """Download any missing offline cover bundles in the background."""
-    server = getattr(window, "_store_server_url", "") or ""
-    try:
-        covers.ensure_cover_bundles(server)
-    except Exception:  # noqa: BLE001 - background best-effort
-        pass
-
-
 def main():
     logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)-7s %(name)-14s %(message)s")
     init_db()  # migrate legacy on-share DB/covers to local storage, then schema
@@ -5746,7 +5849,7 @@ def main():
     window.setWindowIcon(app.windowIcon())
     window.show()
     log.info("main window ready")
-    threading.Thread(target=_start_bundle_check, args=(window,), daemon=True).start()
+    QTimer.singleShot(1200, window.maybe_offer_covers_bundle)
 
     # Ctrl+C should close the window gracefully (running closeEvent's thread
     # cleanup) rather than tearing Qt down mid-thread, which segfaults.