.github/workflows/Bleeding-Job.yaml

@@ -1,36 +0,0 @@
-name: Bleeding Update version
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  update-version:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Check out the repository
-        uses: actions/checkout@v3
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.x'
-
-      - name: Update version.json
-        run: |
-          git fetch --prune --unshallow
-          commit_count=$(git rev-list --count HEAD)
-          version=$(jq -r '.version' version.json)
-          jq --arg versionBleeding "$version-$commit_count" '. + {versionBleeding: $versionBleeding}' version.json > version.tmp && mv version.tmp version.json
-
-      - name: Commit and push changes
-        run: |
-          git config --global user.name 'github-actions[bot]'
-          git config --global user.email 'github-actions[bot]@users.noreply.github.com'
-          git add version.json
-          git commit -m "Update version.json with commit count"
-          git push
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/Build.yml

@@ -9,8 +9,6 @@ jobs:
   version-release:
     runs-on: windows-latest  # Use Windows 10 runner
 
-    if: github.actor != 'github-actions[bot]'  # Only run if the actor is not the GitHub Actions bot
-
     steps:
     - name: Checkout repository
       uses: actions/checkout@v3

PKGBUILD

@@ -1,76 +0,0 @@
-pkgname=picodulce
-pkgver=0.11.7
-pkgrel=1
-pkgdesc="Launcher for Minecraft based on the picomc library"
-arch=('x86_64')
-OPTIONS=(!strip !docs libtool emptydirs)
-url="https://github.com/nixietab/picodulce"
-license=('MIT')  # Replace with your project's license
-depends=('python' 'python-virtualenv' 'xdg-utils')
-makedepends=('git')
-source=("git+https://github.com/nixietab/picodulce.git")
-sha256sums=('SKIP')
-
-package() {
-    cd "$srcdir/$pkgname"
-
-    # Create a directory for the application in the user's home directory
-    install -dm755 "$pkgdir/usr/share/$pkgname"
-
-    # Copy all project files to the created directory
-    cp -r . "$pkgdir/usr/share/$pkgname"
-
-    # Create a virtual environment
-    python -m venv "$pkgdir/usr/share/$pkgname/venv"
-
-    # Activate the virtual environment and install dependencies
-    source "$pkgdir/usr/share/$pkgname/venv/bin/activate"
-    pip install -r requirements.txt
-
-    # Create a run.sh script
-    install -Dm755 /dev/stdin "$pkgdir/usr/share/$pkgname/run.sh" <<EOF
-#!/bin/bash
-
-if [ ! -d "venv" ]; then
-  echo "venv folder does not exist. Creating virtual environment..."
-  python3 -m venv venv
-
-  source venv/bin/activate
-
-  echo "Installing required packages..."
-  pip install -r requirements.txt
-else
-  source venv/bin/activate
-fi
-
-python picodulce.py
-EOF
-
-
-    # Make the run.sh script executable
-    chmod +x "$pkgdir/usr/share/$pkgname/run.sh"
-
-    # Create a desktop entry for the application
-    install -Dm644 /dev/stdin "$pkgdir/usr/share/applications/$pkgname.desktop" <<EOF
-[Desktop Entry]
-Name=Picodulce
-Exec=/usr/share/picodulce/run.sh
-Icon=/usr/share/picodulce/launcher_icon.ico
-Terminal=true
-Type=Application
-Comment=Picodulce Launcher
-Categories=Game;
-EOF
-
-    # Ensure the normal user has permission to write to the picodulce folder
-    chown -R "$USER:$USER" "$pkgdir/usr/share/$pkgname"
-    chmod -R u+w "$pkgdir/usr/share/$pkgname"
-
-    #Install into bin
-    install -Dm755 /dev/stdin "$pkgdir/usr/bin/picodulce" <<EOF
-#!/bin/bash
-cd /usr/share/picodulce/
-exec ./run.sh
-EOF
-}
-# vim:set ts=2 sw=2 et:

README.md

@@ -40,21 +40,7 @@
 - **Custom Theme Support**: Create and apply personalized themes with ease. A dedicated repository and guide are [available to help you get started.](https://github.com/nixietab/picodulce-themes)
 
 # Installation
-
+If you are on windows you may be more interested in a [installer](https://github.com/nixietab/picodulce/releases/latest)
-## Windows
-For Windows systems using the [installer](https://github.com/nixietab/picodulce/releases/latest) is recommended
-
-## Arch Linux
-The package is available in the [AUR](https://aur.archlinux.org/packages/picodulce) as ```picodulce```
-
-For installing on Arch without using an AUR helper a PKGBUILD is provided
-```
-git clone https://aur.archlinux.org/picodulce.git
-cd picodulce
-makepkg -si
-```
-
-## Other OS
 
 ### 1. Clone the repository
 

authser.py

@@ -1,366 +0,0 @@
-import sys
-import json
-import os
-import uuid
-import asyncio
-import aiohttp
-from datetime import datetime, timezone
-from pathlib import Path
-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
-from picomc.logging import logger
-from picomc.launcher import get_default_root, Launcher
-
-# Constants for Microsoft Authentication
-URL_DEVICE_AUTH = "https://login.microsoftonline.com/consumers/oauth2/v2.0/devicecode"
-URL_TOKEN = "https://login.microsoftonline.com/consumers/oauth2/v2.0/token"
-URL_XBL = "https://user.auth.xboxlive.com/user/authenticate"
-URL_XSTS = "https://xsts.auth.xboxlive.com/xsts/authorize"
-URL_MC = "https://api.minecraftservices.com/authentication/login_with_xbox"
-URL_PROFILE = "https://api.minecraftservices.com/minecraft/profile"
-
-CLIENT_ID = "c52aed44-3b4d-4215-99c5-824033d2bc0f"
-SCOPE = "XboxLive.signin offline_access"
-GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code"
-
-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()
-    access_token_received = pyqtSignal(dict)
-    
-    def __init__(self, username):
-        super().__init__()
-        self.username = username
-        self.device_code = None
-        self.is_running = True
-
-    async def _ms_oauth(self):
-        data = {"client_id": CLIENT_ID, "scope": SCOPE}
-        
-        async with aiohttp.ClientSession() as session:
-            async with session.post(URL_DEVICE_AUTH, data=data) as resp:
-                if resp.status != 200:
-                    raise Exception(f"Failed to get device code: {await resp.text()}")
-                j = await resp.json()
-                self.device_code = j["device_code"]
-                self.auth_data_received.emit({
-                    'url': j["verification_uri"],
-                    'code': j["user_code"]
-                })
-
-            while self.is_running:
-                data = {
-                    "grant_type": GRANT_TYPE,
-                    "client_id": CLIENT_ID,
-                    "device_code": self.device_code
-                }
-                
-                async with session.post(URL_TOKEN, data=data) as resp:
-                    j = await resp.json()
-                    if resp.status == 400:
-                        if j["error"] == "authorization_pending":
-                            await asyncio.sleep(2)
-                            continue
-                        else:
-                            raise Exception(j["error_description"])
-                    elif resp.status != 200:
-                        raise Exception(f"Token request failed: {j}")
-
-                    return j["access_token"], j["refresh_token"]
-
-    async def _xbl_auth(self, access_token):
-        data = {
-            "Properties": {
-                "AuthMethod": "RPS",
-                "SiteName": "user.auth.xboxlive.com",
-                "RpsTicket": f"d={access_token}"
-            },
-            "RelyingParty": "http://auth.xboxlive.com",
-            "TokenType": "JWT"
-        }
-
-        async with aiohttp.ClientSession() as session:
-            async with session.post(URL_XBL, json=data) as resp:
-                if resp.status != 200:
-                    raise Exception(f"XBL auth failed: {await resp.text()}")
-                j = await resp.json()
-                return j["Token"], j["DisplayClaims"]["xui"][0]["uhs"]
-
-    async def _xsts_auth(self, xbl_token):
-        data = {
-            "Properties": {
-                "SandboxId": "RETAIL",
-                "UserTokens": [xbl_token]
-            },
-            "RelyingParty": "rp://api.minecraftservices.com/",
-            "TokenType": "JWT"
-        }
-
-        async with aiohttp.ClientSession() as session:
-            async with session.post(URL_XSTS, json=data) as resp:
-                if resp.status != 200:
-                    raise Exception(f"XSTS auth failed: {await resp.text()}")
-                j = await resp.json()
-                return j["Token"]
-
-    async def _mc_auth(self, uhs, xsts_token):
-        data = {
-            "identityToken": f"XBL3.0 x={uhs};{xsts_token}"
-        }
-
-        async with aiohttp.ClientSession() as session:
-            async with session.post(URL_MC, json=data) as resp:
-                if resp.status != 200:
-                    raise Exception(f"MC auth failed: {await resp.text()}")
-                j = await resp.json()
-                return j["access_token"]
-
-    async def _get_profile(self, mc_token):
-        headers = {
-            "Authorization": f"Bearer {mc_token}"
-        }
-
-        async with aiohttp.ClientSession() as session:
-            async with session.get(URL_PROFILE, headers=headers) as resp:
-                if resp.status != 200:
-                    raise Exception(f"Profile request failed: {await resp.text()}")
-                return await resp.json()
-
-    async def _auth_flow(self):
-        try:
-            ms_access_token, refresh_token = await self._ms_oauth()
-            xbl_token, uhs = await self._xbl_auth(ms_access_token)
-            xsts_token = await self._xsts_auth(xbl_token)
-            mc_token = await self._mc_auth(uhs, xsts_token)
-            profile = await self._get_profile(mc_token)
-
-            self.access_token_received.emit({
-                'access_token': mc_token,
-                'refresh_token': refresh_token,
-                'profile': profile
-            })
-
-        except Exception as e:
-            self.error_occurred.emit(str(e))
-
-    def run(self):
-        try:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            loop.run_until_complete(self._auth_flow())
-        except Exception as e:
-            self.error_occurred.emit(str(e))
-        finally:
-            self.finished.emit()
-
-    def stop(self):
-        self.is_running = False
-
-class MinecraftAuthenticator(QObject):
-    auth_finished = pyqtSignal(bool)
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.auth_thread = None
-        self.auth_dialog = None
-        self.success = False
-        self.username = None
-        
-        # Initialize the launcher to get the correct config path
-        with Launcher.new() as launcher:
-            self.config_path = launcher.root
-
-    def authenticate(self, username):
-        self.username = username
-        self.success = False
-
-        # Create accounts.json if it doesn't exist
-        if not self.save_to_accounts_json():
-            return
-
-        self.auth_thread = AuthenticationThread(username)
-        self.auth_thread.auth_data_received.connect(self.show_auth_dialog)
-        self.auth_thread.error_occurred.connect(self.show_error)
-        self.auth_thread.access_token_received.connect(self.on_access_token_received)
-        self.auth_thread.finished.connect(self.on_authentication_finished)
-        self.auth_thread.start()
-
-    def show_auth_dialog(self, auth_data):
-        if self.auth_dialog is not None:
-            self.auth_dialog.close()
-            
-        self.auth_dialog = AuthDialog(auth_data['url'], auth_data['code'])
-        
-        result = self.auth_dialog.exec_()
-        
-        if result != QDialog.Accepted:
-            self.auth_thread.stop()
-
-    def show_error(self, error_msg):
-        QMessageBox.critical(None, "Error", error_msg)
-        self.success = False
-        self.auth_finished.emit(False)
-
-    def save_to_accounts_json(self):
-        try:
-            accounts_file = Path(self.config_path) / "accounts.json"
-            
-            if accounts_file.exists():
-                with open(accounts_file) as f:
-                    config = json.load(f)
-            else:
-                config = {
-                    "default": None,
-                    "accounts": {},
-                    "client_token": str(uuid.uuid4())
-                }
-                accounts_file.parent.mkdir(parents=True, exist_ok=True)
-            
-            # Only create/update if account doesn't exist
-            if self.username not in config["accounts"]:
-                config["accounts"][self.username] = {
-                    "uuid": "-",
-                    "online": True,
-                    "microsoft": True,
-                    "gname": "-",
-                    "access_token": "-",
-                    "refresh_token": "-",
-                    "is_authenticated": False
-                }
-                
-                # Set as default if no default exists
-                if config["default"] is None:
-                    config["default"] = self.username
-                
-                with open(accounts_file, 'w') as f:
-                    json.dump(config, f, indent=4)
-                    
-            return True
-
-        except Exception as e:
-            logger.error(f"Failed to initialize account data: {str(e)}")
-            QMessageBox.critical(None, "Error", f"Failed to initialize account data: {str(e)}")
-            return False
-
-    def on_access_token_received(self, data):
-        try:
-            accounts_file = Path(self.config_path) / "accounts.json"
-            
-            with open(accounts_file) as f:
-                config = json.load(f)
-            
-            if self.username in config["accounts"]:
-                config["accounts"][self.username].update({
-                    "access_token": data['access_token'],
-                    "refresh_token": data['refresh_token'],
-                    "uuid": data['profile']['id'],
-                    "gname": data['profile']['name'],
-                    "is_authenticated": True
-                })
-                
-                with open(accounts_file, 'w') as f:
-                    json.dump(config, f, indent=4)
-                
-                self.success = True
-                QMessageBox.information(None, "Success", 
-                                      f"Successfully authenticated account: {self.username}")
-            else:
-                raise Exception("Account not found in configuration")
-                
-        except Exception as e:
-            logger.error(f"Failed to update account data: {str(e)}")
-            QMessageBox.critical(None, "Error", f"Failed to update account data: {str(e)}")
-            self.success = False
-            
-        self.auth_finished.emit(self.success)
-
-    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
-            
-        if not self.success:
-            self.auth_finished.emit(False)
-
-    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()
-
-def create_authenticator():
-    """Factory function to create a new MinecraftAuthenticator instance"""
-    return MinecraftAuthenticator()

healthcheck.py

@@ -1,119 +0,0 @@
-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")

modulecli.py

@@ -1,30 +0,0 @@
-import click
-from picomc.cli.main import picomc_cli
-from io import StringIO
-import sys
-
-def run_command(command="picomc"):
-    # Redirect stdout and stderr to capture the command output
-    old_stdout, old_stderr = sys.stdout, sys.stderr
-    sys.stdout = mystdout = StringIO()
-    sys.stderr = mystderr = StringIO()
-    
-    try:
-        picomc_cli.main(args=command.split())
-    except SystemExit as e:
-        if e.code != 0:
-            print(f"Command exited with code {e.code}", file=sys.stderr)
-    except Exception as e:
-        print(f"Unexpected error: {e}", file=sys.stderr)
-    finally:
-        # Restore stdout and stderr
-        sys.stdout = old_stdout
-        sys.stderr = old_stderr
-
-    output = mystdout.getvalue().strip()
-    error = mystderr.getvalue().strip()
-    
-    if not output:
-        return f"Error: No output from command. Stderr: {error}"
-    
-    return output

picodulce.py

@@ -10,30 +10,21 @@ import requests
 import json
 import os
 import time
-
-from authser import MinecraftAuthenticator
-from healthcheck import HealthCheck
-import modulecli
-
 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
 from datetime import datetime
 
-logging.basicConfig(level=logging.ERROR, format='%(levelname)s - %(message)s')
+logging.basicConfig(level=logging.ERROR, format='%(asctime)s - %(levelname)s - %(message)s')
 
 class PicomcVersionSelector(QWidget):
     def __init__(self):
         self.current_state = "menu"
         self.open_dialogs = []
-
+        self.check_config_file()
-        # Set up and use the health_check module
+        self.themes_integrity()
-        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
@@ -57,13 +48,6 @@ class PicomcVersionSelector(QWidget):
             discord_rcp_thread.daemon = True  # Make the thread a daemon so it terminates when the main program exits
             discord_rcp_thread.start()
 
-        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'
@@ -123,47 +107,98 @@ class PicomcVersionSelector(QWidget):
         else:
             print("Theme dosn't seem to have a stylesheet")
 
-    def FirstLaunch(self):
+    def themes_integrity(self):
-        try:
+        # Define folder and file paths
-            self.config_path = "config.json"
+        themes_folder = "themes"
-            print("Running picomc instance create default command...")
+        dark_theme_file = os.path.join(themes_folder, "Dark.json")
+        native_theme_file = os.path.join(themes_folder, "Native.json")
 
-            # Run the command using modulecli
+        # Define the default content for Dark.json
-            command = "instance create default"
+        dark_theme_content = {
-            result = modulecli.run_command(command)
+            "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": ""
+        }
 
-            # Print the output of the command
+        # Define the default content for Native.json
-            print("Command output:", result)
+        native_theme_content = {
+            "manifest": {
+                "name": "Native",
+                "description": "The native looks of your OS",
+                "author": "Your Qt Style",
+                "license": "Any"
+            },
+            "palette": {}
+        }
 
-            # Change the value of IsFirstLaunch to False
+        # Step 1: Ensure the themes folder exists
-            self.config["IsFirstLaunch"] = False
+        if not os.path.exists(themes_folder):
-            print("IsFirstLaunch set to False")
+            print(f"Creating folder: {themes_folder}")
+            os.makedirs(themes_folder)
 
-            # Save the updated config to the config.json file
+        # Step 2: Ensure Dark.json exists
-            with open(self.config_path, 'w') as f:
+        if not os.path.isfile(dark_theme_file):
-                json.dump(self.config, f, indent=4)
+            print(f"Creating file: {dark_theme_file}")
-            print("Configuration saved to", self.config_path)
+            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")
 
-        except Exception as e:
-            print("An error occurred while creating the instance.")
-            print("Error output:", str(e))
 
     def resize_event(self, event):
         if hasattr(self, 'movie_label'):
-            self.movie_label.setGeometry(0, 0, 400, 320)
+            self.movie_label.setGeometry(0, 0, self.width(), self.height())
         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
 
+    def init_ui(self):
+        self.setWindowTitle('PicoDulce Launcher')  # Change window title
+        current_date = datetime.now()
+        if (current_date.month == 12 and current_date.day >= 8) or (current_date.month == 1 and current_date.day <= 1):
+            self.setWindowIcon(QIcon('holiday.ico'))  # Set holiday icon
+        else:
+            self.setWindowIcon(QIcon('launcher_icon.ico'))  # Set regular icon
+
+        self.setGeometry(100, 100, 400, 250)
+
+        # Set application style and theme
+        QApplication.setStyle("Fusion")
+        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 not theme_background_base64:
+            if 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())
@@ -196,24 +231,8 @@ class PicomcVersionSelector(QWidget):
                         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
-        current_date = datetime.now()
-        if (current_date.month == 12 and current_date.day >= 8) or (current_date.month == 1 and current_date.day <= 1):
-            self.setWindowIcon(QIcon('holiday.ico'))  # Set holiday icon
             else:
-            self.setWindowIcon(QIcon('launcher_icon.ico'))  # Set regular icon
+                print("No background GIF base64 string found in the theme file.")
-
-        self.setGeometry(100, 100, 400, 250)
-
-        # Set application style and theme
-        QApplication.setStyle("Fusion")
-        with open("config.json", "r") as config_file:
-            config = json.load(config_file)
-
-        # Load theme background
-        self.load_theme_background()
 
         # Create title label
         title_label = QLabel('PicoDulce Launcher')  # Change label text
@@ -293,6 +312,48 @@ class PicomcVersionSelector(QWidget):
         else:
             super().keyPressEvent(event)
 
+    def check_config_file(self):
+        config_path = "config.json"
+        default_config = {
+            "IsRCPenabled": False,
+            "CheckUpdate": False,
+            "LastPlayed": "",
+            "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')
@@ -317,14 +378,9 @@ class PicomcVersionSelector(QWidget):
         check_updates_checkbox = QCheckBox('Check Updates on Start')
         check_updates_checkbox.setChecked(self.config.get("CheckUpdate", False))
 
-        bleeding_edge_checkbox = QCheckBox('Bleeding Edge')
-        bleeding_edge_checkbox.setChecked(self.config.get("IsBleeding", False))
-        bleeding_edge_checkbox.stateChanged.connect(lambda: self.show_bleeding_edge_popup(bleeding_edge_checkbox))
-
         settings_layout.addWidget(title_label)
         settings_layout.addWidget(discord_rcp_checkbox)
         settings_layout.addWidget(check_updates_checkbox)
-        settings_layout.addWidget(bleeding_edge_checkbox)
 
         # Add buttons in the settings tab
         update_button = QPushButton('Check for updates')
@@ -356,27 +412,24 @@ class PicomcVersionSelector(QWidget):
 
         # QListWidget to display available themes
         json_files_label = QLabel('Installed Themes:')
-        self.json_files_list_widget = QListWidget()
+        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(self.json_files_list_widget, themes_list)
+        self.populate_themes(json_files_list_widget)
 
         # Update current theme label when a theme is selected
-        self.json_files_list_widget.itemClicked.connect(
+        json_files_list_widget.itemClicked.connect(
-            lambda: self.on_theme_selected(self.json_files_list_widget, current_theme_label)
+            lambda: self.on_theme_selected(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(self.json_files_list_widget)
+        customization_layout.addWidget(json_files_list_widget)
 
         # Button to download themes
         download_themes_button = QPushButton("Download More Themes")
@@ -397,8 +450,7 @@ class PicomcVersionSelector(QWidget):
                 discord_rcp_checkbox.isChecked(),
                 check_updates_checkbox.isChecked(),
                 theme_background_checkbox.isChecked(),
-                self.selected_theme,
+                self.selected_theme  # Pass the selected theme here
-                bleeding_edge_checkbox.isChecked() 
             )
         )
 
@@ -410,20 +462,9 @@ class PicomcVersionSelector(QWidget):
         dialog.setLayout(main_layout)
         dialog.exec_()
 
-    def show_bleeding_edge_popup(self, checkbox):
+    def populate_themes(self, json_files_list_widget):
-        if checkbox.isChecked():
-            response = QMessageBox.question(
-                self,
-                "Bleeding Edge Feature",
-                "Enabling 'Bleeding Edge' mode may expose you to unstable and experimental features. Do you want to enable it anyway? In normal mode, updates are only downloaded when a stable release is made.",
-                QMessageBox.Yes | QMessageBox.No
-            )
-            if response == QMessageBox.No:
-                checkbox.setChecked(False)
-
-    def build_themes_list(self):
         themes_folder = os.path.join(os.getcwd(), "themes")
-        themes_list = []
+        json_files_list_widget.clear()
         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:
@@ -439,12 +480,6 @@ class PicomcVersionSelector(QWidget):
 
                     # Create display text and list item
                     display_text = f"{name}\n{description}\nBy: {author}"
-                    themes_list.append((display_text, json_file))
-        return themes_list
-
-    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
 
@@ -509,16 +544,9 @@ 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:
@@ -638,14 +666,13 @@ class PicomcVersionSelector(QWidget):
         ## REPOSITORY BLOCK ENDS
 
 
-    def save_settings(self, is_rcp_enabled, check_updates_on_start, theme_background, selected_theme, is_bleeding):
+    def save_settings(self, is_rcp_enabled, check_updates_on_start, theme_background, selected_theme):
         config_path = "config.json"
         updated_config = {
             "IsRCPenabled": is_rcp_enabled,
             "CheckUpdate": check_updates_on_start,
             "ThemeBackground": theme_background,
-            "Theme": selected_theme,
+            "Theme": selected_theme
-            "IsBleeding": is_bleeding
         }
 
         # Update config values
@@ -662,6 +689,20 @@ class PicomcVersionSelector(QWidget):
         )
         self.__init__()
 
+    def get_palette(self, palette_type):
+        """Retrieve the corresponding palette based on the palette type."""
+        palettes = {
+            "Dark": self.create_dark_palette,
+            "Obsidian": self.create_obsidian_palette,
+            "Redstone": self.create_redstone_palette,
+            "Alpha": self.create_alpha_palette,
+            "Strawberry": self.create_strawberry_palette,
+            "Native": self.create_native_palette,
+            "Christmas": self.create_christmas_palette,
+        }
+        # Default to dark palette if the type is not specified or invalid
+        return palettes.get(palette_type, self.create_dark_palette)()
+
     def get_system_info(self):
         # Get system information
         java_version = subprocess.getoutput("java -version 2>&1 | head -n 1")
@@ -701,16 +742,16 @@ class PicomcVersionSelector(QWidget):
 
     def open_game_directory(self):
         try:
-            # Run the command using modulecli
+            # Run the command and capture the output
-            command = "instance dir"
+            result = subprocess.run(['picomc', 'instance', 'dir'], capture_output=True, text=True, check=True)
-            result = modulecli.run_command(command)
+            game_directory = result.stdout.strip()
-            game_directory = result.strip()
 
             # Open the directory in the system's file explorer
             QDesktopServices.openUrl(QUrl.fromLocalFile(game_directory))
-        except Exception as e:
+        except subprocess.CalledProcessError as e:
             print(f"Error running picomc command: {e}")
 
+
     def populate_installed_versions(self):
         config_path = "config.json"
         
@@ -731,17 +772,20 @@ class PicomcVersionSelector(QWidget):
 
         # Run the command and capture the output
         try:
-            command = "version list"
+            process = subprocess.Popen(['picomc', 'version', 'list'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            output = modulecli.run_command(command)
+            output, error = process.communicate()
             
-            if not output:
+            if process.returncode != 0:
-                raise Exception("Failed to get output from modulecli")
+                raise subprocess.CalledProcessError(process.returncode, process.args, output=output, stderr=error)
-        except Exception as e:
+        except FileNotFoundError:
-            logging.error("Error running 'picomc': %s", e)
+            logging.error("'picomc' command not found. Please ensure it's installed and in your PATH.")
+            return
+        except subprocess.CalledProcessError as e:
+            logging.error("Error running 'picomc': %s", e.stderr)
             return
 
         # Parse the output and replace '[local]' with a space
-        versions = [version.replace('[local]', ' ').strip() for version in output.splitlines() if version.strip()]
+        versions = [version.replace('[local]', ' ').strip() for version in output.splitlines()]
 
         # Get the last played version from the config
         last_played = self.config.get("LastPlayed", "")
@@ -758,22 +802,28 @@ class PicomcVersionSelector(QWidget):
     def populate_installed_versions_normal_order(self):
         # Run the 'picomc instance create default' command at the start
         try:
-            command = "instance create default"
+            process = subprocess.Popen(['picomc', 'instance', 'create', 'default'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            output = modulecli.run_command(command)
+            output, error = process.communicate()
-            if not output:
+            if process.returncode != 0:
-                raise Exception("Failed to get output from modulecli for 'instance create default'")
+                raise subprocess.CalledProcessError(process.returncode, process.args, error)
-        except Exception as e:
+        except FileNotFoundError:
-            logging.error("Error creating default instance: %s", str(e))
+            logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
+            return
+        except subprocess.CalledProcessError as e:
+            logging.error("Error creating default instance: %s", e.stderr)
             return
 
         # Run the 'picomc version list' command and get the output
         try:
-            command = "version list"
+            process = subprocess.Popen(['picomc', 'version', 'list'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            output = modulecli.run_command(command)
+            output, error = process.communicate()
-            if not output:
+            if process.returncode != 0:
-                raise Exception("Failed to get output from modulecli for 'version list'")
+                raise subprocess.CalledProcessError(process.returncode, process.args, error)
-        except Exception as e:
+        except FileNotFoundError:
-            logging.error("Error: %s", str(e))
+            logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
+            return
+        except subprocess.CalledProcessError as e:
+            logging.error("Error: %s", e.stderr)
             return
 
         # Parse the output and replace '[local]' with a space
@@ -800,7 +850,7 @@ class PicomcVersionSelector(QWidget):
 
         # Check if there are any accounts
         try:
-            account_list_output = modulecli.run_command("account list").strip()
+            account_list_output = subprocess.check_output(["picomc", "account", "list"]).decode("utf-8").strip()
             if not account_list_output:
                 QMessageBox.warning(self, "No Account Available", "Please create an account first.")
                 return
@@ -809,25 +859,18 @@ class PicomcVersionSelector(QWidget):
             if '*' not in account_list_output:
                 QMessageBox.warning(self, "No Account Selected", "Please select an account.")
                 return
-        except Exception as e:
+        except subprocess.CalledProcessError as e:
             error_message = f"Error fetching accounts: {str(e)}"
             logging.error(error_message)
             QMessageBox.critical(self, "Error", error_message)
             return
 
         selected_instance = self.installed_version_combo.currentText()
-        logging.info(f"Selected instance from dropdown: {selected_instance}")
+        logging.info(f"Selected instance: {selected_instance}")
-
-        # Verify the selected instance value before starting the game
-        if not selected_instance:
-            logging.error("No instance selected.")
-            QMessageBox.warning(self, "No Instance Selected", "Please select an instance.")
-            return
 
         play_thread = threading.Thread(target=self.run_game, args=(selected_instance,))
         play_thread.start()
 
-
     def run_game(self, selected_instance):
         try:
             # Set current_state to the selected instance
@@ -842,14 +885,10 @@ class PicomcVersionSelector(QWidget):
             update_thread = threading.Thread(target=self.update_last_played, args=(selected_instance,))
             update_thread.start()
 
-            # Run the game using the modulecli module
+            # Run the game subprocess with the instance_value from config.json
-            command = f"instance launch --version-override {selected_instance} {instance_value}"
+            subprocess.run(['picomc', 'instance', 'launch', '--version-override', selected_instance, instance_value], check=True)
-            output = modulecli.run_command(command)
 
-            if not output:
+        except subprocess.CalledProcessError as e:
-                raise Exception("Failed to get output from modulecli")
-
-        except Exception as e:
             error_message = f"Error playing {selected_instance}: {e}"
             logging.error(error_message)
             # Use QMetaObject.invokeMethod to call showError safely
@@ -861,7 +900,6 @@ class PicomcVersionSelector(QWidget):
             # Reset current_state to "menu" after the game closes
             self.current_state = "menu"
             
-            
     def update_last_played(self, selected_instance):
         config_path = "config.json"
         self.config["LastPlayed"] = selected_instance
@@ -959,16 +997,16 @@ class PicomcVersionSelector(QWidget):
             return
 
         try:
-            command = f"account create {username}"
+            command = ['picomc', 'account', 'create', username]
             if is_microsoft:
-                command += " --ms"
+                command.append('--ms')
 
-            modulecli.run_command(command)
+            subprocess.run(command, check=True)
             QMessageBox.information(dialog, "Success", f"Account '{username}' created successfully!")
             self.populate_accounts_for_all_dialogs()
             dialog.accept()
-        except Exception as e:
+        except subprocess.CalledProcessError as e:
-            error_message = f"Error creating account: {str(e)}"
+            error_message = f"Error creating account: {e.stderr.decode()}"
             logging.error(error_message)
             QMessageBox.critical(dialog, "Error", error_message)
 
@@ -979,36 +1017,19 @@ class PicomcVersionSelector(QWidget):
         return False
 
     def authenticate_account(self, dialog, account_name):
-        # Clean up the account name
+        # Authenticate a selected account
         account_name = account_name.strip().lstrip(" * ")
         if not account_name:
             QMessageBox.warning(dialog, "Warning", "Please select an account to authenticate.")
             return
 
         try:
-            # Create authenticator instance if it doesn't exist
+            subprocess.run(['picomc', 'account', 'authenticate', account_name], check=True)
-            if self.authenticator is None:
+            QMessageBox.information(self, "Success", f"Account '{account_name}' authenticated successfully!")
-                self.authenticator = MinecraftAuthenticator(self)
+        except subprocess.CalledProcessError as e:
-                self.authenticator.auth_finished.connect(self._on_auth_finished)
+            error_message = f"Error authenticating account '{account_name}': {e.stderr.decode()}"
-
-            # 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(dialog, "Error", error_message)
+            QMessageBox.critical(self, "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
@@ -1021,20 +1042,22 @@ class PicomcVersionSelector(QWidget):
         confirm_dialog = QMessageBox.question(dialog, "Confirm Removal", confirm_message, QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
         if confirm_dialog == QMessageBox.Yes:
             try:
-                command = f"account remove {username}"
+                subprocess.run(['picomc', 'account', 'remove', username], check=True)
-                modulecli.run_command(command)
                 QMessageBox.information(dialog, "Success", f"Account '{username}' removed successfully!")
                 self.populate_accounts_for_all_dialogs()
-            except Exception as e:
+            except subprocess.CalledProcessError as e:
-                error_message = f"Error removing account: {str(e)}"
+                error_message = f"Error removing account: {e.stderr.decode()}"
                 logging.error(error_message)
                 QMessageBox.critical(dialog, "Error", error_message)
 
+
     def populate_accounts(self, account_combo):
         # Populate the account dropdown
         try:
-            command = "account list"
+            process = subprocess.Popen(['picomc', 'account', 'list'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            output = modulecli.run_command(command)
+            output, error = process.communicate()
+            if process.returncode != 0:
+                raise subprocess.CalledProcessError(process.returncode, process.args, error)
 
             # Process accounts, keeping the one with "*" at the top
             accounts = output.splitlines()
@@ -1059,8 +1082,10 @@ class PicomcVersionSelector(QWidget):
             for account in normal_accounts:
                 account_combo.addItem(account)
 
-        except Exception as e:
+        except FileNotFoundError:
-            logging.error(f"Error: {str(e)}")
+            logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
+        except subprocess.CalledProcessError as e:
+            logging.error(f"Error: {e.stderr}")
 
     def populate_accounts_for_all_dialogs(self):
         # Update account dropdowns in all open dialogs
@@ -1077,38 +1102,22 @@ class PicomcVersionSelector(QWidget):
             return
 
         try:
-            command = f"account setdefault {account_name}"
+            subprocess.run(['picomc', 'account', 'setdefault', account_name], check=True)
-            modulecli.run_command(command)
             QMessageBox.information(self, "Success", f"Account '{account_name}' set as default!")
             self.populate_accounts_for_all_dialogs()
-        except Exception as e:
+        except subprocess.CalledProcessError as e:
-            error_message = f"Error setting default account '{account_name}': {str(e)}"
+            error_message = f"Error setting default account '{account_name}': {e.stderr.decode()}"
             logging.error(error_message)
             QMessageBox.critical(self, "Error", error_message)
 
-
     def show_about_dialog(self):
         # Load the version number from version.json
         try:
             with open('version.json', 'r') as version_file:
                 version_data = json.load(version_file)
                 version_number = version_data.get('version', 'unknown version')
-                version_bleeding = version_data.get('versionBleeding', None)
         except (FileNotFoundError, json.JSONDecodeError):
             version_number = 'unknown version'
-            version_bleeding = None
-
-        # Check the configuration for IsBleeding
-        try:
-            with open('config.json', 'r') as config_file:
-                config_data = json.load(config_file)
-                is_bleeding = config_data.get('IsBleeding', False)
-        except (FileNotFoundError, json.JSONDecodeError):
-            is_bleeding = False
-
-        # Use versionBleeding if IsBleeding is true
-        if is_bleeding and version_bleeding:
-            version_number = version_bleeding
 
         about_message = (
             f"PicoDulce Launcher (v{version_number})\n\n"
@@ -1125,39 +1134,19 @@ class PicomcVersionSelector(QWidget):
             with open("version.json") as f:
                 local_version_info = json.load(f)
                 local_version = local_version_info.get("version")
-                local_version_bleeding = local_version_info.get("versionBleeding")
                 logging.info(f"Local version: {local_version}")
-                logging.info(f"Local bleeding version: {local_version_bleeding}")
-
-                with open("config.json") as config_file:
-                    config = json.load(config_file)
-                    is_bleeding = config.get("IsBleeding", False)
-
                 if local_version:
                     remote_version_info = self.fetch_remote_version()
                     remote_version = remote_version_info.get("version")
-                    remote_version_bleeding = remote_version_info.get("versionBleeding")
                     logging.info(f"Remote version: {remote_version}")
-                    logging.info(f"Remote bleeding version: {remote_version_bleeding}")
+                    if remote_version and remote_version != local_version:
-
-                    if is_bleeding:
-                        remote_version_to_check = remote_version_bleeding
-                        local_version_to_check = local_version_bleeding
-                    else:
-                        remote_version_to_check = remote_version
-                        local_version_to_check = local_version
-                    
-                    if remote_version_to_check and (remote_version_to_check != local_version_to_check):
-                        if is_bleeding:
-                            update_message = f"Do you want to update to the bleeding edge version ({remote_version_bleeding})?"
-                        else:
                         update_message = f"A new version ({remote_version}) is available!\nDo you want to download it now?"
                         update_dialog = QMessageBox.question(self, "Update Available", update_message, QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
                         if update_dialog == QMessageBox.Yes:
                             # Download and apply the update
                             self.download_update(remote_version_info)
                     else:
-                        print(f"You already have the latest version!")
+                        print("Up to Date", "You already have the latest version!")
                 else:
                     logging.error("Failed to read local version information.")
                     QMessageBox.critical(self, "Error", "Failed to check for updates.")
@@ -1170,32 +1159,12 @@ class PicomcVersionSelector(QWidget):
             with open("version.json") as f:
                 local_version_info = json.load(f)
                 local_version = local_version_info.get("version")
-                local_version_bleeding = local_version_info.get("versionBleeding")
                 logging.info(f"Local version: {local_version}")
-                logging.info(f"Local bleeding version: {local_version_bleeding}")
-
-                with open("config.json") as config_file:
-                    config = json.load(config_file)
-                    is_bleeding = config.get("IsBleeding", False)
-
                 if local_version:
                     remote_version_info = self.fetch_remote_version()
                     remote_version = remote_version_info.get("version")
-                    remote_version_bleeding = remote_version_info.get("versionBleeding")
                     logging.info(f"Remote version: {remote_version}")
-                    logging.info(f"Remote bleeding version: {remote_version_bleeding}")
+                    if remote_version and remote_version != local_version:
-
-                    if is_bleeding:
-                        remote_version_to_check = remote_version_bleeding
-                        local_version_to_check = local_version_bleeding
-                    else:
-                        remote_version_to_check = remote_version
-                        local_version_to_check = local_version
-                    
-                    if remote_version_to_check and (remote_version_to_check != local_version_to_check):
-                        if is_bleeding:
-                            update_message = f"Do you want to update to the bleeding edge version ({remote_version_bleeding})?"
-                        else:
                         update_message = f"A new version ({remote_version}) is available!\nDo you want to download it now?"
                         update_dialog = QMessageBox.question(self, "Update Available", update_message, QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
                         if update_dialog == QMessageBox.Yes:
@@ -1303,7 +1272,7 @@ class PicomcVersionSelector(QWidget):
 
 
     def open_mod_loader_and_version_menu(self):
-        dialog = ModLoaderAndVersionMenu(parent=self)
+        dialog = ModLoaderAndVersionMenu()
         dialog.finished.connect(self.populate_installed_versions)
         dialog.exec_()
 
@@ -1316,24 +1285,16 @@ class DownloadThread(QThread):
 
     def run(self):
         try:
-            command = f"version prepare {self.version}"
+            subprocess.run(['picomc', 'version', 'prepare', self.version], check=True)
-            modulecli.run_command(command)
             self.completed.emit(True, f"Version {self.version} prepared successfully!")
-        except Exception as e:
+        except subprocess.CalledProcessError as e:
-            error_message = f"Error preparing {self.version}: {str(e)}"
+            error_message = f"Error preparing {self.version}: {e.stderr.decode()}"
             self.completed.emit(False, error_message)
 
 class ModLoaderAndVersionMenu(QDialog):
-    def __init__(self, parent=None):
+    def __init__(self):
-        super().__init__(parent)
+        super().__init__()
         self.setWindowTitle("Mod Loader and Version Menu")
-        # Set window position relative to parent
-        if parent:
-            parent_pos = parent.pos()
-            x = parent_pos.x() + (parent.width() - 400) // 2
-            y = parent_pos.y() + (parent.height() - 300) // 2
-            self.setGeometry(x, y, 400, 300)
-        else:
         self.setGeometry(100, 100, 400, 300)
 
         main_layout = QVBoxLayout(self)
@@ -1344,11 +1305,11 @@ class ModLoaderAndVersionMenu(QDialog):
         # Create tabs
         install_mod_tab = QWidget()
         download_version_tab = QWidget()
-        instances_tab = QWidget()
+        instances_tab = QWidget()  # New tab for instances
 
         tab_widget.addTab(download_version_tab, "Download Version")
         tab_widget.addTab(install_mod_tab, "Install Mod Loader")
-        tab_widget.addTab(instances_tab, "Instances")
+        tab_widget.addTab(instances_tab, "Instances")  # Add the new tab
 
         # Add content to "Install Mod Loader" tab
         self.setup_install_mod_loader_tab(install_mod_tab)
@@ -1400,8 +1361,11 @@ class ModLoaderAndVersionMenu(QDialog):
         if instance_name:
             try:
                 # Run the "picomc instance create" command
-                command = f"instance create {instance_name}"
+                process = subprocess.Popen(['picomc', 'instance', 'create', instance_name], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-                modulecli.run_command(command)
+                output, error = process.communicate()
+
+                if process.returncode != 0:
+                    raise subprocess.CalledProcessError(process.returncode, process.args, error)
 
                 # Notify the user that the instance was created
                 QMessageBox.information(self, "Instance Created", f"Instance '{instance_name}' has been created successfully.")
@@ -1412,9 +1376,11 @@ class ModLoaderAndVersionMenu(QDialog):
                 # Optionally select the newly created instance
                 self.on_instance_selected(self.instances_list_widget.item(self.instances_list_widget.count() - 1))
 
-            except Exception as e:
+            except FileNotFoundError:
-                logging.error("Error creating instance: %s", str(e))
+                logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
-                QMessageBox.critical(self, "Error", f"Failed to create instance: {str(e)}")
+            except subprocess.CalledProcessError as e:
+                logging.error("Error creating instance: %s", e.stderr)
+                QMessageBox.critical(self, "Error", f"Failed to create instance: {e.stderr}")
         else:
             QMessageBox.warning(self, "Invalid Input", "Please enter a valid instance name.")
 
@@ -1425,8 +1391,14 @@ class ModLoaderAndVersionMenu(QDialog):
 
         try:
             # Run the "picomc instance rename" command
-            command = f"instance rename {old_instance_name} {new_instance_name}"
+            process = subprocess.Popen(
-            modulecli.run_command(command)
+                ['picomc', 'instance', 'rename', old_instance_name, new_instance_name],
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+            )
+            output, error = process.communicate()
+
+            if process.returncode != 0:
+                raise subprocess.CalledProcessError(process.returncode, process.args, error)
 
             QMessageBox.information(self, "Instance Renamed", f"Instance '{old_instance_name}' has been renamed to '{new_instance_name}' successfully.")
 
@@ -1438,9 +1410,11 @@ class ModLoaderAndVersionMenu(QDialog):
             if matching_items:
                 self.instances_list_widget.setCurrentItem(matching_items[0])
 
-        except Exception as e:
+        except FileNotFoundError:
-            logging.error("Error renaming instance: %s", str(e))
+            logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
-            QMessageBox.critical(self, "Error", f"Failed to rename instance: {str(e)}")
+        except subprocess.CalledProcessError as e:
+            logging.error("Error renaming instance: %s", e.stderr)
+            QMessageBox.critical(self, "Error", f"Failed to rename instance: {e.stderr}")
 
     def delete_instance(self, instance_name):
         if instance_name == "default":
@@ -1455,8 +1429,11 @@ class ModLoaderAndVersionMenu(QDialog):
         if confirm_delete == QMessageBox.Yes:
             try:
                 # Run the "picomc instance delete" command
-                command = f"instance delete {instance_name}"
+                process = subprocess.Popen(['picomc', 'instance', 'delete', instance_name], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-                modulecli.run_command(command)
+                output, error = process.communicate()
+
+                if process.returncode != 0:
+                    raise subprocess.CalledProcessError(process.returncode, process.args, error)
 
                 # Notify the user that the instance was deleted
                 QMessageBox.information(self, "Instance Deleted", f"Instance '{instance_name}' has been deleted successfully.")
@@ -1464,15 +1441,18 @@ class ModLoaderAndVersionMenu(QDialog):
                 # Reload the instances list
                 self.load_instances()
 
-            except Exception as e:
+            except FileNotFoundError:
-                logging.error("Error deleting instance: %s", str(e))
+                logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
-                QMessageBox.critical(self, "Error", f"Failed to delete instance: {str(e)}")
+            except subprocess.CalledProcessError as e:
+                logging.error("Error deleting instance: %s", e.stderr)
+                QMessageBox.critical(self, "Error", f"Failed to delete instance: {e.stderr}")
 
     def load_instances(self):
         try:
-            # Run the "picomc instance list" command
+            process = subprocess.Popen(['picomc', 'instance', 'list'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            command = "instance list"
+            output, error = process.communicate()
-            output = modulecli.run_command(command)
+            if process.returncode != 0:
+                raise subprocess.CalledProcessError(process.returncode, process.args, error)
 
             # Parse the output and add each instance to the list widget
             instances = output.splitlines()
@@ -1482,9 +1462,10 @@ class ModLoaderAndVersionMenu(QDialog):
                 self.instances_list_widget.addItem(item)
                 self.add_instance_buttons(item, instance)
 
-        except Exception as e:
+        except FileNotFoundError:
-            logging.error("Error fetching instances: %s", str(e))
+            logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
-
+        except subprocess.CalledProcessError as e:
+            logging.error("Error fetching instances: %s", e.stderr)
 
     def add_instance_buttons(self, list_item, instance_name):
         widget = QWidget()
@@ -1640,19 +1621,21 @@ class ModLoaderAndVersionMenu(QDialog):
                 options.append('--beta')
             if options:
                 try:
-                    command = 'version list ' + ' '.join(options)
+                    process = subprocess.Popen(['picomc', 'version', 'list'] + options, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-                    output = modulecli.run_command(command)
+                    output, error = process.communicate()
-                    if "Error" in output:
+                    if process.returncode != 0:
-                        logging.error(output)
+                        raise subprocess.CalledProcessError(process.returncode, process.args, error)
+                except FileNotFoundError:
+                    logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
+                    return
+                except subprocess.CalledProcessError as e:
+                    logging.error("Error: %s", e.stderr)
                     return
 
                 # Parse the output and replace '[local]' with a space
                 versions = output.splitlines()
                 versions = [version.replace('[local]', ' ').strip() for version in versions]
                 self.version_combo.addItems(versions)
-                except Exception as e:
-                    logging.error("Unexpected error: %s", e)
-                    return
             # Update the download button state whenever versions are updated
             self.update_download_button_state()
 
@@ -1709,10 +1692,15 @@ class ModLoaderAndVersionMenu(QDialog):
 
     def populate_available_releases(self, version_combo, install_forge, install_fabric):
         try:
-            command = "version list --release"
+            process = subprocess.Popen(['picomc', 'version', 'list', '--release'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            output = modulecli.run_command(command)
+            output, error = process.communicate()
-        except Exception as e:
+            if process.returncode != 0:
-            logging.error("Error: %s", str(e))
+                raise subprocess.CalledProcessError(process.returncode, process.args, error)
+        except FileNotFoundError:
+            logging.error("'picomc' command not found. Please make sure it's installed and in your PATH.")
+            return
+        except subprocess.CalledProcessError as e:
+            logging.error("Error: %s", e.stderr)
             return
 
         if install_fabric:
@@ -1742,13 +1730,12 @@ class ModLoaderAndVersionMenu(QDialog):
 
         try:
             if mod_loader == 'forge':
-                command = f"mod loader forge install --game {version}"
+                subprocess.run(['picomc', 'mod', 'loader', 'forge', 'install', '--game', version], check=True)
             elif mod_loader == 'fabric':
-                command = f"mod loader fabric install {version}"
+                subprocess.run(['picomc', 'mod', 'loader', 'fabric', 'install', version], check=True)
-            modulecli.run_command(command)
             QMessageBox.information(self, "Success", f"{mod_loader.capitalize()} installed successfully for version {version}!")
-        except Exception as e:
+        except subprocess.CalledProcessError as e:
-            error_message = f"Error installing {mod_loader} for version {version}: {str(e)}"
+            error_message = f"Error installing {mod_loader} for version {version}: {e.stderr.decode()}"
             QMessageBox.critical(self, "Error", error_message)
             logging.error(error_message)
 

requirements.txt

@@ -1,6 +1,4 @@
 picomc
 PyQt5
 requests
-aiohttp
 pypresence
-tqdm

version.json

@@ -1,15 +1,11 @@
 {
-  "version": "0.13.1",
+  "version": "0.11.7",
   "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",
-    "https://raw.githubusercontent.com/nixietab/picodulce/main/modulecli.py"
-  ],
-  "versionBleeding": "0.13.1-202"
 }