instance_handler.py changes:

parent_path Parameter: Now takes parent_path as input, which is the BlueStacks Engine directory, ensuring it operates on Android.bstk.in correctly.
Robust Type Modification: More robustly handles cases where "Readonly" or "Normal" might not already exist in the line. It now appends Type="{new_mode}" if no type is found.
File Found Flag: Added file_found_in_bstk flag to avoid rewriting the BSTK file if no target file names were found within it, improving efficiency.
Clearer Logging: Improved logging messages for different scenarios (modification, appending, no changes, errors).

is_instance_readonly Improvements:
Parent Path Determination: Now determines the parent_path from the provided instance_path to correctly locate BSTK files in the Engine directory.
File Existence Check: Checks if the BSTK file exists before trying to open it, and logs a warning if not found, skipping to the next file instead of causing an error for the whole process.
More Robust Path Handling: Uses os.path.join for path construction.
terminate_bluestacks Function (New):
Added a function to terminate common BlueStacks processes using psutil. This aligns with the main GUI script's requirements and allows for controlled termination.
Includes logging for successful terminations, timeouts, and errors during process termination.

Enhancements in registry_handler.py:
Clearer Logging: Improved log messages to include the full registry path (HKLM\\SOFTWARE\\BlueStacks_nxt) for better context.
Informational Success Log: Changed the success log from debug to info level to highlight successful registry key retrieval.
PermissionError Handling: Added specific handling for PermissionError, suggesting running as administrator in the error message, which is a common issue with registry access.
Debug Exception Details: Added logger.debug("Full exception details:", exc_info=True) in except blocks to log full exception tracebacks at DEBUG level for more detailed debugging when needed.

Enhancements in config_handler.py:
Setting Appending: If the setting is not found in the config file during modify_config_file, it now appends the setting to the end of the file. This is useful if a setting is missing.
Clearer Logging: Improved log messages, especially differentiating between updating an existing setting and appending a new one. Success logs are now at info level.
Debug Exception Details: Added logger.debug("Full exception details:", exc_info=True) in except blocks to log full exception tracebacks at DEBUG level.
Informational Root Status Logs: Changed the log level for root status checks to info to provide more visible feedback on root status. Also added info log when setting is not found, and assuming disabled, which is important to know.

Author: RobThePCGuy

README.md

@@ -5,7 +5,7 @@
 > [!IMPORTANT]
 > This is an unofficial modification for the BlueStacks Android emulator. If you encounter any issues, please open a GitHub issue.
 >
-> *As of January 9, 2025, this tool works as expected. However, it's important to note that this method is not compatible with Nougat instances. This README will be updated if that changes.*
+> *As of February 16th, 2025, this tool works as expected. However, it's important to note that this method is not compatible with Nougat instances. This README will be updated if that changes.*
 
 This GUI streamlines the configuration process outlined in my guide to [rooting BlueStacks](https://github.com/RobThePCGuy/Root-Bluestacks-with-Kitsune-Mask/). While it simplifies certain steps, **both repositories** are still required for complete rooting because the linked repository contains the core rooting process. This tool lets you toggle root access and enable read/write permissions for the filesystem within the `bluestacks.conf` file of selected BlueStacks instances, providing a user-friendly alternative to manual editing.
 

config_handler.py

@@ -4,7 +4,8 @@
 
 # Initialize logger for config_handler module
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO) # Or desired level, if not set at root logger
+logger.setLevel(logging.INFO)  # Or desired level, if not set at root logger
+
 
 def modify_config_file(config_path, setting, new_value):
     """Modifies a setting in bluestacks.conf.
@@ -16,34 +17,45 @@ def modify_config_file(config_path, setting, new_value):
     """
     changed = False
     try:
-        logger.debug(f"Attempting to modify setting '{setting}' in config file: {config_path}")
+        logger.debug(f"Attempting to modify setting '{setting}' to '{new_value}' in config file: {config_path}")
         # Open with encoding='utf-8' for reading
         with open(config_path, "r", encoding='utf-8') as f:
             lines = f.readlines()
 
+        updated_lines = []
+        setting_found = False # Flag to check if setting was found
+        for line in lines:
+            if line.startswith(f"{setting}="):
+                logger.debug(f"Found setting '{setting}', replacing value. Original line: '{line.strip()}'")
+                updated_lines.append(f"{setting}=\"{new_value}\"\n")
+                changed = True
+                setting_found = True
+                logger.info(f"Setting '{setting}' updated to '{new_value}' in {config_path}") # Info level for successful modification
+            else:
+                updated_lines.append(line)
+
+        if not setting_found: # Setting not found, append it to the end
+            updated_lines.append(f"{setting}=\"{new_value}\"\n")
+            changed = True
+            logger.info(f"Setting '{setting}' not found, appending to {config_path} with value '{new_value}'.")
+
+
         # Open with encoding='utf-8' for writing
         with open(config_path, "w", encoding='utf-8') as f:
-            for line in lines:
-                if line.startswith(f"{setting}="):
-                    logger.debug(f"Found setting '{setting}', replacing value. Original line: '{line.strip()}'")
-                    f.write(f"{setting}=\"{new_value}\"\n")
-                    changed = True
-                    logger.debug(f"Setting '{setting}' updated to '{new_value}'")
-                else:
-                    f.write(line)
+            f.writelines(updated_lines)
+
 
-        if changed:
-            logger.info(f"Successfully updated setting '{setting}' to '{new_value}' in {config_path}")
-        else:
-            logger.info(f"Setting '{setting}' not found in {config_path}, no changes made.")
     except FileNotFoundError:
         error_msg = f"Config file not found at {config_path}"
         logger.error(error_msg)
-        print(error_msg) # Keep print for user feedback if needed in CLI context, but logging is primary
+        print(error_msg)  # Keep print for user feedback if needed in CLI context, but logging is primary
+        logger.debug("Full exception details:", exc_info=True)
     except Exception as e:
         error_msg = f"Error modifying configuration file {config_path}: {e}"
-        logger.exception(error_msg) # Log full exception traceback
-        print(error_msg) # Keep print for user feedback
+        logger.exception(error_msg)  # Log full exception traceback
+        print(error_msg)  # Keep print for user feedback
+        logger.debug("Full exception details:", exc_info=True)
+
 
 
 def is_root_enabled(config_path, instance_name):
@@ -58,23 +70,25 @@ def is_root_enabled(config_path, instance_name):
     """
     try:
         setting_key = f"bst.instance.{instance_name}.enable_root_access="
-        logger.debug(f"Checking root status for instance '{instance_name}' in {config_path}")
+        logger.debug(f"Checking root status for instance '{instance_name}' in {config_path}, setting key: '{setting_key}'")
         # Open with encoding='utf-8' for reading
         with open(config_path, "r", encoding='utf-8') as f:
             for line in f:
                 if line.startswith(setting_key):
                     is_enabled = line.strip().endswith("=\"1\"")
-                    logger.debug(f"Root status for instance '{instance_name}': {'Enabled' if is_enabled else 'Disabled'}")
+                    logger.info(f"Root status for instance '{instance_name}': {'Enabled' if is_enabled else 'Disabled'} in {config_path}") # Info level for root status
                     return is_enabled
-        logger.debug(f"Root setting '{setting_key}' not found for instance '{instance_name}' in {config_path}. Assuming root is disabled.")
-        return False # Setting not found, assume root is disabled
+        logger.info(f"Root setting '{setting_key}' not found for instance '{instance_name}' in {config_path}. Assuming root is disabled.") # Info level for not found, but assuming disabled is important info
+        return False  # Setting not found, assume root is disabled
     except FileNotFoundError:
         error_msg = f"Config file not found at {config_path}"
         logger.error(error_msg)
         print(error_msg)
+        logger.debug("Full exception details:", exc_info=True)
         return False
     except Exception as e:
         error_msg = f"Error reading configuration file {config_path}: {e}"
         logger.exception(error_msg)
         print(error_msg)
-        return False
+        logger.debug("Full exception details:", exc_info=True)
+        return False

instance_handler.py

@@ -1,108 +1,168 @@
 import os
 import glob
 import logging
+import psutil  # Import psutil for process termination
 
 # Initialize logger for instance_handler module
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO) # Or desired level, if not set at root logger
+logger.setLevel(logging.INFO)  # Or desired level, if not set at root logger
 
 
-def modify_instance_files(instance_path, file_names, new_type):
-    """Modifies file types in .bstk files to toggle R/W status, and logs changes in detail.
+def modify_instance_files(engine_path, instance_path, file_names, new_mode):
+    """Modifies file types in .bstk files to toggle R/W status.
+
+    Operates on Android.bstk.in in the engine_path and instance .bstk files in instance_path.
 
     Args:
-        instance_path (str): Path to the BlueStacks instance directory.
-        file_names (list): List of file names to modify within the .bstk files.
-        new_type (str): The new file type to set ("Normal" or "Readonly").
+        engine_path (str): Path to the BlueStacks Engine directory (e.g., C:\ProgramData\BlueStacks_nxt\Engine\Rvc64_4).
+        instance_path (str): Path to the BlueStacks instance directory (e.g., ...\instance_0).
+                                 This might be the same as engine_path for the master instance.
+        file_names (list): List of file names to modify within the .bstk files (e.g., [FASTBOOT_VDI, ROOT_VHD]).
+        new_mode (str): The new file type to set ("Normal" or "Readonly").
     """
-    bstk_files = ["Android.bstk.in"]
-    instance_bstk_files = glob.glob(os.path.join(instance_path, "*.bstk"))
-
-    if not instance_bstk_files:
-        error_msg = f"Error: No .bstk file found in instance path: {instance_path}"
+    android_bstk_in_path = os.path.join(engine_path, "Android.bstk.in") # Android.bstk.in is always in engine_path
+    instance_bstk_files_glob = os.path.join(instance_path, "*.bstk") # Instance .bstk files are in instance_path
+    instance_bstk_files = glob.glob(instance_bstk_files_glob)
+
+    bstk_files = []
+    if os.path.exists(android_bstk_in_path):
+        bstk_files.append("Android.bstk.in") # Add master Android.bstk.in if it exists
+    else:
+        error_msg = f"Error: Android.bstk.in not found in engine path: {engine_path}"
         logger.error(error_msg)
-        print(error_msg)
+        print(error_msg)  # Keep print for immediate feedback
         return
 
-    bstk_files.append(os.path.basename(instance_bstk_files[0])) # Take the first one found
+    if instance_bstk_files:
+        bstk_files.extend([os.path.basename(f) for f in instance_bstk_files]) # Add instance specific .bstk files
 
-    logger.debug(f"Modifying instance files in path: {instance_path}, BSTK files: {bstk_files}, Target files: {file_names}, New type: {new_type}")
+    logger.debug(f"Modifying instance files in engine path: {engine_path}, instance path: {instance_path}, BSTK files: {bstk_files}, Target files: {file_names}, New mode: {new_mode}")
 
     for bstk_file in bstk_files:
-        bstk_path = os.path.join(instance_path, bstk_file)
-        changed_entries = []  # Store (filename, old_value, new_value)
+        if bstk_file == "Android.bstk.in":
+            current_bstk_path = os.path.join(engine_path, bstk_file) # Path for master Android.bstk.in
+        else:
+            current_bstk_path = os.path.join(instance_path, bstk_file) # Path for instance .bstk files
+
+        changed_entries = []
 
         try:
-            logger.debug(f"Processing BSTK file: {bstk_path}")
-            with open(bstk_path, "r") as f:
+            logger.debug(f"Processing BSTK file: {current_bstk_path}")
+            with open(current_bstk_path, "r") as f:
                 content = f.readlines()
 
-            with open(bstk_path, "w") as f:
-                for line in content:
-                    # Check if any target file_name is mentioned in this line
-                    matched_file_name = next((fn for fn in file_names if fn in line), None)
-                    if matched_file_name:
-                        if "Readonly" in line:
-                            old_value = "Readonly"
-                            line = line.replace("Readonly", new_type)
-                            changed_entries.append((matched_file_name, old_value, new_type))
-                            logger.debug(f"Modified line for file '{matched_file_name}': from 'Readonly' to '{new_type}'")
-                        elif "Normal" in line:
-                            old_value = "Normal"
-                            line = line.replace("Normal", new_type)
-                            changed_entries.append((matched_file_name, old_value, new_type))
-                            logger.debug(f"Modified line for file '{matched_file_name}': from 'Normal' to '{new_type}'")
-                    f.write(line)
+            updated_content = []
+            file_found_in_bstk = False # Flag to track if any target file is found in current bstk
+            for line in content:
+                modified_line = line
+                for target_file_name in file_names:
+                    if target_file_name in line:
+                        file_found_in_bstk = True
+                        if "Readonly" in line or "Normal" in line: # Existing type found, replace
+                            old_mode = "Readonly" if "Readonly" in line else "Normal"
+                            modified_line = line.replace(old_mode, new_mode)
+                            if old_mode != new_mode:
+                                changed_entries.append((target_file_name, old_mode, new_mode))
+                                logger.debug(f"Modified line for file '{target_file_name}': from '{old_mode}' to '{new_mode}' in {bstk_file}")
+                        else: # No type specified, append the type
+                            modified_line = line.rstrip() + f" Type=\"{new_mode}\"\n" # Append type
+                            changed_entries.append((target_file_name, "None", new_mode)) # Old mode as None to indicate appended
+                            logger.debug(f"Appended type '{new_mode}' for file '{target_file_name}' in {bstk_file}")
+                        break # Move to next line after processing a target file
+
+                updated_content.append(modified_line)
+
+
+            if file_found_in_bstk: # Only rewrite if file was found in bstk, to avoid unnecessary writes
+                with open(current_bstk_path, "w") as f:
+                    f.writelines(updated_content)
 
             if changed_entries:
                 for (file_name, old_val, new_val) in changed_entries:
-                    logger.info(f"Successfully updated file type for '{file_name}' in {bstk_path}: from '{old_val}' to '{new_val}'")
+                    logger.info(f"Successfully updated file type for '{file_name}' in {current_bstk_path}: from '{old_val}' to '{new_val}'")
             else:
-                logger.info(f"No target file types ('Readonly' or 'Normal' with filenames {file_names}) found to modify in {bstk_path}.")
+                if file_found_in_bstk:
+                    logger.info(f"Target file types already set to '{new_mode}' or no change needed in {current_bstk_path} for files: {file_names}.")
+                else:
+                    logger.info(f"No target files {file_names} found to modify in {current_bstk_path}.")
+
 
         except FileNotFoundError:
-            error_msg = f"BSTK file not found at {bstk_path}"
+            error_msg = f"BSTK file not found at {current_bstk_path}"
             logger.error(error_msg)
             print(error_msg)
         except Exception as e:
-            error_msg = f"Error modifying BSTK file {bstk_path}: {e}"
+            error_msg = f"Error modifying BSTK file {current_bstk_path}: {e}"
             logger.exception(error_msg)
             print(error_msg)
 
 
 def is_instance_readonly(instance_path):
-    """Checks if instance files are set to 'Readonly'.
+    """Checks if instance files are set to 'Readonly' in Android.bstk.in and instance .bstk files.
 
     Args:
-        instance_path (str): Path to the BlueStacks instance directory.
+        instance_path (str): Path to the BlueStacks instance directory (or engine directory for master).
 
     Returns:
         bool: True if 'Readonly' is found in any checked .bstk file, False otherwise.
     """
-    bstk_files_to_check = ["Android.bstk.in"] # Define filenames to check directly
-    instance_bstk_files = glob.glob(os.path.join(instance_path, "*.bstk"))
-    if instance_bstk_files: # Only add if found, avoid index error if glob returns empty list
-        bstk_files_to_check.append(os.path.basename(instance_bstk_files[0]))
+    engine_path = instance_path # For master instance, instance_path IS engine_path
+    android_bstk_in_path = os.path.join(engine_path, "Android.bstk.in")
+    instance_bstk_files_glob = os.path.join(instance_path, "*.bstk") # Instance .bstk still relative to instance_path
+    instance_bstk_files = glob.glob(instance_bstk_files_glob)
+
+    bstk_files_to_check = []
+    if os.path.exists(android_bstk_in_path):
+        bstk_files_to_check.append("Android.bstk.in")
+    if instance_bstk_files:
+        bstk_files_to_check.extend([os.path.basename(f) for f in instance_bstk_files])
 
-    logger.debug(f"Checking readonly status for instance path: {instance_path}, BSTK files to check: {bstk_files_to_check}")
+    logger.debug(f"Checking readonly status for instance path: {instance_path}, Engine path: {engine_path}, BSTK files to check: {bstk_files_to_check}")
 
     for bstk_file in bstk_files_to_check:
-        bstk_path = os.path.join(instance_path, bstk_file)
+        if bstk_file == "Android.bstk.in":
+            current_bstk_path = os.path.join(engine_path, bstk_file)
+        else:
+            current_bstk_path = os.path.join(instance_path, bstk_file)
+
+        if not os.path.exists(current_bstk_path):
+            logger.warning(f"BSTK file not found at {current_bstk_path}, skipping readonly check for this file.")
+            continue # Skip to next file, don't treat as error for overall readonly status
+
         try:
-            with open(bstk_path, "r") as f:
+            with open(current_bstk_path, "r") as f:
                 for line in f:
                     if "Readonly" in line:
-                        logger.debug(f"'Readonly' found in {bstk_path}")
+                        logger.debug(f"'Readonly' found in {current_bstk_path}")
                         return True
-            logger.debug(f"'Readonly' not found in {bstk_path}") # Log even when not found to confirm check
-        except FileNotFoundError:
-            error_msg = f"BSTK file not found at {bstk_path}"
-            logger.error(error_msg)
-            print(error_msg)
-            return False # If one file not found, consider it not readonly for safety (or adjust logic)
+            logger.debug(f"'Readonly' not found in {current_bstk_path}")
         except Exception as e:
-            error_msg = f"Error reading BSTK file {bstk_path}: {e}"
+            error_msg = f"Error reading BSTK file {current_bstk_path}: {e}"
             logger.exception(error_msg)
-            print(error_msg)
-            return False
-    return False # Readonly not found in any checked files
+            print(error_msg) # Keep print for debugging
+            return False # Consider not readonly on read error, or adjust logic
+    return False  # Readonly not found in any checked files
+
+
+def terminate_bluestacks():
+    """Terminates BlueStacks processes."""
+    processes_to_kill = ["HD-Player.exe", "BlueStacks.exe", "HD-Agent.exe", "BstkSVC.exe", "HD-Frontend.exe"] # Common BlueStacks processes
+    killed_processes = []
+    for proc_name in processes_to_kill:
+        for proc in psutil.process_iter(['pid', 'name']):
+            if proc.info['name'] == proc_name:
+                try:
+                    proc.terminate()
+                    proc.wait(timeout=5) # Wait for termination, with timeout
+                    killed_processes.append(proc_name)
+                    logger.info(f"Terminated process: {proc_name} (PID: {proc.info['pid']})")
+                except psutil.NoSuchProcess:
+                    logger.debug(f"Process {proc_name} not found during termination attempt.")
+                except psutil.TimeoutExpired:
+                    logger.warning(f"Process {proc_name} did not terminate in time, may still be running.")
+                except Exception as e:
+                    logger.error(f"Error terminating process {proc_name}: {e}")
+    if killed_processes:
+        logger.info(f"Successfully terminated BlueStacks processes: {', '.join(killed_processes)}")
+    else:
+        logger.info("No BlueStacks processes found to terminate.")