Add plugin updater, notification badge, fixes

* feat: add CEF Remote Debugging toggle

* feat: disable remote debugger on startup

* refactor: stop debugger instead of disable

* feat: add option to allow remote debugging by default

Co-authored-by: TrainDoctor <traindoctor@protonmail.com>

.github/workflows/build.yml

@@ -117,29 +117,27 @@ jobs:
       id: ready_tag
       run: |
         export VERSION=${{ steps.old_tag.outputs.tag }}
-        export SEMVER=$(sed -r 's/(-.*)?-pre$//' <<< $VERSION)
         echo "VERS: $VERSION"
-        echo "TO SEMVER: $SEMVER"
-        OUT=$(semver bump prerel "$SEMVER")-pre
+        OUT=$(semver bump prerel "$VERSION")
         echo "OUT: $OUT"
-        echo ::set-output name=tag_name::$(sed -r 's/(-.*)?-pre$//' <<< $VERSION)-pre
+        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' }}
       with:
         tag: ${{ steps.ready_tag.outputs.tag_name }}
-        message: Nightly ${{ 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' }}
-    #   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: Release 📦
+      uses: softprops/action-gh-release@v1
+      if: ${{ github.event_name == 'workflow_dispatch' }}
+      with:
+        name: Prerelease ${{ steps.ready_tag.outputs.tag_name }}
+        tag_name: ${{ steps.ready_tag.outputs.tag_name }}
+        files: ./dist/PluginLoader
+        prerelease: true
+        generate_release_notes: true
 
   # nightly:
   #   name: Release the nightly version of the package

backend/helpers.py

@@ -1,17 +1,24 @@
 import certifi
 import ssl
 import uuid
+import re
+import subprocess
 
 from aiohttp.web import middleware, Response
 from subprocess import check_output
 from time import sleep
 
+
+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/.*")
+
 def get_ssl_context():
     return ssl_ctx
 
@@ -20,7 +27,7 @@ def get_csrf_token():
 
 @middleware
 async def csrf_middleware(request, handler):
-    if str(request.method) == "OPTIONS" or request.headers.get('Authentication') == csrf_token or str(request.rel_url) == "/auth/token" or str(request.rel_url).startswith("/plugins/load_main/") or str(request.rel_url).startswith("/static/") or str(request.rel_url).startswith("/legacy/") or str(request.rel_url).startswith("/steam_resource/"):
+    if str(request.method) == "OPTIONS" or request.headers.get('Authentication') == csrf_token or str(request.rel_url) == "/auth/token" or str(request.rel_url).startswith("/plugins/load_main/") or str(request.rel_url).startswith("/static/") or str(request.rel_url).startswith("/legacy/") or str(request.rel_url).startswith("/steam_resource/") or assets_regex.match(str(request.rel_url)):
         return await handler(request)
     return Response(text='Forbidden', status='403')
 
@@ -60,3 +67,17 @@ def get_user_group() -> str:
     if group == None:
         raise ValueError("helpers.get_user_group method called before group variable was set. Run helpers.set_user_group first.")
     return group
+
+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.DEVNULL, stderr=subprocess.DEVNULL)
+
+async def start_systemd_unit(unit_name: str) -> subprocess.CompletedProcess:
+    cmd = ["systemctl", "start", unit_name]
+
+    return subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

backend/injector.py

@@ -5,6 +5,7 @@ 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"
 
@@ -65,11 +66,13 @@ async def get_tabs():
         while True:
             try:
                 res = await web.get(f"{BASE_ADDRESS}/json")
-                break
-            except:
+            except ClientConnectorError:
+                logger.debug("ClientConnectorError excepted.")
                 logger.debug("Steam isn't available yet. Wait for a moment...")
                 logger.debug(format_exc())
                 await sleep(5)
+            else:
+                break
 
         if res.status == 200:
             r = await res.json()

backend/loader.py

@@ -88,7 +88,7 @@ class Loader:
 
     async def get_plugins(self, request):
         plugins = list(self.plugins.values())
-        return web.json_response([str(i) if not i.legacy else "$LEGACY_"+str(i) for i in plugins])
+        return web.json_response([{"name": str(i) if not i.legacy else "$LEGACY_"+str(i), "version": i.version} for i in plugins])
 
     def handle_frontend_assets(self, request):
         plugin = self.plugins[request.match_info["plugin_name"]]
@@ -116,13 +116,13 @@ class Loader:
                 self.logger.info(f"Plugin {plugin.name} is passive")
             self.plugins[plugin.name] = plugin.start()
             self.logger.info(f"Loaded {plugin.name}")
-            self.loop.create_task(self.dispatch_plugin(plugin.name if not plugin.legacy else "$LEGACY_" + plugin.name))
+            self.loop.create_task(self.dispatch_plugin(plugin.name if not plugin.legacy else "$LEGACY_" + plugin.name, plugin.version))
         except Exception as e:
             self.logger.error(f"Could not load {file}. {e}")
             print_exc()
 
-    async def dispatch_plugin(self, name):
-        await inject_to_tab("SP", f"window.importDeckyPlugin('{name}')")
+    async def dispatch_plugin(self, name, version):
+        await inject_to_tab("SP", f"window.importDeckyPlugin('{name}', '{version}')")
 
     def import_plugins(self):
         self.logger.info(f"import plugins from {self.plugin_path}")

backend/main.py

@@ -13,7 +13,7 @@ from subprocess import call
 
 # local modules
 from browser import PluginBrowser
-from helpers import csrf_middleware, get_csrf_token, get_user, get_user_group, set_user, set_user_group
+from helpers import csrf_middleware, get_csrf_token, get_user, get_user_group, set_user, set_user_group, stop_systemd_unit, REMOTE_DEBUGGER_UNIT
 from injector import inject_to_tab, tab_has_global_var
 from loader import Loader
 from updater import Updater
@@ -28,8 +28,9 @@ 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", HOME_PATH+"/homebrew/plugins"),
+    "plugin_path": getenv("PLUGIN_PATH", HOMEBREW_PATH+"/plugins"),
     "chown_plugin_path": getenv("CHOWN_PLUGIN_PATH", "1") == "1",
     "server_host": getenv("SERVER_HOST", "127.0.0.1"),
     "server_port": int(getenv("SERVER_PORT", "1337")),
@@ -47,6 +48,9 @@ async def chown_plugin_dir(_):
     if code_chown != 0 or code_chmod != 0:
         logger.error(f"chown/chmod exited with a non-zero exit code (chown: {code_chown}, chmod: {code_chmod})")
 
+def remote_debugging_allowed():
+    return path.exists(HOMEBREW_PATH + "/allow_remote_debugging")
+
 class PluginManager:
     def __init__(self) -> None:
         self.loop = get_event_loop()
@@ -62,11 +66,12 @@ class PluginManager:
         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 remote_debugging_allowed():
+            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)])
 
@@ -98,6 +103,8 @@ class PluginManager:
         #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"):
@@ -106,7 +113,7 @@ class PluginManager:
 
     async def inject_javascript(self, request=None):
         try:
-            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)
+            await inject_to_tab("SP", "try{window.deckyHasLoaded = true;(async()=>{while(!window.SP_REACT){await new Promise(r => setTimeout(r, 10))};" + open(path.join(path.dirname(__file__), "./static/plugin-loader.iife.js"), "r").read() + "})();}catch(e){console.error(e)}", True)
         except:
             logger.info("Failed to inject JavaScript into tab")
             pass

backend/plugin.py

@@ -21,7 +21,13 @@ class PluginWrapper:
         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 ""

backend/updater.py

@@ -68,7 +68,7 @@ class Updater:
         async with ClientSession() as web:
             async with web.request("GET", "https://api.github.com/repos/SteamDeckHomebrew/decky-loader/releases", ssl=helpers.get_ssl_context()) as res:
                 remoteVersions = await res.json()
-                self.remoteVer = next(filter(lambda ver: ver["prerelease"] and ver["tag_name"].startswith("v") and ver["tag_name"].endswith("-pre"), remoteVersions), None)
+                self.remoteVer = next(filter(lambda ver: ver["prerelease"] and ver["tag_name"].startswith("v") and ver["tag_name"].find("-pre"), remoteVersions), None)
                 logger.info("Updated remote version information")
                 tab = await get_tab("SP")
                 await tab.evaluate_js(f"window.DeckyPluginLoader.notifyUpdates()", False, True, False)

backend/utilities.py

@@ -5,6 +5,7 @@ from aiohttp import ClientSession, web
 
 from injector import inject_to_tab
 import helpers
+import subprocess
 
 class Utilities:
     def __init__(self, context) -> None:
@@ -16,7 +17,10 @@ class Utilities:
             "confirm_plugin_install": self.confirm_plugin_install,
             "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
+            "remove_css_from_tab": self.remove_css_from_tab,
+            "allow_remote_debugging": self.allow_remote_debugging,
+            "disallow_remote_debugging": self.disallow_remote_debugging,
+            "remote_debugging_allowed": self.remote_debugging_allowed
         }
 
         if context:
@@ -133,3 +137,15 @@ class Utilities:
                 "success": False,
                 "result": e
             }
+
+
+    async def remote_debugging_allowed(self):
+        return await helpers.is_systemd_unit_active(helpers.REMOTE_DEBUGGER_UNIT)
+
+    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

frontend/package.json

@@ -37,7 +37,7 @@
     }
   },
   "dependencies": {
-    "decky-frontend-lib": "^1.5.1",
+    "decky-frontend-lib": "^1.7.5",
     "react-icons": "^4.4.0"
   }
 }

frontend/pnpm-lock.yaml

@@ -9,7 +9,7 @@ specifiers:
   '@types/react': 16.14.0
   '@types/react-router': 5.1.18
   '@types/webpack': ^5.28.0
-  decky-frontend-lib: ^1.5.1
+  decky-frontend-lib: ^1.7.5
   husky: ^8.0.1
   import-sort-style-module: ^6.0.0
   inquirer: ^8.2.4
@@ -23,7 +23,7 @@ specifiers:
   typescript: ^4.7.4
 
 dependencies:
-  decky-frontend-lib: 1.5.1
+  decky-frontend-lib: 1.7.5
   react-icons: 4.4.0_react@16.14.0
 
 devDependencies:
@@ -806,8 +806,8 @@ packages:
       ms: 2.1.2
     dev: true
 
-  /decky-frontend-lib/1.5.1:
-    resolution: {integrity: sha512-XrcMNxqdXJFyuJYJX4Wmo7DvFVkwBsl8aWU5wfLdPQmcPz3drafyEgqIdO4AxpFuTsHTf1qaHBiYYw349vYpgw==}
+  /decky-frontend-lib/1.7.5:
+    resolution: {integrity: sha512-1OX/Ix9W76gF0NJjfm0k/01LYPmC2k/k+k/qqH8JJPlPHh5+W5P8ZG2T8m5wKsqoP7jx2W3k7RNZBh9vAqFoFw==}
     dependencies:
       minimist: 1.2.6
     dev: false
@@ -1255,10 +1255,6 @@ packages:
       brace-expansion: 1.1.11
     dev: true
 
-  /minimist/1.2.6:
-    resolution: {integrity: sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==}
-    dev: false
-
   /ms/2.1.2:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
     dev: true

frontend/src/components/DeckyState.tsx

@@ -1,20 +1,30 @@
 import { FC, createContext, useContext, useEffect, useState } from 'react';
 
 import { Plugin } from '../plugin';
+import { PluginUpdateMapping } from '../store';
 
 interface PublicDeckyState {
   plugins: Plugin[];
   activePlugin: Plugin | null;
+  updates: PluginUpdateMapping | null;
+  hasLoaderUpdate?: boolean;
 }
 
 export class DeckyState {
   private _plugins: Plugin[] = [];
   private _activePlugin: Plugin | null = null;
+  private _updates: PluginUpdateMapping | null = null;
+  private _hasLoaderUpdate: boolean = false;
 
   public eventBus = new EventTarget();
 
   publicState(): PublicDeckyState {
-    return { plugins: this._plugins, activePlugin: this._activePlugin };
+    return {
+      plugins: this._plugins,
+      activePlugin: this._activePlugin,
+      updates: this._updates,
+      hasLoaderUpdate: this._hasLoaderUpdate,
+    };
   }
 
   setPlugins(plugins: Plugin[]) {
@@ -32,6 +42,16 @@ export class DeckyState {
     this.notifyUpdate();
   }
 
+  setUpdates(updates: PluginUpdateMapping) {
+    this._updates = updates;
+    this.notifyUpdate();
+  }
+
+  setHasLoaderUpdate(hasUpdate: boolean) {
+    this._hasLoaderUpdate = hasUpdate;
+    this.notifyUpdate();
+  }
+
   private notifyUpdate() {
     this.eventBus.dispatchEvent(new Event('update'));
   }

frontend/src/components/NotificationBadge.tsx

@@ -0,0 +1,25 @@
+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,30 +1,47 @@
-import { ButtonItem, PanelSection, PanelSectionRow } from 'decky-frontend-lib';
+import {
+  ButtonItem,
+  PanelSection,
+  PanelSectionRow,
+  joinClassNames,
+  scrollClasses,
+  staticClasses,
+} from 'decky-frontend-lib';
 import { VFC } from 'react';
 
 import { useDeckyState } from './DeckyState';
+import NotificationBadge from './NotificationBadge';
 
 const PluginView: VFC = () => {
-  const { plugins, activePlugin, setActivePlugin } = useDeckyState();
+  const { plugins, updates, activePlugin, setActivePlugin } = useDeckyState();
 
   if (activePlugin) {
-    return <div style={{ height: '100%' }}>{activePlugin.content}</div>;
+    return (
+      <div
+        className={joinClassNames(staticClasses.TabGroupPanel, scrollClasses.ScrollPanel, scrollClasses.ScrollY)}
+        style={{ height: '100%' }}
+      >
+        {activePlugin.content}
+      </div>
+    );
   }
-
   return (
-    <PanelSection>
-      {plugins
-        .filter((p) => p.content)
-        .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>
+    <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', justifyContent: 'space-between' }}>
+                  <div>{icon}</div>
+                  <div>{name}</div>
+                  <NotificationBadge show={updates?.has(name)} style={{ top: '-5px', right: '-5px' }} />
+                </div>
+              </ButtonItem>
+            </PanelSectionRow>
+          ))}
+      </PanelSection>
+    </div>
   );
 };
 

frontend/src/components/TitleView.tsx

@@ -7,7 +7,6 @@ import { useDeckyState } from './DeckyState';
 const titleStyles: CSSProperties = {
   display: 'flex',
   paddingTop: '3px',
-  paddingBottom: '14px',
   paddingRight: '16px',
   boxShadow: 'unset',
 };

frontend/src/components/modals/PluginInstallModal.tsx

@@ -20,9 +20,7 @@ const PluginInstallModal: FC<PluginInstallModalProps> = ({ artifact, version, ha
       onOK={async () => {
         setLoading(true);
         await onOK();
-        Router.NavigateBackOrOpenMenu();
-        await sleep(250);
-        setTimeout(() => Router.OpenQuickAccessMenu(QuickAccessTab.Decky), 1000);
+        setTimeout(() => Router.OpenQuickAccessMenu(QuickAccessTab.Decky), 250);
       }}
       onCancel={async () => {
         await onCancel();

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

@@ -0,0 +1,34 @@
+import { Field, Toggle } from 'decky-frontend-lib';
+import { useEffect, useState } from 'react';
+import { FaBug } from 'react-icons/fa';
+
+export default function RemoteDebuggingSettings() {
+  const [allowRemoteDebugging, setAllowRemoteDebugging] = useState<boolean>(false);
+  useEffect(() => {
+    (async () => {
+      const res = (await window.DeckyPluginLoader.callServerMethod('remote_debugging_allowed')) as { result: boolean };
+      setAllowRemoteDebugging(res.result);
+    })();
+  }, []);
+
+  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}
+        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/index.tsx

@@ -2,7 +2,8 @@ import { DialogButton, Field, TextField } from 'decky-frontend-lib';
 import { useState } from 'react';
 import { FaShapes } from 'react-icons/fa';
 
-import { installFromURL } from '../../../store/Store';
+import { installFromURL } from '../../../../store';
+import RemoteDebuggingSettings from './RemoteDebugging';
 import UpdaterSettings from './Updater';
 
 export default function GeneralSettings() {
@@ -20,6 +21,7 @@ export default function GeneralSettings() {
         />
       </Field> */}
       <UpdaterSettings />
+      <RemoteDebuggingSettings />
       <Field
         label="Manual plugin install"
         description={<TextField label={'URL'} value={pluginURL} onChange={(e) => setPluginURL(e?.target.value)} />}

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

@@ -1,10 +1,16 @@
-import { DialogButton, staticClasses } from 'decky-frontend-lib';
-import { FaTrash } from 'react-icons/fa';
+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 } = useDeckyState();
+  const { plugins, updates } = useDeckyState();
+
+  useEffect(() => {
+    window.DeckyPluginLoader.checkPluginUpdates();
+  }, []);
 
   if (plugins.length === 0) {
     return (
@@ -16,19 +22,45 @@ export default function PluginList() {
 
   return (
     <ul style={{ listStyleType: 'none' }}>
-      {plugins.map(({ name }) => (
-        <li style={{ display: 'flex', flexDirection: 'row', alignItems: 'center' }}>
-          <span>{name}</span>
-          <div className={staticClasses.Title} style={{ marginLeft: 'auto', boxShadow: 'none' }}>
-            <DialogButton
-              style={{ height: '40px', width: '40px', padding: '10px 12px' }}
-              onClick={() => window.DeckyPluginLoader.uninstallPlugin(name)}
-            >
-              <FaTrash />
-            </DialogButton>
-          </div>
-        </li>
-      ))}
+      {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

@@ -6,6 +6,7 @@ import {
   Router,
   SingleDropdownOption,
   SuspensefulImage,
+  joinClassNames,
   staticClasses,
 } from 'decky-frontend-lib';
 import { FC, useRef, useState } from 'react';
@@ -14,22 +15,15 @@ import {
   LegacyStorePlugin,
   StorePlugin,
   StorePluginVersion,
+  isLegacyPlugin,
   requestLegacyPluginInstall,
   requestPluginInstall,
-} from './Store';
+} from '../../store';
 
 interface PluginCardProps {
   plugin: StorePlugin | LegacyStorePlugin;
 }
 
-const classNames = (...classes: string[]) => {
-  return classes.join(' ');
-};
-
-function isLegacyPlugin(plugin: LegacyStorePlugin | StorePlugin): plugin is LegacyStorePlugin {
-  return 'artifact' in plugin;
-}
-
 const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
   const [selectedOption, setSelectedOption] = useState<number>(0);
   const buttonRef = useRef<HTMLDivElement>(null);
@@ -44,7 +38,7 @@ const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
     >
       {/* TODO: abstract this messy focus hackiness into a custom component in lib */}
       <Focusable
-        // className="Panel Focusable"
+        className="deckyStoreCard"
         ref={containerRef}
         onActivate={(_: CustomEvent) => {
           buttonRef.current!.focus();
@@ -68,15 +62,17 @@ const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
           boxSizing: 'border-box',
         }}
       >
-        <div style={{ display: 'flex', alignItems: 'center' }}>
+        <div className="deckyStoreCardHeader" style={{ display: 'flex', alignItems: 'center' }}>
           <a
             style={{ fontSize: '18pt', padding: '10px' }}
-            className={classNames(staticClasses.Text)}
+            className={joinClassNames(staticClasses.Text)}
             // onClick={() => Router.NavigateToExternalWeb('https://github.com/' + plugin.artifact)}
           >
             {isLegacyPlugin(plugin) ? (
-              <div>
-                <span style={{ color: 'grey' }}>{plugin.artifact.split('/')[0]}/</span>
+              <div className="deckyStoreCardNameContainer">
+                <span className="deckyStoreCardLegacyRepoOwner" style={{ color: 'grey' }}>
+                  {plugin.artifact.split('/')[0]}/
+                </span>
                 {plugin.artifact.split('/')[1]}
               </div>
             ) : (
@@ -89,8 +85,10 @@ const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
             display: 'flex',
             flexDirection: 'row',
           }}
+          className="deckyStoreCardBody"
         >
           <SuspensefulImage
+            className="deckyStoreCardImage"
             suspenseWidth="256px"
             style={{
               width: 'auto',
@@ -113,17 +111,26 @@ const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
               display: 'flex',
               flexDirection: 'column',
             }}
+            className="deckyStoreCardInfo"
           >
-            <p className={classNames(staticClasses.PanelSectionRow)}>
+            <p className={joinClassNames(staticClasses.PanelSectionRow)}>
               <span>Author: {plugin.author}</span>
             </p>
-            <p className={classNames(staticClasses.PanelSectionRow)}>
-              <span>Tags:</span>
+            <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',
-                    marginRight: '10px',
                     borderRadius: '5px',
                     background: tag == 'root' ? '#842029' : '#ACB2C947',
                   }}
@@ -133,10 +140,10 @@ const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
               ))}
               {isLegacyPlugin(plugin) && (
                 <span
+                  className="deckyStoreCardTag deckyStoreCardLegacyTag"
                   style={{
                     color: '#232120',
                     padding: '5px',
-                    marginRight: '10px',
                     borderRadius: '5px',
                     background: '#EDE841',
                   }}
@@ -148,6 +155,7 @@ const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
           </div>
         </div>
         <div
+          className="deckyStoreCardActionsContainer"
           style={{
             width: '100%',
             alignSelf: 'flex-end',
@@ -156,6 +164,7 @@ const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
           }}
         >
           <Focusable
+            className="deckyStoreCardActions"
             style={{
               display: 'flex',
               flexDirection: 'row',
@@ -163,22 +172,25 @@ const PluginCard: FC<PluginCardProps> = ({ plugin }) => {
             }}
           >
             <div
+              className="deckyStoreCardInstallButtonContainer"
               style={{
                 flex: '1',
               }}
             >
               <DialogButton
+                className="deckyStoreCardInstallButton"
                 ref={buttonRef}
                 onClick={() =>
                   isLegacyPlugin(plugin)
                     ? requestLegacyPluginInstall(plugin, Object.keys(plugin.versions)[selectedOption])
-                    : requestPluginInstall(plugin, plugin.versions[selectedOption])
+                    : requestPluginInstall(plugin.name, plugin.versions[selectedOption])
                 }
               >
                 Install
               </DialogButton>
             </div>
             <div
+              className="deckyStoreCardVersionDropdownContainer"
               style={{
                 flex: '0.2',
               }}

frontend/src/components/store/Store.tsx

@@ -1,111 +1,21 @@
-import { ModalRoot, SteamSpinner, showModal, staticClasses } from 'decky-frontend-lib';
+import { SteamSpinner } from 'decky-frontend-lib';
 import { FC, useEffect, useState } from 'react';
 
+import { LegacyStorePlugin, StorePlugin, getLegacyPluginList, getPluginList } from '../../store';
 import PluginCard from './PluginCard';
 
-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[];
-}
-
-export async function installFromURL(url: string) {
-  const formData = new FormData();
-  const splitURL = url.split('/');
-  formData.append('name', splitURL[splitURL.length - 1].replace('.zip', ''));
-  formData.append('artifact', url);
-  await fetch('http://localhost:1337/browser/install_plugin', {
-    method: 'POST',
-    body: formData,
-    credentials: 'include',
-    headers: {
-      Authentication: window.deckyAuthToken,
-    },
-  });
-}
-
-export function requestLegacyPluginInstall(plugin: LegacyStorePlugin, selectedVer: string) {
-  showModal(
-    <ModalRoot
-      onOK={() => {
-        const formData = new FormData();
-        formData.append('name', plugin.artifact);
-        formData.append('artifact', `https://github.com/${plugin.artifact}/archive/refs/tags/${selectedVer}.zip`);
-        formData.append('version', selectedVer);
-        formData.append('hash', plugin.versions[selectedVer]);
-        fetch('http://localhost:1337/browser/install_plugin', {
-          method: 'POST',
-          body: formData,
-          credentials: 'include',
-          headers: {
-            Authentication: window.deckyAuthToken,
-          },
-        });
-      }}
-      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.
-    </ModalRoot>,
-  );
-}
-
-export async function requestPluginInstall(plugin: StorePlugin, selectedVer: StorePluginVersion) {
-  const formData = new FormData();
-  formData.append('name', plugin.name);
-  formData.append('artifact', `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/versions/${selectedVer.hash}.zip`);
-  formData.append('version', selectedVer.name);
-  formData.append('hash', selectedVer.hash);
-  await fetch('http://localhost:1337/browser/install_plugin', {
-    method: 'POST',
-    body: formData,
-    credentials: 'include',
-    headers: {
-      Authentication: window.deckyAuthToken,
-    },
-  });
-}
-
 const StorePage: FC<{}> = () => {
   const [data, setData] = useState<StorePlugin[] | null>(null);
   const [legacyData, setLegacyData] = useState<LegacyStorePlugin[] | null>(null);
 
   useEffect(() => {
     (async () => {
-      const res = await fetch('https://beta.deckbrew.xyz/plugins', {
-        method: 'GET',
-      }).then((r) => r.json());
+      const res = await getPluginList();
       console.log(res);
-      setData(res.filter((x: StorePlugin) => x.name !== 'Example Plugin'));
+      setData(res);
     })();
     (async () => {
-      const res = await fetch('https://plugins.deckbrew.xyz/get_plugins', {
-        method: 'GET',
-      }).then((r) => r.json());
+      const res = await getLegacyPluginList();
       console.log(res);
       setLegacyData(res);
     })();

frontend/src/index.tsx

@@ -1,4 +1,5 @@
-import { sleep } from 'decky-frontend-lib';
+import { ButtonItem, CommonUIModule, webpackCache } from 'decky-frontend-lib';
+import { forwardRef } from 'react';
 
 import PluginLoader from './plugin-loader';
 import { DeckyUpdater } from './updater';
@@ -11,18 +12,40 @@ declare global {
     syncDeckyPlugins: Function;
     deckyHasLoaded: boolean;
     deckyAuthToken: string;
+    webpackJsonp: any;
   }
 }
+
+// HACK to fix plugins using webpack v4 push
+
+const v4Cache = {};
+for (let m of Object.keys(webpackCache)) {
+  v4Cache[m] = { exports: webpackCache[m] };
+}
+
+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} />;
+  });
+}
+
 (async () => {
-  await sleep(1000);
   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) {
-    window.DeckyPluginLoader?.importPlugin(name);
+  window.importDeckyPlugin = function (name: string, version: string) {
+    window.DeckyPluginLoader?.importPlugin(name, version);
   };
 
   window.syncDeckyPlugins = async function () {
@@ -33,11 +56,11 @@ declare global {
       })
     ).json();
     for (const plugin of plugins) {
-      if (!window.DeckyPluginLoader.hasPlugin(plugin)) window.DeckyPluginLoader?.importPlugin(plugin);
+      if (!window.DeckyPluginLoader.hasPlugin(plugin.name))
+        window.DeckyPluginLoader?.importPlugin(plugin.name, plugin.version);
     }
+    window.DeckyPluginLoader.checkPluginUpdates();
   };
 
   setTimeout(() => window.syncDeckyPlugins(), 5000);
-
-  window.deckyHasLoaded = true;
 })();

frontend/src/plugin-loader.tsx

@@ -1,9 +1,10 @@
-import { ModalRoot, QuickAccessTab, showModal, staticClasses } from 'decky-frontend-lib';
+import { ModalRoot, QuickAccessTab, Router, showModal, sleep, staticClasses } from 'decky-frontend-lib';
 import { FaPlug } from 'react-icons/fa';
 
-import { DeckyState, DeckyStateContextProvider } from './components/DeckyState';
+import { DeckyState, DeckyStateContextProvider, useDeckyState } from './components/DeckyState';
 import LegacyPlugin from './components/LegacyPlugin';
 import PluginInstallModal from './components/modals/PluginInstallModal';
+import NotificationBadge from './components/NotificationBadge';
 import PluginView from './components/PluginView';
 import SettingsPage from './components/settings';
 import StorePage from './components/store/Store';
@@ -11,6 +12,7 @@ import TitleView from './components/TitleView';
 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';
@@ -29,12 +31,17 @@ class PluginLoader extends Logger {
 
   private reloadLock: boolean = false;
   // stores a list of plugin names which requested to be reloaded
-  private pluginReloadQueue: string[] = [];
+  private pluginReloadQueue: { name: string; version?: string }[] = [];
 
   constructor() {
     super(PluginLoader.name);
     this.log('Initialized');
 
+    const TabIcon = () => {
+      const { updates, hasLoaderUpdate } = useDeckyState();
+      return <NotificationBadge show={(updates && updates.size > 0) || hasLoaderUpdate} />;
+    };
+
     this.tabsHook.add({
       id: QuickAccessTab.Decky,
       title: null,
@@ -44,7 +51,14 @@ class PluginLoader extends Logger {
           <PluginView />
         </DeckyStateContextProvider>
       ),
-      icon: <FaPlug />,
+      icon: (
+        <DeckyStateContextProvider deckyState={this.deckyState}>
+          <>
+            <FaPlug />
+            <TabIcon />
+          </>
+        </DeckyStateContextProvider>
+      ),
     });
 
     this.routerHook.addRoute('/decky/store', () => <StorePage />);
@@ -62,7 +76,28 @@ class PluginLoader extends Logger {
     if (versionInfo?.remote && versionInfo?.remote?.tag_name != versionInfo?.current) {
       this.toaster.toast({
         title: 'Decky',
-        body: `Update to ${versionInfo?.remote?.tag_name} availiable!`,
+        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'),
       });
     }
   }
@@ -128,10 +163,10 @@ class PluginLoader extends Logger {
     this.deckyState.setPlugins(this.plugins);
   }
 
-  public async importPlugin(name: string) {
+  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);
+      this.pluginReloadQueue.push({ name, version: version });
       return;
     }
 
@@ -144,7 +179,7 @@ class PluginLoader extends Logger {
       if (name.startsWith('$LEGACY_')) {
         await this.importLegacyPlugin(name.replace('$LEGACY_', ''));
       } else {
-        await this.importReactPlugin(name);
+        await this.importReactPlugin(name, version);
       }
 
       this.deckyState.setPlugins(this.plugins);
@@ -155,12 +190,12 @@ class PluginLoader extends Logger {
       this.reloadLock = false;
       const nextPlugin = this.pluginReloadQueue.shift();
       if (nextPlugin) {
-        this.importPlugin(nextPlugin);
+        this.importPlugin(nextPlugin.name, nextPlugin.version);
       }
     }
   }
 
-  private async importReactPlugin(name: string) {
+  private async importReactPlugin(name: string, version?: string) {
     let res = await fetch(`http://127.0.0.1:1337/plugins/${name}/frontend_bundle`, {
       credentials: 'include',
       headers: {
@@ -172,6 +207,7 @@ class PluginLoader extends Logger {
       this.plugins.push({
         ...plugin,
         name: name,
+        version: version,
       });
     } else throw new Error(`${name} frontend_bundle not OK`);
   }

frontend/src/plugin.ts

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

frontend/src/router-hook.tsx

@@ -1,6 +1,6 @@
 import { afterPatch, findModuleChild, unpatch } from 'decky-frontend-lib';
-import { ReactElement, createElement, memo } from 'react';
-import type { Route, RouteProps } from 'react-router';
+import { ReactElement, ReactNode, cloneElement, createElement, memo } from 'react';
+import type { Route } from 'react-router';
 
 import {
   DeckyRouterState,
@@ -40,7 +40,7 @@ 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, Route>();
+    let toReplace = new Map<string, ReactNode>();
     const DeckyWrapper = ({ children }: { children: ReactElement }) => {
       const { routes, routePatches } = useDeckyRouterState();
 
@@ -62,17 +62,24 @@ class RouterHook extends Logger {
       routeList.forEach((route: Route, index: number) => {
         const replaced = toReplace.get(route?.props?.path as string);
         if (replaced) {
-          routeList[index] = 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
-            createElement(routeList[index].type, routeList[index].props, routeList[index].props.children),
+            routeList[index].props.children,
           );
           routePatches.get(route.props.path as string)?.forEach((patch) => {
-            routeList[index].props = patch(routeList[index].props);
+            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;
           });
         }
       });

frontend/src/store.tsx

@@ -0,0 +1,121 @@
+import { ModalRoot, 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 formData = new FormData();
+  const splitURL = url.split('/');
+  formData.append('name', splitURL[splitURL.length - 1].replace('.zip', ''));
+  formData.append('artifact', url);
+  await fetch('http://localhost:1337/browser/install_plugin', {
+    method: 'POST',
+    body: formData,
+    credentials: 'include',
+    headers: {
+      Authentication: window.deckyAuthToken,
+    },
+  });
+}
+
+export function requestLegacyPluginInstall(plugin: LegacyStorePlugin, selectedVer: string) {
+  showModal(
+    <ModalRoot
+      onOK={() => {
+        const formData = new FormData();
+        formData.append('name', plugin.artifact);
+        formData.append('artifact', `https://github.com/${plugin.artifact}/archive/refs/tags/${selectedVer}.zip`);
+        formData.append('version', selectedVer);
+        formData.append('hash', plugin.versions[selectedVer]);
+        fetch('http://localhost:1337/browser/install_plugin', {
+          method: 'POST',
+          body: formData,
+          credentials: 'include',
+          headers: {
+            Authentication: window.deckyAuthToken,
+          },
+        });
+      }}
+      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.
+    </ModalRoot>,
+  );
+}
+
+export async function requestPluginInstall(plugin: string, selectedVer: StorePluginVersion) {
+  const formData = new FormData();
+  formData.append('name', plugin);
+  formData.append('artifact', `https://cdn.tzatzikiweeb.moe/file/steam-deck-homebrew/versions/${selectedVer.hash}.zip`);
+  formData.append('version', selectedVer.name);
+  formData.append('hash', selectedVer.hash);
+  await fetch('http://localhost:1337/browser/install_plugin', {
+    method: 'POST',
+    body: formData,
+    credentials: 'include',
+    headers: {
+      Authentication: window.deckyAuthToken,
+    },
+  });
+}
+
+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

@@ -103,7 +103,7 @@ class TabsHook extends Logger {
   }
 
   deinit() {
-    unpatch(this.cNode.stateNode, 'render');
+    if (this.cNode) unpatch(this.cNode.stateNode, 'render');
     if (this.qAPTree) this.qAPTree.type = this.quickAccess;
     if (this.rendererTree) this.rendererTree.type = this.tabRenderer;
     if (this.cNode) this.cNode.stateNode.forceUpdate();

frontend/src/toaster.tsx

@@ -35,7 +35,7 @@ class Toaster extends Logger {
     while (true) {
       instance = findInReactTree(
         (document.getElementById('root') as any)._reactRootContainer._internalRoot.current,
-        (x) => x?.memoizedProps?.className?.startsWith('toastmanager_ToastPlaceholder'),
+        (x) => x?.memoizedProps?.className?.startsWith?.('toastmanager_ToastPlaceholder'),
       );
       if (instance) break;
       this.debug('finding instance');
@@ -84,9 +84,9 @@ class Toaster extends Logger {
   }
 
   deinit() {
-    unpatch(this.instanceRet, 'type');
-    delete this.node.stateNode.render;
-    this.node.stateNode.forceUpdate();
+    this.instanceRet && unpatch(this.instanceRet, 'type');
+    this.node && delete this.node.stateNode.render;
+    this.node && this.node.stateNode.forceUpdate();
   }
 }