Merge pull request #2620 from ludovic111/feat/launcher-import
🤖 Agent: launcher-features-1: base main, merge-tree clean against main, CI verify + launcher green; queued.
This commit is contained in:
@@ -344,6 +344,17 @@ Export an instance (or a port) to share: its settings, packs, Horizon mods and t
|
||||
|
||||
MCP: `instance_export`.
|
||||
|
||||
## `horizon-launcher instance import`
|
||||
|
||||
Import what a file is, as dropping it on the window does: a shared instance (a .mrpack without mod loaders, such as `instance export` writes, or a game folder zip) becomes a new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into the instance (default: the selected one).
|
||||
|
||||
horizon-launcher instance import <FILE>
|
||||
|
||||
- `FILE`
|
||||
- `--instance`: The instance a pack goes into
|
||||
|
||||
MCP: `instance_import`.
|
||||
|
||||
## `horizon-launcher worlds list`
|
||||
|
||||
The worlds: name, mode, version, last played and size (the default).
|
||||
|
||||
@@ -198,6 +198,16 @@ enum InstanceCmd {
|
||||
#[arg(long)]
|
||||
out: Option<PathBuf>,
|
||||
},
|
||||
/// Import what a file is, as dropping it on the window does: a shared instance (a .mrpack
|
||||
/// without mod loaders, such as `instance export` writes, or a game folder zip) becomes a
|
||||
/// new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into
|
||||
/// the instance (default: the selected one)
|
||||
Import {
|
||||
file: PathBuf,
|
||||
/// The instance a pack goes into
|
||||
#[arg(long)]
|
||||
instance: Option<String>,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, clap::ValueEnum)]
|
||||
@@ -1765,6 +1775,51 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
|
||||
};
|
||||
changed(instances::edit(&instance, |m| m.version = pin)?)
|
||||
}
|
||||
InstanceCmd::Import { file, instance } => {
|
||||
use horizon_launcher::import::{self, Dropped};
|
||||
use horizon_launcher::modpacks;
|
||||
match import::what(&file)? {
|
||||
Dropped::Instance => {
|
||||
let i = import::import_instance(&file, &|line, _| eprintln!("{line}"))?;
|
||||
if as_json {
|
||||
json(value(&i, false));
|
||||
} else {
|
||||
println!(
|
||||
"Made the instance {} in {}: horizon-launcher instance select \"{}\"",
|
||||
i.name,
|
||||
i.home.display(),
|
||||
i.name
|
||||
);
|
||||
}
|
||||
}
|
||||
Dropped::Modpack => {
|
||||
let pack = modpacks::import(&file, &|line: String| eprintln!("{line}"))?;
|
||||
println!("{} ({})", modpacks::outcome(&pack), pack.summary());
|
||||
println!(
|
||||
"Port and play it: horizon-launcher modpack port {}",
|
||||
pack.slug
|
||||
);
|
||||
}
|
||||
Dropped::Pack(_) => {
|
||||
let i = match instance {
|
||||
Some(name) => instances::find(&name)?,
|
||||
None => instances::selected(),
|
||||
};
|
||||
let p = horizon_launcher::packs::add(&i.home, &file)?;
|
||||
println!(
|
||||
"Added {} to {}: turn it on with horizon-launcher packs on",
|
||||
p.title, i.name
|
||||
);
|
||||
}
|
||||
Dropped::DataPack => {
|
||||
return Err(format!(
|
||||
"{} is a data pack: put it into a world with horizon-launcher worlds \
|
||||
datapack-add <world> <file>",
|
||||
file.display()
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
InstanceCmd::Export {
|
||||
instance,
|
||||
format,
|
||||
|
||||
@@ -0,0 +1,232 @@
|
||||
//! A file dropped on the window (or given to `instance import`): what it is, and an instance
|
||||
//! made from a shared one.
|
||||
//!
|
||||
//! - A `.mrpack` that needs no mod loader (only `minecraft` in its dependencies), such as
|
||||
//! [`crate::export`] writes, or a `.zip` laid out as a game folder: a new instance. Its
|
||||
//! `overrides/` (and `client-overrides/`) go into the instance's folder; each of its `files`
|
||||
//! is downloaded from Modrinth and checked against its SHA-512 (`browser::download`).
|
||||
//! - A `.mrpack` for a mod loader, or a CurseForge modpack zip (`manifest.json`): a Java
|
||||
//! modpack, for the Modpacks import (`modpacks::import`).
|
||||
//! - A zip with `pack.mcmeta`: a data pack (`data/`) or a resource pack; with `shaders/`, or a
|
||||
//! `.hshader`: a shader pack.
|
||||
//!
|
||||
//! Only what an instance holds is taken from a shared zip ([`crate::export::FILES`],
|
||||
//! [`crate::export::FOLDERS`], `saves/`), and every path is checked to stay inside its folder.
|
||||
use crate::browser::{download, FileRef};
|
||||
use crate::export::{FILES, FOLDERS};
|
||||
use crate::instances::{self, Instance};
|
||||
use crate::packs;
|
||||
use std::fs;
|
||||
use std::io::Read;
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
const INDEX: &str = "modrinth.index.json";
|
||||
/// The `.mrpack` folders copied into the game folder; `server-overrides/` is a server's.
|
||||
const OVERRIDES: [&str; 2] = ["overrides/", "client-overrides/"];
|
||||
|
||||
/// What a dropped file is.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Dropped {
|
||||
/// A shared instance: a new instance is made from it.
|
||||
Instance,
|
||||
/// A Java modpack, for the Modpacks import.
|
||||
Modpack,
|
||||
/// A resource or shader pack, for the selected instance.
|
||||
Pack(packs::Kind),
|
||||
/// A data pack: it goes into a world.
|
||||
DataPack,
|
||||
}
|
||||
|
||||
fn open(file: &Path) -> Result<zip::ZipArchive<fs::File>, String> {
|
||||
fs::File::open(file)
|
||||
.ok()
|
||||
.and_then(|f| zip::ZipArchive::new(f).ok())
|
||||
.ok_or_else(|| format!("{} is not a zip file that can be read.", name_of(file)))
|
||||
}
|
||||
|
||||
fn name_of(file: &Path) -> String {
|
||||
file.file_name()
|
||||
.map(|n| n.to_string_lossy().into_owned())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
fn read_index(zip: &mut zip::ZipArchive<fs::File>) -> Result<serde_json::Value, String> {
|
||||
let mut text = Vec::new();
|
||||
zip.by_name(INDEX)
|
||||
.map_err(|_| format!("It has no {INDEX}: not a .mrpack."))?
|
||||
.take(16 << 20)
|
||||
.read_to_end(&mut text)
|
||||
.map_err(|e| e.to_string())?;
|
||||
serde_json::from_slice(&text).map_err(|e| format!("{INDEX}: {e}"))
|
||||
}
|
||||
|
||||
/// What `file` is, from its name and what is inside.
|
||||
pub fn what(file: &Path) -> Result<Dropped, String> {
|
||||
let name = name_of(file);
|
||||
let ext = file
|
||||
.extension()
|
||||
.map(|e| e.to_string_lossy().to_ascii_lowercase());
|
||||
match ext.as_deref() {
|
||||
Some("hshader") => return Ok(Dropped::Pack(packs::Kind::Shader)),
|
||||
Some("mrpack") => {
|
||||
let index = read_index(&mut open(file)?)?;
|
||||
let loaders = index["dependencies"]
|
||||
.as_object()
|
||||
.is_some_and(|d| d.keys().any(|k| k != "minecraft"));
|
||||
return Ok(match loaders {
|
||||
true => Dropped::Modpack,
|
||||
false => Dropped::Instance,
|
||||
});
|
||||
}
|
||||
Some("zip") => {}
|
||||
_ => {
|
||||
return Err(format!(
|
||||
"{name} can't be imported: drop a .mrpack, a .zip or a .hshader."
|
||||
))
|
||||
}
|
||||
}
|
||||
let zip = open(file)?;
|
||||
let has = |n: &str| zip.index_for_name(n).is_some();
|
||||
let under = |p: &str| zip.file_names().any(|n| n.starts_with(p));
|
||||
if has("manifest.json") && !has("pack.mcmeta") {
|
||||
return Ok(Dropped::Modpack);
|
||||
}
|
||||
if has("pack.mcmeta") {
|
||||
return Ok(match under("data/") {
|
||||
true => Dropped::DataPack,
|
||||
false => Dropped::Pack(packs::Kind::Resource),
|
||||
});
|
||||
}
|
||||
if under("shaders/") {
|
||||
return Ok(Dropped::Pack(packs::Kind::Shader));
|
||||
}
|
||||
if FILES.iter().any(|f| has(f))
|
||||
|| under("saves/")
|
||||
|| FOLDERS.iter().any(|f| under(&format!("{f}/")))
|
||||
{
|
||||
return Ok(Dropped::Instance);
|
||||
}
|
||||
Err(format!(
|
||||
"{name} is neither a pack nor a shared instance: nothing in it that Horizon reads."
|
||||
))
|
||||
}
|
||||
|
||||
/// Where an archive entry goes in the instance's folder, when it is one an instance holds and
|
||||
/// stays inside it.
|
||||
fn target(home: &Path, relative: &str) -> Option<PathBuf> {
|
||||
let path = Path::new(relative);
|
||||
if relative.ends_with('/') || !path.components().all(|c| matches!(c, Component::Normal(_))) {
|
||||
return None;
|
||||
}
|
||||
let top = relative.split('/').next()?;
|
||||
let kept = FILES.contains(&relative)
|
||||
|| (relative.contains('/') && (FOLDERS.contains(&top) || top == "saves"));
|
||||
kept.then(|| home.join(path))
|
||||
}
|
||||
|
||||
/// Makes a new instance from a shared one: `file` is a `.mrpack` without mod loaders or a game
|
||||
/// folder `.zip`. Named after the pack (or the file), with "(2)" when the name is taken.
|
||||
pub fn import_instance(file: &Path, progress: &dyn Fn(&str, f32)) -> Result<Instance, String> {
|
||||
import_into(file, progress, &|name| instances::create(name, None))
|
||||
}
|
||||
|
||||
/// [`import_instance`] with the instance made by `create`.
|
||||
pub fn import_into(
|
||||
file: &Path,
|
||||
progress: &dyn Fn(&str, f32),
|
||||
create: &dyn Fn(&str) -> Result<Instance, String>,
|
||||
) -> Result<Instance, String> {
|
||||
if what(file)? != Dropped::Instance {
|
||||
return Err(format!("{} is not a shared instance.", name_of(file)));
|
||||
}
|
||||
let mut zip = open(file)?;
|
||||
let mrpack = zip.index_for_name(INDEX).is_some();
|
||||
let index = match mrpack {
|
||||
true => Some(read_index(&mut zip)?),
|
||||
false => None,
|
||||
};
|
||||
let stem = file
|
||||
.file_stem()
|
||||
.map(|s| s.to_string_lossy().into_owned())
|
||||
.unwrap_or_else(|| "Imported".into());
|
||||
let base = index
|
||||
.as_ref()
|
||||
.and_then(|i| i["name"].as_str())
|
||||
.map(str::trim)
|
||||
.filter(|n| !n.is_empty())
|
||||
.map(str::to_string)
|
||||
.unwrap_or(stem);
|
||||
let instance = (1..20)
|
||||
.map(|n| match n {
|
||||
1 => base.clone(),
|
||||
n => format!("{base} ({n})"),
|
||||
})
|
||||
.find_map(|name| create(&name).ok())
|
||||
.ok_or_else(|| format!("Could not make an instance called {base}."))?;
|
||||
let home = instance.home.clone();
|
||||
let filled = fill(&mut zip, index.as_ref(), &home, progress);
|
||||
if let Err(e) = filled {
|
||||
let _ = fs::remove_dir_all(&home);
|
||||
return Err(e);
|
||||
}
|
||||
Ok(instance)
|
||||
}
|
||||
|
||||
fn fill(
|
||||
zip: &mut zip::ZipArchive<fs::File>,
|
||||
index: Option<&serde_json::Value>,
|
||||
home: &Path,
|
||||
progress: &dyn Fn(&str, f32),
|
||||
) -> Result<(), String> {
|
||||
let count = zip.len();
|
||||
for i in 0..count {
|
||||
let mut entry = zip.by_index(i).map_err(|e| e.to_string())?;
|
||||
let name = entry.name().to_string();
|
||||
let relative = match index {
|
||||
Some(_) => match OVERRIDES.iter().find_map(|o| name.strip_prefix(o)) {
|
||||
Some(r) => r.to_string(),
|
||||
None => continue,
|
||||
},
|
||||
None => name.clone(),
|
||||
};
|
||||
let Some(to) = target(home, &relative) else {
|
||||
continue;
|
||||
};
|
||||
fs::create_dir_all(to.parent().expect("inside home")).map_err(|e| e.to_string())?;
|
||||
let mut out = fs::File::create(&to).map_err(|e| format!("{}: {e}", to.display()))?;
|
||||
std::io::copy(&mut entry, &mut out).map_err(|e| format!("{}: {e}", to.display()))?;
|
||||
progress(
|
||||
&format!("Copying {relative}"),
|
||||
(i + 1) as f32 / count as f32,
|
||||
);
|
||||
}
|
||||
let files = index
|
||||
.and_then(|i| i["files"].as_array())
|
||||
.cloned()
|
||||
.unwrap_or_default();
|
||||
for f in files {
|
||||
if f["env"]["client"] == "unsupported" {
|
||||
continue;
|
||||
}
|
||||
let relative = f["path"].as_str().unwrap_or_default();
|
||||
let to = target(home, relative)
|
||||
.ok_or_else(|| format!("{relative} isn't a place an instance keeps files."))?;
|
||||
let file = FileRef {
|
||||
url: f["downloads"][0].as_str().unwrap_or_default().to_string(),
|
||||
name: to.file_name().unwrap().to_string_lossy().into_owned(),
|
||||
size: f["fileSize"].as_u64().unwrap_or(0),
|
||||
sha512: f["hashes"]["sha512"].as_str().map(str::to_ascii_lowercase),
|
||||
sha256: None,
|
||||
sha1: f["hashes"]["sha1"].as_str().map(str::to_ascii_lowercase),
|
||||
primary: true,
|
||||
};
|
||||
let folder = to.parent().expect("inside home");
|
||||
download::fetch(&file, folder, &|p| progress(&file.name, p))
|
||||
.map_err(|e| format!("{relative}: {e}"))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "import/tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,207 @@
|
||||
use super::*;
|
||||
use crate::export::{export, Format};
|
||||
use std::io::Write;
|
||||
use std::time::Duration;
|
||||
|
||||
fn scratch(name: &str) -> PathBuf {
|
||||
let root = std::env::temp_dir().join(format!(
|
||||
"horizon-launcher-import-{name}-{}",
|
||||
std::process::id()
|
||||
));
|
||||
let _ = fs::remove_dir_all(&root);
|
||||
fs::create_dir_all(&root).unwrap();
|
||||
root
|
||||
}
|
||||
|
||||
fn zip_file(path: &Path, files: &[(&str, &[u8])]) {
|
||||
fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
let mut zip = zip::ZipWriter::new(fs::File::create(path).unwrap());
|
||||
for (name, bytes) in files {
|
||||
zip.start_file(*name, zip::write::SimpleFileOptions::default())
|
||||
.unwrap();
|
||||
zip.write_all(bytes).unwrap();
|
||||
}
|
||||
zip.finish().unwrap();
|
||||
}
|
||||
|
||||
fn put(path: &Path, bytes: &[u8]) {
|
||||
fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
fs::write(path, bytes).unwrap();
|
||||
}
|
||||
|
||||
/// Makes instances as folders of `root`, refusing a name already taken, as the launcher does.
|
||||
fn maker(root: &Path) -> impl Fn(&str) -> Result<Instance, String> + '_ {
|
||||
move |name: &str| {
|
||||
let home = root.join(crate::modpacks::slug(name));
|
||||
if home.exists() {
|
||||
return Err(format!("There is already an instance called {name}."));
|
||||
}
|
||||
fs::create_dir_all(&home).unwrap();
|
||||
Ok(Instance {
|
||||
id: crate::modpacks::slug(name),
|
||||
name: name.into(),
|
||||
kind: instances::Kind::Own,
|
||||
work: home.clone(),
|
||||
home,
|
||||
icon: None,
|
||||
group: None,
|
||||
version: None,
|
||||
played: Duration::ZERO,
|
||||
last_played: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
const NONE: &dyn Fn(&str, f32) = &|_, _| {};
|
||||
|
||||
#[test]
|
||||
fn says_what_a_dropped_file_is() {
|
||||
let dir = scratch("what");
|
||||
let mrpack = |name: &str, deps: &str| {
|
||||
let path = dir.join(name);
|
||||
let index = format!(r#"{{"formatVersion":1,"name":"P","files":[],"dependencies":{deps}}}"#);
|
||||
zip_file(&path, &[("modrinth.index.json", index.as_bytes())]);
|
||||
path
|
||||
};
|
||||
let cases: Vec<(PathBuf, Result<Dropped, ()>)> = vec![
|
||||
(
|
||||
mrpack("shared.mrpack", r#"{"minecraft":"26.3"}"#),
|
||||
Ok(Dropped::Instance),
|
||||
),
|
||||
(
|
||||
mrpack(
|
||||
"java.mrpack",
|
||||
r#"{"minecraft":"1.21.1","fabric-loader":"0.16"}"#,
|
||||
),
|
||||
Ok(Dropped::Modpack),
|
||||
),
|
||||
{
|
||||
let p = dir.join("cf.zip");
|
||||
zip_file(
|
||||
&p,
|
||||
&[("manifest.json", b"{}"), ("overrides/config/a.toml", b"")],
|
||||
);
|
||||
(p, Ok(Dropped::Modpack))
|
||||
},
|
||||
{
|
||||
let p = dir.join("rp.zip");
|
||||
zip_file(&p, &[("pack.mcmeta", b"{}"), ("assets/a.png", b"")]);
|
||||
(p, Ok(Dropped::Pack(packs::Kind::Resource)))
|
||||
},
|
||||
{
|
||||
let p = dir.join("dp.zip");
|
||||
zip_file(
|
||||
&p,
|
||||
&[
|
||||
("pack.mcmeta", b"{}"),
|
||||
("data/a/function/f.mcfunction", b""),
|
||||
],
|
||||
);
|
||||
(p, Ok(Dropped::DataPack))
|
||||
},
|
||||
{
|
||||
let p = dir.join("sp.zip");
|
||||
zip_file(&p, &[("shaders/final.fsh", b"")]);
|
||||
(p, Ok(Dropped::Pack(packs::Kind::Shader)))
|
||||
},
|
||||
{
|
||||
let p = dir.join("glow.hshader");
|
||||
put(&p, b"PK");
|
||||
(p, Ok(Dropped::Pack(packs::Kind::Shader)))
|
||||
},
|
||||
{
|
||||
let p = dir.join("folder.zip");
|
||||
zip_file(
|
||||
&p,
|
||||
&[("options.txt", b"lang:fr_ch\n"), ("saves/W/level.dat", b"")],
|
||||
);
|
||||
(p, Ok(Dropped::Instance))
|
||||
},
|
||||
{
|
||||
let p = dir.join("random.zip");
|
||||
zip_file(&p, &[("readme.txt", b"")]);
|
||||
(p, Err(()))
|
||||
},
|
||||
{
|
||||
let p = dir.join("picture.png");
|
||||
put(&p, b"png");
|
||||
(p, Err(()))
|
||||
},
|
||||
];
|
||||
for (file, want) in cases {
|
||||
assert_eq!(what(&file).map_err(|_| ()), want, "{}", file.display());
|
||||
}
|
||||
fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_export_comes_back_as_an_instance_and_nothing_escapes_its_folder() {
|
||||
let dir = scratch("roundtrip");
|
||||
let home = dir.join("from");
|
||||
put(&home.join("options.txt"), b"lang:fr_ch\n");
|
||||
put(&home.join("resourcepacks/Glass.zip"), b"glass");
|
||||
put(
|
||||
&home.join("horizon-mods/coords/horizon-mod.toml"),
|
||||
b"id = \"coords\"\n",
|
||||
);
|
||||
put(&home.join("saves/Base/region/r.0.0.mca"), b"region");
|
||||
put(&home.join("saves/Base/level.dat"), b"not nbt");
|
||||
let made = dir.join("instances");
|
||||
for format in [Format::Mrpack, Format::Zip] {
|
||||
let out = dir.join(format!("Shared.{}", format.extension()));
|
||||
export(&home, "Shared", format, &["Base".into()], &[], &out).unwrap();
|
||||
let i = import_into(&out, NONE, &maker(&made)).unwrap();
|
||||
for f in [
|
||||
"options.txt",
|
||||
"resourcepacks/Glass.zip",
|
||||
"horizon-mods/coords/horizon-mod.toml",
|
||||
"saves/Base/region/r.0.0.mca",
|
||||
] {
|
||||
assert_eq!(
|
||||
fs::read(i.home.join(f)).unwrap(),
|
||||
fs::read(home.join(f)).unwrap(),
|
||||
"{f}"
|
||||
);
|
||||
}
|
||||
}
|
||||
// The .mrpack took the pack's name; the zip came second and got "(2)".
|
||||
assert!(made.join("shared").is_dir() && made.join("shared-2").is_dir());
|
||||
|
||||
// A zip that reaches out of its folder, or carries what an instance doesn't keep.
|
||||
let evil = dir.join("evil.zip");
|
||||
zip_file(
|
||||
&evil,
|
||||
&[
|
||||
("options.txt", b"ok"),
|
||||
("../outside.txt", b"no"),
|
||||
("saves/../../up.txt", b"no"),
|
||||
("logs/latest.log", b"no"),
|
||||
("session.json", b"no"),
|
||||
],
|
||||
);
|
||||
let i = import_into(&evil, NONE, &maker(&made)).unwrap();
|
||||
assert!(i.home.join("options.txt").is_file());
|
||||
assert!(!dir.join("outside.txt").exists() && !made.join("up.txt").exists());
|
||||
assert!(!i.home.join("logs").exists() && !i.home.join("session.json").exists());
|
||||
|
||||
// A file to download from anywhere but Modrinth is refused, and the half-made folder goes.
|
||||
let index = r#"{"formatVersion":1,"name":"Far","dependencies":{"minecraft":"26.3"},
|
||||
"files":[{"path":"resourcepacks/x.zip","hashes":{"sha1":"00","sha512":"00"},
|
||||
"downloads":["https://example.com/x.zip"],"fileSize":1}]}"#;
|
||||
let far = dir.join("far.mrpack");
|
||||
zip_file(&far, &[("modrinth.index.json", index.as_bytes())]);
|
||||
let refused = import_into(&far, NONE, &maker(&made)).unwrap_err();
|
||||
assert!(refused.contains("resourcepacks/x.zip"), "{refused}");
|
||||
assert!(!made.join("far").exists());
|
||||
|
||||
let java = dir.join("java.mrpack");
|
||||
zip_file(
|
||||
&java,
|
||||
&[(
|
||||
"modrinth.index.json",
|
||||
br#"{"name":"J","files":[],"dependencies":{"neoforge":"21"}}"#,
|
||||
)],
|
||||
);
|
||||
assert!(import_into(&java, NONE, &maker(&made)).is_err());
|
||||
fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
@@ -10,6 +10,7 @@ pub mod export;
|
||||
#[cfg(unix)]
|
||||
pub mod game_app;
|
||||
pub mod heads;
|
||||
pub mod import;
|
||||
pub mod instances;
|
||||
pub mod modpacks;
|
||||
pub mod mojang;
|
||||
|
||||
Reference in New Issue
Block a user