diff --git a/crates/cargo-horizon-mod/Cargo.toml b/crates/cargo-horizon-mod/Cargo.toml index 6d0a231ec..34eefe227 100644 --- a/crates/cargo-horizon-mod/Cargo.toml +++ b/crates/cargo-horizon-mod/Cargo.toml @@ -4,10 +4,10 @@ version = "0.1.0" edition.workspace = true license.workspace = true rust-version = "1.86" -description = "cargo horizon-mod new/build/run: make Horizon mods in Rust (docs/mods.md)" +description = "cargo horizon-mod new/build/run/check: make Horizon mods in Rust (docs/mods.md)" [dependencies] -horizon-mods = { path = "../horizon-mods", default-features = false, features = ["pack"] } +horizon-mods = { path = "../horizon-mods", default-features = false, features = ["pack", "runtime", "index"] } serde_json = "1.0.151" [lints] diff --git a/crates/cargo-horizon-mod/src/check.rs b/crates/cargo-horizon-mod/src/check.rs new file mode 100644 index 000000000..0294bec98 --- /dev/null +++ b/crates/cargo-horizon-mod/src/check.rs @@ -0,0 +1,268 @@ +//! `cargo horizon-mod check `: what the registry checks of a submission, +//! run anywhere: its kind's own checks (docs/api/mod-index.md), its signature +//! when given a key, and for a mod a trial run in the sandbox: it must start, +//! survive ticks, frames, a chat line and each of its commands, and import +//! no more than its capabilities. +use horizon_mods::{ + Clock, Mods, Output, Package, Player, Snapshot, Status, + index::{self, Facts, Kind}, + manifest::component_imports, +}; +use serde_json::{Value, json}; +use std::path::Path; + +/// How long the trial run plays: two seconds of game. +const TICKS: u64 = 40; +const FRAMES_PER_TICK: u64 = 3; + +pub struct Report { + pub kind: Kind, + pub facts: Facts, + pub sha256: String, + pub size: u64, + pub signed: bool, + /// A mod's component imports. + pub imports: Vec, + /// A mod's commands, each run once. + pub commands: Vec, + /// What the mod showed during the trial run. + pub output: Vec, +} + +impl Report { + pub fn json(&self) -> Value { + let requires: Vec = self + .facts + .requires + .iter() + .map(|r| json!({"id": r.id, "version": r.version, "sha256": r.sha256})) + .collect(); + json!({ + "kind": self.kind.name(), + "id": self.facts.id, + "version": self.facts.version, + "api": self.facts.api, + "side": self.facts.side, + "capabilities": self.facts.capabilities, + "game": self.facts.game, + "requires": requires, + "sha256": self.sha256, + "size": self.size, + "signed": self.signed, + "imports": self.imports, + "commands": self.commands, + "output": self.output, + }) + } + + pub fn text(&self) -> String { + let f = &self.facts; + let mut out = format!( + "{} {} ({}", + f.id.as_deref().unwrap_or("resource pack"), + f.version.as_deref().unwrap_or(""), + self.kind.name() + ); + if let Some(side) = f.side { + let side = serde_json::to_value(side).unwrap_or_default(); + out += &format!(", API {}, {}", f.api, side.as_str().unwrap_or("?")); + } else if !f.api.is_empty() { + out += &format!(", format {}", f.api); + } + if let Some(game) = &f.game { + out += &format!(", for {game}"); + } + let signed = if self.signed { + "signature verified" + } else { + "unsigned" + }; + out += &format!( + ")\n {} bytes, SHA-256 {}, {signed}\n", + self.size, self.sha256 + ); + for c in &f.capabilities { + out += &format!(" may {}\n", c.describe()); + } + for r in &f.requires { + out += &format!(" needs {} {} ({})\n", r.id, r.version, &r.sha256[..12]); + } + if self.kind == Kind::Mod { + let commands = if self.commands.is_empty() { + String::new() + } else { + format!(", /{}", self.commands.join(", /")) + }; + out += &format!( + " trial run: started, {TICKS} ticks, {} frames, a chat line{commands}: ok\n", + TICKS * FRAMES_PER_TICK + ); + } + out + } +} + +/// The kind a file's extension says. +pub fn kind_of(path: &Path) -> Option { + match path.extension()?.to_str()? { + "hmod" => Some(Kind::Mod), + "hpack" => Some(Kind::Modpack), + "zip" => Some(Kind::ResourcePack), + _ => None, + } +} + +/// Checks the file at `path` as `kind`; `key` and `signature` (the +/// `.minisig` text) check its signature. +pub fn check( + path: &Path, + kind: Kind, + key: Option<&str>, + signature: Option<&str>, +) -> Result { + let size = std::fs::metadata(path) + .map_err(|e| format!("{}: {e}", path.display()))? + .len(); + if size > index::MAX_FILE { + return Err(format!("over {} MiB", index::MAX_FILE >> 20)); + } + index::open(&kind)?; + let facts = index::inspect(&kind, path)?; + let signed = match (key, signature) { + (Some(key), Some(sig)) => { + index::verify_signature(key, sig, path)?; + true + } + (None, None) => false, + _ => return Err("--key and --signature go together".into()), + }; + let mut report = Report { + kind, + facts, + sha256: index::sha256_file(path)?, + size, + signed, + imports: Vec::new(), + commands: Vec::new(), + output: Vec::new(), + }; + if report.kind == Kind::Mod { + trial_run(path, &mut report)?; + } + Ok(report) +} + +/// Runs a mod in the sandbox, as the game does, from a scratch copy so its +/// storage lands in a folder removed afterwards. +fn trial_run(path: &Path, report: &mut Report) -> Result<(), String> { + let package = Package::read(path)?; + let wasm = package.wasm.as_deref().ok_or("the .hmod has no mod.wasm")?; + report.imports = component_imports(wasm)?; + package + .manifest + .check_imports(report.imports.iter().map(String::as_str))?; + let dir = std::env::temp_dir().join(format!("horizon-mod-check-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?; + let copy = dir.join("mod.hmod"); + let result = std::fs::copy(path, ©) + .map_err(|e| e.to_string()) + .and_then(|_| play(©, report)); + let _ = std::fs::remove_dir_all(&dir); + result +} + +fn play(path: &Path, report: &mut Report) -> Result<(), String> { + let mut mods = Mods::load(&[path.to_path_buf()], |_| true, |_| false); + let failed = |mods: &Mods| match &mods.entries()[0].status { + Status::Failed(reason) => Some(reason.clone()), + _ => None, + }; + if let Some(reason) = failed(&mods) { + return Err(format!("it didn't start: {reason}")); + } + report.commands = mods.commands().map(str::to_owned).collect(); + for t in 0..TICKS { + mods.set_snapshot(Snapshot { + player: Some(Player { + x: 0.5 + t as f64 * 0.1, + y: 64.0, + z: 0.5, + yaw: 90.0, + pitch: 0.0, + health: 20.0, + food: 20, + dimension: "minecraft:overworld".into(), + }), + clock: Some(Clock { + game_time: t, + day_time: 1000 + t, + }), + }); + mods.tick(t); + for _ in 0..FRAMES_PER_TICK { + mods.frame(1.0 / 60.0); + } + } + mods.chat(" hello"); + for name in report.commands.clone() { + mods.command(&name); + } + for out in mods.drain() { + report.output.push(match out { + Output::Chat { text, .. } => format!("chat: {text}"), + Output::Feedback { text, error } => { + format!("{}: {text}", if error { "error" } else { "feedback" }) + } + Output::Stopped { reason, .. } => return Err(format!("it stopped: {reason}")), + }); + } + match failed(&mods) { + Some(reason) => Err(format!("it stopped: {reason}")), + None => Ok(()), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn fixture(name: &str) -> std::path::PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../horizon-mods/tests/index") + .join(name) + } + + #[test] + fn checks_each_kind_its_own_way() { + let pack = fixture("cozy-1.0.0.hpack"); + let report = check(&pack, kind_of(&pack).unwrap(), None, None).unwrap(); + assert_eq!(report.facts.requires[0].id, "coords_hud"); + assert!( + report + .text() + .contains("cozy 1.0.0 (modpack, format 1, for 26.3)") + ); + // The fixture mod's code is a stand-in: its manifest reads, its run fails. + let hmod = fixture("coords_hud-0.1.0.hmod"); + let key = std::fs::read_to_string(fixture("test.pub")).unwrap(); + let sig = std::fs::read_to_string(fixture("coords_hud-0.1.0.hmod.minisig")).unwrap(); + let key = key.lines().last().unwrap(); + let e = check(&hmod, Kind::Mod, Some(key), Some(&sig)) + .err() + .unwrap(); + assert!(e.contains("didn't start"), "{e}"); + let e = check( + &hmod, + Kind::Mod, + Some(key), + Some("untrusted comment: x\nRUQ=\n"), + ) + .err() + .unwrap(); + assert!(e.contains("signature"), "{e}"); + let e = check(&pack, Kind::Shader, None, None).err().unwrap(); + assert!(e.contains("shader packs open"), "{e}"); + assert!(check(&pack, Kind::Mod, None, None).is_err()); + } +} diff --git a/crates/cargo-horizon-mod/src/main.rs b/crates/cargo-horizon-mod/src/main.rs index 6b088d278..9e0076083 100644 --- a/crates/cargo-horizon-mod/src/main.rs +++ b/crates/cargo-horizon-mod/src/main.rs @@ -4,10 +4,14 @@ //! - `build [--debug]`: the `.hmod` in `target/horizon-mod/`. //! - `run [--game ] [-- ]`: build, then play with //! the mod; run `build` again and the game reloads it. +//! - `check [--json]`: what the registry checks of a submission +//! (`.hmod`, `.hpack`, resource pack `.zip`), with a trial run for a mod. use horizon_mods::{ Manifest, Package, manifest::{MANIFEST, component_imports, componentize}, }; +mod check; + use std::{ path::{Path, PathBuf}, process::{Command, ExitCode, Stdio}, @@ -28,7 +32,8 @@ fn main() -> ExitCode { println!("Built {}", p.display()); }), Some("run") => run(&args[1..]), - _ => Err("usage: cargo horizon-mod new | build [--debug] | run [--game ] [-- ]".into()), + Some("check") => check(&args[1..]), + _ => Err("usage: cargo horizon-mod new | build [--debug] | run [--game ] [-- ] | check [--kind ] [--key --signature ] [--json]".into()), }; match result { Ok(()) => ExitCode::SUCCESS, @@ -150,6 +155,37 @@ fn build(release: bool) -> Result { Ok(path) } +/// `check `: the registry's checks of a submission, printed; fails +/// when one does. +fn check(args: &[String]) -> Result<(), String> { + let file = args + .first() + .filter(|a| !a.starts_with("--")) + .ok_or("cargo horizon-mod check ")?; + let path = Path::new(file); + let kind = match flag(args, "--kind") { + Some(k) => horizon_mods::index::Kind::from(k.to_string()), + None => check::kind_of(path) + .ok_or("pass --kind mod|modpack|resourcepack: the extension doesn't say")?, + }; + let signature = flag(args, "--signature") + .map(|p| std::fs::read_to_string(p).map_err(|e| format!("{p}: {e}"))) + .transpose()?; + let report = check::check(path, kind, flag(args, "--key"), signature.as_deref()); + if args.iter().any(|a| a == "--json") { + let json = match &report { + Ok(r) => serde_json::json!({"ok": true, "report": r.json()}), + Err(e) => serde_json::json!({"ok": false, "error": e}), + }; + println!("{json}"); + } + let report = report?; + if !args.iter().any(|a| a == "--json") { + print!("{}", report.text()); + } + Ok(()) +} + fn run(args: &[String]) -> Result<(), String> { let path = build(true)?; let game = flag(args, "--game") diff --git a/crates/horizon-mods/src/index.rs b/crates/horizon-mods/src/index.rs index 73af7b46d..692b1ae73 100644 --- a/crates/horizon-mods/src/index.rs +++ b/crates/horizon-mods/src/index.rs @@ -448,60 +448,109 @@ pub fn check_file( (None, None) => Trust::Unsigned, _ => return Err("its signature and the project's key don't go together".into()), }; - match project.kind { - Kind::Mod => { - let m = Package::read(path)?.manifest; - crate::Content::read(path, &m)?; - let mut caps = m.capabilities.clone(); - caps.sort(); - let mut listed = version.capabilities.clone(); - listed.sort(); - let differs = m.id != project.id - || m.version != version.version - || m.api != version.api - || Some(m.side) != version.side - || caps != listed; - if differs { - return Err(format!( - "its horizon-mod.toml ({} {}, API {}, {:?}, {}) isn't what the index lists", - m.id, - m.version, - m.api, - m.side, - names(&caps) - )); - } - } - Kind::ResourcePack => check_resource_pack(path)?, - Kind::Shader | Kind::Other(_) => { - return Err(format!( - "this Horizon can't install a {} yet", - project.kind.name() - )); - } - Kind::Modpack => { - let pack = Modpack::read(path)?; - let m = &pack.manifest; - let mods: Vec = m.mods.iter().map(modpack::PackMod::requirement).collect(); - if m.id != project.id - || m.version != version.version - || m.format.to_string() != version.api - || m.game != version.game - || mods != version.requires - { - return Err(format!( - "its {} isn't what the index lists", - modpack::MANIFEST - )); - } - } + if matches!(project.kind, Kind::Shader | Kind::Other(_)) { + return Err(format!( + "this Horizon can't install a {} yet", + project.kind.name() + )); } + inspect(&project.kind, path)?.matches(project, version)?; Ok(trust) } +/// What a file says about itself, read by its kind's own check +/// ([`inspect`]). The registry's CI writes these into the index; the +/// launcher compares them with the index before it installs. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Facts { + /// A mod's or a modpack's manifest id; None for a resource pack. + pub id: Option, + pub version: Option, + /// A mod's API line, a modpack's format, a resource pack's pack format. + pub api: String, + pub side: Option, + /// In the manifest's order. + pub capabilities: Vec, + /// The Minecraft version, when the file names one (a modpack does). + pub game: Option, + pub requires: Vec, +} + +impl Facts { + /// Whether the file is the one `version` of `project` describes. + pub fn matches(&self, project: &Project, version: &Version) -> Result<(), String> { + let (mut caps, mut listed) = (self.capabilities.clone(), version.capabilities.clone()); + caps.sort(); + listed.sort(); + let differs = self.id.as_ref().is_some_and(|id| *id != project.id) + || self.version.as_ref().is_some_and(|v| *v != version.version) + || self.api != version.api + || self.side != version.side + || caps != listed + || self.game.as_ref().is_some_and(|g| *g != version.game) + || self.requires != version.requires; + if !differs { + return Ok(()); + } + Err(match project.kind { + Kind::Mod => format!( + "its horizon-mod.toml ({} {}, API {}, {:?}, {}) isn't what the index lists", + self.id.as_deref().unwrap_or("?"), + self.version.as_deref().unwrap_or("?"), + self.api, + self.side, + names(&self.capabilities) + ), + Kind::Modpack => format!("its {} isn't what the index lists", modpack::MANIFEST), + _ => format!("its pack format {} isn't what the index lists", self.api), + }) + } +} + +/// Reads and checks a file as its kind: a mod's manifest and content, a +/// modpack's manifest and overrides, a resource pack's `pack.mcmeta` and +/// paths. Shader packs and kinds this build doesn't know are refused: their +/// checks come with their formats. +pub fn inspect(kind: &Kind, path: &Path) -> Result { + match kind { + Kind::Mod => { + let m = Package::read(path)?.manifest; + crate::Content::read(path, &m)?; + Ok(Facts { + capabilities: m.capabilities, + id: Some(m.id), + version: Some(m.version), + api: m.api, + side: Some(m.side), + ..Facts::default() + }) + } + Kind::Modpack => { + let m = Modpack::read(path)?.manifest; + Ok(Facts { + requires: m.mods.iter().map(modpack::PackMod::requirement).collect(), + id: Some(m.id), + version: Some(m.version), + api: m.format.to_string(), + game: Some(m.game), + ..Facts::default() + }) + } + Kind::ResourcePack => Ok(Facts { + api: check_resource_pack(path)?, + ..Facts::default() + }), + Kind::Shader => Err( + "Horizon's own shader pack format isn't out yet: shader packs open when it is".into(), + ), + Kind::Other(name) => Err(format!("this Horizon can't read a {name} yet")), + } +} + /// A resource pack: a zip with `pack.mcmeta` at its root holding a `pack` -/// object, and only plain paths. -fn check_resource_pack(path: &Path) -> Result<(), String> { +/// object, and only plain paths. Returns its pack format (`pack_format`, or +/// `min_format` in newer packs), empty when it names none. +fn check_resource_pack(path: &Path) -> Result { let file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?; let mut zip = zip::ZipArchive::new(file).map_err(|e| e.to_string())?; for i in 0..zip.len() { @@ -523,10 +572,35 @@ fn check_resource_pack(path: &Path) -> Result<(), String> { .map_err(|e| format!("pack.mcmeta: {e}"))?; let json: serde_json::Value = serde_json::from_str(&meta).map_err(|e| format!("pack.mcmeta: {e}"))?; - if !json["pack"].is_object() { + let pack = &json["pack"]; + if !pack.is_object() { return Err("pack.mcmeta: no \"pack\" object".into()); } - Ok(()) + let format = [&pack["pack_format"], &pack["min_format"]] + .into_iter() + .find(|f| !f.is_null()) + .map(|f| match f { + serde_json::Value::Array(parts) => parts + .iter() + .map(ToString::to_string) + .collect::>() + .join("."), + other => other.to_string(), + }) + .unwrap_or_default(); + Ok(format) +} + +/// The kinds the registry takes submissions for. Shader packs wait for +/// Horizon's own format; other kinds for theirs. +pub fn open(kind: &Kind) -> Result<(), String> { + match kind { + Kind::Mod | Kind::Modpack | Kind::ResourcePack => Ok(()), + Kind::Shader => Err( + "shader packs open when Horizon's own shader pack format is out (Iris and OptiFine packs stay on Modrinth)".into(), + ), + Kind::Other(name) => Err(format!("the registry doesn't take {name} yet")), + } } fn names(caps: &[Capability]) -> String { diff --git a/crates/horizon-mods/src/index/tests.rs b/crates/horizon-mods/src/index/tests.rs index b6d7f5bfb..e3883f79e 100644 --- a/crates/horizon-mods/src/index/tests.rs +++ b/crates/horizon-mods/src/index/tests.rs @@ -151,7 +151,10 @@ fn resource_packs_need_a_pack_mcmeta() { path }; let meta = r#"{"pack": {"description": "Look", "min_format": 75, "max_format": 75}}"#; - assert_eq!(check_resource_pack(&pack(&[("pack.mcmeta", meta)])), Ok(())); + assert_eq!( + check_resource_pack(&pack(&[("pack.mcmeta", meta)])), + Ok("75".into()) + ); let e = check_resource_pack(&pack(&[("assets/x.png", "")])).unwrap_err(); assert!(e.contains("missing"), "{e}"); let e = check_resource_pack(&pack(&[("pack.mcmeta", "{}")])).unwrap_err(); diff --git a/docs/mods.md b/docs/mods.md index 6f3216d38..ac8afda94 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -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` | +| Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new / build / run / check` | | 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 | @@ -226,6 +226,18 @@ always on, and the game checks its file once a second: rebuild and it restarts with "Mods reloaded" in chat. Its in-memory state starts over; whatever it saved with capability `storage` survives the reload. +Before you submit it to the registry, run what its CI runs: + +```sh +cargo horizon-mod check target/horizon-mod/my_mod.hmod # --json for the report as JSON +``` + +It reads the manifest and content, refuses imports the capabilities don't +cover, then plays the mod in the sandbox for 40 ticks, 120 frames, a chat line +and each of its commands: it must start and never trap or overrun. It checks a +`.hpack` and a resource pack `.zip` too, and a signature with `--key --signature .minisig`. + ### Template layout ```