Files
horizon-airdef/launcher/src/browser.rs
T
Ludovic Marie 784e8f0648 Mod browser (1/3): Modrinth and CurseForge sources, checksum-checked downloads
The launcher's core gains `browser`: search Modrinth for what Horizon loads
(resource packs, Iris/OptiFine shader packs, modpacks; never Java mod jars),
say how well each result runs, pick the newest version that runs, and
download a file only from Modrinth's or CurseForge's file servers, with a
plain file name, kept only when its size and SHA-512 (SHA-1 on CurseForge)
match. CurseForge is a pluggable source that stays off until an API key
exists (HORIZON_CURSEFORGE_API_KEY at run time or build time; the launcher
workflow passes the repository secret). docs/mod-browser.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 03:17:25 +02:00

297 lines
9.4 KiB
Rust

//! The mod browser's sources: search Modrinth (and CurseForge, once a key exists) for what
//! Horizon loads, say how well each result runs, and download a file only after its checksum
//! matches (docs/mod-browser.md).
//!
//! Only what Horizon actually loads is offered: resource packs (`resourcepacks/`), Java shader
//! packs (`shaderpacks/`, Iris and OptiFine) and modpacks (imported and ported on the Modpacks
//! 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 modrinth;
/// 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)]
pub enum Kind {
ResourcePack,
ShaderPack,
Modpack,
}
impl Kind {
pub const ALL: [Kind; 3] = [Kind::ResourcePack, Kind::ShaderPack, Kind::Modpack];
pub fn label(self) -> &'static str {
match self {
Kind::ResourcePack => "Resource packs",
Kind::ShaderPack => "Shader packs",
Kind::Modpack => "Modpacks",
}
}
/// The folder beside `options.txt` the file goes in; a modpack is imported instead.
pub fn folder(self) -> Option<&'static str> {
match self {
Kind::ResourcePack => Some("resourcepacks"),
Kind::ShaderPack => Some("shaderpacks"),
Kind::Modpack => None,
}
}
}
/// Where a project comes from.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SourceId {
Modrinth,
CurseForge,
}
impl SourceId {
pub fn label(self) -> &'static str {
match self {
SourceId::Modrinth => "Modrinth",
SourceId::CurseForge => "CurseForge",
}
}
}
/// How well a project runs in Horizon.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Support {
/// Made for the version Horizon plays, and Horizon reads everything it uses.
Works,
/// It loads, with the limit said.
Partial(String),
/// It can't run in Horizon: never offered for install.
No(String),
}
impl Support {
pub fn installable(&self) -> bool {
!matches!(self, Support::No(_))
}
pub fn label(&self) -> &'static str {
match self {
Support::Works => "Works",
Support::Partial(_) => "Partly",
Support::No(_) => "Doesn't run",
}
}
pub fn reason(&self) -> Option<&str> {
match self {
Support::Works => None,
Support::Partial(r) | Support::No(r) => Some(r),
}
}
}
/// A search result or a looked-up project.
#[derive(Clone, Debug, PartialEq)]
pub struct Project {
pub source: SourceId,
pub id: String,
pub slug: String,
pub title: String,
pub summary: String,
pub author: String,
pub downloads: u64,
/// The project's page on its source, for the player to read before installing.
pub page: String,
pub icon: Option<String>,
pub license: String,
pub kind: Kind,
/// The Minecraft versions its files list, and the loaders (`iris`, `optifine`, `minecraft`...).
pub game_versions: Vec<String>,
pub loaders: Vec<String>,
}
impl Project {
pub fn support(&self) -> Support {
support(self.kind, &self.game_versions, &self.loaders)
}
}
/// One downloadable file of a version, with the checksums its source publishes.
#[derive(Clone, Debug, PartialEq)]
pub struct FileRef {
pub url: String,
pub name: String,
pub size: u64,
pub sha512: Option<String>,
pub sha1: Option<String>,
pub primary: bool,
}
impl FileRef {
/// The strongest checksum the source gives: what the download is checked against.
pub fn checksum(&self) -> Option<(&'static str, &str)> {
match (&self.sha512, &self.sha1) {
(Some(h), _) => Some(("SHA-512", h)),
(None, Some(h)) => Some(("SHA-1", h)),
(None, None) => None,
}
}
}
/// A version of a project: its files and what it needs.
#[derive(Clone, Debug, PartialEq)]
pub struct Version {
pub id: String,
pub number: String,
pub published: String,
pub game_versions: Vec<String>,
pub loaders: Vec<String>,
pub files: Vec<FileRef>,
/// Required dependencies, as project ids on the same source.
pub required: Vec<String>,
/// Why this version can't be downloaded from here (CurseForge authors can forbid it).
pub blocked: Option<String>,
}
impl Version {
/// The file to install: the primary one, else the first.
pub fn file(&self) -> Option<&FileRef> {
self.files
.iter()
.find(|f| f.primary)
.or_else(|| self.files.first())
}
}
/// A search.
#[derive(Clone, Debug, PartialEq)]
pub struct Query {
pub text: String,
pub kind: Kind,
/// Off: only what runs (made for [`GAME`], Iris or OptiFine shaders). On: everything of the
/// kind, each result marked with how well it runs.
pub everything: bool,
pub offset: usize,
pub limit: usize,
}
impl Query {
pub fn new(text: &str, kind: Kind) -> Self {
Self {
text: text.trim().to_owned(),
kind,
everything: false,
offset: 0,
limit: 20,
}
}
}
/// A place projects come from.
pub trait Source: Send + Sync {
fn id(&self) -> SourceId;
fn search(&self, query: &Query) -> Result<Vec<Project>, String>;
fn project(&self, id: &str) -> Result<Project, String>;
/// Versions, newest first.
fn versions(&self, project: &Project) -> Result<Vec<Version>, String>;
}
/// The sources this launcher can use: Modrinth always, CurseForge when it has an API key.
pub fn sources() -> Vec<Box<dyn Source>> {
let mut all: Vec<Box<dyn Source>> = vec![Box::new(modrinth::Modrinth)];
if let Some(cf) = curseforge::CurseForge::from_env() {
all.push(Box::new(cf));
}
all
}
/// The loaders a Java shader pack may name that Horizon translates.
const SHADER_LOADERS: [&str; 2] = ["iris", "optifine"];
/// How well a project of `kind` made for `game_versions` and `loaders` runs in Horizon.
pub fn support(kind: Kind, game_versions: &[String], loaders: &[String]) -> Support {
match kind {
Kind::ResourcePack => {
if game_versions.iter().any(|v| v == GAME) {
Support::Works
} else if let Some(newest) = newest_release(game_versions) {
Support::Partial(format!(
"Made for {newest}: it loads with vanilla's compatibility warning, and \
what changed since may look wrong."
))
} else {
Support::Partial("Lists no Minecraft version.".into())
}
}
Kind::ShaderPack => {
if loaders.iter().any(|l| SHADER_LOADERS.contains(&l.as_str())) {
Support::Partial(
"Java shader packs are translated: their full-screen passes draw, the world \
and shadow passes don't yet (BSL and Complementary tested)."
.into(),
)
} else {
let named = loaders.first().map(String::as_str).unwrap_or("unknown");
Support::No(format!(
"A shader pack for {named}: Horizon runs Iris and OptiFine packs only."
))
}
}
Kind::Modpack => Support::Partial(
"Imported on the Modpacks page: Horizon runs the mods it can port, from your own \
downloads."
.into(),
),
}
}
/// The newest plain release (`1.21.4`, `26.2`) in a list of Minecraft versions.
fn newest_release(versions: &[String]) -> Option<&str> {
versions
.iter()
.filter(|v| {
v.split('.')
.all(|p| !p.is_empty() && p.bytes().all(|b| b.is_ascii_digit()))
})
.max_by_key(|v| {
v.split('.')
.map(|p| p.parse::<u32>().unwrap_or(0))
.collect::<Vec<_>>()
})
.map(String::as_str)
}
/// The version to install: the newest one that runs, or with `everything` the newest at all.
/// `versions` is newest first, as [`Source::versions`] gives them.
pub fn pick(kind: Kind, versions: &[Version], everything: bool) -> Option<&Version> {
let mut usable = versions
.iter()
.filter(|v| v.blocked.is_none() && v.file().is_some());
let runs = |v: &&Version| match support(kind, &v.game_versions, &v.loaders) {
Support::Works => true,
// A modpack's version is for its own Minecraft; any shader pack Horizon translates.
Support::Partial(_) => kind != Kind::ResourcePack,
Support::No(_) => false,
};
if let Some(v) = usable.clone().find(runs) {
return Some(v);
}
usable.find(|v| everything && support(kind, &v.game_versions, &v.loaders).installable())
}
/// A file name from a source, kept only when it is one plain name: no folders, no `..`, no
/// hidden file, nothing a file system would read as something else.
pub fn safe_name(name: &str) -> Option<&str> {
let ok = !name.is_empty()
&& name.len() <= 200
&& !name.starts_with('.')
&& !name.ends_with(['.', ' '])
&& name.chars().all(|c| {
!c.is_control() && !matches!(c, '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|')
});
ok.then_some(name)
}
#[cfg(test)]
mod tests;