Implement feedback for filepicker optimalisations

* feat: started work on saving plugin order

* feat: implemented local ReorderableList

* feat: reoder complete except for usage of DFL

* switched to using dfl reorderableList

* fix: added missing file and removed frag

* updated to newest dfl

* Update defsettings.json

* fix: plugin order was missing on init

* fix: now await pluginOrder

* fix: moved the plugin-order load to plugin-loader

* chore: v6 and dfl bump

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -12,6 +12,7 @@ body:
         - label: I have searched existing issues
         - label: This issue is not a duplicate of an existing one
         - label: I have checked the [common issues section in the readme file](https://github.com/SteamDeckHomebrew/decky-loader#-common-issues)
+        - label: I have attached logs to this bug report (failure to include logs will mean your issue will not be responded too).
 
   - type: textarea
     attributes:
@@ -70,4 +71,4 @@ body:
       description: Please reboot your deck (if possible) when attempting to recreate the issue, then run ``cd ~ && journalctl -b0  -u plugin_loader.service > deckylog.txt``. This will save the log file to ``~`` aka ``/home/deck``. Please upload the file here
       placeholder: deckylog.txt
     validations:
-      required: false
+      required: true

.github/workflows/build.yml

@@ -69,7 +69,7 @@ jobs:
       run: pnpm run build
 
     - name: Build Python Backend 🛠️
-      run: pyinstaller --noconfirm --onefile --name "PluginLoader" --add-data ./backend/static:/static --add-data ./backend/legacy:/legacy ./backend/*.py
+      run: pyinstaller --noconfirm --onefile --name "PluginLoader" --add-data ./backend/static:/static --add-data ./backend/legacy:/legacy --add-data ./plugin:/plugin ./backend/*.py
         
     - name: Upload package artifact ⬆️
       if: ${{ !env.ACT }}
@@ -84,6 +84,49 @@ jobs:
       with:
         path: ./dist/PluginLoader
 
+  build-win:
+    name: Build PluginLoader for Win
+    runs-on: windows-2022
+
+    steps:
+    - name: Checkout 🧰
+      uses: actions/checkout@v3
+
+    - name: Set up NodeJS 18 💎
+      uses: actions/setup-node@v3
+      with:
+        node-version: 18
+      
+    - name: Set up Python 3.10.2 🐍
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10.2"
+        
+    - name: Install Python dependencies ⬇️
+      run: |
+        python -m pip install --upgrade pip
+        pip install pyinstaller==5.5
+        pip install -r requirements.txt
+
+    - name: Install JS dependencies ⬇️
+      working-directory: ./frontend
+      run: |
+        npm i -g pnpm
+        pnpm i --frozen-lockfile
+
+    - name: Build JS Frontend 🛠️
+      working-directory: ./frontend
+      run: pnpm run build
+
+    - name: Build Python Backend 🛠️
+      run: pyinstaller --noconfirm --onefile --name "PluginLoader" --add-data "./backend/static;/static" --add-data "./backend/legacy;/legacy" --add-data "./plugin;/plugin" ./backend/main.py
+        
+    - name: Upload package artifact ⬆️
+      uses: actions/upload-artifact@v3
+      with:
+        name: PluginLoader Win
+        path: ./dist/PluginLoader.exe
+
   release:
     name: Release stable version of the package
     if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.release == 'release' }}

.github/workflows/edit-check.yml

@@ -0,0 +1,55 @@
+name: Push Updated Plugin Stub to Template
+
+on: push
+
+jobs:
+  copy-stub:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@8230315d06ad95c617244d2f265d237a1682d445
+      with:
+        ref: ${{ github.sha }}
+        fetch-depth: 0
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Checkout
+      uses: actions/checkout@v2
+      
+    - name: Get changed files
+      id: changed-files
+      uses: tj-actions/changed-files@v35.6.3
+      with:
+        separator: ","
+        files: |
+          plugin/*
+          
+    - name: Is stub changed
+      id: changed-stub
+      run: |
+        STUB_CHANGED="false"
+        PATHS=(plugin plugin/decky_plugin.pyi)
+        SHA=${{ github.sha }}
+        SHA_PREV=HEAD^
+        FILES=$(git diff $SHA_PREV..$SHA --name-only -- ${PATHS[@]} | jq -Rsc 'split("\n")[:-1] | join (",")')
+        if [[ "$FILES" == *"plugin/decky_plugin.pyi"* ]]; then
+          $STUB_CHANGED="true"
+          echo "Stub has changed, pushing updated stub"
+        else
+          echo "Stub has not changed, exiting."
+          echo "has_changed=$STUB_CHANGED" >> $GITHUB_OUTPUT
+          exit 0
+        fi
+        echo "has_changed=$STUB_CHANGED" >> $GITHUB_OUTPUT
+
+    - name: Push updated stub
+      if: steps.changed-stub.outputs.has_changed == true
+      uses: dmnemec/copy_file_to_another_repo_action@bbebd3da22e4a37d04dca5f782edd5201cb97083
+      env:
+        API_TOKEN_GITHUB: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        source_file: 'plugin/decky_plugin.pyi'
+        destination_repo: 'SteamDeckHomebrew/decky-plugin-template'
+        user_email: '11465594+TrainDoctor@users.noreply.github.com'
+        user_name: 'TrainDoctor'
+        commit_message: 'Updated template with latest plugin stub changes'

.github/workflows/lint.yml

@@ -15,13 +15,3 @@ jobs:
           pushd frontend
           npm install
           npm run lint
-
-      - name: Run black (Python formatting)
-        uses: lgeiger/black-action@v1.0.1
-        with:
-          args: "./backend --experimental-string-processing --config ./backend/pyproject.toml"
-
-      - name: Run ruff (Python linting)
-        uses: jpetrucciani/ruff-check@main
-        with:
-          path: "./backend"

.vscode/defsettings.json

@@ -4,4 +4,4 @@
     "deckpass"  : "ssap",
     "deckkey"   : "-i ${env:HOME}/.ssh/id_rsa",
     "deckdir"   : "/home/deck"
-}
+}

README.md

@@ -11,7 +11,7 @@
   <a href="https://github.com/SteamDeckHomebrew/decky-loader/stargazers"><img src="https://img.shields.io/github/stars/SteamDeckHomebrew/decky-loader" /></a>
   <a href="https://github.com/SteamDeckHomebrew/decky-loader/commits/main"><img src="https://img.shields.io/github/last-commit/SteamDeckHomebrew/decky-loader.svg" /></a>
   <a href="https://github.com/SteamDeckHomebrew/decky-loader/blob/main/LICENSE"><img src="https://img.shields.io/github/license/SteamDeckHomebrew/decky-loader" /></a>
-  <a href="https://discord.gg/ZU74G2NJzk"><img src="https://img.shields.io/discord/960281551428522045?color=%235865F2&label=discord" /></a>
+  <a href="https://deckbrew.xyz/discord"><img src="https://img.shields.io/discord/960281551428522045?color=%235865F2&label=discord" /></a>
   <br>
   <br>
   <img src="https://media.discordapp.net/attachments/966017112244125756/1012466063893610506/main.jpg" alt="Decky screenshot" width="80%">
@@ -62,7 +62,7 @@ For more information about Decky Loader as well as documentation and development
 
 ### 👋 Uninstallation
 
-We are sorry to see you go! If you are considering uninstalling because you are having issues, please consider [opening an issue](https://github.com/SteamDeckHomebrew/decky-loader/issues) or [joining our Discord](https://discord.gg/ZU74G2NJzk) so we can help you and other users.
+We are sorry to see you go! If you are considering uninstalling because you are having issues, please consider [opening an issue](https://github.com/SteamDeckHomebrew/decky-loader/issues) or [joining our Discord](https://deckbrew.xyz/discord) so we can help you and other users.
 
 1. Press the <img src="./docs/images/light/steam.svg#gh-dark-mode-only" height=16><img src="./docs/images/dark/steam.svg#gh-light-mode-only" height=16> button and open the Power menu.
 1. Select "Switch to Desktop".
@@ -84,15 +84,16 @@ Now that you have Decky Loader installed, you can start using plugins. Each plug
 
 ### 🛠️ Plugin Development
 
-There is no complete plugin development documentation yet. However a good starting point is the [plugin template repository](https://github.com/SteamDeckHomebrew/decky-plugin-template). Consider [joining our Discord](https://discord.gg/ZU74G2NJzk) if you have any questions.
+There is no complete plugin development documentation yet. However a good starting point is the [plugin template repository](https://github.com/SteamDeckHomebrew/decky-plugin-template). Consider [joining our Discord](https://deckbrew.xyz/discord) if you have any questions.
 
 ### 🤝 Contributing
 
-Please consult [the wiki page regarding development](https://deckbrew.xyz/en/loader-dev/development) for more information on installing development versions of Decky Loader. You can also install the Steam Deck UI on a Windows or Linux computer for testing by following [this YouTube guide](https://youtu.be/1IAbZte8e7E?t=112).
+Please consult [the wiki page regarding development](https://wiki.deckbrew.xyz/en/loader-dev/development) for more information on installing development versions of Decky Loader. You can also install the Steam Deck UI on a Windows or Linux computer for testing by following [this YouTube guide](https://youtu.be/1IAbZte8e7E?t=112).
 
 1. Clone the repository using the latest commit to main before starting your PR.
 1. In your clone of the repository, run these commands.
    ```bash
+   cd frontend
    pnpm i
    pnpm run build
    ```

backend/browser.py

@@ -1,33 +1,27 @@
 # Full imports
 import json
-
 # import pprint
 # from pprint import pformat
 
 # Partial imports
-from aiohttp import ClientSession
-from asyncio import sleep
+from aiohttp import ClientSession, web
+from asyncio import get_event_loop, sleep
+from concurrent.futures import ProcessPoolExecutor
 from hashlib import sha256
 from io import BytesIO
 from logging import getLogger
-from os import R_OK, W_OK, path, listdir, access, mkdir
+from os import R_OK, W_OK, path, rename, listdir, access, mkdir
 from shutil import rmtree
-from subprocess import call
 from time import time
 from zipfile import ZipFile
+from localplatform import chown, chmod
 
 # Local modules
-from helpers import (
-    get_ssl_context,
-    get_user,
-    get_user_group,
-    download_remote_binary_to_path,
-)
+from helpers import get_ssl_context, download_remote_binary_to_path
 from injector import get_gamepadui_tab
 
 logger = getLogger("Browser")
 
-
 class PluginInstallContext:
     def __init__(self, artifact, name, version, hash) -> None:
         self.artifact = artifact
@@ -35,12 +29,12 @@ class PluginInstallContext:
         self.version = version
         self.hash = hash
 
-
 class PluginBrowser:
-    def __init__(self, plugin_path, plugins, loader) -> None:
+    def __init__(self, plugin_path, plugins, loader, settings) -> None:
         self.plugin_path = plugin_path
         self.plugins = plugins
         self.loader = loader
+        self.settings = settings
         self.install_requests = {}
 
     def _unzip_to_plugin_dir(self, zip, name, hash):
@@ -49,41 +43,32 @@ class PluginBrowser:
             return False
         zip_file = ZipFile(zip)
         zip_file.extractall(self.plugin_path)
-        plugin_dir = self.find_plugin_folder(name)
-        code_chown = call(
-            ["chown", "-R", get_user() + ":" + get_user_group(), plugin_dir]
-        )
-        code_chmod = call(["chmod", "-R", "555", plugin_dir])
-        if code_chown != 0 or code_chmod != 0:
-            logger.error(
-                f"chown/chmod exited with a non-zero exit code (chown: {code_chown},"
-                f" chmod: {code_chmod})"
-            )
+        plugin_dir = path.join(self.plugin_path, self.find_plugin_folder(name))
+
+        if not chown(plugin_dir) or not chmod(plugin_dir, 555):
+            logger.error(f"chown/chmod exited with a non-zero exit code")
             return False
         return True
-
+    
     async def _download_remote_binaries_for_plugin_with_name(self, pluginBasePath):
         rv = False
         try:
-            packageJsonPath = path.join(pluginBasePath, "package.json")
-            pluginBinPath = path.join(pluginBasePath, "bin")
+            packageJsonPath = path.join(pluginBasePath, 'package.json')
+            pluginBinPath = path.join(pluginBasePath, 'bin')
 
             if access(packageJsonPath, R_OK):
                 with open(packageJsonPath, "r", encoding="utf-8") as f:
                     packageJson = json.load(f)
-                    if (
-                        "remote_binary" in packageJson
-                        and len(packageJson["remote_binary"]) > 0
-                    ):
+                    if "remote_binary" in packageJson and len(packageJson["remote_binary"]) > 0:
                         # create bin directory if needed.
-                        call(["chmod", "-R", "777", pluginBasePath])
+                        chmod(pluginBasePath, 777)
                         if access(pluginBasePath, W_OK):
-
+                            
                             if not path.exists(pluginBinPath):
                                 mkdir(pluginBinPath)
-
+                            
                             if not access(pluginBinPath, W_OK):
-                                call(["chmod", "-R", "777", pluginBinPath])
+                                chmod(pluginBinPath, 777)
 
                         rv = True
                         for remoteBinary in packageJson["remote_binary"]:
@@ -91,57 +76,42 @@ class PluginBrowser:
                             binName = remoteBinary["name"]
                             binURL = remoteBinary["url"]
                             binHash = remoteBinary["sha256hash"]
-                            if not await download_remote_binary_to_path(
-                                binURL, binHash, path.join(pluginBinPath, binName)
-                            ):
+                            if not await download_remote_binary_to_path(binURL, binHash, path.join(pluginBinPath, binName)):
                                 rv = False
-                                raise Exception(
-                                    "Error Downloading Remote Binary"
-                                    f" {binName}@{binURL} with hash {binHash} to"
-                                    f" {path.join(pluginBinPath, binName)}"
-                                )
+                                raise Exception(f"Error Downloading Remote Binary {binName}@{binURL} with hash {binHash} to {path.join(pluginBinPath, binName)}")
 
-                        call(
-                            [
-                                "chown",
-                                "-R",
-                                get_user() + ":" + get_user_group(),
-                                self.plugin_path,
-                            ]
-                        )
-                        call(["chmod", "-R", "555", pluginBasePath])
+                        chown(self.plugin_path)
+                        chmod(pluginBasePath, 555)
                     else:
                         rv = True
-                        logger.debug("No Remote Binaries to Download")
-
+                        logger.debug(f"No Remote Binaries to Download")
+                
         except Exception as e:
             rv = False
             logger.debug(str(e))
 
         return rv
 
+    """Return the filename (only) for the specified plugin"""
     def find_plugin_folder(self, name):
         for folder in listdir(self.plugin_path):
             try:
-                with open(
-                    path.join(self.plugin_path, folder, "plugin.json"),
-                    "r",
-                    encoding="utf-8",
-                ) as f:
+                with open(path.join(self.plugin_path, folder, 'plugin.json'), "r", encoding="utf-8") as f:
                     plugin = json.load(f)
 
-                if plugin["name"] == name:
-                    return str(path.join(self.plugin_path, folder))
-            except Exception:
+                if plugin['name'] == name:
+                    return folder
+            except:
                 logger.debug(f"skipping {folder}")
 
     async def uninstall_plugin(self, name):
         if self.loader.watcher:
             self.loader.watcher.disabled = True
         tab = await get_gamepadui_tab()
+        plugin_dir = path.join(self.plugin_path, self.find_plugin_folder(name))
         try:
             logger.info("uninstalling " + name)
-            logger.info(" at dir " + self.find_plugin_folder(name))
+            logger.info(" at dir " + plugin_dir)
             logger.debug("calling frontend unload for %s" % str(name))
             res = await tab.evaluate_js(f"DeckyPluginLoader.unloadPlugin('{name}')")
             logger.debug("result of unload from UI: %s", res)
@@ -154,15 +124,17 @@ class PluginBrowser:
                 logger.debug("Plugin %s was stopped", name)
                 del self.plugins[name]
                 logger.debug("Plugin %s was removed from the dictionary", name)
+                current_plugin_order = self.settings.getSetting("pluginOrder")
+                current_plugin_order.remove(name)
+                self.settings.setSetting("pluginOrder", current_plugin_order)
+                logger.debug("Plugin %s was removed from the pluginOrder setting", name)
             logger.debug("removing files %s" % str(name))
-            rmtree(self.find_plugin_folder(name))
+            rmtree(plugin_dir)
         except FileNotFoundError:
             logger.warning(f"Plugin {name} not installed, skipping uninstallation")
         except Exception as e:
-            logger.error(
-                f"Plugin {name} in {self.find_plugin_folder(name)} was not uninstalled"
-            )
-            logger.error("Error at %s", exc_info=e)
+            logger.error(f"Plugin {name} in {plugin_dir} was not uninstalled")
+            logger.error(f"Error at %s", exc_info=e)
         if self.loader.watcher:
             self.loader.watcher.disabled = False
 
@@ -174,11 +146,8 @@ class PluginBrowser:
             pluginFolderPath = self.find_plugin_folder(name)
             if pluginFolderPath:
                 isInstalled = True
-        except Exception:
-            logger.error(
-                f"Failed to determine if {name} is already installed, continuing"
-                " anyway."
-            )
+        except:
+            logger.error(f"Failed to determine if {name} is already installed, continuing anyway.")
         logger.info(f"Installing {name} (Version: {version})")
         async with ClientSession() as client:
             logger.debug(f"Fetching {artifact}")
@@ -192,26 +161,28 @@ class PluginBrowser:
                     try:
                         logger.debug("Uninstalling existing plugin...")
                         await self.uninstall_plugin(name)
-                    except Exception:
+                    except:
                         logger.error(f"Plugin {name} could not be uninstalled.")
                 logger.debug("Unzipping...")
                 ret = self._unzip_to_plugin_dir(res_zip, name, hash)
                 if ret:
-                    plugin_dir = self.find_plugin_folder(name)
-                    ret = await self._download_remote_binaries_for_plugin_with_name(
-                        plugin_dir
-                    )
+                    plugin_folder = self.find_plugin_folder(name)
+                    plugin_dir = path.join(self.plugin_path, plugin_folder)
+                    ret = await self._download_remote_binaries_for_plugin_with_name(plugin_dir)
                     if ret:
                         logger.info(f"Installed {name} (Version: {version})")
                         if name in self.loader.plugins:
                             self.loader.plugins[name].stop()
                             self.loader.plugins.pop(name, None)
                         await sleep(1)
-                        self.loader.import_plugin(
-                            path.join(plugin_dir, "main.py"), plugin_dir
-                        )
+                        
+                        current_plugin_order = self.settings.getSetting("pluginOrder")
+                        current_plugin_order.append(name)
+                        self.settings.setSetting("pluginOrder", current_plugin_order)
+                        logger.debug("Plugin %s was added to the pluginOrder setting", name)
+                        self.loader.import_plugin(path.join(plugin_dir, "main.py"), plugin_folder)
                     else:
-                        logger.fatal("Failed Downloading Remote Binaries")
+                        logger.fatal(f"Failed Downloading Remote Binaries")
                 else:
                     self.log.fatal(f"SHA-256 Mismatch!!!! {name} (Version: {version})")
                 if self.loader.watcher:
@@ -221,21 +192,14 @@ class PluginBrowser:
 
     async def request_plugin_install(self, artifact, name, version, hash):
         request_id = str(time())
-        self.install_requests[request_id] = PluginInstallContext(
-            artifact, name, version, hash
-        )
+        self.install_requests[request_id] = PluginInstallContext(artifact, name, version, hash)
         tab = await get_gamepadui_tab()
         await tab.open_websocket()
-        await tab.evaluate_js(
-            f"DeckyPluginLoader.addPluginInstallPrompt('{name}', '{version}',"
-            f" '{request_id}', '{hash}')"
-        )
+        await tab.evaluate_js(f"DeckyPluginLoader.addPluginInstallPrompt('{name}', '{version}', '{request_id}', '{hash}')")
 
     async def confirm_plugin_install(self, request_id):
         request = self.install_requests.pop(request_id)
-        await self._install(
-            request.artifact, request.name, request.version, request.hash
-        )
+        await self._install(request.artifact, request.name, request.version, request.hash)
 
     def cancel_plugin_install(self, request_id):
         self.install_requests.pop(request_id)

backend/customtypes.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class UserType(Enum):
+    HOST_USER = 1
+    EFFECTIVE_USER = 2
+    ROOT = 3

backend/helpers.py

@@ -1,17 +1,18 @@
-import grp
-import pwd
 import re
 import ssl
-import subprocess
 import uuid
 import os
 import sys
+import subprocess
 from hashlib import sha256
 from io import BytesIO
 
 import certifi
 from aiohttp.web import Response, middleware
 from aiohttp import ClientSession
+import localplatform
+from customtypes import UserType
+from logging import getLogger
 
 REMOTE_DEBUGGER_UNIT = "steam-web-debug-portforward.service"
 
@@ -21,135 +22,55 @@ ssl_ctx = ssl.create_default_context(cafile=certifi.where())
 
 assets_regex = re.compile("^/plugins/.*/assets/.*")
 frontend_regex = re.compile("^/frontend/.*")
-
+logger = getLogger("Main")
 
 def get_ssl_context():
     return ssl_ctx
 
-
 def get_csrf_token():
     return csrf_token
 
-
 @middleware
 async def csrf_middleware(request, handler):
-    if (
-        str(request.method) == "OPTIONS"
-        or request.headers.get("Authentication") == csrf_token
-        or str(request.rel_url) == "/auth/token"
-        or str(request.rel_url).startswith("/plugins/load_main/")
-        or str(request.rel_url).startswith("/static/")
-        or str(request.rel_url).startswith("/legacy/")
-        or str(request.rel_url).startswith("/steam_resource/")
-        or str(request.rel_url).startswith("/frontend/")
-        or assets_regex.match(str(request.rel_url))
-        or frontend_regex.match(str(request.rel_url))
-    ):
+    if str(request.method) == "OPTIONS" or request.headers.get('Authentication') == csrf_token or str(request.rel_url) == "/auth/token" or str(request.rel_url).startswith("/plugins/load_main/") or str(request.rel_url).startswith("/static/") or str(request.rel_url).startswith("/legacy/") or str(request.rel_url).startswith("/steam_resource/") or str(request.rel_url).startswith("/frontend/") or assets_regex.match(str(request.rel_url)) or frontend_regex.match(str(request.rel_url)):
         return await handler(request)
-    return Response(text="Forbidden", status="403")
-
-
-# Deprecated
-def set_user():
-    pass
-
-
-# Get the user id hosting the plugin loader
-def get_user_id() -> int:
-    proc_path = os.path.realpath(sys.argv[0])
-    pws = sorted(pwd.getpwall(), reverse=True, key=lambda pw: len(pw.pw_dir))
-    for pw in pws:
-        if proc_path.startswith(os.path.realpath(pw.pw_dir)):
-            return pw.pw_uid
-    raise PermissionError(
-        "The plugin loader does not seem to be hosted by any known user."
-    )
-
-
-# Get the user hosting the plugin loader
-def get_user() -> str:
-    return pwd.getpwuid(get_user_id()).pw_name
-
-
-# Get the effective user id of the running process
-def get_effective_user_id() -> int:
-    return os.geteuid()
-
-
-# Get the effective user of the running process
-def get_effective_user() -> str:
-    return pwd.getpwuid(get_effective_user_id()).pw_name
-
-
-# Get the effective user group id of the running process
-def get_effective_user_group_id() -> int:
-    return os.getegid()
-
-
-# Get the effective user group of the running process
-def get_effective_user_group() -> str:
-    return grp.getgrgid(get_effective_user_group_id()).gr_name
-
-
-# Get the user owner of the given file path.
-def get_user_owner(file_path) -> str:
-    return pwd.getpwuid(os.stat(file_path).st_uid).pw_name
-
-
-# Deprecated
-def set_user_group() -> str:
-    return get_user_group()
-
-
-# Get the group id of the user hosting the plugin loader
-def get_user_group_id() -> int:
-    return pwd.getpwuid(get_user_id()).pw_gid
-
-
-# Get the group of the user hosting the plugin loader
-def get_user_group(file_path) -> str:
-    if file_path:
-        return grp.getgrgid(os.stat(file_path).st_gid).gr_name
-    else:
-        return grp.getgrgid(get_user_group_id()).gr_name
-
-
-# Get the default home path unless a user is specified
-def get_home_path(username=None) -> str:
-    if username is None:
-        username = get_user()
-    return pwd.getpwnam(username).pw_dir
-
+    return Response(text='Forbidden', status='403')
 
 # Get the default homebrew path unless a home_path is specified
-def get_homebrew_path(home_path=None) -> str:
-    if home_path is None:
-        home_path = get_home_path()
-    return os.path.join(home_path, "homebrew")
-
+def get_homebrew_path(home_path = None) -> str:
+    return os.path.join(home_path if home_path != None else localplatform.get_home_path(), "homebrew")
 
 # Recursively create path and chown as user
 def mkdir_as_user(path):
     path = os.path.realpath(path)
     os.makedirs(path, exist_ok=True)
-    chown_path = get_home_path()
-    parts = os.path.relpath(path, chown_path).split(os.sep)
-    uid = get_user_id()
-    gid = get_user_group_id()
-    for p in parts:
-        chown_path = os.path.join(chown_path, p)
-        os.chown(chown_path, uid, gid)
-
+    localplatform.chown(path)
 
 # Fetches the version of loader
 def get_loader_version() -> str:
-    with open(
-        os.path.join(os.path.dirname(sys.argv[0]), ".loader.version"),
-        "r",
-        encoding="utf-8",
-    ) as version_file:
-        return version_file.readline().replace("\n", "")
+    try:
+        with open(os.path.join(os.getcwd(), ".loader.version"), "r", encoding="utf-8") as version_file:
+            return version_file.readline().strip()
+    except Exception as e:
+        logger.warn(f"Failed to execute get_loader_version(): {str(e)}")
+        return "unknown"
 
+# returns the appropriate system python paths
+def get_system_pythonpaths() -> list[str]:
+    extra_args = {}
+
+    if localplatform.ON_LINUX:
+        # run as normal normal user to also include user python paths
+        extra_args["user"] = localplatform.localplatform._get_user_id()
+        extra_args["env"] = {}
+
+    try:
+        proc = subprocess.run(["python3" if localplatform.ON_LINUX else "python", "-c", "import sys; print('\\n'.join(x for x in sys.path if x))"],
+                              capture_output=True, **extra_args)
+        return [x.strip() for x in proc.stdout.decode().strip().split("\n")]
+    except Exception as e:
+        logger.warn(f"Failed to execute get_system_pythonpaths(): {str(e)}")
+        return []
 
 # Download Remote Binaries to local Plugin
 async def download_remote_binary_to_path(url, binHash, path) -> bool:
@@ -163,37 +84,79 @@ async def download_remote_binary_to_path(url, binHash, path) -> bool:
                 remoteHash = sha256(data.getbuffer()).hexdigest()
                 if binHash == remoteHash:
                     data.seek(0)
-                    with open(path, "wb") as f:
+                    with open(path, 'wb') as f:
                         f.write(data.getbuffer())
                         rv = True
                 else:
-                    raise Exception(
-                        f"Fatal Error: Hash Mismatch for remote binary {path}@{url}"
-                    )
+                    raise Exception(f"Fatal Error: Hash Mismatch for remote binary {path}@{url}")
             else:
                 rv = False
-    except Exception:
+    except:
         rv = False
 
     return rv
 
+# Deprecated
+def set_user():
+    pass
+
+# Deprecated
+def set_user_group() -> str:
+    return get_user_group()
+
+#########
+# Below is legacy code, provided for backwards compatibility. This will break on windows
+#########
+
+# Get the user id hosting the plugin loader
+def get_user_id() -> int:
+    return localplatform.localplatform._get_user_id()
+
+# Get the user hosting the plugin loader
+def get_user() -> str:
+    return localplatform.localplatform._get_user()
+
+# Get the effective user id of the running process
+def get_effective_user_id() -> int:
+    return localplatform.localplatform._get_effective_user_id()
+
+# Get the effective user of the running process
+def get_effective_user() -> str:
+    return localplatform.localplatform._get_effective_user()
+
+# Get the effective user group id of the running process
+def get_effective_user_group_id() -> int:
+    return localplatform.localplatform._get_effective_user_group_id()
+
+# Get the effective user group of the running process
+def get_effective_user_group() -> str:
+    return localplatform.localplatform._get_effective_user_group()
+
+# Get the user owner of the given file path.
+def get_user_owner(file_path) -> str:
+    return localplatform.localplatform._get_user_owner(file_path)
+
+# Get the user group of the given file path.
+def get_user_group(file_path) -> str:
+    return localplatform.localplatform._get_user_group(file_path)
+
+# Get the group id of the user hosting the plugin loader
+def get_user_group_id() -> int:
+    return localplatform.localplatform._get_user_group_id()
+
+# Get the group of the user hosting the plugin loader
+def get_user_group() -> str:
+    return localplatform.localplatform._get_user_group()
+
+# Get the default home path unless a user is specified
+def get_home_path(username = None) -> str:
+    return localplatform.get_home_path(UserType.ROOT if username == "root" else UserType.HOST_USER)
 
 async def is_systemd_unit_active(unit_name: str) -> bool:
-    res = subprocess.run(
-        ["systemctl", "is-active", unit_name],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    return res.returncode == 0
+    return await localplatform.service_active(unit_name)
 
+async def stop_systemd_unit(unit_name: str) -> bool:
+    return await localplatform.service_stop(unit_name)
 
-async def stop_systemd_unit(unit_name: str) -> subprocess.CompletedProcess:
-    cmd = ["systemctl", "stop", unit_name]
-
-    return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-
-
-async def start_systemd_unit(unit_name: str) -> subprocess.CompletedProcess:
-    cmd = ["systemctl", "start", unit_name]
-
-    return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+async def start_systemd_unit(unit_name: str) -> bool:
+    return await localplatform.service_start(unit_name)

backend/injector.py

@@ -2,9 +2,10 @@
 
 from asyncio import sleep
 from logging import getLogger
+from traceback import format_exc
 from typing import List
 
-from aiohttp import ClientSession
+from aiohttp import ClientSession, WSMsgType
 from aiohttp.client_exceptions import ClientConnectorError, ClientOSError
 from asyncio.exceptions import TimeoutError
 import uuid
@@ -38,12 +39,9 @@ class Tab:
         async for message in self.websocket:
             data = message.json()
             yield data
-        logger.warn(
-            f"The Tab {self.title} socket has been disconnected while listening for"
-            " messages."
-        )
+        logger.warn(f"The Tab {self.title} socket has been disconnected while listening for messages.")
         await self.close_websocket()
-
+            
     async def _send_devtools_cmd(self, dc, receive=True):
         if self.websocket:
             self.cmd_id += 1
@@ -56,24 +54,19 @@ class Tab:
             return None
         raise RuntimeError("Websocket not opened")
 
-    async def evaluate_js(
-        self, js, run_async=False, manage_socket=True, get_result=True
-    ):
+    async def evaluate_js(self, js, run_async=False, manage_socket=True, get_result=True):
         try:
             if manage_socket:
                 await self.open_websocket()
 
-            res = await self._send_devtools_cmd(
-                {
-                    "method": "Runtime.evaluate",
-                    "params": {
-                        "expression": js,
-                        "userGesture": True,
-                        "awaitPromise": run_async,
-                    },
-                },
-                get_result,
-            )
+            res = await self._send_devtools_cmd({
+                "method": "Runtime.evaluate",
+                "params": {
+                    "expression": js,
+                    "userGesture": True,
+                    "awaitPromise": run_async
+                }
+            }, get_result)
 
         finally:
             if manage_socket:
@@ -81,17 +74,9 @@ class Tab:
         return res
 
     async def has_global_var(self, var_name, manage_socket=True):
-        res = await self.evaluate_js(
-            f"window['{var_name}'] !== null && window['{var_name}'] !== undefined",
-            False,
-            manage_socket,
-        )
+        res = await self.evaluate_js(f"window['{var_name}'] !== null && window['{var_name}'] !== undefined", False, manage_socket)
 
-        if (
-            "result" not in res
-            or "result" not in res["result"]
-            or "value" not in res["result"]["result"]
-        ):
+        if not "result" in res or not "result" in res["result"] or not "value" in res["result"]["result"]:
             return False
 
         return res["result"]["result"]["value"]
@@ -101,12 +86,9 @@ class Tab:
             if manage_socket:
                 await self.open_websocket()
 
-            res = await self._send_devtools_cmd(
-                {
-                    "method": "Page.close",
-                },
-                False,
-            )
+            res = await self._send_devtools_cmd({
+                "method": "Page.close",
+            }, False)
 
         finally:
             if manage_socket:
@@ -117,42 +99,32 @@ class Tab:
         """
         Enables page domain notifications.
         """
-        await self._send_devtools_cmd(
-            {
-                "method": "Page.enable",
-            },
-            False,
-        )
+        await self._send_devtools_cmd({
+            "method": "Page.enable",
+        }, False)
 
     async def disable(self):
         """
         Disables page domain notifications.
         """
-        await self._send_devtools_cmd(
-            {
-                "method": "Page.disable",
-            },
-            False,
-        )
+        await self._send_devtools_cmd({
+            "method": "Page.disable",
+        }, False)
 
-    async def refresh(self, manage_socket=False):
+    async def refresh(self):
         try:
             if manage_socket:
                 await self.open_websocket()
 
-            await self._send_devtools_cmd(
-                {
-                    "method": "Page.reload",
-                },
-                False,
-            )
+            await self._send_devtools_cmd({
+                "method": "Page.reload",
+            }, False)
 
         finally:
             if manage_socket:
                 await self.close_websocket()
 
         return
-
     async def reload_and_evaluate(self, js, manage_socket=True):
         """
         Reloads the current tab, with JS to run on load via debugger
@@ -161,70 +133,64 @@ class Tab:
             if manage_socket:
                 await self.open_websocket()
 
-            await self._send_devtools_cmd({"method": "Debugger.enable"}, True)
+            await self._send_devtools_cmd({
+                "method": "Debugger.enable"
+            }, True)
 
-            await self._send_devtools_cmd(
-                {
-                    "method": "Runtime.evaluate",
-                    "params": {
-                        "expression": "location.reload();",
-                        "userGesture": True,
-                        "awaitPromise": False,
-                    },
-                },
-                False,
-            )
+            await self._send_devtools_cmd({
+                "method": "Runtime.evaluate",
+                "params": {
+                    "expression": "location.reload();",
+                    "userGesture": True,
+                    "awaitPromise": False
+                }
+            }, False)
 
-            breakpoint_res = await self._send_devtools_cmd(
-                {
-                    "method": "Debugger.setInstrumentationBreakpoint",
-                    "params": {"instrumentation": "beforeScriptExecution"},
-                },
-                True,
-            )
+            breakpoint_res = await self._send_devtools_cmd({
+                "method": "Debugger.setInstrumentationBreakpoint",
+                "params": {
+                    "instrumentation": "beforeScriptExecution"
+                }
+            }, True)
 
             logger.info(breakpoint_res)
-
+            
             # Page finishes loading when breakpoint hits
 
             for x in range(20):
                 # this works around 1/5 of the time, so just send it 8 times.
                 # the js accounts for being injected multiple times allowing only one instance to run at a time anyway
-                await self._send_devtools_cmd(
-                    {
-                        "method": "Runtime.evaluate",
-                        "params": {
-                            "expression": js,
-                            "userGesture": True,
-                            "awaitPromise": False,
-                        },
-                    },
-                    False,
-                )
-
-            await self._send_devtools_cmd(
-                {
-                    "method": "Debugger.removeBreakpoint",
+                await self._send_devtools_cmd({
+                    "method": "Runtime.evaluate",
                     "params": {
-                        "breakpointId": breakpoint_res["result"]["breakpointId"]
-                    },
-                },
-                False,
-            )
+                        "expression": js,
+                        "userGesture": True,
+                        "awaitPromise": False
+                    }
+                }, False)
+
+            await self._send_devtools_cmd({
+                "method": "Debugger.removeBreakpoint",
+                "params": {
+                    "breakpointId": breakpoint_res["result"]["breakpointId"]
+                }
+            }, False)
 
             for x in range(4):
-                await self._send_devtools_cmd({"method": "Debugger.resume"}, False)
+                await self._send_devtools_cmd({
+                    "method": "Debugger.resume"
+                }, False)
 
-            await self._send_devtools_cmd({"method": "Debugger.disable"}, True)
+            await self._send_devtools_cmd({
+                "method": "Debugger.disable"
+            }, True)
 
         finally:
             if manage_socket:
                 await self.close_websocket()
         return
 
-    async def add_script_to_evaluate_on_new_document(
-        self, js, add_dom_wrapper=True, manage_socket=True, get_result=True
-    ):
+    async def add_script_to_evaluate_on_new_document(self, js, add_dom_wrapper=True, manage_socket=True, get_result=True):
         """
         How the underlying call functions is not particularly clear from the devtools docs, so stealing puppeteer's description:
 
@@ -259,44 +225,35 @@ class Tab:
         """
         try:
 
-            wrappedjs = (
-                """
-            function scriptFunc() {{
+            wrappedjs = """
+            function scriptFunc() {
                 {js}
-            }}
-            if (document.readyState === 'loading') {{
-                addEventListener('DOMContentLoaded', () => {{
+            }
+            if (document.readyState === 'loading') {
+                addEventListener('DOMContentLoaded', () => {
                 scriptFunc();
-            }});
-            }} else {{
+            });
+            } else {
                 scriptFunc();
-            }}
-            """.format(
-                    js=js
-                )
-                if add_dom_wrapper
-                else js
-            )
+            }
+            """.format(js=js) if add_dom_wrapper else js
 
             if manage_socket:
                 await self.open_websocket()
 
-            res = await self._send_devtools_cmd(
-                {
-                    "method": "Page.addScriptToEvaluateOnNewDocument",
-                    "params": {"source": wrappedjs},
-                },
-                get_result,
-            )
+            res = await self._send_devtools_cmd({
+                "method": "Page.addScriptToEvaluateOnNewDocument",
+                "params": {
+                    "source": wrappedjs
+                }
+            }, get_result)
 
         finally:
             if manage_socket:
                 await self.close_websocket()
         return res
 
-    async def remove_script_to_evaluate_on_new_document(
-        self, script_id, manage_socket=True
-    ):
+    async def remove_script_to_evaluate_on_new_document(self, script_id, manage_socket=True):
         """
         Removes a script from a page that was added with `add_script_to_evaluate_on_new_document`
 
@@ -310,28 +267,21 @@ class Tab:
             if manage_socket:
                 await self.open_websocket()
 
-            await self._send_devtools_cmd(
-                {
-                    "method": "Page.removeScriptToEvaluateOnNewDocument",
-                    "params": {"identifier": script_id},
-                },
-                False,
-            )
+            res = await self._send_devtools_cmd({
+                "method": "Page.removeScriptToEvaluateOnNewDocument",
+                "params": {
+                    "identifier": script_id
+                }
+            }, False)
 
         finally:
             if manage_socket:
                 await self.close_websocket()
 
     async def has_element(self, element_name, manage_socket=True):
-        res = await self.evaluate_js(
-            f"document.getElementById('{element_name}') != null", False, manage_socket
-        )
+        res = await self.evaluate_js(f"document.getElementById('{element_name}') != null", False, manage_socket)
 
-        if (
-            "result" not in res
-            or "result" not in res["result"]
-            or "value" not in res["result"]["result"]
-        ):
+        if not "result" in res or not "result" in res["result"] or not "value" in res["result"]["result"]:
             return False
 
         return res["result"]["result"]["value"]
@@ -348,17 +298,23 @@ class Tab:
                     document.head.append(style);
                     style.textContent = `{style}`;
                 }})()
-                """,
-                False,
-                manage_socket,
-            )
+                """, False, manage_socket)
 
             if "exceptionDetails" in result["result"]:
-                return {"success": False, "result": result["result"]}
+                return {
+                    "success": False,
+                    "result": result["result"]
+                }
 
-            return {"success": True, "result": css_id}
+            return {
+                "success": True,
+                "result": css_id
+            }
         except Exception as e:
-            return {"success": False, "result": e}
+            return {
+                "success": False,
+                "result": e
+            }
 
     async def remove_css(self, css_id, manage_socket=True):
         try:
@@ -370,24 +326,25 @@ class Tab:
                     if (style.nodeName.toLowerCase() == 'style')
                         style.parentNode.removeChild(style);
                 }})()
-                """,
-                False,
-                manage_socket,
-            )
+                """, False, manage_socket)
 
             if "exceptionDetails" in result["result"]:
-                return {"success": False, "result": result}
+                return {
+                    "success": False,
+                    "result": result
+                }
 
-            return {"success": True}
+            return {
+                "success": True
+            }
         except Exception as e:
-            return {"success": False, "result": e}
+            return {
+                "success": False,
+                "result": e
+            }
 
     async def get_steam_resource(self, url):
-        res = await self.evaluate_js(
-            f'(async function test() {{ return await (await fetch("{url}")).text()'
-            " })()",
-            True,
-        )
+        res = await self.evaluate_js(f'(async function test() {{ return await (await fetch("{url}")).text() }})()', True)
         return res["result"]["result"]["value"]
 
     def __repr__(self):
@@ -430,45 +387,34 @@ async def get_tab(tab_name) -> Tab:
         raise ValueError(f"Tab {tab_name} not found")
     return tab
 
-
 async def get_tab_lambda(test) -> Tab:
     tabs = await get_tabs()
     tab = next((i for i in tabs if test(i)), None)
     if not tab:
-        raise ValueError("Tab not found by lambda")
+        raise ValueError(f"Tab not found by lambda")
     return tab
 
+SHARED_CTX_NAMES = ["SharedJSContext", "Steam Shared Context presented by Valve™", "Steam", "SP"]
 
 def tab_is_gamepadui(t: Tab) -> bool:
-    return "https://steamloopback.host/routes/" in t.url and (
-        t.title == "Steam Shared Context presented by Valve™"
-        or t.title == "Steam"
-        or t.title == "SP"
-    )
-
+    return "https://steamloopback.host/routes/" in t.url and t.title in SHARED_CTX_NAMES
 
 async def get_gamepadui_tab() -> Tab:
     tabs = await get_tabs()
     tab = next((i for i in tabs if tab_is_gamepadui(i)), None)
     if not tab:
-        raise ValueError("GamepadUI Tab not found")
+        raise ValueError(f"GamepadUI Tab not found")
     return tab
 
-
 async def inject_to_tab(tab_name, js, run_async=False):
     tab = await get_tab(tab_name)
 
     return await tab.evaluate_js(js, run_async)
 
-
 async def close_old_tabs():
     tabs = await get_tabs()
     for t in tabs:
-        if not t.title or (
-            t.title != "Steam Shared Context presented by Valve™"
-            and t.title != "Steam"
-            and t.title != "SP"
-        ):
+        if not t.title or t.title not in SHARED_CTX_NAMES:
             logger.debug("Closing tab: " + getattr(t, "title", "Untitled"))
             await t.close()
             await sleep(0.5)

backend/loader.py

@@ -6,22 +6,16 @@ from pathlib import Path
 from traceback import print_exc
 
 from aiohttp import web
-from genericpath import exists
+from os.path import exists
 from watchdog.events import RegexMatchingEventHandler
-from watchdog.utils import UnsupportedLibc
-
-try:
-    from watchdog.observers.inotify import InotifyObserver as Observer
-except UnsupportedLibc:
-    from watchdog.observers.fsevents import FSEventsObserver as Observer
+from watchdog.observers import Observer
 
 from injector import get_tab, get_gamepadui_tab
 from plugin import PluginWrapper
 
-
 class FileChangeHandler(RegexMatchingEventHandler):
     def __init__(self, queue, plugin_path) -> None:
-        super().__init__(regexes=[r"^.*?dist\/index\.js$", r"^.*?main\.py$"])
+        super().__init__(regexes=[r'^.*?dist\/index\.js$', r'^.*?main\.py$'])
         self.logger = getLogger("file-watcher")
         self.plugin_path = plugin_path
         self.queue = queue
@@ -32,9 +26,7 @@ class FileChangeHandler(RegexMatchingEventHandler):
             return
         plugin_dir = Path(path.relpath(src_path, self.plugin_path)).parts[0]
         if exists(path.join(self.plugin_path, plugin_dir, "plugin.json")):
-            self.queue.put_nowait(
-                (path.join(self.plugin_path, plugin_dir, "main.py"), plugin_dir, True)
-            )
+            self.queue.put_nowait((path.join(self.plugin_path, plugin_dir, "main.py"), plugin_dir, True))
 
     def on_created(self, event):
         src_path = event.src_path
@@ -64,7 +56,6 @@ class FileChangeHandler(RegexMatchingEventHandler):
         self.logger.debug(f"file modified: {src_path}")
         self.maybe_reload(src_path)
 
-
 class Loader:
     def __init__(self, server_instance, plugin_path, loop, live_reload=False) -> None:
         self.loop = loop
@@ -84,30 +75,18 @@ class Loader:
             self.loop.create_task(self.handle_reloads())
             self.loop.create_task(self.enable_reload_wait())
 
-        server_instance.add_routes(
-            [
-                web.get("/frontend/{path:.*}", self.handle_frontend_assets),
-                web.get("/plugins", self.get_plugins),
-                web.get(
-                    "/plugins/{plugin_name}/frontend_bundle",
-                    self.handle_frontend_bundle,
-                ),
-                web.post(
-                    "/plugins/{plugin_name}/methods/{method_name}",
-                    self.handle_plugin_method_call,
-                ),
-                web.get(
-                    "/plugins/{plugin_name}/assets/{path:.*}",
-                    self.handle_plugin_frontend_assets,
-                ),
-                # The following is legacy plugin code.
-                web.get("/plugins/load_main/{name}", self.load_plugin_main_view),
-                web.get(
-                    "/plugins/plugin_resource/{name}/{path:.+}", self.handle_sub_route
-                ),
-                web.get("/steam_resource/{path:.+}", self.get_steam_resource),
-            ]
-        )
+        server_instance.add_routes([
+            web.get("/frontend/{path:.*}", self.handle_frontend_assets),
+            web.get("/plugins", self.get_plugins),
+            web.get("/plugins/{plugin_name}/frontend_bundle", self.handle_frontend_bundle),
+            web.post("/plugins/{plugin_name}/methods/{method_name}", self.handle_plugin_method_call),
+            web.get("/plugins/{plugin_name}/assets/{path:.*}", self.handle_plugin_frontend_assets),
+
+            # The following is legacy plugin code.
+            web.get("/plugins/load_main/{name}", self.load_plugin_main_view),
+            web.get("/plugins/plugin_resource/{name}/{path:.+}", self.handle_sub_route),
+            web.get("/steam_resource/{path:.+}", self.get_steam_resource)
+        ])
 
     async def enable_reload_wait(self):
         if self.live_reload:
@@ -122,63 +101,36 @@ class Loader:
 
     async def get_plugins(self, request):
         plugins = list(self.plugins.values())
-        return web.json_response(
-            [
-                {
-                    "name": str(i) if not i.legacy else "$LEGACY_" + str(i),
-                    "version": i.version,
-                }
-                for i in plugins
-            ]
-        )
+        return web.json_response([{"name": str(i) if not i.legacy else "$LEGACY_"+str(i), "version": i.version} for i in plugins])
 
     def handle_plugin_frontend_assets(self, request):
         plugin = self.plugins[request.match_info["plugin_name"]]
-        file = path.join(
-            self.plugin_path,
-            plugin.plugin_directory,
-            "dist/assets",
-            request.match_info["path"],
-        )
+        file = path.join(self.plugin_path, plugin.plugin_directory, "dist/assets", request.match_info["path"])
 
         return web.FileResponse(file, headers={"Cache-Control": "no-cache"})
 
     def handle_frontend_bundle(self, request):
         plugin = self.plugins[request.match_info["plugin_name"]]
 
-        with open(
-            path.join(self.plugin_path, plugin.plugin_directory, "dist/index.js"),
-            "r",
-            encoding="utf-8",
-        ) as bundle:
-            return web.Response(
-                text=bundle.read(), content_type="application/javascript"
-            )
+        with open(path.join(self.plugin_path, plugin.plugin_directory, "dist/index.js"), "r", encoding="utf-8") as bundle:
+            return web.Response(text=bundle.read(), content_type="application/javascript")
 
     def import_plugin(self, file, plugin_directory, refresh=False, batch=False):
         try:
             plugin = PluginWrapper(file, plugin_directory, self.plugin_path)
             if plugin.name in self.plugins:
-                if "debug" not in plugin.flags and refresh:
-                    self.logger.info(
-                        f"Plugin {plugin.name} is already loaded and has requested to"
-                        " not be re-loaded"
-                    )
-                    return
-                else:
-                    self.plugins[plugin.name].stop()
-                    self.plugins.pop(plugin.name, None)
+                    if not "debug" in plugin.flags and refresh:
+                        self.logger.info(f"Plugin {plugin.name} is already loaded and has requested to not be re-loaded")
+                        return
+                    else:
+                        self.plugins[plugin.name].stop()
+                        self.plugins.pop(plugin.name, None)
             if plugin.passive:
                 self.logger.info(f"Plugin {plugin.name} is passive")
             self.plugins[plugin.name] = plugin.start()
             self.logger.info(f"Loaded {plugin.name}")
             if not batch:
-                self.loop.create_task(
-                    self.dispatch_plugin(
-                        plugin.name if not plugin.legacy else "$LEGACY_" + plugin.name,
-                        plugin.version,
-                    )
-                )
+                self.loop.create_task(self.dispatch_plugin(plugin.name if not plugin.legacy else "$LEGACY_" + plugin.name, plugin.version))
         except Exception as e:
             self.logger.error(f"Could not load {file}. {e}")
             print_exc()
@@ -190,20 +142,10 @@ class Loader:
     def import_plugins(self):
         self.logger.info(f"import plugins from {self.plugin_path}")
 
-        directories = [
-            i
-            for i in listdir(self.plugin_path)
-            if path.isdir(path.join(self.plugin_path, i))
-            and path.isfile(path.join(self.plugin_path, i, "plugin.json"))
-        ]
+        directories = [i for i in listdir(self.plugin_path) if path.isdir(path.join(self.plugin_path, i)) and path.isfile(path.join(self.plugin_path, i, "plugin.json"))]
         for directory in directories:
             self.logger.info(f"found plugin: {directory}")
-            self.import_plugin(
-                path.join(self.plugin_path, directory, "main.py"),
-                directory,
-                False,
-                True,
-            )
+            self.import_plugin(path.join(self.plugin_path, directory, "main.py"), directory, False, True)
 
     async def handle_reloads(self):
         while True:
@@ -220,10 +162,10 @@ class Loader:
         except JSONDecodeError:
             args = {}
         try:
-            if method_name.startswith("_"):
-                raise RuntimeError("Tried to call private method")
-            res["result"] = await plugin.execute_method(method_name, args)
-            res["success"] = True
+          if method_name.startswith("_"):
+              raise RuntimeError("Tried to call private method")
+          res["result"] = await plugin.execute_method(method_name, args)
+          res["success"] = True
         except Exception as e:
             res["result"] = str(e)
             res["success"] = False
@@ -236,14 +178,9 @@ class Loader:
     can introduce it more smoothly and give people the chance to sample the new features even
     without plugin support. They will be removed once legacy plugins are no longer relevant.
     """
-
     async def load_plugin_main_view(self, request):
         plugin = self.plugins[request.match_info["name"]]
-        with open(
-            path.join(self.plugin_path, plugin.plugin_directory, plugin.main_view_html),
-            "r",
-            encoding="utf-8",
-        ) as template:
+        with open(path.join(self.plugin_path, plugin.plugin_directory, plugin.main_view_html), "r", encoding="utf-8") as template:
             template_data = template.read()
             ret = f"""
             <script src="/legacy/library.js"></script>
@@ -267,11 +204,6 @@ class Loader:
     async def get_steam_resource(self, request):
         tab = await get_tab("SP")
         try:
-            return web.Response(
-                text=await tab.get_steam_resource(
-                    f"https://steamloopback.host/{request.match_info['path']}"
-                ),
-                content_type="text/html",
-            )
+            return web.Response(text=await tab.get_steam_resource(f"https://steamloopback.host/{request.match_info['path']}"), content_type="text/html")
         except Exception as e:
             return web.Response(text=str(e), status=400)

backend/localplatform.py

@@ -0,0 +1,11 @@
+import platform
+
+ON_WINDOWS = platform.system() == "Windows"
+ON_LINUX = not ON_WINDOWS
+
+if ON_WINDOWS:
+    from localplatformwin import *
+    import localplatformwin as localplatform
+else:
+    from localplatformlinux import *
+    import localplatformlinux as localplatform

backend/localplatformlinux.py

@@ -0,0 +1,138 @@
+import os, pwd, grp, sys
+from subprocess import call, run, DEVNULL, PIPE, STDOUT
+from customtypes import UserType
+
+# Get the user id hosting the plugin loader
+def _get_user_id() -> int:
+    proc_path = os.path.realpath(sys.argv[0])
+    pws = sorted(pwd.getpwall(), reverse=True, key=lambda pw: len(pw.pw_dir))
+    for pw in pws:
+        if proc_path.startswith(os.path.realpath(pw.pw_dir)):
+            return pw.pw_uid
+    raise PermissionError("The plugin loader does not seem to be hosted by any known user.")
+
+# Get the user hosting the plugin loader
+def _get_user() -> str:
+    return pwd.getpwuid(_get_user_id()).pw_name
+
+# Get the effective user id of the running process
+def _get_effective_user_id() -> int:
+    return os.geteuid()
+
+# Get the effective user of the running process
+def _get_effective_user() -> str:
+    return pwd.getpwuid(_get_effective_user_id()).pw_name
+
+# Get the effective user group id of the running process
+def _get_effective_user_group_id() -> int:
+    return os.getegid()
+
+# Get the effective user group of the running process
+def _get_effective_user_group() -> str:
+    return grp.getgrgid(_get_effective_user_group_id()).gr_name
+
+# Get the user owner of the given file path.
+def _get_user_owner(file_path) -> str:
+    return pwd.getpwuid(os.stat(file_path).st_uid).pw_name
+
+# Get the user group of the given file path.
+def _get_user_group(file_path) -> str:
+    return grp.getgrgid(os.stat(file_path).st_gid).gr_name
+
+# Get the group id of the user hosting the plugin loader
+def _get_user_group_id() -> int:
+    return pwd.getpwuid(_get_user_id()).pw_gid
+
+# Get the group of the user hosting the plugin loader
+def _get_user_group() -> str:
+    return grp.getgrgid(_get_user_group_id()).gr_name
+
+def chown(path : str,  user : UserType = UserType.HOST_USER, recursive : bool = True) -> bool:
+    user_str = ""
+
+    if (user == UserType.HOST_USER):
+        user_str = _get_user()+":"+_get_user_group()
+    elif (user == UserType.EFFECTIVE_USER):
+        user_str = _get_effective_user()+":"+_get_effective_user_group()
+    else:
+        raise Exception("Unknown User Type")
+
+    result = call(["chown", "-R", user_str, path] if recursive else ["chown", user_str, path])
+    return result == 0
+
+def chmod(path : str, permissions : int, recursive : bool = True) -> bool:
+    result = call(["chmod", "-R", str(permissions), path] if recursive else ["chmod", str(permissions), path])
+    return result == 0
+
+def folder_owner(path : str) -> UserType|None:
+    user_owner = _get_user_owner(path)
+
+    if (user_owner == _get_user()):
+        return UserType.HOST_USER
+
+    elif (user_owner == _get_effective_user()):
+        return UserType.EFFECTIVE_USER
+
+    else:
+        return None 
+
+def get_home_path(user : UserType = UserType.HOST_USER) -> str:
+    user_name = "root"
+
+    if user == UserType.HOST_USER:
+        user_name = _get_user()
+    elif user == UserType.EFFECTIVE_USER:
+        user_name = _get_effective_user()
+    elif user == UserType.ROOT:
+        pass
+    else:
+        raise Exception("Unknown User Type")
+
+    return pwd.getpwnam(user_name).pw_dir
+
+def get_username() -> str:
+    return _get_user()
+
+def setgid(user : UserType = UserType.HOST_USER):
+    user_id = 0
+
+    if user == UserType.HOST_USER:
+        user_id = _get_user_group_id()
+    elif user == UserType.ROOT:
+        pass
+    else:
+        raise Exception("Unknown user type")
+    
+    os.setgid(user_id)
+
+def setuid(user : UserType = UserType.HOST_USER):
+    user_id = 0
+
+    if user == UserType.HOST_USER:
+        user_id = _get_user_id()
+    elif user == UserType.ROOT:
+        pass
+    else:
+        raise Exception("Unknown user type")
+    
+    os.setuid(user_id)
+
+async def service_active(service_name : str) -> bool:
+    res = run(["systemctl", "is-active", service_name], stdout=DEVNULL, stderr=DEVNULL)
+    return res.returncode == 0
+
+async def service_restart(service_name : str) -> bool:
+    call(["systemctl", "daemon-reload"])
+    cmd = ["systemctl", "restart", service_name]
+    res = run(cmd, stdout=PIPE, stderr=STDOUT)
+    return res.returncode == 0
+
+async def service_stop(service_name : str) -> bool:
+    cmd = ["systemctl", "stop", service_name]
+    res = run(cmd, stdout=PIPE, stderr=STDOUT)
+    return res.returncode == 0
+
+async def service_start(service_name : str) -> bool:
+    cmd = ["systemctl", "start", service_name]
+    res = run(cmd, stdout=PIPE, stderr=STDOUT)
+    return res.returncode == 0

backend/localplatformwin.py

@@ -0,0 +1,38 @@
+from customtypes import UserType
+import os, sys
+
+def chown(path : str,  user : UserType = UserType.HOST_USER, recursive : bool = True) -> bool:
+    return True # Stubbed
+
+def chmod(path : str, permissions : int, recursive : bool = True) -> bool:
+    return True # Stubbed
+
+def folder_owner(path : str) -> UserType|None:
+    return UserType.HOST_USER # Stubbed
+
+def get_home_path(user : UserType = UserType.HOST_USER) -> str:
+    return os.path.expanduser("~") # Mostly stubbed
+
+def setgid(user : UserType = UserType.HOST_USER):
+    pass # Stubbed
+
+def setuid(user : UserType = UserType.HOST_USER):
+    pass # Stubbed
+
+async def service_active(service_name : str) -> bool:
+    return True # Stubbed
+
+async def service_stop(service_name : str) -> bool:
+    return True # Stubbed
+
+async def service_start(service_name : str) -> bool:
+    return True # Stubbed
+
+async def service_restart(service_name : str) -> bool:
+    if service_name == "plugin_loader":
+        sys.exit(42)
+
+    return True # Stubbed
+
+def get_username() -> str:
+    return os.getlogin()

backend/localsocket.py

@@ -0,0 +1,132 @@
+import asyncio, time, random
+from localplatform import ON_WINDOWS
+
+BUFFER_LIMIT = 2 ** 20  # 1 MiB
+
+class UnixSocket:
+    def __init__(self, on_new_message):
+        '''
+        on_new_message takes 1 string argument.
+        It's return value gets used, if not None, to write data to the socket.
+        Method should be async
+        '''
+        self.socket_addr = f"/tmp/plugin_socket_{time.time()}"
+        self.on_new_message = on_new_message
+        self.socket = None
+        self.reader = None
+        self.writer = None
+
+    async def setup_server(self):
+        self.socket = await asyncio.start_unix_server(self._listen_for_method_call, path=self.socket_addr, limit=BUFFER_LIMIT)
+    
+    async def _open_socket_if_not_exists(self):
+        if not self.reader:
+            retries = 0
+            while retries < 10:
+                try:
+                    self.reader, self.writer = await asyncio.open_unix_connection(self.socket_addr, limit=BUFFER_LIMIT)
+                    return True
+                except:
+                    await asyncio.sleep(2)
+                    retries += 1
+            return False
+        else:
+            return True
+
+    async def get_socket_connection(self):
+        if not await self._open_socket_if_not_exists():
+            return None, None
+        
+        return self.reader, self.writer
+    
+    async def close_socket_connection(self):
+        if self.writer != None:
+            self.writer.close()
+
+        self.reader = None
+
+    async def read_single_line(self) -> str|None:
+        reader, writer = await self.get_socket_connection()
+
+        if self.reader == None:
+            return None
+
+        return await self._read_single_line(reader)
+
+    async def write_single_line(self, message : str):
+        reader, writer = await self.get_socket_connection()
+
+        if self.writer == None:
+            return;
+
+        await self._write_single_line(writer, message)
+
+    async def _read_single_line(self, reader) -> str:
+        line = bytearray()
+        while True:
+            try:
+                line.extend(await reader.readuntil())
+            except asyncio.LimitOverrunError:
+                line.extend(await reader.read(reader._limit))
+                continue
+            except asyncio.IncompleteReadError as err:
+                line.extend(err.partial)
+                break
+            else:
+                break
+
+        return line.decode("utf-8")
+    
+    async def _write_single_line(self, writer, message : str):
+        if not message.endswith("\n"):
+            message += "\n"
+
+        writer.write(message.encode("utf-8"))
+        await writer.drain()
+
+    async def _listen_for_method_call(self, reader, writer):
+        while True:
+            line = await self._read_single_line(reader)
+
+            try:
+                res = await self.on_new_message(line)
+            except Exception as e:
+                return
+
+            if res != None:
+                await self._write_single_line(writer, res)
+            
+class PortSocket (UnixSocket):
+    def __init__(self, on_new_message):
+        '''
+        on_new_message takes 1 string argument.
+        It's return value gets used, if not None, to write data to the socket.
+        Method should be async
+        '''
+        super().__init__(on_new_message)
+        self.host = "127.0.0.1"
+        self.port = random.sample(range(40000, 60000), 1)[0]
+    
+    async def setup_server(self):
+        self.socket = await asyncio.start_server(self._listen_for_method_call, host=self.host, port=self.port, limit=BUFFER_LIMIT)
+    
+    async def _open_socket_if_not_exists(self):
+        if not self.reader:
+            retries = 0
+            while retries < 10:
+                try:
+                    self.reader, self.writer = await asyncio.open_connection(host=self.host, port=self.port, limit=BUFFER_LIMIT)
+                    return True
+                except:
+                    await asyncio.sleep(2)
+                    retries += 1
+            return False
+        else:
+            return True
+
+if ON_WINDOWS:
+    class LocalSocket (PortSocket): 
+        pass
+else:
+    class LocalSocket (UnixSocket):
+        pass

backend/main.py

@@ -1,42 +1,34 @@
 # Change PyInstaller files permissions
 import sys
-from subprocess import call
-
-if hasattr(sys, "_MEIPASS"):
-    call(["chmod", "-R", "755", sys._MEIPASS])
+from localplatform import chmod, chown, service_stop, service_start, ON_WINDOWS
+if hasattr(sys, '_MEIPASS'):
+    chmod(sys._MEIPASS, 755)
 # Full imports
 from asyncio import new_event_loop, set_event_loop, sleep
-from logging import basicConfig, getLogger
+from json import dumps, loads
+from logging import DEBUG, INFO, basicConfig, getLogger
 from os import getenv, path
 from traceback import format_exc
+import multiprocessing
 
 import aiohttp_cors
-
 # Partial imports
-from aiohttp import client_exceptions
+from aiohttp import client_exceptions, WSMsgType
 from aiohttp.web import Application, Response, get, run_app, static
 from aiohttp_jinja2 import setup as jinja_setup
 
 # local modules
 from browser import PluginBrowser
-from helpers import (
-    REMOTE_DEBUGGER_UNIT,
-    csrf_middleware,
-    get_csrf_token,
-    get_homebrew_path,
-    get_user,
-    get_user_group,
-    stop_systemd_unit,
-    start_systemd_unit,
-)
-from injector import get_gamepadui_tab, Tab, close_old_tabs
+from helpers import (REMOTE_DEBUGGER_UNIT, csrf_middleware, get_csrf_token,
+                     get_homebrew_path, mkdir_as_user, get_system_pythonpaths)
+                     
+from injector import get_gamepadui_tab, Tab, get_tabs, close_old_tabs
 from loader import Loader
 from settings import SettingsManager
 from updater import Updater
 from utilities import Utilities
+from customtypes import UserType
 
-USER = get_user()
-GROUP = get_user_group()
 HOMEBREW_PATH = get_homebrew_path()
 CONFIG = {
     "plugin_path": getenv("PLUGIN_PATH", path.join(HOMEBREW_PATH, "plugins")),
@@ -50,46 +42,37 @@ CONFIG = {
 }
 
 basicConfig(
-    level=CONFIG["log_level"], format="[%(module)s][%(levelname)s]: %(message)s"
+    level=CONFIG["log_level"],
+    format="[%(module)s][%(levelname)s]: %(message)s"
 )
 
 logger = getLogger("Main")
 
-
 def chown_plugin_dir():
-    code_chown = call(["chown", "-R", USER + ":" + GROUP, CONFIG["plugin_path"]])
-    code_chmod = call(["chmod", "-R", "555", CONFIG["plugin_path"]])
-    if code_chown != 0 or code_chmod != 0:
-        logger.error(
-            f"chown/chmod exited with a non-zero exit code (chown: {code_chown}, chmod:"
-            f" {code_chmod})"
-        )
+    if not path.exists(CONFIG["plugin_path"]): # For safety, create the folder before attempting to do anything with it
+        mkdir_as_user(CONFIG["plugin_path"])
 
+    if not chown(CONFIG["plugin_path"], UserType.HOST_USER) or not chmod(CONFIG["plugin_path"], 555):
+        logger.error(f"chown/chmod exited with a non-zero exit code")
 
-if CONFIG["chown_plugin_path"] is True:
+if CONFIG["chown_plugin_path"] == True:
     chown_plugin_dir()
 
-
 class PluginManager:
     def __init__(self, loop) -> None:
         self.loop = loop
         self.web_app = Application()
         self.web_app.middlewares.append(csrf_middleware)
-        self.cors = aiohttp_cors.setup(
-            self.web_app,
-            defaults={
-                "https://steamloopback.host": aiohttp_cors.ResourceOptions(
-                    expose_headers="*", allow_headers="*", allow_credentials=True
-                )
-            },
-        )
-        self.plugin_loader = Loader(
-            self.web_app, CONFIG["plugin_path"], self.loop, CONFIG["live_reload"]
-        )
-        self.plugin_browser = PluginBrowser(
-            CONFIG["plugin_path"], self.plugin_loader.plugins, self.plugin_loader
-        )
+        self.cors = aiohttp_cors.setup(self.web_app, defaults={
+            "https://steamloopback.host": aiohttp_cors.ResourceOptions(
+                expose_headers="*",
+                allow_headers="*",
+                allow_credentials=True
+            )
+        })
+        self.plugin_loader = Loader(self.web_app, CONFIG["plugin_path"], self.loop, CONFIG["live_reload"])
         self.settings = SettingsManager("loader", path.join(HOMEBREW_PATH, "settings"))
+        self.plugin_browser = PluginBrowser(CONFIG["plugin_path"], self.plugin_loader.plugins, self.plugin_loader, self.settings)
         self.utilities = Utilities(self)
         self.updater = Updater(self)
 
@@ -97,9 +80,9 @@ class PluginManager:
 
         async def startup(_):
             if self.settings.getSetting("cef_forward", False):
-                self.loop.create_task(start_systemd_unit(REMOTE_DEBUGGER_UNIT))
+                self.loop.create_task(service_start(REMOTE_DEBUGGER_UNIT))
             else:
-                self.loop.create_task(stop_systemd_unit(REMOTE_DEBUGGER_UNIT))
+                self.loop.create_task(service_stop(REMOTE_DEBUGGER_UNIT))
             self.loop.create_task(self.loader_reinjector())
             self.loop.create_task(self.load_plugins())
 
@@ -110,12 +93,8 @@ class PluginManager:
 
         for route in list(self.web_app.router.routes()):
             self.cors.add(route)
-        self.web_app.add_routes(
-            [static("/static", path.join(path.dirname(__file__), "static"))]
-        )
-        self.web_app.add_routes(
-            [static("/legacy", path.join(path.dirname(__file__), "legacy"))]
-        )
+        self.web_app.add_routes([static("/static", path.join(path.dirname(__file__), 'static'))])
+        self.web_app.add_routes([static("/legacy", path.join(path.dirname(__file__), 'legacy'))])
 
     def exception_handler(self, loop, context):
         if context["message"] == "Unclosed connection":
@@ -130,6 +109,9 @@ class PluginManager:
         logger.debug("Loading plugins")
         self.plugin_loader.import_plugins()
         # await inject_to_tab("SP", "window.syncDeckyPlugins();")
+        if self.settings.getSetting("pluginOrder", None) == None:
+          self.settings.setSetting("pluginOrder", list(self.plugin_loader.plugins.keys()))
+          logger.debug("Did not find pluginOrder setting, set it to default")
 
     async def loader_reinjector(self):
         while True:
@@ -139,10 +121,7 @@ class PluginManager:
             while not tab:
                 try:
                     tab = await get_gamepadui_tab()
-                except (
-                    client_exceptions.ClientConnectorError,
-                    client_exceptions.ServerDisconnectedError,
-                ):
+                except (client_exceptions.ClientConnectorError, client_exceptions.ServerDisconnectedError):
                     if not dc:
                         logger.debug("Couldn't connect to debugger, waiting...")
                         dc = True
@@ -173,7 +152,7 @@ class PluginManager:
                 # This is because of https://github.com/aio-libs/aiohttp/blob/3ee7091b40a1bc58a8d7846e7878a77640e96996/aiohttp/client_ws.py#L321
                 logger.info("CEF has disconnected...")
                 # At this point the loop starts again and we connect to the freshly started Steam client once it is ready.
-            except Exception:
+            except Exception as e:
                 logger.error("Exception while reading page events " + format_exc())
                 await tab.close_websocket()
                 pass
@@ -189,31 +168,29 @@ class PluginManager:
             if first:
                 if await tab.has_global_var("deckyHasLoaded", False):
                     await close_old_tabs()
-            await tab.evaluate_js(
-                "try{if (window.deckyHasLoaded){setTimeout(() => location.reload(),"
-                " 100)}else{window.deckyHasLoaded ="
-                " true;(async()=>{try{while(!window.SP_REACT){await new Promise(r =>"
-                " setTimeout(r, 10))};await"
-                " import('http://localhost:1337/frontend/index.js')}catch(e){console.error(e)};})();}}catch(e){console.error(e)}",
-                False,
-                False,
-                False,
-            )
-        except Exception:
+            await tab.evaluate_js("try{if (window.deckyHasLoaded){setTimeout(() => location.reload(), 100)}else{window.deckyHasLoaded = true;(async()=>{try{while(!window.SP_REACT){await new Promise(r => setTimeout(r, 10))};await import('http://localhost:1337/frontend/index.js')}catch(e){console.error(e)};})();}}catch(e){console.error(e)}", False, False, False)
+        except:
             logger.info("Failed to inject JavaScript into tab\n" + format_exc())
             pass
 
     def run(self):
-        return run_app(
-            self.web_app,
-            host=CONFIG["server_host"],
-            port=CONFIG["server_port"],
-            loop=self.loop,
-            access_log=None,
-        )
-
+        return run_app(self.web_app, host=CONFIG["server_host"], port=CONFIG["server_port"], loop=self.loop, access_log=None)
 
 if __name__ == "__main__":
+    if ON_WINDOWS:
+        # Fix windows/flask not recognising that .js means 'application/javascript'
+        import mimetypes
+        mimetypes.add_type('application/javascript', '.js')
+
+        # Required for multiprocessing support in frozen files
+        multiprocessing.freeze_support()
+
+    # Append the loader's plugin path to the recognized python paths
+    sys.path.append(path.join(path.dirname(__file__), "plugin"))
+
+    # Append the system and user python paths
+    sys.path.extend(get_system_pythonpaths())
+
     loop = new_event_loop()
     set_event_loop(loop)
     PluginManager(loop).run()

backend/plugin.py

@@ -1,57 +1,33 @@
 import multiprocessing
-from asyncio import (
-    Lock,
-    get_event_loop,
-    new_event_loop,
-    open_unix_connection,
-    set_event_loop,
-    sleep,
-    start_unix_server,
-    IncompleteReadError,
-    LimitOverrunError,
-)
+from asyncio import (Lock, get_event_loop, new_event_loop,
+                     set_event_loop, sleep)
+from concurrent.futures import ProcessPoolExecutor
 from importlib.util import module_from_spec, spec_from_file_location
 from json import dumps, load, loads
 from logging import getLogger
 from traceback import format_exc
-from os import path, setgid, setuid, environ
+from os import path, environ
 from signal import SIGINT, signal
-from sys import exit
+from sys import exit, path as syspath
 from time import time
+from localsocket import LocalSocket
+from localplatform import setgid, setuid, get_username, get_home_path
+from customtypes import UserType
 import helpers
 
-multiprocessing.set_start_method("fork")
-
-BUFFER_LIMIT = 2**20  # 1 MiB
-
-
 class PluginWrapper:
     def __init__(self, file, plugin_directory, plugin_path) -> None:
         self.file = file
         self.plugin_path = plugin_path
         self.plugin_directory = plugin_directory
-        self.reader = None
-        self.writer = None
-        self.socket_addr = f"/tmp/plugin_socket_{time()}"
         self.method_call_lock = Lock()
+        self.socket = LocalSocket(self._on_new_message)
 
         self.version = None
 
-        json = load(
-            open(
-                path.join(plugin_path, plugin_directory, "plugin.json"),
-                "r",
-                encoding="utf-8",
-            )
-        )
+        json = load(open(path.join(plugin_path, plugin_directory, "plugin.json"), "r", encoding="utf-8"))
         if path.isfile(path.join(plugin_path, plugin_directory, "package.json")):
-            package_json = load(
-                open(
-                    path.join(plugin_path, plugin_directory, "package.json"),
-                    "r",
-                    encoding="utf-8",
-                )
-            )
+            package_json = load(open(path.join(plugin_path, plugin_directory, "package.json"), "r", encoding="utf-8"))
             self.version = package_json["version"]
 
         self.legacy = False
@@ -77,120 +53,76 @@ class PluginWrapper:
             set_event_loop(new_event_loop())
             if self.passive:
                 return
-            setgid(0 if "root" in self.flags else helpers.get_user_group_id())
-            setuid(0 if "root" in self.flags else helpers.get_user_id())
+            setgid(UserType.ROOT if "root" in self.flags else UserType.HOST_USER)
+            setuid(UserType.ROOT if "root" in self.flags else UserType.HOST_USER)
             # export a bunch of environment variables to help plugin developers
-            environ["HOME"] = helpers.get_home_path(
-                "root" if "root" in self.flags else helpers.get_user()
-            )
-            environ["USER"] = "root" if "root" in self.flags else helpers.get_user()
+            environ["HOME"] = get_home_path(UserType.ROOT if "root" in self.flags else UserType.HOST_USER)
+            environ["USER"] = "root" if "root" in self.flags else get_username()
             environ["DECKY_VERSION"] = helpers.get_loader_version()
-            environ["DECKY_USER"] = helpers.get_user()
+            environ["DECKY_USER"] = get_username()
+            environ["DECKY_USER_HOME"] = helpers.get_home_path()
             environ["DECKY_HOME"] = helpers.get_homebrew_path()
-            environ["DECKY_PLUGIN_SETTINGS_DIR"] = path.join(
-                environ["DECKY_HOME"], "settings", self.plugin_directory
-            )
+            environ["DECKY_PLUGIN_SETTINGS_DIR"] = path.join(environ["DECKY_HOME"], "settings", self.plugin_directory)
             helpers.mkdir_as_user(environ["DECKY_PLUGIN_SETTINGS_DIR"])
-            environ["DECKY_PLUGIN_RUNTIME_DIR"] = path.join(
-                environ["DECKY_HOME"], "data", self.plugin_directory
-            )
+            environ["DECKY_PLUGIN_RUNTIME_DIR"] = path.join(environ["DECKY_HOME"], "data", self.plugin_directory)
             helpers.mkdir_as_user(environ["DECKY_PLUGIN_RUNTIME_DIR"])
-            environ["DECKY_PLUGIN_LOG_DIR"] = path.join(
-                environ["DECKY_HOME"], "logs", self.plugin_directory
-            )
+            environ["DECKY_PLUGIN_LOG_DIR"] = path.join(environ["DECKY_HOME"], "logs", self.plugin_directory)
             helpers.mkdir_as_user(environ["DECKY_PLUGIN_LOG_DIR"])
-            environ["DECKY_PLUGIN_DIR"] = path.join(
-                self.plugin_path, self.plugin_directory
-            )
+            environ["DECKY_PLUGIN_DIR"] = path.join(self.plugin_path, self.plugin_directory)
             environ["DECKY_PLUGIN_NAME"] = self.name
             environ["DECKY_PLUGIN_VERSION"] = self.version
             environ["DECKY_PLUGIN_AUTHOR"] = self.author
+
+            # append the plugin's `py_modules` to the recognized python paths
+            syspath.append(path.join(environ["DECKY_PLUGIN_DIR"], "py_modules"))
+
             spec = spec_from_file_location("_", self.file)
             module = module_from_spec(spec)
             spec.loader.exec_module(module)
             self.Plugin = module.Plugin
 
+            if hasattr(self.Plugin, "_migration"):
+                get_event_loop().run_until_complete(self.Plugin._migration(self.Plugin))
             if hasattr(self.Plugin, "_main"):
                 get_event_loop().create_task(self.Plugin._main(self.Plugin))
-            get_event_loop().create_task(self._setup_socket())
+            get_event_loop().create_task(self.socket.setup_server())
             get_event_loop().run_forever()
-        except Exception:
+        except:
             self.log.error("Failed to start " + self.name + "!\n" + format_exc())
             exit(0)
 
     async def _unload(self):
         try:
-            self.log.info(
-                "Attempting to unload with plugin "
-                + self.name
-                + '\'s "_unload" function.\n'
-            )
+            self.log.info("Attempting to unload with plugin " + self.name + "'s \"_unload\" function.\n")
             if hasattr(self.Plugin, "_unload"):
                 await self.Plugin._unload(self.Plugin)
                 self.log.info("Unloaded " + self.name + "\n")
             else:
-                self.log.info(
-                    'Could not find "_unload" in ' + self.name + "'s main.py" + "\n"
-                )
-        except Exception:
+                self.log.info("Could not find \"_unload\" in " + self.name + "'s main.py" + "\n")
+        except:
             self.log.error("Failed to unload " + self.name + "!\n" + format_exc())
             exit(0)
 
-    async def _setup_socket(self):
-        self.socket = await start_unix_server(
-            self._listen_for_method_call, path=self.socket_addr, limit=BUFFER_LIMIT
-        )
+    async def _on_new_message(self, message : str) -> str|None:
+        data = loads(message)
 
-    async def _listen_for_method_call(self, reader, writer):
-        while True:
-            line = bytearray()
-            while True:
-                try:
-                    line.extend(await reader.readuntil())
-                except LimitOverrunError:
-                    line.extend(await reader.read(reader._limit))
-                    continue
-                except IncompleteReadError as err:
-                    line.extend(err.partial)
-                    break
-                else:
-                    break
-            data = loads(line.decode("utf-8"))
-            if "stop" in data:
-                self.log.info("Calling Loader unload function.")
-                await self._unload()
-                get_event_loop().stop()
-                while get_event_loop().is_running():
-                    await sleep(0)
-                get_event_loop().close()
-                return
-            d = {"res": None, "success": True}
-            try:
-                d["res"] = await getattr(self.Plugin, data["method"])(
-                    self.Plugin, **data["args"]
-                )
-            except Exception as e:
-                d["res"] = str(e)
-                d["success"] = False
-            finally:
-                writer.write((dumps(d, ensure_ascii=False) + "\n").encode("utf-8"))
-                await writer.drain()
+        if "stop" in data:
+            self.log.info("Calling Loader unload function.")
+            await self._unload()
+            get_event_loop().stop()
+            while get_event_loop().is_running():
+                await sleep(0)
+            get_event_loop().close()
+            raise Exception("Closing message listener")
 
-    async def _open_socket_if_not_exists(self):
-        if not self.reader:
-            retries = 0
-            while retries < 10:
-                try:
-                    self.reader, self.writer = await open_unix_connection(
-                        self.socket_addr, limit=BUFFER_LIMIT
-                    )
-                    return True
-                except Exception:
-                    await sleep(2)
-                    retries += 1
-            return False
-        else:
-            return True
+        d = {"res": None, "success": True}
+        try:
+            d["res"] = await getattr(self.Plugin, data["method"])(self.Plugin, **data["args"])
+        except Exception as e:
+            d["res"] = str(e)
+            d["success"] = False
+        finally:
+            return dumps(d, ensure_ascii=False)
 
     def start(self):
         if self.passive:
@@ -203,44 +135,22 @@ class PluginWrapper:
             return
 
         async def _(self):
-            if await self._open_socket_if_not_exists():
-                self.writer.write(
-                    (dumps({"stop": True}, ensure_ascii=False) + "\n").encode("utf-8")
-                )
-                await self.writer.drain()
-                self.writer.close()
-
+            await self.socket.write_single_line(dumps({ "stop": True }, ensure_ascii=False))
+            await self.socket.close_socket_connection()
+            
         get_event_loop().create_task(_(self))
 
     async def execute_method(self, method_name, kwargs):
         if self.passive:
-            raise RuntimeError(
-                "This plugin is passive (aka does not implement main.py)"
-            )
+            raise RuntimeError("This plugin is passive (aka does not implement main.py)")
         async with self.method_call_lock:
-            if await self._open_socket_if_not_exists():
-                self.writer.write(
-                    (
-                        dumps(
-                            {"method": method_name, "args": kwargs}, ensure_ascii=False
-                        )
-                        + "\n"
-                    ).encode("utf-8")
-                )
-                await self.writer.drain()
-                line = bytearray()
-                while True:
-                    try:
-                        line.extend(await self.reader.readuntil())
-                    except LimitOverrunError:
-                        line.extend(await self.reader.read(self.reader._limit))
-                        continue
-                    except IncompleteReadError as err:
-                        line.extend(err.partial)
-                        break
-                    else:
-                        break
-                res = loads(line.decode("utf-8"))
+            reader, writer = await self.socket.get_socket_connection()
+
+            await self.socket.write_single_line(dumps({ "method": method_name, "args": kwargs }, ensure_ascii=False))
+
+            line = await self.socket.read_single_line()
+            if line != None:
+                res = loads(line)
                 if not res["success"]:
                     raise Exception(res["res"])
-                return res["res"]
+                return res["res"]

backend/pyproject.toml

@@ -1,15 +0,0 @@
-[flake8]
-max-line-length = 88
-
-[tool.ruff]
-ignore = [
-    # Ignore line length check and let Black handle it
-    "E501",
-
-    # Ignore SyntaxError due to ruff not supporting pattern matching
-    # https://github.com/charliermarsh/ruff/issues/282
-    "E999",
-]
-
-# Assume Python 3.10.
-target-version = "py310"

backend/settings.py

@@ -1,45 +1,42 @@
 from json import dump, load
 from os import mkdir, path, listdir, rename
-from shutil import chown
+from localplatform import chown, folder_owner
+from customtypes import UserType
 
-from helpers import (
-    get_homebrew_path,
-    get_user,
-    get_user_group,
-    get_user_owner,
-)
+from helpers import get_homebrew_path
 
 
 class SettingsManager:
-    def __init__(self, name, settings_directory=None) -> None:
-        USER = get_user()
-        GROUP = get_user_group()
+    def __init__(self, name, settings_directory = None) -> None:
         wrong_dir = get_homebrew_path()
-        if settings_directory is None:
+        if settings_directory == None:
             settings_directory = path.join(wrong_dir, "settings")
 
         self.path = path.join(settings_directory, name + ".json")
 
-        # Create the folder with the correct permission
+        #Create the folder with the correct permission
         if not path.exists(settings_directory):
             mkdir(settings_directory)
-            chown(settings_directory, USER, GROUP)
+            chown(settings_directory)
 
-        # Copy all old settings file in the root directory to the correct folder
+        #Copy all old settings file in the root directory to the correct folder
         for file in listdir(wrong_dir):
             if file.endswith(".json"):
-                rename(path.join(wrong_dir, file), path.join(settings_directory, file))
+                rename(path.join(wrong_dir,file),
+                       path.join(settings_directory, file)) 
                 self.path = path.join(settings_directory, name + ".json")
 
-        # If the owner of the settings directory is not the user, then set it as the user:
-        if get_user_owner(settings_directory) != USER:
-            chown(settings_directory, USER, GROUP)
+
+        #If the owner of the settings directory is not the user, then set it as the user:
+
+        if folder_owner(settings_directory) != UserType.HOST_USER:
+            chown(settings_directory, UserType.HOST_USER, False)
 
         self.settings = {}
 
         try:
             open(self.path, "x", encoding="utf-8")
-        except FileExistsError:
+        except FileExistsError as e:
             self.read()
             pass
 

backend/updater.py

@@ -6,7 +6,7 @@ from ensurepip import version
 from json.decoder import JSONDecodeError
 from logging import getLogger
 from os import getcwd, path, remove
-from subprocess import call
+from localplatform import chmod, service_restart, ON_LINUX
 
 from aiohttp import ClientSession, web
 
@@ -16,7 +16,6 @@ from settings import SettingsManager
 
 logger = getLogger("Updater")
 
-
 class Updater:
     def __init__(self, context) -> None:
         self.context = context
@@ -27,27 +26,22 @@ class Updater:
             "get_version": self.get_version,
             "do_update": self.do_update,
             "do_restart": self.do_restart,
-            "check_for_updates": self.check_for_updates,
+            "check_for_updates": self.check_for_updates
         }
         self.remoteVer = None
         self.allRemoteVers = None
-        try:
-            self.localVer = helpers.get_loader_version()
-        except:
-            self.localVer = False
+        self.localVer = helpers.get_loader_version()
 
         try:
             self.currentBranch = self.get_branch(self.context.settings)
         except:
             self.currentBranch = 0
-            logger.error(
-                'Current branch could not be determined, defaulting to "Stable"'
-            )
+            logger.error("Current branch could not be determined, defaulting to \"Stable\"")
 
         if context:
-            context.web_app.add_routes(
-                [web.post("/updater/{method_name}", self._handle_server_method_call)]
-            )
+            context.web_app.add_routes([
+                web.post("/updater/{method_name}", self._handle_server_method_call)
+            ])
             context.loop.create_task(self.version_reloader())
 
     async def _handle_server_method_call(self, request):
@@ -71,7 +65,7 @@ class Updater:
         logger.debug("current branch: %i" % ver)
         if ver == -1:
             logger.info("Current branch is not set, determining branch from version...")
-            if self.localVer.startswith("v") and self.localVer.find("-pre"):
+            if self.localVer.startswith("v") and "-pre" in self.localVer:
                 logger.info("Current version determined to be pre-release")
                 return 1
             else:
@@ -92,71 +86,38 @@ class Updater:
             case 1 | 2:
                 url = "https://raw.githubusercontent.com/SteamDeckHomebrew/decky-loader/main/dist/plugin_loader-prerelease.service"
             case _:
-                logger.error(
-                    "You have an invalid branch set... Defaulting to prerelease"
-                    " service, please send the logs to the devs!"
-                )
+                logger.error("You have an invalid branch set... Defaulting to prerelease service, please send the logs to the devs!")
                 url = "https://raw.githubusercontent.com/SteamDeckHomebrew/decky-loader/main/dist/plugin_loader-prerelease.service"
         return str(url)
 
     async def get_version(self):
-        if self.localVer:
-            return {
-                "current": self.localVer,
-                "remote": self.remoteVer,
-                "all": self.allRemoteVers,
-                "updatable": self.localVer != None,
-            }
-        else:
-            return {
-                "current": "unknown",
-                "remote": self.remoteVer,
-                "all": self.allRemoteVers,
-                "updatable": False,
-            }
+        return {
+            "current": self.localVer,
+            "remote": self.remoteVer,
+            "all": self.allRemoteVers,
+            "updatable": self.localVer != "unknown"
+        }
 
     async def check_for_updates(self):
         logger.debug("checking for updates")
         selectedBranch = self.get_branch(self.context.settings)
         async with ClientSession() as web:
-            async with web.request(
-                "GET",
-                "https://api.github.com/repos/SteamDeckHomebrew/decky-loader/releases",
-                ssl=helpers.get_ssl_context(),
-            ) as res:
+            async with web.request("GET", "https://api.github.com/repos/SteamDeckHomebrew/decky-loader/releases", ssl=helpers.get_ssl_context()) as res:
                 remoteVersions = await res.json()
         self.allRemoteVers = remoteVersions
         logger.debug("determining release type to find, branch is %i" % selectedBranch)
         if selectedBranch == 0:
             logger.debug("release type: release")
-            self.remoteVer = next(
-                filter(
-                    lambda ver: ver["tag_name"].startswith("v")
-                    and not ver["prerelease"]
-                    and ver["tag_name"],
-                    remoteVersions,
-                ),
-                None,
-            )
+            self.remoteVer = next(filter(lambda ver: ver["tag_name"].startswith("v") and not ver["prerelease"] and not ver["tag_name"].find("-pre") > 0 and ver["tag_name"], remoteVersions), None)
         elif selectedBranch == 1:
             logger.debug("release type: pre-release")
-            self.remoteVer = next(
-                filter(
-                    lambda ver: ver["prerelease"]
-                    and ver["tag_name"].startswith("v")
-                    and ver["tag_name"].find("-pre"),
-                    remoteVersions,
-                ),
-                None,
-            )
+            self.remoteVer = next(filter(lambda ver:ver["tag_name"].startswith("v"), remoteVersions), None)
         else:
             logger.error("release type: NOT FOUND")
             raise ValueError("no valid branch found")
         logger.info("Updated remote version information")
         tab = await get_gamepadui_tab()
-        await tab.evaluate_js(
-            f"window.DeckyPluginLoader.notifyUpdates()", False, True, False
-        )
+        await tab.evaluate_js(f"window.DeckyPluginLoader.notifyUpdates()", False, True, False)
         return await self.get_version()
 
     async def version_reloader(self):
@@ -166,65 +127,59 @@ class Updater:
                 await self.check_for_updates()
             except:
                 pass
-            await sleep(60 * 60 * 6)  # 6 hours
+            await sleep(60 * 60 * 6) # 6 hours
 
     async def do_update(self):
         logger.debug("Starting update.")
         version = self.remoteVer["tag_name"]
-        download_url = self.remoteVer["assets"][0]["browser_download_url"]
+        download_url = None
+        download_filename = "PluginLoader" if ON_LINUX else "PluginLoader.exe"
+        download_temp_filename = download_filename + ".new"
+
+        for x in self.remoteVer["assets"]:
+            if x["name"] == download_filename:
+                download_url = x["browser_download_url"]
+                break
+        
+        if download_url == None:
+            raise Exception("Download url not found")
+
         service_url = self.get_service_url()
         logger.debug("Retrieved service URL")
 
         tab = await get_gamepadui_tab()
         await tab.open_websocket()
         async with ClientSession() as web:
-            logger.debug("Downloading systemd service")
-            # download the relevant systemd service depending upon branch
-            async with web.request(
-                "GET", service_url, ssl=helpers.get_ssl_context(), allow_redirects=True
-            ) as res:
-                logger.debug("Downloading service file")
-                data = await res.content.read()
-            logger.debug(str(data))
-            service_file_path = path.join(getcwd(), "plugin_loader.service")
-            try:
-                with open(path.join(getcwd(), "plugin_loader.service"), "wb") as out:
-                    out.write(data)
-            except Exception as e:
-                logger.error(f"Error at %s", exc_info=e)
-            with open(
-                path.join(getcwd(), "plugin_loader.service"), "r", encoding="utf-8"
-            ) as service_file:
-                service_data = service_file.read()
-            service_data = service_data.replace(
-                "${HOMEBREW_FOLDER}", helpers.get_homebrew_path()
-            )
-            with open(
-                path.join(getcwd(), "plugin_loader.service"), "w", encoding="utf-8"
-            ) as service_file:
-                service_file.write(service_data)
-
-            logger.debug("Saved service file")
-            logger.debug("Copying service file over current file.")
-            shutil.copy(service_file_path, "/etc/systemd/system/plugin_loader.service")
-            if not os.path.exists(path.join(getcwd(), ".systemd")):
-                os.mkdir(path.join(getcwd(), ".systemd"))
-            shutil.move(
-                service_file_path,
-                path.join(getcwd(), ".systemd") + "/plugin_loader.service",
-            )
-
-            logger.debug("Downloading binary")
-            async with web.request(
-                "GET", download_url, ssl=helpers.get_ssl_context(), allow_redirects=True
-            ) as res:
-                total = int(res.headers.get("content-length", 0))
-                # we need to not delete the binary until we have downloaded the new binary!
+            if ON_LINUX:
+                logger.debug("Downloading systemd service")
+                # download the relevant systemd service depending upon branch
+                async with web.request("GET", service_url, ssl=helpers.get_ssl_context(), allow_redirects=True) as res:
+                    logger.debug("Downloading service file")
+                    data = await res.content.read()
+                logger.debug(str(data))
+                service_file_path = path.join(getcwd(), "plugin_loader.service")
                 try:
-                    remove(path.join(getcwd(), "PluginLoader"))
-                except:
-                    pass
-                with open(path.join(getcwd(), "PluginLoader"), "wb") as out:
+                    with open(path.join(getcwd(), "plugin_loader.service"), "wb") as out:
+                        out.write(data)
+                except Exception as e:
+                    logger.error(f"Error at %s", exc_info=e)
+                with open(path.join(getcwd(), "plugin_loader.service"), "r", encoding="utf-8") as service_file:
+                    service_data = service_file.read()
+                service_data = service_data.replace("${HOMEBREW_FOLDER}", helpers.get_homebrew_path())
+                with open(path.join(getcwd(), "plugin_loader.service"), "w", encoding="utf-8") as service_file:
+                        service_file.write(service_data)
+                    
+                logger.debug("Saved service file")
+                logger.debug("Copying service file over current file.")
+                shutil.copy(service_file_path, "/etc/systemd/system/plugin_loader.service")
+                if not os.path.exists(path.join(getcwd(), ".systemd")):
+                    os.mkdir(path.join(getcwd(), ".systemd"))
+                shutil.move(service_file_path, path.join(getcwd(), ".systemd")+"/plugin_loader.service")
+            
+            logger.debug("Downloading binary")
+            async with web.request("GET", download_url, ssl=helpers.get_ssl_context(), allow_redirects=True) as res:
+                total = int(res.headers.get('content-length', 0))
+                with open(path.join(getcwd(), download_temp_filename), "wb") as out:
                     progress = 0
                     raw = 0
                     async for c in res.content.iter_chunked(512):
@@ -232,27 +187,21 @@ class Updater:
                         raw += len(c)
                         new_progress = round((raw / total) * 100)
                         if progress != new_progress:
-                            self.context.loop.create_task(
-                                tab.evaluate_js(
-                                    f"window.DeckyUpdater.updateProgress({new_progress})",
-                                    False,
-                                    False,
-                                    False,
-                                )
-                            )
+                            self.context.loop.create_task(tab.evaluate_js(f"window.DeckyUpdater.updateProgress({new_progress})", False, False, False))
                             progress = new_progress
 
-            with open(
-                path.join(getcwd(), ".loader.version"), "w", encoding="utf-8"
-            ) as out:
+            with open(path.join(getcwd(), ".loader.version"), "w", encoding="utf-8") as out:
                 out.write(version)
 
-            call(["chmod", "+x", path.join(getcwd(), "PluginLoader")])
+            if ON_LINUX:
+                remove(path.join(getcwd(), download_filename))
+                shutil.move(path.join(getcwd(), download_temp_filename), path.join(getcwd(), download_filename))
+                chmod(path.join(getcwd(), download_filename), 777, False)
+
             logger.info("Updated loader installation.")
             await tab.evaluate_js("window.DeckyUpdater.finish()", False, False)
             await self.do_restart()
             await tab.close_websocket()
 
     async def do_restart(self):
-        call(["systemctl", "daemon-reload"])
-        call(["systemctl", "restart", "plugin_loader"])
+        await service_restart("plugin_loader")

backend/utilities.py

@@ -3,13 +3,14 @@ import os
 from json.decoder import JSONDecodeError
 from traceback import format_exc
 
-from asyncio import start_server, gather, open_connection
+from asyncio import sleep, start_server, gather, open_connection
 from aiohttp import ClientSession, web
 
 from logging import getLogger
 from injector import inject_to_tab, get_gamepadui_tab, close_old_tabs
 import helpers
-
+import subprocess
+from localplatform import service_stop, service_start
 
 class Utilities:
     def __init__(self, context) -> None:
@@ -30,7 +31,7 @@ class Utilities:
             "get_setting": self.get_setting,
             "filepicker_ls": self.filepicker_ls,
             "disable_rdt": self.disable_rdt,
-            "enable_rdt": self.enable_rdt,
+            "enable_rdt": self.enable_rdt
         }
 
         self.logger = getLogger("Utilities")
@@ -40,9 +41,9 @@ class Utilities:
         self.rdt_proxy_task = None
 
         if context:
-            context.web_app.add_routes(
-                [web.post("/methods/{method_name}", self._handle_server_method_call)]
-            )
+            context.web_app.add_routes([
+                web.post("/methods/{method_name}", self._handle_server_method_call)
+            ])
 
     async def _handle_server_method_call(self, request):
         method_name = request.match_info["method_name"]
@@ -60,11 +61,12 @@ class Utilities:
             res["success"] = False
         return web.json_response(res)
 
-    async def install_plugin(
-        self, artifact="", name="No name", version="dev", hash=False
-    ):
+    async def install_plugin(self, artifact="", name="No name", version="dev", hash=False):
         return await self.context.plugin_browser.request_plugin_install(
-            artifact=artifact, name=name, version=version, hash=hash
+            artifact=artifact,
+            name=name,
+            version=version,
+            hash=hash
         )
 
     async def confirm_plugin_install(self, request_id):
@@ -78,11 +80,13 @@ class Utilities:
 
     async def http_request(self, method="", url="", **kwargs):
         async with ClientSession() as web:
-            res = await web.request(
-                method, url, ssl=helpers.get_ssl_context(), **kwargs
-            )
+            res = await web.request(method, url, ssl=helpers.get_ssl_context(), **kwargs)
             text = await res.text()
-        return {"status": res.status, "headers": dict(res.headers), "body": text}
+        return {
+            "status": res.status,
+            "headers": dict(res.headers),
+            "body": text
+        }
 
     async def ping(self, **kwargs):
         return "pong"
@@ -91,18 +95,26 @@ class Utilities:
         try:
             result = await inject_to_tab(tab, code, run_async)
             if "exceptionDetails" in result["result"]:
-                return {"success": False, "result": result["result"]}
+                return {
+                    "success": False,
+                    "result": result["result"]
+                }
 
-            return {"success": True, "result": result["result"]["result"].get("value")}
+            return {
+                "success": True,
+                "result": result["result"]["result"].get("value")
+            }
         except Exception as e:
-            return {"success": False, "result": e}
+            return {
+              "success": False,
+              "result": e
+            }
 
     async def inject_css_into_tab(self, tab, style):
         try:
             css_id = str(uuid.uuid4())
 
-            result = await inject_to_tab(
-                tab,
+            result = await inject_to_tab(tab,
                 f"""
                 (function() {{
                     const style = document.createElement('style');
@@ -110,21 +122,27 @@ class Utilities:
                     document.head.append(style);
                     style.textContent = `{style}`;
                 }})()
-                """,
-                False,
-            )
+                """, False)
 
             if "exceptionDetails" in result["result"]:
-                return {"success": False, "result": result["result"]}
+                return {
+                    "success": False,
+                    "result": result["result"]
+                }
 
-            return {"success": True, "result": css_id}
+            return {
+                "success": True,
+                "result": css_id
+            }
         except Exception as e:
-            return {"success": False, "result": e}
+            return {
+                "success": False,
+                "result": e
+            }
 
     async def remove_css_from_tab(self, tab, css_id):
         try:
-            result = await inject_to_tab(
-                tab,
+            result = await inject_to_tab(tab,
                 f"""
                 (function() {{
                     let style = document.getElementById("{css_id}");
@@ -132,16 +150,22 @@ class Utilities:
                     if (style.nodeName.toLowerCase() == 'style')
                         style.parentNode.removeChild(style);
                 }})()
-                """,
-                False,
-            )
+                """, False)
 
             if "exceptionDetails" in result["result"]:
-                return {"success": False, "result": result}
+                return {
+                    "success": False,
+                    "result": result
+                }
 
-            return {"success": True}
+            return {
+                "success": True
+            }
         except Exception as e:
-            return {"success": False, "result": e}
+            return {
+                "success": False,
+                "result": e
+            }
 
     async def get_setting(self, key, default):
         return self.context.settings.getSetting(key, default)
@@ -150,37 +174,38 @@ class Utilities:
         return self.context.settings.setSetting(key, value)
 
     async def allow_remote_debugging(self):
-        await helpers.start_systemd_unit(helpers.REMOTE_DEBUGGER_UNIT)
+        await service_start(helpers.REMOTE_DEBUGGER_UNIT)
         return True
 
     async def disallow_remote_debugging(self):
-        await helpers.stop_systemd_unit(helpers.REMOTE_DEBUGGER_UNIT)
+        await service_stop(helpers.REMOTE_DEBUGGER_UNIT)
         return True
 
-    async def filepicker_ls(self, path, include_files=True):
+    async def filepicker_ls(self, path, include_files : bool = True, max : int = 1000, page : int = 1):
         # def sorter(file): # Modification time
         #     if os.path.isdir(os.path.join(path, file)) or os.path.isfile(os.path.join(path, file)):
         #         return os.path.getmtime(os.path.join(path, file))
         #     return 0
         # file_names = sorted(os.listdir(path), key=sorter, reverse=True) # TODO provide more sort options
-        file_names = sorted(os.listdir(path))  # Alphabetical
 
-        files = []
+        realpath = os.path.realpath(path)
+        files, folders = [], []
 
-        for file in file_names:
-            full_path = os.path.join(path, file)
-            is_dir = os.path.isdir(full_path)
+        for x in os.scandir(realpath):
+            if x.is_dir():
+                folders.append(x)
+            elif include_files:
+                files.append(x)
 
-            if is_dir or include_files:
-                files.append(
-                    {
-                        "isdir": is_dir,
-                        "name": file,
-                        "realpath": os.path.realpath(full_path),
-                    }
-                )
+        files = sorted(files, key=lambda x: x.name)
+        folders = sorted(folders, key=lambda x: x.name)
+        all = [{ "isdir": x.is_dir(), "name": x.name, "realpath": x.path } for x in folders + files]
 
-        return {"realpath": os.path.realpath(path), "files": files}
+        return {
+            "realpath": realpath,
+            "files": all[(page-1)*max:(page)*max],
+            "total": len(all)
+        }
 
     # Based on https://stackoverflow.com/a/46422554/13174603
     def start_rdt_proxy(self, ip, port):
@@ -190,10 +215,10 @@ class Utilities:
                     writer.write(await reader.read(2048))
             finally:
                 writer.close()
-
         async def handle_client(local_reader, local_writer):
             try:
-                remote_reader, remote_writer = await open_connection(ip, port)
+                remote_reader, remote_writer = await open_connection(
+                    ip, port)
                 pipe1 = pipe(local_reader, remote_writer)
                 pipe2 = pipe(remote_reader, local_writer)
                 await gather(pipe1, pipe2)
@@ -214,14 +239,11 @@ class Utilities:
             self.stop_rdt_proxy()
             ip = self.context.settings.getSetting("developer.rdt.ip", None)
 
-            if ip is not None:
+            if ip != None:
                 self.logger.info("Connecting to React DevTools at " + ip)
                 async with ClientSession() as web:
-                    res = await web.request(
-                        "GET", "http://" + ip + ":8097", ssl=helpers.get_ssl_context()
-                    )
-                    script = (
-                        """
+                    res = await web.request("GET", "http://" + ip + ":8097", ssl=helpers.get_ssl_context())
+                    script = """
                     if (!window.deckyHasConnectedRDT) {
                         window.deckyHasConnectedRDT = true;
                         // This fixes the overlay when hovering over an element in RDT
@@ -229,13 +251,10 @@ class Utilities:
                             enumerable: true,
                             configurable: true,
                             get: function() {
-                                return FocusNavController?.m_ActiveContext?.ActiveWindow || window;
+                                return (GamepadNavTree?.m_context?.m_controller || FocusNavController)?.m_ActiveContext?.ActiveWindow || window;
                             }
                         });
-                    """
-                        + await res.text()
-                        + "\n}"
-                    )
+                    """ + await res.text() + "\n}"
                 if res.status != 200:
                     self.logger.error("Failed to connect to React DevTools at " + ip)
                     return False
@@ -246,7 +265,7 @@ class Utilities:
                 await close_old_tabs()
                 result = await tab.reload_and_evaluate(script)
                 self.logger.info(result)
-
+                        
         except Exception:
             self.logger.error("Failed to connect to React DevTools")
             self.logger.error(format_exc())

frontend/package.json

@@ -12,28 +12,28 @@
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^21.1.0",
-    "@rollup/plugin-image": "^3.0.1",
+    "@rollup/plugin-image": "^3.0.2",
     "@rollup/plugin-json": "^4.1.0",
     "@rollup/plugin-node-resolve": "^13.3.0",
     "@rollup/plugin-replace": "^4.0.0",
-    "@rollup/plugin-typescript": "^8.3.3",
+    "@rollup/plugin-typescript": "^8.5.0",
     "@types/react": "16.14.0",
     "@types/react-file-icon": "^1.0.1",
     "@types/react-router": "5.1.18",
-    "@types/webpack": "^5.28.0",
-    "husky": "^8.0.1",
+    "@types/webpack": "^5.28.1",
+    "husky": "^8.0.3",
     "import-sort-style-module": "^6.0.0",
-    "inquirer": "^8.2.4",
-    "prettier": "^2.7.1",
+    "inquirer": "^8.2.5",
+    "prettier": "^2.8.7",
     "prettier-plugin-import-sort": "^0.0.7",
     "react": "16.14.0",
     "react-dom": "16.14.0",
-    "rollup": "^2.76.0",
+    "rollup": "^2.79.1",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-external-globals": "^0.6.1",
     "rollup-plugin-polyfill-node": "^0.10.2",
-    "tslib": "^2.4.0",
-    "typescript": "^4.7.4"
+    "tslib": "^2.5.0",
+    "typescript": "^4.9.5"
   },
   "importSort": {
     ".js, .jsx, .ts, .tsx": {
@@ -42,10 +42,10 @@
     }
   },
   "dependencies": {
-    "decky-frontend-lib": "^3.18.10",
-    "react-file-icon": "^1.2.0",
-    "react-icons": "^4.4.0",
-    "react-markdown": "^8.0.3",
+    "decky-frontend-lib": "^3.20.0",
+    "react-file-icon": "^1.3.0",
+    "react-icons": "^4.8.0",
+    "react-markdown": "^8.0.6",
     "remark-gfm": "^3.0.1"
   }
 }

frontend/src/components/DeckyState.tsx

@@ -6,6 +6,7 @@ import { VerInfo } from '../updater';
 
 interface PublicDeckyState {
   plugins: Plugin[];
+  pluginOrder: string[];
   activePlugin: Plugin | null;
   updates: PluginUpdateMapping | null;
   hasLoaderUpdate?: boolean;
@@ -15,6 +16,7 @@ interface PublicDeckyState {
 
 export class DeckyState {
   private _plugins: Plugin[] = [];
+  private _pluginOrder: string[] = [];
   private _activePlugin: Plugin | null = null;
   private _updates: PluginUpdateMapping | null = null;
   private _hasLoaderUpdate: boolean = false;
@@ -26,6 +28,7 @@ export class DeckyState {
   publicState(): PublicDeckyState {
     return {
       plugins: this._plugins,
+      pluginOrder: this._pluginOrder,
       activePlugin: this._activePlugin,
       updates: this._updates,
       hasLoaderUpdate: this._hasLoaderUpdate,
@@ -44,6 +47,11 @@ export class DeckyState {
     this.notifyUpdate();
   }
 
+  setPluginOrder(pluginOrder: string[]) {
+    this._pluginOrder = pluginOrder;
+    this.notifyUpdate();
+  }
+
   setActivePlugin(name: string) {
     this._activePlugin = this._plugins.find((plugin) => plugin.name === name) ?? null;
     this.notifyUpdate();
@@ -78,6 +86,7 @@ interface DeckyStateContext extends PublicDeckyState {
   setVersionInfo(versionInfo: VerInfo): void;
   setIsLoaderUpdating(hasUpdate: boolean): void;
   setActivePlugin(name: string): void;
+  setPluginOrder(pluginOrder: string[]): void;
   closeActivePlugin(): void;
 }
 
@@ -106,10 +115,18 @@ export const DeckyStateContextProvider: FC<Props> = ({ children, deckyState }) =
   const setVersionInfo = (versionInfo: VerInfo) => deckyState.setVersionInfo(versionInfo);
   const setActivePlugin = (name: string) => deckyState.setActivePlugin(name);
   const closeActivePlugin = () => deckyState.closeActivePlugin();
+  const setPluginOrder = (pluginOrder: string[]) => deckyState.setPluginOrder(pluginOrder);
 
   return (
     <DeckyStateContext.Provider
-      value={{ ...publicDeckyState, setIsLoaderUpdating, setVersionInfo, setActivePlugin, closeActivePlugin }}
+      value={{
+        ...publicDeckyState,
+        setIsLoaderUpdating,
+        setVersionInfo,
+        setActivePlugin,
+        closeActivePlugin,
+        setPluginOrder,
+      }}
     >
       {children}
     </DeckyStateContext.Provider>

frontend/src/components/Markdown.tsx

@@ -1,4 +1,4 @@
-import { Focusable, Router } from 'decky-frontend-lib';
+import { Focusable, Navigation } from 'decky-frontend-lib';
 import { FunctionComponent, useRef } from 'react';
 import ReactMarkdown, { Options as ReactMarkdownOptions } from 'react-markdown';
 import remarkGfm from 'remark-gfm';
@@ -22,7 +22,7 @@ const Markdown: FunctionComponent<MarkdownProps> = (props) => {
                 onActivate={() => {}}
                 onOKButton={() => {
                   props.onDismiss?.();
-                  Router.NavigateToExternalWeb(aRef.current!.href);
+                  Navigation.NavigateToExternalWeb(aRef.current!.href);
                 }}
                 style={{ display: 'inline' }}
               >

frontend/src/components/PluginView.tsx

@@ -7,17 +7,27 @@ import {
   scrollClasses,
   staticClasses,
 } from 'decky-frontend-lib';
-import { VFC } from 'react';
+import { VFC, useEffect, useState } from 'react';
 
+import { Plugin } from '../plugin';
 import { useDeckyState } from './DeckyState';
 import NotificationBadge from './NotificationBadge';
 import { useQuickAccessVisible } from './QuickAccessVisibleState';
 import TitleView from './TitleView';
 
 const PluginView: VFC = () => {
-  const { plugins, updates, activePlugin, setActivePlugin, closeActivePlugin } = useDeckyState();
+  const { plugins, updates, activePlugin, pluginOrder, setActivePlugin, closeActivePlugin } = useDeckyState();
   const visible = useQuickAccessVisible();
 
+  const [pluginList, setPluginList] = useState<Plugin[]>(
+    plugins.sort((a, b) => pluginOrder.indexOf(a.name) - pluginOrder.indexOf(b.name)),
+  );
+
+  useEffect(() => {
+    setPluginList(plugins.sort((a, b) => pluginOrder.indexOf(a.name) - pluginOrder.indexOf(b.name)));
+    console.log('updating PluginView after changes');
+  }, [plugins, pluginOrder]);
+
   if (activePlugin) {
     return (
       <Focusable onCancelButton={closeActivePlugin}>
@@ -36,7 +46,7 @@ const PluginView: VFC = () => {
       <TitleView />
       <div className={joinClassNames(staticClasses.TabGroupPanel, scrollClasses.ScrollPanel, scrollClasses.ScrollY)}>
         <PanelSection>
-          {plugins
+          {pluginList
             .filter((p) => p.content)
             .map(({ name, icon }) => (
               <PanelSectionRow key={name}>

frontend/src/components/QuickAccessVisibleState.tsx

@@ -4,15 +4,11 @@ const QuickAccessVisibleState = createContext<boolean>(true);
 
 export const useQuickAccessVisible = () => useContext(QuickAccessVisibleState);
 
-export const QuickAccessVisibleStateProvider: FC<{ initial: boolean; setter: ((val: boolean) => {}[]) | never[] }> = ({
-  children,
-  initial,
-  setter,
-}) => {
+export const QuickAccessVisibleStateProvider: FC<{ initial: boolean; tab: any }> = ({ children, initial, tab }) => {
   const [visible, setVisible] = useState<boolean>(initial);
   const [prev, setPrev] = useState<boolean>(initial);
-  // hack to use an array as a "pointer" to pass the setter up the tree
-  setter[0] = setVisible;
+  // HACK but i can't think of a better way to do this
+  tab.qAMVisibilitySetter = setVisible;
   if (initial != prev) {
     setPrev(initial);
     setVisible(initial);

frontend/src/components/modals/filepicker/patches/library.ts

@@ -4,13 +4,6 @@ import Logger from '../../../../logger';
 
 const logger = new Logger('LibraryPatch');
 
-declare global {
-  interface Window {
-    SteamClient: any;
-    appDetailsStore: any;
-  }
-}
-
 let patch: Patch;
 
 function rePatch() {
@@ -20,7 +13,9 @@ function rePatch() {
       const details = window.appDetailsStore.GetAppDetails(appid);
       logger.debug('game details', details);
       // strShortcutStartDir
-      const file = await window.DeckyPluginLoader.openFilePicker(details.strShortcutStartDir.replaceAll('"', ''));
+      const file = await window.DeckyPluginLoader.openFilePicker(
+        details?.strShortcutStartDir.replaceAll('"', '') || '/',
+      );
       logger.debug('user selected', file);
       window.SteamClient.Apps.SetShortcutExe(appid, JSON.stringify(file.path));
       const pathArr = file.path.split('/');

frontend/src/components/settings/pages/developer/index.tsx

@@ -52,7 +52,7 @@ export default function DeveloperSettings() {
       >
         <Toggle
           value={reactDevtoolsEnabled}
-          disabled={reactDevtoolsIP == ''}
+          // disabled={reactDevtoolsIP == ''}
           onChange={(toggleValue) => {
             setReactDevtoolsEnabled(toggleValue);
             setShouldConnectToReactDevTools(toggleValue);

frontend/src/components/settings/pages/general/Updater.tsx

@@ -6,6 +6,7 @@ import {
   Focusable,
   ProgressBarWithInfo,
   Spinner,
+  findSP,
   showModal,
 } from 'decky-frontend-lib';
 import { useCallback } from 'react';
@@ -14,7 +15,6 @@ import { useEffect, useState } from 'react';
 import { FaExclamation } from 'react-icons/fa';
 
 import { VerInfo, callUpdaterMethod, finishUpdate } from '../../../../updater';
-import { findSP } from '../../../../utils/windows';
 import { useDeckyState } from '../../../DeckyState';
 import InlinePatchNotes from '../../../patchnotes/InlinePatchNotes';
 import WithSuspense from '../../../WithSuspense';

frontend/src/components/settings/pages/plugin_list/index.tsx

@@ -2,24 +2,93 @@ import {
   DialogBody,
   DialogButton,
   DialogControlsSection,
-  Focusable,
+  GamepadEvent,
   Menu,
   MenuItem,
+  ReorderableEntry,
+  ReorderableList,
   showContextMenu,
 } from 'decky-frontend-lib';
-import { useEffect } from 'react';
+import { useEffect, useState } from 'react';
 import { FaDownload, FaEllipsisH } from 'react-icons/fa';
 
-import { requestPluginInstall } from '../../../../store';
+import { StorePluginVersion, requestPluginInstall } from '../../../../store';
+import { useSetting } from '../../../../utils/hooks/useSetting';
 import { useDeckyState } from '../../../DeckyState';
 
+function PluginInteractables(props: { entry: ReorderableEntry<PluginData> }) {
+  const data = props.entry.data;
+
+  const showCtxMenu = (e: MouseEvent | GamepadEvent) => {
+    showContextMenu(
+      <Menu label="Plugin Actions">
+        <MenuItem onSelected={() => window.DeckyPluginLoader.importPlugin(props.entry.label, data?.version)}>
+          Reload
+        </MenuItem>
+        <MenuItem onSelected={() => window.DeckyPluginLoader.uninstallPlugin(props.entry.label)}>Uninstall</MenuItem>
+      </Menu>,
+      e.currentTarget ?? window,
+    );
+  };
+
+  return (
+    <>
+      {data?.update && (
+        <DialogButton
+          style={{ height: '40px', minWidth: '60px', marginRight: '10px' }}
+          onClick={() => requestPluginInstall(props.entry.label, data?.update as StorePluginVersion)}
+          onOKButton={() => requestPluginInstall(props.entry.label, data?.update as StorePluginVersion)}
+        >
+          <div style={{ display: 'flex', flexDirection: 'row' }}>
+            Update to {data?.update?.name}
+            <FaDownload style={{ paddingLeft: '2rem' }} />
+          </div>
+        </DialogButton>
+      )}
+      <DialogButton
+        style={{ height: '40px', width: '40px', padding: '10px 12px', minWidth: '40px' }}
+        onClick={showCtxMenu}
+        onOKButton={showCtxMenu}
+      >
+        <FaEllipsisH />
+      </DialogButton>
+    </>
+  );
+}
+
+type PluginData = {
+  update?: StorePluginVersion;
+  version?: string;
+};
+
 export default function PluginList() {
-  const { plugins, updates } = useDeckyState();
+  const { plugins, updates, pluginOrder, setPluginOrder } = useDeckyState();
+  const [_, setPluginOrderSetting] = useSetting<string[]>(
+    'pluginOrder',
+    plugins.map((plugin) => plugin.name),
+  );
 
   useEffect(() => {
     window.DeckyPluginLoader.checkPluginUpdates();
   }, []);
 
+  const [pluginEntries, setPluginEntries] = useState<ReorderableEntry<PluginData>[]>([]);
+
+  useEffect(() => {
+    setPluginEntries(
+      plugins.map((plugin) => {
+        return {
+          label: plugin.name,
+          data: {
+            update: updates?.get(plugin.name),
+            version: plugin.version,
+          },
+          position: pluginOrder.indexOf(plugin.name),
+        };
+      }),
+    );
+  }, [plugins, updates]);
+
   if (plugins.length === 0) {
     return (
       <div>
@@ -28,52 +97,17 @@ export default function PluginList() {
     );
   }
 
+  function onSave(entries: ReorderableEntry<PluginData>[]) {
+    const newOrder = entries.map((entry) => entry.label);
+    console.log(newOrder);
+    setPluginOrder(newOrder);
+    setPluginOrderSetting(newOrder);
+  }
+
   return (
     <DialogBody>
       <DialogControlsSection>
-        <ul style={{ listStyleType: 'none', padding: '0' }}>
-          {plugins.map(({ name, version }) => {
-            const update = updates?.get(name);
-            return (
-              <li style={{ display: 'flex', flexDirection: 'row', alignItems: 'center', paddingBottom: '10px' }}>
-                <span>
-                  {name} <span style={{ opacity: '50%' }}>{'(' + version + ')'}</span>
-                </span>
-                <Focusable style={{ marginLeft: 'auto', boxShadow: 'none', display: 'flex', justifyContent: 'right' }}>
-                  {update && (
-                    <DialogButton
-                      style={{ height: '40px', minWidth: '60px', marginRight: '10px' }}
-                      onClick={() => requestPluginInstall(name, update)}
-                    >
-                      <div style={{ display: 'flex', flexDirection: 'row' }}>
-                        Update to {update.name}
-                        <FaDownload style={{ paddingLeft: '2rem' }} />
-                      </div>
-                    </DialogButton>
-                  )}
-                  <DialogButton
-                    style={{ height: '40px', width: '40px', padding: '10px 12px', minWidth: '40px' }}
-                    onClick={(e: MouseEvent) =>
-                      showContextMenu(
-                        <Menu label="Plugin Actions">
-                          <MenuItem onSelected={() => window.DeckyPluginLoader.importPlugin(name, version)}>
-                            Reload
-                          </MenuItem>
-                          <MenuItem onSelected={() => window.DeckyPluginLoader.uninstallPlugin(name)}>
-                            Uninstall
-                          </MenuItem>
-                        </Menu>,
-                        e.currentTarget ?? window,
-                      )
-                    }
-                  >
-                    <FaEllipsisH />
-                  </DialogButton>
-                </Focusable>
-              </li>
-            );
-          })}
-        </ul>
+        <ReorderableList<PluginData> entries={pluginEntries} onSave={onSave} interactables={PluginInteractables} />
       </DialogControlsSection>
     </DialogBody>
   );

frontend/src/components/store/Store.tsx

@@ -15,7 +15,7 @@ import Logger from '../../logger';
 import { StorePlugin, getPluginList } from '../../store';
 import PluginCard from './PluginCard';
 
-const logger = new Logger('FilePicker');
+const logger = new Logger('Store');
 
 const StorePage: FC<{}> = () => {
   const [currentTabRoute, setCurrentTabRoute] = useState<string>('browse');

frontend/src/index.tsx

@@ -56,6 +56,7 @@ declare global {
       if (!window.DeckyPluginLoader.hasPlugin(plugin.name))
         window.DeckyPluginLoader?.importPlugin(plugin.name, plugin.version);
     }
+
     window.DeckyPluginLoader.checkPluginUpdates();
   };
 

frontend/src/plugin-loader.tsx

@@ -169,6 +169,12 @@ class PluginLoader extends Logger {
     getSetting('developer.enabled', false).then((val) => {
       if (val) import('./developer').then((developer) => developer.startup());
     });
+
+    //* Grab and set plugin order
+    getSetting<string[]>('pluginOrder', []).then((pluginOrder) => {
+      console.log(pluginOrder);
+      this.deckyState.setPluginOrder(pluginOrder);
+    });
   }
 
   public deinit() {

frontend/src/router-hook.tsx

@@ -123,11 +123,9 @@ class RouterHook extends Logger {
     this.wrapperPatch = afterPatch(this.gamepadWrapper, 'render', (_: any, ret: any) => {
       if (ret?.props?.children?.props?.children?.length == 5 || ret?.props?.children?.props?.children?.length == 4) {
         const idx = ret?.props?.children?.props?.children?.length == 4 ? 1 : 2;
-        if (
-          ret.props.children.props.children[idx]?.props?.children?.[0]?.type?.type
-            ?.toString()
-            ?.includes('GamepadUI.Settings.Root()')
-        ) {
+        const potentialSettingsRootString =
+          ret.props.children.props.children[idx]?.props?.children?.[0]?.type?.type?.toString() || '';
+        if (potentialSettingsRootString?.includes('Settings.Root()')) {
           if (!this.router) {
             this.router = ret.props.children.props.children[idx]?.props?.children?.[0]?.type;
             this.routerPatch = afterPatch(this.router, 'type', (_: any, ret: any) => {

frontend/src/steamfixes/index.ts

@@ -7,6 +7,6 @@ export function deinitSteamFixes() {
 }
 
 export async function initSteamFixes() {
-  fixes.push(reloadFix());
+  fixes.push(await reloadFix());
   fixes.push(await restartFix());
 }

frontend/src/steamfixes/reload.ts

@@ -1,10 +1,17 @@
+import { getFocusNavController, sleep } from 'decky-frontend-lib';
+
 import Logger from '../logger';
 
 const logger = new Logger('ReloadSteamFix');
 
-export default function reloadFix() {
+declare global {
+  var GamepadNavTree: any;
+}
+
+export default async function reloadFix() {
   // Hack to unbreak the ui when reloading it
-  if (window.FocusNavController?.m_rgAllContexts?.length == 0) {
+  await sleep(4000);
+  if (getFocusNavController()?.m_rgAllContexts?.length == 0) {
     SteamClient.URL.ExecuteSteamURL('steam://open/settings');
     logger.log('Applied UI reload fix.');
   }

frontend/src/steamfixes/restart.ts

@@ -4,13 +4,6 @@ import Logger from '../logger';
 
 const logger = new Logger('RestartSteamFix');
 
-declare global {
-  interface Window {
-    SteamClient: any;
-    appDetailsStore: any;
-  }
-}
-
 let patch: Patch;
 
 function rePatch() {

frontend/src/tabs-hook.tsx

@@ -35,7 +35,7 @@ class TabsHook extends Logger {
     const tree = (document.getElementById('root') as any)._reactRootContainer._internalRoot.current;
     let qAMRoot: any;
     const findQAMRoot = (currentNode: any, iters: number): any => {
-      if (iters >= 55) {
+      if (iters >= 65) {
         // currently 45
         return null;
       }
@@ -128,22 +128,23 @@ class TabsHook extends Logger {
     let deckyTabAmount = existingTabs.reduce((prev: any, cur: any) => (cur.decky ? prev + 1 : prev), 0);
     if (deckyTabAmount == this.tabs.length) {
       for (let tab of existingTabs) {
-        if (tab?.decky) tab.panel.props.setter[0](visible);
+        if (tab?.decky && tab?.qAMVisibilitySetter) tab?.qAMVisibilitySetter(visible);
       }
       return;
     }
     for (const { title, icon, content, id } of this.tabs) {
-      existingTabs.push({
+      const tab: any = {
         key: id,
         title,
         tab: icon,
         decky: true,
-        panel: (
-          <QuickAccessVisibleStateProvider initial={visible} setter={[]}>
-            {content}
-          </QuickAccessVisibleStateProvider>
-        ),
-      });
+      };
+      tab.panel = (
+        <QuickAccessVisibleStateProvider initial={visible} tab={tab}>
+          {content}
+        </QuickAccessVisibleStateProvider>
+      );
+      existingTabs.push(tab);
     }
   }
 }

frontend/src/toaster.tsx

@@ -40,11 +40,15 @@ class Toaster extends Logger {
     let instance: any;
     const tree = (document.getElementById('root') as any)._reactRootContainer._internalRoot.current;
     const findToasterRoot = (currentNode: any, iters: number): any => {
-      if (iters >= 50) {
-        // currently 40
+      if (iters >= 65) {
+        // currently 65
         return null;
       }
-      if (currentNode?.memoizedProps?.className?.startsWith?.('toastmanager_ToastPlaceholder')) {
+      if (
+        currentNode?.memoizedProps?.className?.startsWith?.('gamepadtoasts_GamepadToastPlaceholder') ||
+        currentNode?.memoizedProps?.className?.startsWith?.('toastmanager_ToastPlaceholder') ||
+        currentNode?.memoizedProps?.className?.startsWith?.('toastmanager_ToastPopup')
+      ) {
         this.log(`Toaster root was found in ${iters} recursion cycles`);
         return currentNode;
       }

frontend/src/utils/windows.ts

@@ -1,7 +0,0 @@
-export function findSP(): Window {
-  // old (SP as host)
-  if (document.title == 'SP') return window;
-  // new (SP as popup)
-  return FocusNavController.m_ActiveContext.m_rgGamepadNavigationTrees.find((x: any) => x.m_ID == 'root_1_').Root
-    .Element.ownerDocument.defaultView;
-}

frontend/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "module": "ESNext",
-    "target": "ES2020",
+    "target": "ES2021",
     "jsx": "react",
     "jsxFactory": "window.SP_REACT.createElement",
     "jsxFragmentFactory": "window.SP_REACT.Fragment",

plugin/decky_plugin.py

@@ -0,0 +1,201 @@
+"""
+This module exposes various constants and helpers useful for decky plugins.
+
+* Plugin's settings and configurations should be stored under `DECKY_PLUGIN_SETTINGS_DIR`.
+* Plugin's runtime data should be stored under `DECKY_PLUGIN_RUNTIME_DIR`.
+* Plugin's persistent log files should be stored under `DECKY_PLUGIN_LOG_DIR`.
+
+Avoid writing outside of `DECKY_HOME`, storing under the suggested paths is strongly recommended.
+
+Some basic migration helpers are available: `migrate_any`, `migrate_settings`, `migrate_runtime`, `migrate_logs`.
+
+A logging facility `logger` is available which writes to the recommended location.
+"""
+
+__version__ = '0.1.0'
+
+import os
+import subprocess
+import logging
+
+"""
+Constants
+"""
+
+HOME: str = os.getenv("HOME", default="")
+"""
+The home directory of the effective user running the process.
+Environment variable: `HOME`.
+If `root` was specified in the plugin's flags it will be `/root` otherwise the user whose home decky resides in.
+e.g.: `/home/deck`
+"""
+
+USER: str = os.getenv("USER", default="")
+"""
+The effective username running the process.
+Environment variable: `USER`.
+It would be `root` if `root` was specified in the plugin's flags otherwise the user whose home decky resides in.
+e.g.: `deck`
+"""
+
+DECKY_VERSION: str = os.getenv("DECKY_VERSION", default="")
+"""
+The version of the decky loader.
+Environment variable: `DECKY_VERSION`.
+e.g.: `v2.5.0-pre1`
+"""
+
+DECKY_USER: str = os.getenv("DECKY_USER", default="")
+"""
+The user whose home decky resides in.
+Environment variable: `DECKY_USER`.
+e.g.: `deck`
+"""
+
+DECKY_USER_HOME: str = os.getenv("DECKY_USER_HOME", default="")
+"""
+The home of the user where decky resides in.
+Environment variable: `DECKY_USER_HOME`.
+e.g.: `/home/deck`
+"""
+
+DECKY_HOME: str = os.getenv("DECKY_HOME", default="")
+"""
+The root of the decky folder.
+Environment variable: `DECKY_HOME`.
+e.g.: `/home/deck/homebrew`
+"""
+
+DECKY_PLUGIN_SETTINGS_DIR: str = os.getenv(
+    "DECKY_PLUGIN_SETTINGS_DIR", default="")
+"""
+The recommended path in which to store configuration files (created automatically).
+Environment variable: `DECKY_PLUGIN_SETTINGS_DIR`.
+e.g.: `/home/deck/homebrew/settings/decky-plugin-template`
+"""
+
+DECKY_PLUGIN_RUNTIME_DIR: str = os.getenv(
+    "DECKY_PLUGIN_RUNTIME_DIR", default="")
+"""
+The recommended path in which to store runtime data (created automatically).
+Environment variable: `DECKY_PLUGIN_RUNTIME_DIR`.
+e.g.: `/home/deck/homebrew/data/decky-plugin-template`
+"""
+
+DECKY_PLUGIN_LOG_DIR: str = os.getenv("DECKY_PLUGIN_LOG_DIR", default="")
+"""
+The recommended path in which to store persistent logs (created automatically).
+Environment variable: `DECKY_PLUGIN_LOG_DIR`.
+e.g.: `/home/deck/homebrew/logs/decky-plugin-template`
+"""
+
+DECKY_PLUGIN_DIR: str = os.getenv("DECKY_PLUGIN_DIR", default="")
+"""
+The root of the plugin's directory.
+Environment variable: `DECKY_PLUGIN_DIR`.
+e.g.: `/home/deck/homebrew/plugins/decky-plugin-template`
+"""
+
+DECKY_PLUGIN_NAME: str = os.getenv("DECKY_PLUGIN_NAME", default="")
+"""
+The name of the plugin as specified in the 'plugin.json'.
+Environment variable: `DECKY_PLUGIN_NAME`.
+e.g.: `Example Plugin`
+"""
+
+DECKY_PLUGIN_VERSION: str = os.getenv("DECKY_PLUGIN_VERSION", default="")
+"""
+The version of the plugin as specified in the 'package.json'.
+Environment variable: `DECKY_PLUGIN_VERSION`.
+e.g.: `0.0.1`
+"""
+
+DECKY_PLUGIN_AUTHOR: str = os.getenv("DECKY_PLUGIN_AUTHOR", default="")
+"""
+The author of the plugin as specified in the 'plugin.json'.
+Environment variable: `DECKY_PLUGIN_AUTHOR`.
+e.g.: `John Doe`
+"""
+
+DECKY_PLUGIN_LOG: str = os.path.join(DECKY_PLUGIN_LOG_DIR, "plugin.log")
+"""
+The path to the plugin's main logfile.
+Environment variable: `DECKY_PLUGIN_LOG`.
+e.g.: `/home/deck/homebrew/logs/decky-plugin-template/plugin.log`
+"""
+
+"""
+Migration helpers
+"""
+
+
+def migrate_any(target_dir: str, *files_or_directories: str) -> dict[str, str]:
+    """
+    Migrate files and directories to a new location and remove old locations.
+    Specified files will be migrated to `target_dir`.
+    Specified directories will have their contents recursively migrated to `target_dir`.
+
+    Returns the mapping of old -> new location.
+    """
+    file_map: dict[str, str] = {}
+    for f in files_or_directories:
+        if not os.path.exists(f):
+            file_map[f] = ""
+            continue
+        if os.path.isdir(f):
+            src_dir = f
+            src_file = "."
+            file_map[f] = target_dir
+        else:
+            src_dir = os.path.dirname(f)
+            src_file = os.path.basename(f)
+            file_map[f] = os.path.join(target_dir, src_file)
+        subprocess.run(["sh", "-c", "mkdir -p \"$3\"; tar -cf - -C \"$1\" \"$2\" | tar -xf - -C \"$3\" && rm -rf \"$4\"",
+                       "_", src_dir, src_file, target_dir, f])
+    return file_map
+
+
+def migrate_settings(*files_or_directories: str) -> dict[str, str]:
+    """
+    Migrate files and directories relating to plugin settings to the recommended location and remove old locations.
+    Specified files will be migrated to `DECKY_PLUGIN_SETTINGS_DIR`.
+    Specified directories will have their contents recursively migrated to `DECKY_PLUGIN_SETTINGS_DIR`.
+
+    Returns the mapping of old -> new location.
+    """
+    return migrate_any(DECKY_PLUGIN_SETTINGS_DIR, *files_or_directories)
+
+
+def migrate_runtime(*files_or_directories: str) -> dict[str, str]:
+    """
+    Migrate files and directories relating to plugin runtime data to the recommended location and remove old locations
+    Specified files will be migrated to `DECKY_PLUGIN_RUNTIME_DIR`.
+    Specified directories will have their contents recursively migrated to `DECKY_PLUGIN_RUNTIME_DIR`.
+
+    Returns the mapping of old -> new location.
+    """
+    return migrate_any(DECKY_PLUGIN_RUNTIME_DIR, *files_or_directories)
+
+
+def migrate_logs(*files_or_directories: str) -> dict[str, str]:
+    """
+    Migrate files and directories relating to plugin logs to the recommended location and remove old locations.
+    Specified files will be migrated to `DECKY_PLUGIN_LOG_DIR`.
+    Specified directories will have their contents recursively migrated to `DECKY_PLUGIN_LOG_DIR`.
+
+    Returns the mapping of old -> new location.
+    """
+    return migrate_any(DECKY_PLUGIN_LOG_DIR, *files_or_directories)
+
+
+"""
+Logging
+"""
+
+logging.basicConfig(filename=DECKY_PLUGIN_LOG,
+                    format='[%(asctime)s][%(levelname)s]: %(message)s',
+                    force=True)
+logger: logging.Logger = logging.getLogger()
+"""The main plugin logger writing to `DECKY_PLUGIN_LOG`."""
+
+logger.setLevel(logging.INFO)

plugin/decky_plugin.pyi

@@ -0,0 +1,173 @@
+"""
+This module exposes various constants and helpers useful for decky plugins.
+
+* Plugin's settings and configurations should be stored under `DECKY_PLUGIN_SETTINGS_DIR`.
+* Plugin's runtime data should be stored under `DECKY_PLUGIN_RUNTIME_DIR`.
+* Plugin's persistent log files should be stored under `DECKY_PLUGIN_LOG_DIR`.
+
+Avoid writing outside of `DECKY_HOME`, storing under the suggested paths is strongly recommended.
+
+Some basic migration helpers are available: `migrate_any`, `migrate_settings`, `migrate_runtime`, `migrate_logs`.
+
+A logging facility `logger` is available which writes to the recommended location.
+"""
+
+__version__ = '0.1.0'
+
+import logging
+
+"""
+Constants
+"""
+
+HOME: str
+"""
+The home directory of the effective user running the process.
+Environment variable: `HOME`.
+If `root` was specified in the plugin's flags it will be `/root` otherwise the user whose home decky resides in.
+e.g.: `/home/deck`
+"""
+
+USER: str
+"""
+The effective username running the process.
+Environment variable: `USER`.
+It would be `root` if `root` was specified in the plugin's flags otherwise the user whose home decky resides in.
+e.g.: `deck`
+"""
+
+DECKY_VERSION: str
+"""
+The version of the decky loader.
+Environment variable: `DECKY_VERSION`.
+e.g.: `v2.5.0-pre1`
+"""
+
+DECKY_USER: str
+"""
+The user whose home decky resides in.
+Environment variable: `DECKY_USER`.
+e.g.: `deck`
+"""
+
+DECKY_USER_HOME: str
+"""
+The home of the user where decky resides in.
+Environment variable: `DECKY_USER_HOME`.
+e.g.: `/home/deck`
+"""
+
+DECKY_HOME: str
+"""
+The root of the decky folder.
+Environment variable: `DECKY_HOME`.
+e.g.: `/home/deck/homebrew`
+"""
+
+DECKY_PLUGIN_SETTINGS_DIR: str
+"""
+The recommended path in which to store configuration files (created automatically).
+Environment variable: `DECKY_PLUGIN_SETTINGS_DIR`.
+e.g.: `/home/deck/homebrew/settings/decky-plugin-template`
+"""
+
+DECKY_PLUGIN_RUNTIME_DIR: str
+"""
+The recommended path in which to store runtime data (created automatically).
+Environment variable: `DECKY_PLUGIN_RUNTIME_DIR`.
+e.g.: `/home/deck/homebrew/data/decky-plugin-template`
+"""
+
+DECKY_PLUGIN_LOG_DIR: str
+"""
+The recommended path in which to store persistent logs (created automatically).
+Environment variable: `DECKY_PLUGIN_LOG_DIR`.
+e.g.: `/home/deck/homebrew/logs/decky-plugin-template`
+"""
+
+DECKY_PLUGIN_DIR: str
+"""
+The root of the plugin's directory.
+Environment variable: `DECKY_PLUGIN_DIR`.
+e.g.: `/home/deck/homebrew/plugins/decky-plugin-template`
+"""
+
+DECKY_PLUGIN_NAME: str
+"""
+The name of the plugin as specified in the 'plugin.json'.
+Environment variable: `DECKY_PLUGIN_NAME`.
+e.g.: `Example Plugin`
+"""
+
+DECKY_PLUGIN_VERSION: str
+"""
+The version of the plugin as specified in the 'package.json'.
+Environment variable: `DECKY_PLUGIN_VERSION`.
+e.g.: `0.0.1`
+"""
+
+DECKY_PLUGIN_AUTHOR: str
+"""
+The author of the plugin as specified in the 'plugin.json'.
+Environment variable: `DECKY_PLUGIN_AUTHOR`.
+e.g.: `John Doe`
+"""
+
+DECKY_PLUGIN_LOG: str
+"""
+The path to the plugin's main logfile.
+Environment variable: `DECKY_PLUGIN_LOG`.
+e.g.: `/home/deck/homebrew/logs/decky-plugin-template/plugin.log`
+"""
+
+"""
+Migration helpers
+"""
+
+
+def migrate_any(target_dir: str, *files_or_directories: str) -> dict[str, str]:
+    """
+    Migrate files and directories to a new location and remove old locations.
+    Specified files will be migrated to `target_dir`.
+    Specified directories will have their contents recursively migrated to `target_dir`.
+
+    Returns the mapping of old -> new location.
+    """
+
+
+def migrate_settings(*files_or_directories: str) -> dict[str, str]:
+    """
+    Migrate files and directories relating to plugin settings to the recommended location and remove old locations.
+    Specified files will be migrated to `DECKY_PLUGIN_SETTINGS_DIR`.
+    Specified directories will have their contents recursively migrated to `DECKY_PLUGIN_SETTINGS_DIR`.
+
+    Returns the mapping of old -> new location.
+    """
+
+
+def migrate_runtime(*files_or_directories: str) -> dict[str, str]:
+    """
+    Migrate files and directories relating to plugin runtime data to the recommended location and remove old locations
+    Specified files will be migrated to `DECKY_PLUGIN_RUNTIME_DIR`.
+    Specified directories will have their contents recursively migrated to `DECKY_PLUGIN_RUNTIME_DIR`.
+
+    Returns the mapping of old -> new location.
+    """
+
+
+def migrate_logs(*files_or_directories: str) -> dict[str, str]:
+    """
+    Migrate files and directories relating to plugin logs to the recommended location and remove old locations.
+    Specified files will be migrated to `DECKY_PLUGIN_LOG_DIR`.
+    Specified directories will have their contents recursively migrated to `DECKY_PLUGIN_LOG_DIR`.
+
+    Returns the mapping of old -> new location.
+    """
+
+
+"""
+Logging
+"""
+
+logger: logging.Logger
+"""The main plugin logger writing to `DECKY_PLUGIN_LOG`."""