Fixed an issue regarding the scroll root path (#201 )

* Changed so searching for the scroll root node will look through siblings of children nodes. * Added a missing await Seem to have missed an await from when I was converting my proof-of-concept to an async function. * Minor stylistic change * Changed where program retries to find the scroll root.
Fix outdated line about manual install
2026-06-17 08:47:49 +00:00 · 2022-10-04 11:54:54 -07:00 · 2022-10-02 10:56:06 -07:00 · 2022-10-02 08:19:41 -07:00 · 2022-10-02 08:11:00 -07:00 · 2022-10-02 10:29:33 -04:00
46 changed files with 2542 additions and 460 deletions
@@ -54,13 +54,20 @@ jobs:
      run: pyinstaller --noconfirm --onefile --name "PluginLoader" --add-data ./backend/static:/static --add-data ./backend/legacy:/legacy ./backend/*.py
        
    - name: Upload package artifact ⬆️
+      if: ${{ !env.ACT }}
      uses: actions/upload-artifact@v3
      with:
        name: PluginLoader
        path: ./dist/PluginLoader

+    - name: Download package artifact locally
+      if: ${{ env.ACT }}
+      uses: actions/upload-artifact@v3
+      with:
+        path: ./dist/PluginLoader
+
  release:
-    name: Release the package
+    name: Release stable version of the package
    if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.release == 'release' }}
    needs: build
    runs-on: ubuntu-latest
@@ -69,144 +76,125 @@ jobs:
    - name: Checkout 🧰
      uses: actions/checkout@v3

-    - name: Fetch package artifact ⬇️
-      uses: actions/download-artifact@v3
-      with:
-        name: PluginLoader
-        path: dist
-
-    - name: Release 📦
-      uses: softprops/action-gh-release@v1
-      with:
-        name: Release ${{ steps.tag_version.outputs.new_tag }}
-        tag_name: ${{ steps.tag_version.outputs.new_tag }}
-        files: ./dist/PluginLoader
-        generate_release_notes: true
-
-  prerelease:
-    name: Release the pre-release version of the package
-    if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.release == 'prerelease' }}
-    needs: build
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout 🧰
-      uses: actions/checkout@v3
-
-    - name: Fetch package artifact ⬇️
-      uses: actions/download-artifact@v3
-      with:
-        name: PluginLoader
-        path: dist
-    
    - name: Install semver-tool asdf
      uses: asdf-vm/actions/install@v1
      with:
        tool_versions: |
          semver 3.3.0
-    
-    - name: Get tag 🏷️
-      id: old_tag
-      uses: rafarlopes/get-latest-pre-release-tag-action@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Fetch package artifact ⬇️
+      uses: actions/download-artifact@v3
+      if: ${{ !env.ACT }}
      with:
-        repository: 'decky-loader'
+        name: PluginLoader
+        path: dist
+
+    - name: Get latest release
+      uses: rez0n/actions-github-release@main
+      id: latest_release
+      env:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        repository: "SteamDeckHomebrew/decky-loader"
+        type: "nodraft"

    - name: Prepare tag ⚙️
      id: ready_tag
      run: |
-        export VERSION=${{ steps.old_tag.outputs.tag }}
+        export VERSION=${{ steps.latest_release.outputs.release }}
        echo "VERS: $VERSION"
-        OUT=$(semver bump prerel "$VERSION")
-        echo "OUT: $OUT"
+        OUT="notsemver"
+        if [[ "$VERSION" =~ "-pre" ]]; then
+          printf "is prerelease, bumping to release\n"
+          OUT=$(semver bump release "$VERSION")
+          printf "OUT: ${OUT}\n"
+        elif [[ ! "$VERSION" =~ "-pre" ]]; then
+          printf "previous tag is a release, bumping by a patch\n"
+          OUT=$(semver bump patch "$VERSION")
+          printf "OUT: ${OUT}\n" 
+        fi
+        echo "vOUT: v$OUT"
        echo ::set-output name=tag_name::v$OUT

    - name: Push tag 📤
      uses: rickstaa/action-create-tag@v1.3.2
-      if: ${{ steps.ready_tag.outputs.tag_name && github.event_name == 'workflow_dispatch' }}
+      if: ${{ steps.ready_tag.outputs.tag_name && github.event_name == 'workflow_dispatch' && !env.ACT }}
      with:
        tag: ${{ steps.ready_tag.outputs.tag_name }}
        message: Pre-release ${{ steps.ready_tag.outputs.tag_name }}

    - name: Release 📦
      uses: softprops/action-gh-release@v1
-      if: ${{ github.event_name == 'workflow_dispatch' }}
+      if: ${{ github.event_name == 'workflow_dispatch' && !env.ACT  }}
+      with:
+        name: Prerelease ${{ steps.ready_tag.outputs.tag_name }}
+        tag_name: ${{ steps.ready_tag.outputs.tag_name }}
+        files: ./dist/PluginLoader
+        prerelease: false
+        generate_release_notes: true
+  
+  prerelease:
+    name: Release the pre-release version of the package
+    if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.release == 'prerelease' }}
+    needs: build
+    runs-on: ubuntu-latest
+
+    steps:    
+    - name: Checkout 🧰
+      uses: actions/checkout@v3
+
+    - name: Install semver-tool asdf
+      uses: asdf-vm/actions/install@v1
+      with:
+        tool_versions: |
+          semver 3.3.0
+
+    - name: Fetch package artifact ⬇️
+      uses: actions/download-artifact@v3
+      if: ${{ !env.ACT }}
+      with:
+        name: PluginLoader
+        path: dist
+
+    - name: Get latest release
+      uses: rez0n/actions-github-release@main
+      id: latest_release
+      env:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        repository: "SteamDeckHomebrew/decky-loader"
+        type: "nodraft"
+
+    - name: Prepare tag ⚙️
+      id: ready_tag
+      run: |
+        export VERSION=${{ steps.latest_release.outputs.release }}
+        echo "VERS: $VERSION"
+        OUT=""
+        if [[ ! "$VERSION" =~ "-pre" ]]; then
+          printf "is release, bumping  minor version and prerel\n"
+          OUT=$(semver bump patch "$VERSION")
+          OUT="$OUT-pre"
+          OUT=$(semver bump prerel "$OUT")
+          printf "OUT: ${OUT}\n"
+        elif [[ "$VERSION" =~ "-pre" ]]; then
+          printf "is a prerelease, bumping prerel\n"
+          OUT=$(semver bump prerel "$VERSION")
+          printf "OUT: ${OUT}\n"
+        fi
+        echo ::set-output name=tag_name::v$OUT
+
+    - name: Push tag 📤
+      uses: rickstaa/action-create-tag@v1.3.2
+      if: ${{ steps.ready_tag.outputs.tag_name && github.event_name == 'workflow_dispatch' && !env.ACT }}
+      with:
+        tag: ${{ steps.ready_tag.outputs.tag_name }}
+        message: Pre-release ${{ steps.ready_tag.outputs.tag_name }}
+
+    - name: Release 📦
+      uses: softprops/action-gh-release@v1
+      if: ${{ github.event_name == 'workflow_dispatch' && !env.ACT  }}
      with:
        name: Prerelease ${{ steps.ready_tag.outputs.tag_name }}
        tag_name: ${{ steps.ready_tag.outputs.tag_name }}
        files: ./dist/PluginLoader
        prerelease: true
        generate_release_notes: true
-
-  # nightly:
-  #   name: Release the nightly version of the package
-  #   if: ${{ github.event_name == 'schedule' }}
-  #   needs: build
-  #   runs-on: ubuntu-latest
-
-  #   steps:
-  #   - name: Checkout 🧰
-  #     uses: actions/checkout@v3
-
-  #   - name: Fetch package artifact ⬇️
-  #     uses: actions/download-artifact@v3
-  #     with:
-  #       name: PluginLoader
-  #       path: dist
-    
-  #   - name: Get tag 🏷️
-  #     id: old_tag
-  #     uses: rafarlopes/get-latest-pre-release-tag-action@v1
-  #     env:
-  #       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  #     with:
-  #       repository: 'decky-loader'
-    
-  #   - name: Prepare tag ⚙️
-  #     id: ready_tag
-  #     run: |
-  #       export VERSION=${{ steps.old_tag.outputs.tag }}
-  #       export COMMIT=$(git log -1 --pretty=format:%h)
-  #       echo ::set-output name=tag_name::$(sed -r 's/(-.*)?-pre$//' <<< $VERSION)-$COMMIT-nightly
-
-  #   - name: Push tag 📤
-  #     uses: rickstaa/action-create-tag@v1.3.2
-  #     if: ${{ steps.ready_tag.outputs.tag_name && github.event_name == 'workflow_dispatch' }}
-  #     with:
-  #       tag: ${{ steps.ready_tag.outputs.tag_name }}
-  #       message: Nightly ${{ steps.ready_tag.outputs.tag_name }}
-
-  #   - name: Release 📦
-  #     uses: softprops/action-gh-release@v1
-  #     if: ${{ github.event_name == 'workflow_dispatch' }}
-  #     with:
-  #       name: Prerelease ${{ steps.ready_tag.outputs.tag_name }}
-  #       tag_name: ${{ steps.ready_tag.outputs.tag_name }}
-  #       files: ./dist/PluginLoader
-  #       prerelease: true
-  #       generate_release_notes: true
-
-    # - name: Bump prerelease ⏫
-    #   id: bump
-    #   if: ${{ github.event_name == 'schedule' }}
-    #   run: |
-    #     git_hash=$(git rev-parse --short "$GITHUB_SHA")
-    #     echo ::set-output new_tag="nightly-$git_hash"
-
-    # - name: Push tag 📤
-    #   uses: rickstaa/action-create-tag@v1.3.2
-    #   if: ${{ github.event_name == 'schedule' }}
-    #   with:
-    #     tag: ${{ steps.bump.outputs.new_tag }}
-    #     message: Nightly ${{ steps.bump.outputs.new_tag }}
-
-    # - name: Release 📦
-    #   uses: softprops/action-gh-release@v1
-    #   if: ${{ github.event_name == 'schedule' }}
-    #   with:
-    #     name: Nightly ${{ steps.bump.outputs.new_tag }}
-    #     tag_name: ${{ steps.bump.outputs.new_tag }}
-    #     files: ./dist/PluginLoader
-    #     prerelease: true
-    #     generate_release_notes: true
@@ -159,4 +159,6 @@ backend/static
 .vscode/settings.json

 # plugins folder for local launches
-plugins/*
+plugins/*
+act/.directory
+act/artifacts/*
@@ -89,17 +89,6 @@
            "command": "rsync -azp --delete --rsh='ssh -p ${config:deckport} ${config:deckkey}' --exclude='.git/' --exclude='.github/' --exclude='.vscode/' --exclude='frontend/' --exclude='dist/' --exclude='contrib/' --exclude='*.log' --exclude='requirements.txt' --exclude='backend/__pycache__/' --exclude='.gitignore' . deck@${config:deckip}:${config:deckdir}/homebrew/dev/pluginloader",
            "problemMatcher": []
        },
-        {
-            "label": "deployall",
-            "dependsOrder": "sequence",
-            "group": "none",
-            "dependsOn": [
-                "createfolders",
-                "dependencies",
-                "deploy"
-            ],
-            "problemMatcher": []
-        },
        // RUN
        {
            "label": "runpydeck",
@@ -107,7 +96,7 @@
            "type": "shell",
            "group": "none",
            "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; echo '${config:deckpass}' | sudo -SE python3 ${config:deckdir}/homebrew/dev/pluginloader/backend/main.py'",
+            "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": []
        },
        {
@@ -126,12 +115,12 @@
            "group": "none",
            "dependsOn": [
                "buildall",
-                "deployall",
+                "deploy",
            ],
            "problemMatcher": []
        },
        {
-            "label": "allinone",
+            "label": "updateandrun",
            "detail": "Build, deploy and run",
            "dependsOrder": "sequence",
            "group": {
@@ -140,7 +129,24 @@
            },
            "dependsOn": [
                "buildall",
-                "deployall",
+                "deploy",
+                "runpydeck"
+            ],
+            "problemMatcher": []
+        },
+        {
+            "label": "allinone",
+            "detail": "Build, install dependencies, deploy and run",
+            "dependsOrder": "sequence",
+            "group": {
+                "kind": "build",
+                "isDefault": false
+            },
+            "dependsOn": [
+                "buildall",
+                "createfolders",
+                "dependencies",
+                "deploy",
                "runpydeck"
            ],
            "problemMatcher": []
@@ -1,29 +1,30 @@
-# Plugin Loader [![Chat](https://img.shields.io/badge/chat-on%20discord-7289da.svg)](https://discord.gg/ZU74G2NJzk)
+# Decky Loader [![Chat](https://img.shields.io/badge/chat-on%20discord-7289da.svg)](https://discord.gg/ZU74G2NJzk)

-![steamuserimages-a akamaihd](https://user-images.githubusercontent.com/10835354/161068262-ca723dc5-6795-417a-80f6-d8c1f9d03e93.jpg)
+![Decky](https://media.discordapp.net/attachments/966017112244125756/1012466063893610506/main.jpg)

-Keep an eye on the [Wiki](https://deckbrew.xyz) for more information about Plugin Loader, documentation + tools for plugin development and more.
+Keep an eye on the [Wiki](https://deckbrew.xyz) for more information about Decky Loader, documentation + tools for plugin development and more.

 ## Installation
 1. Go into the Steam Deck Settings
 2. Under System -> System Settings toggle `Enable Developer Mode`
 3. Scroll the sidebar all the way down and click on `Developer`
 4. Under Miscellaneous, enable `CEF Remote Debugging`
-5. Click on the `STEAM` button and select `Power` -> `Switch to Desktop`
-6. Make sure you have a password set with the "passwd" command in terminal to install it ([YouTube Guide](https://www.youtube.com/watch?v=1vOMYGj22rQ)).
-7. Open a terminal and paste the following command into it:
+5. Confirm dialog and wait for system reboot
+6. Click on the `STEAM` button and select `Power` -> `Switch to Desktop`
+7. Make sure you have a password set with the "passwd" command in terminal to install it ([YouTube Guide](https://www.youtube.com/watch?v=1vOMYGj22rQ)).
+8. Open a terminal ("Konsole" is the pre-installed terminal application) and paste the following command into it:
+    - For the latest release:
+        - `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/install_release.sh | sh`
    - For the latest pre-release:
        - `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/install_prerelease.sh | sh`
    - For testers/plugin developers:
        - `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/install_prerelease.sh | sh`
        - [Wiki Link](https://deckbrew.xyz/en/loader-dev/development)
-    - For the legacy version (unsupported):
-        - `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/legacy/dist/install_release.sh | sh`
-7. Done! Reboot back into Gaming mode and enjoy your plugins!
+9. Done! Reboot back into Gaming mode and enjoy your plugins!

 ### Install/Uninstall Plugins
- Using the shopping bag button in the top right corner, you can go to the offical ["Plugin Store"](https://plugins.deckbrew.xyz/)
- Simply copy the plugin's folder into `~/homebrew/plugins`
+- Using the shopping bag button in the top right corner of the plugin menu, you can go to the offical Plugin Store ([Web Preview](https://beta.deckbrew.xyz/)).
+- Install from URL in the settings menu.
 - Use the settings menu to uninstall plugins, this will not remove any files made in different directories by plugins.

 ### Uninstall
@@ -41,8 +42,8 @@ Keep an eye on the [Wiki](https://deckbrew.xyz) for more information about Plugi
 - There is no complete plugin development documentation yet. However a good starting point is the [Plugin Template](https://github.com/SteamDeckHomebrew/decky-plugin-template) repository.

 ## [Contribution](https://deckbrew.xyz/en/loader-dev/development)
- Please consult the [Wiki](https://deckbrew.xyz/en/loader-dev/development) for installing development versions of PluginLoader.
-  - This is also useful for Plugin Developers looking to target new but unreleased versions of PluginLoader.
+- Please consult the [Wiki](https://deckbrew.xyz/en/loader-dev/development) for installing development versions of Decky Loader.
+  - This is also useful for Plugin Developers looking to target new but unreleased versions of Decky Loader.
 - [Here's how to get the Steam Deck UI on your enviroment of choice.](https://youtu.be/1IAbZte8e7E?t=112)
    - (The video shows Windows usage but unless you're using Arch WSL/cygwin this script is unsupported on Windows.)

@@ -0,0 +1,10 @@
+this directory contains artifacts generated by invocations of https://github.com/nektos/act in order to do local testing of binary builds
+
+how to?
+run:
+
+./act/run-act.sh prerelease
+
+or
+
+./act/run-act.sh release
@@ -0,0 +1,5 @@
+{
+  "inputs": {
+    "release": "prerelease"
+  }
+}
@@ -0,0 +1,5 @@
+{
+  "inputs": {
+    "release": "release"
+  }
+}
@@ -0,0 +1,44 @@
+#!/bin/bash
+
+type=$1
+
+oldartifactsdir="old"
+
+parent_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$parent_path"
+
+artifactfolders=$(find artifacts/ -maxdepth 1 -mindepth 1 -type d)
+if [[ ${#artifactfolders[@]} > 0 ]]; then
+    for i in ${artifactfolders[@]}; do
+        foldername=$(dirname $i)
+        subfoldername=$(basename $i)
+        out=$foldername/$oldartifactsdir/$subfoldername-$(date +'%s')
+        if [[ ! "$subfoldername" =~ "$oldartifactsdir" ]]; then
+            mkdir -p $out
+            mv $i $out
+            printf "Moved "${foldername}"/"${subfoldername}" to "${out}" \n"
+        fi
+    done
+fi
+
+cd ..
+
+if [[ "$type" == "release" ]]; then
+    printf "release!\n"
+    act workflow_dispatch -e act/release.json --artifact-server-path act/artifacts
+elif [[ "$type" == "prerelease" ]]; then
+    printf "prerelease!\n"
+    act workflow_dispatch -e act/prerelease.json --artifact-server-path act/artifacts
+else
+    printf "Release type unspecified/badly specified.\n"
+    printf "Options: 'release' or 'prerelease'\n"
+fi
+
+cd act/artifacts
+
+if [[ -d "1" ]]; then
+    cd "1/artifact"
+    cp "PluginLoader.gz__" "PluginLoader.gz"
+    gzip -d "PluginLoader.gz"
+    chmod +x PluginLoader
+fi
@@ -3,19 +3,19 @@ import json

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

 # Local modules
-from helpers import get_ssl_context, get_user, get_user_group
+from helpers import get_ssl_context, get_user, get_user_group, download_remote_binary_to_path
 from injector import get_tab, inject_to_tab

 logger = getLogger("Browser")
@@ -28,28 +28,67 @@ class PluginInstallContext:
        self.hash = hash

 class PluginBrowser:
-    def __init__(self, plugin_path, server_instance, plugins) -> None:
+    def __init__(self, plugin_path, plugins, loader) -> None:
        self.plugin_path = plugin_path
        self.plugins = plugins
+        self.loader = loader
        self.install_requests = {}

-        server_instance.add_routes([
-            web.post("/browser/install_plugin", self.install_plugin),
-            web.post("/browser/uninstall_plugin", self.uninstall_plugin)
-        ])
-
    def _unzip_to_plugin_dir(self, zip, name, hash):
        zip_hash = sha256(zip.getbuffer()).hexdigest()
        if hash and (zip_hash != hash):
            return False
        zip_file = ZipFile(zip)
        zip_file.extractall(self.plugin_path)
-        code_chown = call(["chown", "-R", get_user()+":"+get_user_group(), self.plugin_path])
-        code_chmod = call(["chmod", "-R", "555", self.plugin_path])
+        plugin_dir = self.find_plugin_folder(name)
+        code_chown = call(["chown", "-R", get_user()+":"+get_user_group(), plugin_dir])
+        code_chmod = call(["chmod", "-R", "555", plugin_dir])
        if code_chown != 0 or code_chmod != 0:
            logger.error(f"chown/chmod exited with a non-zero exit code (chown: {code_chown}, 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')
+
+            if access(packageJsonPath, R_OK):
+                with open(packageJsonPath, 'r') as f:
+                    packageJson = json.load(f)
+                    if len(packageJson["remote_binary"]) > 0:
+                        # create bin directory if needed.
+                        rc=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])
+
+                        rv = True
+                        for remoteBinary in packageJson["remote_binary"]:
+                            # Required Fields. If any Remote Binary is missing these fail the install.
+                            binName = remoteBinary["name"]
+                            binURL = remoteBinary["url"]
+                            binHash = remoteBinary["sha256hash"]
+                            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)}")
+
+                        code_chown = call(["chown", "-R", get_user()+":"+get_user_group(), self.plugin_path])
+                        rc=call(["chmod", "-R", "555", pluginBasePath])
+                    else:
+                        rv = True
+                        logger.debug(f"No Remote Binaries to Download")
+                
+        except Exception as e:
+            rv = False
+            logger.debug(str(e))
+
+        return rv

    def find_plugin_folder(self, name):
        for folder in listdir(self.plugin_path):
@@ -63,26 +102,31 @@ class PluginBrowser:
                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")
-
        try:
-            if type(name) != str:
-                data = await name.post()
-                name = data.get("name", "undefined")
            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}')")
            if self.plugins[name]:
                self.plugins[name].stop()
-                self.plugins.pop(name, None)
+                del self.plugins[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")
-
-        return web.Response(text="Requested plugin uninstall")
+        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)
+        if self.loader.watcher:
+            self.loader.watcher.disabled = False

    async def _install(self, artifact, name, version, hash):
-        try: 
+        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")
@@ -95,29 +139,35 @@ class PluginBrowser:
                data = await res.read()
                logger.debug(f"Read {len(data)} bytes")
                res_zip = BytesIO(data)
-                with ProcessPoolExecutor() as executor:
-                    logger.debug("Unzipping...")
-                    ret = self._unzip_to_plugin_dir(res_zip, name, hash)
+                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)
                    if ret:
                        logger.info(f"Installed {name} (Version: {version})")
-                        await inject_to_tab("SP", "window.syncDeckyPlugins()")
+                        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()")
                    else:
-                        logger.fatal(f"SHA-256 Mismatch!!!! {name} (Version: {version})")
+                        logger.fatal(f"Failed Downloading Remote Binaries")
+                else:
+                    self.log.fatal(f"SHA-256 Mismatch!!!! {name} (Version: {version})")
+                if self.loader.watcher:
+                    self.loader.watcher.disabled = False
            else:
                logger.fatal(f"Could not fetch from URL. {await res.text()}")

-    async def install_plugin(self, request):
-        data = await request.post()
-        get_event_loop().create_task(self.request_plugin_install(data.get("artifact", ""), data.get("name", "No name"), data.get("version", "dev"), data.get("hash", False)))
-        return web.Response(text="Requested plugin install")
-
    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")
        await tab.open_websocket()
        await tab.evaluate_js(f"DeckyPluginLoader.addPluginInstallPrompt('{name}', '{version}', '{request_id}', '{hash}')")
-    
+
    async def confirm_plugin_install(self, request_id):
        request = self.install_requests.pop(request_id)
        await self._install(request.artifact, request.name, request.version, request.hash)
@@ -1,13 +1,16 @@
-import certifi
-import ssl
-import uuid
 import re
+import ssl
 import subprocess
-
-from aiohttp.web import middleware, Response
+import uuid
+import os
 from subprocess import check_output
 from time import sleep
+from hashlib import sha256
+from io import BytesIO

+import certifi
+from aiohttp.web import Response, middleware
+from aiohttp import ClientSession

 REMOTE_DEBUGGER_UNIT = "steam-web-debug-portforward.service"

@@ -18,6 +21,7 @@ user = None
 group = None

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

 def get_ssl_context():
    return ssl_ctx
@@ -27,7 +31,7 @@ def get_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 assets_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')

@@ -68,6 +72,45 @@ def get_user_group() -> str:
        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)
+
+# 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:
+    rv = False
+    try:
+        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}")
+                else:
+                    rv = False
+    except:
+        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)
    return res.returncode == 0
@@ -75,9 +118,9 @@ async def is_systemd_unit_active(unit_name: str) -> bool:
 async def stop_systemd_unit(unit_name: str) -> subprocess.CompletedProcess:
    cmd = ["systemctl", "stop", unit_name]

-    return subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

 async def start_systemd_unit(unit_name: str) -> subprocess.CompletedProcess:
    cmd = ["systemctl", "start", unit_name]

-    return subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
@@ -69,7 +69,7 @@ async def get_tabs():
            except ClientConnectorError:
                logger.debug("ClientConnectorError excepted.")
                logger.debug("Steam isn't available yet. Wait for a moment...")
-                logger.debug(format_exc())
+                logger.error(format_exc())
                await sleep(5)
            else:
                break
@@ -1,4 +1,4 @@
-from asyncio import Queue
+from asyncio import Queue, sleep
 from json.decoder import JSONDecodeError
 from logging import getLogger
 from os import listdir, path
@@ -25,8 +25,11 @@ class FileChangeHandler(RegexMatchingEventHandler):
        self.logger = getLogger("file-watcher")
        self.plugin_path = plugin_path
        self.queue = queue
+        self.disabled = False

    def maybe_reload(self, src_path):
+        if self.disabled:
+            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))
@@ -66,19 +69,22 @@ class Loader:
        self.plugin_path = plugin_path
        self.logger.info(f"plugin_path: {self.plugin_path}")
        self.plugins = {}
+        self.watcher = None

        if live_reload:
            self.reload_queue = Queue()
            self.observer = Observer()
-            self.observer.schedule(FileChangeHandler(self.reload_queue, plugin_path), self.plugin_path, recursive=True)
+            self.watcher = FileChangeHandler(self.reload_queue, plugin_path)
+            self.observer.schedule(self.watcher, self.plugin_path, recursive=True)
            self.observer.start()
            self.loop.create_task(self.handle_reloads())

        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_frontend_assets),
+            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),
@@ -86,15 +92,20 @@ class Loader:
            web.get("/steam_resource/{path:.+}", self.get_steam_resource)
        ])

+    async def handle_frontend_assets(self, request):
+        file = path.join(path.dirname(__file__), "static", request.match_info["path"])
+
+        return web.FileResponse(file, headers={"Cache-Control": "no-cache"})
+
    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])

-    def handle_frontend_assets(self, request):
+    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"])

-        return web.FileResponse(file)
+        return web.FileResponse(file, headers={"Cache-Control": "no-cache"})

    def handle_frontend_bundle(self, request):
        plugin = self.plugins[request.match_info["plugin_name"]]
@@ -1,21 +1,26 @@
 # Full imports
-import aiohttp_cors
-
-# Partial imports
-from aiohttp import ClientSession
-from aiohttp.web import Application, run_app, static, get, Response
-from aiohttp_jinja2 import setup as jinja_setup
 from asyncio import get_event_loop, sleep
 from json import dumps, loads
 from logging import DEBUG, INFO, basicConfig, getLogger
 from os import getenv, path
 from subprocess import call
+from traceback import format_exc
+
+import aiohttp_cors
+# Partial imports
+from aiohttp import ClientSession
+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 csrf_middleware, get_csrf_token, get_user, get_user_group, set_user, set_user_group, stop_systemd_unit, REMOTE_DEBUGGER_UNIT
+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 loader import Loader
+from settings import SettingsManager
 from updater import Updater
 from utilities import Utilities

@@ -35,10 +40,15 @@ CONFIG = {
    "server_host": getenv("SERVER_HOST", "127.0.0.1"),
    "server_port": int(getenv("SERVER_PORT", "1337")),
    "live_reload": getenv("LIVE_RELOAD", "1") == "1",
-    "log_level": {"CRITICAL": 50, "ERROR": 40, "WARNING":30, "INFO": 20, "DEBUG": 10}[getenv("LOG_LEVEL", "INFO")]
+    "log_level": {"CRITICAL": 50, "ERROR": 40, "WARNING": 30, "INFO": 20, "DEBUG": 10}[
+        getenv("LOG_LEVEL", "INFO")
+    ],
 }

-basicConfig(level=CONFIG["log_level"], format="[%(module)s][%(levelname)s]: %(message)s")
+basicConfig(
+    level=CONFIG["log_level"],
+    format="[%(module)s][%(levelname)s]: %(message)s"
+)

 logger = getLogger("Main")

@@ -48,20 +58,21 @@ async def chown_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})")

-def remote_debugging_allowed():
-    return path.exists(HOMEBREW_PATH + "/allow_remote_debugging")
-
 class PluginManager:
    def __init__(self) -> None:
        self.loop = get_event_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)
+            "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.web_app, self.plugin_loader.plugins)
+        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)

@@ -70,13 +81,13 @@ class PluginManager:
            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 remote_debugging_allowed():
+        if not self.settings.getSetting("cef_forward", False):
            self.loop.create_task(stop_systemd_unit(REMOTE_DEBUGGER_UNIT))
        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.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'))])

@@ -100,7 +111,7 @@ class PluginManager:
    async def load_plugins(self):
        await self.wait_for_server()
        self.plugin_loader.import_plugins()
-        #await inject_to_tab("SP", "window.syncDeckyPlugins();")
+        # await inject_to_tab("SP", "window.syncDeckyPlugins();")

    async def loader_reinjector(self):
        await sleep(2)
@@ -113,9 +124,9 @@ class PluginManager:

    async def inject_javascript(self, request=None):
        try:
-            await inject_to_tab("SP", "try{window.deckyHasLoaded = true;(async()=>{while(!window.SP_REACT){await new Promise(r => setTimeout(r, 10))};" + open(path.join(path.dirname(__file__), "./static/plugin-loader.iife.js"), "r").read() + "})();}catch(e){console.error(e)}", True)
+            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:
-            logger.info("Failed to inject JavaScript into tab")
+            logger.info("Failed to inject JavaScript into tab\n" + format_exc())
            pass

    def run(self):
@@ -1,10 +1,12 @@
 import multiprocessing
 from asyncio import (Lock, get_event_loop, new_event_loop,
                     open_unix_connection, set_event_loop, sleep,
-                     start_unix_server)
+                     start_unix_server, IncompleteReadError, LimitOverrunError)
 from concurrent.futures import ProcessPoolExecutor
 from importlib.util import module_from_spec, spec_from_file_location
 from json import dumps, load, loads
+from logging import getLogger
+from traceback import format_exc
 from os import path, setgid, setuid
 from signal import SIGINT, signal
 from sys import exit
@@ -12,6 +14,8 @@ from time import time

 multiprocessing.set_start_method("fork")

+BUFFER_LIMIT = 2 ** 20  # 1 MiB
+
 class PluginWrapper:
    def __init__(self, file, plugin_directory, plugin_path) -> None:
        self.file = file
@@ -38,35 +42,53 @@ class PluginWrapper:
        self.author = json["author"]
        self.flags = json["flags"]

+        self.log = getLogger("plugin")
+
        self.passive = not path.isfile(self.file)

    def __str__(self) -> str:
        return self.name

    def _init(self):
-        signal(SIGINT, lambda s, f: exit(0))
+        try:
+            signal(SIGINT, lambda s, f: exit(0))

-        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)
-        spec = spec_from_file_location("_", self.file)
-        module = module_from_spec(spec)
-        spec.loader.exec_module(module)
-        self.Plugin = module.Plugin
+            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)
+            spec = spec_from_file_location("_", self.file)
+            module = module_from_spec(spec)
+            spec.loader.exec_module(module)
+            self.Plugin = module.Plugin

-        if hasattr(self.Plugin, "_main"):
-            get_event_loop().create_task(self.Plugin._main(self.Plugin))
-        get_event_loop().create_task(self._setup_socket())
-        get_event_loop().run_forever()
+            if hasattr(self.Plugin, "_main"):
+                get_event_loop().create_task(self.Plugin._main(self.Plugin))
+            get_event_loop().create_task(self._setup_socket())
+            get_event_loop().run_forever()
+        except:
+            self.log.error("Failed to start " + 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)
+        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:
-            data = loads((await reader.readline()).decode("utf-8"))
+            line = bytearray()
+            while True:
+                try:
+                    line.extend(await reader.readuntil())
+                except LimitOverrunError:
+                    line.extend(await reader.read(reader._limit))
+                    continue
+                except IncompleteReadError as err:
+                    line.extend(err.partial)
+                    break
+                else:
+                    break
+            data = loads(line.decode("utf-8"))
            if "stop" in data:
                get_event_loop().stop()
                while get_event_loop().is_running():
@@ -88,7 +110,7 @@ class PluginWrapper:
            retries = 0
            while retries < 10:
                try:
-                    self.reader, self.writer = await open_unix_connection(self.socket_addr)
+                    self.reader, self.writer = await open_unix_connection(self.socket_addr, limit=BUFFER_LIMIT)
                    return True
                except:
                    await sleep(2)
@@ -121,7 +143,19 @@ class PluginWrapper:
                self.writer.write(
                    (dumps({"method": method_name, "args": kwargs})+"\n").encode("utf-8"))
                await self.writer.drain()
-                res = loads((await self.reader.readline()).decode("utf-8"))
+                line = bytearray()
+                while True:
+                    try:
+                        line.extend(await self.reader.readuntil())
+                    except LimitOverrunError:
+                        line.extend(await self.reader.read(self.reader._limit))
+                        continue
+                    except IncompleteReadError as err:
+                        line.extend(err.partial)
+                        break
+                    else:
+                        break
+                res = loads(line.decode("utf-8"))
                if not res["success"]:
                    raise Exception(res["res"])
                return res["res"]
@@ -0,0 +1,44 @@
+import imp
+from json import dump, load
+from os import mkdir, path
+
+from helpers import get_home_path, get_homebrew_path, get_user, set_user
+
+
+class SettingsManager:
+    def __init__(self, name, settings_directory = None) -> None:
+        set_user()
+        USER = get_user()
+        if settings_directory == None:
+            settings_directory = get_homebrew_path(get_home_path(USER))
+        self.path = path.join(settings_directory, name + ".json")
+
+        if not path.exists(settings_directory):
+            mkdir(settings_directory)
+
+        self.settings = {}
+
+        try:
+            open(self.path, "x")
+        except FileExistsError as e:
+            self.read()
+            pass
+
+    def read(self):
+        try:
+            with open(self.path, "r") 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)
+
+    def getSetting(self, key, default):
+        return self.settings.get(key, default)
+
+    def setSetting(self, key, value):
+        self.settings[key] = value
+        self.commit()
@@ -1,37 +1,46 @@
 import uuid
-from logging import getLogger
-from json.decoder import JSONDecodeError
-
 from asyncio import sleep
+from ensurepip import version
+from json.decoder import JSONDecodeError
+from logging import getLogger
+from os import getcwd, path, remove
+from subprocess import call

 from aiohttp import ClientSession, web

-from injector import inject_to_tab, get_tab
-
-from os import getcwd, path, remove
-
-from subprocess import call
-
 import helpers
+from injector import get_tab, inject_to_tab
+from settings import SettingsManager

 logger = getLogger("Updater")

 class Updater:
    def __init__(self, context) -> None:
        self.context = context
+        self.settings = self.context.settings
+        # Exposes updater methods to frontend
        self.updater_methods = {
+            "get_branch": self._get_branch,
            "get_version": self.get_version,
            "do_update": self.do_update,
            "do_restart": self.do_restart,
            "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", "")
        except:
            self.localVer = False

+        try:
+            self.currentBranch = self.get_branch(self.context.settings)
+        except:
+            self.currentBranch = 0
+            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)
@@ -54,21 +63,55 @@ class Updater:
            res["success"] = False
        return web.json_response(res)

+    def get_branch(self, manager: SettingsManager):
+        ver = manager.getSetting("branch", -1)
+        logger.debug("current branch: %i" % ver)
+        if ver == -1:
+            logger.info("Current branch is not set, determining branch from version...")
+            if self.localVer.startswith("v") and self.localVer.find("-pre"):
+                logger.info("Current version determined to be pre-release")
+                return 1
+            else:
+                logger.info("Current version determined to be stable")
+                return 0
+        return ver
+
+    async def _get_branch(self, manager: SettingsManager):
+        return self.get_branch(manager)
+
    async def get_version(self):
        if self.localVer:
            return {
                "current": self.localVer,
                "remote": self.remoteVer,
+                "all": self.allRemoteVers,
                "updatable": self.localVer != None
            }
        else:
-            return {"current": "unknown", "remote": self.remoteVer, "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:
                remoteVersions = await res.json()
-                self.remoteVer = next(filter(lambda ver: ver["prerelease"] and ver["tag_name"].startswith("v") and ver["tag_name"].find("-pre"), remoteVersions), None)
+                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)
@@ -85,7 +128,6 @@ class Updater:

    async def do_update(self):
        version = self.remoteVer["tag_name"]
-        #TODO don't hardcode this
        download_url = self.remoteVer["assets"][0]["browser_download_url"]

        tab = await get_tab("SP")
@@ -1,4 +1,5 @@
 import uuid
+import os
 from json.decoder import JSONDecodeError

 from aiohttp import ClientSession, web
@@ -7,20 +8,25 @@ from injector import inject_to_tab
 import helpers
 import subprocess

+
 class Utilities:
    def __init__(self, context) -> None:
        self.context = context
        self.util_methods = {
            "ping": self.ping,
            "http_request": self.http_request,
+            "install_plugin": self.install_plugin,
            "cancel_plugin_install": self.cancel_plugin_install,
            "confirm_plugin_install": self.confirm_plugin_install,
+            "uninstall_plugin": self.uninstall_plugin,
            "execute_in_tab": self.execute_in_tab,
            "inject_css_into_tab": self.inject_css_into_tab,
            "remove_css_from_tab": self.remove_css_from_tab,
            "allow_remote_debugging": self.allow_remote_debugging,
            "disallow_remote_debugging": self.disallow_remote_debugging,
-            "remote_debugging_allowed": self.remote_debugging_allowed
+            "set_setting": self.set_setting,
+            "get_setting": self.get_setting,
+            "filepicker_ls": self.filepicker_ls
        }

        if context:
@@ -44,12 +50,23 @@ class Utilities:
            res["success"] = False
        return web.json_response(res)

+    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
+        )
+
    async def confirm_plugin_install(self, request_id):
        return await self.context.plugin_browser.confirm_plugin_install(request_id)

    def cancel_plugin_install(self, request_id):
        return self.context.plugin_browser.cancel_plugin_install(request_id)

+    async def uninstall_plugin(self, name):
+        return await self.context.plugin_browser.uninstall_plugin(name)
+
    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:
@@ -73,12 +90,12 @@ class Utilities:

            return {
                "success": True,
-                "result" : result["result"]["result"].get("value")
+                "result": result["result"]["result"].get("value")
            }
        except Exception as e:
            return {
-                "success": False,
-                "result": e
+              "success": False,
+              "result": e
            }

    async def inject_css_into_tab(self, tab, style):
@@ -103,7 +120,7 @@ class Utilities:

            return {
                "success": True,
-                "result" : css_id
+                "result": css_id
            }
        except Exception as e:
            return {
@@ -138,9 +155,11 @@ class Utilities:
                "result": e
            }

+    async def get_setting(self, key, default):
+        return self.context.settings.getSetting(key, default)

-    async def remote_debugging_allowed(self):
-        return await helpers.is_systemd_unit_active(helpers.REMOTE_DEBUGGER_UNIT)
+    async def set_setting(self, key, value):
+        return self.context.settings.setSetting(key, value)

    async def allow_remote_debugging(self):
        await helpers.start_systemd_unit(helpers.REMOTE_DEBUGGER_UNIT)
@@ -149,3 +168,29 @@ class Utilities:
    async def disallow_remote_debugging(self):
        await helpers.stop_systemd_unit(helpers.REMOTE_DEBUGGER_UNIT)
        return True
+
+    async def filepicker_ls(self, path, include_files=True):
+        # def sorter(file): # Modification time
+        #     if os.path.isdir(os.path.join(path, file)) or os.path.isfile(os.path.join(path, file)):
+        #         return os.path.getmtime(os.path.join(path, file))
+        #     return 0
+        # file_names = sorted(os.listdir(path), key=sorter, reverse=True) # TODO provide more sort options
+        file_names = sorted(os.listdir(path)) # Alphabetical
+
+        files = []
+
+        for file in file_names:
+            full_path = os.path.join(path, file)
+            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)
+                })
+
+        return {
+            "realpath": os.path.realpath(path),
+            "files": files
+        }
@@ -13,8 +13,13 @@ sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/services"
 sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/plugins"

 # Download latest release and install it
-curl -L https://github.com/SteamDeckHomebrew/PluginLoader/releases/latest/download/PluginLoader --output "${HOMEBREW_FOLDER}/services/PluginLoader"
-chmod +x "${HOMEBREW_FOLDER}/services/PluginLoader"
+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}))
+
+printf "Installing version %s...\n" "${VERSION}"
+curl -L $DOWNLOADURL --output ${HOMEBREW_FOLDER}/services/PluginLoader
+chmod +x ${HOMEBREW_FOLDER}/services/PluginLoader
+echo $VERSION > ${HOMEBREW_FOLDER}/services/.loader.version

 systemctl --user stop plugin_loader 2> /dev/null
 systemctl --user disable plugin_loader 2> /dev/null
@@ -1,6 +1,6 @@
 {
  "name": "decky_frontend",
-  "version": "0.0.1",
+  "version": "2.1.1",
  "private": true,
  "license": "GPLV2",
  "scripts": {
@@ -17,6 +17,7 @@
    "@rollup/plugin-replace": "^4.0.0",
    "@rollup/plugin-typescript": "^8.3.3",
    "@types/react": "16.14.0",
+    "@types/react-file-icon": "^1.0.1",
    "@types/react-router": "5.1.18",
    "@types/webpack": "^5.28.0",
    "husky": "^8.0.1",
@@ -27,6 +28,9 @@
    "react": "16.14.0",
    "react-dom": "16.14.0",
    "rollup": "^2.76.0",
+    "rollup-plugin-delete": "^2.0.0",
+    "rollup-plugin-external-globals": "^0.6.1",
+    "rollup-plugin-polyfill-node": "^0.10.2",
    "tslib": "^2.4.0",
    "typescript": "^4.7.4"
  },
@@ -37,7 +41,10 @@
    }
  },
  "dependencies": {
-    "decky-frontend-lib": "^1.7.8",
-    "react-icons": "^4.4.0"
+    "decky-frontend-lib": "^3.1.3",
+    "react-file-icon": "^1.2.0",
+    "react-icons": "^4.4.0",
+    "react-markdown": "^8.0.3",
+    "remark-gfm": "^3.0.1"
  }
 }
@@ -1,6 +1,8 @@
 import commonjs from '@rollup/plugin-commonjs';
 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';
@@ -8,8 +10,17 @@ import { defineConfig } from 'rollup';
 export default defineConfig({
  input: 'src/index.tsx',
  plugins: [
+    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}'
+    }),
    typescript(),
    json(),
    replace({
@@ -17,13 +28,12 @@ export default defineConfig({
      'process.env.NODE_ENV': JSON.stringify('production'),
    }),
  ],
-  external: ["react", "react-dom"],
+  preserveEntrySignatures: false,
  output: {
-    file: '../backend/static/plugin-loader.iife.js',
-    globals: {
-      react: 'SP_REACT',
-      'react-dom': 'SP_REACTDOM',
-    },
-    format: 'iife',
-  },
+    dir: '../backend/static',
+    format: 'esm',
+    chunkFileNames: (chunkInfo) => {
+      return 'chunk-[hash].js'
+    }
+  }
 });
@@ -2,6 +2,7 @@ import { FC, createContext, useContext, useEffect, useState } from 'react';

 import { Plugin } from '../plugin';
 import { PluginUpdateMapping } from '../store';
+import { VerInfo } from '../updater';

 interface PublicDeckyState {
  plugins: Plugin[];
@@ -9,6 +10,7 @@ interface PublicDeckyState {
  updates: PluginUpdateMapping | null;
  hasLoaderUpdate?: boolean;
  isLoaderUpdating: boolean;
+  versionInfo: VerInfo | null;
 }

 export class DeckyState {
@@ -17,6 +19,7 @@ export class DeckyState {
  private _updates: PluginUpdateMapping | null = null;
  private _hasLoaderUpdate: boolean = false;
  private _isLoaderUpdating: boolean = false;
+  private _versionInfo: VerInfo | null = null;

  public eventBus = new EventTarget();

@@ -27,9 +30,15 @@ export class DeckyState {
      updates: this._updates,
      hasLoaderUpdate: this._hasLoaderUpdate,
      isLoaderUpdating: this._isLoaderUpdating,
+      versionInfo: this._versionInfo,
    };
  }

+  setVersionInfo(versionInfo: VerInfo) {
+    this._versionInfo = versionInfo;
+    this.notifyUpdate();
+  }
+
  setPlugins(plugins: Plugin[]) {
    this._plugins = plugins;
    this.notifyUpdate();
@@ -66,6 +75,7 @@ export class DeckyState {
 }

 interface DeckyStateContext extends PublicDeckyState {
+  setVersionInfo(versionInfo: VerInfo): void;
  setIsLoaderUpdating(hasUpdate: boolean): void;
  setActivePlugin(name: string): void;
  closeActivePlugin(): void;
@@ -93,12 +103,13 @@ export const DeckyStateContextProvider: FC<Props> = ({ children, deckyState }) =
  }, []);

  const setIsLoaderUpdating = (hasUpdate: boolean) => deckyState.setIsLoaderUpdating(hasUpdate);
+  const setVersionInfo = (versionInfo: VerInfo) => deckyState.setVersionInfo(versionInfo);
  const setActivePlugin = (name: string) => deckyState.setActivePlugin(name);
  const closeActivePlugin = () => deckyState.closeActivePlugin();

  return (
    <DeckyStateContext.Provider
-      value={{ ...publicDeckyState, setIsLoaderUpdating, setActivePlugin, closeActivePlugin }}
+      value={{ ...publicDeckyState, setIsLoaderUpdating, setVersionInfo, setActivePlugin, closeActivePlugin }}
    >
      {children}
    </DeckyStateContext.Provider>
@@ -0,0 +1,42 @@
+import { Focusable } from 'decky-frontend-lib';
+import { FunctionComponent, useRef } from 'react';
+import ReactMarkdown, { Options as ReactMarkdownOptions } from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+
+interface MarkdownProps extends ReactMarkdownOptions {
+  onDismiss?: () => void;
+}
+
+const Markdown: FunctionComponent<MarkdownProps> = (props) => {
+  return (
+    <Focusable>
+      <ReactMarkdown
+        remarkPlugins={[remarkGfm]}
+        components={{
+          div: (nodeProps) => <Focusable {...nodeProps.node.properties}>{nodeProps.children}</Focusable>,
+          a: (nodeProps) => {
+            const aRef = useRef<HTMLAnchorElement>(null);
+            return (
+              // TODO fix focus ring
+              <Focusable
+                onActivate={() => {}}
+                onOKButton={() => {
+                  aRef?.current?.click();
+                  props.onDismiss?.();
+                }}
+                style={{ display: 'inline' }}
+              >
+                <a ref={aRef} {...nodeProps.node.properties}>
+                  {nodeProps.children}
+                </a>
+              </Focusable>
+            );
+          },
+        }}
+        {...props}
+      />
+    </Focusable>
+  );
+};
+
+export default Markdown;
@@ -32,8 +32,8 @@ const PluginView: VFC = () => {
          .map(({ name, icon }) => (
            <PanelSectionRow key={name}>
              <ButtonItem layout="below" onClick={() => setActivePlugin(name)}>
-                <div style={{ display: 'flex', justifyContent: 'space-between' }}>
-                  <div>{icon}</div>
+                <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+                  {icon}
                  <div>{name}</div>
                  <NotificationBadge show={updates?.has(name)} style={{ top: '-5px', right: '-5px' }} />
                </div>
@@ -0,0 +1,38 @@
+import { Focusable, SteamSpinner } from 'decky-frontend-lib';
+import { FunctionComponent, ReactElement, ReactNode, Suspense } from 'react';
+
+interface WithSuspenseProps {
+  children: ReactNode;
+  route?: boolean;
+}
+
+// Nice little wrapper around Suspense so we don't have to duplicate the styles and code for the loading spinner
+const WithSuspense: FunctionComponent<WithSuspenseProps> = (props) => {
+  const propsCopy = { ...props };
+  delete propsCopy.children;
+  (props.children as ReactElement)?.props && Object.assign((props.children as ReactElement).props, propsCopy); // There is probably a better way to do this but valve does it this way so ¯\_(ツ)_/¯
+  return (
+    <Suspense
+      fallback={
+        <Focusable
+          // needed to enable focus ring so that the focus properly resets on load
+          onActivate={() => {}}
+          style={{
+            overflowY: 'scroll',
+            backgroundColor: 'transparent',
+            ...(props.route && {
+              marginTop: '40px',
+              height: 'calc( 100% - 40px )',
+            }),
+          }}
+        >
+          <SteamSpinner />
+        </Focusable>
+      }
+    >
+      {props.children}
+    </Suspense>
+  );
+};
+
+export default WithSuspense;
@@ -1,4 +1,4 @@
-import { ModalRoot, QuickAccessTab, Router, Spinner, staticClasses } from 'decky-frontend-lib';
+import { ConfirmModal, QuickAccessTab, Router, Spinner, staticClasses } from 'decky-frontend-lib';
 import { FC, useState } from 'react';

 interface PluginInstallModalProps {
@@ -14,13 +14,14 @@ interface PluginInstallModalProps {
 const PluginInstallModal: FC<PluginInstallModalProps> = ({ artifact, version, hash, onOK, onCancel, closeModal }) => {
  const [loading, setLoading] = useState<boolean>(false);
  return (
-    <ModalRoot
+    <ConfirmModal
      bOKDisabled={loading}
      closeModal={closeModal}
      onOK={async () => {
        setLoading(true);
        await onOK();
        setTimeout(() => Router.OpenQuickAccessMenu(QuickAccessTab.Decky), 250);
+        setTimeout(() => window.DeckyPluginLoader.checkPluginUpdates(), 1000);
      }}
      onCancel={async () => {
        await onCancel();
@@ -34,7 +35,7 @@ const PluginInstallModal: FC<PluginInstallModalProps> = ({ artifact, version, ha
          {!loading && '?'}
        </div>
      </div>
-    </ModalRoot>
+    </ConfirmModal>
  );
 };

@@ -0,0 +1,170 @@
+// https://codesandbox.io/s/react-file-icon-colored-tmwut?file=/src/App.js
+import { FileIconProps } from 'react-file-icon';
+
+type T_FileExtList = string[];
+
+const styleDef: [FileIconProps, T_FileExtList][] = [];
+
+// video ////////////////////////////////////
+const videoStyle = {
+  color: '#f00f0f',
+};
+const videoExtList = [
+  'avi',
+  '3g2',
+  '3gp',
+  'aep',
+  'asf',
+  'flv',
+  'm4v',
+  'mkv',
+  'mov',
+  'mp4',
+  'mpeg',
+  'mpg',
+  'ogv',
+  'pr',
+  'swfw',
+  'webm',
+  'wmv',
+  'swf',
+  'rm',
+];
+
+styleDef.push([videoStyle, videoExtList]);
+
+// image ////////////////////////////////////
+const imageStyle = {
+  color: '#d18f00',
+};
+
+const imageExtList = ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tif', 'tiff'];
+
+styleDef.push([imageStyle, imageExtList]);
+
+// zip ////////////////////////////////////
+const zipStyle = {
+  color: '#f7b500',
+  labelTextColor: '#000',
+  // glyphColor: "#de9400"
+};
+
+const zipExtList = ['zip', 'zipx', '7zip', 'tar', 'sitx', 'gz', 'rar'];
+
+styleDef.push([zipStyle, zipExtList]);
+
+// audio ////////////////////////////////////
+const audioStyle = {
+  color: '#f00f0f',
+};
+
+const audioExtList = ['aac', 'aif', 'aiff', 'flac', 'm4a', 'mid', 'mp3', 'ogg', 'wav'];
+
+styleDef.push([audioStyle, audioExtList]);
+
+// text ////////////////////////////////////
+const textStyle = {
+  color: '#ffffff',
+  glyphColor: '#787878',
+};
+
+const textExtList = ['cue', 'odt', 'md', 'rtf', 'txt', 'tex', 'wpd', 'wps', 'xlr', 'fodt'];
+
+styleDef.push([textStyle, textExtList]);
+
+// system ////////////////////////////////////
+const systemStyle = {
+  color: '#111',
+};
+
+const systemExtList = ['exe', 'ini', 'dll', 'plist', 'sys'];
+
+styleDef.push([systemStyle, systemExtList]);
+
+// srcCode ////////////////////////////////////
+const srcCodeStyle = {
+  glyphColor: '#787878',
+  color: '#ffffff',
+};
+
+const srcCodeExtList = [
+  'asp',
+  'aspx',
+  'c',
+  'cpp',
+  'cs',
+  'css',
+  'scss',
+  'py',
+  'json',
+  'htm',
+  'html',
+  'java',
+  'yml',
+  'php',
+  'js',
+  'ts',
+  'rb',
+  'jsx',
+  'tsx',
+];
+
+styleDef.push([srcCodeStyle, srcCodeExtList]);
+
+// vector ////////////////////////////////////
+const vectorStyle = {
+  color: '#ffe600',
+};
+
+const vectorExtList = ['dwg', 'dxf', 'ps', 'svg', 'eps'];
+
+styleDef.push([vectorStyle, vectorExtList]);
+
+// font ////////////////////////////////////
+const fontStyle = {
+  color: '#555',
+};
+
+const fontExtList = ['fnt', 'ttf', 'otf', 'fon', 'eot', 'woff'];
+
+styleDef.push([fontStyle, fontExtList]);
+
+// objectModel ////////////////////////////////////
+const objectModelStyle = {
+  color: '#bf6a02',
+  glyphColor: '#bf6a02',
+};
+
+const objectModelExtList = ['3dm', '3ds', 'max', 'obj', 'pkg'];
+
+styleDef.push([objectModelStyle, objectModelExtList]);
+
+// sheet ////////////////////////////////////
+const sheetStyle = {
+  color: '#2a6e00',
+};
+
+const sheetExtList = ['csv', 'fods', 'ods', 'xlr'];
+
+styleDef.push([sheetStyle, sheetExtList]);
+
+// const defaultStyle: Record<string, FileIconProps> = {
+//   pdf: {
+// glyphColor: "white",
+// color: "#D93831"
+//   }
+// };
+
+//////////////////////////////////////////////////
+
+function createStyleObj(extList: T_FileExtList, styleObj: Partial<FileIconProps>) {
+  return Object.fromEntries(
+    extList.map((ext) => {
+      return [ext, { ...styleObj, glyphColor: 'white' }];
+    }),
+  );
+}
+
+export const styleDefObj = styleDef.reduce((acc, [fileStyle, fileExtList]) => {
+  return { ...acc, ...createStyleObj(fileExtList, fileStyle) };
+});
@@ -0,0 +1,160 @@
+import { DialogButton, Focusable, SteamSpinner, TextField } from 'decky-frontend-lib';
+import { useEffect } from 'react';
+import { FunctionComponent, useState } from 'react';
+import { FileIcon, defaultStyles } from 'react-file-icon';
+import { FaArrowUp, FaFolder } from 'react-icons/fa';
+
+import Logger from '../../../logger';
+import { styleDefObj } from './iconCustomizations';
+
+const logger = new Logger('FilePicker');
+
+export interface FilePickerProps {
+  startPath: string;
+  includeFiles?: boolean;
+  regex?: RegExp;
+  onSubmit: (val: { path: string; realpath: string }) => void;
+  closeModal?: () => void;
+}
+
+interface File {
+  isdir: boolean;
+  name: string;
+  realpath: string;
+}
+
+interface FileListing {
+  realpath: string;
+  files: File[];
+}
+
+function getList(
+  path: string,
+  includeFiles: boolean = true,
+): Promise<{ result: FileListing | string; success: boolean }> {
+  return window.DeckyPluginLoader.callServerMethod('filepicker_ls', { path, include_files: includeFiles });
+}
+
+const iconStyles = {
+  paddingRight: '10px',
+  width: '1em',
+};
+
+const FilePicker: FunctionComponent<FilePickerProps> = ({
+  startPath,
+  includeFiles = true,
+  regex,
+  onSubmit,
+  closeModal,
+}) => {
+  if (startPath.endsWith('/')) startPath = startPath.substring(0, startPath.length - 1); // remove trailing path
+  const [path, setPath] = useState<string>(startPath);
+  const [listing, setListing] = useState<FileListing>({ files: [], realpath: path });
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState<boolean>(true);
+
+  useEffect(() => {
+    (async () => {
+      if (error) setError(null);
+      setLoading(true);
+      const listing = await getList(path, includeFiles);
+      if (!listing.success) {
+        setListing({ files: [], realpath: path });
+        setLoading(false);
+        setError(listing.result as string);
+        logger.error(listing.result);
+        return;
+      }
+      setLoading(false);
+      setListing(listing.result as FileListing);
+      logger.log('reloaded', path, listing);
+    })();
+  }, [path]);
+
+  return (
+    <div className="deckyFilePicker">
+      <Focusable style={{ display: 'flex', flexDirection: 'row', paddingBottom: '10px' }}>
+        <DialogButton
+          style={{
+            minWidth: 'unset',
+            width: '40px',
+            flexGrow: '0',
+            borderRadius: 'unset',
+            margin: '0',
+            padding: '10px',
+          }}
+          onClick={() => {
+            const newPathArr = path.split('/');
+            newPathArr.pop();
+            let newPath = newPathArr.join('/');
+            if (newPath == '') newPath = '/';
+            setPath(newPath);
+          }}
+        >
+          <FaArrowUp />
+        </DialogButton>
+        <div style={{ flexGrow: '1', width: '100%' }}>
+          <TextField
+            value={path}
+            onChange={(e) => {
+              e.target.value && setPath(e.target.value);
+            }}
+            style={{ height: '100%' }}
+          />
+        </div>
+      </Focusable>
+      <Focusable style={{ display: 'flex', flexDirection: 'column', height: '60vh', overflow: 'scroll' }}>
+        {loading && <SteamSpinner style={{ height: '100%' }} />}
+        {!loading &&
+          listing.files
+            .filter((file) => (includeFiles || file.isdir) && (!regex || regex.test(file.name)))
+            .map((file) => {
+              let extension = file.realpath.split('.').pop() as string;
+              return (
+                <DialogButton
+                  style={{ borderRadius: 'unset', margin: '0', padding: '10px' }}
+                  onClick={() => {
+                    const fullPath = `${path}${path.endsWith('/') ? '' : '/'}${file.name}`;
+                    if (file.isdir) setPath(fullPath);
+                    else {
+                      onSubmit({ path: fullPath, realpath: file.realpath });
+                      closeModal?.();
+                    }
+                  }}
+                >
+                  <div style={{ display: 'flex', flexDirection: 'row', alignItems: 'flex-start' }}>
+                    {file.isdir ? (
+                      <FaFolder style={iconStyles} />
+                    ) : (
+                      <div style={iconStyles}>
+                        {file.realpath.includes('.') ? (
+                          <FileIcon {...defaultStyles[extension]} {...styleDefObj[extension]} extension={''} />
+                        ) : (
+                          <FileIcon />
+                        )}
+                      </div>
+                    )}
+                    {file.name}
+                  </div>
+                </DialogButton>
+              );
+            })}
+        {error}
+      </Focusable>
+      {!loading && !error && !includeFiles && (
+        <DialogButton
+          className="Primary"
+          style={{ marginTop: '10px', alignSelf: 'flex-end' }}
+          onClick={() => {
+            onSubmit({ path, realpath: listing.realpath });
+            closeModal?.();
+          }}
+        >
+          Use this folder
+        </DialogButton>
+      )}
+    </div>
+  );
+};
+
+export default FilePicker;
@@ -0,0 +1 @@
+This directory contains patches that replace Valve's broken file picker with ours.
@@ -0,0 +1,10 @@
+import library from './library';
+let patches: Function[] = [];
+
+export function deinitFilepickerPatches() {
+  patches.forEach((unpatch) => unpatch());
+}
+
+export async function initFilepickerPatches() {
+  patches.push(await library());
+}
@@ -0,0 +1,57 @@
+import { Patch, findModuleChild, replacePatch } from 'decky-frontend-lib';
+
+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 within the first 20s of the last patch
+  patch = replacePatch(window.SteamClient.Apps, 'PromptToChangeShortcut', async ([appid]: number[]) => {
+    try {
+      const details = window.appDetailsStore.GetAppDetails(appid);
+      console.log(details);
+      // strShortcutStartDir
+      const file = await window.DeckyPluginLoader.openFilePicker(details.strShortcutStartDir.replaceAll('"', ''));
+      console.log('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);
+    }
+  });
+}
+
+// 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();
+    const unlisten = History.listen(() => {
+      if (window.SteamClient.Apps.PromptToChangeShortcut !== patch.patchedFunction) {
+        rePatch();
+      }
+    });
+
+    return () => {
+      patch.unpatch();
+      unlisten();
+    };
+  } catch (e) {
+    console.error('Error patching library file picker', e);
+  }
+  return () => {};
+}
@@ -0,0 +1,21 @@
+import { Focusable, updaterFieldClasses } from 'decky-frontend-lib';
+import { FunctionComponent, ReactNode } from 'react';
+
+interface InlinePatchNotesProps {
+  date: ReactNode;
+  title: string;
+  children: ReactNode;
+  onClick?: () => void;
+}
+
+const InlinePatchNotes: FunctionComponent<InlinePatchNotesProps> = ({ date, title, children, onClick }) => {
+  return (
+    <Focusable className={updaterFieldClasses.PatchNotes} onActivate={onClick}>
+      <div className={updaterFieldClasses.PostedTime}>{date}</div>
+      <div className={updaterFieldClasses.EventDetailTitle}>{title}</div>
+      <div className={updaterFieldClasses.EventDetailsBody}>{children}</div>
+    </Focusable>
+  );
+};
+
+export default InlinePatchNotes;
@@ -0,0 +1,41 @@
+import { Dropdown, Field } from 'decky-frontend-lib';
+import { FunctionComponent } from 'react';
+
+import Logger from '../../../../logger';
+import { callUpdaterMethod } from '../../../../updater';
+import { useSetting } from '../../../../utils/hooks/useSetting';
+
+const logger = new Logger('BranchSelect');
+
+enum UpdateBranch {
+  Stable,
+  Prerelease,
+  // Nightly,
+}
+
+const BranchSelect: FunctionComponent<{}> = () => {
+  const [selectedBranch, setSelectedBranch] = useSetting<UpdateBranch>('branch', UpdateBranch.Prerelease);
+
+  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">
+      <Dropdown
+        rgOptions={Object.values(UpdateBranch)
+          .filter((branch) => typeof branch == 'string')
+          .map((branch) => ({
+            label: branch,
+            data: UpdateBranch[branch],
+          }))}
+        selectedOption={selectedBranch}
+        onChange={async (newVal) => {
+          await setSelectedBranch(newVal.data);
+          callUpdaterMethod('check_for_updates');
+          logger.log('switching branches!');
+        }}
+      />
+    </Field>
+  );
+};
+
+export default BranchSelect;
@@ -1,15 +1,10 @@
 import { Field, Toggle } from 'decky-frontend-lib';
-import { useEffect, useState } from 'react';
 import { FaBug } from 'react-icons/fa';

+import { useSetting } from '../../../../utils/hooks/useSetting';
+
 export default function RemoteDebuggingSettings() {
-  const [allowRemoteDebugging, setAllowRemoteDebugging] = useState<boolean>(false);
-  useEffect(() => {
-    (async () => {
-      const res = (await window.DeckyPluginLoader.callServerMethod('remote_debugging_allowed')) as { result: boolean };
-      setAllowRemoteDebugging(res.result);
-    })();
-  }, []);
+  const [allowRemoteDebugging, setAllowRemoteDebugging] = useSetting<boolean>('cef_forward', false);

  return (
    <Field
@@ -22,7 +17,7 @@ export default function RemoteDebuggingSettings() {
      icon={<FaBug style={{ display: 'block' }} />}
    >
      <Toggle
-        value={allowRemoteDebugging}
+        value={allowRemoteDebugging || false}
        onChange={(toggleValue) => {
          setAllowRemoteDebugging(toggleValue);
          if (toggleValue) window.DeckyPluginLoader.callServerMethod('allow_remote_debugging');
@@ -1,24 +1,74 @@
-import { DialogButton, Field, ProgressBarWithInfo, Spinner } from 'decky-frontend-lib';
+import {
+  Carousel,
+  DialogButton,
+  Field,
+  FocusRing,
+  Focusable,
+  ProgressBarWithInfo,
+  Spinner,
+  showModal,
+} from 'decky-frontend-lib';
+import { useCallback } from 'react';
+import { Suspense, lazy } from 'react';
 import { useEffect, useState } from 'react';
 import { FaArrowDown } from 'react-icons/fa';

 import { VerInfo, callUpdaterMethod, finishUpdate } from '../../../../updater';
 import { useDeckyState } from '../../../DeckyState';
+import InlinePatchNotes from '../../../patchnotes/InlinePatchNotes';
+import WithSuspense from '../../../WithSuspense';
+
+const MarkdownRenderer = lazy(() => import('../../../Markdown'));
+
+function PatchNotesModal({ versionInfo, closeModal }: { versionInfo: VerInfo | null; closeModal?: () => {} }) {
+  return (
+    <Focusable onCancelButton={closeModal}>
+      <FocusRing>
+        <Carousel
+          fnItemRenderer={(id: number) => (
+            <Focusable
+              style={{
+                marginTop: '40px',
+                height: 'calc( 100% - 40px )',
+                overflowY: 'scroll',
+                display: 'flex',
+                justifyContent: 'center',
+                margin: '40px',
+              }}
+            >
+              <div>
+                <h1>{versionInfo?.all?.[id]?.name}</h1>
+                {versionInfo?.all?.[id]?.body ? (
+                  <WithSuspense>
+                    <MarkdownRenderer onDismiss={closeModal}>{versionInfo.all[id].body}</MarkdownRenderer>
+                  </WithSuspense>
+                ) : (
+                  'no patch notes for this version'
+                )}
+              </div>
+            </Focusable>
+          )}
+          fnGetId={(id) => id}
+          nNumItems={versionInfo?.all?.length}
+          nHeight={window.innerHeight - 40}
+          nItemHeight={window.innerHeight - 40}
+          nItemMarginX={0}
+          initialColumn={0}
+          autoFocus={true}
+          fnGetColumnWidth={() => window.innerWidth}
+        />
+      </FocusRing>
+    </Focusable>
+  );
+}

 export default function UpdaterSettings() {
-  const [versionInfo, setVersionInfo] = useState<VerInfo | null>(null);
+  const { isLoaderUpdating, setIsLoaderUpdating, versionInfo, setVersionInfo } = useDeckyState();
+
  const [checkingForUpdates, setCheckingForUpdates] = useState<boolean>(false);
-  const { isLoaderUpdating, setIsLoaderUpdating } = useDeckyState();
  const [updateProgress, setUpdateProgress] = useState<number>(-1);
  const [reloading, setReloading] = useState<boolean>(false);

-  useEffect(() => {
-    (async () => {
-      const res = (await callUpdaterMethod('get_version')) as { result: VerInfo };
-      setVersionInfo(res.result);
-    })();
-  }, []);
-
  useEffect(() => {
    window.DeckyUpdater = {
      updateProgress: (i) => {
@@ -33,56 +83,80 @@ export default function UpdaterSettings() {
    };
  }, []);

+  const showPatchNotes = useCallback(() => {
+    showModal(<PatchNotesModal versionInfo={versionInfo} />);
+  }, [versionInfo]);
+
  return (
-    <Field
-      label="Updates"
-      description={
-        versionInfo && (
-          <span style={{ whiteSpace: 'pre-line' }}>{`Current version: ${versionInfo.current}\n${
-            versionInfo.updatable ? `Latest version: ${versionInfo.remote?.tag_name}` : ''
-          }`}</span>
-        )
-      }
-      icon={
-        !versionInfo ? (
-          <Spinner style={{ width: '1em', height: 20, display: 'block' }} />
+    <>
+      <Field
+        onOptionsActionDescription={versionInfo?.all ? 'Patch Notes' : undefined}
+        onOptionsButton={versionInfo?.all ? showPatchNotes : undefined}
+        label="Updates"
+        description={
+          versionInfo && (
+            <span style={{ whiteSpace: 'pre-line' }}>{`Current version: ${versionInfo.current}\n${
+              versionInfo.updatable ? `Latest version: ${versionInfo.remote?.tag_name}` : ''
+            }`}</span>
+          )
+        }
+        icon={
+          !versionInfo ? (
+            <Spinner style={{ width: '1em', height: 20, display: 'block' }} />
+          ) : (
+            <FaArrowDown style={{ display: 'block' }} />
+          )
+        }
+      >
+        {updateProgress == -1 && !isLoaderUpdating ? (
+          <DialogButton
+            disabled={!versionInfo?.updatable || checkingForUpdates}
+            onClick={
+              !versionInfo?.remote || versionInfo?.remote?.tag_name == versionInfo?.current
+                ? async () => {
+                    setCheckingForUpdates(true);
+                    const res = (await callUpdaterMethod('check_for_updates')) as { result: VerInfo };
+                    setVersionInfo(res.result);
+                    setCheckingForUpdates(false);
+                  }
+                : async () => {
+                    setUpdateProgress(0);
+                    callUpdaterMethod('do_update');
+                  }
+            }
+          >
+            {checkingForUpdates
+              ? 'Checking'
+              : !versionInfo?.remote || versionInfo?.remote?.tag_name == versionInfo?.current
+              ? 'Check For Updates'
+              : 'Install Update'}
+          </DialogButton>
        ) : (
-          <FaArrowDown style={{ display: 'block' }} />
-        )
-      }
-    >
-      {updateProgress == -1 && !isLoaderUpdating ? (
-        <DialogButton
-          disabled={!versionInfo?.updatable || checkingForUpdates}
-          onClick={
-            !versionInfo?.remote || versionInfo?.remote?.tag_name == versionInfo?.current
-              ? async () => {
-                  setCheckingForUpdates(true);
-                  const res = (await callUpdaterMethod('check_for_updates')) as { result: VerInfo };
-                  setVersionInfo(res.result);
-                  setCheckingForUpdates(false);
-                }
-              : async () => {
-                  setUpdateProgress(0);
-                  callUpdaterMethod('do_update');
-                }
-          }
+          <ProgressBarWithInfo
+            layout="inline"
+            bottomSeparator="none"
+            nProgress={updateProgress}
+            indeterminate={reloading}
+            sOperationText={reloading ? 'Reloading' : 'Updating'}
+          />
+        )}
+      </Field>
+      {versionInfo?.remote && (
+        <InlinePatchNotes
+          title={versionInfo?.remote.name}
+          date={new Intl.RelativeTimeFormat('en-US', {
+            numeric: 'auto',
+          }).format(
+            Math.ceil((new Date(versionInfo.remote.published_at).getTime() - new Date().getTime()) / 86400000),
+            'day',
+          )}
+          onClick={showPatchNotes}
        >
-          {checkingForUpdates
-            ? 'Checking'
-            : !versionInfo?.remote || versionInfo?.remote?.tag_name == versionInfo?.current
-            ? 'Check For Updates'
-            : 'Install Update'}
-        </DialogButton>
-      ) : (
-        <ProgressBarWithInfo
-          layout="inline"
-          bottomSeparator={false}
-          nProgress={updateProgress}
-          indeterminate={reloading}
-          sOperationText={reloading ? 'Reloading' : 'Updating'}
-        />
+          <Suspense fallback={<Spinner style={{ width: '24', height: '24' }} />}>
+            <MarkdownRenderer>{versionInfo?.remote.body}</MarkdownRenderer>
+          </Suspense>
+        </InlinePatchNotes>
      )}
-    </Field>
+    </>
  );
 }
@@ -3,6 +3,7 @@ import { useState } from 'react';
 import { FaShapes } from 'react-icons/fa';

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

@@ -21,6 +22,7 @@ export default function GeneralSettings() {
        />
      </Field> */}
      <UpdaterSettings />
+      <BranchSelect />
      <RemoteDebuggingSettings />
      <Field
        label="Manual plugin install"
@@ -1,9 +1,12 @@
 import { SteamSpinner } from 'decky-frontend-lib';
 import { FC, useEffect, useState } from 'react';

+import Logger from '../../logger';
 import { LegacyStorePlugin, StorePlugin, getLegacyPluginList, getPluginList } from '../../store';
 import PluginCard from './PluginCard';

+const logger = new Logger('FilePicker');
+
 const StorePage: FC<{}> = () => {
  const [data, setData] = useState<StorePlugin[] | null>(null);
  const [legacyData, setLegacyData] = useState<LegacyStorePlugin[] | null>(null);
@@ -11,12 +14,12 @@ const StorePage: FC<{}> = () => {
  useEffect(() => {
    (async () => {
      const res = await getPluginList();
-      console.log(res);
+      logger.log('got data!', res);
      setData(res);
    })();
    (async () => {
      const res = await getLegacyPluginList();
-      console.log(res);
+      logger.log('got legacy data!', res);
      setLegacyData(res);
    })();
  }, []);
@@ -19,7 +19,7 @@ export const debug = (name: string, ...args: any[]) => {
 };

 export const error = (name: string, ...args: any[]) => {
-  console.log(
+  console.error(
    `%c Decky %c ${name} %c`,
    'background: #16a085; color: black;',
    'background: #FF0000;',
@@ -40,6 +40,10 @@ class Logger {
  debug(...args: any[]) {
    debug(this.name, ...args);
  }
+
+  error(...args: any[]) {
+    error(this.name, ...args);
+  }
 }

 export default Logger;
@@ -1,14 +1,27 @@
-import { ModalRoot, QuickAccessTab, Router, showModal, sleep, staticClasses } from 'decky-frontend-lib';
+import {
+  ConfirmModal,
+  ModalRoot,
+  Patch,
+  QuickAccessTab,
+  Router,
+  callOriginal,
+  findModuleChild,
+  replacePatch,
+  showModal,
+  sleep,
+  staticClasses,
+} from 'decky-frontend-lib';
+import { lazy } from 'react';
 import { FaPlug } from 'react-icons/fa';

 import { DeckyState, DeckyStateContextProvider, useDeckyState } from './components/DeckyState';
 import LegacyPlugin from './components/LegacyPlugin';
+import { deinitFilepickerPatches, initFilepickerPatches } from './components/modals/filepicker/patches';
 import PluginInstallModal from './components/modals/PluginInstallModal';
 import NotificationBadge from './components/NotificationBadge';
 import PluginView from './components/PluginView';
-import SettingsPage from './components/settings';
-import StorePage from './components/store/Store';
 import TitleView from './components/TitleView';
+import WithSuspense from './components/WithSuspense';
 import Logger from './logger';
 import { Plugin } from './plugin';
 import RouterHook from './router-hook';
@@ -17,6 +30,11 @@ import TabsHook from './tabs-hook';
 import Toaster from './toaster';
 import { VerInfo, callUpdaterMethod } from './updater';

+const StorePage = lazy(() => import('./components/store/Store'));
+const SettingsPage = lazy(() => import('./components/settings'));
+
+const FilePicker = lazy(() => import('./components/modals/filepicker'));
+
 declare global {
  interface Window {}
 }
@@ -33,11 +51,13 @@ class PluginLoader extends Logger {
  // stores a list of plugin names which requested to be reloaded
  private pluginReloadQueue: { name: string; version?: string }[] = [];

+  private focusWorkaroundPatch?: Patch;
+
  constructor() {
    super(PluginLoader.name);
    this.log('Initialized');

-    const TabIcon = () => {
+    const TabBadge = () => {
      const { updates, hasLoaderUpdate } = useDeckyState();
      return <NotificationBadge show={(updates && updates.size > 0) || hasLoaderUpdate} />;
    };
@@ -53,26 +73,73 @@ class PluginLoader extends Logger {
      ),
      icon: (
        <DeckyStateContextProvider deckyState={this.deckyState}>
-          <>
-            <FaPlug />
-            <TabIcon />
-          </>
+          <FaPlug />
+          <TabBadge />
        </DeckyStateContextProvider>
      ),
    });

-    this.routerHook.addRoute('/decky/store', () => <StorePage />);
+    this.routerHook.addRoute('/decky/store', () => (
+      <WithSuspense route={true}>
+        <StorePage />
+      </WithSuspense>
+    ));
    this.routerHook.addRoute('/decky/settings', () => {
      return (
        <DeckyStateContextProvider deckyState={this.deckyState}>
-          <SettingsPage />
+          <WithSuspense route={true}>
+            <SettingsPage />
+          </WithSuspense>
        </DeckyStateContextProvider>
      );
    });
+
+    initFilepickerPatches();
+
+    this.updateVersion();
+
+    const self = this;
+
+    try {
+      // TODO remove all of this once Valve fixes the bug
+      const focusManager = findModuleChild((m) => {
+        if (typeof m !== 'object') return false;
+        for (let prop in m) {
+          if (m[prop]?.prototype?.TakeFocus) return m[prop];
+        }
+        return false;
+      });
+
+      this.focusWorkaroundPatch = replacePatch(focusManager.prototype, 'TakeFocus', function () {
+        // @ts-ignore
+        const classList = this.m_node?.m_element.classList;
+        if (
+          // @ts-ignore
+          (this.m_node?.m_element && classList.contains(staticClasses.TabGroupPanel)) ||
+          classList.contains('FriendsListTab') ||
+          classList.contains('FriendsTabList') ||
+          classList.contains('FriendsListAndChatsSteamDeck')
+        ) {
+          self.debug('Intercepted friends re-focus');
+          return true;
+        }
+
+        return callOriginal;
+      });
+    } catch (e) {
+      this.error('Friends focus patch failed', e);
+    }
+  }
+
+  public async updateVersion() {
+    const versionInfo = (await callUpdaterMethod('get_version')).result as VerInfo;
+    this.deckyState.setVersionInfo(versionInfo);
+
+    return versionInfo;
  }

  public async notifyUpdates() {
-    const versionInfo = (await callUpdaterMethod('get_version')).result as VerInfo;
+    const versionInfo = await this.updateVersion();
    if (versionInfo?.remote && versionInfo?.remote?.tag_name != versionInfo?.current) {
      this.toaster.toast({
        title: 'Decky',
@@ -116,18 +183,9 @@ class PluginLoader extends Logger {

  public uninstallPlugin(name: string) {
    showModal(
-      <ModalRoot
+      <ConfirmModal
        onOK={async () => {
-          const formData = new FormData();
-          formData.append('name', name);
-          await fetch('http://localhost:1337/browser/uninstall_plugin', {
-            method: 'POST',
-            body: formData,
-            credentials: 'include',
-            headers: {
-              Authentication: window.deckyAuthToken,
-            },
-          });
+          await this.callServerMethod('uninstall_plugin', { name });
        }}
        onCancel={() => {
          // do nothing
@@ -136,7 +194,7 @@ class PluginLoader extends Logger {
        <div className={staticClasses.Title} style={{ flexDirection: 'column' }}>
          Uninstall {name}?
        </div>
-      </ModalRoot>,
+      </ConfirmModal>,
    );
  }

@@ -154,6 +212,8 @@ class PluginLoader extends Logger {
  public deinit() {
    this.routerHook.removeRoute('/decky/store');
    this.routerHook.removeRoute('/decky/settings');
+    deinitFilepickerPatches();
+    this.focusWorkaroundPatch?.unpatch();
  }

  public unloadPlugin(name: string) {
@@ -203,7 +263,8 @@ class PluginLoader extends Logger {
      },
    });
    if (res.ok) {
-      let plugin = await eval(await res.text())(this.createPluginAPI(name));
+      let plugin_export = await eval(await res.text());
+      let plugin = plugin_export(this.createPluginAPI(name));
      this.plugins.push({
        ...plugin,
        name: name,
@@ -235,11 +296,41 @@ class PluginLoader extends Logger {
    return response.json();
  }

+  openFilePicker(
+    startPath: string,
+    includeFiles?: boolean,
+    regex?: RegExp,
+  ): Promise<{ path: string; realpath: string }> {
+    return new Promise((resolve, reject) => {
+      const Content = ({ closeModal }: { closeModal?: () => void }) => (
+        // Purposely outside of the FilePicker component as lazy-loaded ModalRoots don't focus correctly
+        <ModalRoot
+          onCancel={() => {
+            reject('User canceled');
+            closeModal?.();
+          }}
+        >
+          <WithSuspense>
+            <FilePicker
+              startPath={startPath}
+              includeFiles={includeFiles}
+              regex={regex}
+              onSubmit={resolve}
+              closeModal={closeModal}
+            />
+          </WithSuspense>
+        </ModalRoot>
+      );
+      showModal(<Content />);
+    });
+  }
+
  createPluginAPI(pluginName: string) {
    return {
      routerHook: this.routerHook,
      toaster: this.toaster,
      callServerMethod: this.callServerMethod,
+      openFilePicker: this.openFilePicker,
      async callPluginMethod(methodName: string, args = {}) {
        const response = await fetch(`http://127.0.0.1:1337/plugins/${pluginName}/methods/${methodName}`, {
          method: 'POST',
@@ -1,4 +1,4 @@
-import { afterPatch, findModuleChild, unpatch } from 'decky-frontend-lib';
+import { Patch, afterPatch, findModuleChild } from 'decky-frontend-lib';
 import { ReactElement, ReactNode, cloneElement, createElement, memo } from 'react';
 import type { Route } from 'react-router';

@@ -22,6 +22,8 @@ class RouterHook extends Logger {
  private memoizedRouter: any;
  private gamepadWrapper: any;
  private routerState: DeckyRouterState = new DeckyRouterState();
+  private wrapperPatch: Patch;
+  private routerPatch?: Patch;

  constructor() {
    super('RouterHook');
@@ -87,7 +89,7 @@ class RouterHook extends Logger {
      return children;
    };

-    afterPatch(this.gamepadWrapper, 'render', (_: any, ret: any) => {
+    this.wrapperPatch = afterPatch(this.gamepadWrapper, 'render', (_: any, ret: any) => {
      if (ret?.props?.children?.props?.children?.length == 5) {
        if (
          ret.props.children.props.children[2]?.props?.children?.[0]?.type?.type
@@ -96,7 +98,7 @@ class RouterHook extends Logger {
        ) {
          if (!this.router) {
            this.router = ret.props.children.props.children[2]?.props?.children?.[0]?.type;
-            afterPatch(this.router, 'type', (_: any, ret: any) => {
+            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;
              const returnVal = (
@@ -133,8 +135,8 @@ class RouterHook extends Logger {
  }

  deinit() {
-    unpatch(this.gamepadWrapper, 'render');
-    this.router && unpatch(this.router, 'type');
+    this.wrapperPatch.unpatch();
+    this.routerPatch?.unpatch();
  }
 }

@@ -1,4 +1,4 @@
-import { ModalRoot, showModal, staticClasses } from 'decky-frontend-lib';
+import { ConfirmModal, showModal, staticClasses } from 'decky-frontend-lib';

 import { Plugin } from './plugin';

@@ -42,36 +42,22 @@ export function getLegacyPluginList(): Promise<LegacyStorePlugin[]> {
 }

 export async function installFromURL(url: string) {
-  const formData = new FormData();
  const splitURL = url.split('/');
-  formData.append('name', splitURL[splitURL.length - 1].replace('.zip', ''));
-  formData.append('artifact', url);
-  await fetch('http://localhost:1337/browser/install_plugin', {
-    method: 'POST',
-    body: formData,
-    credentials: 'include',
-    headers: {
-      Authentication: window.deckyAuthToken,
-    },
+  await window.DeckyPluginLoader.callServerMethod('install_plugin', {
+    name: splitURL[splitURL.length - 1].replace('.zip', ''),
+    artifact: url,
  });
 }

 export function requestLegacyPluginInstall(plugin: LegacyStorePlugin, selectedVer: string) {
  showModal(
-    <ModalRoot
+    <ConfirmModal
      onOK={() => {
-        const formData = new FormData();
-        formData.append('name', plugin.artifact);
-        formData.append('artifact', `https://github.com/${plugin.artifact}/archive/refs/tags/${selectedVer}.zip`);
-        formData.append('version', selectedVer);
-        formData.append('hash', plugin.versions[selectedVer]);
-        fetch('http://localhost:1337/browser/install_plugin', {
-          method: 'POST',
-          body: formData,
-          credentials: 'include',
-          headers: {
-            Authentication: window.deckyAuthToken,
-          },
+        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={() => {
@@ -84,23 +70,16 @@ export function requestLegacyPluginInstall(plugin: LegacyStorePlugin, selectedVe
      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.
-    </ModalRoot>,
+    </ConfirmModal>,
  );
 }

 export async function requestPluginInstall(plugin: string, selectedVer: StorePluginVersion) {
-  const formData = new FormData();
-  formData.append('name', plugin);
-  formData.append('artifact', `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/versions/${selectedVer.hash}.zip`);
-  formData.append('version', selectedVer.name);
-  formData.append('hash', selectedVer.hash);
-  await fetch('http://localhost:1337/browser/install_plugin', {
-    method: 'POST',
-    body: formData,
-    credentials: 'include',
-    headers: {
-      Authentication: window.deckyAuthToken,
-    },
+  await window.DeckyPluginLoader.callServerMethod('install_plugin', {
+    name: plugin,
+    artifact: `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/versions/${selectedVer.hash}.zip`,
+    version: selectedVer.name,
+    hash: selectedVer.hash,
  });
 }

@@ -1,4 +1,4 @@
-import { QuickAccessTab, afterPatch, sleep, unpatch } from 'decky-frontend-lib';
+import { Patch, QuickAccessTab, afterPatch, sleep } from 'decky-frontend-lib';
 import { memo } from 'react';

 import Logger from './logger';
@@ -35,6 +35,8 @@ class TabsHook extends Logger {
  private qAPTree: any;
  private rendererTree: any;

+  private cNodePatch?: Patch;
+
  constructor() {
    super('TabsHook');

@@ -45,22 +47,29 @@ class TabsHook extends Logger {
    const self = this;
    const tree = (document.getElementById('root') as any)._reactRootContainer._internalRoot.current;
    let scrollRoot: any;
-    let currentNode = tree;
+    async function findScrollRoot(currentNode: any, iters: number): Promise<any> {
+      if (iters >= 30) {
+        await sleep(5000);
+        return await findScrollRoot(tree, 0);
+      }
+      currentNode = currentNode?.child;
+      if (currentNode?.type?.prototype?.RemoveSmartScrollContainer) return currentNode;
+      if (!currentNode) return null;
+      if (currentNode.sibling) {
+        let node = await findScrollRoot(currentNode.sibling, iters++);
+        if (node !== null) return node;
+      }
+      return await findScrollRoot(currentNode, iters++);
+    }
    (async () => {
-      let iters = 0;
-      while (!scrollRoot) {
-        iters++;
-        currentNode = currentNode?.child;
-        if (iters >= 30 || !currentNode) {
-          iters = 0;
-          currentNode = tree;
-          await sleep(5000);
-        }
-        if (currentNode?.type?.prototype?.RemoveSmartScrollContainer) scrollRoot = currentNode;
+      scrollRoot = await findScrollRoot(tree, 0);
+      if (!scrollRoot) {
+        this.error('Failed to find scroll root node!');
+        return;
      }
      let newQA: any;
      let newQATabRenderer: any;
-      afterPatch(scrollRoot.stateNode, 'render', (_: any, ret: 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) => {
@@ -99,11 +108,12 @@ class TabsHook extends Logger {
      });
      this.cNode = scrollRoot;
      this.cNode.stateNode.forceUpdate();
+      this.log('Finished initial injection');
    })();
  }

  deinit() {
-    if (this.cNode) unpatch(this.cNode.stateNode, 'render');
+    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();
@@ -1,4 +1,5 @@
-import { ToastData, afterPatch, findInReactTree, findModuleChild, sleep, unpatch } from 'decky-frontend-lib';
+import { Patch, ToastData, afterPatch, findInReactTree, findModuleChild, sleep } from 'decky-frontend-lib';
+import { ReactNode } from 'react';

 import Toast from './components/Toast';
 import Logger from './logger';
@@ -11,9 +12,10 @@ declare global {
 }

 class Toaster extends Logger {
-  private instanceRet: any;
+  private instanceRetPatch?: Patch;
  private node: any;
  private settingsModule: any;
+  private ready: boolean = false;

  constructor() {
    super('Toaster');
@@ -24,14 +26,8 @@ class Toaster extends Logger {
  }

  async init() {
-    this.settingsModule = findModuleChild((m) => {
-      if (typeof m !== 'object') return undefined;
-      for (let prop in m) {
-        if (typeof m[prop]?.settings?.bDisableToastsInGame !== 'undefined') return m[prop];
-      }
-    });
-
    let instance: any;
+
    while (true) {
      instance = findInReactTree(
        (document.getElementById('root') as any)._reactRootContainer._internalRoot.current,
@@ -43,14 +39,26 @@ class Toaster extends Logger {
    }

    this.node = instance.return.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.instanceRet = ret;
-        afterPatch(ret, 'type', (_: any, ret: any) => {
-          if (ret?.props?.children[1]?.children?.props?.notification?.decky) {
-            const toast = ret.props.children[1].children.props.notification;
-            ret.props.children[1].children.type = () => <Toast toast={toast} />;
+        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;
+              } else {
+                toast = currentToast;
+                renderedToast = <Toast toast={toast} />;
+                ret.props.children[1].children = renderedToast;
+              }
+            } else {
+              toast = null;
+              renderedToast = null;
+            }
          }
          return ret;
        });
@@ -58,11 +66,21 @@ class Toaster extends Logger {
      return ret;
    };
    this.node.stateNode.forceUpdate();
+    this.settingsModule = findModuleChild((m) => {
+      if (typeof m !== 'object') return undefined;
+      for (let prop in m) {
+        if (typeof m[prop]?.settings && m[prop]?.communityPreferences) return m[prop];
+      }
+    });
    this.log('Initialized');
+    this.ready = true;
  }

-  toast(toast: ToastData) {
-    const settings = this.settingsModule.settings;
+  async toast(toast: ToastData) {
+    while (!this.ready) {
+      await sleep(100);
+    }
+    const settings = this.settingsModule?.settings;
    let toastData = {
      nNotificationID: window.NotificationStore.m_nNextTestNotificationID++,
      rtCreated: Date.now(),
@@ -74,17 +92,16 @@ class Toaster extends Logger {
    // @ts-ignore
    toastData.data.appid = () => 0;
    if (
-      (settings.bDisableAllToasts && !toast.critical) ||
-      (settings.bDisableToastsInGame && !toast.critical && window.NotificationStore.BIsUserInGame())
+      (settings?.bDisableAllToasts && !toast.critical) ||
+      (settings?.bDisableToastsInGame && !toast.critical && window.NotificationStore.BIsUserInGame())
    )
      return;
    window.NotificationStore.m_rgNotificationToasts.push(toastData);
    window.NotificationStore.DispatchNextToast();
-    window.NotificationStore.m_rgNotificationToasts.pop();
  }

  deinit() {
-    this.instanceRet && unpatch(this.instanceRet, 'type');
+    this.instanceRetPatch?.unpatch();
    this.node && delete this.node.stateNode.render;
    this.node && this.node.stateNode.forceUpdate();
  }
@@ -1,5 +1,3 @@
-import { sleep } from 'decky-frontend-lib';
-
 export enum Branches {
  Release,
  Prerelease,
@@ -11,19 +9,22 @@ export interface DeckyUpdater {
  finish: () => void;
 }

+export interface RemoteVerInfo {
+  assets: {
+    browser_download_url: string;
+    created_at: string;
+  }[];
+  name: string;
+  body: string;
+  prerelease: boolean;
+  published_at: string;
+  tag_name: string;
+}
+
 export interface VerInfo {
  current: string;
-  remote: {
-    assets: {
-      browser_download_url: string;
-      created_at: string;
-    }[];
-    name: string;
-    body: string;
-    prerelease: boolean;
-    published_at: string;
-    tag_name: string;
-  } | null;
+  remote: RemoteVerInfo | null;
+  all: RemoteVerInfo[] | null;
  updatable: boolean;
 }

@@ -43,6 +44,4 @@ export async function callUpdaterMethod(methodName: string, args = {}) {

 export async function finishUpdate() {
  callUpdaterMethod('do_restart');
-  await sleep(3000);
-  location.reload();
 }
@@ -0,0 +1,36 @@
+import { useEffect, useState } from 'react';
+
+interface GetSettingArgs<T> {
+  key: string;
+  default: T;
+}
+
+interface SetSettingArgs<T> {
+  key: string;
+  value: T;
+}
+
+export function useSetting<T>(key: string, def: T): [value: T | null, setValue: (value: T) => Promise<void>] {
+  const [value, setValue] = useState(def);
+
+  useEffect(() => {
+    (async () => {
+      const res = (await window.DeckyPluginLoader.callServerMethod('get_setting', {
+        key,
+        default: def,
+      } as GetSettingArgs<T>)) as { result: T };
+      setValue(res.result);
+    })();
+  }, []);
+
+  return [
+    value,
+    async (val: T) => {
+      setValue(val);
+      await window.DeckyPluginLoader.callServerMethod('set_setting', {
+        key,
+        value: val,
+      } as SetSettingArgs<T>);
+    },
+  ];
+}
@@ -1,6 +1,5 @@
 {
  "compilerOptions": {
-    "outDir": "dist",
    "module": "ESNext",
    "target": "ES2020",
    "jsx": "react",
Author	SHA1	Message	Date
Devon Schneider	d58001c323	Fixed an issue regarding the scroll root path (#201 ) * Changed so searching for the scroll root node will look through siblings of children nodes. * Added a missing await Seem to have missed an await from when I was converting my proof-of-concept to an async function. * Minor stylistic change * Changed where program retries to find the scroll root.	2022-10-04 11:54:54 -07:00
TrainDoctor	d727ba72f3	Fix outdated line about manual install	2022-10-02 10:56:06 -07:00
TrainDoctor	fa028fa525	Update build.yml	2022-10-02 08:19:41 -07:00
TrainDoctor	c947548064	Update build.yml	2022-10-02 08:11:00 -07:00
AAGaming	19d5527bdf	ACTUALLY FIX the friends focus workaround	2022-10-02 10:29:33 -04:00
AAGaming	ef51b96f08	fix styling on links in markdown	2022-10-02 10:14:51 -04:00
AAGaming	617916e8e5	actually fix focus issue on startup	2022-10-01 23:10:25 -04:00
TrainDoctor	6c4a4d0a44	Update install_release.sh	2022-10-01 19:04:05 -07:00
TrainDoctor	bedcb0fb71	Update README.md	2022-10-01 18:58:59 -07:00
AAGaming	2461f52ca7	change console.log to styled log	2022-10-01 21:24:10 -04:00
AAGaming	3c00eb8cf4	fix friends menu focusing itself	2022-10-01 21:22:30 -04:00
TrainDoctor	21e1d8504a	Update README.md	2022-10-01 16:17:40 -07:00
Party Wumpus	ba93c4add2	Change 'PluginLoader' to 'Decky Loader' in readme (#190 ) * (readme) Make store link go to beta.deckbrew + Change wording for clarification * further change * change line 26 to say plugin menu * Change all 'PluginLoader' to 'Decky Loader' in readme Seems like a reasonable change as Decky was rebranded a while ago	2022-10-01 14:41:09 -07:00
TrainDoctor	61fea41c8a	Update package.json	2022-09-30 21:40:51 -07:00
TrainDoctor	e40d3e4db5	Removal of legacy link	2022-09-30 21:31:19 -07:00
Lukas Senionis	bbad6bf2be	fix(pluginview): align icon and plugin name (#185 )	2022-09-26 21:51:39 -07:00
Party Wumpus	4e04455163	(readme) Make store link go to beta.deckbrew + Change wording (#184 ) * (readme) Make store link go to beta.deckbrew + Change wording for clarification * further change * change line 26 to say plugin menu	2022-09-25 10:04:50 -07:00
Dan Burkhardt	314292b042	updated installation steps to reflect confirmation and system reboot step (#180 ) Co-authored-by: TrainDoctor <traindoctor@protonmail.com>	2022-09-21 15:05:18 -07:00
Aamir Tahir	a264f36966	Add note about opening terminal to README (#176 ) Quick note about how to open the terminal using the pre-installed Konsole app for users that are either new to linux or Steam Deck.	2022-09-21 14:56:45 -07:00
AAGaming	60c8c5db42	check for plugin updates after installing a plugin	2022-09-19 21:13:06 -04:00
Trent Callan	852c52c59a	Grab Plugin path from find_plugin_folder plugin name is not always folder anme (#178 )	2022-09-18 22:13:45 -07:00
Trent Callan	3136ad72ed	Download Remote Binaries during Store Install (#177 ) * Download Remote Binaries during store install. Fix Manual Install Modal Type * Use Unix Line endings. (Thanks WSL) * Fix Merge Commit with main branch.	2022-09-18 17:20:19 -07:00
AAGaming	3700dd7437	fix plugin updating	2022-09-18 15:44:16 -04:00
AAGaming	c6d48389c9	bump lib	2022-09-18 15:44:01 -04:00
AAGaming	490fc18008	enable debug logs in dev	2022-09-18 15:43:26 -04:00
AAGaming	797c7ea3b0	hopefully actually fix toaster	2022-09-18 15:03:59 -04:00
AAGaming	0f06bc1ef0	Updater UI tweaks, Markdown tweaks, bump lib	2022-09-18 14:53:36 -04:00
AAGaming	c774451ff4	don't crash when plugin backends do	2022-09-18 14:51:17 -04:00
AAGaming	62a5bdbbb0	add more URLs to bypass authentication	2022-09-18 14:49:56 -04:00
AAGaming	7716c73014	fix plugin loading after install, move updater reloads to loader	2022-09-18 14:49:32 -04:00
AAGaming	8829adc5b6	update tasks	2022-09-18 14:48:08 -04:00
AAGaming	62bd3e76bd	small changes making breakpoint debugging easier	2022-09-18 11:07:30 -04:00
AAGaming	9867d7bea0	Possibly actually fix the toasts issue	2022-09-18 10:17:39 -04:00
AAGaming	c4d6731401	fix updater for new installs, fix file picker patch, fix scrolling on patch notes, fix tasks dir	2022-09-17 23:23:51 -04:00
AAGaming	fded2fa8bf	fix plugin install modal	2022-09-17 16:02:03 -04:00
TrainDoctor	90c523ec45	Update updater.py	2022-09-17 09:26:24 -07:00
AAGaming	c5ccb4dfb8	fix TS errors in Toast	2022-09-17 11:36:53 -04:00
AAGaming	8b1925bc53	fix spacing [skip ci]	2022-09-17 11:35:31 -04:00
AAGaming	a8c7c2f18f	fix asyncio error on get_branch	2022-09-17 11:35:05 -04:00
AAGaming	463258febb	wait for toaster ready, hopefully fix file browser patch	2022-09-16 18:49:35 -04:00
TrainDoctor	304fc0f94c	Update build.yml	2022-09-11 15:40:19 -07:00
AAGaming	b5b041fdee	add file picker, add library file picker patch, bump lib, logger tweaks	2022-09-09 16:25:52 -04:00
AAGaming	9d980618a7	spice up js-side logs from store and branch select	2022-09-08 20:19:54 -04:00
Nik	6dad3f81e8	Updated screenshot	2022-09-08 23:22:47 +02:00
TrainDoctor	adc1a792fb	Whoopsie	2022-09-05 20:13:08 -07:00
TrainDoctor	6347ad0856	Added handling for release to pre-release, pre-rel to rel and rel to rel	2022-09-05 20:03:09 -07:00
TrainDoctor	1377d83023	Better handling for release to new pre-release	2022-09-05 19:37:33 -07:00
TrainDoctor	43d36d2b35	temp	2022-09-05 19:32:27 -07:00
AAGaming	591c58330c	fix(toaster): fix toasts rendering multiple times	2022-09-05 14:28:52 -04:00
AAGaming	501145a210	fix(toasts): handle toasts ingame properly without useComposition hack	2022-09-05 11:24:04 -04:00
AAGaming	843e03b42c	fix(toaster): allow toasts to show ingame	2022-09-04 22:14:35 -04:00
TrainDoctor	5f469bfb16	Merge ci-for-auto-update to main	2022-09-04 18:18:51 -07:00
AAGaming	acaf6c72e4	Update decky-frontend-lib and refactor patches	2022-09-04 13:33:42 -04:00
TrainDoctor	eb439574be	Addition of proper branch slection (#168 ) * This is a bit better, but branch selection still isn't working -_- * I'm the king of oversight * Selecting different branch checks for updates * Stable doesn't detect old versions, which indicates it doesn't work * Start adding deckyState for plugin updating * Few tweaks * Disable nightly selection * Update decky-frontend-lib and move useSetting set setting to async	2022-09-01 13:46:49 -07:00
TrainDoctor	16a6e9b6a9	Give SettingsManager a default directory	2022-08-31 12:20:31 -07:00
Philipp Richter	6f84cf94b5	Fix LimitOverrunError when a lot of data is passed to the backend (fixes #158 ) (#161 ) * Fix LimitOverrunError when a lot of data is passed to the backend * Raise socket's buffer limit to something more sensible	2022-08-31 10:46:40 -07:00
TrainDoctor	7c06db5ece	Moved traceback to higher log level for cleaner logs	2022-08-29 15:18:18 -07:00
TrainDoctor	aeb2decfc1	Fix plugin uninstalling	2022-08-29 14:41:10 -07:00
botato	b7d7ca04e1	Refractor plugin backend (#111 ) * refractor uninstall plugin backend * refractor plugin installation method * Change formatting in browser.py * Manually format main.py * Manually format utilities.py * remove inconsistency * remove unnecessary linebreaks * lol what * last minute pythoning * Fix async missing * lint * more refractor * await forgotten * fix: menu not disappearing after first click * lint * bug: fix double click on uninstall * depricate request installs * basic patch notes viewer, lazy-load settings and store, build frontend as esmodule, add lazy-loaded react-markdown, backend changes to accomodate ESModule frontend * refractor uninstall plugin backend * Change formatting in browser.py * Manually format main.py * Manually format utilities.py * remove unnecessary linebreaks * lol what * last minute pythoning * Fix async missing * rebase onto main * fix error, fix React crash if patch notes are opened before remote version info is loaded Co-authored-by: TrainDoctor <traindoctor@protonmail.com> Co-authored-by: AAGaming <aa@mail.catvibers.me>	2022-08-26 21:01:23 -07:00
AAGaming	d4d1c2bbab	basic patch notes viewer, lazy-load settings and store, build frontend as esmodule, add lazy-loaded react-markdown, backend changes to accomodate ESModule frontend	2022-08-26 01:18:28 -04:00
TrainDoctor	effc4ab0f5	Hide branch select until it's working	2022-08-24 21:18:38 -07:00
AAGaming	79db0c779d	Settings API for loader, preview branch select	2022-08-24 23:51:20 -04:00
				`@@ -0,0 +1 @@`
				`This directory contains patches that replace Valve's broken file picker with ours.`