chore(release): merge dev into main for v0.2.38

Author: BAKAOLC

Compat/Sts2ModManagerCompat.cs

@@ -1,3 +1,5 @@
+using System.Reflection;
+using MegaCrit.Sts2.Core.Localization;
 using MegaCrit.Sts2.Core.Modding;
 
 namespace STS2RitsuLib.Compat
@@ -8,6 +10,29 @@ namespace STS2RitsuLib.Compat
     /// </summary>
     internal static class Sts2ModManagerCompat
     {
+        private const BindingFlags InstanceMemberFlags =
+            BindingFlags.Instance |
+            BindingFlags.Public |
+            BindingFlags.NonPublic;
+
+        private static readonly Func<Mod, ModManifest?> ReadManifest = CreateModManifestAccessor();
+        private static readonly Func<Mod, Assembly?> ReadAssembly = CreateModAssemblyAccessor();
+        private static readonly Func<Mod, IReadOnlyList<LocString>> ReadErrors = CreateModErrorsAccessor();
+        private static readonly Func<Mod, string> ReadSource = CreateModSourceAccessor();
+        private static readonly Func<Mod, int, string> ReadLoadState = CreateLoadStateAccessor();
+
+        private static readonly Func<ModManifest, string?> ReadManifestId =
+            CreateManifestStringAccessor("id", static manifest => manifest.id);
+
+        private static readonly Func<ModManifest, string?> ReadManifestName =
+            CreateManifestStringAccessor("name", static manifest => manifest.name);
+
+        private static readonly Func<ModManifest, string?> ReadManifestVersion =
+            CreateManifestStringAccessor("version", static manifest => manifest.version);
+
+        private static readonly Func<ModManifest, bool> ReadManifestAffectsGameplay =
+            CreateManifestBoolAccessor("affectsGameplay", static manifest => manifest.affectsGameplay, true);
+
         internal static IEnumerable<Mod> EnumerateLoadedModsWithAssembly()
         {
             return ModManager.GetLoadedMods();
@@ -21,5 +46,206 @@ internal static IEnumerable<Mod> EnumerateModsForManifestLookup()
         {
             return ModManager.Mods;
         }
+
+        internal static IReadOnlyList<Sts2ModInventoryEntry> BuildModInventoryEntries()
+        {
+            return EnumerateModsForManifestLookup()
+                .Select(TryBuildModInventoryEntry)
+                .Where(entry => entry != null)
+                .Select(entry => entry!)
+                .OrderBy(entry => entry.Id, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(entry => entry.AssemblyName ?? "", StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+        }
+
+        private static Sts2ModInventoryEntry? TryBuildModInventoryEntry(Mod mod)
+        {
+            try
+            {
+                var manifest = ReadManifest(mod);
+                var assembly = ReadAssembly(mod);
+                var assemblyName = ResolveAssemblyName(assembly);
+                var errors = ReadErrors(mod);
+                var fallbackName = assemblyName?.Name ?? "<unknown>";
+                return new(
+                    manifest == null ? fallbackName : ReadManifestId(manifest) ?? fallbackName,
+                    manifest == null ? fallbackName : ReadManifestName(manifest) ?? fallbackName,
+                    manifest == null ? null : ReadManifestVersion(manifest),
+                    ReadLoadState(mod, errors.Count),
+                    ReadSource(mod),
+                    manifest == null || ReadManifestAffectsGameplay(manifest),
+                    assemblyName?.Name,
+                    assemblyName?.Version?.ToString(),
+                    errors);
+            }
+            catch (Exception ex)
+            {
+                RitsuLibFramework.Logger.Warn(
+                    $"[Compat] Failed to describe a registered mod for inventory telemetry: {ex.Message}");
+                return null;
+            }
+        }
+
+        private static Func<Mod, ModManifest?> CreateModManifestAccessor()
+        {
+            if (typeof(Mod).GetField("manifest", InstanceMemberFlags) != null)
+                return static mod => mod.manifest;
+
+            var getter = CreateUntypedMemberGetter(typeof(Mod), "manifest");
+            return mod => getter?.Invoke(mod) as ModManifest;
+        }
+
+        private static Func<Mod, Assembly?> CreateModAssemblyAccessor()
+        {
+            if (typeof(Mod).GetField("assembly", InstanceMemberFlags) != null)
+                return static mod => mod.assembly;
+
+            var getter = CreateUntypedMemberGetter(typeof(Mod), "assembly");
+            return mod => getter?.Invoke(mod) as Assembly;
+        }
+
+        private static Func<Mod, IReadOnlyList<LocString>> CreateModErrorsAccessor()
+        {
+            if (typeof(Mod).GetField("errors", InstanceMemberFlags) != null)
+                return static mod => NormalizeErrors(mod.errors);
+
+            var getter = CreateUntypedMemberGetter(typeof(Mod), "errors");
+            return mod => NormalizeErrors(getter?.Invoke(mod) as IEnumerable<LocString>);
+        }
+
+        private static Func<Mod, string> CreateModSourceAccessor()
+        {
+            if (typeof(Mod).GetField("modSource", InstanceMemberFlags) != null)
+                return static mod => mod.modSource.ToString();
+
+            var getter = CreateUntypedMemberGetter(typeof(Mod), "modSource");
+            return mod => getter?.Invoke(mod)?.ToString() ?? "None";
+        }
+
+        private static Func<Mod, int, string> CreateLoadStateAccessor()
+        {
+            if (typeof(Mod).GetField("state", InstanceMemberFlags) != null)
+                return static (mod, _) => mod.state.ToString();
+
+            var stateGetter = CreateUntypedMemberGetter(typeof(Mod), "state");
+            var wasLoadedGetter = CreateUntypedMemberGetter(typeof(Mod), "wasLoaded");
+            var assemblyLoadedSuccessfullyGetter =
+                CreateUntypedMemberGetter(typeof(Mod), "assemblyLoadedSuccessfully");
+            return (mod, errorCount) =>
+            {
+                if (stateGetter?.Invoke(mod) is { } stateValue)
+                    return stateValue.ToString() ?? "None";
+
+                if (ReadBool(wasLoadedGetter, mod) == true)
+                    return "Loaded";
+
+                if (ReadBool(assemblyLoadedSuccessfullyGetter, mod) == false || errorCount > 0)
+                    return "Failed";
+
+                return "None";
+            };
+        }
+
+        private static Func<ModManifest, string?> CreateManifestStringAccessor(
+            string memberName,
+            Func<ModManifest, string?> directAccessor)
+        {
+            if (typeof(ModManifest).GetField(memberName, InstanceMemberFlags) != null)
+                return directAccessor;
+
+            var getter = CreateUntypedMemberGetter(typeof(ModManifest), memberName);
+            return manifest => getter?.Invoke(manifest) as string;
+        }
+
+        private static Func<ModManifest, bool> CreateManifestBoolAccessor(
+            string memberName,
+            Func<ModManifest, bool> directAccessor,
+            bool defaultValue)
+        {
+            if (typeof(ModManifest).GetField(memberName, InstanceMemberFlags) != null)
+                return directAccessor;
+
+            var getter = CreateUntypedMemberGetter(typeof(ModManifest), memberName);
+            return manifest => ReadBool(getter, manifest) ?? defaultValue;
+        }
+
+        private static AssemblyName? ResolveAssemblyName(Assembly? assembly)
+        {
+            if (assembly == null)
+                return null;
+
+            try
+            {
+                return assembly.GetName();
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static IReadOnlyList<LocString> NormalizeErrors(IEnumerable<LocString>? errors)
+        {
+            return errors?.Where(error => error != null).ToArray() ?? [];
+        }
+
+        private static bool? ReadBool(Func<object, object?>? getter, object target)
+        {
+            return getter?.Invoke(target) is bool value ? value : null;
+        }
+
+        private static Func<object, object?>? CreateUntypedMemberGetter(Type type, string memberName)
+        {
+            var field = type.GetField(memberName, InstanceMemberFlags);
+            if (field != null)
+                return field.GetValue;
+
+            var property = type.GetProperty(memberName, InstanceMemberFlags);
+            if (property == null)
+                return null;
+
+            var getter = property.GetGetMethod(true);
+            if (getter == null)
+                return property.GetValue;
+
+            try
+            {
+                return CreateUntypedPropertyGetter(type, property.PropertyType, getter);
+            }
+            catch
+            {
+                return target => getter.Invoke(target, null);
+            }
+        }
+
+        private static Func<object, object?> CreateUntypedPropertyGetter(
+            Type declaringType,
+            Type valueType,
+            MethodInfo getter)
+        {
+            var method = typeof(Sts2ModManagerCompat)
+                .GetMethod(nameof(CreateUntypedPropertyGetterCore), BindingFlags.Static | BindingFlags.NonPublic)!
+                .MakeGenericMethod(declaringType, valueType);
+            return (Func<object, object?>)method.Invoke(null, [getter])!;
+        }
+
+        private static Func<object, object?> CreateUntypedPropertyGetterCore<TDeclaring, TValue>(
+            MethodInfo getter)
+        {
+            var typedGetter = getter.CreateDelegate<Func<TDeclaring, TValue>>();
+
+            return target => typedGetter((TDeclaring)target);
+        }
     }
+
+    internal sealed record Sts2ModInventoryEntry(
+        string Id,
+        string Name,
+        string? Version,
+        string State,
+        string Source,
+        bool AffectsGameplay,
+        string? AssemblyName,
+        string? AssemblyVersion,
+        IReadOnlyList<LocString> Errors);
 }

Const.cs

@@ -22,7 +22,7 @@ public static class Const
         ///     Assembly / manifest version string.
         ///     程序集/清单版本字符串。
         /// </summary>
-        public const string Version = "0.2.37";
+        public const string Version = "0.2.38";
 
         /// <summary>
         ///     Root key for RitsuLib JSON settings under the mod’s user folder.

STS2-RitsuLib.csproj

@@ -33,7 +33,7 @@
 
     <PropertyGroup Label="NuGet package">
         <IsPackable>true</IsPackable>
-        <Version>0.2.37</Version>
+        <Version>0.2.38</Version>
         <Authors>OLC</Authors>
         <Description>Shared framework library for Slay the Spire 2 mods.</Description>
         <PackageReadmeFile>README.md</PackageReadmeFile>

Telemetry/Adapters/HttpJsonTelemetryAdapter.cs

@@ -9,7 +9,11 @@ namespace STS2RitsuLib.Telemetry
     /// </summary>
     public sealed class HttpJsonTelemetryAdapter : ITelemetryAdapter
     {
-        private static readonly HttpClient Client = new();
+        private static readonly HttpClient Client = new()
+        {
+            Timeout = TimeSpan.FromSeconds(60),
+        };
+
         private readonly IReadOnlyDictionary<string, string> _headers;
 
         /// <summary>
@@ -48,21 +52,32 @@ public async ValueTask<TelemetrySendResult> SendAsync(
                 events,
             }, TelemetryJson.Options);
 
-            using var request = new HttpRequestMessage(HttpMethod.Post, Endpoint);
-            request.Content = new StringContent(body, Encoding.UTF8, "application/json");
+            try
+            {
+                using var request = new HttpRequestMessage(HttpMethod.Post, Endpoint);
+                request.Content = new StringContent(body, Encoding.UTF8, "application/json");
 
-            foreach (var header in _headers)
-                request.Headers.TryAddWithoutValidation(header.Key, header.Value);
+                foreach (var header in _headers)
+                    request.Headers.TryAddWithoutValidation(header.Key, header.Value);
 
-            using var response = await Client.SendAsync(request, cancellationToken);
-            if (response.IsSuccessStatusCode)
-                return TelemetrySendResult.Ok();
+                using var response = await Client.SendAsync(request, cancellationToken);
+                if (response.IsSuccessStatusCode)
+                    return TelemetrySendResult.Ok();
 
-            var responseBody = await response.Content.ReadAsStringAsync(cancellationToken);
-            var reason = string.IsNullOrWhiteSpace(responseBody)
-                ? $"{(int)response.StatusCode} {response.ReasonPhrase}"
-                : $"{(int)response.StatusCode} {response.ReasonPhrase}: {responseBody}";
-            return TelemetrySendResult.Fail(reason);
+                var responseBody = await response.Content.ReadAsStringAsync(cancellationToken);
+                var reason = string.IsNullOrWhiteSpace(responseBody)
+                    ? $"{(int)response.StatusCode} {response.ReasonPhrase}"
+                    : $"{(int)response.StatusCode} {response.ReasonPhrase}: {responseBody}";
+                return TelemetrySendResult.Fail(reason);
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            {
+                return TelemetrySendResult.Fail($"Timed out posting telemetry to {Endpoint}.");
+            }
+            catch (Exception ex)
+            {
+                return TelemetrySendResult.Fail(ex.Message);
+            }
         }
     }
 }

Telemetry/Adapters/PostHogTelemetryAdapter.cs

@@ -9,7 +9,10 @@ namespace STS2RitsuLib.Telemetry
     /// </summary>
     public sealed class PostHogTelemetryAdapter : ITelemetryAdapter
     {
-        private static readonly HttpClient Client = new();
+        private static readonly HttpClient Client = new()
+        {
+            Timeout = TimeSpan.FromSeconds(60),
+        };
 
         /// <summary>
         ///     Creates a PostHog adapter for a fixed host and project API key.
@@ -63,14 +66,25 @@ public async ValueTask<TelemetrySendResult> SendAsync(
                 batch,
             }, TelemetryJson.Options);
 
-            using var response = await Client.PostAsync(
-                new Uri(Host, "/batch/"),
-                new StringContent(body, Encoding.UTF8, "application/json"),
-                cancellationToken);
+            try
+            {
+                using var response = await Client.PostAsync(
+                    new Uri(Host, "/batch/"),
+                    new StringContent(body, Encoding.UTF8, "application/json"),
+                    cancellationToken);
 
-            return response.IsSuccessStatusCode
-                ? TelemetrySendResult.Ok()
-                : TelemetrySendResult.Fail($"{(int)response.StatusCode} {response.ReasonPhrase}");
+                return response.IsSuccessStatusCode
+                    ? TelemetrySendResult.Ok()
+                    : TelemetrySendResult.Fail($"{(int)response.StatusCode} {response.ReasonPhrase}");
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            {
+                return TelemetrySendResult.Fail($"Timed out posting telemetry to {Host}.");
+            }
+            catch (Exception ex)
+            {
+                return TelemetrySendResult.Fail(ex.Message);
+            }
         }
 
         private static Dictionary<string, object?> BuildProperties(TelemetryEnvelope evt)