From 20988e810e4aa17c4fe8f71040b782e3de2d0e3d Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Wed, 14 Oct 2026 15:14:10 -0400 Subject: [PATCH 1/2] fix(prepare): reuse verified imports from installed versions --- crates/horizon-prepare/src/artifacts.rs | 229 +++++++++++++++++++++++- crates/horizon-prepare/src/lib.rs | 2 +- launcher/README.md | 5 +- launcher/src/backend.rs | 45 ++--- launcher/src/main.rs | 9 +- 5 files changed, 257 insertions(+), 33 deletions(-) diff --git a/crates/horizon-prepare/src/artifacts.rs b/crates/horizon-prepare/src/artifacts.rs index a3e6c2cc0..6f8e45bf8 100644 --- a/crates/horizon-prepare/src/artifacts.rs +++ b/crates/horizon-prepare/src/artifacts.rs @@ -573,6 +573,69 @@ pub struct Artifacts { pub libraries: Vec, } +/// Reuses checked imports from this root or another installed version beside it. +pub fn reuse_imported(root: &Path, log: Log) -> Result { + let root = fs::canonicalize(root).map_err(|e| format!("{}: {e}", root.display()))?; + let lock = Lock::read(&root)?; + let checked = |directory: PathBuf| -> Result, String> { + let candidate = Lock { + json: lock.json.clone(), + version: lock.version.clone(), + java_major: lock.java_major, + directory, + }; + let found = verify(&candidate)?; + let client = client_libraries(&candidate, &found.manifest)?; + let mut files = vec![ + candidate.directory.join("manifest.json"), + candidate.directory.join("jars/client.jar"), + candidate.directory.join("jars/server.jar"), + found.jars["server"].clone(), + ]; + files.extend(found.libraries); + files.extend(client); + Ok(files) + }; + if checked(lock.directory.clone()).is_ok() { + log(&format!("Using imported Minecraft {}", lock.version)); + return Ok(true); + } + let Some(versions) = root.parent() else { + return Ok(false); + }; + let mut siblings: Vec<_> = fs::read_dir(versions) + .map_err(|e| format!("{}: {e}", versions.display()))? + .filter_map(Result::ok) + .map(|entry| entry.path()) + .filter(|path| path != &root && path.is_dir()) + .collect(); + siblings.sort(); + for sibling in siblings { + let source = sibling.join(".local/minecraft").join(&lock.version); + let Ok(files) = checked(source.clone()) else { + continue; + }; + for file in files { + let relative = file.strip_prefix(&source).map_err(|e| e.to_string())?; + import_copy( + &file, + &lock.directory.join(relative), + &digest(&file, "sha256")?, + "sha256", + "", + )?; + } + checked(lock.directory.clone())?; + log(&format!( + "Reused imported Minecraft {} from {}", + lock.version, + sibling.display() + )); + return Ok(true); + } + Ok(false) +} + pub fn verify(lock: &Lock) -> Result { let manifest_path = lock.directory.join("manifest.json"); if !manifest_path.exists() { @@ -597,7 +660,10 @@ pub fn verify(lock: &Lock) -> Result { .and_then(|d| d.get(side)) .and_then(|d| d.get("sha1")) .and_then(Value::as_str); - if !jar.exists() || Some(digest(&jar, "sha1")?.as_str()) != pinned { + if pinned != Some(lock.pin(&format!("{side}_sha1"))?) + || !jar.exists() + || Some(digest(&jar, "sha1")?.as_str()) != pinned + { return Err(format!( "{side} artifact checksum changed; prepare again with --prepare" )); @@ -648,6 +714,167 @@ pub fn client_libraries(lock: &Lock, manifest: &Value) -> Result, S #[cfg(test)] mod tests { use super::*; + use std::io::Write; + + struct Imports { + directory: PathBuf, + source: PathBuf, + target: PathBuf, + } + + impl Imports { + fn new() -> Self { + static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0); + let n = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + let directory = std::env::temp_dir() + .join(format!("horizon-import-reuse-{}-{n}", std::process::id())); + let source = directory.join("old"); + let target = directory.join("new"); + fs::create_dir_all(&target).unwrap(); + let imported = source.join(".local/minecraft/9.9"); + let write = |path: &str, data: &[u8]| { + let path = imported.join(path); + fs::create_dir_all(path.parent().unwrap()).unwrap(); + fs::write(path, data).unwrap(); + }; + write("jars/client.jar", b"client"); + write("jars/server-game.jar", b"server game"); + write("libraries/server/server.jar", b"server library"); + write("libraries/client/client.jar", b"client library"); + write("reports/private.txt", b"not an imported artifact"); + let mut bundle = + zip::ZipWriter::new(fs::File::create(imported.join("jars/server.jar")).unwrap()); + let entries = [ + ( + "META-INF/versions.list", + format!("{}\t9.9\tgame.jar\n", crate::sha256_hex(b"server game")), + ), + ( + "META-INF/libraries.list", + format!( + "{}\tserver:library:1\tserver.jar\n", + crate::sha256_hex(b"server library") + ), + ), + ]; + for (name, text) in entries { + bundle + .start_file(name, zip::write::SimpleFileOptions::default()) + .unwrap(); + bundle.write_all(text.as_bytes()).unwrap(); + } + for (name, bytes) in [ + ("META-INF/versions/game.jar", b"server game".as_slice()), + ( + "META-INF/libraries/server.jar", + b"server library".as_slice(), + ), + ] { + bundle + .start_file(name, zip::write::SimpleFileOptions::default()) + .unwrap(); + bundle.write_all(bytes).unwrap(); + } + bundle.finish().unwrap(); + let client_sha1 = digest(&imported.join("jars/client.jar"), "sha1").unwrap(); + let server_sha1 = digest(&imported.join("jars/server.jar"), "sha1").unwrap(); + let library_sha1 = + digest(&imported.join("libraries/client/client.jar"), "sha1").unwrap(); + let manifest = format!( + "{{\"id\":\"9.9\",\"downloads\":{{\"client\":{{\"sha1\":\"{client_sha1}\"}},\"server\":{{\"sha1\":\"{server_sha1}\"}}}},\"libraries\":[{{\"name\":\"client:library:1\",\"downloads\":{{\"artifact\":{{\"path\":\"client.jar\",\"sha1\":\"{library_sha1}\"}}}}}}]}}" + ); + write("manifest.json", manifest.as_bytes()); + let manifest_sha1 = digest(&imported.join("manifest.json"), "sha1").unwrap(); + let lock = format!( + "{{\"minecraft\":{{\"version\":\"9.9\",\"java_major\":25,\"manifest_sha1\":\"{manifest_sha1}\",\"client_sha1\":\"{client_sha1}\",\"server_sha1\":\"{server_sha1}\"}}}}" + ); + fs::write(target.join("research-lock.json"), lock).unwrap(); + Self { + directory, + source, + target, + } + } + + fn imported(&self, root: &Path) -> PathBuf { + root.join(".local/minecraft/9.9") + } + } + + impl Drop for Imports { + fn drop(&mut self) { + let _ = fs::remove_dir_all(&self.directory); + } + } + + #[test] + fn imported_files_are_reused_without_the_official_install() { + let fixture = Imports::new(); + assert!(reuse_imported(&fixture.target, &|_| {}).unwrap()); + let lock = Lock::read(&fixture.target).unwrap(); + let artifacts = verify(&lock).unwrap(); + assert_eq!( + client_libraries(&lock, &artifacts.manifest).unwrap().len(), + 1 + ); + assert_eq!(artifacts.libraries.len(), 1); + assert!(!lock.directory.join("reports/private.txt").exists()); + // The current root's valid imports suffice even after the older copy is corrupted. + fs::write( + fixture.imported(&fixture.source).join("jars/client.jar"), + b"bad", + ) + .unwrap(); + assert!(reuse_imported(&fixture.target, &|_| {}).unwrap()); + } + + #[test] + fn reuse_rejects_corrupt_imports() { + for file in [ + "manifest.json", + "jars/client.jar", + "jars/server.jar", + "jars/server-game.jar", + "libraries/client/client.jar", + "libraries/server/server.jar", + ] { + let fixture = Imports::new(); + fs::write(fixture.imported(&fixture.source).join(file), b"bad").unwrap(); + assert!(!reuse_imported(&fixture.target, &|_| {}).unwrap(), "{file}"); + assert!(!fixture.imported(&fixture.target).exists()); + } + } + + #[test] + fn reuse_checks_the_target_pins() { + let fixture = Imports::new(); + let mut lock = Lock::read(&fixture.target).unwrap(); + let client = lock.pin("client_sha1").unwrap().to_string(); + let text = fs::read_to_string(fixture.target.join("research-lock.json")).unwrap(); + fs::write( + fixture.target.join("research-lock.json"), + text.replace(&client, "wrong-client-pin"), + ) + .unwrap(); + assert!(!reuse_imported(&fixture.target, &|_| {}).unwrap()); + lock.directory = fixture.imported(&fixture.source); + assert!(verify(&lock).is_ok()); + } + + #[test] + fn reuse_skips_a_bad_sibling_and_repairs_bad_current_imports() { + let fixture = Imports::new(); + let bad = fixture.directory.join("a-bad"); + fs::rename(&fixture.source, &bad).unwrap(); + let valid = Imports::new(); + fs::rename(&valid.source, &fixture.source).unwrap(); + fs::write(fixture.imported(&bad).join("jars/client.jar"), b"bad").unwrap(); + let target = fixture.imported(&fixture.target); + fs::create_dir_all(target.join("jars")).unwrap(); + fs::write(target.join("jars/client.jar"), b"bad").unwrap(); + assert!(reuse_imported(&fixture.target, &|_| {}).unwrap()); + assert_eq!(fs::read(target.join("jars/client.jar")).unwrap(), b"client"); + } #[test] fn natives_follow_the_architecture() { diff --git a/crates/horizon-prepare/src/lib.rs b/crates/horizon-prepare/src/lib.rs index 246cb4d51..24cf44645 100644 --- a/crates/horizon-prepare/src/lib.rs +++ b/crates/horizon-prepare/src/lib.rs @@ -402,7 +402,7 @@ pub fn prepare(options: &Options, log: Log) -> Result { let lock = artifacts::Lock::read(root)?; // Java first: nothing below can finish without it, and the player should hear it at once. let jdk = java::find(lock.java_major)?; - if options.import { + if options.import && !artifacts::reuse_imported(root, log)? { artifacts::import( root, &lock, diff --git a/launcher/README.md b/launcher/README.md index f77d345d2..4eda309d1 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -21,7 +21,10 @@ The opening, then Play ([clip](docs/opening.webm)): server (`--dedicated --nogui`) in a folder you choose, with a live console. Preparing is horizon-prepare: linked into the launcher, used in-process when a version ships the same preparer sources, else that version's own `horizon-prepare`; versions released before it - still prepare with their Python script and need Python 3.10+. + still prepare with their Python script and need Python 3.10+. Before importing, + preparation reuses checksum-verified game jars and libraries from the current + or another installed Horizon version, so the original Minecraft install is + only required when no valid imported copy exists. - **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Join Discord" and "Website" links sit in the sidebar footer. Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux, diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index 354837d2c..6bac3f6cd 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -591,17 +591,18 @@ fn preparer_binary(dir: &Path) -> Option { /// Java (and Python, for versions before horizon-prepare). pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result { let version = game_version(tag); + let dir = version_dir(tag); + let reused = horizon_prepare::artifacts::reuse_imported(&dir, &|line| log(line.to_string()))?; let manifest = minecraft .join("versions") .join(&version) .join(format!("{version}.json")); - if !manifest.exists() { + if !reused && !manifest.exists() { return Err(format!( "Minecraft {version} is not in {}. Play {version} once from the official launcher, or choose another folder.", minecraft.display() )); } - let dir = version_dir(tag); let binary = preparer_binary(&dir); let python = if binary.is_some() { // The JDK the version pins, found as horizon-prepare finds it, so a missing one is @@ -625,7 +626,7 @@ pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result
 Result
 Result<(), String> {
 }
 
 /// The Minecraft folder to prepare from: the one given, the one chosen in the launcher, or the
-/// official launcher's default.
+/// official launcher's default. It may be absent when imported files can be reused.
 pub fn minecraft_dir(requested: Option) -> Result {
-    requested
+    Ok(requested
         .or(Settings::load().minecraft_dir)
         .or_else(default_minecraft_dir)
-        .ok_or_else(|| {
-            "No Minecraft folder found. Pass the official launcher's game folder.".into()
-        })
+        .unwrap_or_else(|| horizon_prepare::artifacts::minecraft_dir(None)))
 }
 
 /// The server folder: the one given, the one chosen in the launcher, or `server/` in the data folder.
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index be556226f..2a950b1a4 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -501,10 +501,11 @@ impl Launcher {
         let Some(tag) = self.selected().cloned() else {
             return;
         };
-        let Some(minecraft) = self.settings.minecraft_dir.clone() else {
-            self.prepare_error = Some("Choose your Minecraft folder first.".into());
-            return;
-        };
+        let minecraft = self
+            .settings
+            .minecraft_dir
+            .clone()
+            .unwrap_or_else(|| horizon_prepare::artifacts::minecraft_dir(None));
         self.prepare_log.clear();
         self.prepare_error = None;
         self.prepare_log

From 8caee518976214dfeb5cdda6495afd84d6dd6367 Mon Sep 17 00:00:00 2001
From: Cosmic <84875247+Online5277@users.noreply.github.com>
Date: Wed, 14 Oct 2026 15:37:32 -0400
Subject: [PATCH 2/2] Regenerate preparation metadata when reusing imports

---
 crates/horizon-prepare/src/artifacts.rs | 152 +++++++++++++++++++++---
 1 file changed, 134 insertions(+), 18 deletions(-)

diff --git a/crates/horizon-prepare/src/artifacts.rs b/crates/horizon-prepare/src/artifacts.rs
index 6f8e45bf8..c9b1947ed 100644
--- a/crates/horizon-prepare/src/artifacts.rs
+++ b/crates/horizon-prepare/src/artifacts.rs
@@ -513,7 +513,27 @@ pub fn import(
             &hint(LAUNCHER_HINT, version),
         )?);
     }
-    for (side, jar) in [("client", &client), ("server", &server)] {
+    write_import_metadata(
+        root,
+        lock,
+        &client,
+        &server,
+        &client_libraries,
+        &server_libraries,
+        log,
+    )
+}
+
+fn write_import_metadata(
+    root: &Path,
+    lock: &Lock,
+    client: &Path,
+    server: &Path,
+    client_libraries: &[PathBuf],
+    server_libraries: &[PathBuf],
+    log: Log,
+) -> Result<(), String> {
+    for (side, jar) in [("client", client), ("server", server)] {
         let data = crate::inventory::inventory(jar)?;
         let count = |key| data.get(key).cloned().unwrap_or(Value::Null);
         write_json(
@@ -538,25 +558,19 @@ pub fn import(
     write_json(
         &lock.directory.join("prepared.json"),
         &Value::Object(vec![
-            ("version".into(), Value::str(id)),
+            ("version".into(), Value::str(&lock.version)),
             (
                 "jars".into(),
                 Value::Object(vec![
-                    (
-                        "client".into(),
-                        Value::Str(relative_display(&client, root)?),
-                    ),
-                    (
-                        "server".into(),
-                        Value::Str(relative_display(&server, root)?),
-                    ),
+                    ("client".into(), Value::Str(relative_display(client, root)?)),
+                    ("server".into(), Value::Str(relative_display(server, root)?)),
                 ]),
             ),
             (
                 "libraries".into(),
                 Value::Object(vec![
-                    ("client".into(), paths(&client_libraries)?),
-                    ("server".into(), paths(&server_libraries)?),
+                    ("client".into(), paths(client_libraries)?),
+                    ("server".into(), paths(server_libraries)?),
                 ]),
             ),
         ]),
@@ -597,12 +611,33 @@ pub fn reuse_imported(root: &Path, log: Log) -> Result {
         Ok(files)
     };
     if checked(lock.directory.clone()).is_ok() {
+        if [
+            "prepared.json",
+            "reports/client-inventory.json",
+            "reports/server-inventory.json",
+        ]
+        .iter()
+        .any(|path| !lock.directory.join(path).is_file())
+        {
+            let found = verify(&lock)?;
+            let client_libraries = client_libraries(&lock, &found.manifest)?;
+            write_import_metadata(
+                &root,
+                &lock,
+                &found.jars["client"],
+                &found.jars["server"],
+                &client_libraries,
+                &found.libraries,
+                log,
+            )?;
+        }
         log(&format!("Using imported Minecraft {}", lock.version));
         return Ok(true);
     }
     let Some(versions) = root.parent() else {
         return Ok(false);
     };
+    // Sibling discovery is intended for the launcher's versions/ folder.
     let mut siblings: Vec<_> = fs::read_dir(versions)
         .map_err(|e| format!("{}: {e}", versions.display()))?
         .filter_map(Result::ok)
@@ -625,7 +660,17 @@ pub fn reuse_imported(root: &Path, log: Log) -> Result {
                 "",
             )?;
         }
-        checked(lock.directory.clone())?;
+        let found = verify(&lock)?;
+        let client_libraries = client_libraries(&lock, &found.manifest)?;
+        write_import_metadata(
+            &root,
+            &lock,
+            &found.jars["client"],
+            &found.jars["server"],
+            &client_libraries,
+            &found.libraries,
+            log,
+        )?;
         log(&format!(
             "Reused imported Minecraft {} from {}",
             lock.version,
@@ -716,6 +761,15 @@ mod tests {
     use super::*;
     use std::io::Write;
 
+    fn jar(marker: &[u8]) -> Vec {
+        let mut archive = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+        archive
+            .start_file("marker", zip::write::SimpleFileOptions::default())
+            .unwrap();
+        archive.write_all(marker).unwrap();
+        archive.finish().unwrap().into_inner()
+    }
+
     struct Imports {
         directory: PathBuf,
         source: PathBuf,
@@ -737,8 +791,10 @@ mod tests {
                 fs::create_dir_all(path.parent().unwrap()).unwrap();
                 fs::write(path, data).unwrap();
             };
-            write("jars/client.jar", b"client");
-            write("jars/server-game.jar", b"server game");
+            let client = jar(b"client");
+            let game = jar(b"server game");
+            write("jars/client.jar", &client);
+            write("jars/server-game.jar", &game);
             write("libraries/server/server.jar", b"server library");
             write("libraries/client/client.jar", b"client library");
             write("reports/private.txt", b"not an imported artifact");
@@ -747,7 +803,7 @@ mod tests {
             let entries = [
                 (
                     "META-INF/versions.list",
-                    format!("{}\t9.9\tgame.jar\n", crate::sha256_hex(b"server game")),
+                    format!("{}\t9.9\tgame.jar\n", crate::sha256_hex(&game)),
                 ),
                 (
                     "META-INF/libraries.list",
@@ -764,7 +820,7 @@ mod tests {
                 bundle.write_all(text.as_bytes()).unwrap();
             }
             for (name, bytes) in [
-                ("META-INF/versions/game.jar", b"server game".as_slice()),
+                ("META-INF/versions/game.jar", game.as_slice()),
                 (
                     "META-INF/libraries/server.jar",
                     b"server library".as_slice(),
@@ -810,6 +866,11 @@ mod tests {
     #[test]
     fn imported_files_are_reused_without_the_official_install() {
         let fixture = Imports::new();
+        fs::write(
+            fixture.imported(&fixture.source).join("prepared.json"),
+            b"stale source metadata",
+        )
+        .unwrap();
         assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
         let lock = Lock::read(&fixture.target).unwrap();
         let artifacts = verify(&lock).unwrap();
@@ -818,14 +879,66 @@ mod tests {
             1
         );
         assert_eq!(artifacts.libraries.len(), 1);
+        let prepared = read_json(&lock.directory.join("prepared.json")).unwrap();
+        assert_eq!(prepared.get("version").and_then(Value::as_str), Some("9.9"));
+        for side in ["client", "server"] {
+            assert_eq!(
+                prepared
+                    .get("jars")
+                    .unwrap()
+                    .get(side)
+                    .and_then(Value::as_str),
+                Some(
+                    relative_display(&artifacts.jars[side], &fixture.target)
+                        .unwrap()
+                        .as_str()
+                )
+            );
+            let inventory = read_json(
+                &lock
+                    .directory
+                    .join(format!("reports/{side}-inventory.json")),
+            )
+            .unwrap();
+            assert_eq!(
+                inventory.get("jar_sha256").and_then(Value::as_str),
+                Some(digest(&artifacts.jars[side], "sha256").unwrap().as_str())
+            );
+        }
         assert!(!lock.directory.join("reports/private.txt").exists());
+        for side in ["client", "server"] {
+            let libraries = prepared
+                .get("libraries")
+                .unwrap()
+                .get(side)
+                .unwrap()
+                .as_array()
+                .unwrap();
+            assert_eq!(libraries.len(), 1);
+            assert_eq!(
+                libraries[0].as_str(),
+                Some(
+                    relative_display(
+                        &lock.directory.join(format!("libraries/{side}/{side}.jar")),
+                        &fixture.target
+                    )
+                    .unwrap()
+                    .as_str()
+                )
+            );
+        }
         // The current root's valid imports suffice even after the older copy is corrupted.
         fs::write(
             fixture.imported(&fixture.source).join("jars/client.jar"),
             b"bad",
         )
         .unwrap();
+        // Repair metadata omitted by earlier reuse implementations, without a sibling.
+        fs::remove_file(lock.directory.join("prepared.json")).unwrap();
+        fs::remove_file(lock.directory.join("reports/client-inventory.json")).unwrap();
         assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
+        assert!(read_json(&lock.directory.join("prepared.json")).is_ok());
+        assert!(read_json(&lock.directory.join("reports/client-inventory.json")).is_ok());
     }
 
     #[test]
@@ -873,7 +986,10 @@ mod tests {
         fs::create_dir_all(target.join("jars")).unwrap();
         fs::write(target.join("jars/client.jar"), b"bad").unwrap();
         assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
-        assert_eq!(fs::read(target.join("jars/client.jar")).unwrap(), b"client");
+        assert_eq!(
+            fs::read(target.join("jars/client.jar")).unwrap(),
+            fs::read(fixture.imported(&fixture.source).join("jars/client.jar")).unwrap()
+        );
     }
 
     #[test]