fix: address 5 Copilot review suggestions

1. BsdiffDiffer: recognize Brotli marker (0x02) as extended-header format
   even on netstandard2.0 (fail-fast) instead of mis-detecting as legacy BZip2
2. VersionComparer.ParseVersion: use TryParseNumeric with overflow guard
   instead of bare long.Parse (can throw on > Int64 values)
3. VersionComparer.ComparePrerelease: add IsNumericString fallback for
   purely-numeric identifiers that exceed long.MaxValue (length+ordinal)
4. OssStrategy: limit diagnostic file listing to 20 entries to prevent
   unbounded log noise on non-Windows
5. VersionComparerTests: fix doc comment (long.MaxValue -> int.MaxValue)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: JusterZhu

src/c#/GeneralUpdate.Core/Strategy/OssStrategy.cs

@@ -269,8 +269,15 @@ private async Task ExecuteClientAsync()
         try
         {
             var searchPattern = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "*.exe" : "*";
-            var dirFiles = Directory.GetFiles(upgradeDir, searchPattern).Select(f => Path.GetFileName(f));
-            GeneralTracer.Info($"[OssClient] Files in {upgradeDir}: [{string.Join(", ", dirFiles)}]");
+            const int maxDisplay = 20;
+            var dirFiles = Directory.EnumerateFiles(upgradeDir, searchPattern)
+                .Take(maxDisplay + 1)
+                .Select(f => Path.GetFileName(f))
+                .ToList();
+            var summary = dirFiles.Count > maxDisplay
+                ? $"[{string.Join(", ", dirFiles.Take(maxDisplay))}, ... and {dirFiles.Count - maxDisplay} more]"
+                : $"[{string.Join(", ", dirFiles)}]";
+            GeneralTracer.Info($"[OssClient] Files in {upgradeDir}: {summary}");
         }
         catch (Exception ex)
         {

src/c#/GeneralUpdate.Differential/Differ/BsdiffDiffer.cs

@@ -309,9 +309,7 @@ await Task.Run(() =>
                             byte candidate = formatByte[0];
 
                             if (candidate == BZip2FormatVersion || candidate == DeflateFormatVersion
-#if NET6_0_OR_GREATER
                                 || candidate == BrotliFormatVersion
-#endif
                                )
                             {
                                 formatVersion = candidate;
@@ -444,9 +442,7 @@ await Task.Run(() =>
 
         private const byte BZip2FormatVersion = 0x00;
         private const byte DeflateFormatVersion = 0x01;
-#if NET6_0_OR_GREATER
         private const byte BrotliFormatVersion = 0x02;
-#endif
 
         private static FileStream OpenPatchStream(string patchPath)
         {

src/c#/GeneralUpdate.Drivelution/Core/Utilities/VersionComparer.cs

@@ -103,16 +103,35 @@ private static SemVerInfo ParseVersion(string version)
             throw new FormatException($"Version '{version}' does not follow SemVer 2.0 format");
         }
 
+        if (!TryParseNumeric(match.Groups["major"].Value, out var major))
+            throw new FormatException($"Version '{version}' has a 'major' component that exceeds the supported range.");
+        if (!TryParseNumeric(match.Groups["minor"].Value, out var minor))
+            throw new FormatException($"Version '{version}' has a 'minor' component that exceeds the supported range.");
+        if (!TryParseNumeric(match.Groups["patch"].Value, out var patch))
+            throw new FormatException($"Version '{version}' has a 'patch' component that exceeds the supported range.");
+
         return new SemVerInfo
         {
-            Major = long.Parse(match.Groups["major"].Value),
-            Minor = long.Parse(match.Groups["minor"].Value),
-            Patch = long.Parse(match.Groups["patch"].Value),
+            Major = major,
+            Minor = minor,
+            Patch = patch,
             Prerelease = match.Groups["prerelease"].Value,
             BuildMetadata = match.Groups["buildmetadata"].Value
         };
     }
 
+    private static bool TryParseNumeric(string value, out long result)
+    {
+        // SemVer numeric components are non-negative integers per spec.
+        // long.MaxValue (≈9.2e18) is the largest we support.
+        if (value.Length > 19) // any value > long.MaxValue has at least 19 digits
+        {
+            result = 0;
+            return false;
+        }
+        return long.TryParse(value, out result);
+    }
+
     private static int ComparePrerelease(string pre1, string pre2)
     {
         var parts1 = pre1.Split('.');
@@ -122,14 +141,27 @@ private static int ComparePrerelease(string pre1, string pre2)
 
         for (int i = 0; i < minLength; i++)
         {
-            var isNum1 = long.TryParse(parts1[i], out long num1);
-            var isNum2 = long.TryParse(parts2[i], out long num2);
+            // Test numeric identifiers — if both parse, compare numerically.
+            // Per SemVer 2.0 §11, numeric prerelease identifiers are compared
+            // as integers.  If an identifier exceeds long.MaxValue, fall back
+            // to a digit-length + ordinal comparison so the ordering remains
+            // integer-like even when the platform type can't hold the value.
+            bool isNum1 = TryParseNumeric(parts1[i], out long num1);
+            bool isNum2 = TryParseNumeric(parts2[i], out long num2);
 
             if (isNum1 && isNum2)
             {
                 if (num1 != num2)
                     return num1.CompareTo(num2);
             }
+            else if (IsNumericString(parts1[i]) && IsNumericString(parts2[i]))
+            {
+                // Both are purely numeric but exceed long.MaxValue.
+                // Compare by digit length first, then ordinal.
+                int cmp = parts1[i].Length.CompareTo(parts2[i].Length);
+                if (cmp != 0) return cmp;
+                return string.CompareOrdinal(parts1[i], parts2[i]);
+            }
             else if (isNum1)
             {
                 return -1; // Numeric identifier is less than alphanumeric
@@ -150,6 +182,19 @@ private static int ComparePrerelease(string pre1, string pre2)
         return parts1.Length.CompareTo(parts2.Length);
     }
 
+    /// <summary>
+    /// Returns true when <paramref name="s"/> is non-empty and every character
+    /// is an ASCII digit — without attempting to parse into a numeric type.
+    /// </summary>
+    private static bool IsNumericString(string s)
+    {
+        if (string.IsNullOrEmpty(s)) return false;
+        foreach (char c in s)
+            if (c < '0' || c > '9')
+                return false;
+        return true;
+    }
+
     private class SemVerInfo
     {
         public long Major { get; set; }

tests/DrivelutionTest/Utilities/VersionComparerAndRestartHelperTests.cs

@@ -218,7 +218,8 @@ public void Compare_VeryLargeNumbers_DoesNotOverflow()
     [Fact]
     public void Compare_PrereleaseWithLargeNumbers_DoesNotOverflow()
     {
-        // long.MaxValue ~9.2e18 approaching overflow in int
+        // Values up to ~1e12 exceed int.MaxValue (~2.1e9) so this verifies
+        // the long-based numeric overflow guard in ComparePrerelease.
         var result = VersionComparer.Compare("1.0.0-999999999999", "1.0.0-0");
         Assert.True(result > 0);
     }