refactor: relaunch updates via the update --state sub-command

Adopt update-rs 0.4's customizable launcher to restore Git-Tool's original
relaunch convention: a `GitToolLauncher` (overriding `resume_args`) relaunches
the binary as `gt update --state <json>` rather than with the library's default
`--update-resume-internal` flag. This keeps resume handling in the `update`
command (parsed by clap, and unit-testable) instead of an argv pre-scan in
`main`.

- Cargo.toml: update-rs 0.3 -> 0.4.
- src/update.rs: install `GitToolLauncher` on the manager.
- commands/update.rs: re-add the hidden `--state` arg; `run` resumes from it via
  `resume_from_arg`. Add a (network-free) test that resume failures bubble up
  without being reported to Sentry by the command.
- main.rs: drop the argv pre-scan; keep `--update-resume-internal` as a tolerated
  hidden global so clap still accepts the relaunch emitted by currently-installed
  releases (which pass `--update-resume-internal <s> --trace-context <c>
  update --state <s>`) — the `update --state` sub-command drives the resume.

The trace context still rides inside the serialized state (update-rs's
`opentelemetry` feature), so the relaunch needs no `--trace-context` argument.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: notheotherben

Cargo.lock

@@ -50,7 +50,7 @@ tracing-batteries = { git = "https://github.com/sierrasoftworks/tracing-batterie
 # Self-update machinery (extracted from this project). The `opentelemetry`
 # feature emits tracing spans for the update and propagates the trace context
 # across the three relaunch phases via the update state.
-update-rs = { version = "0.3", features = ["opentelemetry"] }
+update-rs = { version = "0.4", features = ["opentelemetry"] }
 dirs = "6.0.0"
 shellexpand = "3"
 

Cargo.toml

@@ -16,6 +16,11 @@ impl CommandRunnable for UpdateCommand {
             .version("1.0")
             .about("updates Git-Tool automatically by fetching the latest release from GitHub")
             .long_about("Allows you to update Git-Tool to the latest version, or a specific version, automatically.")
+            .arg(Arg::new("state")
+                .long("state")
+                .help("Serialized state used to resume an in-progress update. Set automatically when the updater relaunches Git-Tool between phases.")
+                .hide(true)
+                .action(clap::ArgAction::Set))
             .arg(Arg::new("list")
                 .long("list")
                 .help("Prints the list of available releases.")
@@ -31,13 +36,24 @@ impl CommandRunnable for UpdateCommand {
 
     #[tracing::instrument(name = "gt update", err, skip(self, core, matches))]
     async fn run(&self, core: &Core, matches: &ArgMatches) -> Result<i32, engine::Error> {
+        let manager = crate::update::manager();
+
+        // When the updater relaunches us between phases it invokes
+        // `gt update --state <json>`; hand that straight back to the updater to
+        // continue the in-progress update (the state also carries the trace
+        // context, so the phases stay on one distributed trace).
+        if let Some(state) = matches.get_one::<String>("state") {
+            info!("Resuming an in-progress update.");
+            manager.resume_from_arg(state).await?;
+            return Ok(0);
+        }
+
         let current_version: semver::Version = version!().parse().map_err(|err| human_errors::wrap_system(
                 err,
                 "Could not parse the current application version into a SemVer version number.",
                 &["Please report this issue to us on GitHub and try updating manually by downloading the latest release from GitHub once the problem is resolved."],
             ))?;
 
-        let manager = crate::update::manager();
         let releases = manager.get_releases().await?;
 
         if matches.get_flag("list") {
@@ -155,6 +171,8 @@ fn format_release_list(releases: &[Release], current_version: &semver::Version)
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::console::MockConsoleProvider;
+    use std::sync::Arc;
 
     fn release(id: &str, version: &str, prerelease: bool, supported: bool) -> Release {
         Release {
@@ -194,4 +212,40 @@ mod tests {
             "an available pre-release is left unmarked and labelled"
         );
     }
+
+    #[test]
+    fn run_resume_bubbles_up_failures_without_reporting() {
+        // `gt update --state <json>` resumes an in-progress update. The command
+        // shouldn't report resume failures to Sentry itself; it bubbles them up so
+        // `main` decides what to record (only system-caused errors are). Resuming
+        // a cleanup phase with no temporary application path is a system error we
+        // can trigger without any network access.
+        let events = sentry::test::with_captured_events(|| {
+            let rt = tokio::runtime::Builder::new_current_thread()
+                .build()
+                .expect("we should be able to build a Tokio runtime");
+
+            rt.block_on(async {
+                let console = Arc::new(MockConsoleProvider::new());
+                let core = Core::builder()
+                    .with_default_config()
+                    .with_console(console.clone())
+                    .build();
+
+                let cmd = UpdateCommand {};
+                let args =
+                    cmd.app()
+                        .get_matches_from(vec!["update", "--state", r#"{"phase":"cleanup"}"#]);
+
+                cmd.run(&core, &args)
+                    .await
+                    .expect_err("resuming a cleanup phase without a temporary path should fail");
+            });
+        });
+
+        assert!(
+            events.is_empty(),
+            "the update command should not report resume failures to Sentry directly"
+        );
+    }
 }

src/commands/update.rs

@@ -82,6 +82,11 @@ fn build_app() -> clap::Command {
                 .value_name("FILE")
                 .help("The path to your git-tool configuration file.")
                 .action(clap::ArgAction::Set))
+            .arg(Arg::new("update-resume-internal")
+                .long("update-resume-internal")
+                .help("A legacy flag emitted by older Git-Tool releases when coordinating an update. Tolerated (and ignored) so an update started by an older release can hand off to this one via the `update --state` sub-command it also passes.")
+                .action(clap::ArgAction::Set)
+                .hide(true))
             .arg(Arg::new("trace")
                 .long("trace")
                 .global(true)
@@ -95,20 +100,6 @@ fn build_app() -> clap::Command {
 
 #[tracing::instrument(err, skip(app, session), fields(otel.name=EmptyField, command=EmptyField, exit_code=EmptyField, otel.status_code=0, exception=EmptyField))]
 async fn host(app: clap::Command, session: &TelemetrySession) -> Result<i32, human_errors::Error> {
-    // If a previous update phase relaunched us with the resume flag, hand control
-    // straight to the updater before any argument parsing. The relaunch may carry
-    // trailing arguments (from older Git-Tool versions, which also appended an
-    // `update --state` sub-command) that clap would otherwise reject, and the
-    // serialized state continues the update's distributed trace.
-    let raw_args: Vec<String> = std::env::args().collect();
-    if let Some(idx) = raw_args.iter().position(|a| a == update::RESUME_FLAG)
-        && let Some(state) = raw_args.get(idx + 1)
-    {
-        info!("Detected an in-progress update relaunch; resuming the update.");
-        update::manager().resume_from_arg(state).await?;
-        return Ok(0);
-    }
-
     let matches = match app.clone().try_get_matches() {
         Ok(matches) => {
             if let Some(context) = matches.get_one::<String>("trace-context") {

src/main.rs

@@ -1,22 +1,41 @@
 //! Self-update support, built on the [`update-rs`](https://docs.rs/update-rs)
 //! crate (which was extracted from this project).
 //!
-//! This module just configures the updater for Git-Tool's GitHub releases and
-//! re-exports the handful of types the rest of the application needs; all of the
-//! three-phase download/replace/relaunch machinery lives in the crate.
+//! This module configures the updater for Git-Tool's GitHub releases and its
+//! relaunch convention, then re-exports the handful of types the rest of the
+//! application needs; all of the three-phase download/replace/relaunch machinery
+//! lives in the crate.
 
-pub use update_rs::{RESUME_FLAG, Release};
+pub use update_rs::Release;
 
-use update_rs::{GitHubSource, UpdateManager, naming};
+use std::ffi::OsString;
+use update_rs::{GitHubSource, Launcher, UpdateManager, naming};
 
 /// The GitHub repository Git-Tool's releases are published to.
 const REPO: &str = "SierraSoftworks/git-tool";
 
+/// Relaunches Git-Tool between update phases via its `update --state <json>`
+/// sub-command — the convention Git-Tool has used since its Go implementation.
+///
+/// Keeping it means an update started by an older installed release (which
+/// relaunches the new binary with `update --state <json>`) hands off cleanly to
+/// this one. The active trace context is carried inside the state itself (via
+/// update-rs's `opentelemetry` feature), so no extra arguments are needed.
+struct GitToolLauncher;
+
+impl Launcher for GitToolLauncher {
+    fn resume_args(&self, state_json: &str) -> Vec<OsString> {
+        vec!["update".into(), "--state".into(), state_json.into()]
+    }
+}
+
 /// Build an [`UpdateManager`] configured for Git-Tool's releases.
 ///
 /// It downloads the Go-style `git-tool-<os>-<arch>[.exe]` asset for the current
 /// platform (matching the names produced by `.github/workflows/release.yml`)
-/// from the project's GitHub releases, whose tags are `vX.Y.Z`.
+/// from the project's GitHub releases, whose tags are `vX.Y.Z`, and relaunches
+/// through the `update --state` sub-command.
 pub fn manager() -> UpdateManager<GitHubSource> {
     UpdateManager::new(GitHubSource::new(REPO, naming::go("git-tool")).with_release_tag_prefix("v"))
+        .with_launcher(Box::new(GitToolLauncher))
 }