Add stop functionality

.github/workflows/build.yml

@@ -2,250 +2,52 @@ name: Builder
 
 on:
   push:
+    branches: [ "*" ]
   pull_request:
-  # schedule:
-  #   - cron: '0 13 * * *' # run at 1 PM UTC
-  workflow_dispatch:
-    inputs:
-      release:
-        type: choice
-        description: Release the asset
-        default: 'none'
-        options:
-          - none
-          - prerelease
-          - release
-      bump:
-        type: choice
-        description: Semver to bump
-        default: 'none'
-        options:
-          - none
-          - patch
-          - minor
-          - major
+    branches: [ "*" ]
 
 permissions:
-  contents: write
+  contents: read
 
 jobs:
   build:
-    name: Build PluginLoader
+
+    name: Packager
     runs-on: ubuntu-latest
 
     steps:
-    - name: Print input
-      run : |
-        echo "release: ${{ github.event.inputs.release }}\n"
-        echo "bump: ${{ github.event.inputs.bump }}\n"
-
-    - name: Checkout 🧰
+    - name: 🧰 Checkout
       uses: actions/checkout@v3
 
-    - name: Set up NodeJS 17 💎
+    - name: 💎 Set up NodeJS 17
       uses: actions/setup-node@v3
       with:
         node-version: 17
       
-    - name: Set up Python 3.10 🐍
+    - name: 🐍 Set up Python 3.10
       uses: actions/setup-python@v3
       with:
         python-version: "3.10"
         
-    - name: Install Python dependencies ⬇️
+    - name: ⬇️ Install Python dependencies
       run: |
         python -m pip install --upgrade pip
         pip install pyinstaller
-        [ -f requirements.txt ] && pip install -r requirements.txt
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
 
-    - name: Install NodeJS dependencies ⬇️
+    - name: ⬇️ Install NodeJS dependencies
       run: |
         cd frontend
         npm i
         npm run build
 
-    - name: Build 🛠️
-      run: pyinstaller --noconfirm --onefile --name "PluginLoader" --add-data ./backend/static:/static --add-data ./backend/legacy:/legacy ./backend/*.py
+    - name: 🛠️ Build
+      run: |
+        pyinstaller --noconfirm --onefile --name "Decky" --add-data ./backend/static:/static ./backend/*.py
         
-    - name: Upload package artifact ⬆️
-      if: ${{ !env.ACT }}
-      uses: actions/upload-artifact@v3
+    - name: ⬆️ Upload package
+      uses: actions/upload-artifact@v2
       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 stable version of the package
-    if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.release == 'release' }}
-    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="notsemver"
-        if [[ "$VERSION" =~ "-pre" ]]; then
-          printf "is prerelease, bumping to release\n"
-          OUT=$(semver bump release "$VERSION")
-          printf "OUT: ${OUT}\n"\
-          printf "bumping by selected type.\n"
-          if [[ "${{github.event.inputs.bump}}" != "none" ]]; then
-            OUT=$(semver bump ${{github.event.inputs.bump}} "$OUT")
-            printf "OUT: ${OUT}\n"
-          else
-            printf "no type selected, defaulting to patch.\n"
-            OUT=$(semver bump patch "$OUT")
-            printf "OUT: ${OUT}\n"
-          fi
-        elif [[ ! "$VERSION" =~ "-pre" ]]; then
-          printf "previous tag is a release, bumping by selected type.\n"
-          if [[ "${{github.event.inputs.bump}}" != "none" ]]; then
-            OUT=$(semver bump ${{github.event.inputs.bump}} "$VERSION")
-            printf "OUT: ${OUT}\n"
-          else
-            printf "previous tag is a release, but no bump selected. Defaulting to a patch bump.\n"
-            OUT=$(semver bump patch "$VERSION")
-            printf "OUT: ${OUT}\n"
-          fi
-        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' && !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: 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 "pre-release from release, bumping by selected type and prerel\n"
-          if [[ ! ${{ github.event.inputs.bump }} == "none" ]]; then
-            OUT=$(semver bump ${{github.event.inputs.bump}} "$VERSION")
-            printf "OUT: ${OUT}\n"
-          else
-            printf "type not selected, defaulting to patch\n"
-            OUT=$(semver bump patch "$VERSION")
-            printf "OUT: ${OUT}\n"
-          fi
-          OUT="$OUT-pre"
-          OUT=$(semver bump prerel "$OUT")
-          printf "OUT: ${OUT}\n"
-        elif [[ "$VERSION" =~ "-pre" ]]; then
-          printf "pre-release to pre-release, bumping by selected type and or prerel version\n"
-          if [[ ! ${{ github.event.inputs.bump }} == "none" ]]; then
-            OUT=$(semver bump ${{github.event.inputs.bump}} "$VERSION")
-            printf "OUT: ${OUT}\n"
-            OUT="$OUT-pre"
-            printf "OUT: ${OUT}\n"
-            printf "bumping prerel\n"
-            OUT=$(semver bump prerel "$OUT")
-            printf "OUT: ${OUT}\n"
-          else
-            printf "type not selected, defaulting to new pre-release only\n"
-            printf "bumping prerel\n"
-            OUT="$VERSION-pre"
-            printf "OUT: ${OUT}\n"
-            OUT=$(semver bump prerel "$OUT")
-            printf "OUT: ${OUT}\n"
-          fi
-        fi
-        printf "vOUT: v${OUT}\n"
-        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
+        name: Plugin Loader
+        path: |
+          ./dist/*

.gitignore

@@ -154,11 +154,5 @@ cython_debug/
 # static files are built
 backend/static
 
-# ignore settings.json
-# prevents leaking login details
-.vscode/settings.json
-
-# plugins folder for local launches
-plugins/*
-act/.directory
-act/artifacts/*
+# pnpm lockfile
+frontend/pnpm-lock.yaml

.vscode/config.sh

@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-SCRIPT_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]:-$0}"; )" &> /dev/null && pwd 2> /dev/null; )";
-# printf "${SCRIPT_DIR}\n"
-# printf "$(dirname $0)\n"
-if ! [[ -e "${SCRIPT_DIR}/settings.json" ]]; then 
-     printf '.vscode/settings.json does not exist. Creating it with default settings. Exiting afterwards. Run your task again.\n\n'
-     cp "${SCRIPT_DIR}/defsettings.json" "${SCRIPT_DIR}/settings.json"
-     exit 1
-else
-    printf '.vscode/settings.json does exist. Congrats.\n'
-    printf 'Make sure to change settings.json to match your deck.\n'
-fi

.vscode/defsettings.json

@@ -1,7 +0,0 @@
-{
-    "deckip"    : "0.0.0.0",
-    "deckport"  : "22",
-    "deckpass"  : "ssap",
-    "deckkey"   : "-i ${env:HOME}/.ssh/id_rsa",
-    "deckdir"   : "/home/deck"
-}

.vscode/launch.json

@@ -2,25 +2,16 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "Run (Remote)",
-            "type": "python",
-            "request": "launch",
-            "console": "integratedTerminal",
-            "preLaunchTask": "remoterun",
-            "cwd": "",
-            "program": "",      
-        },
-        {
-            "name": "Run (Local)",
+            "name": "Debug",
             "type": "python",
             "request": "launch",
             "program": "${workspaceFolder}/backend/main.py",
             "cwd": "${workspaceFolder}/backend",
             "console": "integratedTerminal",
             "env": {
-                "PLUGIN_PATH": "${workspaceFolder}/plugins"
+                "PLUGIN_PATH": "/home/deck/homebrew/plugins"
             },
-            "preLaunchTask": "localrun"
+            "preLaunchTask": "Build frontend"
         }
     ]
 }

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "[python]": {
+    "editor.detectIndentation": false,
+    "editor.tabSize": 4
+  }
+}

.vscode/tasks.json

@@ -1,155 +1,15 @@
 {
     "version": "2.0.0",
     "tasks": [
-        // OTHER
         {
-            "label": "checkforsettings",
+            "label": "Stop Service",
             "type": "shell",
-            "group": "none",
-            "detail": "Check that settings.json has been created",
-            "command": "bash -c ${workspaceFolder}/.vscode/config.sh",
-            "problemMatcher": []
+            "command":"systemctl --user stop plugin_loader",
         },
         {
-            "label": "localrun",
+            "label": "Build frontend",
             "type": "shell",
-            "group": "none",
-            "dependsOn" : ["buildall"],
-            "detail": "Check for local runs, create a plugins folder",
-            "command": "mkdir -p plugins",
-            "problemMatcher": []
-        },
-        {
-            "label": "remoterun",
-            "type": "shell",
-            "group": "none",
-            "dependsOn": [
-                "updateremote",
-                "runpydeck"
-            ],
-            "detail": "Task for remote run launches",
-            "command": "exit 0",
-            "problemMatcher": []
-        },
-        {
-            "label": "dependencies",
-            "type": "shell",
-            "group": "none",
-            "detail": "Check for local runs, create a plugins folder",
-            "command": "rsync -azp --rsh='ssh -p ${config:deckport} ${config:deckkey}' requirements.txt deck@${config:deckip}:${config:deckdir}/homebrew/dev/pluginloader/requirements.txt && ssh deck@${config:deckip} -p ${config:deckport} ${config:deckkey} 'python -m ensurepip && python -m pip install --upgrade pip && python -m pip install --upgrade setuptools && python -m pip install -r ${config:deckdir}/homebrew/dev/pluginloader/requirements.txt'",
-            "problemMatcher": []
-        },
-        // BUILD
-        {
-            "label": "pnpmsetup",
-            "type": "shell",
-            "group": "build",
-            "detail": "Setup pnpm",
-            "command": "cd frontend && pnpm i",
-            "problemMatcher": []
-        },
-        {
-            "label": "buildfrontend",
-            "type": "npm",
-            "group": "build",
-            "detail": "rollup -c",
-            "script": "build",
-            "path": "frontend",
-            "problemMatcher": [],
-            
-        },
-        {
-            "label": "buildall",
-            "group": "build",
-            "detail": "Deploy pluginloader to deck",
-            "dependsOrder": "sequence",
-            "dependsOn": [
-                "pnpmsetup",
-                "buildfrontend"
-            ],
-            "problemMatcher": []
-        },
-        // DEPLOY
-        {
-            "label": "createfolders",
-            "detail": "Create plugins folder in expected directory",
-            "type": "shell",
-            "group": "none",
-            "dependsOn": [
-                "checkforsettings"
-            ],
-            "command": "ssh deck@${config:deckip} -p ${config:deckport} ${config:deckkey} 'mkdir -p ${config:deckdir}/homebrew/dev/pluginloader && mkdir -p ${config:deckdir}/homebrew/dev/plugins'",
-            "problemMatcher": []
-        },
-        {
-            "label": "deploy",
-            "detail": "Deploy dev PluginLoader to deck",
-            "type": "shell",
-            "group": "none",
-            "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": []
-        },
-        // RUN
-        {
-            "label": "runpydeck",
-            "detail": "Run indev PluginLoader on Deck",
-            "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; export LOG_LEVEL=DEBUG; cd ${config:deckdir}/homebrew/services; echo '${config:deckpass}' | sudo -SE python3 ${config:deckdir}/homebrew/dev/pluginloader/backend/main.py'",
-            "problemMatcher": []
-        },
-        {
-            "label": "runpylocal",
-            "detail": "Run PluginLoader from python locally",
-            "type": "shell",
-            "group": "none",
-            "command": "export PLUGIN_PATH=${workspaceFolder}/plugins; export CHOWN_PLUGIN_PATH=0; sudo -E python3 ${workspaceFolder}/backend/main.py",
-            "problemMatcher": []
-        },
-        // ALL-IN-ONES
-        {
-            "label": "updateremote",
-            "detail": "Build and deploy",
-            "dependsOrder": "sequence",
-            "group": "none",
-            "dependsOn": [
-                "buildall",
-                "deploy",
-            ],
-            "problemMatcher": []
-        },
-        {
-            "label": "updateandrun",
-            "detail": "Build, deploy and run",
-            "dependsOrder": "sequence",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "dependsOn": [
-                "buildall",
-                "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": []
-        }
+            "command":"cd ${workspaceFolder}/frontend; npm run build",
+        }        
     ]
 }

README.md

@@ -1,36 +1,37 @@
-# Decky Loader [![Chat](https://img.shields.io/badge/chat-on%20discord-7289da.svg)](https://discord.gg/ZU74G2NJzk)
+# TODO
+- Fix button size/display
+- Add plugin installation prompts for browser
+- Fix components not updating unless tab opened first (with new tab hook)
+- Clean up code
 
-![Decky](https://media.discordapp.net/attachments/966017112244125756/1012466063893610506/main.jpg)
+# Plugin Loader [![Chat](https://img.shields.io/badge/chat-on%20discord-7289da.svg)](https://discord.gg/ZU74G2NJzk)
 
-Keep an eye on the [Wiki](https://deckbrew.xyz) for more information about Decky Loader, documentation + tools for plugin development and more.
+![steamuserimages-a akamaihd](https://user-images.githubusercontent.com/10835354/161068262-ca723dc5-6795-417a-80f6-d8c1f9d03e93.jpg)
+
+Keep an eye on the [Wiki](https://deckbrew.xyz) for more information about Plugin 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. 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)).
-    - It will look like the password isn't typing properly. That's normal, it's a security feature (Similar to `***` when typing passwords online)
-8. Open a terminal ("Konsole" is the pre-installed terminal application) and paste the following command into it:
-    - For the latest release (recommended for all users):
-        - `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/install_release.sh | sh`
-    - For the latest pre-release (testing releases, unlikely to be fully stable):
-        - `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)
-9. Done! Reboot back into Gaming mode and enjoy your plugins!
+5. Click on the `STEAM` button and select `Power` -> `Switch to Desktop`
+6. Open a terminal and paste the following command into it: 
+    - For users:
+        - `curl -L https://github.com/SteamDeckHomebrew/PluginLoader/raw/main/dist/install_release.sh | sh`
+    - For plugin developers:
+        ~~- `curl -L https://github.com/SteamDeckHomebrew/PluginLoader/raw/main/dist/install_nightly.sh | sh`~~
+        Nightly releases are currently broken.
+7. Done! Reboot back into Gaming mode and enjoy your plugins!
 
-### Install/Uninstall 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.
+### Install 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`
 
 ### Uninstall
 - Open a terminal and paste the following command into it:
-  - `curl -L https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/uninstall.sh | sh`
+    - For both users and developers:
+        - `curl -L https://github.com/SteamDeckHomebrew/PluginLoader/raw/main/dist/uninstall.sh | sh`
 
 ## Features
 - Clean injecting and loading of one or more plugins
@@ -42,26 +43,24 @@ Keep an eye on the [Wiki](https://deckbrew.xyz) for more information about Decky
 ## Developing plugins
 - 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 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.)
-
-### Getting Started
-
-1. Clone the repository using the latest commit to main before starting your PR.
-2. In your clone of the repository run these commands:
-   1. ``pnpm i``
-   2. ``pnpm run build``
-3. If you are modifying the UI, these will need to be run before deploying the changes to your Deck.
-4. Use the vscode tasks or ``deck.sh`` script to deploy your changes to your Deck to test them.
-5. You will be testing your changes with the python script version, so you will need to build, deploy and reload each time.
-
-Note: If you are recieveing build errors due to an out of date library, you should run this command inside of your repository:
+## Contribution
+- For Plugin Loader contributors (in possession of a Steam Deck):
+    - `curl -L https://github.com/SteamDeckHomebrew/PluginLoader/raw/react-frontend-plugins/contrib/deck.sh | sh`
+- For PluginLoader contributors (without a Steam Deck):
+  - `curl -L https://github.com/SteamDeckHomebrew/PluginLoader/raw/react-frontend-plugins/contrib/pc.sh | sh`
+  - [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 WSL/cygwin this script is unsupported on Windows.)
 
+To run your development version of Plugin Loader on Deck, run a command like this:
 ```bash
-pnpm update decky-frontend-lib --latest
+ssh deck@steamdeck 'export PLUGIN_PATH=/home/deck/loaderdev/plugins; export CHOWN_PLUGIN_PATH=0; echo 'password' | sudo -SE python3 /home/deck/loaderdev/pluginloader/backend/main.py'
+```
+
+Or on PC with the Deck UI enabled:
+```bash
+export PLUGIN_PATH=/home/user/installdirectory/plugins; 
+export CHOWN_PLUGIN_PATH=0;
+sudo python3 /home/deck/loaderdev/pluginloader/backend/main.py
 ```
 
 Source control and deploying plugins are left to each respective contributor for the cloned repos in order to keep depedencies up to date.

act/artifacts/readme

@@ -1,10 +0,0 @@
-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

act/prerelease.json

@@ -1,6 +0,0 @@
-{
-  "inputs": {
-    "release": "prerelease",
-    "bump": "none"
-  }
-}

act/release.json

@@ -1,6 +0,0 @@
-{
-  "inputs": {
-    "release": "release",
-    "bump": "none"
-  }
-}

act/run-act.sh

@@ -1,45 +0,0 @@
-#!/bin/bash
-
-type=$1
-# bump=$2
-
-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

backend/browser.py

@@ -1,176 +1,92 @@
-# Full imports
-import json
-
-# Partial imports
-from aiohttp import ClientSession, web
-from asyncio import get_event_loop, sleep
-from concurrent.futures import ProcessPoolExecutor
-from hashlib import sha256
-from io import BytesIO
+from injector import get_tab
 from logging import getLogger
-from os import R_OK, W_OK, path, rename, listdir, access, mkdir
+from os import path, rename
 from shutil import rmtree
-from subprocess import call
-from time import time
+from aiohttp import ClientSession, web
+from io import BytesIO
 from zipfile import ZipFile
-
-# Local modules
-from helpers import get_ssl_context, get_user, get_user_group, download_remote_binary_to_path
-from injector import get_tab, inject_to_tab
-
-logger = getLogger("Browser")
+from concurrent.futures import ProcessPoolExecutor
+from asyncio import get_event_loop
+from time import time
+from hashlib import sha256
+from subprocess import Popen
 
 class PluginInstallContext:
-    def __init__(self, artifact, name, version, hash) -> None:
-        self.artifact = artifact
-        self.name = name
+    def __init__(self, gh_url, version, hash) -> None:
+        self.gh_url = gh_url
         self.version = version
         self.hash = hash
 
 class PluginBrowser:
-    def __init__(self, plugin_path, plugins, loader) -> None:
+    def __init__(self, plugin_path, server_instance, store_url) -> None:
+        self.log = getLogger("browser")
         self.plugin_path = plugin_path
-        self.plugins = plugins
-        self.loader = loader
+        self.store_url = store_url
         self.install_requests = {}
 
+        server_instance.add_routes([
+            web.post("/browser/install_plugin", self.install_plugin),
+            web.get("/browser/redirect", self.redirect_to_store)
+        ])
+
     def _unzip_to_plugin_dir(self, zip, name, hash):
         zip_hash = sha256(zip.getbuffer()).hexdigest()
-        if hash and (zip_hash != hash):
+        if zip_hash != hash:
             return False
         zip_file = ZipFile(zip)
         zip_file.extractall(self.plugin_path)
-        plugin_dir = self.find_plugin_folder(name)
-        code_chown = call(["chown", "-R", get_user()+":"+get_user_group(), plugin_dir])
-        code_chmod = call(["chmod", "-R", "555", plugin_dir])
-        if code_chown != 0 or code_chmod != 0:
-            logger.error(f"chown/chmod exited with a non-zero exit code (chown: {code_chown}, chmod: {code_chmod})")
-            return False
+        rename(path.join(self.plugin_path, zip_file.namelist()[0]), path.join(self.plugin_path, name))
+        Popen(["chown", "-R", "deck:deck", self.plugin_path])
+        Popen(["chmod", "-R", "555", self.plugin_path])
         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):
-            try:
-                with open(path.join(self.plugin_path, folder, 'plugin.json'), 'r') as f:
-                    plugin = json.load(f)
-
-                if plugin['name'] == name:
-                    return path.join(self.plugin_path, folder)
-            except:
-                logger.debug(f"skipping {folder}")
-
-    async def uninstall_plugin(self, name):
-        if self.loader.watcher:
-            self.loader.watcher.disabled = True
-        tab = await get_tab("SP")
-        try:
-            logger.info("uninstalling " + name)
-            logger.info(" at dir " + self.find_plugin_folder(name))
-            logger.debug("unloading %s" % str(name))
-            await tab.evaluate_js(f"DeckyPluginLoader.unloadPlugin('{name}')")
-            if self.plugins[name]:
-                self.plugins[name].stop()
-                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")
-        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):
-        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")
-        logger.info(f"Installing {name} (Version: {version})")
+    async def _install(self, artifact, version, hash):
+        name = artifact.split("/")[-1]
+        rmtree(path.join(self.plugin_path, name), ignore_errors=True)
+        self.log.info(f"Installing {artifact} (Version: {version})")
         async with ClientSession() as client:
-            logger.debug(f"Fetching {artifact}")
-            res = await client.get(artifact, ssl=get_ssl_context())
+            url = f"https://github.com/{artifact}/archive/refs/tags/{version}.zip"
+            self.log.debug(f"Fetching {url}")
+            res = await client.get(url)
             if res.status == 200:
-                logger.debug("Got 200. Reading...")
+                self.log.debug("Got 200. Reading...")
                 data = await res.read()
-                logger.debug(f"Read {len(data)} bytes")
+                self.log.debug(f"Read {len(data)} bytes")
                 res_zip = BytesIO(data)
-                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)
+                with ProcessPoolExecutor() as executor:
+                    self.log.debug("Unzipping...")
+                    ret = await get_event_loop().run_in_executor(
+                        executor,
+                        self._unzip_to_plugin_dir,
+                        res_zip,
+                        name,
+                        hash
+                    )
                     if ret:
-                        logger.info(f"Installed {name} (Version: {version})")
-                        if name in self.loader.plugins:
-                            self.loader.plugins[name].stop()
-                            self.loader.plugins.pop(name, None)
-                        await sleep(1)
-                        self.loader.import_plugin(path.join(plugin_dir, "main.py"), plugin_dir)
-                        # await inject_to_tab("SP", "window.syncDeckyPlugins()")
+                        self.log.info(f"Installed {artifact} (Version: {version})")
                     else:
-                        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
+                        self.log.fatal(f"SHA-256 Mismatch!!!! {artifact} (Version: {version})")
             else:
-                logger.fatal(f"Could not fetch from URL. {await res.text()}")
+                self.log.fatal(f"Could not fetch from github. {await res.text()}")
 
-    async def request_plugin_install(self, artifact, name, version, hash):
+    async def redirect_to_store(self, request):
+        return web.Response(status=302, headers={"Location": self.store_url})
+    
+    async def install_plugin(self, request):
+        data = await request.post()
+        get_event_loop().create_task(self.request_plugin_install(data["artifact"], data["version"], data["hash"]))
+        return web.Response(text="Requested plugin install")
+
+    async def request_plugin_install(self, artifact, version, hash):
         request_id = str(time())
-        self.install_requests[request_id] = PluginInstallContext(artifact, name, version, hash)
+        self.install_requests[request_id] = PluginInstallContext(artifact, version, hash)
         tab = await get_tab("SP")
         await tab.open_websocket()
-        await tab.evaluate_js(f"DeckyPluginLoader.addPluginInstallPrompt('{name}', '{version}', '{request_id}', '{hash}')")
-
+        await tab.evaluate_js(f"DeckyPluginLoader.addPluginInstallPrompt('{artifact}', '{version}', '{request_id}')")
+    
     async def confirm_plugin_install(self, request_id):
         request = self.install_requests.pop(request_id)
-        await self._install(request.artifact, request.name, request.version, request.hash)
+        await self._install(request.gh_url, request.version, request.hash)
 
     def cancel_plugin_install(self, request_id):
-        self.install_requests.pop(request_id)
+        self.install_requests.pop(request_id)

backend/helpers.py

@@ -1,126 +0,0 @@
-import re
-import ssl
-import subprocess
-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"
-
-# global vars
-csrf_token = str(uuid.uuid4())
-ssl_ctx = ssl.create_default_context(cafile=certifi.where())
-user = None
-group = None
-
-assets_regex = re.compile("^/plugins/.*/assets/.*")
-frontend_regex = re.compile("^/frontend/.*")
-
-def get_ssl_context():
-    return ssl_ctx
-
-def get_csrf_token():
-    return csrf_token
-
-@middleware
-async def csrf_middleware(request, handler):
-    if str(request.method) == "OPTIONS" or request.headers.get('Authentication') == csrf_token or str(request.rel_url) == "/auth/token" or str(request.rel_url).startswith("/plugins/load_main/") or str(request.rel_url).startswith("/static/") or str(request.rel_url).startswith("/legacy/") or str(request.rel_url).startswith("/steam_resource/") or str(request.rel_url).startswith("/frontend/") or assets_regex.match(str(request.rel_url)) or frontend_regex.match(str(request.rel_url)):
-        return await handler(request)
-    return Response(text='Forbidden', status='403')
-
-# Get the user by checking for the first logged in user. As this is run
-# by systemd at startup the process is likely to start before the user
-# logs in, so we will wait here until they are available. Note that
-# other methods such as getenv wont work as there was no $SUDO_USER to
-# start the systemd service.
-def set_user():
-    global user
-    cmd = "who | awk '{print $1}' | sort | head -1"
-    while user == None:
-        name = check_output(cmd, shell=True).decode().strip()
-        if name not in [None, '']:
-            user = name
-        sleep(0.1)
-
-# Get the global user. get_user must be called first.
-def get_user() -> str:
-    global user
-    if user == None:
-        raise ValueError("helpers.get_user method called before user variable was set. Run helpers.set_user first.")
-    return user
-
-# Set the global user group. get_user must be called first
-def set_user_group() -> str:
-    global group
-    global user
-    if user == None:
-        raise ValueError("helpers.set_user_dir method called before user variable was set. Run helpers.set_user first.")
-    if group == None:
-        group = check_output(["id", "-g", "-n", user]).decode().strip()
-
-# Get the group of the global user. set_user_group must be called first.
-def get_user_group() -> str:
-    global group
-    if group == None:
-        raise ValueError("helpers.get_user_group method called before group variable was set. Run helpers.set_user_group first.")
-    return group
-
-# Get the default home path unless a user is specified
-def get_home_path(username = None) -> str:
-    if username == None:
-        raise ValueError("Username not defined, no home path can be found.")
-    else:
-        return str("/home/"+username)
-
-# 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
-
-async def stop_systemd_unit(unit_name: str) -> subprocess.CompletedProcess:
-    cmd = ["systemctl", "stop", unit_name]
-
-    return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-
-async def start_systemd_unit(unit_name: str) -> subprocess.CompletedProcess:
-    cmd = ["systemctl", "start", unit_name]
-
-    return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

backend/injector.py

@@ -5,7 +5,6 @@ from logging import debug, getLogger
 from traceback import format_exc
 
 from aiohttp import ClientSession
-from aiohttp.client_exceptions import ClientConnectorError
 
 BASE_ADDRESS = "http://localhost:8080"
 
@@ -34,10 +33,8 @@ class Tab:
             return (await self.websocket.receive_json()) if receive else None
         raise RuntimeError("Websocket not opened")
 
-    async def evaluate_js(self, js, run_async=False, manage_socket=True, get_result=True):
-        if manage_socket:
-            await self.open_websocket()
-
+    async def evaluate_js(self, js, run_async=False):
+        await self.open_websocket()
         res = await self._send_devtools_cmd({
             "id": 1,
             "method": "Runtime.evaluate",
@@ -46,10 +43,9 @@ class Tab:
                 "userGesture": True,
                 "awaitPromise": run_async
             }
-        }, get_result)
+        })
 
-        if manage_socket:
-            await self.client.close()
+        await self.client.close()
         return res
 
     async def get_steam_resource(self, url):
@@ -66,19 +62,17 @@ async def get_tabs():
         while True:
             try:
                 res = await web.get(f"{BASE_ADDRESS}/json")
-            except ClientConnectorError:
-                logger.debug("ClientConnectorError excepted.")
-                logger.debug("Steam isn't available yet. Wait for a moment...")
-                logger.error(format_exc())
-                await sleep(5)
-            else:
                 break
+            except:
+                logger.debug("Steam isn't available yet. Wait for a moment...")
+                logger.debug(format_exc())
+                await sleep(5)
 
         if res.status == 200:
             r = await res.json()
             return [Tab(i) for i in r]
         else:
-            raise Exception(f"/json did not return 200. {await res.text()}")
+            raise Exception(f"/json did not return 200. {await r.text()}")
 
 async def get_tab(tab_name):
     tabs = await get_tabs()

backend/legacy/library.js

@@ -1,84 +0,0 @@
-class PluginEventTarget extends EventTarget { }
-method_call_ev_target = new PluginEventTarget();
-
-window.addEventListener("message", function(evt) {
-    let ev = new Event(evt.data.call_id);
-    ev.data = evt.data.result;
-    method_call_ev_target.dispatchEvent(ev);
-}, false);
-
-async function call_server_method(method_name, arg_object={}) {
-    const token = await fetch("http://127.0.0.1:1337/auth/token").then(r => r.text());
-    const response = await fetch(`http://127.0.0.1:1337/methods/${method_name}`, {
-      method: 'POST',
-      credentials: "include",
-      headers: {
-        'Content-Type': 'application/json',
-        Authentication: token
-      },
-      body: JSON.stringify(arg_object),
-    });
-
-    const dta = await response.json();
-    if (!dta.success) throw dta.result;
-    return dta.result;
-}
-
-// Source: https://stackoverflow.com/a/2117523 Thanks!
-function uuidv4() {
-    return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
-        (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
-    );
-}
-
-async function fetch_nocors(url, request={}) {
-    let args = { method: "POST", headers: {}, body: "" };
-    request = {...args, ...request};
-    request.url = url;
-    request.data = request.body;
-    delete request.body; //maintain api-compatibility with fetch
-    return await call_server_method("http_request", request);
-}
-
-async function call_plugin_method(method_name, arg_object={}) {
-    if (plugin_name == undefined) 
-        throw new Error("Plugin methods can only be called from inside plugins (duh)");
-    const token = await fetch("http://127.0.0.1:1337/auth/token").then(r => r.text());
-    const response = await fetch(`http://127.0.0.1:1337/plugins/${plugin_name}/methods/${method_name}`, {
-        method: 'POST',
-        credentials: "include",
-        headers: {
-            'Content-Type': 'application/json',
-            Authentication: token
-        },
-        body: JSON.stringify({
-            args: arg_object,
-        }),
-    });
-
-    const dta = await response.json();
-    if (!dta.success) throw dta.result;
-    return dta.result;
-}
-
-async function execute_in_tab(tab, run_async, code) {
-    return await call_server_method("execute_in_tab", {
-        'tab': tab,
-        'run_async': run_async,
-        'code': code
-    });
-}
-
-async function inject_css_into_tab(tab, style) {
-    return await call_server_method("inject_css_into_tab", {
-        'tab': tab,
-        'style': style
-    });
-}
-
-async function remove_css_from_tab(tab, css_id) {
-    return await call_server_method("remove_css_from_tab", {
-        'tab': tab,
-        'css_id': css_id
-    });
-}

backend/loader.py

@@ -1,4 +1,4 @@
-from asyncio import Queue, sleep
+from asyncio import Queue, get_event_loop, sleep, wait_for
 from json.decoder import JSONDecodeError
 from logging import getLogger
 from os import listdir, path
@@ -16,7 +16,7 @@ except UnsupportedLibc:
     from watchdog.observers.fsevents import FSEventsObserver as Observer
 
 from injector import get_tab, inject_to_tab
-from plugin import PluginWrapper
+from plugin_wrapper import PluginWrapper
 
 
 class FileChangeHandler(RegexMatchingEventHandler):
@@ -25,14 +25,11 @@ class FileChangeHandler(RegexMatchingEventHandler):
         self.logger = getLogger("file-watcher")
         self.plugin_path = plugin_path
         self.queue = queue
-        self.disabled = True
 
     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))
+            self.queue.put_nowait(plugin_dir, True)
 
     def on_created(self, event):
         src_path = event.src_path
@@ -69,24 +66,19 @@ class Loader:
         self.plugin_path = plugin_path
         self.logger.info(f"plugin_path: {self.plugin_path}")
         self.plugins = {}
-        self.watcher = None
-        self.live_reload = live_reload
 
         if live_reload:
             self.reload_queue = Queue()
             self.observer = Observer()
-            self.watcher = FileChangeHandler(self.reload_queue, plugin_path)
-            self.observer.schedule(self.watcher, self.plugin_path, recursive=True)
+            self.observer.schedule(FileChangeHandler(self.reload_queue, plugin_path), self.plugin_path, recursive=True)
             self.observer.start()
             self.loop.create_task(self.handle_reloads())
-            self.loop.create_task(self.enable_reload_wait())
 
         server_instance.add_routes([
-            web.get("/frontend/{path:.*}", self.handle_frontend_assets),
             web.get("/plugins", self.get_plugins),
             web.get("/plugins/{plugin_name}/frontend_bundle", self.handle_frontend_bundle),
             web.post("/plugins/{plugin_name}/methods/{method_name}", self.handle_plugin_method_call),
-            web.get("/plugins/{plugin_name}/assets/{path:.*}", self.handle_plugin_frontend_assets),
+            web.get("/plugins/{plugin_name}/assets/{path:.*}", self.handle_frontend_assets),
 
             # The following is legacy plugin code.
             web.get("/plugins/load_main/{name}", self.load_plugin_main_view),
@@ -94,26 +86,15 @@ class Loader:
             web.get("/steam_resource/{path:.+}", self.get_steam_resource)
         ])
 
-    async def enable_reload_wait(self):
-        if self.live_reload:
-            await sleep(10)
-            self.logger.info("Hot reload enabled")
-            self.watcher.disabled = False
-
-    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])
+        return web.json_response([str(i) if not i.legacy else "$LEGACY_"+str(i) for i in plugins])
 
-    def handle_plugin_frontend_assets(self, request):
+    def handle_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, headers={"Cache-Control": "no-cache"})
+        return web.FileResponse(file)
 
     def handle_frontend_bundle(self, request):
         plugin = self.plugins[request.match_info["plugin_name"]]
@@ -121,9 +102,9 @@ class Loader:
         with open(path.join(self.plugin_path, plugin.plugin_directory, "dist/index.js"), 'r') as bundle:
             return web.Response(text=bundle.read(), content_type="application/javascript")
 
-    def import_plugin(self, file, plugin_directory, refresh=False):
+    def import_plugin(self, plugin_directory, refresh=False):
         try:
-            plugin = PluginWrapper(file, plugin_directory, self.plugin_path)
+            plugin = PluginWrapper(plugin_directory, self.plugin_path)
             if plugin.name in self.plugins:
                     if not "debug" in plugin.flags and refresh:
                         self.logger.info(f"Plugin {plugin.name} is already loaded and has requested to not be re-loaded")
@@ -131,17 +112,16 @@ class Loader:
                     else:
                         self.plugins[plugin.name].stop()
                         self.plugins.pop(plugin.name, None)
-            if plugin.passive:
-                self.logger.info(f"Plugin {plugin.name} is passive")
-            self.plugins[plugin.name] = plugin.start()
+            self.plugins[plugin.name] = plugin
+            self.loop.create_task(plugin.start())
             self.logger.info(f"Loaded {plugin.name}")
-            self.loop.create_task(self.dispatch_plugin(plugin.name if not plugin.legacy else "$LEGACY_" + plugin.name, plugin.version))
+            self.loop.create_task(self.dispatch_plugin(plugin.name))
         except Exception as e:
-            self.logger.error(f"Could not load {file}. {e}")
+            self.logger.error(f"Could not load {plugin_directory}. {e}")
             print_exc()
 
-    async def dispatch_plugin(self, name, version):
-        await inject_to_tab("SP", f"window.importDeckyPlugin('{name}', '{version}')")
+    async def dispatch_plugin(self, name):
+        await inject_to_tab("SP", f"window.importDeckyPlugin('{name}')")
 
     def import_plugins(self):
         self.logger.info(f"import plugins from {self.plugin_path}")
@@ -149,7 +129,7 @@ class Loader:
         directories = [i for i in listdir(self.plugin_path) if path.isdir(path.join(self.plugin_path, i)) and path.isfile(path.join(self.plugin_path, i, "plugin.json"))]
         for directory in directories:
             self.logger.info(f"found plugin: {directory}")
-            self.import_plugin(path.join(self.plugin_path, directory, "main.py"), directory)
+            self.import_plugin(directory)
 
     async def handle_reloads(self):
         while True:
@@ -162,16 +142,15 @@ class Loader:
         method_name = request.match_info["method_name"]
         try:
             method_info = await request.json()
-            args = method_info["args"]
+            method_args = method_info["args"]
         except JSONDecodeError:
-            args = {}
+            method_args = {}
         try:
           if method_name.startswith("_"):
               raise RuntimeError("Tried to call private method")
-          res["result"] = await plugin.execute_method(method_name, args)
-          res["success"] = True
+          res = await plugin.call_method(method_name, method_args)
         except Exception as e:
-            res["result"] = str(e)
+            res["result"] = repr(e)
             res["success"] = False
         return web.json_response(res)
 
@@ -187,8 +166,8 @@ class Loader:
         with open(path.join(self.plugin_path, plugin.plugin_directory, plugin.main_view_html), 'r') as template:
             template_data = template.read()
             ret = f"""
-            <script src="/legacy/library.js"></script>
-            <script>window.plugin_name = '{plugin.name}' </script>
+            <script src="/static/legacy-library.js"></script>
+            <script>const plugin_name = '{plugin.name}' </script>
             <base href="http://127.0.0.1:1337/plugins/plugin_resource/{plugin.name}/">
             {template_data}
             """

backend/main.py

@@ -1,108 +1,68 @@
-# Change PyInstaller files permissions
-import sys
-from subprocess import call
-if hasattr(sys, '_MEIPASS'):
-    call(['chmod', '-R', '755', sys._MEIPASS])
-# Full imports
-from asyncio import get_event_loop, sleep
-from json import dumps, loads
 from logging import DEBUG, INFO, basicConfig, getLogger
-from os import getenv, chmod
-from traceback import format_exc
+from os import getenv
 
-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 (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
-
-# Ensure USER and GROUP vars are set first.
-# TODO: This isn't the best way to do this but supports the current
-# implementation. All the config load and environment setting eventually be
-# moved into init or a config/loader method.
-set_user()
-set_user_group()
-USER = get_user()
-GROUP = get_user_group()
-HOME_PATH = "/home/"+USER
-HOMEBREW_PATH = HOME_PATH+"/homebrew"
 CONFIG = {
-    "plugin_path": getenv("PLUGIN_PATH", HOMEBREW_PATH+"/plugins"),
+    "plugin_path": getenv("PLUGIN_PATH", "/home/deck/homebrew/plugins"),
     "chown_plugin_path": getenv("CHOWN_PLUGIN_PATH", "1") == "1",
     "server_host": getenv("SERVER_HOST", "127.0.0.1"),
     "server_port": int(getenv("SERVER_PORT", "1337")),
     "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")],
+    "store_url": getenv("STORE_URL", "https://beta.deckbrew.xyz")
 }
 
-basicConfig(
-    level=CONFIG["log_level"],
-    format="[%(module)s][%(levelname)s]: %(message)s"
-)
+basicConfig(level=CONFIG["log_level"], format="[%(module)s][%(levelname)s]: %(message)s")
+
+from asyncio import get_event_loop, sleep
+from json import dumps, loads
+from os import path
+from subprocess import Popen
+
+import aiohttp_cors
+from aiohttp.web import Application, run_app, static
+from aiohttp_jinja2 import setup as jinja_setup
+
+from browser import PluginBrowser
+from injector import inject_to_tab, tab_has_global_var
+from loader import Loader
+from utilities import Utilities
 
 logger = getLogger("Main")
 
 async def chown_plugin_dir(_):
-    code_chown = call(["chown", "-R", USER+":"+GROUP, CONFIG["plugin_path"]])
-    code_chmod = call(["chmod", "-R", "555", CONFIG["plugin_path"]])
-    if code_chown != 0 or code_chmod != 0:
-        logger.error(f"chown/chmod exited with a non-zero exit code (chown: {code_chown}, chmod: {code_chmod})")
+    Popen(["chown", "-R", "deck:deck", CONFIG["plugin_path"]])
+    Popen(["chmod", "-R", "555", CONFIG["plugin_path"]])
 
 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="*")
         })
         self.plugin_loader = Loader(self.web_app, CONFIG["plugin_path"], self.loop, CONFIG["live_reload"])
-        self.plugin_browser = PluginBrowser(CONFIG["plugin_path"], self.plugin_loader.plugins, self.plugin_loader)
-        self.settings = SettingsManager("loader", path.join(HOMEBREW_PATH, "settings"))
+        self.plugin_browser = PluginBrowser(CONFIG["plugin_path"], self.web_app, CONFIG["store_url"])
         self.utilities = Utilities(self)
-        self.updater = Updater(self)
 
         jinja_setup(self.web_app)
+        self.web_app.on_startup.append(self.inject_javascript)
         if CONFIG["chown_plugin_path"] == True:
             self.web_app.on_startup.append(chown_plugin_dir)
         self.loop.create_task(self.loader_reinjector())
         self.loop.create_task(self.load_plugins())
-        if not self.settings.getSetting("cef_forward", False):
-            self.loop.create_task(stop_systemd_unit(REMOTE_DEBUGGER_UNIT))
         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'))])
 
     def exception_handler(self, loop, context):
         if context["message"] == "Unclosed connection":
             return
         loop.default_exception_handler(context)
 
-    async def get_auth_token(self, request):
-        return Response(text=get_csrf_token())
-
     async def wait_for_server(self):
         async with ClientSession() as web:
             while True:
@@ -115,22 +75,20 @@ 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)
-        await self.inject_javascript()
         while True:
-            await sleep(5)
-            if not await tab_has_global_var("SP", "deckyHasLoaded"):
+            await sleep(1)
+            if not await tab_has_global_var("SP", "DeckyPluginLoader"):
                 logger.info("Plugin loader isn't present in Steam anymore, reinjecting...")
                 await self.inject_javascript()
 
     async def inject_javascript(self, request=None):
         try:
-            await inject_to_tab("SP", "try{if (window.deckyHasLoaded) location.reload();window.deckyHasLoaded = true;(async()=>{while(!window.SP_REACT){await new Promise(r => setTimeout(r, 10))};await import('http://localhost:1337/frontend/index.js')})();}catch(e){console.error(e)}", True)
+            await inject_to_tab("SP", "try{" + open(path.join(path.dirname(__file__), "./static/plugin-loader.iife.js"), "r").read() + "}catch(e){console.error(e)}", True)
         except:
-            logger.info("Failed to inject JavaScript into tab\n" + format_exc())
+            logger.info("Failed to inject JavaScript into tab")
             pass
 
     def run(self):

backend/plugin.py

@@ -1,161 +0,0 @@
-import multiprocessing
-from asyncio import (Lock, get_event_loop, new_event_loop,
-                     open_unix_connection, set_event_loop, sleep,
-                     start_unix_server, IncompleteReadError, LimitOverrunError)
-from concurrent.futures import ProcessPoolExecutor
-from 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
-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
-        self.plugin_directory = plugin_directory
-        self.reader = None
-        self.writer = None
-        self.socket_addr = f"/tmp/plugin_socket_{time()}"
-        self.method_call_lock = Lock()
-
-        self.version = None
-
-        json = load(open(path.join(plugin_path, plugin_directory, "plugin.json"), "r"))
-        if path.isfile(path.join(plugin_path, plugin_directory, "package.json")):
-            package_json = load(open(path.join(plugin_path, plugin_directory, "package.json"), "r"))
-            self.version = package_json["version"]
-
-
-        self.legacy = False
-        self.main_view_html = json["main_view_html"] if "main_view_html" in json else ""
-        self.tile_view_html = json["tile_view_html"] if "tile_view_html" in json else ""
-        self.legacy = self.main_view_html or self.tile_view_html
-
-        self.name = json["name"]
-        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):
-        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
-
-            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, limit=BUFFER_LIMIT)
-
-    async def _listen_for_method_call(self, reader, writer):
-        while True:
-            line = bytearray()
-            while True:
-                try:
-                    line.extend(await reader.readuntil())
-                except LimitOverrunError:
-                    line.extend(await reader.read(reader._limit))
-                    continue
-                except IncompleteReadError as err:
-                    line.extend(err.partial)
-                    break
-                else:
-                    break
-            data = loads(line.decode("utf-8"))
-            if "stop" in data:
-                get_event_loop().stop()
-                while get_event_loop().is_running():
-                    await sleep(0)
-                get_event_loop().close()
-                return
-            d = {"res": None, "success": True}
-            try:
-                d["res"] = await getattr(self.Plugin, data["method"])(self.Plugin, **data["args"])
-            except Exception as e:
-                d["res"] = str(e)
-                d["success"] = False
-            finally:
-                writer.write((dumps(d)+"\n").encode("utf-8"))
-                await writer.drain()
-
-    async def _open_socket_if_not_exists(self):
-        if not self.reader:
-            retries = 0
-            while retries < 10:
-                try:
-                    self.reader, self.writer = await open_unix_connection(self.socket_addr, limit=BUFFER_LIMIT)
-                    return True
-                except:
-                    await sleep(2)
-                    retries += 1
-            return False
-        else:
-            return True
-
-    def start(self):
-        if self.passive:
-            return self
-        multiprocessing.Process(target=self._init).start()
-        return self
-
-    def stop(self):
-        if self.passive:
-            return
-        async def _(self):
-            if await self._open_socket_if_not_exists():
-                self.writer.write((dumps({"stop": True})+"\n").encode("utf-8"))
-                await self.writer.drain()
-                self.writer.close()
-        get_event_loop().create_task(_(self))
-
-    async def execute_method(self, method_name, kwargs):
-        if self.passive:
-            raise RuntimeError("This plugin is passive (aka does not implement main.py)")
-        async with self.method_call_lock:
-            if await self._open_socket_if_not_exists():
-                self.writer.write(
-                    (dumps({"method": method_name, "args": kwargs})+"\n").encode("utf-8"))
-                await self.writer.drain()
-                line = bytearray()
-                while True:
-                    try:
-                        line.extend(await self.reader.readuntil())
-                    except LimitOverrunError:
-                        line.extend(await self.reader.read(self.reader._limit))
-                        continue
-                    except IncompleteReadError as err:
-                        line.extend(err.partial)
-                        break
-                    else:
-                        break
-                res = loads(line.decode("utf-8"))
-                if not res["success"]:
-                    raise Exception(res["res"])
-                return res["res"]

backend/plugin/binary_plugin.py

@@ -0,0 +1,59 @@
+import os
+from asyncio import get_event_loop, sleep, subprocess
+from posixpath import join
+from tempfile import mkdtemp
+
+from plugin_protocol import PluginProtocolServer
+
+
+class BinaryPlugin:
+    def __init__(self, plugin_directory, file_name, flags, logger) -> None:
+        self.server = PluginProtocolServer(self)
+        self.connection = None
+        self.process = None
+
+        self.flags = flags
+        self.logger = logger
+
+        self.plugin_directory = plugin_directory
+        self.file_name = file_name
+
+
+    async def start(self):
+        if self.connection and self.connection.is_serving:
+            self.connection.close()
+
+        self.unix_socket_path = BinaryPlugin.generate_socket_path()
+        self.logger.debug(f"starting unix server on {self.unix_socket_path}")
+        self.connection = await get_event_loop().create_unix_server(lambda: self.server, path=self.unix_socket_path)
+
+        env = dict(DECKY_PLUGIN_SOCKET = self.unix_socket_path)
+        self.process = await subprocess.create_subprocess_exec(join(self.plugin_directory, self.file_name), env=env)
+        get_event_loop().create_task(self.process_loop())
+
+    async def stop(self):
+        self.stopped = True
+        if self.connection and self.connection.is_serving:
+            self.connection.close()
+
+        if self.process and self.process.is_alive:
+            self.process.terminate()
+
+    async def process_loop(self):
+        await self.process.wait()
+        if not self.stopped:
+            self.logger.info("backend process was killed - restarting in 10 seconds")
+            await sleep(10)
+            await self.start()
+
+    def generate_socket_path():
+        tmp_dir = mkdtemp("decky-plugin")
+        os.chown(tmp_dir, 1000, 1000)
+        return join(tmp_dir, "socket")
+
+    # called on the server/loader process
+    async def call_method(self, method_name, method_args):
+        if self.process.returncode == None:
+            return dict(success = False, result = "Process not alive")
+
+        return await self.server.call_method(method_name, method_args)

backend/plugin/passive_plugin.py

@@ -0,0 +1,18 @@
+class PassivePlugin:
+    def __init__(self, logger) -> None:
+        self.logger
+        pass
+
+    def call_method(self, method_name, args):
+        self.logger.debug(f"Tried to call method {method_name}, but plugin is in passive mode")
+        pass
+
+    def execute_method(self, method_name, method_args):
+        self.logger.debug(f"Tried to execute method {method_name}, but plugin is in passive mode")
+        pass
+
+    async def start(self):
+        pass
+
+    async def stop(self):
+        pass

backend/plugin/plugin.py

@@ -0,0 +1,18 @@
+from posixpath import join
+
+from genericpath import isfile
+
+from plugin.binary_plugin import BinaryPlugin
+from plugin.passive_plugin import PassivePlugin
+from plugin.python_plugin import PythonPlugin
+
+
+def get_plugin_backend(spec, plugin_directory, flags, logger):
+    if spec == None and isfile(join(plugin_directory, "main.py")):
+        return PythonPlugin(plugin_directory, "main.py", flags, logger)
+    elif spec["type"] == "python":
+        return PythonPlugin(plugin_directory, spec["file"], flags, logger)
+    elif spec["type"] == "binary":
+        return BinaryPlugin(plugin_directory, spec["file"], flags, logger)
+    else:
+        return PassivePlugin(logger)

backend/plugin/python_plugin.py

@@ -0,0 +1,129 @@
+import json
+import multiprocessing
+import os
+import uuid
+from asyncio import (Protocol, get_event_loop, new_event_loop, set_event_loop,
+                     sleep)
+from importlib.util import module_from_spec, spec_from_file_location
+from posixpath import join
+from signal import SIGINT, signal
+from tempfile import mkdtemp
+
+from plugin_protocol import PluginProtocolServer
+
+multiprocessing.set_start_method("fork")
+
+# only useable by the python backend
+class PluginProtocolClient(Protocol):
+    def __init__(self, backend, logger) -> None:
+        super().__init__()
+        self.backend = backend
+        self.logger = logger
+
+    def connection_made(self, transport):
+        self.transport = transport
+
+    def data_received(self, data: bytes) -> None:
+        message = json.loads(data.decode("utf-8"))
+        message_id = str(uuid.UUID(message["id"]))
+        message_type = message["type"]
+        payload = message["payload"]
+
+        self.logger.debug(f"received {message_id} {message_type} {payload}")
+        if message_type == "method_call":
+          get_event_loop().create_task(self.handle_method_call(message_id, payload["name"], payload["args"]))
+
+    async def handle_method_call(self, message_id, method_name, method_args):
+        try:
+            result = await self.backend.execute_method(method_name, method_args)
+            self.respond_message(message_id, "method_response", dict(success = True, result = result))
+        except AttributeError as e:
+            self.respond_message(message_id, "method_response", dict(success = False, result = f"plugin does not expose a method called {method_name}"))
+        except Exception as e:
+            self.respond_message(message_id, "method_response", dict(success = False, result = str(e)))
+
+    def respond_message(self, message_id, message_type, payload):
+        self.logger.debug(f"sending {message_id} {message_type} {payload}")
+        message = json.dumps(dict(id = str(message_id), type = message_type, payload = payload))
+        self.transport.write(message.encode('utf-8'))
+
+
+class PythonPlugin:
+    def __init__(self, plugin_directory, file_name, flags, logger) -> None:
+        self.client = PluginProtocolClient(self, logger)
+        self.server = PluginProtocolServer(self)
+        self.connection = None
+        self.process = None
+        self.stopped = False
+
+        self.plugin_directory = plugin_directory
+        self.file_name = file_name
+        self.flags = flags
+        self.logger = logger
+
+    def _init(self):
+        self.logger.debug(f"child process Initializing")
+        signal(SIGINT, lambda s, f: exit(0))
+
+        set_event_loop(new_event_loop())
+        # TODO: both processes can access the socket
+        # setuid(0 if "root" in self.flags else 1000)
+        spec = spec_from_file_location("_", join(self.plugin_directory, self.file_name))
+        module = module_from_spec(spec)
+        spec.loader.exec_module(module)
+        self.Plugin = module.Plugin
+
+        if hasattr(self.Plugin, "_main"):
+            self.logger.debug("Found _main, calling it")
+            get_event_loop().create_task(self.Plugin._main(self.Plugin))
+
+        get_event_loop().create_task(self._connect())
+        get_event_loop().run_forever()
+
+    async def _connect(self):
+        self.logger.debug(f"connecting to unix server on {self.unix_socket_path}")
+        await get_event_loop().create_unix_connection(lambda: self.client, path=self.unix_socket_path)
+
+    async def start(self):
+        if self.connection:
+            self.connection.close()
+
+        self.unix_socket_path = PythonPlugin.generate_socket_path()
+        self.logger.debug(f"starting unix server on {self.unix_socket_path}")
+        self.connection = await get_event_loop().create_unix_server(lambda: self.server, path=self.unix_socket_path)
+
+        self.process = multiprocessing.Process(target=self._init)
+        self.process.start()
+        get_event_loop().create_task(self.process_loop())
+        self.stopped = False
+
+    async def stop(self):
+        self.stopped = True
+        if self.connection:
+            self.connection.close()
+
+        if self.process and self.process.is_alive:
+            self.process.terminate()
+
+    async def process_loop(self):
+        await get_event_loop().run_in_executor(None, self.process.join)
+        if not self.stopped:
+            self.logger.info("backend process was killed - restarting in 10 seconds")
+            await sleep(10)
+            await self.start()
+
+    # called on the server/loader process
+    async def call_method(self, method_name, method_args):
+        if not self.process.is_alive():
+            return dict(success = False, result = "Process not alive")
+
+        return await self.server.call_method(method_name, method_args)
+
+    # called on the client
+    def execute_method(self, method_name, method_args):
+        return getattr(self.Plugin, method_name)(self.Plugin, **method_args)
+
+    def generate_socket_path():
+        tmp_dir = mkdtemp("decky-plugin")
+        os.chown(tmp_dir, 1000, 1000)
+        return join(tmp_dir, "socket")

backend/plugin_protocol.py

@@ -0,0 +1,46 @@
+import json
+import uuid
+from asyncio import Protocol, TimeoutError, get_event_loop, wait_for
+from gc import callbacks
+from subprocess import call
+
+
+class PluginProtocolServer(Protocol):
+  def __init__(self, backend) -> None:
+    super().__init__()
+    self.backend = backend
+    self.callbacks = {}
+
+  def connection_made(self, transport):
+    self.transport = transport
+
+  def data_received(self, data: bytes) -> None:
+    message = json.loads(data.decode("utf-8"))
+    message_id = str(uuid.UUID(message["id"]))
+    message_type = message["type"]
+    payload = message["payload"]
+
+    if message_type == "method_response":
+      get_event_loop().create_task(self.handle_method_response(message_id, payload["success"], payload["result"]))
+
+  async def handle_method_response(self, message_id, success, result):
+    if message_id in self.callbacks:
+      self.callbacks[message_id].set_result(dict(success = success, result = result))
+      del self.callbacks[message_id]
+
+  async def send_message(self, type, payload):
+    id = str(uuid.uuid4())
+    callback = get_event_loop().create_future()
+    message = json.dumps(dict(id = id, type = type, payload = payload))
+
+    self.callbacks[id] = callback
+    self.transport.write(message.encode('utf-8'))
+
+    try:
+      return await wait_for(callback, 10)
+    except TimeoutError as e:
+      del self.callbacks[id]
+      raise e
+
+  def call_method(self, method_name, method_args):
+    return self.send_message("method_call", dict(name = method_name, args = method_args))

backend/plugin_wrapper.py

@@ -0,0 +1,37 @@
+import multiprocessing
+from json import load
+from logging import getLogger
+from os import path
+
+from plugin.plugin import get_plugin_backend
+
+
+class PluginWrapper:
+    def __init__(self, plugin_relative_directory, plugin_path) -> None:
+        self.plugin_directory = path.join(plugin_path, plugin_relative_directory)
+
+        json = load(open(path.join(self.plugin_directory, "plugin.json"), "r"))
+
+        self.legacy = False
+        self.main_view_html = json["main_view_html"] if "main_view_html" in json else ""
+        self.tile_view_html = json["tile_view_html"] if "tile_view_html" in json else ""
+        self.legacy = self.main_view_html or self.tile_view_html
+
+        self.name = json["name"]
+        self.author = json["author"]
+        self.flags = json["flags"]
+        self.logger = getLogger(f"{self.name}")
+
+        self.backend = get_plugin_backend(json.get("backend"), self.plugin_directory, self.flags, self.logger)
+
+    def call_method(self, method_name, args):
+        return self.backend.call_method(method_name, args)
+
+    def start(self):
+        return self.backend.start()
+
+    def stop(self):
+        return self.backend.stop()
+
+    def __str__(self) -> str:
+        return self.name

backend/settings.py

@@ -1,44 +0,0 @@
-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()

backend/updater.py

@@ -1,164 +0,0 @@
-import uuid
-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
-
-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)
-            ])
-            context.loop.create_task(self.version_reloader())
-
-    async def _handle_server_method_call(self, request):
-        method_name = request.match_info["method_name"]
-        try:
-            args = await request.json()
-        except JSONDecodeError:
-            args = {}
-        res = {}
-        try:
-            r = await self.updater_methods[method_name](**args)
-            res["result"] = r
-            res["success"] = True
-        except Exception as e:
-            res["result"] = str(e)
-            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, "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.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)
-        return await self.get_version()
-
-    async def version_reloader(self):
-        await sleep(30)
-        while True:
-            try:
-                await self.check_for_updates()
-            except:
-                pass
-            await sleep(60 * 60 * 6) # 6 hours
-
-    async def do_update(self):
-        version = self.remoteVer["tag_name"]
-        download_url = self.remoteVer["assets"][0]["browser_download_url"]
-
-        tab = await get_tab("SP")
-        await tab.open_websocket()
-        async with ClientSession() as web:
-            async with web.request("GET", download_url, ssl=helpers.get_ssl_context(), allow_redirects=True) as res:
-                total = int(res.headers.get('content-length', 0))
-                try:
-                    remove(path.join(getcwd(), "PluginLoader"))
-                except:
-                    pass
-                with open(path.join(getcwd(), "PluginLoader"), "wb") as out:
-                    progress = 0
-                    raw = 0
-                    async for c in res.content.iter_chunked(512):
-                        out.write(c)
-                        raw += len(c)
-                        new_progress = round((raw / total) * 100)
-                        if progress != new_progress:
-                            self.context.loop.create_task(tab.evaluate_js(f"window.DeckyUpdater.updateProgress({new_progress})", False, False, False))
-                            progress = new_progress
-
-                with open(path.join(getcwd(), ".loader.version"), "w") as out:
-                    out.write(version)
-
-                call(['chmod', '+x', path.join(getcwd(), "PluginLoader")])
-
-                logger.info("Updated loader installation.")
-                await tab.evaluate_js("window.DeckyUpdater.finish()", False, False)
-                await tab.client.close()
-
-    async def do_restart(self):
-        call(["systemctl", "daemon-reload"])
-        call(["systemctl", "restart", "plugin_loader"])

backend/utilities.py

@@ -1,12 +1,9 @@
 import uuid
-import os
 from json.decoder import JSONDecodeError
 
 from aiohttp import ClientSession, web
 
 from injector import inject_to_tab
-import helpers
-import subprocess
 
 
 class Utilities:
@@ -15,18 +12,11 @@ class Utilities:
         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,
-            "set_setting": self.set_setting,
-            "get_setting": self.get_setting,
-            "filepicker_ls": self.filepicker_ls
+            "remove_css_from_tab": self.remove_css_from_tab
         }
 
         if context:
@@ -50,26 +40,15 @@ 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:
+            async with web.request(method, url, **kwargs) as res:
                 return {
                     "status": res.status,
                     "headers": dict(res.headers),
@@ -90,12 +69,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):
@@ -120,7 +99,7 @@ class Utilities:
 
             return {
                 "success": True,
-                "result": css_id
+                "result" : css_id
             }
         except Exception as e:
             return {
@@ -154,43 +133,3 @@ class Utilities:
                 "success": False,
                 "result": e
             }
-
-    async def get_setting(self, key, default):
-        return self.context.settings.getSetting(key, default)
-
-    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)
-        return True
-
-    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
-        }

contrib/deck.sh

@@ -4,8 +4,6 @@
 ## This script defaults to port 22 unless otherwise specified, and cannot run without a sudo password or LAN IP.
 ## You will need to specify the path to the ssh key if using key connection exclusively.
 
-## TODO: document latest changes to wiki
-
 ## Pre-parse arugments for ease of use
 CLONEFOLDER=${1:-""}
 INSTALLFOLDER=${2:-""}
@@ -13,13 +11,9 @@ DECKIP=${3:-""}
 SSHPORT=${4:-""}
 PASSWORD=${5:-""}
 SSHKEYLOC=${6:-""}
-LOADERBRANCH=${7:-""}
-LIBRARYBRANCH=${8:-""}
-TEMPLATEBRANCH=${9:-""}
-LATEST=${10:-""}
 
 ## gather options into an array 
-OPTIONSARRAY=("$CLONEFOLDER" "$INSTALLFOLDER" "$DECKIP" "$SSHPORT" "$PASSWORD" "$SSHKEYLOC" "$LOADERBRANCH" "$LIBRARYBRANCH" "$TEMPLATEBRANCH" "$LATEST")
+OPTIONSARRAY=("$CLONEFOLDER" $INSTALLFOLDER "$DECKIP" "$SSHPORT" "$PASSWORD" "$SSHKEYLOC")
 
 ## iterate through options array to check their presence
 count=0
@@ -34,21 +28,19 @@ setfolder() {
         local DEFAULT="git"
     elif [[ "$2" == "install" ]]; then
         local ACTION="install"
-        local DEFAULT="dev"
+        local DEFAULT="loaderdev"
     fi
-    
+
+    printf "Enter the directory in /home/user to ${ACTION} to.\n"
+    printf "Example: if your home directory is /home/user you would type: ${DEFAULT}\n"
+    printf "The ${ACTION} directory would be: ${HOME}/${DEFAULT}\n"
     if [[ "$ACTION" == "clone" ]]; then
-        printf "Enter the directory in /home/user/ to ${ACTION} to.\n"
-        printf "The ${ACTION} directory would be: ${HOME}/${DEFAULT}\n"
         read -p "Enter your ${ACTION} directory: " CLONEFOLDER
         if ! [[ "$CLONEFOLDER" =~ ^[[:alnum:]]+$ ]]; then
             printf "Folder name not provided. Using default, '${DEFAULT}'.\n"
             CLONEFOLDER="${DEFAULT}"
         fi
     elif [[ "$ACTION" == "install" ]]; then
-        printf "Enter the directory in /home/deck/homebrew to ${ACTION} pluginloader to.\n"
-        printf "The ${ACTION} directory would be: /home/deck/homebrew/${DEFAULT}/pluginloader\n"
-        printf "It is highly recommended that you use the default folder path seen above, just press enter at the next prompt.\n"
         read -p "Enter your ${ACTION} directory: " INSTALLFOLDER
         if ! [[ "$INSTALLFOLDER" =~ ^[[:alnum:]]+$ ]]; then
             printf "Folder name not provided. Using default, '${DEFAULT}'.\n"
@@ -114,81 +106,47 @@ clonefromto() {
     # printf "repo=$1\n"
     # printf "outdir=$2\n"
     # printf "branch=$3\n"
-    printf "Repository: $1\n"
-    git clone $1 $2 &> '/dev/null'
+    if [[ -z $3 ]]; then
+        BRANCH=""
+    else
+        BRANCH="-b $3"
+    fi
+    git clone $1 $2 $BRANCH &> '/dev/null'
     CODE=$?
-    # printf "CODE=${CODE}"
     if [[ $CODE -eq 128 ]]; then
         cd $2
-        git fetch --all &> '/dev/null'
-    fi
-    if [[ -z $3 ]]; then
-        printf "Enter the desired branch for repository "$1" :\n"
-        local OUT="$(git branch -r | sed '/\/HEAD/d')"
-        # $OUT="$($OUT > )"
-        printf "$OUT\nbranch: "
-        read BRANCH
-    else
-        printf "on branch: $3\n"
-        BRANCH="$3"
-    fi
-    if ! [[ -z ${BRANCH} ]]; then
-        git checkout $BRANCH &> '/dev/null'
-    fi
-    if [[ ${LATEST} == "true" ]]; then
-        git pull --all
-    elif [[ ${LATEST} == "true" ]]; then
-        printf "Assuming user not pulling latest commits.\n"
-    else
-        printf "Pull latest commits? (y/N): "
-        read PULL
-        case ${PULL:0:1} in
-            y|Y )
-                printf "Pulling latest commits.\n"
-                git pull --all
-            ;;
-            * )
-                printf "Not pulling latest commits.\n"
-            ;;
-        esac
-        if ! [[ "$PULL" =~ ^[[:alnum:]]+$ ]]; then
-            printf "Assuming user not pulling latest commits.\n"
-        fi
+        git fetch &> '/dev/null'
     fi
 }
 
-pnpmtransbundle() {
+npmtransbundle() {
     cd $1
     if [[ "$2" == "library" ]]; then
         npm install --quiet &> '/dev/null'
         npm run build --quiet &> '/dev/null'
         sudo npm link --quiet &> '/dev/null'
-    elif [[ "$2" == "frontend" ]]; then
-        pnpm i &> '/dev/null'
-        pnpm run build &> '/dev/null'
-    elif [[ "$2" == "template" ]]; then
-        pnpm i &> '/dev/null'
-        pnpm run build &> '/dev/null'
+    elif [[ "$2" == "frontend" ]] || [[ "$2" == "template" ]]; then
+        npm install --quiet &> '/dev/null'
+        npm link decky-frontend-lib --quiet &> '/dev/null'
+        npm run build --quiet &> '/dev/null'
     fi
 }
 
-if ! [[ $count -gt 9 ]] ; then
-    printf "Installing Steam Deck Plugin Loader contributor/developer (for Steam Deck)...\n"
+printf "Installing Steam Deck Plugin Loader contributor (for Steam Deck)...\n"
 
-    printf "THIS SCRIPT ASSUMES YOU ARE RUNNING IT ON A PC, NOT THE DECK!
-    Not planning to contribute to or develop for PluginLoader?
-    If so, you should not be using this script.\n
-    If you have a release/nightly installed this script will disable it.\n"
+printf "THIS SCRIPT ASSUMES YOU ARE RUNNING IT ON A PC, NOT THE DECK!
+Not planning to contribute to PluginLoader?
+If so, you should not be using this script.\n
+If you have a release/nightly installed this script will disable it.\n"
 
-    printf "This script requires you to have nodejs installed. (If nodejs doesn't bundle npm on your OS/distro, then npm is required as well).\n"
-fi
+printf "This script requires you to have nodejs installed. (If nodejs doesn't bundle npm on your OS/distro, then npm is required as well).\n"
+
+# [[ $count -gt 0 ]] || read -p "Press any key to continue"
 
 if ! [[ $count -gt 0 ]] ; then
     read -p "Press any key to continue"
 fi
 
-printf "\n"
-
 ## User chooses preffered clone & install directories
 
 if [[ "$CLONEFOLDER" == "" ]]; then
@@ -200,7 +158,7 @@ if [[ "$INSTALLFOLDER" == "" ]]; then
 fi
 
 CLONEDIR="$HOME/$CLONEFOLDER"
-INSTALLDIR="/home/deck/homebrew/$INSTALLFOLDER"
+INSTALLDIR="/home/deck/$INSTALLFOLDER"
 
 ## Input ip address, port, password and sshkey
 
@@ -250,7 +208,7 @@ fi
 
 ## Create folder structure
 
-printf "Cloning git repositories.\n"
+printf "\nCloning git repositories.\n"
 
 mkdir -p ${CLONEDIR} &> '/dev/null'
 
@@ -259,72 +217,61 @@ mkdir -p ${CLONEDIR} &> '/dev/null'
 # rm -r ${CLONEDIR}/pluginlibrary
 # rm -r ${CLONEDIR}/plugintemplate
 
-clonefromto "https://github.com/SteamDeckHomebrew/PluginLoader" ${CLONEDIR}/pluginloader "$LOADERBRANCH"
+clonefromto "https://github.com/SteamDeckHomebrew/PluginLoader" ${CLONEDIR}/pluginloader react-frontend-plugins
 
-clonefromto "https://github.com/SteamDeckHomebrew/decky-frontend-lib" ${CLONEDIR}/pluginlibrary "$LIBRARYBRANCH"
+clonefromto "https://github.com/SteamDeckHomebrew/decky-frontend-lib" ${CLONEDIR}/pluginlibrary
 
-clonefromto "https://github.com/SteamDeckHomebrew/decky-plugin-template" ${CLONEDIR}/plugintemplate "$TEMPLATEBRANCH"
-
-## install python dependencies to deck
-
-printf "\nInstalling python dependencies.\n"
-
-rsync -azp --rsh="ssh -p $SSHPORT $IDENINVOC" ${CLONEDIR}/pluginloader/requirements.txt deck@${DECKIP}:${INSTALLDIR}/pluginloader/requirements.txt &> '/dev/null'
-
-ssh deck@${DECKIP} -p ${SSHPORT} ${IDENINVOC} "python -m ensurepip && python -m pip install --upgrade pip && python -m pip install --upgrade setuptools && python -m pip install -r $INSTALLDIR/pluginloader/requirements.txt" &> '/dev/null'
+clonefromto "https://github.com/SteamDeckHomebrew/decky-plugin-template" ${CLONEDIR}/plugintemplate
 
 ## Transpile and bundle typescript
 
-[ "$UID" -eq 0 ] || printf "Input password to proceed with install.\n"
+type npm &> '/dev/null'
 
-sudo npm install -g pnpm &> '/dev/null'
+NPMLIVES=$?
 
-type pnpm &> '/dev/null'
-
-PNPMLIVES=$?
-
-if ! [[ "$PNPMLIVES" -eq 0 ]]; then
-    printf "pnpm does not appear to be installed, exiting.\n"
+if ! [[ "$NPMLIVES" -eq 0 ]]; then
+    printf "npm does not to be installed, exiting.\n"
     exit 1
 fi
 
+[ "$UID" -eq 0 ] || printf "Input password to install typscript compiler.\n"
+
+## TODO: add a way of verifying if tsc is installed and to skip this step if it is
+sudo npm install --quiet -g tsc &> '/dev/null'
+
 printf "Transpiling and bundling typescript.\n"
 
-pnpmtransbundle ${CLONEDIR}/pluginlibrary/ "library"
+npmtransbundle ${CLONEDIR}/pluginlibrary/ "library"
 
-pnpmtransbundle ${CLONEDIR}/pluginloader/frontend "frontend"
+npmtransbundle ${CLONEDIR}/pluginloader/frontend "frontend"
 
-pnpmtransbundle ${CLONEDIR}/plugintemplate "template"
+npmtransbundle ${CLONEDIR}/plugintemplate "template"
 
 ## Transfer relevant files to deck
 
 printf "Copying relevant files to install directory\n\n"
 
-ssh deck@${DECKIP} -p ${SSHPORT} ${IDENINVOC} "mkdir -p $INSTALLDIR/pluginloader && mkdir -p $INSTALLDIR/plugins" &> '/dev/null'
-
 ### copy files for PluginLoader
-rsync -avzp --rsh="ssh -p $SSHPORT $IDENINVOC" --exclude='.git/' --exclude='.github/' --exclude='.vscode/' --exclude='frontend/' --exclude='dist/' --exclude='contrib/' --exclude='*.log' --exclude='requirements.txt' --exclude='backend/__pycache__/' --exclude='.gitignore' --delete ${CLONEDIR}/pluginloader/* deck@${DECKIP}:${INSTALLDIR}/pluginloader &> '/dev/null'
-
+rsync -avzp --mkpath --rsh="ssh -p ${SSHPORT} ${IDENINVOC}" --exclude='.git/' --exclude='node_modules' --exclude="package-lock.json" --exclude=='frontend' --exclude="*dist*" --exclude="*contrib*" --delete ${CLONEDIR}/pluginloader/* deck@${DECKIP}:${INSTALLDIR}/pluginloader/ &> '/dev/null'
 if ! [[ $? -eq 0 ]]; then
-    printf "Error occurred when copying $CLONEDIR/pluginloader/ to $INSTALLDIR/pluginloader/\n"
-    printf "Check that your Steam Deck is active, ssh is enabled and running and is accepting connections.\n"
+    printf "Error occurred when copying ${CLONEDIR}/pluginloader/ to ${INSTALLDIR}/pluginloader/\n"
     exit 1
 fi
 
-### copy files for plugin template
-rsync -avzp --rsh="ssh -p $SSHPORT $IDENINVOC" --exclude='.git/' --exclude='.github/' --exclude='.vscode/' --exclude='node_modules/' --exclude='src/' --exclude='*.log' --exclude='.gitignore' --exclude='pnpm-lock.yaml' --exclude='package.json' --exclude='rollup.config.js' --exclude='tsconfig.json' --delete ${CLONEDIR}/plugintemplate deck@${DECKIP}:${INSTALLDIR}/plugins &> '/dev/null'
+### copy files for PluginLoader template
+rsync -avzp --mkpath --rsh="ssh -p ${SSHPORT} ${IDENINVOC}" --exclude='.git/' --exclude='node_modules' --exclude="package-lock.json" --delete ${CLONEDIR}/plugintemplate deck@${DECKIP}:${INSTALLDIR}/plugins &> '/dev/null'
 if ! [[ $? -eq 0 ]]; then
-    printf "Error occurred when copying $CLONEDIR/plugintemplate to $INSTALLDIR/plugins\n"
+    printf "Error occurred when copying ${CLONEDIR}/plugintemplate to ${INSTALLDIR}/plugins\n"
     exit 1
 fi
 
 ## TODO: direct contributors to wiki for this info?
 
 printf "Run these commands to deploy your local changes to the deck:\n"
-printf "'rsync -avzp --mkpath --rsh=""\"ssh -p $SSHPORT $IDENINVOC\""" --exclude='.git/' --exclude='.github/' --exclude='.vscode/' --exclude='frontend/' --exclude='dist/' --exclude='contrib/' --exclude='*.log' --exclude='requirements.txt' --exclude='backend/__pycache__/' --exclude='.gitignore' --delete $CLONEDIR/pluginloader/* deck@$DECKIP:$INSTALLDIR/pluginloader/'\n"
-printf "'rsync -avzp --mkpath --rsh=""\"ssh -p $SSHPORT $IDENINVOC\""" --exclude='.git/' --exclude='.github/' --exclude='.vscode/' --exclude='node_modules/' --exclude='src/' --exclude='*.log' --exclude='.gitignore' --exclude='package-lock.json' --delete $CLONEDIR/pluginname deck@$DECKIP:$INSTALLDIR/plugins'\n\n"
+printf "'rsync -avzp --mkpath --rsh=""\"ssh -p ${SSHPORT} ${IDENINVOC}\""" --exclude='.git/' --exclude='node_modules' --exclude='package-lock.json' --delete ${CLONEDIR}/pluginname deck@${DECKIP}:${INSTALLDIR}/plugins'\n"
+printf "'rsync -avzp --mkpath --rsh=""\"ssh -p ${SSHPORT} ${IDENINVOC}\""" --exclude='.git/' --exclude='node_modules' --exclude='package-lock.json' --exclude=='frontend' --exclude='*dist*' --exclude='*contrib*' --delete ${CLONEDIR}/pluginloader/* deck@${DECKIP}:${INSTALLDIR}/pluginloader/'\n"
 
-printf "Run in console or in a script this command to run your development version:\n'ssh deck@$DECKIP -p $SSHPORT $IDENINVOC 'export PLUGIN_PATH=$INSTALLDIR/plugins; export CHOWN_PLUGIN_PATH=0; echo 'steam' | sudo -SE python3 $INSTALLDIR/pluginloader/backend/main.py'\n"
+printf "Run in console or in a script this command to run your development version:\n'ssh deck@${DECKIP} -p 22 ${IDENINVOC} 'export PLUGIN_PATH=${INSTALLDIR}/plugins; export CHOWN_PLUGIN_PATH=0; echo 'steam' | sudo -SE python3 ${INSTALLDIR}/pluginloader/backend/main.py'\n"
 
 ## Disable Releases versions if they exist
 
@@ -332,4 +279,4 @@ printf "Run in console or in a script this command to run your development versi
 printf "Connecting via ssh to disable any PluginLoader release versions.\n"
 printf "Script will exit after this. All done!\n"
 
-ssh deck@${DECKIP} -p ${SSHPORT} ${IDENINVOC} "printf $PASSWORD | sudo -S systemctl disable --now plugin_loader; echo $?" &> '/dev/null'
+ssh deck@$DECKIP -p $SSHPORT $IDENINVOC "printf ${PASSWORD} | sudo -S systemctl disable --now plugin_loader; echo $?"

contrib/nodeck.sh

@@ -2,115 +2,87 @@
 
 ## Pre-parse arugments for ease of use
 CLONEFOLDER=${1:-""}
-LOADERBRANCH=${2:-""}
-LIBRARYBRANCH=${3:-""}
-TEMPLATEBRANCH=${4:-""}
-LATEST=${5:-""}
 
-## gather options into an array 
-OPTIONSARRAY=("$CLONEFOLDER" "$LOADERBRANCH" "$LIBRARYBRANCH" "$TEMPLATEBRANCH" "$LATEST")
+setfolder() {
+    if [[ "$2" == "clone" ]]; then
+        local ACTION="clone"
+        local DEFAULT="git"
+    elif [[ "$2" == "install" ]]; then
+        local ACTION="install"
+        local DEFAULT="loaderdev"
+    fi
 
-## iterate through options array to check their presence
-count=0
-for OPTION in ${OPTIONSARRAY[@]}; do
-    ! [[ "$OPTION" == "" ]] && count=$(($count+1))
-    # printf "OPTION=$OPTION\n"
-done
+    printf "Enter the directory in /home/user to ${ACTION} to.\n"
+    printf "Example: if your home directory is /home/user you would type: ${DEFAULT}\n"
+    printf "The ${ACTION} directory would be: ${HOME}/${DEFAULT}\n"
+    if [[ "$ACTION" == "clone" ]]; then
+        read -p "Enter your ${ACTION} directory: " CLONEFOLDER
+        if ! [[ "$CLONEFOLDER" =~ ^[[:alnum:]]+$ ]]; then
+            printf "Folder name not provided. Using default, '${DEFAULT}'.\n"
+            CLONEFOLDER="${DEFAULT}"
+        fi
+    elif [[ "$ACTION" == "install" ]]; then
+        read -p "Enter your ${ACTION} directory: " INSTALLFOLDER
+        if ! [[ "$INSTALLFOLDER" =~ ^[[:alnum:]]+$ ]]; then
+            printf "Folder name not provided. Using default, '${DEFAULT}'.\n"
+            INSTALLFOLDER="${DEFAULT}"
+        fi
+    else
+        printf "Folder type could not be determined, exiting\n"
+        exit 1
+    fi
+}
 
 clonefromto() {
     # printf "repo=$1\n"
     # printf "outdir=$2\n"
     # printf "branch=$3\n"
-    printf "Repository: $1\n"
-    git clone $1 $2 &> '/dev/null'
+    if [[ -z $3 ]]; then
+        BRANCH=""
+    else
+        BRANCH="-b $3"
+    fi
+    git clone $1 $2 $BRANCH &> '/dev/null'
     CODE=$?
-    # printf "CODE=${CODE}"
     if [[ $CODE -eq 128 ]]; then
         cd $2
-        git fetch --all &> '/dev/null'
-    fi
-    if [[ -z $3 ]]; then
-        printf "Enter the desired branch for repository "$1" :\n"
-        local OUT="$(git branch -r | sed '/\/HEAD/d')"
-        # $OUT="$($OUT > )"
-        printf "$OUT\nbranch: "
-        read BRANCH
-    else
-        printf "on branch: $3\n"
-        BRANCH="$3"
-    fi
-    if ! [[ -z ${BRANCH} ]]; then
-        git checkout $BRANCH &> '/dev/null'
-    fi
-    if [[ ${LATEST} == "true" ]]; then
-        git pull --all
-    elif [[ ${LATEST} == "true" ]]; then
-        printf "Assuming user not pulling latest commits.\n"
-    else
-        printf "Pull latest commits? (y/N): "
-        read PULL
-        case ${PULL:0:1} in
-            y|Y )
-                printf "Pulling latest commits.\n"
-                git pull --all
-            ;;
-            * )
-                printf "Not pulling latest commits.\n"
-            ;;
-        esac
-        if ! [[ "$PULL" =~ ^[[:alnum:]]+$ ]]; then
-            printf "Assuming user not pulling latest commits.\n"
-        fi
+        git fetch &> '/dev/null'
     fi
 }
 
-pnpmtransbundle() {
+npmtransbundle() {
     cd $1
     if [[ "$2" == "library" ]]; then
         npm install --quiet &> '/dev/null'
         npm run build --quiet &> '/dev/null'
         sudo npm link --quiet &> '/dev/null'
-    elif [[ "$2" == "frontend" ]]; then
-        pnpm i &> '/dev/null'
-        pnpm run build &> '/dev/null'
-    elif [[ "$2" == "template" ]]; then
-        pnpm i &> '/dev/null'
-        pnpm run build &> '/dev/null'
+    elif [[ "$2" == "frontend" ]] || [[ "$2" == "template" ]]; then
+        npm install --quiet &> '/dev/null'
+        npm link decky-frontend-lib --quiet &> '/dev/null'
+        npm run build --quiet &> '/dev/null'
     fi
 }
 
+printf "Installing Steam Deck Plugin Loader contributor (no Steam Deck)..."
 
-if ! [[ $count -gt 4 ]] ; then
-    printf "Installing Steam Deck Plugin Loader contributor/developer (no Steam Deck)..."
+printf "\nTHIS SCRIPT ASSUMES YOU ARE RUNNING IT ON A PC, NOT THE DECK!
+If you are not planning to contribute to PluginLoader then you should not be using this script.\n"
 
-    printf "\nTHIS SCRIPT ASSUMES YOU ARE RUNNING IT ON A PC, NOT THE DECK!
-    Not planning to contribute to or develop for PluginLoader?
-    Then you should not be using this script.\n"
+printf "\nThis script requires you to have nodejs installed. (If nodejs doesn't bundle npm on your OS/distro, then npm is required as well).\n"
 
-    printf "\nThis script requires you to have nodejs installed. (If nodejs doesn't bundle npm on your OS/distro, then npm is required as well).\n"
-fi
-
-if ! [[ $count -gt 0 ]] ; then
+if [[ -z $1 ]]; then
     read -p "Press any key to continue"
 fi
 
-printf "\n"
-
 if [[ "$CLONEFOLDER" == "" ]]; then
-    printf "Enter the directory in /home/user/ to clone to.\n"
-    printf "The clone directory would be: ${HOME}/git \n"
-    read -p "Enter your clone directory: " CLONEFOLDER
-    if ! [[ "$CLONEFOLDER" =~ ^[[:alnum:]]+$ ]]; then
-        printf "Folder name not provided. Using default, '${DEFAULT}'.\n"
-        CLONEFOLDER="${DEFAULT}"
-    fi
+    setfolder "$CLONEFOLDER" "clone"
 fi
 
 CLONEDIR="$HOME/$CLONEFOLDER"
 
 ## Create folder structure
 
-printf "Cloning git repositories.\n"
+printf "\nCloning git repositories.\n"
 
 mkdir -p ${CLONEDIR} &> '/dev/null'
 
@@ -119,47 +91,33 @@ mkdir -p ${CLONEDIR} &> '/dev/null'
 # rm -r ${CLONEDIR}/pluginlibrary
 # rm -r ${CLONEDIR}/plugintemplate
 
-clonefromto "https://github.com/SteamDeckHomebrew/PluginLoader" ${CLONEDIR}/pluginloader "$LOADERBRANCH"
+clonefromto "https://github.com/SteamDeckHomebrew/PluginLoader" ${CLONEDIR}/pluginloader react-frontend-plugins
 
-clonefromto "https://github.com/SteamDeckHomebrew/decky-frontend-lib" ${CLONEDIR}/pluginlibrary "$LIBRARYBRANCH"
+clonefromto "https://github.com/SteamDeckHomebrew/decky-frontend-lib" ${CLONEDIR}/pluginlibrary
 
-clonefromto "https://github.com/SteamDeckHomebrew/decky-plugin-template" ${CLONEDIR}/plugintemplate "$TEMPLATEBRANCH"
-
-## install python dependencies (maybe use venv?)
-
-python -m pip install -r ${CLONEDIR}/pluginloader/requirements.txt &> '/dev/null'
+clonefromto "https://github.com/SteamDeckHomebrew/decky-plugin-template" ${CLONEDIR}/plugintemplate 
 
 ## Transpile and bundle typescript
-
-[ "$UID" -eq 0 ] || printf "Input password to proceed with install.\n"
-
 type npm &> '/dev/null'
 
 NPMLIVES=$?
 
-if ! [[ "$PNPMLIVES" -eq 0 ]]; then
-    printf "npm does not appear to be installed, exiting.\n"
+if ! [[ "$NPMLIVES" -eq 0 ]]; then
+    printf "npm needs to be installed, exiting.\n"
     exit 1
 fi
 
-sudo npm install -g pnpm &> '/dev/null'
+[ "$UID" -eq 0 ] || printf "Input password to install typscript compiler.\n"
 
-type pnpm &> '/dev/null'
-
-PNPMLIVES=$?
-
-if ! [[ "$PNPMLIVES" -eq 0 ]]; then
-    printf "pnpm does not appear to be installed, exiting.\n"
-    exit 1
-fi
+sudo npm install --quiet -g tsc &> '/dev/null'
 
 printf "Transpiling and bundling typescript.\n"
 
-pnpmtransbundle ${CLONEDIR}/pluginlibrary/ "library"
+npmtransbundle ${CLONEDIR}/pluginlibrary/ "library"
 
-pnpmtransbundle ${CLONEDIR}/pluginloader/frontend "frontend"
+npmtransbundle ${CLONEDIR}/pluginloader/frontend "frontend"
 
-pnpmtransbundle ${CLONEDIR}/plugintemplate "template"
+npmtransbundle ${CLONEDIR}/plugintemplate "template"
 
 printf "Plugin Loader is located at '${CLONEDIR}/pluginloader/'.\n"
 

dist/install_nightly.sh

@@ -4,13 +4,12 @@
 
 echo "Installing Steam Deck Plugin Loader nightly..."
 
-USER_DIR="$(getent passwd $SUDO_USER | cut -d: -f6)"
-HOMEBREW_FOLDER="${USER_DIR}/homebrew"
+HOMEBREW_FOLDER=/home/deck/homebrew
 
 # Create folder structure
 rm -rf ${HOMEBREW_FOLDER}/services
-sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/services"
-sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/plugins"
+sudo -u deck mkdir -p ${HOMEBREW_FOLDER}/services
+sudo -u deck mkdir -p ${HOMEBREW_FOLDER}/plugins
 
 # Download latest nightly build and install it
 rm -rf /tmp/plugin_loader
@@ -23,7 +22,7 @@ chmod +x ${HOMEBREW_FOLDER}/services/PluginLoader
 
 systemctl --user stop plugin_loader 2> /dev/null
 systemctl --user disable plugin_loader 2> /dev/null
-rm -f ${USER_DIR}/.config/systemd/user/plugin_loader.service
+rm -f /home/deck/.config/systemd/user/plugin_loader.service
 
 systemctl stop plugin_loader 2> /dev/null
 systemctl disable plugin_loader 2> /dev/null
@@ -38,9 +37,10 @@ Type=simple
 User=root
 Restart=always
 
-ExecStart=${HOMEBREW_FOLDER}/services/PluginLoader
-WorkingDirectory=${HOMEBREW_FOLDER}/services
-Environment=PLUGIN_PATH=${HOMEBREW_FOLDER}/plugins
+ExecStart=/home/deck/homebrew/services/PluginLoader
+WorkingDirectory=/home/deck/homebrew/services
+
+Environment=PLUGIN_PATH=/home/deck/homebrew/plugins
 
 [Install]
 WantedBy=multi-user.target

dist/install_prerelease.sh

@@ -1,46 +0,0 @@
-#!/bin/sh
-
-[ "$UID" -eq 0 ] || exec sudo "$0" "$@"
-
-echo "Installing Steam Deck Plugin Loader pre-release..."
-
-USER_DIR="$(getent passwd $SUDO_USER | cut -d: -f6)"
-HOMEBREW_FOLDER="${USER_DIR}/homebrew"
-
-# # Create folder structure
-rm -rf ${HOMEBREW_FOLDER}/services
-sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/services"
-sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/plugins"
-
-# Download latest release and install it
-RELEASE=$(curl -s 'https://api.github.com/repos/SteamDeckHomebrew/decky-loader/releases' | jq -r "first(.[] | select(.prerelease == "true"))")
-read VERSION DOWNLOADURL < <(echo $(jq -r '.tag_name, .assets[].browser_download_url' <<< ${RELEASE}))
-
-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
-
-systemctl stop plugin_loader 2> /dev/null
-systemctl disable plugin_loader 2> /dev/null
-rm -f /etc/systemd/system/plugin_loader.service
-cat > /etc/systemd/system/plugin_loader.service <<- EOM
-[Unit]
-Description=SteamDeck Plugin Loader
-[Service]
-Type=simple
-User=root
-Restart=always
-ExecStart=${HOMEBREW_FOLDER}/services/PluginLoader
-WorkingDirectory=${HOMEBREW_FOLDER}/services
-Environment=PLUGIN_PATH=${HOMEBREW_FOLDER}/plugins
-Environment=LOG_LEVEL=DEBUG
-[Install]
-WantedBy=multi-user.target
-EOM
-systemctl daemon-reload
-systemctl start plugin_loader
-systemctl enable plugin_loader

dist/install_release.sh

@@ -4,39 +4,33 @@
 
 echo "Installing Steam Deck Plugin Loader release..."
 
-USER_DIR="$(getent passwd $SUDO_USER | cut -d: -f6)"
-HOMEBREW_FOLDER="${USER_DIR}/homebrew"
+HOMEBREW_FOLDER=/home/deck/homebrew
 
 # Create folder structure
-rm -rf "${HOMEBREW_FOLDER}/services"
-sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/services"
-sudo -u $SUDO_USER mkdir -p "${HOMEBREW_FOLDER}/plugins"
+rm -rf ${HOMEBREW_FOLDER}/services
+sudo -u deck mkdir -p ${HOMEBREW_FOLDER}/services
+sudo -u deck mkdir -p ${HOMEBREW_FOLDER}/plugins
 
 # Download latest release and install it
-RELEASE=$(curl -s 'https://api.github.com/repos/SteamDeckHomebrew/decky-loader/releases' | jq -r "first(.[] | select(.prerelease == "false"))")
-read VERSION DOWNLOADURL < <(echo $(jq -r '.tag_name, .assets[].browser_download_url' <<< ${RELEASE}))
-
-printf "Installing version %s...\n" "${VERSION}"
-curl -L $DOWNLOADURL --output ${HOMEBREW_FOLDER}/services/PluginLoader
+curl -L https://github.com/SteamDeckHomebrew/PluginLoader/releases/latest/download/PluginLoader --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
 
 systemctl stop plugin_loader 2> /dev/null
 systemctl disable plugin_loader 2> /dev/null
-rm -f "/etc/systemd/system/plugin_loader.service"
-cat > "/etc/systemd/system/plugin_loader.service" <<- EOM
+rm -f /etc/systemd/system/plugin_loader.service
+cat > /etc/systemd/system/plugin_loader.service <<- EOM
 [Unit]
 Description=SteamDeck Plugin Loader
 [Service]
 Type=simple
 User=root
 Restart=always
-ExecStart=${HOMEBREW_FOLDER}/services/PluginLoader
-WorkingDirectory=${HOMEBREW_FOLDER}/services
-Environment=PLUGIN_PATH=${HOMEBREW_FOLDER}/plugins
+ExecStart=/home/deck/homebrew/services/PluginLoader
+WorkingDirectory=/home/deck/homebrew/services
+Environment=PLUGIN_PATH=/home/deck/homebrew/plugins
 [Install]
 WantedBy=multi-user.target
 EOM

dist/uninstall.sh

@@ -1,20 +1,17 @@
 #!/bin/sh
 
-[ "$UID" -eq 0 ] || exec sudo "$0" "$@"
-
 echo "Uninstalling Steam Deck Plugin Loader..."
 
-USER_DIR="$(getent passwd $SUDO_USER | cut -d: -f6)"
-HOMEBREW_FOLDER="${USER_DIR}/homebrew"
+HOMEBREW_FOLDER=/home/deck/homebrew
 
 # Disable and remove services
 sudo systemctl disable --now plugin_loader.service > /dev/null
-sudo rm -f "${USER_DIR}/.config/systemd/user/plugin_loader.service"
-sudo rm -f "/etc/systemd/system/plugin_loader.service"
+sudo rm -f /home/deck/.config/systemd/user/plugin_loader.service
+sudo rm -f /etc/systemd/system/plugin_loader.service
 
 # Remove temporary folder if it exists from the install process
-rm -rf "/tmp/plugin_loader"
+rm -rf /tmp/plugin_loader
 
 # Cleanup services folder
-sudo rm "${HOMEBREW_FOLDER}/services/PluginLoader"
+sudo rm ${HOMEBREW_FOLDER}/services/PluginLoader
 

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decky_frontend",
-  "version": "2.1.1",
+  "version": "0.0.1",
   "private": true,
   "license": "GPLV2",
   "scripts": {
@@ -13,26 +13,21 @@
   "devDependencies": {
     "@rollup/plugin-commonjs": "^21.1.0",
     "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^13.3.0",
+    "@rollup/plugin-node-resolve": "^13.2.1",
     "@rollup/plugin-replace": "^4.0.0",
-    "@rollup/plugin-typescript": "^8.3.3",
+    "@rollup/plugin-typescript": "^8.3.2",
     "@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",
     "import-sort-style-module": "^6.0.0",
-    "inquirer": "^8.2.4",
-    "prettier": "^2.7.1",
+    "prettier": "^2.6.2",
     "prettier-plugin-import-sort": "^0.0.7",
     "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",
+    "rollup": "^2.70.2",
     "tslib": "^2.4.0",
-    "typescript": "^4.7.4"
+    "typescript": "^4.7.2"
   },
   "importSort": {
     ".js, .jsx, .ts, .tsx": {
@@ -41,10 +36,7 @@
     }
   },
   "dependencies": {
-    "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"
+    "decky-frontend-lib": "^0.0.6",
+    "react-icons": "^4.3.1"
   }
 }

frontend/rollup.config.js

@@ -1,8 +1,6 @@
 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';
@@ -10,17 +8,8 @@ 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({
@@ -28,12 +17,13 @@ export default defineConfig({
       'process.env.NODE_ENV': JSON.stringify('production'),
     }),
   ],
-  preserveEntrySignatures: false,
+  external: ["react", "react-dom"],
   output: {
-    dir: '../backend/static',
-    format: 'esm',
-    chunkFileNames: (chunkInfo) => {
-      return 'chunk-[hash].js'
-    }
-  }
+    file: '../backend/static/plugin-loader.iife.js',
+    globals: {
+      react: 'SP_REACT',
+      'react-dom': 'SP_REACTDOM',
+    },
+    format: 'iife',
+  },
 });

frontend/src/components/DeckyRouterState.tsx

@@ -6,21 +6,17 @@ export interface RouterEntry {
   component: ComponentType;
 }
 
-export type RoutePatch = (route: RouteProps) => RouteProps;
-
 interface PublicDeckyRouterState {
   routes: Map<string, RouterEntry>;
-  routePatches: Map<string, Set<RoutePatch>>;
 }
 
 export class DeckyRouterState {
   private _routes = new Map<string, RouterEntry>();
-  private _routePatches = new Map<string, Set<RoutePatch>>();
 
   public eventBus = new EventTarget();
 
   publicState(): PublicDeckyRouterState {
-    return { routes: this._routes, routePatches: this._routePatches };
+    return { routes: this._routes };
   }
 
   addRoute(path: string, component: RouterEntry['component'], props: RouterEntry['props'] = {}) {
@@ -28,26 +24,6 @@ export class DeckyRouterState {
     this.notifyUpdate();
   }
 
-  addPatch(path: string, patch: RoutePatch) {
-    let patchList = this._routePatches.get(path);
-    if (!patchList) {
-      patchList = new Set();
-      this._routePatches.set(path, patchList);
-    }
-    patchList.add(patch);
-    this.notifyUpdate();
-    return patch;
-  }
-
-  removePatch(path: string, patch: RoutePatch) {
-    const patchList = this._routePatches.get(path);
-    patchList?.delete(patch);
-    if (patchList?.size == 0) {
-      this._routePatches.delete(path);
-    }
-    this.notifyUpdate();
-  }
-
   removeRoute(path: string) {
     this._routes.delete(path);
     this.notifyUpdate();
@@ -60,8 +36,6 @@ export class DeckyRouterState {
 
 interface DeckyRouterStateContext extends PublicDeckyRouterState {
   addRoute(path: string, component: RouterEntry['component'], props: RouterEntry['props']): void;
-  addPatch(path: string, patch: RoutePatch): RoutePatch;
-  removePatch(path: string, patch: RoutePatch): void;
   removeRoute(path: string): void;
 }
 
@@ -88,15 +62,12 @@ export const DeckyRouterStateContextProvider: FC<Props> = ({ children, deckyRout
     return () => deckyRouterState.eventBus.removeEventListener('update', onUpdate);
   }, []);
 
-  const addRoute = deckyRouterState.addRoute.bind(deckyRouterState);
-  const addPatch = deckyRouterState.addPatch.bind(deckyRouterState);
-  const removePatch = deckyRouterState.removePatch.bind(deckyRouterState);
-  const removeRoute = deckyRouterState.removeRoute.bind(deckyRouterState);
+  const addRoute = (path: string, component: RouterEntry['component'], props: RouterEntry['props'] = {}) =>
+    deckyRouterState.addRoute(path, component, props);
+  const removeRoute = (path: string) => deckyRouterState.removeRoute(path);
 
   return (
-    <DeckyRouterStateContext.Provider
-      value={{ ...publicDeckyRouterState, addRoute, addPatch, removePatch, removeRoute }}
-    >
+    <DeckyRouterStateContext.Provider value={{ ...publicDeckyRouterState, addRoute, removeRoute }}>
       {children}
     </DeckyRouterStateContext.Provider>
   );

frontend/src/components/DeckyState.tsx

@@ -1,42 +1,20 @@
 import { FC, createContext, useContext, useEffect, useState } from 'react';
 
 import { Plugin } from '../plugin';
-import { PluginUpdateMapping } from '../store';
-import { VerInfo } from '../updater';
 
 interface PublicDeckyState {
   plugins: Plugin[];
   activePlugin: Plugin | null;
-  updates: PluginUpdateMapping | null;
-  hasLoaderUpdate?: boolean;
-  isLoaderUpdating: boolean;
-  versionInfo: VerInfo | null;
 }
 
 export class DeckyState {
   private _plugins: Plugin[] = [];
   private _activePlugin: Plugin | null = null;
-  private _updates: PluginUpdateMapping | null = null;
-  private _hasLoaderUpdate: boolean = false;
-  private _isLoaderUpdating: boolean = false;
-  private _versionInfo: VerInfo | null = null;
 
   public eventBus = new EventTarget();
 
   publicState(): PublicDeckyState {
-    return {
-      plugins: this._plugins,
-      activePlugin: this._activePlugin,
-      updates: this._updates,
-      hasLoaderUpdate: this._hasLoaderUpdate,
-      isLoaderUpdating: this._isLoaderUpdating,
-      versionInfo: this._versionInfo,
-    };
-  }
-
-  setVersionInfo(versionInfo: VerInfo) {
-    this._versionInfo = versionInfo;
-    this.notifyUpdate();
+    return { plugins: this._plugins, activePlugin: this._activePlugin };
   }
 
   setPlugins(plugins: Plugin[]) {
@@ -54,29 +32,12 @@ export class DeckyState {
     this.notifyUpdate();
   }
 
-  setUpdates(updates: PluginUpdateMapping) {
-    this._updates = updates;
-    this.notifyUpdate();
-  }
-
-  setHasLoaderUpdate(hasUpdate: boolean) {
-    this._hasLoaderUpdate = hasUpdate;
-    this.notifyUpdate();
-  }
-
-  setIsLoaderUpdating(isUpdating: boolean) {
-    this._isLoaderUpdating = isUpdating;
-    this.notifyUpdate();
-  }
-
   private notifyUpdate() {
     this.eventBus.dispatchEvent(new Event('update'));
   }
 }
 
 interface DeckyStateContext extends PublicDeckyState {
-  setVersionInfo(versionInfo: VerInfo): void;
-  setIsLoaderUpdating(hasUpdate: boolean): void;
   setActivePlugin(name: string): void;
   closeActivePlugin(): void;
 }
@@ -102,15 +63,11 @@ export const DeckyStateContextProvider: FC<Props> = ({ children, deckyState }) =
     return () => deckyState.eventBus.removeEventListener('update', onUpdate);
   }, []);
 
-  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, setVersionInfo, setActivePlugin, closeActivePlugin }}
-    >
+    <DeckyStateContext.Provider value={{ ...publicDeckyState, setActivePlugin, closeActivePlugin }}>
       {children}
     </DeckyStateContext.Provider>
   );

frontend/src/components/Markdown.tsx

@@ -1,42 +0,0 @@
-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;

frontend/src/components/NotificationBadge.tsx

@@ -1,25 +0,0 @@
-import { CSSProperties, FunctionComponent } from 'react';
-
-interface NotificationBadgeProps {
-  show?: boolean;
-  style?: CSSProperties;
-}
-
-const NotificationBadge: FunctionComponent<NotificationBadgeProps> = ({ show, style }) => {
-  return show ? (
-    <div
-      style={{
-        position: 'absolute',
-        top: '8px',
-        right: '8px',
-        height: '10px',
-        width: '10px',
-        background: 'orange',
-        borderRadius: '50%',
-        ...style,
-      }}
-    />
-  ) : null;
-};
-
-export default NotificationBadge;

frontend/src/components/PluginView.tsx

@@ -1,47 +1,48 @@
-import {
-  ButtonItem,
-  PanelSection,
-  PanelSectionRow,
-  joinClassNames,
-  scrollClasses,
-  staticClasses,
-} from 'decky-frontend-lib';
+import { ButtonItem, DialogButton, PanelSection, PanelSectionRow, Router } from 'decky-frontend-lib';
 import { VFC } from 'react';
+import { FaArrowLeft, FaStore } from 'react-icons/fa';
 
 import { useDeckyState } from './DeckyState';
-import NotificationBadge from './NotificationBadge';
 
 const PluginView: VFC = () => {
-  const { plugins, updates, activePlugin, setActivePlugin } = useDeckyState();
+  const { plugins, activePlugin, setActivePlugin, closeActivePlugin } = useDeckyState();
+
+  const onStoreClick = () => {
+    Router.CloseSideMenus();
+    Router.NavigateToExternalWeb('http://127.0.0.1:1337/browser/redirect');
+  };
 
   if (activePlugin) {
     return (
-      <div
-        className={joinClassNames(staticClasses.TabGroupPanel, scrollClasses.ScrollPanel, scrollClasses.ScrollY)}
-        style={{ height: '100%' }}
-      >
+      <div style={{ height: '100%' }}>
+        <div style={{ position: 'absolute', top: '3px', left: '16px', zIndex: 20 }}>
+          <DialogButton style={{ minWidth: 0, padding: '10px 12px' }} onClick={closeActivePlugin}>
+            <FaArrowLeft style={{ display: 'block' }} />
+          </DialogButton>
+        </div>
         {activePlugin.content}
       </div>
     );
   }
+
   return (
-    <div className={joinClassNames(staticClasses.TabGroupPanel, scrollClasses.ScrollPanel, scrollClasses.ScrollY)}>
-      <PanelSection>
-        {plugins
-          .filter((p) => p.content)
-          .map(({ name, icon }) => (
-            <PanelSectionRow key={name}>
-              <ButtonItem layout="below" onClick={() => setActivePlugin(name)}>
-                <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-                  {icon}
-                  <div>{name}</div>
-                  <NotificationBadge show={updates?.has(name)} style={{ top: '-5px', right: '-5px' }} />
-                </div>
-              </ButtonItem>
-            </PanelSectionRow>
-          ))}
-      </PanelSection>
-    </div>
+    <PanelSection>
+      <div style={{ position: 'absolute', top: '3px', right: '16px', zIndex: 20 }}>
+        <DialogButton style={{ minWidth: 0, padding: '10px 12px' }} onClick={onStoreClick}>
+          <FaStore style={{ display: 'block' }} />
+        </DialogButton>
+      </div>
+      {plugins.map(({ name, icon }) => (
+        <PanelSectionRow key={name}>
+          <ButtonItem layout="below" onClick={() => setActivePlugin(name)}>
+            <div style={{ display: 'flex', justifyContent: 'space-between' }}>
+              <div>{icon}</div>
+              <div>{name}</div>
+            </div>
+          </ButtonItem>
+        </PanelSectionRow>
+      ))}
+    </PanelSection>
   );
 };
 

frontend/src/components/TitleView.tsx

@@ -1,57 +1,18 @@
-import { DialogButton, Focusable, Router, staticClasses } from 'decky-frontend-lib';
-import { CSSProperties, VFC } from 'react';
-import { FaArrowLeft, FaCog, FaStore } from 'react-icons/fa';
+import { staticClasses } from 'decky-frontend-lib';
+import { VFC } from 'react';
 
 import { useDeckyState } from './DeckyState';
 
-const titleStyles: CSSProperties = {
-  display: 'flex',
-  paddingTop: '3px',
-  paddingRight: '16px',
-};
-
 const TitleView: VFC = () => {
-  const { activePlugin, closeActivePlugin } = useDeckyState();
-
-  const onSettingsClick = () => {
-    Router.CloseSideMenus();
-    Router.Navigate('/decky/settings');
-  };
-
-  const onStoreClick = () => {
-    Router.CloseSideMenus();
-    Router.Navigate('/decky/store');
-  };
+  const { activePlugin } = useDeckyState();
 
   if (activePlugin === null) {
-    return (
-      <Focusable style={titleStyles} className={staticClasses.Title}>
-        <DialogButton
-          style={{ height: '28px', width: '40px', minWidth: 0, padding: '10px 12px' }}
-          onClick={onSettingsClick}
-        >
-          <FaCog style={{ marginTop: '-4px', display: 'block' }} />
-        </DialogButton>
-        <div style={{ marginRight: 'auto', flex: 0.9 }}>Decky</div>
-        <DialogButton
-          style={{ height: '28px', width: '40px', minWidth: 0, padding: '10px 12px' }}
-          onClick={onStoreClick}
-        >
-          <FaStore style={{ marginTop: '-4px', display: 'block' }} />
-        </DialogButton>
-      </Focusable>
-    );
+    return <div className={staticClasses.Title}>Decky</div>;
   }
 
   return (
-    <div className={staticClasses.Title} style={titleStyles}>
-      <DialogButton
-        style={{ height: '28px', width: '40px', minWidth: 0, padding: '10px 12px' }}
-        onClick={closeActivePlugin}
-      >
-        <FaArrowLeft style={{ marginTop: '-4px', display: 'block' }} />
-      </DialogButton>
-      <div style={{ flex: 0.9 }}>{activePlugin.name}</div>
+    <div className={staticClasses.Title} style={{ paddingLeft: '60px' }}>
+      {activePlugin.name}
     </div>
   );
 };

frontend/src/components/Toast.tsx

@@ -1,54 +0,0 @@
-import { ToastData, findModule, joinClassNames } from 'decky-frontend-lib';
-import { FunctionComponent } from 'react';
-
-interface ToastProps {
-  toast: {
-    data: ToastData;
-    nToastDurationMS: number;
-  };
-}
-
-const toastClasses = findModule((mod) => {
-  if (typeof mod !== 'object') return false;
-
-  if (mod.ToastPlaceholder) {
-    return true;
-  }
-
-  return false;
-});
-
-const templateClasses = findModule((mod) => {
-  if (typeof mod !== 'object') return false;
-
-  if (mod.ShortTemplate) {
-    return true;
-  }
-
-  return false;
-});
-
-const Toast: FunctionComponent<ToastProps> = ({ toast }) => {
-  return (
-    <div
-      style={{ '--toast-duration': `${toast.nToastDurationMS}ms` } as React.CSSProperties}
-      className={joinClassNames(toastClasses.ToastPopup, toastClasses.toastEnter)}
-    >
-      <div
-        onClick={toast.data.onClick}
-        className={joinClassNames(templateClasses.ShortTemplate, toast.data.className || '')}
-      >
-        {toast.data.logo && <div className={templateClasses.StandardLogoDimensions}>{toast.data.logo}</div>}
-        <div className={joinClassNames(templateClasses.Content, toast.data.contentClassName || '')}>
-          <div className={templateClasses.Header}>
-            {toast.data.icon && <div className={templateClasses.Icon}>{toast.data.icon}</div>}
-            <div className={templateClasses.Title}>{toast.data.title}</div>
-          </div>
-          <div className={templateClasses.Body}>{toast.data.body}</div>
-        </div>
-      </div>
-    </div>
-  );
-};
-
-export default Toast;

frontend/src/components/WithSuspense.tsx

@@ -1,38 +0,0 @@
-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;

frontend/src/components/modals/PluginInstallModal.tsx

@@ -1,42 +0,0 @@
-import { ConfirmModal, QuickAccessTab, Router, Spinner, staticClasses } from 'decky-frontend-lib';
-import { FC, useState } from 'react';
-
-interface PluginInstallModalProps {
-  artifact: string;
-  version: string;
-  hash: string;
-  // reinstall: boolean;
-  onOK(): void;
-  onCancel(): void;
-  closeModal?(): void;
-}
-
-const PluginInstallModal: FC<PluginInstallModalProps> = ({ artifact, version, hash, onOK, onCancel, closeModal }) => {
-  const [loading, setLoading] = useState<boolean>(false);
-  return (
-    <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();
-      }}
-    >
-      <div className={staticClasses.Title} style={{ flexDirection: 'column' }}>
-        {hash == 'False' ? <h3 style={{ color: 'red' }}>!!!!NO HASH PROVIDED!!!!</h3> : null}
-        <div style={{ flexDirection: 'row' }}>
-          {loading && <Spinner style={{ width: '20px' }} />} {loading ? 'Installing' : 'Install'} {artifact}
-          {version ? ' version ' + version : null}
-          {!loading && '?'}
-        </div>
-      </div>
-    </ConfirmModal>
-  );
-};
-
-export default PluginInstallModal;

frontend/src/components/modals/filepicker/iconCustomizations.ts

@@ -1,170 +0,0 @@
-// 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) };
-});

frontend/src/components/modals/filepicker/index.tsx

@@ -1,160 +0,0 @@
-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;

frontend/src/components/modals/filepicker/patches/README.md

@@ -1 +0,0 @@
-This directory contains patches that replace Valve's broken file picker with ours.

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

@@ -1,10 +0,0 @@
-import library from './library';
-let patches: Function[] = [];
-
-export function deinitFilepickerPatches() {
-  patches.forEach((unpatch) => unpatch());
-}
-
-export async function initFilepickerPatches() {
-  patches.push(await library());
-}

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

@@ -1,57 +0,0 @@
-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 () => {};
-}

frontend/src/components/patchnotes/InlinePatchNotes.tsx

@@ -1,21 +0,0 @@
-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;

frontend/src/components/settings/index.tsx

@@ -1,25 +0,0 @@
-import { SidebarNavigation } from 'decky-frontend-lib';
-
-import GeneralSettings from './pages/general';
-import PluginList from './pages/plugin_list';
-
-export default function SettingsPage() {
-  return (
-    <SidebarNavigation
-      title="Decky Settings"
-      showTitle
-      pages={[
-        {
-          title: 'General',
-          content: <GeneralSettings />,
-          route: '/decky/settings/general',
-        },
-        {
-          title: 'Plugins',
-          content: <PluginList />,
-          route: '/decky/settings/plugins',
-        },
-      ]}
-    />
-  );
-}

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

@@ -1,41 +0,0 @@
-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;

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

@@ -1,29 +0,0 @@
-import { Field, Toggle } from 'decky-frontend-lib';
-import { FaBug } from 'react-icons/fa';
-
-import { useSetting } from '../../../../utils/hooks/useSetting';
-
-export default function RemoteDebuggingSettings() {
-  const [allowRemoteDebugging, setAllowRemoteDebugging] = useSetting<boolean>('cef_forward', false);
-
-  return (
-    <Field
-      label="Allow Remote CEF Debugging"
-      description={
-        <span style={{ whiteSpace: 'pre-line' }}>
-          Allow unauthenticated access to the CEF debugger to anyone in your network
-        </span>
-      }
-      icon={<FaBug style={{ display: 'block' }} />}
-    >
-      <Toggle
-        value={allowRemoteDebugging || false}
-        onChange={(toggleValue) => {
-          setAllowRemoteDebugging(toggleValue);
-          if (toggleValue) window.DeckyPluginLoader.callServerMethod('allow_remote_debugging');
-          else window.DeckyPluginLoader.callServerMethod('disallow_remote_debugging');
-        }}
-      />
-    </Field>
-  );
-}

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

@@ -1,162 +0,0 @@
-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 { isLoaderUpdating, setIsLoaderUpdating, versionInfo, setVersionInfo } = useDeckyState();
-
-  const [checkingForUpdates, setCheckingForUpdates] = useState<boolean>(false);
-  const [updateProgress, setUpdateProgress] = useState<number>(-1);
-  const [reloading, setReloading] = useState<boolean>(false);
-
-  useEffect(() => {
-    window.DeckyUpdater = {
-      updateProgress: (i) => {
-        setUpdateProgress(i);
-        setIsLoaderUpdating(true);
-      },
-      finish: async () => {
-        setUpdateProgress(0);
-        setReloading(true);
-        await finishUpdate();
-      },
-    };
-  }, []);
-
-  const showPatchNotes = useCallback(() => {
-    showModal(<PatchNotesModal versionInfo={versionInfo} />);
-  }, [versionInfo]);
-
-  return (
-    <>
-      <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>
-        ) : (
-          <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}
-        >
-          <Suspense fallback={<Spinner style={{ width: '24', height: '24' }} />}>
-            <MarkdownRenderer>{versionInfo?.remote.body}</MarkdownRenderer>
-          </Suspense>
-        </InlinePatchNotes>
-      )}
-    </>
-  );
-}

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

@@ -1,38 +0,0 @@
-import { DialogButton, Field, TextField } from 'decky-frontend-lib';
-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';
-
-export default function GeneralSettings() {
-  const [pluginURL, setPluginURL] = useState('');
-  // const [checked, setChecked] = useState(false); // store these in some kind of State instead
-  return (
-    <div>
-      {/* <Field
-        label="A Toggle with an icon"
-        icon={<FaShapes style={{ display: 'block' }} />}
-      >
-        <Toggle
-          value={checked}
-          onChange={(e) => setChecked(e)}
-        />
-      </Field> */}
-      <UpdaterSettings />
-      <BranchSelect />
-      <RemoteDebuggingSettings />
-      <Field
-        label="Manual plugin install"
-        description={<TextField label={'URL'} value={pluginURL} onChange={(e) => setPluginURL(e?.target.value)} />}
-        icon={<FaShapes style={{ display: 'block' }} />}
-      >
-        <DialogButton disabled={pluginURL.length == 0} onClick={() => installFromURL(pluginURL)}>
-          Install
-        </DialogButton>
-      </Field>
-    </div>
-  );
-}

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

@@ -1,66 +0,0 @@
-import { DialogButton, Focusable, Menu, MenuItem, showContextMenu } from 'decky-frontend-lib';
-import { useEffect } from 'react';
-import { FaDownload, FaEllipsisH } from 'react-icons/fa';
-
-import { requestPluginInstall } from '../../../../store';
-import { useDeckyState } from '../../../DeckyState';
-
-export default function PluginList() {
-  const { plugins, updates } = useDeckyState();
-
-  useEffect(() => {
-    window.DeckyPluginLoader.checkPluginUpdates();
-  }, []);
-
-  if (plugins.length === 0) {
-    return (
-      <div>
-        <p>No plugins installed</p>
-      </div>
-    );
-  }
-
-  return (
-    <ul style={{ listStyleType: 'none' }}>
-      {plugins.map(({ name, version }) => {
-        const update = updates?.get(name);
-        return (
-          <li style={{ display: 'flex', flexDirection: 'row', alignItems: 'center', paddingBottom: '10px' }}>
-            <span>
-              {name} {version}
-            </span>
-            <Focusable style={{ marginLeft: 'auto', boxShadow: 'none', display: 'flex', justifyContent: 'right' }}>
-              {update && (
-                <DialogButton
-                  style={{ height: '40px', minWidth: '60px', marginRight: '10px' }}
-                  onClick={() => requestPluginInstall(name, update)}
-                >
-                  <div style={{ display: 'flex', flexDirection: 'row' }}>
-                    Update to {update.name}
-                    <FaDownload style={{ paddingLeft: '2rem' }} />
-                  </div>
-                </DialogButton>
-              )}
-              <DialogButton
-                style={{ height: '40px', width: '40px', padding: '10px 12px', minWidth: '40px' }}
-                onClick={(e: MouseEvent) =>
-                  showContextMenu(
-                    <Menu label="Plugin Actions">
-                      <MenuItem onSelected={() => window.DeckyPluginLoader.importPlugin(name, version)}>
-                        Reload
-                      </MenuItem>
-                      <MenuItem onSelected={() => window.DeckyPluginLoader.uninstallPlugin(name)}>Uninstall</MenuItem>
-                    </Menu>,
-                    e.currentTarget ?? window,
-                  )
-                }
-              >
-                <FaEllipsisH />
-              </DialogButton>
-            </Focusable>
-          </li>
-        );
-      })}
-    </ul>
-  );
-}

frontend/src/components/store/PluginCard.tsx

@@ -1,236 +0,0 @@
-import {
-  DialogButton,
-  Dropdown,
-  Focusable,
-  QuickAccessTab,
-  Router,
-  SingleDropdownOption,
-  SuspensefulImage,
-  joinClassNames,
-  staticClasses,
-} from 'decky-frontend-lib';
-import { FC, useRef, useState } from 'react';
-
-import {
-  LegacyStorePlugin,
-  StorePlugin,
-  StorePluginVersion,
-  isLegacyPlugin,
-  requestLegacyPluginInstall,
-  requestPluginInstall,
-} from '../../store';
-
-interface PluginCardProps {
-  plugin: StorePlugin | LegacyStorePlugin;
-}
-
-const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
-  const [selectedOption, setSelectedOption] = useState<number>(0);
-  const buttonRef = useRef<HTMLDivElement>(null);
-  const containerRef = useRef<HTMLDivElement>(null);
-  return (
-    <div
-      style={{
-        padding: '30px',
-        paddingTop: '10px',
-        paddingBottom: '10px',
-      }}
-    >
-      {/* TODO: abstract this messy focus hackiness into a custom component in lib */}
-      <Focusable
-        className="deckyStoreCard"
-        ref={containerRef}
-        onActivate={(_: CustomEvent) => {
-          buttonRef.current!.focus();
-        }}
-        onCancel={(_: CustomEvent) => {
-          if (containerRef.current!.querySelectorAll('* :focus').length === 0) {
-            Router.NavigateBackOrOpenMenu();
-            setTimeout(() => Router.OpenQuickAccessMenu(QuickAccessTab.Decky), 1000);
-          } else {
-            containerRef.current!.focus();
-          }
-        }}
-        style={{
-          display: 'flex',
-          flexDirection: 'column',
-          background: '#ACB2C924',
-          height: 'unset',
-          marginBottom: 'unset',
-          // boxShadow: var(--gpShadow-Medium);
-          scrollSnapAlign: 'start',
-          boxSizing: 'border-box',
-        }}
-      >
-        <div className="deckyStoreCardHeader" style={{ display: 'flex', alignItems: 'center' }}>
-          <a
-            style={{ fontSize: '18pt', padding: '10px' }}
-            className={joinClassNames(staticClasses.Text)}
-            // onClick={() => Router.NavigateToExternalWeb('https://github.com/' + plugin.artifact)}
-          >
-            {isLegacyPlugin(plugin) ? (
-              <div className="deckyStoreCardNameContainer">
-                <span className="deckyStoreCardLegacyRepoOwner" style={{ color: 'grey' }}>
-                  {plugin.artifact.split('/')[0]}/
-                </span>
-                {plugin.artifact.split('/')[1]}
-              </div>
-            ) : (
-              plugin.name
-            )}
-          </a>
-        </div>
-        <div
-          style={{
-            display: 'flex',
-            flexDirection: 'row',
-          }}
-          className="deckyStoreCardBody"
-        >
-          <SuspensefulImage
-            className="deckyStoreCardImage"
-            suspenseWidth="256px"
-            style={{
-              width: 'auto',
-              height: '160px',
-            }}
-            src={
-              isLegacyPlugin(plugin)
-                ? `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/artifact_images/${plugin.artifact.replace(
-                    '/',
-                    '_',
-                  )}.png`
-                : `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/artifact_images/${plugin.name.replace(
-                    '/',
-                    '_',
-                  )}.png`
-            }
-          />
-          <div
-            style={{
-              display: 'flex',
-              flexDirection: 'column',
-            }}
-            className="deckyStoreCardInfo"
-          >
-            <p
-              className={joinClassNames(staticClasses.PanelSectionRow)}
-              style={{ marginTop: '0px', marginLeft: '16px' }}
-            >
-              <span style={{ paddingLeft: '0px' }}>Author: {plugin.author}</span>
-            </p>
-            <p
-              className={joinClassNames(staticClasses.PanelSectionRow)}
-              style={{
-                marginLeft: '16px',
-                marginTop: '0px',
-                marginBottom: '0px',
-                marginRight: '16px',
-              }}
-            >
-              <span style={{ paddingLeft: '0px' }}>{plugin.description}</span>
-            </p>
-            <p
-              className={joinClassNames('deckyStoreCardTagsContainer', staticClasses.PanelSectionRow)}
-              style={{
-                padding: '0 16px',
-                display: 'flex',
-                flexWrap: 'wrap',
-                gap: '5px 10px',
-              }}
-            >
-              <span style={{ padding: '5px 0' }}>Tags:</span>
-              {plugin.tags.map((tag: string) => (
-                <span
-                  className="deckyStoreCardTag"
-                  style={{
-                    padding: '5px',
-                    borderRadius: '5px',
-                    background: tag == 'root' ? '#842029' : '#ACB2C947',
-                  }}
-                >
-                  {tag == 'root' ? 'Requires root' : tag}
-                </span>
-              ))}
-              {isLegacyPlugin(plugin) && (
-                <span
-                  className="deckyStoreCardTag deckyStoreCardLegacyTag"
-                  style={{
-                    color: '#232120',
-                    padding: '5px',
-                    borderRadius: '5px',
-                    background: '#EDE841',
-                  }}
-                >
-                  legacy
-                </span>
-              )}
-            </p>
-          </div>
-        </div>
-        <div
-          className="deckyStoreCardActionsContainer"
-          style={{
-            width: '100%',
-            alignSelf: 'flex-end',
-            display: 'flex',
-            flexDirection: 'row',
-          }}
-        >
-          <Focusable
-            className="deckyStoreCardActions"
-            style={{
-              display: 'flex',
-              flexDirection: 'row',
-              width: '100%',
-            }}
-          >
-            <div
-              className="deckyStoreCardInstallButtonContainer"
-              style={{
-                flex: '1',
-              }}
-            >
-              <DialogButton
-                className="deckyStoreCardInstallButton"
-                ref={buttonRef}
-                onClick={() =>
-                  isLegacyPlugin(plugin)
-                    ? requestLegacyPluginInstall(plugin, Object.keys(plugin.versions)[selectedOption])
-                    : requestPluginInstall(plugin.name, plugin.versions[selectedOption])
-                }
-              >
-                Install
-              </DialogButton>
-            </div>
-            <div
-              className="deckyStoreCardVersionDropdownContainer"
-              style={{
-                flex: '0.2',
-              }}
-            >
-              <Dropdown
-                rgOptions={
-                  (isLegacyPlugin(plugin)
-                    ? Object.keys(plugin.versions).map((v, k) => ({
-                        data: k,
-                        label: v,
-                      }))
-                    : plugin.versions.map((version: StorePluginVersion, index) => ({
-                        data: index,
-                        label: version.name,
-                      }))) as SingleDropdownOption[]
-                }
-                strDefaultLabel={'Select a version'}
-                selectedOption={selectedOption}
-                onChange={({ data }) => setSelectedOption(data)}
-              />
-            </div>
-          </Focusable>
-        </div>
-      </Focusable>
-    </div>
-  );
-};
-
-export default PluginCard;

frontend/src/components/store/Store.tsx

@@ -1,64 +0,0 @@
-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);
-
-  useEffect(() => {
-    (async () => {
-      const res = await getPluginList();
-      logger.log('got data!', res);
-      setData(res);
-    })();
-    (async () => {
-      const res = await getLegacyPluginList();
-      logger.log('got legacy data!', res);
-      setLegacyData(res);
-    })();
-  }, []);
-
-  return (
-    <div
-      style={{
-        marginTop: '40px',
-        height: 'calc( 100% - 40px )',
-        overflowY: 'scroll',
-      }}
-    >
-      <div
-        style={{
-          display: 'flex',
-          flexWrap: 'nowrap',
-          flexDirection: 'column',
-          height: '100%',
-        }}
-      >
-        {!data ? (
-          <div style={{ height: '100%' }}>
-            <SteamSpinner />
-          </div>
-        ) : (
-          <div>
-            {data.map((plugin: StorePlugin) => (
-              <PluginCard plugin={plugin} />
-            ))}
-            {!legacyData ? (
-              <SteamSpinner />
-            ) : (
-              legacyData.map((plugin: LegacyStorePlugin) => <PluginCard plugin={plugin} />)
-            )}
-          </div>
-        )}
-      </div>
-    </div>
-  );
-};
-
-export default StorePage;

frontend/src/index.tsx

@@ -1,66 +1,25 @@
-import { ButtonItem, CommonUIModule, webpackCache } from 'decky-frontend-lib';
-import { forwardRef } from 'react';
-
 import PluginLoader from './plugin-loader';
-import { DeckyUpdater } from './updater';
 
 declare global {
   interface Window {
     DeckyPluginLoader: PluginLoader;
-    DeckyUpdater?: DeckyUpdater;
     importDeckyPlugin: Function;
     syncDeckyPlugins: Function;
-    deckyHasLoaded: boolean;
-    deckyAuthToken: string;
-    webpackJsonp: any;
   }
 }
 
-// HACK to fix plugins using webpack v4 push
+window.DeckyPluginLoader?.dismountAll();
 
-const v4Cache = {};
-for (let m of Object.keys(webpackCache)) {
-  v4Cache[m] = { exports: webpackCache[m] };
-}
+window.DeckyPluginLoader = new PluginLoader();
+window.importDeckyPlugin = function (name: string) {
+  window.DeckyPluginLoader?.importPlugin(name);
+};
 
-if (!window.webpackJsonp || window.webpackJsonp.deckyShimmed) {
-  window.webpackJsonp = {
-    deckyShimmed: true,
-    push: (mod: any): any => {
-      if (mod[1].get_require) return { c: v4Cache };
-    },
-  };
-  CommonUIModule.__deckyButtonItemShim = forwardRef((props: any, ref: any) => {
-    // tricks the old filter into working
-    const dummy = `childrenContainerWidth:"min"`;
-    return <ButtonItem ref={ref} _shim={dummy} {...props} />;
-  });
-}
+window.syncDeckyPlugins = async function () {
+  const plugins = await (await fetch('http://127.0.0.1:1337/plugins')).json();
+  for (const plugin of plugins) {
+    window.DeckyPluginLoader?.importPlugin(plugin);
+  }
+};
 
-(async () => {
-  window.deckyAuthToken = await fetch('http://127.0.0.1:1337/auth/token').then((r) => r.text());
-
-  window.DeckyPluginLoader?.dismountAll();
-  window.DeckyPluginLoader?.deinit();
-
-  window.DeckyPluginLoader = new PluginLoader();
-  window.importDeckyPlugin = function (name: string, version: string) {
-    window.DeckyPluginLoader?.importPlugin(name, version);
-  };
-
-  window.syncDeckyPlugins = async function () {
-    const plugins = await (
-      await fetch('http://127.0.0.1:1337/plugins', {
-        credentials: 'include',
-        headers: { Authentication: window.deckyAuthToken },
-      })
-    ).json();
-    for (const plugin of plugins) {
-      if (!window.DeckyPluginLoader.hasPlugin(plugin.name))
-        window.DeckyPluginLoader?.importPlugin(plugin.name, plugin.version);
-    }
-    window.DeckyPluginLoader.checkPluginUpdates();
-  };
-
-  setTimeout(() => window.syncDeckyPlugins(), 5000);
-})();
+setTimeout(() => window.syncDeckyPlugins(), 5000);

frontend/src/logger.ts

@@ -8,18 +8,8 @@ export const log = (name: string, ...args: any[]) => {
   );
 };
 
-export const debug = (name: string, ...args: any[]) => {
-  console.debug(
-    `%c Decky %c ${name} %c`,
-    'background: #16a085; color: black;',
-    'background: #1abc9c; color: black;',
-    'color: blue;',
-    ...args,
-  );
-};
-
 export const error = (name: string, ...args: any[]) => {
-  console.error(
+  console.log(
     `%c Decky %c ${name} %c`,
     'background: #16a085; color: black;',
     'background: #FF0000;',
@@ -38,11 +28,7 @@ class Logger {
   }
 
   debug(...args: any[]) {
-    debug(this.name, ...args);
-  }
-
-  error(...args: any[]) {
-    error(this.name, ...args);
+    log(this.name, ...args);
   }
 }
 

frontend/src/plugin-loader.tsx

@@ -1,39 +1,14 @@
-import {
-  ConfirmModal,
-  ModalRoot,
-  Patch,
-  QuickAccessTab,
-  Router,
-  callOriginal,
-  findModuleChild,
-  replacePatch,
-  showModal,
-  sleep,
-  staticClasses,
-} from 'decky-frontend-lib';
-import { lazy } from 'react';
+import { ModalRoot, showModal, staticClasses } from 'decky-frontend-lib';
 import { FaPlug } from 'react-icons/fa';
 
-import { DeckyState, DeckyStateContextProvider, useDeckyState } from './components/DeckyState';
+import { DeckyState, DeckyStateContextProvider } 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 TitleView from './components/TitleView';
-import WithSuspense from './components/WithSuspense';
 import Logger from './logger';
 import { Plugin } from './plugin';
 import RouterHook from './router-hook';
-import { checkForUpdates } from './store';
 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 {}
@@ -44,164 +19,51 @@ class PluginLoader extends Logger {
   private tabsHook: TabsHook = new TabsHook();
   // private windowHook: WindowHook = new WindowHook();
   private routerHook: RouterHook = new RouterHook();
-  private toaster: Toaster = new Toaster();
   private deckyState: DeckyState = new DeckyState();
 
   private reloadLock: boolean = false;
   // stores a list of plugin names which requested to be reloaded
-  private pluginReloadQueue: { name: string; version?: string }[] = [];
-
-  private focusWorkaroundPatch?: Patch;
+  private pluginReloadQueue: string[] = [];
 
   constructor() {
     super(PluginLoader.name);
     this.log('Initialized');
 
-    const TabBadge = () => {
-      const { updates, hasLoaderUpdate } = useDeckyState();
-      return <NotificationBadge show={(updates && updates.size > 0) || hasLoaderUpdate} />;
-    };
-
     this.tabsHook.add({
-      id: QuickAccessTab.Decky,
-      title: null,
-      content: (
+      id: 'main',
+      title: (
         <DeckyStateContextProvider deckyState={this.deckyState}>
           <TitleView />
+        </DeckyStateContextProvider>
+      ),
+      content: (
+        <DeckyStateContextProvider deckyState={this.deckyState}>
           <PluginView />
         </DeckyStateContextProvider>
       ),
-      icon: (
-        <DeckyStateContextProvider deckyState={this.deckyState}>
-          <FaPlug />
-          <TabBadge />
-        </DeckyStateContextProvider>
-      ),
+      icon: <FaPlug />,
     });
-
-    this.routerHook.addRoute('/decky/store', () => (
-      <WithSuspense route={true}>
-        <StorePage />
-      </WithSuspense>
-    ));
-    this.routerHook.addRoute('/decky/settings', () => {
-      return (
-        <DeckyStateContextProvider deckyState={this.deckyState}>
-          <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 this.updateVersion();
-    if (versionInfo?.remote && versionInfo?.remote?.tag_name != versionInfo?.current) {
-      this.toaster.toast({
-        title: 'Decky',
-        body: `Update to ${versionInfo?.remote?.tag_name} available!`,
-        onClick: () => Router.Navigate('/decky/settings'),
-      });
-      this.deckyState.setHasLoaderUpdate(true);
-    }
-    await sleep(7000);
-    await this.notifyPluginUpdates();
-  }
-
-  public async checkPluginUpdates() {
-    const updates = await checkForUpdates(this.plugins);
-    this.deckyState.setUpdates(updates);
-    return updates;
-  }
-
-  public async notifyPluginUpdates() {
-    const updates = await this.checkPluginUpdates();
-    if (updates?.size > 0) {
-      this.toaster.toast({
-        title: 'Decky',
-        body: `Updates available for ${updates.size} plugin${updates.size > 1 ? 's' : ''}!`,
-        onClick: () => Router.Navigate('/decky/settings/plugins'),
-      });
-    }
-  }
-
-  public addPluginInstallPrompt(artifact: string, version: string, request_id: string, hash: string) {
+  public addPluginInstallPrompt(artifact: string, version: string, request_id: string) {
     showModal(
-      <PluginInstallModal
-        artifact={artifact}
-        version={version}
-        hash={hash}
-        onOK={() => this.callServerMethod('confirm_plugin_install', { request_id })}
-        onCancel={() => this.callServerMethod('cancel_plugin_install', { request_id })}
-      />,
-    );
-  }
-
-  public uninstallPlugin(name: string) {
-    showModal(
-      <ConfirmModal
-        onOK={async () => {
-          await this.callServerMethod('uninstall_plugin', { name });
+      <ModalRoot
+        onOK={() => {
+          console.log('ok');
+          this.callServerMethod('confirm_plugin_install', { request_id });
         }}
         onCancel={() => {
-          // do nothing
+          console.log('nope');
+          this.callServerMethod('cancel_plugin_install', { request_id });
         }}
       >
-        <div className={staticClasses.Title} style={{ flexDirection: 'column' }}>
-          Uninstall {name}?
+        <div className={staticClasses.Title}>
+          Install {artifact} version {version}?
         </div>
-      </ConfirmModal>,
+      </ModalRoot>,
     );
   }
 
-  public hasPlugin(name: string) {
-    return Boolean(this.plugins.find((plugin) => plugin.name == name));
-  }
-
   public dismountAll() {
     for (const plugin of this.plugins) {
       this.log(`Dismounting ${plugin.name}`);
@@ -209,66 +71,44 @@ class PluginLoader extends Logger {
     }
   }
 
-  public deinit() {
-    this.routerHook.removeRoute('/decky/store');
-    this.routerHook.removeRoute('/decky/settings');
-    deinitFilepickerPatches();
-    this.focusWorkaroundPatch?.unpatch();
-  }
-
-  public unloadPlugin(name: string) {
-    const plugin = this.plugins.find((plugin) => plugin.name === name || plugin.name === name.replace('$LEGACY_', ''));
-    plugin?.onDismount?.();
-    this.plugins = this.plugins.filter((p) => p !== plugin);
-    this.deckyState.setPlugins(this.plugins);
-  }
-
-  public async importPlugin(name: string, version?: string | undefined) {
-    if (this.reloadLock) {
-      this.log('Reload currently in progress, adding to queue', name);
-      this.pluginReloadQueue.push({ name, version: version });
-      return;
-    }
-
+  public async importPlugin(name: string) {
     try {
-      this.reloadLock = true;
+      if (this.reloadLock) {
+        this.log('Reload currently in progress, adding to queue', name);
+        this.pluginReloadQueue.push(name);
+        return;
+      }
+
       this.log(`Trying to load ${name}`);
-
-      this.unloadPlugin(name);
-
+      let find = this.plugins.find((x) => x.name == name);
+      if (find) this.plugins.splice(this.plugins.indexOf(find), 1);
       if (name.startsWith('$LEGACY_')) {
         await this.importLegacyPlugin(name.replace('$LEGACY_', ''));
       } else {
-        await this.importReactPlugin(name, version);
+        await this.importReactPlugin(name);
       }
+      this.log(`Loaded ${name}`);
 
       this.deckyState.setPlugins(this.plugins);
-      this.log(`Loaded ${name}`);
     } catch (e) {
       throw e;
     } finally {
       this.reloadLock = false;
       const nextPlugin = this.pluginReloadQueue.shift();
       if (nextPlugin) {
-        this.importPlugin(nextPlugin.name, nextPlugin.version);
+        this.importPlugin(nextPlugin);
       }
     }
   }
 
-  private async importReactPlugin(name: string, version?: string) {
-    let res = await fetch(`http://127.0.0.1:1337/plugins/${name}/frontend_bundle`, {
-      credentials: 'include',
-      headers: {
-        Authentication: window.deckyAuthToken,
-      },
-    });
+  private async importReactPlugin(name: string) {
+    let res = await fetch(`http://127.0.0.1:1337/plugins/${name}/frontend_bundle`);
     if (res.ok) {
-      let plugin_export = await eval(await res.text());
-      let plugin = plugin_export(this.createPluginAPI(name));
+      let content = await eval(await res.text())(this.createPluginAPI(name));
       this.plugins.push({
-        ...plugin,
         name: name,
-        version: version,
+        icon: content.icon,
+        content: content.content,
       });
     } else throw new Error(`${name} frontend_bundle not OK`);
   }
@@ -285,10 +125,8 @@ class PluginLoader extends Logger {
   async callServerMethod(methodName: string, args = {}) {
     const response = await fetch(`http://127.0.0.1:1337/methods/${methodName}`, {
       method: 'POST',
-      credentials: 'include',
       headers: {
         'Content-Type': 'application/json',
-        Authentication: window.deckyAuthToken,
       },
       body: JSON.stringify(args),
     });
@@ -296,48 +134,15 @@ 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',
-          credentials: 'include',
           headers: {
             'Content-Type': 'application/json',
-            Authentication: window.deckyAuthToken,
           },
           body: JSON.stringify({
             args,
@@ -347,7 +152,7 @@ class PluginLoader extends Logger {
         return response.json();
       },
       fetchNoCors(url: string, request: any = {}) {
-        let args = { method: 'POST', headers: {} };
+        let args = { method: 'POST', headers: {}, body: '' };
         const req = { ...args, ...request, url, data: request.body };
         return this.callServerMethod('http_request', req);
       },

frontend/src/plugin.ts

@@ -1,7 +1,6 @@
 export interface Plugin {
-  name: string;
-  version?: string;
-  icon: JSX.Element;
-  content?: JSX.Element;
+  name: any;
+  content: any;
+  icon: any;
   onDismount?(): void;
 }

frontend/src/router-hook.tsx

@@ -1,11 +1,10 @@
-import { Patch, afterPatch, findModuleChild } from 'decky-frontend-lib';
-import { ReactElement, ReactNode, cloneElement, createElement, memo } from 'react';
+import { afterPatch, findModuleChild, unpatch } from 'decky-frontend-lib';
+import { ReactElement, createElement, memo } from 'react';
 import type { Route } from 'react-router';
 
 import {
   DeckyRouterState,
   DeckyRouterStateContextProvider,
-  RoutePatch,
   RouterEntry,
   useDeckyRouterState,
 } from './components/DeckyRouterState';
@@ -22,8 +21,6 @@ class RouterHook extends Logger {
   private memoizedRouter: any;
   private gamepadWrapper: any;
   private routerState: DeckyRouterState = new DeckyRouterState();
-  private wrapperPatch: Patch;
-  private routerPatch?: Patch;
 
   constructor() {
     super('RouterHook');
@@ -41,16 +38,14 @@ class RouterHook extends Logger {
     });
 
     let Route: new () => Route;
-    // Used to store the new replicated routes we create to allow routes to be unpatched.
-    let toReplace = new Map<string, ReactNode>();
     const DeckyWrapper = ({ children }: { children: ReactElement }) => {
-      const { routes, routePatches } = useDeckyRouterState();
+      const { routes } = useDeckyRouterState();
 
-      const routeList = children.props.children[0].props.children;
-
-      let routerIndex = routeList.length;
-      if (!routeList[routerIndex - 1]?.length || routeList[routerIndex - 1]?.length !== routes.size) {
-        if (routeList[routerIndex - 1]?.length && routeList[routerIndex - 1].length !== routes.size) routerIndex--;
+      const routerIndex = children.props.children[0].props.children.length - 1;
+      if (
+        !children.props.children[0].props.children[routerIndex].length ||
+        children.props.children[0].props.children !== routes.size
+      ) {
         const newRouterArray: ReactElement[] = [];
         routes.forEach(({ component, props }, path) => {
           newRouterArray.push(
@@ -59,37 +54,12 @@ class RouterHook extends Logger {
             </Route>,
           );
         });
-        routeList[routerIndex] = newRouterArray;
+        children.props.children[0].props.children[routerIndex] = newRouterArray;
       }
-      routeList.forEach((route: Route, index: number) => {
-        const replaced = toReplace.get(route?.props?.path as string);
-        if (replaced) {
-          routeList[index].props.children = replaced;
-          toReplace.delete(route?.props?.path as string);
-        }
-        if (route?.props?.path && routePatches.has(route.props.path as string)) {
-          toReplace.set(
-            route?.props?.path as string,
-            // @ts-ignore
-            routeList[index].props.children,
-          );
-          routePatches.get(route.props.path as string)?.forEach((patch) => {
-            const oType = routeList[index].props.children.type;
-            routeList[index].props.children = patch({
-              ...routeList[index].props,
-              children: {
-                ...cloneElement(routeList[index].props.children),
-                type: (props) => createElement(oType, props),
-              },
-            }).children;
-          });
-        }
-      });
-      this.debug('Rerendered routes list');
       return children;
     };
 
-    this.wrapperPatch = afterPatch(this.gamepadWrapper, 'render', (_: any, ret: any) => {
+    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
@@ -98,7 +68,7 @@ class RouterHook extends Logger {
         ) {
           if (!this.router) {
             this.router = ret.props.children.props.children[2]?.props?.children?.[0]?.type;
-            this.routerPatch = afterPatch(this.router, 'type', (_: any, ret: any) => {
+            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 = (
@@ -122,21 +92,9 @@ class RouterHook extends Logger {
     this.routerState.addRoute(path, component, props);
   }
 
-  addPatch(path: string, patch: RoutePatch) {
-    return this.routerState.addPatch(path, patch);
-  }
-
-  removePatch(path: string, patch: RoutePatch) {
-    this.routerState.removePatch(path, patch);
-  }
-
-  removeRoute(path: string) {
-    this.routerState.removeRoute(path);
-  }
-
   deinit() {
-    this.wrapperPatch.unpatch();
-    this.routerPatch?.unpatch();
+    unpatch(this.gamepadWrapper, 'render');
+    this.router && unpatch(this.router, 'type');
   }
 }
 

frontend/src/store.tsx

@@ -1,100 +0,0 @@
-import { ConfirmModal, showModal, staticClasses } from 'decky-frontend-lib';
-
-import { Plugin } from './plugin';
-
-export interface StorePluginVersion {
-  name: string;
-  hash: string;
-}
-
-export interface StorePlugin {
-  id: number;
-  name: string;
-  versions: StorePluginVersion[];
-  author: string;
-  description: string;
-  tags: string[];
-}
-
-export interface LegacyStorePlugin {
-  artifact: string;
-  versions: {
-    [version: string]: string;
-  };
-  author: string;
-  description: string;
-  tags: string[];
-}
-
-// name: version
-export type PluginUpdateMapping = Map<string, StorePluginVersion>;
-
-export function getPluginList(): Promise<StorePlugin[]> {
-  return fetch('https://beta.deckbrew.xyz/plugins', {
-    method: 'GET',
-  }).then((r) => r.json());
-}
-
-export function getLegacyPluginList(): Promise<LegacyStorePlugin[]> {
-  return fetch('https://plugins.deckbrew.xyz/get_plugins', {
-    method: 'GET',
-  }).then((r) => r.json());
-}
-
-export async function installFromURL(url: string) {
-  const splitURL = url.split('/');
-  await window.DeckyPluginLoader.callServerMethod('install_plugin', {
-    name: splitURL[splitURL.length - 1].replace('.zip', ''),
-    artifact: url,
-  });
-}
-
-export function requestLegacyPluginInstall(plugin: LegacyStorePlugin, selectedVer: string) {
-  showModal(
-    <ConfirmModal
-      onOK={() => {
-        window.DeckyPluginLoader.callServerMethod('install_plugin', {
-          name: plugin.artifact,
-          artifact: `https://github.com/${plugin.artifact}/archive/refs/tags/${selectedVer}.zip`,
-          version: selectedVer,
-          hash: plugin.versions[selectedVer],
-        });
-      }}
-      onCancel={() => {
-        // do nothing
-      }}
-    >
-      <div className={staticClasses.Title} style={{ flexDirection: 'column', boxShadow: 'unset' }}>
-        Using legacy plugins
-      </div>
-      You are currently installing a <b>legacy</b> plugin. Legacy plugins are no longer supported and may have issues.
-      Legacy plugins do not support gamepad input. To interact with a legacy plugin, you will need to use the
-      touchscreen.
-    </ConfirmModal>,
-  );
-}
-
-export async function requestPluginInstall(plugin: string, selectedVer: StorePluginVersion) {
-  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,
-  });
-}
-
-export async function checkForUpdates(plugins: Plugin[]): Promise<PluginUpdateMapping> {
-  const serverData = await getPluginList();
-  const updateMap = new Map<string, StorePluginVersion>();
-  for (let plugin of plugins) {
-    const remotePlugin = serverData?.find((x) => x.name == plugin.name);
-    if (remotePlugin && remotePlugin.versions?.length > 0 && plugin.version != remotePlugin?.versions?.[0]?.name) {
-      updateMap.set(plugin.name, remotePlugin.versions[0]);
-    }
-  }
-  return updateMap;
-}
-
-export function isLegacyPlugin(plugin: LegacyStorePlugin | StorePlugin): plugin is LegacyStorePlugin {
-  return 'artifact' in plugin;
-}

frontend/src/tabs-hook.ts

@@ -1,6 +1,3 @@
-import { Patch, QuickAccessTab, afterPatch, sleep } from 'decky-frontend-lib';
-import { memo } from 'react';
-
 import Logger from './logger';
 
 declare global {
@@ -14,11 +11,11 @@ declare global {
 
 const isTabsArray = (tabs: any) => {
   const length = tabs.length;
-  return length >= 7 && tabs[length - 1]?.tab;
+  return length === 7 && tabs[length - 1]?.key === 6 && tabs[length - 1]?.tab;
 };
 
 interface Tab {
-  id: QuickAccessTab | number;
+  id: string;
   title: any;
   content: any;
   icon: any;
@@ -27,111 +24,33 @@ interface Tab {
 class TabsHook extends Logger {
   // private keys = 7;
   tabs: Tab[] = [];
-  private quickAccess: any;
-  private tabRenderer: any;
-  private memoizedQuickAccess: any;
-  private cNode: any;
-
-  private qAPTree: any;
-  private rendererTree: any;
-
-  private cNodePatch?: Patch;
 
   constructor() {
     super('TabsHook');
 
     this.log('Initialized');
-    window.__TABS_HOOK_INSTANCE?.deinit?.();
     window.__TABS_HOOK_INSTANCE = this;
 
     const self = this;
-    const tree = (document.getElementById('root') as any)._reactRootContainer._internalRoot.current;
-    let scrollRoot: any;
-    async function findScrollRoot(currentNode: any, iters: number): Promise<any> {
-      if (iters >= 30) {
-        self.error(
-          'Scroll root was not found before hitting the recursion limit, a developer will need to increase the limit.',
-        );
-        return null;
-      }
-      currentNode = currentNode?.child;
-      if (currentNode?.type?.prototype?.RemoveSmartScrollContainer) {
-        self.log(`Scroll root was found in ${iters} recursion cycles`);
-        return currentNode;
-      }
-      if (!currentNode) return null;
-      if (currentNode.sibling) {
-        let node = await findScrollRoot(currentNode.sibling, iters + 1);
-        if (node !== null) return node;
-      }
-      return await findScrollRoot(currentNode, iters + 1);
-    }
-    (async () => {
-      scrollRoot = await findScrollRoot(tree, 0);
-      while (!scrollRoot) {
-        this.log('Failed to find scroll root node, reattempting in 5 seconds');
-        await sleep(5000);
-        scrollRoot = await findScrollRoot(tree, 0);
-      }
-      let newQA: any;
-      let newQATabRenderer: any;
-      this.cNodePatch = afterPatch(scrollRoot.stateNode, 'render', (_: any, ret: any) => {
-        if (!this.quickAccess && ret.props.children.props.children[4]) {
-          this.quickAccess = ret?.props?.children?.props?.children[4].type;
-          newQA = (...args: any) => {
-            const ret = this.quickAccess.type(...args);
-            if (ret) {
-              if (!newQATabRenderer) {
-                this.tabRenderer = ret.props.children[1].children.type;
-                newQATabRenderer = (...args: any) => {
-                  const oFilter = Array.prototype.filter;
-                  Array.prototype.filter = function (...args: any[]) {
-                    if (isTabsArray(this)) {
-                      self.render(this);
-                    }
-                    // @ts-ignore
-                    return oFilter.call(this, ...args);
-                  };
-                  // TODO remove array hack entirely and use this instead const tabs = ret.props.children.props.children[0].props.children[1].props.children[0].props.children[0].props.tabs
-                  const ret = this.tabRenderer(...args);
-                  Array.prototype.filter = oFilter;
-                  return ret;
-                };
-              }
-              this.rendererTree = ret.props.children[1].children;
-              ret.props.children[1].children.type = newQATabRenderer;
-            }
-            return ret;
-          };
-          this.memoizedQuickAccess = memo(newQA);
-          this.memoizedQuickAccess.isDeckyQuickAccess = true;
-        }
-        if (ret.props.children.props.children[4]) {
-          this.qAPTree = ret.props.children.props.children[4];
-          ret.props.children.props.children[4].type = this.memoizedQuickAccess;
-        }
-        return ret;
-      });
-      this.cNode = scrollRoot;
-      this.cNode.stateNode.forceUpdate();
-      this.log('Finished initial injection');
-    })();
-  }
 
-  deinit() {
-    this.cNodePatch?.unpatch();
-    if (this.qAPTree) this.qAPTree.type = this.quickAccess;
-    if (this.rendererTree) this.rendererTree.type = this.tabRenderer;
-    if (this.cNode) this.cNode.stateNode.forceUpdate();
+    const filter = Array.prototype.__filter ?? Array.prototype.filter;
+    Array.prototype.__filter = filter;
+    Array.prototype.filter = function (...args: any[]) {
+      if (isTabsArray(this)) {
+        self.render(this);
+      }
+      // @ts-ignore
+      return filter.call(this, ...args);
+    };
   }
 
   add(tab: Tab) {
-    this.debug('Adding tab', tab.id, 'to render array');
+    this.log('Adding tab', tab.id, 'to render array');
     this.tabs.push(tab);
   }
 
-  removeById(id: number) {
-    this.debug('Removing tab', id);
+  removeById(id: string) {
+    this.log('Removing tab', id);
     this.tabs = this.tabs.filter((tab) => tab.id !== id);
   }
 

frontend/src/toaster.tsx

@@ -1,110 +0,0 @@
-import { Patch, ToastData, afterPatch, findInReactTree, findModuleChild, sleep } from 'decky-frontend-lib';
-import { ReactNode } from 'react';
-
-import Toast from './components/Toast';
-import Logger from './logger';
-
-declare global {
-  interface Window {
-    __TOASTER_INSTANCE: any;
-    NotificationStore: any;
-  }
-}
-
-class Toaster extends Logger {
-  private instanceRetPatch?: Patch;
-  private node: any;
-  private settingsModule: any;
-  private ready: boolean = false;
-
-  constructor() {
-    super('Toaster');
-
-    window.__TOASTER_INSTANCE?.deinit?.();
-    window.__TOASTER_INSTANCE = this;
-    this.init();
-  }
-
-  async init() {
-    let instance: any;
-
-    while (true) {
-      instance = findInReactTree(
-        (document.getElementById('root') as any)._reactRootContainer._internalRoot.current,
-        (x) => x?.memoizedProps?.className?.startsWith?.('toastmanager_ToastPlaceholder'),
-      );
-      if (instance) break;
-      this.debug('finding instance');
-      await sleep(2000);
-    }
-
-    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.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;
-        });
-      }
-      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;
-  }
-
-  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(),
-      eType: 15,
-      nToastDurationMS: toast.duration || 5e3,
-      data: toast,
-      decky: true,
-    };
-    // @ts-ignore
-    toastData.data.appid = () => 0;
-    if (
-      (settings?.bDisableAllToasts && !toast.critical) ||
-      (settings?.bDisableToastsInGame && !toast.critical && window.NotificationStore.BIsUserInGame())
-    )
-      return;
-    window.NotificationStore.m_rgNotificationToasts.push(toastData);
-    window.NotificationStore.DispatchNextToast();
-  }
-
-  deinit() {
-    this.instanceRetPatch?.unpatch();
-    this.node && delete this.node.stateNode.render;
-    this.node && this.node.stateNode.forceUpdate();
-  }
-}
-
-export default Toaster;

frontend/src/updater.ts

@@ -1,47 +0,0 @@
-export enum Branches {
-  Release,
-  Prerelease,
-  Nightly,
-}
-
-export interface DeckyUpdater {
-  updateProgress: (val: number) => void;
-  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: RemoteVerInfo | null;
-  all: RemoteVerInfo[] | null;
-  updatable: boolean;
-}
-
-export async function callUpdaterMethod(methodName: string, args = {}) {
-  const response = await fetch(`http://127.0.0.1:1337/updater/${methodName}`, {
-    method: 'POST',
-    credentials: 'include',
-    headers: {
-      'Content-Type': 'application/json',
-      Authentication: window.deckyAuthToken,
-    },
-    body: JSON.stringify(args),
-  });
-
-  return response.json();
-}
-
-export async function finishUpdate() {
-  callUpdaterMethod('do_restart');
-}

frontend/src/utils/hooks/useSetting.ts

@@ -1,36 +0,0 @@
-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>);
-    },
-  ];
-}

frontend/tsconfig.json

@@ -1,10 +1,10 @@
 {
   "compilerOptions": {
+    "outDir": "dist",
     "module": "ESNext",
     "target": "ES2020",
     "jsx": "react",
     "jsxFactory": "window.SP_REACT.createElement",
-    "jsxFragmentFactory": "window.SP_REACT.Fragment",
     "declaration": false,
     "moduleResolution": "node",
     "noUnusedLocals": true,

requirements.txt

@@ -2,4 +2,3 @@ aiohttp==3.8.1
 aiohttp-jinja2==1.5.0
 aiohttp_cors==0.7.0
 watchdog==2.1.7
-certifi==2022.6.15