fix: Boundary-aware version matching for download URLs and update assets

- Add VersionUtil.containsVersion() to prevent substring false positives
  (e.g. "1.21.1" no longer matches "1.21.10" or "1.21.11")
- AddonMetadata.getDownloadUrls(): skip latest_release when it doesn't
  match current MC version, deduplicate against downloads list
- GitHubReleaseAPI.findJarAsset(): select version-matching JAR from
  multi-asset releases, return empty instead of wrong-version fallback
- AddonManager.downloadAddon(): rename file to match actual URL on
  fallback success, strip query strings from filenames, isolate rename
  errors so they don't mask successful downloads
- UpdateInfo.getVersionChangeDisplay(): show only new version instead
  of arrow notation that doesn't render in Meteor's GUI

Author: GhostTypes

src/main/java/com/cope/meteoraddons/models/AddonMetadata.java

@@ -81,18 +81,19 @@ public String[] getDownloadUrls() {
         }
 
         List<String> urls = new ArrayList<>();
+        String currentVersion = VersionUtil.getCurrentMinecraftVersion();
 
-        // Priority 1: Latest Release
-        if (links.latest_release != null && !links.latest_release.isEmpty()) {
+        // Priority 1: Latest Release (only if it matches current MC version)
+        if (links.latest_release != null && !links.latest_release.isEmpty()
+                && VersionUtil.containsVersion(links.latest_release, currentVersion)) {
             urls.add(links.latest_release);
         }
 
         // Priority 2: Compatible downloads from the list
         if (links.downloads != null && !links.downloads.isEmpty()) {
-            String currentVersion = VersionUtil.getCurrentMinecraftVersion();
-
             links.downloads.stream()
-                    .filter(url -> url != null && url.contains(currentVersion))
+                    .filter(url -> url != null && VersionUtil.containsVersion(url, currentVersion))
+                    .filter(url -> !urls.contains(url))
                     .forEach(urls::add);
         }
 

src/main/java/com/cope/meteoraddons/models/UpdateInfo.java

@@ -77,11 +77,11 @@ public Path getLocalJarPath() {
     }
 
     /**
-     * Get a display string showing version change.
+     * Get a display string showing the new version available.
      */
     public String getVersionChangeDisplay() {
-        if (currentVersion != null && newVersion != null && !currentVersion.equals(newVersion)) {
-            return currentVersion + " → " + newVersion;
+        if (newVersion != null && !newVersion.isEmpty()) {
+            return newVersion;
         }
         return "Update available";
     }

src/main/java/com/cope/meteoraddons/systems/AddonManager.java

@@ -19,7 +19,9 @@
 
 import java.io.IOException;
 import java.lang.reflect.Type;
+import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -210,14 +212,28 @@ public boolean downloadAddon(OnlineAddon addon) {
             Path modsFolder = meteorFolder.getParent().resolve("mods");
 
             String url = downloadUrls[0];
-            String fileName = url.substring(url.lastIndexOf('/') + 1);
+            String fileName = extractFileName(url);
             Path destPath = modsFolder.resolve(fileName);
 
             MeteorAddonsAddon.LOG.info("Downloading addon {} to {}", addon.getName(), destPath);
 
             String successUrl = HttpClient.downloadFileWithFallback(downloadUrls, destPath);
 
             if (successUrl != null) {
+                // If a fallback URL succeeded, rename the file to match the actual download
+                if (!successUrl.equals(url)) {
+                    try {
+                        String actualFileName = extractFileName(successUrl);
+                        Path actualDestPath = modsFolder.resolve(actualFileName);
+                        if (!destPath.equals(actualDestPath)) {
+                            Files.move(destPath, actualDestPath, StandardCopyOption.REPLACE_EXISTING);
+                            MeteorAddonsAddon.LOG.info("Renamed downloaded file to match actual URL: {}", actualFileName);
+                        }
+                    } catch (Exception e) {
+                        MeteorAddonsAddon.LOG.warn("Failed to rename downloaded file, keeping original name: {}", e.getMessage());
+                    }
+                }
+
                 MeteorAddonsAddon.LOG.info("Successfully downloaded addon: {}", addon.getName());
                 installedAddonNames.add(addon.getName());
                 save();
@@ -234,6 +250,17 @@ public boolean downloadAddon(OnlineAddon addon) {
         }
     }
 
+    /**
+     * Extract the filename from a URL, stripping any query string or fragment.
+     */
+    private static String extractFileName(String url) {
+        int queryStart = url.indexOf('?');
+        if (queryStart != -1) url = url.substring(0, queryStart);
+        int fragmentStart = url.indexOf('#');
+        if (fragmentStart != -1) url = url.substring(0, fragmentStart);
+        return url.substring(url.lastIndexOf('/') + 1);
+    }
+
     public List<Addon> getOnlineAddons() {
         return onlineAddons;
     }

src/main/java/com/cope/meteoraddons/util/GitHubReleaseAPI.java

@@ -75,23 +75,42 @@ public static Optional<ReleaseInfo> getLatestRelease(String owner, String repo)
     }
 
     /**
-     * Find the asset digest for a JAR file from the release.
-     * Looks for .jar files and returns the first match's digest.
+     * Find the JAR asset from a release that matches the current Minecraft version.
+     * If multiple JARs exist, selects the one whose filename contains the current version
+     * and returns empty if none match. Single-JAR releases are assumed version-agnostic.
      */
     public static Optional<AssetInfo> findJarAsset(ReleaseInfo release) {
         if (release.assets == null || release.assets.isEmpty()) {
             return Optional.empty();
         }
 
-        return release.assets.stream()
+        List<Asset> jars = release.assets.stream()
             .filter(asset -> asset.name != null && asset.name.endsWith(".jar"))
-            .findFirst()
-            .map(asset -> new AssetInfo(
-                asset.name,
-                asset.browserDownloadUrl,
-                HashUtil.parseGitHubDigest(asset.digest),
-                asset.size
-            ));
+            .toList();
+
+        if (jars.isEmpty()) {
+            return Optional.empty();
+        }
+
+        String currentVersion = VersionUtil.getCurrentMinecraftVersion();
+
+        Optional<Asset> versionMatch = jars.stream()
+            .filter(asset -> VersionUtil.containsVersion(asset.name, currentVersion))
+            .findFirst();
+
+        // Multi-JAR release with no version match — no safe fallback
+        if (versionMatch.isEmpty() && jars.size() > 1) {
+            return Optional.empty();
+        }
+
+        Asset match = versionMatch.orElse(jars.get(0));
+
+        return Optional.of(new AssetInfo(
+            match.name,
+            match.browserDownloadUrl,
+            HashUtil.parseGitHubDigest(match.digest),
+            match.size
+        ));
     }
 
     /**

src/main/java/com/cope/meteoraddons/util/VersionUtil.java

@@ -11,4 +11,21 @@ public static String getCurrentMinecraftVersion() {
         }
         return cachedVersion;
     }
+
+    /**
+     * Performs a boundary-aware version match within a string.
+     * Returns true only if the version occurrence is not immediately followed by another digit,
+     * ensuring exact version segments are matched (e.g. "1.21.1" won't match inside "1.21.10").
+     */
+    public static boolean containsVersion(String text, String version) {
+        int idx = text.indexOf(version);
+        while (idx != -1) {
+            int end = idx + version.length();
+            if (end >= text.length() || !Character.isDigit(text.charAt(end))) {
+                return true;
+            }
+            idx = text.indexOf(version, idx + 1);
+        }
+        return false;
+    }
 }