Merge pull request #1646 from ludovic111/feat/mod-registry-tools
This commit is contained in:
@@ -6,11 +6,13 @@
|
||||
//! the mod; run `build` again and the game reloads it.
|
||||
//! - `check <file> [--json]`: what the registry checks of a submission
|
||||
//! (`.hmod`, `.hpack`, resource pack `.zip`), with a trial run for a mod.
|
||||
//! - `registry build|review|check|list`: the registry repository's CI.
|
||||
use horizon_mods::{
|
||||
Manifest, Package,
|
||||
manifest::{MANIFEST, component_imports, componentize},
|
||||
};
|
||||
mod check;
|
||||
mod registry;
|
||||
|
||||
use std::{
|
||||
path::{Path, PathBuf},
|
||||
@@ -33,7 +35,8 @@ fn main() -> ExitCode {
|
||||
}),
|
||||
Some("run") => run(&args[1..]),
|
||||
Some("check") => check(&args[1..]),
|
||||
_ => Err("usage: cargo horizon-mod new <path> | build [--debug] | run [--game <horizon-client>] [-- <game args>] | check <file> [--kind <kind>] [--key <public key> --signature <file.minisig>] [--json]".into()),
|
||||
Some("registry") => registry::main(&args[1..]),
|
||||
_ => Err("usage: cargo horizon-mod new <path> | build [--debug] | run [--game <horizon-client>] [-- <game args>] | check <file> [--kind <kind>] [--key <public key> --signature <file.minisig>] [--json] | registry build|review|check|list".into()),
|
||||
};
|
||||
match result {
|
||||
Ok(()) => ExitCode::SUCCESS,
|
||||
|
||||
@@ -0,0 +1,159 @@
|
||||
//! `cargo horizon-mod registry build|review|check|list`: the registry repository's CI
|
||||
//! (`ludovic111/horizon-mods`, docs/api/mod-index.md). Network-free: the
|
||||
//! workflow downloads the files and publishes what this writes.
|
||||
use horizon_mods::index::{
|
||||
FILE_HOST,
|
||||
registry::{self, Sources},
|
||||
};
|
||||
use std::path::Path;
|
||||
|
||||
/// Where the registry's site is published (its icons).
|
||||
const SITE: &str = "https://ludovic111.github.io/horizon-mods/";
|
||||
|
||||
const USAGE: &str = "usage: cargo horizon-mod registry build <checkout> --files <dir> --out <index.json> [--release <url>] [--site <url>] [--generated <time>]
|
||||
cargo horizon-mod registry review <base checkout> <head checkout> --author <login> [--json]
|
||||
cargo horizon-mod registry check <base checkout> <head checkout> --files <dir>
|
||||
cargo horizon-mod registry list <checkout>";
|
||||
|
||||
fn flag<'a>(args: &'a [String], name: &str) -> Option<&'a str> {
|
||||
super::flag(args, name)
|
||||
}
|
||||
|
||||
fn positional(args: &[String]) -> Vec<&str> {
|
||||
let mut out = Vec::new();
|
||||
let mut skip = false;
|
||||
for a in args {
|
||||
if skip {
|
||||
skip = false;
|
||||
} else if a == "--json" {
|
||||
} else if a.starts_with("--") {
|
||||
skip = true;
|
||||
} else {
|
||||
out.push(a.as_str());
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn lines(errors: Vec<String>) -> String {
|
||||
format!("{} problem(s):\n {}", errors.len(), errors.join("\n "))
|
||||
}
|
||||
|
||||
pub fn main(args: &[String]) -> Result<(), String> {
|
||||
let rest = args.get(1..).unwrap_or_default();
|
||||
let pos = positional(rest);
|
||||
match args.first().map(String::as_str) {
|
||||
Some("build") => {
|
||||
let [checkout] = pos[..] else {
|
||||
return Err(USAGE.into());
|
||||
};
|
||||
let (files, out) = (flag(rest, "--files"), flag(rest, "--out"));
|
||||
let (Some(files), Some(out)) = (files, out) else {
|
||||
return Err(USAGE.into());
|
||||
};
|
||||
let generated = flag(rest, "--generated")
|
||||
.map(str::to_owned)
|
||||
.or_else(|| std::env::var("REGISTRY_GENERATED").ok())
|
||||
.unwrap_or_default();
|
||||
let index = registry::build(&Sources {
|
||||
registry: Path::new(checkout),
|
||||
files: Path::new(files),
|
||||
release: flag(rest, "--release").unwrap_or(FILE_HOST),
|
||||
site: flag(rest, "--site").unwrap_or(SITE),
|
||||
generated,
|
||||
})
|
||||
.map_err(lines)?;
|
||||
let text = serde_json::to_string_pretty(&index).map_err(|e| e.to_string())?;
|
||||
std::fs::write(out, text + "\n").map_err(|e| format!("{out}: {e}"))?;
|
||||
println!(
|
||||
"Wrote {out}: {} project(s), {} taken down",
|
||||
index.projects.len(),
|
||||
index.revoked.len()
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
Some("review") => {
|
||||
let [base, head] = pos[..] else {
|
||||
return Err(USAGE.into());
|
||||
};
|
||||
let author = flag(rest, "--author").ok_or(USAGE)?;
|
||||
let (base, _) = registry::load(Path::new(base)).map_err(lines)?;
|
||||
let (head, _) = registry::load(Path::new(head)).map_err(lines)?;
|
||||
let review = registry::review(&base, &head, author);
|
||||
if rest.iter().any(|a| a == "--json") {
|
||||
let json = serde_json::json!({"errors": review.errors, "notes": review.notes});
|
||||
println!("{json}");
|
||||
} else {
|
||||
for n in &review.notes {
|
||||
println!("note: {n}");
|
||||
}
|
||||
for e in &review.errors {
|
||||
println!("error: {e}");
|
||||
}
|
||||
}
|
||||
if review.errors.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(format!(
|
||||
"{} change(s) the registry refuses",
|
||||
review.errors.len()
|
||||
))
|
||||
}
|
||||
}
|
||||
// `check` (and its trial run) on each file `head` lists and `base`
|
||||
// doesn't: a pull request's new files.
|
||||
Some("check") => {
|
||||
let [base, head] = pos[..] else {
|
||||
return Err(USAGE.into());
|
||||
};
|
||||
let files = Path::new(flag(rest, "--files").ok_or(USAGE)?);
|
||||
let old: Vec<String> = match registry::load(Path::new(base)) {
|
||||
Ok((entries, _)) => entries
|
||||
.iter()
|
||||
.flat_map(|e| e.versions.iter().map(|v| v.sha256.clone()))
|
||||
.collect(),
|
||||
// The first pull request has no entries to compare with.
|
||||
Err(_) => Vec::new(),
|
||||
};
|
||||
let (entries, _) = registry::load(Path::new(head)).map_err(lines)?;
|
||||
let mut failed = 0;
|
||||
for e in &entries {
|
||||
for v in e.versions.iter().filter(|v| !old.contains(&v.sha256)) {
|
||||
println!("{} {} ({}):", e.id, v.version, v.file);
|
||||
let report = crate::check::check(
|
||||
&files.join(&v.sha256),
|
||||
e.kind.clone(),
|
||||
e.key.as_deref(),
|
||||
v.signature.as_deref(),
|
||||
);
|
||||
match report {
|
||||
Ok(r) => print!("{}", r.text()),
|
||||
Err(err) => {
|
||||
failed += 1;
|
||||
println!(" error: {err}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if failed == 0 {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(format!("{failed} file(s) failed their check"))
|
||||
}
|
||||
}
|
||||
// The files CI must download for `build`: `<sha256> <id> <version> <file>`.
|
||||
Some("list") => {
|
||||
let [checkout] = pos[..] else {
|
||||
return Err(USAGE.into());
|
||||
};
|
||||
let (entries, _) = registry::load(Path::new(checkout)).map_err(lines)?;
|
||||
for e in &entries {
|
||||
for v in &e.versions {
|
||||
println!("{} {} {} {}", v.sha256, e.id, v.version, v.file);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
_ => Err(USAGE.into()),
|
||||
}
|
||||
}
|
||||
@@ -608,5 +608,6 @@ fn names(caps: &[Capability]) -> String {
|
||||
format!("[{}]", names.join(", "))
|
||||
}
|
||||
|
||||
pub mod registry;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
@@ -0,0 +1,415 @@
|
||||
//! The registry repository (`ludovic111/horizon-mods`, docs/api/mod-index.md):
|
||||
//! one `mods/<id>.toml` per project, written by the submission form or by
|
||||
//! hand and reviewed in a pull request, plus `revoked.toml`. Its CI turns
|
||||
//! them into `index.json` with [`build`], reading every listed file, and
|
||||
//! checks a pull request's changes with [`review`].
|
||||
//!
|
||||
//! What an entry can't say for itself (a mod's API, side and capabilities,
|
||||
//! a modpack's mods, a file's size) is read from the file, never typed.
|
||||
pub use super::open;
|
||||
use super::{File, Index, Kind, Project, Revoked, SCHEMA, Version, hex64, inspect, valid_id};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
/// The folder of entries in the registry repository.
|
||||
pub const ENTRIES: &str = "mods";
|
||||
/// The list of files taken down.
|
||||
pub const REVOKED: &str = "revoked.toml";
|
||||
/// Ids the site uses for its own pages (`/mods/submit`).
|
||||
const RESERVED: [&str; 1] = ["submit"];
|
||||
/// The biggest icon, a PNG in `icons/`.
|
||||
const MAX_ICON: u64 = 256 << 10;
|
||||
|
||||
/// `mods/<id>.toml`.
|
||||
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Entry {
|
||||
pub id: String,
|
||||
pub kind: Kind,
|
||||
pub name: String,
|
||||
pub summary: String,
|
||||
#[serde(default, skip_serializing_if = "String::is_empty")]
|
||||
pub description: String,
|
||||
#[serde(default)]
|
||||
pub authors: Vec<String>,
|
||||
/// GitHub logins allowed to publish updates.
|
||||
pub owners: Vec<String>,
|
||||
pub license: String,
|
||||
pub source: String,
|
||||
/// `icons/<id>.png` in the registry repository, or an `https://` address.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub icon: Option<String>,
|
||||
/// The author's minisign public key.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub key: Option<String>,
|
||||
/// Newest first.
|
||||
pub versions: Vec<EntryVersion>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct EntryVersion {
|
||||
pub version: String,
|
||||
/// `YYYY-MM-DD`.
|
||||
pub published: String,
|
||||
/// The Minecraft version it is for.
|
||||
pub game: String,
|
||||
/// The name players download, with the kind's extension.
|
||||
pub file: String,
|
||||
/// Lowercase hex: pins the reviewed file.
|
||||
pub sha256: String,
|
||||
/// The `.minisig` text, when the project has a key.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub signature: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "String::is_empty")]
|
||||
pub changelog: String,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct RevokedFile {
|
||||
#[serde(default)]
|
||||
revoked: Vec<Revoked>,
|
||||
}
|
||||
|
||||
/// Where [`build`] reads and what it writes into the index.
|
||||
pub struct Sources<'a> {
|
||||
/// A checkout of the registry repository.
|
||||
pub registry: &'a Path,
|
||||
/// Every listed file, named by its SHA-256 (CI downloads them there).
|
||||
pub files: &'a Path,
|
||||
/// Where the files are published: `<files>/<id>-<version>/<file>`
|
||||
/// ([`super::FILE_HOST`]; `file:///` for a local test registry).
|
||||
pub release: &'a str,
|
||||
/// Where the registry's site is (its icons): `https://.../horizon-mods/`.
|
||||
pub site: &'a str,
|
||||
/// RFC 3339.
|
||||
pub generated: String,
|
||||
}
|
||||
|
||||
/// The release tag a version's file is published under.
|
||||
pub fn tag(id: &str, version: &str) -> String {
|
||||
format!("{id}-{version}")
|
||||
}
|
||||
|
||||
/// Reads `mods/*.toml` and `revoked.toml`: every problem found, not only the
|
||||
/// first, so a pull request's check lists them all.
|
||||
pub fn load(registry: &Path) -> Result<(Vec<Entry>, Vec<Revoked>), Vec<String>> {
|
||||
let mut errors = Vec::new();
|
||||
let mut entries = Vec::new();
|
||||
let dir = registry.join(ENTRIES);
|
||||
let mut paths: Vec<PathBuf> = match std::fs::read_dir(&dir) {
|
||||
Ok(read) => read.filter_map(|e| e.ok().map(|e| e.path())).collect(),
|
||||
Err(e) => return Err(vec![format!("{}: {e}", dir.display())]),
|
||||
};
|
||||
paths.sort();
|
||||
for path in paths {
|
||||
let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
|
||||
let Some(stem) = name.strip_suffix(".toml") else {
|
||||
errors.push(format!("{ENTRIES}/{name}: only <id>.toml files go here"));
|
||||
continue;
|
||||
};
|
||||
let parsed = std::fs::read_to_string(&path)
|
||||
.map_err(|e| e.to_string())
|
||||
.and_then(|text| toml::from_str::<Entry>(&text).map_err(|e| e.to_string()));
|
||||
match parsed {
|
||||
Ok(entry) if entry.id == stem => entries.push(entry),
|
||||
Ok(entry) => errors.push(format!(
|
||||
"{ENTRIES}/{name}: its id is {:?}; the file must be {ENTRIES}/{}.toml",
|
||||
entry.id, entry.id
|
||||
)),
|
||||
Err(e) => errors.push(format!("{ENTRIES}/{name}: {e}")),
|
||||
}
|
||||
}
|
||||
let revoked = match std::fs::read_to_string(registry.join(REVOKED)) {
|
||||
Ok(text) => match toml::from_str::<RevokedFile>(&text) {
|
||||
Ok(file) => file.revoked,
|
||||
Err(e) => {
|
||||
errors.push(format!("{REVOKED}: {e}"));
|
||||
Vec::new()
|
||||
}
|
||||
},
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Vec::new(),
|
||||
Err(e) => {
|
||||
errors.push(format!("{REVOKED}: {e}"));
|
||||
Vec::new()
|
||||
}
|
||||
};
|
||||
if errors.is_empty() {
|
||||
Ok((entries, revoked))
|
||||
} else {
|
||||
Err(errors)
|
||||
}
|
||||
}
|
||||
|
||||
/// A version string that is also a plain release tag and file name part.
|
||||
fn plain_version(v: &str) -> bool {
|
||||
!v.is_empty()
|
||||
&& v.len() <= 64
|
||||
&& v.as_bytes()[0].is_ascii_alphanumeric()
|
||||
&& v.bytes()
|
||||
.all(|b| b.is_ascii_alphanumeric() || b".-_".contains(&b))
|
||||
}
|
||||
|
||||
fn plain_date(d: &str) -> bool {
|
||||
let b = d.as_bytes();
|
||||
b.len() == 10
|
||||
&& b[4] == b'-'
|
||||
&& b[7] == b'-'
|
||||
&& b.iter()
|
||||
.enumerate()
|
||||
.all(|(i, c)| i == 4 || i == 7 || c.is_ascii_digit())
|
||||
}
|
||||
|
||||
/// One project's entry and its files, as the index lists them.
|
||||
pub fn project(entry: &Entry, src: &Sources) -> Result<Project, Vec<String>> {
|
||||
let mut errors = Vec::new();
|
||||
let id = &entry.id;
|
||||
if !valid_id(id) {
|
||||
return Err(vec![format!("{id:?} is not [a-z0-9_]{{1,64}}")]);
|
||||
}
|
||||
if RESERVED.contains(&id.as_str()) {
|
||||
return Err(vec![format!("{id:?} is reserved: pick another id")]);
|
||||
}
|
||||
open(&entry.kind).map_err(|e| vec![format!("{id}: {e}")])?;
|
||||
if entry.owners.is_empty() {
|
||||
errors.push(format!("{id}: needs at least one owner (a GitHub login)"));
|
||||
}
|
||||
if entry.summary.chars().count() > 160 {
|
||||
errors.push(format!("{id}: the summary is over 160 characters"));
|
||||
}
|
||||
let icon = match entry.icon.as_deref() {
|
||||
None => None,
|
||||
Some(url) if url.starts_with("https://") => Some(url.to_owned()),
|
||||
Some(path) => {
|
||||
let ok = path
|
||||
.strip_prefix("icons/")
|
||||
.is_some_and(|name| super::plain_name(name) && name.ends_with(".png"));
|
||||
let size = std::fs::metadata(src.registry.join(path)).map(|m| m.len());
|
||||
match (ok, size) {
|
||||
(true, Ok(n)) if n <= MAX_ICON => Some(format!("{}{path}", src.site)),
|
||||
(true, Ok(_)) => {
|
||||
errors.push(format!("{id}: {path} is over {} KiB", MAX_ICON >> 10));
|
||||
None
|
||||
}
|
||||
(true, Err(e)) => {
|
||||
errors.push(format!("{id}: {path}: {e}"));
|
||||
None
|
||||
}
|
||||
(false, _) => {
|
||||
errors.push(format!(
|
||||
"{id}: icon {path:?} is neither icons/<name>.png nor https://"
|
||||
));
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
if entry.versions.is_empty() {
|
||||
errors.push(format!("{id}: has no version"));
|
||||
}
|
||||
let mut versions = Vec::new();
|
||||
for v in &entry.versions {
|
||||
match version(entry, v, src) {
|
||||
Ok(v) => versions.push(v),
|
||||
Err(e) => errors.push(format!("{id} {}: {e}", v.version)),
|
||||
}
|
||||
}
|
||||
if !errors.is_empty() {
|
||||
return Err(errors);
|
||||
}
|
||||
Ok(Project {
|
||||
id: id.clone(),
|
||||
kind: entry.kind.clone(),
|
||||
name: entry.name.clone(),
|
||||
summary: entry.summary.clone(),
|
||||
description: entry.description.clone(),
|
||||
authors: entry.authors.clone(),
|
||||
owners: entry.owners.clone(),
|
||||
license: entry.license.clone(),
|
||||
source: entry.source.clone(),
|
||||
icon,
|
||||
key: entry.key.as_ref().map(|k| k.trim().to_owned()),
|
||||
versions,
|
||||
})
|
||||
}
|
||||
|
||||
fn version(entry: &Entry, v: &EntryVersion, src: &Sources) -> Result<Version, String> {
|
||||
if !plain_version(&v.version) {
|
||||
return Err("a version is letters, digits, '.', '-' and '_'".into());
|
||||
}
|
||||
if !plain_date(&v.published) {
|
||||
return Err(format!("published {:?} is not YYYY-MM-DD", v.published));
|
||||
}
|
||||
hex64(&v.sha256)?;
|
||||
let path = src.files.join(&v.sha256);
|
||||
let size = std::fs::metadata(&path)
|
||||
.map_err(|e| format!("its file {}: {e}", v.sha256))?
|
||||
.len();
|
||||
if super::sha256_file(&path)? != v.sha256 {
|
||||
return Err("the file isn't the one its sha256 names".into());
|
||||
}
|
||||
match (&entry.key, &v.signature) {
|
||||
(Some(key), Some(sig)) => super::verify_signature(key, sig, &path)?,
|
||||
(Some(_), None) => return Err("the project has a key: sign the file with it".into()),
|
||||
(None, Some(_)) => return Err("signed, but the project has no key".into()),
|
||||
(None, None) => {}
|
||||
}
|
||||
let facts = inspect(&entry.kind, &path)?;
|
||||
if facts.id.as_ref().is_some_and(|id| *id != entry.id) {
|
||||
return Err(format!(
|
||||
"the file's id is {:?}, not {:?}",
|
||||
facts.id.unwrap_or_default(),
|
||||
entry.id
|
||||
));
|
||||
}
|
||||
if facts.version.as_ref().is_some_and(|x| *x != v.version) {
|
||||
return Err(format!(
|
||||
"the file says version {:?}",
|
||||
facts.version.unwrap_or_default()
|
||||
));
|
||||
}
|
||||
if facts.game.as_ref().is_some_and(|g| *g != v.game) {
|
||||
return Err(format!(
|
||||
"the file is for {:?}, the entry says {:?}",
|
||||
facts.game.unwrap_or_default(),
|
||||
v.game
|
||||
));
|
||||
}
|
||||
Ok(Version {
|
||||
version: v.version.clone(),
|
||||
published: v.published.clone(),
|
||||
changelog: v.changelog.clone(),
|
||||
api: facts.api,
|
||||
side: facts.side,
|
||||
capabilities: facts.capabilities,
|
||||
game: v.game.clone(),
|
||||
requires: facts.requires,
|
||||
file: File {
|
||||
url: format!("{}{}/{}", src.release, tag(&entry.id, &v.version), v.file),
|
||||
name: v.file.clone(),
|
||||
size,
|
||||
sha256: v.sha256.clone(),
|
||||
signature: v.signature.clone(),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
impl Entry {
|
||||
/// The entry as `mods/<id>.toml` holds it (the submission form writes it).
|
||||
pub fn to_toml(&self) -> Result<String, String> {
|
||||
toml::to_string(self).map_err(|e| e.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
/// The index of the whole registry: every entry and file checked, then the
|
||||
/// index's own rules ([`Index::check`]: names, a modpack's mods present).
|
||||
pub fn build(src: &Sources) -> Result<Index, Vec<String>> {
|
||||
let (mut entries, revoked) = load(src.registry)?;
|
||||
entries.sort_by(|a, b| a.id.cmp(&b.id));
|
||||
let mut errors = Vec::new();
|
||||
let mut projects = Vec::new();
|
||||
for entry in &entries {
|
||||
match project(entry, src) {
|
||||
Ok(p) => projects.push(p),
|
||||
Err(e) => errors.extend(e),
|
||||
}
|
||||
}
|
||||
if !errors.is_empty() {
|
||||
return Err(errors);
|
||||
}
|
||||
let index = Index {
|
||||
schema: SCHEMA,
|
||||
generated: src.generated.clone(),
|
||||
projects,
|
||||
revoked,
|
||||
};
|
||||
let local = src.release.starts_with("file:///");
|
||||
index.check_with(local).map_err(|e| vec![e])?;
|
||||
Ok(index)
|
||||
}
|
||||
|
||||
/// What a pull request changes, for its reviewers.
|
||||
#[derive(Debug, Default, PartialEq)]
|
||||
pub struct Review {
|
||||
/// Changes the registry refuses whoever reviews them.
|
||||
pub errors: Vec<String>,
|
||||
/// What reviewers should look at: new projects, new owners or keys, a
|
||||
/// change by someone who isn't an owner.
|
||||
pub notes: Vec<String>,
|
||||
}
|
||||
|
||||
/// Compares the entries of a pull request (`head`) with `main`'s (`base`):
|
||||
/// a published file never changes and is never removed (take it down in
|
||||
/// `revoked.toml`), a project's kind never changes, and changes by someone
|
||||
/// who isn't an owner, or to owners and keys, are pointed out.
|
||||
pub fn review(base: &[Entry], head: &[Entry], author: &str) -> Review {
|
||||
let mut r = Review::default();
|
||||
for old in base {
|
||||
let Some(new) = head.iter().find(|e| e.id == old.id) else {
|
||||
r.errors.push(format!(
|
||||
"{}: removed; take its files down in {REVOKED} instead",
|
||||
old.id
|
||||
));
|
||||
continue;
|
||||
};
|
||||
if new == old {
|
||||
continue;
|
||||
}
|
||||
if !old.owners.iter().any(|o| o.eq_ignore_ascii_case(author)) {
|
||||
r.notes.push(format!(
|
||||
"{}: changed by {author}, who isn't one of its owners ({})",
|
||||
old.id,
|
||||
old.owners.join(", ")
|
||||
));
|
||||
}
|
||||
if new.kind != old.kind {
|
||||
r.errors.push(format!("{}: its kind can't change", old.id));
|
||||
}
|
||||
for v in &old.versions {
|
||||
match new.versions.iter().find(|w| w.version == v.version) {
|
||||
None => r.errors.push(format!(
|
||||
"{} {}: removed; take it down in {REVOKED} instead",
|
||||
old.id, v.version
|
||||
)),
|
||||
Some(w) if w.sha256 != v.sha256 || w.file != v.file => r.errors.push(format!(
|
||||
"{} {}: a published file never changes: publish a new version",
|
||||
old.id, v.version
|
||||
)),
|
||||
Some(_) => {}
|
||||
}
|
||||
}
|
||||
if new.owners != old.owners {
|
||||
r.notes.push(format!(
|
||||
"{}: owners {} -> {}",
|
||||
old.id,
|
||||
old.owners.join(", "),
|
||||
new.owners.join(", ")
|
||||
));
|
||||
}
|
||||
if new.key != old.key {
|
||||
r.notes.push(format!(
|
||||
"{}: its signing key changes; updates signed with the old one stop working",
|
||||
old.id
|
||||
));
|
||||
}
|
||||
let added = new.versions.len().saturating_sub(old.versions.len());
|
||||
if added > 0 {
|
||||
r.notes.push(format!("{}: {added} new version(s)", old.id));
|
||||
}
|
||||
}
|
||||
for new in head {
|
||||
if !base.iter().any(|e| e.id == new.id) {
|
||||
r.notes.push(format!(
|
||||
"{}: a new {} by {}",
|
||||
new.id,
|
||||
new.kind.name(),
|
||||
new.owners.join(", ")
|
||||
));
|
||||
}
|
||||
}
|
||||
r
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,237 @@
|
||||
//! A registry checkout holding the sample index's mod and modpack builds the
|
||||
//! sample index (`tests/index/index-v1.json`) exactly.
|
||||
use super::*;
|
||||
|
||||
const HMOD: &str = "e1135345692f6dd8fd4c51920151944b82333e17049c9bb7d756f27b8deefc53";
|
||||
const HPACK: &str = "241ac840f9c5ea3f6252d849da10c90d36cb1da4d6cd8d1d268c2760a353cd65";
|
||||
|
||||
fn fixtures() -> PathBuf {
|
||||
Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/index")
|
||||
}
|
||||
|
||||
fn sample() -> Index {
|
||||
Index::parse(&std::fs::read_to_string(fixtures().join("index-v1.json")).unwrap()).unwrap()
|
||||
}
|
||||
|
||||
fn hud_entry() -> String {
|
||||
let p = sample();
|
||||
let sig = p.project("coords_hud").unwrap().versions[0]
|
||||
.file
|
||||
.signature
|
||||
.clone()
|
||||
.unwrap();
|
||||
format!(
|
||||
r#"id = "coords_hud"
|
||||
kind = "mod"
|
||||
name = "Coordinates HUD"
|
||||
summary = "Your coordinates, facing and the time of day in a corner of the screen."
|
||||
description = "`/where` puts them in chat, `/coords` hides or shows the panel."
|
||||
authors = ["Horizon"]
|
||||
owners = ["ludovic111"]
|
||||
license = "MIT"
|
||||
source = "https://github.com/ludovic111/horizon/tree/main/crates/horizon-mod-sdk/examples/coords-hud"
|
||||
icon = "icons/coords_hud.png"
|
||||
key = "RWTVtuGb/GRXcBf3Re5hzM07EzoStr2sLTJjghJia0xX15ULoZRFFZDb"
|
||||
|
||||
[[versions]]
|
||||
version = "0.1.0"
|
||||
published = "2026-10-24"
|
||||
game = "26.3"
|
||||
file = "coords_hud-0.1.0.hmod"
|
||||
sha256 = "{HMOD}"
|
||||
signature = """{sig}"""
|
||||
"#
|
||||
)
|
||||
}
|
||||
|
||||
const COZY: &str = r#"id = "cozy"
|
||||
kind = "modpack"
|
||||
name = "Cozy"
|
||||
summary = "Coordinates and a calm render distance."
|
||||
authors = ["Horizon"]
|
||||
owners = ["ludovic111"]
|
||||
license = "MIT"
|
||||
source = "https://github.com/ludovic111/horizon-mods"
|
||||
|
||||
[[versions]]
|
||||
version = "1.0.0"
|
||||
published = "2026-10-24"
|
||||
game = "26.3"
|
||||
file = "cozy-1.0.0.hpack"
|
||||
sha256 = "241ac840f9c5ea3f6252d849da10c90d36cb1da4d6cd8d1d268c2760a353cd65"
|
||||
"#;
|
||||
|
||||
const REVOKED_TOML: &str = r#"[[revoked]]
|
||||
id = "bad_mod"
|
||||
sha256 = "1111111111111111111111111111111111111111111111111111111111111111"
|
||||
reason = "Sent chat messages it didn't declare."
|
||||
date = "2026-10-24"
|
||||
"#;
|
||||
|
||||
/// A registry checkout and its downloaded files, in a scratch folder.
|
||||
struct Scratch(PathBuf);
|
||||
|
||||
impl Scratch {
|
||||
fn new(name: &str) -> Scratch {
|
||||
let dir =
|
||||
std::env::temp_dir().join(format!("horizon-registry-{name}-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
for sub in ["repo/mods", "repo/icons", "files"] {
|
||||
std::fs::create_dir_all(dir.join(sub)).unwrap();
|
||||
}
|
||||
let s = Scratch(dir);
|
||||
s.write("mods/coords_hud.toml", &hud_entry());
|
||||
s.write("mods/cozy.toml", COZY);
|
||||
s.write("revoked.toml", REVOKED_TOML);
|
||||
s.write("icons/coords_hud.png", "png");
|
||||
for (name, hash) in [("coords_hud-0.1.0.hmod", HMOD), ("cozy-1.0.0.hpack", HPACK)] {
|
||||
std::fs::copy(fixtures().join(name), s.0.join("files").join(hash)).unwrap();
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
fn write(&self, path: &str, text: &str) {
|
||||
std::fs::write(self.0.join("repo").join(path), text).unwrap();
|
||||
}
|
||||
|
||||
fn build(&self) -> Result<Index, Vec<String>> {
|
||||
let (repo, files) = (self.0.join("repo"), self.0.join("files"));
|
||||
build(&Sources {
|
||||
registry: &repo,
|
||||
files: &files,
|
||||
release: super::super::FILE_HOST,
|
||||
site: "https://ludovic111.github.io/horizon-mods/",
|
||||
generated: "2026-10-24T18:00:00Z".into(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Scratch {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_the_sample_index() {
|
||||
let s = Scratch::new("sample");
|
||||
let built = s.build().unwrap();
|
||||
let sample = sample();
|
||||
assert_eq!(built.projects, sample.projects[..2]);
|
||||
assert_eq!(built.revoked, sample.revoked);
|
||||
assert_eq!(built.generated, sample.generated);
|
||||
// What it writes reads back.
|
||||
Index::parse(&serde_json::to_string_pretty(&built).unwrap()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lists_every_problem_of_a_registry() {
|
||||
let s = Scratch::new("bad");
|
||||
// A file that isn't the one its hash names, an unsigned version of a
|
||||
// signed project, a shader pack, and a mod whose file is another mod.
|
||||
std::fs::write(s.0.join("files").join(HPACK), b"other bytes").unwrap();
|
||||
s.write(
|
||||
"mods/coords_hud.toml",
|
||||
&hud_entry().replace("signature = \"\"\"", "changelog = \"\"\""),
|
||||
);
|
||||
s.write(
|
||||
"mods/glow.toml",
|
||||
&COZY
|
||||
.replace("\"cozy\"", "\"glow\"")
|
||||
.replace("modpack", "shader"),
|
||||
);
|
||||
s.write(
|
||||
"mods/other.toml",
|
||||
&hud_entry()
|
||||
.replace("\"coords_hud\"", "\"other\"")
|
||||
.replace("key = ", "# key = ")
|
||||
.replace("signature = \"\"\"", "changelog = \"\"\""),
|
||||
);
|
||||
let errors = s.build().unwrap_err();
|
||||
let has = |part: &str| errors.iter().any(|e| e.contains(part));
|
||||
assert!(
|
||||
has("cozy 1.0.0: the file isn't the one its sha256 names"),
|
||||
"{errors:?}"
|
||||
);
|
||||
assert!(has("coords_hud 0.1.0: the project has a key"), "{errors:?}");
|
||||
assert!(has("glow: shader packs open when"), "{errors:?}");
|
||||
assert!(
|
||||
has("other 0.1.0: the file's id is \"coords_hud\""),
|
||||
"{errors:?}"
|
||||
);
|
||||
assert_eq!(errors.len(), 4, "{errors:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_entry_is_named_by_its_id_and_has_only_known_fields() {
|
||||
let s = Scratch::new("names");
|
||||
s.write("mods/hud.toml", &hud_entry());
|
||||
s.write("mods/notes.txt", "");
|
||||
s.write("mods/cozy.toml", &format!("{COZY}homepage = \"x\"\n"));
|
||||
let errors = load(&s.0.join("repo")).unwrap_err();
|
||||
assert_eq!(errors.len(), 3, "{errors:?}");
|
||||
assert!(errors[0].contains("cozy.toml") && errors[0].contains("homepage"));
|
||||
assert!(errors[1].contains("must be mods/coords_hud.toml"));
|
||||
assert!(errors[2].contains("only <id>.toml"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_entry_written_reads_back() {
|
||||
let entry: Entry = toml::from_str(&hud_entry()).unwrap();
|
||||
let text = entry.to_toml().unwrap();
|
||||
assert_eq!(toml::from_str::<Entry>(&text).unwrap(), entry);
|
||||
assert!(text.contains("[[versions]]"), "{text}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_review_protects_published_files() {
|
||||
let base: Entry = toml::from_str(&hud_entry()).unwrap();
|
||||
let cozy: Entry = toml::from_str(COZY).unwrap();
|
||||
let one = std::slice::from_ref(&base);
|
||||
let same = review(one, one, "someone");
|
||||
assert_eq!(same, Review::default());
|
||||
|
||||
let mut update = base.clone();
|
||||
let mut next = update.versions[0].clone();
|
||||
next.version = "0.2.0".into();
|
||||
update.versions.insert(0, next);
|
||||
let r = review(one, std::slice::from_ref(&update), "ludovic111");
|
||||
assert!(r.errors.is_empty(), "{r:?}");
|
||||
assert_eq!(r.notes, ["coords_hud: 1 new version(s)"]);
|
||||
let r = review(one, &[update], "stranger");
|
||||
assert!(r.notes[0].contains("isn't one of its owners"), "{r:?}");
|
||||
|
||||
let mut swapped = base.clone();
|
||||
swapped.versions[0].sha256 = HPACK.into();
|
||||
swapped.kind = Kind::ResourcePack;
|
||||
swapped.key = None;
|
||||
let r = review(&[base.clone(), cozy.clone()], &[swapped], "ludovic111");
|
||||
assert_eq!(r.errors.len(), 3, "{r:?}");
|
||||
assert!(r.errors.iter().any(|e| e.contains("cozy: removed")));
|
||||
assert!(r.errors.iter().any(|e| e.contains("never changes")));
|
||||
assert!(r.errors.iter().any(|e| e.contains("kind can't change")));
|
||||
assert!(r.notes.iter().any(|n| n.contains("signing key")));
|
||||
|
||||
let r = review(&[], &[cozy], "newcomer");
|
||||
assert_eq!(r.notes, ["cozy: a new modpack by ludovic111"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_open_kinds_are_taken() {
|
||||
assert!(open(&Kind::Mod).is_ok() && open(&Kind::ResourcePack).is_ok());
|
||||
assert!(open(&Kind::Shader).unwrap_err().contains("Iris"));
|
||||
assert!(open(&Kind::Other("world".into())).is_err());
|
||||
let mut submit: Entry = toml::from_str(COZY).unwrap();
|
||||
submit.id = "submit".into();
|
||||
let dir = std::env::temp_dir();
|
||||
let src = Sources {
|
||||
registry: &dir,
|
||||
files: &dir,
|
||||
release: super::super::FILE_HOST,
|
||||
site: "https://x.test/",
|
||||
generated: String::new(),
|
||||
};
|
||||
assert!(project(&submit, &src).unwrap_err()[0].contains("reserved"));
|
||||
assert!(plain_version("1.0.0-beta.2") && !plain_version("../1") && !plain_version("1 0"));
|
||||
assert!(plain_date("2026-10-24") && !plain_date("24/10/2026"));
|
||||
}
|
||||
@@ -90,6 +90,59 @@ Unknown keys are refused. `overrides/` may hold only `options.txt`, `horizon-gra
|
||||
capability `storage`), each at most 64 MiB and 256 MiB in all; anything else refuses the pack. The launcher copies
|
||||
them into the profile's game folder.
|
||||
|
||||
## The registry repository
|
||||
|
||||
[ludovic111/horizon-mods](https://github.com/ludovic111/horizon-mods) holds one `mods/<id>.toml` per project, written by
|
||||
the submission form or by hand, and `revoked.toml`. What an entry can't vouch for is read from its file by the kind's
|
||||
own check (`index::inspect`): a mod's API, side and capabilities, a modpack's mods, the size. Types and rules:
|
||||
`horizon_mods::index::registry`.
|
||||
|
||||
```toml
|
||||
id = "coords_hud" # the file's name, and the manifest's id
|
||||
kind = "mod" # mod | modpack | resourcepack; shader once its format exists
|
||||
name = "Coordinates HUD"
|
||||
summary = "One line, at most 160 characters."
|
||||
description = """Markdown.""" # optional
|
||||
authors = ["Horizon"]
|
||||
owners = ["ludovic111"] # GitHub logins who may publish updates
|
||||
license = "MIT"
|
||||
source = "https://github.com/..."
|
||||
icon = "icons/coords_hud.png" # optional: a PNG of at most 256 KiB in the repository, or https://
|
||||
key = "RWT..." # optional: the minisign public key every version is signed with
|
||||
|
||||
[[versions]] # newest first
|
||||
version = "0.1.0" # letters, digits, '.', '-', '_': the release tag is <id>-<version>
|
||||
published = "2026-10-24"
|
||||
game = "26.3"
|
||||
file = "coords_hud-0.1.0.hmod" # the name players download
|
||||
sha256 = "e113..." # pins the reviewed file
|
||||
signature = """untrusted comment: ...""" # when the project has a key
|
||||
changelog = "" # optional
|
||||
```
|
||||
|
||||
```toml
|
||||
# revoked.toml
|
||||
[[revoked]]
|
||||
id = "bad_mod"
|
||||
sha256 = "1111..." # optional: without it, every version
|
||||
reason = "Sent chat messages it didn't declare."
|
||||
date = "2026-10-24"
|
||||
```
|
||||
|
||||
Unknown keys are refused. Its CI runs `cargo-horizon-mod` (`crates/cargo-horizon-mod`):
|
||||
|
||||
| Command | What it does |
|
||||
| --- | --- |
|
||||
| `cargo horizon-mod check <file> [--json]` | A submission's checks: its kind's (above), its signature with `--key` and `--signature`, and for a mod a trial run in the sandbox (40 ticks, 120 frames, a chat line, each command). |
|
||||
| `cargo horizon-mod registry check <base> <head> --files <dir>` | `check` on each file `head` lists and `base` doesn't: a pull request's new files. |
|
||||
| `cargo horizon-mod registry list <checkout>` | `<sha256> <id> <version> <file>` per version: the files to download. |
|
||||
| `cargo horizon-mod registry build <checkout> --files <dir> --out index.json` | Reads every entry and its file (`<dir>/<sha256>`), lists every problem, and writes the index with URLs `<release>/<id>-<version>/<file>`. |
|
||||
| `cargo horizon-mod registry review <base> <head> --author <login>` | A pull request's changes: a published file never changes and is never removed (take it down in `revoked.toml`), a kind never changes; changes by a non-owner and to owners or keys are pointed out for the reviewers. |
|
||||
|
||||
Kinds open to submissions: `mod`, `modpack`, `resourcepack`. `shader` is in the schema and stays closed until
|
||||
Horizon's own shader pack format exists (Iris and OptiFine packs are for the Modrinth browser); its check will compile
|
||||
the pack in a headless Horizon. A new kind gets its own check before it opens.
|
||||
|
||||
## Changelog
|
||||
|
||||
- Schema 1 (2026-10-24): kinds `mod`, `modpack`, `resourcepack`, `shader`; `.hpack` format 1.
|
||||
|
||||
+1
-1
@@ -16,7 +16,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
|
||||
| SDK for mod authors | `crates/horizon-mod-sdk` | 0.1 |
|
||||
| Example mod | `crates/horizon-mod-sdk/examples/coords-hud` | coordinates, facing and time HUD, `/where`, `/coords` |
|
||||
| Runtime | `crates/horizon-mods` | wasmtime 36 LTS, component model |
|
||||
| Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new / build / run / check` |
|
||||
| Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new / build / run / check`, and the registry's CI (`registry build / review / list`) |
|
||||
| In the game | `crates/horizon-client/src/game/mods.rs`, Options > Mods | client mods |
|
||||
| Launcher mod browser (Modrinth, CurseForge with a key) | [mod-browser.md](mod-browser.md) | resource packs, modpacks |
|
||||
| Registry index (`index.json`, `.hpack`), signatures | `horizon_mods::index`, [api/mod-index.md](api/mod-index.md) | schema 1; launcher and website next |
|
||||
|
||||
Reference in New Issue
Block a user