Mod browser (2/3): install, update and remove, with horizon-launcher mods
browser::installed installs a pack and its required dependencies into resourcepacks/ or shaderpacks/, every file checked before any download (a dependency that is a Java mod stops it) and checksum-verified on the way in; mod-browser.json records source, version, file and checksum. Update swaps the file, remove deletes only what the browser installed (a player's own file of the same name is never overwritten). A modpack is downloaded, checked, and imported through the Modpacks page's pipeline. The CLI gains `mods list|search|install|update|remove`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -30,6 +30,31 @@ never offered for install.
|
||||
else removes the part file and installs nothing.
|
||||
- A file whose source lists no checksum is refused.
|
||||
|
||||
## Installing, updating, removing
|
||||
|
||||
`mod-browser.json` beside `options.txt` lists every file the browser installed: its source, project, version, file
|
||||
and the checksum it was checked against. The browser replaces or removes only the files it lists; a file of the
|
||||
same name the player put there is never overwritten.
|
||||
|
||||
- **Install** picks the newest version that runs, then its required dependencies, checked before any download: a
|
||||
dependency that isn't a pack Horizon loads (a Java mod) stops the install. Dependencies go in first. A resource
|
||||
pack still has to be turned on in the game's Resource Packs screen, and a shader pack in Video Settings > Shader
|
||||
Packs, as in vanilla and Iris.
|
||||
- **Update** installs the newer version and removes the old file.
|
||||
- **Remove** deletes the file and its entry. Packs installed as dependencies stay.
|
||||
- **A modpack** is downloaded (checked the same way) into `ports/downloads/` and imported on the Modpacks page,
|
||||
which says what of it Horizon runs and ports it.
|
||||
|
||||
From a terminal (or an agent):
|
||||
|
||||
```sh
|
||||
horizon-launcher mods search faithful # --kind resource|shader|modpack, --everything, --source
|
||||
horizon-launcher mods install faithful-32x # id or slug; a modpack is imported
|
||||
horizon-launcher mods list # --json
|
||||
horizon-launcher mods update [faithful-32x] [--check]
|
||||
horizon-launcher mods remove faithful-32x
|
||||
```
|
||||
|
||||
## Sources
|
||||
|
||||
**Modrinth.** The public API (`api.modrinth.com/v2`) needs no key. The launcher names itself in its user agent, as
|
||||
|
||||
@@ -139,6 +139,11 @@ The same binary is a command-line tool; without a subcommand it opens the window
|
||||
horizon-launcher modpack port <pack> [--from <dir>] [--version <tag>] get the jars and carry them over
|
||||
horizon-launcher modpack play <pack> [--version <tag>] play it as its own profile
|
||||
horizon-launcher modpack remove <pack>
|
||||
horizon-launcher mods [list] what the mod browser installed (docs/mod-browser.md)
|
||||
horizon-launcher mods search <text> [--kind resource|shader|modpack] [--everything] [--source modrinth|curseforge]
|
||||
horizon-launcher mods install <id or slug> checksum checked, with what it needs; a modpack is imported
|
||||
horizon-launcher mods update [<pack>] [--check]
|
||||
horizon-launcher mods remove <pack>
|
||||
horizon-launcher servers [list] the servers hosted from the launcher, and whether they run
|
||||
horizon-launcher servers create [--name N] [--seed S | --copy-world DIR] [--mode M] [--difficulty D]
|
||||
[--max-players N] [--open] [--check-accounts] [--player NAME]... --accept-eula
|
||||
|
||||
+21
-2
@@ -7,14 +7,18 @@
|
||||
//! page). Java mod jars don't run in Horizon (docs/mods.md), so they are never searched.
|
||||
pub mod curseforge;
|
||||
pub mod download;
|
||||
pub mod installed;
|
||||
pub mod modrinth;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// The Minecraft version Horizon plays. A version port updates it with the other `"26.3"` sites
|
||||
/// (docs/version-ports.md).
|
||||
pub const GAME: &str = "26.3";
|
||||
|
||||
/// What a project is, as far as Horizon is concerned.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "kebab-case")]
|
||||
pub enum Kind {
|
||||
ResourcePack,
|
||||
ShaderPack,
|
||||
@@ -43,7 +47,8 @@ impl Kind {
|
||||
}
|
||||
|
||||
/// Where a project comes from.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "kebab-case")]
|
||||
pub enum SourceId {
|
||||
Modrinth,
|
||||
CurseForge,
|
||||
@@ -194,6 +199,15 @@ pub trait Source: Send + Sync {
|
||||
fn project(&self, id: &str) -> Result<Project, String>;
|
||||
/// Versions, newest first.
|
||||
fn versions(&self, project: &Project) -> Result<Vec<Version>, String>;
|
||||
/// Downloads one of its files into `folder`, checked ([`download::fetch`]).
|
||||
fn fetch(
|
||||
&self,
|
||||
file: &FileRef,
|
||||
folder: &std::path::Path,
|
||||
progress: &dyn Fn(f32),
|
||||
) -> Result<std::path::PathBuf, String> {
|
||||
download::fetch(file, folder, progress)
|
||||
}
|
||||
}
|
||||
|
||||
/// The sources this launcher can use: Modrinth always, CurseForge when it has an API key.
|
||||
@@ -205,6 +219,11 @@ pub fn sources() -> Vec<Box<dyn Source>> {
|
||||
all
|
||||
}
|
||||
|
||||
/// The source of that id, when this launcher can use it.
|
||||
pub fn source(id: SourceId) -> Option<Box<dyn Source>> {
|
||||
sources().into_iter().find(|s| s.id() == id)
|
||||
}
|
||||
|
||||
/// The loaders a Java shader pack may name that Horizon translates.
|
||||
const SHADER_LOADERS: [&str; 2] = ["iris", "optifine"];
|
||||
|
||||
|
||||
@@ -0,0 +1,260 @@
|
||||
//! What the browser installed into the game folder, and installing, updating and removing it.
|
||||
//!
|
||||
//! `mod-browser.json` beside `options.txt` lists each file the browser put in `resourcepacks/`
|
||||
//! or `shaderpacks/`: where it came from, its version and its checksum. Files the player put
|
||||
//! there themselves are never touched: the browser only replaces or removes what it lists.
|
||||
use super::{pick, safe_name, Kind, Project, Source, SourceId, Support, Version};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
const MANIFEST: &str = "mod-browser.json";
|
||||
/// How deep required dependencies are followed.
|
||||
const MAX_DEPTH: usize = 4;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct Entry {
|
||||
pub source: SourceId,
|
||||
pub project: String,
|
||||
pub slug: String,
|
||||
pub title: String,
|
||||
pub kind: Kind,
|
||||
pub version: String,
|
||||
pub number: String,
|
||||
/// Relative to the game folder: `resourcepacks/<name>`.
|
||||
pub file: String,
|
||||
/// The checksum the download was checked against: `SHA-512:<hex>`.
|
||||
pub checksum: String,
|
||||
pub page: String,
|
||||
/// Installed because another pack needs it.
|
||||
#[serde(default)]
|
||||
pub dependency: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Serialize, Deserialize)]
|
||||
pub struct Installed {
|
||||
pub entries: Vec<Entry>,
|
||||
}
|
||||
|
||||
impl Installed {
|
||||
pub fn load(home: &Path) -> Self {
|
||||
fs::read_to_string(home.join(MANIFEST))
|
||||
.ok()
|
||||
.and_then(|t| serde_json::from_str(&t).ok())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
pub fn save(&self, home: &Path) -> Result<(), String> {
|
||||
let path = home.join(MANIFEST);
|
||||
let part = home.join(format!(".{MANIFEST}.part"));
|
||||
let text = serde_json::to_string_pretty(self).map_err(|e| e.to_string())?;
|
||||
fs::create_dir_all(home).map_err(|e| format!("{}: {e}", home.display()))?;
|
||||
fs::write(&part, text).map_err(|e| format!("{}: {e}", part.display()))?;
|
||||
fs::rename(&part, &path).map_err(|e| format!("{}: {e}", path.display()))
|
||||
}
|
||||
|
||||
pub fn find(&self, source: SourceId, project: &str) -> Option<&Entry> {
|
||||
self.entries
|
||||
.iter()
|
||||
.find(|e| e.source == source && e.project == project)
|
||||
}
|
||||
|
||||
/// By project id or slug, as the CLI takes them.
|
||||
pub fn lookup(&self, name: &str) -> Option<&Entry> {
|
||||
self.entries
|
||||
.iter()
|
||||
.find(|e| e.project == name || e.slug == name)
|
||||
}
|
||||
}
|
||||
|
||||
/// One file to install: the project, the version chosen and why it was pulled in.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Step {
|
||||
pub project: Project,
|
||||
pub version: Version,
|
||||
pub dependency: bool,
|
||||
}
|
||||
|
||||
/// What installing `project` takes, dependencies first, checked before any byte is downloaded:
|
||||
/// every file runs in Horizon and has a version to install.
|
||||
pub fn plan(source: &dyn Source, project: &Project, everything: bool) -> Result<Vec<Step>, String> {
|
||||
if project.kind.folder().is_none() {
|
||||
return Err(format!(
|
||||
"{} is a modpack: it is imported on the Modpacks page.",
|
||||
project.title
|
||||
));
|
||||
}
|
||||
let mut steps = Vec::new();
|
||||
add(source, project.clone(), everything, false, 0, &mut steps)?;
|
||||
Ok(steps)
|
||||
}
|
||||
|
||||
fn add(
|
||||
source: &dyn Source,
|
||||
project: Project,
|
||||
everything: bool,
|
||||
dependency: bool,
|
||||
depth: usize,
|
||||
steps: &mut Vec<Step>,
|
||||
) -> Result<(), String> {
|
||||
if steps.iter().any(|s| s.project.id == project.id) {
|
||||
return Ok(());
|
||||
}
|
||||
if depth > MAX_DEPTH {
|
||||
return Err(format!("{}'s dependencies go too deep.", project.title));
|
||||
}
|
||||
if let Support::No(why) = project.support() {
|
||||
return Err(format!("{} doesn't run in Horizon: {why}", project.title));
|
||||
}
|
||||
let versions = source.versions(&project)?;
|
||||
let Some(version) = pick(project.kind, &versions, everything).cloned() else {
|
||||
return Err(match versions.iter().find_map(|v| v.blocked.clone()) {
|
||||
Some(why) => format!("{} can't be installed from here: {why}", project.title),
|
||||
None => format!("{} has no version Horizon runs.", project.title),
|
||||
});
|
||||
};
|
||||
for id in &version.required {
|
||||
let needed = source.project(id).map_err(|_| {
|
||||
format!(
|
||||
"{} needs {id} on {}, which isn't a pack Horizon loads (a Java mod?).",
|
||||
project.title,
|
||||
source.id().label()
|
||||
)
|
||||
})?;
|
||||
if needed.kind.folder().is_none() {
|
||||
return Err(format!(
|
||||
"{} needs the modpack {}.",
|
||||
project.title, needed.title
|
||||
));
|
||||
}
|
||||
add(source, needed, everything, true, depth + 1, steps)?;
|
||||
}
|
||||
steps.push(Step {
|
||||
project,
|
||||
version,
|
||||
dependency,
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Installs `project` (and what it needs) into the game folder `home`. A project already
|
||||
/// installed is updated to the version chosen. `progress` gets a line per file and the fraction.
|
||||
pub fn install(
|
||||
source: &dyn Source,
|
||||
project: &Project,
|
||||
everything: bool,
|
||||
home: &Path,
|
||||
progress: &dyn Fn(&str, f32),
|
||||
) -> Result<Vec<Entry>, String> {
|
||||
let steps = plan(source, project, everything)?;
|
||||
let mut installed = Installed::load(home);
|
||||
let mut done = Vec::new();
|
||||
for step in steps {
|
||||
let p = &step.project;
|
||||
let old = installed.find(p.source, &p.id).cloned();
|
||||
if old.as_ref().is_some_and(|o| o.version == step.version.id) {
|
||||
done.push(old.expect("checked"));
|
||||
continue;
|
||||
}
|
||||
let file = step
|
||||
.version
|
||||
.file()
|
||||
.expect("pick keeps versions with a file");
|
||||
let folder_name = p.kind.folder().expect("plan keeps folder kinds");
|
||||
let name = safe_name(&file.name)
|
||||
.ok_or_else(|| format!("{:?} isn't a plain file name.", file.name))?;
|
||||
let relative = format!("{folder_name}/{name}");
|
||||
let owner = installed.entries.iter().find(|e| e.file == relative);
|
||||
let ours = owner.is_some_and(|e| e.source == p.source && e.project == p.id);
|
||||
if home.join(&relative).exists() && !ours {
|
||||
return Err(match owner {
|
||||
Some(e) => format!(
|
||||
"{relative} belongs to {}, installed from the browser.",
|
||||
e.title
|
||||
),
|
||||
None => format!(
|
||||
"{relative} is already there and wasn't installed by the browser: move it \
|
||||
away first, or keep it."
|
||||
),
|
||||
});
|
||||
}
|
||||
let line = format!("{} {}", p.title, step.version.number);
|
||||
let path = source.fetch(file, &home.join(folder_name), &|f| progress(&line, f))?;
|
||||
let (algo, hash) = file.checksum().expect("fetch checks for one");
|
||||
if let Some(old) = &old {
|
||||
if old.file != relative {
|
||||
let _ = fs::remove_file(home.join(&old.file));
|
||||
}
|
||||
}
|
||||
let entry = Entry {
|
||||
source: p.source,
|
||||
project: p.id.clone(),
|
||||
slug: p.slug.clone(),
|
||||
title: p.title.clone(),
|
||||
kind: p.kind,
|
||||
version: step.version.id.clone(),
|
||||
number: step.version.number.clone(),
|
||||
file: relative,
|
||||
checksum: format!("{algo}:{hash}"),
|
||||
page: p.page.clone(),
|
||||
// Asked for by the player once: it stays theirs.
|
||||
dependency: step.dependency && old.as_ref().is_none_or(|o| o.dependency),
|
||||
};
|
||||
debug_assert!(path.ends_with(name));
|
||||
installed
|
||||
.entries
|
||||
.retain(|e| !(e.source == p.source && e.project == p.id));
|
||||
installed.entries.push(entry.clone());
|
||||
installed.save(home)?;
|
||||
done.push(entry);
|
||||
}
|
||||
Ok(done)
|
||||
}
|
||||
|
||||
/// Removes what the browser installed for `name` (a project id or slug): its file and its entry.
|
||||
pub fn remove(home: &Path, name: &str) -> Result<Entry, String> {
|
||||
let mut installed = Installed::load(home);
|
||||
let entry = installed
|
||||
.lookup(name)
|
||||
.cloned()
|
||||
.ok_or_else(|| format!("{name} wasn't installed by the browser."))?;
|
||||
match fs::remove_file(home.join(&entry.file)) {
|
||||
Ok(()) => {}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(e) => return Err(format!("{}: {e}", entry.file)),
|
||||
}
|
||||
installed
|
||||
.entries
|
||||
.retain(|e| !(e.source == entry.source && e.project == entry.project));
|
||||
installed.save(home)?;
|
||||
Ok(entry)
|
||||
}
|
||||
|
||||
/// The newer version `entry` can be updated to, if any.
|
||||
pub fn update_for(source: &dyn Source, entry: &Entry) -> Result<Option<Version>, String> {
|
||||
let project = source.project(&entry.project)?;
|
||||
let versions = source.versions(&project)?;
|
||||
Ok(pick(project.kind, &versions, true)
|
||||
.filter(|v| v.id != entry.version)
|
||||
.cloned())
|
||||
}
|
||||
|
||||
/// Downloads a modpack's file, checked, into `folder` (kept there: the import reads it).
|
||||
pub fn fetch_modpack(
|
||||
source: &dyn Source,
|
||||
project: &Project,
|
||||
folder: &Path,
|
||||
progress: &dyn Fn(f32),
|
||||
) -> Result<PathBuf, String> {
|
||||
if project.kind != Kind::Modpack {
|
||||
return Err(format!("{} isn't a modpack.", project.title));
|
||||
}
|
||||
let versions = source.versions(project)?;
|
||||
let version = pick(Kind::Modpack, &versions, true)
|
||||
.ok_or_else(|| format!("{} has no file to download.", project.title))?;
|
||||
let file = version.file().expect("pick keeps versions with a file");
|
||||
source.fetch(file, folder, progress)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,252 @@
|
||||
use super::*;
|
||||
use crate::browser::{download, FileRef, Query, GAME};
|
||||
use sha2::Digest;
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Mutex;
|
||||
|
||||
/// A source in memory: projects, their versions, and the bytes each file URL serves.
|
||||
#[derive(Default)]
|
||||
struct Fake {
|
||||
projects: HashMap<String, Project>,
|
||||
versions: Mutex<HashMap<String, Vec<Version>>>,
|
||||
bytes: Mutex<HashMap<String, Vec<u8>>>,
|
||||
}
|
||||
|
||||
impl Source for Fake {
|
||||
fn id(&self) -> SourceId {
|
||||
SourceId::Modrinth
|
||||
}
|
||||
fn search(&self, _: &Query) -> Result<Vec<Project>, String> {
|
||||
Ok(self.projects.values().cloned().collect())
|
||||
}
|
||||
fn project(&self, id: &str) -> Result<Project, String> {
|
||||
self.projects
|
||||
.get(id)
|
||||
.cloned()
|
||||
.ok_or_else(|| "not a pack".into())
|
||||
}
|
||||
fn versions(&self, p: &Project) -> Result<Vec<Version>, String> {
|
||||
Ok(self
|
||||
.versions
|
||||
.lock()
|
||||
.unwrap()
|
||||
.get(&p.id)
|
||||
.cloned()
|
||||
.unwrap_or_default())
|
||||
}
|
||||
fn fetch(
|
||||
&self,
|
||||
file: &FileRef,
|
||||
folder: &Path,
|
||||
progress: &dyn Fn(f32),
|
||||
) -> Result<PathBuf, String> {
|
||||
let body = self
|
||||
.bytes
|
||||
.lock()
|
||||
.unwrap()
|
||||
.get(&file.url)
|
||||
.cloned()
|
||||
.unwrap_or_default();
|
||||
download::save(file, &body[..], folder, progress)
|
||||
}
|
||||
}
|
||||
|
||||
fn project(id: &str, kind: Kind) -> Project {
|
||||
Project {
|
||||
source: SourceId::Modrinth,
|
||||
id: id.into(),
|
||||
slug: format!("{id}-slug"),
|
||||
title: format!("Pack {id}"),
|
||||
summary: String::new(),
|
||||
author: String::new(),
|
||||
downloads: 0,
|
||||
page: format!("https://modrinth.com/resourcepack/{id}-slug"),
|
||||
icon: None,
|
||||
license: "MIT".into(),
|
||||
kind,
|
||||
game_versions: vec![GAME.into()],
|
||||
loaders: vec![if kind == Kind::ShaderPack {
|
||||
"iris"
|
||||
} else {
|
||||
"minecraft"
|
||||
}
|
||||
.into()],
|
||||
}
|
||||
}
|
||||
|
||||
impl Fake {
|
||||
fn add(&mut self, p: Project) {
|
||||
self.projects.insert(p.id.clone(), p);
|
||||
}
|
||||
/// A new newest version of `id`, its file serving `body`; `tamper` serves other bytes.
|
||||
fn release(&self, id: &str, number: &str, needs: &[&str], body: &[u8], tamper: bool) {
|
||||
let url = format!("https://cdn.modrinth.com/data/{id}/versions/{number}/{id}-{number}.zip");
|
||||
let file = FileRef {
|
||||
url: url.clone(),
|
||||
name: format!("{id}-{number}.zip"),
|
||||
size: body.len() as u64,
|
||||
sha512: Some(
|
||||
sha2::Sha512::digest(body)
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect(),
|
||||
),
|
||||
sha1: None,
|
||||
primary: true,
|
||||
};
|
||||
let version = Version {
|
||||
id: format!("{id}@{number}"),
|
||||
number: number.into(),
|
||||
published: number.into(),
|
||||
game_versions: vec![GAME.into()],
|
||||
loaders: self.projects[id].loaders.clone(),
|
||||
files: vec![file],
|
||||
required: needs.iter().map(|s| s.to_string()).collect(),
|
||||
blocked: None,
|
||||
};
|
||||
let mut served = body.to_vec();
|
||||
if tamper {
|
||||
served[0] ^= 1;
|
||||
}
|
||||
self.bytes.lock().unwrap().insert(url, served);
|
||||
let mut versions = self.versions.lock().unwrap();
|
||||
versions.entry(id.into()).or_default().insert(0, version);
|
||||
}
|
||||
}
|
||||
|
||||
fn home(name: &str) -> PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!("horizon-installed-{name}-{}", std::process::id()));
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
const NONE: &dyn Fn(&str, f32) = &|_, _| {};
|
||||
|
||||
#[test]
|
||||
fn installs_with_dependencies_then_updates_and_removes() {
|
||||
let home = home("cycle");
|
||||
let mut fake = Fake::default();
|
||||
fake.add(project("base", Kind::ResourcePack));
|
||||
fake.add(project("addon", Kind::ResourcePack));
|
||||
fake.release("base", "1", &[], b"base pack", false);
|
||||
fake.release("addon", "1", &["base"], b"addon pack", false);
|
||||
let addon = fake.project("addon").unwrap();
|
||||
|
||||
let done = install(&fake, &addon, false, &home, NONE).unwrap();
|
||||
let files: Vec<&str> = done.iter().map(|e| e.file.as_str()).collect();
|
||||
assert_eq!(
|
||||
files,
|
||||
["resourcepacks/base-1.zip", "resourcepacks/addon-1.zip"]
|
||||
);
|
||||
assert!(done[0].dependency && !done[1].dependency);
|
||||
assert!(done[1].checksum.starts_with("SHA-512:"));
|
||||
assert_eq!(
|
||||
fs::read(home.join("resourcepacks/addon-1.zip")).unwrap(),
|
||||
b"addon pack"
|
||||
);
|
||||
assert_eq!(Installed::load(&home).entries.len(), 2);
|
||||
|
||||
// Installing again with nothing new downloads nothing.
|
||||
fs::remove_file(home.join("resourcepacks/base-1.zip")).unwrap();
|
||||
install(&fake, &addon, false, &home, NONE).unwrap();
|
||||
assert!(!home.join("resourcepacks/base-1.zip").exists());
|
||||
|
||||
// An update replaces the old file.
|
||||
fake.release("addon", "2", &["base"], b"addon pack v2", false);
|
||||
let entry = Installed::load(&home).lookup("addon").cloned().unwrap();
|
||||
assert_eq!(update_for(&fake, &entry).unwrap().unwrap().number, "2");
|
||||
install(&fake, &addon, false, &home, NONE).unwrap();
|
||||
assert!(!home.join("resourcepacks/addon-1.zip").exists());
|
||||
assert_eq!(
|
||||
fs::read(home.join("resourcepacks/addon-2.zip")).unwrap(),
|
||||
b"addon pack v2"
|
||||
);
|
||||
let entry = Installed::load(&home)
|
||||
.lookup("addon-slug")
|
||||
.cloned()
|
||||
.unwrap();
|
||||
assert_eq!(entry.number, "2");
|
||||
assert!(update_for(&fake, &entry).unwrap().is_none());
|
||||
|
||||
let removed = remove(&home, "addon").unwrap();
|
||||
assert_eq!(removed.project, "addon");
|
||||
assert!(!home.join("resourcepacks/addon-2.zip").exists());
|
||||
assert!(remove(&home, "addon").is_err());
|
||||
assert_eq!(Installed::load(&home).entries.len(), 1);
|
||||
fs::remove_dir_all(&home).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_is_installed_when_a_check_fails() {
|
||||
let home = home("refuse");
|
||||
let mut fake = Fake::default();
|
||||
fake.add(project("good", Kind::ResourcePack));
|
||||
fake.add(project("bad", Kind::ResourcePack));
|
||||
fake.add(project("needs-mod", Kind::ResourcePack));
|
||||
fake.release("good", "1", &[], b"good", false);
|
||||
fake.release("bad", "1", &[], b"tampered", true);
|
||||
fake.release("needs-mod", "1", &["sodium"], b"x", false);
|
||||
|
||||
let e = install(&fake, &fake.project("bad").unwrap(), false, &home, NONE).unwrap_err();
|
||||
assert!(e.contains("checksum doesn't match"), "{e}");
|
||||
let e = install(
|
||||
&fake,
|
||||
&fake.project("needs-mod").unwrap(),
|
||||
false,
|
||||
&home,
|
||||
NONE,
|
||||
)
|
||||
.unwrap_err();
|
||||
assert!(e.contains("needs sodium"), "{e}");
|
||||
assert!(
|
||||
!home.join("resourcepacks").exists()
|
||||
|| fs::read_dir(home.join("resourcepacks")).unwrap().count() == 0
|
||||
);
|
||||
assert!(Installed::load(&home).entries.is_empty());
|
||||
|
||||
// The player's own file of the same name is never replaced.
|
||||
fs::create_dir_all(home.join("resourcepacks")).unwrap();
|
||||
fs::write(home.join("resourcepacks/good-1.zip"), b"mine").unwrap();
|
||||
let e = install(&fake, &fake.project("good").unwrap(), false, &home, NONE).unwrap_err();
|
||||
assert!(e.contains("wasn't installed by the browser"), "{e}");
|
||||
assert_eq!(
|
||||
fs::read(home.join("resourcepacks/good-1.zip")).unwrap(),
|
||||
b"mine"
|
||||
);
|
||||
assert!(remove(&home, "good").is_err());
|
||||
assert!(home.join("resourcepacks/good-1.zip").exists());
|
||||
|
||||
// What doesn't run is refused before anything is asked for.
|
||||
let mut canvas = project("canvas", Kind::ShaderPack);
|
||||
canvas.loaders = vec!["canvas".into()];
|
||||
fake.add(canvas.clone());
|
||||
assert!(install(&fake, &canvas, true, &home, NONE)
|
||||
.unwrap_err()
|
||||
.contains("doesn't run"));
|
||||
let pack = project("pack", Kind::Modpack);
|
||||
assert!(plan(&fake, &pack, false)
|
||||
.unwrap_err()
|
||||
.contains("Modpacks page"));
|
||||
fs::remove_dir_all(&home).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shader_packs_go_to_their_folder_and_modpacks_download_checked() {
|
||||
let home = home("kinds");
|
||||
let mut fake = Fake::default();
|
||||
fake.add(project("bsl", Kind::ShaderPack));
|
||||
fake.release("bsl", "10", &[], b"shaders", false);
|
||||
install(&fake, &fake.project("bsl").unwrap(), false, &home, NONE).unwrap();
|
||||
assert!(home.join("shaderpacks/bsl-10.zip").is_file());
|
||||
|
||||
fake.add(project("atm", Kind::Modpack));
|
||||
fake.release("atm", "1", &[], b"mrpack", false);
|
||||
let downloads = home.join("downloads");
|
||||
let path = fetch_modpack(&fake, &fake.project("atm").unwrap(), &downloads, &|_| {}).unwrap();
|
||||
assert_eq!(fs::read(path).unwrap(), b"mrpack");
|
||||
fake.release("atm", "2", &[], b"mrpack 2", true);
|
||||
assert!(fetch_modpack(&fake, &fake.project("atm").unwrap(), &downloads, &|_| {}).is_err());
|
||||
assert!(!downloads.join("atm-2.zip").exists());
|
||||
fs::remove_dir_all(&home).unwrap();
|
||||
}
|
||||
@@ -155,6 +155,68 @@ enum ModpackCmd {
|
||||
Remove { pack: String },
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
enum ModsCmd {
|
||||
/// What the browser installed (the default)
|
||||
List,
|
||||
/// Search for packs Horizon loads
|
||||
Search {
|
||||
text: Vec<String>,
|
||||
#[arg(long, value_enum, default_value_t = KindArg::Resource)]
|
||||
kind: KindArg,
|
||||
/// Also what was made for other versions or runs only partly, each marked
|
||||
#[arg(long)]
|
||||
everything: bool,
|
||||
#[arg(long, value_enum, default_value_t = SourceArg::Modrinth)]
|
||||
source: SourceArg,
|
||||
},
|
||||
/// Install a pack and what it needs, by its id or slug (checksums checked); a modpack is
|
||||
/// imported on the Modpacks page
|
||||
Install {
|
||||
project: String,
|
||||
/// Allow a version made for another Minecraft version
|
||||
#[arg(long)]
|
||||
everything: bool,
|
||||
#[arg(long, value_enum, default_value_t = SourceArg::Modrinth)]
|
||||
source: SourceArg,
|
||||
},
|
||||
/// Update what the browser installed (or one pack)
|
||||
Update {
|
||||
project: Option<String>,
|
||||
/// Only say what is newer
|
||||
#[arg(long)]
|
||||
check: bool,
|
||||
},
|
||||
/// Remove a pack the browser installed
|
||||
Remove { project: String },
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, clap::ValueEnum)]
|
||||
enum KindArg {
|
||||
Resource,
|
||||
Shader,
|
||||
Modpack,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, clap::ValueEnum)]
|
||||
enum SourceArg {
|
||||
Modrinth,
|
||||
Curseforge,
|
||||
}
|
||||
|
||||
impl SourceArg {
|
||||
fn get(self) -> Result<Box<dyn horizon_launcher::browser::Source>, String> {
|
||||
use horizon_launcher::browser::{self, SourceId};
|
||||
let id = match self {
|
||||
SourceArg::Modrinth => SourceId::Modrinth,
|
||||
SourceArg::Curseforge => SourceId::CurseForge,
|
||||
};
|
||||
browser::source(id).ok_or_else(|| {
|
||||
"CurseForge needs an API key: HORIZON_CURSEFORGE_API_KEY (docs/mod-browser.md).".into()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
enum Cmd {
|
||||
/// List Horizon releases, or the installed versions
|
||||
@@ -257,6 +319,12 @@ enum Cmd {
|
||||
#[command(subcommand)]
|
||||
action: Option<ModpackCmd>,
|
||||
},
|
||||
/// The mod browser: resource packs, shader packs and modpacks from Modrinth (and CurseForge
|
||||
/// with a key), each file checked against its checksum (docs/mod-browser.md)
|
||||
Mods {
|
||||
#[command(subcommand)]
|
||||
action: Option<ModsCmd>,
|
||||
},
|
||||
/// Servers hosted with horizon-server (the Servers page): list them, create one, or run any
|
||||
/// horizon-server command on one
|
||||
Servers {
|
||||
@@ -523,6 +591,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
|
||||
}
|
||||
}
|
||||
Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
|
||||
Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List), as_json)?,
|
||||
Cmd::Servers { action } => servers(action.unwrap_or(ServersCmd::List), as_json)?,
|
||||
Cmd::Mcp => unreachable!(),
|
||||
}
|
||||
@@ -821,6 +890,148 @@ fn servers(action: ServersCmd, as_json: bool) -> Result<(), String> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
|
||||
use horizon_launcher::browser::{installed, Kind, Query};
|
||||
use horizon_launcher::modpacks;
|
||||
let home = backend::game_home();
|
||||
let entry_json = |e: &installed::Entry| serde_json::to_value(e).unwrap_or_default();
|
||||
let line = |label: &str, f: f32| progress(label.to_string())(f);
|
||||
match action {
|
||||
ModsCmd::List => {
|
||||
let list = installed::Installed::load(&home).entries;
|
||||
if as_json {
|
||||
json(list.iter().map(entry_json).collect());
|
||||
} else if list.is_empty() {
|
||||
println!(
|
||||
"Nothing installed from the browser yet: horizon-launcher mods search <text>"
|
||||
);
|
||||
}
|
||||
for e in list.iter().filter(|_| !as_json) {
|
||||
println!(
|
||||
"{} {} ({}, {})\n {} {}",
|
||||
e.title,
|
||||
e.number,
|
||||
e.source.label(),
|
||||
e.slug,
|
||||
e.file,
|
||||
e.checksum
|
||||
);
|
||||
}
|
||||
}
|
||||
ModsCmd::Search {
|
||||
text,
|
||||
kind,
|
||||
everything,
|
||||
source,
|
||||
} => {
|
||||
let kind = match kind {
|
||||
KindArg::Resource => Kind::ResourcePack,
|
||||
KindArg::Shader => Kind::ShaderPack,
|
||||
KindArg::Modpack => Kind::Modpack,
|
||||
};
|
||||
let query = Query {
|
||||
everything,
|
||||
..Query::new(&text.join(" "), kind)
|
||||
};
|
||||
let found = source.get()?.search(&query)?;
|
||||
if as_json {
|
||||
json(found.iter().map(|p| {
|
||||
let support = p.support();
|
||||
serde_json::json!({
|
||||
"id": p.id, "slug": p.slug, "title": p.title, "summary": p.summary,
|
||||
"author": p.author, "downloads": p.downloads, "page": p.page,
|
||||
"license": p.license, "support": support.label(), "reason": support.reason(),
|
||||
})
|
||||
}).collect());
|
||||
} else {
|
||||
for p in &found {
|
||||
let support = p.support();
|
||||
println!(
|
||||
"{} ({}) {} · {} downloads\n {}",
|
||||
p.title,
|
||||
p.slug,
|
||||
support.label(),
|
||||
p.downloads,
|
||||
p.summary
|
||||
);
|
||||
if let Some(why) = support.reason() {
|
||||
println!(" {why}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ModsCmd::Install {
|
||||
project,
|
||||
everything,
|
||||
source,
|
||||
} => {
|
||||
let source = source.get()?;
|
||||
let p = source.project(&project)?;
|
||||
if p.kind == Kind::Modpack {
|
||||
let folder = modpacks::ports_dir().join("downloads");
|
||||
let file =
|
||||
installed::fetch_modpack(&*source, &p, &folder, &progress(p.title.clone()))?;
|
||||
let log = &|line: String| eprintln!("{line}");
|
||||
let pack = modpacks::import(&file, log)?;
|
||||
println!(
|
||||
"Imported {} ({}): horizon-launcher modpack port {}",
|
||||
pack.title(),
|
||||
pack.summary(),
|
||||
pack.slug
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
let done = installed::install(&*source, &p, everything, &home, &line)?;
|
||||
if as_json {
|
||||
json(done.iter().map(entry_json).collect());
|
||||
}
|
||||
for e in done.iter().filter(|_| !as_json) {
|
||||
println!("{} {}: {} ({})", e.title, e.number, e.file, e.checksum);
|
||||
}
|
||||
}
|
||||
ModsCmd::Update { project, check } => {
|
||||
let list = installed::Installed::load(&home).entries;
|
||||
let chosen: Vec<_> = list
|
||||
.iter()
|
||||
.filter(|e| {
|
||||
project
|
||||
.as_deref()
|
||||
.is_none_or(|n| e.project == n || e.slug == n)
|
||||
})
|
||||
.collect();
|
||||
if chosen.is_empty() {
|
||||
return Err(match project {
|
||||
Some(n) => format!("{n} wasn't installed by the browser."),
|
||||
None => "Nothing installed from the browser yet.".into(),
|
||||
});
|
||||
}
|
||||
for e in chosen {
|
||||
let Some(source) = horizon_launcher::browser::source(e.source) else {
|
||||
println!("{}: {} isn't available here.", e.title, e.source.label());
|
||||
continue;
|
||||
};
|
||||
match installed::update_for(&*source, e)? {
|
||||
None => println!("{} {}: up to date.", e.title, e.number),
|
||||
Some(v) if check => {
|
||||
println!("{} {}: {} is available.", e.title, e.number, v.number)
|
||||
}
|
||||
Some(_) => {
|
||||
let p = source.project(&e.project)?;
|
||||
for done in installed::install(&*source, &p, true, &home, &line)? {
|
||||
println!("{} {}: {}", done.title, done.number, done.file);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ModsCmd::Remove { project } => {
|
||||
let e = installed::remove(&home, &project)?;
|
||||
println!("Removed {} ({}).", e.title, e.file);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn modpack(action: ModpackCmd, as_json: bool) -> Result<(), String> {
|
||||
use horizon_launcher::modpacks::{self, Imported};
|
||||
use horizon_port_pack::report::Status;
|
||||
|
||||
Reference in New Issue
Block a user