Merge branch 'main' into python-lint-format-test

Add lint job to build workflow (#363 )
* Add lint job to build workflow * Add prettier-plugin-import-sort * Install prettier plugins before linting * Use lint script from package.json * Move linters to separate workflow * Remove Python and Shell linters * Remove popd * Test that prettier properly fails the lint job
2026-06-13 12:15:09 +03:00 · 2023-02-04 00:42:38 -03:00 · 2023-02-03 19:40:29 -08:00 · 2023-02-04 00:31:42 -03:00 · 2023-02-04 00:29:34 -03:00 · 2023-02-04 00:22:17 -03:00
65 changed files with 3042 additions and 1314 deletions
@@ -0,0 +1,73 @@
+name: Bug report
+description: File a bug/issue
+title: "[BUG] <title>"
+labels: [bug]
+body:
+  - type: checkboxes
+    id: low-effort-checks
+    attributes:
+      label: Please confirm
+      description: Issues without all checks may be ignored/closed.
+      options:
+        - 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)
+
+  - type: textarea
+    attributes:
+      label: Bug Report Description
+      description: A clear and concise description of what the bug is and if possible, the steps you used to get to the bug. If appropriate, include screenshots or videos.
+      placeholder: |
+        When I try to use ...
+
+        Steps to reproduce the behavior:
+        1. Go to '...'
+        2. Click on '....'
+        3. Scroll down to '....'
+        4. See error
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Expected Behaviour
+      description: A brief description of the expected behavior.
+      placeholder: It should be ...
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: SteamOS version
+#      description: Can be found with `uname -a`
+#      placeholder: "Linux steamdeck 5.13.0-valve36-1-neptune #1 SMP PREEMPT Mon, 19 Dec 2022 23:39:41 +0000 x86_64 GNU/Linux"
+      placeholder: "SteamOS 3.4.3 Stable"
+    validations:
+      required: true
+
+  - type: dropdown
+    attributes:
+      label: Selected Update Channel
+      description: Which branch of Decky are you on?
+      multiple: false
+      options:
+         - Stable
+         - Prerelease
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: Have you modified the read-only filesystem at any point?
+      description: Describe how here, if you haven't done anything you can leave this blank
+      placeholder: Yes, I've installed neofetch via pacman.
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: Logs
+      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
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Steam Deck Homebrew Discord Server
+    url: https://discord.gg/ZU74G2NJzk
+    about: Please ask and answer questions here.
@@ -0,0 +1,35 @@
+name: Feature request
+description: Request a new feature (NOT A PLUGIN)
+title: "[Request] <title>"
+labels: [feature request]
+body:
+  - type: checkboxes
+    id: low-effort-checks
+    attributes:
+      label: Please confirm
+      description: Issues without all checks may be ignored/closed.
+      options:
+        - label: I have searched existing issues
+        - label: This issue is not a duplicate of an existing one
+        - label: This is not a request for a plugin
+
+  - type: textarea
+    attributes:
+      label: Feature Request Description
+      description: A clear and concise description of what the new feature. 
+      placeholder: |
+        Decky plugins should be sortable in the quick access menu
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Further Description
+      description: A further explanation of the feature. If appropriate, include screenshots or videos.
+      placeholder: |
+        This would help make the UI clearer and easier to use as there is less clutter in the QAM.
+        It would also make it faster to access plugins that are used more.
+
+        This could be implemented by adding ...
+    validations:
+      required: false
@@ -31,7 +31,7 @@ permissions:
 jobs:
  build:
    name: Build PluginLoader
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04

    steps:
    - name: Print input
@@ -47,15 +47,15 @@ jobs:
      with:
        node-version: 18
      
-    - name: Set up Python 3.10 🐍
-      uses: actions/setup-python@v3
+    - name: Set up Python 3.10.2 🐍
+      uses: actions/setup-python@v4
      with:
-        python-version: "3.10"
+        python-version: "3.10.2"
        
    - name: Install Python dependencies ⬇️
      run: |
        python -m pip install --upgrade pip
-        pip install pyinstaller
+        pip install pyinstaller==5.5
        [ -f requirements.txt ] && pip install -r requirements.txt

    - name: Install JS dependencies ⬇️
@@ -130,9 +130,7 @@ jobs:
            OUT=$(semver bump ${{github.event.inputs.bump}} "$OUT")
            printf "OUT: ${OUT}\n"
          else
-            printf "no type selected, defaulting to patch.\n"
-            OUT=$(semver bump patch "$OUT")
-            printf "OUT: ${OUT}\n"
+            printf "no type selected, not bumping for release.\n"
          fi
        elif [[ ! "$VERSION" =~ "-pre" ]]; then
          printf "previous tag is a release, bumping by selected type.\n"
@@ -159,7 +157,7 @@ jobs:
      uses: softprops/action-gh-release@v1
      if: ${{ github.event_name == 'workflow_dispatch' && !env.ACT  }}
      with:
-        name: Prerelease ${{ steps.ready_tag.outputs.tag_name }}
+        name: Release ${{ steps.ready_tag.outputs.tag_name }}
        tag_name: ${{ steps.ready_tag.outputs.tag_name }}
        files: ./dist/PluginLoader
        prerelease: false
@@ -0,0 +1,27 @@
+name: Lint
+
+on:
+  push:
+
+jobs:
+  lint:
+    name: Run linters
+    runs-on: ubuntu-20.04
+
+    steps:
+      - uses: actions/checkout@v2 # Check out the repository first.
+      - name: Run prettier (JavaScript & TypeScript)
+        run: |
+          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"
@@ -14,7 +14,9 @@
            "label": "localrun",
            "type": "shell",
            "group": "none",
-            "dependsOn" : ["buildall"],
+            "dependsOn": [
+                "buildall"
+            ],
            "detail": "Check for local runs, create a plugins folder",
            "command": "mkdir -p plugins",
            "problemMatcher": []
@@ -48,6 +50,16 @@
            "command": "cd frontend && pnpm i",
            "problemMatcher": []
        },
+        {
+            "script": "watch",
+            "type": "npm",
+            "path": "frontend",
+            "group": "build",
+            "problemMatcher": [],
+            "label": "watchfrontend",
+            "detail": "rollup -c -w",
+            "isBackground": true
+        },
        {
            "label": "buildfrontend",
            "type": "npm",
@@ -55,8 +67,7 @@
            "detail": "rollup -c",
            "script": "build",
            "path": "frontend",
-            "problemMatcher": [],
-            
+            "problemMatcher": []
        },
        {
            "label": "buildall",
@@ -95,7 +106,9 @@
            "detail": "Run indev PluginLoader on Deck",
            "type": "shell",
            "group": "none",
-            "dependsOn" : ["checkforsettings"],
+            "dependsOn": [
+                "checkforsettings"
+            ],
            "command": "ssh deck@${config:deckip} -p ${config:deckport} ${config:deckkey} 'export PLUGIN_PATH=${config:deckdir}/homebrew/dev/plugins; export CHOWN_PLUGIN_PATH=0; export LOG_LEVEL=DEBUG; cd ${config:deckdir}/homebrew/services; echo '${config:deckpass}' | sudo -SE python3 ${config:deckdir}/homebrew/dev/pluginloader/backend/main.py'",
            "problemMatcher": []
        },
@@ -108,6 +121,20 @@
            "problemMatcher": []
        },
        // ALL-IN-ONES
+        {
+            "label": "deployandrun",
+            "detail": "Deploy and run, skipping JS build. Useful when combined with npm:watch",
+            "dependsOrder": "sequence",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "dependsOn": [
+                "deploy",
+                "runpydeck"
+            ],
+            "problemMatcher": []
+        },
        {
            "label": "updateremote",
            "detail": "Build and deploy",
@@ -115,7 +142,7 @@
            "group": "none",
            "dependsOn": [
                "buildall",
-                "deploy",
+                "deploy"
            ],
            "problemMatcher": []
        },
@@ -128,7 +155,7 @@
                "isDefault": true
            },
            "dependsOn": [
-                "buildall",
+                "buildfrontend",
                "deploy",
                "runpydeck"
            ],
@@ -152,4 +179,4 @@
            "problemMatcher": []
        }
    ]
-}
+}
@@ -1,7 +1,9 @@
 <h1 align="center">
-  <a name="logo" href="https://deckbrew.xyz/"><img src="https://deckbrew.xyz/logo.png" alt="Deckbrew logo" width="200"></a>
+  <a name="logo" href="https://deckbrew.xyz/"><img src="https://deckbrew.xyz/static/icon-45ca1f5aea376a9ad37e92db906f283e.png" alt="Deckbrew logo" width="200"></a>
  <br>
  Decky Loader
+  <br>
+  <a name="logo" href="https://github.com/SteamDeckHomebrew/decky-installer/releases/latest/download/decky_installer.desktop"><img src="./docs/images/download_button.png"  alt="Download decky" width="350"></a>
 </h1>

 <p align="center">
@@ -17,7 +19,7 @@

 ## 📖 About

-Decky Loader is a homebrew plugin launcher for the Steam Deck. It can be used to [stylize your menus](https://github.com/suchmememanyskill/SDH-CssLoader), [change system sounds](https://github.com/EMERALD0874/SDH-AudioLoader), [adjust your screen saturation](https://github.com/libvibrant/vibrantDeck), [change additional system settings](https://github.com/NGnius/PowerTools), and [more](https://beta.deckbrew.xyz/).
+Decky Loader is a homebrew plugin launcher for the Steam Deck. It can be used to [stylize your menus](https://github.com/suchmememanyskill/SDH-CssLoader), [change system sounds](https://github.com/EMERALD0874/SDH-AudioLoader), [adjust your screen saturation](https://github.com/libvibrant/vibrantDeck), [change additional system settings](https://github.com/NGnius/PowerTools), and [more](https://plugins.deckbrew.xyz/).

 For more information about Decky Loader as well as documentation and development tools, please visit [our wiki](https://deckbrew.xyz).

@@ -33,14 +35,11 @@ For more information about Decky Loader as well as documentation and development

 - Crankshaft is incompatible with Decky Loader. If you are using Crankshaft, please uninstall it before installing Decky Loader.
 - Syncthing may use port 8080 on Steam Deck, which Decky Loader needs to function. If you are using Syncthing as a service, please change its port to something else.
- If you are using any software that uses port 1337, please change its port to something else or uninstall it.
+- If you are using any software that uses port 1337 or 8080, please change its port to something else or uninstall it.
+- If you run the installer and it just opens a file in a text editor: click the (...) button in the top right of dolphin (the file manager) then 'configure' and 'configure dolphin'. Click on the 'confirmations' tab and set 'when opening an executable file' to 'run script'.

 ## 💾 Installation
-
-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 Settings menu.
-1. Navigate to the System menu and scroll to the System Settings. Toggle "Enable Developer Mode" so it is enabled.
-1. Navigate to the Developer menu and scroll to Miscellaneous. Toggle "CEF Remote Debugging" so it is enabled.
-1. Select "Restart Now" to apply your changes.
+- This installation can be done without an admin/sudo password set.
 1. Prepare a mouse and keyboard if possible.
   - Keyboards and mice can be connected to the Steam Deck via USB-C or Bluetooth.
   - Many Bluetooth keyboard and mouse apps are available for iOS and Android.
@@ -48,24 +47,27 @@ For more information about Decky Loader as well as documentation and development
   - If you have no other options, use the right trackpad as a mouse and press <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>+<img src="./docs/images/light/x.svg#gh-dark-mode-only" height=16><img src="./docs/images/dark/x.svg#gh-light-mode-only" height=16> to open the on-screen keyboard as needed.
 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".
-1. Open the Konsole app and enter the command `passwd`. You can skip this step if you have already created a sudo password using this command. ([YouTube Guide](https://www.youtube.com/watch?v=1vOMYGj22rQ))
-1. You will be prompted to create a password. Your text will not be visible. After you press enter, you will need to type your password again to confirm.
-1. Choose the version of Decky Loader you want to install and paste the following command into the Konsole app.
+1. Navigate to this Github page on a browser of your choice.
+1. Press the 'Download' button at the top of the page.
+1. Run the downloaded file by clicking on it in Dolphin (the file manager).
+1. Either type your admin password or allow Decky to temporarily set your password to `Decky!`
+1. Choose the version of Decky Loader you want to install.
   - **Latest Release**  
     Intended for most users. This is the latest stable version of Decky Loader.  
-     `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/install_release.sh | sh`
   - **Latest Pre-Release**  
-     Intended for plugin developers. Pre-releases are unlikely to be fully stable but contain the latest changes. For more information on plugin development, please consult [the wiki page](https://deckbrew.xyz/en/loader-dev/development).  
-     `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/install_prerelease.sh | sh`
+     Intended for plugin developers. Pre-releases are unlikely to be fully stable but contain the latest changes. For more information on plugin development, please consult [the wiki page](https://deckbrew.xyz/en/loader-dev/development).
 1. Open the Return to Gaming Mode shortcut on your desktop.

+- There is also a fast install for those who can use Konsole. Run `curl -L https://github.com/SteamDeckHomebrew/decky-installer/releases/latest/download/install_release.sh | sh` and type your password when prompted.
+
 ### 👋 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.

 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".
-1. Open the Konsole app and run `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/uninstall.sh | sh`.
+1. Run the installer file again, and select `uninstall decky loader` 
+- There is also a fast uninstall for those who can use Konsole. Run `curl -L https://github.com/SteamDeckHomebrew/decky-installer/releases/latest/download/uninstall.sh | sh` and type your password when prompted.

 ## 🚀 Getting Started

@@ -26,10 +26,10 @@ cd ..

 if [[ "$type" == "release" ]]; then
    printf "release!\n"
-    act workflow_dispatch -e act/release.json --artifact-server-path act/artifacts
+    act workflow_dispatch -e act/release.json --artifact-server-path act/artifacts --container-architecture linux/amd64
 elif [[ "$type" == "prerelease" ]]; then
    printf "prerelease!\n"
-    act workflow_dispatch -e act/prerelease.json --artifact-server-path act/artifacts
+    act workflow_dispatch -e act/prerelease.json --artifact-server-path act/artifacts --container-architecture linux/amd64
 else
    printf "Release type unspecified/badly specified.\n"
    printf "Options: 'release' or 'prerelease'\n"
@@ -1,25 +1,33 @@
 # Full imports
 import json

+# import pprint
+# from pprint import pformat
+
 # Partial imports
-from aiohttp import ClientSession, web
-from asyncio import get_event_loop, sleep
-from concurrent.futures import ProcessPoolExecutor
+from aiohttp import ClientSession
+from asyncio import sleep
 from hashlib import sha256
 from io import BytesIO
 from logging import getLogger
-from os import R_OK, W_OK, path, rename, listdir, access, mkdir
+from os import R_OK, W_OK, path, listdir, access, mkdir
 from shutil import rmtree
 from subprocess import call
 from time import time
 from zipfile import ZipFile

 # Local modules
-from helpers import get_ssl_context, get_user, get_user_group, download_remote_binary_to_path
-from injector import get_tab, inject_to_tab
+from helpers import (
+    get_ssl_context,
+    get_user,
+    get_user_group,
+    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
@@ -27,6 +35,7 @@ class PluginInstallContext:
        self.version = version
        self.hash = hash

+
 class PluginBrowser:
    def __init__(self, plugin_path, plugins, loader) -> None:
        self.plugin_path = plugin_path
@@ -41,32 +50,40 @@ class PluginBrowser:
        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_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}, chmod: {code_chmod})")
+            logger.error(
+                f"chown/chmod exited with a non-zero exit code (chown: {code_chown},"
+                f" chmod: {code_chmod})"
+            )
            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') as f:
+                with open(packageJsonPath, "r", encoding="utf-8") as f:
                    packageJson = json.load(f)
-                    if len(packageJson["remote_binary"]) > 0:
+                    if (
+                        "remote_binary" in packageJson
+                        and len(packageJson["remote_binary"]) > 0
+                    ):
                        # create bin directory if needed.
-                        rc=call(["chmod", "-R", "777", pluginBasePath])
+                        call(["chmod", "-R", "777", pluginBasePath])
                        if access(pluginBasePath, W_OK):
-                            
+
                            if not path.exists(pluginBinPath):
                                mkdir(pluginBinPath)
-                            
+
                            if not access(pluginBinPath, W_OK):
-                                rc=call(["chmod", "-R", "777", pluginBinPath])
+                                call(["chmod", "-R", "777", pluginBinPath])

                        rv = True
                        for remoteBinary in packageJson["remote_binary"]:
@@ -74,16 +91,29 @@ 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(f"Error Downloading Remote Binary {binName}@{binURL} with hash {binHash} to {path.join(pluginBinPath, binName)}")
+                                raise Exception(
+                                    "Error Downloading Remote Binary"
+                                    f" {binName}@{binURL} with hash {binHash} to"
+                                    f" {path.join(pluginBinPath, binName)}"
+                                )

-                        code_chown = call(["chown", "-R", get_user()+":"+get_user_group(), self.plugin_path])
-                        rc=call(["chmod", "-R", "555", pluginBasePath])
+                        call(
+                            [
+                                "chown",
+                                "-R",
+                                get_user() + ":" + get_user_group(),
+                                self.plugin_path,
+                            ]
+                        )
+                        call(["chmod", "-R", "555", pluginBasePath])
                    else:
                        rv = True
-                        logger.debug(f"No Remote Binaries to Download")
-                
+                        logger.debug("No Remote Binaries to Download")
+
        except Exception as e:
            rv = False
            logger.debug(str(e))
@@ -93,43 +123,62 @@ class PluginBrowser:
    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') 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 path.join(self.plugin_path, folder)
-            except:
+                if plugin["name"] == name:
+                    return str(path.join(self.plugin_path, folder))
+            except Exception:
                logger.debug(f"skipping {folder}")

    async def uninstall_plugin(self, name):
        if self.loader.watcher:
            self.loader.watcher.disabled = True
-        tab = await get_tab("SP")
+        tab = await get_gamepadui_tab()
        try:
            logger.info("uninstalling " + name)
            logger.info(" at dir " + self.find_plugin_folder(name))
-            logger.debug("unloading %s" % str(name))
-            await tab.evaluate_js(f"DeckyPluginLoader.unloadPlugin('{name}')")
+            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)
+            # plugins_snapshot = self.plugins.copy()
+            # snapshot_string = pformat(plugins_snapshot)
+            # logger.debug("current plugins: %s", snapshot_string)
            if self.plugins[name]:
+                logger.debug("Plugin %s was found", name)
                self.plugins[name].stop()
+                logger.debug("Plugin %s was stopped", name)
                del self.plugins[name]
+                logger.debug("Plugin %s was removed from the dictionary", name)
            logger.debug("removing files %s" % str(name))
            rmtree(self.find_plugin_folder(name))
        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(f"Error at %s", exc_info=e)
+            logger.error(
+                f"Plugin {name} in {self.find_plugin_folder(name)} was not uninstalled"
+            )
+            logger.error("Error at %s", exc_info=e)
        if self.loader.watcher:
            self.loader.watcher.disabled = False

    async def _install(self, artifact, name, version, hash):
+        isInstalled = False
        if self.loader.watcher:
            self.loader.watcher.disabled = True
        try:
-            await self.uninstall_plugin(name)
-        except:
-            logger.error(f"Plugin {name} not installed, skipping uninstallation")
+            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."
+            )
        logger.info(f"Installing {name} (Version: {version})")
        async with ClientSession() as client:
            logger.debug(f"Fetching {artifact}")
@@ -139,21 +188,30 @@ class PluginBrowser:
                data = await res.read()
                logger.debug(f"Read {len(data)} bytes")
                res_zip = BytesIO(data)
+                if isInstalled:
+                    try:
+                        logger.debug("Uninstalling existing plugin...")
+                        await self.uninstall_plugin(name)
+                    except Exception:
+                        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)
+                    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)
-                        # await inject_to_tab("SP", "window.syncDeckyPlugins()")
+                        self.loader.import_plugin(
+                            path.join(plugin_dir, "main.py"), plugin_dir
+                        )
                    else:
-                        logger.fatal(f"Failed Downloading Remote Binaries")
+                        logger.fatal("Failed Downloading Remote Binaries")
                else:
                    self.log.fatal(f"SHA-256 Mismatch!!!! {name} (Version: {version})")
                if self.loader.watcher:
@@ -163,14 +221,21 @@ 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)
-        tab = await get_tab("SP")
+        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}', '{request_id}', '{hash}')")
+        await tab.evaluate_js(
+            f"DeckyPluginLoader.addPluginInstallPrompt('{name}', '{version}',"
+            f" '{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)
@@ -1,10 +1,11 @@
+import grp
+import pwd
 import re
 import ssl
 import subprocess
 import uuid
 import os
-from subprocess import check_output
-from time import sleep
+import sys
 from hashlib import sha256
 from io import BytesIO

@@ -17,75 +18,138 @@ REMOTE_DEBUGGER_UNIT = "steam-web-debug-portforward.service"
 # global vars
 csrf_token = str(uuid.uuid4())
 ssl_ctx = ssl.create_default_context(cafile=certifi.where())
-user = None
-group = None

 assets_regex = re.compile("^/plugins/.*/assets/.*")
 frontend_regex = re.compile("^/frontend/.*")

+
 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')
+    return Response(text="Forbidden", status="403")

-# Get the user by checking for the first logged in user. As this is run
-# by systemd at startup the process is likely to start before the user
-# logs in, so we will wait here until they are available. Note that
-# other methods such as getenv wont work as there was no $SUDO_USER to
-# start the systemd service.
+
+# Deprecated
 def set_user():
-    global user
-    cmd = "who | awk '{print $1}' | sort | head -1"
-    while user == None:
-        name = check_output(cmd, shell=True).decode().strip()
-        if name not in [None, '']:
-            user = name
-        sleep(0.1)
+    pass

-# Get the global user. get_user must be called first.
+
+# 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:
-    global user
-    if user == None:
-        raise ValueError("helpers.get_user method called before user variable was set. Run helpers.set_user first.")
-    return user
+    return pwd.getpwuid(get_user_id()).pw_name

-# Set the global user group. get_user must be called first
+
+# 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:
-    global group
-    global user
-    if user == None:
-        raise ValueError("helpers.set_user_dir method called before user variable was set. Run helpers.set_user first.")
-    if group == None:
-        group = check_output(["id", "-g", "-n", user]).decode().strip()
+    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 group of the global user. set_user_group must be called first.
-def get_user_group() -> str:
-    global group
-    if group == None:
-        raise ValueError("helpers.get_user_group method called before group variable was set. Run helpers.set_user_group first.")
-    return group

 # Get the default home path unless a user is specified
-def get_home_path(username = None) -> str:
-    if username == None:
-        raise ValueError("Username not defined, no home path can be found.")
-    else:
-        return str("/home/"+username)
+def get_home_path(username=None) -> str:
+    if username is None:
+        username = get_user()
+    return pwd.getpwnam(username).pw_dir
+
+
+# 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")
+
+
+# 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)
+
+
+# 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", "")

-# Get the default homebrew path unless a user is specified
-def get_homebrew_path(home_path = None) -> str:
-    if home_path == None:
-        raise ValueError("Home path not defined, homebrew dir cannot be determined.")
-    else:
-        return str(home_path+"/homebrew")
-    # return str(home_path+"/homebrew")

 # Download Remote Binaries to local Plugin
 async def download_remote_binary_to_path(url, binHash, path) -> bool:
@@ -94,32 +158,41 @@ async def download_remote_binary_to_path(url, binHash, path) -> bool:
        if os.access(os.path.dirname(path), os.W_OK):
            async with ClientSession() as client:
                res = await client.get(url, ssl=get_ssl_context())
-                if res.status == 200:
-                    data = BytesIO(await res.read())
-                    remoteHash = sha256(data.getbuffer()).hexdigest()
-                    if binHash == remoteHash:
-                        data.seek(0)
-                        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}")
+            if res.status == 200:
+                data = BytesIO(await res.read())
+                remoteHash = sha256(data.getbuffer()).hexdigest()
+                if binHash == remoteHash:
+                    data.seek(0)
+                    with open(path, "wb") as f:
+                        f.write(data.getbuffer())
+                        rv = True
                else:
-                    rv = False
-    except:
+                    raise Exception(
+                        f"Fatal Error: Hash Mismatch for remote binary {path}@{url}"
+                    )
+            else:
+                rv = False
+    except Exception:
        rv = False

    return rv

+
 async def is_systemd_unit_active(unit_name: str) -> bool:
-    res = subprocess.run(["systemctl", "is-active", unit_name], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    res = subprocess.run(
+        ["systemctl", "is-active", unit_name],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
    return res.returncode == 0

+
 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]

@@ -2,10 +2,12 @@

 from asyncio import sleep
 from logging import getLogger
-from traceback import format_exc
+from typing import List

 from aiohttp import ClientSession
-from aiohttp.client_exceptions import ClientConnectorError
+from aiohttp.client_exceptions import ClientConnectorError, ClientOSError
+from asyncio.exceptions import TimeoutError
+import uuid

 BASE_ADDRESS = "http://localhost:8080"

@@ -18,6 +20,7 @@ class Tab:
    def __init__(self, res) -> None:
        self.title = res["title"]
        self.id = res["id"]
+        self.url = res["url"]
        self.ws_url = res["webSocketDebuggerUrl"]

        self.websocket = None
@@ -28,12 +31,18 @@ class Tab:
        self.websocket = await self.client.ws_connect(self.ws_url)

    async def close_websocket(self):
+        await self.websocket.close()
        await self.client.close()

    async def listen_for_message(self):
        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."
+        )
+        await self.close_websocket()

    async def _send_devtools_cmd(self, dc, receive=True):
        if self.websocket:
@@ -47,103 +56,175 @@ class Tab:
            return None
        raise RuntimeError("Websocket not opened")

-    async def evaluate_js(self, js, run_async=False, manage_socket=True, get_result=True):
-        if manage_socket:
-            await self.open_websocket()
+    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,
+            )

-        if manage_socket:
-            await self.close_websocket()
+        finally:
+            if manage_socket:
+                await self.close_websocket()
+        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,
+        )
+
+        if (
+            "result" not in res
+            or "result" not in res["result"]
+            or "value" not in res["result"]["result"]
+        ):
+            return False
+
+        return res["result"]["result"]["value"]
+
+    async def close(self, manage_socket=True):
+        try:
+            if manage_socket:
+                await self.open_websocket()
+
+            res = await self._send_devtools_cmd(
+                {
+                    "method": "Page.close",
+                },
+                False,
+            )
+
+        finally:
+            if manage_socket:
+                await self.close_websocket()
        return res

    async def enable(self):
        """
        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):
+        try:
+            if manage_socket:
+                await self.open_websocket()
+
+            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
        """
-        if manage_socket:
-            await self.open_websocket()
+        try:
+            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
+            logger.info(breakpoint_res)

-        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)
+            # Page finishes loading when breakpoint hits

-        await self._send_devtools_cmd({
-            "method": "Debugger.removeBreakpoint",
-            "params": {
-                "breakpointId": breakpoint_res["result"]["breakpointId"]
-            }
-        }, False)
+            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,
+                )

-        for x in range(4):
-            await self._send_devtools_cmd({
-                "method": "Debugger.resume"
-            }, False)
+            await self._send_devtools_cmd(
+                {
+                    "method": "Debugger.removeBreakpoint",
+                    "params": {
+                        "breakpointId": breakpoint_res["result"]["breakpointId"]
+                    },
+                },
+                False,
+            )

-        await self._send_devtools_cmd({
-            "method": "Debugger.disable"
-        }, True)
+            for x in range(4):
+                await self._send_devtools_cmd({"method": "Debugger.resume"}, False)

-        if manage_socket:
-            await self.close_websocket()
+            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:

@@ -176,35 +257,46 @@ class Tab:
            (see remove_script_to_evaluate_on_new_document below)
            None is returned if `get_result` is False
        """
+        try:

-        wrappedjs = """
-        function scriptFunc() {
-            {js}
-        }
-        if (document.readyState === 'loading') {
-            addEventListener('DOMContentLoaded', () => {
-            scriptFunc();
-        });
-        } else {
-            scriptFunc();
-        }
-        """.format(js=js) if add_dom_wrapper else js
+            wrappedjs = (
+                """
+            function scriptFunc() {{
+                {js}
+            }}
+            if (document.readyState === 'loading') {{
+                addEventListener('DOMContentLoaded', () => {{
+                scriptFunc();
+            }});
+            }} else {{
+                scriptFunc();
+            }}
+            """.format(
+                    js=js
+                )
+                if add_dom_wrapper
+                else js
+            )

-        if manage_socket:
-            await self.open_websocket()
+            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,
+            )

-        if manage_socket:
-            await self.close_websocket()
+        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`

@@ -214,50 +306,124 @@ class Tab:
            The identifier of the script to remove (returned from `add_script_to_evaluate_on_new_document`)
        """

-        if manage_socket:
-            await self.open_websocket()
+        try:
+            if manage_socket:
+                await self.open_websocket()

-        res = await self._send_devtools_cmd({
-            "method": "Page.removeScriptToEvaluateOnNewDocument",
-            "params": {
-                "identifier": script_id
-            }
-        }, False)
+            await self._send_devtools_cmd(
+                {
+                    "method": "Page.removeScriptToEvaluateOnNewDocument",
+                    "params": {"identifier": script_id},
+                },
+                False,
+            )

-        if manage_socket:
-            await self.close_websocket()
+        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
+        )
+
+        if (
+            "result" not in res
+            or "result" not in res["result"]
+            or "value" not in res["result"]["result"]
+        ):
+            return False
+
+        return res["result"]["result"]["value"]
+
+    async def inject_css(self, style, manage_socket=True):
+        try:
+            css_id = str(uuid.uuid4())
+
+            result = await self.evaluate_js(
+                f"""
+                (function() {{
+                    const style = document.createElement('style');
+                    style.id = "{css_id}";
+                    document.head.append(style);
+                    style.textContent = `{style}`;
+                }})()
+                """,
+                False,
+                manage_socket,
+            )
+
+            if "exceptionDetails" in result["result"]:
+                return {"success": False, "result": result["result"]}
+
+            return {"success": True, "result": css_id}
+        except Exception as e:
+            return {"success": False, "result": e}
+
+    async def remove_css(self, css_id, manage_socket=True):
+        try:
+            result = await self.evaluate_js(
+                f"""
+                (function() {{
+                    let style = document.getElementById("{css_id}");
+
+                    if (style.nodeName.toLowerCase() == 'style')
+                        style.parentNode.removeChild(style);
+                }})()
+                """,
+                False,
+                manage_socket,
+            )
+
+            if "exceptionDetails" in result["result"]:
+                return {"success": False, "result": result}
+
+            return {"success": True}
+        except Exception as 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):
        return self.title


-async def get_tabs():
-    async with ClientSession() as web:
-        res = {}
+async def get_tabs() -> List[Tab]:
+    res = {}

-        while True:
-            try:
-                res = await web.get(f"{BASE_ADDRESS}/json")
-            except ClientConnectorError:
-                logger.debug("ClientConnectorError excepted.")
+    na = False
+    while True:
+        try:
+            async with ClientSession() as web:
+                res = await web.get(f"{BASE_ADDRESS}/json", timeout=3)
+        except ClientConnectorError:
+            if not na:
                logger.debug("Steam isn't available yet. Wait for a moment...")
-                logger.error(format_exc())
-                await sleep(5)
-            else:
-                break
-
-        if res.status == 200:
-            r = await res.json()
-            return [Tab(i) for i in r]
+                na = True
+            await sleep(5)
+        except ClientOSError:
+            logger.warn(f"The request to {BASE_ADDRESS}/json was reset")
+            await sleep(1)
+        except TimeoutError:
+            logger.warn(f"The request to {BASE_ADDRESS}/json timed out")
+            await sleep(1)
        else:
-            raise Exception(f"/json did not return 200. {await res.text()}")
+            break
+
+    if res.status == 200:
+        r = await res.json()
+        return [Tab(i) for i in r]
+    else:
+        raise Exception(f"/json did not return 200. {await res.text()}")


-async def get_tab(tab_name):
+async def get_tab(tab_name) -> Tab:
    tabs = await get_tabs()
    tab = next((i for i in tabs if i.title == tab_name), None)
    if not tab:
@@ -265,33 +431,44 @@ async def get_tab(tab_name):
    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")
+    return tab
+
+
+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"
+    )
+
+
+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")
+    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 tab_has_global_var(tab_name, var_name):
-    try:
-        tab = await get_tab(tab_name)
-    except ValueError:
-        return False
-    res = await tab.evaluate_js(f"window['{var_name}'] !== null && window['{var_name}'] !== undefined", False)
-
-    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"]
-
-
-async def tab_has_element(tab_name, element_name):
-    try:
-        tab = await get_tab(tab_name)
-    except ValueError:
-        return False
-    res = await tab.evaluate_js(f"document.getElementById('{element_name}') != null", False)
-
-    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"]
+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"
+        ):
+            logger.debug("Closing tab: " + getattr(t, "title", "Untitled"))
+            await t.close()
+            await sleep(0.5)
@@ -15,13 +15,13 @@ try:
 except UnsupportedLibc:
    from watchdog.observers.fsevents import FSEventsObserver as Observer

-from injector import get_tab, inject_to_tab
+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,7 +32,9 @@ 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
@@ -62,6 +64,7 @@ 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
@@ -81,18 +84,30 @@ 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:
@@ -107,49 +122,88 @@ 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') 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):
+    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 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 "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 plugin.passive:
                self.logger.info(f"Plugin {plugin.name} is passive")
            self.plugins[plugin.name] = plugin.start()
            self.logger.info(f"Loaded {plugin.name}")
-            self.loop.create_task(self.dispatch_plugin(plugin.name if not plugin.legacy else "$LEGACY_" + plugin.name, plugin.version))
+            if not batch:
+                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()

    async def dispatch_plugin(self, name, version):
-        await inject_to_tab("SP", f"window.importDeckyPlugin('{name}', '{version}')")
+        gpui_tab = await get_gamepadui_tab()
+        await gpui_tab.evaluate_js(f"window.importDeckyPlugin('{name}', '{version}')")

    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)
+            self.import_plugin(
+                path.join(self.plugin_path, directory, "main.py"),
+                directory,
+                False,
+                True,
+            )

    async def handle_reloads(self):
        while True:
@@ -166,10 +220,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
@@ -182,9 +236,14 @@ 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') 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>
@@ -200,14 +259,19 @@ class Loader:
        self.logger.info(path)
        ret = ""
        file_path = path.join(self.plugin_path, plugin.plugin_directory, route_path)
-        with open(file_path, 'r') as resource_data:
+        with open(file_path, "r", encoding="utf-8") as resource_data:
            ret = resource_data.read()

        return web.Response(text=ret)

    async def get_steam_resource(self, request):
-        tab = await get_tab("QuickAccess")
+        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)
@@ -1,45 +1,45 @@
 # Change PyInstaller files permissions
 import sys
 from subprocess import call
-if hasattr(sys, '_MEIPASS'):
-    call(['chmod', '-R', '755', sys._MEIPASS])
+
+if hasattr(sys, "_MEIPASS"):
+    call(["chmod", "-R", "755", sys._MEIPASS])
 # Full imports
-from asyncio import get_event_loop, sleep
-from json import dumps, loads
-from logging import DEBUG, INFO, basicConfig, getLogger
-from os import getenv, chmod, path
+from asyncio import new_event_loop, set_event_loop, sleep
+from logging import basicConfig, getLogger
+from os import getenv, path
 from traceback import format_exc

 import aiohttp_cors
+
 # Partial imports
-from aiohttp import ClientSession
+from aiohttp import client_exceptions
 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_home_path, get_homebrew_path, get_user,
-                     get_user_group, set_user, set_user_group,
-                     stop_systemd_unit)
-from injector import inject_to_tab, tab_has_global_var
+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 loader import Loader
 from settings import SettingsManager
 from updater import Updater
 from utilities import Utilities

-# Ensure USER and GROUP vars are set first.
-# TODO: This isn't the best way to do this but supports the current
-# implementation. All the config load and environment setting eventually be
-# moved into init or a config/loader method.
-set_user()
-set_user_group()
 USER = get_user()
 GROUP = get_user_group()
-HOME_PATH = "/home/"+USER
-HOMEBREW_PATH = HOME_PATH+"/homebrew"
+HOMEBREW_PATH = get_homebrew_path()
 CONFIG = {
-    "plugin_path": getenv("PLUGIN_PATH", HOMEBREW_PATH+"/plugins"),
+    "plugin_path": getenv("PLUGIN_PATH", path.join(HOMEBREW_PATH, "plugins")),
    "chown_plugin_path": getenv("CHOWN_PLUGIN_PATH", "1") == "1",
    "server_host": getenv("SERVER_HOST", "127.0.0.1"),
    "server_port": int(getenv("SERVER_PORT", "1337")),
@@ -50,50 +50,72 @@ 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")

-async def chown_plugin_dir(_):
-    code_chown = call(["chown", "-R", USER+":"+GROUP, CONFIG["plugin_path"]])
+
+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: {code_chmod})")
+        logger.error(
+            f"chown/chmod exited with a non-zero exit code (chown: {code_chown}, chmod:"
+            f" {code_chmod})"
+        )
+
+
+if CONFIG["chown_plugin_path"] is True:
+    chown_plugin_dir()
+

 class PluginManager:
-    def __init__(self) -> None:
-        self.loop = get_event_loop()
+    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.plugin_browser = PluginBrowser(
+            CONFIG["plugin_path"], self.plugin_loader.plugins, self.plugin_loader
+        )
        self.settings = SettingsManager("loader", path.join(HOMEBREW_PATH, "settings"))
        self.utilities = Utilities(self)
        self.updater = Updater(self)

        jinja_setup(self.web_app)
-        if CONFIG["chown_plugin_path"] == True:
-            self.web_app.on_startup.append(chown_plugin_dir)
-        self.loop.create_task(self.loader_reinjector())
-        self.loop.create_task(self.load_plugins())
-        if not self.settings.getSetting("cef_forward", False):
-            self.loop.create_task(stop_systemd_unit(REMOTE_DEBUGGER_UNIT))
+
+        async def startup(_):
+            if self.settings.getSetting("cef_forward", False):
+                self.loop.create_task(start_systemd_unit(REMOTE_DEBUGGER_UNIT))
+            else:
+                self.loop.create_task(stop_systemd_unit(REMOTE_DEBUGGER_UNIT))
+            self.loop.create_task(self.loader_reinjector())
+            self.loop.create_task(self.load_plugins())
+
+        self.web_app.on_startup.append(startup)
+
        self.loop.set_exception_handler(self.exception_handler)
        self.web_app.add_routes([get("/auth/token", self.get_auth_token)])

        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":
@@ -103,38 +125,95 @@ class PluginManager:
    async def get_auth_token(self, request):
        return Response(text=get_csrf_token())

-    async def wait_for_server(self):
-        async with ClientSession() as web:
-            while True:
-                try:
-                    await web.get(f"http://{CONFIG['server_host']}:{CONFIG['server_port']}")
-                    return
-                except Exception as e:
-                    await sleep(0.1)
-
    async def load_plugins(self):
-        await self.wait_for_server()
+        # await self.wait_for_server()
+        logger.debug("Loading plugins")
        self.plugin_loader.import_plugins()
        # await inject_to_tab("SP", "window.syncDeckyPlugins();")

    async def loader_reinjector(self):
-        await sleep(2)
-        await self.inject_javascript()
        while True:
-            await sleep(5)
-            if not await tab_has_global_var("SP", "deckyHasLoaded"):
-                logger.info("Plugin loader isn't present in Steam anymore, reinjecting...")
-                await self.inject_javascript()
+            tab = None
+            nf = False
+            dc = False
+            while not tab:
+                try:
+                    tab = await get_gamepadui_tab()
+                except (
+                    client_exceptions.ClientConnectorError,
+                    client_exceptions.ServerDisconnectedError,
+                ):
+                    if not dc:
+                        logger.debug("Couldn't connect to debugger, waiting...")
+                        dc = True
+                    pass
+                except ValueError:
+                    if not nf:
+                        logger.debug("Couldn't find GamepadUI tab, waiting...")
+                        nf = True
+                    pass
+                if not tab:
+                    await sleep(5)
+            await tab.open_websocket()
+            await tab.enable()
+            await self.inject_javascript(tab, True)
+            try:
+                async for msg in tab.listen_for_message():
+                    # this gets spammed a lot
+                    if msg.get("method", None) != "Page.navigatedWithinDocument":
+                        logger.debug("Page event: " + str(msg.get("method", None)))
+                        if msg.get("method", None) == "Page.domContentEventFired":
+                            if not await tab.has_global_var("deckyHasLoaded", False):
+                                await self.inject_javascript(tab)
+                        if msg.get("method", None) == "Inspector.detached":
+                            logger.info("CEF has requested that we detach.")
+                            await tab.close_websocket()
+                            break
+                # If this is a forceful disconnect the loop will just stop without any failure message. In this case, injector.py will handle this for us so we don't need to close the socket.
+                # 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:
+                logger.error("Exception while reading page events " + format_exc())
+                await tab.close_websocket()
+                pass
+        # while True:
+        #     await sleep(5)
+        #     if not await tab.has_global_var("deckyHasLoaded", False):
+        #         logger.info("Plugin loader isn't present in Steam anymore, reinjecting...")
+        #         await self.inject_javascript(tab)

-    async def inject_javascript(self, request=None):
+    async def inject_javascript(self, tab: Tab, first=False, request=None):
+        logger.info("Loading Decky frontend!")
        try:
-            await inject_to_tab("SP", "try{if (window.deckyHasLoaded) location.reload();window.deckyHasLoaded = true;(async()=>{while(!window.SP_REACT){await new Promise(r => setTimeout(r, 10))};await import('http://localhost:1337/frontend/index.js')})();}catch(e){console.error(e)}", True)
-        except:
+            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:
            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__":
-    PluginManager().run()
+    loop = new_event_loop()
+    set_event_loop(loop)
+    PluginManager(loop).run()
@@ -1,24 +1,34 @@
 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 concurrent.futures import ProcessPoolExecutor
+from asyncio import (
+    Lock,
+    get_event_loop,
+    new_event_loop,
+    open_unix_connection,
+    set_event_loop,
+    sleep,
+    start_unix_server,
+    IncompleteReadError,
+    LimitOverrunError,
+)
 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
+from os import path, setgid, setuid, environ
 from signal import SIGINT, signal
 from sys import exit
 from time import time
+import helpers

 multiprocessing.set_start_method("fork")

-BUFFER_LIMIT = 2 ** 20  # 1 MiB
+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
@@ -27,12 +37,23 @@ class PluginWrapper:

        self.version = None

-        json = load(open(path.join(plugin_path, plugin_directory, "plugin.json"), "r"))
+        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"))
+            package_json = load(
+                open(
+                    path.join(plugin_path, plugin_directory, "package.json"),
+                    "r",
+                    encoding="utf-8",
+                )
+            )
            self.version = package_json["version"]

-
        self.legacy = False
        self.main_view_html = json["main_view_html"] if "main_view_html" in json else ""
        self.tile_view_html = json["tile_view_html"] if "tile_view_html" in json else ""
@@ -56,8 +77,34 @@ class PluginWrapper:
            set_event_loop(new_event_loop())
            if self.passive:
                return
-            setgid(0 if "root" in self.flags else 1000)
-            setuid(0 if "root" in self.flags else 1000)
+            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())
+            # 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["DECKY_VERSION"] = helpers.get_loader_version()
+            environ["DECKY_USER"] = helpers.get_user()
+            environ["DECKY_HOME"] = helpers.get_homebrew_path()
+            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
+            )
+            helpers.mkdir_as_user(environ["DECKY_PLUGIN_RUNTIME_DIR"])
+            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_NAME"] = self.name
+            environ["DECKY_PLUGIN_VERSION"] = self.version
+            environ["DECKY_PLUGIN_AUTHOR"] = self.author
            spec = spec_from_file_location("_", self.file)
            module = module_from_spec(spec)
            spec.loader.exec_module(module)
@@ -67,12 +114,32 @@ class PluginWrapper:
                get_event_loop().create_task(self.Plugin._main(self.Plugin))
            get_event_loop().create_task(self._setup_socket())
            get_event_loop().run_forever()
-        except:
+        except Exception:
            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'
+            )
+            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.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)
+        self.socket = await start_unix_server(
+            self._listen_for_method_call, path=self.socket_addr, limit=BUFFER_LIMIT
+        )

    async def _listen_for_method_call(self, reader, writer):
        while True:
@@ -90,6 +157,8 @@ class PluginWrapper:
                    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)
@@ -97,12 +166,14 @@ class PluginWrapper:
                return
            d = {"res": None, "success": True}
            try:
-                d["res"] = await getattr(self.Plugin, data["method"])(self.Plugin, **data["args"])
+                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)+"\n").encode("utf-8"))
+                writer.write((dumps(d, ensure_ascii=False) + "\n").encode("utf-8"))
                await writer.drain()

    async def _open_socket_if_not_exists(self):
@@ -110,9 +181,11 @@ class PluginWrapper:
            retries = 0
            while retries < 10:
                try:
-                    self.reader, self.writer = await open_unix_connection(self.socket_addr, limit=BUFFER_LIMIT)
+                    self.reader, self.writer = await open_unix_connection(
+                        self.socket_addr, limit=BUFFER_LIMIT
+                    )
                    return True
-                except:
+                except Exception:
                    await sleep(2)
                    retries += 1
            return False
@@ -128,20 +201,32 @@ class PluginWrapper:
    def stop(self):
        if self.passive:
            return
+
        async def _(self):
            if await self._open_socket_if_not_exists():
-                self.writer.write((dumps({"stop": True})+"\n").encode("utf-8"))
+                self.writer.write(
+                    (dumps({"stop": True}, ensure_ascii=False) + "\n").encode("utf-8")
+                )
                await self.writer.drain()
                self.writer.close()
+
        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})+"\n").encode("utf-8"))
+                    (
+                        dumps(
+                            {"method": method_name, "args": kwargs}, ensure_ascii=False
+                        )
+                        + "\n"
+                    ).encode("utf-8")
+                )
                await self.writer.drain()
                line = bytearray()
                while True:
@@ -0,0 +1,15 @@
+[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"
@@ -1,40 +1,59 @@
-import imp
 from json import dump, load
-from os import mkdir, path
+from os import mkdir, path, listdir, rename
+from shutil import chown

-from helpers import get_home_path, get_homebrew_path, get_user, set_user
+from helpers import (
+    get_homebrew_path,
+    get_user,
+    get_user_group,
+    get_user_owner,
+)


 class SettingsManager:
-    def __init__(self, name, settings_directory = None) -> None:
-        set_user()
+    def __init__(self, name, settings_directory=None) -> None:
        USER = get_user()
-        if settings_directory == None:
-            settings_directory = get_homebrew_path(get_home_path(USER))
+        GROUP = get_user_group()
+        wrong_dir = get_homebrew_path()
+        if settings_directory is None:
+            settings_directory = path.join(wrong_dir, "settings")
+
        self.path = path.join(settings_directory, name + ".json")

+        # Create the folder with the correct permission
        if not path.exists(settings_directory):
            mkdir(settings_directory)
+            chown(settings_directory, USER, GROUP)
+
+        # 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))
+                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)

        self.settings = {}

        try:
-            open(self.path, "x")
-        except FileExistsError as e:
+            open(self.path, "x", encoding="utf-8")
+        except FileExistsError:
            self.read()
            pass

    def read(self):
        try:
-            with open(self.path, "r") as file:
+            with open(self.path, "r", encoding="utf-8") as file:
                self.settings = load(file)
        except Exception as e:
            print(e)
            pass

    def commit(self):
-        with open(self.path, "w+") as file:
-            dump(self.settings, file, indent=4)
+        with open(self.path, "w+", encoding="utf-8") as file:
+            dump(self.settings, file, indent=4, ensure_ascii=False)

    def getSetting(self, key, default):
        return self.settings.get(key, default)
@@ -1,3 +1,5 @@
+import os
+import shutil
 import uuid
 from asyncio import sleep
 from ensurepip import version
@@ -9,11 +11,12 @@ from subprocess import call
 from aiohttp import ClientSession, web

 import helpers
-from injector import get_tab, inject_to_tab
+from injector import get_gamepadui_tab, inject_to_tab
 from settings import SettingsManager

 logger = getLogger("Updater")

+
 class Updater:
    def __init__(self, context) -> None:
        self.context = context
@@ -24,14 +27,12 @@ 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:
-            logger.info(getcwd())
-            with open(path.join(getcwd(), ".loader.version"), 'r') as version_file:
-                self.localVer = version_file.readline().replace("\n", "")
+            self.localVer = helpers.get_loader_version()
        except:
            self.localVer = False

@@ -39,12 +40,14 @@ class Updater:
            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):
@@ -79,42 +82,81 @@ class Updater:
    async def _get_branch(self, manager: SettingsManager):
        return self.get_branch(manager)

+    # retrieve relevant service file's url for each branch
+    def get_service_url(self):
+        logger.debug("Getting service URL")
+        branch = self.get_branch(self.context.settings)
+        match branch:
+            case 0:
+                url = "https://raw.githubusercontent.com/SteamDeckHomebrew/decky-loader/main/dist/plugin_loader-release.service"
+            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!"
+                )
+                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
+                "updatable": self.localVer != None,
            }
        else:
-            return {"current": "unknown", "remote": self.remoteVer, "all": self.allRemoteVers, "updatable": False}
+            return {
+                "current": "unknown",
+                "remote": self.remoteVer,
+                "all": self.allRemoteVers,
+                "updatable": False,
+            }

    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)
-                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)
-                # elif selectedBranch == 2:
-                #     logger.debug("release type: nightly")
-                #     self.remoteVer = next(filter(lambda ver: ver["prerelease"] and ver["tag_name"].startswith("v") and ver["tag_name"].find("nightly"), remoteVersions), None)
-                else:
-                    logger.error("release type: NOT FOUND")
-                    raise ValueError("no valid branch found")
-                # doesn't make it to this line below or farther
-                # logger.debug("Remote Version: %s" % self.remoteVer.find("name"))
-                logger.info("Updated remote version information")
-                tab = await get_tab("SP")
-                await tab.evaluate_js(f"window.DeckyPluginLoader.notifyUpdates()", False, True, False)
+        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,
+            )
+        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,
+            )
+        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
+        )
        return await self.get_version()

    async def version_reloader(self):
@@ -124,17 +166,60 @@ 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"]
+        service_url = self.get_service_url()
+        logger.debug("Retrieved service URL")

-        tab = await get_tab("SP")
+        tab = await get_gamepadui_tab()
        await tab.open_websocket()
        async with ClientSession() as web:
-            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))
+            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!
                try:
                    remove(path.join(getcwd(), "PluginLoader"))
                except:
@@ -147,17 +232,26 @@ 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") as out:
-                    out.write(version)
+            with open(
+                path.join(getcwd(), ".loader.version"), "w", encoding="utf-8"
+            ) as out:
+                out.write(version)

-                call(['chmod', '+x', path.join(getcwd(), "PluginLoader")])
-
-                logger.info("Updated loader installation.")
-                await tab.evaluate_js("window.DeckyUpdater.finish()", False, False)
-                await tab.client.close()
+            call(["chmod", "+x", path.join(getcwd(), "PluginLoader")])
+            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"])
@@ -3,13 +3,12 @@ import os
 from json.decoder import JSONDecodeError
 from traceback import format_exc

-from asyncio import sleep, start_server, gather, open_connection
+from asyncio import start_server, gather, open_connection
 from aiohttp import ClientSession, web

 from logging import getLogger
-from injector import inject_to_tab, get_tab
+from injector import inject_to_tab, get_gamepadui_tab, close_old_tabs
 import helpers
-import subprocess


 class Utilities:
@@ -31,7 +30,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")
@@ -41,9 +40,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"]
@@ -61,12 +60,11 @@ 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):
@@ -80,12 +78,11 @@ class Utilities:

    async def http_request(self, method="", url="", **kwargs):
        async with ClientSession() as web:
-            async with web.request(method, url, ssl=helpers.get_ssl_context(), **kwargs) as res:
-                return {
-                    "status": res.status,
-                    "headers": dict(res.headers),
-                    "body": await res.text()
-                }
+            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}

    async def ping(self, **kwargs):
        return "pong"
@@ -94,26 +91,18 @@ 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');
@@ -121,27 +110,21 @@ 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}");
@@ -149,22 +132,16 @@ 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)
@@ -186,7 +163,7 @@ class Utilities:
        #         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
+        file_names = sorted(os.listdir(path))  # Alphabetical

        files = []

@@ -195,16 +172,15 @@ class Utilities:
            is_dir = os.path.isdir(full_path)

            if is_dir or include_files:
-                files.append({
-                    "isdir": is_dir,
-                    "name": file,
-                    "realpath": os.path.realpath(full_path)
-                })
+                files.append(
+                    {
+                        "isdir": is_dir,
+                        "name": file,
+                        "realpath": os.path.realpath(full_path),
+                    }
+                )

-        return {
-            "realpath": os.path.realpath(path),
-            "files": files
-        }
+        return {"realpath": os.path.realpath(path), "files": files}

    # Based on https://stackoverflow.com/a/46422554/13174603
    def start_rdt_proxy(self, ip, port):
@@ -214,10 +190,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)
@@ -232,34 +208,56 @@ class Utilities:
            self.rdt_proxy_server.close()
            self.rdt_proxy_task.cancel()

-    async def enable_rdt(self):
+    async def _enable_rdt(self):
        # TODO un-hardcode port
        try:
            self.stop_rdt_proxy()
            ip = self.context.settings.getSetting("developer.rdt.ip", None)

-            if ip != None:
+            if ip is not None:
                self.logger.info("Connecting to React DevTools at " + ip)
                async with ClientSession() as web:
-                    async with web.request("GET", "http://" + ip + ":8097", ssl=helpers.get_ssl_context()) as res:
-                        if res.status != 200:
-                            self.logger.error("Failed to connect to React DevTools at " + ip)
-                            return False
-                        self.start_rdt_proxy(ip, 8097)
-                        script = "if(!window.deckyHasConnectedRDT){window.deckyHasConnectedRDT=true;\n" + await res.text() + "\n}"
-                        self.logger.info("Connected to React DevTools, loading script")
-                        tab = await get_tab("SP")
-                        # RDT needs to load before React itself to work.
-                        result = await tab.reload_and_evaluate(script)
-                        self.logger.info(result)
-                        
+                    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
+                        Object.defineProperty(window, '__REACT_DEVTOOLS_TARGET_WINDOW__', {
+                            enumerable: true,
+                            configurable: true,
+                            get: function() {
+                                return FocusNavController?.m_ActiveContext?.ActiveWindow || window;
+                            }
+                        });
+                    """
+                        + await res.text()
+                        + "\n}"
+                    )
+                if res.status != 200:
+                    self.logger.error("Failed to connect to React DevTools at " + ip)
+                    return False
+                self.start_rdt_proxy(ip, 8097)
+                self.logger.info("Connected to React DevTools, loading script")
+                tab = await get_gamepadui_tab()
+                # RDT needs to load before React itself to work.
+                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())

+    async def enable_rdt(self):
+        self.context.loop.create_task(self._enable_rdt())
+
    async def disable_rdt(self):
        self.logger.info("Disabling React DevTools")
-        tab = await get_tab("SP")
+        tab = await get_gamepadui_tab()
        self.rdt_script_id = None
+        await close_old_tabs()
        await tab.evaluate_js("location.reload();", False, True, False)
        self.logger.info("React DevTools disabled")
@@ -1,50 +0,0 @@
-#!/bin/sh
-
-[ "$UID" -eq 0 ] || exec sudo "$0" "$@"
-
-echo "Installing Steam Deck Plugin Loader nightly..."
-
-USER_DIR="$(getent passwd $SUDO_USER | cut -d: -f6)"
-HOMEBREW_FOLDER="${USER_DIR}/homebrew"
-
-# Create folder structure
-rm -rf ${HOMEBREW_FOLDER}/services
-sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/services"
-sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/plugins"
-
-# Download latest nightly build and install it
-rm -rf /tmp/plugin_loader
-mkdir -p /tmp/plugin_loader
-curl -L https://nightly.link/SteamDeckHomebrew/PluginLoader/workflows/build/main/Plugin%20Loader.zip --output /tmp/plugin_loader/PluginLoader.zip
-unzip /tmp/plugin_loader/PluginLoader.zip -d /tmp/plugin_loader
-cp /tmp/plugin_loader/PluginLoader ${HOMEBREW_FOLDER}/services/PluginLoader
-rm -rf /tmp/plugin_loader
-chmod +x ${HOMEBREW_FOLDER}/services/PluginLoader
-
-systemctl --user stop plugin_loader 2> /dev/null
-systemctl --user disable plugin_loader 2> /dev/null
-rm -f ${USER_DIR}/.config/systemd/user/plugin_loader.service
-
-systemctl stop plugin_loader 2> /dev/null
-systemctl disable plugin_loader 2> /dev/null
-rm -f /etc/systemd/system/plugin_loader.service
-
-cat > /etc/systemd/system/plugin_loader.service <<- EOM
-[Unit]
-Description=SteamDeck Plugin Loader
-
-[Service]
-Type=simple
-User=root
-Restart=always
-
-ExecStart=${HOMEBREW_FOLDER}/services/PluginLoader
-WorkingDirectory=${HOMEBREW_FOLDER}/services
-Environment=PLUGIN_PATH=${HOMEBREW_FOLDER}/plugins
-
-[Install]
-WantedBy=multi-user.target
-EOM
-systemctl daemon-reload
-systemctl start plugin_loader
-systemctl enable plugin_loader
@@ -7,14 +7,16 @@ echo "Installing Steam Deck Plugin Loader pre-release..."
 USER_DIR="$(getent passwd $SUDO_USER | cut -d: -f6)"
 HOMEBREW_FOLDER="${USER_DIR}/homebrew"

-# # Create folder structure
-rm -rf ${HOMEBREW_FOLDER}/services
+# Create folder structure
+rm -rf "${HOMEBREW_FOLDER}/services"
 sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/services"
 sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/plugins"
+touch "${USER_DIR}/.steam/steam/.cef-enable-remote-debugging"

 # Download latest release and install it
 RELEASE=$(curl -s 'https://api.github.com/repos/SteamDeckHomebrew/decky-loader/releases' | jq -r "first(.[] | select(.prerelease == "true"))")
-read VERSION DOWNLOADURL < <(echo $(jq -r '.tag_name, .assets[].browser_download_url' <<< ${RELEASE}))
+VERSION=$(jq -r '.tag_name' <<< ${RELEASE} )
+DOWNLOADURL=$(jq -r '.assets[].browser_download_url | select(endswith("PluginLoader"))' <<< ${RELEASE})

 printf "Installing version %s...\n" "${VERSION}"
 curl -L $DOWNLOADURL --output ${HOMEBREW_FOLDER}/services/PluginLoader
@@ -26,21 +28,42 @@ systemctl --user disable plugin_loader 2> /dev/null

 systemctl stop plugin_loader 2> /dev/null
 systemctl disable plugin_loader 2> /dev/null
-rm -f /etc/systemd/system/plugin_loader.service
-cat > /etc/systemd/system/plugin_loader.service <<- EOM
+
+curl -L https://raw.githubusercontent.com/SteamDeckHomebrew/decky-loader/main/dist/plugin_loader-prerelease.service  --output ${HOMEBREW_FOLDER}/services/plugin_loader-prerelease.service
+
+cat > "${HOMEBREW_FOLDER}/services/plugin_loader-backup.service" <<- EOM
 [Unit]
 Description=SteamDeck Plugin Loader
+After=network-online.target
+Wants=network-online.target
 [Service]
 Type=simple
 User=root
 Restart=always
 ExecStart=${HOMEBREW_FOLDER}/services/PluginLoader
 WorkingDirectory=${HOMEBREW_FOLDER}/services
+KillSignal=SIGKILL
 Environment=PLUGIN_PATH=${HOMEBREW_FOLDER}/plugins
 Environment=LOG_LEVEL=DEBUG
 [Install]
 WantedBy=multi-user.target
 EOM
+
+if [[ -f "${HOMEBREW_FOLDER}/services/plugin_loader-prerelease.service" ]]; then
+    printf "Grabbed latest prerelease service.\n"
+    sed -i -e "s|\${HOMEBREW_FOLDER}|${HOMEBREW_FOLDER}|" "${HOMEBREW_FOLDER}/services/plugin_loader-prerelease.service"
+    cp -f "${HOMEBREW_FOLDER}/services/plugin_loader-prerelease.service" "/etc/systemd/system/plugin_loader.service"
+else
+    printf "Could not curl latest prerelease systemd service, using built-in service as a backup!\n"
+    rm -f "/etc/systemd/system/plugin_loader.service"
+    cp "${HOMEBREW_FOLDER}/services/plugin_loader-backup.service" "/etc/systemd/system/plugin_loader.service"
+fi
+
+mkdir -p ${HOMEBREW_FOLDER}/services/.systemd
+cp ${HOMEBREW_FOLDER}/services/plugin_loader-prerelease.service ${HOMEBREW_FOLDER}/services/.systemd/plugin_loader-prerelease.service
+cp ${HOMEBREW_FOLDER}/services/plugin_loader-backup.service ${HOMEBREW_FOLDER}/services/.systemd/plugin_loader-backup.service
+rm ${HOMEBREW_FOLDER}/services/plugin_loader-backup.service ${HOMEBREW_FOLDER}/services/plugin_loader-prerelease.service
+
 systemctl daemon-reload
 systemctl start plugin_loader
 systemctl enable plugin_loader
@@ -11,10 +11,12 @@ HOMEBREW_FOLDER="${USER_DIR}/homebrew"
 rm -rf "${HOMEBREW_FOLDER}/services"
 sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/services"
 sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/plugins"
+touch "${USER_DIR}/.steam/steam/.cef-enable-remote-debugging"

 # Download latest release and install it
 RELEASE=$(curl -s 'https://api.github.com/repos/SteamDeckHomebrew/decky-loader/releases' | jq -r "first(.[] | select(.prerelease == "false"))")
-read VERSION DOWNLOADURL < <(echo $(jq -r '.tag_name, .assets[].browser_download_url' <<< ${RELEASE}))
+VERSION=$(jq -r '.tag_name' <<< ${RELEASE} )
+DOWNLOADURL=$(jq -r '.assets[].browser_download_url | select(endswith("PluginLoader"))' <<< ${RELEASE})

 printf "Installing version %s...\n" "${VERSION}"
 curl -L $DOWNLOADURL --output ${HOMEBREW_FOLDER}/services/PluginLoader
@@ -26,20 +28,42 @@ systemctl --user disable plugin_loader 2> /dev/null

 systemctl stop plugin_loader 2> /dev/null
 systemctl disable plugin_loader 2> /dev/null
-rm -f "/etc/systemd/system/plugin_loader.service"
-cat > "/etc/systemd/system/plugin_loader.service" <<- EOM
+
+curl -L https://raw.githubusercontent.com/SteamDeckHomebrew/decky-loader/main/dist/plugin_loader-release.service  --output ${HOMEBREW_FOLDER}/services/plugin_loader-release.service
+
+cat > "${HOMEBREW_FOLDER}/services/plugin_loader-backup.service" <<- EOM
 [Unit]
 Description=SteamDeck Plugin Loader
+After=network-online.target
+Wants=network-online.target
 [Service]
 Type=simple
 User=root
 Restart=always
 ExecStart=${HOMEBREW_FOLDER}/services/PluginLoader
 WorkingDirectory=${HOMEBREW_FOLDER}/services
+KillSignal=SIGKILL
 Environment=PLUGIN_PATH=${HOMEBREW_FOLDER}/plugins
+Environment=LOG_LEVEL=INFO
 [Install]
 WantedBy=multi-user.target
 EOM
+
+if [[ -f "${HOMEBREW_FOLDER}/services/plugin_loader-release.service" ]]; then
+    printf "Grabbed latest release service.\n"
+    sed -i -e "s|\${HOMEBREW_FOLDER}|${HOMEBREW_FOLDER}|" "${HOMEBREW_FOLDER}/services/plugin_loader-release.service"
+    cp -f "${HOMEBREW_FOLDER}/services/plugin_loader-release.service" "/etc/systemd/system/plugin_loader.service"
+else
+    printf "Could not curl latest release systemd service, using built-in service as a backup!\n"
+    rm -f "/etc/systemd/system/plugin_loader.service"
+    cp "${HOMEBREW_FOLDER}/services/plugin_loader-backup.service" "/etc/systemd/system/plugin_loader.service"
+fi
+
+mkdir -p ${HOMEBREW_FOLDER}/services/.systemd
+cp ${HOMEBREW_FOLDER}/services/plugin_loader-release.service ${HOMEBREW_FOLDER}/services/.systemd/plugin_loader-release.service
+cp ${HOMEBREW_FOLDER}/services/plugin_loader-backup.service ${HOMEBREW_FOLDER}/services/.systemd/plugin_loader-backup.service
+rm ${HOMEBREW_FOLDER}/services/plugin_loader-backup.service ${HOMEBREW_FOLDER}/services/plugin_loader-release.service
+
 systemctl daemon-reload
 systemctl start plugin_loader
 systemctl enable plugin_loader
@@ -0,0 +1,15 @@
+[Unit]
+Description=SteamDeck Plugin Loader
+After=network-online.target
+Wants=network-online.target
+[Service]
+Type=simple
+User=root
+Restart=always
+ExecStart=${HOMEBREW_FOLDER}/services/PluginLoader
+WorkingDirectory=${HOMEBREW_FOLDER}/services
+KillSignal=SIGKILL
+Environment=PLUGIN_PATH=${HOMEBREW_FOLDER}/plugins
+Environment=LOG_LEVEL=DEBUG
+[Install]
+WantedBy=multi-user.target
@@ -0,0 +1,15 @@
+[Unit]
+Description=SteamDeck Plugin Loader
+After=network-online.target
+Wants=network-online.target
+[Service]
+Type=simple
+User=root
+Restart=always
+ExecStart=${HOMEBREW_FOLDER}/services/PluginLoader
+WorkingDirectory=${HOMEBREW_FOLDER}/services
+KillSignal=SIGKILL
+Environment=PLUGIN_PATH=${HOMEBREW_FOLDER}/plugins
+Environment=LOG_LEVEL=INFO
+[Install]
+WantedBy=multi-user.target
@@ -0,0 +1,2 @@
+declare module '*.png';
+declare module '*.jpg';
@@ -12,6 +12,7 @@
  },
  "devDependencies": {
    "@rollup/plugin-commonjs": "^21.1.0",
+    "@rollup/plugin-image": "^3.0.1",
    "@rollup/plugin-json": "^4.1.0",
    "@rollup/plugin-node-resolve": "^13.3.0",
    "@rollup/plugin-replace": "^4.0.0",
@@ -41,7 +42,7 @@
    }
  },
  "dependencies": {
-    "decky-frontend-lib": "^3.6.0",
+    "decky-frontend-lib": "^3.18.10",
    "react-file-icon": "^1.2.0",
    "react-icons": "^4.4.0",
    "react-markdown": "^8.0.3",
@@ -2,6 +2,7 @@ lockfileVersion: 5.4

 specifiers:
  '@rollup/plugin-commonjs': ^21.1.0
+  '@rollup/plugin-image': ^3.0.1
  '@rollup/plugin-json': ^4.1.0
  '@rollup/plugin-node-resolve': ^13.3.0
  '@rollup/plugin-replace': ^4.0.0
@@ -10,7 +11,7 @@ specifiers:
  '@types/react-file-icon': ^1.0.1
  '@types/react-router': 5.1.18
  '@types/webpack': ^5.28.0
-  decky-frontend-lib: ^3.6.0
+  decky-frontend-lib: ^3.18.10
  husky: ^8.0.1
  import-sort-style-module: ^6.0.0
  inquirer: ^8.2.4
@@ -30,7 +31,7 @@ specifiers:
  typescript: ^4.7.4

 dependencies:
-  decky-frontend-lib: 3.6.0
+  decky-frontend-lib: 3.18.10
  react-file-icon: 1.2.0_wcqkhtmu7mswc6yz4uyexck3ty
  react-icons: 4.4.0_react@16.14.0
  react-markdown: 8.0.3_vshvapmxg47tngu7tvrsqpq55u
@@ -38,6 +39,7 @@ dependencies:

 devDependencies:
  '@rollup/plugin-commonjs': 21.1.0_rollup@2.76.0
+  '@rollup/plugin-image': 3.0.1_rollup@2.76.0
  '@rollup/plugin-json': 4.1.0_rollup@2.76.0
  '@rollup/plugin-node-resolve': 13.3.0_rollup@2.76.0
  '@rollup/plugin-replace': 4.0.0_rollup@2.76.0
@@ -339,6 +341,20 @@ packages:
      rollup: 2.76.0
    dev: true

+  /@rollup/plugin-image/3.0.1_rollup@2.76.0:
+    resolution: {integrity: sha512-F50Sko4Xcc576x7HG9f3MvJKKnBfSmqfVFWJkJgyIEkI8YxZxux28lDbuy0+GsAK6BFl9Gn+TRXOUgHHJbFh3w==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      rollup: ^1.20.0||^2.0.0||^3.0.0
+    peerDependenciesMeta:
+      rollup:
+        optional: true
+    dependencies:
+      '@rollup/pluginutils': 5.0.2_rollup@2.76.0
+      mini-svg-data-uri: 1.4.4
+      rollup: 2.76.0
+    dev: true
+
  /@rollup/plugin-inject/4.0.4_rollup@2.76.0:
    resolution: {integrity: sha512-4pbcU4J/nS+zuHk+c+OL3WtmEQhqxlZ9uqfjQMQDOHOPld7PsCd8k5LWs8h5wjwJN7MgnAn768F2sDxEP4eNFQ==}
    peerDependencies:
@@ -422,6 +438,21 @@ packages:
      picomatch: 2.3.1
    dev: true

+  /@rollup/pluginutils/5.0.2_rollup@2.76.0:
+    resolution: {integrity: sha512-pTd9rIsP92h+B6wWwFbW8RkZv4hiR/xKsqre4SIuAOaOEQRxi0lqLke9k2/7WegC85GgUs9pjmOjCUi3In4vwA==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      rollup: ^1.20.0||^2.0.0||^3.0.0
+    peerDependenciesMeta:
+      rollup:
+        optional: true
+    dependencies:
+      '@types/estree': 1.0.0
+      estree-walker: 2.0.2
+      picomatch: 2.3.1
+      rollup: 2.76.0
+    dev: true
+
  /@types/debug/4.1.7:
    resolution: {integrity: sha512-9AonUzyTjXXhEOa0DnqpzZi6VHlqKMswga9EXjpXnnqxwLtdvPPtlO8evrI5D9S6asFRCQ6v+wpiUKbw+vKqyg==}
    dependencies:
@@ -944,10 +975,8 @@ packages:
    dependencies:
      ms: 2.1.2

-  /decky-frontend-lib/3.6.0:
-    resolution: {integrity: sha512-X3VbTbmW7TnBwPW0ui0xjSVoa2UsuKPwI6nFi7LY2ZzmNytCfszk+ZfJSBm2lD2fqV+btqJzr0qFnWFl+bgjEA==}
-    dependencies:
-      minimist: 1.2.7
+  /decky-frontend-lib/3.18.10:
+    resolution: {integrity: sha512-2mgbA3sSkuwQR/FnmhXVrcW6LyTS95IuL6muJAmQCruhBvXapDtjk1TcgxqMZxFZwGD1IPnemPYxHZll6IgnZw==}
    dev: false

  /decode-named-character-reference/1.0.2:
@@ -1938,16 +1967,17 @@ packages:
    engines: {node: '>=6'}
    dev: true

+  /mini-svg-data-uri/1.4.4:
+    resolution: {integrity: sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg==}
+    hasBin: true
+    dev: true
+
  /minimatch/3.1.2:
    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
    dependencies:
      brace-expansion: 1.1.11
    dev: true

-  /minimist/1.2.7:
-    resolution: {integrity: sha512-bzfL1YUZsP41gmu/qjrEk0Q6i2ix/cVeAhbCbqH9u3zYutS1cLg00qhrD0M2MVdCcx4Sc0UpP2eBWo9rotpq6g==}
-    dev: false
-
  /mri/1.2.0:
    resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
    engines: {node: '>=4'}
@@ -1,25 +1,28 @@
 import commonjs from '@rollup/plugin-commonjs';
+import image from '@rollup/plugin-image';
 import json from '@rollup/plugin-json';
 import { nodeResolve } from '@rollup/plugin-node-resolve';
-import externalGlobals from "rollup-plugin-external-globals";
-import del from 'rollup-plugin-delete'
 import replace from '@rollup/plugin-replace';
 import typescript from '@rollup/plugin-typescript';
 import { defineConfig } from 'rollup';
+import del from 'rollup-plugin-delete';
+import externalGlobals from 'rollup-plugin-external-globals';
+
+const hiddenWarnings = ['THIS_IS_UNDEFINED', 'EVAL'];

 export default defineConfig({
  input: 'src/index.tsx',
  plugins: [
-    del({ targets: "../backend/static/*", force: true }),
+    del({ targets: '../backend/static/*', force: true }),
    commonjs(),
    nodeResolve(),
    externalGlobals({
      react: 'SP_REACT',
      'react-dom': 'SP_REACTDOM',
      // hack to shut up react-markdown
-      'process': '{cwd: () => {}}',
-      'path': '{dirname: () => {}, join: () => {}, basename: () => {}, extname: () => {}}',
-      'url': '{fileURLToPath: (f) => f}'
+      process: '{cwd: () => {}}',
+      path: '{dirname: () => {}, join: () => {}, basename: () => {}, extname: () => {}}',
+      url: '{fileURLToPath: (f) => f}',
    }),
    typescript(),
    json(),
@@ -27,13 +30,18 @@ export default defineConfig({
      preventAssignment: false,
      'process.env.NODE_ENV': JSON.stringify('production'),
    }),
+    image(),
  ],
  preserveEntrySignatures: false,
  output: {
    dir: '../backend/static',
    format: 'esm',
    chunkFileNames: (chunkInfo) => {
-      return 'chunk-[hash].js'
-    }
-  }
+      return 'chunk-[hash].js';
+    },
+  },
+  onwarn: function (message, handleWarning) {
+    if (hiddenWarnings.some((warning) => message.code === warning)) return;
+    handleWarning(message);
+  },
 });
@@ -0,0 +1,74 @@
+import { FC, createContext, useContext, useEffect, useState } from 'react';
+
+interface PublicDeckyGlobalComponentsState {
+  components: Map<string, FC>;
+}
+
+export class DeckyGlobalComponentsState {
+  // TODO a set would be better
+  private _components = new Map<string, FC>();
+
+  public eventBus = new EventTarget();
+
+  publicState(): PublicDeckyGlobalComponentsState {
+    return { components: this._components };
+  }
+
+  addComponent(path: string, component: FC) {
+    this._components.set(path, component);
+    this.notifyUpdate();
+  }
+
+  removeComponent(path: string) {
+    this._components.delete(path);
+    this.notifyUpdate();
+  }
+
+  private notifyUpdate() {
+    this.eventBus.dispatchEvent(new Event('update'));
+  }
+}
+
+interface DeckyGlobalComponentsContext extends PublicDeckyGlobalComponentsState {
+  addComponent(path: string, component: FC): void;
+  removeComponent(path: string): void;
+}
+
+const DeckyGlobalComponentsContext = createContext<DeckyGlobalComponentsContext>(null as any);
+
+export const useDeckyGlobalComponentsState = () => useContext(DeckyGlobalComponentsContext);
+
+interface Props {
+  deckyGlobalComponentsState: DeckyGlobalComponentsState;
+}
+
+export const DeckyGlobalComponentsStateContextProvider: FC<Props> = ({
+  children,
+  deckyGlobalComponentsState: deckyGlobalComponentsState,
+}) => {
+  const [publicDeckyGlobalComponentsState, setPublicDeckyGlobalComponentsState] =
+    useState<PublicDeckyGlobalComponentsState>({
+      ...deckyGlobalComponentsState.publicState(),
+    });
+
+  useEffect(() => {
+    function onUpdate() {
+      setPublicDeckyGlobalComponentsState({ ...deckyGlobalComponentsState.publicState() });
+    }
+
+    deckyGlobalComponentsState.eventBus.addEventListener('update', onUpdate);
+
+    return () => deckyGlobalComponentsState.eventBus.removeEventListener('update', onUpdate);
+  }, []);
+
+  const addComponent = deckyGlobalComponentsState.addComponent.bind(deckyGlobalComponentsState);
+  const removeComponent = deckyGlobalComponentsState.removeComponent.bind(deckyGlobalComponentsState);
+
+  return (
+    <DeckyGlobalComponentsContext.Provider
+      value={{ ...publicDeckyGlobalComponentsState, addComponent, removeComponent }}
+    >
+      {children}
+    </DeckyGlobalComponentsContext.Provider>
+  );
+};
@@ -0,0 +1,37 @@
+export default function DeckyIcon() {
+  return (
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 456" width="512" height="456">
+      <g>
+        <path
+          style={{ fill: 'none' }}
+          d="M154.33,72.51v49.79c11.78-0.17,23.48,2,34.42,6.39c10.93,4.39,20.89,10.91,29.28,19.18
+          c8.39,8.27,15.06,18.13,19.61,29c4.55,10.87,6.89,22.54,6.89,34.32c0,11.78-2.34,23.45-6.89,34.32
+          c-4.55,10.87-11.21,20.73-19.61,29c-8.39,8.27-18.35,14.79-29.28,19.18c-10.94,4.39-22.63,6.56-34.42,6.39v49.77
+          c36.78,0,72.05-14.61,98.05-40.62c26-26.01,40.61-61.28,40.61-98.05c0-36.78-14.61-72.05-40.61-98.05
+          C226.38,87.12,191.11,72.51,154.33,72.51z"
+        />
+
+        <ellipse
+          transform="matrix(0.982 -0.1891 0.1891 0.982 -37.1795 32.9988)"
+          style={{ fill: 'none' }}
+          cx="154.33"
+          cy="211.33"
+          rx="69.33"
+          ry="69.33"
+        />
+        <path style={{ fill: 'none' }} d="M430,97h-52v187h52c7.18,0,13-5.82,13-13V110C443,102.82,437.18,97,430,97z" />
+        <path
+          style={{ fill: 'currentColor' }}
+          d="M432,27h-54V0H0v361c0,52.47,42.53,95,95,95h188c52.47,0,95-42.53,95-95v-7h54c44.18,0,80-35.82,80-80V107
+          C512,62.82,476.18,27,432,27z M85,211.33c0-38.29,31.04-69.33,69.33-69.33c38.29,0,69.33,31.04,69.33,69.33
+          c0,38.29-31.04,69.33-69.33,69.33C116.04,280.67,85,249.62,85,211.33z M252.39,309.23c-26.01,26-61.28,40.62-98.05,40.62v-49.77
+          c11.78,0.17,23.48-2,34.42-6.39c10.93-4.39,20.89-10.91,29.28-19.18c8.39-8.27,15.06-18.13,19.61-29
+          c4.55-10.87,6.89-22.53,6.89-34.32c0-11.78-2.34-23.45-6.89-34.32c-4.55-10.87-11.21-20.73-19.61-29
+          c-8.39-8.27-18.35-14.79-29.28-19.18c-10.94-4.39-22.63-6.56-34.42-6.39V72.51c36.78,0,72.05,14.61,98.05,40.61
+          c26,26.01,40.61,61.28,40.61,98.05C293,247.96,278.39,283.23,252.39,309.23z M443,271c0,7.18-5.82,13-13,13h-52V97h52
+          c7.18,0,13,5.82,13,13V271z"
+        />
+      </g>
+    </svg>
+  );
+}
@@ -0,0 +1,54 @@
+import { ToastData, joinClassNames } from 'decky-frontend-lib';
+import { FC, useEffect, useState } from 'react';
+import { ReactElement } from 'react-markdown/lib/react-markdown';
+
+import { useDeckyToasterState } from './DeckyToasterState';
+import Toast, { toastClasses } from './Toast';
+
+interface DeckyToasterProps {}
+
+interface RenderedToast {
+  component: ReactElement;
+  data: ToastData;
+}
+
+const DeckyToaster: FC<DeckyToasterProps> = () => {
+  const { toasts, removeToast } = useDeckyToasterState();
+  const [renderedToast, setRenderedToast] = useState<RenderedToast | null>(null);
+  console.log(toasts);
+  if (toasts.size > 0) {
+    const [activeToast] = toasts;
+    if (!renderedToast || activeToast != renderedToast.data) {
+      // TODO play toast sound
+      console.log('rendering toast', activeToast);
+      setRenderedToast({ component: <Toast key={Math.random()} toast={activeToast} />, data: activeToast });
+    }
+  } else {
+    if (renderedToast) setRenderedToast(null);
+  }
+  useEffect(() => {
+    // not actually node but TS is shit
+    let interval: NodeJS.Timer | null;
+    if (renderedToast) {
+      interval = setTimeout(() => {
+        interval = null;
+        console.log('clear toast', renderedToast.data);
+        removeToast(renderedToast.data);
+      }, (renderedToast.data.duration || 5e3) + 1000);
+      console.log('set int', interval);
+    }
+    return () => {
+      if (interval) {
+        console.log('clearing int', interval);
+        clearTimeout(interval);
+      }
+    };
+  }, [renderedToast]);
+  return (
+    <div className={joinClassNames('deckyToaster', toastClasses.ToastPlaceholder)}>
+      {renderedToast && renderedToast.component}
+    </div>
+  );
+};
+
+export default DeckyToaster;
@@ -0,0 +1,69 @@
+import { ToastData } from 'decky-frontend-lib';
+import { FC, createContext, useContext, useEffect, useState } from 'react';
+
+interface PublicDeckyToasterState {
+  toasts: Set<ToastData>;
+}
+
+export class DeckyToasterState {
+  // TODO a set would be better
+  private _toasts: Set<ToastData> = new Set();
+
+  public eventBus = new EventTarget();
+
+  publicState(): PublicDeckyToasterState {
+    return { toasts: this._toasts };
+  }
+
+  addToast(toast: ToastData) {
+    this._toasts.add(toast);
+    this.notifyUpdate();
+  }
+
+  removeToast(toast: ToastData) {
+    this._toasts.delete(toast);
+    this.notifyUpdate();
+  }
+
+  private notifyUpdate() {
+    this.eventBus.dispatchEvent(new Event('update'));
+  }
+}
+
+interface DeckyToasterContext extends PublicDeckyToasterState {
+  addToast(toast: ToastData): void;
+  removeToast(toast: ToastData): void;
+}
+
+const DeckyToasterContext = createContext<DeckyToasterContext>(null as any);
+
+export const useDeckyToasterState = () => useContext(DeckyToasterContext);
+
+interface Props {
+  deckyToasterState: DeckyToasterState;
+}
+
+export const DeckyToasterStateContextProvider: FC<Props> = ({ children, deckyToasterState }) => {
+  const [publicDeckyToasterState, setPublicDeckyToasterState] = useState<PublicDeckyToasterState>({
+    ...deckyToasterState.publicState(),
+  });
+
+  useEffect(() => {
+    function onUpdate() {
+      setPublicDeckyToasterState({ ...deckyToasterState.publicState() });
+    }
+
+    deckyToasterState.eventBus.addEventListener('update', onUpdate);
+
+    return () => deckyToasterState.eventBus.removeEventListener('update', onUpdate);
+  }, []);
+
+  const addToast = deckyToasterState.addToast.bind(deckyToasterState);
+  const removeToast = deckyToasterState.removeToast.bind(deckyToasterState);
+
+  return (
+    <DeckyToasterContext.Provider value={{ ...publicDeckyToasterState, addToast, removeToast }}>
+      {children}
+    </DeckyToasterContext.Provider>
+  );
+};
@@ -1,4 +1,4 @@
-import { Focusable } from 'decky-frontend-lib';
+import { Focusable, Router } from 'decky-frontend-lib';
 import { FunctionComponent, useRef } from 'react';
 import ReactMarkdown, { Options as ReactMarkdownOptions } from 'react-markdown';
 import remarkGfm from 'remark-gfm';
@@ -21,8 +21,8 @@ const Markdown: FunctionComponent<MarkdownProps> = (props) => {
              <Focusable
                onActivate={() => {}}
                onOKButton={() => {
-                  aRef?.current?.click();
                  props.onDismiss?.();
+                  Router.NavigateToExternalWeb(aRef.current!.href);
                }}
                style={{ display: 'inline' }}
              >
@@ -1,13 +1,21 @@
-import { FC, createContext, useContext } from 'react';
+import { FC, createContext, useContext, useState } from 'react';

 const QuickAccessVisibleState = createContext<boolean>(true);

 export const useQuickAccessVisible = () => useContext(QuickAccessVisibleState);

-interface Props {
-  visible: boolean;
-}
-
-export const QuickAccessVisibleStateProvider: FC<Props> = ({ children, visible }) => {
+export const QuickAccessVisibleStateProvider: FC<{ initial: boolean; setter: ((val: boolean) => {}[]) | never[] }> = ({
+  children,
+  initial,
+  setter,
+}) => {
+  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;
+  if (initial != prev) {
+    setPrev(initial);
+    setVisible(initial);
+  }
  return <QuickAccessVisibleState.Provider value={visible}>{children}</QuickAccessVisibleState.Provider>;
 };
@@ -1,6 +1,7 @@
 import { DialogButton, Focusable, Router, staticClasses } from 'decky-frontend-lib';
 import { CSSProperties, VFC } from 'react';
-import { FaArrowLeft, FaCog, FaStore } from 'react-icons/fa';
+import { BsGearFill } from 'react-icons/bs';
+import { FaArrowLeft, FaStore } from 'react-icons/fa';

 import { useDeckyState } from './DeckyState';

@@ -26,12 +27,6 @@ const TitleView: VFC = () => {
  if (activePlugin === null) {
    return (
      <Focusable style={titleStyles} className={staticClasses.Title}>
-        <DialogButton
-          style={{ height: '28px', width: '40px', minWidth: 0, padding: '10px 12px' }}
-          onClick={onSettingsClick}
-        >
-          <FaCog style={{ marginTop: '-4px', display: 'block' }} />
-        </DialogButton>
        <div style={{ marginRight: 'auto', flex: 0.9 }}>Decky</div>
        <DialogButton
          style={{ height: '28px', width: '40px', minWidth: 0, padding: '10px 12px' }}
@@ -39,6 +34,12 @@ const TitleView: VFC = () => {
        >
          <FaStore style={{ marginTop: '-4px', display: 'block' }} />
        </DialogButton>
+        <DialogButton
+          style={{ height: '28px', width: '40px', minWidth: 0, padding: '10px 12px' }}
+          onClick={onSettingsClick}
+        >
+          <BsGearFill style={{ marginTop: '-4px', display: 'block' }} />
+        </DialogButton>
      </Focusable>
    );
  }
@@ -2,13 +2,10 @@ import { ToastData, findModule, joinClassNames } from 'decky-frontend-lib';
 import { FunctionComponent } from 'react';

 interface ToastProps {
-  toast: {
-    data: ToastData;
-    nToastDurationMS: number;
-  };
+  toast: ToastData;
 }

-const toastClasses = findModule((mod) => {
+export const toastClasses = findModule((mod) => {
  if (typeof mod !== 'object') return false;

  if (mod.ToastPlaceholder) {
@@ -31,21 +28,17 @@ const templateClasses = findModule((mod) => {
 const Toast: FunctionComponent<ToastProps> = ({ toast }) => {
  return (
    <div
-      style={{ '--toast-duration': `${toast.nToastDurationMS}ms` } as React.CSSProperties}
-      className={toastClasses.toastEnter}
+      style={{ '--toast-duration': `${toast.duration}ms` } as React.CSSProperties}
+      onClick={toast.onClick}
+      className={joinClassNames(templateClasses.ShortTemplate, toast.className || '')}
    >
-      <div
-        onClick={toast.data.onClick}
-        className={joinClassNames(templateClasses.ShortTemplate, toast.data.className || '')}
-      >
-        {toast.data.logo && <div className={templateClasses.StandardLogoDimensions}>{toast.data.logo}</div>}
-        <div className={joinClassNames(templateClasses.Content, toast.data.contentClassName || '')}>
-          <div className={templateClasses.Header}>
-            {toast.data.icon && <div className={templateClasses.Icon}>{toast.data.icon}</div>}
-            <div className={templateClasses.Title}>{toast.data.title}</div>
-          </div>
-          <div className={templateClasses.Body}>{toast.data.body}</div>
+      {toast.logo && <div className={templateClasses.StandardLogoDimensions}>{toast.logo}</div>}
+      <div className={joinClassNames(templateClasses.Content, toast.contentClassName || '')}>
+        <div className={templateClasses.Header}>
+          {toast.icon && <div className={templateClasses.Icon}>{toast.icon}</div>}
+          <div className={templateClasses.Title}>{toast.title}</div>
        </div>
+        <div className={templateClasses.Body}>{toast.body}</div>
      </div>
    </div>
  );
@@ -1,4 +1,4 @@
-import { ConfirmModal, QuickAccessTab, Router, Spinner, staticClasses } from 'decky-frontend-lib';
+import { ConfirmModal, Navigation, QuickAccessTab } from 'decky-frontend-lib';
 import { FC, useState } from 'react';

 interface PluginInstallModalProps {
@@ -20,21 +20,20 @@ const PluginInstallModal: FC<PluginInstallModalProps> = ({ artifact, version, ha
      onOK={async () => {
        setLoading(true);
        await onOK();
-        setTimeout(() => Router.OpenQuickAccessMenu(QuickAccessTab.Decky), 250);
+        setTimeout(() => Navigation.OpenQuickAccessMenu(QuickAccessTab.Decky), 250);
        setTimeout(() => window.DeckyPluginLoader.checkPluginUpdates(), 1000);
      }}
      onCancel={async () => {
        await onCancel();
      }}
+      strTitle={`Install ${artifact}`}
+      strOKButtonText={loading ? 'Installing' : 'Install'}
    >
-      <div className={staticClasses.Title} style={{ flexDirection: 'column' }}>
-        {hash == 'False' ? <h3 style={{ color: 'red' }}>!!!!NO HASH PROVIDED!!!!</h3> : null}
-        <div style={{ flexDirection: 'row' }}>
-          {loading && <Spinner style={{ width: '20px' }} />} {loading ? 'Installing' : 'Install'} {artifact}
-          {version ? ' version ' + version : null}
-          {!loading && '?'}
-        </div>
-      </div>
+      {hash == 'False' ? (
+        <h3 style={{ color: 'red' }}>!!!!NO HASH PROVIDED!!!!</h3>
+      ) : (
+        `Are you sure you want to install ${artifact} ${version}?`
+      )}
    </ConfirmModal>
  );
 };
@@ -1,4 +1,8 @@
-import { Patch, findModuleChild, replacePatch } from 'decky-frontend-lib';
+import { Patch, findModuleChild, replacePatch, sleep } from 'decky-frontend-lib';
+
+import Logger from '../../../../logger';
+
+const logger = new Logger('LibraryPatch');

 declare global {
  interface Window {
@@ -10,36 +14,44 @@ declare global {
 let patch: Patch;

 function rePatch() {
-  // If you patch anything on SteamClient within the first few seconds of the client having loaded it will get redefined for some reason, so repatch any of these changes that occur within the first 20s of the last patch
+  // If you patch anything on SteamClient within the first few seconds of the client having loaded it will get redefined for some reason, so repatch any of these changes that occur with History.listen or an interval
  patch = replacePatch(window.SteamClient.Apps, 'PromptToChangeShortcut', async ([appid]: number[]) => {
    try {
      const details = window.appDetailsStore.GetAppDetails(appid);
-      console.log(details);
+      logger.debug('game details', details);
      // strShortcutStartDir
      const file = await window.DeckyPluginLoader.openFilePicker(details.strShortcutStartDir.replaceAll('"', ''));
-      console.log('user selected', file);
+      logger.debug('user selected', file);
      window.SteamClient.Apps.SetShortcutExe(appid, JSON.stringify(file.path));
      const pathArr = file.path.split('/');
      pathArr.pop();
      const folder = pathArr.join('/');
      window.SteamClient.Apps.SetShortcutStartDir(appid, JSON.stringify(folder));
    } catch (e) {
-      console.error(e);
+      logger.error(e);
    }
  });
 }

-// TODO type and add to frontend-lib
-const History = findModuleChild((m) => {
-  if (typeof m !== 'object') return undefined;
-  for (let prop in m) {
-    if (m[prop]?.m_history) return m[prop].m_history;
-  }
-});
-
 export default async function libraryPatch() {
  try {
    rePatch();
+    // TODO type and add to frontend-lib
+    let History: any;
+
+    while (!History) {
+      History = findModuleChild((m) => {
+        if (typeof m !== 'object') return undefined;
+        for (let prop in m) {
+          if (m[prop]?.m_history) return m[prop].m_history;
+        }
+      });
+      if (!History) {
+        logger.debug('Waiting 5s for history to become available.');
+        await sleep(5000);
+      }
+    }
+
    const unlisten = History.listen(() => {
      if (window.SteamClient.Apps.PromptToChangeShortcut !== patch.patchedFunction) {
        rePatch();
@@ -47,11 +59,11 @@ export default async function libraryPatch() {
    });

    return () => {
-      patch.unpatch();
      unlisten();
+      patch.unpatch();
    };
  } catch (e) {
-    console.error('Error patching library file picker', e);
+    logger.error('Error patching library file picker', e);
  }
  return () => {};
 }
@@ -1,7 +1,9 @@
 import { SidebarNavigation } from 'decky-frontend-lib';
 import { lazy } from 'react';
+import { FaCode, FaPlug } from 'react-icons/fa';

 import { useSetting } from '../../utils/hooks/useSetting';
+import DeckyIcon from '../DeckyIcon';
 import WithSuspense from '../WithSuspense';
 import GeneralSettings from './pages/general';
 import PluginList from './pages/plugin_list';
@@ -13,19 +15,18 @@ export default function SettingsPage() {

  const pages = [
    {
-      title: 'General',
+      title: 'Decky',
      content: <GeneralSettings isDeveloper={isDeveloper} setIsDeveloper={setIsDeveloper} />,
      route: '/decky/settings/general',
+      icon: <DeckyIcon />,
    },
    {
      title: 'Plugins',
      content: <PluginList />,
      route: '/decky/settings/plugins',
+      icon: <FaPlug />,
    },
-  ];
-
-  if (isDeveloper)
-    pages.push({
+    {
      title: 'Developer',
      content: (
        <WithSuspense>
@@ -33,7 +34,10 @@ export default function SettingsPage() {
        </WithSuspense>
      ),
      route: '/decky/settings/developer',
-    });
+      icon: <FaCode />,
+      visible: isDeveloper,
+    },
+  ];

-  return <SidebarNavigation title="Decky Settings" showTitle pages={pages} />;
+  return <SidebarNavigation pages={pages} />;
 }
@@ -1,9 +1,10 @@
-import { Field, Focusable, TextField, Toggle } from 'decky-frontend-lib';
+import { DialogBody, Field, TextField, Toggle } from 'decky-frontend-lib';
 import { useRef } from 'react';
 import { FaReact, FaSteamSymbol } from 'react-icons/fa';

 import { setShouldConnectToReactDevTools, setShowValveInternal } from '../../../../developer';
 import { useSetting } from '../../../../utils/hooks/useSetting';
+import RemoteDebuggingSettings from '../general/RemoteDebugging';

 export default function DeveloperSettings() {
  const [enableValveInternal, setEnableValveInternal] = useSetting<boolean>('developer.valve_internal', false);
@@ -12,7 +13,8 @@ export default function DeveloperSettings() {
  const textRef = useRef<HTMLDivElement>(null);

  return (
-    <>
+    <DialogBody>
+      <RemoteDebuggingSettings />
      <Field
        label="Enable Valve Internal"
        description={
@@ -30,55 +32,33 @@ export default function DeveloperSettings() {
            setShowValveInternal(toggleValue);
          }}
        />
-      </Field>{' '}
-      <Focusable
-        onTouchEnd={
-          reactDevtoolsIP == ''
-            ? () => {
-                (textRef.current?.childNodes[0] as HTMLInputElement)?.focus();
-              }
-            : undefined
-        }
-        onClick={
-          reactDevtoolsIP == ''
-            ? () => {
-                (textRef.current?.childNodes[0] as HTMLInputElement)?.focus();
-              }
-            : undefined
-        }
-        onOKButton={
-          reactDevtoolsIP == ''
-            ? () => {
-                (textRef.current?.childNodes[0] as HTMLInputElement)?.focus();
-              }
-            : undefined
+      </Field>
+      <Field
+        label="Enable React DevTools"
+        description={
+          <>
+            <span style={{ whiteSpace: 'pre-line' }}>
+              Enables connection to a computer running React DevTools. Changing this setting will reload Steam. Set the
+              IP address before enabling.
+            </span>
+            <br />
+            <br />
+            <div ref={textRef}>
+              <TextField label={'IP'} value={reactDevtoolsIP} onChange={(e) => setReactDevtoolsIP(e?.target.value)} />
+            </div>
+          </>
        }
+        icon={<FaReact style={{ display: 'block' }} />}
      >
-        <Field
-          label="Enable React DevTools"
-          description={
-            <>
-              <span style={{ whiteSpace: 'pre-line' }}>
-                Enables connection to a computer running React DevTools. Changing this setting will reload Steam. Set
-                the IP address before enabling.
-              </span>
-              <div ref={textRef}>
-                <TextField label={'IP'} value={reactDevtoolsIP} onChange={(e) => setReactDevtoolsIP(e?.target.value)} />
-              </div>
-            </>
-          }
-          icon={<FaReact style={{ display: 'block' }} />}
-        >
-          <Toggle
-            value={reactDevtoolsEnabled}
-            disabled={reactDevtoolsIP == ''}
-            onChange={(toggleValue) => {
-              setReactDevtoolsEnabled(toggleValue);
-              setShouldConnectToReactDevTools(toggleValue);
-            }}
-          />
-        </Field>
-      </Focusable>
-    </>
+        <Toggle
+          value={reactDevtoolsEnabled}
+          disabled={reactDevtoolsIP == ''}
+          onChange={(toggleValue) => {
+            setReactDevtoolsEnabled(toggleValue);
+            setShouldConnectToReactDevTools(toggleValue);
+          }}
+        />
+      </Field>
+    </DialogBody>
  );
 }
@@ -10,7 +10,7 @@ const logger = new Logger('BranchSelect');
 enum UpdateBranch {
  Stable,
  Prerelease,
-  // Nightly,
+  // Testing,
 }

 const BranchSelect: FunctionComponent<{}> = () => {
@@ -19,7 +19,7 @@ const BranchSelect: FunctionComponent<{}> = () => {
  return (
    // Returns numerical values from 0 to 2 (with current branch setup as of 8/28/22)
    // 0 being stable, 1 being pre-release and 2 being nightly
-    <Field label="Update Channel">
+    <Field label="Decky Update Channel" childrenContainerWidth={'fixed'}>
      <Dropdown
        rgOptions={Object.values(UpdateBranch)
          .filter((branch) => typeof branch == 'string')
@@ -1,5 +1,5 @@
 import { Field, Toggle } from 'decky-frontend-lib';
-import { FaBug } from 'react-icons/fa';
+import { FaChrome } from 'react-icons/fa';

 import { useSetting } from '../../../../utils/hooks/useSetting';

@@ -11,10 +11,10 @@ export default function RemoteDebuggingSettings() {
      label="Allow Remote CEF Debugging"
      description={
        <span style={{ whiteSpace: 'pre-line' }}>
-          Allow unauthenticated access to the CEF debugger to anyone in your network
+          Allows unauthenticated access to the CEF debugger to anyone in your network.
        </span>
      }
-      icon={<FaBug style={{ display: 'block' }} />}
+      icon={<FaChrome style={{ display: 'block' }} />}
    >
      <Toggle
        value={allowRemoteDebugging || false}
@@ -0,0 +1,52 @@
+import { Dropdown, Field, TextField } from 'decky-frontend-lib';
+import { FunctionComponent } from 'react';
+import { FaShapes } from 'react-icons/fa';
+
+import Logger from '../../../../logger';
+import { Store } from '../../../../store';
+import { useSetting } from '../../../../utils/hooks/useSetting';
+
+const logger = new Logger('StoreSelect');
+
+const StoreSelect: FunctionComponent<{}> = () => {
+  const [selectedStore, setSelectedStore] = useSetting<Store>('store', Store.Default);
+  const [selectedStoreURL, setSelectedStoreURL] = useSetting<string | null>('store-url', null);
+
+  // Returns numerical values from 0 to 2 (with current branch setup as of 8/28/22)
+  // 0 being Default, 1 being Testing and 2 being Custom
+  return (
+    <>
+      <Field label="Plugin Store Channel" childrenContainerWidth={'fixed'}>
+        <Dropdown
+          rgOptions={Object.values(Store)
+            .filter((store) => typeof store == 'string')
+            .map((store) => ({
+              label: store,
+              data: Store[store],
+            }))}
+          selectedOption={selectedStore}
+          onChange={async (newVal) => {
+            await setSelectedStore(newVal.data);
+            logger.log('switching stores!');
+          }}
+        />
+      </Field>
+      {selectedStore == Store.Custom && (
+        <Field
+          label="Custom Store"
+          indentLevel={1}
+          description={
+            <TextField
+              label={'URL'}
+              value={selectedStoreURL || undefined}
+              onChange={(e) => setSelectedStoreURL(e?.target.value || null)}
+            />
+          }
+          icon={<FaShapes style={{ display: 'block' }} />}
+        ></Field>
+      )}
+    </>
+  );
+};
+
+export default StoreSelect;
@@ -11,9 +11,10 @@ import {
 import { useCallback } from 'react';
 import { Suspense, lazy } from 'react';
 import { useEffect, useState } from 'react';
-import { FaArrowDown } from 'react-icons/fa';
+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';
@@ -21,6 +22,7 @@ import WithSuspense from '../../../WithSuspense';
 const MarkdownRenderer = lazy(() => import('../../../Markdown'));

 function PatchNotesModal({ versionInfo, closeModal }: { versionInfo: VerInfo | null; closeModal?: () => {} }) {
+  const SP = findSP();
  return (
    <Focusable onCancelButton={closeModal}>
      <FocusRing>
@@ -50,12 +52,13 @@ function PatchNotesModal({ versionInfo, closeModal }: { versionInfo: VerInfo | n
          )}
          fnGetId={(id) => id}
          nNumItems={versionInfo?.all?.length}
-          nHeight={window.innerHeight - 40}
-          nItemHeight={window.innerHeight - 40}
+          nHeight={SP.innerHeight - 40}
+          nItemHeight={SP.innerHeight - 40}
          nItemMarginX={0}
          initialColumn={0}
          autoFocus={true}
-          fnGetColumnWidth={() => window.innerWidth}
+          fnGetColumnWidth={() => SP.innerWidth}
+          name="Decky Updates"
        />
      </FocusRing>
    </Focusable>
@@ -92,21 +95,21 @@ export default function UpdaterSettings() {
      <Field
        onOptionsActionDescription={versionInfo?.all ? 'Patch Notes' : undefined}
        onOptionsButton={versionInfo?.all ? showPatchNotes : undefined}
-        label="Updates"
+        label="Decky Updates"
        description={
-          versionInfo && (
-            <span style={{ whiteSpace: 'pre-line' }}>{`Current version: ${versionInfo.current}\n${
-              versionInfo.updatable ? `Latest version: ${versionInfo.remote?.tag_name}` : ''
-            }`}</span>
+          checkingForUpdates || versionInfo?.remote?.tag_name != versionInfo?.current || !versionInfo?.remote ? (
+            ''
+          ) : (
+            <span>Up to date: running {versionInfo?.current}</span>
          )
        }
        icon={
-          !versionInfo ? (
-            <Spinner style={{ width: '1em', height: 20, display: 'block' }} />
-          ) : (
-            <FaArrowDown style={{ display: 'block' }} />
+          versionInfo?.remote &&
+          versionInfo?.remote?.tag_name != versionInfo?.current && (
+            <FaExclamation color="var(--gpColor-Yellow)" style={{ display: 'block' }} />
          )
        }
+        childrenContainerWidth={'fixed'}
      >
        {updateProgress == -1 && !isLoaderUpdating ? (
          <DialogButton
@@ -141,7 +144,7 @@ export default function UpdaterSettings() {
          />
        )}
      </Field>
-      {versionInfo?.remote && (
+      {versionInfo?.remote && versionInfo?.remote?.tag_name != versionInfo?.current && (
        <InlinePatchNotes
          title={versionInfo?.remote.name}
          date={new Intl.RelativeTimeFormat('en-US', {
@@ -1,10 +1,18 @@
-import { DialogButton, Field, TextField, Toggle } from 'decky-frontend-lib';
+import {
+  DialogBody,
+  DialogButton,
+  DialogControlsSection,
+  DialogControlsSectionHeader,
+  Field,
+  TextField,
+  Toggle,
+} from 'decky-frontend-lib';
 import { useState } from 'react';
-import { FaShapes, FaTools } from 'react-icons/fa';

 import { installFromURL } from '../../../../store';
+import { useDeckyState } from '../../../DeckyState';
 import BranchSelect from './BranchSelect';
-import RemoteDebuggingSettings from './RemoteDebugging';
+import StoreSelect from './StoreSelect';
 import UpdaterSettings from './Updater';

 export default function GeneralSettings({
@@ -15,42 +23,44 @@ export default function GeneralSettings({
  setIsDeveloper: (val: boolean) => void;
 }) {
  const [pluginURL, setPluginURL] = useState('');
-  // const [checked, setChecked] = useState(false); // store these in some kind of State instead
+  const { versionInfo } = useDeckyState();
+
  return (
-    <div>
-      {/* <Field
-        label="A Toggle with an icon"
-        icon={<FaShapes style={{ display: 'block' }} />}
-      >
-        <Toggle
-          value={checked}
-          onChange={(e) => setChecked(e)}
-        />
-      </Field> */}
-      <UpdaterSettings />
-      <BranchSelect />
-      <RemoteDebuggingSettings />
-      <Field
-        label="Developer mode"
-        description={<span style={{ whiteSpace: 'pre-line' }}>Enables Decky's developer settings.</span>}
-        icon={<FaTools style={{ display: 'block' }} />}
-      >
-        <Toggle
-          value={isDeveloper}
-          onChange={(toggleValue) => {
-            setIsDeveloper(toggleValue);
-          }}
-        />
-      </Field>
-      <Field
-        label="Manual plugin install"
-        description={<TextField label={'URL'} value={pluginURL} onChange={(e) => setPluginURL(e?.target.value)} />}
-        icon={<FaShapes style={{ display: 'block' }} />}
-      >
-        <DialogButton disabled={pluginURL.length == 0} onClick={() => installFromURL(pluginURL)}>
-          Install
-        </DialogButton>
-      </Field>
-    </div>
+    <DialogBody>
+      <DialogControlsSection>
+        <DialogControlsSectionHeader>Updates</DialogControlsSectionHeader>
+        <UpdaterSettings />
+      </DialogControlsSection>
+      <DialogControlsSection>
+        <DialogControlsSectionHeader>Beta Participation</DialogControlsSectionHeader>
+        <BranchSelect />
+        <StoreSelect />
+      </DialogControlsSection>
+      <DialogControlsSection>
+        <DialogControlsSectionHeader>Other</DialogControlsSectionHeader>
+        <Field label="Enable Developer Mode">
+          <Toggle
+            value={isDeveloper}
+            onChange={(toggleValue) => {
+              setIsDeveloper(toggleValue);
+            }}
+          />
+        </Field>
+        <Field
+          label="Install plugin from URL"
+          description={<TextField label={'URL'} value={pluginURL} onChange={(e) => setPluginURL(e?.target.value)} />}
+        >
+          <DialogButton disabled={pluginURL.length == 0} onClick={() => installFromURL(pluginURL)}>
+            Install
+          </DialogButton>
+        </Field>
+      </DialogControlsSection>
+      <DialogControlsSection>
+        <DialogControlsSectionHeader>About</DialogControlsSectionHeader>
+        <Field label="Decky Version" focusable={true}>
+          <div style={{ color: 'var(--gpSystemLighterGrey)' }}>{versionInfo?.current}</div>
+        </Field>
+      </DialogControlsSection>
+    </DialogBody>
  );
 }
@@ -1,4 +1,12 @@
-import { DialogButton, Focusable, Menu, MenuItem, showContextMenu } from 'decky-frontend-lib';
+import {
+  DialogBody,
+  DialogButton,
+  DialogControlsSection,
+  Focusable,
+  Menu,
+  MenuItem,
+  showContextMenu,
+} from 'decky-frontend-lib';
 import { useEffect } from 'react';
 import { FaDownload, FaEllipsisH } from 'react-icons/fa';

@@ -21,46 +29,52 @@ export default function PluginList() {
  }

  return (
-    <ul style={{ listStyleType: 'none' }}>
-      {plugins.map(({ name, version }) => {
-        const update = updates?.get(name);
-        return (
-          <li style={{ display: 'flex', flexDirection: 'row', alignItems: 'center', paddingBottom: '10px' }}>
-            <span>
-              {name} {version}
-            </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>
+    <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>
+      </DialogControlsSection>
+    </DialogBody>
  );
 }
@@ -1,234 +1,177 @@
 import {
-  DialogButton,
+  ButtonItem,
  Dropdown,
  Focusable,
-  QuickAccessTab,
-  Router,
+  PanelSectionRow,
  SingleDropdownOption,
  SuspensefulImage,
-  joinClassNames,
-  staticClasses,
 } from 'decky-frontend-lib';
-import { FC, useRef, useState } from 'react';
+import { FC, useState } from 'react';

-import {
-  LegacyStorePlugin,
-  StorePlugin,
-  StorePluginVersion,
-  isLegacyPlugin,
-  requestLegacyPluginInstall,
-  requestPluginInstall,
-} from '../../store';
+import { StorePlugin, StorePluginVersion, requestPluginInstall } from '../../store';

 interface PluginCardProps {
-  plugin: StorePlugin | LegacyStorePlugin;
+  plugin: StorePlugin;
 }

 const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
  const [selectedOption, setSelectedOption] = useState<number>(0);
-  const buttonRef = useRef<HTMLDivElement>(null);
-  const containerRef = useRef<HTMLDivElement>(null);
+  const root: boolean = plugin.tags.some((tag) => tag === 'root');
+
  return (
    <div
+      className="deckyStoreCard"
      style={{
-        padding: '30px',
-        paddingTop: '10px',
-        paddingBottom: '10px',
+        marginLeft: '20px',
+        marginRight: '20px',
+        marginBottom: '20px',
+        display: 'flex',
+        alignItems: 'center',
      }}
    >
-      {/* TODO: abstract this messy focus hackiness into a custom component in lib */}
-      <Focusable
-        className="deckyStoreCard"
-        ref={containerRef}
-        onActivate={(_: CustomEvent) => {
-          buttonRef.current!.focus();
-        }}
-        onCancel={(_: CustomEvent) => {
-          if (containerRef.current!.querySelectorAll('* :focus').length === 0) {
-            Router.NavigateBackOrOpenMenu();
-            setTimeout(() => Router.OpenQuickAccessMenu(QuickAccessTab.Decky), 1000);
-          } else {
-            containerRef.current!.focus();
-          }
-        }}
+      <div
+        className="deckyStoreCardImageContainer"
        style={{
-          display: 'flex',
-          flexDirection: 'column',
-          background: '#ACB2C924',
-          height: 'unset',
-          marginBottom: 'unset',
-          // boxShadow: var(--gpShadow-Medium);
-          scrollSnapAlign: 'start',
-          boxSizing: 'border-box',
+          width: '320px',
+          height: '200px',
+          position: 'relative',
        }}
      >
-        <div className="deckyStoreCardHeader" style={{ display: 'flex', alignItems: 'center' }}>
-          <a
-            style={{ fontSize: '18pt', padding: '10px' }}
-            className={joinClassNames(staticClasses.Text)}
-            // onClick={() => Router.NavigateToExternalWeb('https://github.com/' + plugin.artifact)}
-          >
-            {isLegacyPlugin(plugin) ? (
-              <div className="deckyStoreCardNameContainer">
-                <span className="deckyStoreCardLegacyRepoOwner" style={{ color: 'grey' }}>
-                  {plugin.artifact.split('/')[0]}/
-                </span>
-                {plugin.artifact.split('/')[1]}
-              </div>
-            ) : (
-              plugin.name
-            )}
-          </a>
-        </div>
-        <div
+        <SuspensefulImage
+          className="deckyStoreCardImage"
+          suspenseHeight="200px"
+          suspenseWidth="320px"
          style={{
-            display: 'flex',
-            flexDirection: 'row',
+            width: '320px',
+            height: '200px',
+            objectFit: 'cover',
          }}
-          className="deckyStoreCardBody"
-        >
-          <SuspensefulImage
-            className="deckyStoreCardImage"
-            suspenseWidth="256px"
-            style={{
-              width: 'auto',
-              height: '160px',
-            }}
-            src={
-              isLegacyPlugin(plugin)
-                ? `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/artifact_images/${plugin.artifact.replace(
-                    '/',
-                    '_',
-                  )}.png`
-                : `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/artifact_images/${plugin.name.replace(
-                    '/',
-                    '_',
-                  )}.png`
-            }
-          />
-          <div
-            style={{
-              display: 'flex',
-              flexDirection: 'column',
-            }}
-            className="deckyStoreCardInfo"
-          >
-            <p
-              className={joinClassNames(staticClasses.PanelSectionRow)}
-              style={{ marginTop: '0px', marginLeft: '16px' }}
-            >
-              <span style={{ paddingLeft: '0px' }}>Author: {plugin.author}</span>
-            </p>
-            <p
-              className={joinClassNames(staticClasses.PanelSectionRow)}
-              style={{
-                marginLeft: '16px',
-                marginTop: '0px',
-                marginBottom: '0px',
-                marginRight: '16px',
-              }}
-            >
-              <span style={{ paddingLeft: '0px' }}>{plugin.description}</span>
-            </p>
-            <p
-              className={joinClassNames('deckyStoreCardTagsContainer', staticClasses.PanelSectionRow)}
-              style={{
-                padding: '0 16px',
-                display: 'flex',
-                flexWrap: 'wrap',
-                gap: '5px 10px',
-              }}
-            >
-              <span style={{ padding: '5px 0' }}>Tags:</span>
-              {plugin.tags.map((tag: string) => (
-                <span
-                  className="deckyStoreCardTag"
-                  style={{
-                    padding: '5px',
-                    borderRadius: '5px',
-                    background: tag == 'root' ? '#842029' : '#ACB2C947',
-                  }}
-                >
-                  {tag == 'root' ? 'Requires root' : tag}
-                </span>
-              ))}
-              {isLegacyPlugin(plugin) && (
-                <span
-                  className="deckyStoreCardTag deckyStoreCardLegacyTag"
-                  style={{
-                    color: '#232120',
-                    padding: '5px',
-                    borderRadius: '5px',
-                    background: '#EDE841',
-                  }}
-                >
-                  legacy
-                </span>
-              )}
-            </p>
-          </div>
-        </div>
-        <div
-          className="deckyStoreCardActionsContainer"
+          src={plugin.image_url}
+        />
+      </div>
+      <div
+        className="deckyStoreCardInfo"
+        style={{
+          width: 'calc(100% - 320px)', // The calc is here so that the info section doesn't expand into the image
+          display: 'flex',
+          flexDirection: 'column',
+          height: '100%',
+          marginLeft: '1em',
+          justifyContent: 'center',
+        }}
+      >
+        <span
+          className="deckyStoreCardTitle"
          style={{
+            fontSize: '1.25em',
+            fontWeight: 'bold',
+            whiteSpace: 'nowrap',
+            overflow: 'hidden',
+            textOverflow: 'ellipsis',
+            width: '90%',
+          }}
+        >
+          {plugin.name}
+        </span>
+        <span
+          className="deckyStoreCardAuthor"
+          style={{
+            marginRight: 'auto',
+            fontSize: '1em',
+          }}
+        >
+          {plugin.author}
+        </span>
+        <span
+          className="deckyStoreCardDescription"
+          style={{
+            fontSize: '13px',
+            color: '#969696',
+            WebkitLineClamp: root ? '2' : '3',
+            WebkitBoxOrient: 'vertical',
+            overflow: 'hidden',
+            display: '-webkit-box',
+          }}
+        >
+          {plugin.description ? (
+            plugin.description
+          ) : (
+            <span>
+              <i style={{ color: '#666' }}>No description provided.</i>
+            </span>
+          )}
+        </span>
+        {root && (
+          <span
+            className="deckyStoreCardDescription deckyStoreCardDescriptionRoot"
+            style={{
+              fontSize: '13px',
+              color: '#fee75c',
+            }}
+          >
+            <i>This plugin has full access to your Steam Deck.</i>{' '}
+            <a
+              className="deckyStoreCardDescriptionRootLink"
+              href="https://deckbrew.xyz/root"
+              target="_blank"
+              style={{
+                color: '#fee75c',
+                textDecoration: 'none',
+              }}
+            >
+              deckbrew.xyz/root
+            </a>
+          </span>
+        )}
+        <div
+          className="deckyStoreCardButtonRow"
+          style={{
+            marginTop: '1em',
            width: '100%',
-            alignSelf: 'flex-end',
-            display: 'flex',
-            flexDirection: 'row',
+            overflow: 'hidden',
          }}
        >
-          <Focusable
-            className="deckyStoreCardActions"
-            style={{
-              display: 'flex',
-              flexDirection: 'row',
-              width: '100%',
-            }}
-          >
-            <div
-              className="deckyStoreCardInstallButtonContainer"
-              style={{
-                flex: '1',
-              }}
-            >
-              <DialogButton
-                className="deckyStoreCardInstallButton"
-                ref={buttonRef}
-                onClick={() =>
-                  isLegacyPlugin(plugin)
-                    ? requestLegacyPluginInstall(plugin, Object.keys(plugin.versions)[selectedOption])
-                    : requestPluginInstall(plugin.name, plugin.versions[selectedOption])
-                }
+          <PanelSectionRow>
+            <Focusable style={{ display: 'flex', maxWidth: '100%' }}>
+              <div
+                className="deckyStoreCardInstallContainer"
+                style={{
+                  paddingTop: '0px',
+                  paddingBottom: '0px',
+                  width: '40%',
+                }}
              >
-                Install
-              </DialogButton>
-            </div>
-            <div
-              className="deckyStoreCardVersionDropdownContainer"
-              style={{
-                flex: '0.2',
-              }}
-            >
-              <Dropdown
-                rgOptions={
-                  (isLegacyPlugin(plugin)
-                    ? Object.keys(plugin.versions).map((v, k) => ({
-                        data: k,
-                        label: v,
-                      }))
-                    : plugin.versions.map((version: StorePluginVersion, index) => ({
-                        data: index,
-                        label: version.name,
-                      }))) as SingleDropdownOption[]
-                }
-                strDefaultLabel={'Select a version'}
-                selectedOption={selectedOption}
-                onChange={({ data }) => setSelectedOption(data)}
-              />
-            </div>
-          </Focusable>
+                <ButtonItem
+                  bottomSeparator="none"
+                  layout="below"
+                  onClick={() => requestPluginInstall(plugin.name, plugin.versions[selectedOption])}
+                >
+                  <span className="deckyStoreCardInstallText">Install</span>
+                </ButtonItem>
+              </div>
+              <div
+                className="deckyStoreCardVersionContainer"
+                style={{
+                  marginLeft: '5%',
+                  width: '30%',
+                }}
+              >
+                <Dropdown
+                  rgOptions={
+                    plugin.versions.map((version: StorePluginVersion, index) => ({
+                      data: index,
+                      label: version.name,
+                    })) as SingleDropdownOption[]
+                  }
+                  menuLabel="Plugin Version"
+                  selectedOption={selectedOption}
+                  onChange={({ data }) => setSelectedOption(data)}
+                />
+              </div>
+            </Focusable>
+          </PanelSectionRow>
        </div>
-      </Focusable>
+      </div>
    </div>
  );
 };
@@ -1,15 +1,29 @@
-import { SteamSpinner } from 'decky-frontend-lib';
-import { FC, useEffect, useState } from 'react';
+import {
+  Dropdown,
+  DropdownOption,
+  Focusable,
+  PanelSectionRow,
+  SteamSpinner,
+  Tabs,
+  TextField,
+  findModule,
+} from 'decky-frontend-lib';
+import { FC, useEffect, useMemo, useState } from 'react';

+import logo from '../../../assets/plugin_store.png';
 import Logger from '../../logger';
-import { LegacyStorePlugin, StorePlugin, getLegacyPluginList, getPluginList } from '../../store';
+import { StorePlugin, getPluginList } from '../../store';
 import PluginCard from './PluginCard';

 const logger = new Logger('FilePicker');

 const StorePage: FC<{}> = () => {
+  const [currentTabRoute, setCurrentTabRoute] = useState<string>('browse');
  const [data, setData] = useState<StorePlugin[] | null>(null);
-  const [legacyData, setLegacyData] = useState<LegacyStorePlugin[] | null>(null);
+  const { TabCount } = findModule((m) => {
+    if (m?.TabCount && m?.TabTitle) return true;
+    return false;
+  });

  useEffect(() => {
    (async () => {
@@ -17,27 +31,15 @@ const StorePage: FC<{}> = () => {
      logger.log('got data!', res);
      setData(res);
    })();
-    (async () => {
-      const res = await getLegacyPluginList();
-      logger.log('got legacy data!', res);
-      setLegacyData(res);
-    })();
  }, []);

  return (
-    <div
-      style={{
-        marginTop: '40px',
-        height: 'calc( 100% - 40px )',
-        overflowY: 'scroll',
-      }}
-    >
+    <>
      <div
        style={{
-          display: 'flex',
-          flexWrap: 'nowrap',
-          flexDirection: 'column',
-          height: '100%',
+          marginTop: '40px',
+          height: 'calc( 100% - 40px )',
+          background: '#0005',
        }}
      >
        {!data ? (
@@ -45,18 +47,193 @@ const StorePage: FC<{}> = () => {
            <SteamSpinner />
          </div>
        ) : (
-          <div>
-            {data.map((plugin: StorePlugin) => (
-              <PluginCard plugin={plugin} />
-            ))}
-            {!legacyData ? (
-              <SteamSpinner />
-            ) : (
-              legacyData.map((plugin: LegacyStorePlugin) => <PluginCard plugin={plugin} />)
-            )}
-          </div>
+          <Tabs
+            activeTab={currentTabRoute}
+            onShowTab={(tabId: string) => {
+              setCurrentTabRoute(tabId);
+            }}
+            tabs={[
+              {
+                title: 'Browse',
+                content: <BrowseTab children={{ data: data }} />,
+                id: 'browse',
+                renderTabAddon: () => <span className={TabCount}>{data.length}</span>,
+              },
+              {
+                title: 'About',
+                content: <AboutTab />,
+                id: 'about',
+              },
+            ]}
+          />
        )}
      </div>
+    </>
+  );
+};
+
+const BrowseTab: FC<{ children: { data: StorePlugin[] } }> = (data) => {
+  const sortOptions = useMemo(
+    (): DropdownOption[] => [
+      { data: 1, label: 'Alphabetical (A to Z)' },
+      { data: 2, label: 'Alphabetical (Z to A)' },
+    ],
+    [],
+  );
+
+  // const filterOptions = useMemo((): DropdownOption[] => [{ data: 1, label: 'All' }], []);
+
+  const [selectedSort, setSort] = useState<number>(sortOptions[0].data);
+  // const [selectedFilter, setFilter] = useState<number>(filterOptions[0].data);
+  const [searchFieldValue, setSearchValue] = useState<string>('');
+
+  return (
+    <>
+      <style>{`
+              .deckyStoreCardInstallContainer > .Panel {
+                padding: 0;
+              }
+            `}</style>
+      {/* This should be used once filtering is added
+
+      <PanelSectionRow>
+        <Focusable style={{ display: 'flex', maxWidth: '100%' }}>
+          <div
+            style={{
+              display: 'flex',
+              flexDirection: 'column',
+              width: '47.5%',
+            }}
+          >
+            <span className="DialogLabel">Sort</span>
+            <Dropdown
+              menuLabel="Sort"
+              rgOptions={sortOptions}
+              strDefaultLabel="Last Updated (Newest)"
+              selectedOption={selectedSort}
+              onChange={(e) => setSort(e.data)}
+            />
+          </div>
+          <div
+            style={{
+              display: 'flex',
+              flexDirection: 'column',
+              width: '47.5%',
+              marginLeft: 'auto',
+            }}
+          >
+            <span className="DialogLabel">Filter</span>
+            <Dropdown
+              menuLabel="Filter"
+              rgOptions={filterOptions}
+              strDefaultLabel="All"
+              selectedOption={selectedFilter}
+              onChange={(e) => setFilter(e.data)}
+            />
+          </div>
+        </Focusable>
+      </PanelSectionRow>
+      <div style={{ justifyContent: 'center', display: 'flex' }}>
+        <Focusable style={{ display: 'flex', alignItems: 'center', width: '96%' }}>
+          <div style={{ width: '100%' }}>
+            <TextField label="Search" value={searchFieldValue} onChange={(e) => setSearchValue(e.target.value)} />
+          </div>
+        </Focusable>
+      </div>
+      */}
+      <PanelSectionRow>
+        <Focusable style={{ display: 'flex', maxWidth: '100%' }}>
+          <div
+            style={{
+              display: 'flex',
+              flexDirection: 'column',
+              minWidth: '100%',
+              maxWidth: '100%',
+            }}
+          >
+            <span className="DialogLabel">Sort</span>
+            <Dropdown
+              menuLabel="Sort"
+              rgOptions={sortOptions}
+              strDefaultLabel="Last Updated (Newest)"
+              selectedOption={selectedSort}
+              onChange={(e) => setSort(e.data)}
+            />
+          </div>
+        </Focusable>
+      </PanelSectionRow>
+      <div style={{ justifyContent: 'center', display: 'flex' }}>
+        <Focusable style={{ display: 'flex', alignItems: 'center', width: '96%' }}>
+          <div style={{ width: '100%' }}>
+            <TextField label="Search" value={searchFieldValue} onChange={(e) => setSearchValue(e.target.value)} />
+          </div>
+        </Focusable>
+      </div>
+      <div>
+        {data.children.data
+          .filter((plugin: StorePlugin) => {
+            return (
+              plugin.name.toLowerCase().includes(searchFieldValue.toLowerCase()) ||
+              plugin.description.toLowerCase().includes(searchFieldValue.toLowerCase()) ||
+              plugin.author.toLowerCase().includes(searchFieldValue.toLowerCase()) ||
+              plugin.tags.some((tag: string) => tag.toLowerCase().includes(searchFieldValue.toLowerCase()))
+            );
+          })
+          .sort((a, b) => {
+            if (selectedSort % 2 === 1) return a.name.localeCompare(b.name);
+            else return b.name.localeCompare(a.name);
+          })
+          .map((plugin: StorePlugin) => (
+            <PluginCard plugin={plugin} />
+          ))}
+      </div>
+    </>
+  );
+};
+
+const AboutTab: FC<{}> = () => {
+  return (
+    <div
+      style={{
+        display: 'flex',
+        flexDirection: 'column',
+      }}
+    >
+      <style>{`
+              .deckyStoreAboutHeader {
+                font-size: 24px;
+                font-weight: 600;
+                margin-top: 20px;
+              }
+            `}</style>
+      <img
+        src={logo}
+        style={{
+          width: '256px',
+          height: 'auto',
+          alignSelf: 'center',
+        }}
+      />
+      <span className="deckyStoreAboutHeader">Testing</span>
+      <span>
+        Please consider testing new plugins to help the Decky Loader team!{' '}
+        <a
+          href="https://deckbrew.xyz/testing"
+          target="_blank"
+          style={{
+            textDecoration: 'none',
+          }}
+        >
+          deckbrew.xyz/testing
+        </a>
+      </span>
+      <span className="deckyStoreAboutHeader">Contributing</span>
+      <span>
+        If you would like to contribute to the Decky Plugin Store, check the SteamDeckHomebrew/decky-plugin-template
+        repository on GitHub. Information on development and distribution is available in the README.
+      </span>
+      <span className="deckyStoreAboutHeader">Source Code</span>
+      <span>All plugin source code is available on SteamDeckHomebrew/decky-plugin-database repository on GitHub.</span>
    </div>
  );
 };
@@ -1,6 +1,10 @@
 import {
+  Navigation,
  ReactRouter,
  Router,
+  fakeRenderComponent,
+  findInReactTree,
+  findInTree,
  findModule,
  findModuleChild,
  gamepadDialogClasses,
@@ -23,13 +27,20 @@ const logger = new Logger('DeveloperMode');

 let removeSettingsObserver: () => void = () => {};

-export function setShowValveInternal(show: boolean) {
-  const settingsMod = findModuleChild((m) => {
-    if (typeof m !== 'object') return undefined;
-    for (let prop in m) {
-      if (typeof m[prop]?.settings?.bIsValveEmail !== 'undefined') return m[prop];
+export async function setShowValveInternal(show: boolean) {
+  let settingsMod: any;
+  while (!settingsMod) {
+    settingsMod = findModuleChild((m) => {
+      if (typeof m !== 'object') return undefined;
+      for (let prop in m) {
+        if (typeof m[prop]?.settings?.bIsValveEmail !== 'undefined') return m[prop];
+      }
+    });
+    if (!settingsMod) {
+      logger.debug('[ValveInternal] waiting for settingsMod');
+      await sleep(1000);
    }
-  });
+  }

  if (show) {
    removeSettingsObserver = settingsMod[
@@ -71,8 +82,14 @@ export async function startup() {
  window.DFL = {
    findModuleChild,
    findModule,
+    Navigation,
    Router,
    ReactRouter,
+    ReactUtils: {
+      fakeRenderComponent,
+      findInReactTree,
+      findInTree,
+    },
    classes: {
      scrollClasses,
      staticClasses,
@@ -1,3 +1,5 @@
+import { Navigation, Router, sleep } from 'decky-frontend-lib';
+
 import PluginLoader from './plugin-loader';
 import { DeckyUpdater } from './updater';

@@ -14,6 +16,23 @@ declare global {
  }
 }

+(async () => {
+  try {
+    if (!Router.NavigateToAppProperties || !Router.NavigateToLibraryTab || !Router.NavigateToInvites) {
+      while (!Navigation.NavigateToAppProperties) await sleep(100);
+      const shims = {
+        NavigateToAppProperties: Navigation.NavigateToAppProperties,
+        NavigateToInvites: Navigation.NavigateToInvites,
+        NavigateToLibraryTab: Navigation.NavigateToLibraryTab,
+      };
+      (Router as unknown as any).deckyShim = true;
+      Object.assign(Router, shims);
+    }
+  } catch (e) {
+    console.error('[DECKY]: Error initializing Navigation interface shims', e);
+  }
+})();
+
 (async () => {
  window.deckyAuthToken = await fetch('http://127.0.0.1:1337/auth/token').then((r) => r.text());

@@ -1,15 +1,6 @@
-import {
-  ConfirmModal,
-  ModalRoot,
-  Patch,
-  QuickAccessTab,
-  Router,
-  showModal,
-  sleep,
-  staticClasses,
-} from 'decky-frontend-lib';
-import { lazy } from 'react';
-import { FaPlug } from 'react-icons/fa';
+import { ConfirmModal, ModalRoot, Patch, QuickAccessTab, Router, showModal, sleep } from 'decky-frontend-lib';
+import { FC, lazy } from 'react';
+import { FaCog, FaExclamationCircle, FaPlug } from 'react-icons/fa';

 import { DeckyState, DeckyStateContextProvider, useDeckyState } from './components/DeckyState';
 import LegacyPlugin from './components/LegacyPlugin';
@@ -21,8 +12,10 @@ import WithSuspense from './components/WithSuspense';
 import Logger from './logger';
 import { Plugin } from './plugin';
 import RouterHook from './router-hook';
+import { deinitSteamFixes, initSteamFixes } from './steamfixes';
 import { checkForUpdates } from './store';
 import TabsHook from './tabs-hook';
+import OldTabsHook from './tabs-hook.old';
 import Toaster from './toaster';
 import { VerInfo, callUpdaterMethod } from './updater';
 import { getSetting } from './utils/settings';
@@ -32,13 +25,9 @@ const SettingsPage = lazy(() => import('./components/settings'));

 const FilePicker = lazy(() => import('./components/modals/filepicker'));

-declare global {
-  interface Window {}
-}
-
 class PluginLoader extends Logger {
  private plugins: Plugin[] = [];
-  private tabsHook: TabsHook = new TabsHook();
+  private tabsHook: TabsHook | OldTabsHook = document.title == 'SP' ? new OldTabsHook() : new TabsHook();
  // private windowHook: WindowHook = new WindowHook();
  private routerHook: RouterHook = new RouterHook();
  public toaster: Toaster = new Toaster();
@@ -52,6 +41,7 @@ class PluginLoader extends Logger {

  constructor() {
    super(PluginLoader.name);
+    this.tabsHook.init();
    this.log('Initialized');

    const TabBadge = () => {
@@ -90,6 +80,8 @@ class PluginLoader extends Logger {
      );
    });

+    initSteamFixes();
+
    initFilepickerPatches();

    this.updateVersion();
@@ -154,10 +146,10 @@ class PluginLoader extends Logger {
        onCancel={() => {
          // do nothing
        }}
+        strTitle={`Uninstall ${name}`}
+        strOKButtonText={'Uninstall'}
      >
-        <div className={staticClasses.Title} style={{ flexDirection: 'column' }}>
-          Uninstall {name}?
-        </div>
+        Are you sure you want to uninstall {name}?
      </ConfirmModal>,
    );
  }
@@ -182,11 +174,13 @@ class PluginLoader extends Logger {
  public deinit() {
    this.routerHook.removeRoute('/decky/store');
    this.routerHook.removeRoute('/decky/settings');
+    deinitSteamFixes();
    deinitFilepickerPatches();
    this.focusWorkaroundPatch?.unpatch();
  }

  public unloadPlugin(name: string) {
+    console.log('Plugin List: ', this.plugins);
    const plugin = this.plugins.find((plugin) => plugin.name === name || plugin.name === name.replace('$LEGACY_', ''));
    plugin?.onDismount?.();
    this.plugins = this.plugins.filter((p) => p !== plugin);
@@ -233,13 +227,36 @@ class PluginLoader extends Logger {
      },
    });
    if (res.ok) {
-      let plugin_export = await eval(await res.text());
-      let plugin = plugin_export(this.createPluginAPI(name));
-      this.plugins.push({
-        ...plugin,
-        name: name,
-        version: version,
-      });
+      try {
+        let plugin_export = await eval(await res.text());
+        let plugin = plugin_export(this.createPluginAPI(name));
+        this.plugins.push({
+          ...plugin,
+          name: name,
+          version: version,
+        });
+      } catch (e) {
+        this.error('Error loading plugin ' + name, e);
+        const TheError: FC<{}> = () => (
+          <>
+            Error:{' '}
+            <pre>
+              <code>{e instanceof Error ? e.stack : JSON.stringify(e)}</code>
+            </pre>
+            <>
+              Please go to <FaCog style={{ display: 'inline' }} /> in the Decky menu if you need to uninstall this
+              plugin.
+            </>
+          </>
+        );
+        this.plugins.push({
+          name: name,
+          version: version,
+          content: <TheError />,
+          icon: <FaExclamationCircle />,
+        });
+        this.toaster.toast({ title: 'Error loading ' + name, body: '' + e, icon: <FaExclamationCircle /> });
+      }
    } else throw new Error(`${name} frontend_bundle not OK`);
  }

@@ -319,6 +336,7 @@ class PluginLoader extends Logger {
      fetchNoCors(url: string, request: any = {}) {
        let args = { method: 'POST', headers: {} };
        const req = { ...args, ...request, url, data: request.body };
+        req?.body && delete req.body;
        return this.callServerMethod('http_request', req);
      },
      executeInTab(tab: string, runAsync: boolean, code: string) {
@@ -1,7 +1,12 @@
 import { Patch, afterPatch, findModuleChild } from 'decky-frontend-lib';
-import { ReactElement, ReactNode, cloneElement, createElement, memo } from 'react';
+import { FC, ReactElement, ReactNode, cloneElement, createElement, memo } from 'react';
 import type { Route } from 'react-router';

+import {
+  DeckyGlobalComponentsState,
+  DeckyGlobalComponentsStateContextProvider,
+  useDeckyGlobalComponentsState,
+} from './components/DeckyGlobalComponentsState';
 import {
  DeckyRouterState,
  DeckyRouterStateContextProvider,
@@ -22,8 +27,10 @@ class RouterHook extends Logger {
  private memoizedRouter: any;
  private gamepadWrapper: any;
  private routerState: DeckyRouterState = new DeckyRouterState();
+  private globalComponentsState: DeckyGlobalComponentsState = new DeckyGlobalComponentsState();
  private wrapperPatch: Patch;
  private routerPatch?: Patch;
+  public routes?: any[];

  constructor() {
    super('RouterHook');
@@ -42,24 +49,28 @@ class RouterHook extends Logger {

    let Route: new () => Route;
    // Used to store the new replicated routes we create to allow routes to be unpatched.
-    let toReplace = new Map<string, ReactNode>();
-    const DeckyWrapper = ({ children }: { children: ReactElement }) => {
-      const { routes, routePatches } = useDeckyRouterState();
-
-      const routeList = children.props.children[0].props.children;
-
+    const processList = (
+      routeList: any[],
+      routes: Map<string, RouterEntry> | null,
+      routePatches: Map<string, Set<RoutePatch>>,
+      save: boolean,
+    ) => {
+      this.debug('Route list: ', routeList);
+      if (save) this.routes = routeList;
      let routerIndex = routeList.length;
-      if (!routeList[routerIndex - 1]?.length || routeList[routerIndex - 1]?.length !== routes.size) {
-        if (routeList[routerIndex - 1]?.length && routeList[routerIndex - 1].length !== routes.size) routerIndex--;
-        const newRouterArray: ReactElement[] = [];
-        routes.forEach(({ component, props }, path) => {
-          newRouterArray.push(
-            <Route path={path} {...props}>
-              {createElement(component)}
-            </Route>,
-          );
-        });
-        routeList[routerIndex] = newRouterArray;
+      if (routes) {
+        if (!routeList[routerIndex - 1]?.length || routeList[routerIndex - 1]?.length !== routes.size) {
+          if (routeList[routerIndex - 1]?.length && routeList[routerIndex - 1].length !== routes.size) routerIndex--;
+          const newRouterArray: ReactElement[] = [];
+          routes.forEach(({ component, props }, path) => {
+            newRouterArray.push(
+              <Route path={path} {...props}>
+                {createElement(component)}
+              </Route>,
+            );
+          });
+          routeList[routerIndex] = newRouterArray;
+        }
      }
      routeList.forEach((route: Route, index: number) => {
        const replaced = toReplace.get(route?.props?.path as string);
@@ -85,19 +96,40 @@ class RouterHook extends Logger {
          });
        }
      });
+    };
+    let toReplace = new Map<string, ReactNode>();
+    const DeckyWrapper = ({ children }: { children: ReactElement }) => {
+      const { routes, routePatches } = useDeckyRouterState();
+      const mainRouteList = children.props.children[0].props.children;
+      const ingameRouteList = children.props.children[1].props.children; // /appoverlay and /apprunning
+      processList(mainRouteList, routes, routePatches, true);
+      processList(ingameRouteList, null, routePatches, false);
+
      this.debug('Rerendered routes list');
      return children;
    };

+    let renderedComponents: ReactElement[] = [];
+
+    const DeckyGlobalComponentsWrapper = () => {
+      const { components } = useDeckyGlobalComponentsState();
+      if (renderedComponents.length != components.size) {
+        this.debug('Rerendering global components');
+        renderedComponents = Array.from(components.values()).map((GComponent) => <GComponent />);
+      }
+      return <>{renderedComponents}</>;
+    };
+
    this.wrapperPatch = afterPatch(this.gamepadWrapper, 'render', (_: any, ret: any) => {
-      if (ret?.props?.children?.props?.children?.length == 5) {
+      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[2]?.props?.children?.[0]?.type?.type
+          ret.props.children.props.children[idx]?.props?.children?.[0]?.type?.type
            ?.toString()
            ?.includes('GamepadUI.Settings.Root()')
        ) {
          if (!this.router) {
-            this.router = ret.props.children.props.children[2]?.props?.children?.[0]?.type;
+            this.router = ret.props.children.props.children[idx]?.props?.children?.[0]?.type;
            this.routerPatch = afterPatch(this.router, 'type', (_: any, ret: any) => {
              if (!Route)
                Route = ret.props.children[0].props.children.find((x: any) => x.props.path == '/createaccount').type;
@@ -111,7 +143,12 @@ class RouterHook extends Logger {
            this.memoizedRouter = memo(this.router.type);
            this.memoizedRouter.isDeckyRouter = true;
          }
-          ret.props.children.props.children[2].props.children[0].type = this.memoizedRouter;
+          ret.props.children.props.children.push(
+            <DeckyGlobalComponentsStateContextProvider deckyGlobalComponentsState={this.globalComponentsState}>
+              <DeckyGlobalComponentsWrapper />
+            </DeckyGlobalComponentsStateContextProvider>,
+          );
+          ret.props.children.props.children[idx].props.children[0].type = this.memoizedRouter;
        }
      }
      return ret;
@@ -126,6 +163,14 @@ class RouterHook extends Logger {
    return this.routerState.addPatch(path, patch);
  }

+  addGlobalComponent(name: string, component: FC) {
+    this.globalComponentsState.addComponent(name, component);
+  }
+
+  removeGlobalComponent(name: string) {
+    this.globalComponentsState.removeComponent(name);
+  }
+
  removePatch(path: string, patch: RoutePatch) {
    this.routerState.removePatch(path, patch);
  }
@@ -0,0 +1,13 @@
+## What's this?
+
+`steamfixes` contains various fixes and workaround for things Valve has broken that cause Decky issues.
+
+## Current fixes:
+
+- StartRestart() -> StartShutdown(false) override:
+
+  StartRestart() breaks CEF debugging, StartShutdown(false) doesn't. We can safely replace StartRestart() with StartShutdown(false) as gamescope-session will automatically restart the steam client anyway if it shuts down, bypassing the broken restart codepath. Added 12/29/2022
+
+- ExecuteSteamURL UI reload fix:
+
+  Starting sometime in November 2022, Valve broke reloading the Steam UI pages via location.reload, as it won't properly start the UI. We can manually trigger UI startup if we detect no active input contexts by calling `SteamClient.URL.ExecuteSteamURL("steam://open/settings/")` Added 12/29/2022
@@ -0,0 +1,12 @@
+import reloadFix from './reload';
+import restartFix from './restart';
+let fixes: Function[] = [];
+
+export function deinitSteamFixes() {
+  fixes.forEach((deinit) => deinit());
+}
+
+export async function initSteamFixes() {
+  fixes.push(reloadFix());
+  fixes.push(await restartFix());
+}
@@ -0,0 +1,14 @@
+import Logger from '../logger';
+
+const logger = new Logger('ReloadSteamFix');
+
+export default function reloadFix() {
+  // Hack to unbreak the ui when reloading it
+  if (window.FocusNavController?.m_rgAllContexts?.length == 0) {
+    SteamClient.URL.ExecuteSteamURL('steam://open/settings');
+    logger.log('Applied UI reload fix.');
+  }
+
+  // This steamfix does not need to deinit.
+  return () => {};
+}
@@ -0,0 +1,60 @@
+import { Patch, findModuleChild, replacePatch, sleep } from 'decky-frontend-lib';
+
+import Logger from '../logger';
+
+const logger = new Logger('RestartSteamFix');
+
+declare global {
+  interface Window {
+    SteamClient: any;
+    appDetailsStore: any;
+  }
+}
+
+let patch: Patch;
+
+function rePatch() {
+  // If you patch anything on SteamClient within the first few seconds of the client having loaded it will get redefined for some reason, so repatch any of these changes that occur with History.listen or an interval
+  patch = replacePatch(window.SteamClient.User, 'StartRestart', () => SteamClient.User.StartShutdown(false));
+}
+
+export default async function restartFix() {
+  try {
+    rePatch();
+    // TODO type and add to frontend-lib
+    let History: any;
+
+    while (!History) {
+      History = findModuleChild((m) => {
+        if (typeof m !== 'object') return undefined;
+        for (let prop in m) {
+          if (m[prop]?.m_history) return m[prop].m_history;
+        }
+      });
+      if (!History) {
+        logger.debug('Waiting 5s for history to become available.');
+        await sleep(5000);
+      }
+    }
+
+    function repatchIfNeeded() {
+      if (window.SteamClient.User.StartRestart !== patch.patchedFunction) {
+        rePatch();
+      }
+    }
+
+    const unlisten = History.listen(repatchIfNeeded);
+
+    // Just in case
+    setTimeout(repatchIfNeeded, 5000);
+    setTimeout(repatchIfNeeded, 10000);
+
+    return () => {
+      unlisten();
+      patch.unpatch();
+    };
+  } catch (e) {
+    logger.error('Error patching StartRestart', e);
+  }
+  return () => {};
+}
@@ -1,10 +1,16 @@
-import { ConfirmModal, showModal, staticClasses } from 'decky-frontend-lib';
-
 import { Plugin } from './plugin';
+import { getSetting, setSetting } from './utils/settings';
+
+export enum Store {
+  Default,
+  Testing,
+  Custom,
+}

 export interface StorePluginVersion {
  name: string;
  hash: string;
+  artifact: string | undefined | null;
 }

 export interface StorePlugin {
@@ -14,31 +20,49 @@ export interface StorePlugin {
  author: string;
  description: string;
  tags: string[];
-}
-
-export interface LegacyStorePlugin {
-  artifact: string;
-  versions: {
-    [version: string]: string;
-  };
-  author: string;
-  description: string;
-  tags: string[];
+  image_url: string;
 }

 // name: version
 export type PluginUpdateMapping = Map<string, StorePluginVersion>;

-export function getPluginList(): Promise<StorePlugin[]> {
-  return fetch('https://beta.deckbrew.xyz/plugins', {
-    method: 'GET',
-  }).then((r) => r.json());
-}
-
-export function getLegacyPluginList(): Promise<LegacyStorePlugin[]> {
-  return fetch('https://plugins.deckbrew.xyz/get_plugins', {
-    method: 'GET',
-  }).then((r) => r.json());
+export async function getPluginList(): Promise<StorePlugin[]> {
+  let version = await window.DeckyPluginLoader.updateVersion();
+  let store = await getSetting<Store>('store', Store.Default);
+  let customURL = await getSetting<string>('store-url', 'https://plugins.deckbrew.xyz/plugins');
+  let storeURL;
+  if (!store) {
+    console.log('Could not get a default store, using Default.');
+    await setSetting('store-url', Store.Default);
+    return fetch('https://plugins.deckbrew.xyz/plugins', {
+      method: 'GET',
+      headers: {
+        'X-Decky-Version': version.current,
+      },
+    }).then((r) => r.json());
+  } else {
+    switch (+store) {
+      case Store.Default:
+        storeURL = 'https://plugins.deckbrew.xyz/plugins';
+        break;
+      case Store.Testing:
+        storeURL = 'https://testing.deckbrew.xyz/plugins';
+        break;
+      case Store.Custom:
+        storeURL = customURL;
+        break;
+      default:
+        console.error('Somehow you ended up without a standard URL, using the default URL.');
+        storeURL = 'https://plugins.deckbrew.xyz/plugins';
+        break;
+    }
+    return fetch(storeURL, {
+      method: 'GET',
+      headers: {
+        'X-Decky-Version': version.current,
+      },
+    }).then((r) => r.json());
+  }
 }

 export async function installFromURL(url: string) {
@@ -49,35 +73,12 @@ export async function installFromURL(url: string) {
  });
 }

-export function requestLegacyPluginInstall(plugin: LegacyStorePlugin, selectedVer: string) {
-  showModal(
-    <ConfirmModal
-      onOK={() => {
-        window.DeckyPluginLoader.callServerMethod('install_plugin', {
-          name: plugin.artifact,
-          artifact: `https://github.com/${plugin.artifact}/archive/refs/tags/${selectedVer}.zip`,
-          version: selectedVer,
-          hash: plugin.versions[selectedVer],
-        });
-      }}
-      onCancel={() => {
-        // do nothing
-      }}
-    >
-      <div className={staticClasses.Title} style={{ flexDirection: 'column', boxShadow: 'unset' }}>
-        Using legacy plugins
-      </div>
-      You are currently installing a <b>legacy</b> plugin. Legacy plugins are no longer supported and may have issues.
-      Legacy plugins do not support gamepad input. To interact with a legacy plugin, you will need to use the
-      touchscreen.
-    </ConfirmModal>,
-  );
-}
-
 export async function requestPluginInstall(plugin: string, selectedVer: StorePluginVersion) {
+  const artifactUrl =
+    selectedVer.artifact ?? `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/versions/${selectedVer.hash}.zip`;
  await window.DeckyPluginLoader.callServerMethod('install_plugin', {
    name: plugin,
-    artifact: `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/versions/${selectedVer.hash}.zip`,
+    artifact: artifactUrl,
    version: selectedVer.name,
    hash: selectedVer.hash,
  });
@@ -94,7 +95,3 @@ export async function checkForUpdates(plugins: Plugin[]): Promise<PluginUpdateMa
  }
  return updateMap;
 }
-
-export function isLegacyPlugin(plugin: LegacyStorePlugin | StorePlugin): plugin is LegacyStorePlugin {
-  return 'artifact' in plugin;
-}
@@ -0,0 +1,119 @@
+// TabsHook for versions before the Desktop merge
+import { Patch, afterPatch, sleep } from 'decky-frontend-lib';
+import { memo } from 'react';
+
+import NewTabsHook from './tabs-hook';
+
+declare global {
+  interface Array<T> {
+    __filter: any;
+  }
+}
+
+const isTabsArray = (tabs: any) => {
+  const length = tabs.length;
+  return length >= 7 && tabs[length - 1]?.tab;
+};
+
+class TabsHook extends NewTabsHook {
+  // private keys = 7;
+  private quickAccess: any;
+  private tabRenderer: any;
+  private memoizedQuickAccess: any;
+  private cNode: any;
+
+  private qAPTree: any;
+  private rendererTree: any;
+
+  private cNodePatch?: Patch;
+
+  constructor() {
+    super();
+
+    this.log('Initialized stable TabsHook');
+  }
+
+  init() {
+    const self = this;
+    const tree = (document.getElementById('root') as any)._reactRootContainer._internalRoot.current;
+    let scrollRoot: any;
+    async function findScrollRoot(currentNode: any, iters: number): Promise<any> {
+      if (iters >= 30) {
+        self.error(
+          'Scroll root was not found before hitting the recursion limit, a developer will need to increase the limit.',
+        );
+        return null;
+      }
+      currentNode = currentNode?.child;
+      if (currentNode?.type?.prototype?.RemoveSmartScrollContainer) {
+        self.log(`Scroll root was found in ${iters} recursion cycles`);
+        return currentNode;
+      }
+      if (!currentNode) return null;
+      if (currentNode.sibling) {
+        let node = await findScrollRoot(currentNode.sibling, iters + 1);
+        if (node !== null) return node;
+      }
+      return await findScrollRoot(currentNode, iters + 1);
+    }
+    (async () => {
+      scrollRoot = await findScrollRoot(tree, 0);
+      while (!scrollRoot) {
+        this.log('Failed to find scroll root node, reattempting in 5 seconds');
+        await sleep(5000);
+        scrollRoot = await findScrollRoot(tree, 0);
+      }
+      let newQA: any;
+      let newQATabRenderer: any;
+      this.cNodePatch = afterPatch(scrollRoot.stateNode, 'render', (_: any, ret: any) => {
+        if (!this.quickAccess && ret.props.children.props.children[4]) {
+          this.quickAccess = ret?.props?.children?.props?.children[4].type;
+          newQA = (...args: any) => {
+            const ret = this.quickAccess.type(...args);
+            if (ret) {
+              if (!newQATabRenderer) {
+                this.tabRenderer = ret.props.children[1].children.type;
+                newQATabRenderer = (...qamArgs: any[]) => {
+                  const oFilter = Array.prototype.filter;
+                  Array.prototype.filter = function (...args: any[]) {
+                    if (isTabsArray(this)) {
+                      self.render(this, qamArgs[0].visible);
+                    }
+                    // @ts-ignore
+                    return oFilter.call(this, ...args);
+                  };
+                  // TODO remove array hack entirely and use this instead const tabs = ret.props.children.props.children[0].props.children[1].props.children[0].props.children[0].props.tabs
+                  const ret = this.tabRenderer(...qamArgs);
+                  Array.prototype.filter = oFilter;
+                  return ret;
+                };
+              }
+              this.rendererTree = ret.props.children[1].children;
+              ret.props.children[1].children.type = newQATabRenderer;
+            }
+            return ret;
+          };
+          this.memoizedQuickAccess = memo(newQA);
+          this.memoizedQuickAccess.isDeckyQuickAccess = true;
+        }
+        if (ret.props.children.props.children[4]) {
+          this.qAPTree = ret.props.children.props.children[4];
+          ret.props.children.props.children[4].type = this.memoizedQuickAccess;
+        }
+        return ret;
+      });
+      this.cNode = scrollRoot;
+      this.cNode.stateNode.forceUpdate();
+      this.log('Finished initial injection');
+    })();
+  }
+
+  deinit() {
+    this.cNodePatch?.unpatch();
+    if (this.qAPTree) this.qAPTree.type = this.quickAccess;
+    if (this.rendererTree) this.rendererTree.type = this.tabRenderer;
+    if (this.cNode) this.cNode.stateNode.forceUpdate();
+  }
+}
+
+export default TabsHook;
@@ -1,5 +1,5 @@
-import { Patch, QuickAccessTab, afterPatch, sleep } from 'decky-frontend-lib';
-import { memo } from 'react';
+// TabsHook for versions after the Desktop merge
+import { Patch, QuickAccessTab, afterPatch, findInReactTree, sleep } from 'decky-frontend-lib';

 import { QuickAccessVisibleStateProvider } from './components/QuickAccessVisibleState';
 import Logger from './logger';
@@ -8,16 +8,8 @@ declare global {
  interface Window {
    __TABS_HOOK_INSTANCE: any;
  }
-  interface Array<T> {
-    __filter: any;
-  }
 }

-const isTabsArray = (tabs: any) => {
-  const length = tabs.length;
-  return length >= 7 && tabs[length - 1]?.tab;
-};
-
 interface Tab {
  id: QuickAccessTab | number;
  title: any;
@@ -28,15 +20,8 @@ interface Tab {
 class TabsHook extends Logger {
  // private keys = 7;
  tabs: Tab[] = [];
-  private quickAccess: any;
-  private tabRenderer: any;
-  private memoizedQuickAccess: any;
-  private cNode: any;
-
-  private qAPTree: any;
-  private rendererTree: any;
-
-  private cNodePatch?: Patch;
+  private qAMRoot?: any;
+  private qamPatch?: Patch;

  constructor() {
    super('TabsHook');
@@ -44,86 +29,89 @@ class TabsHook extends Logger {
    this.log('Initialized');
    window.__TABS_HOOK_INSTANCE?.deinit?.();
    window.__TABS_HOOK_INSTANCE = this;
+  }

-    const self = this;
+  init() {
    const tree = (document.getElementById('root') as any)._reactRootContainer._internalRoot.current;
-    let scrollRoot: any;
-    async function findScrollRoot(currentNode: any, iters: number): Promise<any> {
-      if (iters >= 30) {
-        self.error(
-          'Scroll root was not found before hitting the recursion limit, a developer will need to increase the limit.',
-        );
+    let qAMRoot: any;
+    const findQAMRoot = (currentNode: any, iters: number): any => {
+      if (iters >= 55) {
+        // currently 45
        return null;
      }
-      currentNode = currentNode?.child;
-      if (currentNode?.type?.prototype?.RemoveSmartScrollContainer) {
-        self.log(`Scroll root was found in ${iters} recursion cycles`);
+      if (
+        typeof currentNode?.memoizedProps?.visible == 'boolean' &&
+        currentNode?.type?.toString()?.includes('QuickAccessMenuBrowserView')
+      ) {
+        this.log(`QAM root was found in ${iters} recursion cycles`);
        return currentNode;
      }
-      if (!currentNode) return null;
-      if (currentNode.sibling) {
-        let node = await findScrollRoot(currentNode.sibling, iters + 1);
+      if (currentNode.child) {
+        let node = findQAMRoot(currentNode.child, iters + 1);
        if (node !== null) return node;
      }
-      return await findScrollRoot(currentNode, iters + 1);
-    }
-    (async () => {
-      scrollRoot = await findScrollRoot(tree, 0);
-      while (!scrollRoot) {
-        this.log('Failed to find scroll root node, reattempting in 5 seconds');
-        await sleep(5000);
-        scrollRoot = await findScrollRoot(tree, 0);
+      if (currentNode.sibling) {
+        let node = findQAMRoot(currentNode.sibling, iters + 1);
+        if (node !== null) return node;
      }
-      let newQA: any;
-      let newQATabRenderer: any;
-      this.cNodePatch = afterPatch(scrollRoot.stateNode, 'render', (_: any, ret: any) => {
-        if (!this.quickAccess && ret.props.children.props.children[4]) {
-          this.quickAccess = ret?.props?.children?.props?.children[4].type;
-          newQA = (...args: any) => {
-            const ret = this.quickAccess.type(...args);
-            if (ret) {
-              if (!newQATabRenderer) {
-                this.tabRenderer = ret.props.children[1].children.type;
-                newQATabRenderer = (...qamArgs: any[]) => {
-                  const oFilter = Array.prototype.filter;
-                  Array.prototype.filter = function (...args: any[]) {
-                    if (isTabsArray(this)) {
-                      self.render(this, qamArgs[0].visible);
-                    }
-                    // @ts-ignore
-                    return oFilter.call(this, ...args);
-                  };
-                  // TODO remove array hack entirely and use this instead const tabs = ret.props.children.props.children[0].props.children[1].props.children[0].props.children[0].props.tabs
-                  const ret = this.tabRenderer(...qamArgs);
-                  Array.prototype.filter = oFilter;
-                  return ret;
-                };
+      return null;
+    };
+    (async () => {
+      qAMRoot = findQAMRoot(tree, 0);
+      while (!qAMRoot) {
+        this.error(
+          'Failed to find QAM root node, reattempting in 5 seconds. A developer may need to increase the recursion limit.',
+        );
+        await sleep(5000);
+        qAMRoot = findQAMRoot(tree, 0);
+      }
+      this.qAMRoot = qAMRoot;
+      let patchedInnerQAM: any;
+      this.qamPatch = afterPatch(qAMRoot.return, 'type', (_: any, ret: any) => {
+        try {
+          if (!qAMRoot?.child) {
+            qAMRoot = findQAMRoot(tree, 0);
+            this.qAMRoot = qAMRoot;
+          }
+          if (qAMRoot?.child && !qAMRoot?.child?.type?.decky) {
+            afterPatch(qAMRoot.child, 'type', (_: any, ret: any) => {
+              try {
+                const qamTabsRenderer = findInReactTree(ret, (x) => x?.props?.onFocusNavDeactivated);
+                if (patchedInnerQAM) {
+                  qamTabsRenderer.type = patchedInnerQAM;
+                } else {
+                  afterPatch(qamTabsRenderer, 'type', (innerArgs: any, ret: any) => {
+                    const tabs = findInReactTree(ret, (x) => x?.props?.tabs);
+                    this.render(tabs.props.tabs, innerArgs[0].visible);
+                    return ret;
+                  });
+                  patchedInnerQAM = qamTabsRenderer.type;
+                }
+              } catch (e) {
+                this.error('Error patching QAM inner', e);
              }
-              this.rendererTree = ret.props.children[1].children;
-              ret.props.children[1].children.type = newQATabRenderer;
-            }
-            return ret;
-          };
-          this.memoizedQuickAccess = memo(newQA);
-          this.memoizedQuickAccess.isDeckyQuickAccess = true;
-        }
-        if (ret.props.children.props.children[4]) {
-          this.qAPTree = ret.props.children.props.children[4];
-          ret.props.children.props.children[4].type = this.memoizedQuickAccess;
+              return ret;
+            });
+            qAMRoot.child.type.decky = true;
+            qAMRoot.child.alternate.type = qAMRoot.child.type;
+          }
+        } catch (e) {
+          this.error('Error patching QAM', e);
        }
+
        return ret;
      });
-      this.cNode = scrollRoot;
-      this.cNode.stateNode.forceUpdate();
+
+      if (qAMRoot.return.alternate) {
+        qAMRoot.return.alternate.type = qAMRoot.return.type;
+      }
      this.log('Finished initial injection');
    })();
  }

  deinit() {
-    this.cNodePatch?.unpatch();
-    if (this.qAPTree) this.qAPTree.type = this.quickAccess;
-    if (this.rendererTree) this.rendererTree.type = this.tabRenderer;
-    if (this.cNode) this.cNode.stateNode.forceUpdate();
+    this.qamPatch?.unpatch();
+    this.qAMRoot.return.alternate.type = this.qAMRoot.return.type;
  }

  add(tab: Tab) {
@@ -137,12 +125,24 @@ class TabsHook extends Logger {
  }

  render(existingTabs: any[], visible: boolean) {
+    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);
+      }
+      return;
+    }
    for (const { title, icon, content, id } of this.tabs) {
      existingTabs.push({
        key: id,
        title,
        tab: icon,
-        panel: <QuickAccessVisibleStateProvider visible={visible}>{content}</QuickAccessVisibleStateProvider>,
+        decky: true,
+        panel: (
+          <QuickAccessVisibleStateProvider initial={visible} setter={[]}>
+            {content}
+          </QuickAccessVisibleStateProvider>
+        ),
      });
    }
  }
@@ -1,4 +1,4 @@
-import { Patch, ToastData, afterPatch, findInReactTree, findModuleChild, sleep } from 'decky-frontend-lib';
+import { Module, Patch, ToastData, afterPatch, findInReactTree, findModuleChild, sleep } from 'decky-frontend-lib';
 import { ReactNode } from 'react';

 import Toast from './components/Toast';
@@ -7,18 +7,24 @@ import Logger from './logger';
 declare global {
  interface Window {
    __TOASTER_INSTANCE: any;
+    settingsStore: any;
    NotificationStore: any;
  }
 }

 class Toaster extends Logger {
-  private instanceRetPatch?: Patch;
+  // private routerHook: RouterHook;
+  // private toasterState: DeckyToasterState = new DeckyToasterState();
  private node: any;
-  private settingsModule: any;
-  private ready: boolean = false;
+  private rNode: any;
+  private audioModule: any;
+  private finishStartup?: () => void;
+  private ready: Promise<void> = new Promise((res) => (this.finishStartup = res));
+  private toasterPatch?: Patch;

  constructor() {
    super('Toaster');
+    // this.routerHook = routerHook;

    window.__TOASTER_INSTANCE?.deinit?.();
    window.__TOASTER_INSTANCE = this;
@@ -26,87 +32,154 @@ class Toaster extends Logger {
  }

  async init() {
+    // this.routerHook.addGlobalComponent('DeckyToaster', () => (
+    //   <DeckyToasterStateContextProvider deckyToasterState={this.toasterState}>
+    //     <DeckyToaster />
+    //   </DeckyToasterStateContextProvider>
+    // ));
    let instance: any;
-
-    while (true) {
-      instance = findInReactTree(
-        (document.getElementById('root') as any)._reactRootContainer._internalRoot.current,
-        (x) => x?.memoizedProps?.className?.startsWith?.('toastmanager_ToastPlaceholder'),
+    const tree = (document.getElementById('root') as any)._reactRootContainer._internalRoot.current;
+    const findToasterRoot = (currentNode: any, iters: number): any => {
+      if (iters >= 50) {
+        // currently 40
+        return null;
+      }
+      if (currentNode?.memoizedProps?.className?.startsWith?.('toastmanager_ToastPlaceholder')) {
+        this.log(`Toaster root was found in ${iters} recursion cycles`);
+        return currentNode;
+      }
+      if (currentNode.sibling) {
+        let node = findToasterRoot(currentNode.sibling, iters + 1);
+        if (node !== null) return node;
+      }
+      if (currentNode.child) {
+        let node = findToasterRoot(currentNode.child, iters + 1);
+        if (node !== null) return node;
+      }
+      return null;
+    };
+    instance = findToasterRoot(tree, 0);
+    while (!instance) {
+      this.error(
+        'Failed to find Toaster root node, reattempting in 5 seconds. A developer may need to increase the recursion limit.',
      );
-      if (instance) break;
-      this.debug('finding instance');
-      await sleep(2000);
+      await sleep(5000);
+      instance = findToasterRoot(tree, 0);
    }
-
-    this.node = instance.sibling.child;
+    this.node = instance.return;
+    this.rNode = this.node.return;
    let toast: any;
    let renderedToast: ReactNode = null;
-    this.node.stateNode.render = (...args: any[]) => {
-      const ret = this.node.stateNode.__proto__.render.call(this.node.stateNode, ...args);
-      if (ret) {
-        this.instanceRetPatch = afterPatch(ret, 'type', (_: any, ret: any) => {
-          if (ret?.props?.children[1]?.children?.props) {
-            const currentToast = ret.props.children[1].children.props.notification;
-            if (currentToast?.decky) {
-              if (currentToast == toast) {
-                ret.props.children[1].children = renderedToast;
+    let innerPatched: any;
+    const repatch = () => {
+      if (this.node && !this.node.type.decky) {
+        this.toasterPatch = afterPatch(this.node, 'type', (_: any, ret: any) => {
+          const inner = findInReactTree(ret.props.children, (x) => x?.props?.onDismiss);
+          if (innerPatched) {
+            inner.type = innerPatched;
+          } else {
+            afterPatch(inner, 'type', (innerArgs: any, ret: any) => {
+              const currentToast = innerArgs[0]?.notification;
+              if (currentToast?.decky) {
+                if (currentToast == toast) {
+                  ret.props.children = renderedToast;
+                } else {
+                  toast = currentToast;
+                  renderedToast = <Toast toast={toast.data} />;
+                  ret.props.children = renderedToast;
+                }
              } else {
-                toast = currentToast;
-                renderedToast = <Toast toast={toast} />;
-                ret.props.children[1].children = renderedToast;
+                toast = null;
+                renderedToast = null;
              }
-            } else {
-              toast = null;
-              renderedToast = null;
-            }
+              return ret;
+            });
+            innerPatched = inner.type;
          }
          return ret;
        });
-        this.node.stateNode.shouldComponentUpdate = () => {
-          return false;
-        };
-        delete this.node.stateNode.render;
+        this.node.type.decky = true;
+        this.node.alternate.type = this.node.type;
      }
+    };
+    const oRender = this.rNode.stateNode.__proto__.render;
+    let int: NodeJS.Timer | undefined;
+    this.rNode.stateNode.render = (...args: any[]) => {
+      const ret = oRender.call(this.rNode.stateNode, ...args);
+      if (ret && !this?.node?.return?.return) {
+        clearInterval(int);
+        int = setInterval(() => {
+          const n = findToasterRoot(tree, 0);
+          if (n?.return) {
+            clearInterval(int);
+            this.node = n.return;
+            this.rNode = this.node.return;
+            repatch();
+          } else {
+            this.error('Failed to re-grab Toaster node, trying again...');
+          }
+        }, 1200);
+      }
+      repatch();
      return ret;
-    });
-    this.settingsModule = findModuleChild((m) => {
+    };
+
+    this.rNode.stateNode.shouldComponentUpdate = () => true;
+    this.rNode.stateNode.forceUpdate();
+    delete this.rNode.stateNode.shouldComponentUpdate;
+
+    this.audioModule = findModuleChild((m: Module) => {
      if (typeof m !== 'object') return undefined;
      for (let prop in m) {
-        if (typeof m[prop]?.settings && m[prop]?.communityPreferences) return m[prop];
+        try {
+          if (m[prop].PlayNavSound && m[prop].RegisterCallbackOnPlaySound) return m[prop];
+        } catch {
+          return undefined;
+        }
      }
    });
+
    this.log('Initialized');
-    this.ready = true;
+    this.finishStartup?.();
  }

  async toast(toast: ToastData) {
-    while (!this.ready) {
-      await sleep(100);
-    }
-    const settings = this.settingsModule?.settings;
+    // toast.duration = toast.duration || 5e3;
+    // this.toasterState.addToast(toast);
+    await this.ready;
    let toastData = {
      nNotificationID: window.NotificationStore.m_nNextTestNotificationID++,
      rtCreated: Date.now(),
-      eType: 15,
-      nToastDurationMS: toast.duration || 5e3,
+      eType: toast.eType || 11,
+      nToastDurationMS: toast.duration || (toast.duration = 5e3),
      data: toast,
      decky: true,
    };
    // @ts-ignore
    toastData.data.appid = () => 0;
+    if (toast.sound === undefined) toast.sound = 6;
+    if (toast.playSound === undefined) toast.playSound = true;
+    if (toast.showToast === undefined) toast.showToast = true;
    if (
-      (settings?.bDisableAllToasts && !toast.critical) ||
-      (settings?.bDisableToastsInGame && !toast.critical && window.NotificationStore.BIsUserInGame())
+      (window.settingsStore.settings.bDisableAllToasts && !toast.critical) ||
+      (window.settingsStore.settings.bDisableToastsInGame &&
+        !toast.critical &&
+        window.NotificationStore.BIsUserInGame())
    )
      return;
-    window.NotificationStore.m_rgNotificationToasts.push(toastData);
-    window.NotificationStore.DispatchNextToast();
+    if (toast.playSound) this.audioModule?.PlayNavSound(toast.sound);
+    if (toast.showToast) {
+      window.NotificationStore.m_rgNotificationToasts.push(toastData);
+      window.NotificationStore.DispatchNextToast();
+    }
  }

  deinit() {
-    this.instanceRetPatch?.unpatch();
-    this.node && delete this.node.stateNode.shouldComponentUpdate;
-    this.node && this.node.stateNode.forceUpdate();
+    this.toasterPatch?.unpatch();
+    this.node.alternate.type = this.node.type;
+    delete this.rNode.stateNode.render;
+    this.ready = new Promise((res) => (this.finishStartup = res));
+    // this.routerHook.removeGlobalComponent('DeckyToaster');
  }
 }

@@ -1,7 +1,7 @@
 export enum Branches {
  Release,
  Prerelease,
-  Nightly,
+  // Testing,
 }

 export interface DeckyUpdater {
@@ -0,0 +1,7 @@
+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;
+}
@@ -18,6 +18,6 @@
    "allowSyntheticDefaultImports": true,
    "skipLibCheck": true
  },
-  "include": ["src"],
+  "include": ["src", "index.d.ts"],
  "exclude": ["node_modules"]
 }
@@ -2,4 +2,4 @@ aiohttp==3.8.1
 aiohttp-jinja2==1.5.0
 aiohttp_cors==0.7.0
 watchdog==2.1.7
-certifi==2022.6.15
+certifi==2022.12.7
Author	SHA1	Message	Date
Sky Leite	f1db083749	Merge branch 'main' into python-lint-format-test	2023-02-04 00:42:38 -03:00
Sky Leite	0b718daa47	Add lint job to build workflow (#363 ) * Add lint job to build workflow * Add prettier-plugin-import-sort * Install prettier plugins before linting * Use lint script from package.json * Move linters to separate workflow * Remove Python and Shell linters * Remove popd * Test that prettier properly fails the lint job	2023-02-03 19:40:29 -08:00
Sky Leite	897e1773a5	Disable SyntaxError lint rule due to ruff not supporting pattern matching	2023-02-04 00:31:42 -03:00
Sky Leite	4e92d4bfc5	Fix unescaped curly braces in javascript formatting This would previously throw an error due to `format` interpreting the curly braces as placeholders	2023-02-04 00:29:34 -03:00
Sky Leite	1edcc09020	Fix F821 lint rule	2023-02-04 00:22:17 -03:00
Sky Leite	e3e1cf2df7	Fix F811 linter rule get_user_group was defined twice, so I merged both definitions	2023-02-04 00:21:31 -03:00
Sky Leite	93587fe33b	Fix E722 linter rule	2023-02-04 00:12:00 -03:00
Sky Leite	8fab487153	Add python linting actions	2023-02-04 00:06:53 -03:00
Sky Leite	b6fce46081	Fix most formatting and linting errors	2023-02-03 23:59:43 -03:00
Sky Leite	e20fd5042c	Revert "Test that prettier properly fails the lint job" This reverts commit `1f596e5a10`.	2023-02-03 10:36:05 -03:00
Sky Leite	1f596e5a10	Test that prettier properly fails the lint job	2023-02-03 10:34:50 -03:00
Sky Leite	6edc3bb658	Remove popd	2023-02-03 10:31:07 -03:00
Sky Leite	b33d44c53d	Remove Python and Shell linters	2023-02-03 10:29:40 -03:00
Sky Leite	1379a40a89	Move linters to separate workflow	2023-02-03 10:07:16 -03:00
Sky Leite	d48fc885a3	Use lint script from package.json	2023-02-03 09:51:28 -03:00
Sky Leite	7675775527	Install prettier plugins before linting	2023-02-02 18:59:23 -03:00
Sky Leite	1320b13507	Add prettier-plugin-import-sort	2023-02-02 18:50:33 -03:00
Sky Leite	52777bc2a4	Add lint job to build workflow	2023-02-02 18:46:57 -03:00
EMERALD	0929b9c5cb	Specify linux/amd64 Docker architecture (#356 )	2023-02-01 17:17:24 -08:00
EMERALD	43b2269ea7	Fix UI inconsistencies, various improvements (#357 ) * Make version gray in plugin list * Settings/store icons together & plugin list fix * Navigation name/icon improvements * Decky settings overhaul and other fixes - Revert the tab icon to a plug - Rename DeckyFlat function to DeckyIcon - Add DialogBody to settings pages to improve scrolling - Add remote debugging settings to the developer settings - Fix React devtools interactions to work more easily - Add spacing to React devtools description - Specify Decky vs. plugin store - Compact version information by update button - Add current version to bottom of settings - Remove unnecessary settings icons - Change CEF debugger icon to Chrome (bug icon too generic, is Chromium) - Make buttons/dropdowns in settings have fixed width - Make download icon act/appear similar to Valve's for Deck * Final UI adjustments * Switch plugin settings icon to plug	2023-02-01 17:16:42 -08:00
Party Wumpus	0c4e27cd34	[readme] add installer issue to common issues (#359 )	2023-02-01 12:31:44 -08:00
TrainDoctor	36cf85b08a	Comment out un-needed pprint usage	2023-01-29 15:27:52 -08:00
TrainDoctor	994da868af	Add python logging to browser and plugin	2023-01-29 15:16:16 -08:00
TrainDoctor	2e53fb217a	Add better handling for unloading of plugins	2023-01-29 13:59:02 -08:00
Philipp Richter	c2b76d9099	Expose useful env vars to plugin processes (#349 ) * recommended paths for storing data * improve helper functions	2023-01-22 16:54:05 -08:00
TrainDoctor	c05e8f9ae0	Update build.yml	2023-01-22 16:33:06 -08:00
TrainDoctor	2dce0646bd	Update README.md	2023-01-22 16:29:27 -08:00
Beebles	6569f1b268	Fix http_request not allowing bodys (#352 )	2023-01-22 14:33:26 -08:00
EMERALD	3ebaac6752	Store and plugin installation visual improvements (#343 ) * Redesign store, add comments for filtering * Improve installation/uninstallation modals * Fix store comment to be easier to fix * Add source code info to about page	2023-01-19 18:00:42 -08:00
dependabot[bot]	cbbd564860	Bump certifi from 2022.6.15 to 2022.12.7 (#345 ) Bumps [certifi](https://github.com/certifi/python-certifi) from 2022.6.15 to 2022.12.7. - [Release notes](https://github.com/certifi/python-certifi/releases) - [Commits](https://github.com/certifi/python-certifi/compare/2022.06.15...2022.12.07) --- updated-dependencies: - dependency-name: certifi dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-01-19 17:54:50 -08:00
TrainDoctor	635edf7f5b	fix releases being called prereleases	2023-01-17 15:37:43 -08:00
Nox	1b6e18bcb3	Updated store CSS (#305 ) * PluginCard Store CSS Update * Fixing CSS * Updated * Removed padding	2023-01-16 14:43:16 -08:00
AAGaming	0ad0016c62	move the chown	2023-01-16 14:44:16 -05:00
AAGaming	a2716449f9	fix missing await on chown_plugin_dir	2023-01-16 14:17:27 -05:00
AAGaming	649eed89c9	bump dfl	2023-01-16 09:13:30 -05:00
AAGaming	83680fffa2	indicate to DFL that the router has shim applied	2023-01-16 09:12:52 -05:00
AAGaming	d695b90baf	fix React DevTools again	2023-01-15 21:22:54 -05:00
TrainDoctor	5fdcc56409	Aa/bump dfl navigation fix jan2023 (#341 ) * fix React DevTools * bump DFL to fix Navigation * Bump DFL and add shims * fix shims not applying due to timing issue Co-authored-by: AAGaming <aa@mail.catvibers.me>	2023-01-15 17:40:47 -08:00
Party Wumpus	915997d149	[readme] change terminal commands to point at decky-installer (#342 ) * update readme to point at decky-installer for konsole scripts * test change to make dark/light theme work properly * Update README.md * Update README.md * revert <picture> changes as they didn't actually work	2023-01-14 07:49:23 -08:00
Party Wumpus	e8b4c4a307	Fix the download button (#330 ) * Remove .desktop file from build.yml * Make download button link to decky-installer repo * Point download button to the .desktop file not the .sh file woops * Delete decky_installer.desktop * Delete user_install_script.sh	2023-01-09 10:16:20 -08:00
Party Wumpus	e92b66068a	Use the new installer in the readme instructions (#324 )	2023-01-08 13:16:44 -08:00
AAGaming	b72b327610	Fix reloading UI on updates and restarting steam (#303 )	2023-01-07 17:33:28 -08:00
Party Wumpus	b8fdff8093	Add feature requests as an issue template (#318 ) * Create feature_request.yml * Update feature_request.yml	2023-01-06 09:23:05 -08:00
AAGaming	880b4c2f8f	maybe working fix for jan 05 beta (#316 )	2023-01-05 20:00:48 -08:00
TrainDoctor	34af340009	Update config.yml	2023-01-05 18:50:10 -08:00
Party Wumpus	80b6115f6f	User Friendlier Installer (#297 ) * Add files via upload * Rename EasierInstallScript.sh to user_install_script.sh * Add files via upload * change so it works on deck instead of my desktop * Update decky_installer.desktop * make auto password setter work without the password * Update user_install_script.sh * make installer exit properly if user does not accept temp password * Update user_install_script.sh * add uninstall option * Update user_install_script.sh * Update user_install_script.sh * Update user_install_script.sh * "optimisation" * Update user_install_script.sh * Add sizing to all zenity prompts * "optimization" part 2 * "Program now runs 50% faster" :) * Update user_install_script.sh * Update user_install_script.sh * Update user_install_script.sh * Change text in branch selection in installer 'Select Branch' if choosing between release and prerelease 'Select Option' if choosing between release, prerelease and uninstall * .desktop file points at where script is going to be * add comments * Change "installing" to "uninstalling" * change it to ask for "sudo/admin" password * Add secondary loading bar for download progress Shamelessly stolen (with permission) from emudeck, who stole it from a random blog No I don't know how that line works, and I don't think I want to. * Make uninstaller tell user they can exit * add default text to the download bar just in case * silence script download * silence password check	2023-01-02 08:52:11 -08:00
Party Wumpus	3bed83697e	Add cef debugging to the installer scripts (#310 ) * Update install_prerelease.sh * Update install_release.sh	2023-01-02 08:46:46 -08:00
Party Wumpus	0ffef6e4bf	Better bug report format (#312 ) * Add files via upload * Delete bug_report.md * Update bug_report.yml * Update bug_report.yml * Update bug_report.yml * Update bug_report.yml * Update bug_report.yml * Update bug_report.yml * Update bug_report.yml	2023-01-02 08:45:42 -08:00
AAGaming	8810a014f3	somehow accidentally left this in	2022-12-29 13:11:11 -05:00
AAGaming	385552451b	shut down steam instead of restarting it to avoid broken CEF debugger (gamescope will restart stean for us instead)	2022-12-28 12:24:28 -05:00
AAGaming	c2c9d11c66	fix broken valveInternal when on a multi-user deck	2022-12-28 12:23:42 -05:00
Nik	0474095a40	Potentially fix locale issues (#284 )	2022-12-16 06:23:04 -08:00
AAGaming	346f80beb3	bump DFL to fix modals, Router -> Navigation in some places	2022-12-15 21:16:22 -05:00
TrainDoctor	2a6bf75f02	Move back to python 3.10.2 in CI	2022-12-10 15:26:51 -08:00
jurassicplayer	f73918c902	feat(MoreCustomizableToasts): Allow plugin developers to customize some toast properties (#268 ) * Use settingsStore directly * Change toast etype, add showToast/playSound * Update DFL and rebase	2022-12-10 15:09:21 -08:00
TrainDoctor	ea35af2050	Update build.yml	2022-12-08 15:18:44 -08:00
NGnius (Graham)	6232e3da58	Add custom CDN support for custom stores (#269 ) * Add custom CDN support for custom stores * Update Python for CI	2022-12-07 16:27:32 -08:00
TrainDoctor	35e46f9ccb	Update build.yml	2022-12-07 14:31:09 -08:00
TrainDoctor	2b9a80c151	Update install_prerelease.sh	2022-12-04 19:05:29 -08:00
TrainDoctor	a90ed38c89	Update install_release.sh	2022-12-04 19:05:16 -08:00
TrainDoctor	3653cf5640	Update plugin_loader-release.service	2022-12-04 19:05:01 -08:00
TrainDoctor	0db45ca71e	Update plugin_loader-prerelease.service	2022-12-04 19:04:46 -08:00
AAGaming	16681fabb5	fix http requests	2022-11-19 22:33:51 -05:00
AAGaming	c210523a22	fix handleWarning in rollup config	2022-11-19 20:07:08 -05:00
Marco Rodolfi	5d8601347a	Fix for wrong path for settings json files (#258 ) Co-authored-by: AAGaming <aa@mail.catvibers.me>	2022-11-19 19:34:38 -05:00
AAGaming	1e02fcf394	fix broken trycatch causing occasional injection failures	2022-11-19 19:22:30 -05:00
TrainDoctor	f923306a7f	Update issue templates	2022-11-19 14:19:33 -08:00
TrainDoctor	478fe32527	Revert "Fix for setting json files ending up in ~/homebrew" This reverts commit `aec7063139`.	2022-11-15 15:01:26 -08:00
AAGaming	50764600c8	Refactoring in preparation for WebSockets (#254 ) * Fix injector race conditions * add some more tasks * hide useless rollup warnings * goodbye to clientsession errors * completely fix desktop mode switch race condition * fix typos and TS warning in plugin error handler * fix chown error * start debugger if needed and not already started * fix get_steam_resource for the like 2 legacy plugins still using it lol * add ClientOSError to get_tabs error handling	2022-11-15 13:44:24 -08:00
TrainDoctor	aec7063139	Fix for setting json files ending up in ~/homebrew	2022-11-13 17:48:46 -08:00
TrainDoctor	c9ee98e0c0	Fix desktop mode loop (#253 ) * fix desktop mode making injector get stuck * Fix imports and variable references * Get data for all messages Co-authored-by: AAGaming <aa@mail.catvibers.me>	2022-11-13 17:36:00 -08:00
TrainDoctor	093b064a4e	Inline icon propely	2022-11-13 16:44:15 -08:00
TrainDoctor	2955681975	Show plugin as error and give guidance for uninstall	2022-11-13 16:31:05 -08:00
TrainDoctor	de42639726	Add errored plugins to plugin array for uninstalls	2022-11-13 16:01:06 -08:00
TrainDoctor	17742e947a	Fix import revert	2022-11-08 17:05:10 -08:00
TrainDoctor	898271b33d	Revert "Disable store selection until PRs actually deploy to testing" This reverts commit `d389b403b5`.	2022-11-06 15:37:02 -08:00
AAGaming	b44896524f	Fix on steam client beta, restart steam instead of reloading tab since that is broken	2022-11-04 21:49:05 -04:00
TrainDoctor	db7bb236d8	facepalm	2022-10-30 18:45:18 -07:00
TrainDoctor	5e3de747d3	Systemd service updating (#240 ) * Add services and updated installer files * Loader updates service file during update! * Testing update branch doesn't exist lol * Update to dfl 3.7.12 * Fix services and add working service updater * Revert services but replace their aliases * Fix install scripts as well * Move leftover service files to .systemd dir * No wonder it's not trimming the file... * fix whitespace * Remove unused imports * Remove another un-used import Co-authored-by: AAGaming <aa@mail.catvibers.me>	2022-10-30 16:37:19 -07:00
TrainDoctor	d389b403b5	Disable store selection until PRs actually deploy to testing	2022-10-30 10:38:49 -07:00
TrainDoctor	bace5143d2	Merge Tabs and Injection Fixes, bring back native Valve toaster (#238 ) * Bring back component patch-based tabshook * better injection point * finally fix dumb loading error * fix QAM injection breaking after lock * shut up typescript * fix lock screen focusing issues * Bring back the Valve toaster! * Add support for stable steamos * fix focus bug on lock screen but actually * oops: remove extra console log * shut up typescript again * better fix for lockscreen bug * better probably * actually fix focus issues (WTF) Co-authored-by: AAGaming <aa@mail.catvibers.me>	2022-10-30 10:32:05 -07:00
suchmememanyskill	f5fc205384	Add timeout to get tabs request, wait for network online target before booting decky (#239 ) * Add timeout to tabs get request * Wait for network interfaces to be ready before booting decky	2022-10-29 15:13:19 -07:00
TrainDoctor	4d30339c34	Add StoreSelect component	2022-10-29 15:03:21 -07:00
TrainDoctor	5996a3f88b	Remove unused nightly and tweak prerelease	2022-10-29 12:43:38 -07:00
AAGaming	1b635c74b1	chore(readme): link change for store, port clarification	2022-10-29 00:55:19 -04:00
AAGaming	a9bd5079de	remove ver suffix	2022-10-24 21:08:35 -04:00
AAGaming	c1fabe5b35	pin pyinstaller to 5.5-py3	2022-10-24 21:07:49 -04:00
AAGaming	ed82f51bb7	use same python ver as deck	2022-10-24 20:55:38 -04:00
AAGaming	df1524e15f	nevermind dont	2022-10-24 20:51:56 -04:00
AAGaming	2edd910df3	ci: upgrade python to 3.11	2022-10-24 20:48:58 -04:00
AAGaming	1cd69097ad	import uuid in injector, update DFL	2022-10-24 20:41:27 -04:00
AAGaming	84c3b039c3	preview 10/21/2022 fixes (#234 ) * initial fixes: everything working except toasts and patch notes * tabshook changes, disable toaster for now * prettier * oops * implement custom toaster because I am tired of Valve's shit also fix QAM not injecting sometimes * remove extra logging * add findSP, fix patch notes, fix vscode screwup * fix patch notes * show error when plugin frontends fail to load * add get_tab_lambda * add css and has_element helpers to Tab * small modals fixup * Don't forceUpdate QuickAccess on stable * add routes prop used to get tabs component * add more dev utils to DFL global	2022-10-24 16:14:56 -07:00
TrainDoctor	2e6b3834da	Properly utilize image_url from Store	2022-10-23 14:00:29 -07:00
TrainDoctor	6749c78ed7	During update, download updates first before removing old plugin files (#223 ) * Remove old nightly support and unused logging * Removed legacy code + added logic to account for offline update attempts * Update backend/browser.py Co-authored-by: AAGaming <aa@mail.catvibers.me> * Update backend/browser.py Co-authored-by: AAGaming <aa@mail.catvibers.me> * Update frontend/src/toaster.tsx Co-authored-by: AAGaming <aa@mail.catvibers.me> * Use str instead of String (I was tired okay...) * Remove false logic * look for plugins not having remote_binary in pkg Co-authored-by: AAGaming <aa@mail.catvibers.me>	2022-10-23 13:41:12 -07:00
TrainDoctor	4ad15568cd	Merge drop-legacy to main.	2022-10-23 13:04:00 -07:00
TrainDoctor	58849b3002	Reduce amount of actions taken when using updateandrun	2022-10-22 19:11:00 -07:00
TrainDoctor	6346da6fe5	Actually utilize the unload function	2022-10-22 18:44:44 -07:00
TrainDoctor	af51a29055	Added unload hook for plugins.	2022-10-22 18:36:49 -07:00
TrainDoctor	c546a818f1	Send version when asking for plugin list	2022-10-22 16:52:48 -07:00
TrainDoctor	0226bd2bf8	Update build.yml	2022-10-22 13:02:23 -07:00
TrainDoctor	7b16b623c8	Fix toaster initialization	2022-10-16 15:52:21 -07:00