7115c708e1
Home's Instance row gets Launch...: a shell command run in the instance's folder before the game (which starts only if it succeeds), a wrapper the game runs through, and environment variables, kept in instances.json. The game stays one process: /bin/sh runs the command and execs the wrapper and game through "$@" on Unix, cmd /C on Windows. The window's Play and `play` both use them. CLI and MCP: instance launch (confirm needed over MCP). The Instance row's actions move under its name, and editing an instance that shares its name with an import works again. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2457 lines
90 KiB
Rust
2457 lines
90 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>,
|
|
},
|
|
/// Show or set what runs around an instance's game: a shell command before it (the game
|
|
/// starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment
|
|
/// variables ("NAME=value NAME2=value"). An empty value clears one
|
|
Launch {
|
|
instance: String,
|
|
#[arg(long)]
|
|
pre_launch: Option<String>,
|
|
#[arg(long)]
|
|
wrapper: Option<String>,
|
|
#[arg(long)]
|
|
env: Option<String>,
|
|
},
|
|
/// Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop
|
|
/// file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows
|
|
Shortcut {
|
|
/// The instance (default: the selected one)
|
|
instance: Option<String>,
|
|
/// Move the instance's shortcuts to the trash instead
|
|
#[arg(long)]
|
|
remove: bool,
|
|
},
|
|
/// 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),
|
|
/// while-playing stay|minimize|hide (what the window does while the game runs)
|
|
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>,
|
|
},
|
|
/// Upload an instance's latest.log to mclo.gs (a paste service for Minecraft logs) and print
|
|
/// its link, for a bug report: only when the player asks. The home folder, the user name and
|
|
/// the account names are taken out first; the link expires after 90 days unread
|
|
ShareLog {
|
|
/// The instance (default: the selected one)
|
|
#[arg(long)]
|
|
instance: Option<String>,
|
|
},
|
|
/// Delete a log shared with share-log: the "<id>:<token>" it printed
|
|
UnshareLog { shared: 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; 7] = [
|
|
"selected-version",
|
|
"minecraft-dir",
|
|
"server-dir",
|
|
"install-new-versions",
|
|
"opening-animation",
|
|
"proxy",
|
|
"while-playing",
|
|
];
|
|
|
|
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)?,
|
|
"while-playing" => {
|
|
s.while_playing = backend::WhilePlaying::parse(value)
|
|
.ok_or_else(|| format!("{value}: say stay, minimize or hide"))?
|
|
}
|
|
"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),
|
|
"while_playing": s.while_playing.name(),
|
|
"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(horizon_launcher::launch::wrap(cmd, &instance.launch));
|
|
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::ShareLog { instance } => {
|
|
use horizon_launcher::game_log;
|
|
let i = match instance {
|
|
Some(name) => instances::find(&name)?,
|
|
None => instances::selected(),
|
|
};
|
|
let path = i.home.join("logs/latest.log");
|
|
let text =
|
|
std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?;
|
|
let names = game_log::names(&[&i.home, &backend::game_home()]);
|
|
let text = game_log::private(&text, dirs::home_dir().as_deref(), &names);
|
|
let shared = game_log::share(&text)?;
|
|
if as_json {
|
|
json(serde_json::json!({
|
|
"url": shared.url, "delete": format!("{}:{}", shared.id, shared.token),
|
|
}));
|
|
} else {
|
|
println!("{}", shared.url);
|
|
println!(
|
|
"Delete it: horizon-launcher unshare-log {}:{}",
|
|
shared.id, shared.token
|
|
);
|
|
}
|
|
}
|
|
Cmd::UnshareLog { shared } => {
|
|
let (id, token) = shared
|
|
.split_once(':')
|
|
.ok_or("Give the \"<id>:<token>\" share-log printed.")?;
|
|
horizon_launcher::game_log::unshare(&horizon_launcher::game_log::Shared {
|
|
url: String::new(),
|
|
id: id.into(),
|
|
token: token.into(),
|
|
})?;
|
|
println!("Deleted the shared log {id}.");
|
|
}
|
|
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::Launch {
|
|
instance,
|
|
pre_launch,
|
|
wrapper,
|
|
env,
|
|
} => {
|
|
use horizon_launcher::launch;
|
|
let env = env.as_deref().map(launch::parse_env).transpose()?;
|
|
let changing = pre_launch.is_some() || wrapper.is_some() || env.is_some();
|
|
let i = match changing {
|
|
false => instances::find(&instance)?,
|
|
true => instances::edit(&instance, |m| {
|
|
if let Some(p) = pre_launch {
|
|
m.launch.pre_launch = p.trim().to_string();
|
|
}
|
|
if let Some(w) = wrapper {
|
|
m.launch.wrapper = w.trim().to_string();
|
|
}
|
|
if let Some(e) = env {
|
|
m.launch.env = e;
|
|
}
|
|
})?,
|
|
};
|
|
let l = &i.launch;
|
|
if as_json {
|
|
json(serde_json::json!({
|
|
"instance": i.id, "pre_launch": l.pre_launch, "wrapper": l.wrapper, "env": l.env,
|
|
}));
|
|
} else {
|
|
println!(
|
|
"{}: {}",
|
|
i.name,
|
|
l.summary().unwrap_or("nothing around the game".into())
|
|
);
|
|
println!(" pre-launch: {}", l.pre_launch);
|
|
println!(" wrapper: {}", l.wrapper);
|
|
println!(" env: {}", launch::env_line(&l.env));
|
|
}
|
|
}
|
|
InstanceCmd::Shortcut { instance, remove } => {
|
|
use horizon_launcher::shortcut;
|
|
let i = match instance {
|
|
Some(name) => instances::find(&name)?,
|
|
None => instances::selected(),
|
|
};
|
|
let paths = match remove {
|
|
false => shortcut::make(backend::exe_path(), &i.id, &i.name)?,
|
|
true => shortcut::remove(&i.id)?,
|
|
};
|
|
if as_json {
|
|
json(serde_json::json!({ "instance": i.id, "paths": paths }));
|
|
} else if remove && paths.is_empty() {
|
|
println!("{} has no shortcut.", i.name);
|
|
} else {
|
|
let did = if remove { "Moved to the trash" } else { "Made" };
|
|
for path in paths {
|
|
println!("{did}: {}", path.display());
|
|
}
|
|
}
|
|
}
|
|
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(©)),
|
|
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(®istry) {
|
|
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 ®istry {
|
|
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());
|
|
}
|
|
}
|