redo for the modern age

qimiko · qimiko · commit 2b4e4fbe0eb3 · 2025-11-17T12:39:17.000-07:00
diff --git a/loader/src/loader/updater.cpp b/loader/src/loader/updater.cpp
@@ -7,6 +7,8 @@
 #include "ModMetadataImpl.hpp"
 #include <Geode/utils/string.hpp>
 
+#include "../server/Server.hpp"
+
 using namespace geode::prelude;
 
 static std::unordered_map<std::string, web::WebTask> RUNNING_REQUESTS {};
@@ -23,10 +25,12 @@ updater::LoaderUpdateEvent::LoaderUpdateEvent(
 
 updater::LoaderUpdateFilter::LoaderUpdateFilter() = default;
 
+bool s_isNewUpdateDownloaded = false;
+
+/*
 // cache for the json of the latest github release to avoid hitting
 // the github api too much
 std::optional<matjson::Value> s_latestGithubRelease;
-bool s_isNewUpdateDownloaded = false;
 
 void updater::fetchLatestGithubRelease(
     const std::function<void(matjson::Value const&)>& then,
@@ -86,34 +90,24 @@ void updater::fetchLatestGithubRelease(
         )
     );
 }
+*/
 
 void updater::downloadLatestLoaderResources() {
     log::debug("Downloading latest resources", Loader::get()->getVersion().toVString());
-    fetchLatestGithubRelease(
-        [](matjson::Value const& raw) {
-            auto root = checkJson(raw, "[]");
-
-            // find release asset
-            for (auto& obj : root.needs("assets").items()) {
-                if (obj.needs("name").get<std::string>() == "resources.zip") {
-                    updater::tryDownloadLoaderResources(
-                        obj.needs("browser_download_url").get<std::string>(),
-                        false
-                    );
-                    return;
-                }
-            }
 
-            ResourceDownloadEvent(
-                UpdateFailed("Unable to find resources in latest GitHub release")
-            ).post();
-        },
-        [](std::string const& info) {
-            ResourceDownloadEvent(
-                UpdateFailed("Unable to download resources: " + info)
-            ).post();
-        },
-        true
+    server::getLatestLoaderVersion().listen(
+        [](Result<server::ServerLoaderVersion, server::ServerError>* res) {
+            if (res->ok()) {
+                auto& release = res->unwrap();
+                updater::downloadLoaderUpdate(
+                    fmt::format("https://github.com/geode-sdk/geode/releases/download/{0}/geode-{0}-{1}.zip", release.tag, GEODE_PLATFORM_SHORT_IDENTIFIER_NOARCH)
+                );
+            } else {
+                ResourceDownloadEvent(
+                    UpdateFailed("Unable to download resources: " + res->unwrapErr().details)
+                ).post();
+            }
+        }
     );
 }
 
@@ -351,56 +345,40 @@ void updater::downloadLoaderUpdate(std::string const& url) {
 
 void updater::checkForLoaderUpdates() {
     // Check for updates in the background
-    fetchLatestGithubRelease(
-        [](matjson::Value const& raw) {
-            auto root = checkJson(raw, "[]");
+    server::getLatestLoaderVersion().listen(
+        [](Result<server::ServerLoaderVersion, server::ServerError>* res) {
+            if (res->ok()) {
+                auto& release = res->unwrap();
+                auto ver = VersionInfo::parse(release.tag).unwrapOrDefault();
 
-            VersionInfo ver { 0, 0, 0 };
-            root.needs("tag_name").into(ver);
+                log::info("Latest Geode version is {}", ver.toVString());
+                Mod::get()->setSavedValue("latest-version-auto-update-check", ver.toVString());
 
-            log::info("Latest Geode version is {}", ver.toVString());
-            Mod::get()->setSavedValue("latest-version-auto-update-check", ver.toVString());
+                // make sure release is newer
+                if (ver <= Loader::get()->getVersion()) {
+                    if(ver <= VersionInfo(2, 0, 0, VersionTag(VersionTag::Beta, 1))) {
+                        log::warn("Invalid loader version detected, resetting update check time");
 
-            // make sure release is newer
-            if (ver <= Loader::get()->getVersion()) {
-                if(ver <= VersionInfo(2, 0, 0, VersionTag(VersionTag::Beta, 1))) {
-                    log::warn("Invalid loader version detected, resetting update check time");
-
-                    Mod::get()->setSavedValue("last-modified-auto-update-check", std::string());
+                        Mod::get()->setSavedValue("last-modified-auto-update-check", std::string());
+                    }
+                    return;
                 }
-                return;
-            }
-
-            // don't auto-update major versions when not on forward compat
-            if (!Loader::get()->isForwardCompatMode() && ver.getMajor() > Loader::get()->getVersion().getMajor()) {
-                return;
-            }
 
-            // find release asset
-            for (auto& obj : root.needs("assets").items()) {
-                if (string::endsWith(
-                    obj.needs("name").get<std::string>(),
-                    fmt::format("{}.zip", PlatformID::toShortString(GEODE_PLATFORM_TARGET, true))
-                )) {
-                    updater::downloadLoaderUpdate(
-                        obj.needs("browser_download_url").get<std::string>()
-                    );
+                // don't auto-update major versions when not on forward compat
+                if (!Loader::get()->isForwardCompatMode() && ver.getMajor() > Loader::get()->getVersion().getMajor()) {
                     return;
                 }
-            }
-
-            log::error("Failed to find release asset for " GEODE_PLATFORM_NAME);
-            LoaderUpdateEvent(
-                UpdateFailed("Unable to find release asset for " GEODE_PLATFORM_NAME)
-            ).post();
 
-            Mod::get()->setSavedValue("last-modified-auto-update-check", std::string());
-        },
-        [](std::string const& info) {
-            log::error("Failed to fetch updates {}", info);
-            LoaderUpdateEvent(
-                UpdateFailed("Unable to check for updates: " + info)
-            ).post();
+                // find release asset
+                updater::downloadLoaderUpdate(
+                    fmt::format("https://github.com/geode-sdk/geode/releases/download/{0}/geode-{0}-{1}.zip", release.tag, GEODE_PLATFORM_SHORT_IDENTIFIER_NOARCH)
+                );
+            } else {
+                log::error("Failed to fetch updates {}", res->unwrapErr().details);
+                LoaderUpdateEvent(
+                    UpdateFailed("Unable to check for updates: " + res->unwrapErr().details)
+                ).post();
+            }
         }
     );
 }
diff --git a/loader/src/loader/updater.hpp b/loader/src/loader/updater.hpp
@@ -43,11 +43,14 @@ namespace geode::updater {
     void downloadLoaderResources(bool useLatestRelease = false);
     void downloadLatestLoaderResources();
     void downloadLoaderUpdate(std::string const& url);
+
+    /*
     void fetchLatestGithubRelease(
         const std::function<void(matjson::Value const&)>& then,
         std::function<void(std::string const&)> expect,
         bool force = false
     );
+    */
 
     bool verifyLoaderResources();
     void checkForLoaderUpdates();
diff --git a/loader/src/server/Server.cpp b/loader/src/server/Server.cpp
@@ -529,6 +529,20 @@ Result<ServerModsList> ServerModsList::parse(matjson::Value const& raw) {
     return payload.ok(list);
 }
 
+Result<ServerLoaderVersion> ServerLoaderVersion::parse(matjson::Value const& raw) {
+    auto root = checkJson(raw, "ServerLoaderVersion");
+
+    auto res = ServerLoaderVersion();
+    root.needs("version").into(res.version);
+    root.needs("tag").into(res.tag);
+    root.needs("commit_hash").into(res.commitHash);
+
+    auto gd_obj = root.needs("gd");
+    gd_obj.needs(GEODE_PLATFORM_SHORT_IDENTIFIER).into(res.gameVersion);
+
+    return root.ok(res);
+}
+
 ModMetadata ServerModMetadata::latestVersion() const {
     return this->versions.front().metadata;
 }
@@ -890,6 +904,40 @@ ServerRequest<std::vector<ServerModUpdate>> server::checkAllUpdates(bool useCach
     );
 }
 
+ServerRequest<ServerLoaderVersion> server::getLatestLoaderVersion(bool useCache) {
+    if (useCache) {
+        return getCache<getLatestLoaderVersion>().get();
+    }
+
+    auto req = web::WebRequest();
+    req.userAgent(getServerUserAgent());
+
+    req.param("platform", GEODE_PLATFORM_SHORT_IDENTIFIER_NOARCH);
+    req.param("gd", GEODE_GD_VERSION_STR);
+
+    return req.get(formatServerURL("/loader/versions/latest")).map(
+        [](web::WebResponse* response) -> Result<ServerLoaderVersion, ServerError> {
+            if (response->ok()) {
+                // Parse payload
+                auto payload = parseServerPayload(*response);
+                if (!payload) {
+                    return Err(payload.unwrapErr());
+                }
+                // Parse response
+                auto r = ServerLoaderVersion::parse(payload.unwrap());
+                if (!r) {
+                    return Err(ServerError(response->code(), "Unable to parse response: {}", r.unwrapErr()));
+                }
+                return Ok(r.unwrap());
+            }
+            return Err(parseServerError(*response));
+        },
+        [](web::WebProgress* progress) {
+            return parseServerProgress(*progress, "Checking for loader updates");
+        }
+    );
+}
+
 void server::clearServerCaches(bool clearGlobalCaches) {
     getCache<&getMods>().clear();
     getCache<&getMod>().clear();
@@ -899,6 +947,7 @@ void server::clearServerCaches(bool clearGlobalCaches) {
     if (clearGlobalCaches) {
         getCache<&getTags>().clear();
         getCache<&checkAllUpdates>().clear();
+        getCache<&getLatestLoaderVersion>().clear();
     }
 }
 
diff --git a/loader/src/server/Server.hpp b/loader/src/server/Server.hpp
@@ -103,6 +103,15 @@ namespace server {
         static Result<ServerModsList> parse(matjson::Value const& json);
     };
 
+    struct ServerLoaderVersion final {
+        std::string version;
+        std::string tag;
+        std::string commitHash;
+        std::string gameVersion;
+
+        static Result<ServerLoaderVersion> parse(matjson::Value const& json);
+    };
+
     enum class ModsSort {
         Downloads,
         RecentlyUpdated,
@@ -178,6 +187,7 @@ namespace server {
     );
 
     ServerRequest<std::vector<ServerModUpdate>> checkAllUpdates(bool useCache = true);
+    ServerRequest<ServerLoaderVersion> getLatestLoaderVersion(bool useCache = true);
 
     void clearServerCaches(bool clearGlobalCaches = false);
 }
