fix(playnite): trust IPC when reporting plugin status

Disconnected or signed-out RDP sessions can keep the Playnite connector
alive, but the status API treated a failed per-user extension-path lookup
as proof that the plugin was missing. That led the dashboard to tell users
to reinstall the plugin even while IPC connectivity and sync still worked.

Treat an active Playnite IPC connection as authoritative evidence that the
plugin is installed, fall back to the extension file check only when IPC is
inactive, and return an unknown install state when neither check can verify
it. Update the Playnite UI flows to prefer active connectivity and only show
missing-plugin recovery when the backend explicitly reports uninstalled.

Generated with [Codex](https://openai.com/index/introducing-gpt-5-3-codex/)

Model: GPT-5.4 X-High
(cherry picked from commit 692a9f637f55f2aa4a085af1bcbafb06918b20fa)

Author: Nonary

src/confighttp_playnite.cpp

@@ -60,18 +60,32 @@ namespace confighttp {
   void bad_request(resp_https_t response, req_https_t request, const std::string &error_message = "Bad Request");
   bool check_content_type(resp_https_t response, req_https_t request, const std::string_view &contentType);
 
-  // Helper: check if the Sunshine Playnite plugin is installed (by presence of files)
-  static bool is_plugin_installed() {
+  struct playnite_install_state_t {
+    std::optional<bool> installed;
+    std::filesystem::path extensions_dir;
+  };
+
+  // Helper: determine whether the Playnite plugin is installed.
+  // An active IPC connection is authoritative proof that the plugin is loaded,
+  // even if the current service context cannot resolve the user's extension path.
+  static playnite_install_state_t query_plugin_install_state(bool active) {
+    playnite_install_state_t state;
     try {
       std::string destPath;
-      if (!platf::playnite::get_extension_target_dir(destPath)) {
-        return false;
+      if (platf::playnite::get_extension_target_dir(destPath)) {
+        state.extensions_dir = destPath;
+        state.installed =
+          std::filesystem::exists(state.extensions_dir / "extension.yaml") &&
+          std::filesystem::exists(state.extensions_dir / "SunshinePlaynite.psm1");
+      } else if (active) {
+        state.installed = true;
       }
-      std::filesystem::path dest = destPath;
-      return std::filesystem::exists(dest / "extension.yaml") && std::filesystem::exists(dest / "SunshinePlaynite.psm1");
     } catch (...) {
-      return false;
+      if (active) {
+        state.installed = true;
+      }
     }
+    return state;
   }
 
   // Enhance app JSON with a Playnite-derived cover path when applicable.
@@ -101,22 +115,19 @@ namespace confighttp {
     platf::playnite::ensure_client_for_api();
     nlohmann::json out;
     // Active reflects current pipe/server connection only
-    out["active"] = platf::playnite::is_active();
+    const bool active = platf::playnite::is_active();
+    out["active"] = active;
     // Deprecated fields removed: playnite_running, installed_unknown
-    std::string destPath;
-    std::filesystem::path dest;
-    // Session requirement removed: IPC is available during RDP/lock; rely on Playnite process presence instead.
-    // Resolve the user's Playnite extensions directory via URL association.
-    // Requires user impersonation when running as SYSTEM.
-    if (platf::playnite::get_extension_target_dir(destPath)) {
-      dest = destPath;
-      bool installed = std::filesystem::exists(dest / "extension.yaml") && std::filesystem::exists(dest / "SunshinePlaynite.psm1");
-      out["installed"] = installed;
-      out["extensions_dir"] = dest.string();
+    // Session requirement removed: IPC is available during RDP/lock; rely on
+    // active IPC first, then fall back to per-user extension path resolution.
+    const auto install_state = query_plugin_install_state(active);
+    const auto &dest = install_state.extensions_dir;
+    if (install_state.installed.has_value()) {
+      out["installed"] = *install_state.installed;
     } else {
-      out["installed"] = false;
-      out["extensions_dir"] = std::string();
+      out["installed"] = nullptr;
     }
+    out["extensions_dir"] = dest.string();
     // Version info and update flag
     auto normalize_ver = [](std::string s) {
       // strip leading 'v' and whitespace
@@ -176,7 +187,7 @@ namespace confighttp {
       out["packaged_version"] = packaged_ver;
     }
     bool update_available = false;
-    if (out["installed"].get<bool>() && have_installed && have_packaged) {
+    if (out["installed"].is_boolean() && out["installed"].get<bool>() && have_installed && have_packaged) {
       update_available = semver_cmp(installed_ver, packaged_ver) < 0;
     }
     out["update_available"] = update_available;
@@ -198,7 +209,7 @@ namespace confighttp {
     }
     print_req(request);
     try {
-      if (!is_plugin_installed()) {
+      if (!query_plugin_install_state(platf::playnite::is_active()).installed.value_or(false)) {
         SimpleWeb::CaseInsensitiveMultimap headers;
         headers.emplace("Content-Type", "application/json");
         headers.emplace("X-Frame-Options", "DENY");
@@ -228,7 +239,7 @@ namespace confighttp {
     }
     print_req(request);
     try {
-      if (!is_plugin_installed()) {
+      if (!query_plugin_install_state(platf::playnite::is_active()).installed.value_or(false)) {
         SimpleWeb::CaseInsensitiveMultimap headers;
         headers.emplace("Content-Type", "application/json");
         headers.emplace("X-Frame-Options", "DENY");
@@ -258,7 +269,7 @@ namespace confighttp {
     }
     print_req(request);
     try {
-      if (!is_plugin_installed()) {
+      if (!query_plugin_install_state(platf::playnite::is_active()).installed.value_or(false)) {
         SimpleWeb::CaseInsensitiveMultimap headers;
         headers.emplace("Content-Type", "application/json");
         headers.emplace("X-Frame-Options", "DENY");

src_assets/common/assets/web/components/AppEditModal.vue

@@ -2466,7 +2466,8 @@ async function refreshPlayniteStatus() {
     const r = await http.get('/api/playnite/status', { validateStatus: () => true });
     if (r.status === 200 && r.data && typeof r.data === 'object' && r.data !== null) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      playniteInstalled.value = !!(r.data as any).installed;
+      const data = r.data as any;
+      playniteInstalled.value = data.installed === true || data.active === true;
     }
   } catch (_) {}
 }

src_assets/common/assets/web/configs/tabs/Playnite.vue

@@ -719,15 +719,15 @@ const platform = computed(() =>
 const { t } = useI18n();
 
 const status = reactive<{
-  installed: boolean;
+  installed: boolean | null;
   installed_unknown?: boolean;
   active: boolean;
   enabled?: boolean;
   playnite_running?: boolean;
   extensions_dir: string;
   plugin_version?: string;
   plugin_latest?: string;
-}>({ installed: false, active: false, extensions_dir: '' });
+}>({ installed: null, active: false, extensions_dir: '' });
 const launching = ref(false);
 const uninstalling = ref(false);
 const deletingAutosync = ref(false);
@@ -872,7 +872,7 @@ async function refreshStatus() {
     const r = await http.get('/api/playnite/status');
     if (r.status === 200 && r.data) {
       const d = r.data as any;
-      status.installed = !!d.installed;
+      status.installed = typeof d.installed === 'boolean' ? d.installed : null;
       status.active = !!d.active;
       // 'enabled' is no longer a config; presence is indicated by 'installed'
       if (typeof d.playnite_running === 'boolean') status.playnite_running = !!d.playnite_running;
@@ -1246,9 +1246,11 @@ onUnmounted(() => {
 });
 
 const statusKind = computed<'active' | 'waiting' | 'uninstalled' | 'unknown'>(() => {
+  if (status.active) return 'active';
   if (!status.extensions_dir) return 'unknown';
-  if (!status.installed) return 'uninstalled';
-  return status.active ? 'active' : 'waiting';
+  if (status.installed === false) return 'uninstalled';
+  if (status.installed === true) return 'waiting';
+  return 'unknown';
 });
 const statusType = computed<'success' | 'warning' | 'error' | 'default'>(() => {
   switch (statusKind.value) {
@@ -1300,12 +1302,12 @@ function cmpSemver(a?: string, b?: string): number {
 }
 
 const pluginOutdated = computed(() => {
-  if (!status.installed) return false;
+  if (status.installed !== true) return false;
   if (!status.plugin_version || !status.plugin_latest) return false;
   return cmpSemver(status.plugin_version, status.plugin_latest) < 0;
 });
 const canLaunch = computed(() => {
-  return !!(status.extensions_dir && status.installed && !status.active);
+  return !!(status.extensions_dir && status.installed === true && !status.active);
 });
 
 const statusTimer = ref<number | undefined>();

src_assets/common/assets/web/views/ApplicationsView.vue

@@ -256,7 +256,8 @@ async function fetchPlayniteStatus(): Promise<void> {
       'installed' in (r.data as Record<string, unknown>)
     ) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      playniteInstalled.value = !!(r.data as any).installed;
+      const data = r.data as any;
+      playniteInstalled.value = data.installed === true || data.active === true;
     }
   } catch {
     // ignore; will retry on next auth change

src_assets/common/assets/web/views/DashboardView.vue

@@ -495,7 +495,7 @@ const vigemInstalled = ref<boolean | null>(null);
 const vigemVersion = ref('');
 // Playnite extension status
 type PlayniteStatus = {
-  installed: boolean;
+  installed: boolean | null;
   active: boolean;
   extensions_dir?: string;
   installed_version?: string;
@@ -1023,7 +1023,7 @@ const hasPlayniteFullscreenApp = computed(() => {
 const showPlayniteMissingPluginBanner = computed(() => {
   const plat = (configStore.metadata?.platform || '').toLowerCase();
   if (plat !== 'windows') return false;
-  if (!playnite.value || playnite.value.installed !== false) return false;
+  if (!playnite.value || playnite.value.active === true || playnite.value.installed !== false) return false;
   return playniteAutoSyncedAppsCount.value > 0 || hasPlayniteFullscreenApp.value;
 });
 const playniteMissingPluginBannerText = computed(() => {