3.2.8 — manifest caching: skip per-file validation when patch list unchanged

Adds PatchManifestCache that hashes the raw API JSON response and stores
it locally. On subsequent launches, if the server hash matches the cached
one the full per-file validation is skipped entirely, eliminating the
perpetual-update loop. The cache is saved after a clean check or
successful update, and cleared before Verify Game Files so a manual
verify always runs fresh.

Author: ways15xx

Wauncher/Services/UpdateService.cs

@@ -46,6 +46,7 @@ public partial class UpdateService : ObservableObject, IUpdateService
         private Patches? _cachedPatches;
         private bool _forceValidateAllOnce;
         private long _lastInstallProgressTick;
+        private string? _pendingManifestHash;
 
         [ObservableProperty]
         private bool _isExtracting;
@@ -230,6 +231,9 @@ public async Task<bool> ValidateGameFilesAsync(bool fullValidate = false)
                 {
                     // "Verify Game Files": always hash every file from scratch (ignore the
                     // fast-path and any cached result), reporting live progress.
+                    // Clear the cached manifest first so a fresh API fetch drives this check.
+                    PatchManifestCache.Clear();
+                    _pendingManifestHash = null;
                     currentPatches = await Task.Run(() => PatchManager.ValidatePatches(
                         validateAll: true,
                         onProgress: (done, total) => Dispatcher.UIThread.Post(() =>
@@ -299,6 +303,14 @@ await DownloadManager.DownloadPatch(
                 UpdateStatusSpeed = "";
                 UpdateProgress = 100;
                 IsUpdateAvailable = false;
+
+                // Patch list is now applied — cache the manifest so the next launch skips validation.
+                if (_pendingManifestHash != null)
+                {
+                    PatchManifestCache.Save(_pendingManifestHash);
+                    _pendingManifestHash = null;
+                }
+
                 return true;
             }
             catch (Exception ex)
@@ -324,13 +336,32 @@ await DownloadManager.DownloadPatch(
 
             try
             {
-                var patches = await PatchManager.ValidatePatches(deleteOutdatedFiles: false);
+                string rawJson = await PatchManager.FetchPatchJsonAsync();
+                string manifestHash = PatchManifestCache.ComputeHash(rawJson);
+                _pendingManifestHash = manifestHash;
+
+                // If the server's patch list hasn't changed since the last successful check,
+                // skip full per-file hashing — any API change (new file, new hash) changes this.
+                if (PatchManifestCache.Load() == manifestHash)
+                {
+                    _cachedPatches = new Patches(true, new List<Patch>(), new List<Patch>());
+                    return _cachedPatches;
+                }
+
+                var patches = await Task.Run(() => PatchManager.ValidatePatches(rawJson, deleteOutdatedFiles: false));
                 _cachedPatches = patches;
+
+                // Game already up to date — save manifest so next launch skips validation.
+                if (patches.Missing.Count == 0 && patches.Outdated.Count == 0)
+                {
+                    PatchManifestCache.Save(manifestHash);
+                    _pendingManifestHash = null;
+                }
+
                 return patches;
             }
             catch (UpdateServerUnreachableException ex)
             {
-                // Surface a clear, friendly message in the bottom bar instead of hanging/failing silently.
                 ErrorLogger.LogError("UpdateService.GetPatchesAsync", ex, "Update server unreachable");
                 UpdateStatusFile = "Error: Can't connect to update server";
                 return null;

Wauncher/Utils/Patch.cs

@@ -2,10 +2,46 @@
 using Newtonsoft.Json.Linq;
 using System.Collections.Concurrent;
 using System.Security.Cryptography;
+using System.Text;
 using System.Threading;
 
 namespace Wauncher.Utils
 {
+    internal static class PatchManifestCache
+    {
+        private static string CachePath => Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "ClassicCounter", "Wauncher", "patch_manifest.hash");
+
+        public static string? Load()
+        {
+            try { return File.ReadAllText(CachePath).Trim(); }
+            catch { return null; }
+        }
+
+        public static void Save(string hash)
+        {
+            try
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(CachePath)!);
+                File.WriteAllText(CachePath, hash);
+            }
+            catch { }
+        }
+
+        public static void Clear()
+        {
+            try { File.Delete(CachePath); }
+            catch { }
+        }
+
+        public static string ComputeHash(string input)
+        {
+            var bytes = MD5.HashData(Encoding.UTF8.GetBytes(input));
+            return Convert.ToHexString(bytes).ToLowerInvariant();
+        }
+    }
+
     public class Patch
     {
         [JsonProperty(PropertyName = "file")]
@@ -40,23 +76,42 @@ private static string GetOriginalFileName(string fileName)
             return fileName.EndsWith(".7z") ? fileName[..^3] : fileName;
         }
 
-        private static async Task<List<Patch>> GetPatches(bool validateAll = false)
+        public static async Task<string> FetchPatchJsonAsync()
         {
-            List<Patch> patches = new List<Patch>();
-
-            string responseString;
             try
             {
-                responseString = await Api.ClassicCounter.GetPatches();
+                return await Api.ClassicCounter.GetPatches();
             }
             catch (Exception ex)
             {
-                // Network failure / timeout / DNS — surface it instead of swallowing,
-                // so the UI can say "Can't connect to update server" rather than hang.
                 if (Debug.Enabled())
-                    Terminal.Debug($"Couldn't reach {(validateAll ? "full game" : "patch")} API: {ex.Message}");
+                    Terminal.Debug($"Couldn't reach patch API: {ex.Message}");
                 throw new UpdateServerUnreachableException("Can't connect to update server", ex);
             }
+        }
+
+        private static async Task<List<Patch>> GetPatches(string? rawJson = null)
+        {
+            List<Patch> patches = new List<Patch>();
+
+            string responseString;
+            if (rawJson != null)
+            {
+                responseString = rawJson;
+            }
+            else
+            {
+                try
+                {
+                    responseString = await Api.ClassicCounter.GetPatches();
+                }
+                catch (Exception ex)
+                {
+                    if (Debug.Enabled())
+                        Terminal.Debug($"Couldn't reach patch API: {ex.Message}");
+                    throw new UpdateServerUnreachableException("Can't connect to update server", ex);
+                }
+            }
 
             try
             {
@@ -67,7 +122,6 @@ private static async Task<List<Patch>> GetPatches(bool validateAll = false)
             }
             catch (Exception ex)
             {
-                // Reachable but returned something we can't parse — treat as a server problem.
                 if (Debug.Enabled())
                     Terminal.Debug($"Update server returned invalid data: {ex.Message}");
                 throw new UpdateServerUnreachableException("Update server returned invalid data", ex);
@@ -84,9 +138,9 @@ private static async Task<string> GetHash(string filePath)
             return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
         }
 
-        public static async Task<Patches> ValidatePatches(bool validateAll = false, bool deleteOutdatedFiles = true, Action<int, int>? onProgress = null)
+        public static async Task<Patches> ValidatePatches(string? rawJson = null, bool validateAll = false, bool deleteOutdatedFiles = true, Action<int, int>? onProgress = null)
         {
-            List<Patch> patches = await GetPatches(validateAll);
+            List<Patch> patches = await GetPatches(rawJson);
             List<Patch> missing = new();
             List<Patch> outdated = new();
             Patch? dirPatch = null;

Wauncher/Wauncher.csproj

@@ -15,7 +15,7 @@
     <PublishSingleFile>true</PublishSingleFile>
     <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
     <SelfContained>false</SelfContained>
-    <Version>3.2.7</Version>
+    <Version>3.2.8</Version>
     <AssemblyVersion>$(Version)</AssemblyVersion>
     <FileVersion>$(Version)</FileVersion>
     <AssemblyName>wauncher</AssemblyName>