Sync from development - prepare for v0.2.2

CHANGELOG.md

@@ -1,5 +1,21 @@
 # Jackify Changelog
 
+## v0.2.2 - VNV Automation and First-Launch Improvements
+**Release Date:** 2026-01-21
+
+### Major Features
+- **Viva New Vegas Post-Install Automation (experimental)**: Full automated workflow for the Viva New Vegas modlist. Handles root files copying, 4GB patcher, and BSA decompression as per the VNV install guide. This is an initial pass at automating this, so considered experimental.
+- **Game Directory Pre-Creation**: Automatically creates My Documents/My Games and AppData/Local directories for some. Prevents some first-launch failures where games can't initialize under Proton. Supports Skyrim SE, FNV, FO4, Oblivion, Oblivion Remastered, Enderal, and Starfield so far.
+
+### Bug Fixes
+- **Configure Existing Modlist**: Fixed AttributeError when VNV automation check runs after configuration completes
+- **Enderal Directory Creation**: Fixed bug where Enderal My Documents directory was created for all modlists instead of only Enderal
+
+### Improvements
+- **Winetricks Bundling**: Implemented Wine wrapper scripts that replicate protontricks' environment setup for improved reliability
+
+---
+
 ## v0.2.1.1 - Bug Fixes and Improvements
 **Release Date:** 2026-01-15
 

jackify/__init__.py

@@ -5,4 +5,4 @@ This package provides both CLI and GUI interfaces for managing
 Wabbajack modlists natively on Linux systems.
 """
 
-__version__ = "0.2.1.1"
+__version__ = "0.2.2"

jackify/backend/handlers/logging_handler.py

@@ -81,7 +81,7 @@ class LoggingHandler:
         if log_file or is_general:
             file_path = self.log_dir / (log_file if log_file else "jackify-cli.log")
             file_handler = logging.handlers.RotatingFileHandler(
-                file_path, mode='a', encoding='utf-8', maxBytes=1024*1024, backupCount=5
+                file_path, mode='a', encoding='utf-8', maxBytes=100*1024*1024, backupCount=5
             )
             file_handler.setLevel(logging.DEBUG)
             file_handler.setFormatter(file_formatter)
@@ -90,7 +90,7 @@ class LoggingHandler:
             
         return logger
         
-    def rotate_logs(self, max_bytes: int = 1024 * 1024, backup_count: int = 5) -> None:
+    def rotate_logs(self, max_bytes: int = 100 * 1024 * 1024, backup_count: int = 5) -> None:
         """Rotate log files based on size."""
         for log_file in self.get_log_files():
             try:

jackify/backend/handlers/menu_handler.py

@@ -667,6 +667,35 @@ class ModlistMenuHandler:
             self.logger.warning(f"ENB configuration skipped due to error: {e}")
             # Continue workflow - ENB config is optional
 
+        # Run modlist-specific post-install automation (e.g., VNV) before showing completion
+        # Only in CLI mode - GUI handles this in install_modlist.py
+        if not gui_mode:
+            from jackify.backend.services.vnv_integration_helper import run_vnv_automation_if_applicable
+            from jackify.backend.services.automated_prefix_service import AutomatedPrefixService
+            from pathlib import Path
+
+            modlist_name = context.get('name', '')
+            modlist_path = Path(context.get('path', ''))
+
+            try:
+                print("")
+                print("Running VNV post-install automation...")
+                automation_ran, error = run_vnv_automation_if_applicable(
+                    modlist_name=modlist_name,
+                    modlist_install_location=modlist_path,
+                    game_root=None,  # Will be auto-detected
+                    ttw_installer_path=AutomatedPrefixService.get_ttw_installer_path(),
+                    progress_callback=lambda msg: print(msg),
+                    manual_file_callback=None,  # CLI doesn't support manual file callback yet
+                    confirmation_callback=None  # Will use default confirmation in CLI
+                )
+                if error:
+                    print(f"{COLOR_WARNING}VNV automation encountered an error: {error}{COLOR_RESET}")
+                    print("You can complete these steps manually by following: https://vivanewvegas.moddinglinked.com/wabbajack.html")
+            except Exception as e:
+                self.logger.debug(f"VNV automation check skipped: {e}")
+                # Not an error - just means VNV automation wasn't applicable
+
         print("")
         print("")
         print("")  # Extra blank line before completion

jackify/backend/handlers/winetricks_handler.py

@@ -353,7 +353,7 @@ class WinetricksHandler:
                 for cmd in commands:
                     bundled_tool = self._get_bundled_tool(cmd, fallback_to_system=False)
                     if bundled_tool:
-                        dep_msg = f"  ✓ {dep_name}: {bundled_tool} (bundled)"
+                        dep_msg = f"  {dep_name}: {bundled_tool} (bundled)"
                         self.logger.info(dep_msg)
                         if status_callback:
                             status_callback(dep_msg)
@@ -367,7 +367,7 @@ class WinetricksHandler:
                         result = subprocess.run(['which', cmd], capture_output=True, timeout=2)
                         if result.returncode == 0:
                             cmd_path = result.stdout.decode().strip()
-                            dep_msg = f"  ✓ {dep_name}: {cmd_path} (system)"
+                            dep_msg = f"  {dep_name}: {cmd_path} (system)"
                             self.logger.info(dep_msg)
                             if status_callback:
                                 status_callback(dep_msg)
@@ -379,9 +379,9 @@ class WinetricksHandler:
             if not found:
                 missing_deps.append(dep_name)
                 if dep_name in bundled_tools_list:
-                    self.logger.warning(f"  ✗ {dep_name}: NOT FOUND (neither bundled nor system)")
+                    self.logger.warning(f"  {dep_name}: NOT FOUND (neither bundled nor system)")
                 else:
-                    self.logger.warning(f"  ✗ {dep_name}: NOT FOUND (system only - not bundled)")
+                    self.logger.warning(f"  {dep_name}: NOT FOUND (system only - not bundled)")
         
         if missing_deps:
             # Separate critical vs optional dependencies

jackify/backend/services/automated_prefix_service.py

@@ -1785,6 +1785,18 @@ echo Prefix creation complete.
             logger.error(f"Error setting Proton on shortcut: {e}")
             return False
 
+    @staticmethod
+    def get_ttw_installer_path() -> Optional[Path]:
+        """Get path to TTW_Linux_Installer if available"""
+        try:
+            from jackify.shared.paths import get_jackify_data_dir
+            ttw_path = get_jackify_data_dir() / "TTW_Linux_Installer" / "ttw_linux_gui"
+            if ttw_path.exists():
+                return ttw_path
+        except Exception:
+            pass
+        return None
+
     def run_working_workflow(self, shortcut_name: str, modlist_install_dir: str,
                             final_exe_path: str, progress_callback=None, steamdeck: Optional[bool] = None) -> Tuple[bool, Optional[Path], Optional[int], Optional[str]]:
         """
@@ -1800,6 +1812,8 @@ echo Prefix creation complete.
             shortcut_name: Name for the Steam shortcut
             modlist_install_dir: Directory where the modlist is installed
             final_exe_path: Path to ModOrganizer.exe
+            progress_callback: Optional callback for progress updates
+            steamdeck: Optional Steam Deck detection override
 
         Returns:
             Tuple of (success, prefix_path, appid, last_timestamp)
@@ -1922,7 +1936,7 @@ echo Prefix creation complete.
                     progress_callback(f"{self._get_progress_timestamp()} Injecting {special_game_type.upper()} game registry entries...")
 
                 if prefix_path:
-                    self._inject_game_registry_entries(str(prefix_path))
+                    self._inject_game_registry_entries(str(prefix_path), special_game_type)
                 else:
                     logger.warning("Could not find prefix path for registry injection")
             else:
@@ -1930,6 +1944,16 @@ echo Prefix creation complete.
                 if progress_callback:
                     progress_callback(f"{self._get_progress_timestamp()} No special game registry injection needed")
 
+            # Step 5.5: Pre-create game-specific directories for all modlists
+            logger.info(f"Step 5.5: Creating game-specific user directories")
+            if progress_callback:
+                progress_callback(f"{self._get_progress_timestamp()} Creating game user directories...")
+
+            if prefix_path:
+                self._create_game_user_directories(str(prefix_path), special_game_type)
+            else:
+                logger.warning("Could not find prefix path for directory creation")
+            
             last_timestamp = self._get_progress_timestamp()
             logger.info(f" Working workflow completed successfully! AppID: {appid}, Prefix: {prefix_path}")
             if progress_callback:
@@ -3250,7 +3274,7 @@ echo Prefix creation complete.
             logger.debug(f"Error during recursive wine search in {proton_path}: {e}")
             return None
 
-    def _inject_game_registry_entries(self, modlist_compatdata_path: str):
+    def _inject_game_registry_entries(self, modlist_compatdata_path: str, special_game_type: str):
         """Detect and inject FNV/Enderal game paths and apply universal dotnet4.x compatibility fixes"""
         system_reg_path = os.path.join(modlist_compatdata_path, "pfx", "system.reg")
         if not os.path.exists(system_reg_path):
@@ -3290,15 +3314,6 @@ echo Prefix creation complete.
                 )
                 if success:
                     logger.info(f"Updated registry entry for {config['name']}")
-
-                    # Special handling for Enderal: Create required user directory
-                    if app_id == "976620":  # Enderal Special Edition
-                        try:
-                            enderal_docs_path = os.path.join(modlist_compatdata_path, "pfx", "drive_c", "users", "steamuser", "Documents", "My Games", "Enderal Special Edition")
-                            os.makedirs(enderal_docs_path, exist_ok=True)
-                            logger.info(f"Created Enderal user directory: {enderal_docs_path}")
-                        except Exception as e:
-                            logger.warning(f"Failed to create Enderal user directory: {e}")
                 else:
                     logger.warning(f"Failed to update registry entry for {config['name']}")
             else:
@@ -3306,6 +3321,49 @@ echo Prefix creation complete.
                 
         logger.info("Game registry injection completed")
 
+    def _create_game_user_directories(self, modlist_compatdata_path: str, special_game_type: str):
+        """
+        Pre-create game-specific user directories to prevent first-launch issues.
+
+        Creates both My Documents/My Games and AppData/Local directories for the game.
+        This prevents issues where games fail to create these on first launch under Proton.
+        """
+        # Map game types to their directory names
+        game_dir_names = {
+            "skyrim": "Skyrim Special Edition",
+            "fnv": "FalloutNV",
+            "fo4": "Fallout4",
+            "oblivion": "Oblivion",
+            "oblivion_remastered": "Oblivion Remastered",
+            "enderal": "Enderal Special Edition",
+            "starfield": "Starfield"
+        }
+
+        # Get the directory name for this game type
+        game_dir_name = game_dir_names.get(special_game_type)
+        if not game_dir_name:
+            logger.debug(f"No user directory mapping for game type: {special_game_type}")
+            return
+
+        base_path = os.path.join(modlist_compatdata_path, "pfx", "drive_c", "users", "steamuser")
+
+        directories_to_create = [
+            os.path.join(base_path, "Documents", "My Games", game_dir_name),
+            os.path.join(base_path, "AppData", "Local", game_dir_name)
+        ]
+
+        created_count = 0
+        for directory in directories_to_create:
+            try:
+                os.makedirs(directory, exist_ok=True)
+                logger.info(f"Created user directory: {directory}")
+                created_count += 1
+            except Exception as e:
+                logger.warning(f"Failed to create directory {directory}: {e}")
+
+        if created_count > 0:
+            logger.info(f"Created {created_count} user directories for {game_dir_name}")
+
     def _get_lorerim_preferred_proton(self):
         """Get Lorerim's preferred Proton 9 version with specific priority order"""
         try:

jackify/backend/services/nexus_download_service.py

@@ -0,0 +1,220 @@
+"""
+Nexus Download Service
+
+Handles downloading mod files from Nexus Mods using OAuth authentication.
+"""
+
+import logging
+import requests
+import time
+from pathlib import Path
+from typing import Optional, Callable, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class NexusDownloadService:
+    """Service for downloading files from Nexus Mods"""
+
+    NEXUS_API_BASE = "https://api.nexusmods.com/v1"
+
+    def __init__(self, auth_token: str):
+        """
+        Initialize Nexus download service.
+
+        Args:
+            auth_token: OAuth access token or API key
+        """
+        self.auth_token = auth_token
+        self.headers = {
+            "Authorization": f"Bearer {auth_token}",
+            "User-Agent": "jackify"
+        }
+
+    def get_mod_files(self, game_domain: str, mod_id: int) -> Optional[list]:
+        """
+        Get list of files for a mod.
+
+        Args:
+            game_domain: Game domain (e.g., 'newvegas')
+            mod_id: Mod ID number
+
+        Returns:
+            List of file metadata dicts, or None if failed
+        """
+        try:
+            url = f"{self.NEXUS_API_BASE}/games/{game_domain}/mods/{mod_id}/files.json"
+
+            response = requests.get(url, headers=self.headers, timeout=30)
+            response.raise_for_status()
+
+            data = response.json()
+            files = data.get('files', [])
+
+            logger.info(f"Found {len(files)} files for mod {mod_id}")
+            return files
+
+        except Exception as e:
+            logger.error(f"Failed to get mod files: {e}")
+            return None
+
+    def get_download_link(self, game_domain: str, mod_id: int, file_id: int) -> Optional[str]:
+        """
+        Get download link for a specific file.
+
+        Args:
+            game_domain: Game domain (e.g., 'newvegas')
+            mod_id: Mod ID number
+            file_id: File ID number
+
+        Returns:
+            Download URL, or None if failed
+        """
+        try:
+            url = f"{self.NEXUS_API_BASE}/games/{game_domain}/mods/{mod_id}/files/{file_id}/download_link.json"
+
+            response = requests.get(url, headers=self.headers, timeout=30)
+
+            # Check for specific error codes
+            if response.status_code == 403:
+                logger.error(f"Download link request forbidden (403) - Nexus Premium required for file {file_id}")
+                return None
+            elif response.status_code == 404:
+                logger.error(f"Download link request not found (404) - file {file_id} may not exist")
+                return None
+
+            response.raise_for_status()
+
+            data = response.json()
+
+            # API returns list of download servers
+            if isinstance(data, list) and len(data) > 0:
+                download_url = data[0].get('URI')
+                logger.info(f"Got download link for file {file_id}")
+                return download_url
+            else:
+                logger.error(f"No download link returned for file {file_id}")
+                return None
+
+        except requests.exceptions.HTTPError as e:
+            logger.error(f"Failed to get download link: HTTP {e.response.status_code} - {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Failed to get download link: {e}")
+            return None
+
+    def download_file(
+        self,
+        download_url: str,
+        output_path: Path,
+        progress_callback: Optional[Callable[[int, int], None]] = None
+    ) -> bool:
+        """
+        Download a file from Nexus.
+
+        Args:
+            download_url: Download URL from get_download_link()
+            output_path: Where to save the file
+            progress_callback: Optional callback(downloaded_bytes, total_bytes)
+
+        Returns:
+            True if successful
+        """
+        try:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            response = requests.get(download_url, stream=True, timeout=60)
+            response.raise_for_status()
+
+            total_size = int(response.headers.get('content-length', 0))
+            downloaded = 0
+
+            with open(output_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+
+                        if progress_callback and total_size > 0:
+                            progress_callback(downloaded, total_size)
+
+            logger.info(f"Downloaded {output_path.name} ({downloaded} bytes)")
+            return True
+
+        except Exception as e:
+            logger.error(f"Download failed: {e}")
+            if output_path.exists():
+                output_path.unlink()
+            return False
+
+    def download_latest_file(
+        self,
+        game_domain: str,
+        mod_id: int,
+        output_dir: Path,
+        file_name_filter: Optional[str] = None,
+        progress_callback: Optional[Callable[[str], None]] = None
+    ) -> Tuple[bool, Optional[Path], str]:
+        """
+        Download the latest file from a mod.
+
+        Args:
+            game_domain: Game domain (e.g., 'newvegas')
+            mod_id: Mod ID number
+            output_dir: Directory to save file
+            file_name_filter: Optional substring to filter files (e.g., 'linux', 'mpi')
+            progress_callback: Optional callback for status updates
+
+        Returns:
+            Tuple of (success, file_path, message)
+        """
+        def update_progress(msg: str):
+            if progress_callback:
+                progress_callback(msg)
+            logger.info(msg)
+
+        try:
+            update_progress(f"Fetching file list for mod {mod_id}...")
+
+            files = self.get_mod_files(game_domain, mod_id)
+            if not files:
+                return False, None, "Failed to get mod file list"
+
+            # Filter files if requested
+            if file_name_filter:
+                filtered = [f for f in files if file_name_filter.lower() in f.get('file_name', '').lower()]
+                if not filtered:
+                    return False, None, f"No files found matching '{file_name_filter}'"
+                files = filtered
+
+            # Get the most recent file
+            files.sort(key=lambda f: f.get('uploaded_timestamp', 0), reverse=True)
+            latest_file = files[0]
+
+            file_id = latest_file['file_id']
+            file_name = latest_file['file_name']
+
+            update_progress(f"Downloading {file_name}...")
+
+            download_url = self.get_download_link(game_domain, mod_id, file_id)
+            if not download_url:
+                return False, None, "Failed to get download link"
+
+            output_path = output_dir / file_name
+
+            def download_progress(downloaded, total):
+                if total > 0:
+                    percent = (downloaded / total) * 100
+                    update_progress(f"Downloading: {percent:.1f}%")
+
+            success = self.download_file(download_url, output_path, download_progress)
+
+            if success:
+                return True, output_path, f"Downloaded {file_name}"
+            else:
+                return False, None, "Download failed"
+
+        except Exception as e:
+            error_msg = f"Download failed: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return False, None, error_msg

jackify/backend/services/vnv_integration_helper.py

@@ -0,0 +1,198 @@
+"""
+VNV Integration Helper
+
+Helper functions to integrate VNV post-install automation into modlist workflows.
+Handles detection, confirmation, and execution for:
+- Install Modlist
+- Configure New Modlist
+- Configure Existing Modlist
+"""
+
+import logging
+import configparser
+import re
+from pathlib import Path
+from typing import Optional, Callable, Tuple
+
+from .vnv_post_install_service import VNVPostInstallService
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_bytearray_value(value: str) -> str:
+    """
+    Parse Qt @ByteArray format to extract the actual string value.
+    
+    Format: @ByteArray(Viva New Vegas Extended)
+    Returns: Viva New Vegas Extended
+    """
+    match = re.match(r'@ByteArray\((.*)\)', value)
+    if match:
+        return match.group(1)
+    return value
+
+
+def _check_modorganizer_ini_profile(modlist_install_location: Path) -> bool:
+    """
+    Check ModOrganizer.ini for VNV profile names.
+    
+    Args:
+        modlist_install_location: Path to modlist installation directory
+        
+    Returns:
+        True if selected_profile is "Viva New Vegas" or "Viva New Vegas Extended"
+    """
+    try:
+        mo_ini_path = modlist_install_location / "ModOrganizer.ini"
+        if not mo_ini_path.exists():
+            logger.debug(f"ModOrganizer.ini not found at {mo_ini_path}")
+            return False
+
+        config = configparser.ConfigParser()
+        # Read with UTF-8-sig to handle BOM
+        config.read(mo_ini_path, encoding='utf-8-sig')
+        
+        if 'General' not in config:
+            logger.debug("No [General] section in ModOrganizer.ini")
+            return False
+        
+        selected_profile_raw = config.get('General', 'selected_profile', fallback='')
+        if not selected_profile_raw:
+            logger.debug("No selected_profile in ModOrganizer.ini")
+            return False
+        
+        # Parse @ByteArray format
+        selected_profile = _parse_bytearray_value(selected_profile_raw)
+        logger.debug(f"Found selected_profile: {selected_profile}")
+        
+        # Check if it's one of the VNV profiles
+        vnv_profiles = ["Viva New Vegas", "Viva New Vegas Extended"]
+        return selected_profile in vnv_profiles
+        
+    except Exception as e:
+        logger.debug(f"Error checking ModOrganizer.ini for VNV profile: {e}")
+        return False
+
+
+def should_offer_vnv_automation(modlist_name: str, modlist_install_location: Optional[Path] = None) -> bool:
+    """
+    Check if VNV automation should be offered for this modlist.
+    
+    Detection methods (in order of reliability):
+    1. Check ModOrganizer.ini selected_profile (most reliable)
+    2. Check modlist name for VNV patterns
+    
+    Args:
+        modlist_name: Name of the modlist
+        modlist_install_location: Optional path to modlist installation directory
+        
+    Returns:
+        True if VNV automation should be offered
+    """
+    # Method 1: Check ModOrganizer.ini profile (most reliable)
+    if modlist_install_location:
+        if _check_modorganizer_ini_profile(modlist_install_location):
+            logger.info(f"VNV detected via ModOrganizer.ini profile in {modlist_install_location}")
+            return True
+    
+    # Method 2: Check modlist name patterns
+    modlist_name_lower = modlist_name.lower()
+    vnv_patterns = [
+        "viva new vegas",
+        "vnv",  # Common abbreviation
+        "viva new vegas extended"
+    ]
+    
+    for pattern in vnv_patterns:
+        if pattern in modlist_name_lower:
+            logger.info(f"VNV detected via name pattern '{pattern}' in '{modlist_name}'")
+            return True
+    
+    return False
+
+
+def run_vnv_automation_if_applicable(
+    modlist_name: str,
+    modlist_install_location: Path,
+    game_root: Path,
+    ttw_installer_path: Optional[Path] = None,
+    progress_callback: Optional[Callable[[str], None]] = None,
+    manual_file_callback: Optional[Callable[[str, str], Optional[Path]]] = None,
+    confirmation_callback: Optional[Callable[[str], bool]] = None
+) -> Tuple[bool, Optional[str]]:
+    """
+    Check if VNV automation should run, get user confirmation, and execute if confirmed.
+
+    Args:
+        modlist_name: Name of the installed modlist
+        modlist_install_location: Path to modlist installation
+        game_root: Path to game root directory
+        ttw_installer_path: Optional path to TTW_Linux_Installer (for BSA decompression)
+        progress_callback: Optional callback for progress updates
+        manual_file_callback: Optional callback for manual file selection (non-Premium)
+        confirmation_callback: Optional callback for user confirmation
+                              Takes description string, returns True if user confirms
+
+    Returns:
+        Tuple of (automation_was_run: bool, error_message: Optional[str])
+    """
+    try:
+        # Check if this is VNV (pass install location for ModOrganizer.ini check)
+        if not should_offer_vnv_automation(modlist_name, modlist_install_location):
+            logger.debug(f"Modlist '{modlist_name}' does not require VNV automation")
+            return False, None
+
+        logger.info(f"VNV detected: {modlist_name}")
+
+        # Initialize service
+        vnv_service = VNVPostInstallService(
+            modlist_install_location=modlist_install_location,
+            game_root=game_root,
+            ttw_installer_path=ttw_installer_path
+        )
+
+        # Check what's already done
+        completed = vnv_service.check_already_completed()
+        # Only skip if ALL three steps are completed
+        if completed['root_mods'] and completed['4gb_patch'] and completed['bsa_decompressed']:
+            logger.info("VNV automation steps already completed")
+            if progress_callback:
+                progress_callback("VNV post-install steps already completed")
+            return False, None
+
+        # Get confirmation from user (required)
+        if not confirmation_callback:
+            logger.error("VNV automation requires confirmation_callback")
+            return False, "VNV automation requires user confirmation"
+        
+        if confirmation_callback:
+            description = vnv_service.get_automation_description()
+            if not confirmation_callback(description):
+                logger.info("User declined VNV automation")
+                if progress_callback:
+                    progress_callback("VNV automation skipped by user")
+                return False, None
+
+        # Run automation
+        logger.info("Starting VNV post-install automation")
+        if progress_callback:
+            progress_callback("Running VNV post-install automation...")
+
+        success, message = vnv_service.run_all_steps(
+            progress_callback=progress_callback,
+            manual_file_callback=manual_file_callback
+        )
+
+        if success:
+            logger.info(f"VNV automation completed: {message}")
+            if progress_callback:
+                progress_callback(f"VNV automation: {message}")
+            return True, None
+        else:
+            logger.error(f"VNV automation failed: {message}")
+            return True, message
+
+    except Exception as e:
+        error_msg = f"VNV automation error: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        return True, error_msg

jackify/backend/services/vnv_post_install_service.py

@@ -0,0 +1,622 @@
+"""
+Viva New Vegas Post-Install Service
+
+Automates the post-installation steps required for Viva New Vegas modlist:
+1. Root Mods - Copy files from '__Files Requiring Manual Install' to game root
+2. 4GB Patcher - Download Linux version from Nexus, run natively
+3. BSA Decompression - Download FNV BSA Decompressor MPI, run via TTW_Linux_Installer
+
+These steps are documented at: https://vivanewvegas.moddinglinked.com/wabbajack.html
+
+Uses native Linux tools (no Wine required) by downloading from Nexus with OAuth.
+"""
+
+import logging
+import os
+import shutil
+import subprocess
+import stat
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Optional, Callable
+
+from ..handlers.subprocess_utils import get_clean_subprocess_env
+from .nexus_download_service import NexusDownloadService
+from .nexus_auth_service import NexusAuthService
+
+logger = logging.getLogger(__name__)
+
+
+class VNVPostInstallService:
+    """Handles automated post-installation tasks for Viva New Vegas modlist."""
+
+    # Nexus mod IDs for required tools
+    LINUX_4GB_PATCHER_MOD_ID = 62552
+    FNV_BSA_DECOMPRESSOR_MOD_ID = 65854
+    GAME_DOMAIN = "newvegas"
+
+    def __init__(self, modlist_install_location: Path, game_root: Path,
+                 ttw_installer_path: Optional[Path] = None):
+        """
+        Initialize VNV post-install service.
+
+        Args:
+            modlist_install_location: Path to the VNV installation (e.g., ~/VNV)
+            game_root: Path to Fallout New Vegas game root
+            ttw_installer_path: Path to TTW_Linux_Installer executable (for BSA decompression)
+        """
+        self.modlist_install = modlist_install_location
+        self.game_root = game_root
+        self.ttw_installer_path = ttw_installer_path
+
+        # VNV-specific paths
+        self.manual_install_dir = self.modlist_install / "__Files Requiring Manual Install"
+
+        # Download cache directory
+        from jackify.shared.paths import get_jackify_data_dir
+        self.cache_dir = get_jackify_data_dir() / "vnv_post_install_cache"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        # Initialize authentication
+        self.auth_service = NexusAuthService()
+        self.download_service = None
+
+    def _ensure_auth(self, progress_callback: Optional[Callable[[str], None]] = None) -> bool:
+        """
+        Ensure we have valid Nexus authentication for downloads.
+
+        Args:
+            progress_callback: Optional callback for progress updates
+
+        Returns:
+            True if authenticated
+        """
+        auth_token = self.auth_service.ensure_valid_auth()
+
+        if not auth_token:
+            if progress_callback:
+                progress_callback("Nexus authentication required for post-install steps")
+            logger.error("No Nexus authentication available")
+            return False
+
+        self.download_service = NexusDownloadService(auth_token)
+        return True
+
+    def should_run_automation(self, modlist_name: str) -> bool:
+        """
+        Check if this modlist should trigger VNV automation.
+
+        Args:
+            modlist_name: Name of the installed modlist
+
+        Returns:
+            True if VNV automation should be offered
+        """
+        return "viva new vegas" in modlist_name.lower()
+
+    def get_automation_description(self) -> str:
+        """
+        Get user-friendly description of what VNV automation does.
+
+        Returns:
+            Description string for confirmation dialog
+        """
+        return (
+            "Viva New Vegas Automation\n\n"
+            "Jackify can automatically perform the following post-install steps:\n\n"
+            "1. Copy root mods to game directory\n"
+            "2. Download and run Linux 4GB patcher\n"
+            "3. Download and run BSA decompressor (reduces loading times)\n\n"
+            "Premium users: Downloads happen automatically\n"
+            "Non-Premium users: You'll be prompted to download files manually\n\n"
+            "Would you like Jackify to automate these steps?"
+        )
+
+    def check_already_completed(self) -> dict:
+        """
+        Check which VNV automation steps have already been completed.
+
+        Returns:
+            Dict with keys: 'root_mods', '4gb_patch', 'bsa_decompressed'
+        """
+        # Check if 4GB patch already applied
+        backup_exe = self.game_root / "FalloutNV_backup.exe"
+        already_patched = backup_exe.exists()
+
+        # Check if root mods copied (look for FNVpatch.exe in game root)
+        root_mods_copied = (self.game_root / "FNVpatch.exe").exists()
+
+        # Check for BSA decompression marker file
+        marker_file = self.game_root / ".jackify_bsa_decompressed"
+        bsa_decompressed = marker_file.exists()
+
+        return {
+            'root_mods': root_mods_copied,
+            '4gb_patch': already_patched,
+            'bsa_decompressed': bsa_decompressed
+        }
+
+    def run_all_steps(self, progress_callback: Optional[Callable[[str], None]] = None,
+                      manual_file_callback: Optional[Callable[[str, str], Optional[Path]]] = None,
+                      skip_confirmation: bool = False) -> tuple[bool, str]:
+        """
+        Run all VNV post-install steps in sequence.
+
+        Args:
+            progress_callback: Optional callback for progress updates
+            manual_file_callback: Optional callback for manual file selection (non-Premium users)
+                                 Takes (title, instructions) returns Path or None
+            skip_confirmation: Skip user confirmation (for programmatic use)
+
+        Returns:
+            (success: bool, message: str)
+        """
+        def update_progress(msg: str):
+            if progress_callback:
+                progress_callback(msg)
+            logger.info(msg)
+
+        try:
+            # Ensure authentication
+            update_progress("Checking Nexus authentication...")
+            if not self._ensure_auth(progress_callback):
+                return False, "Nexus authentication required. Please authenticate in Settings."
+
+            # Step 1: Copy root mods
+            update_progress("Step 1/3: Copying root mods to game directory...")
+            success, msg = self.copy_root_mods()
+            if not success:
+                return False, f"Root mods failed: {msg}"
+            update_progress(f"Root mods: {msg}")
+
+            # Step 2: Run 4GB patcher
+            update_progress("Step 2/3: Downloading and running 4GB patcher...")
+            success, msg = self.run_4gb_patcher(update_progress, manual_file_callback)
+            if not success:
+                return False, f"4GB patcher failed: {msg}"
+            update_progress(f"4GB patcher: {msg}")
+
+            # Step 3: Run BSA decompressor
+            update_progress("Step 3/3: Downloading and running BSA decompressor...")
+            success, msg = self.run_bsa_decompressor(update_progress, manual_file_callback)
+            if not success:
+                return False, f"BSA decompression failed: {msg}"
+            update_progress(f"BSA decompression: {msg}")
+
+            return True, "VNV post-install completed successfully"
+
+        except Exception as e:
+            error_msg = f"VNV post-install failed: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return False, error_msg
+
+    def copy_root_mods(self) -> tuple[bool, str]:
+        """
+        Copy files from '__Files Requiring Manual Install' to game root.
+
+        Returns:
+            (success: bool, message: str)
+        """
+        try:
+            if not self.manual_install_dir.exists():
+                return False, f"Manual install directory not found: {self.manual_install_dir}"
+
+            if not self.game_root.exists():
+                return False, f"Game root directory not found: {self.game_root}"
+
+            # Copy all files from manual install to game root
+            copied_files = []
+            for item in self.manual_install_dir.iterdir():
+                dest = self.game_root / item.name
+
+                if item.is_file():
+                    shutil.copy2(item, dest)
+                    copied_files.append(item.name)
+                    logger.debug(f"Copied: {item.name}")
+                elif item.is_dir():
+                    # Merge directories to preserve vanilla game files (e.g., BSA files in Data/)
+                    # dirs_exist_ok=True allows adding NVSE to Data/ without deleting vanilla BSAs
+                    shutil.copytree(item, dest, dirs_exist_ok=True)
+                    copied_files.append(f"{item.name}/")
+                    logger.debug(f"Copied directory: {item.name}/")
+
+            if not copied_files:
+                return False, "No files found to copy"
+
+            logger.info(f"Copied {len(copied_files)} items to game root")
+            return True, f"Copied {len(copied_files)} items to game root"
+
+        except Exception as e:
+            error_msg = f"Failed to copy root mods: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return False, error_msg
+
+    def run_4gb_patcher(self, progress_callback: Optional[Callable[[str], None]] = None,
+                       manual_file_callback: Optional[Callable[[str, str], Optional[Path]]] = None) -> tuple[bool, str]:
+        """
+        Download and run native Linux 4GB patcher.
+
+        Args:
+            progress_callback: Optional callback for progress updates
+            manual_file_callback: Optional callback for manual file selection
+                                 Takes (title, instructions) returns Path or None
+
+        Returns:
+            (success: bool, message: str)
+        """
+        try:
+            # Check if already patched
+            backup_exe = self.game_root / "FalloutNV_backup.exe"
+            if backup_exe.exists():
+                logger.info("Game already has 4GB patch (backup exists)")
+                return True, "Game already patched (backup exists)"
+
+            # Check cache first - look for extracted executable or zip
+            patcher_path = None
+            cached_extracted = list(self.cache_dir.glob("*4gb*_extracted/*"))
+            if cached_extracted:
+                # Use already extracted executable
+                for f in cached_extracted:
+                    if f.is_file():
+                        patcher_path = f
+                        logger.info(f"Using cached extracted 4GB patcher: {patcher_path}")
+                        break
+
+            if not patcher_path:
+                cached_files = list(self.cache_dir.glob("*4gb*.zip"))
+                if cached_files:
+                    patcher_path = cached_files[0]
+                    logger.info(f"Using cached 4GB patcher zip: {patcher_path}")
+
+            if not patcher_path:
+                # Try to download from Nexus
+                # Note: The Linux version is named "FNV4GB for Proton", not "linux"
+                success, patcher_path, msg = self.download_service.download_latest_file(
+                    self.GAME_DOMAIN,
+                    self.LINUX_4GB_PATCHER_MOD_ID,
+                    self.cache_dir,
+                    file_name_filter="proton",
+                    progress_callback=progress_callback
+                )
+
+                if not success:
+                    # Download failed - offer manual download
+                    logger.error(f"Automatic download failed: {msg}")
+                    logger.debug(f"Looking for file with 'proton' in name on mod {self.LINUX_4GB_PATCHER_MOD_ID}")
+
+                    if not manual_file_callback:
+                        return False, f"Failed to download 4GB patcher: {msg}\n\nPlease download manually from: https://www.nexusmods.com/newvegas/mods/62552"
+
+                    instructions = (
+                        "Automatic download failed (requires Nexus Premium).\n\n"
+                        "Please download the Linux 4GB Patcher manually:\n\n"
+                        "1. Visit: https://www.nexusmods.com/newvegas/mods/62552\n\n"
+                        "2. Download the file named 'FNV4GB for Linux'\n\n"
+                        "3. Select the downloaded file below"
+                    )
+
+                    patcher_path = manual_file_callback("4GB Patcher Required", instructions)
+
+                    if not patcher_path or not patcher_path.exists():
+                        return False, "4GB patcher file not provided"
+
+                    # Copy to cache for future use
+                    cached_path = self.cache_dir / patcher_path.name
+                    shutil.copy2(patcher_path, cached_path)
+                    patcher_path = cached_path
+                    logger.info(f"Using manually selected 4GB patcher: {patcher_path}")
+
+            # Extract if it's a zip file and not already extracted
+            if patcher_path.suffix.lower() == '.zip':
+                extract_dir = self.cache_dir / f"{patcher_path.stem}_extracted"
+
+                # Extract if not already done
+                if not extract_dir.exists():
+                    logger.info(f"Extracting {patcher_path.name}...")
+                    extract_dir.mkdir(parents=True, exist_ok=True)
+                    with zipfile.ZipFile(patcher_path, 'r') as zip_ref:
+                        zip_ref.extractall(extract_dir)
+                    logger.info(f"Extracted to {extract_dir}")
+
+                # Find the executable
+                executables = list(extract_dir.glob("*"))
+                if not executables:
+                    return False, "No files found in 4GB patcher zip"
+
+                # Look for executable file (FalloutNVPatcher or similar)
+                patcher_exe = None
+                for f in executables:
+                    if f.is_file() and ('fallout' in f.name.lower() or 'patcher' in f.name.lower() or 'fnv' in f.name.lower()):
+                        patcher_exe = f
+                        break
+
+                if not patcher_exe:
+                    # Use first file if no obvious match
+                    patcher_exe = next((f for f in executables if f.is_file()), None)
+
+                if not patcher_exe:
+                    return False, "No executable found in 4GB patcher zip"
+
+                patcher_path = patcher_exe
+                logger.info(f"Using patcher executable: {patcher_path.name}")
+
+            # Make executable
+            patcher_path.chmod(patcher_path.stat().st_mode | stat.S_IEXEC)
+
+            # Run patcher
+            if progress_callback:
+                progress_callback("Running 4GB patcher...")
+
+            result = subprocess.run(
+                [str(patcher_path)],
+                cwd=str(self.game_root),
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+
+            # Check if backup was created (indicates success)
+            if backup_exe.exists():
+                logger.info("4GB patch applied successfully")
+                return True, "4GB patch applied successfully"
+            else:
+                logger.warning(f"Patcher output: {result.stdout}")
+                if result.stderr:
+                    logger.warning(f"Patcher errors: {result.stderr}")
+                return False, "Patcher ran but FalloutNV_backup.exe not created"
+
+        except subprocess.TimeoutExpired:
+            return False, "4GB patcher timed out after 60 seconds"
+        except Exception as e:
+            error_msg = f"Failed to run 4GB patcher: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return False, error_msg
+
+    def run_bsa_decompressor(self, progress_callback: Optional[Callable[[str], None]] = None,
+                            manual_file_callback: Optional[Callable[[str, str], Optional[Path]]] = None) -> tuple[bool, str]:
+        """
+        Download FNV BSA Decompressor MPI and run via TTW_Linux_Installer.
+
+        Args:
+            progress_callback: Optional callback for progress updates
+            manual_file_callback: Optional callback for manual file selection
+                                 Takes (title, instructions) returns Path or None
+
+        Returns:
+            (success: bool, message: str)
+        """
+        try:
+            # Check if already completed
+            marker_file = self.game_root / ".jackify_bsa_decompressed"
+            if marker_file.exists():
+                logger.info("BSA decompression already completed (marker file exists)")
+                return True, "BSA decompression already completed"
+
+            if not self.ttw_installer_path or not self.ttw_installer_path.exists():
+                logger.warning("TTW_Linux_Installer not found, skipping BSA decompression")
+                return True, "BSA decompression skipped (TTW_Linux_Installer not available)"
+
+            # Check cache first
+            cached_files = list(self.cache_dir.glob("*BSA*.mpi"))
+            if cached_files:
+                mpi_path = cached_files[0]
+                logger.info(f"Using cached BSA Decompressor MPI: {mpi_path}")
+            else:
+                # Also check for exact filename match (handles spaces in filename)
+                exact_path = self.cache_dir / "FNV BSA Decompressor.mpi"
+                if exact_path.exists():
+                    mpi_path = exact_path
+                    logger.info(f"Using cached BSA Decompressor MPI: {mpi_path}")
+                else:
+                    # Try to download from Nexus
+                    success, mpi_path, msg = self.download_service.download_latest_file(
+                        self.GAME_DOMAIN,
+                        self.FNV_BSA_DECOMPRESSOR_MOD_ID,
+                        self.cache_dir,
+                        file_name_filter="mpi",
+                        progress_callback=progress_callback
+                    )
+
+                    if not success:
+                        # Download failed - offer manual download
+                        logger.warning(f"Automatic download failed: {msg}")
+
+                        if not manual_file_callback:
+                            return False, f"Failed to download BSA Decompressor MPI: {msg}\n\nPlease download manually from: https://www.nexusmods.com/newvegas/mods/65854"
+
+                        instructions = (
+                            "Automatic download failed (requires Nexus Premium).\n\n"
+                            "Please download the FNV BSA Decompressor manually:\n"
+                            "1. Visit: https://www.nexusmods.com/newvegas/mods/65854\n"
+                            "2. Download the .mpi file\n"
+                            "3. Select the downloaded file below"
+                        )
+
+                        mpi_path = manual_file_callback("BSA Decompressor Required", instructions)
+
+                        if not mpi_path or not mpi_path.exists():
+                            return False, "BSA Decompressor MPI file not provided"
+
+                        # Validate it's an MPI file
+                        if not mpi_path.suffix.lower() == '.mpi':
+                            return False, f"Selected file is not an MPI file: {mpi_path}"
+
+                        # Copy to cache for future use
+                        cached_path = self.cache_dir / mpi_path.name
+                        shutil.copy2(mpi_path, cached_path)
+                        mpi_path = cached_path
+                        logger.info(f"Using manually selected BSA Decompressor MPI: {mpi_path}")
+
+            # Create temp output directory
+            with tempfile.TemporaryDirectory() as temp_output:
+                temp_output_path = Path(temp_output)
+
+                # Create config file for TTW_Linux_Installer (handles spaces in paths better)
+                config_file = self.ttw_installer_path.parent / "ttw-config.json"
+                import json
+                config_data = {
+                    "FalloutNVRoot": str(self.game_root),
+                    "MpiPackagePath": str(mpi_path),
+                    "DestinationPath": str(temp_output_path)
+                }
+                with open(config_file, 'w') as f:
+                    json.dump(config_data, f, indent=2)
+                logger.debug(f"Created MPI config file: {config_file}")
+
+                # Run via TTW_Linux_Installer
+                if progress_callback:
+                    progress_callback("Running BSA decompressor...")
+
+                cmd = [
+                    str(self.ttw_installer_path),
+                    "--start"
+                ]
+
+                logger.info(f"Running BSA decompressor: {' '.join(cmd)}")
+                logger.debug(f"Using config file: {config_file}")
+                logger.debug(f"Config: {json.dumps(config_data, indent=2)}")
+
+                env = get_clean_subprocess_env()
+
+                # Stream output and parse progress
+                import re
+                process = subprocess.Popen(
+                    cmd,
+                    cwd=str(self.ttw_installer_path.parent),
+                    env=env,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    bufsize=1
+                )
+
+                # Pattern to match progress: "Assets processed: 12345/48649"
+                progress_pattern = re.compile(r'Assets processed: (\d+)/(\d+)')
+                last_progress = None
+
+                # Capture all output for diagnostics
+                all_output = []
+                already_modified_detected = False
+
+                # Stream output line by line
+                for line in process.stdout:
+                    line = line.rstrip()
+                    all_output.append(line)
+
+                    # Check for "already modified" messages
+                    if "already" in line.lower() and ("modified" in line.lower() or "decompressed" in line.lower()):
+                        already_modified_detected = True
+                        logger.info(f"BSA decompressor reports: {line}")
+
+                    # Check for progress updates
+                    match = progress_pattern.search(line)
+                    if match:
+                        current = int(match.group(1))
+                        total = int(match.group(2))
+                        percent = (current / total * 100) if total > 0 else 0
+                        progress_msg = f"Decompressing BSA files: {current}/{total} ({percent:.1f}%)"
+
+                        # Only send update if progress changed significantly
+                        if last_progress is None or current - last_progress >= total // 100:
+                            if progress_callback:
+                                progress_callback(progress_msg)
+                            # Log progress updates (not every single file)
+                            logger.debug(f"BSA decompression progress: {current}/{total} ({percent:.1f}%)")
+                            last_progress = current
+
+                # Wait for process to complete
+                return_code = process.wait(timeout=600)
+
+                # Log full output for debugging failures
+                if return_code != 0:
+                    logger.debug(f"BSA decompressor output:\n" + "\n".join(all_output[-50:]))  # Last 50 lines
+
+                # Clean up config file after execution
+                try:
+                    if config_file.exists():
+                        config_file.unlink()
+                        logger.debug(f"Cleaned up config file: {config_file}")
+                except Exception as e:
+                    logger.warning(f"Failed to clean up config file: {e}")
+
+                if return_code == 0:
+                    # Check if files were actually extracted to temp directory
+                    extracted_files = list(temp_output_path.rglob("*"))
+                    if extracted_files:
+                        logger.info(f"BSA decompression extracted {len(extracted_files)} files")
+                        
+                        # Copy extracted files back to game Data directory
+                        data_dir = self.game_root / "Data"
+                        copied_count = 0
+                        for extracted_file in extracted_files:
+                            if extracted_file.is_file():
+                                # Preserve relative path structure
+                                relative_path = extracted_file.relative_to(temp_output_path)
+                                dest_file = data_dir / relative_path
+                                dest_file.parent.mkdir(parents=True, exist_ok=True)
+                                shutil.copy2(extracted_file, dest_file)
+                                copied_count += 1
+                        
+                        logger.info(f"Copied {copied_count} decompressed files to {data_dir}")
+                        
+                        # Create marker file to indicate completion
+                        marker_file = self.game_root / ".jackify_bsa_decompressed"
+                        marker_file.touch()
+                        logger.info("BSA decompression completed successfully")
+                        return True, "BSA decompression completed successfully"
+                    else:
+                        # No files extracted - might be already decompressed or failed silently
+                        logger.warning("BSA decompressor returned 0 but no files were extracted")
+                        # Check if already decompressed by looking for marker
+                        marker_file = self.game_root / ".jackify_bsa_decompressed"
+                        if marker_file.exists():
+                            logger.info("BSA files already decompressed (marker file exists)")
+                            return True, "BSA files already decompressed"
+                        else:
+                            return False, "BSA decompressor completed but no files were extracted"
+                else:
+                    # Exit code 1 often means "already decompressed" - check output and marker
+                    marker_file = self.game_root / ".jackify_bsa_decompressed"
+
+                    # If output explicitly said "already modified/decompressed", treat as success
+                    if already_modified_detected:
+                        logger.info("BSA decompressor reports files already modified - marking as completed")
+                        marker_file.touch()
+                        return True, "BSA files already decompressed"
+
+                    # Check marker file
+                    if marker_file.exists():
+                        logger.info("BSA decompressor returned error but marker file exists - assuming already completed")
+                        return True, "BSA decompression already completed"
+
+                    # Try to provide helpful error message based on exit code and output
+                    logger.error(f"BSA decompressor failed with exit code {return_code}")
+
+                    error_details = f"BSA decompressor failed with exit code {return_code}."
+
+                    if return_code == 1:
+                        error_details += (
+                            "\n\nThis may indicate the BSA files are already decompressed or modified. "
+                            "If you've run this before, the step may have already completed. "
+                            "Otherwise, try running the decompressor manually from: "
+                            "https://www.nexusmods.com/newvegas/mods/65854"
+                        )
+                    else:
+                        error_details += (
+                            f"\n\nPlease check that:\n"
+                            f"1. Fallout New Vegas is properly installed at: {self.game_root}\n"
+                            f"2. The BSA files exist in the Data directory\n"
+                            f"3. You have write permissions to the game directory\n\n"
+                            f"You can complete this step manually using the guide at:\n"
+                            f"https://vivanewvegas.moddinglinked.com/wabbajack.html"
+                        )
+
+                    return False, error_details
+
+        except subprocess.TimeoutExpired:
+            return False, "BSA decompression timed out after 10 minutes"
+        except Exception as e:
+            error_msg = f"Failed to run BSA decompressor: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return False, error_msg

jackify/frontends/gui/dialogs/success_dialog.py

@@ -40,6 +40,7 @@ class SuccessDialog(QDialog):
         self.setWindowTitle("Success!")
         self.setWindowModality(Qt.NonModal)
         self.setAttribute(Qt.WA_ShowWithoutActivating, True)
+        self.setAttribute(Qt.WA_DeleteOnClose, True)
         self.setFixedSize(500, 500)
         self.setWindowFlag(Qt.WindowDoesNotAcceptFocus, True)
         self.setStyleSheet("QDialog { background: #181818; color: #fff; border-radius: 12px; }" )
@@ -184,7 +185,7 @@ class SuccessDialog(QDialog):
         self._update_countdown()
         self._timer.start(1000)
         self.return_btn.clicked.connect(self.accept)
-        self.exit_btn.clicked.connect(QApplication.quit)
+        self.exit_btn.clicked.connect(self._safe_exit)
 
         # Set the Wabbajack icon if available
         self._set_dialog_icon()
@@ -257,3 +258,14 @@ class SuccessDialog(QDialog):
             self.return_btn.setEnabled(True)
             self.exit_btn.setEnabled(True)
             self._timer.stop()
+
+    def _safe_exit(self):
+        """Safely exit the application with proper cleanup"""
+        try:
+            if self._timer.isActive():
+                self._timer.stop()
+            self.close()
+            QApplication.quit()
+        except Exception as e:
+            logger.error(f"Error during safe exit: {e}")
+            QApplication.quit() 

jackify/frontends/gui/dialogs/vnv_automation_dialog.py

@@ -0,0 +1,112 @@
+"""
+VNV Automation Confirmation Dialog
+
+Custom dialog for VNV automation confirmation with optional BSA decompression checkbox.
+"""
+
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, 
+    QCheckBox, QFrame, QTextEdit, QScrollArea
+)
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont
+
+
+class VNVAutomationDialog(QDialog):
+    """Dialog for confirming VNV automation with optional BSA decompression."""
+    
+    def __init__(self, parent=None, description: str = ""):
+        super().__init__(parent)
+        self.setWindowTitle("VNV Post-Install Automation")
+        self.setModal(True)
+        self.setFixedSize(600, 450)
+        self.setStyleSheet("QDialog { background: #181818; color: #fff; }")
+        
+        # Result: (confirmed: bool, include_bsa: bool)
+        self.result_data = (False, True)
+        
+        self.setup_ui(description)
+    
+    def setup_ui(self, description: str):
+        """Set up the dialog UI."""
+        main_layout = QVBoxLayout(self)
+        main_layout.setSpacing(0)
+        main_layout.setContentsMargins(20, 20, 20, 20)
+        
+        # Card background for content
+        card = QFrame(self)
+        card.setObjectName("vnvCard")
+        card.setFrameShape(QFrame.StyledPanel)
+        card.setFrameShadow(QFrame.Raised)
+        card.setStyleSheet(
+            "QFrame#vnvCard { "
+            "  background: #2d2d2d; "
+            "  border-radius: 12px; "
+            "  border: 1px solid #555; "
+            "}"
+        )
+        card_layout = QVBoxLayout(card)
+        card_layout.setSpacing(16)
+        card_layout.setContentsMargins(28, 28, 28, 28)
+        
+        # Description text - use QTextEdit for scrollable long text
+        description_text = QTextEdit()
+        description_text.setPlainText(description)
+        description_text.setReadOnly(True)
+        description_text.setMaximumHeight(200)
+        description_text.setStyleSheet(
+            "QTextEdit { "
+            "  background: #1a1a1a; "
+            "  color: #fff; "
+            "  border: 1px solid #555; "
+            "  border-radius: 4px; "
+            "  padding: 8px; "
+            "}"
+        )
+        card_layout.addWidget(description_text)
+        
+        # BSA Decompression checkbox
+        self.bsa_checkbox = QCheckBox("Include BSA Decompression")
+        self.bsa_checkbox.setChecked(True)  # Default to checked
+        self.bsa_checkbox.setStyleSheet("color: #fff; padding: 5px;")
+        card_layout.addWidget(self.bsa_checkbox)
+        
+        card_layout.addStretch()
+        
+        # Buttons
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        
+        self.yes_button = QPushButton("Yes")
+        self.yes_button.setDefault(True)
+        self.yes_button.setMinimumWidth(100)
+        self.yes_button.clicked.connect(self.accept_dialog)
+        button_layout.addWidget(self.yes_button)
+        
+        self.no_button = QPushButton("No")
+        self.no_button.setMinimumWidth(100)
+        self.no_button.clicked.connect(self.reject_dialog)
+        button_layout.addWidget(self.no_button)
+        
+        card_layout.addLayout(button_layout)
+        main_layout.addWidget(card)
+    
+    def accept_dialog(self):
+        """Handle Yes button click."""
+        self.result_data = (True, self.bsa_checkbox.isChecked())
+        self.accept()
+    
+    def reject_dialog(self):
+        """Handle No button click."""
+        self.result_data = (False, False)
+        self.reject()
+    
+    def get_result(self) -> tuple[bool, bool]:
+        """
+        Get the dialog result.
+        
+        Returns:
+            Tuple of (confirmed: bool, include_bsa_decompression: bool)
+        """
+        return self.result_data
+

jackify/frontends/gui/main.py

@@ -1628,6 +1628,19 @@ class JackifyMainWindow(QMainWindow):
     def cleanup_processes(self):
         """Clean up any running processes before closing"""
         try:
+            # Clean up background threads first
+            if hasattr(self, '_update_thread') and self._update_thread is not None:
+                if self._update_thread.isRunning():
+                    self._update_thread.quit()
+                    self._update_thread.wait(2000)
+                self._update_thread = None
+
+            if hasattr(self, '_gallery_cache_preload_thread') and self._gallery_cache_preload_thread is not None:
+                if self._gallery_cache_preload_thread.isRunning():
+                    self._gallery_cache_preload_thread.quit()
+                    self._gallery_cache_preload_thread.wait(2000)
+                self._gallery_cache_preload_thread = None
+
             # Clean up GUI services
             for service in self.gui_services.values():
                 if hasattr(service, 'cleanup'):

jackify/frontends/gui/screens/configure_existing_modlist.py

@@ -635,6 +635,9 @@ class ConfigureExistingModlistScreen(QWidget):
         # This ensures Proton version and winetricks settings are current
         self.config_handler._load_config()
 
+        # Store install_dir for later use in on_configuration_complete
+        self._current_install_dir = install_dir
+
         try:
             # Start time tracking
             self._workflow_start_time = time.time()
@@ -735,6 +738,11 @@ class ConfigureExistingModlistScreen(QWidget):
         self._enable_controls_after_operation()
 
         if success:
+            # Check for VNV post-install automation after configuration
+            install_dir = getattr(self, '_current_install_dir', None)
+            if install_dir:
+                self._check_and_run_vnv_automation(modlist_name, install_dir)
+
             # Calculate time taken
             time_taken = self._calculate_time_taken()
 
@@ -763,6 +771,90 @@ class ConfigureExistingModlistScreen(QWidget):
         self._safe_append_text(f"Configuration error: {error_message}")
         MessageService.critical(self, "Configuration Error", f"Configuration failed: {error_message}", safety_level="medium")
 
+    def _check_and_run_vnv_automation(self, modlist_name: str, install_dir: str):
+        """Check if VNV automation should run and execute if applicable
+
+        Args:
+            modlist_name: Name of the installed modlist
+            install_dir: Installation directory path
+        """
+        try:
+            from pathlib import Path
+            from jackify.backend.services.vnv_integration_helper import run_vnv_automation_if_applicable, should_offer_vnv_automation
+            from jackify.backend.services.automated_prefix_service import AutomatedPrefixService
+            from jackify.backend.handlers.path_handler import PathHandler
+
+            # Get paths first (needed for VNV detection)
+            install_path = Path(install_dir)
+            
+            # Quick check before importing more (pass install location for ModOrganizer.ini check)
+            if not should_offer_vnv_automation(modlist_name, install_path):
+                return
+            game_paths = PathHandler().find_vanilla_game_paths()
+            game_root = game_paths.get('Fallout New Vegas')
+
+            if not game_root:
+                debug_print("DEBUG: VNV automation skipped - FNV game root not found")
+                return
+
+            # Confirmation callback - show dialog to user
+            def confirmation_callback(description: str) -> bool:
+                from ..services.message_service import MessageService
+                reply = MessageService.question(
+                    self,
+                    "VNV Post-Install Automation",
+                    description,
+                    critical=False,
+                    safety_level="medium"
+                )
+                return reply == QMessageBox.Yes
+
+            # Manual file callback for non-Premium users
+            def manual_file_callback(title: str, instructions: str) -> Optional[Path]:
+                from PySide6.QtWidgets import QFileDialog
+                from ..services.message_service import MessageService
+
+                # Show instructions
+                MessageService.information(self, title, instructions)
+
+                # Open file picker
+                file_path, _ = QFileDialog.getOpenFileName(
+                    self,
+                    title,
+                    str(Path.home() / "Downloads"),
+                    "All Files (*.*)"
+                )
+
+                if file_path:
+                    return Path(file_path)
+                return None
+
+            # Run automation
+            automation_ran, error = run_vnv_automation_if_applicable(
+                modlist_name=modlist_name,
+                modlist_install_location=install_path,
+                game_root=game_root,
+                ttw_installer_path=AutomatedPrefixService.get_ttw_installer_path(),
+                progress_callback=None,  # GUI doesn't need progress updates for post-install
+                manual_file_callback=manual_file_callback,
+                confirmation_callback=confirmation_callback
+            )
+
+            if error:
+                from ..services.message_service import MessageService
+                MessageService.warning(
+                    self,
+                    "VNV Automation Failed",
+                    f"VNV post-install automation encountered an error:\n\n{error}\n\n"
+                    "You can complete these steps manually by following the guide at:\n"
+                    "https://vivanewvegas.moddinglinked.com/wabbajack.html"
+                )
+
+        except Exception as e:
+            debug_print(f"ERROR: Failed to run VNV automation: {e}")
+            import traceback
+            debug_print(f"Traceback: {traceback.format_exc()}")
+
     def show_manual_steps_dialog(self, extra_warning=""):
         modlist_name = self.shortcut_combo.currentText().split('(')[0].strip() or "your modlist"
         msg = (

jackify/frontends/gui/screens/configure_new_modlist.py

@@ -1464,6 +1464,11 @@ class ConfigureNewModlistScreen(QWidget):
         self._enable_controls_after_operation()
 
         if success:
+            # Check for VNV post-install automation after configuration
+            install_dir = self.install_dir_edit.text().strip()
+            if install_dir:
+                self._check_and_run_vnv_automation(modlist_name, install_dir)
+
             # Calculate time taken
             time_taken = self._calculate_time_taken()
 
@@ -1541,6 +1546,90 @@ class ConfigureNewModlistScreen(QWidget):
         else:
             return f"{elapsed_seconds_remainder} seconds"
 
+    def _check_and_run_vnv_automation(self, modlist_name: str, install_dir: str):
+        """Check if VNV automation should run and execute if applicable
+
+        Args:
+            modlist_name: Name of the installed modlist
+            install_dir: Installation directory path
+        """
+        try:
+            from pathlib import Path
+            from jackify.backend.services.vnv_integration_helper import run_vnv_automation_if_applicable, should_offer_vnv_automation
+            from jackify.backend.services.automated_prefix_service import AutomatedPrefixService
+            from jackify.backend.handlers.path_handler import PathHandler
+
+            # Get paths first (needed for VNV detection)
+            install_path = Path(install_dir)
+            
+            # Quick check before importing more (pass install location for ModOrganizer.ini check)
+            if not should_offer_vnv_automation(modlist_name, install_path):
+                return
+            game_paths = PathHandler().find_vanilla_game_paths()
+            game_root = game_paths.get('Fallout New Vegas')
+
+            if not game_root:
+                debug_print("DEBUG: VNV automation skipped - FNV game root not found")
+                return
+
+            # Confirmation callback - show dialog to user
+            def confirmation_callback(description: str) -> bool:
+                from ..services.message_service import MessageService
+                reply = MessageService.question(
+                    self,
+                    "VNV Post-Install Automation",
+                    description,
+                    critical=False,
+                    safety_level="medium"
+                )
+                return reply == QMessageBox.Yes
+
+            # Manual file callback for non-Premium users
+            def manual_file_callback(title: str, instructions: str) -> Optional[Path]:
+                from PySide6.QtWidgets import QFileDialog
+                from ..services.message_service import MessageService
+
+                # Show instructions
+                MessageService.information(self, title, instructions)
+
+                # Open file picker
+                file_path, _ = QFileDialog.getOpenFileName(
+                    self,
+                    title,
+                    str(Path.home() / "Downloads"),
+                    "All Files (*.*)"
+                )
+
+                if file_path:
+                    return Path(file_path)
+                return None
+
+            # Run automation
+            automation_ran, error = run_vnv_automation_if_applicable(
+                modlist_name=modlist_name,
+                modlist_install_location=install_path,
+                game_root=game_root,
+                ttw_installer_path=AutomatedPrefixService.get_ttw_installer_path(),
+                progress_callback=None,  # GUI doesn't need progress updates for post-install
+                manual_file_callback=manual_file_callback,
+                confirmation_callback=confirmation_callback
+            )
+
+            if error:
+                from ..services.message_service import MessageService
+                MessageService.warning(
+                    self,
+                    "VNV Automation Failed",
+                    f"VNV post-install automation encountered an error:\n\n{error}\n\n"
+                    "You can complete these steps manually by following the guide at:\n"
+                    "https://vivanewvegas.moddinglinked.com/wabbajack.html"
+                )
+
+        except Exception as e:
+            debug_print(f"ERROR: Failed to run VNV automation: {e}")
+            import traceback
+            debug_print(f"Traceback: {traceback.format_exc()}")
+
     def show_next_steps_dialog(self, message):
         dlg = QDialog(self)
         dlg.setWindowTitle("Next Steps")

jackify/frontends/gui/screens/install_modlist.py

@@ -1784,6 +1784,27 @@ class InstallModlistScreen(QWidget):
             modlist_name = getattr(self, '_ttw_modlist_name', 'Unknown')
             game_name = "Fallout New Vegas"
 
+            # Check for VNV post-install automation after TTW installation
+            vnv_automation_running = False
+            if hasattr(self, '_ttw_install_dir') and hasattr(self, '_ttw_modlist_name'):
+                vnv_automation_running = self._check_and_run_vnv_automation(self._ttw_modlist_name, self._ttw_install_dir)
+
+            if vnv_automation_running:
+                # Store success dialog params for later (after VNV automation completes)
+                self._pending_success_dialog_params = {
+                    'modlist_name': modlist_name,
+                    'time_taken': time_str,
+                    'game_name': game_name,
+                    'enb_detected': False,  # TTW installs don't have ENB
+                    'ttw_version': ttw_version if 'ttw_version' in locals() else None
+                }
+                # Keep post-install feedback active during VNV automation
+                # Don't show success dialog yet - will be shown in _on_vnv_complete
+                return
+
+            # No VNV automation - end post-install feedback now
+            self._end_post_install_feedback(True)
+
             # Clear Activity window before showing success dialog
             self.file_progress_list.clear()
 
@@ -1797,7 +1818,7 @@ class InstallModlistScreen(QWidget):
             )
 
             # Add TTW installation info to dialog if possible
-            if hasattr(success_dialog, 'add_info_line'):
+            if 'ttw_version' in locals() and hasattr(success_dialog, 'add_info_line'):
                 success_dialog.add_info_line(f"TTW {ttw_version} integrated successfully")
 
             success_dialog.show()
@@ -1810,6 +1831,216 @@ class InstallModlistScreen(QWidget):
                 f"TTW integration completed but failed to show success dialog: {str(e)}"
             )
 
+    def _check_and_run_vnv_automation(self, modlist_name: str, install_dir: str) -> bool:
+        """Check if VNV automation should run and execute if applicable in background thread
+
+        Args:
+            modlist_name: Name of the installed modlist
+            install_dir: Installation directory path
+
+        Returns:
+            True if VNV automation is starting (success dialog should be deferred)
+            False if no VNV automation needed (show success dialog immediately)
+        """
+        try:
+            from pathlib import Path
+            from jackify.backend.services.vnv_integration_helper import should_offer_vnv_automation
+            from jackify.backend.handlers.path_handler import PathHandler
+            from jackify.backend.services.vnv_post_install_service import VNVPostInstallService
+            from jackify.backend.services.automated_prefix_service import AutomatedPrefixService
+
+            # Get paths first (needed for VNV detection)
+            install_path = Path(install_dir)
+
+            # Quick check before importing more (pass install location for ModOrganizer.ini check)
+            if not should_offer_vnv_automation(modlist_name, install_path):
+                return False
+
+            game_paths = PathHandler().find_vanilla_game_paths()
+            game_root = game_paths.get('Fallout New Vegas')
+
+            if not game_root:
+                debug_print("DEBUG: VNV automation skipped - FNV game root not found")
+                return False
+
+            # Initialize service to check completion status
+            vnv_service = VNVPostInstallService(
+                modlist_install_location=install_path,
+                game_root=game_root,
+                ttw_installer_path=AutomatedPrefixService.get_ttw_installer_path()
+            )
+
+            # Check what's already done
+            completed = vnv_service.check_already_completed()
+            # Only skip if ALL three steps are completed
+            if completed['root_mods'] and completed['4gb_patch'] and completed['bsa_decompressed']:
+                logger.info("VNV automation steps already completed")
+                return False
+
+            # Get automation description for confirmation
+            description = vnv_service.get_automation_description()
+
+            # Show confirmation dialog ON MAIN THREAD (not in worker thread!)
+            from ..services.message_service import MessageService
+            reply = MessageService.question(
+                self,
+                "VNV Post-Install Automation",
+                description,
+                critical=False,
+                safety_level="medium"
+            )
+
+            if reply != QMessageBox.Yes:
+                logger.info("User declined VNV automation")
+                return False
+
+            # Manual file callback for non-Premium users
+            def manual_file_callback(title: str, instructions: str) -> Optional[Path]:
+                from PySide6.QtWidgets import QFileDialog
+                from ..services.message_service import MessageService
+
+                # Show instructions
+                MessageService.information(self, title, instructions)
+
+                # Open file picker
+                file_path, _ = QFileDialog.getOpenFileName(
+                    self,
+                    title,
+                    str(Path.home() / "Downloads"),
+                    "All Files (*.*)"
+                )
+
+                if file_path:
+                    return Path(file_path)
+                return None
+
+            # Enable post-install progress tracking for VNV automation
+            self._begin_post_install_feedback()
+
+            # User confirmed - start automation in background thread
+            self._run_vnv_automation_threaded(
+                modlist_name,
+                install_path,
+                game_root,
+                manual_file_callback
+            )
+
+            return True  # VNV automation is running, defer success dialog
+
+        except Exception as e:
+            debug_print(f"ERROR: Failed to start VNV automation: {e}")
+            import traceback
+            debug_print(f"Traceback: {traceback.format_exc()}")
+            return False  # Error - show success dialog anyway
+
+    def _run_vnv_automation_threaded(self, modlist_name, install_path, game_root,
+                                      manual_file_callback):
+        """Run VNV automation in a background thread with progress updates
+
+        Note: User confirmation should already be obtained before calling this method.
+        """
+        from PySide6.QtCore import QThread, Signal
+        from jackify.backend.services.vnv_integration_helper import run_vnv_automation_if_applicable
+        from jackify.backend.services.automated_prefix_service import AutomatedPrefixService
+
+        class VNVAutomationWorker(QThread):
+            progress_update = Signal(str)
+            completed = Signal(bool, str)  # (success, error_message)
+
+            def __init__(self, modlist_name, install_path, game_root, ttw_installer_path,
+                        manual_file_callback):
+                super().__init__()
+                self.modlist_name = modlist_name
+                self.install_path = install_path
+                self.game_root = game_root
+                self.ttw_installer_path = ttw_installer_path
+                self.manual_file_callback = manual_file_callback
+
+            def run(self):
+                try:
+                    # User already confirmed, pass lambda that always returns True
+                    automation_ran, error = run_vnv_automation_if_applicable(
+                        modlist_name=self.modlist_name,
+                        modlist_install_location=self.install_path,
+                        game_root=self.game_root,
+                        ttw_installer_path=self.ttw_installer_path,
+                        progress_callback=self.progress_update.emit,
+                        manual_file_callback=self.manual_file_callback,
+                        confirmation_callback=lambda desc: True  # Already confirmed on main thread
+                    )
+                    self.completed.emit(error is None, error or "")
+                except Exception as e:
+                    import traceback
+                    self.completed.emit(False, f"Exception: {str(e)}\n{traceback.format_exc()}")
+
+        # Create and start worker
+        self.vnv_worker = VNVAutomationWorker(
+            modlist_name,
+            install_path,
+            game_root,
+            AutomatedPrefixService.get_ttw_installer_path(),
+            manual_file_callback
+        )
+
+        # Connect signals
+        self.vnv_worker.progress_update.connect(self._on_vnv_progress)
+        self.vnv_worker.completed.connect(self._on_vnv_complete)
+        self.vnv_worker.finished.connect(self.vnv_worker.deleteLater)
+
+        # Start worker
+        self.vnv_worker.start()
+
+    def _on_vnv_progress(self, message: str):
+        """Handle VNV automation progress updates"""
+        self._safe_append_text(message)
+        # Also update progress indicator, Activity window, and Details window
+        self._handle_post_install_progress(message)
+
+    def _on_vnv_complete(self, success: bool, error: str):
+        """Handle VNV automation completion and show deferred success dialog"""
+        # End post-install feedback now that VNV automation is complete
+        self._end_post_install_feedback(True)
+
+        if not success and error:
+            from ..services.message_service import MessageService
+            MessageService.warning(
+                self,
+                "VNV Automation Failed",
+                f"VNV post-install automation encountered an error:\n\n{error}\n\n"
+                "You can complete these steps manually by following the guide at:\n"
+                "https://vivanewvegas.moddinglinked.com/wabbajack.html"
+            )
+        elif success:
+            self._safe_append_text("VNV post-install automation completed successfully")
+
+        # Show the deferred success dialog now that VNV automation is complete
+        if hasattr(self, '_pending_success_dialog_params'):
+            params = self._pending_success_dialog_params
+            del self._pending_success_dialog_params  # Clean up
+
+            # Clear Activity window before showing success dialog
+            self.file_progress_list.clear()
+
+            # Show success dialog
+            from ..dialogs import SuccessDialog
+            success_dialog = SuccessDialog(
+                modlist_name=params['modlist_name'],
+                workflow_type="install",
+                time_taken=params['time_taken'],
+                game_name=params['game_name'],
+                parent=self
+            )
+            success_dialog.show()
+
+            # Show ENB Proton dialog if ENB was detected
+            if params.get('enb_detected'):
+                try:
+                    from ..dialogs.enb_proton_dialog import ENBProtonDialog
+                    enb_dialog = ENBProtonDialog(modlist_name=params['modlist_name'], parent=self)
+                    enb_dialog.exec()  # Modal dialog - blocks until user clicks OK
+                except Exception as e:
+                    # Non-blocking: if dialog fails, just log and continue
+                    logger.warning(f"Failed to show ENB dialog: {e}")
 
 
     def validate_and_start_install(self):
@@ -3255,6 +3486,39 @@ class InstallModlistScreen(QWidget):
                     "backup",
                 ],
             },
+            {
+                'id': 'vnv_root_mods',
+                'label': "VNV: Copying root mods",
+                'keywords': [
+                    "step 1/3: copying root mods",
+                    "copying root mods to game directory",
+                    "root mods:",
+                ],
+            },
+            {
+                'id': 'vnv_4gb_patch',
+                'label': "VNV: Applying 4GB patch",
+                'keywords': [
+                    "step 2/3: downloading and running 4gb patcher",
+                    "downloading fnv4gb",
+                    "downloading:",
+                    "fetching file list",
+                    "running 4gb patcher",
+                    "4gb patcher:",
+                ],
+            },
+            {
+                'id': 'vnv_bsa_decompress',
+                'label': "VNV: Decompressing BSA files",
+                'keywords': [
+                    "step 3/3: downloading and running bsa decompressor",
+                    "downloading:",
+                    "fetching file list",
+                    "running bsa decompressor",
+                    "decompressing bsa files:",
+                    "bsa decompression:",
+                ],
+            },
             {
                 'id': 'config_finalize',
                 'label': "Finalising Jackify configuration",
@@ -3262,7 +3526,8 @@ class InstallModlistScreen(QWidget):
                     "configuration completed successfully",
                     "configuration complete",
                     "manual steps validation failed",
-                    "configuration failed"
+                    "configuration failed",
+                    "vnv post-install completed successfully"
                 ],
             },
         ]
@@ -3865,7 +4130,8 @@ class InstallModlistScreen(QWidget):
             self.file_progress_list.stop_cpu_tracking()
             # Re-enable controls now that installation/configuration is complete
             self._enable_controls_after_operation()
-            self._end_post_install_feedback(success)
+            # Don't end post-install feedback yet - may continue with VNV automation
+            # Will be called in _on_vnv_complete or after VNV check
 
             if success:
                 # Check if we need to show Somnium guidance
@@ -3917,6 +4183,24 @@ class InstallModlistScreen(QWidget):
                         self._initiate_ttw_workflow(modlist_name, install_dir)
                         return  # Don't show success dialog yet, will show after TTW completes
 
+                # Check for VNV post-install automation after TTW check
+                vnv_automation_running = self._check_and_run_vnv_automation(modlist_name, install_dir)
+
+                if vnv_automation_running:
+                    # Store success dialog params for later (after VNV automation completes)
+                    self._pending_success_dialog_params = {
+                        'modlist_name': modlist_name,
+                        'time_taken': time_str,
+                        'game_name': game_name,
+                        'enb_detected': enb_detected
+                    }
+                    # Keep post-install feedback active during VNV automation
+                    # Don't show success dialog yet - will be shown in _on_vnv_complete
+                    return
+
+                # No VNV automation - end post-install feedback now
+                self._end_post_install_feedback(True)
+
                 # Clear Activity window before showing success dialog
                 self.file_progress_list.clear()
 
@@ -3941,10 +4225,12 @@ class InstallModlistScreen(QWidget):
                         logger.warning(f"Failed to show ENB dialog: {e}")
             elif hasattr(self, '_manual_steps_retry_count') and self._manual_steps_retry_count >= 3:
                 # Max retries reached - show failure message
+                self._end_post_install_feedback(False)
                 MessageService.critical(self, "Manual Steps Failed",
                                    "Manual steps validation failed after multiple attempts.")
             else:
                 # Configuration failed for other reasons
+                self._end_post_install_feedback(False)
                 MessageService.critical(self, "Configuration Failed",
                                    "Post-install configuration failed. Please check the console output.")
         except Exception as e:

jackify/shared/logging.py

@@ -106,7 +106,7 @@ class LoggingHandler:
         if log_file or is_general:
             file_path = self.log_dir / (log_file if log_file else "jackify-cli.log")
             file_handler = logging.handlers.RotatingFileHandler(
-                file_path, mode='a', encoding='utf-8', maxBytes=1024*1024, backupCount=5
+                file_path, mode='a', encoding='utf-8', maxBytes=100*1024*1024, backupCount=5
             )
             # File handler always accepts DEBUG - root logger level controls what gets through
             file_handler.setLevel(logging.DEBUG)
@@ -116,7 +116,7 @@ class LoggingHandler:
             
         return logger
         
-    def rotate_logs(self, max_bytes: int = 1024 * 1024, backup_count: int = 5) -> None:
+    def rotate_logs(self, max_bytes: int = 100 * 1024 * 1024, backup_count: int = 5) -> None:
         """Rotate log files based on size."""
         for log_file in self.get_log_files():
             try:

jackify/tools/.gitignore

@@ -0,0 +1,19 @@
+# Tools downloaded during AppImage build
+# These are fetched from upstream sources during build_appimage_simple.sh
+# They are NOT stored in git to keep the repository clean
+# See THIRD_PARTY_NOTICES.md for licensing information
+
+# Downloaded during build:
+winetricks
+cabextract
+7z
+wget
+unzip
+sha256sum
+
+# lz4 is copied from system during build
+lz4
+
+# Keep this .gitignore and README
+!.gitignore
+!README.md

jackify/tools/README.md

@@ -0,0 +1,52 @@
+# Jackify Tools Directory
+
+This directory contains utility tools bundled with Jackify for self-contained AppImage distribution.
+
+## How It Works
+
+**In Git Repository**: This directory only contains this README and .gitignore (no binaries).
+
+**During Build**: The `build_appimage_simple.sh` script downloads required tools from their official sources.
+
+**In AppImage**: Tools are bundled for self-contained distribution (users don't need to install dependencies).
+
+## Tools Downloaded During Build
+
+### winetricks
+- **Source**: https://github.com/Winetricks/winetricks
+- **License**: LGPL v2.1
+- **Purpose**: Wine prefix configuration and Windows component installation
+- **Downloaded from**: GitHub master branch (latest version)
+
+### cabextract
+- **Source**: https://github.com/kyz/cabextract
+- **License**: GPL v3
+- **Purpose**: Microsoft Cabinet file extraction
+- **Downloaded from**: GitHub releases (v1.11)
+
+### 7-Zip (7z / 7zz)
+- **Source**: https://www.7-zip.org/
+- **License**: GNU LGPL + unRAR restriction
+- **Purpose**: Archive extraction and compression
+- **Downloaded from**: Official 7-Zip website
+
+### lz4
+- **Source**: System package (copied from /usr/bin/lz4)
+- **License**: BSD 2-Clause
+- **Purpose**: Fast compression for TTW installer patch decompression
+- **Note**: Copied from build system, not downloaded
+
+## Why Not Store in Git?
+
+1. **Repository Size**: Binaries total ~11MB, bloating git history
+2. **Updates**: Tools update independently of Jackify code
+3. **Professional Practice**: Industry standard separates source code from build artifacts
+4. **Licensing**: Clear separation between our code and third-party binaries
+
+## For Developers
+
+When building locally with `./build_appimage_simple.sh`, these tools are automatically downloaded.
+
+If build fails to download tools, the script will attempt to use system versions as fallback.
+
+See `THIRD_PARTY_NOTICES.md` in project root for complete licensing information.

jackify/tools/winetricks

@@ -76,6 +76,7 @@ WINETRICKS_VERSION=20250102-next
 #   Copyright (C) 2013,2016 André Hentschel <nerv!dawncrow.de>
 #   Copyright (C) 2023 Georgi Georgiev (RacerBG) <g.georgiev.shumen!gmail.com>
 #   Copyright (C) 2025 ykla <yklaxds!gmail.com>
+#   Copyright (C) 2025 Allan Rémy
 #
 # License:
 #   This program is free software; you can redistribute it and/or
@@ -360,6 +361,31 @@ _w_get_broken_messages()
             broken_only_bad_version_known_win64="Пакетът (${W_PACKAGE}) е повреден при 64-битовата архитектура на wine-${_wine_version_stripped}. Повреден е от версия ${bad_version}. Използвайте папка, създадена с WINEARCH=win32. Вижте ${bug_link} за повече информация. Използвайте --force, за да опитате въпреки това."
             broken_no_version_known_win64="Пакетът (${W_PACKAGE}) е повреден, когато wine е създаден без mingw. Вижте ${bug_link} за повече информация. Използвайте --force, за да опитате въпреки това."
             ;;
+        fr*)
+            # default broken messages
+            broken_good_version_known_default="Ce paquet (${W_PACKAGE}) ne fonctionne pas correctement dans wine-${_wine_version_stripped}. Effectuez une mise à niveau vers >=${good_version}. Consultez ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_good_and_bad_version_known_default="Ce paquet (${W_PACKAGE}) est cassé dans wine-${_wine_version_stripped}. Cassé depuis ${bad_version}. Mettez à jour vers >=${good_version}. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_only_bad_version_known_default="Ce paquet (${W_PACKAGE}) est cassé dans wine-${_wine_version_stripped}. Cassé depuis ${bad_version}. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_no_version_known_default="Ce paquet (${W_PACKAGE}) est cassé. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+
+            # mingw broken messages
+            broken_good_version_known_mingw="Ce paquet (${W_PACKAGE}) ne fonctionne pas sous wine-${_wine_version_stripped} lorsque wine est compilé avec mingw. Effectuez une mise à niveau vers >=${good_version} ou recompilez wine sans mingw. Consultez ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_good_and_bad_version_known_mingw="Ce paquet (${W_PACKAGE}) est cassé dans wine-${_wine_version_stripped}. Cassé depuis ${bad_version} lorsque wine est compilé avec mingw. Mettez à jour vers >=${good_version} ou recompilez wine sans mingw. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_only_bad_version_known_mingw="Ce paquet (${W_PACKAGE}) est cassé dans wine-${_wine_version_stripped}. Cassé depuis ${bad_version} lorsque wine est compilé avec mingw. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_no_version_known_mingw="Ce paquet (${W_PACKAGE}) est cassé lorsque Wine est compilé avec mingw. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+
+            # no mingw broken messages
+            broken_good_version_known_no_mingw="Ce paquet (${W_PACKAGE}) est défectueux dans wine-${_wine_version_stripped} lorsque wine est compilé sans mingw. Effectuez une mise à niveau vers >=${good_version}. Consultez ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_good_and_bad_version_known_no_mingw="Ce paquet (${W_PACKAGE}) est cassé dans wine-${_wine_version_stripped}. Cassé depuis ${bad_version} lorsque wine est compilé sans mingw. Mettez à jour vers >=${good_version}. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_only_bad_version_known_no_mingw="Ce paquet (${W_PACKAGE}) est cassé dans wine-${_wine_version_stripped}. Cassé depuis ${bad_version} lorsque wine est compilé sans mingw. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_no_version_known_no_mingw="Ce paquet (${W_PACKAGE}) est cassé lorsque wine est compilé sans mingw. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+
+            # win64 broken messages
+            broken_good_version_known_win64="Ce paquet (${W_PACKAGE}) ne fonctionne pas sous Wine 64 bits-${_wine_version_stripped}. Utilisez un préfixe créé avec WINEARCH=win32 ou mettez à niveau Wine vers >=${good_version} pour contourner ce problème. Ou utilisez --force pour essayer quand même. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_good_and_bad_version_known_win64="Ce paquet (${W_PACKAGE}) est cassé sur wine-${_wine_version_stripped} 64 bits. Cassé depuis ${bad_version}. Utilisez un préfixe créé avec WINEARCH=win32 ou mettez à jour wine vers >=${good_version} pour contourner ce problème. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_only_bad_version_known_win64="Ce paquet (${W_PACKAGE}) est cassé sur wine-${_wine_version_stripped} 64 bits. Cassé depuis ${bad_version}. Utilisez un préfixe créé avec WINEARCH=win32 pour contourner ce problème. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            broken_no_version_known_win64="Ce paquet (${W_PACKAGE}) est cassé lorsque wine est compilé sans mingw. Voir ${bug_link} pour plus d'informations. Utilisez --force pour essayer quand même."
+            ;;
         pt*)
             # default broken messages
             broken_good_version_known_default="O pacote (${W_PACKAGE}) está quebrado no wine-${_wine_version_stripped}. Atualize para >=${good_version}. Veja ${bug_link} para mais informações. Use --force para tentar forçar de toda forma."
@@ -1154,6 +1180,29 @@ w_get_github_latest_prerelease()
     echo "${latest_version}"
 }
 
+# Get the latest tagged release from gitlab.com API
+w_get_gitlab_latest_release()
+{
+    # FIXME: can we get releases that aren't on master branch?
+    org="$1"
+    repo="$2"
+
+    # release.json might still exists from the previous verb
+    w_try rm -f "${W_TMP_EARLY}/release.json"
+
+    WINETRICKS_SUPER_QUIET=1 w_download_to "${W_TMP_EARLY}" "https://gitlab.com/api/v4/projects/${org}%2F${repo}/releases" "" "release.json" >/dev/null 2>&1
+
+    # aria2c condenses the json (https://github.com/aria2/aria2/issues/1389)
+    # but curl/wget don't, so handle both cases:
+    json_length="$(wc -l "${W_TMP_EARLY}/release.json")"
+    case "${json_length}" in
+        0*) latest_version="$(sed -e "s/\",\"/|/g" "${W_TMP_EARLY}/release.json" | tr '|' '\n' | grep tag_name | sed 's@.*"@@' | head -n 1)";;
+        *) latest_version="$(grep -w tag_name "${W_TMP_EARLY}/release.json" | cut -d '"' -f 4 | head -n 1)";;
+    esac
+
+    echo "${latest_version}"
+}
+
 # get sha256sum string and set $_W_gotsha256sum to it
 w_get_sha256sum()
 {
@@ -3193,6 +3242,17 @@ winetricks_prefixmenu()
             _W_msg_unattended1="Включване на автоматичното инсталиране"
             _W_msg_help="Отваряне на помощта"
             ;;
+        fr*) _W_msg_title="Winetricks - Choisir un préfixe"
+            _W_msg_body="Que souhaitez-vous faire ?"
+            _W_msg_apps="Installer une application"
+            _W_msg_benchmarks="Installer un benchmark"
+            _W_msg_default="Sélectionner le préfixe par défaut"
+            _W_msg_mkprefix="Créer un nouveau préfixe"
+            _W_msg_unattended0="Désactiver une installation silencieuse"
+            _W_msg_unattended1="Activer une installation silencieuse"
+            _W_msg_help="Voir aide"
+            _W_msg_cancel="Quitter"
+            ;;
         ru*) _W_msg_title="Winetricks - выберите путь wine (префикс)"
             _W_msg_body='Что вы хотите сделать?'
             _W_msg_apps='Установить программу'
@@ -3373,6 +3433,10 @@ winetricks_mkprefixmenu()
             _W_msg_name="Name"
             _W_msg_arch="Architektur"
             ;;
+        fr*)  _W_msg_title="Winetricks - Créer un nouveau préfixe"
+            _W_msg_name="Nom :"
+            _W_msg_arch="Architecture"
+            ;;
         pt*) _W_msg_title="Winetricks - criar novo wineprefix"
             _W_msg_name="Nome"
             _W_msg_arch="Arquitetura"
@@ -3458,6 +3522,23 @@ winetricks_mainmenu()
             _W_msg_folder='Ordner durchsuchen'
             _W_msg_annihilate="ALLE DATEIEN UND PROGRAMME IN DIESEM WINEPREFIX Löschen"
             ;;
+        fr*) _W_msg_title="Winetricks - Le préfixe actuel est \"${WINEPREFIX}\""
+            _W_msg_body='Que souhaitez-vous faire avec ce préfixe ?'
+            _W_msg_cancel="Revenir en arrière"
+            _W_msg_dlls="Installer une DLL ou un composant Windows"
+            _W_msg_fonts='Installer une police'
+            _W_msg_settings='Modifier les paramètres'
+            _W_msg_winecfg='Exécuter winecfg'
+            _W_msg_regedit='Exécuter regedit'
+            _W_msg_taskmgr='Exécuter taskmgr'
+            _W_msg_explorer='Exécuter explorer'
+            _W_msg_uninstaller='Exécuter uninstaller'
+            _W_msg_winecmd='Exécuter une invite de commande'
+            _W_msg_wine_misc_exe='Exécuter un exécutable arbitraire (.exe/.msi/.msu)'
+            _W_msg_shell='Exécuter une invite de commande pour le débogage'
+            _W_msg_folder='Parcourir les fichiers'
+            _W_msg_annihilate="Supprimer TOUTES LES DONNÉES ET APPLICATIONS CONTENUES DANS CE PRÉFIXE"
+            ;;
         pl*) _W_msg_title="Winetricks - obecny prefiks to \"${WINEPREFIX}\""
             _W_msg_body='Co chcesz zrobić w tym prefiksie?'
             _W_msg_dlls="Zainstalować windowsową bibliotekę DLL lub komponent"
@@ -3472,7 +3553,7 @@ winetricks_mainmenu()
             _W_msg_wine_misc_exe='Run an arbitrary executable (.exe/.msi/.msu)'
             _W_msg_shell='Uruchomić powłokę wiersza poleceń (dla debugowania)'
             _W_msg_folder='Przeglądać pliki'
-            _W_msg_annihilate="Usuńąć WSZYSTKIE DANE I APLIKACJE WEWNĄTRZ TEGO PREFIKSU WINE"
+            _W_msg_annihilate="Usunąć WSZYSTKIE DANE I APLIKACJE WEWNĄTRZ TEGO PREFIKSU WINE"
             ;;
         pt*) _W_msg_title="Winetricks - o prefixo atual é \"${WINEPREFIX}\""
             _W_msg_body='O que você gostaria de fazer com este prefixo wineprefix?'
@@ -3644,6 +3725,9 @@ winetricks_settings_menu()
         de*) _W_msg_title="Winetricks - Aktueller Präfix ist \"${WINEPREFIX}\""
             _W_msg_body='Welche Einstellungen möchten Sie ändern?'
             ;;
+        fr*) _W_msg_title="Winetricks - Le préfixe actuel est \"${WINEPREFIX}\""
+            _W_msg_body='Quels paramètres souhaitez-vous modifier ?'
+            ;;
         pl*) _W_msg_title="Winetricks - obecny prefiks to \"${WINEPREFIX}\""
             _W_msg_body='Jakie ustawienia chcesz zmienić?'
             ;;
@@ -3706,6 +3790,19 @@ winetricks_settings_menu()
                         --width ${WINETRICKS_MENU_WIDTH} \
                         "
                     ;;
+                fr*) printf %s "zenity \
+                        --title '${_W_msg_title}' \
+                        --text '${_W_msg_body}' \
+                        --cancel-label 'Revenir en arrière' \
+                        --list \
+                        --checklist \
+                        --column '' \
+                        --column Paramètres \
+                        --column Titre \
+                        --height ${WINETRICKS_MENU_HEIGHT} \
+                        --width ${WINETRICKS_MENU_WIDTH} \
+                        "
+                    ;;
                 pl*) printf %s "zenity \
                         --title '${_W_msg_title}' \
                         --text '${_W_msg_body}' \
@@ -3867,6 +3964,10 @@ winetricks_showmenu()
             _W_msg_body='Welche Paket(e) möchten Sie installieren?'
             _W_cached="gecached"
             ;;
+        fr*) _W_msg_title="Winetricks - Le préfixe actuel est \"${WINEPREFIX}\""
+            _W_msg_body="Quel(s) paquet(s) souhaitez-vous installer ?"
+            _W_cached="mis en cache"
+            ;;
         pl*) _W_msg_title="Winetricks - obecny prefiks to \"${WINEPREFIX}\""
             _W_msg_body='Które paczki chesz zainstalować?'
             _W_cached="zarchiwizowane"
@@ -3949,6 +4050,22 @@ winetricks_showmenu()
                         --width ${WINETRICKS_MENU_WIDTH} \
                         "
                         ;;
+                fr*) printf %s "zenity \
+                        --title '${_W_msg_title}' \
+                        --text '${_W_msg_body}' \
+                        --list \
+                        --checklist \
+                        --column '' \
+                        --column Package \
+                        --column Titre \
+                        --column Éditeur \
+                        --column Année \
+                        --column Media \
+                        --column Status \
+                        --height ${WINETRICKS_MENU_HEIGHT} \
+                        --width ${WINETRICKS_MENU_WIDTH} \
+                        "
+                        ;;
                 pl*) printf %s "zenity \
                         --title '${_W_msg_title}' \
                         --text '${_W_msg_body}' \
@@ -4289,6 +4406,7 @@ winetricks_list_all()
         bg*) _W_cached="кеширано"   ; _W_download="за изтегляне"  ;;
         da*) _W_cached="cached"   ; _W_download="kan hentes"    ;;
         de*) _W_cached="gecached" ; _W_download="herunterladbar";;
+        fr*) _W_cached="mis en cache"   ; _W_download="téléchargeable";;
         pl*) _W_cached="zarchiwizowane"   ; _W_download="do pobrania"  ;;
         pt*) _W_cached="em cache"   ; _W_download="para download"  ;;
         ru*) _W_cached="в кэше"   ; _W_download="доступно для скачивания"  ;;
@@ -4609,6 +4727,7 @@ winetricks_set_wineprefix()
         if [ "${W_NO_WIN64_WARNINGS}" = 0 ]; then
             case ${LANG} in
                 bg*) w_warn "Използвате 64-битова папка. Повечето програми са за 32-битова архитектура. Ако възникнат проблеми, моля, използвайте 32-битова папка, преди да ги докладвате." ;;
+                fr*) w_warn "Vous utilisez un WINEPREFIX 64 bits. Notez que de nombreux verbes n'installent que des versions 32 bits des paquets. Si vous rencontrez des problèmes, veuillez refaire un test dans un WINEPREFIX 32 bits propre avant de signaler un bug." ;;
                 ru*) w_warn "Вы используете 64-битный WINEPREFIX. Важно: многие ветки устанавливают только 32-битные версии пакетов. Если у вас возникли проблемы, пожалуйста, проверьте еще раз на чистом 32-битном WINEPREFIX до отправки отчета об ошибке." ;;
                 pt*) w_warn "Você está usando um WINEPREFIX de 64-bit. Observe que muitos casos instalam apenas versões de pacotes de 32-bit. Se você encontrar problemas, teste novamente em um WINEPREFIX limpo de 32-bit antes de relatar um bug." ;;
                 zh_CN*) w_warn "您正在使用 64 位的 WINEPREFIX。请注意，许多脚本（verbs）只安装 32 位版本的软件包。如果遇到问题，请先在干净的 32 位 WINEPREFIX 中重新测试，然后再报告错误。" ;;
@@ -4721,6 +4840,7 @@ winetricks_annihilate_wineprefix()
 
     case ${LANG} in
         bg*) w_askpermission "Изтриване на ${WINEPREFIX}, нейните приложения, икони и менюта?" ;;
+        fr*) w_askpermission "Supprimer ${WINEPREFIX}, ses applications, ses icônes et ses éléments de menu ?" ;;
         uk*) w_askpermission "Бажаєте видалити '${WINEPREFIX}'?" ;;
         pl*) w_askpermission "Czy na pewno chcesz usunąć prefiks ${WINEPREFIX} i wszystkie jego elementy?" ;;
         pt*) w_askpermission "Apagar ${WINEPREFIX}, Estes apps, ícones e ítens do menu?" ;;
@@ -5082,6 +5202,50 @@ arch=32|64            Neues wineprefix mit 32 oder 64 bit erstellen, diese Optio
                       nicht im Falle des Standard Wineprefix.
 prefix=foobar         WINEPREFIX=${W_PREFIXES_ROOT}/foobar auswählen
 annihilate            ALLE DATEIEN UND PROGRAMME IN DIESEM WINEPREFIX Löschen
+_EOF_
+            ;;
+        fr*)
+            cat <<_EOF_
+Utilisation : $0 [options] [commande|verbe|chemin-vers-le-verbe] ...
+Exécute les verbes donnés. Chaque verbe installe une application ou modifie un paramètre.
+
+Options :
+    --country=CC      Définit le code pays sur CC et ne détecte pas votre adresse IP
+-f, --force           Ne vérifie pas si les paquets sont déjà installés
+    --gui             Affiche les diagnostics de l'interface graphique même lorsque l'application est lancée en ligne de commande
+    --gui=OPT         Définit OPT sur kdialog ou zenity pour remplacer le moteur GUI
+    --isolate         Installe chaque application ou jeu dans son propre bottle (WINEPREFIX)
+    --self-update     Mettre à jour cette application vers la dernière version (non Debian)
+    --update-rollback Annuler la dernière mise à jour automatique
+-k, --keep_isos       Mettre en cache les images ISO (permet une installation ultérieure sans disque)
+    --no-clean        Ne pas supprimer les répertoires temporaires (utile pendant le débogage)
+    --optin           Activer le rapport des verbes que vous utilisez aux responsables de Winetricks
+    --optout          Désactiver le rapport des verbes que vous utilisez aux responsables de Winetricks
+-q, --unattended      Ne poser aucune question, installer automatiquement
+-r, --ddrescue        Réessayer plusieurs fois lors de la mise en cache de disques rayés
+-t  --torify          Exécute les téléchargements sous torify, si disponible
+    --verify          Exécute des tests GUI (automatisés) pour les verbes, si disponibles
+-v, --verbose         Affiche toutes les commandes au fur et à mesure de leur exécution
+-h, --help            Affiche ce message et quitte
+-V, --version         Affiche la version et quitte
+
+Commandes :
+list                  Liste des catégories
+list-all              Liste toutes les catégories et leurs verbes
+apps list             Liste les verbes dans la catégorie « applications »
+benchmarks list       Liste les verbes dans la catégorie « benchmarks »
+dlls list             Liste les verbes de la catégorie « dlls »
+fonts list            Liste les verbes de la catégorie « polices »
+settings list         Liste les verbes de la catégorie « paramètres »
+list-cached           Liste les verbes mis en cache et prêts à être installés
+list-download         Liste les verbes qui se téléchargent automatiquement
+list-manual-download  Liste les verbes qui se téléchargent avec l'aide de l'utilisateur
+list-installed        Liste les verbes déjà installés
+arch=32|64            Crée un préfixe en 32 ou 64 bits, cette option doit être
+                      Spécifiée avant prefix=foobar et ne fonctionnera pas dans le cas du
+                      wineprefix par défaut.
+prefix=foobar         Sélectionner WINEPREFIX=${W_PREFIXES_ROOT}/foobar
+annihilate            Supprimer TOUTES LES DONNÉES ET APPLICATIONS CONTENUES DANS CE WINEPREFIX
 _EOF_
             ;;
         zh_CN*)
@@ -5122,6 +5286,7 @@ list-installed        列出已安装的脚本
 arch=32|64            创建 32 位或 64 位 wineprefix，此选项必须在 prefix=foobar 之前指定，默认 wineprefix 不支持此选项
 prefix=foobar         选择 WINEPREFIX 为 ${W_PREFIXES_ROOT}/foobar
 annihilate            删除该 WINEPREFIX 内的所有数据和应用程序
+_EOF_
             ;;
         *)
             cat <<_EOF_
@@ -6452,7 +6617,7 @@ load_dinput8()
 #----------------------------------------------------------------
 
 w_metadata dinputto8 dlls \
-    title="A dll module that is designed to improve compatibility in games using DirectInput 1-7 by converting all API calls to their equivalent DirectInput 8 (1.0.78.0)" \
+    title="A dll module that is designed to improve compatibility in games using DirectInput 1-7 by converting all API calls to their equivalent DirectInput 8 (1.0.92.0)" \
     homepage="https://github.com/elishacloud/dinputto8" \
     publisher="Elisha Riedlinger" \
     year="2018" \
@@ -6463,7 +6628,7 @@ w_metadata dinputto8 dlls \
 
 load_dinputto8()
 {
-    w_download https://github.com/elishacloud/dinputto8/releases/download/v1.0.78.0/dinput.dll 467f50cac676635ed68658b8be32e1a2cacece37a22bb13e8ec8330706a32ca7
+    w_download https://github.com/elishacloud/dinputto8/releases/download/v1.0.92.0/dinput.dll 8f1e53a55c66f870b91c1e43a39c02a4a87900cf453776de41643863bdfa00e6
     w_try_cp_dll "${W_CACHE}/${W_PACKAGE}/dinput.dll" "${W_SYSTEM32_DLLS}/dinput.dll"
     w_override_dlls native dinput
 }
@@ -7841,6 +8006,86 @@ load_dxvk()
 
 #----------------------------------------------------------------
 
+# $1 - dxvk async archive name (required)
+# $2 - dxvk async version (required)
+# $3 - minimum Wine version (required)
+# $4 - minimum Vulkan API version (required)
+# $5 - [dxgi,][d3d8,][d3d9,][d3d10core,]d3d11 (required)
+helper_dxvk_async()
+{
+    _W_package_archive="${1}"
+    _W_package_version="${2}"
+    _W_min_wine_version="${3}"
+    _W_min_vulkan_version="${4}"
+    _W_dll_overrides="$(echo "${5}" | sed 's/,/ /g')"
+    # dxvk async repository, for d3d8/d3d9/d3d10/d3d11 support
+    _W_repository="Ph42oN/dxvk-gplasync"
+
+    _W_supported_overrides="dxgi d3d8 d3d9 d3d10core d3d11"
+    _W_invalid_overrides="$(echo "${_W_dll_overrides}" | awk -vvalid_overrides_regex="$(echo "${_W_supported_overrides}" | sed 's/ /|/g')" '{ gsub(valid_overrides_regex,""); sub("[ ]*",""); print $0 }')"
+    if [ "${_W_invalid_overrides}" != "" ]; then
+        w_die "parameter (4) unsupported dll override: '${_W_invalid_overrides}' ; supported dll overrides: ${_W_supported_overrides}"
+    fi
+
+    _W_package_dir="${_W_package_archive%.tar.gz}"
+    w_warn "Please refer to ${_W_repository#*/} version ${_W_package_version} release notes... See: https://gitlab.com/${_W_repository}/-/releases/v${_W_package_version}"
+    w_warn "Please refer to current dxvk base graphics driver requirements... See: https://github.com/doitsujin/dxvk/wiki/Driver-support" # The async fork lacks a wiki, and upstream's is most relevant anyway
+
+    if w_wine_version_in ",${_W_min_wine_version}" ; then
+        # shellcheck disable=SC2140
+        w_warn "${_W_repository#*/} ${_W_package_version} does not support wine version ${_wine_version_stripped} . "\
+            "${_W_repository#*/} ${_W_package_version} requires wine version ${_W_min_wine_version} (or newer). "\
+            "Vulkan ${_W_min_vulkan_version} API (or newer) support is recommended."
+    fi
+
+    if [ "${_W_package_archive##*.}" = "zip" ]; then
+        w_try_unzip "${W_TMP}" "${W_CACHE}/${W_PACKAGE}/${_W_package_archive}"
+    else
+        w_try tar -C "${W_TMP}" -zxf "${W_CACHE}/${W_PACKAGE}/${_W_package_archive}"
+    fi
+
+    for _W_dll in ${_W_dll_overrides}; do
+        w_try mv "${W_TMP}/${_W_package_dir}/x32/${_W_dll}.dll" "${W_SYSTEM32_DLLS}/"
+    done
+
+    if test "${W_ARCH}" = "win64"; then
+        for _W_dll in ${_W_dll_overrides}; do
+            w_try mv "${W_TMP}/${_W_package_dir}/x64/${_W_dll}.dll" "${W_SYSTEM64_DLLS}/"
+        done
+    fi
+    # shellcheck disable=SC2086
+    w_override_dlls native ${_W_dll_overrides}
+
+    unset _W_dll _W_dll_overrides _W_invalid_overrides _W_min_vulkan_version _W_min_wine_version \
+        _W_package_archive _W_package_dir _W_package_version \
+        _W_repository _W_supported_overrides
+}
+
+#----------------------------------------------------------------
+
+w_metadata dxvk_async dlls \
+    title="DXVK with Async and GPL patches [USE AT OWN RISK IN GAMES WITH ANTICHEAT] (latest)" \
+    publisher="Ph42oN" \
+    year="2025" \
+    media="download" \
+    installed_file1="${W_SYSTEM32_DLLS_WIN}/d3d8.dll" \
+    installed_file2="${W_SYSTEM32_DLLS_WIN}/d3d9.dll" \
+    installed_file3="${W_SYSTEM32_DLLS_WIN}/d3d10core.dll" \
+    installed_file4="${W_SYSTEM32_DLLS_WIN}/d3d11.dll" \
+    installed_file5="${W_SYSTEM32_DLLS_WIN}/dxgi.dll"
+
+load_dxvk_async()
+{
+    # https://gitlab.com/Ph42oN/dxvk-gplasync
+    _W_dxvk_async_version="$(w_get_gitlab_latest_release Ph42oN dxvk-gplasync)"
+    _W_dxvk_async_version="${_W_dxvk_async_version#v}"
+    w_linkcheck_ignore=1 w_download "https://gitlab.com/Ph42oN/dxvk-gplasync/-/raw/main/releases/dxvk-gplasync-v${_W_dxvk_async_version}.tar.gz"
+    helper_dxvk_async "dxvk-gplasync-v${_W_dxvk_async_version}.tar.gz" "${_W_dxvk_async_version}" "7.1" "1.3.204" "dxgi,d3d8,d3d9,d3d10core,d3d11"
+    unset _W_dxvk_async_version
+}
+
+#----------------------------------------------------------------
+
 # $1 - dxvk-nvapi archive name (required)
 # $2 - minimum Wine version (required)
 # $3 - nvapi,[nvapi64] (required)
@@ -9787,7 +10032,7 @@ load_dsound()
 
     # Don't try to register native dsound; it doesn't export DllRegisterServer().
     #w_try_regsvr32 dsound.dll
-    w_override_dlls native dsound
+    w_override_dlls native,builtin dsound
 }
 
 #----------------------------------------------------------------
@@ -12734,7 +12979,7 @@ load_vcrun2003()
 {
     # Sadly, I know of no Microsoft URL for these
     # winetricks-test can't handle ${file1} in url since it does a raw parsing :/
-    w_download https://sourceforge.net/projects/bzflag/files/bzedit%20win32/1.6.5/BZEditW32_1.6.5.exe 84d1bda5dbf814742898a2e1c0e4bc793e9bc1fba4b7a93d59a7ef12bd0fd802
+    w_download https://downloads.sourceforge.net/project/bzflag/bzedit%20win32/1.6.5/BZEditW32_1.6.5.exe 84d1bda5dbf814742898a2e1c0e4bc793e9bc1fba4b7a93d59a7ef12bd0fd802
 
     w_try_7z "${W_SYSTEM32_DLLS}" "${W_CACHE}/vcrun2003/BZEditW32_1.6.5.exe" "mfc71.dll" "msvcp71.dll" "msvcr71.dll" -y
 }
@@ -12749,7 +12994,7 @@ w_metadata mfc71 dlls \
 
 load_mfc71()
 {
-    w_download_to vcrun2003 https://sourceforge.net/projects/bzflag/files/bzedit%20win32/1.6.5/BZEditW32_1.6.5.exe 84d1bda5dbf814742898a2e1c0e4bc793e9bc1fba4b7a93d59a7ef12bd0fd802
+    w_download_to vcrun2003 https://downloads.sourceforge.net/project/bzflag/bzedit%20win32/1.6.5/BZEditW32_1.6.5.exe 84d1bda5dbf814742898a2e1c0e4bc793e9bc1fba4b7a93d59a7ef12bd0fd802
 
     w_try_7z "${W_SYSTEM32_DLLS}" "${W_CACHE}/vcrun2003/BZEditW32_1.6.5.exe" "mfc71.dll" -y
 }
@@ -15247,40 +15492,6 @@ load_emu8086()
 
 #----------------------------------------------------------------
 
-w_metadata ev3 apps \
-    title="Lego Mindstorms EV3 Home Edition" \
-    publisher="Lego" \
-    year="2014" \
-    media="download" \
-    file1="LMS-EV3-WIN32-ENUS-01-02-01-full-setup.exe" \
-    installed_exe1="${W_PROGRAMS_X86_WIN}/LEGO Software/LEGO MINDSTORMS EV3 Home Edition/MindstormsEV3.exe"
-
-load_ev3()
-{
-    if w_workaround_wine_bug 40192 "Installing vcrun2005 as Wine does not have MFC80.dll"; then
-        w_call vcrun2005
-    fi
-
-    if w_workaround_wine_bug 40193 "Installing IE8 as built-in Gecko is not sufficient"; then
-        w_call ie8
-    fi
-
-    w_call dotnet40
-
-    # 2016/03/22: LMS-EV3-WIN32-ENUS-01-02-01-full-setup.exe c47341f08242f0f6f01996530e7c93bda2d666747ada60ab93fa773a55d40a19
-
-    w_download http://esd.lego.com.edgesuite.net/digitaldelivery/mindstorms/6ecda7c2-1189-4816-b2dd-440e22d65814/public/LMS-EV3-WIN32-ENUS-01-02-01-full-setup.exe c47341f08242f0f6f01996530e7c93bda2d666747ada60ab93fa773a55d40a19
-
-    w_try_cd "${W_CACHE}"/"${W_PACKAGE}"
-    w_try "${WINE}" "${file1}" ${W_OPT_UNATTENDED:+/qb /AcceptLicenses yes}
-
-    if w_workaround_wine_bug 40729 "Setting override for urlmon.dll to native to avoid crash"; then
-        w_override_dlls native urlmon
-    fi
-}
-
-#----------------------------------------------------------------
-
 w_metadata firefox apps \
     title="Firefox 51.0" \
     publisher="Mozilla" \
@@ -17828,6 +18039,32 @@ w_metadata windowmanagerdecorated=n settings \
 
 #----------------------------------------------------------------
 
+w_metadata useegl=y settings \
+    title="Enable EGL (default)"
+w_metadata useegl=n settings \
+    title="Disable EGL, use GLX instead"
+
+load_useegl()
+{
+    case "$1" in
+        y) arg="Y";;
+        n) arg="N";;
+        *) w_die "illegal value $1 for UseEGL";;
+    esac
+
+    echo "Setting UseEGL to ${arg}"
+    cat > "${W_TMP}"/set-useegl.reg <<_EOF_
+REGEDIT4
+
+[HKEY_CURRENT_USER\\Software\\Wine\\X11 Driver]
+"UseEGL"="${arg}"
+
+_EOF_
+    w_try_regedit "${W_TMP}"/set-useegl.reg
+}
+
+#----------------------------------------------------------------
+
 w_metadata usetakefocus=y settings \
     title_bg="Включете UseTakeFocus" \
     title_cz="Aktivovat UseTakeFocus" \