mi6_cli/commands/

upgrade.rs

//! Self-upgrade command for mi6.
//!
//! Detects installation method and uses the appropriate upgrade strategy:
//! - Homebrew: `brew upgrade mi6`
//! - Cargo: `cargo install mi6`
//! - Standalone: Uses `self_update` crate to download from GitHub releases

use std::process::Command;

use anyhow::{Context, Result};

use crate::display::confirm_stdout;

/// How mi6 was installed
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InstallMethod {
    /// Installed via Homebrew
    Homebrew,
    /// Installed via `cargo install`
    Cargo,
    /// Standalone binary (e.g., downloaded from GitHub releases)
    Standalone,
}

impl InstallMethod {
    /// Detect the installation method based on the executable path
    pub fn detect() -> Result<Self> {
        let exe_path = std::env::current_exe().context("failed to get current executable path")?;
        let path_str = exe_path.to_string_lossy();

        if path_str.contains("/Cellar/") || path_str.contains("/homebrew/") {
            Ok(Self::Homebrew)
        } else if path_str.contains("/.cargo/bin/") {
            Ok(Self::Cargo)
        } else {
            Ok(Self::Standalone)
        }
    }

    /// Get a human-readable name for the install method
    pub const fn name(self) -> &'static str {
        match self {
            Self::Homebrew => "Homebrew",
            Self::Cargo => "Cargo",
            Self::Standalone => "Standalone",
        }
    }
}

/// Options for the upgrade command
pub struct UpgradeOptions {
    /// Target version (only for Cargo installs)
    pub version: Option<String>,
    /// Skip confirmation prompt
    pub yes: bool,
    /// Check for updates without installing
    pub dry_run: bool,
}

/// Run the upgrade command
pub fn run_upgrade(options: UpgradeOptions) -> Result<()> {
    let current_version = env!("CARGO_PKG_VERSION");
    let method = InstallMethod::detect()?;

    println!("mi6 v{}", current_version);
    println!("Detected: {} install", method.name());
    println!();

    // Warn if --version is used with non-Cargo install methods
    if options.version.is_some() && method != InstallMethod::Cargo {
        println!(
            "Warning: --version is only supported for Cargo installs (ignored for {})",
            method.name()
        );
        println!();
    }

    // Handle dry-run mode
    if options.dry_run {
        return check_for_updates(current_version, method);
    }

    match method {
        InstallMethod::Homebrew => upgrade_homebrew(options.yes)?,
        InstallMethod::Cargo => upgrade_cargo(options.version.as_deref(), options.yes)?,
        InstallMethod::Standalone => upgrade_standalone(current_version, options.yes)?,
    }

    println!();
    println!("Done! Run `mi6 --version` to verify.");

    Ok(())
}

/// Check for available updates without installing (dry-run mode)
fn check_for_updates(current_version: &str, method: InstallMethod) -> Result<()> {
    match method {
        InstallMethod::Standalone => {
            println!("Checking GitHub for updates...");
            println!();

            let update = self_update::backends::github::Update::configure()
                .repo_owner("paradigmxyz")
                .repo_name("mi6")
                .bin_name("mi6")
                .current_version(current_version)
                .build()
                .context("failed to configure self-updater")?;

            let latest = update
                .get_latest_release()
                .context("failed to check for updates")?;

            let latest_version = latest.version.trim_start_matches('v');

            if latest_version == current_version {
                println!("Already at the latest version (v{}).", current_version);
            } else {
                println!(
                    "Update available: v{} -> v{}",
                    current_version, latest_version
                );
                println!();
                println!("Run `mi6 upgrade` to install.");
            }
        }
        InstallMethod::Homebrew => {
            println!("To check for Homebrew updates, run:");
            println!("  brew outdated mi6");
        }
        InstallMethod::Cargo => {
            println!("To check for Cargo updates, run:");
            println!("  cargo search mi6");
        }
    }

    Ok(())
}

fn upgrade_homebrew(skip_confirm: bool) -> Result<()> {
    if !skip_confirm {
        println!("This will run: brew upgrade mi6");
        if !confirm_stdout("Proceed?")? {
            println!("Aborted.");
            return Ok(());
        }
        println!();
    }

    println!("Running: brew upgrade mi6");
    println!();

    let status = Command::new("brew")
        .args(["upgrade", "mi6"])
        .status()
        .context("failed to run brew upgrade")?;

    if !status.success() {
        // Homebrew returns non-zero if package is already at latest version
        println!();
        println!("Note: brew upgrade exited with non-zero status.");
        println!("This usually means mi6 is already at the latest version.");
        println!("If not, try: brew reinstall mi6");
    }

    Ok(())
}

fn upgrade_cargo(version: Option<&str>, skip_confirm: bool) -> Result<()> {
    let mut args = vec!["install", "mi6"];
    if let Some(v) = version {
        args.extend(["--version", v]);
    }

    if !skip_confirm {
        println!("This will run: cargo {}", args.join(" "));
        if !confirm_stdout("Proceed?")? {
            println!("Aborted.");
            return Ok(());
        }
        println!();
    }

    println!("Running: cargo {}", args.join(" "));
    println!();

    let status = Command::new("cargo")
        .args(&args)
        .status()
        .context("failed to run cargo install")?;

    if !status.success() {
        anyhow::bail!("cargo install failed with exit code: {:?}", status.code());
    }

    Ok(())
}

fn upgrade_standalone(current_version: &str, skip_confirm: bool) -> Result<()> {
    println!("Checking GitHub for updates...");
    println!();

    let update = self_update::backends::github::Update::configure()
        .repo_owner("paradigmxyz")
        .repo_name("mi6")
        .bin_name("mi6")
        .current_version(current_version)
        .build()
        .context("failed to configure self-updater")?;

    // Check for update first
    let latest = update
        .get_latest_release()
        .context("failed to check for updates")?;

    let latest_version = latest.version.trim_start_matches('v');

    if latest_version == current_version {
        println!("Already at the latest version (v{}).", current_version);
        return Ok(());
    }

    println!(
        "New version available: v{} -> v{}",
        current_version, latest_version
    );

    if !skip_confirm && !confirm_stdout("Proceed with update?")? {
        println!("Aborted.");
        return Ok(());
    }
    println!();

    println!("Downloading and installing v{}...", latest_version);

    // Create a new update with show_progress for the actual download
    let status = self_update::backends::github::Update::configure()
        .repo_owner("paradigmxyz")
        .repo_name("mi6")
        .bin_name("mi6")
        .current_version(current_version)
        .show_download_progress(true)
        .build()
        .context("failed to configure self-updater")?
        .update()
        .context("failed to perform update")?;

    println!();
    println!("Updated to v{}!", status.version());

    Ok(())
}