Merge pull request #1429 from ludovic111/feat/launcher-single-channel

🤖 Agent: merged after verify and CI parity passed; release dry run 39935111815 was green (the smoke test drew a world, no blocker, it would publish as the release and latest). One channel, as Ludovic decided on 2026-10-23.
This commit is contained in:
Ludovic Marie
2026-10-23 17:11:04 +02:00
committed by GitHub
10 changed files with 230 additions and 289 deletions
+1 -2
View File
@@ -71,7 +71,6 @@ passes on without checking it).
| Dedicated server here: start, console, log, stop | Servers | yes | yes | yes | yes | `server`; MCP `server`, `server_command`, `server_log`, `server_stop` |
| Hosted servers: list, create, set up, run a command, forget | Servers | yes | no | yes | yes | `servers ...`; `servers_forget` needs `confirm` |
| Accounts: list, sign in, sign out, select, offline | Settings | yes | part | yes | yes | names and UUIDs only; sign-in is a device code; `account_offline` was missing |
| Update channel (Alpha, Stable) | Settings | yes | yes | yes | yes | |
| Game folder, server folder, install new versions, opening animation | Settings | no | no | yes | yes | `settings [KEY VALUE]` |
| Extra game arguments | Settings | yes | no | yes | yes | `game-args` |
| Applications menu entry (Linux) | Settings | yes | no | yes | yes | `desktop-entry` |
@@ -148,7 +147,7 @@ The switch is in three places: Settings > AI in the launcher, Horizon Settings i
| Companion (#1068) | uses the same switch (see horizon-parity companion-notes.md) |
Every other launcher command stays usable: versions, install, remove, prepare, play, server,
notes, links, account, update-channel, settings, game-args, logs, update, desktop-entry, data,
notes, links, account, settings, game-args, logs, update, desktop-entry, data,
modpack, mods, servers, no-ai and benchmark. None of them drives the game for an agent. The
launcher itself, packagers, the docs and players' scripts need them, and `no-ai` has to stay to
turn the switch off.
-10
View File
@@ -130,16 +130,6 @@ Play offline, without an account.
MCP: `account_offline`.
## `horizon-launcher update-channel`
Show or set which Horizon releases install by themselves: stable (a tested build about once a day) or alpha (every release as soon as it is built; can break).
horizon-launcher update-channel [CHANNEL]
- `CHANNEL` (stable, alpha): Omit to show the current channel
MCP: `update_channel`.
## `horizon-launcher settings`
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.
+16 -14
View File
@@ -78,16 +78,13 @@ page `servers.json` (the list), `servers/<name>/` (the servers created there) an
`server-runtime/` (the programs and game files they run).
- **Settings**: install new Horizon versions automatically (on unless you turn it off; the
selected version only moves to the new one if you were on the newest), which ones (Updates,
below), the opening animation, the game's extra command-line arguments, and the launcher's own
version and update state.
- **Updates**: **Stable** (the default) installs a tested build about once a day, the betas that
`promote.yml` makes stable; **Alpha** installs every release as soon as it is built, several
times a day, and can break (docs/release-flow.md, "Channels"). While it is open, the launcher
looks for new releases every 4 hours on Stable and every 30 minutes on Alpha. Kept as `update_channel` in
`settings.json`; a `beta_builds: true` from launchers before 0.2 reads as Alpha (so does a `nightly` from the channel's first name).
`horizon-launcher update-channel [stable|alpha]` shows or sets it. The **Versions** page
shows each release's channel. The launcher's own updates don't depend on it.
selected version only moves to the new one if you were on the newest), the opening animation,
the game's extra command-line arguments, and the launcher's own version and update state.
- **Updates**: there is one channel. Every release is published as the release, GitHub's latest,
once its smoke test passed (docs/release-flow.md), and the launcher installs it. The game
pre-releases of the old Alpha channel (v0.2.1 on) stay on the Versions page to install
by hand, but are never installed as an update. The `update_channel` and `beta_builds` keys
older launchers wrote in `settings.json` are ignored and dropped on the next save.
- **Game arguments**: extra arguments added to the game's command line (for example
`--server-thread`), one line where quotes group a word with spaces. They are appended after the
launcher's own arguments, kept as `game_args` in `settings.json`, and apply the next time the
@@ -102,7 +99,7 @@ their content overflows. Drag the thumb or click the track to navigate without a
## Updates
The launcher looks for a newer Horizon release when it starts and every four hours while it
The launcher looks for a newer Horizon release when it starts and every 30 minutes while it
is open, and shows a small "available, Install" line on Play.
It also updates itself from GitHub releases tagged `launcher@X.Y.Z` (Horizon's own are `vX.Y.Z`;
@@ -111,8 +108,14 @@ every 0.2 tag counts as newer than all of those (docs/versioning.md). It downloa
own binary, and offers "Restart" in the footer. Development builds and
`HORIZON_LAUNCHER_NO_SELF_UPDATE=1` never replace themselves.
On Linux a release build that starts writes its applications-menu entry only when there is
none, or when the program the entry starts (its `TryExec`, else its `Exec`) no longer exists.
An entry pointing at another launcher that works is left alone, so a test or development build
never takes it over. Turning the Settings switch on, or `horizon-launcher desktop-entry`,
points the entry at this launcher whatever is there.
Linux packagers can set `HORIZON_LAUNCHER_DESKTOP_EXEC` to a wrapper's absolute path.
Menu entries created by Settings or `desktop-entry` then start that wrapper, which can
Menu entries the launcher writes then start that wrapper, which can
set `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` to keep launcher updates with the package manager.
Launcher releases are automatic (docs/release-flow.md in the repository): when main changes the
@@ -134,7 +137,6 @@ The same binary is a command-line tool; without a subcommand it opens the window
horizon-launcher server [--dir <dir>] [--version <tag>] [--accept-eula]
horizon-launcher notes [<tag>] patch notes as plain text
horizon-launcher links the Discord, sponsor and website links
horizon-launcher update-channel [stable|alpha] show or set which releases install by themselves
horizon-launcher game-args [<line>] show or set the extra arguments the game starts with
horizon-launcher update [--check] Horizon and the launcher
horizon-launcher logs [--lines N] [--crash] the end of the game's log, or its newest crash report
@@ -168,7 +170,7 @@ The same binary is a command-line tool; without a subcommand it opens the window
horizon-launcher data benchmark <report.json> upload a benchmark report, printed first
`--json` prints JSON where there is something to report (`versions`, `install`, `notes`,
`next`, `links`, `update-channel`, `game-args`, `update --check`, `logs`, `account`, `benchmark`, `data`, `modpack`). Errors go to stderr with exit code 1. `server` runs in the terminal,
`next`, `links`, `game-args`, `update --check`, `logs`, `account`, `benchmark`, `data`, `modpack`). Errors go to stderr with exit code 1. `server` runs in the terminal,
so lines you type reach its console. `HORIZON_LAUNCHER_HOME` replaces the data folder (for
scripts and tests).
+59 -174
View File
@@ -37,8 +37,9 @@ pub struct Release {
pub body: String,
pub date: String,
pub asset: Option<(String, u64)>,
/// A beta: a game release not promoted to stable yet (a GitHub pre-release, docs/release-flow.md).
pub beta: bool,
/// A GitHub pre-release: the Alpha builds from before every release went out as the release
/// (v0.2.1 on, docs/release-flow.md). Listed and installed by hand, never as an update.
pub prerelease: bool,
}
#[cfg(all(target_os = "linux", target_arch = "x86_64"))]
@@ -264,7 +265,7 @@ fn parse_releases(
.take(10)
.collect(),
asset: found,
beta: r["prerelease"].as_bool().unwrap_or(false),
prerelease: r["prerelease"].as_bool().unwrap_or(false),
});
}
out.sort_by(|a, b| compare_versions(&b.tag, &a.tag));
@@ -348,75 +349,14 @@ pub fn latest(releases: &[Release]) -> Option<&Release> {
releases.iter().find(|r| r.asset.is_some())
}
/// The releases a launcher installs by itself: stable ones, and betas too on the Alpha channel.
pub fn channel(releases: &[Release], channel: UpdateChannel) -> Vec<Release> {
releases
.iter()
.filter(|r| channel.takes(r))
.cloned()
.collect()
/// The releases a launcher installs by itself: every one that is published as a release, so
/// GitHub's latest when it comes out. The pre-releases of the old Alpha channel are left out.
pub fn installable_updates(releases: &[Release]) -> Vec<Release> {
releases.iter().filter(|r| !r.prerelease).cloned().collect()
}
/// Which game releases install by themselves (Settings, "Updates"; docs/release-flow.md, "Channels").
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum UpdateChannel {
/// A tested build about once a day: the betas promote.yml makes stable.
#[default]
Stable,
/// Every release as soon as it is built, pre-releases included. It was called "nightly"
/// while the channels were new: that name is still read.
#[serde(alias = "nightly")]
Alpha,
}
impl UpdateChannel {
pub fn name(self) -> &'static str {
match self {
UpdateChannel::Stable => "stable",
UpdateChannel::Alpha => "alpha",
}
}
/// Its name in Settings and on the Versions page.
pub fn label(self) -> &'static str {
match self {
UpdateChannel::Stable => "Stable",
UpdateChannel::Alpha => "Alpha",
}
}
pub fn parse(name: &str) -> Option<Self> {
match name {
"stable" => Some(UpdateChannel::Stable),
"alpha" | "nightly" => Some(UpdateChannel::Alpha),
_ => None,
}
}
/// Whether this channel installs `release`: betas only reach Alpha.
pub fn takes(self, release: &Release) -> bool {
self == UpdateChannel::Alpha || !release.beta
}
/// How often a launcher left open looks for new releases: Alpha's come many times a day,
/// Stable's once.
pub fn check_every(self) -> std::time::Duration {
std::time::Duration::from_secs(match self {
UpdateChannel::Stable => 4 * 3600,
UpdateChannel::Alpha => 30 * 60,
})
}
/// The channel a release is on when it is listed: betas are Alpha's only.
pub fn of(release: &Release) -> Self {
if release.beta {
UpdateChannel::Alpha
} else {
UpdateChannel::Stable
}
}
}
/// How often a launcher left open looks for new releases: they come out several times a day.
pub const CHECK_EVERY: std::time::Duration = std::time::Duration::from_secs(30 * 60);
/// The community, sponsor and website links, from `launcher/links.json` on main, so they can change
/// without a launcher release. An empty address hides its button.
@@ -1745,17 +1685,10 @@ fn launcher_update_from(releases: &[Release], own: &str) -> Option<Release> {
pub fn releases_and_updates(
on_releases: impl FnOnce(Result<Vec<Release>, String>),
) -> Result<Updates, String> {
releases_and_updates_with(
Settings::load().update_channel,
release_list,
installed,
launcher_releases_in,
on_releases,
)
releases_and_updates_with(release_list, installed, launcher_releases_in, on_releases)
}
fn releases_and_updates_with(
update_channel: UpdateChannel,
load: impl FnOnce() -> Result<serde_json::Value, String>,
installed: impl FnOnce() -> Vec<String>,
launchers: impl FnOnce(&serde_json::Value) -> Vec<Release>,
@@ -1769,7 +1702,7 @@ fn releases_and_updates_with(
}
};
let releases = parse_releases(&list, ASSET, is_game_tag);
let horizon = horizon_update(&channel(&releases, update_channel), &installed());
let horizon = horizon_update(&installable_updates(&releases), &installed());
on_releases(Ok(releases));
Ok(Updates {
horizon,
@@ -1791,15 +1724,14 @@ pub fn select_after_update(selected: Option<&str>, installed_before: &[String])
}
}
/// Installs `tag` (or with "latest" the newest release of the player's channel), then updates the selection as
/// Installs `tag` (or with "latest" the newest release, pre-releases left out), then updates the selection as
/// `select_after_update` says when `as_update`, or always selects it otherwise.
pub fn install_tag(tag: &str, as_update: bool, progress: impl Fn(f32)) -> Result<String, String> {
let releases = releases()?;
let release = if tag == "latest" {
let update_channel = Settings::load().update_channel;
releases
.iter()
.find(|r| r.asset.is_some() && update_channel.takes(r))
.find(|r| r.asset.is_some() && !r.prerelease)
.ok_or("No release has a build for this platform yet.")?
} else {
releases
@@ -2262,10 +2194,6 @@ pub struct Settings {
/// default. Appended after the launcher's own arguments, so they can add to or override them.
#[serde(default, skip_serializing_if = "String::is_empty")]
pub game_args: String,
/// Which releases install by themselves: Stable by default. Launchers before 0.2 had a "Beta
/// builds" switch instead; [`Settings::parse`] reads its `beta_builds: true` as Alpha.
#[serde(default)]
pub update_channel: UpdateChannel,
/// Dark, Light, or the system's: the launcher's look. Dark by default.
#[serde(default)]
pub appearance: Appearance,
@@ -2284,20 +2212,7 @@ impl Settings {
return Self::default();
};
if let Some(fields) = value.as_object_mut() {
// The switch from before 0.2: on meant every release at once, the Alpha channel.
if fields.remove("beta_builds") == Some(serde_json::Value::Bool(true)) {
fields
.entry("update_channel")
.or_insert_with(|| UpdateChannel::Alpha.name().into());
}
// A channel this launcher doesn't know is Stable, not a reason to lose every setting.
if fields
.get("update_channel")
.is_some_and(|c| c.as_str().and_then(UpdateChannel::parse).is_none())
{
fields.remove("update_channel");
}
// The same for an appearance from a newer launcher.
// An appearance from a newer launcher is Dark, not a reason to lose every setting.
if fields
.get("appearance")
.is_some_and(|a| serde_json::from_value::<Appearance>(a.clone()).is_err())
@@ -2517,41 +2432,35 @@ mod tests {
assert_eq!(offered(&["v2026.10.15.1", "v2026.10.14"]), None);
}
/// Betas (GitHub pre-releases) install by themselves only on the Alpha channel; Stable waits
/// for promote.yml's daily promotion (docs/release-flow.md, "Channels").
/// Every release is published as the release, and launchers update to it. The pre-releases
/// of the old Alpha channel (v0.2.1 on) are only installed by hand: a launcher that
/// had one installed waits for the next release instead of going back.
#[test]
fn updates_follow_the_stable_channel_unless_alpha_is_picked() {
fn updates_follow_every_release_and_leave_the_old_alpha_ones_out() {
let asset = ASSET.unwrap_or("horizon-linux-x86_64.tar.gz");
let list = serde_json::json!([
{"tag_name": "v2026.10.19.02", "prerelease": true, "assets": [{"name": asset, "browser_download_url": "b", "size": 1}]},
{"tag_name": "v2026.10.19.01", "assets": [{"name": asset, "browser_download_url": "s", "size": 1}]},
{"tag_name": "v0.2.13", "assets": [{"name": asset, "browser_download_url": "n", "size": 1}]},
{"tag_name": "v0.2.12", "prerelease": true, "assets": [{"name": asset, "browser_download_url": "a", "size": 1}]},
{"tag_name": "v0.2.0", "assets": [{"name": asset, "browser_download_url": "s", "size": 1}]},
]);
let releases = parse_releases(&list, Some(asset), is_game_tag);
assert_eq!(
releases.iter().map(|r| r.beta).collect::<Vec<_>>(),
[true, false]
releases.iter().map(|r| r.prerelease).collect::<Vec<_>>(),
[false, true, false]
);
let offered = |alpha: bool, installed: &[&str]| {
let offered = |releases: &[Release], installed: &[&str]| {
let installed: Vec<String> = installed.iter().map(|t| t.to_string()).collect();
let on = if alpha {
UpdateChannel::Alpha
} else {
UpdateChannel::Stable
};
horizon_update(&channel(&releases, on), &installed).map(|r| r.tag)
horizon_update(&installable_updates(releases), &installed).map(|r| r.tag)
};
assert_eq!(offered(false, &[]), Some("v2026.10.19.01".into()));
assert_eq!(
offered(true, &["v2026.10.19.01"]),
Some("v2026.10.19.02".into())
);
assert_eq!(offered(false, &["v2026.10.19.01"]), None);
// A beta installed earlier is never "updated" to an older stable build.
assert_eq!(offered(false, &["v2026.10.19.02"]), None);
assert_eq!(
releases.iter().map(UpdateChannel::of).collect::<Vec<_>>(),
[UpdateChannel::Alpha, UpdateChannel::Stable]
);
assert_eq!(offered(&releases, &[]), Some("v0.2.13".into()));
assert_eq!(offered(&releases, &["v0.2.0"]), Some("v0.2.13".into()));
assert_eq!(offered(&releases, &["v0.2.12"]), Some("v0.2.13".into()));
assert_eq!(offered(&releases, &["v0.2.13"]), None);
// Before the first release of the single channel: the old Alpha one stays where it is.
let before = &releases[1..];
assert_eq!(offered(before, &["v0.2.0"]), None);
assert_eq!(offered(before, &["v0.2.12", "v0.2.0"]), None);
assert_eq!(CHECK_EVERY.as_secs(), 30 * 60);
}
#[test]
@@ -2573,48 +2482,20 @@ mod tests {
}
#[test]
fn the_update_channel_is_stored_by_name_and_the_old_beta_switch_reads_as_alpha() {
let read = |text: &str| Settings::parse(text).update_channel;
assert_eq!(read(""), UpdateChannel::Stable);
assert_eq!(read("{}"), UpdateChannel::Stable);
assert_eq!(
read(r#"{"update_channel": "stable"}"#),
UpdateChannel::Stable
);
assert_eq!(read(r#"{"update_channel": "alpha"}"#), UpdateChannel::Alpha);
// The channel's first name, from launchers built while it was called Nightly.
assert_eq!(
read(r#"{"update_channel": "nightly"}"#),
UpdateChannel::Alpha
);
assert_eq!(UpdateChannel::parse("nightly"), Some(UpdateChannel::Alpha));
// Launchers before 0.2: "Beta builds" on is Alpha, off is Stable.
assert_eq!(read(r#"{"beta_builds": true}"#), UpdateChannel::Alpha);
assert_eq!(read(r#"{"beta_builds": false}"#), UpdateChannel::Stable);
// Once a channel is picked, it wins over a switch left behind.
let both = r#"{"beta_builds": true, "update_channel": "stable"}"#;
assert_eq!(read(both), UpdateChannel::Stable);
// An unknown channel is Stable, and the rest of the settings survive it.
let odd =
Settings::parse(r#"{"update_channel": "beta", "game_args": "--x", "beta_builds": 1}"#);
assert_eq!(odd.update_channel, UpdateChannel::Stable);
assert_eq!(odd.game_args, "--x");
// Saved as a name, without the old switch.
let mut settings = Settings::parse(r#"{"selected": "v0.2.0", "beta_builds": true}"#);
let saved = serde_json::to_value(&settings).unwrap();
assert_eq!(saved["update_channel"], "alpha");
assert!(saved.get("beta_builds").is_none());
assert_eq!(saved["selected"], "v0.2.0");
settings.update_channel = UpdateChannel::Stable;
let text = serde_json::to_string(&settings).unwrap();
assert_eq!(read(&text), UpdateChannel::Stable);
for c in [UpdateChannel::Stable, UpdateChannel::Alpha] {
assert_eq!(UpdateChannel::parse(c.name()), Some(c));
fn the_old_update_channel_settings_are_dropped_and_the_rest_kept() {
for old in [
r#"{"update_channel": "alpha", "game_args": "--x", "selected": "v0.2.0"}"#,
r#"{"update_channel": "stable", "game_args": "--x", "selected": "v0.2.0"}"#,
r#"{"beta_builds": true, "game_args": "--x", "selected": "v0.2.0"}"#,
r#"{"beta_builds": false, "update_channel": "nightly", "game_args": "--x", "selected": "v0.2.0"}"#,
] {
let settings = Settings::parse(old);
assert_eq!(settings.game_args, "--x", "{old}");
assert_eq!(settings.selected.as_deref(), Some("v0.2.0"), "{old}");
let saved = serde_json::to_value(&settings).unwrap();
assert!(saved.get("update_channel").is_none(), "{old}");
assert!(saved.get("beta_builds").is_none(), "{old}");
}
// An open launcher looks again every 4 hours on Stable, every 30 minutes on Alpha.
let minutes = |c: UpdateChannel| c.check_every().as_secs() / 60;
assert_eq!(minutes(UpdateChannel::Stable), 240);
assert_eq!(minutes(UpdateChannel::Alpha), 30);
}
#[test]
@@ -2635,7 +2516,7 @@ mod tests {
body: String::new(),
date: String::new(),
asset: Some(("u".into(), 1)),
beta: false,
prerelease: false,
};
assert!(launcher_update(&[r(own_tag())]).is_none());
assert_eq!(launcher_version(&own_tag()), Some(VERSION));
@@ -2675,7 +2556,7 @@ mod tests {
body: String::new(),
date: String::new(),
asset: Some(("u".into(), 1)),
beta: false,
prerelease: false,
};
let mut list = vec![
r("launcher-v0.16.0"),
@@ -2744,10 +2625,14 @@ mod tests {
]);
let releases = parse_releases(&list, Some(asset), is_game_tag);
let installed = ["v2026.10.19.15".to_string(), "v2026.10.12".to_string()];
let offered = |on| horizon_update(&channel(&releases, on), &installed).map(|r| r.tag);
// A beta 0.2.0 reaches launchers on Alpha; Stable ones wait for its promotion.
assert_eq!(offered(UpdateChannel::Alpha), Some("v0.2.0".into()));
assert_eq!(offered(UpdateChannel::Stable), None);
// A pre-release 0.2.0 is not an update; once published as the release, it is one.
let offered = |releases: &[Release]| {
horizon_update(&installable_updates(releases), &installed).map(|r| r.tag)
};
assert_eq!(offered(&releases), None);
let mut released = releases.clone();
released[0].prerelease = false;
assert_eq!(offered(&released), Some("v0.2.0".into()));
let mut sorted = vec![
"v2026.10.19.15".to_string(),
"v0.2.1".into(),
@@ -2837,7 +2722,7 @@ mod tests {
body: String::new(),
date: String::new(),
asset: Some(("u".into(), 1)),
beta: false,
prerelease: false,
};
let releases = [r("v2026.10.13"), r("v2026.10.12")];
assert_eq!(
@@ -45,7 +45,6 @@ fn baseline(load: impl Fn() -> Result<serde_json::Value, String>) -> (Vec<Releas
fn shared(load: impl FnOnce() -> Result<serde_json::Value, String>) -> (Vec<Release>, Updates) {
let mut releases = None;
let updates = releases_and_updates_with(
UpdateChannel::Stable,
load,
installed_fixture,
|list| parse_releases(list, LAUNCHER_ASSET, is_launcher_tag),
@@ -82,7 +81,6 @@ fn errors_reach_releases_and_updates_without_fallback() {
] {
let mut published = None;
let result = releases_and_updates_with(
UpdateChannel::Stable,
|| Err(error.into()),
|| panic!("no installed scan after failure"),
|_| panic!("no fallback after failure"),
@@ -97,7 +95,6 @@ fn errors_reach_releases_and_updates_without_fallback() {
fn publish_games_before_older_launcher_fallback() {
let events = RefCell::new(Vec::new());
let result = releases_and_updates_with(
UpdateChannel::Stable,
|| Ok(serde_json::json!([{"tag_name": "v2026.10.14", "assets": []}])),
Vec::new,
|list| {
@@ -132,7 +129,6 @@ fn failed_launcher_fallback_keeps_game_result_and_checks_stay_fresh() {
for day in [14, 15] {
let mut published = None;
let updates = releases_and_updates_with(
UpdateChannel::Stable,
|| {
requests.fetch_add(1, Ordering::Relaxed);
Ok(serde_json::json!([{"tag_name": format!("v2026.10.{day}")}]))
+2 -24
View File
@@ -287,13 +287,6 @@ enum Cmd {
#[command(subcommand)]
action: Option<AccountCmd>,
},
/// Show or set which Horizon releases install by themselves: stable (a tested build about once
/// a day) or alpha (every release as soon as it is built; can break)
UpdateChannel {
/// Omit to show the current channel
#[arg(value_parser = ["stable", "alpha"])]
channel: Option<String>,
},
/// 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
@@ -435,7 +428,6 @@ fn settings_json(s: &backend::Settings) -> serde_json::Value {
"server_dir": backend::server_dir(None),
"install_new_versions": s.install_new_versions.unwrap_or(true),
"opening_animation": !s.skip_opening,
"update_channel": s.update_channel.name(),
"game_args": s.game_args,
"desktop_entry": s.desktop_entry.unwrap_or(true),
"no_ai": backend::no_ai(),
@@ -504,7 +496,7 @@ fn attached(mut cmd: Command) -> Result<(), String> {
fn release_json(r: &Release) -> serde_json::Value {
serde_json::json!({
"tag": r.tag, "name": r.name, "date": r.date, "channel": backend::UpdateChannel::of(r).name(),
"tag": r.tag, "name": r.name, "date": r.date, "prerelease": r.prerelease,
"available_here": r.asset.is_some(), "installed": backend::installed().contains(&r.tag),
})
}
@@ -555,8 +547,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
(false, true) => "",
(false, false) => "no build for this platform",
};
let channel = backend::UpdateChannel::of(r).name();
println!("{:<15} {} {:<7} {}", r.tag, r.date, channel, state);
println!("{:<15} {} {}", r.tag, r.date, state);
}
}
Cmd::Install { tag } => {
@@ -733,19 +724,6 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
}
}
}
Cmd::UpdateChannel { channel } => {
let mut settings = backend::Settings::load();
if let Some(channel) = channel.as_deref().and_then(backend::UpdateChannel::parse) {
settings.update_channel = channel;
settings.save();
}
let channel = settings.update_channel.name();
if as_json {
json(serde_json::json!({ "update_channel": channel }));
} else {
println!("Update channel: {channel}");
}
}
Cmd::GameArgs { args } => {
let mut settings = backend::Settings::load();
if let Some(line) = args {
-1
View File
@@ -366,7 +366,6 @@ mod tests {
"prepare",
"notes",
"update",
"update_channel",
"game_args",
"settings",
"logs",
+138 -9
View File
@@ -2,8 +2,12 @@
//! `applications/horizon-launcher.desktop` (pointing at wherever the binary is now) and Horizon's
//! icon into the `hicolor` theme, under `$XDG_DATA_HOME` (`~/.local/share` by default), so no root
//! is needed; `horizon.desktop` (hidden from menus) gives the game's window its icon on Wayland.
//! A release build does this when it starts, and again whenever the binary has moved; the
//! Settings switch and `horizon-launcher desktop-entry --remove` take it all away again.
//! A release build writes it when it starts only if there is no entry yet or the one there starts
//! a program that is gone ([`repair`]), so a development or test build never takes over a working
//! entry. Turning the Settings switch on (or `horizon-launcher desktop-entry`) points it at this
//! binary whatever is there ([`install`]); the switch off and `desktop-entry --remove` take it all
//! away again.
use std::ffi::OsStr;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
@@ -153,15 +157,85 @@ pub fn remove_in(data: &Path) -> io::Result<()> {
Ok(())
}
/// Registers the launcher, using a distributor's wrapper when one is configured.
/// Both GUI registration (including the settings switch) and the CLI use this path.
/// The program an entry starts: its `TryExec`, else the first word of its `Exec` (unquoted as
/// [`quote`] writes it). None when the entry names neither.
fn entry_target(entry: &str) -> Option<String> {
let mut in_main = false;
let (mut exec, mut try_exec) = (None, None);
for line in entry.lines().map(str::trim) {
if line.starts_with('[') {
in_main = line == "[Desktop Entry]";
} else if let Some((key, value)) = line.split_once('=').filter(|_| in_main) {
match key.trim() {
"TryExec" if try_exec.is_none() => try_exec = Some(value.trim()),
"Exec" if exec.is_none() => exec = Some(value.trim()),
_ => {}
}
}
}
if let Some(program) = try_exec.filter(|p| !p.is_empty()) {
return Some(program.to_string());
}
let exec = exec?;
let program = match exec.strip_prefix('"') {
Some(rest) => {
let (mut out, mut chars) = (String::new(), rest.chars());
while let Some(c) = chars.next() {
match c {
'"' => break,
'\\' => out.extend(chars.next()),
c => out.push(c),
}
}
out
}
None => exec.split_whitespace().next()?.to_string(),
};
(!program.is_empty()).then_some(program)
}
/// Whether an entry's program is there: a path that exists, or a bare name found on `path`
/// (`$PATH`), as menus look `TryExec` up.
fn target_exists(program: &str, path: Option<&OsStr>) -> bool {
if program.contains('/') {
return Path::new(program).exists();
}
path.is_some_and(|dirs| std::env::split_paths(dirs).any(|dir| dir.join(program).is_file()))
}
/// Whether the launcher may write its entry by itself: there is none under `data`, or the one
/// there starts a program that no longer exists. An entry pointing at another launcher that
/// still works is left alone.
pub fn needs_repair_in(data: &Path, path: Option<&OsStr>) -> bool {
match fs::read_to_string(data.join("applications").join(LAUNCHER_ENTRY)) {
Ok(entry) => !entry_target(&entry).is_some_and(|p| target_exists(&p, path)),
Err(e) => e.kind() == io::ErrorKind::NotFound,
}
}
/// What the entry starts: a distributor's wrapper (`HORIZON_LAUNCHER_DESKTOP_EXEC`) when one is
/// configured, else the binary at `exe`.
fn target(exe: &Path) -> PathBuf {
std::env::var_os("HORIZON_LAUNCHER_DESKTOP_EXEC")
.filter(|path| !path.is_empty())
.map_or_else(|| exe.to_path_buf(), PathBuf::from)
}
/// Registers the launcher whatever entry is there: for the player turning it on (the Settings
/// switch, `horizon-launcher desktop-entry`).
pub fn install(exe: &Path) -> Result<bool, String> {
let data = data_home().ok_or("No home folder to put the menu entry in.")?;
let wrapper = std::env::var_os("HORIZON_LAUNCHER_DESKTOP_EXEC")
.filter(|path| !path.is_empty())
.map(PathBuf::from);
install_in(&data, wrapper.as_deref().unwrap_or(exe))
.map_err(|e| format!("{}: {e}", data.display()))
install_in(&data, &target(exe)).map_err(|e| format!("{}: {e}", data.display()))
}
/// At start: registers the launcher only when [`needs_repair_in`] says so. Returns whether it
/// wrote anything.
pub fn repair(exe: &Path) -> Result<bool, String> {
let data = data_home().ok_or("No home folder to put the menu entry in.")?;
if !needs_repair_in(&data, std::env::var_os("PATH").as_deref()) {
return Ok(false);
}
install_in(&data, &target(exe)).map_err(|e| format!("{}: {e}", data.display()))
}
pub fn remove() -> Result<(), String> {
@@ -206,4 +280,59 @@ mod tests {
remove_in(&data).unwrap();
let _ = fs::remove_dir_all(&data);
}
#[test]
fn the_target_is_try_exec_else_the_first_word_of_exec() {
let ours = launcher_entry(Path::new("/opt/a b/horizon \"x\"/horizon-launcher"));
assert_eq!(
entry_target(&ours).as_deref(),
Some("/opt/a b/horizon \"x\"/horizon-launcher")
);
let without_try = ours.replace("TryExec=", "X-Old=");
assert_eq!(
entry_target(&without_try).as_deref(),
Some("/opt/a b/horizon \"x\"/horizon-launcher")
);
let wrapper = "[Desktop Entry]\nExec=flatpak run dev.horizon.Launcher %U\n";
assert_eq!(entry_target(wrapper).as_deref(), Some("flatpak"));
// Only the main group counts: an action's Exec is not the launcher.
let action = "[Desktop Action play]\nExec=/a\n[Desktop Entry]\nExec=/b --x\n";
assert_eq!(entry_target(action).as_deref(), Some("/b"));
assert_eq!(entry_target("[Desktop Entry]\nName=Horizon\n"), None);
assert_eq!(entry_target("[Desktop Entry]\nExec=\nTryExec=\n"), None);
}
/// A build that starts never takes over an entry that works (a test or development build
/// started on a player's machine, 2026-10-23); it writes one only when there is none or the
/// program it starts is gone.
#[test]
fn a_start_writes_the_entry_only_when_none_works() {
let root =
std::env::temp_dir().join(format!("horizon-desktop-repair-{}", std::process::id()));
let _ = fs::remove_dir_all(&root);
let (data, bin) = (root.join("data"), root.join("bin"));
fs::create_dir_all(&bin).unwrap();
let installed = bin.join("horizon-launcher");
fs::write(&installed, b"").unwrap();
let entry = data.join("applications").join(LAUNCHER_ENTRY);
let path = Some(bin.as_os_str());
// No entry: write one.
assert!(needs_repair_in(&data, path));
install_in(&data, &installed).unwrap();
// Ours works: a build elsewhere leaves it alone.
assert!(!needs_repair_in(&data, path));
// So does one another launcher wrote, found on PATH or by its path.
fs::write(&entry, "[Desktop Entry]\nExec=horizon-launcher %U\n").unwrap();
assert!(!needs_repair_in(&data, path));
assert!(needs_repair_in(&data, None));
// The program is gone (a deleted target/ folder, a moved binary): write it again.
install_in(&data, &installed).unwrap();
fs::remove_file(&installed).unwrap();
assert!(needs_repair_in(&data, path));
// An entry that starts nothing is broken too.
fs::write(&entry, "[Desktop Entry]\nName=Horizon\n").unwrap();
assert!(needs_repair_in(&data, path));
let _ = fs::remove_dir_all(&root);
}
}
+13 -50
View File
@@ -238,15 +238,16 @@ impl Launcher {
if settings.minecraft_dir.is_none() {
settings.minecraft_dir = backend::default_minecraft_dir();
}
// Release builds on Linux keep their entry in the applications menu up to date (a moved
// binary changes it); `HORIZON_LAUNCHER_DESKTOP_ENTRY=1` does it in a development build.
// Release builds on Linux put their entry back in the applications menu when there is
// none or it starts a program that is gone (a moved or deleted binary), never over one
// that works; `HORIZON_LAUNCHER_DESKTOP_ENTRY=1` does it in a development build.
if cfg!(target_os = "linux")
&& settings.desktop_entry()
&& (!cfg!(debug_assertions)
|| std::env::var_os("HORIZON_LAUNCHER_DESKTOP_ENTRY").is_some())
{
std::thread::spawn(|| {
let _ = horizon_launcher::desktop::install(backend::exe_path());
let _ = horizon_launcher::desktop::repair(backend::exe_path());
});
}
let installed = backend::installed();
@@ -658,8 +659,10 @@ impl Launcher {
changed = true;
}
}
let every = self.settings.update_channel.check_every();
if self.checked.is_some_and(|at| at.elapsed() > every) {
if self
.checked
.is_some_and(|at| at.elapsed() > backend::CHECK_EVERY)
{
self.check_updates();
}
if changed {
@@ -1698,14 +1701,10 @@ impl Launcher {
));
}
foot = foot.child(
caps(format!(
"Launcher {} · {}",
backend::VERSION,
self.settings.update_channel.label()
))
.px(px(8.))
.pt(px(6.))
.text_color(t.muted),
caps(format!("Launcher {}", backend::VERSION))
.px(px(8.))
.pt(px(6.))
.text_color(t.muted),
);
div()
.id("sidebar")
@@ -2339,25 +2338,6 @@ impl Launcher {
cx.notify();
}),
);
use backend::UpdateChannel::{Alpha, Stable};
let this = cx.entity().downgrade();
let update_channel = segments(
"update-channel",
&[(Stable, Stable.label()), (Alpha, Alpha.label())],
self.settings.update_channel,
&t,
move |picked, _, cx| {
let _ = this.update(cx, |this, cx| {
if this.settings.update_channel != picked {
this.settings.update_channel = picked;
this.settings.save();
// What counts as new changed: check again (and install it if that is on).
this.check_updates();
}
cx.notify();
});
},
);
let opening = switch("opening", !self.settings.skip_opening, &t).on_click(cx.listener(
|this, _: &ClickEvent, _, cx| {
this.settings.skip_opening = !this.settings.skip_opening;
@@ -2487,22 +2467,6 @@ impl Launcher {
Some(toggle.into_any_element()),
&t,
))
.child(index_row(
n + 2,
"Updates",
Some(
div()
.flex()
.flex_col()
.child("Stable: a tested build about once a day.")
.child(
"Alpha: every change as soon as it is built, several times a day; can break.",
)
.into_any_element(),
),
Some(update_channel.into_any_element()),
&t,
))
.child(group("Launcher", "monitor"))
.child(index_row(
n + 3,
@@ -2955,8 +2919,7 @@ impl Launcher {
let tag = release.tag.clone();
let installed = self.installed.contains(&tag);
let selected = self.selected() == Some(&tag);
let channel = backend::UpdateChannel::of(&release).label();
let mut meta = vec![channel.to_string(), release.date.clone()];
let mut meta = vec![release.date.clone()];
if let Some((_, size)) = release.asset {
meta.push(megabytes(size));
}
+1 -1
View File
@@ -9,7 +9,7 @@ Everything you can do with the mouse and keyboard, through commands instead of c
- **In the launcher:**
- install, remove and prepare versions;
- start the game, alone or with a world, or a server;
- your settings, the update channel and the extra game arguments;
- your settings and the extra game arguments;
- the mod browser (mods, resource packs, shader packs, modpacks), imported modpacks and hosted servers;
- your accounts (names only), logs and crash reports, patch notes, the data collection settings and the benchmark.
- **In the game:**