Update version.json with commit count

* Update picodulce.py

* Update picodulce.py

* Update picodulce.py

* Update picodulce.py

* Create healtcheck.py

* Update picodulce.py

* Update version.json

* Create locales-go-here

* Add files via upload

* Update version.json

* Update picodulce.py

* Update healtcheck.py

* Update picodulce.py

* Added more locales

* Update version.json

* Update picodulce.py

authser.py

@@ -0,0 +1,244 @@
+import sys
+import subprocess
+import re
+from PyQt5.QtWidgets import (QApplication, QDialog, QLabel, QVBoxLayout, 
+                          QPushButton, QLineEdit, QMessageBox)
+from PyQt5.QtCore import QThread, pyqtSignal, Qt, QUrl, QObject
+from PyQt5.QtGui import QDesktopServices
+
+class AuthenticationParser:
+    @staticmethod
+    def clean_ansi(text):
+        ansi_clean = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+        printable_clean = re.compile(r'[^\x20-\x7E\n]')
+        text = ansi_clean.sub('', text)
+        text = printable_clean.sub('', text)
+        return text.strip()
+
+    @staticmethod
+    def is_auth_error(output):
+        cleaned_output = AuthenticationParser.clean_ansi(output)
+        return "AADSTS70016" in cleaned_output and "not yet been authorized" in cleaned_output
+
+    @staticmethod
+    def parse_auth_output(output):
+        cleaned_output = AuthenticationParser.clean_ansi(output)
+        if AuthenticationParser.is_auth_error(cleaned_output):
+            return None
+
+        pattern = r"https://[^\s]+"
+        code_pattern = r"code\s+([A-Z0-9]+)"
+        
+        url_match = re.search(pattern, cleaned_output)
+        code_match = re.search(code_pattern, cleaned_output, re.IGNORECASE)
+        
+        if url_match and code_match:
+            return {
+                'url': url_match.group(0),
+                'code': code_match.group(1)
+            }
+        return None
+
+class AuthDialog(QDialog):
+    def __init__(self, url, code, parent=None, error_mode=False):
+        super().__init__(parent)
+        self.setWindowTitle("Microsoft Authentication")
+        self.setWindowFlags(self.windowFlags() & ~Qt.WindowContextHelpButtonHint)
+        self.setModal(True)
+        self.setup_ui(url, code, error_mode)
+
+    def setup_ui(self, url, code, error_mode):
+        layout = QVBoxLayout(self)
+        
+        if error_mode:
+            error_label = QLabel("Error in Login - Please try again")
+            error_label.setStyleSheet("QLabel { color: red; font-weight: bold; }")
+            layout.addWidget(error_label)
+
+        instructions = QLabel(
+            "To authenticate your Microsoft Account:\n\n"
+            "1. Click 'Open Authentication Page' or visit:\n"
+            "2. Copy the code below\n"
+            "3. Paste the code on the Microsoft website\n"
+            "4. After completing authentication, click 'I've Completed Authentication'"
+        )
+        instructions.setWordWrap(True)
+        layout.addWidget(instructions)
+
+        url_label = QLabel(url)
+        url_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
+        url_label.setWordWrap(True)
+        layout.addWidget(url_label)
+        
+        self.code_input = QLineEdit(code)
+        self.code_input.setReadOnly(True)
+        self.code_input.setAlignment(Qt.AlignCenter)
+        self.code_input.setStyleSheet("""
+            QLineEdit {
+                font-size: 16pt;
+                font-weight: bold;
+                padding: 5px;
+            }
+        """)
+        layout.addWidget(self.code_input)
+        
+        copy_button = QPushButton("Copy Code")
+        copy_button.clicked.connect(self.copy_code)
+        layout.addWidget(copy_button)
+        
+        open_url_button = QPushButton("Open Authentication Page")
+        open_url_button.clicked.connect(lambda: self.open_url(url))
+        layout.addWidget(open_url_button)
+        
+        continue_button = QPushButton("I've Completed Authentication")
+        continue_button.clicked.connect(self.accept)
+        layout.addWidget(continue_button)
+
+    def copy_code(self):
+        clipboard = QApplication.clipboard()
+        clipboard.setText(self.code_input.text())
+
+    def open_url(self, url):
+        QDesktopServices.openUrl(QUrl(url))
+
+class AuthenticationThread(QThread):
+    auth_data_received = pyqtSignal(dict)
+    error_occurred = pyqtSignal(str)
+    auth_error_detected = pyqtSignal(str)
+    finished = pyqtSignal()
+    
+    def __init__(self, account):
+        super().__init__()
+        self.account = account
+        self.process = None
+        self.is_running = True
+        self.current_output = ""
+        self.waiting_for_auth = False
+
+    def run(self):
+        try:
+            command = f'picomc account authenticate {self.account}'
+            
+            self.process = subprocess.Popen(
+                command,
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                stdin=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            self.current_output = ""
+            while self.is_running and self.process.poll() is None:
+                line = self.process.stdout.readline()
+                if line:
+                    self.current_output += line
+                    
+                    if not self.waiting_for_auth:
+                        parsed_data = AuthenticationParser.parse_auth_output(self.current_output)
+                        if parsed_data:
+                            self.auth_data_received.emit(parsed_data)
+                            self.waiting_for_auth = True
+                            self.current_output = ""
+                    elif AuthenticationParser.is_auth_error(self.current_output):
+                        self.auth_error_detected.emit(self.current_output)
+                        self.waiting_for_auth = False
+                        self.current_output = ""
+            
+            self.process.wait()
+            self.finished.emit()
+            
+        except Exception as e:
+            self.error_occurred.emit(str(e))
+            self.finished.emit()
+
+    def send_enter(self):
+        if self.process and self.process.poll() is None:
+            self.process.stdin.write("\n")
+            self.process.stdin.flush()
+
+    def stop(self):
+        self.is_running = False
+        if self.process:
+            self.process.terminate()
+
+class MinecraftAuthenticator(QObject):  # Changed to inherit from QObject
+    auth_finished = pyqtSignal(bool)  # Add signal for completion
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.auth_thread = None
+        self.current_auth_data = None
+        self.auth_dialog = None
+        self.success = False
+        
+    def authenticate(self, username):
+        """
+        Start the authentication process for the given username
+        Returns immediately, authentication result will be emitted via auth_finished signal
+        """
+        self.success = False
+        self.auth_thread = AuthenticationThread(username)
+        self.auth_thread.auth_data_received.connect(self.show_auth_dialog)
+        self.auth_thread.auth_error_detected.connect(self.handle_auth_error)
+        self.auth_thread.error_occurred.connect(self.show_error)
+        self.auth_thread.finished.connect(self.on_authentication_finished)
+        self.auth_thread.start()
+
+    def show_auth_dialog(self, auth_data):
+        self.current_auth_data = auth_data
+        
+        if self.auth_dialog is not None:
+            self.auth_dialog.close()
+            self.auth_dialog = None
+        
+        self.auth_dialog = AuthDialog(auth_data['url'], auth_data['code'])
+        if self.auth_dialog.exec_() == QDialog.Accepted:
+            self.auth_thread.send_enter()
+
+    def handle_auth_error(self, output):
+        if self.current_auth_data:
+            if self.auth_dialog is not None:
+                self.auth_dialog.close()
+                self.auth_dialog = None
+            
+            self.auth_dialog = AuthDialog(
+                self.current_auth_data['url'],
+                self.current_auth_data['code'],
+                error_mode=True
+            )
+            if self.auth_dialog.exec_() == QDialog.Accepted:
+                self.auth_thread.send_enter()
+
+    def show_error(self, error_message):
+        QMessageBox.critical(None, "Error", f"Authentication error: {error_message}")
+        self.success = False
+        self.auth_finished.emit(False)
+
+    def on_authentication_finished(self):
+        if self.auth_dialog is not None:
+            self.auth_dialog.close()
+            self.auth_dialog = None
+            
+        if self.auth_thread:
+            self.auth_thread.stop()
+            self.auth_thread = None
+            
+        self.success = True
+        self.auth_finished.emit(True)
+
+    def cleanup(self):
+        if self.auth_dialog is not None:
+            self.auth_dialog.close()
+            self.auth_dialog = None
+            
+        if self.auth_thread and self.auth_thread.isRunning():
+            self.auth_thread.stop()
+            self.auth_thread.wait()
+
+# Example usage
+if __name__ == '__main__':
+    authenticator = MinecraftAuthenticator()
+    authenticator.authenticate("TestUser")

healthcheck.py

@@ -0,0 +1,119 @@
+import os
+import json
+import requests
+
+
+class HealthCheck:
+    def __init__(self):
+        self.config = None
+
+    def check_config_file(self):
+        config_path = "config.json"
+        default_config = {
+            "IsRCPenabled": False,
+            "CheckUpdate": False,
+            "IsBleeding": False,
+            "LastPlayed": "",
+            "IsFirstLaunch": True,
+            "Instance": "default",
+            "Theme": "Dark.json",
+            "ThemeBackground": True,
+            "ThemeRepository": "https://raw.githubusercontent.com/nixietab/picodulce-themes/main/repo.json",
+            "Locale": "en"
+        }
+
+        # Step 1: Check if the file exists; if not, create it with default values
+        if not os.path.exists(config_path):
+            with open(config_path, "w") as config_file:
+                json.dump(default_config, config_file, indent=4)
+            self.config = default_config
+            return
+
+        # Step 2: Try loading the config file, handle invalid JSON
+        try:
+            with open(config_path, "r") as config_file:
+                self.config = json.load(config_file)
+        except (json.JSONDecodeError, ValueError):
+            # File is corrupted, overwrite it with default configuration
+            with open(config_path, "w") as config_file:
+                json.dump(default_config, config_file, indent=4)
+            self.config = default_config
+            return
+
+        # Step 3: Check for missing keys and add defaults if necessary
+        updated = False
+        for key, value in default_config.items():
+            if key not in self.config:  # Field is missing
+                self.config[key] = value
+                updated = True
+
+        # Step 4: Save the repaired config back to the file
+        if updated:
+            with open(config_path, "w") as config_file:
+                json.dump(self.config, config_file, indent=4)
+
+    def themes_integrity(self):
+        # Define folder and file paths
+        themes_folder = "themes"
+        dark_theme_file = os.path.join(themes_folder, "Dark.json")
+        native_theme_file = os.path.join(themes_folder, "Native.json")
+
+        # Define the default content for Dark.json
+        dark_theme_content = {
+            "manifest": {
+                "name": "Dark",
+                "description": "The default picodulce launcher theme",
+                "author": "Nixietab",
+                "license": "MIT"
+            },
+            "palette": {
+                "Window": "#353535",
+                "WindowText": "#ffffff",
+                "Base": "#191919",
+                "AlternateBase": "#353535",
+                "ToolTipBase": "#ffffff",
+                "ToolTipText": "#ffffff",
+                "Text": "#ffffff",
+                "Button": "#353535",
+                "ButtonText": "#ffffff",
+                "BrightText": "#ff0000",
+                "Link": "#2a82da",
+                "Highlight": "#4bb679",
+                "HighlightedText": "#ffffff"
+            },
+            "background_image_base64": ""
+        }
+
+        # Define the default content for Native.json
+        native_theme_content = {
+            "manifest": {
+                "name": "Native",
+                "description": "The native looks of your OS",
+                "author": "Your Qt Style",
+                "license": "Any"
+            },
+            "palette": {}
+        }
+
+        # Step 1: Ensure the themes folder exists
+        if not os.path.exists(themes_folder):
+            print(f"Creating folder: {themes_folder}")
+            os.makedirs(themes_folder)
+
+        # Step 2: Ensure Dark.json exists
+        if not os.path.isfile(dark_theme_file):
+            print(f"Creating file: {dark_theme_file}")
+            with open(dark_theme_file, "w", encoding="utf-8") as file:
+                json.dump(dark_theme_content, file, indent=2)
+            print("Dark.json has been created successfully.")
+
+        # Step 3: Ensure Native.json exists
+        if not os.path.isfile(native_theme_file):
+            print(f"Creating file: {native_theme_file}")
+            with open(native_theme_file, "w", encoding="utf-8") as file:
+                json.dump(native_theme_content, file, indent=2)
+            print("Native.json has been created successfully.")
+
+        # Check if both files exist and print OK message
+        if os.path.isfile(dark_theme_file) and os.path.isfile(native_theme_file):
+            print("Theme Integrity OK")

picodulce.py

@@ -10,6 +10,10 @@ import requests
 import json
 import os
 import time
+
+from authser import MinecraftAuthenticator
+from healthcheck import HealthCheck
+
 from PyQt5.QtWidgets import QApplication, QComboBox, QWidget, QInputDialog, QVBoxLayout, QListWidget, QPushButton, QMessageBox, QDialog, QHBoxLayout, QLabel, QLineEdit, QCheckBox, QTabWidget, QFrame, QSpacerItem, QSizePolicy, QMainWindow, QGridLayout, QTextEdit, QListWidget, QListWidgetItem, QMenu
 from PyQt5.QtGui import QFont, QIcon, QColor, QPalette, QMovie, QPixmap, QDesktopServices, QBrush
 from PyQt5.QtCore import Qt, QObject, pyqtSignal, QThread, QUrl, QMetaObject, Q_ARG, QByteArray, QSize
@@ -21,10 +25,14 @@ class PicomcVersionSelector(QWidget):
     def __init__(self):
         self.current_state = "menu"
         self.open_dialogs = []
-        self.check_config_file()
-        self.themes_integrity()
+
+        # Set up and use the health_check module
+        health_checker = HealthCheck()
+        health_checker.themes_integrity()
+        health_checker.check_config_file()
+        self.config = health_checker.config
+
         themes_folder = "themes"
-        
         theme_file = self.config.get("Theme", "Dark.json")
 
         # Ensure the theme file exists in the themes directory
@@ -51,6 +59,10 @@ class PicomcVersionSelector(QWidget):
         if self.config.get("IsFirstLaunch", False):
             self.FirstLaunch()
 
+        self.authenticator = MinecraftAuthenticator(self)
+        self.authenticator.auth_finished.connect(self._on_auth_finished)
+
+
     def load_theme_from_file(self, file_path, app):
         self.theme = {}
         # Check if the file exists, else load 'Dark.json'
@@ -110,73 +122,6 @@ class PicomcVersionSelector(QWidget):
         else:
             print("Theme dosn't seem to have a stylesheet")
 
-    def themes_integrity(self):
-        # Define folder and file paths
-        themes_folder = "themes"
-        dark_theme_file = os.path.join(themes_folder, "Dark.json")
-        native_theme_file = os.path.join(themes_folder, "Native.json")
-
-        # Define the default content for Dark.json
-        dark_theme_content = {
-            "manifest": {
-                "name": "Dark",
-                "description": "The default picodulce launcher theme",
-                "author": "Nixietab",
-                "license": "MIT"
-            },
-            "palette": {
-                "Window": "#353535",
-                "WindowText": "#ffffff",
-                "Base": "#191919",
-                "AlternateBase": "#353535",
-                "ToolTipBase": "#ffffff",
-                "ToolTipText": "#ffffff",
-                "Text": "#ffffff",
-                "Button": "#353535",
-                "ButtonText": "#ffffff",
-                "BrightText": "#ff0000",
-                "Link": "#2a82da",
-                "Highlight": "#4bb679",
-                "HighlightedText": "#ffffff"
-            },
-            "background_image_base64": ""
-        }
-
-        # Define the default content for Native.json
-        native_theme_content = {
-            "manifest": {
-                "name": "Native",
-                "description": "The native looks of your OS",
-                "author": "Your Qt Style",
-                "license": "Any"
-            },
-            "palette": {}
-        }
-
-        # Step 1: Ensure the themes folder exists
-        if not os.path.exists(themes_folder):
-            print(f"Creating folder: {themes_folder}")
-            os.makedirs(themes_folder)
-
-        # Step 2: Ensure Dark.json exists
-        if not os.path.isfile(dark_theme_file):
-            print(f"Creating file: {dark_theme_file}")
-            with open(dark_theme_file, "w", encoding="utf-8") as file:
-                json.dump(dark_theme_content, file, indent=2)
-            print("Dark.json has been created successfully.")
-
-        # Step 3: Ensure Native.json exists
-        if not os.path.isfile(native_theme_file):
-            print(f"Creating file: {native_theme_file}")
-            with open(native_theme_file, "w", encoding="utf-8") as file:
-                json.dump(native_theme_content, file, indent=2)
-            print("Native.json has been created successfully.")
-
-        # Check if both files exist and print OK message
-        if os.path.isfile(dark_theme_file) and os.path.isfile(native_theme_file):
-            print("Theme Integrity OK")
-
-
     def FirstLaunch(self):
         try:
             self.config_path = "config.json"
@@ -205,6 +150,49 @@ class PicomcVersionSelector(QWidget):
             self.movie_label.setGeometry(0, 0, 400, 320)
         event.accept()  # Accept the resize event
 
+    def load_theme_background(self):
+        """Load and set the theme background image from base64 data in the theme configuration."""
+        if not self.config.get("ThemeBackground", False):  # Default to False if ThemeBackground is missing
+            return
+
+        # Get the base64 string for the background image from the theme file
+        theme_background_base64 = self.theme.get("background_image_base64", "")
+        if not theme_background_base64:
+            print("No background GIF base64 string found in the theme file.")
+            return
+
+        try:
+            # Decode the base64 string to get the binary data
+            background_image_data = QByteArray.fromBase64(theme_background_base64.encode())
+            temp_gif_path = "temp.gif"  # Write the gif into a temp file because Qt stuff
+            with open(temp_gif_path, 'wb') as temp_gif_file:
+                temp_gif_file.write(background_image_data)
+
+            # Create a QMovie object from the temporary file
+            movie = QMovie(temp_gif_path)
+            if movie.isValid():
+                self.setAutoFillBackground(True)
+                palette = self.palette()
+
+                # Set the QMovie to a QLabel
+                self.movie_label = QLabel(self)
+                self.movie_label.setMovie(movie)
+                self.movie_label.setGeometry(0, 0, movie.frameRect().width(), movie.frameRect().height())
+                self.movie_label.setScaledContents(True)  # Ensure the QLabel scales its contents
+                movie.start()
+
+                # Use the QLabel pixmap as the brush texture
+                brush = QBrush(QPixmap(movie.currentPixmap()))
+                brush.setStyle(Qt.TexturePattern)
+                palette.setBrush(QPalette.Window, brush)
+                self.setPalette(palette)
+
+                # Adjust the QLabel size when the window is resized
+                self.movie_label.resizeEvent = self.resize_event
+            else:
+                print("Error: Failed to load background GIF from base64 string.")
+        except Exception as e:
+            print(f"Error: Failed to decode and set background GIF. {e}")
 
     def init_ui(self):
         self.setWindowTitle('PicoDulce Launcher')  # Change window title
@@ -221,44 +209,8 @@ class PicomcVersionSelector(QWidget):
         with open("config.json", "r") as config_file:
             config = json.load(config_file)
 
-        if self.config.get("ThemeBackground", False):  # Default to False if ThemeBackground is missing
-            # Get the base64 string for the background image from the theme file
-            theme_background_base64 = self.theme.get("background_image_base64", "")
-            if theme_background_base64:
-                try:
-                    # Decode the base64 string to get the binary data
-                    background_image_data = QByteArray.fromBase64(theme_background_base64.encode())
-                    temp_gif_path = "temp.gif"  # Write the gif into a temp file because Qt stuff
-                    with open(temp_gif_path, 'wb') as temp_gif_file:
-                        temp_gif_file.write(background_image_data)
-
-                    # Create a QMovie object from the temporary file
-                    movie = QMovie(temp_gif_path)
-                    if movie.isValid():
-                        self.setAutoFillBackground(True)
-                        palette = self.palette()
-
-                        # Set the QMovie to a QLabel
-                        self.movie_label = QLabel(self)
-                        self.movie_label.setMovie(movie)
-                        self.movie_label.setGeometry(0, 0, movie.frameRect().width(), movie.frameRect().height())
-                        self.movie_label.setScaledContents(True)  # Ensure the QLabel scales its contents
-                        movie.start()
-
-                        # Use the QLabel pixmap as the brush texture
-                        brush = QBrush(QPixmap(movie.currentPixmap()))
-                        brush.setStyle(Qt.TexturePattern)
-                        palette.setBrush(QPalette.Window, brush)
-                        self.setPalette(palette)
-
-                        # Adjust the QLabel size when the window is resized
-                        self.movie_label.resizeEvent = self.resize_event
-                    else:
-                        print("Error: Failed to load background GIF from base64 string.")
-                except Exception as e:
-                    print(f"Error: Failed to decode and set background GIF. {e}")
-            else:
-                print("No background GIF base64 string found in the theme file.")
+        # Load theme background
+        self.load_theme_background()
 
         # Create title label
         title_label = QLabel('PicoDulce Launcher')  # Change label text
@@ -323,7 +275,7 @@ class PicomcVersionSelector(QWidget):
         main_layout.setSpacing(20)
 
         self.setLayout(main_layout)
-
+    
     def keyPressEvent(self, event):
         focus_widget = self.focusWidget()
         if event.key() == Qt.Key_Down:
@@ -338,50 +290,6 @@ class PicomcVersionSelector(QWidget):
         else:
             super().keyPressEvent(event)
 
-    def check_config_file(self):
-        config_path = "config.json"
-        default_config = {
-            "IsRCPenabled": False,
-            "CheckUpdate": False,
-            "IsBleeding": False,
-            "LastPlayed": "",
-            "IsFirstLaunch": True,
-            "Instance": "default",
-            "Theme": "Dark.json",
-            "ThemeBackground": True,
-            "ThemeRepository": "https://raw.githubusercontent.com/nixietab/picodulce-themes/main/repo.json"
-        }
-
-        # Step 1: Check if the file exists; if not, create it with default values
-        if not os.path.exists(config_path):
-            with open(config_path, "w") as config_file:
-                json.dump(default_config, config_file, indent=4)
-            self.config = default_config
-            return
-
-        # Step 2: Try loading the config file, handle invalid JSON
-        try:
-            with open(config_path, "r") as config_file:
-                self.config = json.load(config_file)
-        except (json.JSONDecodeError, ValueError):
-            # File is corrupted, overwrite it with default configuration
-            with open(config_path, "w") as config_file:
-                json.dump(default_config, config_file, indent=4)
-            self.config = default_config
-            return
-
-        # Step 3: Check for missing keys and add defaults if necessary
-        updated = False
-        for key, value in default_config.items():
-            if key not in self.config:  # Field is missing
-                self.config[key] = value
-                updated = True
-
-        # Step 4: Save the repaired config back to the file
-        if updated:
-            with open(config_path, "w") as config_file:
-                json.dump(self.config, config_file, indent=4)
-
     def open_settings_dialog(self):
         dialog = QDialog(self)
         dialog.setWindowTitle('Settings')
@@ -445,24 +353,27 @@ class PicomcVersionSelector(QWidget):
 
         # QListWidget to display available themes
         json_files_label = QLabel('Installed Themes:')
-        json_files_list_widget = QListWidget()
+        self.json_files_list_widget = QListWidget()
 
         # Track selected theme
         self.selected_theme = theme_filename  # Default to current theme
 
+        # Build the list of themes
+        themes_list = self.build_themes_list()
+        
         # Populate themes initially
-        self.populate_themes(json_files_list_widget)
+        self.populate_themes(self.json_files_list_widget, themes_list)
 
         # Update current theme label when a theme is selected
-        json_files_list_widget.itemClicked.connect(
-            lambda: self.on_theme_selected(json_files_list_widget, current_theme_label)
+        self.json_files_list_widget.itemClicked.connect(
+            lambda: self.on_theme_selected(self.json_files_list_widget, current_theme_label)
         )
 
         # Add widgets to the layout
         customization_layout.addWidget(theme_background_checkbox)
         customization_layout.addWidget(current_theme_label)
         customization_layout.addWidget(json_files_label)
-        customization_layout.addWidget(json_files_list_widget)
+        customization_layout.addWidget(self.json_files_list_widget)
 
         # Button to download themes
         download_themes_button = QPushButton("Download More Themes")
@@ -507,9 +418,9 @@ class PicomcVersionSelector(QWidget):
             if response == QMessageBox.No:
                 checkbox.setChecked(False)
 
-    def populate_themes(self, json_files_list_widget):
+    def build_themes_list(self):
         themes_folder = os.path.join(os.getcwd(), "themes")
-        json_files_list_widget.clear()
+        themes_list = []
         if os.path.exists(themes_folder):
             json_files = [f for f in os.listdir(themes_folder) if f.endswith('.json')]
             for json_file in json_files:
@@ -525,15 +436,21 @@ class PicomcVersionSelector(QWidget):
 
                     # Create display text and list item
                     display_text = f"{name}\n{description}\nBy: {author}"
-                    list_item = QListWidgetItem(display_text)
-                    list_item.setData(Qt.UserRole, json_file)  # Store the JSON filename as metadata
+                    themes_list.append((display_text, json_file))
+        return themes_list
 
-                    # Style the name in bold
-                    font = QFont()
-                    font.setBold(False)
-                    list_item.setFont(font)
+    def populate_themes(self, json_files_list_widget, themes_list):
+        json_files_list_widget.clear()
+        for display_text, json_file in themes_list:
+            list_item = QListWidgetItem(display_text)
+            list_item.setData(Qt.UserRole, json_file)  # Store the JSON filename as metadata
 
-                    json_files_list_widget.addItem(list_item)
+            # Style the name in bold
+            font = QFont()
+            font.setBold(False)
+            list_item.setFont(font)
+
+            json_files_list_widget.addItem(list_item)
 
         # Apply spacing and styling to the list
         json_files_list_widget.setStyleSheet("""
@@ -551,8 +468,8 @@ class PicomcVersionSelector(QWidget):
         if selected_item:
             self.selected_theme = selected_item.data(Qt.UserRole)
             current_theme_label.setText(f"Current Theme: {self.selected_theme}")
-
-        ## REPOSITORY BLOCK BEGGINS
+            
+     ## REPOSITORY BLOCK BEGGINS
 
     def download_themes_window(self):
         dialog = QDialog(self)
@@ -589,9 +506,16 @@ class PicomcVersionSelector(QWidget):
         main_layout.addLayout(right_layout)
         dialog.setLayout(main_layout)
 
+        dialog.finished.connect(lambda: self.update_themes_list())
+
+
         self.load_themes()
         dialog.exec_()
 
+    def update_themes_list(self):
+        themes_list = self.build_themes_list()
+        self.populate_themes(self.json_files_list_widget, themes_list)
+
     def fetch_themes(self):
         try:
             with open("config.json", "r") as config_file:
@@ -1063,19 +987,36 @@ class PicomcVersionSelector(QWidget):
         return False
 
     def authenticate_account(self, dialog, account_name):
-        # Authenticate a selected account
+        # Clean up the account name
         account_name = account_name.strip().lstrip(" * ")
         if not account_name:
             QMessageBox.warning(dialog, "Warning", "Please select an account to authenticate.")
             return
 
         try:
-            subprocess.run(['picomc', 'account', 'authenticate', account_name], check=True)
-            QMessageBox.information(self, "Success", f"Account '{account_name}' authenticated successfully!")
-        except subprocess.CalledProcessError as e:
-            error_message = f"Error authenticating account '{account_name}': {e.stderr.decode()}"
+            # Create authenticator instance if it doesn't exist
+            if self.authenticator is None:
+                self.authenticator = MinecraftAuthenticator(self)
+                self.authenticator.auth_finished.connect(self._on_auth_finished)
+
+            # Start authentication process
+            self.authenticator.authenticate(account_name)
+            
+        except Exception as e:
+            error_message = f"Error authenticating account '{account_name}': {str(e)}"
             logging.error(error_message)
-            QMessageBox.critical(self, "Error", error_message)
+            QMessageBox.critical(dialog, "Error", error_message)
+
+    def _on_auth_finished(self, success):
+        if success:
+            QMessageBox.information(self, "Success", "Account authenticated successfully!")
+        else:
+            QMessageBox.critical(self, "Error", "Failed to authenticate account")
+
+        # Cleanup
+        if self.authenticator:
+            self.authenticator.cleanup()
+            self.authenticator = None
 
     def remove_account(self, dialog, username):
         # Remove a selected account
@@ -1226,7 +1167,7 @@ class PicomcVersionSelector(QWidget):
                             # Download and apply the update
                             self.download_update(remote_version_info)
                     else:
-                        QMessageBox.information(self, "Up to Date", "You already have the latest version!")
+                        print(f"You already have the latest version!")
                 else:
                     logging.error("Failed to read local version information.")
                     QMessageBox.critical(self, "Error", "Failed to check for updates.")

version.json

@@ -1,12 +1,14 @@
 {
-  "version": "0.11.9",
+  "version": "0.12.1",
   "links": [
     "https://raw.githubusercontent.com/nixietab/picodulce/main/version.json",
     "https://raw.githubusercontent.com/nixietab/picodulce/main/picodulce.py",
     "https://raw.githubusercontent.com/nixietab/picodulce/main/requirements.txt",
     "https://raw.githubusercontent.com/nixietab/picodulce/main/drums.gif",
     "https://raw.githubusercontent.com/nixietab/picodulce/main/marroc.py",
-    "https://raw.githubusercontent.com/nixietab/picodulce/main/holiday.ico"
+    "https://raw.githubusercontent.com/nixietab/picodulce/main/holiday.ico",
+    "https://raw.githubusercontent.com/nixietab/picodulce/main/authser.py",
+    "https://raw.githubusercontent.com/nixietab/picodulce/main/healthcheck.py"
   ],
-  "versionBleeding": "0.11.8-149"
+  "versionBleeding": "0.12.1-188"
 }