Sync from development - prepare for v0.1.6.5

jackify/backend/handlers/menu_handler.py

@@ -152,8 +152,10 @@ class ModlistMenuHandler:
             self.path_handler = PathHandler()
             self.vdf_handler = VDFHandler()
             
-            # Determine Steam Deck status (already done by ConfigHandler, use it)
-            self.steamdeck = config_handler.settings.get('steamdeck', False)
+            # Determine Steam Deck status using centralized detection
+            from ..services.platform_detection_service import PlatformDetectionService
+            platform_service = PlatformDetectionService.get_instance()
+            self.steamdeck = platform_service.is_steamdeck
             
             # Create the resolution handler
             self.resolution_handler = ResolutionHandler()
@@ -178,7 +180,13 @@ class ModlistMenuHandler:
             self.logger.error(f"Error initializing ModlistMenuHandler: {e}")
             # Initialize with defaults/empty to prevent errors
             self.filesystem_handler = FileSystemHandler()
-            self.steamdeck = False
+            # Use centralized detection even in fallback
+            try:
+                from ..services.platform_detection_service import PlatformDetectionService
+                platform_service = PlatformDetectionService.get_instance()
+                self.steamdeck = platform_service.is_steamdeck
+            except:
+                self.steamdeck = False  # Final fallback
             self.modlist_handler = None
 
     def show_modlist_menu(self):

jackify/backend/handlers/modlist_handler.py

@@ -109,6 +109,12 @@ class ModlistHandler:
         self.logger = logging.getLogger(__name__)
         self.logger.propagate = False
         self.steamdeck = steamdeck
+
+        # DEBUG: Log ModlistHandler instantiation details for SD card path debugging
+        import traceback
+        caller_info = traceback.extract_stack()[-2]  # Get caller info
+        self.logger.debug(f"[SD_CARD_DEBUG] ModlistHandler created: id={id(self)}, steamdeck={steamdeck}")
+        self.logger.debug(f"[SD_CARD_DEBUG] Created from: {caller_info.filename}:{caller_info.lineno} in {caller_info.name}()")
         self.steam_path: Optional[Path] = None
         self.verbose = verbose # Store verbose flag
         self.mo2_path: Optional[Path] = None
@@ -321,13 +327,24 @@ class ModlistHandler:
         
         # Determine if modlist is on SD card (Steam Deck only)
         # On non-Steam Deck systems, /media mounts should use Z: drive, not D: drive
-        if (str(self.modlist_dir).startswith("/run/media") or str(self.modlist_dir).startswith("/media")) and self.steamdeck:
+        is_on_sdcard_path = str(self.modlist_dir).startswith("/run/media") or str(self.modlist_dir).startswith("/media")
+
+        # DEBUG: Log SD card detection logic
+        self.logger.debug(f"[SD_CARD_DEBUG] SD card detection for instance id={id(self)}:")
+        self.logger.debug(f"[SD_CARD_DEBUG] modlist_dir: {self.modlist_dir}")
+        self.logger.debug(f"[SD_CARD_DEBUG] is_on_sdcard_path: {is_on_sdcard_path}")
+        self.logger.debug(f"[SD_CARD_DEBUG] self.steamdeck: {self.steamdeck}")
+
+        if is_on_sdcard_path and self.steamdeck:
              self.modlist_sdcard = True
              self.logger.info("Modlist appears to be on an SD card (Steam Deck).")
+             self.logger.debug(f"[SD_CARD_DEBUG] Set modlist_sdcard=True")
         else:
              self.modlist_sdcard = False
-             if (str(self.modlist_dir).startswith("/run/media") or str(self.modlist_dir).startswith("/media")) and not self.steamdeck:
+             self.logger.debug(f"[SD_CARD_DEBUG] Set modlist_sdcard=False because: is_on_sdcard_path={is_on_sdcard_path} AND steamdeck={self.steamdeck}")
+             if is_on_sdcard_path and not self.steamdeck:
                  self.logger.info("Modlist on /media mount detected on non-Steam Deck system - using Z: drive mapping.")
+                 self.logger.debug("[SD_CARD_DEBUG] This is the ROOT CAUSE - SD card path but steamdeck=False!")
 
         # Find and set compatdata path now that we have appid
         # Ensure PathHandler is available (should be initialized in __init__)
@@ -812,6 +829,15 @@ class ModlistHandler:
         # Conditionally update binary and working directory paths
         # Skip for jackify-engine workflows since paths are already correct
         # Exception: Always run for SD card installs to fix Z:/run/media/... to D:/... paths
+
+        # DEBUG: Add comprehensive logging to identify Steam Deck SD card path manipulation issues
+        engine_installed = getattr(self, 'engine_installed', False)
+        self.logger.debug(f"[SD_CARD_DEBUG] ModlistHandler instance: id={id(self)}")
+        self.logger.debug(f"[SD_CARD_DEBUG] engine_installed: {engine_installed}")
+        self.logger.debug(f"[SD_CARD_DEBUG] modlist_sdcard: {self.modlist_sdcard}")
+        self.logger.debug(f"[SD_CARD_DEBUG] steamdeck parameter passed to constructor: {getattr(self, 'steamdeck', 'NOT_SET')}")
+        self.logger.debug(f"[SD_CARD_DEBUG] Path manipulation condition: not {engine_installed} or {self.modlist_sdcard} = {not engine_installed or self.modlist_sdcard}")
+
         if not getattr(self, 'engine_installed', False) or self.modlist_sdcard:
             # Convert steamapps/common path to library root path
             steam_libraries = None
@@ -831,7 +857,8 @@ class ModlistHandler:
                 print("Error: Failed to update binary and working directory paths in ModOrganizer.ini.")
                 return False  # Abort on failure
         else:
-            self.logger.debug("Skipping path manipulation - jackify-engine already set correct paths in ModOrganizer.ini")
+            self.logger.debug("[SD_CARD_DEBUG] Skipping path manipulation - jackify-engine already set correct paths in ModOrganizer.ini")
+            self.logger.debug(f"[SD_CARD_DEBUG] SKIPPED because: engine_installed={engine_installed} and modlist_sdcard={self.modlist_sdcard}")
         self.logger.info("Step 8: Updating ModOrganizer.ini paths... Done")
 
         # Step 9: Update Resolution Settings (if applicable)

jackify/backend/handlers/path_handler.py

@@ -777,17 +777,35 @@ class PathHandler:
             
             # Extract existing gamePath to use as source of truth for vanilla game location
             existing_game_path = None
-            for line in lines:
+            gamepath_line_index = -1
+            for i, line in enumerate(lines):
                 if re.match(r'^\s*gamepath\s*=.*@ByteArray\(([^)]+)\)', line, re.IGNORECASE):
                     match = re.search(r'@ByteArray\(([^)]+)\)', line)
                     if match:
                         raw_path = match.group(1)
+                        gamepath_line_index = i
                         # Convert Windows path back to Linux path
                         if raw_path.startswith(('Z:', 'D:')):
                             linux_path = raw_path[2:].replace('\\\\', '/').replace('\\', '/')
                             existing_game_path = linux_path
                             logger.debug(f"Extracted existing gamePath: {existing_game_path}")
                             break
+
+            # Special handling for gamePath in three-true scenario (engine_installed + steamdeck + sdcard)
+            if modlist_sdcard and existing_game_path and existing_game_path.startswith('/run/media') and gamepath_line_index != -1:
+                # Simple manual stripping of /run/media/deck/UUID pattern for SD card paths
+                # Match /run/media/deck/[UUID]/Games/... and extract just /Games/...
+                sdcard_pattern = r'^/run/media/deck/[^/]+(/Games/.*)$'
+                match = re.match(sdcard_pattern, existing_game_path)
+                if match:
+                    stripped_path = match.group(1)  # Just the /Games/... part
+                    new_gamepath_value = f"D:\\\\{stripped_path.replace('/', '\\\\')}"
+                    new_gamepath_line = f"gamePath = @ByteArray({new_gamepath_value})\n"
+
+                    logger.info(f"Updating gamePath for SD card: {lines[gamepath_line_index].strip()} -> {new_gamepath_line.strip()}")
+                    lines[gamepath_line_index] = new_gamepath_line
+                else:
+                    logger.warning(f"SD card path doesn't match expected pattern: {existing_game_path}")
             
             game_path_updated = False
             binary_paths_updated = 0

jackify/backend/handlers/protontricks_handler.py

@@ -149,9 +149,29 @@ class ProtontricksHandler:
                 should_install = True
             else:
                 try:
-                    response = input("Protontricks not found. Install the Flatpak version? (Y/n): ").lower()
-                    if response == 'y' or response == '':
+                    print("\nProtontricks not found. Choose installation method:")
+                    print("1. Install via Flatpak (automatic)")
+                    print("2. Install via native package manager (manual)")
+                    print("3. Skip (Use bundled winetricks instead)")
+                    choice = input("Enter choice (1/2/3): ").strip()
+
+                    if choice == '1' or choice == '':
                         should_install = True
+                    elif choice == '2':
+                        print("\nTo install protontricks via your system package manager:")
+                        print("• Ubuntu/Debian: sudo apt install protontricks")
+                        print("• Fedora: sudo dnf install protontricks")
+                        print("• Arch Linux: sudo pacman -S protontricks")
+                        print("• openSUSE: sudo zypper install protontricks")
+                        print("\nAfter installation, please rerun Jackify.")
+                        return False
+                    elif choice == '3':
+                        print("Skipping protontricks installation. Will use bundled winetricks for component installation.")
+                        logger.info("User chose to skip protontricks and use winetricks fallback")
+                        return False
+                    else:
+                        print("Invalid choice. Installation cancelled.")
+                        return False
                 except KeyboardInterrupt:
                      print("\nInstallation cancelled.")
                      return False

jackify/backend/handlers/wine_utils.py

@@ -668,7 +668,10 @@ class WineUtils:
         # Add standard compatibility tool locations (covers edge cases like Flatpak)
         compatibility_paths.extend([
             Path.home() / ".steam/root/compatibilitytools.d",
-            Path.home() / ".var/app/com.valvesoftware.Steam/.local/share/Steam/compatibilitytools.d"
+            Path.home() / ".var/app/com.valvesoftware.Steam/.local/share/Steam/compatibilitytools.d",
+            # Flatpak GE-Proton extension paths
+            Path.home() / ".var/app/com.valvesoftware.Steam.CompatibilityTool.Proton-GE/.local/share/Steam/compatibilitytools.d",
+            Path.home() / ".var/app/com.valvesoftware.Steam/.local/share/Steam/compatibilitytools.d/GE-Proton"
         ])
         # Special handling for Proton 9: try all possible directory names
         if proton_version.strip().startswith("Proton 9"):
@@ -822,7 +825,12 @@ class WineUtils:
         """
         compat_paths = [
             Path.home() / ".steam/steam/compatibilitytools.d",
-            Path.home() / ".local/share/Steam/compatibilitytools.d"
+            Path.home() / ".local/share/Steam/compatibilitytools.d",
+            Path.home() / ".steam/root/compatibilitytools.d",
+            Path.home() / ".var/app/com.valvesoftware.Steam/.local/share/Steam/compatibilitytools.d",
+            # Flatpak GE-Proton extension paths
+            Path.home() / ".var/app/com.valvesoftware.Steam.CompatibilityTool.Proton-GE/.local/share/Steam/compatibilitytools.d",
+            Path.home() / ".var/app/com.valvesoftware.Steam/.local/share/Steam/compatibilitytools.d/GE-Proton"
         ]
 
         # Return only existing paths

jackify/backend/services/automated_prefix_service.py

@@ -2697,9 +2697,18 @@ echo Prefix creation complete.
             # Run proton run wineboot -u to initialize the prefix
             cmd = [str(proton_path), 'run', 'wineboot', '-u']
             logger.info(f"Running: {' '.join(cmd)}")
-            
+
+            # Adjust timeout for SD card installations on Steam Deck (slower I/O)
+            from ..services.platform_detection_service import PlatformDetectionService
+            platform_service = PlatformDetectionService.get_instance()
+            is_steamdeck_sdcard = (platform_service.is_steamdeck and
+                                 str(proton_path).startswith('/run/media/'))
+            timeout = 180 if is_steamdeck_sdcard else 60
+            if is_steamdeck_sdcard:
+                logger.info(f"Using extended timeout ({timeout}s) for Steam Deck SD card Proton installation")
+
             # Use jackify-engine's approach: UseShellExecute=false, CreateNoWindow=true equivalent
-            result = subprocess.run(cmd, env=env, capture_output=True, text=True, timeout=60,
+            result = subprocess.run(cmd, env=env, capture_output=True, text=True, timeout=timeout,
                                   shell=False, creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
             logger.info(f"Proton exit code: {result.returncode}")
             

jackify/backend/services/modlist_service.py

@@ -34,8 +34,10 @@ class ModlistService:
         """Lazy initialization of modlist handler."""
         if self._modlist_handler is None:
             from ..handlers.modlist_handler import ModlistHandler
-            # Initialize with proper dependencies
-            self._modlist_handler = ModlistHandler()
+            from ..services.platform_detection_service import PlatformDetectionService
+            # Initialize with proper dependencies and centralized Steam Deck detection
+            platform_service = PlatformDetectionService.get_instance()
+            self._modlist_handler = ModlistHandler(steamdeck=platform_service.is_steamdeck)
         return self._modlist_handler
     
     def _get_wabbajack_handler(self):

jackify/backend/services/platform_detection_service.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""
+Platform Detection Service
+
+Centralizes platform detection logic (Steam Deck, etc.) to be performed once at application startup
+and shared across all components.
+"""
+
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class PlatformDetectionService:
+    """
+    Service for detecting platform-specific information once at startup
+    """
+
+    _instance = None
+    _is_steamdeck = None
+
+    def __new__(cls):
+        """Singleton pattern to ensure only one instance"""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        """Initialize platform detection if not already done"""
+        if self._is_steamdeck is None:
+            self._detect_platform()
+
+    def _detect_platform(self):
+        """Perform platform detection once"""
+        logger.debug("Performing platform detection...")
+
+        # Steam Deck detection
+        self._is_steamdeck = False
+        try:
+            if os.path.exists('/etc/os-release'):
+                with open('/etc/os-release', 'r') as f:
+                    content = f.read().lower()
+                    if 'steamdeck' in content:
+                        self._is_steamdeck = True
+                        logger.info("Steam Deck platform detected")
+                    else:
+                        logger.debug("Non-Steam Deck Linux platform detected")
+            else:
+                logger.debug("No /etc/os-release found - assuming non-Steam Deck platform")
+        except Exception as e:
+            logger.warning(f"Error detecting Steam Deck platform: {e}")
+            self._is_steamdeck = False
+
+        logger.debug(f"Platform detection complete: is_steamdeck={self._is_steamdeck}")
+
+    @property
+    def is_steamdeck(self) -> bool:
+        """Get Steam Deck detection result"""
+        if self._is_steamdeck is None:
+            self._detect_platform()
+        return self._is_steamdeck
+
+    @classmethod
+    def get_instance(cls):
+        """Get the singleton instance"""
+        return cls()