Sync from development - prepare for v0.1.5.3

jackify/backend/handlers/winetricks_handler.py

@@ -257,10 +257,10 @@ class WinetricksHandler:
         components_to_install = self._reorder_components_for_installation(all_components)
         self.logger.info(f"WINEPREFIX: {wineprefix}, Game: {game_var}, Ordered Components: {components_to_install}")
 
-        # Install components separately if dotnet40 is present (mimics protontricks behavior)
+        # Hybrid approach: Use protontricks for dotnet40 only, winetricks for everything else
         if "dotnet40" in components_to_install:
-            self.logger.info("dotnet40 detected - installing components separately like protontricks")
-            return self._install_components_separately(components_to_install, wineprefix, wine_binary, env)
+            self.logger.info("dotnet40 detected - using hybrid approach: protontricks for dotnet40, winetricks for others")
+            return self._install_components_hybrid_approach(components_to_install, wineprefix, game_var)
 
         # For non-dotnet40 installations, install all components together (faster)
         max_attempts = 3
@@ -482,6 +482,225 @@ class WinetricksHandler:
         self.logger.info("✓ All components installed successfully using separate sessions")
         return True
 
+    def _install_components_hybrid_approach(self, components: list, wineprefix: str, game_var: str) -> bool:
+        """
+        Hybrid approach: Install dotnet40 with protontricks (known to work),
+        then install remaining components with winetricks (faster for other components).
+
+        Args:
+            components: List of all components to install
+            wineprefix: Wine prefix path
+            game_var: Game variable for AppID detection
+
+        Returns:
+            bool: True if all installations succeeded, False otherwise
+        """
+        self.logger.info("Starting hybrid installation approach")
+
+        # Separate dotnet40 (protontricks) from other components (winetricks)
+        protontricks_components = [comp for comp in components if comp == "dotnet40"]
+        other_components = [comp for comp in components if comp != "dotnet40"]
+
+        self.logger.info(f"Protontricks components: {protontricks_components}")
+        self.logger.info(f"Other components: {other_components}")
+
+        # Step 1: Install dotnet40 with protontricks if present
+        if protontricks_components:
+            self.logger.info(f"Installing {protontricks_components} using protontricks...")
+            if not self._install_dotnet40_with_protontricks(wineprefix, game_var):
+                self.logger.error(f"Failed to install {protontricks_components} with protontricks")
+                return False
+            self.logger.info(f"✓ {protontricks_components} installation completed successfully with protontricks")
+
+        # Step 2: Install remaining components with winetricks if any
+        if other_components:
+            self.logger.info(f"Installing remaining components with winetricks: {other_components}")
+
+            # Use existing winetricks logic for other components
+            env = self._prepare_winetricks_environment(wineprefix)
+            if not env:
+                return False
+
+            return self._install_components_with_winetricks(other_components, wineprefix, env)
+
+        self.logger.info("✓ Hybrid component installation completed successfully")
+        return True
+
+    def _install_dotnet40_with_protontricks(self, wineprefix: str, game_var: str) -> bool:
+        """
+        Install dotnet40 using protontricks (known to work reliably).
+
+        Args:
+            wineprefix: Wine prefix path
+            game_var: Game variable for AppID detection
+
+        Returns:
+            bool: True if installation succeeded, False otherwise
+        """
+        try:
+            # Extract AppID from wineprefix path (e.g., /path/to/compatdata/123456789/pfx -> 123456789)
+            appid = None
+            if 'compatdata' in wineprefix:
+                # Standard Steam compatdata structure
+                path_parts = Path(wineprefix).parts
+                for i, part in enumerate(path_parts):
+                    if part == 'compatdata' and i + 1 < len(path_parts):
+                        potential_appid = path_parts[i + 1]
+                        if potential_appid.isdigit():
+                            appid = potential_appid
+                            break
+
+            if not appid:
+                self.logger.error(f"Could not extract AppID from wineprefix path: {wineprefix}")
+                return False
+
+            self.logger.info(f"Using AppID {appid} for protontricks dotnet40 installation")
+
+            # Import and use protontricks handler
+            from .protontricks_handler import ProtontricksHandler
+
+            # Determine if we're on Steam Deck (for protontricks handler)
+            steamdeck = os.path.exists('/home/deck')
+
+            protontricks_handler = ProtontricksHandler(steamdeck=steamdeck, logger=self.logger)
+
+            # Detect protontricks availability
+            if not protontricks_handler.detect_protontricks():
+                self.logger.error("Protontricks not available for dotnet40 installation")
+                return False
+
+            # Install dotnet40 using protontricks
+            success = protontricks_handler.install_wine_components(appid, game_var, ["dotnet40"])
+
+            if success:
+                self.logger.info("✓ dotnet40 installed successfully with protontricks")
+                return True
+            else:
+                self.logger.error("✗ dotnet40 installation failed with protontricks")
+                return False
+
+        except Exception as e:
+            self.logger.error(f"Error installing dotnet40 with protontricks: {e}", exc_info=True)
+            return False
+
+    def _prepare_winetricks_environment(self, wineprefix: str) -> Optional[dict]:
+        """
+        Prepare the environment for winetricks installation.
+        This reuses the existing environment setup logic.
+
+        Args:
+            wineprefix: Wine prefix path
+
+        Returns:
+            dict: Environment variables for winetricks, or None if failed
+        """
+        try:
+            env = os.environ.copy()
+            env['WINEDEBUG'] = '-all'
+            env['WINEPREFIX'] = wineprefix
+            env['WINETRICKS_GUI'] = 'none'
+
+            # Existing Proton detection logic
+            from ..handlers.config_handler import ConfigHandler
+            from ..handlers.wine_utils import WineUtils
+
+            config = ConfigHandler()
+            user_proton_path = config.get_proton_path()
+
+            wine_binary = None
+            if user_proton_path != 'auto':
+                if os.path.exists(user_proton_path):
+                    resolved_proton_path = os.path.realpath(user_proton_path)
+                    valve_proton_wine = os.path.join(resolved_proton_path, 'dist', 'bin', 'wine')
+                    ge_proton_wine = os.path.join(resolved_proton_path, 'files', 'bin', 'wine')
+
+                    if os.path.exists(valve_proton_wine):
+                        wine_binary = valve_proton_wine
+                    elif os.path.exists(ge_proton_wine):
+                        wine_binary = ge_proton_wine
+
+            if not wine_binary:
+                best_proton = WineUtils.select_best_proton()
+                if best_proton:
+                    wine_binary = WineUtils.find_proton_binary(best_proton['name'])
+
+            if not wine_binary or not (os.path.exists(wine_binary) and os.access(wine_binary, os.X_OK)):
+                self.logger.error(f"Cannot prepare winetricks environment: No compatible Proton found")
+                return None
+
+            env['WINE'] = str(wine_binary)
+
+            # Set up protontricks-compatible environment (existing logic)
+            proton_dist_path = os.path.dirname(os.path.dirname(wine_binary))
+            env['WINEDLLPATH'] = f"{proton_dist_path}/lib64/wine:{proton_dist_path}/lib/wine"
+            env['PATH'] = f"{proton_dist_path}/bin:{env.get('PATH', '')}"
+
+            # Existing DLL overrides
+            dll_overrides = {
+                "beclient": "b,n", "beclient_x64": "b,n", "dxgi": "n", "d3d9": "n",
+                "d3d10core": "n", "d3d11": "n", "d3d12": "n", "d3d12core": "n",
+                "nvapi": "n", "nvapi64": "n", "nvofapi64": "n", "nvcuda": "b"
+            }
+
+            env['WINEDLLOVERRIDES'] = ';'.join(f"{name}={setting}" for name, setting in dll_overrides.items())
+            env['WINE_LARGE_ADDRESS_AWARE'] = '1'
+            env['DXVK_ENABLE_NVAPI'] = '1'
+
+            # Set up winetricks cache
+            from jackify.shared.paths import get_jackify_data_dir
+            jackify_cache_dir = get_jackify_data_dir() / 'winetricks_cache'
+            jackify_cache_dir.mkdir(parents=True, exist_ok=True)
+            env['WINETRICKS_CACHE'] = str(jackify_cache_dir)
+
+            return env
+
+        except Exception as e:
+            self.logger.error(f"Failed to prepare winetricks environment: {e}")
+            return None
+
+    def _install_components_with_winetricks(self, components: list, wineprefix: str, env: dict) -> bool:
+        """
+        Install components using winetricks with the prepared environment.
+
+        Args:
+            components: List of components to install
+            wineprefix: Wine prefix path
+            env: Prepared environment variables
+
+        Returns:
+            bool: True if installation succeeded, False otherwise
+        """
+        max_attempts = 3
+        for attempt in range(1, max_attempts + 1):
+            if attempt > 1:
+                self.logger.warning(f"Retrying winetricks installation (attempt {attempt}/{max_attempts})")
+                self._cleanup_wine_processes()
+
+            try:
+                cmd = [self.winetricks_path, '--unattended'] + components
+                self.logger.debug(f"Running winetricks: {' '.join(cmd)}")
+
+                result = subprocess.run(
+                    cmd,
+                    env=env,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    timeout=600
+                )
+
+                if result.returncode == 0:
+                    self.logger.info(f"✓ Winetricks components installed successfully: {components}")
+                    return True
+                else:
+                    self.logger.error(f"✗ Winetricks failed (attempt {attempt}): {result.stderr.strip()}")
+
+            except Exception as e:
+                self.logger.error(f"Error during winetricks run (attempt {attempt}): {e}")
+
+        self.logger.error(f"Failed to install components with winetricks after {max_attempts} attempts")
+        return False
+
     def _cleanup_wine_processes(self):
         """
         Internal method to clean up wine processes during component installation