Files
horizon-airdef/launcher/src/cli.rs
T
Ludovic Marie e28bcba3d3 launcher: import a shared instance, or route any dropped file
`horizon_launcher::import` works out what a file is from its contents:
- a shared instance: a .mrpack needing no mod loader (as `instance
  export` writes) or a game-folder zip;
- a Java modpack: a .mrpack with a loader, or a CurseForge zip;
- a resource or shader pack;
- a data pack.

A shared instance becomes a new instance named after the pack, with
"(2)" if the name is taken. Its overrides/ (or the zip's entries) are
copied in, but only the files an instance keeps, and only paths that
stay inside its folder. Its .mrpack files are downloaded from Modrinth
and checked against their SHA-512. If anything fails, the half-made
folder is removed.

CLI and MCP: `horizon-launcher instance import <file> [--instance <i>]`
does what dropping the file on the window will do.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 03:31:52 +01:00

2324 lines
84 KiB
Rust

//! `horizon-launcher <subcommand>`: the same steps as the window, from a terminal. Every
//! command goes through `backend`; this file only parses arguments and prints.
use clap::{Parser, Subcommand};
use horizon_launcher::account::{self, Accounts};
use horizon_launcher::backend::{self, Release};
use horizon_launcher::instances;
use horizon_launcher::server_list;
use std::io::{IsTerminal, Write};
use std::path::PathBuf;
use std::process::Command;
#[derive(Parser)]
#[command(
name = "horizon-launcher",
version = backend::VERSION,
about = "Installs, prepares and starts Horizon. Without a subcommand, opens the window."
)]
struct Cli {
/// Print JSON instead of text, where a command has something to report
#[arg(long, global = true)]
json: bool,
#[command(subcommand)]
command: Option<Cmd>,
}
#[derive(Subcommand)]
enum ServersCmd {
/// The servers, their folder and whether they run
List,
/// Create a server; with no options it is a new world, survival, normal, 10 players, friends only
Create {
#[arg(long, default_value = "My server")]
name: String,
/// The new world's seed (default: random)
#[arg(long, conflicts_with = "copy_world")]
seed: Option<String>,
/// Start from a copy of this world folder (one of your saves)
#[arg(long)]
copy_world: Option<PathBuf>,
#[arg(long, default_value = "survival", value_parser = ["survival", "creative", "adventure", "spectator"])]
mode: String,
#[arg(long, default_value = "normal", value_parser = ["peaceful", "easy", "normal", "hard"])]
difficulty: String,
#[arg(long, default_value_t = 10)]
max_players: u32,
/// Let anyone in (no whitelist)
#[arg(long)]
open: bool,
/// Check players' Minecraft accounts (they must sign in with Microsoft)
#[arg(long)]
check_accounts: bool,
/// Who may join (repeatable); the first becomes an operator
#[arg(long = "player")]
players: Vec<String>,
/// The installed version whose programs and game files servers use, if none are set up yet
#[arg(long)]
version: Option<String>,
/// Agree to the Minecraft EULA (https://aka.ms/MinecraftEULA)
#[arg(long)]
accept_eula: bool,
},
/// Copy an installed, prepared version's programs and game files for the servers (again)
SetUp {
#[arg(long)]
version: Option<String>,
},
/// Run a horizon-server command on a server, for example: servers run "My server" -- status
Run {
/// The server's name or folder
server: String,
#[arg(last = true, required = true)]
args: Vec<String>,
},
/// Take a server off the list (its folder stays)
Forget { server: String },
}
#[derive(Subcommand)]
enum AccountCmd {
/// The signed-in accounts and which one plays
List,
/// Sign in with a Microsoft account in your browser (device code)
SignIn,
/// Sign out: the account's tokens leave the keychain
SignOut {
/// Its name or UUID
who: String,
},
/// Play as this account
Select { who: String },
/// Play offline, without an account
Offline,
}
#[derive(Subcommand)]
enum DataCmd {
/// What is allowed, the install ID and how many items wait (the default)
Status,
/// Turn kinds on: performance, crashes, bugs, benchmarks, or all
Allow {
#[arg(required = true)]
kinds: Vec<String>,
},
/// Turn kinds off: performance, crashes, bugs, benchmarks, or all
Deny {
#[arg(required = true)]
kinds: Vec<String>,
},
/// Print exactly what would be sent
Show,
/// Delete everything sent from here, and what waits, and take a new install ID
Delete,
/// Send what is waiting now
Send,
/// Send a bug report you write; it is printed first, as it would leave
Bug {
text: String,
/// Add the end of the game's log (scrubbed, without chat)
#[arg(long)]
log: bool,
/// Send without asking
#[arg(long)]
yes: bool,
},
/// Upload a benchmark report (docs/benchmark-report.md); it is printed first
Benchmark {
file: PathBuf,
#[arg(long)]
yes: bool,
},
}
#[derive(Subcommand)]
enum ModpackCmd {
/// The imported packs and their coverage (the default)
List,
/// Import a .mrpack, a CurseForge zip or an instance folder, and write its coverage report
Import { path: PathBuf },
/// Get the jars of what this computer can port and carry them over
Port {
/// The pack's folder name, as list shows it
pack: String,
/// A folder with your own jars (an installed instance, a downloads folder)
#[arg(long)]
from: Option<PathBuf>,
/// The installed version the ports are for (default: the selected one)
#[arg(long)]
version: Option<String>,
},
/// Play a ported pack as its own profile
Play {
pack: String,
#[arg(long)]
version: Option<String>,
},
/// Remove an imported pack: its jars, ports and the profile's saves
Remove { pack: String },
}
#[derive(Subcommand)]
enum InstanceCmd {
/// The instances, each with its game folder (* = the one Play starts)
List,
/// Make an instance: empty but for your options and name, or a copy of another one's
/// worlds, options and packs
Create {
name: String,
/// The instance to copy (its name or id)
#[arg(long)]
copy: Option<String>,
},
/// Rename an instance (its folder stays)
Rename { instance: String, name: String },
/// Set an instance's icon: a block or item name from your prepared files (grass_block),
/// a colour (#3fa7d6), or none
Icon { instance: String, icon: String },
/// Put an instance in a sidebar group, or take it out with no group
Group {
instance: String,
group: Option<String>,
},
/// Make Play start this instance
Select { instance: String },
/// Keep an instance on one installed Horizon version, or "latest" to follow updates again
Version { instance: String, version: String },
/// Export an instance (or a port) to share: its settings, packs, Horizon mods and the worlds
/// named, as a .mrpack (resource packs from Modrinth listed by download) or a zip. Never
/// logs, screenshots or account data; worlds go without their per-player files
Export {
/// The instance (default: the selected one)
instance: Option<String>,
#[arg(long, value_enum, default_value_t = ExportFormat::Mrpack)]
format: ExportFormat,
/// A world to put in it (its name or folder); repeat for more
#[arg(long)]
world: Vec<String>,
/// Where to write it (default: "<name>.mrpack" in the current folder)
#[arg(long)]
out: Option<PathBuf>,
},
/// Import what a file is, as dropping it on the window does: a shared instance (a .mrpack
/// without mod loaders, such as `instance export` writes, or a game folder zip) becomes a
/// new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into
/// the instance (default: the selected one)
Import {
file: PathBuf,
/// The instance a pack goes into
#[arg(long)]
instance: Option<String>,
},
}
#[derive(Clone, Copy, clap::ValueEnum)]
enum ExportFormat {
/// Modrinth's modpack format
Mrpack,
/// The game folder's layout, zipped
Zip,
}
#[derive(Subcommand)]
enum WorldsCmd {
/// The worlds: name, mode, version, last played and size (the default)
List {
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
/// Zip a world into the instance's backups/ folder, as the game's Make Backup does
Backup {
/// Its folder or name
world: String,
#[arg(long)]
instance: Option<String>,
},
/// Copy a world beside it, as "<name> (1)"
Copy {
world: String,
#[arg(long)]
instance: Option<String>,
},
/// Move a world to the system's trash
Delete {
world: String,
#[arg(long)]
instance: Option<String>,
},
/// A world's data packs, and which are on
DatapackList {
world: String,
#[arg(long)]
instance: Option<String>,
},
/// Copy a data pack zip into a world (the game turns it on when the world opens)
DatapackAdd {
world: String,
file: PathBuf,
#[arg(long)]
instance: Option<String>,
},
/// Move a world's data pack to the system's trash
DatapackRemove {
world: String,
/// Its file name, with or without .zip
pack: String,
#[arg(long)]
instance: Option<String>,
},
}
#[derive(Clone, Copy, clap::ValueEnum)]
enum PackKindArg {
Resource,
Shader,
}
impl From<PackKindArg> for horizon_launcher::packs::Kind {
fn from(k: PackKindArg) -> Self {
match k {
PackKindArg::Resource => Self::Resource,
PackKindArg::Shader => Self::Shader,
}
}
}
#[derive(Subcommand)]
enum PacksCmd {
/// The resource and shader packs, and which are on (the default)
List {
/// Only this kind
#[arg(long, value_enum)]
kind: Option<PackKindArg>,
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
/// Copy a pack file in: a resource pack .zip, a shader pack .zip or a .hshader
Add {
file: PathBuf,
#[arg(long)]
instance: Option<String>,
},
/// Turn a pack on (a resource pack goes on top; a shader pack replaces the one that was on)
On {
/// Its file name or title
pack: String,
#[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
kind: PackKindArg,
#[arg(long)]
instance: Option<String>,
},
/// Turn a pack off
Off {
pack: String,
#[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
kind: PackKindArg,
#[arg(long)]
instance: Option<String>,
},
/// Turn a pack off and move it to the system's trash
Remove {
pack: String,
#[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
kind: PackKindArg,
#[arg(long)]
instance: Option<String>,
},
}
#[derive(Subcommand)]
enum ScreenshotsCmd {
/// The screenshots, the newest first, with their files (the default)
List {
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
/// Move a screenshot to the system's trash
Delete {
/// Its file name, with or without .png
screenshot: String,
#[arg(long)]
instance: Option<String>,
},
}
#[derive(Subcommand)]
enum MultiplayerCmd {
/// The servers of the game's Multiplayer screen (the default)
List {
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
/// Add a server to the list
Add {
/// Its address, as in the game's Add Server (host or host:port)
address: String,
/// Its name in the list (default: Minecraft Server)
#[arg(long)]
name: Option<String>,
#[arg(long)]
instance: Option<String>,
},
/// Remove a server from the list: its position from 1, name or address
Remove {
server: String,
#[arg(long)]
instance: Option<String>,
},
}
#[derive(Subcommand)]
enum ModsCmd {
/// What the browser installed in an instance (the default)
List {
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
/// 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,
},
/// Say how well a Java mod runs in Horizon: its jar is downloaded (checksum checked),
/// carried over and read; the answer is kept
Check {
project: String,
/// Allow a version made for another Minecraft version (1.21 and later)
#[arg(long)]
everything: bool,
#[arg(long, value_enum, default_value_t = SourceArg::Modrinth)]
source: SourceArg,
},
/// Install a pack and what it needs into an instance, by its id or slug (checksums
/// checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported as
/// an instance of its own; a data pack goes into the world `--world` names
Install {
project: String,
/// Install the project's data pack into this world of the instance (its name or folder)
#[arg(long)]
world: Option<String>,
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<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,
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
/// Remove a pack the browser installed
Remove {
project: String,
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
/// Turn on a mod the browser installed (horizon-mods.txt, as the game's Options > Mods does)
Enable {
project: String,
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
/// Turn off a mod the browser installed; it stays installed
Disable {
project: String,
/// The instance (default: the selected one)
#[arg(long)]
instance: Option<String>,
},
}
#[derive(Clone, Copy, clap::ValueEnum)]
enum KindArg {
Mod,
Resource,
Modpack,
/// Horizon's own shader packs (Horizon's registry only)
Shader,
/// Data packs (Modrinth): install one into a world with `mods install <pack> --world <name>`
Datapack,
}
#[derive(Clone, Copy, clap::ValueEnum)]
enum SourceArg {
Modrinth,
/// CurseForge support is coming soon
Curseforge,
/// Horizon's own registry: mods, modpacks and resource packs made for Horizon, reviewed
Horizon,
}
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,
SourceArg::Horizon => SourceId::Horizon,
};
browser::source(id).ok_or_else(|| browser::CURSEFORGE_SOON.into())
}
}
#[derive(Subcommand)]
enum Cmd {
/// List Horizon releases, or the installed versions
Versions {
/// Only the versions installed here (no network)
#[arg(long)]
installed: bool,
},
/// Download and install a release (a tag such as v2026.10.13, or "latest")
Install { tag: String },
/// Remove an installed version
Remove { tag: String },
/// Prepare a version's resources from your own Minecraft install
Prepare {
/// The game folder of the official launcher, Prism Launcher, MultiMC, the Modrinth App,
/// ATLauncher or GDLauncher (default: the launcher's, then every launcher's default)
#[arg(long)]
minecraft: Option<PathBuf>,
/// The installed version (default: the selected one)
#[arg(long)]
version: Option<String>,
},
/// Start the client
Play {
#[arg(long)]
version: Option<String>,
/// The instance to play (its name or id; default: the selected one)
#[arg(long)]
instance: Option<String>,
/// Open or create this world (a folder under saves) at once
#[arg(long)]
world: Option<String>,
/// Creative mode for a new world
#[arg(long)]
creative: bool,
/// Join a friend's world with its invite code
#[arg(long)]
join: Option<String>,
/// Join this server at once: an address, or a server of the list by name or position
#[arg(long, conflicts_with_all = ["world", "join"])]
server: Option<String>,
/// An extra argument for the game, passed through as-is (repeatable), for example
/// --server-thread
#[arg(long = "arg", value_name = "ARG", allow_hyphen_values = true)]
arg: Vec<String>,
},
/// Run a dedicated server here; type commands into its console
Server {
/// The server's folder (default: the one the launcher uses)
#[arg(long)]
dir: Option<PathBuf>,
#[arg(long)]
version: Option<String>,
/// Agree to the Minecraft EULA (https://aka.ms/MinecraftEULA)
#[arg(long)]
accept_eula: bool,
},
/// Show a release's patch notes (default: the newest)
Notes { tag: Option<String> },
/// Show the Discord, sponsor and website links
Links,
/// Microsoft accounts: list them (the default), sign in, sign out, or pick the one that plays
Account {
#[command(subcommand)]
action: Option<AccountCmd>,
},
/// Show the launcher's settings, or set one (the Settings page): selected-version TAG,
/// minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions
/// on|off, opening-animation on|off, proxy http://host:port ("default" removes it)
Settings {
#[arg(value_parser = SETTING_KEYS)]
key: Option<String>,
/// The new value (with KEY)
#[arg(requires = "key")]
value: Option<String>,
},
/// Show or set the extra arguments the game starts with (for example --server-thread);
/// quotes group a word with spaces in it
GameArgs {
/// Omit to show the current arguments
#[arg(allow_hyphen_values = true)]
args: Option<String>,
},
/// Print the end of the game's log (logs/latest.log in the game folder), or its newest crash
/// report
Logs {
/// How many lines of latest.log
#[arg(long, default_value_t = 100)]
lines: usize,
/// The newest crash report instead
#[arg(long)]
crash: bool,
},
/// Look for a newer Horizon release and launcher, and install them
Update {
/// Only report what is available
#[arg(long)]
check: bool,
},
/// Linux: put Horizon in the applications menu (an entry and the icon, under
/// $XDG_DATA_HOME), or take it out with --remove
DesktopEntry {
/// Remove the entry and the icon, and stop adding them back
#[arg(long)]
remove: bool,
},
/// Opt-in data collection (docs/telemetry.md): what is allowed, what would be sent, and
/// deleting it; all off until you allow a kind
Data {
#[command(subcommand)]
action: Option<DataCmd>,
},
/// Instances: separate game folders, each with its own worlds, options and packs
Instance {
#[command(subcommand)]
action: Option<InstanceCmd>,
},
/// An instance's single-player worlds: list them, back one up, copy or delete it
Worlds {
#[command(subcommand)]
action: Option<WorldsCmd>,
},
/// An instance's resource and shader packs: list, add, turn on or off, remove
Packs {
#[command(subcommand)]
action: Option<PacksCmd>,
},
/// The screenshots F2 took in an instance: list, delete
Screenshots {
#[command(subcommand)]
action: Option<ScreenshotsCmd>,
},
/// The servers in an instance's Multiplayer list (servers.dat): list, add, remove
Multiplayer {
#[command(subcommand)]
action: Option<MultiplayerCmd>,
},
/// Modpacks: import a Java pack, see its coverage report, port what this computer can and
/// play it as its own profile (docs/modpacks.md)
Modpack {
#[command(subcommand)]
action: Option<ModpackCmd>,
},
/// The mod browser: Java mods, resource packs and modpacks from Modrinth
/// (CurseForge support is coming soon), 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 {
#[command(subcommand)]
action: Option<ServersCmd>,
},
/// Serve the Model Context Protocol on stdin and stdout, for AI agents (refused while No AI
/// is on)
Mcp,
/// How to connect an AI agent (Claude Code, Codex, Cursor, any MCP client) to `mcp`: the
/// config to paste and the command that adds it (refused while No AI is on)
AgentConfig {
/// Only this client
#[arg(long, value_parser = ["claude-code", "codex", "cursor", "generic"])]
client: Option<String>,
/// Start the MCP server as a client would and say whether it answered
#[arg(long)]
test: bool,
},
/// Show or set No AI: on hides and turns off every AI feature (the companion, agent control,
/// horizon-ctl and both MCP servers); off, the default, makes them available
NoAi {
/// Omit to show the current state
#[arg(value_parser = ["on", "off"])]
state: Option<String>,
},
/// Measure the launcher: starts (the first is the cold one), page switching, idle CPU and
/// memory, the release list fetch; writes a benchmark report to benchmarks/ in its data folder
Benchmark {
/// How many times to start it
#[arg(long, default_value_t = 5)]
repeats: usize,
},
}
/// The CLI's definition, for the MCP tools generated from it (cli_tools.rs).
pub fn command() -> clap::Command {
<Cli as clap::CommandFactory>::command()
}
/// The commands that exist for AI agents: hidden and refused while No AI is on. Every other
/// command stays: the launcher, packagers and scripts need them, and none drives the game.
pub const AI_COMMANDS: [&str; 2] = ["mcp", "agent-config"];
/// The keys `settings` sets.
const SETTING_KEYS: [&str; 6] = [
"selected-version",
"minecraft-dir",
"server-dir",
"install-new-versions",
"opening-animation",
"proxy",
];
fn on_off(value: &str) -> Result<bool, String> {
match value {
"on" | "true" => Ok(true),
"off" | "false" => Ok(false),
_ => Err(format!("{value}: say on or off")),
}
}
fn set_setting(s: &mut backend::Settings, key: &str, value: &str) -> Result<(), String> {
let folder = |value: &str| (value != "default").then(|| PathBuf::from(value));
match key {
"selected-version" => s.selected = Some(backend::resolve_version(Some(value))?),
"minecraft-dir" => s.minecraft_dir = folder(value),
"server-dir" => s.server_dir = folder(value),
"install-new-versions" => s.install_new_versions = Some(on_off(value)?),
"opening-animation" => s.skip_opening = !on_off(value)?,
"proxy" => {
if value == "default" || value.is_empty() {
s.proxy = None;
} else if let Some(why) = horizon_launcher::proxy::refuse(value) {
return Err(why);
} else {
s.proxy = Some(value.trim().to_string());
}
}
_ => return Err(format!("No setting {key}.")),
}
Ok(())
}
/// Every launcher setting, as `settings` shows them.
fn settings_json(s: &backend::Settings) -> serde_json::Value {
serde_json::json!({
"selected_version": backend::resolve_version(None).ok(),
"minecraft_dir": s.minecraft_dir,
"server_dir": backend::server_dir(None),
"install_new_versions": s.install_new_versions.unwrap_or(true),
"opening_animation": !s.skip_opening,
"game_args": s.game_args,
"proxy": s.proxy,
"desktop_entry": s.desktop_entry.unwrap_or(true),
"no_ai": backend::no_ai(),
})
}
/// Runs a subcommand and returns the exit code, or None when the window should open.
pub fn run() -> Option<i32> {
use clap::FromArgMatches;
let no_ai = backend::no_ai();
let mut definition = command();
if no_ai {
// Hidden from the help too; a call still gets the refusal below.
for name in AI_COMMANDS {
definition = definition.mut_subcommand(name, |c| c.hide(true));
}
}
let cli = Cli::from_arg_matches(&definition.get_matches()).unwrap_or_else(|e| e.exit());
let command = cli.command?;
let result = match command {
Cmd::Mcp | Cmd::AgentConfig { .. } if no_ai => Err(horizon_core::no_ai::REFUSAL.into()),
Cmd::Mcp => crate::mcp::serve(),
command => execute(command, cli.json),
};
Some(match result {
Ok(()) => 0,
Err(e) => {
eprintln!("error: {e}");
1
}
})
}
/// Download progress on one terminal line, only when stderr is a terminal and the percentage moves.
fn progress(label: String) -> impl Fn(f32) {
let last = std::cell::Cell::new(-1);
let tty = std::io::stderr().is_terminal();
move |p| {
let pct = (p * 100.) as i32;
if !tty || pct == last.replace(pct) {
return;
}
eprint!("\r{label} {pct:>3}%");
let _ = std::io::stderr().flush();
if p >= 1.0 {
eprintln!();
}
}
}
fn json(value: serde_json::Value) {
println!("{}", serde_json::to_string_pretty(&value).unwrap());
}
/// Runs a game process in this terminal and reports how it ended.
fn attached(mut cmd: Command) -> Result<(), String> {
let status = cmd
.status()
.map_err(|e| format!("Could not start {:?}: {e}", cmd.get_program()))?;
if status.success() {
Ok(())
} else {
Err(format!("Exited with {status}"))
}
}
fn release_json(r: &Release) -> serde_json::Value {
serde_json::json!({
"tag": r.tag, "name": r.name, "date": r.date, "prerelease": r.prerelease,
"available_here": r.asset.is_some(), "installed": backend::installed().contains(&r.tag),
})
}
fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
if matches!(command, Cmd::Versions { .. } | Cmd::Update { .. }) {
for (tag, from) in backend::reuse_prepared_everywhere() {
if !as_json {
eprintln!("Prepared {tag} with the resources of {from}.");
}
}
}
match command {
Cmd::Versions { installed: true } => {
let installed = backend::installed();
let selected = backend::resolve_version(None).ok();
if as_json {
json(serde_json::json!({ "installed": installed, "selected": selected }));
} else if installed.is_empty() {
println!("No version is installed.");
}
for tag in installed.iter().filter(|_| !as_json) {
let mark = if selected.as_ref() == Some(tag) {
"*"
} else {
" "
};
let state = if !backend::is_prepared(tag) {
"not prepared"
} else if backend::has_sounds(tag) {
"prepared"
} else {
"prepared, no sounds (prepare again)"
};
println!("{mark} {tag} {state}");
}
}
Cmd::Versions { installed: false } => {
let releases = backend::releases()?;
if as_json {
json(releases.iter().map(release_json).collect());
return Ok(());
}
let installed = backend::installed();
for r in &releases {
let state = match (installed.contains(&r.tag), r.asset.is_some()) {
(true, _) => "installed",
(false, true) => "",
(false, false) => "no build for this platform",
};
println!("{:<15} {} {}", r.tag, r.date, state);
}
}
Cmd::Install { tag } => {
let label = format!("Installing {tag}");
let tag = backend::install_tag(&tag, false, progress(label))?;
if as_json {
json(
serde_json::json!({ "installed": tag, "prepared": backend::is_prepared(&tag) }),
);
} else if backend::is_prepared(&tag) {
println!(
"Installed {tag}. It is prepared already, from another installed version."
);
} else {
println!(
"Installed {tag}. Prepare it next: horizon-launcher prepare --version {tag}"
);
}
}
Cmd::Remove { tag } => {
backend::remove_version(&tag)?;
println!("Removed {tag}.");
}
Cmd::Prepare { minecraft, version } => {
let tag = backend::resolve_version(version.as_deref())?;
let minecraft = backend::minecraft_dir(minecraft)?;
let (preparer, minecraft) =
backend::preparer(&tag, &minecraft, &|line| eprintln!("{line}"))?;
backend::sounds(&tag, &minecraft, &|line| println!("{line}"));
match preparer {
backend::Preparer::Process(cmd) => attached(cmd)?,
backend::Preparer::InProcess(options) => {
backend::prepare_in_process(&options, &|line| println!("{line}"))?
}
}
println!("{tag} is prepared.");
}
Cmd::Play {
version,
instance,
world,
creative,
join,
server,
arg,
} => {
let instance = match instance {
Some(name) => instances::find(&name)?,
None => instances::selected(),
};
let mut cmd = backend::client(&instance.resolve_version(version.as_deref())?)?;
instances::apply(&mut cmd, &instance)?;
if let Some(code) = join {
backend::join_friend(&mut cmd, &code)?;
}
if let Some(world) = world {
cmd.arg("--world").arg(world);
}
if let Some(server) = server {
let list = server_list::List::load(&instance.home);
let ip = server_list::find(&list, &server).map_or(server, |(_, s)| s.ip);
cmd.arg("--server").arg(ip);
}
if creative {
cmd.arg("--creative");
}
cmd.args(arg);
let started = std::time::Instant::now();
let played = attached(cmd);
if let Err(e) = instances::record_play(&instance.id, started.elapsed()) {
eprintln!("Play time not saved: {e}");
}
played?
}
Cmd::Server {
dir,
version,
accept_eula,
} => {
let tag = backend::resolve_version(version.as_deref())?;
let dir = backend::server_dir(dir);
// The server inherits this terminal, so typed lines reach its console.
attached(backend::server(&tag, &dir, accept_eula)?)?
}
Cmd::Notes { tag } => {
let r = backend::release_notes(tag.as_deref())?;
if as_json {
json(
serde_json::json!({ "tag": r.tag, "name": r.name, "date": r.date, "notes": r.body }),
);
} else {
let title = if r.name.is_empty() { &r.tag } else { &r.name };
println!(
"{title}\n{} {}\n\n{}",
r.tag,
r.date,
backend::markdown_to_text(&r.body)
);
}
}
Cmd::Account { action } => account_command(action.unwrap_or(AccountCmd::List), as_json)?,
Cmd::Benchmark { repeats } => {
let path = crate::perf::benchmark(repeats.max(1))?;
if as_json {
json(serde_json::json!({ "report": path }));
} else {
println!("{}", path.display());
}
}
Cmd::Links => {
let links = backend::links();
if as_json {
json(serde_json::to_value(&links).unwrap());
} else {
for (name, url) in [
("Discord", &links.discord),
("Sponsor", &links.sponsor),
("Website", &links.website),
] {
println!("{name:<8} {}", if url.is_empty() { "(none)" } else { url });
}
}
}
Cmd::NoAi { state } => {
if let Some(state) = state {
backend::set_no_ai(state == "on")?;
}
let on = backend::no_ai();
if as_json {
json(serde_json::json!({ "no_ai": on }));
} else if on {
println!("No AI is on: every AI feature is hidden and off.");
} else {
println!("No AI is off: AI features are available.");
}
}
Cmd::AgentConfig { test: true, .. } => {
let tools = horizon_launcher::agents::self_test(backend::exe_path())?;
if as_json {
json(serde_json::json!({ "answered": true, "tools": tools }));
} else {
println!("The MCP server answered with {tools} tools.");
}
}
Cmd::AgentConfig { client, .. } => {
use horizon_launcher::agents;
let exe = backend::exe_path();
if as_json {
let mut all = agents::json(exe);
if let Some(id) = &client {
all["clients"] = all["clients"]
.as_array()
.into_iter()
.flatten()
.filter(|c| c["id"] == id.as_str())
.cloned()
.collect();
}
json(all);
return Ok(());
}
for c in agents::clients(exe)
.iter()
.filter(|c| client.as_ref().is_none_or(|id| id == c.id))
{
println!("{}", c.name);
if let Some(line) = c.add_line() {
println!(" Add it with: {line}");
}
println!(" Or put this in {}:", c.file);
for line in c.config.lines() {
println!(" {line}");
}
println!();
}
println!("Then ask your agent to say hello: it can call the links tool, or play.");
}
Cmd::Settings { key, value } => {
let mut settings = backend::Settings::load();
if let Some(key) = key {
let value = value.ok_or("settings KEY VALUE: the value is missing")?;
set_setting(&mut settings, &key, &value)?;
settings.save();
horizon_launcher::proxy::announce(settings.proxy.clone());
}
let all = settings_json(&settings);
if as_json {
json(all);
} else {
for (key, value) in all.as_object().into_iter().flatten() {
println!("{key}: {value}");
}
}
}
Cmd::GameArgs { args } => {
let mut settings = backend::Settings::load();
if let Some(line) = args {
settings.game_args = line;
settings.save();
}
let line = settings.game_args;
if as_json {
json(serde_json::json!({
"game_args": line,
"parsed": backend::split_args(&line),
}));
} else if line.is_empty() {
println!("No extra game arguments.");
} else {
println!("Game arguments: {line}");
}
}
Cmd::Logs { lines, crash } => {
let (path, text) = backend::read_logs(lines, crash)?;
if as_json {
json(serde_json::json!({ "path": path, "text": text }));
} else {
print!("{text}");
}
}
Cmd::Update { check } => update(check, as_json)?,
Cmd::Data { action } => data(action.unwrap_or(DataCmd::Status), as_json)?,
Cmd::DesktopEntry { remove } => {
let mut settings = backend::Settings::load();
settings.desktop_entry = Some(!remove);
settings.save();
if remove {
horizon_launcher::desktop::remove()?;
println!("Removed Horizon from the applications menu.");
} else {
horizon_launcher::desktop::install(backend::exe_path())?;
println!("Horizon is in the applications menu.");
}
}
Cmd::Worlds { action } => worlds(
action.unwrap_or(WorldsCmd::List { instance: None }),
as_json,
)?,
Cmd::Packs { action } => game_packs(
action.unwrap_or(PacksCmd::List {
kind: None,
instance: None,
}),
as_json,
)?,
Cmd::Screenshots { action } => screenshots(
action.unwrap_or(ScreenshotsCmd::List { instance: None }),
as_json,
)?,
Cmd::Multiplayer { action } => multiplayer(
action.unwrap_or(MultiplayerCmd::List { instance: None }),
as_json,
)?,
Cmd::Instance { action } => instance(action.unwrap_or(InstanceCmd::List), as_json)?,
Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List { instance: None }), as_json)?,
Cmd::Servers { action } => servers(action.unwrap_or(ServersCmd::List), as_json)?,
Cmd::Mcp => unreachable!(),
}
Ok(())
}
fn update(check: bool, as_json: bool) -> Result<(), String> {
let updates = backend::check_updates()?;
if as_json && check {
json(serde_json::json!({
"horizon": updates.horizon.as_ref().map(|r| &r.tag),
"launcher": updates.launcher.as_ref().and_then(|r| backend::launcher_version(&r.tag)),
"launcher_current": backend::VERSION,
}));
return Ok(());
}
match &updates.horizon {
None => println!("Horizon: up to date."),
Some(r) if check => println!("Horizon: {} is available.", r.tag),
Some(r) => {
let tag =
backend::install_tag(&r.tag, true, progress(format!("Installing {}", r.tag)))?;
println!("Horizon: installed {tag}.");
}
}
match &updates.launcher {
None => println!("Launcher: {} is up to date.", backend::VERSION),
Some(r) => {
let version = backend::launcher_version(&r.tag).unwrap_or_default();
if check {
println!(
"Launcher: {version} is available (this is {}).",
backend::VERSION
);
} else if !backend::self_update_allowed() {
println!("Launcher: {version} is available; this build does not replace itself.");
} else {
backend::self_update(r, progress(format!("Updating the launcher to {version}")))?;
println!("Launcher: updated to {version}. Restart the launcher to use it.");
}
}
}
Ok(())
}
/// `account …`: names and UUIDs only; tokens are never printed.
fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
let mut accounts = Accounts::load();
let find = |accounts: &Accounts, who: &str| {
accounts
.find(who)
.cloned()
.ok_or_else(|| format!("No signed-in account {who}. See `horizon-launcher account`."))
};
match action {
AccountCmd::List => {
if as_json {
json(serde_json::json!({
"accounts": accounts.accounts.iter().map(|a| serde_json::json!({
"name": a.name, "uuid": a.uuid,
"selected": accounts.selected.as_ref() == Some(&a.uuid),
})).collect::<Vec<_>>(),
"sign_in_configured": account::client_id().is_some(),
}));
} else if accounts.accounts.is_empty() {
println!("No Microsoft account signed in: the game plays offline.");
} else {
for a in &accounts.accounts {
let mark = if accounts.selected.as_ref() == Some(&a.uuid) {
"*"
} else {
" "
};
println!("{mark} {} {}", a.name, a.uuid);
}
if accounts.selected().is_none() {
println!("Playing offline (`account select NAME` to play as one).");
}
}
}
AccountCmd::SignIn => {
let client_id = account::client_id().ok_or(account::NOT_CONFIGURED)?;
let ep = account::Endpoints::live();
let code = account::device_code(&ep, &client_id)?;
eprintln!(
"To sign in, open {} in a browser and enter the code {}",
code.verification_uri, code.user_code
);
let ms = account::wait_for_sign_in(&ep, &client_id, &code, &|| false)?;
let (signed_in, secrets) = account::finish_sign_in(&ep, ms)?;
accounts.add(account::store(), signed_in.clone(), &secrets)?;
accounts.save()?;
println!("Signed in as {}.", signed_in.name);
if !account::store().persistent() {
eprintln!("{}", account::NO_KEYCHAIN);
}
}
AccountCmd::SignOut { who } => {
let a = find(&accounts, &who)?;
accounts.remove(account::store(), &a.uuid)?;
accounts.save()?;
println!("Signed out {}.", a.name);
}
AccountCmd::Select { who } => {
let a = find(&accounts, &who)?;
accounts.selected = Some(a.uuid);
accounts.save()?;
println!("The game plays as {}.", a.name);
}
AccountCmd::Offline => {
accounts.selected = None;
accounts.save()?;
println!("The game plays offline.");
}
}
Ok(())
}
/// `data`: the same consent as Settings → Data collection.
fn data(action: DataCmd, as_json: bool) -> Result<(), String> {
use horizon_launcher::telemetry;
let review = |item: &horizon_telemetry::Item, yes: bool| -> Result<bool, String> {
println!(
"{}",
serde_json::to_string_pretty(item).map_err(|e| e.to_string())?
);
if yes {
return Ok(true);
}
if !std::io::stdin().is_terminal() {
return Err("Add --yes to send it without asking.".into());
}
eprint!("Send this? [y/N] ");
let mut line = String::new();
std::io::stdin()
.read_line(&mut line)
.map_err(|e| e.to_string())?;
Ok(line.trim().eq_ignore_ascii_case("y"))
};
match action {
DataCmd::Status => {
let status = telemetry::status_json();
if as_json {
json(status);
return Ok(());
}
let consent = telemetry::consent();
if consent.needs_asking() {
println!("Not answered yet: nothing is collected.");
}
for (kind, name, _) in telemetry::SWITCHES {
let on = consent.allows(kind);
println!("{name}: {}", if on { "on" } else { "off" });
}
println!("Waiting to be sent: {}", status["waiting"]);
match horizon_telemetry::endpoint() {
Some(url) => println!("Server: {url}"),
None => println!("Server: turned off (HORIZON_TELEMETRY_URL=off), nothing is sent"),
}
}
DataCmd::Allow { kinds } => {
telemetry::set(&telemetry::parse_kinds(&kinds)?, true)?;
return data(DataCmd::Status, as_json);
}
DataCmd::Deny { kinds } => {
telemetry::set(&telemetry::parse_kinds(&kinds)?, false)?;
return data(DataCmd::Status, as_json);
}
DataCmd::Show => {
let (what, text) = telemetry::preview();
eprintln!("{what}");
println!("{text}");
}
DataCmd::Delete => println!("{}", telemetry::delete_my_data()?),
DataCmd::Send => println!("{:?}", telemetry::send()),
DataCmd::Bug { text, log, yes } => {
telemetry::ensure_allowed(horizon_telemetry::Kind::Bug)?;
let item = telemetry::bug_report(&text, log)?;
if review(&item, yes)? {
println!("{}", telemetry::submit(&item)?);
}
}
DataCmd::Benchmark { file, yes } => {
telemetry::ensure_allowed(horizon_telemetry::Kind::Benchmark)?;
let item = telemetry::benchmark_report(&file)?;
if review(&item, yes)? {
println!("{}", telemetry::submit(&item)?);
}
}
}
Ok(())
}
fn servers(action: ServersCmd, as_json: bool) -> Result<(), String> {
use horizon_launcher::servers::{self, NewServer, World};
let find = |which: &str| {
servers::list()
.into_iter()
.find(|e| e.name == which || e.dir == std::path::Path::new(which))
.ok_or_else(|| {
format!("No server called {which}: `horizon-launcher servers` lists them")
})
};
match action {
ServersCmd::List => {
let list = servers::list();
if as_json {
json(serde_json::Value::Array(
list.iter()
.map(|e| {
serde_json::json!({
"name": e.name, "dir": e.dir,
"phase": servers::status(&e.dir).phase,
})
})
.collect(),
));
} else if list.is_empty() {
println!("No server yet: horizon-launcher servers create --accept-eula");
}
for e in list.iter().filter(|_| !as_json) {
println!(
"{} ({}): {}",
e.name,
e.dir.display(),
servers::status(&e.dir).phase
);
}
}
ServersCmd::Create {
name,
seed,
copy_world,
mode,
difficulty,
max_players,
open,
check_accounts,
players,
version,
accept_eula,
} => {
let spec = NewServer {
name,
world: match copy_world {
Some(dir) => World::Copy(dir),
None => World::New {
seed: seed.unwrap_or_default(),
},
},
game_mode: mode,
difficulty,
max_players,
friends_only: !open,
check_accounts,
players,
eula: accept_eula,
};
let tag = backend::resolve_version(version.as_deref()).ok();
let entry = servers::create(&spec, tag.as_deref(), &|l| eprintln!("{l}"))
.map_err(|p| p.message)?;
if as_json {
json(serde_json::json!({ "name": entry.name, "dir": entry.dir }));
} else {
println!("Created {} in {}", entry.name, entry.dir.display());
}
}
ServersCmd::SetUp { version } => {
let tag = backend::resolve_version(version.as_deref())?;
servers::set_up(&tag)?;
println!(
"Servers run Horizon {}",
servers::runtime_release().unwrap_or(tag)
);
}
ServersCmd::Run { server, args } => {
let entry = find(&server)?;
let args: Vec<&str> = args.iter().map(String::as_str).collect();
let status = servers::command(&entry.dir, &args)?
.status()
.map_err(|e| e.to_string())?;
if !status.success() {
return Err(format!("horizon-server exited with {status}"));
}
}
ServersCmd::Forget { server } => {
let entry = find(&server)?;
servers::forget(&entry.dir)?;
println!(
"{} is off the list; its folder stays in {}",
entry.name,
entry.dir.display()
);
}
}
Ok(())
}
fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
use horizon_launcher::browser::{horizon, installed, Kind, Query, SourceId};
use horizon_launcher::modpacks;
// What the browser installs goes into an instance's game folder; Java mods' checks are kept
// in the default one, shared by all.
let home = match &action {
ModsCmd::List { instance }
| ModsCmd::Install { instance, .. }
| ModsCmd::Update { instance, .. }
| ModsCmd::Remove { instance, .. }
| ModsCmd::Enable { instance, .. }
| ModsCmd::Disable { instance, .. } => match instance {
Some(name) => instances::find(name)?.home,
None => instances::selected().home,
},
ModsCmd::Search { .. } | ModsCmd::Check { .. } => 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);
let from_registry = installed::Installed::load(&home)
.entries
.iter()
.any(|e| e.source == SourceId::Horizon);
if from_registry {
if let Ok(index) = horizon::index() {
for said in horizon::turn_off_revoked(&index, &home) {
eprintln!("{said}");
}
}
}
let on = matches!(action, ModsCmd::Enable { .. });
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::Modpack => Kind::Modpack,
KindArg::Mod => Kind::Mod,
KindArg::Shader => Kind::Shader,
KindArg::Datapack => Kind::DataPack,
};
let query = Query {
everything,
..Query::new(&text.join(" "), kind)
};
let found = source.get()?.search(&query)?;
let datapack = kind == Kind::DataPack;
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(),
"about": if p.source == SourceId::Horizon { horizon::trust_and_capabilities(&p.id) } else { Vec::new() },
})
}).collect());
} else {
if datapack && !found.is_empty() {
println!("{}\n", horizon_launcher::browser::DATAPACK_SUPPORT);
}
for p in &found {
let support = p.support();
if p.source == SourceId::Horizon {
println!("{} ({}) {}\n {}", p.title, p.slug, p.author, p.summary);
for line in horizon::trust_and_capabilities(&p.id) {
println!(" {line}");
}
continue;
}
let unchecked = p.kind == Kind::Mod && support.installable();
println!(
"{} ({}) {} · {} downloads\n {}",
p.title,
p.slug,
if unchecked {
"Not checked"
} else {
support.label()
},
p.downloads,
p.summary
);
if unchecked {
println!(" horizon-launcher mods check {}", p.slug);
} else if datapack {
println!(" horizon-launcher mods install {} --world <world>", p.slug);
} else if let Some(why) = support.reason() {
println!(" {why}");
}
}
}
}
ModsCmd::Check {
project,
everything,
source,
} => {
let source = source.get()?;
let p = source.project(&project)?;
if p.kind != Kind::Mod {
return Err(format!("{} isn't a Java mod.", p.title));
}
let (version, c) = horizon_launcher::browser::java::check_project(
&home,
&*source,
&p,
everything,
&progress(p.title.clone()),
)?;
if as_json {
let mut v = serde_json::to_value(&c).unwrap_or_default();
v["version"] = version.number.clone().into();
v["label"] = c.verdict.label().into();
println!("{v}");
return Ok(());
}
println!(
"{} {} ({} {}): {}. {}",
p.title,
version.number,
c.loader,
c.mod_id,
c.verdict.label(),
c.summary
);
for line in &c.ports {
println!(" ports: {line}");
}
for line in &c.skipped {
println!(" doesn't: {line}");
}
}
ModsCmd::Install {
project,
everything,
source,
world,
..
} => {
let source = source.get()?;
let p = source.project(&project)?;
if let Some(world) = world {
let world = horizon_launcher::worlds::find(&home, &world)?;
let done = installed::install_datapack(
&*source,
&p,
everything,
&world.path,
&progress(p.title.clone()),
)?;
if as_json {
json(serde_json::json!({
"world": world.folder, "file": done.pack.file, "version": done.number,
"runs": done.coverage.read, "not_read": done.coverage.unread,
}));
} else {
println!(
"{} {} is in {}'s data packs as {}: the game turns it on when the world \
opens. {}",
p.title,
done.number,
world.name,
done.pack.file,
done.coverage.summary()
);
}
return Ok(());
}
if p.kind == Kind::DataPack {
return Err(format!(
"{} is a data pack: say which world with --world.",
p.title
));
}
if p.kind == Kind::Modpack && p.source == SourceId::Horizon {
let pack = horizon::pack::install(&p.id, &line)?;
if as_json {
json(
serde_json::json!({"pack": pack.id, "version": pack.version, "mods": pack.mods, "home": horizon::pack::home(&pack.work)}),
);
} else {
println!(
"{} {} is installed as its own profile, with {}.",
pack.name,
pack.version,
pack.mods.join(", ")
);
println!("Play it: horizon-launcher modpack play {}", pack.id);
}
return Ok(());
}
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 resources = backend::resolve_version(None)
.ok()
.filter(|t| backend::is_prepared(t))
.map(|t| backend::resources(&t));
let pack = modpacks::import_and_port(&file, resources.as_deref(), log)?;
println!("{} ({})", modpacks::outcome(&pack), pack.summary());
println!("Play it: horizon-launcher modpack play {}", 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);
for s in &e.skipped {
println!(" not ported: {s}");
}
}
}
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);
}
ModsCmd::Enable { project, .. } | ModsCmd::Disable { project, .. } => {
let e = installed::Installed::load(&home)
.lookup(&project)
.cloned()
.ok_or_else(|| format!("{project} wasn't installed by the browser."))?;
let id = horizon::mod_id(&e)
.filter(|_| e.kind == Kind::Mod)
.ok_or_else(|| format!("{} isn't a mod: only mods turn on and off.", e.title))?;
if on {
if let Some(r) = horizon::index()
.ok()
.filter(|_| e.source == SourceId::Horizon)
.and_then(|i| {
i.revoked(&e.project, e.checksum.trim_start_matches("SHA-256:"))
.cloned()
})
{
return Err(format!("{} was taken down: {}", e.title, r.reason));
}
}
horizon_launcher::browser::java::set_enabled(&home, id, on)?;
println!("{} is {}.", e.title, if on { "on" } else { "off" });
}
}
Ok(())
}
fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
use instances::Icon;
let value = |i: &instances::Instance, selected: bool| {
serde_json::json!({
"id": i.id, "name": i.name, "kind": format!("{:?}", i.kind).to_lowercase(),
"home": i.home, "icon": i.icon, "group": i.group, "selected": selected,
"version": i.version, "played_secs": i.played.as_secs(),
"last_played_ms": i.last_played.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok()).map(|d| d.as_millis() as u64),
})
};
let line = |i: &instances::Instance, selected: bool| {
let mark = if selected { "*" } else { " " };
let group = i
.group
.as_ref()
.map(|g| format!(" [{g}]"))
.unwrap_or_default();
let pinned = i
.version
.as_ref()
.map(|v| format!(" {v}"))
.unwrap_or_default();
let played = match i.last_played {
Some(_) => format!(" {} played", instances::play_time(i.played)),
None => String::new(),
};
println!(
"{mark} {} ({}){pinned}{group}{played}\n {}",
i.name,
i.id,
i.home.display()
);
};
let changed = |i: instances::Instance| {
let selected = i.id == instances::selected().id;
match as_json {
true => json(value(&i, selected)),
false => line(&i, selected),
}
};
match action {
InstanceCmd::List => {
let selected = instances::selected().id;
let all = instances::list();
if as_json {
json(all.iter().map(|i| value(i, i.id == selected)).collect());
} else {
all.iter().for_each(|i| line(i, i.id == selected));
}
}
InstanceCmd::Create { name, copy } => changed(instances::create(&name, copy.as_deref())?),
InstanceCmd::Rename { instance, name } => {
changed(instances::edit(&instance, |m| m.name = Some(name))?)
}
InstanceCmd::Icon { instance, icon } => {
let icon = (icon != "none").then(|| Icon::parse(&icon)).transpose()?;
changed(instances::edit(&instance, |m| m.icon = icon)?)
}
InstanceCmd::Group { instance, group } => {
changed(instances::edit(&instance, |m| m.group = group)?)
}
InstanceCmd::Select { instance } => changed(instances::select(&instance)?),
InstanceCmd::Version { instance, version } => {
let pin = match version.as_str() {
"latest" => None,
tag => Some(backend::resolve_version(Some(tag))?),
};
changed(instances::edit(&instance, |m| m.version = pin)?)
}
InstanceCmd::Import { file, instance } => {
use horizon_launcher::import::{self, Dropped};
use horizon_launcher::modpacks;
match import::what(&file)? {
Dropped::Instance => {
let i = import::import_instance(&file, &|line, _| eprintln!("{line}"))?;
if as_json {
json(value(&i, false));
} else {
println!(
"Made the instance {} in {}: horizon-launcher instance select \"{}\"",
i.name,
i.home.display(),
i.name
);
}
}
Dropped::Modpack => {
let pack = modpacks::import(&file, &|line: String| eprintln!("{line}"))?;
println!("{} ({})", modpacks::outcome(&pack), pack.summary());
println!(
"Port and play it: horizon-launcher modpack port {}",
pack.slug
);
}
Dropped::Pack(_) => {
let i = match instance {
Some(name) => instances::find(&name)?,
None => instances::selected(),
};
let p = horizon_launcher::packs::add(&i.home, &file)?;
println!(
"Added {} to {}: turn it on with horizon-launcher packs on",
p.title, i.name
);
}
Dropped::DataPack => {
return Err(format!(
"{} is a data pack: put it into a world with horizon-launcher worlds \
datapack-add <world> <file>",
file.display()
))
}
}
}
InstanceCmd::Export {
instance,
format,
world,
out,
} => {
use horizon_launcher::export::{self, Format};
let i = match instance {
Some(name) => instances::find(&name)?,
None => instances::selected(),
};
let format = match format {
ExportFormat::Mrpack => Format::Mrpack,
ExportFormat::Zip => Format::Zip,
};
let worlds = world
.iter()
.map(|w| horizon_launcher::worlds::find(&i.home, w).map(|w| w.folder))
.collect::<Result<Vec<_>, _>>()?;
let linked = match format {
Format::Mrpack => export::linkable(&i.home, &export::from_modrinth),
Format::Zip => Vec::new(),
};
let out = match out {
Some(out) => out,
None => export::free_path(
&std::env::current_dir().map_err(|e| e.to_string())?,
&i.name,
format,
),
};
let done = export::export(&i.home, &i.name, format, &worlds, &linked, &out)?;
if as_json {
json(serde_json::json!({
"path": done.path, "copied": done.copied, "linked": done.linked,
"worlds": done.worlds,
}));
} else {
println!(
"Exported {} to {}: {} files, {} listed by their Modrinth download{}.",
i.name,
done.path.display(),
done.copied,
done.linked,
match done.worlds.is_empty() {
true => String::new(),
false => format!(", worlds: {}", done.worlds.join(", ")),
}
);
}
}
}
Ok(())
}
fn game_packs(action: PacksCmd, as_json: bool) -> Result<(), String> {
use horizon_launcher::packs::{self, Kind};
let home = |instance: Option<String>| -> Result<PathBuf, String> {
Ok(match instance {
Some(name) => instances::find(&name)?.home,
None => instances::selected().home,
})
};
let value = |p: &packs::Pack| {
serde_json::json!({
"kind": format!("{:?}", p.kind).to_lowercase(), "file": p.file, "title": p.title,
"description": p.description, "enabled": p.enabled, "path": p.path,
})
};
match action {
PacksCmd::List { kind, instance } => {
let home = home(instance)?;
let kinds = match kind {
Some(k) => vec![Kind::from(k)],
None => vec![Kind::Resource, Kind::Shader],
};
let all: Vec<packs::Pack> = kinds.iter().flat_map(|k| packs::list(&home, *k)).collect();
if as_json {
json(all.iter().map(value).collect());
}
for k in kinds.iter().filter(|_| !as_json) {
println!("{}:", k.folder());
let these: Vec<_> = all.iter().filter(|p| p.kind == *k).collect();
if these.is_empty() {
println!(" none");
}
for p in these {
let on = if p.enabled { "on " } else { "off" };
match p.title == p.file {
true => println!(" {on} {}", p.file),
false => println!(" {on} {} ({})", p.title, p.file),
}
}
}
}
PacksCmd::Add { file, instance } => {
let pack = packs::add(&home(instance)?, &file)?;
match as_json {
true => json(value(&pack)),
false => println!("Added {} to {} (off).", pack.file, pack.kind.folder()),
}
}
PacksCmd::On {
pack,
kind,
instance,
} => set_pack(&home(instance)?, kind.into(), &pack, true)?,
PacksCmd::Off {
pack,
kind,
instance,
} => set_pack(&home(instance)?, kind.into(), &pack, false)?,
PacksCmd::Remove {
pack,
kind,
instance,
} => {
let home = home(instance)?;
let p = packs::find(&home, kind.into(), &pack)?;
packs::remove(&home, &p)?;
println!("{} is in the trash.", p.file);
}
}
Ok(())
}
fn set_pack(
home: &std::path::Path,
kind: horizon_launcher::packs::Kind,
query: &str,
on: bool,
) -> Result<(), String> {
use horizon_launcher::packs;
let pack = packs::find(home, kind, query)?;
packs::set_enabled(home, &pack, on)?;
println!("{} is {}.", pack.title, if on { "on" } else { "off" });
Ok(())
}
fn screenshots(action: ScreenshotsCmd, as_json: bool) -> Result<(), String> {
use horizon_launcher::screenshots;
let home = |instance: Option<String>| -> Result<PathBuf, String> {
Ok(match instance {
Some(name) => instances::find(&name)?.home,
None => instances::selected().home,
})
};
match action {
ScreenshotsCmd::List { instance } => {
let home = home(instance)?;
let shots = screenshots::list(&home);
if as_json {
json(
shots
.iter()
.map(|s| {
let millis = s
.taken
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_millis() as u64);
serde_json::json!({ "name": s.name, "path": s.path, "taken_ms": millis, "size": s.size })
})
.collect(),
);
} else if shots.is_empty() {
println!("No screenshots in {}", screenshots::folder(&home).display());
}
for s in shots.iter().filter(|_| !as_json) {
println!("{}", s.path.display());
}
}
ScreenshotsCmd::Delete {
screenshot,
instance,
} => {
let shot = screenshots::find(&home(instance)?, &screenshot)?;
screenshots::delete(&shot)?;
println!("{} is in the trash.", shot.name);
}
}
Ok(())
}
fn multiplayer(action: MultiplayerCmd, as_json: bool) -> Result<(), String> {
let home = |instance: Option<String>| -> Result<PathBuf, String> {
Ok(match instance {
Some(name) => instances::find(&name)?.home,
None => instances::selected().home,
})
};
match action {
MultiplayerCmd::List { instance } => {
let home = home(instance)?;
let servers = server_list::List::load(&home).servers();
if as_json {
json(
servers
.iter()
.map(|s| serde_json::json!({ "name": s.name, "address": s.ip, "icon": s.icon.is_some() }))
.collect(),
);
} else if servers.is_empty() {
println!("No servers in {}", home.join("servers.dat").display());
}
for (i, s) in servers.iter().enumerate().filter(|_| !as_json) {
println!("{}. {} ({})", i + 1, s.name, s.ip);
}
}
MultiplayerCmd::Add {
address,
name,
instance,
} => {
let home = home(instance)?;
let mut list = server_list::List::load(&home);
list.add(name.as_deref().unwrap_or(""), &address)?;
list.save(&home)?;
println!("Added {}.", address.trim());
}
MultiplayerCmd::Remove { server, instance } => {
let home = home(instance)?;
let mut list = server_list::List::load(&home);
let (i, _) = server_list::find(&list, &server)?;
let gone = list.remove(i)?;
list.save(&home)?;
println!("Removed {} ({}).", gone.name, gone.ip);
}
}
Ok(())
}
fn worlds(action: WorldsCmd, as_json: bool) -> Result<(), String> {
use horizon_launcher::datapacks;
use horizon_launcher::worlds::{self, World};
let home = |instance: Option<String>| -> Result<PathBuf, String> {
Ok(match instance {
Some(name) => instances::find(&name)?.home,
None => instances::selected().home,
})
};
let value = |w: &World| {
let millis = w
.last_played
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_millis() as u64);
serde_json::json!({
"folder": w.folder, "name": w.name, "mode": w.mode, "version": w.version,
"last_played_ms": millis, "size": w.size, "path": w.path, "icon": w.icon,
})
};
match action {
WorldsCmd::List { instance } => {
let home = home(instance)?;
let all = worlds::list(&home);
if as_json {
json(all.iter().map(value).collect());
} else if all.is_empty() {
println!("No worlds in {}", home.join("saves").display());
}
for w in all.iter().filter(|_| !as_json) {
let version = w.version.as_deref().unwrap_or("unknown version");
let mb = w.size as f64 / 1_000_000.0;
println!(
"{} ({})\n {}, {version}, {mb:.1} MB",
w.name, w.folder, w.mode
);
}
}
WorldsCmd::Backup { world, instance } => {
let home = home(instance)?;
let zip = worlds::backup(&home, &worlds::find(&home, &world)?)?;
match as_json {
true => json(serde_json::json!({ "backup": zip })),
false => println!("{}", zip.display()),
}
}
WorldsCmd::Copy { world, instance } => {
let home = home(instance)?;
let copy = worlds::copy(&worlds::find(&home, &world)?)?;
match as_json {
true => json(value(&copy)),
false => println!("Copied to {} ({})", copy.name, copy.folder),
}
}
WorldsCmd::Delete { world, instance } => {
let home = home(instance)?;
let w = worlds::find(&home, &world)?;
worlds::delete(&w)?;
println!("{} is in the trash.", w.name);
}
WorldsCmd::DatapackList { world, instance } => {
let w = worlds::find(&home(instance)?, &world)?;
let packs = datapacks::list(&w.path);
if as_json {
json(
packs
.iter()
.map(|p| serde_json::json!({ "file": p.file, "description": p.description, "enabled": p.enabled, "path": p.path }))
.collect(),
);
} else if packs.is_empty() {
println!("No data packs in {}", w.name);
}
for p in packs.iter().filter(|_| !as_json) {
let on = if p.enabled { "on " } else { "off" };
println!(" {on} {} {}", p.file, p.description);
}
}
WorldsCmd::DatapackAdd {
world,
file,
instance,
} => {
let w = worlds::find(&home(instance)?, &world)?;
let p = datapacks::add(&w.path, &file)?;
println!(
"Added {} to {}: the game turns it on when the world opens.",
p.file, w.name
);
}
WorldsCmd::DatapackRemove {
world,
pack,
instance,
} => {
let w = worlds::find(&home(instance)?, &world)?;
let p = datapacks::find(&w.path, &pack)?;
datapacks::remove(&w.path, &p)?;
println!("{} is in the trash.", p.file);
}
}
Ok(())
}
fn modpack(action: ModpackCmd, as_json: bool) -> Result<(), String> {
use horizon_launcher::browser::horizon;
use horizon_launcher::modpacks::{self, Imported};
use horizon_port_pack::report::Status;
let log = &|line: String| eprintln!("{line}");
let work = |pack: &str| {
let registry = horizon::pack::packs_dir().join(pack);
if horizon::pack::is_pack(&registry) {
return Ok(registry);
}
let work = modpacks::ports_dir().join(pack);
modpacks::load(&work).map(|_| work)
};
let show = |p: &Imported| {
let counts: Vec<String> = Status::ALL
.iter()
.map(|s| format!("{} {}", p.count(*s), s.label()))
.collect();
if as_json {
json(serde_json::json!({
"pack": p.slug, "name": p.title(), "summary": p.summary(),
"counts": Status::ALL.iter().map(|s| (s.label(), p.count(*s))).collect::<std::collections::BTreeMap<_, _>>(),
"portable": p.portable, "ported_mods": p.mods.len(), "jars": p.jars(),
"report": p.work.join("coverage.md"),
}));
} else {
println!(
"{} ({})\n {}\n {}",
p.title(),
p.slug,
p.summary(),
counts.join(", ")
);
println!(" {} portable, {} carried over", p.portable, p.mods.len());
if let Some(jars) = p.jars() {
println!(" {jars}");
}
println!(" {}", p.work.join("coverage.md").display());
}
};
match action {
ModpackCmd::List => {
let packs = modpacks::list();
let registry = horizon::pack::list();
if packs.is_empty() && registry.is_empty() && !as_json {
println!("No modpack imported yet: horizon-launcher modpack import <pack>");
}
packs.iter().for_each(show);
for p in &registry {
if as_json {
json(
serde_json::json!({"pack": p.id, "name": p.name, "version": p.version, "source": "horizon", "mods": p.mods}),
);
} else {
println!(
"{} {} ({}, from Horizon's registry)\n {}",
p.name,
p.version,
p.id,
p.mods.join(", ")
);
}
}
}
ModpackCmd::Import { path } => show(&modpacks::import(&path, log)?),
ModpackCmd::Port {
pack,
from,
version,
} => {
let tag = backend::resolve_version(version.as_deref()).ok();
let resources = tag
.filter(|t| backend::is_prepared(t))
.map(|t| backend::resources(&t));
show(&modpacks::port(
&work(&pack)?,
resources.as_deref(),
from.as_deref(),
log,
)?)
}
ModpackCmd::Play { pack, version } => {
let mut cmd = backend::client(&backend::resolve_version(version.as_deref())?)?;
modpacks::apply_profile(&mut cmd, &work(&pack)?)?;
attached(cmd)?
}
ModpackCmd::Remove { pack } => modpacks::remove(&work(&pack)?)?,
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use clap::Parser;
#[test]
fn play_takes_extra_arguments_that_start_with_hyphens() {
let cli = Cli::try_parse_from([
"horizon-launcher",
"play",
"--arg",
"--server-thread",
"--arg",
"40",
])
.unwrap();
match cli.command {
Some(Cmd::Play { arg, .. }) => assert_eq!(arg, ["--server-thread", "40"]),
_ => panic!("expected play"),
}
}
#[test]
fn game_args_takes_one_line_that_starts_with_hyphens() {
let cli = Cli::try_parse_from([
"horizon-launcher",
"game-args",
"--server-thread --render-distance 40",
])
.unwrap();
match cli.command {
Some(Cmd::GameArgs { args }) => {
assert_eq!(
args.as_deref(),
Some("--server-thread --render-distance 40")
);
}
_ => panic!("expected game-args"),
}
}
#[test]
fn mods_commands_name_their_instance() {
let parse = |args: &[&str]| {
let cli = Cli::try_parse_from([&["horizon-launcher", "mods"], args].concat()).unwrap();
match cli.command {
Some(Cmd::Mods { action }) => action,
_ => panic!("expected mods"),
}
};
match parse(&["install", "fresh-animations", "--instance", "Skyblock"]) {
Some(ModsCmd::Install {
project, instance, ..
}) => assert_eq!(
(project.as_str(), instance.as_deref()),
("fresh-animations", Some("Skyblock"))
),
_ => panic!("expected mods install"),
}
assert!(matches!(
parse(&["list"]),
Some(ModsCmd::List { instance: None })
));
assert!(parse(&[]).is_none());
// Search and Check read no instance: checks are shared.
assert!(Cli::try_parse_from([
"horizon-launcher",
"mods",
"search",
"x",
"--instance",
"A"
])
.is_err());
}
}