feat: update changelog for version 1.0.8.3, enhance Pro activation handling, minor fixes and improve renderer script management

AGENTS.md

@@ -22,6 +22,7 @@ This repository patches the Wand Electron app from a .NET Framework WPF desktop
 - The websocket `hello` snapshot must still send cached `installed_apps` and `game_status` even when no trainer snapshot is active yet; do not reintroduce a handshake path that returns early after `trainer_changed`.
 - Remote Play/Stop uses the websocket `remote_command` message. The bridge forwards it over `wand-remote-command` / `wand-remote-command-response`, and `installed-apps-sync.js` resolves Wand's trainer API + trainer service to launch a trainer for a `gameId` or end the current trainer.
 - Remote Play must construct Wand's real trainer launch request class (`69482.vO`) before calling `trainerService.launch(...)`. Passing a plain object launches the game process but breaks Wand's `getMetadata(vO)`-based trainer state, causing missing status, disappearing play/close buttons, and stuck loading behavior.
+- Pro activation is a C# asar patch (`EPatchType.ActivatePro`, independent of the remote panel / bridge). It rewrites three account-returning service methods to inject `subscription:{period:"yearly",state:"active"}` into the response before it reaches the store: `getUserAccount` and `setAccountWandBrandExperience` (Resolver-style, service field via `<service_name>` placeholder) and `setAccountLanguage` (`BuildSetAccountLanguagePatch` PatchFactory — captures the real param names + the original `post("/v3/account/language",{...})` expr and wraps `.then`). Pro is `am(account) = !!account.subscription` (flags/512 are irrelevant). `setAccountLanguage` is the one the original two patches missed, which is why Pro dropped on language change. If a future Wand build changes these method bodies, re-derive the regexes against the live `app-*.bundle.js` (do NOT trust `.source/new` — it is a different version).
 
 ## ASAR Patch Pipeline
 

CHANGELOG.md

@@ -3,6 +3,15 @@
 This file is the source of truth for release notes.
 The newest entry must match the version in `WandEnhancer/Properties/AssemblyInfo.cs`.
 
+## [1.0.8.3] - 2026-06-06
+
+### Fixes
+
+- Fixed the Remote Web Panel patches so they reliably apply on newer Wand builds by making the remote bridge patch anchors version-resilient.
+- Fixed Pro activation being lost after changing the app language; the account language endpoint now keeps the patched subscription.
+- Fixed "WeMod directory not found" when Wand/WeMod is installed outside the default location or only one brand folder exists. The patcher now also resolves the install directory from a running Wand/WeMod process. #82
+- Hid the Pro "Remote" onboarding card in the Explore Pro benefits dialog. #86
+
 ## [1.0.8.2] - 2026-05-15
 
 ### Fixes

README.md

@@ -46,6 +46,45 @@ WandEnhancer includes a built-in **Remote Web Panel** allowing you to control ap
 
 > Source archives are intended for developers who want to build the project locally. They are not prebuilt binaries.
 
+## 🧩 Custom scripts
+
+You can inject your own JavaScript into Wand at patch time to tweak or fix things in the client UI. This reuses the same renderer injection the Remote Web Panel uses, so it requires the **Remote Web Panel** patch to be enabled.
+
+**How to add a script**
+
+- In the patch dialog, add one or more `.js` files (only existing `.js` files are accepted), **or**
+- Drop `.js` files into a `renderer-scripts/` folder placed next to the patcher executable.
+
+Then patch as usual — your scripts are bundled into the client and run inside Wand's window.
+
+**How it runs**
+
+- Each script runs inside Wand's renderer (full DOM access, plus Node `require`).
+- It is wrapped so a thrown error is logged and never crashes Wand.
+- It may run **more than once** per launch (on load and again shortly after), so guard one‑time work behind a global flag.
+- A small `WandEnhancer` helper is available: `WandEnhancer.log(...)`, `WandEnhancer.remoteUrl`, `WandEnhancer.apiVersion`.
+
+**Minimal example** (`hello.js`)
+
+```js
+// Injected scripts can run multiple times — guard one-time setup.
+if (!globalThis.__helloScriptInstalled) {
+  globalThis.__helloScriptInstalled = true;
+
+  WandEnhancer.log("Hello from my custom script!", WandEnhancer.remoteUrl);
+
+  new MutationObserver(() => {
+    const dialog = document.querySelector("ux-dialog:not([data-seen])");
+    if (dialog) {
+      dialog.setAttribute("data-seen", "1");
+      WandEnhancer.log("A dialog opened.");
+    }
+  }).observe(document.documentElement, { childList: true, subtree: true });
+}
+```
+
+> Scripts run with the same privileges as the Wand client. Only add scripts you trust and understand.
+
 ## 🛠️ How to build from source
 
 Building from source on Windows requires a local development environment.

WandEnhancer/Core/Enhancer.cs

@@ -81,7 +81,9 @@ namespace WandEnhancer.Core
                     $"{prefix} Patch failed. Multiple target functions found. Looks like the version is not supported");
             }
 
-            string patchSource = patch.Patch;
+            string patchSource = patch.PatchFactory != null
+                ? patch.PatchFactory(match)
+                : patch.Patch;
 
             if (patch.Resolver != null)
             {
@@ -96,9 +98,20 @@ namespace WandEnhancer.Core
             
             _logger($"{prefix} Found target function in: " + Path.GetFileName(fileName), ELogType.Info);
 
-            string newJs = patch.SingleMatch
+            string newJs;
+            if (patch.PatchFactory != null)
+            {
+                newJs = patch.SingleMatch
+                    ? patch.Target.Replace(js, _ => patchSource, 1)
+                    : patch.Target.Replace(js, _ => patchSource);
+            }
+            else
+            {
+                newJs = patch.SingleMatch
                     ? patch.Target.Replace(js, patchSource, 1)
                     : patch.Target.Replace(js, patchSource);
+            }
+
             _logger($"{prefix} Patch applied", ELogType.Success);
             patch.Applied = true;
             patchApplied = true;

WandEnhancer/Core/EnhancerConfig.cs

@@ -20,6 +20,7 @@ namespace WandEnhancer.Core
         {
             public Regex Target { get; set; }
             public string Patch { get; set; }
+            public Func<Match, string> PatchFactory { get; set; }
             public string Name { get; set; }
             public bool Applied { get; set; }
             public bool SingleMatch { get; set; } = true;
@@ -28,6 +29,66 @@ namespace WandEnhancer.Core
             public ResolveContext Resolver { get; set; }
         }
 
+        private static string RequireGroup(Match match, string groupName, string patchName)
+        {
+            var group = match.Groups[groupName];
+            if (!group.Success || string.IsNullOrEmpty(group.Value))
+            {
+                throw new Exception($"{patchName} failed to resolve {groupName}");
+            }
+
+            return group.Value;
+        }
+
+        private static string RequirePattern(string source, string pattern, string groupName, string patchName)
+        {
+            var match = Regex.Match(source, pattern, RegexOptions.Singleline);
+            return RequireGroup(match, groupName, patchName);
+        }
+
+        private static string BuildSetAccountLanguagePatch(Match match)
+        {
+            var parameters = RequireGroup(match, "params", "setAccountLanguage");
+            var expr = RequireGroup(match, "expr", "setAccountLanguage");
+            return $"setAccountLanguage({parameters}){{return ({expr}).then(response=>{{response&&\"object\"==typeof response&&(response.subscription={{period:\"yearly\",state:\"active\"}});return response;}})}}";
+        }
+
+        private static string BuildRemoteBridgeResetPatch(Match match)
+        {
+            var source = match.Value;
+            var method = RequireGroup(match, "method", "remoteBridgeReset");
+            var disposableField = RequirePattern(source, @"this\.(?<disposable>#[\w$]+)\s*&&\s*\(\s*this\.\k<disposable>\.dispose\(\)", "disposable", "remoteBridgeReset");
+            var instanceField = RequirePattern(source, @"this\.(?<instance>#[\w$]+)\s*=\s*Date\.now\(\)\.toString\(\)", "instance", "remoteBridgeReset");
+            var trainerIdField = RequirePattern(source, @"Date\.now\(\)\.toString\(\)\s*\)?\s*,\s*\(?\s*this\.(?<trainerId>#[\w$]+)\s*=\s*null", "trainerId", "remoteBridgeReset");
+            var supportedVersionsField = RequirePattern(source, @"this\.(?<versions>#[\w$]+)\s*=\s*\[\]", "versions", "remoteBridgeReset");
+            var trainerField = RequirePattern(source, @"this\.(?<versions>#[\w$]+)\s*=\s*\[\]\s*\)?\s*,\s*\(?\s*this\.(?<trainer>#[\w$]+)\s*=\s*null", "trainer", "remoteBridgeReset");
+
+            return $"{method}(){{this.{disposableField}&&(this.{disposableField}.dispose(),this.{disposableField}=null),this.{instanceField}=Date.now().toString(),this.{trainerIdField}=null,this.{supportedVersionsField}=[],this.{trainerField}=null,this.__wandRemoteTrainerInfo=null,this.__wandRemoteBridge?.sync(null)}}";
+        }
+
+        private static string BuildRemoteBridgeSyncSnapshotPatch(Match match)
+        {
+            var source = match.Value;
+            var method = RequireGroup(match, "method", "remoteBridgeSyncSnapshot");
+            var statusAlias = RequirePattern(source, @"this\.status\s*===\s*(?<value>[\w$]+)\.Connected", "value", "remoteBridgeSyncSnapshot");
+            var trainerField = RequirePattern(source, @"this\.(?<trainer>#[\w$]+)\?\.\s*getMetadata\s*\(\s*(?<metadata>[\w$]+\.[\w$]+)\s*\)\?\.\s*gameVersion", "trainer", "remoteBridgeSyncSnapshot");
+            var metadataExport = RequirePattern(source, @"this\.(?<trainer>#[\w$]+)\?\.\s*getMetadata\s*\(\s*(?<metadata>[\w$]+\.[\w$]+)\s*\)\?\.\s*gameVersion", "metadata", "remoteBridgeSyncSnapshot");
+            var notesField = RequirePattern(source, @"this\.(?<notes>#[\w$]+)\s*\[\s*this\.(?<trainerId>#[\w$]+)\s*\?\?\s*""""\s*\]", "notes", "remoteBridgeSyncSnapshot");
+            var trainerIdField = RequirePattern(source, @"this\.(?<notes>#[\w$]+)\s*\[\s*this\.(?<trainerId>#[\w$]+)\s*\?\?\s*""""\s*\]", "trainerId", "remoteBridgeSyncSnapshot");
+            var gameField = RequirePattern(source, @"this\.(?<game>#[\w$]+)\s*&&.*?getPreferredInstallationInfo\s*\(\s*this\.\k<game>\s*\)", "game", "remoteBridgeSyncSnapshot");
+            var installationField = RequirePattern(source, @"this\.(?<game>#[\w$]+)\s*&&.*?this\.(?<installation>#[\w$]+)\.getPreferredInstallationInfo\s*\(\s*this\.\k<game>\s*\)", "installation", "remoteBridgeSyncSnapshot");
+            var supportedVersionsField = RequirePattern(source, @"!\s*this\.(?<versions>#[\w$]+)\.includes\s*\(\s*[\w$]+\.version\s*\)", "versions", "remoteBridgeSyncSnapshot");
+            var remoteChannelField = RequirePattern(source, @"this\.(?<remote>#[\w$]+)\?\.\s*send\s*\(\s*""client-state""", "remote", "remoteBridgeSyncSnapshot");
+            var valuesMethod = RequirePattern(source, @"values\s*:\s*this\.(?<values>#[\w$]+)\s*\(\s*\)", "values", "remoteBridgeSyncSnapshot");
+            var instanceField = RequirePattern(source, @"instanceId\s*:\s*this\.(?<instance>#[\w$]+)", "instance", "remoteBridgeSyncSnapshot");
+            var themeField = RequirePattern(source, @"themeId\s*:\s*this\.(?<theme>#[\w$]+)", "theme", "remoteBridgeSyncSnapshot");
+            var settingsHelper = RequirePattern(source, @"settings\s*:\s*(?<settings>[\w$]+)\s*\(\s*this\.settings\s*\)", "settings", "remoteBridgeSyncSnapshot");
+            var languageField = RequirePattern(source, @"language\s*:\s*this\.(?<language>#[\w$]+)", "language", "remoteBridgeSyncSnapshot");
+            var timerField = RequirePattern(source, @"isTimeLimitExpired\s*:\s*""expired""\s*===\s*this\.(?<timer>#[\w$]+)\.timerState", "timer", "remoteBridgeSyncSnapshot");
+
+            return $"{method}(){{let e,t=!1,s=this.{trainerField}?.getMetadata({metadataExport})?.gameVersion??null,o=!1;const n=this.{notesField}[this.{trainerIdField}??\"\"]||null;this.{gameField}&&(e=this.{installationField}.getPreferredInstallationInfo(this.{gameField}),e.app&&(t=!0,s??=e.version??null,o=\"number\"==typeof e.version&&!this.{supportedVersionsField}.includes(e.version)));this.status==={statusAlias}.Connected&&this.{remoteChannelField}?.send(\"client-state\",{{instanceId:this.{instanceField},trainerId:this.{trainerIdField},trainerLoading:this.{trainerField}?.isLoading(),gameInstalled:t,gameVersion:s,needsCompatibilityWarning:o,values:this.{valuesMethod}(),themeId:this.{themeField},settings:{settingsHelper}(this.settings),language:this.{languageField},accountUuid:this.account.uuid,notesReadHash:n,isTimeLimitExpired:\"expired\"===this.{timerField}.timerState}});this.__wandRemoteBridge?.sync({{instanceId:this.{instanceField},trainerId:this.{trainerIdField},trainerInfo:this.__wandRemoteTrainerInfo??null,metadata:this.{trainerField}?.getMetadata({metadataExport})??null,trainerLoading:this.{trainerField}?.isLoading()??false,gameInstalled:t,gameVersion:s,needsCompatibilityWarning:o,language:this.{languageField},themeId:this.{themeField},notesReadHash:n,isTimeLimitExpired:\"expired\"===this.{timerField}.timerState,values:this.{valuesMethod}()}})}}";
+        }
+
         public static Dictionary<EPatchType, PatchEntry[]> GetInstance()
         {
             return new Dictionary<EPatchType, PatchEntry[]>()
@@ -72,6 +133,19 @@ namespace WandEnhancer.Core
                                 RegexOptions.Singleline),
                             Patch =
                                 "setAccountWandBrandExperience(){return this.#<service_name>.post(\"/v3/account/brand_experience_wand\").then(response=>{response.subscription={period:\"yearly\",state:\"active\"};return response;})}"
+                        },
+                        new PatchEntry
+                        {
+                            // Account-returning endpoint the original patches missed: changing
+                            // language dispatches its (non-Pro) response into the store and
+                            // wiped Pro. Wrap the result the same way. Param names are captured
+                            // so the rewritten body keeps the real argument identifiers.
+                            Name = "setAccountLanguage",
+                            SearchHints = new[] { "setAccountLanguage(", "/v3/account/language" },
+                            Target = new Regex(
+                                @"setAccountLanguage\((?<params>[^)]*)\)\{\s*return\s+(?<expr>this\.#\w+\.post\(""/v3/account/language"",\{[^}]*\}\))\s*;?\s*\}",
+                                RegexOptions.Singleline),
+                            PatchFactory = BuildSetAccountLanguagePatch
                         }
                     }
                 },
@@ -128,15 +202,17 @@ namespace WandEnhancer.Core
                         {
                             Name = "remoteBridgeReset",
                             SearchHints = new[] { "client-state" },
-                            Target = new Regex(@"#Je\(\)\{this\.#Oe&&\(this\.#Oe\.dispose\(\),this\.#Oe=null\),this\.#Pe=Date\.now\(\)\.toString\(\),this\.#ke=null,this\.#_e=\[],this\.#Ee=null\}"),
-                            Patch = "#Je(){this.#Oe&&(this.#Oe.dispose(),this.#Oe=null),this.#Pe=Date.now().toString(),this.#ke=null,this.#_e=[],this.#Ee=null,this.__wandRemoteTrainerInfo=null,this.__wandRemoteBridge?.sync(null)}"
+                            Target = new Regex(@"(?<method>#[\w$]+)\(\)\s*\{\s*(?<body>(?:(?!__wandRemoteBridge|}\s*#[\w$]+\(\)).)*?Date\.now\(\)\.toString\(\)(?:(?!__wandRemoteBridge|}\s*#[\w$]+\(\)).)*?\[\](?:(?!__wandRemoteBridge|}\s*#[\w$]+\(\)).)*?)\s*\}\s*(?=#[\w$]+\(\)\s*\{\s*if\s*\(\s*this\.status\s*===\s*[\w$]+\.Connected\s*\).*?""client-state"")",
+                                RegexOptions.Singleline),
+                            PatchFactory = BuildRemoteBridgeResetPatch
                         },
                         new PatchEntry
                         {
                             Name = "remoteBridgeSyncSnapshot",
                             SearchHints = new[] { "client-state" },
-                            Target = new Regex(@"#Be\(\)\{if\(this\.status===i\.Connected\)\{let e,t=!1,s=this\.#Ee\?\.getMetadata\(h\.vO\)\?\.gameVersion\?\?null,i=!1;const n=this\.#Ve\[this\.#ke\?\?""""\]\|\|null;this\.#Re&&\(e=this\.#Ae\.getPreferredInstallationInfo\(this\.#Re\),e\.app&&\(t=!0,s\?\?=e\.version\?\?null,i=""number""==typeof e\.version&&!this\.#_e\.includes\(e\.version\)\)\),this\.#Me\?\.send\(""client-state"",\{instanceId:this\.#Pe,trainerId:this\.#ke,trainerLoading:this\.#Ee\?\.isLoading\(\),gameInstalled:t,gameVersion:s,needsCompatibilityWarning:i,values:this\.#Ke\(\),themeId:this\.#We,settings:R\(this\.settings\),language:this\.#Ne,accountUuid:this\.account\.uuid,notesReadHash:n,isTimeLimitExpired:""expired""===this\.#Fe\.timerState\}\)\}\}"),
-                            Patch = "#Be(){let e,t=!1,s=this.#Ee?.getMetadata(h.vO)?.gameVersion??null,o=!1;const n=this.#Ve[this.#ke??\"\"]||null;this.#Re&&(e=this.#Ae.getPreferredInstallationInfo(this.#Re),e.app&&(t=!0,s??=e.version??null,o=\"number\"==typeof e.version&&!this.#_e.includes(e.version)));this.status===i.Connected&&this.#Me?.send(\"client-state\",{instanceId:this.#Pe,trainerId:this.#ke,trainerLoading:this.#Ee?.isLoading(),gameInstalled:t,gameVersion:s,needsCompatibilityWarning:o,values:this.#Ke(),themeId:this.#We,settings:R(this.settings),language:this.#Ne,accountUuid:this.account.uuid,notesReadHash:n,isTimeLimitExpired:\"expired\"===this.#Fe.timerState});this.__wandRemoteBridge?.sync({instanceId:this.#Pe,trainerId:this.#ke,trainerInfo:this.__wandRemoteTrainerInfo??null,metadata:this.#Ee?.getMetadata(h.vO)??null,trainerLoading:this.#Ee?.isLoading()??false,gameInstalled:t,gameVersion:s,needsCompatibilityWarning:o,language:this.#Ne,themeId:this.#We,notesReadHash:n,isTimeLimitExpired:\"expired\"===this.#Fe.timerState,values:this.#Ke()})}"
+                            Target = new Regex(@"(?<method>#[\w$]+)\(\)\s*\{\s*if\s*\(\s*this\.status\s*===\s*[\w$]+\.Connected\s*\)\s*\{(?<body>.*?""client-state"".*?isTimeLimitExpired\s*:\s*""expired""\s*===\s*this\.\#[\w$]+\.timerState.*?\)\s*;?\s*\)?\s*;?)\s*\}\s*\}(?=\s*#[\w$]+\(\)\s*\{\s*if\s*\(\s*!this\.\#[\w$]+\?\.\s*isActive\(\)\s*\)\s*return\s*null)",
+                                RegexOptions.Singleline),
+                            PatchFactory = BuildRemoteBridgeSyncSnapshotPatch
                         },
                         new PatchEntry
                         {

WandEnhancer/Properties/AssemblyInfo.cs

@@ -51,5 +51,5 @@ using System.Windows;
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.8.2")]
-[assembly: AssemblyFileVersion("1.0.8.2")]
+[assembly: AssemblyVersion("1.0.8.3")]
+[assembly: AssemblyFileVersion("1.0.8.3")]

WandEnhancer/Utils/Extensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -40,12 +41,72 @@ namespace WandEnhancer.Utils
         {
             string localAppDataPath = Environment.GetEnvironmentVariable("LOCALAPPDATA");
 
+            if (!string.IsNullOrEmpty(localAppDataPath))
+            {
                 foreach (var folder in Constants.WeModBrandNames)
                 {
-                var weModDir = Path.Combine(localAppDataPath ?? "", folder);
-                if(Directory.Exists(weModDir))
+                    var weModDir = Path.Combine(localAppDataPath, folder);
+                    if (!Directory.Exists(weModDir))
                     {
-                    return FindLatestWeMod(weModDir);
+                        continue;
+                    }
+
+                    // Keep scanning the other brand folders if this one has no valid
+                    // install instead of giving up on the first folder that exists.
+                    var config = FindLatestWeMod(weModDir);
+                    if (config != null)
+                    {
+                        return config;
+                    }
+                }
+            }
+
+            // Fallback: a running Wand/WeMod process reveals the install directory
+            // wherever it lives (non-default LOCALAPPDATA, moved install, other drive).
+            return FindWeModFromRunningProcess();
+        }
+
+        private static WeModConfig FindWeModFromRunningProcess()
+        {
+            foreach (var name in Constants.WeModBrandNames)
+            {
+                Process[] processes;
+                try
+                {
+                    processes = Process.GetProcessesByName(name);
+                }
+                catch
+                {
+                    continue;
+                }
+
+                foreach (var process in processes)
+                {
+                    try
+                    {
+                        var exePath = process.MainModule?.FileName;
+                        if (string.IsNullOrEmpty(exePath))
+                        {
+                            continue;
+                        }
+
+                        // Process may be the versioned exe (dir is the install root) or
+                        // the launcher stub at the parent (dir holds `app-*` subfolders).
+                        var processDir = Path.GetDirectoryName(exePath);
+                        var config = CheckWeModPath(processDir) ?? FindLatestWeMod(processDir);
+                        if (config != null)
+                        {
+                            return config;
+                        }
+                    }
+                    catch
+                    {
+                        // MainModule throws on access-denied / bitness mismatch; skip.
+                    }
+                    finally
+                    {
+                        process.Dispose();
+                    }
                 }
             }
 

web-panel/bridge/build.mjs

@@ -25,10 +25,17 @@ await build({
     target: "node16",
 })
 
+const EXCLUDED_RENDERER_SCRIPTS = new Set(["activate-pro.js"])
+
 const rendererEntries = (
     await readdir(rendererScriptsRoot, { withFileTypes: true })
 )
-  .filter((entry) => entry.isFile() && entry.name.endsWith(".js"))
+    .filter(
+        (entry) =>
+            entry.isFile() &&
+            entry.name.endsWith(".js") &&
+            !EXCLUDED_RENDERER_SCRIPTS.has(entry.name)
+    )
     .map((entry) => resolve(rendererScriptsRoot, entry.name))
 
 if (rendererEntries.length === 0) {

web-panel/bridge/scripts/default/activate-pro.js

@@ -0,0 +1,7 @@
+// NOTE: Not wired into the build. Pro activation currently lives in the C# asar
+// patch (EPatchType.ActivatePro). This renderer-side variant is kept for future
+// use and is excluded from bridge/build.mjs (EXCLUDED_RENDERER_SCRIPTS), so it is
+// neither bundled nor injected. To re-enable, remove it from that exclusion list.
+import { installActivatePro } from "./activate-pro/index.js"
+
+installActivatePro(globalThis.WandEnhancer)

web-panel/bridge/scripts/default/activate-pro/index.js

@@ -0,0 +1,140 @@
+// NOTE: Currently unused. Pro activation lives in the C# asar patch
+// (EPatchType.ActivatePro). This renderer-side variant patches the account service
+// prototype to inject the Pro subscription at the source. Kept for future use;
+// the entry `../activate-pro.js` is excluded from bridge/build.mjs.
+import { createLogger } from "../installed-apps-sync/logger.js"
+import {
+    findExportedConstructor,
+    getWebpackRequire,
+    isRecord,
+} from "../installed-apps-sync/runtime.js"
+
+const GLOBAL_FLAG = "__wandActivateProInstalled"
+const SERVICE_PATCH_KEY = "__wandEnhancerProAccountServicePatched"
+const ACCOUNT_SERVICE_METHODS = [
+    "getUserAccount",
+    "setAccountLanguage",
+    "setAccountWandBrandExperience",
+]
+const RETRY_DELAY_MS = 400
+const MAX_ATTEMPTS = 90
+const DEFAULT_SUBSCRIPTION = Object.freeze({ period: "yearly", state: "active" })
+
+export function installActivatePro(WandEnhancer) {
+    if (globalThis[GLOBAL_FLAG]) {
+        return
+    }
+
+    globalThis[GLOBAL_FLAG] = true
+
+    const state = {
+        attempts: 0,
+        log: createLogger(WandEnhancer),
+    }
+
+    state.log("info", "Activate Pro bootstrap starting.")
+    retryBootstrap(state)
+}
+
+function retryBootstrap(state) {
+    if (patchAccountService(state)) {
+        return
+    }
+
+    state.attempts += 1
+    if (state.attempts < MAX_ATTEMPTS) {
+        setTimeout(() => retryBootstrap(state), RETRY_DELAY_MS)
+        return
+    }
+
+    state.log("error", "Activate Pro bootstrap exhausted; account service not found.")
+}
+
+function patchAccountService(state) {
+    const webpackRequire = getWebpackRequire()
+    if (!webpackRequire) {
+        return false
+    }
+
+    const ctor = findExportedConstructor(
+        webpackRequire,
+        (prototype) =>
+            typeof prototype.getUserAccount === "function" &&
+            typeof prototype.setAccountLanguage === "function" &&
+            typeof prototype.setAccountWandBrandExperience === "function"
+    )
+    if (!ctor?.prototype) {
+        return false
+    }
+
+    const prototype = ctor.prototype
+    if (prototype[SERVICE_PATCH_KEY]) {
+        return true
+    }
+
+    try {
+        for (const name of ACCOUNT_SERVICE_METHODS) {
+            const original = prototype[name]
+            if (typeof original !== "function") {
+                continue
+            }
+
+            prototype[name] = function patchedAccountMethod(...args) {
+                return Promise.resolve(original.apply(this, args)).then((account) =>
+                    normalizeProAccount(account)
+                )
+            }
+        }
+
+        Object.defineProperty(prototype, SERVICE_PATCH_KEY, { value: true })
+        state.log("info", "Pro account service patched.")
+        return true
+    } catch (error) {
+        state.log(
+            "warn",
+            "Failed to patch account service.",
+            error?.stack || String(error)
+        )
+        return false
+    }
+}
+
+function normalizeProAccount(account) {
+    if (!isRecord(account)) {
+        return account
+    }
+
+    const nextSubscription = normalizeProSubscription(account.subscription)
+    if (nextSubscription === account.subscription) {
+        return account
+    }
+
+    return {
+        ...account,
+        subscription: nextSubscription,
+    }
+}
+
+function normalizeProSubscription(subscription) {
+    if (!isRecord(subscription)) {
+        return { ...DEFAULT_SUBSCRIPTION }
+    }
+
+    const nextSubscription = { ...subscription }
+    let changed = false
+
+    if (
+        typeof nextSubscription.period !== "string" ||
+        !nextSubscription.period.trim()
+    ) {
+        nextSubscription.period = DEFAULT_SUBSCRIPTION.period
+        changed = true
+    }
+
+    if (nextSubscription.state !== "active") {
+        nextSubscription.state = DEFAULT_SUBSCRIPTION.state
+        changed = true
+    }
+
+    return changed ? nextSubscription : subscription
+}

web-panel/bridge/scripts/default/remote-popup-cleanup.js

@@ -8,6 +8,10 @@
   const style = document.createElement("style")
   style.id = "wand-remote-popup-cleanup-style"
   style.textContent = `
+    .pro-onboarding-card--remote {
+      display: none !important;
+    }
+
     remote-tooltip .remote-tooltip .top-wrapper,
     remote-tooltip .remote-tooltip .remote-tooltip-section-divider,
     remote-tooltip .remote-tooltip .instructions .header,