feat: default user agent (#389)

* feat: default user agent

* fix: Fabric version detection

* refactor: remove junit test

* refactor: read mod loader info in bootstrap

* Optimize mod loader version retrieval

---------

Co-authored-by: ZekerZhayard <[email protected]>
This commit is contained in:
Steven QiuandZekerZhayard authored and GitHub committed 2026-08-12 20:19:00 +08:00
1 parent ebea66d261
commit 873705c4fb
14 files changed
+194 -16

No files matched your search

@@ -0,0 +1,22 @@
package customskinloader.bootstrap;
public final class ModLoaderInfo {
public static final String NAME_PROPERTY = "customskinloader.modLoader.name";
public static final String VERSION_PROPERTY = "customskinloader.modLoader.version";
private ModLoaderInfo() {
}
public static void publish(String name, String version) {
if (name == null || name.trim().isEmpty()) {
throw new IllegalArgumentException("Mod loader name must not be empty");
}
if (version == null || version.trim().isEmpty()) {
throw new IllegalArgumentException("Mod loader version must not be empty");
}
System.setProperty(NAME_PROPERTY, name);
System.setProperty(VERSION_PROPERTY, version);
BootstrapLogger.LOGGER.info("Detected mod loader " + name + " " + version);
}
}
@@ -0,0 +1,51 @@
package customskinloader.bootstrap.util;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.lang3.tuple.Triple;
public class ReflectionUtils {
private static final Map<String, Class<?>> CLASSES = new ConcurrentHashMap<>();
private static final Map<Pair<Class<?>, String>, Field> FIELDS = new ConcurrentHashMap<>();
private static final Map<Triple<Class<?>, String, List<Class<?>>>, Method> METHODS = new ConcurrentHashMap<>();
public static Class<?> findClass(String className) {
return CLASSES.computeIfAbsent(className, k -> {
try {
return Class.forName(k);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
});
}
public static Field findField(Class<?> clazz, String fieldName) {
return FIELDS.computeIfAbsent(Pair.of(clazz, fieldName), k -> {
try {
Field f = k.getLeft().getDeclaredField(k.getRight());
f.setAccessible(true);
return f;
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
}
});
}
public static Method findMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
return METHODS.computeIfAbsent(Triple.of(clazz, methodName, Arrays.asList(parameterTypes)), k -> {
try {
Method m = k.getLeft().getDeclaredMethod(k.getMiddle(), k.getRight().toArray(new Class<?>[0]));
m.setAccessible(true);
return m;
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
});
}
}
@@ -10,6 +10,7 @@ import java.util.Map;
import java.util.Set;
import customskinloader.bootstrap.BootstrapLogger;
import customskinloader.bootstrap.ModLoaderInfo;
import customskinloader.bootstrap.installer.CommonJarInstaller;
import customskinloader.bootstrap.transformer.ClassTransformationReport;
import customskinloader.bootstrap.transformer.TransformerBootstrapSupport;
@@ -35,6 +36,7 @@ final class TransformerBootstrap {
public static void initialize() {
LOGGER.info("Initializing CustomSkinLoader Bootstrap for Fabric");
publishModLoaderInfo();
releaseRuntimeArtifacts();
int targetCount = 0;
for (String targetClassName : SUPPORT.collectTargetClassNames()) {
@@ -44,6 +46,10 @@ final class TransformerBootstrap {
LOGGER.info("Initialized CustomSkinLoader Bootstrap for Fabric with " + targetCount + " reflected Mixin target(s)");
}
private static void publishModLoaderInfo() {
ModLoaderInfo.publish("Fabric", FabricLoader.getInstance().getModContainer("fabricloader").map(m -> m.getMetadata().getVersion().getFriendlyString()).orElse("unknown"));
}
private static void releaseRuntimeArtifacts() {
try {
Path commonJar = CommonJarInstaller.releaseCommonJar(FabricLoader.getInstance().getGameDir(), "intermediary");
@@ -6,10 +6,12 @@ import java.nio.file.Paths;
import java.util.Map;
import customskinloader.bootstrap.BootstrapLogger;
import customskinloader.bootstrap.ModLoaderInfo;
import customskinloader.bootstrap.installer.CommonJarInstaller;
import customskinloader.bootstrap.transformer.ClassTransformationReport;
import customskinloader.bootstrap.transformer.TransformerBootstrapSupport;
import net.minecraft.launchwrapper.LaunchClassLoader;
import net.minecraftforge.fml.relauncher.FMLInjectionData;
import org.apache.logging.log4j.Logger;
import org.objectweb.asm.tree.ClassNode;
@@ -22,6 +24,9 @@ final class TransformerBootstrap {
public static void injectData(Map<String, Object> data) {
try {
Object[] version = FMLInjectionData.data();
ModLoaderInfo.publish("Forge", version[0] + "." + version[1] + "." + version[2] + "." + version[3]);
Path runtimeDirectory = resolveRuntimeDirectory(data);
LOGGER.info("Initializing CustomSkinLoader Bootstrap for Forge v1 in " + BootstrapLogger.formatPath(runtimeDirectory));
Path commonJar = CommonJarInstaller.releaseCommonJar(runtimeDirectory, "srg");
@@ -1,10 +1,9 @@
package customskinloader.bootstrap.forge.v2;
import customskinloader.bootstrap.util.ModLocatorUtils;
import net.minecraftforge.fml.loading.FMLPaths;
import net.minecraftforge.fml.loading.moddiscovery.ModsFolderLocator;
import customskinloader.bootstrap.util.ModLocatorUtils;
public final class CommonModLocator extends ModsFolderLocator {
public CommonModLocator() {
ModLocatorUtils.initialize(this, ModsFolderLocator.class, FMLPaths.GAMEDIR.get(), "srg");
@@ -24,6 +24,7 @@ public final class TransformationService implements ITransformationService {
@Override
public void initialize(IEnvironment environment) {
LOGGER.info("Initializing CustomSkinLoader Bootstrap transformation service");
TransformerBootstrap.publishModLoaderInfo();
try {
List<Path> extraLocators = ModDirTransformerDiscoverer.getExtraLocators();
Path servicePath = Paths.get(this.getClass().getProtectionDomain().getCodeSource().getLocation().toURI()).toAbsolutePath().normalize();
@@ -4,27 +4,59 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import cpw.mods.modlauncher.ArgumentHandler;
import cpw.mods.modlauncher.Launcher;
import cpw.mods.modlauncher.api.ITransformer;
import cpw.mods.modlauncher.api.ITransformerVotingContext;
import cpw.mods.modlauncher.api.TransformerVoteResult;
import customskinloader.bootstrap.BootstrapLogger;
import customskinloader.bootstrap.ModLoaderInfo;
import customskinloader.bootstrap.transformer.ClassTransformationReport;
import customskinloader.bootstrap.transformer.TransformerBootstrapSupport;
import customskinloader.bootstrap.util.ReflectionUtils;
import net.minecraftforge.fml.loading.FMLLoader;
import org.apache.logging.log4j.Logger;
import org.objectweb.asm.tree.ClassNode;
final class TransformerBootstrap {
private static final Logger LOGGER = BootstrapLogger.LOGGER;
private static final TransformerBootstrapSupport SUPPORT = new TransformerBootstrapSupport(TransformerBootstrap.class,
// official: neoforge 1.20.2-20.2.3 ~ 1.21.3-21.3.97
// srg: forge *, neoforge 1.21.4-21.4.0 ~ 1.21.9-21.9.13
Launcher.INSTANCE.environment().findLaunchHandler("forgeclient")
.map(handle -> handle.getClass().getName().startsWith("net.neoforged.")).orElse(false) ? "official" : "srg");
private TransformerBootstrap() {
}
public static void publishModLoaderInfo() {
try {
Object argumentHandler = ReflectionUtils.findField(Launcher.class, "argumentHandler").get(Launcher.INSTANCE);
String[] args = (String[]) ReflectionUtils.findField(ArgumentHandler.class, "args").get(argumentHandler);
for (int i = 0; i < args.length; i++) {
String arg = args[i];
if (Objects.equals(arg, "--fml.forgeVersion")) {
// forge 1.13.2-25.0.216 ~ 1.20.2-48.1.0
ModLoaderInfo.publish("Forge", args[i + 1]);
return;
} else if (Objects.equals(arg, "--fml.neoForgeVersion")) {
// neoforge 1.20.2-20.2.3 ~ 1.21.9-21.9.13
ModLoaderInfo.publish("NeoForge", args[i + 1]);
return;
}
}
// forge 1.20.3-49.0.1+
ModLoaderInfo.publish("Forge", FMLLoader.class.getPackage().getImplementationVersion());
} catch (Exception e) {
LOGGER.warn("Could not determine mod loader", e);
ModLoaderInfo.publish("Forge", "unknown");
}
}
public static List<ITransformer> buildTransformers() {
List<ITransformer> transformers = new ArrayList<>();
for (String targetClassName : SUPPORT.collectTargetClassNames()) {
@@ -9,6 +9,7 @@ public final class CommonModLocator extends ModsFolderLocator {
ModLocatorUtils.initialize(this, ModsFolderLocator.class, FMLPaths.GAMEDIR.get(), "official");
}
@Override
public String name() {
return ModLocatorUtils.LOCATOR_NAME;
}
@@ -1,9 +1,12 @@
package customskinloader.bootstrap.neoforge.v2;
import customskinloader.bootstrap.BootstrapLogger;
import customskinloader.bootstrap.ModLoaderInfo;
import net.neoforged.fml.loading.FMLLoader;
import net.neoforged.neoforgespi.transformation.ClassProcessorProvider;
import org.apache.logging.log4j.Logger;
// NeoForge 21.9.14+
public final class ClassProcessorProviderImpl implements ClassProcessorProvider {
private static final Logger LOGGER = BootstrapLogger.LOGGER;
@@ -11,6 +14,7 @@ public final class ClassProcessorProviderImpl implements ClassProcessorProvider
public void createProcessors(Context context, Collector collector) {
// Always register the bridge processor so late transformer registrations can still be observed.
LOGGER.info("Registering CustomSkinLoader Bootstrap NeoForge class processor");
ModLoaderInfo.publish("NeoForge", FMLLoader.getCurrent().getVersionInfo().neoForgeVersion());
collector.add(TransformerBootstrap.createProcessor());
}
}
@@ -4,6 +4,7 @@ import customskinloader.bootstrap.util.ModLocatorUtils;
import net.neoforged.fml.loading.FMLPaths;
import net.neoforged.fml.loading.moddiscovery.locators.ModsFolderLocator;
// NeoForge 20.6.14+
public final class CommonModLocator extends ModsFolderLocator {
public CommonModLocator() {
ModLocatorUtils.initialize(this, ModsFolderLocator.class, FMLPaths.GAMEDIR.get(), "official");