Add in-game updater (#1050)

Co-authored-by: IRONM00N <64110067+IRONM00N@users.noreply.github.com>

25 files changed, 663 insertions, 566 deletions

diff --git a/src/main/java-templates/io/github/moulberry/notenoughupdates/VersionConst.java b/src/main/java-templates/io/github/moulberry/notenoughupdates/VersionConst.java
new file mode 100644
index 00000000..65638aff
--- /dev/null
+++ b/src/main/java-templates/io/github/moulberry/notenoughupdates/VersionConst.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2024 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates;
+
+public class VersionConst {
+	public static final String VERSION = "{{ neuVersion }}";
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/NotEnoughUpdates.java b/src/main/java/io/github/moulberry/notenoughupdates/NotEnoughUpdates.java
index 21a92faa..b129e644 100644
--- a/src/main/java/io/github/moulberry/notenoughupdates/NotEnoughUpdates.java
+++ b/src/main/java/io/github/moulberry/notenoughupdates/NotEnoughUpdates.java
@@ -23,6 +23,7 @@ import com.google.common.collect.Sets;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonObject;
+import io.github.moulberry.moulconfig.observer.PropertyTypeAdapterFactory;
 import io.github.moulberry.notenoughupdates.autosubscribe.AutoLoad;
 import io.github.moulberry.notenoughupdates.autosubscribe.NEUAutoSubscribe;
 import io.github.moulberry.notenoughupdates.core.BackgroundBlur;
@@ -46,7 +47,6 @@ import io.github.moulberry.notenoughupdates.miscfeatures.StorageManager;
 import io.github.moulberry.notenoughupdates.miscfeatures.customblockzones.CustomBlockSounds;
 import io.github.moulberry.notenoughupdates.miscfeatures.inventory.MuseumCheapestItemOverlay;
 import io.github.moulberry.notenoughupdates.miscfeatures.inventory.MuseumItemHighlighter;
-import io.github.moulberry.notenoughupdates.miscfeatures.updater.AutoUpdater;
 import io.github.moulberry.notenoughupdates.mixins.AccessorMinecraft;
 import io.github.moulberry.notenoughupdates.oneconfig.IOneConfigCompat;
 import io.github.moulberry.notenoughupdates.options.NEUConfig;
@@ -88,6 +88,8 @@ import java.awt.*;
 import java.io.File;
 import java.util.HashMap;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 @NEUAutoSubscribe
 @Mod(
@@ -95,10 +97,29 @@ import java.util.Set;
 	guiFactory = "io.github.moulberry.notenoughupdates.core.config.MoulConfigGuiForgeInterop")
 public class NotEnoughUpdates {
 	public static final String MODID = "notenoughupdates";
-	public static final String VERSION = "2.1.1-PRE";
-	public static final int VERSION_ID = 20106; //2.1.1 only so update notif works
-	public static final int PRE_VERSION_ID = 0;
-	public static final int HOTFIX_VERSION_ID = 0;
+	public static final String VERSION = VersionConst.VERSION;
+	private static final Pattern versionPattern = Pattern.compile("([0-9]+)\\.([0-9]+)\\.([0-9]+)");
+	public static final int VERSION_ID = parseVersion(VERSION);
+
+	private static int parseVersion(String versionName) {
+		Matcher matcher = versionPattern.matcher(versionName);
+		if (!matcher.matches()) {
+			return 0;
+		}
+		int major = Integer.parseInt(matcher.group(1));
+		if (major < 0 || major > 99) {
+			return 0;
+		}
+		int minor = Integer.parseInt(matcher.group(2));
+		if (minor < 0 || minor > 99) {
+			return 0;
+		}
+		int patch = Integer.parseInt(matcher.group(3));
+		if (patch < 0 || patch > 99) {
+			return 0;
+		}
+		return major * 10000 + minor * 100 + patch;
+	}
 
 	public static final Logger LOGGER = LogManager.getLogger("NotEnoughUpdates");
 	/**
@@ -152,6 +173,7 @@ public class NotEnoughUpdates {
 	}};
 	public static ProfileViewer profileViewer;
 	private final Gson gson = new GsonBuilder().setPrettyPrinting().excludeFieldsWithoutExposeAnnotation()
+																						 .registerTypeAdapterFactory(new PropertyTypeAdapterFactory())
 																						 .registerTypeAdapterFactory(KotlinTypeAdapterFactory.INSTANCE).create();
 	public NEUManager manager;
 	public NEUOverlay overlay;
@@ -161,7 +183,6 @@ public class NotEnoughUpdates {
 	public long lastOpenedGui = 0;
 	public boolean packDevEnabled = false;
 	public Color[][] colourMap = null;
-	public AutoUpdater autoUpdater = new AutoUpdater(this);
 	private File configFile;
 	private long lastChatMessage = 0;
 	private long secondLastChatMessage = 0;
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/listener/NEUEventListener.java b/src/main/java/io/github/moulberry/notenoughupdates/listener/NEUEventListener.java
index 15f1a954..7cb39a96 100644
--- a/src/main/java/io/github/moulberry/notenoughupdates/listener/NEUEventListener.java
+++ b/src/main/java/io/github/moulberry/notenoughupdates/listener/NEUEventListener.java
@@ -215,10 +215,6 @@ public class NEUEventListener {
 				if (!joinedSB) {
 					joinedSB = true;
 
-					if (NotEnoughUpdates.INSTANCE.config.notifications.updateChannel != 0) {
-						NotEnoughUpdates.INSTANCE.autoUpdater.displayUpdateMessageIfOutOfDate();
-					}
-
 					if (NotEnoughUpdates.INSTANCE.config.notifications.doRamNotif) {
 						long maxMemoryMB = Runtime.getRuntime().maxMemory() / 1024L / 1024L;
 						if (maxMemoryMB > 4100) {
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/AutoUpdater.java b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/AutoUpdater.java
deleted file mode 100644
index ac77d276..00000000
--- a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/AutoUpdater.java
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * Copyright (C) 2022 NotEnoughUpdates contributors
- *
- * This file is part of NotEnoughUpdates.
- *
- * NotEnoughUpdates is free software: you can redistribute it
- * and/or modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation, either
- * version 3 of the License, or (at your option) any later version.
- *
- * NotEnoughUpdates is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
- */
-
-package io.github.moulberry.notenoughupdates.miscfeatures.updater;
-
-import com.google.common.collect.Iterables;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonPrimitive;
-import com.google.gson.JsonSyntaxException;
-import io.github.moulberry.notenoughupdates.NotEnoughUpdates;
-import io.github.moulberry.notenoughupdates.util.MoulSigner;
-import io.github.moulberry.notenoughupdates.util.NotificationHandler;
-import io.github.moulberry.notenoughupdates.util.Utils;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.event.ClickEvent;
-import net.minecraft.event.HoverEvent;
-import net.minecraft.util.ChatComponentText;
-import net.minecraft.util.ChatStyle;
-import net.minecraft.util.EnumChatFormatting;
-import net.minecraft.util.IChatComponent;
-import net.minecraftforge.fml.common.Loader;
-import org.apache.commons.lang3.SystemUtils;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.Arrays;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
-
-public class AutoUpdater {
-
-	NotEnoughUpdates neu;
-
-	public AutoUpdater(NotEnoughUpdates neu) {
-		this.neu = neu;
-	}
-
-	public void logProgress(String str) {
-		logProgress(new ChatComponentText(str));
-	}
-
-	public void logProgress(IChatComponent chatComponent) {
-		Minecraft.getMinecraft().addScheduledTask(() -> {
-			IChatComponent chatComponent1 = new ChatComponentText("");
-			chatComponent1.setChatStyle(new ChatStyle().setColor(EnumChatFormatting.AQUA));
-			chatComponent1.appendSibling(chatComponent);
-			Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§e[NEU-AutoUpdater] ").appendSibling(
-				chatComponent1));
-		});
-	}
-
-	public UpdateLoader getUpdateLoader(URL url) {
-		if (SystemUtils.IS_OS_UNIX) {
-			return new LinuxBasedUpdater(this, url);
-		}
-		if (Loader.isModLoaded("skyblockclientupdater") && SCUCompatUpdater.IS_ENABLED) {
-			return SCUCompatUpdater.tryCreate(this, url);
-		}
-		return null;
-	}
-
-	UpdateLoader updateLoader;
-
-	public void updateFromURL(URL url) {
-		if (updateLoader != null) {
-			logProgress(
-				"There is already an update in progress, so the auto updater cannot process this update (as it might already be installed or is currently being downloaded). Please restart your client to install another update");
-			return;
-		}
-		if (!"https".equals(url.getProtocol())) {
-			logProgress("§cInvalid protocol in url: " + url + ". Only https is a valid protocol.");
-			return;
-		}
-		updateLoader = getUpdateLoader(url);
-		if (updateLoader == null) {
-			return;
-		}
-		updateLoader.greet();
-		logProgress(new ChatComponentText("[Start download now]")
-			.setChatStyle(new ChatStyle()
-				.setColor(EnumChatFormatting.GREEN)
-				.setChatHoverEvent(new HoverEvent(
-					HoverEvent.Action.SHOW_TEXT,
-					new ChatComponentText("Click to start download.")
-				))
-				.setChatClickEvent(new ClickEvent(
-					ClickEvent.Action.RUN_COMMAND,
-					"/neuupdate scheduleDownload"
-				))));
-	}
-
-	public void scheduleDownload() {
-		if (updateLoader == null) {
-			logProgress("§cNo update found. Try running /neuupdate check first");
-			return;
-		}
-		if (updateLoader.getState() != UpdateLoader.State.NOTHING) {
-			logProgress("§cUpdate download already started. No need to start the download again.");
-			return;
-		}
-		logProgress("Download started.");
-		updateLoader.scheduleDownload();
-	}
-
-	private void displayUpdateMessage(
-		JsonObject updateJson,
-		String updateMessage,
-		String downloadLink,
-		String directDownload
-	) {
-		int firstWidth = -1;
-
-		for (String line : Iterables.concat(Arrays.asList(updateMessage.split("\n")), Arrays.asList("Download here"))) {
-			FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
-			boolean isDownloadLink = line.equals("Download here");
-			int width = fr.getStringWidth(line);
-			if (firstWidth == -1) {
-				firstWidth = width;
-			}
-			int missingLen = firstWidth - width;
-			if (missingLen > 0) {
-				StringBuilder sb = new StringBuilder(missingLen / 4 / 2 + line.length());
-				for (int i = 0; i < missingLen / 4 / 2; i++) { /* fr.getCharWidth(' ') == 4 */
-					sb.append(" ");
-				}
-				sb.append(line);
-				line = sb.toString();
-			}
-			ChatComponentText cp = new ChatComponentText(line);
-			if (isDownloadLink)
-				cp.setChatStyle(Utils.createClickStyle(ClickEvent.Action.OPEN_URL, downloadLink));
-			Minecraft.getMinecraft().thePlayer.addChatMessage(cp);
-		}
-		neu.displayLinks(updateJson, firstWidth);
-		NotificationHandler.displayNotification(Arrays.asList(
-			"",
-			"§eThere is a new version of NotEnoughUpdates available.",
-			"§eCheck the chat for more information"
-		), false);
-		try {
-			if (directDownload != null)
-				updateFromURL(new URL(directDownload));
-		} catch (MalformedURLException e) {
-			e.printStackTrace();
-		}
-	}
-
-	public void displayUpdateMessageIfOutOfDate() {
-		File repo = neu.manager.repoLocation;
-		File updateJson = new File(repo, "update.json");
-		if (updateJson.exists()) {
-			if (!MoulSigner.verifySignature(updateJson)) {
-				NotEnoughUpdates.LOGGER.error("update.json found without signature");
-				Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(
-					"§e[NEU] §cThere has been an error checking for updates. Check the log or join the discord for more information.").setChatStyle(
-					Utils.createClickStyle(
-						ClickEvent.Action.OPEN_URL, "https://discord.gg/moulberry")));
-				return;
-			}
-			try {
-				JsonObject o = neu.manager.getJsonFromFile(updateJson);
-
-				int fullReleaseVersion =
-					o.has("version_id") && o.get("version_id").isJsonPrimitive() ? o.get("version_id").getAsInt() : -1;
-				int preReleaseVersion =
-					o.has("pre_version_id") && o.get("pre_version_id").isJsonPrimitive() ? o.get("pre_version_id").getAsInt() : -1;
-				int hotfixVersion =
-					o.has("hotfix_id") && o.get("hotfix_id").isJsonPrimitive() ? o.get("hotfix_id").getAsInt() : -1;
-
-				boolean hasFullReleaseAvailableForUpgrade = fullReleaseVersion > NotEnoughUpdates.VERSION_ID;
-				boolean hasHotfixAvailableForUpgrade =
-					fullReleaseVersion == NotEnoughUpdates.VERSION_ID && hotfixVersion > NotEnoughUpdates.HOTFIX_VERSION_ID;
-				boolean hasPreReleaseAvailableForUpdate =
-					fullReleaseVersion == NotEnoughUpdates.VERSION_ID && preReleaseVersion > NotEnoughUpdates.PRE_VERSION_ID;
-
-				int updateChannel = NotEnoughUpdates.INSTANCE.config.notifications.updateChannel; /* 1 = Full, 2 = Pre */
-				if (hasFullReleaseAvailableForUpgrade || (hasHotfixAvailableForUpgrade && updateChannel == 1)) {
-					displayUpdateMessage(
-						o,
-						o.get("update_msg").getAsString(),
-						o.get("update_link").getAsString(),
-						o.has("update_direct") ? o.get("update_direct").getAsString() : null
-					);
-				} else if (hasPreReleaseAvailableForUpdate && updateChannel == 2) {
-					displayUpdateMessage(
-						o,
-						o.get("pre_update_msg").getAsString(),
-						o.get("pre_update_link").getAsString(),
-						o.has("pre_update_direct") ? o.get("pre_update_direct").getAsString() : null
-					);
-				}
-			} catch (Exception e) {
-				e.printStackTrace();
-				Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(
-					"§e[NEU] §cThere has been an error checking for updates. Check the log or join the discord for more information.").setChatStyle(
-					Utils.createClickStyle(
-						ClickEvent.Action.OPEN_URL, "https://discord.gg/moulberry")));
-			}
-		}
-	}
-
-	private boolean validateMcModInfo(JsonArray array) {
-		if (array.size() != 1) return false;
-		JsonElement jsonElement = array.get(0);
-		if (!jsonElement.isJsonObject()) return false;
-		JsonObject jsonObject = jsonElement.getAsJsonObject();
-		if (!jsonObject.has("modid")) return false;
-		JsonElement modid = jsonObject.get("modid");
-		if (!modid.isJsonPrimitive()) return false;
-		JsonPrimitive primitive = modid.getAsJsonPrimitive();
-		if (!primitive.isString()) return false;
-		return "notenoughupdates".equals(primitive.getAsString());
-	}
-
-	public boolean isNeuJar(File sus) {
-		try (ZipFile zipFile = new ZipFile(sus)) {
-			ZipEntry entry = zipFile.getEntry("mcmod.info");
-			if (entry == null) {
-				return false;
-			}
-			try (InputStream inputStream = zipFile.getInputStream(entry)) {
-				JsonArray jsonArray = neu.manager.gson.fromJson(
-					new InputStreamReader(inputStream),
-					JsonArray.class
-				);
-				return validateMcModInfo(jsonArray);
-			}
-		} catch (IOException | JsonSyntaxException e) {
-			e.printStackTrace();
-		}
-		return false;
-	}
-}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/LinuxBasedUpdater.java b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/LinuxBasedUpdater.java
deleted file mode 100644
index 3118b135..00000000
--- a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/LinuxBasedUpdater.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2022 NotEnoughUpdates contributors
- *
- * This file is part of NotEnoughUpdates.
- *
- * NotEnoughUpdates is free software: you can redistribute it
- * and/or modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation, either
- * version 3 of the License, or (at your option) any later version.
- *
- * NotEnoughUpdates is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
- */
-
-package io.github.moulberry.notenoughupdates.miscfeatures.updater;
-
-import java.io.File;
-import java.net.URL;
-import java.util.List;
-
-class LinuxBasedUpdater /* Based on what? */ extends UpdateLoader {
-
-	LinuxBasedUpdater(AutoUpdater updater, URL url) {
-		super(updater, url);
-	}
-
-	@Override
-	public void greet() {
-		updater.logProgress(
-			"Welcome Aristocrat! Your superior linux system configuration is supported for NEU auto updates.");
-	}
-
-	@Override
-	public void deleteFiles(List<File> toDelete) {
-		for (File toDel : toDelete) {
-			if (!toDel.delete()) {
-				updater.logProgress("§cCould not delete old version of NEU: " + toDel + ". Please manually delete file.");
-				state = State.FAILED;
-			}
-		}
-	}
-}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SCUCompatUpdater.java b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SCUCompatUpdater.java
deleted file mode 100644
index 3cb600cb..00000000
--- a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SCUCompatUpdater.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (C) 2022 NotEnoughUpdates contributors
- *
- * This file is part of NotEnoughUpdates.
- *
- * NotEnoughUpdates is free software: you can redistribute it
- * and/or modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation, either
- * version 3 of the License, or (at your option) any later version.
- *
- * NotEnoughUpdates is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
- */
-
-package io.github.moulberry.notenoughupdates.miscfeatures.updater;
-
-import java.io.File;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.util.List;
-
-/*
- * Legal considerations: Skyblock Client Updater is licensed under the GNU AGPL v3.0 or later (with modifications).
- * https://github.com/My-Name-Is-Jeff/SkyblockClient-Updater/blob/main/LICENSE
- *
- * However, even tho the AGPL License does not allow conveying covered work in combination with LGPL licensed code
- * (such as our own), we do not perceive ourselves as conveying neither an unmodified version of Skyblock Client Updater
- * nor a work based on Skyblock Client Updater (modified work) since our work is usable and functional in its entirety
- * without presence of Skyblock Client Updater and is not to be distributed along a copy of Skyblock Client Updater
- * unless that combined work is licensed with respect of both the LGPL and the AGPL, therefore is not adapting any part
- * of Skyblock Client Updater unless already part of a whole distribution.
- *
- * In case the Copyright owner (Lily aka My-Name-Is-Jeff on Github) disagrees, we are willing to take down this module
- * (or only convey this component of our work under a pure GPL license) with or without them providing legal grounds
- * for this request. However, due to them not being able to be reached for comment, we will include this
- * component for the time being.
- * */
-public class SCUCompatUpdater extends UpdateLoader {
-
-	public static final boolean IS_ENABLED = false;
-
-	private SCUCompatUpdater(AutoUpdater updater, URL url) {
-		super(updater, url);
-	}
-
-	@Override
-	public void greet() {
-		updater.logProgress("Skyblock Client Updater compatibility layer loaded.");
-	}
-
-	@Override
-	public void deleteFiles(List<File> toDelete) {
-		try {
-			for (File f : toDelete)
-				ReflectionHolder.deleteFileOnShutdownHandle.invoke(ReflectionHolder.updateCheckerInstance, f, "");
-		} catch (Throwable e) {
-			e.printStackTrace();
-			updater.logProgress("Invoking SCU failed. Check the log for more info.");
-			state = State.FAILED;
-		}
-	}
-
-	static class ReflectionHolder {
-		static boolean isSCUFullyPresent = false;
-		static Class<?> updateChecker;
-		static Object updateCheckerInstance;
-		static Method deleteFileOnShutdown;
-		static MethodHandle deleteFileOnShutdownHandle;
-
-		static {
-			try {
-				updateChecker = Class.forName("mynameisjeff.skyblockclientupdater.utils.UpdateChecker");
-				Field instanceField = updateChecker.getDeclaredField("INSTANCE");
-				instanceField.setAccessible(true);
-				updateCheckerInstance = instanceField.get(null);
-				deleteFileOnShutdown = updateChecker.getDeclaredMethod("deleteFileOnShutdown", File.class, String.class);
-				deleteFileOnShutdownHandle = MethodHandles.publicLookup().unreflect(deleteFileOnShutdown);
-				isSCUFullyPresent = true;
-			} catch (NoSuchFieldException | ClassNotFoundException | IllegalAccessException | NoSuchMethodException e) {
-				e.printStackTrace();
-			}
-		}
-	}
-
-	public static UpdateLoader tryCreate(AutoUpdater updater, URL url) {
-		if (!ReflectionHolder.isSCUFullyPresent) {
-			updater.logProgress("§cFound Skyclient Updater Mod, however our hooks did not function properly.");
-			return null;
-		}
-		return new SCUCompatUpdater(updater, url);
-	}
-}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SigningGithubSource.kt b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SigningGithubSource.kt
new file mode 100644
index 00000000..b8c804ff
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SigningGithubSource.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2024 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.miscfeatures.updater
+
+import moe.nea.libautoupdate.GithubReleaseUpdateSource
+import moe.nea.libautoupdate.UpdateData
+import java.io.ByteArrayInputStream
+import java.io.File
+import java.net.URL
+
+class SigningGithubSource(username: String, repo: String) :
+    GithubReleaseUpdateSource(username, repo) {
+
+    val hashRegex = "sha256sum: `(?<hash>[a-fA-F0-9]{64})`".toPattern()
+    override fun findAsset(release: GithubRelease): UpdateData? {
+        var asset = super.findAsset(release) ?: return null
+        val match = release.body.lines()
+            .firstNotNullOfOrNull { line -> hashRegex.matcher(line).takeIf { it.matches() } }
+            ?: return null
+        // Inject our custom sha256sum
+        asset = UpdateData(asset.versionName, asset.versionNumber, match.group("hash"), asset.download)
+        // Verify at least 2 signatures are present on this release
+        if (!verifyAnySignature(release, asset))
+            return null
+        return asset
+    }
+
+    private fun verifyAnySignature(release: GithubRelease, asset: UpdateData): Boolean {
+        val signatories = findValidSignatories(release, asset)
+        for (signatory in signatories) {
+            println("Accepted signature from ${signatory.name}")
+        }
+        return signatories.size >= 2
+    }
+
+    fun findValidSignatories(release: GithubRelease, asset: UpdateData): List<GithubRelease.Download> {
+        val signatures = release.assets?.filter { it.name.endsWith(".asc") } ?: emptyList()
+        return signatures.filter { verifySignature(it, asset) }
+    }
+
+    fun verifySignature(signatureDownload: GithubRelease.Download, asset: UpdateData): Boolean {
+        val name = signatureDownload.name.substringBeforeLast('.').removePrefix("_")
+        val signatureBytes = URL(signatureDownload.browserDownloadUrl).openStream().readBytes()
+        val hashBytes = ByteArrayInputStream(asset.sha256.uppercase().encodeToByteArray())
+        return SigningPool.verifySignature(name, hashBytes, signatureBytes)
+    }
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SigningPool.kt b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SigningPool.kt
new file mode 100644
index 00000000..c75806c0
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/SigningPool.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2024 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.miscfeatures.updater
+
+import io.github.moulberry.notenoughupdates.util.JarUtil
+import java.io.InputStream
+import java.security.KeyFactory
+import java.security.PublicKey
+import java.security.Signature
+import java.security.spec.X509EncodedKeySpec
+
+
+object SigningPool {
+
+    data class PK(
+        val name: String,
+        val publicKey: PublicKey,
+    )
+
+    fun load(): List<PK> {
+        val l = JarUtil.access.listFiles("trusted_team_members")
+        return l.filter { it.endsWith(".key") }
+            .map {
+                loadPK(
+                    it.substringBeforeLast('.'),
+                    JarUtil.access.read("trusted_team_members/$it")
+                )
+            }
+    }
+
+    fun loadPK(name: String, inputStream: InputStream): PK {
+        val publicKeyBytes = inputStream.readBytes()
+        val x509EncodedKeySpec = X509EncodedKeySpec(publicKeyBytes)
+        return PK(name, KeyFactory.getInstance("RSA").generatePublic(x509EncodedKeySpec))
+    }
+
+    val keyPool = load().associateBy { it.name }
+
+    fun verifySignature(name: String, inputStream: InputStream, signatureBytes: ByteArray): Boolean {
+        val signature = Signature.getInstance("SHA256withRSA")
+        signature.initVerify(keyPool[name]?.publicKey ?: return false)
+
+        val b = ByteArray(4096)
+        while (true) {
+            val read = inputStream.read(b)
+            if (read < 0) break
+            signature.update(b, 0, read)
+        }
+        return signature.verify(signatureBytes)
+    }
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/UpdateLoader.java b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/UpdateLoader.java
deleted file mode 100644
index 1a1a8504..00000000
--- a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/updater/UpdateLoader.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (C) 2022 NotEnoughUpdates contributors
- *
- * This file is part of NotEnoughUpdates.
- *
- * NotEnoughUpdates is free software: you can redistribute it
- * and/or modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation, either
- * version 3 of the License, or (at your option) any later version.
- *
- * NotEnoughUpdates is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
- */
-
-package io.github.moulberry.notenoughupdates.miscfeatures.updater;
-
-import io.github.moulberry.notenoughupdates.util.NetUtils;
-import net.minecraft.client.Minecraft;
-import org.apache.commons.io.IOUtils;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.URL;
-import java.nio.file.Files;
-import java.util.ArrayList;
-import java.util.List;
-
-abstract class UpdateLoader {
-
-	enum State {
-		NOTHING, DOWNLOAD_STARTED, DOWNLOAD_FINISHED, INSTALLED, FAILED
-	}
-
-	URL url;
-	AutoUpdater updater;
-
-	State state = State.NOTHING;
-
-	UpdateLoader(AutoUpdater updater, URL url) {
-		this.url = url;
-		this.updater = updater;
-	}
-
-	public State getState() {
-		return state;
-	}
-
-	public void setState(State state) {
-		this.state = state;
-	}
-
-	public URL getUrl() {
-		return url;
-	}
-
-	public void scheduleDownload() {
-		state = State.DOWNLOAD_STARTED;
-		try {
-			NetUtils.downloadAsync(url, File.createTempFile("NotEnoughUpdates-update", ".jar"))
-							.handle(
-								(f, exc) -> {
-									if (exc != null) {
-										state = State.FAILED;
-										updater.logProgress("§cError while downloading. Check your logs for more info.");
-										exc.printStackTrace();
-										return null;
-									}
-									state = State.DOWNLOAD_FINISHED;
-
-									updater.logProgress("Download completed. Trying to install");
-									launchUpdate(f);
-									return null;
-								});
-		} catch (IOException e) {
-			state = State.FAILED;
-			updater.logProgress("§cError while creating download. Check your logs for more info.");
-			e.printStackTrace();
-		}
-	}
-
-	public abstract void greet();
-
-	public void launchUpdate(File file) {
-
-		if (state != State.DOWNLOAD_FINISHED) {
-			updater.logProgress("§cUpdate is invalid state " + state + " to start update.");
-			state = State.FAILED;
-			return;
-		}
-		File mcDataDir = new File(Minecraft.getMinecraft().mcDataDir, "mods");
-		if (!mcDataDir.exists() || !mcDataDir.isDirectory() || !mcDataDir.canRead()) {
-			updater.logProgress("§cCould not find mods folder. Searched: " + mcDataDir);
-			state = State.FAILED;
-			return;
-		}
-		ArrayList<File> toDelete = new ArrayList<>();
-		File[] modFiles = mcDataDir.listFiles();
-		if (modFiles == null) {
-			updater.logProgress("§cCould not list minecraft mod folder (" + mcDataDir + ")");
-			state = State.FAILED;
-			return;
-		}
-		for (File sus : modFiles) {
-			if (sus.getName().endsWith(".jar")) {
-				if (updater.isNeuJar(sus)) {
-					updater.logProgress("Found old NEU file: " + sus + ". Deleting later.");
-					toDelete.add(sus);
-				}
-			}
-		}
-		File dest = new File(mcDataDir, file.getName());
-		try (
-			InputStream i = Files.newInputStream(file.toPath());
-			OutputStream o = Files.newOutputStream(dest.toPath());
-		) {
-			IOUtils.copyLarge(i, o);
-		} catch (IOException e) {
-			e.printStackTrace();
-			updater.logProgress(
-				"§cFailed to copy release JAR. Not making any changes to your mod folder. Consult your logs for more info.");
-			state = State.FAILED;
-		}
-		deleteFiles(toDelete);
-		if (state != State.FAILED) {
-			state = State.INSTALLED;
-			updater.logProgress("Update successful. Thank you for your time.");
-			return;
-		}
-		updater.logProgress("§cFailure to delete some files. Please delte the old NEU version manually from your mods folder.");
-	}
-
-	public abstract void deleteFiles(List<File> toDelete);
-
-}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/options/NEUConfig.java b/src/main/java/io/github/moulberry/notenoughupdates/options/NEUConfig.java
index 200b1c0c..41486dae 100644
--- a/src/main/java/io/github/moulberry/notenoughupdates/options/NEUConfig.java
+++ b/src/main/java/io/github/moulberry/notenoughupdates/options/NEUConfig.java
@@ -39,6 +39,7 @@ import io.github.moulberry.notenoughupdates.miscgui.customtodos.CustomTodo;
 import io.github.moulberry.notenoughupdates.options.customtypes.NEUDebugFlag;
 import io.github.moulberry.notenoughupdates.options.separatesections.AHGraph;
 import io.github.moulberry.notenoughupdates.options.separatesections.AHTweaks;
+import io.github.moulberry.notenoughupdates.options.separatesections.About;
 import io.github.moulberry.notenoughupdates.options.separatesections.AccessoryBag;
 import io.github.moulberry.notenoughupdates.options.separatesections.ApiData;
 import io.github.moulberry.notenoughupdates.options.separatesections.BazaarTweaks;
@@ -248,6 +249,13 @@ public class NEUConfig extends Config {
 
 	@Expose
 	@Category(
+		name = "About",
+		desc = ""
+	)
+	public About about = new About();
+
+	@Expose
+	@Category(
 		name = "Misc",
 		desc = "Miscellaneous options which don't fit into any other category"
 	)
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/options/customtypes/ConfigVersionDisplay.java b/src/main/java/io/github/moulberry/notenoughupdates/options/customtypes/ConfigVersionDisplay.java
new file mode 100644
index 00000000..b86f0b3f
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/options/customtypes/ConfigVersionDisplay.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2024 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.options.customtypes;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ConfigVersionDisplay {
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/options/separatesections/About.java b/src/main/java/io/github/moulberry/notenoughupdates/options/separatesections/About.java
new file mode 100644
index 00000000..fc8c4eb8
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/options/separatesections/About.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2024 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.options.separatesections;
+
+import com.google.gson.annotations.Expose;
+import io.github.moulberry.moulconfig.annotations.Accordion;
+import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean;
+import io.github.moulberry.moulconfig.annotations.ConfigEditorButton;
+import io.github.moulberry.moulconfig.annotations.ConfigEditorDropdown;
+import io.github.moulberry.moulconfig.annotations.ConfigOption;
+import io.github.moulberry.moulconfig.observer.Property;
+import io.github.moulberry.notenoughupdates.options.customtypes.ConfigVersionDisplay;
+import io.github.moulberry.notenoughupdates.util.Utils;
+
+public class About {
+	@ConfigOption(name = "Current Version", desc = "This is the NEU version you are running currently")
+	@ConfigVersionDisplay
+	public transient Void currentVersion = null;
+
+	@ConfigOption(name = "Check for Updates", desc = "Automatically check for updates on each startup")
+	@Expose
+	@ConfigEditorBoolean
+	public boolean autoUpdates = true;
+
+	@ConfigOption(name = "Update Stream", desc = "How often do you want to get updates")
+	@Expose
+	@ConfigEditorDropdown
+	public Property<UpdateStream> updateStream = Property.of(UpdateStream.FULL);
+
+	@ConfigOption(name = "Used Software", desc = "Information about used software and licenses")
+	@Accordion
+	@Expose
+	public Licenses licenses = new Licenses();
+
+	public enum UpdateStream {
+		PRE("Full Releases and Beta", "pre"), FULL("Full Releases", "full"), NONE("None", "none");
+		public final String stream;
+		public final String label;
+
+		UpdateStream(String name, String stream) {
+			this.label = name;
+			this.stream = stream;
+		}
+
+		@Override
+		public String toString() {
+			return label;
+		}
+	}
+
+	public static class Licenses {
+
+		@ConfigOption(name = "Forge", desc = "Forge is available under the LGPL 3.0 license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable forge = () -> Utils.openUrl("https://github.com/MinecraftForge/MinecraftForge");
+
+		@ConfigOption(name = "Mixin", desc = "Mixin is available under the MIT license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable mixin = () -> Utils.openUrl("https://github.com/SpongePowered/Mixin/");
+
+		@ConfigOption(name = "LibAutoUpdate", desc = "LibAutoUpdate is available under the BSD 2 Clause license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable libAutoUpdate = () -> Utils.openUrl("https://git.nea.moe/nea/libautoupdate/");
+
+		@ConfigOption(name = "Kotlin", desc = "Kotlin is available under the Apache 2 license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable kotlin = () -> Utils.openUrl("https://github.com/jetbrains/kotlin/");
+
+		@ConfigOption(name = "AutoService", desc = "auto-service-ksp is available under the Apache 2 license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable autoService = () -> Utils.openUrl("https://github.com/ZacSweers/auto-service-ksp/");
+
+		@ConfigOption(name = "Brigadier", desc = "Brigadier is available under the MIT license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable brigadier = () -> Utils.openUrl("https://github.com/Mojang/brigadier/");
+
+		@ConfigOption(name = "JB Annotations", desc = "Jetbrains annotations is available under the Apache 2 license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable annotations = () -> Utils.openUrl("https://github.com/JetBrains/java-annotations");
+
+		@ConfigOption(name = "MoulConfig", desc = "MoulConfig is available under the LGPL 3.0 license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable moulConfig = () -> Utils.openUrl("https://github.com/NotEnoughUpdates/MoulConfig");
+
+		@ConfigOption(name = "Bliki", desc = "Bliki Core is available under the Eclipse Public License 1.0 license")
+		@ConfigEditorButton(buttonText = "Source")
+		public Runnable blikiCore = () -> Utils.openUrl("https://github.com/AaronZhangL/blikiCore/");
+
+		@ConfigOption(name = "Lombok", desc = "Lombok is available under the MIT license")
+		@ConfigEditorButton(buttonText = "Website")
+		public Runnable lombok = () -> Utils.openUrl("https://projectlombok.org/");
+
+	}
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/util/JarUtil.kt b/src/main/java/io/github/moulberry/notenoughupdates/util/JarUtil.kt
new file mode 100644
index 00000000..d25508ba
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/util/JarUtil.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2024 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.util
+
+import io.github.moulberry.notenoughupdates.NotEnoughUpdates
+import java.io.File
+import java.io.InputStream
+import java.net.URL
+import java.util.jar.JarFile
+import kotlin.io.path.toPath
+
+object JarUtil {
+
+    interface Access {
+        fun listFiles(path: String): List<String>
+        fun read(path: String): InputStream
+    }
+
+    val access = NotEnoughUpdates::class.java.protectionDomain.codeSource.location.let {
+        if (it.protocol.equals("jar")) {
+            val jarFilePath = URL(it.toString().split("!")[0].substring(4))
+                .toURI().toPath().toFile()
+            val jarFile = JarFile(jarFilePath)
+            object : Access {
+                override fun listFiles(path: String): List<String> {
+                    return jarFile.entries().toList().filter { it.name.startsWith(path + "/") }
+                        .filter { it.name.indexOf('/', path.length + 1) < 0 }
+                        .map { it.name.substringAfterLast('/') }
+                }
+
+                override fun read(path: String): InputStream {
+                    return jarFile.getInputStream(jarFile.getJarEntry(path))
+                }
+            }
+        } else {
+            val baseFilePath = it.toString().replace("\\", "/")
+                .replace(NotEnoughUpdates::class.java.getCanonicalName().replace(".", "/") + ".class", "")
+            val baseFile = URL(baseFilePath).toURI().toPath().toFile()
+            object : Access {
+                override fun listFiles(path: String): List<String> {
+                    return baseFile.resolve(path).listFiles()?.map { it.name } ?: listOf()
+                }
+
+                override fun read(path: String): InputStream {
+                    return baseFile.resolve(path).inputStream()
+                }
+            }
+        }
+    }
+
+}
diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/DevTestCommand.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/DevTestCommand.kt
index e8c12442..53e62045 100644
--- a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/DevTestCommand.kt
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/DevTestCommand.kt
@@ -43,6 +43,7 @@ import net.minecraft.util.EnumParticleTypes
 import net.minecraftforge.common.MinecraftForge
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
 import java.util.function.Predicate
+import kotlin.io.path.absolutePathString
 import kotlin.math.floor
 
 @NEUAutoSubscribe
diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/help/SettingsCommand.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/help/SettingsCommand.kt
index 40919a8e..0e6fb1ff 100644
--- a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/help/SettingsCommand.kt
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/help/SettingsCommand.kt
@@ -32,7 +32,9 @@ import io.github.moulberry.notenoughupdates.core.config.GuiOptionEditorBlocked
 import io.github.moulberry.notenoughupdates.events.RegisterBrigadierCommandEvent
 import io.github.moulberry.notenoughupdates.miscfeatures.EnforcedConfigValues
 import io.github.moulberry.notenoughupdates.miscfeatures.IQTest
+import io.github.moulberry.notenoughupdates.miscfeatures.updater.ConfigVersionGuiOption
 import io.github.moulberry.notenoughupdates.options.NEUConfig
+import io.github.moulberry.notenoughupdates.options.customtypes.ConfigVersionDisplay
 import io.github.moulberry.notenoughupdates.util.brigadier.*
 import net.minecraft.client.gui.GuiScreen
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
@@ -122,6 +124,9 @@ object SettingsCommand {
     fun createConfigElement(search: String): MoulConfigEditor<NEUConfig> {
         val processor = BlockingMoulConfigProcessor()
         BuiltinMoulConfigGuis.addProcessors(processor)
+        processor.registerConfigEditor(ConfigVersionDisplay::class.java) { option, annotation ->
+            ConfigVersionGuiOption(option)
+        }
         ConfigProcessorDriver.processConfig(
             NotEnoughUpdates.INSTANCE.config.javaClass,
             NotEnoughUpdates.INSTANCE.config,
diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/misc/MiscCommands.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/misc/MiscCommands.kt
index 422871b4..70a72342 100644
--- a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/misc/MiscCommands.kt
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/misc/MiscCommands.kt
@@ -117,17 +117,6 @@ class MiscCommands {
                 }
             }.withHelp("Look up someones pronouns using their minecraft username")
         }
-        event.command("neuupdate", "neuupdates", "enoughupdates") {
-            thenLiteralExecute("check") {
-                NotEnoughUpdates.INSTANCE.autoUpdater.displayUpdateMessageIfOutOfDate()
-            }.withHelp("Check for updates")
-            thenLiteralExecute("scheduledownload") {
-                NotEnoughUpdates.INSTANCE.autoUpdater.scheduleDownload()
-            }.withHelp("Queue a new version of NEU to be downloaded")
-            thenLiteralExecute("updatemodes") {
-                reply("§bTo ensure we do not accidentally corrupt your mod folder, we can only offer support for auto-updates on system with certain capabilities for file deletions (specifically unix systems). You can still manually update your files")
-            }.withHelp("Display an explanation why you cannot auto update")
-        }
         event.command("neudynamiclights", "neudli", "neudynlights", "neudynamicitems") {
             thenExecute {
                 NotEnoughUpdates.INSTANCE.openGui = DynamicLightItemsEditor()
diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/miscfeatures/updater/AutoUpdater.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/miscfeatures/updater/AutoUpdater.kt
new file mode 100644
index 00000000..b9ce28b2
--- /dev/null
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/miscfeatures/updater/AutoUpdater.kt
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2024 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.miscfeatures.updater
+
+import io.github.moulberry.notenoughupdates.NotEnoughUpdates
+import io.github.moulberry.notenoughupdates.autosubscribe.NEUAutoSubscribe
+import io.github.moulberry.notenoughupdates.events.RegisterBrigadierCommandEvent
+import io.github.moulberry.notenoughupdates.util.MinecraftExecutor
+import io.github.moulberry.notenoughupdates.util.brigadier.thenExecute
+import moe.nea.libautoupdate.CurrentVersion
+import moe.nea.libautoupdate.PotentialUpdate
+import moe.nea.libautoupdate.UpdateContext
+import moe.nea.libautoupdate.UpdateTarget
+import net.minecraft.client.Minecraft
+import net.minecraft.event.ClickEvent
+import net.minecraft.util.ChatComponentText
+import net.minecraftforge.common.MinecraftForge
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+import net.minecraftforge.fml.common.gameevent.TickEvent
+import org.apache.logging.log4j.LogManager
+import java.util.concurrent.CompletableFuture
+
+@NEUAutoSubscribe
+object AutoUpdater {
+    val updateContext = UpdateContext(
+        SigningGithubSource("NotEnoughUpdates", "NotEnoughUpdates"),
+        UpdateTarget.deleteAndSaveInTheSameFolder(AutoUpdater::class.java),
+        CurrentVersion.ofTag(NotEnoughUpdates.VERSION.substringBefore("+")),
+        "notenoughupdates"
+    )
+    val logger = LogManager.getLogger("NEUUpdater")
+    private var activePromise: CompletableFuture<*>? = null
+        set(value) {
+            field?.cancel(true)
+            field = value
+        }
+
+
+    var updateState: UpdateState = UpdateState.NONE
+        private set
+
+    var potentialUpdate: PotentialUpdate? = null
+
+    enum class UpdateState {
+        AVAILABLE,
+        QUEUED,
+        DOWNLOADED,
+        NONE
+    }
+
+    fun reset() {
+        updateState = UpdateState.NONE
+        activePromise = null
+        potentialUpdate = null
+        logger.info("Reset update state")
+    }
+
+    fun checkUpdate() {
+        if (updateState != UpdateState.NONE) {
+            logger.error("Trying to perform update check while another update is already in progress")
+            return
+        }
+        logger.info("Starting update check")
+        val updateStream = config.updateStream.get()
+        activePromise = updateContext.checkUpdate(updateStream.stream)
+            .thenAcceptAsync({
+                logger.info("Update check completed")
+                if (updateState != UpdateState.NONE) {
+                    logger.warn("This appears to be the second update check. Ignoring this one")
+                    return@thenAcceptAsync
+                }
+                potentialUpdate = it
+                if (it.isUpdateAvailable) {
+                    updateState = UpdateState.AVAILABLE
+                    Minecraft.getMinecraft().thePlayer?.addChatMessage(ChatComponentText("§e[NEU] §aNEU found a new update: ${it.update.versionName}. Click here to automatically install this update.").apply {
+                        this.chatStyle = this.chatStyle.setChatClickEvent(
+                            ClickEvent(
+                                ClickEvent.Action.RUN_COMMAND,
+                                "/neuinternalupdatenow"
+                            )
+                        )
+                    })
+                }
+            }, MinecraftExecutor.OnThread)
+    }
+
+    fun queueUpdate() {
+        if (updateState != UpdateState.AVAILABLE) {
+            logger.error("Trying to enqueue an update while another one is already downloaded or none is present")
+        }
+        updateState = UpdateState.QUEUED
+        activePromise = CompletableFuture.supplyAsync {
+            logger.info("Update download started")
+            potentialUpdate!!.prepareUpdate()
+        }.thenAcceptAsync({
+            logger.info("Update download completed, setting exit hook")
+            updateState = UpdateState.DOWNLOADED
+            potentialUpdate!!.executeUpdate()
+        }, MinecraftExecutor.OnThread)
+    }
+
+    init {
+        updateContext.cleanup()
+        config.updateStream.whenChanged { _, _ ->
+            reset()
+        }
+    }
+
+    fun getCurrentVersion(): String {
+        return NotEnoughUpdates.VERSION
+    }
+
+
+    val config get() = NotEnoughUpdates.INSTANCE.config.about
+
+    @SubscribeEvent
+    fun onPlayerAvailableOnce(event: TickEvent.ClientTickEvent) {
+        val p = Minecraft.getMinecraft().thePlayer ?: return
+        MinecraftForge.EVENT_BUS.unregister(this)
+        if (config.autoUpdates)
+            checkUpdate()
+    }
+
+
+    @SubscribeEvent
+    fun testCommand(event: RegisterBrigadierCommandEvent) {
+        event.command("neuinternalupdatenow") {
+            thenExecute {
+                queueUpdate()
+            }
+        }
+    }
+
+    fun getNextVersion(): String? {
+        return potentialUpdate?.update?.versionName
+    }
+
+
+}
diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/miscfeatures/updater/ConfigVersionGuiOption.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/miscfeatures/updater/ConfigVersionGuiOption.kt
new file mode 100644
index 00000000..3a920aec
--- /dev/null
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/miscfeatures/updater/ConfigVersionGuiOption.kt
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2024 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.miscfeatures.updater
+
+import io.github.moulberry.moulconfig.gui.GuiOptionEditor
+import io.github.moulberry.moulconfig.processor.ProcessedOption
+import io.github.moulberry.notenoughupdates.core.util.render.TextRenderUtils
+import io.github.moulberry.notenoughupdates.itemeditor.GuiElementButton
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.GlStateManager
+import net.minecraft.util.EnumChatFormatting.*
+
+import org.lwjgl.input.Mouse
+
+class ConfigVersionGuiOption(option: ProcessedOption) : GuiOptionEditor(option) {
+    val button = GuiElementButton("", -1) { }
+    override fun render(x: Int, y: Int, width: Int) {
+        val fr = Minecraft.getMinecraft().fontRendererObj
+        GlStateManager.pushMatrix()
+        GlStateManager.translate(x.toFloat() + 10, y.toFloat(), 1F)
+        val width = width - 20
+        val nextVersion = AutoUpdater.getNextVersion()
+
+        button.text = when (AutoUpdater.updateState) {
+            AutoUpdater.UpdateState.AVAILABLE -> "Download update"
+            AutoUpdater.UpdateState.QUEUED -> "Downloading..."
+            AutoUpdater.UpdateState.DOWNLOADED -> "Downloaded"
+            AutoUpdater.UpdateState.NONE -> if (nextVersion == null) "Check for Updates" else "Up to date"
+        }
+        button.render(getButtonPosition(width), 10)
+
+        if (AutoUpdater.updateState == AutoUpdater.UpdateState.DOWNLOADED) {
+            TextRenderUtils.drawStringCentered(
+                "${GREEN}The update will be installed after your next restart.",
+                fr,
+                width / 2F,
+                40F,
+                true,
+                -1
+            )
+        }
+
+        val widthRemaining = width - button.width - 10
+
+        GlStateManager.scale(2F, 2F, 1F)
+        TextRenderUtils.drawStringCenteredScaledMaxWidth(
+            "${if (AutoUpdater.updateState == AutoUpdater.UpdateState.NONE) GREEN else RED}${AutoUpdater.getCurrentVersion()}" +
+                    if (nextVersion != null) "➜ ${GREEN}${nextVersion}" else "",
+            widthRemaining / 4F,
+            10F,
+            true,
+            widthRemaining / 2,
+            -1
+        )
+
+        GlStateManager.popMatrix()
+    }
+
+    fun getButtonPosition(width: Int) = width - button.width
+    override fun getHeight(): Int {
+        return 55
+    }
+
+    override fun mouseInput(x: Int, y: Int, width: Int, mouseX: Int, mouseY: Int): Boolean {
+        val width = width - 20
+        if (Mouse.getEventButtonState()) {
+            if ((mouseX - getButtonPosition(width) - x) in (0..button.width) && (mouseY - 10 - y) in (0..button.height)) {
+                when (AutoUpdater.updateState) {
+                    AutoUpdater.UpdateState.AVAILABLE -> AutoUpdater.queueUpdate()
+                    AutoUpdater.UpdateState.QUEUED -> {}
+                    AutoUpdater.UpdateState.DOWNLOADED -> {}
+                    AutoUpdater.UpdateState.NONE -> AutoUpdater.checkUpdate()
+                }
+                return true
+            }
+        }
+        return false
+    }
+
+    override fun keyboardInput(): Boolean {
+        return false
+    }
+
+}
diff --git a/src/main/resources/trusted_team_members/ironmoon.key b/src/main/resources/trusted_team_members/ironmoon.key
new file mode 100644
index 00000000..32060125
--- /dev/null
+++ b/src/main/resources/trusted_team_members/ironmoon.key
diff --git a/src/main/resources/trusted_team_members/jani.key b/src/main/resources/trusted_team_members/jani.key
new file mode 100644
index 00000000..6880aa9d
--- /dev/null
+++ b/src/main/resources/trusted_team_members/jani.key
diff --git a/src/main/resources/trusted_team_members/lulonaut.key b/src/main/resources/trusted_team_members/lulonaut.key
new file mode 100644
index 00000000..0bc0bff5
--- /dev/null
+++ b/src/main/resources/trusted_team_members/lulonaut.key
diff --git a/src/main/resources/trusted_team_members/moulberry.key b/src/main/resources/trusted_team_members/moulberry.key
new file mode 100644
index 00000000..5a7a3307
--- /dev/null
+++ b/src/main/resources/trusted_team_members/moulberry.key
diff --git a/src/main/resources/trusted_team_members/nea.key b/src/main/resources/trusted_team_members/nea.key
new file mode 100644
index 00000000..ec2ff36b
--- /dev/null
+++ b/src/main/resources/trusted_team_members/nea.key
diff --git a/src/main/resources/trusted_team_members/nopo.key b/src/main/resources/trusted_team_members/nopo.key
new file mode 100644
index 00000000..239df76d
--- /dev/null
+++ b/src/main/resources/trusted_team_members/nopo.key
diff --git a/src/test/kotlin/io/github/moulberry/notenoughupdates/util/BootstrapHook.kt b/src/test/kotlin/io/github/moulberry/notenoughupdates/util/BootstrapHook.kt
index cab10aaa..7aea2ca6 100644
--- a/src/test/kotlin/io/github/moulberry/notenoughupdates/util/BootstrapHook.kt
+++ b/src/test/kotlin/io/github/moulberry/notenoughupdates/util/BootstrapHook.kt
@@ -23,6 +23,7 @@ import net.minecraft.block.Block
 import net.minecraft.block.BlockFire
 import net.minecraft.init.Bootstrap
 import net.minecraft.item.Item
+import net.minecraft.launchwrapper.Launch
 import org.junit.jupiter.api.extension.BeforeAllCallback
 import org.junit.jupiter.api.extension.Extension
 import org.junit.jupiter.api.extension.ExtensionContext
@@ -40,7 +41,8 @@ class BootstrapHook : BeforeAllCallback, Extension {
         try {
             if (!bootstrapped) {
                 bootstrapped = true
-
+                Launch.blackboard = HashMap()
+                Launch.blackboard.put("fml.deobfuscatedEnvironment", true)
                 Bootstrap::class.java.getDeclaredField("alreadyRegistered").also { it.isAccessible = true }
                     .set(null, true)
                 Block.registerBlocks()