fix: plugin load crash, debug toggle, and harden compat detection

Fix ModuleNotFoundError on load by adding the plugin dir (and py_modules) to
sys.path before importing compat_logic; the sandboxed loader doesn't put the
plugin root on the path, which crashed the whole backend and made all UI
options disappear.

Fix the verbose debug logging toggle never sticking: the imported
setDebugLogging API callable was shadowed by the useState setter of the same
name, so the handler called the setter (returning undefined) instead of the
backend. Alias the import to apiSetDebugLogging.

Resolve TLS CERTIFICATE_VERIFY_FAILED properly by building a verified SSL
context from the system CA bundle (certifi -> SSL_CERT_FILE -> common paths)
instead of silently falling back to an unverified context.

Ship a snapshot of the curated Compatibility-List with the plugin and fall
back to it when the live fetch fails (offline / HTTP 429), reporting
curated_source to the UI.

List only games that are actually installed on disk (skip leftover Steam
appmanifests), and replace the single "show compatible only" toggle with
independent Verified / Compatible filters.

Add an always-present "— Select a game —" placeholder as the default,
unfiltered first dropdown entry instead of auto-selecting the first game, so
the Verified/Compatible filters no longer keep an unrelated game pinned.

Bump to 0.16.2.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: codingadventures

README.md

@@ -19,7 +19,7 @@ This plugin uses OptiScaler to replace DLSS calls with FSR3/FSR3.1, giving you:
 - **Smart Installation**: Handles all required dependencies and library files
 - **Game Patching**: Easy copy-paste launch commands for enabling/disabling the mod per game
 - **GPU-Aware Defaults**: Detects your GPU and recommends the matching FSR4 runtime (RDNA4 native vs the RDNA2/3/3.5 INT8 override)
-- **Compatibility Marking**: Flags which installed games are OptiScaler compatible, with a "show compatible only" filter and a per-game manual override
+- **Compatibility Marking**: Flags which installed games are OptiScaler compatible, with independent **Verified** / **Compatible** filters and a per-game manual override
 - **OptiScaler Wiki**: Direct access to OptiScaler documentation and settings via a webpage launch button right inside the plugin.
 
 ### Supported Devices
@@ -41,7 +41,9 @@ OptiScaler works by hooking a game's existing upscaler, so it mainly benefits ti
 - **Unknown**: no signal either way. Not shown as a badge in the game list to keep it readable; visible in the compatibility detail field for the selected game.
 - **Not compatible**: you manually marked it as such via the override. Also hidden from the list/badges.
 
-Manually marking a game **Compatible** or **Not compatible** always takes priority over the automatic detection. Use the **Show compatible only** toggle to filter the game dropdown to Verified/Compatible titles, and the **Compatibility override** dropdown to force a per-game result. Detection is best-effort and cached; the curated list is fetched once a day and everything still works offline via the local scan. If the curated list can't be fetched (for example due to an outdated CA certificate bundle on some SteamOS images), games can still be marked **Compatible** by the local scan, and the toggle description will say so.
+Only games that are actually installed on disk are listed (Steam's leftover `appmanifest` entries for removed games are skipped). Manually marking a game **Compatible** or **Not compatible** always takes priority over the automatic detection. Use the **Filter: Verified** and **Filter: Compatible** toggles to narrow the game dropdown (with neither enabled, every installed game is shown), and the **Compatibility override** dropdown to force a per-game result.
+
+Detection is best-effort and cached. The curated list is fetched over a verified TLS connection (using the system CA bundle) at most once a day; a snapshot of the list also **ships with the plugin**, so Verified marking keeps working offline or when GitHub rate-limits the request (HTTP 429). If the live list can't be fetched, the plugin transparently falls back to the bundled snapshot and the filter description notes it. Even with no curated list at all, games can still be marked **Compatible** by the local DLL scan.
 
 > **Note:** The game list and compatibility marking cover your **Steam library** only (they read Steam's `appmanifest` files). Games installed through Heroic (Epic/GOG/Amazon) or Lutris won't appear in the dropdown, but you can still patch them manually with the `~/fgmod/fgmod %command%` wrapper (the launcher script includes Lutris resolution).
 

defaults/Compatibility-List.md

@@ -1,5 +1,6 @@
 import decky
 import os
+import sys
 import subprocess
 import json
 import shutil
@@ -14,6 +15,16 @@
 from datetime import datetime, timezone
 from pathlib import Path
 
+# Decky's sandboxed plugin loader does not put the plugin root directory on
+# sys.path (only py_modules), so a bare `from compat_logic import ...` fails at
+# load time with ModuleNotFoundError. Add both this file's directory and its
+# py_modules subdir to sys.path so the helper module resolves no matter where it
+# ends up in the bundle.
+_PLUGIN_DIR = os.path.dirname(os.path.abspath(__file__))
+for _candidate in (_PLUGIN_DIR, os.path.join(_PLUGIN_DIR, "py_modules")):
+    if _candidate not in sys.path:
+        sys.path.insert(0, _candidate)
+
 from compat_logic import (
     classify_amd_gpu,
     classify_game_compat,
@@ -264,6 +275,7 @@
     "https://raw.githubusercontent.com/wiki/optiscaler/OptiScaler/Compatibility-List.md"
 )
 CURATED_CACHE_FILENAME = "compat-curated-cache.json"
+BUNDLED_CURATED_FILENAME = "Compatibility-List.md"
 SCAN_CACHE_FILENAME = "compat-scan-cache.json"
 OVERRIDES_FILENAME = "compat-overrides.json"
 CURATED_CACHE_TTL_SECONDS = 24 * 60 * 60  # refresh at most once a day
@@ -1620,10 +1632,15 @@ async def list_installed_games(self) -> dict:
             games = []
             for game in self._find_installed_games():
                 install_root = Path(game["install_path"])
+                # Steam keeps appmanifest files around for games that are no
+                # longer on disk; skip those so the list only shows games that
+                # are actually installed and patchable.
+                if not install_root.exists():
+                    continue
                 games.append({
                     "appid": str(game["appid"]),
                     "name": game["name"],
-                    "install_found": install_root.exists(),
+                    "install_found": True,
                 })
             return {"status": "success", "games": games}
         except Exception as e:
@@ -1954,29 +1971,88 @@ def _save_scan_cache(self, cache: dict) -> None:
     def _parse_curated_markdown(self, raw: str) -> set[str]:
         return parse_curated_markdown(raw)
 
+    def _resolve_ca_bundle(self) -> str | None:
+        """Find a usable CA bundle. Decky's Python often can't locate one on
+        SteamOS (its compiled-in OpenSSL path doesn't match the distro), which
+        is what causes CERTIFICATE_VERIFY_FAILED. Prefer certifi if bundled,
+        then the well-known system locations (SteamOS/Arch, Fedora, BSD)."""
+        try:
+            import certifi  # optional; only present if bundled in py_modules
+
+            path = certifi.where()
+            if path and os.path.exists(path):
+                return path
+        except Exception:
+            pass
+        for candidate in (
+            os.environ.get("SSL_CERT_FILE"),
+            "/etc/ssl/certs/ca-certificates.crt",  # SteamOS / Arch / Debian
+            "/etc/pki/tls/certs/ca-bundle.crt",    # Fedora / RHEL
+            "/etc/ssl/cert.pem",                    # BSD / some minimal images
+        ):
+            if candidate and os.path.exists(candidate):
+                return candidate
+        return None
+
+    def _make_ssl_context(self) -> ssl.SSLContext:
+        ca_bundle = self._resolve_ca_bundle()
+        if ca_bundle:
+            try:
+                return ssl.create_default_context(cafile=ca_bundle)
+            except Exception as exc:
+                decky.logger.debug(f"[Framegen] failed to load CA bundle {ca_bundle}: {exc}")
+        return ssl.create_default_context()
+
     def _fetch_curated_markdown(self) -> str:
-        """Fetch the curated compat markdown, retrying with a relaxed SSL
-        context if the default one fails to verify. SteamOS's bundled Python
-        can ship an incomplete CA bundle, which otherwise fails every call
-        silently and leaves every game looking "Unknown"."""
+        """Fetch the curated compat markdown. Uses a verified TLS context backed
+        by the system CA bundle; only if verification still fails does it retry
+        with an unverified context as a last resort (SteamOS's bundled Python
+        can otherwise fail every call and leave every game looking "Unknown")."""
         request = urllib.request.Request(
             CURATED_COMPAT_URL, headers={"User-Agent": "Decky-Framegen"}
         )
         try:
-            with urllib.request.urlopen(request, timeout=10) as response:
+            context = self._make_ssl_context()
+            with urllib.request.urlopen(request, timeout=10, context=context) as response:
                 return response.read().decode("utf-8", errors="replace")
         except urllib.error.URLError as exc:
             reason = getattr(exc, "reason", exc)
             if not isinstance(reason, ssl.SSLCertVerificationError) and "CERTIFICATE_VERIFY_FAILED" not in str(reason):
                 raise
             decky.logger.warning(
                 f"[Framegen] curated compat TLS verification failed ({reason}); "
-                "retrying with an unverified context. Consider updating system CA certificates."
+                "no usable CA bundle found, retrying with an unverified context. "
+                "Consider updating system CA certificates."
             )
             unverified_context = ssl._create_unverified_context()
             with urllib.request.urlopen(request, timeout=10, context=unverified_context) as response:
                 return response.read().decode("utf-8", errors="replace")
 
+    def _bundled_curated_path(self) -> Path | None:
+        """Locate the curated list snapshot bundled with the plugin. On device
+        the contents of defaults/ are extracted next to main.py; in the repo it
+        lives under defaults/."""
+        for candidate in (
+            Path(_PLUGIN_DIR) / BUNDLED_CURATED_FILENAME,
+            Path(_PLUGIN_DIR) / "defaults" / BUNDLED_CURATED_FILENAME,
+        ):
+            if candidate.exists():
+                return candidate
+        return None
+
+    def _load_bundled_curated(self) -> dict:
+        path = self._bundled_curated_path()
+        if not path:
+            return {}
+        try:
+            raw = path.read_text(encoding="utf-8", errors="replace")
+            names = self._parse_curated_markdown(raw)
+            if names:
+                return {"fetched_at": 0, "names": sorted(names), "count": len(names), "bundled": True}
+        except Exception as exc:
+            decky.logger.warning(f"[Framegen] bundled curated list read failed: {exc}")
+        return {}
+
     def _load_curated_compat(self, force_refresh: bool = False) -> dict:
         cache_path = self._fgmod_data_dir() / CURATED_CACHE_FILENAME
         cached = self._read_json_file(cache_path)
@@ -1999,7 +2075,20 @@ def _load_curated_compat(self, force_refresh: bool = False) -> dict:
             decky.logger.warning(f"[Framegen] curated compat fetch failed: {exc}")
             cached = dict(cached)
             cached["last_error"] = str(exc)
-        return cached if cached.get("names") else {"fetched_at": 0, "names": [], "count": 0, "last_error": cached.get("last_error")}
+        if cached.get("names"):
+            return cached
+        # Network fetch failed and there's no usable cache: fall back to the
+        # snapshot bundled with the plugin so games can still be Verified while
+        # offline or rate-limited (HTTP 429).
+        bundled = self._load_bundled_curated()
+        if bundled.get("names"):
+            decky.logger.info(
+                f"[Framegen] using bundled curated list ({bundled['count']} entries) as fallback"
+            )
+            if cached.get("last_error"):
+                bundled["last_error"] = cached["last_error"]
+            return bundled
+        return {"fetched_at": 0, "names": [], "count": 0, "last_error": cached.get("last_error")}
 
     def _load_overrides(self) -> dict:
         return self._read_json_file(self._fgmod_data_dir() / OVERRIDES_FILENAME)
@@ -2040,6 +2129,8 @@ async def list_games_compatibility(self, force_refresh: bool = False) -> dict:
                 name = game["name"]
                 install_path = Path(game["install_path"]) if game.get("install_path") else None
                 install_found = bool(install_path and install_path.exists())
+                if not install_found:
+                    continue
 
                 upscalers: list[str] = []
                 if install_found:
@@ -2099,6 +2190,7 @@ async def list_games_compatibility(self, force_refresh: bool = False) -> dict:
                 "games": results,
                 "curated_count": curated.get("count", len(curated_names)),
                 "curated_available": bool(curated_names),
+                "curated_source": "bundled" if curated.get("bundled") else ("live" if curated_names else "none"),
                 "curated_error": curated.get("last_error"),
             }
         except Exception as exc:

main.py

@@ -1,6 +1,6 @@
 {
   "name": "decky-framegen",
-  "version": "0.16.1",
+  "version": "0.16.2",
   "description": "This plugin installs and manages OptiScaler, a tool that enhances upscaling and enables frame generation in a range of DirectX 12 games.",
   "type": "module",
   "scripts": {

package.json

@@ -76,6 +76,7 @@ export const listGamesCompatibility = callable<
     games: GameCompat[];
     curated_count?: number;
     curated_available?: boolean;
+    curated_source?: "live" | "bundled" | "none";
     curated_error?: string | null;
   }
 >("list_games_compatibility");

src/api/index.ts

@@ -1,6 +1,6 @@
 import { useState, useEffect } from "react";
 import { DropdownItem, Field, PanelSection, PanelSectionRow, ToggleField } from "@decky/ui";
-import { runInstallFGMod, runUninstallFGMod, setDefaultFsr4Variant, detectGpu, getDebugLogging, setDebugLogging } from "../api";
+import { runInstallFGMod, runUninstallFGMod, setDefaultFsr4Variant, detectGpu, getDebugLogging, setDebugLogging as apiSetDebugLogging } from "../api";
 import { OperationResult } from "./ResultDisplay";
 import { createAutoCleanupTimer } from "../utils";
 import { TIMEOUTS, PROXY_DLL_OPTIONS, DEFAULT_PROXY_DLL, FSR4_VARIANT_OPTIONS, DEFAULT_FSR4_VARIANT } from "../utils/constants";
@@ -174,7 +174,7 @@ export function OptiScalerControls({ pathExists, setPathExists, fgmodInfo }: Opt
     setDebugLogging(enabled);
     setDebugLoggingBusy(true);
     try {
-      const result = await setDebugLogging(enabled);
+      const result = await apiSetDebugLogging(enabled);
       if (result.status !== "success") throw new Error(result.message || "Failed to update debug logging.");
       setDebugLogging(Boolean(result.enabled));
       if (result.log_path) setDebugLogPath(result.log_path);

src/components/OptiScalerControls.tsx

@@ -109,7 +109,9 @@ export function SteamGamePatcher({ dllName, fsr4Variant }: SteamGamePatcherProps
   const [compatMap, setCompatMap] = useState<Record<string, GameCompat>>({});
   const [compatLoading, setCompatLoading] = useState(true);
   const [curatedError, setCuratedError] = useState<string | null>(null);
-  const [showCompatibleOnly, setShowCompatibleOnly] = useState(false);
+  const [curatedBundled, setCuratedBundled] = useState(false);
+  const [filterVerified, setFilterVerified] = useState(false);
+  const [filterCompatible, setFilterCompatible] = useState(false);
   const [overrideBusy, setOverrideBusy] = useState(false);
 
   // ── Data loaders ───────────────────────────────────────────────────────────
@@ -123,6 +125,7 @@ export function SteamGamePatcher({ dllName, fsr4Variant }: SteamGamePatcherProps
         for (const entry of result.games) map[entry.appid] = entry;
         setCompatMap(map);
         setCuratedError(result.curated_available ? null : result.curated_error || null);
+        setCuratedBundled(result.curated_source === "bundled");
       }
     } catch (err) {
       // non-fatal: compatibility hints are best-effort
@@ -144,9 +147,10 @@ export function SteamGamePatcher({ dllName, fsr4Variant }: SteamGamePatcherProps
         setSelectedAppId("");
         return;
       }
+      // Default to the "— Select a game —" placeholder rather than auto-picking
+      // the first game, so nothing is forced into the filtered list.
       setSelectedAppId((current) => {
-        const valid =
-          current && gameList.some((g) => g.appid === current) ? current : gameList[0].appid;
+        const valid = current && gameList.some((g) => g.appid === current) ? current : "";
         lastSelectedAppId = valid;
         return valid;
       });
@@ -203,13 +207,17 @@ export function SteamGamePatcher({ dllName, fsr4Variant }: SteamGamePatcherProps
   );
 
   const visibleGames = useMemo(() => {
-    if (!showCompatibleOnly) return games;
+    // No filter selected → show every installed game.
+    if (!filterVerified && !filterCompatible) return games;
     return games.filter((g) => {
       const compat = compatMap[g.appid]?.compat;
       // Always keep the current selection visible so it doesn't vanish.
-      return g.appid === selectedAppId || (compat && BADGE_WORTHY_COMPAT.has(compat));
+      if (g.appid === selectedAppId) return true;
+      if (filterVerified && compat === "verified") return true;
+      if (filterCompatible && compat === "compatible") return true;
+      return false;
     });
-  }, [games, compatMap, showCompatibleOnly, selectedAppId]);
+  }, [games, compatMap, filterVerified, filterCompatible, selectedAppId]);
 
   const selectedVariantLabel = useMemo(
     () => FSR4_VARIANT_OPTIONS.find((option) => option.value === fsr4Variant)?.label ?? fsr4Variant,
@@ -322,16 +330,31 @@ export function SteamGamePatcher({ dllName, fsr4Variant }: SteamGamePatcherProps
     <>
       <PanelSectionRow>
         <ToggleField
-          label="Show compatible only"
+          label="Filter: Verified"
           description={
             compatLoading
-              ? "Scanning games for DLSS / FSR / XeSS..."
+              ? "Loading curated compatibility list..."
               : curatedError
-              ? `Filter to Verified/Compatible games. Curated list unavailable: ${curatedError}`
-              : "Filter to games Verified via the curated list or detected as Compatible."
+              ? `On the OptiScaler curated list. Curated list unavailable: ${curatedError}`
+              : curatedBundled
+              ? "On the OptiScaler curated list (using bundled snapshot; live list unavailable)."
+              : "Show only games on the OptiScaler curated list."
+          }
+          checked={filterVerified}
+          onChange={setFilterVerified}
+        />
+      </PanelSectionRow>
+
+      <PanelSectionRow>
+        <ToggleField
+          label="Filter: Compatible"
+          description={
+            compatLoading
+              ? "Scanning games for DLSS / FSR / XeSS..."
+              : "Show only games with DLSS / FSR / XeSS files detected on disk."
           }
-          checked={showCompatibleOnly}
-          onChange={setShowCompatibleOnly}
+          checked={filterCompatible}
+          onChange={setFilterCompatible}
         />
       </PanelSectionRow>
 
@@ -340,15 +363,19 @@ export function SteamGamePatcher({ dllName, fsr4Variant }: SteamGamePatcherProps
           layout="below"
           label="Steam game"
           menuLabel="Select a Steam game"
-          strDefaultLabel={gamesLoading ? "Loading games..." : "Choose a game"}
-          disabled={gamesLoading || visibleGames.length === 0}
+          strDefaultLabel={gamesLoading ? "Loading games..." : "— Select a game —"}
+          disabled={gamesLoading}
           selectedOption={selectedAppId}
-          rgOptions={visibleGames.map((g) => {
-            const compat = compatMap[g.appid]?.compat;
-            const badge = compat && BADGE_WORTHY_COMPAT.has(compat) ? ` - ${COMPAT_META[compat].short}` : "";
-            const base = g.install_found === false ? `${g.name} (not installed)` : g.name;
-            return { data: g.appid, label: `${base}${badge}` };
-          })}
+          rgOptions={[
+            // Always-present placeholder so the dropdown has a stable, unfiltered
+            // first entry even when the Verified/Compatible filters hide games.
+            { data: "", label: "— Select a game —" },
+            ...visibleGames.map((g) => {
+              const compat = compatMap[g.appid]?.compat;
+              const badge = compat && BADGE_WORTHY_COMPAT.has(compat) ? ` - ${COMPAT_META[compat].short}` : "";
+              return { data: g.appid, label: `${g.name}${badge}` };
+            }),
+          ]}
           onChange={(option) => {
             const next = String(option.data);
             lastSelectedAppId = next;